diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlus.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlus.h new file mode 100644 index 0000000000000000000000000000000000000000..9fb30bcf6a4bdfc44ea7f8f5b347f922881ede7a --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlus.h @@ -0,0 +1,77 @@ +#ifndef DVCSALLPLUS_H +#define DVCSALLPLUS_H + +/** + * @file DVCSAllPlus.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAllPlus + * @brief Longitudinally polarized beam and target asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LL}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \left(\mathrm{d}^4\sigma_{\leftarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\rightarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right)\right) - + * \left(\mathrm{d}^4\sigma_{\rightarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\leftarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right)\right) + * }{ + * \left(\mathrm{d}^4\sigma_{\leftarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\rightarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right)\right) + + * \left(\mathrm{d}^4\sigma_{\rightarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\leftarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right)\right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{h} b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Interference) for target helicity denoted by \f$t_{h}\f$, beam helicity denoted by \f$b_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAllPlus: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAllPlus(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAllPlus(); + + virtual DVCSAllPlus* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAllPlus(const DVCSAllPlus &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALLPLUS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos0Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos0Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..4b2e3005cc873855c68a2d69fc839d85c28af42f --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos0Phi.h @@ -0,0 +1,86 @@ +#ifndef DVCSALLPLUSCOS0PHI_H +#define DVCSALLPLUSCOS0PHI_H + +/** + * @file DVCSAllPlusCos0Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAllPlus.h" + +namespace PARTONS { + +/** + * @class DVCSAllPlusCos0Phi + * + * @brief 0th Fourier moment of longitudinally polarized beam and target asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LL}^{\cos\left(0\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{2\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LL}\left(x_{B}, t, Q^2, \phi\right) \cos\left(0\phi\right) \, , + * \f$ + * + * where \f$A_{LL}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAllPlus. + */ +class DVCSAllPlusCos0Phi: public DVCSAllPlus, public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAllPlusCos0Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAllPlusCos0Phi(); + + virtual DVCSAllPlusCos0Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAllPlusCos0Phi(const DVCSAllPlusCos0Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALLPLUSCOS0PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos1Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos1Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..848877176189c6fb011ee3b168a14b5dff07bfed --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos1Phi.h @@ -0,0 +1,86 @@ +#ifndef DVCSALLPLUSCOS1PHI_H +#define DVCSALLPLUSCOS1PHI_H + +/** + * @file DVCSAllPlusCos1Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAllPlus.h" + +namespace PARTONS { + +/** + * @class DVCSAllPlusCos1Phi + * + * @brief 1th Fourier moment of longitudinally polarized beam and target asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LL}^{\cos\left(1\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LL}\left(x_{B}, t, Q^2, \phi\right) \cos\left(1\phi\right) \, , + * \f$ + * + * where \f$A_{LL}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAllPlus. + */ +class DVCSAllPlusCos1Phi: public DVCSAllPlus, public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAllPlusCos1Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAllPlusCos1Phi(); + + virtual DVCSAllPlusCos1Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAllPlusCos1Phi(const DVCSAllPlusCos1Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALLPLUSCOS1PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos2Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos2Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..fc123484a3b17a2053097a4796e1f2e09d3bd12b --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos2Phi.h @@ -0,0 +1,86 @@ +#ifndef DVCSALLPLUSCOS2PHI_H +#define DVCSALLPLUSCOS2PHI_H + +/** + * @file DVCSAllPlusCos2Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAllPlus.h" + +namespace PARTONS { + +/** + * @class DVCSAllPlusCos2Phi + * + * @brief 2th Fourier moment of longitudinally polarized beam and target asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LL}^{\cos\left(2\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LL}\left(x_{B}, t, Q^2, \phi\right) \cos\left(2\phi\right) \, , + * \f$ + * + * where \f$A_{LL}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAllPlus. + */ +class DVCSAllPlusCos2Phi: public DVCSAllPlus, public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAllPlusCos2Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAllPlusCos2Phi(); + + virtual DVCSAllPlusCos2Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAllPlusCos2Phi(const DVCSAllPlusCos2Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALLPLUSCOS2PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhis.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhis.h new file mode 100644 index 0000000000000000000000000000000000000000..d768b09fd3def1facf93ab6f9b0af332dfdee109 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhis.h @@ -0,0 +1,93 @@ +#ifndef DVCSALTDVCSCOSPHIMPHIS_H +#define DVCSALTDVCSCOSPHIMPHIS_H + +/** + * @file DVCSAltDVCSCosPhiMPhis.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAltDVCSCosPhiMPhis + * @brief Longitudinal beam and transverse target asymmetry (DVCS part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, DVCS}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \left( + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) - + * \left( + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + * }{ + * \left( + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + + * \left( + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{h} b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for target helicity denoted by \f$t_{h}\f$, beam helicity denoted by \f$b_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAltDVCSCosPhiMPhis: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltDVCSCosPhiMPhis(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltDVCSCosPhiMPhis(); + + virtual DVCSAltDVCSCosPhiMPhis* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltDVCSCosPhiMPhis(const DVCSAltDVCSCosPhiMPhis &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTDVCSCOSPHIMPHIS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos0Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos0Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..90f7a28dc76f67eff140b600d65b439f3827c0a8 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos0Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSALTDVCSCOSPHIMPHISCOS0PHI_H +#define DVCSALTDVCSCOSPHIMPHISCOS0PHI_H + +/** + * @file DVCSAltDVCSCosPhiMPhisCos0Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAltDVCSCosPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAltDVCSCosPhiMPhisCos0Phi + * + * @brief 0th Fourier moment of longitudinal beam transverse target asymmetry (DVCS part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, DVCS}^{\cos\left(\phi-\phi_{S}\right)\cos\left(0\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{2\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LT, DVCS}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(0\phi\right) \, , + * \f$ + * + * where \f$A_{UT, DVCS}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAltDVCSCosPhiMPhis. + */ +class DVCSAltDVCSCosPhiMPhisCos0Phi: public DVCSAltDVCSCosPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltDVCSCosPhiMPhisCos0Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltDVCSCosPhiMPhisCos0Phi(); + + virtual DVCSAltDVCSCosPhiMPhisCos0Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltDVCSCosPhiMPhisCos0Phi(const DVCSAltDVCSCosPhiMPhisCos0Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTDVCSCOSPHIMPHISCOS0PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos1Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos1Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..fdfb1185356ad574be13303d03e83b1bf9aa7e4e --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos1Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSALTDVCSCOSPHIMPHISCOS1PHI_H +#define DVCSALTDVCSCOSPHIMPHISCOS1PHI_H + +/** + * @file DVCSAltDVCSCosPhiMPhisCos1Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAltDVCSCosPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAltDVCSCosPhiMPhisCos1Phi + * + * @brief 1th Fourier moment of longitudinal beam transverse target asymmetry (DVCS part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, DVCS}^{\cos\left(\phi-\phi_{S}\right)\cos\left(1\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LT, DVCS}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(1\phi\right) \, , + * \f$ + * + * where \f$A_{UT, DVCS}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAltDVCSCosPhiMPhis. + */ +class DVCSAltDVCSCosPhiMPhisCos1Phi: public DVCSAltDVCSCosPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltDVCSCosPhiMPhisCos1Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltDVCSCosPhiMPhisCos1Phi(); + + virtual DVCSAltDVCSCosPhiMPhisCos1Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltDVCSCosPhiMPhisCos1Phi(const DVCSAltDVCSCosPhiMPhisCos1Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTDVCSCOSPHIMPHISCOS1PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhis.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhis.h new file mode 100644 index 0000000000000000000000000000000000000000..e41562a7682c327106ec2a5f0f2023dadd359cfa --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhis.h @@ -0,0 +1,93 @@ +#ifndef DVCSALTDVCSSINPHIMPHIS_H +#define DVCSALTDVCSSINPHIMPHIS_H + +/** + * @file DVCSAltDVCSSinPhiMPhis.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAltDVCSSinPhiMPhis + * @brief Longitudinal beam and transverse target asymmetry (DVCS part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, DVCS}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \left( + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) - + * \left( + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + * }{ + * \left( + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + + * \left( + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{h} b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for target helicity denoted by \f$t_{h}\f$, beam helicity denoted by \f$b_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAltDVCSSinPhiMPhis: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltDVCSSinPhiMPhis(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltDVCSSinPhiMPhis(); + + virtual DVCSAltDVCSSinPhiMPhis* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltDVCSSinPhiMPhis(const DVCSAltDVCSSinPhiMPhis &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTDVCSSINPHIMPHIS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhisSin1Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhisSin1Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..d78e8364fda182f83853a49cf7ff23b4521d088f --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhisSin1Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSALTDVCSSINPHIMPHISSIN1PHI_H +#define DVCSALTDVCSSINPHIMPHISSIN1PHI_H + +/** + * @file DVCSAltDVCSSinPhiMPhisSin1Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAltDVCSSinPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAltDVCSSinPhiMPhisSin1Phi + * + * @brief 1th Fourier moment of longitudinal beam transverse target asymmetry (DVCS part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, DVCS}^{\sin\left(\phi-\phi_{S}\right)\sin\left(1\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LT, DVCS}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \sin\left(1\phi\right) \, , + * \f$ + * + * where \f$A_{LT, DVCS}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAltDVCSSinPhiMPhis. + */ +class DVCSAltDVCSSinPhiMPhisSin1Phi: public DVCSAltDVCSSinPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltDVCSSinPhiMPhisSin1Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltDVCSSinPhiMPhisSin1Phi(); + + virtual DVCSAltDVCSSinPhiMPhisSin1Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltDVCSSinPhiMPhisSin1Phi(const DVCSAltDVCSSinPhiMPhisSin1Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTDVCSSINPHIMPHISSIN1PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhis.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhis.h new file mode 100644 index 0000000000000000000000000000000000000000..c45ce0f81d39965861e39f050d27fc98d214ef0d --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhis.h @@ -0,0 +1,93 @@ +#ifndef DVCSALTINTCOSPHIMPHIS_H +#define DVCSALTINTCOSPHIMPHIS_H + +/** + * @file DVCSAltIntCosPhiMPhis.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAltIntCosPhiMPhis + * @brief Longitudinal beam and transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \left( + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) - + * \left( + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + * }{ + * \left( + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + + * \left( + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{h} b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for target helicity denoted by \f$t_{h}\f$, beam helicity denoted by \f$b_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAltIntCosPhiMPhis: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltIntCosPhiMPhis(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltIntCosPhiMPhis(); + + virtual DVCSAltIntCosPhiMPhis* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltIntCosPhiMPhis(const DVCSAltIntCosPhiMPhis &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTINTCOSPHIMPHIS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos0Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos0Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..27beb76e3b19ff68101889ad4c174dc62350a465 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos0Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSALTINTCOSPHIMPHISCOS0PHI_H +#define DVCSALTINTCOSPHIMPHISCOS0PHI_H + +/** + * @file DVCSAltIntCosPhiMPhisCos0Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAltIntCosPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAltIntCosPhiMPhisCos0Phi + * + * @brief 0th Fourier moment of longitudinal beam transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)\cos\left(0\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{2\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(0\phi\right) \, , + * \f$ + * + * where \f$A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAltIntCosPhiMPhis. + */ +class DVCSAltIntCosPhiMPhisCos0Phi: public DVCSAltIntCosPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltIntCosPhiMPhisCos0Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltIntCosPhiMPhisCos0Phi(); + + virtual DVCSAltIntCosPhiMPhisCos0Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltIntCosPhiMPhisCos0Phi(const DVCSAltIntCosPhiMPhisCos0Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTINTCOSPHIMPHISCOS0PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos1Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos1Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..9f2c1663bca210a1d67d98b0b8c7d1588c3fc2ba --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos1Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSALTINTCOSPHIMPHISCOS1PHI_H +#define DVCSALTINTCOSPHIMPHISCOS1PHI_H + +/** + * @file DVCSAltIntCosPhiMPhisCos1Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAltIntCosPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAltIntCosPhiMPhisCos1Phi + * + * @brief 1th Fourier moment of longitudinal beam transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)\cos\left(1\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(1\phi\right) \, , + * \f$ + * + * where \f$A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAltIntCosPhiMPhis. + */ +class DVCSAltIntCosPhiMPhisCos1Phi: public DVCSAltIntCosPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltIntCosPhiMPhisCos1Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltIntCosPhiMPhisCos1Phi(); + + virtual DVCSAltIntCosPhiMPhisCos1Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltIntCosPhiMPhisCos1Phi(const DVCSAltIntCosPhiMPhisCos1Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTINTCOSPHIMPHISCOS1PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos2Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos2Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..833e8378431ad23c5f995201dc625fa10f8b5a50 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos2Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSALTINTCOSPHIMPHISCOS2PHI_H +#define DVCSALTINTCOSPHIMPHISCOS2PHI_H + +/** + * @file DVCSAltIntCosPhiMPhisCos2Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAltIntCosPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAltIntCosPhiMPhisCos2Phi + * + * @brief 2th Fourier moment of longitudinal beam transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)\cos\left(2\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(2\phi\right) \, , + * \f$ + * + * where \f$A_{LT, Int}^{\cos\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAltIntCosPhiMPhis. + */ +class DVCSAltIntCosPhiMPhisCos2Phi: public DVCSAltIntCosPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltIntCosPhiMPhisCos2Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltIntCosPhiMPhisCos2Phi(); + + virtual DVCSAltIntCosPhiMPhisCos2Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltIntCosPhiMPhisCos2Phi(const DVCSAltIntCosPhiMPhisCos2Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTINTCOSPHIMPHISCOS2PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhis.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhis.h new file mode 100644 index 0000000000000000000000000000000000000000..acf73a1c2585db829f1c1ca549944a56d7f41a06 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhis.h @@ -0,0 +1,93 @@ +#ifndef DVCSALTINTSINPHIMPHIS_H +#define DVCSALTINTSINPHIMPHIS_H + +/** + * @file DVCSAltIntSinPhiMPhis.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAltIntSinPhiMPhis + * @brief Longitudinal beam and transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \left( + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) - + * \left( + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + * }{ + * \left( + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + + * \left( + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + * \right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{h} b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for target helicity denoted by \f$t_{h}\f$, beam helicity denoted by \f$b_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAltIntSinPhiMPhis: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltIntSinPhiMPhis(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltIntSinPhiMPhis(); + + virtual DVCSAltIntSinPhiMPhis* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltIntSinPhiMPhis(const DVCSAltIntSinPhiMPhis &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTINTSINPHIMPHIS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin1Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin1Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..f2d5491a20e78f8cf2c08333f94e52ba2223febc --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin1Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSALTINTSINPHIMPHISSIN1PHI_H +#define DVCSALTINTSINPHIMPHISSIN1PHI_H + +/** + * @file DVCSAltIntSinPhiMPhisSin1Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAltIntSinPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAltIntSinPhiMPhisSin1Phi + * + * @brief 1th Fourier moment of longitudinal beam transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, Int}^{\sin\left(\phi-\phi_{S}\right)\sin\left(1\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \sin\left(1\phi\right) \, , + * \f$ + * + * where \f$A_{LT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAltIntSinPhiMPhis. + */ +class DVCSAltIntSinPhiMPhisSin1Phi: public DVCSAltIntSinPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltIntSinPhiMPhisSin1Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltIntSinPhiMPhisSin1Phi(); + + virtual DVCSAltIntSinPhiMPhisSin1Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltIntSinPhiMPhisSin1Phi(const DVCSAltIntSinPhiMPhisSin1Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTINTSINPHIMPHISSIN1PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin2Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin2Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..73ce4c60784e31898e28d34cb0c8fe88248e3253 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin2Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSALTINTSINPHIMPHISSIN2PHI_H +#define DVCSALTINTSINPHIMPHISSIN2PHI_H + +/** + * @file DVCSAltIntSinPhiMPhisSin2Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAltIntSinPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAltIntSinPhiMPhisSin2Phi + * + * @brief 2th Fourier moment of longitudinal beam transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LT, Int}^{\sin\left(\phi-\phi_{S}\right)\sin\left(2\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{LT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \sin\left(2\phi\right) \, , + * \f$ + * + * where \f$A_{LT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAltIntSinPhiMPhis. + */ +class DVCSAltIntSinPhiMPhisSin2Phi: public DVCSAltIntSinPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAltIntSinPhiMPhisSin2Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAltIntSinPhiMPhisSin2Phi(); + + virtual DVCSAltIntSinPhiMPhisSin2Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAltIntSinPhiMPhisSin2Phi(const DVCSAltIntSinPhiMPhisSin2Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALTINTSINPHIMPHISSIN2PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAluPlus.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAluPlus.h new file mode 100644 index 0000000000000000000000000000000000000000..0386e3a2eefd717082f26a5ad786ff5082d0782a --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAluPlus.h @@ -0,0 +1,73 @@ +#ifndef DVCSALUPLUS_H +#define DVCSALUPLUS_H + +/** + * @file DVCSAluPlus.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAluPlus + * @brief Longitudinally polarized beam asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{LU}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \mathrm{d}^4\sigma^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + * }{ + * \mathrm{d}^4\sigma^{\rightarrow +}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma^{\leftarrow +}\left(x_{B}, t, Q^2, \phi\right) + * } \, , + * \f$ + * + * where + * \f$\sigma^{b_{h} b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for beam helicity denoted by \f$b_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAluPlus: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAluPlus(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAluPlus(); + + virtual DVCSAluPlus* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAluPlus(const DVCSAluPlus &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSALUPLUS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAulMinus.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulMinus.h index e1c76f037e09b78c374be4b86dd747170291c4d8..506f1d05f9388484a7f445d71913502f0665f8e6 100644 --- a/include/partons/modules/observable/DVCS/asymmetry/DVCSAulMinus.h +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulMinus.h @@ -24,20 +24,16 @@ namespace PARTONS { * \f$ \displaystyle * A_{UL}\left(x_{B}, t, Q^2, \phi\right) = * \frac{ - * \left(\mathrm{d}^4\sigma_{\leftarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + - * \mathrm{d}^4\sigma_{\leftarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right)\right) - - * \left(\mathrm{d}^4\sigma_{\rightarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + - * \mathrm{d}^4\sigma_{\rightarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right)\right) + * \mathrm{d}^4\sigma_{\leftarrow}^{-}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\rightarrow}^{-}\left(x_{B}, t, Q^2, \phi\right) * }{ - * \left(\mathrm{d}^4\sigma_{\leftarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + - * \mathrm{d}^4\sigma_{\leftarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right)\right) + - * \left(\mathrm{d}^4\sigma_{\rightarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + - * \mathrm{d}^4\sigma_{\rightarrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right)\right) + * \mathrm{d}^4\sigma_{\leftarrow}^{-}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\rightarrow}^{-}\left(x_{B}, t, Q^2, \phi\right) * } \, , * \f$ * * where - * \f$\sigma_{t_{h}}^{b_{h} b_{c}}\f$ is q single photon production cross-section (DVCS, BH and Interference) for target helicity denoted by \f$t_{h}\f$, beam helicity denoted by \f$b_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + * \f$\sigma_{t_{h}}^{b_{c}}\f$ is q single photon production cross-section (DVCS, BH and Interference) for target helicity denoted by \f$t_{h}\f$ and beam charge denoted by \f$b_{c}\f$. */ class DVCSAulMinus: public Observable { diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlus.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlus.h new file mode 100644 index 0000000000000000000000000000000000000000..9034c9acac8008de62a5d7ecf526567664daf926 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlus.h @@ -0,0 +1,73 @@ +#ifndef DVCSAULPLUS +#define DVCSAULPLUS + +/** + * @file DVCSAulPlus.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAulPlus + * @brief Longitudinally polarized target asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UL}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \mathrm{d}^4\sigma_{\leftarrow}^{+}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\rightarrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + * }{ + * \mathrm{d}^4\sigma_{\leftarrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\rightarrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{c}}\f$ is q single photon production cross-section (DVCS, BH and Interference) for target helicity denoted by \f$t_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAulPlus: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAulPlus(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAulPlus(); + + virtual DVCSAulPlus* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAulPlus(const DVCSAulPlus &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAULPLUS */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin1Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin1Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..739bee03c38f6ac3cc72f8f208f5944e0dfc9ff6 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin1Phi.h @@ -0,0 +1,86 @@ +#ifndef DVCSAULPLUSSIN1PHI +#define DVCSAULPLUSSIN1PHI + +/** + * @file DVCSAulPlusSin1Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAulPlus.h" + +namespace PARTONS { + +/** + * @class DVCSAulPlusSin1Phi + * + * @brief 1th Fourier moment of longitudinally polarized target asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UL}^{\sin\left(1\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{UL}\left(x_{B}, t, Q^2, \phi\right) \sin\left(1\phi\right) \, , + * \f$ + * + * where \f$A_{UL}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAulPlus. + */ +class DVCSAulPlusSin1Phi: public DVCSAulPlus, public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAulPlusSin1Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAulPlusSin1Phi(); + + virtual DVCSAulPlusSin1Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAulPlusSin1Phi(const DVCSAulPlusSin1Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAULPLUSSIN1PHI */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin2Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin2Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..5dfc23fbf2bd30777c51373fddcd166bc4859e0d --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin2Phi.h @@ -0,0 +1,86 @@ +#ifndef DVCSAULPLUSSIN2PHI +#define DVCSAULPLUSSIN2PHI + +/** + * @file DVCSAulPlusSin2Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAulPlus.h" + +namespace PARTONS { + +/** + * @class DVCSAulPlusSin2Phi + * + * @brief 2th Fourier moment of longitudinally polarized target asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UL}^{\sin\left(2\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{UL}\left(x_{B}, t, Q^2, \phi\right) \sin\left(2\phi\right) \, , + * \f$ + * + * where \f$A_{UL}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAulPlus. + */ +class DVCSAulPlusSin2Phi: public DVCSAulPlus, public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAulPlusSin2Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAulPlusSin2Phi(); + + virtual DVCSAulPlusSin2Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAulPlusSin2Phi(const DVCSAulPlusSin2Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAULPLUSSIN2PHI */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin3Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin3Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..7441991a5bc5d0b423ab9d92f30131cdafbabd79 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin3Phi.h @@ -0,0 +1,86 @@ +#ifndef DVCSAULPLUSSIN3PHI +#define DVCSAULPLUSSIN3PHI + +/** + * @file DVCSAulPlusSin3Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAulPlus.h" + +namespace PARTONS { + +/** + * @class DVCSAulPlusSin3Phi + * + * @brief 3th Fourier moment of longitudinally polarized target asymmetry for positive beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UL}^{\sin\left(3\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{UL}\left(x_{B}, t, Q^2, \phi\right) \sin\left(3\phi\right) \, , + * \f$ + * + * where \f$A_{UL}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAulPlus. + */ +class DVCSAulPlusSin3Phi: public DVCSAulPlus, public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAulPlusSin3Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAulPlusSin3Phi(); + + virtual DVCSAulPlusSin3Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAulPlusSin3Phi(const DVCSAulPlusSin3Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAULPLUSSIN3PHI */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhis.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhis.h new file mode 100644 index 0000000000000000000000000000000000000000..1e5b1ca11843a985304f6c8c74c43a468ff04c23 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhis.h @@ -0,0 +1,77 @@ +#ifndef DVCSAUTDVCSSINPHIMPHIS_H +#define DVCSAUTDVCSSINPHIMPHIS_H + +/** + * @file DVCSAutDVCSSinPhiMPhis.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAutDVCSSinPhiMPhis + * @brief Transverse target asymmetry (DVCS part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UT, DVCS}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \left(\mathrm{d}^4\sigma_{\downarrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{-}\left(x_{B}, t, Q^2, \phi\right)\right) - + * \left(\mathrm{d}^4\sigma_{\uparrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{-}\left(x_{B}, t, Q^2, \phi\right)\right) + * }{ + * \left(\mathrm{d}^4\sigma_{\downarrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{-}\left(x_{B}, t, Q^2, \phi\right)\right) + + * \left(\mathrm{d}^4\sigma_{\uparrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{-}\left(x_{B}, t, Q^2, \phi\right)\right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for target helicity denoted by \f$t_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAutDVCSSinPhiMPhis: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAutDVCSSinPhiMPhis(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAutDVCSSinPhiMPhis(); + + virtual DVCSAutDVCSSinPhiMPhis* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAutDVCSSinPhiMPhis(const DVCSAutDVCSSinPhiMPhis &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAUTDVCSSINPHIMPHIS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhisCos0Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhisCos0Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..cfc1b2a8c78bead1b75bea532de37a359bec9939 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhisCos0Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSAUTDVCSSINPHIMPHISCOS0PHI_H +#define DVCSAUTDVCSSINPHIMPHISCOS0PHI_H + +/** + * @file DVCSAutDVCSSinPhiMPhisCos0Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAutDVCSSinPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAutDVCSSinPhiMPhisCos0Phi + * + * @brief 0th Fourier moment of transverse target asymmetry (DVCS part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UT, DVCS}^{\sin\left(\phi-\phi_{S}\right)\cos\left(0\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{2\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(0\phi\right) \, , + * \f$ + * + * where \f$A_{UT, DVCS}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAutDVCSSinPhiMPhis. + */ +class DVCSAutDVCSSinPhiMPhisCos0Phi: public DVCSAutDVCSSinPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAutDVCSSinPhiMPhisCos0Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAutDVCSSinPhiMPhisCos0Phi(); + + virtual DVCSAutDVCSSinPhiMPhisCos0Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAutDVCSSinPhiMPhisCos0Phi(const DVCSAutDVCSSinPhiMPhisCos0Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAUTDVCSSINPHIMPHISCOS0PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhis.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhis.h new file mode 100644 index 0000000000000000000000000000000000000000..dc735d0c52e97cc5a59da1df710e765b87a4da4d --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhis.h @@ -0,0 +1,77 @@ +#ifndef DVCSAUTINTSINPHIMPHIS_H +#define DVCSAUTINTSINPHIMPHIS_H + +/** + * @file DVCSAutIntSinPhiMPhis.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAutIntSinPhiMPhis + * @brief Transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \left(\mathrm{d}^4\sigma_{\downarrow}^{+}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\downarrow}^{-}\left(x_{B}, t, Q^2, \phi\right)\right) - + * \left(\mathrm{d}^4\sigma_{\uparrow}^{+}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{-}\left(x_{B}, t, Q^2, \phi\right)\right) + * }{ + * \left(\mathrm{d}^4\sigma_{\downarrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\downarrow}^{-}\left(x_{B}, t, Q^2, \phi\right)\right) + + * \left(\mathrm{d}^4\sigma_{\uparrow}^{+}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{-}\left(x_{B}, t, Q^2, \phi\right)\right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for target helicity denoted by \f$t_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAutIntSinPhiMPhis: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAutIntSinPhiMPhis(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAutIntSinPhiMPhis(); + + virtual DVCSAutIntSinPhiMPhis* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAutIntSinPhiMPhis(const DVCSAutIntSinPhiMPhis &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAUTINTSINPHIMPHIS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos0Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos0Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..50c52a30494dc1097b323e96f8f7736e2eee0cc8 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos0Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSAUTINTSINPHIMPHISCOS0PHI_H +#define DVCSAUTINTSINPHIMPHISCOS0PHI_H + +/** + * @file DVCSAutIntSinPhiMPhisCos0Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAutIntSinPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAutIntSinPhiMPhisCos0Phi + * + * @brief 0th Fourier moment of transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UT, Int}^{\sin\left(\phi-\phi_{S}\right)\cos\left(0\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{2\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(0\phi\right) \, , + * \f$ + * + * where \f$A_{UT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAutIntSinPhiMPhis. + */ +class DVCSAutIntSinPhiMPhisCos0Phi: public DVCSAutIntSinPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAutIntSinPhiMPhisCos0Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAutIntSinPhiMPhisCos0Phi(); + + virtual DVCSAutIntSinPhiMPhisCos0Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAutIntSinPhiMPhisCos0Phi(const DVCSAutIntSinPhiMPhisCos0Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAUTINTSINPHIMPHISCOS0PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos1Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos1Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..5b308c6cfe607477647cdc965c186716576d2b06 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos1Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSAUTINTSINPHIMPHISCOS1PHI_H +#define DVCSAUTINTSINPHIMPHISCOS1PHI_H + +/** + * @file DVCSAutIntSinPhiMPhisCos1Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAutIntSinPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAutIntSinPhiMPhisCos1Phi + * + * @brief 1th Fourier moment of transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UT, Int}^{\sin\left(\phi-\phi_{S}\right)\cos\left(1\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(1\phi\right) \, , + * \f$ + * + * where \f$A_{UT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAutIntSinPhiMPhis. + */ +class DVCSAutIntSinPhiMPhisCos1Phi: public DVCSAutIntSinPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAutIntSinPhiMPhisCos1Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAutIntSinPhiMPhisCos1Phi(); + + virtual DVCSAutIntSinPhiMPhisCos1Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAutIntSinPhiMPhisCos1Phi(const DVCSAutIntSinPhiMPhisCos1Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAUTINTSINPHIMPHISCOS1PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisSin1Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisSin1Phi.h new file mode 100644 index 0000000000000000000000000000000000000000..897d41400ff8c754f394ea4ab8e36bfeae02eef5 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisSin1Phi.h @@ -0,0 +1,87 @@ +#ifndef DVCSAUTINTSINPHIMPHISSIN1PHI_H +#define DVCSAUTINTSINPHIMPHISSIN1PHI_H + +/** + * @file DVCSAutIntSinPhiMPhisSin1Phi.h + * @author Pawel Sznajder (NCBJ, Warsaw) + * @date November 16, 2017 + * @version 1.0 + */ + +#include +#include +#include + +#include "../../../MathIntegratorModule.h" +#include "DVCSAutIntSinPhiMPhis.h" + +namespace PARTONS { + +/** + * @class DVCSAutIntSinPhiMPhisSin1Phi + * + * @brief 1th Fourier moment of transverse target asymmetry (interference part). + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UT, Int}^{\sin\left(\phi-\phi_{S}\right)\sin\left(1\phi\right)}\left(x_{B}, t, Q^2\right) = + * \frac{1}{\pi} + * \int_{0}^{2\pi} \mathrm{d}\phi A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \sin\left(1\phi\right) \, , + * \f$ + * + * where \f$A_{UT, Int}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAutIntSinPhiMPhis. + */ +class DVCSAutIntSinPhiMPhisSin1Phi: public DVCSAutIntSinPhiMPhis, + public MathIntegratorModule { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAutIntSinPhiMPhisSin1Phi(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAutIntSinPhiMPhisSin1Phi(); + + virtual DVCSAutIntSinPhiMPhisSin1Phi* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computeFourierObservable(); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAutIntSinPhiMPhisSin1Phi(const DVCSAutIntSinPhiMPhisSin1Phi &other); + + /** + * Functor to perform the integration. + */ + NumA::FunctionType1D* m_pFunctionToIntegrateObservable; + + /** + * Function to be integrated. + */ + virtual double functionToIntegrateObservable(double x, + std::vector params); + + /** + * Initialize functors. + */ + void initFunctorsForIntegrations(); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAUTINTSINPHIMPHISSIN1PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhis.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhis.h new file mode 100644 index 0000000000000000000000000000000000000000..6035daa309c9743fee5f31349d93c37a5bea0e09 --- /dev/null +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhis.h @@ -0,0 +1,73 @@ +#ifndef DVCSAUTMINUSSINPHIMPHIS_H +#define DVCSAUTMINUSSINPHIMPHIS_H + +/** + * @file DVCSAutMinusSinPhiMPhis.h + * @author Bryan BERTHOU (SPhN / CEA Saclay) + * @date November 28, 2014 + * @version 1.0 + */ + +#include +#include + +#include "../../Observable.h" + +namespace PARTONS { + +/** + * @class DVCSAutMinusSinPhiMPhis + * @brief Transverse target asymmetry for negative beam charge. + * + * Definition:
+ * + * \f$ \displaystyle + * A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) = + * \frac{ + * \mathrm{d}^4\sigma_{\downarrow}^{-}\left(x_{B}, t, Q^2, \phi\right) - + * \mathrm{d}^4\sigma_{\uparrow}^{-}\left(x_{B}, t, Q^2, \phi\right) + * }{ + * \mathrm{d}^4\sigma_{\downarrow}^{-}\left(x_{B}, t, Q^2, \phi\right) + + * \mathrm{d}^4\sigma_{\uparrow}^{-}\left(x_{B}, t, Q^2, \phi\right) + * } \, , + * \f$ + * + * where + * \f$\sigma_{t_{h}}^{b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for target helicity denoted by \f$t_{h}\f$ and beam charge denoted by \f$b_{c}\f$. + */ +class DVCSAutMinusSinPhiMPhis: public Observable { + +public: + + /** + * Unique ID to automatically register the class in the registry. + */ + static const unsigned int classId; + + /** + * Constructor. + * @param className Name of class. + */ + DVCSAutMinusSinPhiMPhis(const std::string &className); + + /** + * Destructor. + */ + virtual ~DVCSAutMinusSinPhiMPhis(); + + virtual DVCSAutMinusSinPhiMPhis* clone() const; + virtual void configure(const ElemUtils::Parameters ¶meters); + virtual double computePhiObservable(double phi); + +protected: + + /** + * Copy constructor. + * @param other Object to be copied. + */ + DVCSAutMinusSinPhiMPhis(const DVCSAutMinusSinPhiMPhis &other); +}; + +} /* namespace PARTONS */ + +#endif /* DVCSAUTMINUSSINPHIMPHIS_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhisCos0Phi.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhisCos0Phi.h similarity index 67% rename from include/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhisCos0Phi.h rename to include/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhisCos0Phi.h index 9ad5c6c10aeb77e44fe49ea996d208d4c3950168..703636ccf28f571163e109be645f1f3427a0e595 100644 --- a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhisCos0Phi.h +++ b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhisCos0Phi.h @@ -1,8 +1,8 @@ -#ifndef DVCSAUTSINPHIMPHISCOS0PHI_H -#define DVCSAUTSINPHIMPHISCOS0PHI_H +#ifndef DVCSAUTMINUSSINPHIMPHISCOS0PHI_H +#define DVCSAUTMINUSSINPHIMPHISCOS0PHI_H /** - * @file DVCSAutSinPhiMPhisCos0Phi.h + * @file DVCSAutMinusSinPhiMPhisCos0Phi.h * @author Luca COLANERI (IPNO) * @date July 18, 2016 * @version 1.0 @@ -13,14 +13,14 @@ #include #include "../../../MathIntegratorModule.h" -#include "DVCSAutSinPhiMPhis.h" +#include "DVCSAutMinusSinPhiMPhis.h" namespace PARTONS { /** - * @class DVCSAutSinPhiMPhisCos0Phi + * @class DVCSAutMinusSinPhiMPhisCos0Phi * - * @brief 0th Fourier moment of transverse target beam asymmetry for negative beam charge. + * @brief 0th Fourier moment of transverse target asymmetry for negative beam charge. * * Definition:
* @@ -30,9 +30,9 @@ namespace PARTONS { * \int_{0}^{2\pi} \mathrm{d}\phi A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) \cos\left(0\phi\right) \, , * \f$ * - * where \f$A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAutSinPhiMPhis. + * where \f$A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right)\f$ is defined in DVCSAutMinusSinPhiMPhis. */ -class DVCSAutSinPhiMPhisCos0Phi: public DVCSAutSinPhiMPhis, +class DVCSAutMinusSinPhiMPhisCos0Phi: public DVCSAutMinusSinPhiMPhis, public MathIntegratorModule { public: @@ -46,14 +46,14 @@ public: * Constructor. * @param className Name of class. */ - DVCSAutSinPhiMPhisCos0Phi(const std::string &className); + DVCSAutMinusSinPhiMPhisCos0Phi(const std::string &className); /** * Destructor. */ - virtual ~DVCSAutSinPhiMPhisCos0Phi(); + virtual ~DVCSAutMinusSinPhiMPhisCos0Phi(); - virtual DVCSAutSinPhiMPhisCos0Phi* clone() const; + virtual DVCSAutMinusSinPhiMPhisCos0Phi* clone() const; virtual void configure(const ElemUtils::Parameters ¶meters); virtual double computeFourierObservable(); @@ -63,7 +63,7 @@ protected: * Copy constructor. * @param other Object to be copied. */ - DVCSAutSinPhiMPhisCos0Phi(const DVCSAutSinPhiMPhisCos0Phi &other); + DVCSAutMinusSinPhiMPhisCos0Phi(const DVCSAutMinusSinPhiMPhisCos0Phi &other); /** * Functor to perform the integration. @@ -84,4 +84,4 @@ protected: } /* namespace PARTONS */ -#endif /* DVCSAUTSINPHIMPHISCOS0PHI_H */ +#endif /* DVCSAUTMINUSSINPHIMPHISCOS0PHI_H */ diff --git a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhis.h b/include/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhis.h deleted file mode 100644 index d9b8c4df331552ab3709e6ba6635230c057fee1d..0000000000000000000000000000000000000000 --- a/include/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhis.h +++ /dev/null @@ -1,77 +0,0 @@ -#ifndef DVCSAUTSINPHIMPHIS_H -#define DVCSAUTSINPHIMPHIS_H - -/** - * @file DVCSAutSinPhiMPhis.h - * @author Bryan BERTHOU (SPhN / CEA Saclay) - * @date November 28, 2014 - * @version 1.0 - */ - -#include -#include - -#include "../../Observable.h" - -namespace PARTONS { - -/** - * @class DVCSAutSinPhiMPhis - * @brief Transverse target beam asymmetry for negative beam charge. - * - * Definition:
- * - * \f$ \displaystyle - * A_{UT}^{\sin\left(\phi-\phi_{S}\right)}\left(x_{B}, t, Q^2, \phi\right) = - * \frac{ - * \left(\mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + - * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right)\right) - - * \left(\mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + - * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right)\right) - * }{ - * \left(\mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right) + - * \mathrm{d}^4\sigma_{\downarrow}^{\rightarrow -}\left(x_{B}, t, Q^2, \phi\right)\right) + - * \left(\mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right) + - * \mathrm{d}^4\sigma_{\uparrow}^{\leftarrow -}\left(x_{B}, t, Q^2, \phi\right)\right) - * } \, , - * \f$ - * - * where - * \f$\sigma_{t_{h}}^{b_{h} b_{c}}\f$ is a single photon production cross-section (DVCS, BH and Int) for target helicity denoted by \f$t_{h}\f$, beam helicity denoted by \f$b_{h}\f$ and beam charge denoted by \f$b_{c}\f$. - */ -class DVCSAutSinPhiMPhis: public Observable { - -public: - - /** - * Unique ID to automatically register the class in the registry. - */ - static const unsigned int classId; - - /** - * Constructor. - * @param className Name of class. - */ - DVCSAutSinPhiMPhis(const std::string &className); - - /** - * Destructor. - */ - virtual ~DVCSAutSinPhiMPhis(); - - virtual DVCSAutSinPhiMPhis* clone() const; - virtual void configure(const ElemUtils::Parameters ¶meters); - virtual double computePhiObservable(double phi); - -protected: - - /** - * Copy constructor. - * @param other Object to be copied. - */ - DVCSAutSinPhiMPhis(const DVCSAutSinPhiMPhis &other); -}; - -} /* namespace PARTONS */ - -#endif /* DVCSAUTSINPHIMPHIS_H */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAcCos0Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAcCos0Phi.cpp index 96bd2e2e6053f187bbb44fc5e7561c224ca595c6..571eb578ffe0ecc4431eec3f98768ef182854d2a 100644 --- a/src/partons/modules/observable/DVCS/asymmetry/DVCSAcCos0Phi.cpp +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAcCos0Phi.cpp @@ -60,7 +60,7 @@ void DVCSAcCos0Phi::configure(const ElemUtils::Parameters ¶meters) { double DVCSAcCos0Phi::functionToIntegrateObservable(double x, std::vector params) { - return DVCSAc::computePhiObservable(x); + return DVCSAc::computePhiObservable(x); // * cos(0 * x); } double DVCSAcCos0Phi::computeFourierObservable() { diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAllMinusCos0Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllMinusCos0Phi.cpp index bf536579bf9f147512f3cd788308124fe781d30c..4c7ec99879d94593a0947a5d857981de8fbbf1ba 100644 --- a/src/partons/modules/observable/DVCS/asymmetry/DVCSAllMinusCos0Phi.cpp +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllMinusCos0Phi.cpp @@ -61,7 +61,7 @@ void DVCSAllMinusCos0Phi::configure(const ElemUtils::Parameters ¶meters) { double DVCSAllMinusCos0Phi::functionToIntegrateObservable(double x, std::vector params) { - return DVCSAllMinus::computePhiObservable(x) * cos(0 * x); + return DVCSAllMinus::computePhiObservable(x);// * cos(0 * x); } double DVCSAllMinusCos0Phi::computeFourierObservable() { diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAllMinusCos1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllMinusCos1Phi.cpp index cbbf90c1e91b16449f870aa558d3956472faf66e..808c8d0140f49ea288df27ce7daf24e4d89ea10f 100644 --- a/src/partons/modules/observable/DVCS/asymmetry/DVCSAllMinusCos1Phi.cpp +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllMinusCos1Phi.cpp @@ -61,7 +61,7 @@ void DVCSAllMinusCos1Phi::configure(const ElemUtils::Parameters ¶meters) { double DVCSAllMinusCos1Phi::functionToIntegrateObservable(double x, std::vector params) { - return DVCSAllMinus::computePhiObservable(x) * cos(1 * x); + return DVCSAllMinus::computePhiObservable(x) * cos(x); } double DVCSAllMinusCos1Phi::computeFourierObservable() { diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlus.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlus.cpp new file mode 100644 index 0000000000000000000000000000000000000000..602778b88fb47b85a1b22b91bab66a342c35852c --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlus.cpp @@ -0,0 +1,59 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlus.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + + +const unsigned int DVCSAllPlus::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAllPlus("DVCSAllPlus")); + +DVCSAllPlus::DVCSAllPlus(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAllPlus::DVCSAllPlus(const DVCSAllPlus& other) : + Observable(other) { +} + +DVCSAllPlus::~DVCSAllPlus() { +} + +DVCSAllPlus* DVCSAllPlus::clone() const { + return new DVCSAllPlus(*this); +} + +void DVCSAllPlus::configure(const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAllPlus::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., 0., -1.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., 0., +1.), phi); + + double C = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., 0., +1.), phi); + + double D = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., 0., -1.), phi); + + if (A + B + C + D == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return ((A + B) - (C + D)) / ((A + B) + (C + D)); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhisCos0Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos0Phi.cpp similarity index 53% rename from src/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhisCos0Phi.cpp rename to src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos0Phi.cpp index 079791d6732df8c78df7721d8913e5c7158d3dee..8f03c8ac1e80940bad83bcdf0a2ed593c90f6aaf 100644 --- a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhisCos0Phi.cpp +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos0Phi.cpp @@ -1,4 +1,4 @@ -#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhisCos0Phi.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos0Phi.h" #include #include @@ -12,14 +12,12 @@ namespace PARTONS { - -const unsigned int DVCSAutSinPhiMPhisCos0Phi::classId = +const unsigned int DVCSAllPlusCos0Phi::classId = BaseObjectRegistry::getInstance()->registerBaseObject( - new DVCSAutSinPhiMPhisCos0Phi("DVCSAutSinPhiMPhisCos0Phi")); + new DVCSAllPlusCos0Phi("DVCSAllPlusCos0Phi")); -DVCSAutSinPhiMPhisCos0Phi::DVCSAutSinPhiMPhisCos0Phi( - const std::string &className) : - DVCSAutSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( +DVCSAllPlusCos0Phi::DVCSAllPlusCos0Phi(const std::string &className) : + DVCSAllPlus(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( 0) { m_observableType = ObservableType::FOURIER; @@ -29,15 +27,14 @@ DVCSAutSinPhiMPhisCos0Phi::DVCSAutSinPhiMPhisCos0Phi( initFunctorsForIntegrations(); } -DVCSAutSinPhiMPhisCos0Phi::DVCSAutSinPhiMPhisCos0Phi( - const DVCSAutSinPhiMPhisCos0Phi& other) : - DVCSAutSinPhiMPhis(other), MathIntegratorModule(other) { +DVCSAllPlusCos0Phi::DVCSAllPlusCos0Phi(const DVCSAllPlusCos0Phi& other) : + DVCSAllPlus(other), MathIntegratorModule(other) { m_pFunctionToIntegrateObservable = 0; initFunctorsForIntegrations(); } -DVCSAutSinPhiMPhisCos0Phi::~DVCSAutSinPhiMPhisCos0Phi() { +DVCSAllPlusCos0Phi::~DVCSAllPlusCos0Phi() { if (m_pFunctionToIntegrateObservable) { delete m_pFunctionToIntegrateObservable; @@ -45,28 +42,28 @@ DVCSAutSinPhiMPhisCos0Phi::~DVCSAutSinPhiMPhisCos0Phi() { } } -void DVCSAutSinPhiMPhisCos0Phi::initFunctorsForIntegrations() { +void DVCSAllPlusCos0Phi::initFunctorsForIntegrations() { m_pFunctionToIntegrateObservable = NumA::Integrator1D::newIntegrationFunctor(this, - &DVCSAutSinPhiMPhisCos0Phi::functionToIntegrateObservable); + &DVCSAllPlusCos0Phi::functionToIntegrateObservable); } -DVCSAutSinPhiMPhisCos0Phi* DVCSAutSinPhiMPhisCos0Phi::clone() const { - return new DVCSAutSinPhiMPhisCos0Phi(*this); +DVCSAllPlusCos0Phi* DVCSAllPlusCos0Phi::clone() const { + return new DVCSAllPlusCos0Phi(*this); } -void DVCSAutSinPhiMPhisCos0Phi::configure(const ElemUtils::Parameters ¶meters) { +void DVCSAllPlusCos0Phi::configure(const ElemUtils::Parameters ¶meters) { - DVCSAutSinPhiMPhis::configure(parameters); - MathIntegratorModule::configureIntegrator(parameters); + DVCSAllPlus::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); } -double DVCSAutSinPhiMPhisCos0Phi::functionToIntegrateObservable(double x, +double DVCSAllPlusCos0Phi::functionToIntegrateObservable(double x, std::vector params) { - return DVCSAutSinPhiMPhis::computePhiObservable(x) * cos(x); + return DVCSAllPlus::computePhiObservable(x); // * cos(0 * x); } -double DVCSAutSinPhiMPhisCos0Phi::computeFourierObservable() { +double DVCSAllPlusCos0Phi::computeFourierObservable() { std::vector emptyParameters; diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos1Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ef5360a1c3e37b1d417b0b425322a7b9f9afa433 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos1Phi.cpp @@ -0,0 +1,74 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos1Phi.h" + +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" + +namespace PARTONS { + +const unsigned int DVCSAllPlusCos1Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAllPlusCos1Phi("DVCSAllPlusCos1Phi")); + +DVCSAllPlusCos1Phi::DVCSAllPlusCos1Phi(const std::string &className) : + DVCSAllPlus(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAllPlusCos1Phi::DVCSAllPlusCos1Phi(const DVCSAllPlusCos1Phi& other) : + DVCSAllPlus(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAllPlusCos1Phi::~DVCSAllPlusCos1Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAllPlusCos1Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAllPlusCos1Phi::functionToIntegrateObservable); +} + +DVCSAllPlusCos1Phi* DVCSAllPlusCos1Phi::clone() const { + return new DVCSAllPlusCos1Phi(*this); +} + +void DVCSAllPlusCos1Phi::configure(const ElemUtils::Parameters ¶meters) { + + DVCSAllPlus::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAllPlusCos1Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAllPlus::computePhiObservable(x) * cos(x); +} + +double DVCSAllPlusCos1Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos2Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos2Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4b23fec3659ca1508307b40fce909ed985956518 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos2Phi.cpp @@ -0,0 +1,74 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAllPlusCos2Phi.h" + +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" + +namespace PARTONS { + +const unsigned int DVCSAllPlusCos2Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAllPlusCos2Phi("DVCSAllPlusCos2Phi")); + +DVCSAllPlusCos2Phi::DVCSAllPlusCos2Phi(const std::string &className) : + DVCSAllPlus(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAllPlusCos2Phi::DVCSAllPlusCos2Phi(const DVCSAllPlusCos2Phi& other) : + DVCSAllPlus(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAllPlusCos2Phi::~DVCSAllPlusCos2Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAllPlusCos2Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAllPlusCos2Phi::functionToIntegrateObservable); +} + +DVCSAllPlusCos2Phi* DVCSAllPlusCos2Phi::clone() const { + return new DVCSAllPlusCos2Phi(*this); +} + +void DVCSAllPlusCos2Phi::configure(const ElemUtils::Parameters ¶meters) { + + DVCSAllPlus::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAllPlusCos2Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAllPlus::computePhiObservable(x) * cos(2 * x); +} + +double DVCSAllPlusCos2Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhis.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhis.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4123171f1e6c7875570560d95d92dff25d060077 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhis.cpp @@ -0,0 +1,71 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhis.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + +const unsigned int DVCSAltDVCSCosPhiMPhis::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltDVCSCosPhiMPhis("DVCSAltDVCSCosPhiMPhis")); + +DVCSAltDVCSCosPhiMPhis::DVCSAltDVCSCosPhiMPhis(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAltDVCSCosPhiMPhis::DVCSAltDVCSCosPhiMPhis(const DVCSAltDVCSCosPhiMPhis& other) : + Observable(other) { +} + +DVCSAltDVCSCosPhiMPhis::~DVCSAltDVCSCosPhiMPhis() { +} + +DVCSAltDVCSCosPhiMPhis* DVCSAltDVCSCosPhiMPhis::clone() const { + return new DVCSAltDVCSCosPhiMPhis(*this); +} + +void DVCSAltDVCSCosPhiMPhis::configure(const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAltDVCSCosPhiMPhis::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(-1., 0., 0.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(-1., 0., 0.), phi); + + double C = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(-1., 0., 0.), phi); + + double D = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(-1., 0., 0.), phi); + + double E = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(+1, 0., 0.), phi); + + double F = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(+1, 0., 0.), phi); + + double G = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(+1, 0., 0.), phi); + + double H = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(+1, 0., 0.), phi); + + if (A + B + C + D + E + F + G + H == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return ((A - B + C - D) - (E - F + G - H)) + / ((A + B + C + D) + (E + F + G + H)); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos0Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos0Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..12e56917f8a2bb5eb6ef7a268cdac1427822f797 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos0Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos0Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAltDVCSCosPhiMPhisCos0Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltDVCSCosPhiMPhisCos0Phi( + "DVCSAltDVCSCosPhiMPhisCos0Phi")); + +DVCSAltDVCSCosPhiMPhisCos0Phi::DVCSAltDVCSCosPhiMPhisCos0Phi( + const std::string &className) : + DVCSAltDVCSCosPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAltDVCSCosPhiMPhisCos0Phi::DVCSAltDVCSCosPhiMPhisCos0Phi( + const DVCSAltDVCSCosPhiMPhisCos0Phi& other) : + DVCSAltDVCSCosPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAltDVCSCosPhiMPhisCos0Phi::~DVCSAltDVCSCosPhiMPhisCos0Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAltDVCSCosPhiMPhisCos0Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAltDVCSCosPhiMPhisCos0Phi::functionToIntegrateObservable); +} + +DVCSAltDVCSCosPhiMPhisCos0Phi* DVCSAltDVCSCosPhiMPhisCos0Phi::clone() const { + return new DVCSAltDVCSCosPhiMPhisCos0Phi(*this); +} + +void DVCSAltDVCSCosPhiMPhisCos0Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAltDVCSCosPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAltDVCSCosPhiMPhisCos0Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAltDVCSCosPhiMPhis::computePhiObservable(x);// * cos(0 * x); +} + +double DVCSAltDVCSCosPhiMPhisCos0Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (2 * Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos1Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a4900895d0c8951d43f9a2da9e2c727aa34db1d4 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos1Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSCosPhiMPhisCos1Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAltDVCSCosPhiMPhisCos1Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltDVCSCosPhiMPhisCos1Phi( + "DVCSAltDVCSCosPhiMPhisCos1Phi")); + +DVCSAltDVCSCosPhiMPhisCos1Phi::DVCSAltDVCSCosPhiMPhisCos1Phi( + const std::string &className) : + DVCSAltDVCSCosPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAltDVCSCosPhiMPhisCos1Phi::DVCSAltDVCSCosPhiMPhisCos1Phi( + const DVCSAltDVCSCosPhiMPhisCos1Phi& other) : + DVCSAltDVCSCosPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAltDVCSCosPhiMPhisCos1Phi::~DVCSAltDVCSCosPhiMPhisCos1Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAltDVCSCosPhiMPhisCos1Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAltDVCSCosPhiMPhisCos1Phi::functionToIntegrateObservable); +} + +DVCSAltDVCSCosPhiMPhisCos1Phi* DVCSAltDVCSCosPhiMPhisCos1Phi::clone() const { + return new DVCSAltDVCSCosPhiMPhisCos1Phi(*this); +} + +void DVCSAltDVCSCosPhiMPhisCos1Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAltDVCSCosPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAltDVCSCosPhiMPhisCos1Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAltDVCSCosPhiMPhis::computePhiObservable(x) * cos(x); +} + +double DVCSAltDVCSCosPhiMPhisCos1Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhis.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhis.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2499e7efff5e3eb04fd9edd79b26021c509db5d8 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhis.cpp @@ -0,0 +1,71 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhis.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + +const unsigned int DVCSAltDVCSSinPhiMPhis::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltDVCSSinPhiMPhis("DVCSAltDVCSSinPhiMPhis")); + +DVCSAltDVCSSinPhiMPhis::DVCSAltDVCSSinPhiMPhis(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAltDVCSSinPhiMPhis::DVCSAltDVCSSinPhiMPhis(const DVCSAltDVCSSinPhiMPhis& other) : + Observable(other) { +} + +DVCSAltDVCSSinPhiMPhis::~DVCSAltDVCSSinPhiMPhis() { +} + +DVCSAltDVCSSinPhiMPhis* DVCSAltDVCSSinPhiMPhis::clone() const { + return new DVCSAltDVCSSinPhiMPhis(*this); +} + +void DVCSAltDVCSSinPhiMPhis::configure(const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAltDVCSSinPhiMPhis::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., -1., 0.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., -1., 0.), phi); + + double C = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(0., -1., 0.), phi); + + double D = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(0., -1., 0.), phi); + + double E = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., +1., 0.), phi); + + double F = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., +1., 0.), phi); + + double G = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(0., +1., 0.), phi); + + double H = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(0., +1., 0.), phi); + + if (A + B + C + D + E + F + G + H == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return ((A - B + C - D) - (E - F + G - H)) + / ((A + B + C + D) + (E + F + G + H)); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhisSin1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhisSin1Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0bc6e7512b15a5d2302c72e20c952149f0a66f1d --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhisSin1Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltDVCSSinPhiMPhisSin1Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAltDVCSSinPhiMPhisSin1Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltDVCSSinPhiMPhisSin1Phi( + "DVCSAltDVCSSinPhiMPhisSin1Phi")); + +DVCSAltDVCSSinPhiMPhisSin1Phi::DVCSAltDVCSSinPhiMPhisSin1Phi( + const std::string &className) : + DVCSAltDVCSSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAltDVCSSinPhiMPhisSin1Phi::DVCSAltDVCSSinPhiMPhisSin1Phi( + const DVCSAltDVCSSinPhiMPhisSin1Phi& other) : + DVCSAltDVCSSinPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAltDVCSSinPhiMPhisSin1Phi::~DVCSAltDVCSSinPhiMPhisSin1Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAltDVCSSinPhiMPhisSin1Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAltDVCSSinPhiMPhisSin1Phi::functionToIntegrateObservable); +} + +DVCSAltDVCSSinPhiMPhisSin1Phi* DVCSAltDVCSSinPhiMPhisSin1Phi::clone() const { + return new DVCSAltDVCSSinPhiMPhisSin1Phi(*this); +} + +void DVCSAltDVCSSinPhiMPhisSin1Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAltDVCSSinPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAltDVCSSinPhiMPhisSin1Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAltDVCSSinPhiMPhis::computePhiObservable(x) * sin(x); +} + +double DVCSAltDVCSSinPhiMPhisSin1Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhis.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhis.cpp new file mode 100644 index 0000000000000000000000000000000000000000..84c193705f2a56d425aeccf28e8a0e5c6c9fb808 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhis.cpp @@ -0,0 +1,71 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhis.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + +const unsigned int DVCSAltIntCosPhiMPhis::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltIntCosPhiMPhis("DVCSAltIntCosPhiMPhis")); + +DVCSAltIntCosPhiMPhis::DVCSAltIntCosPhiMPhis(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAltIntCosPhiMPhis::DVCSAltIntCosPhiMPhis(const DVCSAltIntCosPhiMPhis& other) : + Observable(other) { +} + +DVCSAltIntCosPhiMPhis::~DVCSAltIntCosPhiMPhis() { +} + +DVCSAltIntCosPhiMPhis* DVCSAltIntCosPhiMPhis::clone() const { + return new DVCSAltIntCosPhiMPhis(*this); +} + +void DVCSAltIntCosPhiMPhis::configure(const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAltIntCosPhiMPhis::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(-1., 0., 0.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(-1., 0., 0.), phi); + + double C = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(-1., 0., 0.), phi); + + double D = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(-1., 0., 0.), phi); + + double E = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(+1., 0., 0.), phi); + + double F = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(+1., 0., 0.), phi); + + double G = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(+1., 0., 0.), phi); + + double H = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(+1., 0., 0.), phi); + + if (A + B + C + D + E + F + G + H == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return ((A - B - C + D) - (E - F - G + H)) + / ((A + B + C + D) + (E + F + G + H)); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos0Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos0Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..663eec74f796007c0c5dc9fc250b1d209371753b --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos0Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos0Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAltIntCosPhiMPhisCos0Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltIntCosPhiMPhisCos0Phi( + "DVCSAltIntCosPhiMPhisCos0Phi")); + +DVCSAltIntCosPhiMPhisCos0Phi::DVCSAltIntCosPhiMPhisCos0Phi( + const std::string &className) : + DVCSAltIntCosPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAltIntCosPhiMPhisCos0Phi::DVCSAltIntCosPhiMPhisCos0Phi( + const DVCSAltIntCosPhiMPhisCos0Phi& other) : + DVCSAltIntCosPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAltIntCosPhiMPhisCos0Phi::~DVCSAltIntCosPhiMPhisCos0Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAltIntCosPhiMPhisCos0Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAltIntCosPhiMPhisCos0Phi::functionToIntegrateObservable); +} + +DVCSAltIntCosPhiMPhisCos0Phi* DVCSAltIntCosPhiMPhisCos0Phi::clone() const { + return new DVCSAltIntCosPhiMPhisCos0Phi(*this); +} + +void DVCSAltIntCosPhiMPhisCos0Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAltIntCosPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAltIntCosPhiMPhisCos0Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAltIntCosPhiMPhis::computePhiObservable(x); // * cos(0 * x); +} + +double DVCSAltIntCosPhiMPhisCos0Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (2 * Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos1Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..101688915b9503c0371682e9ff8985c215338105 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos1Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos1Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAltIntCosPhiMPhisCos1Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltIntCosPhiMPhisCos1Phi( + "DVCSAltIntCosPhiMPhisCos1Phi")); + +DVCSAltIntCosPhiMPhisCos1Phi::DVCSAltIntCosPhiMPhisCos1Phi( + const std::string &className) : + DVCSAltIntCosPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAltIntCosPhiMPhisCos1Phi::DVCSAltIntCosPhiMPhisCos1Phi( + const DVCSAltIntCosPhiMPhisCos1Phi& other) : + DVCSAltIntCosPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAltIntCosPhiMPhisCos1Phi::~DVCSAltIntCosPhiMPhisCos1Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAltIntCosPhiMPhisCos1Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAltIntCosPhiMPhisCos1Phi::functionToIntegrateObservable); +} + +DVCSAltIntCosPhiMPhisCos1Phi* DVCSAltIntCosPhiMPhisCos1Phi::clone() const { + return new DVCSAltIntCosPhiMPhisCos1Phi(*this); +} + +void DVCSAltIntCosPhiMPhisCos1Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAltIntCosPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAltIntCosPhiMPhisCos1Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAltIntCosPhiMPhis::computePhiObservable(x) * cos(x); +} + +double DVCSAltIntCosPhiMPhisCos1Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos2Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos2Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..70e4980a4092a13164e77f211ef15a782141d72f --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos2Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntCosPhiMPhisCos2Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAltIntCosPhiMPhisCos2Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltIntCosPhiMPhisCos2Phi( + "DVCSAltIntCosPhiMPhisCos2Phi")); + +DVCSAltIntCosPhiMPhisCos2Phi::DVCSAltIntCosPhiMPhisCos2Phi( + const std::string &className) : + DVCSAltIntCosPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAltIntCosPhiMPhisCos2Phi::DVCSAltIntCosPhiMPhisCos2Phi( + const DVCSAltIntCosPhiMPhisCos2Phi& other) : + DVCSAltIntCosPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAltIntCosPhiMPhisCos2Phi::~DVCSAltIntCosPhiMPhisCos2Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAltIntCosPhiMPhisCos2Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAltIntCosPhiMPhisCos2Phi::functionToIntegrateObservable); +} + +DVCSAltIntCosPhiMPhisCos2Phi* DVCSAltIntCosPhiMPhisCos2Phi::clone() const { + return new DVCSAltIntCosPhiMPhisCos2Phi(*this); +} + +void DVCSAltIntCosPhiMPhisCos2Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAltIntCosPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAltIntCosPhiMPhisCos2Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAltIntCosPhiMPhis::computePhiObservable(x) * cos(2 * x); +} + +double DVCSAltIntCosPhiMPhisCos2Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhis.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhis.cpp new file mode 100644 index 0000000000000000000000000000000000000000..82746bf7c60b128ceb624d4476eccec3b0f87d22 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhis.cpp @@ -0,0 +1,71 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhis.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + +const unsigned int DVCSAltIntSinPhiMPhis::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltIntSinPhiMPhis("DVCSAltIntSinPhiMPhis")); + +DVCSAltIntSinPhiMPhis::DVCSAltIntSinPhiMPhis(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAltIntSinPhiMPhis::DVCSAltIntSinPhiMPhis(const DVCSAltIntSinPhiMPhis& other) : + Observable(other) { +} + +DVCSAltIntSinPhiMPhis::~DVCSAltIntSinPhiMPhis() { +} + +DVCSAltIntSinPhiMPhis* DVCSAltIntSinPhiMPhis::clone() const { + return new DVCSAltIntSinPhiMPhis(*this); +} + +void DVCSAltIntSinPhiMPhis::configure(const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAltIntSinPhiMPhis::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., -1., 0.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., -1., 0.), phi); + + double C = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(0., -1., 0.), phi); + + double D = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(0., -1., 0.), phi); + + double E = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., +1., 0.), phi); + + double F = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., +1., 0.), phi); + + double G = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(0., +1., 0.), phi); + + double H = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(0., +1., 0.), phi); + + if (A + B + C + D + E + F + G + H == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return ((A - B - C + D) - (E - F - G + H)) + / ((A + B + C + D) + (E + F + G + H)); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin1Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..183a366132084d0488a75c26d2d7d6d3f88357ed --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin1Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin1Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAltIntSinPhiMPhisSin1Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltIntSinPhiMPhisSin1Phi( + "DVCSAltIntSinPhiMPhisSin1Phi")); + +DVCSAltIntSinPhiMPhisSin1Phi::DVCSAltIntSinPhiMPhisSin1Phi( + const std::string &className) : + DVCSAltIntSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAltIntSinPhiMPhisSin1Phi::DVCSAltIntSinPhiMPhisSin1Phi( + const DVCSAltIntSinPhiMPhisSin1Phi& other) : + DVCSAltIntSinPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAltIntSinPhiMPhisSin1Phi::~DVCSAltIntSinPhiMPhisSin1Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAltIntSinPhiMPhisSin1Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAltIntSinPhiMPhisSin1Phi::functionToIntegrateObservable); +} + +DVCSAltIntSinPhiMPhisSin1Phi* DVCSAltIntSinPhiMPhisSin1Phi::clone() const { + return new DVCSAltIntSinPhiMPhisSin1Phi(*this); +} + +void DVCSAltIntSinPhiMPhisSin1Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAltIntSinPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAltIntSinPhiMPhisSin1Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAltIntSinPhiMPhis::computePhiObservable(x) * sin(x); +} + +double DVCSAltIntSinPhiMPhisSin1Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin2Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin2Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ddf8cf0c687cbd545488b607537250f834c87ac5 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin2Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAltIntSinPhiMPhisSin2Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAltIntSinPhiMPhisSin2Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAltIntSinPhiMPhisSin2Phi( + "DVCSAltIntSinPhiMPhisSin2Phi")); + +DVCSAltIntSinPhiMPhisSin2Phi::DVCSAltIntSinPhiMPhisSin2Phi( + const std::string &className) : + DVCSAltIntSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAltIntSinPhiMPhisSin2Phi::DVCSAltIntSinPhiMPhisSin2Phi( + const DVCSAltIntSinPhiMPhisSin2Phi& other) : + DVCSAltIntSinPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAltIntSinPhiMPhisSin2Phi::~DVCSAltIntSinPhiMPhisSin2Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAltIntSinPhiMPhisSin2Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAltIntSinPhiMPhisSin2Phi::functionToIntegrateObservable); +} + +DVCSAltIntSinPhiMPhisSin2Phi* DVCSAltIntSinPhiMPhisSin2Phi::clone() const { + return new DVCSAltIntSinPhiMPhisSin2Phi(*this); +} + +void DVCSAltIntSinPhiMPhisSin2Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAltIntSinPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAltIntSinPhiMPhisSin2Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAltIntSinPhiMPhis::computePhiObservable(x) * sin(2 * x); +} + +double DVCSAltIntSinPhiMPhisSin2Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAluPlus.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAluPlus.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0bbc071338f8d6069fdc2c666a1004392cc724dc --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAluPlus.cpp @@ -0,0 +1,53 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAluPlus.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + + +const unsigned int DVCSAluPlus::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAluPlus("DVCSAluPlus")); + +DVCSAluPlus::DVCSAluPlus(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAluPlus::DVCSAluPlus(const DVCSAluPlus& other) : + Observable(other) { +} + +DVCSAluPlus::~DVCSAluPlus() { +} + +DVCSAluPlus* DVCSAluPlus::clone() const { + return new DVCSAluPlus(*this); +} + +void DVCSAluPlus::configure(const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAluPlus::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., 0., 0.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., 0., 0.), phi); + + if (A + B == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return (A - B) / (A + B); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlus.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlus.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cf64fd7495c72cd90634c3be892ff61f4aef54da --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlus.cpp @@ -0,0 +1,58 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlus.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + +const unsigned int DVCSAulPlus::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAulPlus("DVCSAulPlus")); + +DVCSAulPlus::DVCSAulPlus(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAulPlus::DVCSAulPlus(const DVCSAulPlus& other) : + Observable(other) { +} + +DVCSAulPlus::~DVCSAulPlus() { +} + +DVCSAulPlus* DVCSAulPlus::clone() const { + return new DVCSAulPlus(*this); +} + +void DVCSAulPlus::configure(const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAulPlus::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., 0., -1.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., 0., -1.), phi); + + double C = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., 0., +1.), phi); + + double D = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., 0., +1.), phi); + + if (A + B + C + D == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return ((A + B) - (C + D)) / ((A + B) + (C + D)); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin1Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..556b0b04208d984aecc948ac1e49c4d7a6bfd16b --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin1Phi.cpp @@ -0,0 +1,72 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin1Phi.h" + +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" + +namespace PARTONS { + +const unsigned int DVCSAulPlusSin1Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAulPlusSin1Phi("DVCSAulPlusSin1Phi")); + +DVCSAulPlusSin1Phi::DVCSAulPlusSin1Phi(const std::string &className) : + DVCSAulPlus(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAulPlusSin1Phi::DVCSAulPlusSin1Phi(const DVCSAulPlusSin1Phi& other) : + DVCSAulPlus(other), MathIntegratorModule(other) { + initFunctorsForIntegrations(); +} + +DVCSAulPlusSin1Phi::~DVCSAulPlusSin1Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAulPlusSin1Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAulPlusSin1Phi::functionToIntegrateObservable); +} + +DVCSAulPlusSin1Phi* DVCSAulPlusSin1Phi::clone() const { + return new DVCSAulPlusSin1Phi(*this); +} + +void DVCSAulPlusSin1Phi::configure(const ElemUtils::Parameters ¶meters) { + + DVCSAulPlus::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAulPlusSin1Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAulPlus::computePhiObservable(x) * sin(x); +} + +double DVCSAulPlusSin1Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / Constant::PI; +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin2Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin2Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e5c198cf52e5dd716e7439e50261472179a6f403 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin2Phi.cpp @@ -0,0 +1,72 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin2Phi.h" + +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" + +namespace PARTONS { + +const unsigned int DVCSAulPlusSin2Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAulPlusSin2Phi("DVCSAulPlusSin2Phi")); + +DVCSAulPlusSin2Phi::DVCSAulPlusSin2Phi(const std::string &className) : + DVCSAulPlus(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAulPlusSin2Phi::DVCSAulPlusSin2Phi(const DVCSAulPlusSin2Phi& other) : + DVCSAulPlus(other), MathIntegratorModule(other) { + initFunctorsForIntegrations(); +} + +DVCSAulPlusSin2Phi::~DVCSAulPlusSin2Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAulPlusSin2Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAulPlusSin2Phi::functionToIntegrateObservable); +} + +DVCSAulPlusSin2Phi* DVCSAulPlusSin2Phi::clone() const { + return new DVCSAulPlusSin2Phi(*this); +} + +void DVCSAulPlusSin2Phi::configure(const ElemUtils::Parameters ¶meters) { + + DVCSAulPlus::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAulPlusSin2Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAulPlus::computePhiObservable(x) * sin(2 * x); +} + +double DVCSAulPlusSin2Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / Constant::PI; +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin3Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin3Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9a239710c7ff610f2abd4a483fa15c581db6ea38 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin3Phi.cpp @@ -0,0 +1,72 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAulPlusSin3Phi.h" + +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" + +namespace PARTONS { + +const unsigned int DVCSAulPlusSin3Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAulPlusSin3Phi("DVCSAulPlusSin3Phi")); + +DVCSAulPlusSin3Phi::DVCSAulPlusSin3Phi(const std::string &className) : + DVCSAulPlus(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAulPlusSin3Phi::DVCSAulPlusSin3Phi(const DVCSAulPlusSin3Phi& other) : + DVCSAulPlus(other), MathIntegratorModule(other) { + initFunctorsForIntegrations(); +} + +DVCSAulPlusSin3Phi::~DVCSAulPlusSin3Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAulPlusSin3Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAulPlusSin3Phi::functionToIntegrateObservable); +} + +DVCSAulPlusSin3Phi* DVCSAulPlusSin3Phi::clone() const { + return new DVCSAulPlusSin3Phi(*this); +} + +void DVCSAulPlusSin3Phi::configure(const ElemUtils::Parameters ¶meters) { + + DVCSAulPlus::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAulPlusSin3Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAulPlus::computePhiObservable(x) * sin(3 * x); +} + +double DVCSAulPlusSin3Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / Constant::PI; +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhis.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhis.cpp new file mode 100644 index 0000000000000000000000000000000000000000..184252b0397215db4853405a6896ca2baac9c302 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhis.cpp @@ -0,0 +1,73 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhis.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + +const unsigned int DVCSAutDVCSSinPhiMPhis::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAutDVCSSinPhiMPhis("DVCSAutDVCSSinPhiMPhis")); + +DVCSAutDVCSSinPhiMPhis::DVCSAutDVCSSinPhiMPhis(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAutDVCSSinPhiMPhis::DVCSAutDVCSSinPhiMPhis( + const DVCSAutDVCSSinPhiMPhis& other) : + Observable(other) { +} + +DVCSAutDVCSSinPhiMPhis::~DVCSAutDVCSSinPhiMPhis() { +} + +DVCSAutDVCSSinPhiMPhis* DVCSAutDVCSSinPhiMPhis::clone() const { + return new DVCSAutDVCSSinPhiMPhis(*this); +} + +void DVCSAutDVCSSinPhiMPhis::configure( + const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAutDVCSSinPhiMPhis::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., -1., 0.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., -1., 0.), phi); + + double C = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(0., -1., 0.), phi); + + double D = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(0., -1., 0.), phi); + + double E = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., +1., 0.), phi); + + double F = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., +1., 0.), phi); + + double G = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(0., +1., 0.), phi); + + double H = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(0., +1., 0.), phi); + + if (A + B + C + D + E + F + G + H == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return ((A + B + C + D) - (E + F + G + H)) + / ((A + B + C + D) + (E + F + G + H)); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhisCos0Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhisCos0Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5213cc825d13b676beb2ed132227bd2fe8a49cbe --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhisCos0Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutDVCSSinPhiMPhisCos0Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAutDVCSSinPhiMPhisCos0Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAutDVCSSinPhiMPhisCos0Phi( + "DVCSAutDVCSSinPhiMPhisCos0Phi")); + +DVCSAutDVCSSinPhiMPhisCos0Phi::DVCSAutDVCSSinPhiMPhisCos0Phi( + const std::string &className) : + DVCSAutDVCSSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAutDVCSSinPhiMPhisCos0Phi::DVCSAutDVCSSinPhiMPhisCos0Phi( + const DVCSAutDVCSSinPhiMPhisCos0Phi& other) : + DVCSAutDVCSSinPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAutDVCSSinPhiMPhisCos0Phi::~DVCSAutDVCSSinPhiMPhisCos0Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAutDVCSSinPhiMPhisCos0Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAutDVCSSinPhiMPhisCos0Phi::functionToIntegrateObservable); +} + +DVCSAutDVCSSinPhiMPhisCos0Phi* DVCSAutDVCSSinPhiMPhisCos0Phi::clone() const { + return new DVCSAutDVCSSinPhiMPhisCos0Phi(*this); +} + +void DVCSAutDVCSSinPhiMPhisCos0Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAutDVCSSinPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAutDVCSSinPhiMPhisCos0Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAutDVCSSinPhiMPhis::computePhiObservable(x);// * cos(0 * x); +} + +double DVCSAutDVCSSinPhiMPhisCos0Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (2 * Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhis.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhis.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e868d14ad96a71d9a09829cc6d00b96a51685b86 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhis.cpp @@ -0,0 +1,71 @@ +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhis.h" + +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/process/ProcessModule.h" + +namespace PARTONS { + +const unsigned int DVCSAutIntSinPhiMPhis::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAutIntSinPhiMPhis("DVCSAutIntSinPhiMPhis")); + +DVCSAutIntSinPhiMPhis::DVCSAutIntSinPhiMPhis(const std::string &className) : + Observable(className) { + m_channel = ObservableChannel::DVCS; +} + +DVCSAutIntSinPhiMPhis::DVCSAutIntSinPhiMPhis(const DVCSAutIntSinPhiMPhis& other) : + Observable(other) { +} + +DVCSAutIntSinPhiMPhis::~DVCSAutIntSinPhiMPhis() { +} + +DVCSAutIntSinPhiMPhis* DVCSAutIntSinPhiMPhis::clone() const { + return new DVCSAutIntSinPhiMPhis(*this); +} + +void DVCSAutIntSinPhiMPhis::configure(const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); +} + +double DVCSAutIntSinPhiMPhis::computePhiObservable(double phi) { + + double A = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., -1., 0.), phi); + + double B = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., -1., 0.), phi); + + double C = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(0., -1., 0.), phi); + + double D = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(0., -1., 0.), phi); + + double E = m_pProcessModule->computeCrossSection(+1, +1, + NumA::Vector3D(0., +1., 0.), phi); + + double F = m_pProcessModule->computeCrossSection(-1, +1, + NumA::Vector3D(0., +1., 0.), phi); + + double G = m_pProcessModule->computeCrossSection(+1, -1, + NumA::Vector3D(0., +1., 0.), phi); + + double H = m_pProcessModule->computeCrossSection(-1, -1, + NumA::Vector3D(0., +1., 0.), phi); + + if (A + B + C + D + E + F + G + H == 0.) { + + warn(__func__, "Asymmetry denominator is zero."); + return 0.; + } + + return ((A + B - C - D) - (E + F - G - H)) + / ((A + B + C + D) + (E + F + G + H)); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos0Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos0Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..13faecc31209f2ced3cdf62ca61cd21dc4ad78f1 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos0Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos0Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAutIntSinPhiMPhisCos0Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAutIntSinPhiMPhisCos0Phi( + "DVCSAutIntSinPhiMPhisCos0Phi")); + +DVCSAutIntSinPhiMPhisCos0Phi::DVCSAutIntSinPhiMPhisCos0Phi( + const std::string &className) : + DVCSAutIntSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAutIntSinPhiMPhisCos0Phi::DVCSAutIntSinPhiMPhisCos0Phi( + const DVCSAutIntSinPhiMPhisCos0Phi& other) : + DVCSAutIntSinPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAutIntSinPhiMPhisCos0Phi::~DVCSAutIntSinPhiMPhisCos0Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAutIntSinPhiMPhisCos0Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAutIntSinPhiMPhisCos0Phi::functionToIntegrateObservable); +} + +DVCSAutIntSinPhiMPhisCos0Phi* DVCSAutIntSinPhiMPhisCos0Phi::clone() const { + return new DVCSAutIntSinPhiMPhisCos0Phi(*this); +} + +void DVCSAutIntSinPhiMPhisCos0Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAutIntSinPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAutIntSinPhiMPhisCos0Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAutIntSinPhiMPhis::computePhiObservable(x);// * cos(0 * x); +} + +double DVCSAutIntSinPhiMPhisCos0Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (2 * Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos1Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fe17687431b6dc77d70e5e6bd7067d8dddedce33 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos1Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisCos1Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAutIntSinPhiMPhisCos1Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAutIntSinPhiMPhisCos1Phi( + "DVCSAutIntSinPhiMPhisCos1Phi")); + +DVCSAutIntSinPhiMPhisCos1Phi::DVCSAutIntSinPhiMPhisCos1Phi( + const std::string &className) : + DVCSAutIntSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAutIntSinPhiMPhisCos1Phi::DVCSAutIntSinPhiMPhisCos1Phi( + const DVCSAutIntSinPhiMPhisCos1Phi& other) : + DVCSAutIntSinPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAutIntSinPhiMPhisCos1Phi::~DVCSAutIntSinPhiMPhisCos1Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAutIntSinPhiMPhisCos1Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAutIntSinPhiMPhisCos1Phi::functionToIntegrateObservable); +} + +DVCSAutIntSinPhiMPhisCos1Phi* DVCSAutIntSinPhiMPhisCos1Phi::clone() const { + return new DVCSAutIntSinPhiMPhisCos1Phi(*this); +} + +void DVCSAutIntSinPhiMPhisCos1Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAutIntSinPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAutIntSinPhiMPhisCos1Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAutIntSinPhiMPhis::computePhiObservable(x) * cos(x); +} + +double DVCSAutIntSinPhiMPhisCos1Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisSin1Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisSin1Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cefcfd1f4df1f756caafbf483363d61c5753ce7f --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisSin1Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutIntSinPhiMPhisSin1Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAutIntSinPhiMPhisSin1Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAutIntSinPhiMPhisSin1Phi( + "DVCSAutIntSinPhiMPhisSin1Phi")); + +DVCSAutIntSinPhiMPhisSin1Phi::DVCSAutIntSinPhiMPhisSin1Phi( + const std::string &className) : + DVCSAutIntSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAutIntSinPhiMPhisSin1Phi::DVCSAutIntSinPhiMPhisSin1Phi( + const DVCSAutIntSinPhiMPhisSin1Phi& other) : + DVCSAutIntSinPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAutIntSinPhiMPhisSin1Phi::~DVCSAutIntSinPhiMPhisSin1Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAutIntSinPhiMPhisSin1Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAutIntSinPhiMPhisSin1Phi::functionToIntegrateObservable); +} + +DVCSAutIntSinPhiMPhisSin1Phi* DVCSAutIntSinPhiMPhisSin1Phi::clone() const { + return new DVCSAutIntSinPhiMPhisSin1Phi(*this); +} + +void DVCSAutIntSinPhiMPhisSin1Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAutIntSinPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAutIntSinPhiMPhisSin1Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAutIntSinPhiMPhis::computePhiObservable(x) * sin(x); +} + +double DVCSAutIntSinPhiMPhisSin1Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (Constant::PI); +} + +} /* namespace PARTONS */ diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhis.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhis.cpp similarity index 62% rename from src/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhis.cpp rename to src/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhis.cpp index cb6850dfcc50c5ab322e19cc2ffa07b4a3cc0eb9..139cc0883b6214f421755644dcb45bf60f1eebb0 100644 --- a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhis.cpp +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhis.cpp @@ -1,39 +1,39 @@ -#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutSinPhiMPhis.h" - #include #include "../../../../../../include/partons/beans/observable/ObservableChannel.h" #include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhis.h" #include "../../../../../../include/partons/modules/process/ProcessModule.h" namespace PARTONS { - -const unsigned int DVCSAutSinPhiMPhis::classId = +const unsigned int DVCSAutMinusSinPhiMPhis::classId = BaseObjectRegistry::getInstance()->registerBaseObject( - new DVCSAutSinPhiMPhis("DVCSAutSinPhiMPhis")); + new DVCSAutMinusSinPhiMPhis("DVCSAutMinusSinPhiMPhis")); -DVCSAutSinPhiMPhis::DVCSAutSinPhiMPhis(const std::string &className) : +DVCSAutMinusSinPhiMPhis::DVCSAutMinusSinPhiMPhis(const std::string &className) : Observable(className) { m_channel = ObservableChannel::DVCS; } -DVCSAutSinPhiMPhis::DVCSAutSinPhiMPhis(const DVCSAutSinPhiMPhis& other) : +DVCSAutMinusSinPhiMPhis::DVCSAutMinusSinPhiMPhis( + const DVCSAutMinusSinPhiMPhis& other) : Observable(other) { } -DVCSAutSinPhiMPhis::~DVCSAutSinPhiMPhis() { +DVCSAutMinusSinPhiMPhis::~DVCSAutMinusSinPhiMPhis() { } -DVCSAutSinPhiMPhis* DVCSAutSinPhiMPhis::clone() const { - return new DVCSAutSinPhiMPhis(*this); +DVCSAutMinusSinPhiMPhis* DVCSAutMinusSinPhiMPhis::clone() const { + return new DVCSAutMinusSinPhiMPhis(*this); } -void DVCSAutSinPhiMPhis::configure(const ElemUtils::Parameters ¶meters) { - Observable::configure(parameters); +void DVCSAutMinusSinPhiMPhis::configure( + const ElemUtils::Parameters ¶meters) { + Observable::configure(parameters); } -double DVCSAutSinPhiMPhis::computePhiObservable(double phi) { +double DVCSAutMinusSinPhiMPhis::computePhiObservable(double phi) { double A = m_pProcessModule->computeCrossSection(+1, -1, NumA::Vector3D(0., -1., 0.), phi); diff --git a/src/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhisCos0Phi.cpp b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhisCos0Phi.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f51f32a2f65b30724fb094cea53f85b3c878bf07 --- /dev/null +++ b/src/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhisCos0Phi.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +#include "../../../../../../include/partons/beans/observable/ObservableChannel.h" +#include "../../../../../../include/partons/beans/observable/ObservableType.h" +#include "../../../../../../include/partons/BaseObjectRegistry.h" +#include "../../../../../../include/partons/FundamentalPhysicalConstants.h" +#include "../../../../../../include/partons/modules/observable/DVCS/asymmetry/DVCSAutMinusSinPhiMPhisCos0Phi.h" + +namespace PARTONS { + +const unsigned int DVCSAutMinusSinPhiMPhisCos0Phi::classId = + BaseObjectRegistry::getInstance()->registerBaseObject( + new DVCSAutMinusSinPhiMPhisCos0Phi( + "DVCSAutMinusSinPhiMPhisCos0Phi")); + +DVCSAutMinusSinPhiMPhisCos0Phi::DVCSAutMinusSinPhiMPhisCos0Phi( + const std::string &className) : + DVCSAutMinusSinPhiMPhis(className), MathIntegratorModule(), m_pFunctionToIntegrateObservable( + 0) { + + m_observableType = ObservableType::FOURIER; + m_channel = ObservableChannel::DVCS; + + setIntegrator(NumA::IntegratorType1D::DEXP); + initFunctorsForIntegrations(); +} + +DVCSAutMinusSinPhiMPhisCos0Phi::DVCSAutMinusSinPhiMPhisCos0Phi( + const DVCSAutMinusSinPhiMPhisCos0Phi& other) : + DVCSAutMinusSinPhiMPhis(other), MathIntegratorModule(other) { + + m_pFunctionToIntegrateObservable = 0; + initFunctorsForIntegrations(); +} + +DVCSAutMinusSinPhiMPhisCos0Phi::~DVCSAutMinusSinPhiMPhisCos0Phi() { + + if (m_pFunctionToIntegrateObservable) { + delete m_pFunctionToIntegrateObservable; + m_pFunctionToIntegrateObservable = 0; + } +} + +void DVCSAutMinusSinPhiMPhisCos0Phi::initFunctorsForIntegrations() { + m_pFunctionToIntegrateObservable = + NumA::Integrator1D::newIntegrationFunctor(this, + &DVCSAutMinusSinPhiMPhisCos0Phi::functionToIntegrateObservable); +} + +DVCSAutMinusSinPhiMPhisCos0Phi* DVCSAutMinusSinPhiMPhisCos0Phi::clone() const { + return new DVCSAutMinusSinPhiMPhisCos0Phi(*this); +} + +void DVCSAutMinusSinPhiMPhisCos0Phi::configure( + const ElemUtils::Parameters ¶meters) { + + DVCSAutMinusSinPhiMPhis::configure(parameters); + MathIntegratorModule::configureIntegrator(parameters); +} + +double DVCSAutMinusSinPhiMPhisCos0Phi::functionToIntegrateObservable(double x, + std::vector params) { + return DVCSAutMinusSinPhiMPhis::computePhiObservable(x);// * cos(0 * x); +} + +double DVCSAutMinusSinPhiMPhisCos0Phi::computeFourierObservable() { + + std::vector emptyParameters; + + return integrate(m_pFunctionToIntegrateObservable, 0., (2 * Constant::PI), + emptyParameters) / (2 * Constant::PI); +} + +} /* namespace PARTONS */