process/DVMP/DVMPProcessModule.h

0001 #ifndef DVMP_PROCESS_MODULE_H
0002 #define DVMP_PROCESS_MODULE_H
0003
0004 /**
0005  * @file DVMPProcessModule.h
0006  * @author Bryan BERTHOU (SPhN / CEA Saclay)
0007  * @date November 19, 2014
0008  * @version 1.0
0009  */
0010
0011 #include <ElementaryUtils/parameters/Parameters.h>
0012 #include <NumA/linear_algebra/vector/Vector3D.h>
0013 #include <complex>
0014 #include <map>
0015 #include <string>
0016
0017 #include "../../../beans/automation/BaseObjectData.h"
0018 #include "../../../beans/convol_coeff_function/DVMP/DVMPConvolCoeffFunctionKinematic.h"
0019 #include "../../../beans/convol_coeff_function/DVMP/DVMPConvolCoeffFunctionResult.h"
0020 #include "../../../beans/gpd/GPDType.h"
0021 #include "../../../beans/List.h"
0022 #include "../../../beans/PolarizationType.h"
0023 #include "../../../beans/MesonType.h"
0024 #include "../../../beans/observable/DVMP/DVMPObservableKinematic.h"
0025 #include "../../../beans/observable/DVMP/DVMPObservableResult.h"
0026 #include "../../../utils/type/PhysicalType.h"
0027 #include "../ProcessModule.h"
0028
0029 namespace PARTONS {
0030 class DVMPConvolCoeffFunctionModule;
0031 class DVMPScalesModule;
0032 class DVMPXiConverterModule;
0033 } /* namespace PARTONS */
0034
0035 namespace PARTONS {
0036
0037 /**
0038  * @class DVMPProcessModule
0039  *
0040  * @brief Abstract class for computing the *differential* cross section of
0041  * Deeply Virtual Meson Production (DVMP).
0042  *
0043  * The cross-section is five-fold differential with respect to the variables: @f$ x_B @f$, @f$ Q^2 @f$, @f$ t @f$, the two angles and it is defined for a specif meson.
0044  */
0045 class DVMPProcessModule: public ProcessModule<DVMPObservableKinematic,
0046         DVMPObservableResult> {
0047
0048 public:
0049
0050     static const std::string DVMP_PROCESS_MODULE_CLASS_NAME; ///< Type of the module in XML automation.
0051
0052     /**
0053      * Destructor.
0054      */
0055     virtual ~DVMPProcessModule();
0056
0057     virtual DVMPProcessModule* clone() const = 0;
0058     virtual std::string toString() const;
0059     virtual void resolveObjectDependencies();
0060     virtual void run();
0061     virtual void configure(const ElemUtils::Parameters &parameters);
0062     virtual void prepareSubModules(
0063             const std::map<std::string, BaseObjectData>& subModulesData);
0064     virtual List<GPDType> getListOfAvailableGPDTypeForComputation() const;
0065     virtual std::vector<double> test();
0066
0067
0068     /**
0069      * Computes the differential cross-section. Must be implemented in the child class.
0070      * @param beamHelicity Helicity of the beam (in units of hbar/2).
0071      * @param beamCharge Charge of the beam (in units of positron charge).
0072      * @param targetPolarization Polarization of the target. In GV conventions.
0073      * @param mesonPolarization Meson polarization.
0074      * @param kinematic Kinematics.
0075      * @param processType Subprocess type.
0076      * @return Result.
0077      */
0078     DVMPObservableResult compute(double beamHelicity, double beamCharge,
0079             NumA::Vector3D targetPolarization,
0080             PolarizationType::Type mesonPolarization,
0081             const DVMPObservableKinematic& kinematic,
0082             const List<GPDType>& gpdType);
0083
0084     /**
0085      * Reset previous kinematics.
0086      */
0087     virtual void resetPreviousKinematic();
0088
0089     /**
0090      * Check if this kinematics is different than the previous one.
0091      */
0092     bool isPreviousCCFKinematicDifferent(
0093             const DVMPConvolCoeffFunctionKinematic& kinematic) const;
0094
0095     // ##### GETTERS & SETTERS #####
0096
0097     /**
0098      * Get scale module.
0099      */
0100     DVMPScalesModule* getScaleModule() const;
0101
0102     /**
0103      * Set scale module.
0104      */
0105     void setScaleModule(DVMPScalesModule* pScaleModule);
0106
0107     /**
0108      * Get xi converter module.
0109      */
0110     DVMPXiConverterModule* getXiConverterModule() const;
0111
0112     /**
0113      * Set xi converted module.
0114      */
0115     void setXiConverterModule(DVMPXiConverterModule* pXiConverterModule);
0116
0117     /**
0118      * Get CCF module;
0119      */
0120     DVMPConvolCoeffFunctionModule* getConvolCoeffFunctionModule() const;
0121
0122     /**
0123      * Set CCF module
0124      */
0125     void setConvolCoeffFunctionModule(
0126             DVMPConvolCoeffFunctionModule* pConvolCoeffFunctionModule);
0127
0128     // ##### IMPLEMENTATION MEMBERS #####
0129
0130     /**
0131      * Differential cross section.
0132      */
0133     virtual PhysicalType<double> CrossSection();
0134
0135     /**
0136      * Set manually CFFs.
0137      */
0138     void setConvolCoeffFunction(const DVMPConvolCoeffFunctionKinematic& kin,
0139             const DVMPConvolCoeffFunctionResult& result);
0140
0141 protected:
0142
0143     /**
0144      * Default constructor.
0145      */
0146     DVMPProcessModule(const std::string &className);
0147
0148     /**
0149      * Copy constructor.
0150      * @param other Object to be copied.
0151      */
0152     DVMPProcessModule(const DVMPProcessModule& other);
0153
0154     virtual void setKinematics(const DVMPObservableKinematic& kinematic);
0155     virtual void setExperimentalConditions(double beamHelicity,
0156             double beamCharge, NumA::Vector3D targetPolarization,
0157             PolarizationType::Type mesonPolarization);
0158     virtual void initModule();
0159     virtual void isModuleWellConfigured();
0160
0161     double m_xB; ///< Bjorken variable.
0162     double m_t; ///< Mandelstam variable (square of the 4-momentum transferm in GeV2).
0163     double m_Q2; ///< Virtuality of the incoming photon (in GeV2).
0164     double m_E; ///< Beam energy in target rest frame (in GeV).
0165     double m_phi; ///<  Angle between leptonic and hadronic plane (in radians, Trento convention).
0166     MesonType::Type m_mesonType; ///< Meson type.
0167
0168     double m_beamHelicity; ///< Beam helicity.
0169     double m_beamCharge; ///< Beam charge.
0170     NumA::Vector3D m_targetPolarization; ///< Target polarization.
0171     PolarizationType::Type m_mesonPolarization; ///< Meson polarization.
0172
0173     double m_tmin; ///< Minimal value of t.
0174     double m_tmax; ///< Maximal value of t.
0175     double m_xBmin; ///< Minimal value of xB.
0176     double m_y; ///< Lepton energy fraction.
0177
0178     DVMPScalesModule* m_pScaleModule; ///< Pointer to the underlying scale module.
0179     DVMPXiConverterModule* m_pXiConverterModule; ///< Pointer to the underlying xi converter module.
0180     DVMPConvolCoeffFunctionModule* m_pConvolCoeffFunctionModule; ///< Pointer to the underlying CCF module.
0181
0182     DVMPConvolCoeffFunctionResult m_dvcsConvolCoeffFunctionResult; ///< Stored Compton Form Factor result.
0183     DVMPConvolCoeffFunctionKinematic m_lastCCFKinematics; ///< Last Compton Form Factor kinematics.
0184
0185     /**
0186      * Compute CCF for a given kinematics.
0187      * @param kinematic Kinematics to be computed.
0188      * @param mesonPolarization Meson polarization.
0189      * @param gpdType List of GPD types to be computed.
0190      */
0191     void computeConvolCoeffFunction(const DVMPObservableKinematic& kinematic,
0192             PolarizationType::Type mesonPolarization,
0193             const List<GPDType> & gpdType = List<GPDType>());
0194
0195     /**
0196      * Gives back a previously computed Compton Form Factor.
0197      * @param gpdType CFF type (e.g. H or E).
0198      * @return CFF value for the given type.
0199      */
0200     std::complex<double> getConvolCoeffFunctionValue(GPDType::Type gpdType);
0201 };
0202
0203 } /* namespace PARTONS */
0204
0205 #endif /* DVMP_PROCESS_MODULE_H */