Refactor: renamed "detector_density" to more correct "detector_operator"

Core/Algorithms/inc/DecouplingApproximationStrategy.h

@@ -46,7 +46,7 @@ protected:
     //! Evaluates the intensity for given list of evaluated form factors
     //! in the presence of polarization of beam and detector
     double evaluateForMatrixList(const cvector_t &k_i, const Eigen::Matrix2cd &beam_density,
-                           const Bin1DCVector &k_f_bin, const Eigen::Matrix2cd &detector_density,
+                           const Bin1DCVector &k_f_bin, const Eigen::Matrix2cd &detector_operator,
                            const MatrixFFVector &ff_list) const;
 
 private:

Core/Algorithms/inc/Detector.h

@@ -79,7 +79,7 @@ public:
 
 #ifndef GCCXML_SKIP_THIS
     //! Gets the polarization density matrix (in spin basis along z-axis)
-    Eigen::Matrix2cd getPolarization() const { return m_polarization; }
+    Eigen::Matrix2cd getPolarizationOperator() const { return m_polarization; }
 #endif
 
     //! Adds parameters from local pool to external pool and call recursion over direct children.
@@ -116,7 +116,7 @@ private:
     double getSolidAngle(OutputData<double> *p_data, size_t index) const;
 
     //! Initialize polarization (for constructors)
-    void initPolarization();
+    void initPolarizationOperator();
 
     SafePointerVector<IAxis> m_axes;
     IDetectorResolution *mp_detector_resolution;

Core/Algorithms/inc/IInterferenceFunctionStrategy.h

@@ -54,7 +54,7 @@ public:
 
     //! Calculates the intensity in the presence of polarization of beam and detector
     double evaluate(const cvector_t &k_i, const Eigen::Matrix2cd &beam_density,
-                    const Bin1DCVector &k_f_bin, const Eigen::Matrix2cd &detector_density,
+                    const Bin1DCVector &k_f_bin, const Eigen::Matrix2cd &detector_operator,
                     Bin1D alpha_f_bin, Bin1D phi_f_bin) const;
 
 protected:
@@ -66,7 +66,7 @@ protected:
     //! in the presence of polarization of beam and detector
     virtual double evaluateForMatrixList(const cvector_t &k_i, const Eigen::Matrix2cd &beam_density,
                                          const Bin1DCVector &k_f_bin,
-                                         const Eigen::Matrix2cd &detector_density,
+                                         const Eigen::Matrix2cd &detector_operator,
                                          const MatrixFFVector &ff_list) const = 0;
 
     //! Returns q-vector from k_i and the bin of k_f
@@ -85,7 +85,7 @@ private:
         Bin1D alpha_bin;
         Bin1D phi_bin;
         Eigen::Matrix2cd beam_density;
-        Eigen::Matrix2cd detector_density;
+        Eigen::Matrix2cd detector_operator;
     };
 
     //! Constructs one list of evaluated form factors to be used in subsequent
@@ -108,7 +108,7 @@ private:
     //! Perform a Monte Carlo integration over the bin for the evaluation of the
     //! polarized intensity
     double MCIntegratedEvaluatePol(const cvector_t &k_i, const Eigen::Matrix2cd &beam_density,
-                                   const Eigen::Matrix2cd &detector_density, Bin1D alpha_f_bin,
+                                   const Eigen::Matrix2cd &detector_operator, Bin1D alpha_f_bin,
                                    Bin1D phi_f_bin) const;
 
     //! Get the reciprocal integration region

Core/Algorithms/inc/IsGISAXSMorphologyFileStrategy.h

@@ -43,7 +43,7 @@ protected:
     //! Evaluates the intensity for given list of evaluated form factors
     //! in the presence of polarization of beam and detector
     double evaluateForMatrixList(const cvector_t &k_i, const Eigen::Matrix2cd &beam_density,
-                           const Bin1DCVector &k_f_bin, const Eigen::Matrix2cd &detector_density,
+                           const Bin1DCVector &k_f_bin, const Eigen::Matrix2cd &detector_operator,
                            const MatrixFFVector &ff_list) const;
 
 private:

Core/Algorithms/inc/SizeSpacingCorrelationApproximationStrategy.h

@@ -43,7 +43,7 @@ protected:
     //! in the presence of polarization of beam and detector
     double evaluateForMatrixList(const cvector_t &k_i, const Eigen::Matrix2cd &beam_density,
                                  const Bin1DCVector &k_f_bin,
-                                 const Eigen::Matrix2cd &detector_density,
+                                 const Eigen::Matrix2cd &detector_operator,
                                  const MatrixFFVector &ff_list) const;
 
 private:

Core/Algorithms/src/DWBASimulation.cpp

@@ -45,7 +45,7 @@ void DWBASimulation::init(const Simulation& simulation)
     if (simulation.getOutputData()->getMask()) {
         m_dwba_intensity.setMask(*simulation.getOutputData()->getMask());
     }
-    m_detector_polarization = detector.getPolarization();
+    m_detector_polarization = detector.getPolarizationOperator();
     Beam beam = simulation.getInstrument().getBeam();
     m_ki = beam.getCentralK();
     kvector_t ki_real(m_ki.x().real(), m_ki.y().real(), m_ki.z().real());

Core/Algorithms/src/DecouplingApproximationStrategy.cpp

@@ -61,7 +61,7 @@ double DecouplingApproximationStrategy::evaluateForList(const cvector_t &k_i,
 
 double DecouplingApproximationStrategy::evaluateForMatrixList(
     const cvector_t &k_i, const Eigen::Matrix2cd &beam_density, const Bin1DCVector &k_f_bin,
-    const Eigen::Matrix2cd &detector_density, const MatrixFFVector &ff_list) const
+    const Eigen::Matrix2cd &detector_operator, const MatrixFFVector &ff_list) const
 {
     Eigen::Matrix2cd mean_intensity = Eigen::Matrix2cd::Zero();
     Eigen::Matrix2cd mean_amplitude = Eigen::Matrix2cd::Zero();
@@ -82,9 +82,9 @@ double DecouplingApproximationStrategy::evaluateForMatrixList(
         mean_amplitude += fraction * ff;
         mean_intensity += fraction * (ff * beam_density * ff.adjoint());
     }
-    Eigen::Matrix2cd amplitude_matrix = detector_density * mean_amplitude * beam_density
+    Eigen::Matrix2cd amplitude_matrix = detector_operator * mean_amplitude * beam_density
                                         * mean_amplitude.adjoint();
-    Eigen::Matrix2cd intensity_matrix = detector_density * mean_intensity;
+    Eigen::Matrix2cd intensity_matrix = detector_operator * mean_intensity;
     double amplitude_trace = std::abs(amplitude_matrix.trace());
     double intensity_trace = std::abs(intensity_matrix.trace());
     double itf_function = m_ifs[0]->evaluate(k_i - k_f_bin.getMidPoint());

Core/Algorithms/src/Detector.cpp

@@ -29,7 +29,7 @@ Detector::Detector() : m_axes(), mp_detector_resolution(0)
 {
     setName("Detector");
     init_parameters();
-    initPolarization();
+    initPolarizationOperator();
 }
 
 Detector::Detector(const Detector &other)
@@ -205,7 +205,7 @@ double Detector::getSolidAngle(OutputData<double> *p_data, size_t index) const
     return dsinalpha * dphi;
 }
 
-void Detector::initPolarization()
+void Detector::initPolarizationOperator()
 {
     m_polarization = Eigen::Matrix2cd::Identity();
 }

Core/Algorithms/src/IInterferenceFunctionStrategy.cpp

@@ -53,15 +53,15 @@ double IInterferenceFunctionStrategy::evaluate(const cvector_t &k_i, const Bin1D
 double IInterferenceFunctionStrategy::evaluate(const cvector_t &k_i,
                                                const Eigen::Matrix2cd &beam_density,
                                                const Bin1DCVector &k_f_bin,
-                                               const Eigen::Matrix2cd &detector_density,
+                                               const Eigen::Matrix2cd &detector_operator,
                                                Bin1D alpha_f_bin, Bin1D phi_f_bin) const
 {
     if (m_sim_params.m_mc_integration && m_sim_params.m_mc_points > 0) {
-        return MCIntegratedEvaluatePol(k_i, beam_density, detector_density, alpha_f_bin, phi_f_bin);
+        return MCIntegratedEvaluatePol(k_i, beam_density, detector_operator, alpha_f_bin, phi_f_bin);
     }
     double result;
     calculateFormFactorLists(k_i, k_f_bin, alpha_f_bin, phi_f_bin);
-    result = evaluateForMatrixList(k_i, beam_density, k_f_bin, detector_density, m_ff_pol);
+    result = evaluateForMatrixList(k_i, beam_density, k_f_bin, detector_operator, m_ff_pol);
     return result;
 }
 
@@ -130,12 +130,12 @@ double IInterferenceFunctionStrategy::MCIntegratedEvaluate(const cvector_t &k_i,
 
 double IInterferenceFunctionStrategy::MCIntegratedEvaluatePol(
     const cvector_t &k_i, const Eigen::Matrix2cd &beam_density,
-    const Eigen::Matrix2cd &detector_density, Bin1D alpha_f_bin, Bin1D phi_f_bin) const
+    const Eigen::Matrix2cd &detector_operator, Bin1D alpha_f_bin, Bin1D phi_f_bin) const
 {
     double result;
     IntegrationParamsAlpha mc_int_pars = getIntegrationParams(k_i, alpha_f_bin, phi_f_bin);
     mc_int_pars.beam_density = beam_density;
-    mc_int_pars.detector_density = detector_density;
+    mc_int_pars.detector_operator = detector_operator;
     MemberFunctionMCMiserIntegrator<IInterferenceFunctionStrategy>::mem_function p_function
         = &IInterferenceFunctionStrategy::evaluate_for_fixed_angles_pol;
     MemberFunctionMCMiserIntegrator<IInterferenceFunctionStrategy> mc_integrator(p_function, this,
@@ -211,6 +211,6 @@ double IInterferenceFunctionStrategy::evaluate_for_fixed_angles_pol(double *frac
 
     double result = 0.0;
     result
-        = evaluateForMatrixList(k_i, pars->beam_density, k_f_bin, pars->detector_density, m_ff_pol);
+        = evaluateForMatrixList(k_i, pars->beam_density, k_f_bin, pars->detector_operator, m_ff_pol);
     return std::cos(alpha) * result;
 }

Core/Algorithms/src/IsGISAXSMorphologyFileStrategy.cpp

@@ -92,7 +92,7 @@ double IsGISAXSMorphologyFileStrategy::evaluateForList(const cvector_t &k_i,
 
 double IsGISAXSMorphologyFileStrategy::evaluateForMatrixList(
     const cvector_t &k_i, const Eigen::Matrix2cd &beam_density, const Bin1DCVector &k_f_bin,
-    const Eigen::Matrix2cd &detector_density, const MatrixFFVector &ff_list) const
+    const Eigen::Matrix2cd &detector_operator, const MatrixFFVector &ff_list) const
 {
     cvector_t q = k_i - k_f_bin.getMidPoint();
 
@@ -103,7 +103,7 @@ double IsGISAXSMorphologyFileStrategy::evaluateForMatrixList(
         double hann_value = hannFunction(m_x_positions[i], m_y_positions[i]);
         coherent_amplitude += fraction * ff_list[i] * hann_value;
     }
-    Eigen::Matrix2cd coh_amplitude_matrix = detector_density * coherent_amplitude * beam_density
+    Eigen::Matrix2cd coh_amplitude_matrix = detector_operator * coherent_amplitude * beam_density
                                         * coherent_amplitude.adjoint();
     double coherent_intensity = std::abs(coh_amplitude_matrix.trace());
 
@@ -118,7 +118,7 @@ double IsGISAXSMorphologyFileStrategy::evaluateForMatrixList(
                                  * (ff_i * beam_density * ff_j.adjoint());
         }
     }
-    Eigen::Matrix2cd intensity_matrix = detector_density * diffuse_matrix;
+    Eigen::Matrix2cd intensity_matrix = detector_operator * diffuse_matrix;
     double diffuse_intensity = std::abs(intensity_matrix.trace());
     return coherent_intensity + diffuse_intensity;
 }

Core/Algorithms/src/SizeSpacingCorrelationApproximationStrategy.cpp

@@ -62,7 +62,7 @@ double SizeSpacingCorrelationApproximationStrategy::evaluateForList(
 
 double SizeSpacingCorrelationApproximationStrategy::evaluateForMatrixList(
     const cvector_t &k_i, const Eigen::Matrix2cd &beam_density, const Bin1DCVector &k_f_bin,
-    const Eigen::Matrix2cd &detector_density, const MatrixFFVector &ff_list) const
+    const Eigen::Matrix2cd &detector_operator, const MatrixFFVector &ff_list) const
 {
     double qp = getqp(k_i, k_f_bin);
     Eigen::Matrix2cd diffuse_matrix = Eigen::Matrix2cd::Zero();
@@ -82,8 +82,8 @@ double SizeSpacingCorrelationApproximationStrategy::evaluateForMatrixList(
     complex_t p2kappa = getCharacteristicSizeCoupling(qp, 2.0 * m_kappa);
     complex_t omega = getCharacteristicDistribution(qp);
     Eigen::Matrix2cd interference_matrix = (2.0 * omega / (1.0 - p2kappa * omega))
-                                           * (detector_density * mcff * beam_density * mcffc);
-    Eigen::Matrix2cd diffuse_matrix2 = detector_density * diffuse_matrix;
+                                           * (detector_operator * mcff * beam_density * mcffc);
+    Eigen::Matrix2cd diffuse_matrix2 = detector_operator * diffuse_matrix;
     double interference_trace = std::abs(interference_matrix.trace());
     double diffuse_trace = std::abs(diffuse_matrix2.trace());
     return total_abundance * (diffuse_trace + interference_trace);