ctd

Core/Computation/GISASSpecularComputation.h

@@ -30,7 +30,7 @@ class GISASSpecularComputation final {
 public:
     GISASSpecularComputation(const IFresnelMap* p_fresnel_map);
 
-    void compute(SimulationElement& elem) const;
+    void compute(SimulationElement& ele) const;
 
 private:
     const IFresnelMap* m_fresnel_map;

Core/Computation/ParticleLayoutComputation.cpp

@@ -56,7 +56,7 @@ ParticleLayoutComputation::ParticleLayoutComputation(const ProcessedLayout& layo
 
 ParticleLayoutComputation::~ParticleLayoutComputation() = default;
 
-void ParticleLayoutComputation::compute(SimulationElement& elem) const
+void ParticleLayoutComputation::compute(SimulationElement& ele) const
 {
-    elem.addIntensity(m_interparticle_strategy->evaluate(elem) * m_layout.surfaceDensity());
+    ele.addIntensity(m_interparticle_strategy->evaluate(ele) * m_layout.surfaceDensity());
 }

Core/Computation/ParticleLayoutComputation.h

@@ -40,7 +40,7 @@ public:
                               bool polarized);
     ~ParticleLayoutComputation();
 
-    void compute(SimulationElement& elem) const;
+    void compute(SimulationElement& ele) const;
 
 private:
     const ProcessedLayout& m_layout;

Core/Computation/RoughMultiLayerComputation.cpp

@@ -46,13 +46,13 @@ RoughMultiLayerComputation::RoughMultiLayerComputation(const ProcessedSample* p_
 {
 }
 
-void RoughMultiLayerComputation::compute(SimulationElement& elem) const
+void RoughMultiLayerComputation::compute(SimulationElement& ele) const
 {
-    if (elem.getAlphaMean() < 0.0)
+    if (ele.getAlphaMean() < 0.0)
         return;
     const size_t n_slices = m_sample->numberOfSlices();
-    kvector_t q = elem.meanQ();
-    double wavelength = elem.wavelength();
+    kvector_t q = ele.meanQ();
+    double wavelength = ele.wavelength();
     double autocorr(0.0);
     complex_t crosscorr(0.0, 0.0);
 
@@ -61,7 +61,7 @@ void RoughMultiLayerComputation::compute(SimulationElement& elem) const
 
     for (size_t i = 0; i + 1 < n_slices; i++) {
         rterm[i] = get_refractive_term(i, wavelength);
-        sterm[i] = get_sum8terms(i, elem);
+        sterm[i] = get_sum8terms(i, ele);
     }
     for (size_t i = 0; i + 1 < n_slices; i++) {
         const LayerRoughness* rough = m_sample->avgeSlice(i + 1).topRoughness();
@@ -80,7 +80,7 @@ void RoughMultiLayerComputation::compute(SimulationElement& elem) const
         }
     }
     //! @TODO clarify complex vs double
-    elem.addIntensity((autocorr + crosscorr.real()) * M_PI / 4. / wavelength / wavelength);
+    ele.addIntensity((autocorr + crosscorr.real()) * M_PI / 4. / wavelength / wavelength);
 }
 
 complex_t RoughMultiLayerComputation::get_refractive_term(size_t ilayer, double wavelength) const

Core/Computation/RoughMultiLayerComputation.h

@@ -33,7 +33,7 @@ class RoughMultiLayerComputation final {
 public:
     RoughMultiLayerComputation(const ProcessedSample* p_sample);
 
-    void compute(SimulationElement& elem) const;
+    void compute(SimulationElement& ele) const;
 
 private:
     const ProcessedSample* m_sample;

Core/Term/SpecularComputationTerm.cpp

@@ -34,13 +34,13 @@ void SpecularComputationTerm::setProgressHandler(ProgressHandler* p_progress)
     m_progress_counter = std::make_unique<DelayedProgressCounter>(p_progress, 100);
 }
 
-void SpecularComputationTerm::computeIntensity(SpecularSimulationElement& elem,
+void SpecularComputationTerm::computeIntensity(SpecularSimulationElement& ele,
                                                const SliceStack& slices) const
 {
-    if (!elem.isCalculated())
+    if (!ele.isCalculated())
         return;
 
-    eval(elem, slices);
+    eval(ele, slices);
 
     if (m_progress_counter)
         m_progress_counter->stepProgress();
@@ -57,11 +57,11 @@ SpecularScalarTerm::SpecularScalarTerm(const MultiLayer& multilayer)
 
 SpecularScalarTerm::~SpecularScalarTerm() = default;
 
-void SpecularScalarTerm::eval(SpecularSimulationElement& elem, const SliceStack& slices) const
+void SpecularScalarTerm::eval(SpecularSimulationElement& ele, const SliceStack& slices) const
 {
     const auto coeff =
-        std::get<complex_t>(m_strategy->computeTopLayerR(slices, elem.produceKz(slices)));
-    elem.setIntensity(std::norm(coeff));
+        std::get<complex_t>(m_strategy->computeTopLayerR(slices, ele.produceKz(slices)));
+    ele.setIntensity(std::norm(coeff));
 }
 
 //  ************************************************************************************************
@@ -70,10 +70,10 @@ void SpecularScalarTerm::eval(SpecularSimulationElement& elem, const SliceStack&
 
 namespace {
 
-double matrix_intensity(const SpecularSimulationElement& elem, const Eigen::Matrix2cd& R)
+double matrix_intensity(const SpecularSimulationElement& ele, const Eigen::Matrix2cd& R)
 {
-    const auto& polarization = elem.polarizationHandler().getPolarization();
-    const auto& analyzer = elem.polarizationHandler().getAnalyzerOperator();
+    const auto& polarization = ele.polarizationHandler().getPolarization();
+    const auto& analyzer = ele.polarizationHandler().getAnalyzerOperator();
 
     const complex_t result = (polarization * R.adjoint() * analyzer * R).trace();
 
@@ -89,9 +89,9 @@ SpecularMatrixTerm::SpecularMatrixTerm(const MultiLayer& multilayer)
 
 SpecularMatrixTerm::~SpecularMatrixTerm() = default;
 
-void SpecularMatrixTerm::eval(SpecularSimulationElement& elem, const SliceStack& slices) const
+void SpecularMatrixTerm::eval(SpecularSimulationElement& ele, const SliceStack& slices) const
 {
     const auto coeff =
-        std::get<Eigen::Matrix2cd>(m_strategy->computeTopLayerR(slices, elem.produceKz(slices)));
-    elem.setIntensity(matrix_intensity(elem, coeff));
+        std::get<Eigen::Matrix2cd>(m_strategy->computeTopLayerR(slices, ele.produceKz(slices)));
+    ele.setIntensity(matrix_intensity(ele, coeff));
 }

Core/Term/SpecularComputationTerm.h

@@ -47,10 +47,10 @@ public:
     SpecularComputationTerm& operator=(const SpecularComputationTerm& other) = delete;
 
     void setProgressHandler(ProgressHandler* p_progress);
-    void computeIntensity(SpecularSimulationElement& elem, const SliceStack& slices) const;
+    void computeIntensity(SpecularSimulationElement& ele, const SliceStack& slices) const;
 
 protected:
-    virtual void eval(SpecularSimulationElement& elem, const SliceStack& slices) const = 0;
+    virtual void eval(SpecularSimulationElement& ele, const SliceStack& slices) const = 0;
 
     const std::unique_ptr<ISpecularStrategy> m_strategy;
 
@@ -69,7 +69,7 @@ public:
 private:
     ~SpecularScalarTerm() override;
 
-    void eval(SpecularSimulationElement& elem, const SliceStack& slices) const override;
+    void eval(SpecularSimulationElement& ele, const SliceStack& slices) const override;
 };
 
 //! Computes the specular scattering for a magnetic sample
@@ -83,7 +83,7 @@ public:
 private:
     ~SpecularMatrixTerm() override;
 
-    void eval(SpecularSimulationElement& elem, const SliceStack& slices) const override;
+    void eval(SpecularSimulationElement& ele, const SliceStack& slices) const override;
 };
 
 #endif // BORNAGAIN_CORE_TERM_SPECULARCOMPUTATIONTERM_H