Replace inheritance by composition

Core/Computation/GISASSpecularComputationTerm.cpp

@@ -20,16 +20,18 @@
 
 GISASSpecularComputationTerm::GISASSpecularComputationTerm(const MultiLayer* p_multi_layer,
                                                            const IFresnelMap* p_fresnel_map)
-    : IComputationTerm(p_multi_layer, p_fresnel_map)
+    : m_multilayer_info(p_multi_layer, p_fresnel_map)
 {}
 
 void GISASSpecularComputationTerm::compute(SimulationElement& elem) const
 {
-    if (mp_multilayer->requiresMatrixRTCoefficients())
+    auto p_multilayer = m_multilayer_info.mp_multilayer;
+    if (p_multilayer->requiresMatrixRTCoefficients())
         return;
 
+    auto p_fresnel_map = m_multilayer_info.mp_fresnel_map;
     if (elem.isSpecular()) {
-        complex_t R = mp_fresnel_map->getInCoefficients(elem, 0)->getScalarR();
+        complex_t R = p_fresnel_map->getInCoefficients(elem, 0)->getScalarR();
         double sin_alpha_i = std::abs(std::sin(elem.getAlphaI()));
         if (sin_alpha_i == 0.0)
             sin_alpha_i = 1.0;

Core/Computation/GISASSpecularComputationTerm.h

@@ -23,12 +23,14 @@ class SimulationElement;
 //! Computes the specular scattering. Used by DWBAComputation.
 //! @ingroup algorithms_internal
 
-class GISASSpecularComputationTerm final : public IComputationTerm
+class GISASSpecularComputationTerm final
 {
 public:
     GISASSpecularComputationTerm(const MultiLayer* p_multi_layer, const IFresnelMap* p_fresnel_map);
 
     void compute(SimulationElement& elem) const;
+private:
+    IComputationTerm m_multilayer_info;
 };
 
 #endif // GISASSPECULARCOMPUTATIONTERM_H_

Core/Computation/IComputationTerm.h

@@ -29,7 +29,6 @@ public:
     IComputationTerm(const MultiLayer* p_multilayer, const IFresnelMap* p_fresnel_map);
     virtual ~IComputationTerm();
 
-protected:
     const MultiLayer* mp_multilayer;
     const IFresnelMap* mp_fresnel_map;
 };

Core/Computation/ParticleLayoutComputation.cpp

@@ -26,9 +26,9 @@
 ParticleLayoutComputation::ParticleLayoutComputation(
         const MultiLayer* p_multilayer, const IFresnelMap* p_fresnel_map, const ILayout* p_layout,
         size_t layer_index, const SimulationOptions& options, bool polarized)
-    : IComputationTerm(p_multilayer, p_fresnel_map)
+    : m_multilayer_info(p_multilayer, p_fresnel_map)
 {
-    LayoutStrategyBuilder builder(mp_multilayer, p_layout, mp_fresnel_map,
+    LayoutStrategyBuilder builder(p_multilayer, p_layout, p_fresnel_map,
                                   polarized, options, layer_index);
     mP_strategy.reset(builder.releaseStrategy());
     m_region_map = builder.regionMap();
@@ -39,8 +39,9 @@ ParticleLayoutComputation::~ParticleLayoutComputation() =default;
 
 void ParticleLayoutComputation::compute(SimulationElement& elem) const
 {
+    auto p_multilayer = m_multilayer_info.mp_multilayer;
     double alpha_f = elem.getAlphaMean();
-    size_t n_layers = mp_multilayer->numberOfLayers();
+    size_t n_layers = p_multilayer->numberOfLayers();
     if (n_layers > 1 && alpha_f < 0) {
         return; // zero for transmission with multilayers (n>1)
     } else {

Core/Computation/ParticleLayoutComputation.h

@@ -32,13 +32,13 @@ class SimulationOptions;
 //! Used by DWBAComputation.
 //! @ingroup algorithms_internal
 
-class ParticleLayoutComputation final : public IComputationTerm
+class ParticleLayoutComputation final
 {
 public:
-    ParticleLayoutComputation(
-        const MultiLayer* p_multilayer, const IFresnelMap* p_fresnel_map, const ILayout* p_layout,
-        size_t layer_index, const SimulationOptions& options, bool polarized);
-    ~ParticleLayoutComputation() override;
+    ParticleLayoutComputation(const MultiLayer* p_multilayer, const IFresnelMap* p_fresnel_map,
+                              const ILayout* p_layout, size_t layer_index,
+                              const SimulationOptions& options, bool polarized);
+    ~ParticleLayoutComputation();
 
     void compute(SimulationElement& elem) const;
 
@@ -46,6 +46,7 @@ public:
     void mergeRegionMap(std::map<size_t, std::vector<HomogeneousRegion>>& region_map) const;
 
 private:
+    IComputationTerm m_multilayer_info;
     std::unique_ptr<const IInterferenceFunctionStrategy> mP_strategy;
     double m_surface_density;
     std::map<size_t, std::vector<HomogeneousRegion>> m_region_map;

Core/Computation/RoughMultiLayerComputation.cpp

@@ -39,38 +39,39 @@ namespace {
 
 RoughMultiLayerComputation::RoughMultiLayerComputation(const MultiLayer *p_multi_layer,
                                                        const IFresnelMap* p_fresnel_map)
-    : IComputationTerm(p_multi_layer, p_fresnel_map)
+    : m_multilayer_info(p_multi_layer, p_fresnel_map)
 {}
 
 void RoughMultiLayerComputation::compute(SimulationElement& elem) const
 {
     if (elem.getAlphaMean()<0.0)
         return;
+    auto p_multilayer = m_multilayer_info.mp_multilayer;
     kvector_t q = elem.getMeanQ();
     double wavelength = elem.getWavelength();
     double autocorr(0.0);
     complex_t crosscorr(0.0, 0.0);
 
-    std::vector<complex_t > rterm( mp_multilayer->numberOfLayers()-1 );
-    std::vector<complex_t > sterm( mp_multilayer->numberOfLayers()-1 );
+    std::vector<complex_t > rterm( p_multilayer->numberOfLayers()-1 );
+    std::vector<complex_t > sterm( p_multilayer->numberOfLayers()-1 );
 
-    for (size_t i=0; i<mp_multilayer->numberOfLayers()-1; i++){
+    for (size_t i=0; i<p_multilayer->numberOfLayers()-1; i++){
         rterm[i] = get_refractive_term(i, wavelength);
         sterm[i] = get_sum8terms(i, elem);
     }
-    for (size_t i=0; i<mp_multilayer->numberOfLayers()-1; i++) {
+    for (size_t i=0; i<p_multilayer->numberOfLayers()-1; i++) {
         const LayerRoughness *rough =
-            mp_multilayer->layerBottomInterface(i)->getRoughness();
+            p_multilayer->layerBottomInterface(i)->getRoughness();
         if(rough)
             autocorr += std::norm( rterm[i] ) * std::norm( sterm[i] ) * rough->getSpectralFun(q);
     }
     // cross correlation between layers
-    if (mp_multilayer->crossCorrLength() != 0.0) {
-        for(size_t j=0; j<mp_multilayer->numberOfLayers()-1; j++){
-            for(size_t k=0; k<mp_multilayer->numberOfLayers()-1; k++) {
+    if (p_multilayer->crossCorrLength() != 0.0) {
+        for(size_t j=0; j<p_multilayer->numberOfLayers()-1; j++){
+            for(size_t k=0; k<p_multilayer->numberOfLayers()-1; k++) {
                 if(j==k) continue;
                 crosscorr += rterm[j]*sterm[j]*
-                    mp_multilayer->crossCorrSpectralFun(q,j,k)*
+                    p_multilayer->crossCorrSpectralFun(q,j,k)*
                     std::conj(rterm[k])*std::conj(sterm[k]);
             }
         }
@@ -81,18 +82,21 @@ void RoughMultiLayerComputation::compute(SimulationElement& elem) const
 
 complex_t RoughMultiLayerComputation::get_refractive_term(size_t ilayer, double wavelength) const
 {
-    return mp_multilayer->layer(ilayer  )->material()->refractiveIndex2(wavelength) -
-           mp_multilayer->layer(ilayer+1)->material()->refractiveIndex2(wavelength);
+    auto p_multilayer = m_multilayer_info.mp_multilayer;
+    return p_multilayer->layer(ilayer  )->material()->refractiveIndex2(wavelength) -
+           p_multilayer->layer(ilayer+1)->material()->refractiveIndex2(wavelength);
 }
 
 complex_t RoughMultiLayerComputation::get_sum8terms(
     size_t ilayer, const SimulationElement& sim_element) const
 {
-    const auto P_in_plus = mp_fresnel_map->getInCoefficients(sim_element, ilayer);
-    const auto P_out_plus = mp_fresnel_map->getOutCoefficients(sim_element, ilayer);
+    auto p_multilayer = m_multilayer_info.mp_multilayer;
+    auto p_fresnel_map = m_multilayer_info.mp_fresnel_map;
+    const auto P_in_plus = p_fresnel_map->getInCoefficients(sim_element, ilayer);
+    const auto P_out_plus = p_fresnel_map->getOutCoefficients(sim_element, ilayer);
 
-    const auto P_in_minus = mp_fresnel_map->getInCoefficients(sim_element, ilayer+1);
-    const auto P_out_minus = mp_fresnel_map->getOutCoefficients(sim_element, ilayer+1);
+    const auto P_in_minus = p_fresnel_map->getInCoefficients(sim_element, ilayer+1);
+    const auto P_out_minus = p_fresnel_map->getOutCoefficients(sim_element, ilayer+1);
 
     complex_t kiz_plus = P_in_plus->getScalarKz();
     complex_t kfz_plus = P_out_plus->getScalarKz();
@@ -100,7 +104,7 @@ complex_t RoughMultiLayerComputation::get_sum8terms(
     complex_t qz2_plus = - kiz_plus + kfz_plus;
     complex_t qz3_plus = - qz2_plus;
     complex_t qz4_plus = - qz1_plus;
-    double thickness = mp_multilayer->layerThickness(ilayer);
+    double thickness = p_multilayer->layerThickness(ilayer);
     complex_t T_in_plus  = P_in_plus ->getScalarT()*exp_I( kiz_plus*thickness);
     complex_t R_in_plus  = P_in_plus ->getScalarR()*exp_I(-kiz_plus*thickness);
     complex_t T_out_plus = P_out_plus->getScalarT()*exp_I( kfz_plus*thickness);
@@ -114,8 +118,8 @@ complex_t RoughMultiLayerComputation::get_sum8terms(
     complex_t qz4_minus = - qz1_minus;
 
     double sigma(0.0);
-    if (const LayerRoughness* roughness
-        = mp_multilayer->layerBottomInterface(ilayer)->getRoughness())
+    if (const LayerRoughness* roughness =
+        p_multilayer->layerBottomInterface(ilayer)->getRoughness())
         sigma = roughness->getSigma();
     complex_t term1 = T_in_plus * T_out_plus * h_plus(qz1_plus*sigma);
     complex_t term2 = T_in_plus * R_out_plus * h_plus(qz2_plus*sigma);

Core/Computation/RoughMultiLayerComputation.h

@@ -24,7 +24,7 @@ class SimulationElement;
 //! Used by DWBAComputation.
 //! @ingroup algorithms_internal
 
-class RoughMultiLayerComputation final : public IComputationTerm
+class RoughMultiLayerComputation final
 {
 public:
     RoughMultiLayerComputation(const MultiLayer* p_multi_layer, const IFresnelMap* p_fresnel_map);
@@ -32,6 +32,7 @@ public:
     void compute(SimulationElement& elem) const;
 
 private:
+    IComputationTerm m_multilayer_info;
     complex_t get_refractive_term(size_t ilayer, double wavelength) const;
     complex_t get_sum8terms(size_t ilayer, const SimulationElement& sim_element) const;
 };