Added SSCA strategy class

Core/Algorithms/inc/SizeSpacingCorrelationApproximationStrategy.h

+#ifndef SIZESPACINGCORRELATIONAPPROXIMATIONSTRATEGY_H_
+#define SIZESPACINGCORRELATIONAPPROXIMATIONSTRATEGY_H_
+// ********************************************************************
+// * The BornAgain project                                            *
+// * Simulation of neutron and x-ray scattering at grazing incidence  *
+// *                                                                  *
+// * LICENSE AND DISCLAIMER                                           *
+// * Lorem ipsum dolor sit amet, consectetur adipiscing elit.  Mauris *
+// * eget quam orci. Quisque  porta  varius  dui,  quis  posuere nibh *
+// * mollis quis. Mauris commodo rhoncus porttitor.                   *
+// ********************************************************************
+//! @file   SizeSpacingCorrelationApproximationStrategy.h
+//! @brief  Definition of SizeSpacingCorrelationApproximationStrategy class
+//! @author Scientific Computing Group at FRM II
+//! @date   Jan 17, 2013
+
+#include "Types.h"
+#include "IInterferenceFunctionStrategy.h"
+
+class SizeSpacingCorrelationApproximationStrategy : public IInterferenceFunctionStrategy
+{
+public:
+    SizeSpacingCorrelationApproximationStrategy(double kappa);
+    virtual ~SizeSpacingCorrelationApproximationStrategy() {}
+
+    virtual void init(const std::vector<IFormFactor *> &form_factors,
+            const std::vector<double> &fractions,
+            const std::vector<IInterferenceFunction *> &interference_functions);
+    virtual double evaluate(const cvector_t &k_i, const Bin1DCVector &k_f_bin,
+            double alpha_i, double alpha_f) const;
+private:
+    bool checkVectorSizes() const;
+    complex_t getMeanCharacteristicFF(const cvector_t &k_i, const Bin1DCVector &k_f_bin,
+            double alpha_i, double alpha_f) const;
+    complex_t getMeanConjCharacteristicFF(const cvector_t &k_i, const Bin1DCVector &k_f_bin,
+            double alpha_i, double alpha_f) const;
+    complex_t getCharacteristicDistribution(double qp) const;
+    complex_t getCharacteristicSizeCoupling(double qp, double kappa) const;
+    complex_t calculatePositionOffsetPhase(double qp, double kappa, size_t index) const;
+    double getqp(const cvector_t &k_i, const Bin1DCVector &k_f_bin) const;
+    void initMeanRadius();
+    double m_mean_radius;
+    double m_kappa;
+};
+
+
+#endif /* SIZESPACINGCORRELATIONAPPROXIMATIONSTRATEGY_H_ */

Core/Algorithms/src/SizeSpacingCorrelationApproximationStrategy.cpp

+#include "SizeSpacingCorrelationApproximationStrategy.h"
+
+SizeSpacingCorrelationApproximationStrategy::SizeSpacingCorrelationApproximationStrategy(
+        double kappa)
+: m_mean_radius(0.0)
+, m_kappa(kappa)
+{
+}
+
+void SizeSpacingCorrelationApproximationStrategy::init(
+        const std::vector<IFormFactor*>& form_factors,
+        const std::vector<double>& fractions,
+        const std::vector<IInterferenceFunction*>& interference_functions)
+{
+    IInterferenceFunctionStrategy::init(form_factors, fractions, interference_functions);
+    if (!checkVectorSizes()) {
+        throw ClassInitializationException("Wrong number of formfactors or interference functions for Decoupling Approximation.");
+    }
+    initMeanRadius();
+}
+
+double SizeSpacingCorrelationApproximationStrategy::evaluate(const cvector_t& k_i,
+        const Bin1DCVector& k_f_bin, double alpha_i, double alpha_f) const
+{
+    double qp = getqp(k_i, k_f_bin);
+    double diffuse_intensity = 0.0;
+    for (size_t i=0; i<m_form_factors.size(); ++i) {
+        complex_t ff = m_form_factors[i]->evaluate(k_i, k_f_bin, alpha_i, alpha_f);
+        double fraction = m_fractions[i];
+        diffuse_intensity += fraction*(std::norm(ff));
+    }
+    complex_t mcff = getMeanCharacteristicFF(k_i, k_f_bin, alpha_i, alpha_f);
+    complex_t mcffc = getMeanConjCharacteristicFF(k_i, k_f_bin, alpha_i, alpha_f);
+    complex_t p2kappa = getCharacteristicSizeCoupling(qp, 2.0*m_kappa);
+    complex_t omega = getCharacteristicDistribution(qp);
+    double interference_intensity = 2.0*( mcff*mcffc*omega/(p2kappa*(1.0 - omega)) ).real();
+    return diffuse_intensity + interference_intensity;
+}
+
+bool SizeSpacingCorrelationApproximationStrategy::checkVectorSizes() const
+{
+    size_t n_ffs = m_form_factors.size();
+    size_t n_frs = m_fractions.size();
+    size_t n_ifs = m_interference_functions.size();
+    return (n_ffs==n_frs && n_ifs==1);
+}
+
+complex_t SizeSpacingCorrelationApproximationStrategy::getMeanCharacteristicFF(
+        const cvector_t& k_i, const Bin1DCVector& k_f_bin, double alpha_i,
+        double alpha_f) const
+{
+    double qp = getqp(k_i, k_f_bin);
+    complex_t result(0.0, 0.0);
+    for (size_t i=0; i<m_form_factors.size(); ++i) {
+        result += m_fractions[i]*m_form_factors[i]->evaluate(k_i, k_f_bin, alpha_i, alpha_f)*
+                calculatePositionOffsetPhase(qp, m_kappa, i);
+    }
+    return result;
+}
+
+complex_t SizeSpacingCorrelationApproximationStrategy::getMeanConjCharacteristicFF(
+        const cvector_t& k_i, const Bin1DCVector& k_f_bin, double alpha_i,
+        double alpha_f) const
+{
+    double qp = getqp(k_i, k_f_bin);
+    complex_t result(0.0, 0.0);
+    for (size_t i=0; i<m_form_factors.size(); ++i) {
+        result += m_fractions[i]*std::conj(m_form_factors[i]->evaluate(k_i, k_f_bin, alpha_i, alpha_f))*
+                calculatePositionOffsetPhase(qp, m_kappa, i);
+    }
+    return result;
+}
+
+complex_t SizeSpacingCorrelationApproximationStrategy::getCharacteristicDistribution(
+        double qp) const
+{
+    InterferenceFunction1DParaCrystal *p_iff = dynamic_cast<InterferenceFunction1DParaCrystal *>(
+            m_interference_functions[0]);
+    if (p_iff==0) {
+        throw ClassInitializationException("Wrong interference function for SSCA");
+    }
+    return getCharacteristicSizeCoupling(qp, m_kappa*2.0)*p_iff->FTGaussianCorrLength(qp);
+}
+
+complex_t SizeSpacingCorrelationApproximationStrategy::getCharacteristicSizeCoupling(
+        double qp, double kappa) const
+{
+    size_t n_frs = m_fractions.size();
+    complex_t result = complex_t(0.0, 0.0);
+    for (size_t i=0; i<n_frs; ++i) {
+        result += m_fractions[i]* calculatePositionOffsetPhase(qp, kappa, i);
+    }
+    return result;
+}
+
+complex_t SizeSpacingCorrelationApproximationStrategy::calculatePositionOffsetPhase(
+        double qp, double kappa, size_t index) const
+{
+    return std::exp(complex_t(0.0, 1.0)*kappa*qp*(m_form_factors[index]->getRadius()-m_mean_radius));
+}
+
+double SizeSpacingCorrelationApproximationStrategy::getqp(const cvector_t& k_i,
+        const Bin1DCVector& k_f_bin) const
+{
+    cvector_t q = k_i - k_f_bin.getMidPoint();
+    double qxr = q.x().real();
+    double qyr = q.y().real();
+    return std::sqrt(qxr*qxr + qyr*qyr);
+}
+
+void SizeSpacingCorrelationApproximationStrategy::initMeanRadius()
+{
+    m_mean_radius = 0.0;
+    for (size_t i=0; i<m_form_factors.size(); ++i) {
+        m_mean_radius += m_fractions[i]*m_form_factors[i]->getRadius();
+    }
+}

Core/Samples/inc/InterferenceFunction1DParaCrystal.h

@@ -26,6 +26,8 @@ public:
 	}
 
     virtual double evaluate(const cvector_t &q) const;
+    //TODO: replace these with strategy pattern for different algorithms
+    complex_t FTGaussianCorrLength(double qpar) const;
 protected:
 	double m_peak_distance;
 	double m_width;
@@ -34,9 +36,6 @@ protected:
 private:
     //! initialize pool parameters, i.e. register some of class members for later access via parameter pool
     virtual void init_parameters();
-
-	//TODO: replace these with strategy pattern for different algorithms
-	complex_t FTGaussianCorrLength(double qpar) const;
 };