GENIEGenerator
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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:
Inheritance graph
[legend]
Collaboration diagram for genie::P33PaschosLalakulichPXSec:
Collaboration graph
[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. 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 RegistryGetConfig (void) const
 
RegistryGetOwnedConfig (void)
 
virtual const AlgIdId (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 AlgorithmSubAlg (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 XSecIntegratorIfXSecIntegrator
 
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)
 
RegistryExtractLocalConfig (const Registry &in) const
 
RegistryExtractLowerConfig (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
 
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. More...
 
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 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...
 
AlgMapfOwnedSubAlgMp
 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.
References:
O.Lalakulich and E.A.Paschos, Resonance Production by Neutrinos: I. J=3/2 Resonances, hep-ph/0501109
Author
Costas Andreopoulos <c.andreopoulos cern.ch> University of Liverpool

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

Created:
February 22, 2005
License:
Copyright (c) 2003-2024, 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 }
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.

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

276 {
277  Algorithm::Configure(config);
278  this->LoadConfig();
279 }
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.

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

282 {
283  Algorithm::Configure(config);
284  this->LoadConfig();
285 }
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.

References fXSecIntegrator, and genie::XSecIntegratorI::Integrate().

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

Definition at line 287 of file P33PaschosLalakulichPXSec.cxx.

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

Referenced by Configure().

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
304  dynamic_cast<const XSecIntegratorI *> (this->SubAlg("XSec-Integrator"));
305  assert(fXSecIntegrator);
306 }
Cross Section Integrator Interface.
bool GetParamDef(const RgKey &name, T &p, const T &def) const
bool GetParam(const RgKey &name, T &p, bool is_top_call=true) const
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 353 of file P33PaschosLalakulichPXSec.cxx.

Referenced by XSec().

354 {
355  return (TMath::Power(W,2) - TMath::Power(MN,2) + Q2)/2/MN;
356 }
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:1077
double W(const Interaction *const i)
Definition: KineUtils.cxx:1101
double P33PaschosLalakulichPXSec::NuStar ( double  Q2,
double  W,
double  MN 
) const
private

...

Definition at line 367 of file P33PaschosLalakulichPXSec.cxx.

References genie::utils::kinematics::W().

Referenced by Pauli().

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

Pauli suppression for D2.

Definition at line 308 of file P33PaschosLalakulichPXSec.cxx.

References NuStar(), and PPiStar().

Referenced by XSec().

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 }
double PPiStar(double W, double MN) const
...
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:1077
double NuStar(double Q2, double W, double MN) const
...
double W(const Interaction *const i)
Definition: KineUtils.cxx:1101
double P33PaschosLalakulichPXSec::PPiStar ( double  W,
double  MN 
) const
private

...

Definition at line 358 of file P33PaschosLalakulichPXSec.cxx.

References a, genie::units::b, genie::constants::kPionMass, and genie::utils::kinematics::W().

Referenced by Pauli(), and XSec().

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 }
static constexpr double b
Definition: Units.h:78
double W(const Interaction *const i)
Definition: KineUtils.cxx:1101
const double a
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.

References genie::kISkipProcessChk.

Referenced by XSec().

270 {
271  if(interaction->TestBit(kISkipProcessChk)) return true;
272  return true;
273 }
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.

References fCos28c, fFermiConstant2, fMa, fMv, fTurnOnPauliCorrection, genie::Algorithm::GetConfig(), genie::Registry::GetString(), genie::Target::HitNucMass(), genie::Target::HitNucPdg(), genie::pdg::IsProton(), genie::utils::mec::J(), 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::utils::kinematics::Q2(), genie::InitialState::Tgt(), genie::XSecAlgorithmI::ValidKinematics(), ValidProcess(), genie::Kinematics::W(), genie::utils::kinematics::W(), genie::utils::res::Width(), and genie::Target::Z().

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 }
double W(bool selected=false) const
Definition: Kinematics.cxx:157
double J(double q0, double q3, double Enu, double ml)
Definition: MECUtils.cxx:147
double PPiStar(double W, double MN) const
...
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:1077
int HitNucPdg(void) const
Definition: Target.cxx:304
double HitNucMass(void) const
Definition: Target.cxx:233
Generated/set kinematical variables for an event.
Definition: Kinematics.h:39
double Mass(Resonance_t res)
resonance mass (GeV)
double Width(Resonance_t res)
resonance width (GeV)
virtual const Registry & GetConfig(void) const
Definition: Algorithm.cxx:246
double Nu(double Q2, double W, double MN) const
kinematic variables
double W(const Interaction *const i)
Definition: KineUtils.cxx:1101
double Pauli(double Q2, double W, double MN) const
Pauli suppression for D2.
virtual bool ValidKinematics(const Interaction *i) const
Is the input kinematical point a physically allowed one?
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:336
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:96
A Neutrino Interaction Target. Is a transparent encapsulation of quite different physical systems suc...
Definition: Target.h:40
int Z(void) const
Definition: Target.h:68
RgStr GetString(RgKey key) const
Definition: Registry.cxx:481
int N(void) const
Definition: Target.h:69
bool ValidProcess(const Interaction *i) const
Can this cross section algorithm handle the input process?
const UInt_t kIAssumeFreeNucleon
Definition: Interaction.h:49
double Jacobian(const Interaction *const i, KinePhaseSpace_t f, KinePhaseSpace_t t)
Definition: KineUtils.cxx:130
double Q2(bool selected=false) const
Definition: Kinematics.cxx:125
const Target & Tgt(void) const
Definition: InitialState.h:66
double ProbeE(RefFrame_t rf) const
Initial State information.
Definition: InitialState.h:48
#define pDEBUG
Definition: Messenger.h:63

Member Data Documentation

double genie::P33PaschosLalakulichPXSec::fCos28c
private

Definition at line 65 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

double genie::P33PaschosLalakulichPXSec::fFermiConstant2
private

Definition at line 62 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

double genie::P33PaschosLalakulichPXSec::fMa
private

Definition at line 63 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

double genie::P33PaschosLalakulichPXSec::fMv
private

Definition at line 64 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

bool genie::P33PaschosLalakulichPXSec::fTurnOnPauliCorrection
private

Definition at line 67 of file P33PaschosLalakulichPXSec.h.

Referenced by LoadConfig(), and XSec().

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: