Public Member Functions | Private Member Functions | Private Attributes | List of all members
genie::P33PaschosLalakulichPXSec Class Reference

Double differential resonance cross section for P33 according to the Paschos, Lalakulich model. More...

#include <P33PaschosLalakulichPXSec.h>

Inheritance diagram for genie::P33PaschosLalakulichPXSec:
genie::XSecAlgorithmI genie::Algorithm

Public Member Functions

 P33PaschosLalakulichPXSec ()
 
 P33PaschosLalakulichPXSec (string name)
 
virtual ~P33PaschosLalakulichPXSec ()
 
double XSec (const Interaction *i, KinePhaseSpace_t k) const
 Compute the cross section for the input interaction. More...
 
double Integral (const Interaction *i) const
 
bool ValidProcess (const Interaction *i) const
 Can this cross section algorithm handle the input process? More...
 
void Configure (const Registry &config)
 
void Configure (string config)
 
- Public Member Functions inherited from genie::XSecAlgorithmI
virtual ~XSecAlgorithmI ()
 
virtual bool ValidKinematics (const Interaction *i) const
 Is the input kinematical point a physically allowed one? More...
 
- Public Member Functions inherited from genie::Algorithm
virtual ~Algorithm ()
 
virtual void FindConfig (void)
 
virtual const Registry & GetConfig (void) const
 
Registry * GetOwnedConfig (void)
 
virtual const AlgId & Id (void) const
 Get algorithm ID. More...
 
virtual AlgStatus_t GetStatus (void) const
 Get algorithm status. More...
 
virtual bool AllowReconfig (void) const
 
virtual AlgCmp_t Compare (const Algorithm *alg) const
 Compare with input algorithm. More...
 
virtual void SetId (const AlgId &id)
 Set algorithm ID. More...
 
virtual void SetId (string name, string config)
 
const Algorithm * SubAlg (const RgKey &registry_key) const
 
void AdoptConfig (void)
 
void AdoptSubstructure (void)
 
virtual void Print (ostream &stream) const
 Print algorithm info. More...
 

Private Member Functions

void LoadConfig (void)
 
double Pauli (double Q2, double W, double MN) const
 Pauli suppression for D2. More...
 
double Nu (double Q2, double W, double MN) const
 kinematic variables More...
 
double NuStar (double Q2, double W, double MN) const
 ... More...
 
double PPiStar (double W, double MN) const
 ... More...
 

Private Attributes

const XSecIntegratorI * fXSecIntegrator
 
bool fTurnOnPauliCorrection
 
double fMa
 
double fMv
 
double fCos28c
 

Additional Inherited Members

- Static Public Member Functions inherited from genie::Algorithm
static string BuildParamVectKey (const std::string &comm_name, unsigned int i)
 
static string BuildParamVectSizeKey (const std::string &comm_name)
 
- Protected Member Functions inherited from genie::XSecAlgorithmI
 XSecAlgorithmI ()
 
 XSecAlgorithmI (string name)
 
 XSecAlgorithmI (string name, string config)
 
- Protected Member Functions inherited from genie::Algorithm
 Algorithm ()
 
 Algorithm (string name)
 
 Algorithm (string name, string config)
 
void Initialize (void)
 
void DeleteConfig (void)
 
void DeleteSubstructure (void)
 
Registry * ExtractLocalConfig (const Registry &in) const
 
Registry * ExtractLowerConfig (const Registry &in, const string &alg_key) const
 Split an incoming configuration Registry into a block valid for the sub-algo identified by alg_key. More...
 
template<class T >
bool GetParam (const RgKey &name, T &p, bool is_top_call=true) const
 
template<class T >
bool GetParamDef (const RgKey &name, T &p, const T &def) const
 
template<class T >
int GetParamVect (const std::string &comm_name, std::vector< T > &v, bool is_top_call=true) const
 Handle to load vectors of parameters. More...
 
int GetParamVectKeys (const std::string &comm_name, std::vector< RgKey > &k, bool is_top_call=true) const
 
int AddTopRegistry (Registry *rp, bool owns=true)
 add registry with top priority, also update ownership More...
 
int AddLowRegistry (Registry *rp, bool owns=true)
 add registry with lowest priority, also update ownership More...
 
int MergeTopRegistry (const Registry &r)
 
int AddTopRegisties (const vector< Registry * > &rs, bool owns=false)
 Add registries with top priority, also udated Ownerships. More...
 
- Protected Attributes inherited from genie::Algorithm
bool fAllowReconfig
 
bool fOwnsSubstruc
 true if it owns its substructure (sub-algs,...) More...
 
AlgId fID
 algorithm name and configuration set More...
 
vector< Registry * > fConfVect
 
vector< bool > fOwnerships
 ownership for every registry in fConfVect More...
 
AlgStatus_t fStatus
 algorithm execution status More...
 
AlgMap * fOwnedSubAlgMp
 local pool for owned sub-algs (taken out of the factory pool) More...
 

Detailed Description

Double differential resonance cross section for P33 according to the Paschos, Lalakulich model.

Is a concrete implementation of the XSecAlgorithmI interface.

O.Lalakulich and E.A.Paschos, Resonance Production by Neutrinos: I. J=3/2 Resonances, hep-ph/0501109

Author
Costas Andreopoulos <constantinos.andreopoulos cern.ch> University of Liverpool & STFC Rutherford Appleton Laboratory

based on code written by the model authors (Olga Lalakulich).

February 22, 2005

Copyright (c) 2003-2020, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 35 of file P33PaschosLalakulichPXSec.h.

Constructor & Destructor Documentation

P33PaschosLalakulichPXSec::P33PaschosLalakulichPXSec ( )

Definition at line 33 of file P33PaschosLalakulichPXSec.cxx.

33  :
34 XSecAlgorithmI("genie::P33PaschosLalakulichPXSec")
35 {
36 
37 }
P33PaschosLalakulichPXSec::P33PaschosLalakulichPXSec ( string  name)

Definition at line 39 of file P33PaschosLalakulichPXSec.cxx.

39  :
40 XSecAlgorithmI("genie::P33PaschosLalakulichPXSec", config)
41 {
42 
43 }
config
static Config * config
Definition: config.cpp:1054
P33PaschosLalakulichPXSec::~P33PaschosLalakulichPXSec ( )
virtual

Definition at line 45 of file P33PaschosLalakulichPXSec.cxx.

46 {
47 
48 }

Member Function Documentation

void P33PaschosLalakulichPXSec::Configure ( const Registry &  config)
virtual

Configure the algorithm with an external registry The registry is merged with the top level registry if it is owned, Otherwise a copy of it is added with the highest priority

Reimplemented from genie::Algorithm.

Definition at line 275 of file P33PaschosLalakulichPXSec.cxx.

276 {
277  Algorithm::Configure(config);
278  this->LoadConfig();
279 }
genie::Algorithm::Configure
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
void P33PaschosLalakulichPXSec::Configure ( string  config)
virtual

Configure the algorithm from the AlgoConfigPool based on param_set string given in input An algorithm contains a vector of registries coming from different xml configuration files, which are loaded according a very precise prioriy This methods will load a number registries in order of priority: 1) "Tunable" parameter set from CommonParametes. This is loaded with the highest prioriry and it is designed to be used for tuning procedure Usage not expected from the user. 2) For every string defined in "CommonParame" the corresponding parameter set will be loaded from CommonParameter.xml 3) parameter set specified by the config string and defined in the xml file of the algorithm 4) if config is not "Default" also the Default parameter set from the same xml file will be loaded Effectively this avoids the repetion of a parameter when it is not changed in the requested configuration

Reimplemented from genie::Algorithm.

Definition at line 281 of file P33PaschosLalakulichPXSec.cxx.

282 {
283  Algorithm::Configure(config);
284  this->LoadConfig();
285 }
config
static Config * config
Definition: config.cpp:1054
genie::Algorithm::Configure
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
double P33PaschosLalakulichPXSec::Integral ( const Interaction *  i) const
virtual

Integrate the model over the kinematic phase space available to the input interaction (kinematical cuts can be included)

Implements genie::XSecAlgorithmI.

Definition at line 261 of file P33PaschosLalakulichPXSec.cxx.

263 {
264  double xsec = fXSecIntegrator->Integrate(this,interaction);
265  return xsec;
266 }
genie::XSecIntegratorI::Integrate
virtual double Integrate(const XSecAlgorithmI *model, const Interaction *interaction) const =0
void P33PaschosLalakulichPXSec::LoadConfig ( void  )
private

Definition at line 287 of file P33PaschosLalakulichPXSec.cxx.

288 {
289  GetParam( "RES-Ma", fMa ) ;
290  GetParam( "RES-Mv", fMv ) ;
291 
292  double thc ;
293  GetParam( "CabibboAngle", thc ) ;
294  fCos28c = TMath::Power( TMath::Cos(thc), 2 );
295 
296  GetParamDef( "TurnOnPauliSuppr", fTurnOnPauliCorrection, false ) ;
297 
298  //-- load the differential cross section integrator
299  fXSecIntegrator =
300  dynamic_cast<const XSecIntegratorI *> (this->SubAlg("XSec-Integrator"));
301  assert(fXSecIntegrator);
302 }
genie::XSecIntegratorI
Cross Section Integrator Interface.
Definition: XSecIntegratorI.h:29
genie::Algorithm::GetParamDef
bool GetParamDef(const RgKey &name, T &p, const T &def) const
genie::Algorithm::GetParam
bool GetParam(const RgKey &name, T &p, bool is_top_call=true) const
genie::Algorithm::SubAlg
const Algorithm * SubAlg(const RgKey &registry_key) const
Definition: Algorithm.cxx:345
double P33PaschosLalakulichPXSec::Nu ( double  Q2,
double  W,
double  MN 
) const
private

kinematic variables

Definition at line 349 of file P33PaschosLalakulichPXSec.cxx.

350 {
351  return (TMath::Power(W,2) - TMath::Power(MN,2) + Q2)/2/MN;
352 }
genie::utils::kinematics::Q2
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:1064
dump_to_simple_cpp.W
W
Definition: dump_to_simple_cpp.py:43
double P33PaschosLalakulichPXSec::NuStar ( double  Q2,
double  W,
double  MN 
) const
private

...

Definition at line 363 of file P33PaschosLalakulichPXSec.cxx.

364 {
365  return (TMath::Power(W,2) - TMath::Power(MN,2) - Q2)/2/W;
366 }
genie::utils::kinematics::Q2
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:1064
dump_to_simple_cpp.W
W
Definition: dump_to_simple_cpp.py:43
double P33PaschosLalakulichPXSec::Pauli ( double  Q2,
double  W,
double  MN 
) const
private

Pauli suppression for D2.

Definition at line 304 of file P33PaschosLalakulichPXSec.cxx.

305 {
306 // Pauli suppression for deuterium with Fermi momentum 0.160 GeV
307 
308  // ---remove--- this value from here & ask GENIE for D2 Fermi momentum
309  double qF=0.160; /* 0.160 deuterium */
310 
311  double Paulii = 0;
312 
313  double p_pi_star = this->PPiStar(W,MN);
314  double nu_star = this->NuStar(Q2,W,MN);
315 
316  double p_pi_star_2 = TMath::Power(p_pi_star, 2);
317  double p_pi_star_4 = TMath::Power(p_pi_star_2, 2);
318  double nu_star_2 = TMath::Power(nu_star, 2);
319 
320  double q3 = TMath::Sqrt(Q2+nu_star_2);
321  double q6 = TMath::Power(q3,2);
322  double q12 = TMath::Power(q6,2);
323 
324  double qF2 = TMath::Power(qF,2);
325  double qF3 = TMath::Power(qF,3);
326 
327  if ( q3+p_pi_star < 2*qF )
328  {
329  Paulii = ( (3*q6 + p_pi_star_2)/2/qF
330  -(5*q12+p_pi_star_4 + 10*q6*p_pi_star_2)/40/qF3
331  )/2/q3;
332  }
333  if ( (q3+p_pi_star > 2*qF) && (q3-p_pi_star < 2*qF) )
334  {
335  double tmp1 = TMath::Power( q3+p_pi_star, 2 );
336  double tmp2 = TMath::Power( q3-p_pi_star, 3 );
337  double tmp3 = TMath::Power( q3-p_pi_star, 5 );
338 
339  Paulii = (tmp1-4.0*qF2/5.0 - tmp2/2/qF + tmp3/40/qF3)/4/p_pi_star/q3;
340  }
341  if ( q3-p_pi_star > 2*qF )
342  {
343  Paulii = 1;
344  }
345 
346  return Paulii;
347 }
genie::P33PaschosLalakulichPXSec::PPiStar
double PPiStar(double W, double MN) const
...
Definition: P33PaschosLalakulichPXSec.cxx:354
genie::utils::kinematics::Q2
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:1064
genie::P33PaschosLalakulichPXSec::NuStar
double NuStar(double Q2, double W, double MN) const
...
Definition: P33PaschosLalakulichPXSec.cxx:363
dump_to_simple_cpp.W
W
Definition: dump_to_simple_cpp.py:43
double P33PaschosLalakulichPXSec::PPiStar ( double  W,
double  MN 
) const
private

...

Definition at line 354 of file P33PaschosLalakulichPXSec.cxx.

355 {
356  double W2 = TMath::Power(W,2);
357  double a = TMath::Power(MN+kPionMass,2);
358  double b = TMath::Power(MN-kPionMass,2);
359 
360  return TMath::Sqrt( (W2-a)*(W2-b) )/2/W;
361 }
a
const double a
Definition: gUpMuFluxGen.cxx:164
dump_to_simple_cpp.W
W
Definition: dump_to_simple_cpp.py:43
genie::constants::kPionMass
static const double kPionMass
Definition: Constants.h:73
b
static bool * b
Definition: config.cpp:1043
bool P33PaschosLalakulichPXSec::ValidProcess ( const Interaction *  i) const
virtual

Can this cross section algorithm handle the input process?

Implements genie::XSecAlgorithmI.

Definition at line 268 of file P33PaschosLalakulichPXSec.cxx.

270 {
271  if(interaction->TestBit(kISkipProcessChk)) return true;
272  return true;
273 }
genie::kISkipProcessChk
const UInt_t kISkipProcessChk
if set, skip process validity checks
Definition: Interaction.h:47
double P33PaschosLalakulichPXSec::XSec ( const Interaction *  i,
KinePhaseSpace_t  k 
) const
virtual

Compute the cross section for the input interaction.

Implements genie::XSecAlgorithmI.

Definition at line 50 of file P33PaschosLalakulichPXSec.cxx.

52 {
53  if(! this -> ValidProcess (interaction) ) return 0.;
54  if(! this -> ValidKinematics (interaction) ) return 0.;
55 
56  //-- Get initial state and kinematic variables
57  const InitialState & init_state = interaction -> InitState();
58  const Kinematics & kinematics = interaction -> Kine();
59  const Target & target = init_state.Tgt();
60 
61  double E = init_state.ProbeE(kRfHitNucRest);
62  double E2 = TMath::Power(E,2);
63  double Q2 = kinematics.Q2();
64  double W = kinematics.W();
65  double MN = target.HitNucMass();
66  double MN2 = TMath::Power(MN,2);
67  double Mmu2 = kMuonMass2;
68  double Mpi2 = kPionMass2;
69 
70  LOG("PaschLal", pDEBUG) << "Input kinematics: W = " << W << ", Q2 = " << Q2;
71 
72  //-- Retrieve P33(1232) information
73  double Gamma_R0 = utils::res::Width (kP33_1232);
74  double MR = utils::res::Mass (kP33_1232);
75  double MR2 = TMath::Power(MR,2);
76  double MR3 = TMath::Power(MR,3);
77 
78  //-- Auxiliary params
79 
80  const double kPlRes_f3_P1232_V = 1.95/MN;
81  const double kPlRes_f4_P1232_V = -1.95/MN;
82  const double kPlRes_f5_P1232_V = 0;
83  const double kPlRes_f5_P1232_A = 1.2;
84  const double kPlRes_f4_P1232_A = -0.3/MN2;
85  const double kPlRes_f3_P1232_A = 0;
86  const double kPlRes_f6_P1232_A = kPlRes_f5_P1232_A;
87 
88  double MA2 = TMath::Power( fMa, 2 );
89  double MV2 = TMath::Power( fMv, 2 );
90  double ftmp1a = TMath::Power( 1 + Q2/MA2, 2 );
91  double ftmp1v = TMath::Power( 1 + Q2/MA2, 2 );
92  double ftmp2a = 1 + Q2/3/MA2;
93  double ftmp2v = 1 + Q2/4/MV2;
94  double f3A = kPlRes_f3_P1232_A/ftmp1a/ftmp2a;
95  double f4A = kPlRes_f4_P1232_A/ftmp1a/ftmp2a;
96  double f5A = kPlRes_f5_P1232_A/ftmp1a/ftmp2a;
97  double f6A = kPlRes_f6_P1232_A/ftmp1a/ftmp2a/(Q2+Mpi2);
98  double f3V = kPlRes_f3_P1232_V/ftmp1v/ftmp2v;
99  double f4V = kPlRes_f4_P1232_V/ftmp1v/ftmp2v/W;
100  double f5V = kPlRes_f5_P1232_V/ftmp1v/ftmp2v;
101  double f3V4A = f3V*f4A;
102  double f3V5A = f3V*f5A;
103  double f4V4A = f4V*f4A;
104  double f4V5A = f4V*f5A;
105  double f3A2 = TMath::Power( f3A, 2 );
106  double f4A2 = TMath::Power( f4A, 2 );
107  double f5A2 = TMath::Power( f5A, 2 );
108  double f6A2 = TMath::Power( f6A, 2 );
109  double f3V2 = TMath::Power( f3V, 2 );
110  double f4V2 = TMath::Power( f4V, 2 );
111  double f5V2 = TMath::Power( f5V, 2 );
112 
113  //-- move these running gamma definitions into GENIE's breit-wigner
114  // functions so that they can be directly used here
115 
116  // model of the running Gamma from Paschos [default]
117  double Gamma_R=Gamma_R0*pow((this->PPiStar(W,MN)/this->PPiStar(MR,MN)),3);
118 
119  // check for other option
120  if ( GetConfig().Exists("running-gamma") ) {
121 
122  string gamma_model = GetConfig().GetString("running-gamma");
123 
124  if ( gamma_model.find("Hagiwara") != string::npos )
125  {
126  // model of the running Gamma from Hagiwara et. al.
127  Gamma_R = Gamma_R0*MR/W*pow((this->PPiStar(W,MN)/this->PPiStar(MR,MN)),1);
128  } else
129  if ( gamma_model.find("Galster") != string::npos )
130  {
131  // model of the running Gamma similar to Galster-1972
132  double gtmp1 = TMath::Power( this->PPiStar(W,MN) / this->PPiStar(MR,MN), 3);
133  double gtmp2 = TMath::Power( this->PPiStar(W,MN) / this->PPiStar(MR,MN), 2);
134  Gamma_R = Gamma_R0*gtmp1/(1+gtmp2);
135  }
136  }
137  double Breit_Wigner = TMath::Power(W*W-MR2,2) + MR2 * TMath::Power(Gamma_R,2);
138 
139  //-- Include Pauli suppression [if the option was turned on by the user]
140  double pauli = 1.;
141  if(fTurnOnPauliCorrection) pauli = this->Pauli(Q2,W,MN);
142 
143  //-- Kinematic variables
144  double nu = this->Nu(Q2,W,MN);
145  double pq = MN*nu;
146  double qk = -(Q2+Mmu2)/2.;
147  double pk = MN*E;
148  double pq2 = TMath::Power(pq,2);
149  double pq3 = TMath::Power(pq,3);
150  double Q4 = TMath::Power(Q2,2);
151 
152  //-- Compute Wi's, i=1-5
153  double W1=0, W2=0, W3=0, W4=0, W5=0;
154 
155  W1 = 3.*(2*f5A2*MN2*MR2+2*f5A2*MN*MR3+2*f3A*f5A*MN2*MR*pq+2*f5A2*MR2*pq
156  +4*f3A*f5A*MN*MR2*pq+4*f4A*f5A*MN2*MR2*pq+2*f3A*f5A*MR3*pq
157  +4*f4A*f5A*MN*MR3*pq+2*f3A2*MN2*pq2+2*f3V2*MN2*pq2+2*f3A*f5A*MR*pq2
158  +2*f3A*f4A*MN2*MR*pq2+2*f3V*f4V*MN2*MR*pq2+2*f3V*f5V*MN2*MR*pq2
159  +2*f3A2*MR2*pq2+2*f3V2*MR2*pq2+4*f4A*f5A*MR2*pq2+4*f3A*f4A*MN*MR2*pq2
160  -4*f3V*f4V*MN*MR2*pq2-4*f3V*f5V*MN*MR2*pq2+2*f4A2*MN2*MR2*pq2+2*f4V2*MN2*MR2*pq2
161  +4*f4V*f5V*MN2*MR2*pq2+2*f5V2*MN2*MR2*pq2+2*f3A*f4A*MR3*pq2+2*f3V*f4V*MR3*pq2
162  +2*f3V*f5V*MR3*pq2+2*f4A2*MN*MR3*pq2-2*f4V2*MN*MR3*pq2-4*f4V*f5V*MN*MR3*pq2
163  -2*f5V2*MN*MR3*pq2+2*f3A2*pq3+2*f3V2*pq3+2*f3A*f4A*MR*pq3+2*f3V*f4V*MR*pq3
164  +2*f3V*f5V*MR*pq3+2*f4A2*MR2*pq3+2*f4V2*MR2*pq3+4*f4V*f5V*MR2*pq3+2*f5V2*MR2*pq3
165  -2*f3A*f5A*MN2*MR*Q2-4*f3A*f5A*MN*MR2*Q2+2*f3A2*MN2*MR2*Q2
166  +2*f3V2*MN2*MR2*Q2-4*f4A*f5A*MN2*MR2*Q2-2*f3A2*MN*MR3*Q2+2*f3V2*MN*MR3*Q2
167  -4*f4A*f5A*MN*MR3*Q2-4*f3A2*MN2*pq*Q2-4*f3V2*MN2*pq*Q2-2*f3A*f5A*MR*pq*Q2
168  -4*f3A*f4A*MN2*MR*pq*Q2-4*f3V*f4V*MN2*MR*pq*Q2-2*f3V*f5V*MN2*MR*pq*Q2
169  -4*f4A*f5A*MR2*pq*Q2-8*f3A*f4A*MN*MR2*pq*Q2+8*f3V*f4V*MN*MR2*pq*Q2
170  +4*f3V*f5V*MN*MR2*pq*Q2-4*f4A2*MN2*MR2*pq*Q2-4*f4V2*MN2*MR2*pq*Q2
171  -4*f4V*f5V*MN2*MR2*pq*Q2-2*f3A*f4A*MR3*pq*Q2-2*f3V*f4V*MR3*pq*Q2
172  -4*f4A2*MN*MR3*pq*Q2+4*f4V2*MN*MR3*pq*Q2+4*f4V*f5V*MN*MR3*pq*Q2
173  -4*f3A2*pq2*Q2-4*f3V2*pq2*Q2-4*f3A*f4A*MR*pq2*Q2-4*f3V*f4V*MR*pq2*Q2
174  -2*f3V*f5V*MR*pq2*Q2-4*f4A2*MR2*pq2*Q2-4*f4V2*MR2*pq2*Q2-4*f4V*f5V*MR2*pq2*Q2
175  +2*f3A2*MN2*Q4+2*f3V2*MN2*Q4+2*f3A*f4A*MN2*MR*Q4+2*f3V*f4V*MN2*MR*Q4
176  +4*f3A*f4A*MN*MR2*Q4-4*f3V*f4V*MN*MR2*Q4+2*f4A2*MN2*MR2*Q4+2*f4V2*MN2*MR2*Q4
177  +2*f4A2*MN*MR3*Q4-2*f4V2*MN*MR3*Q4+2*f3A2*pq*Q4+2*f3V2*pq*Q4+2*f3A*f4A*MR*pq*Q4
178  +2*f3V*f4V*MR*pq*Q4+2*f4A2*MR2*pq*Q4+2*f4V2*MR2*pq*Q4)/(3.*MR2);
179 
180  W2 = 3.*(2*(f5A2*MN2
181  +f5A2*MN*MR+f5A2*pq+f3A2*MN2*Q2+f3V2*MN2*Q2+f3A*f5A*MR*Q2+f3A*f4A*MN2*MR*Q2
182  +f3V*f4V*MN2*MR*Q2+f3V*f5V*MN2*MR*Q2+f3A2*MR2*Q2+f3V2*MR2*Q2
183  +2*f3A*f4A*MN*MR2*Q2-2*f3V*f4V*MN*MR2*Q2-2*f3V*f5V*MN*MR2*Q2
184  +f4A2*MN2*MR2*Q2+f4V2*MN2*MR2*Q2+2*f4V*f5V*MN2*MR2*Q2+f5V2*MN2*MR2*Q2+f3A*f4A*MR3*Q2
185  +f3V*f4V*MR3*Q2+f3V*f5V*MR3*Q2+f4A2*MN*MR3*Q2-f4V2*MN*MR3*Q2
186  -2*f4V*f5V*MN*MR3*Q2-f5V2*MN*MR3*Q2+f3A2*pq*Q2+f3V2*pq*Q2+f3A*f4A*MR*pq*Q2
187  +f3V*f4V*MR*pq*Q2+f3V*f5V*MR*pq*Q2+f4A2*MR2*pq*Q2+f4V2*MR2*pq*Q2
188  +2*f4V*f5V*MR2*pq*Q2+f5V2*MR2*pq*Q2+f5V2*MN2*Q4+f3V*f5V*MR*Q4
189  -f5V2*MN*MR*Q4+f5V2*pq*Q4))/(3.*MR2);
190 
191  W3 = 3.*((f3V4A*(Q2-pq)-f3V5A)*(2*MR2+2*MN*MR+Q2-pq)*4./3./MR
192  -(Q2-pq)*(f4V4A*(Q2-pq)-f4V5A)*4./3.);
193 
194 
195  W4 = 3.*(2*(f5A2*MN2+f5A2*MN*MR+f3A*f5A*MN2*MR
196  +2*f3A*f5A*MN*MR2-f3A2*MN2*MR2-f3V2*MN2*MR2+2*f4A*f5A*MN2*MR2-2*f5A*f6A*MN2*MR2
197  +f3A2*MN*MR3-f3V2*MN*MR3+2*f4A*f5A*MN*MR3-2*f5A*f6A*MN*MR3+f5A2*pq
198  +2*f3A2*MN2*pq+2*f3V2*MN2*pq+2*f5A*f6A*MN2*pq+2*f3A*f5A*MR*pq
199  +2*f5A*f6A*MN*MR*pq+2*f3A*f4A*MN2*MR*pq+2*f3V*f4V*MN2*MR*pq
200  +f3V*f5V*MN2*MR*pq-f3A*f6A*MN2*MR*pq+2*f4A*f5A*MR2*pq
201  -2*f5A*f6A*MR2*pq+4*f3A*f4A*MN*MR2*pq-4*f3V*f4V*MN*MR2*pq
202  -2*f3V*f5V*MN*MR2*pq-2*f3A*f6A*MN*MR2*pq+2*f4A2*MN2*MR2*pq
203  +2*f4V2*MN2*MR2*pq+2*f4V*f5V*MN2*MR2*pq-2*f4A*f6A*MN2*MR2*pq+f3A*f4A*MR3*pq
204  +f3V*f4V*MR3*pq-f3A*f6A*MR3*pq+2*f4A2*MN*MR3*pq-2*f4V2*MN*MR3*pq
205  -2*f4V*f5V*MN*MR3*pq-2*f4A*f6A*MN*MR3*pq+2*f3A2*pq2+2*f3V2*pq2
206  +2*f5A*f6A*pq2+f5V2*MN2*pq2+f6A2*MN2*pq2+2*f3A*f4A*MR*pq2+2*f3V*f4V*MR*pq2
207  +2*f3V*f5V*MR*pq2-f5V2*MN*MR*pq2+f6A2*MN*MR*pq2+2*f4A2*MR2*pq2+2*f4V2*MR2*pq2
208  +2*f4V*f5V*MR2*pq2-2*f4A*f6A*MR2*pq2+f5V2*pq3+f6A2*pq3-f3A2*MN2*Q2-f3V2*MN2*Q2
209  -2*f5A*f6A*MN2*Q2-2*f5A*f6A*MN*MR*Q2-f3A*f4A*MN2*MR*Q2
210  -f3V*f4V*MN2*MR*Q2-2*f3A*f4A*MN*MR2*Q2+2*f3V*f4V*MN*MR2*Q2
211  -f4A2*MN2*MR2*Q2-f4V2*MN2*MR2*Q2+f6A2*MN2*MR2*Q2-f4A2*MN*MR3*Q2+f4V2*MN*MR3*Q2
212  +f6A2*MN*MR3*Q2-f3A2*pq*Q2-f3V2*pq*Q2-2*f5A*f6A*pq*Q2-2*f6A2*MN2*pq*Q2
213  -f3A*f4A*MR*pq*Q2-f3V*f4V*MR*pq*Q2-f3A*f6A*MR*pq*Q2
214  -2*f6A2*MN*MR*pq*Q2-f4A2*MR2*pq*Q2-f4V2*MR2*pq*Q2+f6A2*MR2*pq*Q2
215  -2*f6A2*pq2*Q2+f6A2*MN2*Q4+f6A2*MN*MR*Q4+f6A2*pq*Q4))/(3.*MR2);
216 
217  W5 = 3.*(2*f5A2*MN2
218  +2*f5A2*MN*MR+f3A*f5A*MN2*MR+2*f3A*f5A*MN*MR2+2*f4A*f5A*MN2*MR2
219  +f3A*f5A*MR3+2*f4A*f5A*MN*MR3+2*f5A2*pq+2*f3A2*MN2*pq+2*f3V2*MN2*pq
220  +2*f5A*f6A*MN2*pq+2*f3A*f5A*MR*pq+2*f5A*f6A*MN*MR*pq
221  +2*f3A*f4A*MN2*MR*pq+2*f3V*f4V*MN2*MR*pq+2*f3V*f5V*MN2*MR*pq
222  +2*f3A2*MR2*pq+2*f3V2*MR2*pq+2*f4A*f5A*MR2*pq+4*f3A*f4A*MN*MR2*pq
223  -4*f3V*f4V*MN*MR2*pq-4*f3V*f5V*MN*MR2*pq+2*f4A2*MN2*MR2*pq
224  +2*f4V2*MN2*MR2*pq+4*f4V*f5V*MN2*MR2*pq+2*f5V2*MN2*MR2*pq+2*f3A*f4A*MR3*pq
225  +2*f3V*f4V*MR3*pq+2*f3V*f5V*MR3*pq+2*f4A2*MN*MR3*pq-2*f4V2*MN*MR3*pq
226  -4*f4V*f5V*MN*MR3*pq-2*f5V2*MN*MR3*pq+2*f3A2*pq2+2*f3V2*pq2+2*f5A*f6A*pq2
227  +2*f3A*f4A*MR*pq2+2*f3V*f4V*MR*pq2+2*f3V*f5V*MR*pq2+2*f4A2*MR2*pq2
228  +2*f4V2*MR2*pq2+4*f4V*f5V*MR2*pq2+2*f5V2*MR2*pq2-2*f5A*f6A*MN2*Q2+f3A*f5A*MR*Q2
229  -2*f5A*f6A*MN*MR*Q2-f3A*f6A*MN2*MR*Q2-2*f3A*f6A*MN*MR2*Q2
230  -2*f4A*f6A*MN2*MR2*Q2-f3A*f6A*MR3*Q2-2*f4A*f6A*MN*MR3*Q2
231  -2*f5A*f6A*pq*Q2+2*f5V2*MN2*pq*Q2+2*f3V*f5V*MR*pq*Q2
232  -2*f5V2*MN*MR*pq*Q2-2*f4A*f6A*MR2*pq*Q2+2*f5V2*pq2*Q2-f3A*f6A*MR*Q4)/(3.*MR2);
233 
234  double s1 = W1 * (Q2+Mmu2)
235  + W2 * (2*pk*pk-2*pq*pk+MN*qk)
236  - W3 * (pq*qk+Q2*pk)
237  + W4 * Mmu2*(Q2+Mmu2)/2.
238  - W5 * 2*Mmu2*pk;
239 
240  double xsec = kGF2/4./kPi*fCos28c/MN2/E2*W*MR*Gamma_R/kPi/Breit_Wigner*pauli*s1;
241 
242  //-- The algorithm computes d^2xsec/dWdQ2
243  // Check whether variable tranformation is needed
244  if(kps!=kPSWQ2fE) {
245  double J = utils::kinematics::Jacobian(interaction,kPSWQ2fE,kps);
246  xsec *= J;
247  }
248 
249  //-- If requested return the free nucleon xsec even for input nuclear tgt
250  if( interaction->TestBit(kIAssumeFreeNucleon) ) return xsec;
251 
252  //-- number of scattering centers in the target
253  bool isp = pdg::IsProton(target.HitNucPdg());
254  int NNucl = (isp) ? target.Z() : target.N();
255 
256  xsec*=NNucl; // nuclear xsec (no nuclear suppression factor)
257 
258  return xsec;
259 }
genie::Kinematics::W
double W(bool selected=false) const
Definition: Kinematics.cxx:157
genie::utils::mec::J
double J(double q0, double q3, double Enu, double ml)
Definition: MECUtils.cxx:147
genie::P33PaschosLalakulichPXSec::PPiStar
double PPiStar(double W, double MN) const
...
Definition: P33PaschosLalakulichPXSec.cxx:354
genie::utils::kinematics::Q2
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:1064
genie::Target::HitNucPdg
int HitNucPdg(void) const
Definition: Target.cxx:304
genie::Target::HitNucMass
double HitNucMass(void) const
Definition: Target.cxx:233
cet::pow
constexpr T pow(T x)
Definition: pow.h:72
genie::Kinematics
Generated/set kinematical variables for an event.
Definition: Kinematics.h:39
genie::utils::res::Mass
double Mass(Resonance_t res)
resonance mass (GeV)
Definition: BaryonResUtils.cxx:436
genie::utils::res::Width
double Width(Resonance_t res)
resonance width (GeV)
Definition: BaryonResUtils.cxx:463
generate_CCQE_events.target
target
Definition: generate_CCQE_events.py:44
genie::Algorithm::GetConfig
virtual const Registry & GetConfig(void) const
Definition: Algorithm.cxx:246
genie::P33PaschosLalakulichPXSec::Nu
double Nu(double Q2, double W, double MN) const
kinematic variables
Definition: P33PaschosLalakulichPXSec.cxx:349
genie::P33PaschosLalakulichPXSec::Pauli
double Pauli(double Q2, double W, double MN) const
Pauli suppression for D2.
Definition: P33PaschosLalakulichPXSec.cxx:304
genie::XSecAlgorithmI::ValidKinematics
virtual bool ValidKinematics(const Interaction *i) const
Is the input kinematical point a physically allowed one?
Definition: XSecAlgorithmI.cxx:40
genie::pdg::IsProton
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:333
LOG
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:96
genie::constants::kMuonMass2
static const double kMuonMass2
Definition: Constants.h:84
dump_to_simple_cpp.W
W
Definition: dump_to_simple_cpp.py:43
genie::Target
A Neutrino Interaction Target. Is a transparent encapsulation of quite different physical systems suc...
Definition: Target.h:40
genie::Target::Z
int Z(void) const
Definition: Target.h:68
genie::Registry::GetString
RgStr GetString(RgKey key) const
Definition: Registry.cxx:481
genie::Target::N
int N(void) const
Definition: Target.h:69
genie::P33PaschosLalakulichPXSec::ValidProcess
bool ValidProcess(const Interaction *i) const
Can this cross section algorithm handle the input process?
Definition: P33PaschosLalakulichPXSec.cxx:268
genie::kIAssumeFreeNucleon
const UInt_t kIAssumeFreeNucleon
Definition: Interaction.h:49
E
E
Definition: 018_def.c:13
E2
Definition: 018_def.c:13
genie::utils::kinematics::Jacobian
double Jacobian(const Interaction *const i, KinePhaseSpace_t f, KinePhaseSpace_t t)
Definition: KineUtils.cxx:130
genie::Kinematics::Q2
double Q2(bool selected=false) const
Definition: Kinematics.cxx:125
genie::InitialState::Tgt
const Target & Tgt(void) const
Definition: InitialState.h:66
genie::constants::kGF2
static const double kGF2
Definition: Constants.h:59
genie::InitialState::ProbeE
double ProbeE(RefFrame_t rf) const
Definition: InitialState.cxx:384
genie::constants::kPi
static const double kPi
Definition: Constants.h:37
genie::InitialState
Initial State information.
Definition: InitialState.h:48
pDEBUG
#define pDEBUG
Definition: Messenger.h:63
genie::constants::kPionMass2
static const double kPionMass2
Definition: Constants.h:86

Member Data Documentation

double genie::P33PaschosLalakulichPXSec::fCos28c
private

Definition at line 65 of file P33PaschosLalakulichPXSec.h.

double genie::P33PaschosLalakulichPXSec::fMa
private

Definition at line 63 of file P33PaschosLalakulichPXSec.h.

double genie::P33PaschosLalakulichPXSec::fMv
private

Definition at line 64 of file P33PaschosLalakulichPXSec.h.

bool genie::P33PaschosLalakulichPXSec::fTurnOnPauliCorrection
private

Definition at line 62 of file P33PaschosLalakulichPXSec.h.

const XSecIntegratorI* genie::P33PaschosLalakulichPXSec::fXSecIntegrator
private

Definition at line 60 of file P33PaschosLalakulichPXSec.h.

The documentation for this class was generated from the following files:
Generated by   doxygen 1.8.11