add examples for DVMP

data/examples/cff/computeManyKinematicsForDVMPComptonFormFactor.xml

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+
+<!--
+This scenario demonstrates the evaluation of DVMP Compton Form Factors (CFF) for kinematics defined in a text file. In this file kinematic points are encoded in separate lines using the following format: "xi|t|MuF2|MuR2|Q2". The result of this scenario is printed out to the standard output. These are CFF values for all GPD types defined in the selected GPD model. 
+-->
+
+<!-- Scenario starts here -->
+<!-- For your convenience and for bookkeeping provide creation date and unique description -->
+<scenario date="2017-07-18" description="DVMP CFF evaluation for many kinematics example">
+
+   <!-- First task: evaluate DVMP CFF for a single kinematics --> 
+   <!-- Indicate service and its methods to be used and indicate if the result should be stored in the database --> 
+   <task service="DVMPConvolCoeffFunctionService" method="computeManyKinematic" storeInDB="0">
+
+      <!-- Define DVMP CFF kinematics -->
+      <kinematics type="DVMPConvolCoeffFunctionKinematic">
+
+         <!-- Path to file defining kinematics -->
+         <param name="file" value="/home/partons/git/partons-example/data/examples/cff/kinematics_dvmp_cff_with_units.csv" />
+      </kinematics>
+
+      <!-- Define physics assumptions -->
+      <computation_configuration>
+
+         <!-- Select DVMP CFF model -->
+         <module type="DVMPConvolCoeffFunctionModule" name="DVMPCFFGK06">
+
+            <!-- Parameters of MC integration -->
+            <param name="nWarmUps" value="10000" />
+            <param name="nCalls" value="100000" />
+            <param name="chi2Limit" value="0.8" />
+
+            <!-- Indicate pQCD order of calculation -->
+            <param name="qcd_order_type" value="LO" />
+
+            <!-- Select GPD model -->
+            <module type="GPDModule" name="GPDGK19">
+            </module>
+
+         </module>
+
+      </computation_configuration>
+
+   </task>
+
+   <!-- Second task: print results of the last computation into standard output --> 
+   <task service="DVMPConvolCoeffFunctionService" method="printResults">
+   </task>
+
+</scenario>

data/examples/cff/computeSingleKinematicsForDVMPComptonFormFactor.xml

@@ -19,8 +19,8 @@ This scenario demonstrates a simple task as the evaluation of DVMP Compton Form
          <param name="Q2" value="4." />
          <param name="MuF2" value="4." />
          <param name="MuR2" value="4." />
-         <param name="meson" value="rho0" />
-         <param name="mesonPolarization" value="L" />
+         <param name="meson" value="pi0" />
+         <param name="mesonPolarization" value="UNDEFINED" />
       </kinematics>
 
       <!-- Define physics assumptions -->
@@ -29,11 +29,16 @@ This scenario demonstrates a simple task as the evaluation of DVMP Compton Form
          <!-- Select DVCS CFF model -->
          <module type="DVMPConvolCoeffFunctionModule" name="DVMPCFFGK06">
 
+            <!-- Parameters of MC integration -->
+            <param name="nWarmUps" value="10000" />
+            <param name="nCalls" value="100000" />
+            <param name="chi2Limit" value="0.8" />
+
             <!-- Indicate pQCD order of calculation -->
             <param name="qcd_order_type" value="LO" />
 
             <!-- Select GPD model -->
-            <module type="GPDModule" name="GPDGK16">
+            <module type="GPDModule" name="GPDGK19">
             </module>
 
          </module>

data/examples/cff/kinematics_dvmp_cff.csv

+0.01|-0.1|4.|4.|4.|pi0|undefined
+0.02|-0.1|4.|4.|4.|pi0|undefined

data/examples/cff/kinematics_dvmp_cff_with_units.csv

+#none|GeV2|GeV2|GeV2|GeV2|UNDEFINED|UNDEFINED
+0.01|-0.1|4.|4.|4.|pi0|UNDEFINED
+0.02|-0.1|4.|4.|4.|pi0|UNDEFINED

data/examples/observable/computeManyKinematicsForDVMPObservable.xml

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+
+<!--
+This scenario demonstrates a simple task as the evaluation of DVMP observable in a single kinematic point. The result of this scenario is printed out to the standard output. 
+-->
+
+<!-- Scenario starts here -->
+<!-- For your convenience and for bookkeeping provide creation date and unique description -->
+<scenario date="2017-07-18" description="DVMP observable evaluation for single kinematics example">
+
+   <!-- First task: evaluate DVMP observable for a single kinematics --> 
+   <!-- Indicate service and its methods to be used and indicate if the result should be stored in the database --> 
+   <task service="DVMPObservableService" method="computeManyKinematic" storeInDB="0">
+
+      <!-- Define DVMP observable kinematics -->
+      <kinematics type="DVMPObservableKinematic">
+
+         <!-- Path to file defining kinematics -->
+         <param name="file" value="/home/partons/git/partons-example/data/examples/observable/kinematics_dvmp_observable_with_units.csv" />
+      </kinematics>
+
+      <!-- Define physics assumptions -->
+      <computation_configuration>
+
+         <!-- Select DVMP observable -->
+         <module type="DVMPObservableModule" name="DVMPCrossSectionUUMinusPi0">
+
+            <!-- Select DVMP process model -->
+            <module type="DVMPProcessModule" name="DVMPProcessGK06">
+
+               <!-- Select scales module -->
+               <!-- (it is used to evaluate factorization and renormalization scales out of kinematics) -->
+               <module type="DVMPScalesModule" name="DVMPScalesQ2Multiplier">
+
+                  <!-- Configure this module -->
+                  <param name="lambda" value="1." />
+               </module>
+
+               <!-- Select xi-converter module -->
+               <!-- (it is used to evaluate GPD variable xi out of kinematics) -->
+               <module type="DVMPXiConverterModule" name="DVMPXiConverterXBToXi">
+               </module>
+
+               <!-- Select DVMP CFF model -->
+               <module type="DVMPConvolCoeffFunctionModule" name="DVMPCFFGK06">
+
+            	  <!-- Parameters of MC integration -->
+            	  <param name="nWarmUps" value="10000" />
+            	  <param name="nCalls" value="100000" />
+            	  <param name="chi2Limit" value="0.8" />
+
+                  <!-- Indicate pQCD order of calculation -->
+                  <param name="qcd_order_type" value="LO" />
+
+                  <!-- Select GPD model -->
+                  <module type="GPDModule" name="GPDGK19">
+                  </module>
+
+               </module>
+
+            </module>
+
+         </module>
+
+      </computation_configuration>
+
+   </task>
+
+   <!-- Second task: print results of the last computation into standard output --> 
+   <task service="DVMPObservableService" method="printResults">
+   </task>
+
+</scenario>

data/examples/observable/computeSingleKinematicsForDVMPObservable.xml

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+
+<!--
+This scenario demonstrates a simple task as the evaluation of DVMP observable in a single kinematic point. The result of this scenario is printed out to the standard output. 
+-->
+
+<!-- Scenario starts here -->
+<!-- For your convenience and for bookkeeping provide creation date and unique description -->
+<scenario date="2017-07-18" description="DVMP observable evaluation for single kinematics example">
+
+   <!-- First task: evaluate DVMP observable for a single kinematics --> 
+   <!-- Indicate service and its methods to be used and indicate if the result should be stored in the database --> 
+   <task service="DVMPObservableService" method="computeSingleKinematic" storeInDB="0">
+
+      <!-- Define DVMP observable kinematics -->
+      <kinematics type="DVMPObservableKinematic">
+         <param name="xB" value="0.2" />
+         <param name="t" value="-0.1" />
+         <param name="Q2" value="2." />
+         <param name="E" value="6." />
+         <param name="phi" value="0." />
+         <param name="meson" value="pi0" />
+      </kinematics>
+
+      <!-- Define physics assumptions -->
+      <computation_configuration>
+
+         <!-- Select DVMP observable -->
+         <module type="DVMPObservableModule" name="DVMPCrossSectionUUMinusPi0">
+
+            <!-- Select DVMP process model -->
+            <module type="DVMPProcessModule" name="DVMPProcessGK06">
+
+               <!-- Select scales module -->
+               <!-- (it is used to evaluate factorization and renormalization scales out of kinematics) -->
+               <module type="DVMPScalesModule" name="DVMPScalesQ2Multiplier">
+
+                  <!-- Configure this module -->
+                  <param name="lambda" value="1." />
+               </module>
+
+               <!-- Select xi-converter module -->
+               <!-- (it is used to evaluate GPD variable xi out of kinematics) -->
+               <module type="DVMPXiConverterModule" name="DVMPXiConverterXBToXi">
+               </module>
+
+               <!-- Select DVMP CFF model -->
+               <module type="DVMPConvolCoeffFunctionModule" name="DVMPCFFGK06">
+
+            	  <!-- Parameters of MC integration -->
+            	  <param name="nWarmUps" value="100" />
+            	  <param name="nCalls" value="100000" />
+            	  <param name="chi2Limit" value="0.8" />
+
+                  <!-- Indicate pQCD order of calculation -->
+                  <param name="qcd_order_type" value="LO" />
+
+                  <!-- Select GPD model -->
+                  <module type="GPDModule" name="GPDGK19">
+                  </module>
+
+               </module>
+
+            </module>
+
+         </module>
+
+      </computation_configuration>
+
+   </task>
+
+   <!-- Second task: print results of the last computation into standard output --> 
+   <task service="DVMPObservableService" method="printResults">
+   </task>
+
+</scenario>

data/examples/observable/kinematics_dvmp_observable.csv

+0.21|-0.1|2.|6.|0.|pi0
+0.22|-0.1|2.|6.|0.|pi0

data/examples/observable/kinematics_dvmp_observable_with_units.csv

+#none|GeV2|GeV2|GeV|deg|UNDEFINED
+0.21|-0.1|2.|6.|0.|pi0
+0.22|-0.1|2.|6.|0.|pi0

include/examples.h

@@ -39,6 +39,13 @@ void computeSingleKinematicsForDVCSComptonFormFactor();
  */
 void computeManyKinematicsForDVCSComptonFormFactor();
 
+/**
+ * This function demonstrates a simple task as the evaluation of DVMP Compton Form Factors (CFF) in a single kinematic point.
+ * The result of this function is printed out to the standard output.
+ * These are CFF values for all GPD types defined in the selected GPD model.
+ */
+void computeSingleKinematicsForDVMPComptonFormFactor();
+
 // ******************************************************
 // OBSERVABLE EXAMPLES **********************************
 // ******************************************************
@@ -56,6 +63,12 @@ void computeSingleKinematicsForDVCSObservable();
  */
 void computeManyKinematicsForDVCSObservable();
 
+/**
+ * This function demonstrates a simple task as the evaluation of DVMP observable in a single kinematic point.
+ * The result of this function is printed out to the standard output.
+ */
+void computeSingleKinematicsForDVMPObservable();
+
 // ******************************************************
 // OTHER ************************************************
 // ******************************************************
@@ -74,19 +87,19 @@ void computeManyKinematicsForDVCSObservable();
 void changeIntegrationRoutine();
 
 /**
-* This function demonstrates a simple task as the evaluation of GPD model in a single kinematic point making use of GPD evolution.
-* The result of this function is printed out to the standard output.
-* These are the values for all defined in the model GPDs, including singlet and non-singlet combinations for quarks.
-* Note that you can use this example to include the GPD evolution in the evaluation of CFFs and observables.
-*/
+ * This function demonstrates a simple task as the evaluation of GPD model in a single kinematic point making use of GPD evolution.
+ * The result of this function is printed out to the standard output.
+ * These are the values for all defined in the model GPDs, including singlet and non-singlet combinations for quarks.
+ * Note that you can use this example to include the GPD evolution in the evaluation of CFFs and observables.
+ */
 void makeUseOfGPDEvolution();
 
 /**
-* This function demonstrates a simple task as the evaluation of GPD model in a single kinematic point for specific GPD types only.
-* The result of this function is printed out to the standard output.
-* These are the values for all defined in the model GPDs, including singlet and non-singlet combinations for quarks.
-* Note that you can use this example to select specific GPD types in the evaluation of CFFs and observables.
-*/
+ * This function demonstrates a simple task as the evaluation of GPD model in a single kinematic point for specific GPD types only.
+ * The result of this function is printed out to the standard output.
+ * These are the values for all defined in the model GPDs, including singlet and non-singlet combinations for quarks.
+ * Note that you can use this example to select specific GPD types in the evaluation of CFFs and observables.
+ */
 void selectSpecificGPDTypes();
 
 /**

src/examples.cpp

@@ -7,29 +7,40 @@
 #include <NumA/integration/one_dimension/QuadratureIntegrator1D.h>
 #include <partons/beans/convol_coeff_function/ConvolCoeffFunctionResult.h>
 #include <partons/beans/convol_coeff_function/DVCS/DVCSConvolCoeffFunctionKinematic.h>
+#include <partons/beans/convol_coeff_function/DVMP/DVMPConvolCoeffFunctionKinematic.h>
 #include <partons/beans/gpd/GPDKinematic.h>
 #include <partons/beans/gpd/GPDType.h>
 #include <partons/beans/KinematicUtils.h>
 #include <partons/beans/List.h>
+#include <partons/beans/MesonPolarization.h>
+#include <partons/beans/MesonType.h>
 #include <partons/beans/observable/DVCS/DVCSObservableKinematic.h>
+#include <partons/beans/observable/DVMP/DVMPObservableKinematic.h>
 #include <partons/beans/observable/ObservableResult.h>
 #include <partons/beans/PerturbativeQCDOrderType.h>
 #include <partons/modules/active_flavors_thresholds/ActiveFlavorsThresholdsConstant.h>
 #include <partons/modules/convol_coeff_function/ConvolCoeffFunctionModule.h>
 #include <partons/modules/convol_coeff_function/DVCS/DVCSCFFStandard.h>
+#include <partons/modules/convol_coeff_function/DVMP/DVMPCFFGK06.h>
 #include <partons/modules/evolution/gpd/GPDEvolutionVinnikov.h>
-#include <partons/modules/gpd/GPDGK16.h>
 #include <partons/modules/gpd/GPDGK16Numerical.h>
+#include <partons/modules/gpd/GPDGK19.h>
 #include <partons/modules/observable/DVCS/asymmetry/DVCSAllMinus.h>
+#include <partons/modules/observable/DVMP/cross_section/DVMPCrossSectionUUMinusPi0.h>
 #include <partons/modules/process/DVCS/DVCSProcessGV08.h>
+#include <partons/modules/process/DVMP/DVMPProcessGK06.h>
 #include <partons/modules/running_alpha_strong/RunningAlphaStrongVinnikov.h>
 #include <partons/modules/scales/DVCS/DVCSScalesQ2Multiplier.h>
+#include <partons/modules/scales/DVMP/DVMPScalesQ2Multiplier.h>
 #include <partons/modules/xi_converter/DVCS/DVCSXiConverterXBToXi.h>
+#include <partons/modules/xi_converter/DVMP/DVMPXiConverterXBToXi.h>
 #include <partons/ModuleObjectFactory.h>
 #include <partons/Partons.h>
 #include <partons/services/ConvolCoeffFunctionService.h>
 #include <partons/services/DVCSConvolCoeffFunctionService.h>
 #include <partons/services/DVCSObservableService.h>
+#include <partons/services/DVMPConvolCoeffFunctionService.h>
+#include <partons/services/DVMPObservableService.h>
 #include <partons/services/GPDService.h>
 #include <partons/services/ObservableService.h>
 #include <partons/ServiceObjectRegistry.h>
@@ -199,6 +210,75 @@ void computeManyKinematicsForDVCSComptonFormFactor() {
     pGPDModule = 0;
 }
 
+void computeSingleKinematicsForDVMPComptonFormFactor() {
+
+    // Retrieve service
+    PARTONS::DVMPConvolCoeffFunctionService* pDVMPConvolCoeffFunctionService =
+            PARTONS::Partons::getInstance()->getServiceObjectRegistry()->getDVMPConvolCoeffFunctionService();
+
+    // Create GPD module with the BaseModuleFactory
+    PARTONS::GPDModule* pGPDModule =
+            PARTONS::Partons::getInstance()->getModuleObjectFactory()->newGPDModule(
+                    PARTONS::GPDGK19::classId);
+
+    // Create CFF module with the BaseModuleFactory
+    PARTONS::DVMPConvolCoeffFunctionModule* pDVMPCFFModule =
+            PARTONS::Partons::getInstance()->getModuleObjectFactory()->newDVMPConvolCoeffFunctionModule(
+                    PARTONS::DVMPCFFGK06::classId);
+
+    // Create parameters to configure later DVMPCFFModel with PerturbativeQCD = LO
+    ElemUtils::Parameters parameters;
+
+    parameters.add(
+            ElemUtils::Parameter(
+                    PARTONS::PerturbativeQCDOrderType::PARAMETER_NAME_PERTURBATIVE_QCD_ORDER_TYPE,
+                    PARTONS::PerturbativeQCDOrderType::LO));
+
+    parameters.add(
+            ElemUtils::Parameter(
+                    PARTONS::DVMPCFFGK06::PARAMETER_NAME_DVMPCFFGK06_MC_NWARMUP,
+                    10000));
+    parameters.add(
+            ElemUtils::Parameter(
+                    PARTONS::DVMPCFFGK06::PARAMETER_NAME_DVMPCFFGK06_MC_NCALLS,
+                    100000));
+    parameters.add(
+            ElemUtils::Parameter(
+                    PARTONS::DVMPCFFGK06::PARAMETER_NAME_DVMPCFFGK06_MC_CHI2LIMIT,
+                    0.8));
+
+    // Configure DVMPCFFModule with previous parameters.
+    pDVMPCFFModule->configure(parameters);
+
+    // Link modules (set physics assumptions of your computation)
+    pDVMPCFFModule->setGPDModule(pGPDModule);
+
+    // Create kinematic
+    PARTONS::DVMPConvolCoeffFunctionKinematic cffKinematic =
+            PARTONS::DVMPConvolCoeffFunctionKinematic(0.01, -0.1, 4., 4., 4.,
+                    PARTONS::MesonType::PI0,
+                    PARTONS::MesonPolarization::UNDEFINED);
+
+    // Run computation
+    PARTONS::DVMPConvolCoeffFunctionResult cffResult =
+            pDVMPConvolCoeffFunctionService->computeSingleKinematic(
+                    cffKinematic, pDVMPCFFModule);
+
+    // Print results for DVMPCFFModule
+    PARTONS::Partons::getInstance()->getLoggerManager()->info("main", __func__,
+            cffResult.toString());
+
+    // Remove pointer references
+    // Module pointers are managed by PARTONS
+    PARTONS::Partons::getInstance()->getModuleObjectFactory()->updateModulePointerReference(
+            pDVMPCFFModule, 0);
+    pDVMPCFFModule = 0;
+
+    PARTONS::Partons::getInstance()->getModuleObjectFactory()->updateModulePointerReference(
+            pGPDModule, 0);
+    pGPDModule = 0;
+}
+
 void computeSingleKinematicsForDVCSObservable() {
 
     // Retrieve Observable service
@@ -390,6 +470,120 @@ void computeManyKinematicsForDVCSObservable() {
     pObservable = 0;
 }
 
+void computeSingleKinematicsForDVMPObservable() {
+
+    // Retrieve Observable service
+    PARTONS::DVMPObservableService* pObservableService =
+            PARTONS::Partons::getInstance()->getServiceObjectRegistry()->getDVMPObservableService();
+
+    // Create GPDModule
+    PARTONS::GPDModule* pGPDModule =
+            PARTONS::Partons::getInstance()->getModuleObjectFactory()->newGPDModule(
+                    PARTONS::GPDGK19::classId);
+
+    // Create CFF module with the BaseModuleFactory
+    PARTONS::DVMPConvolCoeffFunctionModule* pDVMPCFFModule =
+            PARTONS::Partons::getInstance()->getModuleObjectFactory()->newDVMPConvolCoeffFunctionModule(
+                    PARTONS::DVMPCFFGK06::classId);
+
+    // Create parameters to configure later DVMPCFFModel with PerturbativeQCD = LO
+    ElemUtils::Parameters parameters;
+
+    parameters.add(
+            ElemUtils::Parameter(
+                    PARTONS::PerturbativeQCDOrderType::PARAMETER_NAME_PERTURBATIVE_QCD_ORDER_TYPE,
+                    PARTONS::PerturbativeQCDOrderType::LO));
+
+    parameters.add(
+            ElemUtils::Parameter(
+                    PARTONS::DVMPCFFGK06::PARAMETER_NAME_DVMPCFFGK06_MC_NWARMUP,
+                    10000));
+    parameters.add(
+            ElemUtils::Parameter(
+                    PARTONS::DVMPCFFGK06::PARAMETER_NAME_DVMPCFFGK06_MC_NCALLS,
+                    100000));
+    parameters.add(
+            ElemUtils::Parameter(
+                    PARTONS::DVMPCFFGK06::PARAMETER_NAME_DVMPCFFGK06_MC_CHI2LIMIT,
+                    0.8));
+
+    // Configure DVMPCFFModule with previous parameters.
+    pDVMPCFFModule->configure(parameters);
+
+    // Create XiConverterModule
+    PARTONS::DVMPXiConverterModule* pXiConverterModule =
+            PARTONS::Partons::getInstance()->getModuleObjectFactory()->newDVMPXiConverterModule(
+                    PARTONS::DVMPXiConverterXBToXi::classId);
+
+    // Create ScalesModule
+    PARTONS::DVMPScalesModule* pScalesModule =
+            PARTONS::Partons::getInstance()->getModuleObjectFactory()->newDVMPScalesModule(
+                    PARTONS::DVMPScalesQ2Multiplier::classId);
+
+    // Set its lambda parameter, so MuF2 = MuR2 = lambda * Q2
+    pScalesModule->configure(
+            ElemUtils::Parameter(
+                    PARTONS::DVMPScalesQ2Multiplier::PARAMETER_NAME_LAMBDA,
+                    1.));
+
+    // Create ProcessModule
+    PARTONS::DVMPProcessModule* pProcessModule =
+            PARTONS::Partons::getInstance()->getModuleObjectFactory()->newDVMPProcessModule(
+                    PARTONS::DVMPProcessGK06::classId);
+
+    // Create Observable
+    PARTONS::DVMPObservable* pObservable =
+            PARTONS::Partons::getInstance()->getModuleObjectFactory()->newDVMPObservable(
+                    PARTONS::DVMPCrossSectionUUMinusPi0::classId);
+
+    // Link modules (set physics assumptions of your computation)
+    pObservable->setProcessModule(pProcessModule);
+    pProcessModule->setScaleModule(pScalesModule);
+    pProcessModule->setXiConverterModule(pXiConverterModule);
+    pProcessModule->setConvolCoeffFunctionModule(pDVMPCFFModule);
+    pDVMPCFFModule->setGPDModule(pGPDModule);
+
+    // Load list of kinematics from file
+    PARTONS::DVMPObservableKinematic observableKinematic =
+            PARTONS::DVMPObservableKinematic(0.2, -0.1, 2., 6., 0.,
+                    PARTONS::MesonType::PI0);
+
+    // Create kinematic
+    PARTONS::DVMPObservableResult observableResult =
+            pObservableService->computeSingleKinematic(observableKinematic,
+                    pObservable);
+
+    // Print results
+    PARTONS::Partons::getInstance()->getLoggerManager()->info("main", __func__,
+            observableResult.toString());
+
+    // Remove pointer references
+    // Module pointers are managed by PARTONS
+    PARTONS::Partons::getInstance()->getModuleObjectFactory()->updateModulePointerReference(
+            pGPDModule, 0);
+    pGPDModule = 0;
+
+    PARTONS::Partons::getInstance()->getModuleObjectFactory()->updateModulePointerReference(
+            pDVMPCFFModule, 0);
+    pDVMPCFFModule = 0;
+
+    PARTONS::Partons::getInstance()->getModuleObjectFactory()->updateModulePointerReference(
+            pXiConverterModule, 0);
+    pXiConverterModule = 0;
+
+    PARTONS::Partons::getInstance()->getModuleObjectFactory()->updateModulePointerReference(
+            pScalesModule, 0);
+    pScalesModule = 0;
+
+    PARTONS::Partons::getInstance()->getModuleObjectFactory()->updateModulePointerReference(
+            pProcessModule, 0);
+    pProcessModule = 0;
+
+    PARTONS::Partons::getInstance()->getModuleObjectFactory()->updateModulePointerReference(
+            pObservable, 0);
+    pObservable = 0;
+}
+
 void changeIntegrationRoutine() {
 
     // Retrieve GPD service