GENIEGenerator
Loading...
Searching...
No Matches
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:
[legend]
Collaboration diagram for genie::P33PaschosLalakulichPXSec:
[legend]

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.
double Integral (const Interaction *i) const
bool ValidProcess (const Interaction *i) const
 Can this cross section algorithm handle the input process?
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?
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.
virtual AlgStatus_t GetStatus (void) const
 Get algorithm status.
virtual bool AllowReconfig (void) const
virtual AlgCmp_t Compare (const Algorithm *alg) const
 Compare with input algorithm.
virtual void SetId (const AlgId &id)
 Set algorithm ID.
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.

Private Member Functions

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

Private Attributes

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

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)
static string BuildParamMatKey (const std::string &comm_name, unsigned int i, unsigned int j)
static string BuildParamMatRowSizeKey (const std::string &comm_name)
static string BuildParamMatColSizeKey (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.
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.
int GetParamVectKeys (const std::string &comm_name, std::vector< RgKey > &k, bool is_top_call=true) const
template<class T>
int GetParamMat (const std::string &comm_name, TMatrixT< T > &mat, bool is_top_call=true) const
 Handle to load matrix of parameters.
template<class T>
int GetParamMatSym (const std::string &comm_name, TMatrixTSym< T > &mat, bool is_top_call=true) const
int GetParamMatKeys (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
int AddLowRegistry (Registry *rp, bool owns=true)
 add registry with lowest priority, also update ownership
int MergeTopRegistry (const Registry &r)
int AddTopRegisties (const vector< Registry * > &rs, bool owns=false)
 Add registries with top priority, also udated Ownerships.
Protected Attributes inherited from genie::Algorithm
bool fAllowReconfig
bool fOwnsSubstruc
 true if it owns its substructure (sub-algs,...)
AlgId fID
 algorithm name and configuration set
vector< Registry * > fConfVect
vector< bool > fOwnerships
 ownership for every registry in fConfVect
AlgStatus_t fStatus
 algorithm execution status
AlgMap * fOwnedSubAlgMp
 local pool for owned sub-algs (taken out of the factory pool)

Detailed Description

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

Is a concrete implementation of the XSecAlgorithmI interface.

References:\n O.Lalakulich and E.A.Paschos, Resonance Production by Neutrinos:
I. J=3/2 Resonances, hep-ph/0501109
Author
Costas Andreopoulos <c.andreopoulos \at cern.ch> University of Liverpool

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

Created:\n February 22, 2005
License:\n Copyright (c) 2003-2025, 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() [1/2]

P33PaschosLalakulichPXSec::P33PaschosLalakulichPXSec ( )

Definition at line 33 of file P33PaschosLalakulichPXSec.cxx.

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

References genie::XSecAlgorithmI::XSecAlgorithmI().

◆ P33PaschosLalakulichPXSec() [2/2]

P33PaschosLalakulichPXSec::P33PaschosLalakulichPXSec ( string name)

Definition at line 39 of file P33PaschosLalakulichPXSec.cxx.

39 :
40XSecAlgorithmI("genie::P33PaschosLalakulichPXSec", config)
41{
42
43}

References genie::XSecAlgorithmI::XSecAlgorithmI().

◆ ~P33PaschosLalakulichPXSec()

P33PaschosLalakulichPXSec::~P33PaschosLalakulichPXSec ( )
virtual

Definition at line 45 of file P33PaschosLalakulichPXSec.cxx.

46{
47
48}

Member Function Documentation

◆ Configure() [1/2]

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

References genie::Algorithm::Configure(), and LoadConfig().

◆ Configure() [2/2]

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}

References genie::Algorithm::Configure(), and LoadConfig().

◆ Integral()

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}

References fXSecIntegrator.

◆ LoadConfig()

void P33PaschosLalakulichPXSec::LoadConfig ( void )
private

Definition at line 287 of file P33PaschosLalakulichPXSec.cxx.

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

References fCos28c, fFermiConstant2, fMa, fMv, fTurnOnPauliCorrection, fXSecIntegrator, genie::Algorithm::GetParam(), genie::Algorithm::GetParamDef(), and genie::Algorithm::SubAlg().

Referenced by Configure(), and Configure().

◆ Nu()

double P33PaschosLalakulichPXSec::Nu ( double Q2,
double W,
double MN ) const
private

kinematic variables

Definition at line 353 of file P33PaschosLalakulichPXSec.cxx.

354{
355 return (TMath::Power(W,2) - TMath::Power(MN,2) + Q2)/2/MN;
356}

Referenced by XSec().

◆ NuStar()

double P33PaschosLalakulichPXSec::NuStar ( double Q2,
double W,
double MN ) const
private

...

Definition at line 367 of file P33PaschosLalakulichPXSec.cxx.

368{
369 return (TMath::Power(W,2) - TMath::Power(MN,2) - Q2)/2/W;
370}
genie::utils::kinematics::W
double W(const Interaction *const i)
Definition KineUtils.cxx:1101

Referenced by Pauli().

◆ Pauli()

double P33PaschosLalakulichPXSec::Pauli ( double Q2,
double W,
double MN ) const
private

Pauli suppression for D2.

Definition at line 308 of file P33PaschosLalakulichPXSec.cxx.

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

References NuStar(), and PPiStar().

Referenced by XSec().

◆ PPiStar()

double P33PaschosLalakulichPXSec::PPiStar ( double W,
double MN ) const
private

...

Definition at line 358 of file P33PaschosLalakulichPXSec.cxx.

359{
360 double W2 = TMath::Power(W,2);
361 double a = TMath::Power(MN+kPionMass,2);
362 double b = TMath::Power(MN-kPionMass,2);
363
364 return TMath::Sqrt( (W2-a)*(W2-b) )/2/W;
365}
a
const double a
Definition gUpMuFluxGen.cxx:164

References a, and genie::constants::kPionMass.

Referenced by Pauli(), and XSec().

◆ ValidProcess()

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

References genie::kISkipProcessChk.

Referenced by XSec().

◆ XSec()

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 = fFermiConstant2/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}
pDEBUG
#define pDEBUG
Definition Messenger.h:63
LOG
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE,...
Definition Messenger.h:96
genie::Algorithm::GetConfig
virtual const Registry & GetConfig(void) const
Definition Algorithm.cxx:246
genie::InitialState::Tgt
const Target & Tgt(void) const
Definition InitialState.h:66
genie::InitialState::ProbeE
double ProbeE(RefFrame_t rf) const
Definition InitialState.cxx:384
genie::Kinematics::Q2
double Q2(bool selected=false) const
Definition Kinematics.cxx:125
genie::Kinematics::W
double W(bool selected=false) const
Definition Kinematics.cxx:157
genie::P33PaschosLalakulichPXSec::Nu
double Nu(double Q2, double W, double MN) const
kinematic variables
Definition P33PaschosLalakulichPXSec.cxx:353
genie::P33PaschosLalakulichPXSec::Pauli
double Pauli(double Q2, double W, double MN) const
Pauli suppression for D2.
Definition P33PaschosLalakulichPXSec.cxx:308
genie::P33PaschosLalakulichPXSec::ValidProcess
bool ValidProcess(const Interaction *i) const
Can this cross section algorithm handle the input process?
Definition P33PaschosLalakulichPXSec.cxx:268
genie::Registry::GetString
RgStr GetString(RgKey key) const
Definition Registry.cxx:481
genie::Target::HitNucPdg
int HitNucPdg(void) const
Definition Target.cxx:304
genie::Target::N
int N(void) const
Definition Target.h:69
genie::Target::Z
int Z(void) const
Definition Target.h:68
genie::Target::HitNucMass
double HitNucMass(void) const
Definition Target.cxx:233
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:336
genie::utils::kinematics::Q2
double Q2(const Interaction *const i)
Definition KineUtils.cxx:1077
genie::utils::kinematics::Jacobian
double Jacobian(const Interaction *const i, KinePhaseSpace_t f, KinePhaseSpace_t t)
Definition KineUtils.cxx:130
genie::utils::mec::J
double J(double q0, double q3, double Enu, double ml)
Definition MECUtils.cxx:147
genie::utils::res::Width
double Width(Resonance_t res)
resonance width (GeV)
Definition BaryonResUtils.cxx:463
genie::utils::res::Mass
double Mass(Resonance_t res)
resonance mass (GeV)
Definition BaryonResUtils.cxx:436
genie::kRfHitNucRest
@ kRfHitNucRest
Definition RefFrame.h:30
genie::kIAssumeFreeNucleon
const UInt_t kIAssumeFreeNucleon
Definition Interaction.h:49

References fCos28c, fFermiConstant2, fMa, fMv, fTurnOnPauliCorrection, genie::Algorithm::GetConfig(), genie::Registry::GetString(), genie::Target::HitNucMass(), genie::Target::HitNucPdg(), genie::pdg::IsProton(), genie::utils::kinematics::Jacobian(), genie::kIAssumeFreeNucleon, genie::constants::kMuonMass2, genie::kP33_1232, genie::constants::kPi, genie::constants::kPionMass2, genie::kPSWQ2fE, genie::kRfHitNucRest, LOG, genie::utils::res::Mass(), genie::Target::N(), Nu(), Pauli(), pDEBUG, PPiStar(), genie::InitialState::ProbeE(), genie::Kinematics::Q2(), genie::InitialState::Tgt(), genie::XSecAlgorithmI::ValidKinematics(), ValidProcess(), genie::Kinematics::W(), genie::utils::res::Width(), and genie::Target::Z().

Member Data Documentation

◆ fCos28c

double genie::P33PaschosLalakulichPXSec::fCos28c
private

Definition at line 65 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

◆ fFermiConstant2

double genie::P33PaschosLalakulichPXSec::fFermiConstant2
private

Definition at line 62 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

◆ fMa

double genie::P33PaschosLalakulichPXSec::fMa
private

Definition at line 63 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

◆ fMv

double genie::P33PaschosLalakulichPXSec::fMv
private

Definition at line 64 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

◆ fTurnOnPauliCorrection

bool genie::P33PaschosLalakulichPXSec::fTurnOnPauliCorrection
private

Definition at line 67 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

◆ fXSecIntegrator

const XSecIntegratorI* genie::P33PaschosLalakulichPXSec::fXSecIntegrator
private

Definition at line 60 of file P33PaschosLalakulichPXSec.h.

Referenced by Integral(), and LoadConfig().

The documentation for this class was generated from the following files:
Generated on for GENIEGenerator by doxygen 1.14.0