#include <string>
#include <TFile.h>
#include <TTree.h>
#include "Framework/Algorithm/Algorithm.h"
#include "Framework/Algorithm/AlgFactory.h"
#include "Physics/DeepInelastic/XSection/DISStructureFunc.h"
#include "Physics/DeepInelastic/XSection/DISStructureFuncModelI.h"
#include "Framework/Messenger/Messenger.h"
#include "Framework/ParticleData/PDGCodes.h"
#include "Framework/Utils/CmdLnArgParser.h"

Include dependency graph for gtestDISSF.cxx:

Functions
void	GetCommandLineArgs (int argc, char **argv)

void	PrintSyntax (void)

void	BuildStdNtuple (void)

void	VerticalSlice (void)

int	main (int argc, char **argv)

Variables
int	gMode = 1

double	gX = 0

double	gQ2 = 0

string	gDISSFAlg = ""

string	gDISSFConfig = ""

Function Documentation

void BuildStdNtuple ( void )

Definition at line 71 of file gtestDISSF.cxx.

References genie::DISStructureFunc::Calculate(), genie::Interaction::DISCC(), genie::DISStructureFunc::F1(), genie::DISStructureFunc::F2(), genie::DISStructureFunc::F3(), genie::DISStructureFunc::F4(), genie::DISStructureFunc::F5(), gDISSFAlg, gDISSFConfig, genie::AlgFactory::GetAlgorithm(), genie::AlgFactory::Instance(), genie::Interaction::KinePtr(), genie::kPdgAntiNuE, genie::kPdgAntiNuMu, genie::kPdgAntiNuTau, genie::kPdgNeutron, genie::kPdgNuE, genie::kPdgNuMu, genie::kPdgNuTau, genie::kPdgProton, genie::kPdgTgtFe56, genie::kPdgTgtFreeN, genie::kPdgTgtFreeP, genie::utils::kinematics::Q2(), genie::DISStructureFunc::SetModel(), genie::Kinematics::SetQ2(), and genie::Kinematics::Setx().

Referenced by main().

 {
   // -- define initial states & x,Q2 values to compute the DIS SFs 
   const int kNNu   = 6;
   const int kNNuc  = 2;
   const int kNTgt  = 3;
   const int kNX    = 12;
   const int kNQ2   = 60;
 
   int neutrino    [kNNu]   = { kPdgNuE, kPdgAntiNuE, kPdgNuMu, kPdgAntiNuMu, kPdgNuTau, kPdgAntiNuTau };
   int hit_nucleon [kNNuc]  = { kPdgProton, kPdgNeutron };
   int target      [kNTgt]  = { kPdgTgtFreeP, kPdgTgtFreeN, kPdgTgtFe56 };
 
   double xbj[kNX] = {
         0.0150, 0.0450, 0.0800, 0.1250, 0.1750, 0.2250,
         0.2750, 0.3500, 0.4500, 0.5500, 0.6500, 0.7500
   };
   double Q2[kNQ2] = {
         0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1.0,  2.0, 
         3.0,  4.0,  5.0,  6.0,  7.0,  8.0,  9.0, 10.0, 11.0, 12.0, 
        13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0,
        23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 42.0,
        33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 52.0,
        43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, 51.0, 62.0
   };
 
   // -- request the specified DIS SF model
   AlgFactory * algf = AlgFactory::Instance();
   const DISStructureFuncModelI * dissf_model =
       dynamic_cast<const DISStructureFuncModelI *> (
                               algf->GetAlgorithm(gDISSFAlg, gDISSFConfig));
   assert(dissf_model);
 
   // -- create a structure functions objects and attach the specified model
   DISStructureFunc dissf;
   dissf.SetModel(dissf_model);
 
   // -- define the outout TTree
   TTree * dissf_nt = new TTree("dissf_nt","DIS SF");
   int    brNu;    // event number
   int    brNuc;   // hit nucleon PDG code
   int    brTgt;   // neutrino PDG code
   double brXbj;   //
   double brQ2;    //
   double brF1;    //
   double brF2;    //
   double brF3;    //
   double brF4;    //
   double brF5;    //
   dissf_nt->Branch("nu",  &brNu,  "nu/I");
   dissf_nt->Branch("nuc", &brNuc, "nuc/I");
   dissf_nt->Branch("tgt", &brTgt, "tgt/I");
   dissf_nt->Branch("x",   &brXbj, "x/D");
   dissf_nt->Branch("Q2",  &brQ2,  "Q2/D");
   dissf_nt->Branch("F1",  &brF1,  "F1/D");
   dissf_nt->Branch("F2",  &brF2,  "F2/D");
   dissf_nt->Branch("F3",  &brF3,  "F3/D");
   dissf_nt->Branch("F4",  &brF4,  "F4/D");
   dissf_nt->Branch("F5",  &brF5,  "F5/D");
 
   // -- loop over the initial states
   for(int inu=0; inu<kNNu; inu++) {
      for(int inuc=0; inuc<kNNuc; inuc++) {
         for(int itgt=0; itgt<kNTgt; itgt++) {
 
            // -- get a DIS interaction object & access its kinematics
            Interaction * interaction = Interaction::DISCC(
                                  target[itgt],hit_nucleon[inuc],neutrino[inu]);
            Kinematics * kine = interaction->KinePtr();
 
            // -- loop over x,Q2
            for(int ix=0; ix<kNX; ix++) {
              for(int iq=0; iq<kNQ2; iq++) {
 
                 // update the interaction kinematics
                 kine->Setx(xbj[ix]);
                 kine->SetQ2(Q2[iq]);
 
                 // calculate the structure functions for the input interaction
                 dissf.Calculate(interaction);
 
                 // update all tree branches & save
                 brNu  = neutrino[inu];
                 brNuc = hit_nucleon[inuc];
                 brTgt = target[itgt];
                 brXbj = xbj[ix];
                 brQ2  = Q2[iq];
                 brF1  = dissf.F1();
                 brF2  = dissf.F2();
                 brF3  = dissf.F3();
                 brF4  = dissf.F4();
                 brF5  = dissf.F5();
                 dissf_nt->Fill();
              }//Q2
            }//x
 
            delete interaction;
 
         }//tgt
      }//nuc
   }//nu
 
   TFile f("./dissf.root","recreate");
   dissf_nt->Write();
   f.Close();
 }

void GetCommandLineArgs	(	int	argc,
		char **	argv
	)

int main	(	int	argc,
		char **	argv
	)

Definition at line 60 of file gtestDISSF.cxx.

References BuildStdNtuple(), GetCommandLineArgs(), gMode, and VerticalSlice().

 {
   // -- parse the command line arguments (model choice,...)
   GetCommandLineArgs(argc,argv);
 
   if(gMode==1) BuildStdNtuple();
   if(gMode==2) VerticalSlice ();
 
   return 0;
 }

void PrintSyntax ( void )

void VerticalSlice ( void )

Definition at line 178 of file gtestDISSF.cxx.

References genie::DISStructureFunc::Calculate(), genie::Interaction::DISCC(), gDISSFAlg, gDISSFConfig, genie::AlgFactory::GetAlgorithm(), gQ2, gX, genie::AlgFactory::Instance(), genie::Messenger::Instance(), genie::Interaction::KinePtr(), genie::kPdgAntiNuMu, genie::kPdgNeutron, genie::kPdgNuMu, genie::kPdgProton, genie::kPdgTgtFe56, LOG, pDEBUG, pNOTICE, genie::DISStructureFunc::SetModel(), genie::Messenger::SetPriorityLevel(), genie::Kinematics::SetQ2(), and genie::Kinematics::Setx().

Referenced by main().

 {
   // manual override of Registry mesg level for more verbose output
   Messenger * msg = Messenger::Instance();
   msg->SetPriorityLevel("DISSF",     pDEBUG);
   msg->SetPriorityLevel("BodekYang", pDEBUG);
   msg->SetPriorityLevel("LHAPDF5",   pDEBUG);
 
   // -- request the specified DIS SF model
   AlgFactory * algf = AlgFactory::Instance();
   const DISStructureFuncModelI * dissf_model =
       dynamic_cast<const DISStructureFuncModelI *> (
                               algf->GetAlgorithm(gDISSFAlg, gDISSFConfig));
   assert(dissf_model);
 
   // -- create a structure functions objects and attach the specified model
   DISStructureFunc dissf;
   dissf.SetModel(dissf_model);
 
   const int kNNu   = 2;
   const int kNNuc  = 2;
   const int kNTgt  = 1;
 
   int neutrino    [kNNu]   = { kPdgNuMu,   kPdgAntiNuMu };
   int hit_nucleon [kNNuc]  = { kPdgProton, kPdgNeutron  };
   int target      [kNTgt]  = { kPdgTgtFe56 };
 
   for(int inu=0; inu<kNNu; inu++) {
      for(int inuc=0; inuc<kNNuc; inuc++) {
         for(int itgt=0; itgt<kNTgt; itgt++) {
 
            // -- get a DIS interaction object & access its kinematics
            Interaction * interaction = Interaction::DISCC(
                               target[itgt],hit_nucleon[inuc],neutrino[inu]);
            Kinematics * kine = interaction->KinePtr();
            kine->Setx(gX);
            kine->SetQ2(gQ2);
 
            LOG("test", pNOTICE) << "*** Vertical SF slice for: ";
            LOG("test", pNOTICE) << *interaction;
 
            // calculate the structure functions for the input interaction
            dissf.Calculate(interaction);
 
            LOG("test", pNOTICE) << dissf;
 
            delete interaction;
         }
      }
   }
 
   // print algorithms & heir configurations
   LOG("test", pNOTICE) << *algf;
 }