GENIEGenerator
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
P33PaschosLalakulichPXSec.cxx
Go to the documentation of this file.
1 //____________________________________________________________________________
2 /*
3  Copyright (c) 2003-2024, The GENIE Collaboration
4  For the full text of the license visit http://copyright.genie-mc.org
5 
6  Costas Andreopoulos <c.andreopoulos \at cern.ch>
7  University of Liverpool
8 
9  based on code written by the model authors (Olga Lalakulich, 17.02.2005).
10 */
11 //____________________________________________________________________________
12 
13 #include <TMath.h>
14 
15 #include "Framework/Algorithm/AlgConfigPool.h"
16 #include "Framework/ParticleData/BaryonResonance.h"
17 #include "Framework/ParticleData/BaryonResUtils.h"
18 #include "Framework/Conventions/Constants.h"
19 #include "Framework/Conventions/RefFrame.h"
20 #include "Framework/Conventions/KineVar.h"
21 #include "Framework/Messenger/Messenger.h"
22 #include "Framework/ParticleData/PDGUtils.h"
23 #include "Framework/Utils/KineUtils.h"
24 #include "Framework/Numerical/MathUtils.h"
25 #include "Framework/Utils/Range1.h"
26 #include "Physics/Resonance/XSection/P33PaschosLalakulichPXSec.h"
27 #include "Physics/XSectionIntegration/XSecIntegratorI.h"
28 
29 using namespace genie;
30 using namespace genie::constants;
31 
32 //____________________________________________________________________________
33 P33PaschosLalakulichPXSec::P33PaschosLalakulichPXSec() :
34 XSecAlgorithmI("genie::P33PaschosLalakulichPXSec")
35 {
36 
37 }
38 //____________________________________________________________________________
39 P33PaschosLalakulichPXSec::P33PaschosLalakulichPXSec(string config) :
40 XSecAlgorithmI("genie::P33PaschosLalakulichPXSec", config)
41 {
42 
43 }
44 //____________________________________________________________________________
45 P33PaschosLalakulichPXSec::~P33PaschosLalakulichPXSec()
46 {
47 
48 }
49 //____________________________________________________________________________
50 double P33PaschosLalakulichPXSec::XSec(
51  const Interaction * interaction, KinePhaseSpace_t kps) const
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 }
260 //____________________________________________________________________________
261 double P33PaschosLalakulichPXSec::Integral(
262  const Interaction * interaction) const
263 {
264  double xsec = fXSecIntegrator->Integrate(this,interaction);
265  return xsec;
266 }
267 //____________________________________________________________________________
268 bool P33PaschosLalakulichPXSec::ValidProcess(
269  const Interaction * interaction) const
270 {
271  if(interaction->TestBit(kISkipProcessChk)) return true;
272  return true;
273 }
274 //____________________________________________________________________________
275 void P33PaschosLalakulichPXSec::Configure(const Registry & config)
276 {
277  Algorithm::Configure(config);
278  this->LoadConfig();
279 }
280 //____________________________________________________________________________
281 void P33PaschosLalakulichPXSec::Configure(string config)
282 {
283  Algorithm::Configure(config);
284  this->LoadConfig();
285 }
286 //____________________________________________________________________________
287 void P33PaschosLalakulichPXSec::LoadConfig(void)
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 }
307 //____________________________________________________________________________
308 double P33PaschosLalakulichPXSec::Pauli(double Q2, double W, double MN) const
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 }
352 //____________________________________________________________________________
353 double P33PaschosLalakulichPXSec::Nu(double Q2, double W, double MN) const
354 {
355  return (TMath::Power(W,2) - TMath::Power(MN,2) + Q2)/2/MN;
356 }
357 //____________________________________________________________________________
358 double P33PaschosLalakulichPXSec::PPiStar(double W, double MN) const
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 }
366 //____________________________________________________________________________
367 double P33PaschosLalakulichPXSec::NuStar(double Q2, double W, double MN) const
368 {
369  return (TMath::Power(W,2) - TMath::Power(MN,2) - Q2)/2/W;
370 }
371 //____________________________________________________________________________
genie::XSecAlgorithmI
Cross Section Calculation Interface.
Definition: XSecAlgorithmI.h:27
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:358
genie::XSecIntegratorI
Cross Section Integrator Interface.
Definition: XSecIntegratorI.h:29
genie::utils::kinematics::Q2
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:1077
genie::Target::HitNucPdg
int HitNucPdg(void) const
Definition: Target.cxx:304
genie::P33PaschosLalakulichPXSec::XSec
double XSec(const Interaction *i, KinePhaseSpace_t k) const
Compute the cross section for the input interaction.
Definition: P33PaschosLalakulichPXSec.cxx:50
genie::Target::HitNucMass
double HitNucMass(void) const
Definition: Target.cxx:233
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::P33PaschosLalakulichPXSec::NuStar
double NuStar(double Q2, double W, double MN) const
...
Definition: P33PaschosLalakulichPXSec.cxx:367
genie::utils::res::Width
double Width(Resonance_t res)
resonance width (GeV)
Definition: BaryonResUtils.cxx:463
genie::KinePhaseSpace_t
enum genie::EKinePhaseSpace KinePhaseSpace_t
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:353
genie::units::b
static constexpr double b
Definition: Units.h:78
genie::utils::kinematics::W
double W(const Interaction *const i)
Definition: KineUtils.cxx:1101
genie::P33PaschosLalakulichPXSec::Pauli
double Pauli(double Q2, double W, double MN) const
Pauli suppression for D2.
Definition: P33PaschosLalakulichPXSec.cxx:308
genie::Interaction
Summary information for an interaction.
Definition: Interaction.h:56
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
LOG
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:96
a
const double a
Definition: gUpMuFluxGen.cxx:164
genie::Target
A Neutrino Interaction Target. Is a transparent encapsulation of quite different physical systems suc...
Definition: Target.h:40
genie::Algorithm::Configure
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
genie::Target::Z
int Z(void) const
Definition: Target.h:68
genie::P33PaschosLalakulichPXSec::Integral
double Integral(const Interaction *i) const
Definition: P33PaschosLalakulichPXSec.cxx:261
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::Registry
A registry. Provides the container for algorithm configuration parameters.
Definition: Registry.h:65
genie::kIAssumeFreeNucleon
const UInt_t kIAssumeFreeNucleon
Definition: Interaction.h:49
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::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::InitialState::Tgt
const Target & Tgt(void) const
Definition: InitialState.h:66
genie::XSecIntegratorI::Integrate
virtual double Integrate(const XSecAlgorithmI *model, const Interaction *interaction) const =0
genie::InitialState::ProbeE
double ProbeE(RefFrame_t rf) const
Definition: InitialState.cxx:384
genie::kISkipProcessChk
const UInt_t kISkipProcessChk
if set, skip process validity checks
Definition: Interaction.h:47
genie::InitialState
Initial State information.
Definition: InitialState.h:48
pDEBUG
#define pDEBUG
Definition: Messenger.h:63
genie::Algorithm::SubAlg
const Algorithm * SubAlg(const RgKey &registry_key) const
Definition: Algorithm.cxx:345
Generated on Wed Jul 17 2024 14:46:44 for GENIEGenerator by   doxygen 1.8.5