P33PaschosLalakulichPXSec.cxx
Go to the documentation of this file.
1 //____________________________________________________________________________
2 /*
3  Copyright (c) 2003-2019, The GENIE Collaboration
4  For the full text of the license visit http://copyright.genie-mc.org
5  or see $GENIE/LICENSE
6 
7  Author: This class is based on code written by the model authors (Olga
8  Lalakulich, 17.02.2005). The code was modified to fit into the
9  GENIE framework by Costas Andreopoulos.
10 
11  For the class documentation see the corresponding header file.
12 
13  Important revisions after version 2.0.0 :
14 
15 */
16 //____________________________________________________________________________
17 
18 #include <TMath.h>
19 
30 #include "Framework/Utils/Range1.h"
33 
34 using namespace genie;
35 using namespace genie::constants;
36 
37 //____________________________________________________________________________
39 XSecAlgorithmI("genie::P33PaschosLalakulichPXSec")
40 {
41 
42 }
43 //____________________________________________________________________________
45 XSecAlgorithmI("genie::P33PaschosLalakulichPXSec", config)
46 {
47 
48 }
49 //____________________________________________________________________________
51 {
52 
53 }
54 //____________________________________________________________________________
56  const Interaction * interaction, KinePhaseSpace_t kps) const
57 {
58  if(! this -> ValidProcess (interaction) ) return 0.;
59  if(! this -> ValidKinematics (interaction) ) return 0.;
60 
61  //-- Get initial state and kinematic variables
62  const InitialState & init_state = interaction -> InitState();
63  const Kinematics & kinematics = interaction -> Kine();
64  const Target & target = init_state.Tgt();
65 
66  double E = init_state.ProbeE(kRfHitNucRest);
67  double E2 = TMath::Power(E,2);
68  double Q2 = kinematics.Q2();
69  double W = kinematics.W();
70  double MN = target.HitNucMass();
71  double MN2 = TMath::Power(MN,2);
72  double Mmu2 = kMuonMass2;
73  double Mpi2 = kPionMass2;
74 
75  LOG("PaschLal", pDEBUG) << "Input kinematics: W = " << W << ", Q2 = " << Q2;
76 
77  //-- Retrieve P33(1232) information
78  double Gamma_R0 = utils::res::Width (kP33_1232);
79  double MR = utils::res::Mass (kP33_1232);
80  double MR2 = TMath::Power(MR,2);
81  double MR3 = TMath::Power(MR,3);
82 
83  //-- Auxiliary params
84 
85  const double kPlRes_f3_P1232_V = 1.95/MN;
86  const double kPlRes_f4_P1232_V = -1.95/MN;
87  const double kPlRes_f5_P1232_V = 0;
88  const double kPlRes_f5_P1232_A = 1.2;
89  const double kPlRes_f4_P1232_A = -0.3/MN2;
90  const double kPlRes_f3_P1232_A = 0;
91  const double kPlRes_f6_P1232_A = kPlRes_f5_P1232_A;
92 
93  double MA2 = TMath::Power( fMa, 2 );
94  double MV2 = TMath::Power( fMv, 2 );
95  double ftmp1a = TMath::Power( 1 + Q2/MA2, 2 );
96  double ftmp1v = TMath::Power( 1 + Q2/MA2, 2 );
97  double ftmp2a = 1 + Q2/3/MA2;
98  double ftmp2v = 1 + Q2/4/MV2;
99  double f3A = kPlRes_f3_P1232_A/ftmp1a/ftmp2a;
100  double f4A = kPlRes_f4_P1232_A/ftmp1a/ftmp2a;
101  double f5A = kPlRes_f5_P1232_A/ftmp1a/ftmp2a;
102  double f6A = kPlRes_f6_P1232_A/ftmp1a/ftmp2a/(Q2+Mpi2);
103  double f3V = kPlRes_f3_P1232_V/ftmp1v/ftmp2v;
104  double f4V = kPlRes_f4_P1232_V/ftmp1v/ftmp2v/W;
105  double f5V = kPlRes_f5_P1232_V/ftmp1v/ftmp2v;
106  double f3V4A = f3V*f4A;
107  double f3V5A = f3V*f5A;
108  double f4V4A = f4V*f4A;
109  double f4V5A = f4V*f5A;
110  double f3A2 = TMath::Power( f3A, 2 );
111  double f4A2 = TMath::Power( f4A, 2 );
112  double f5A2 = TMath::Power( f5A, 2 );
113  double f6A2 = TMath::Power( f6A, 2 );
114  double f3V2 = TMath::Power( f3V, 2 );
115  double f4V2 = TMath::Power( f4V, 2 );
116  double f5V2 = TMath::Power( f5V, 2 );
117 
118  //-- move these running gamma definitions into GENIE's breit-wigner
119  // functions so that they can be directly used here
120 
121  // model of the running Gamma from Paschos [default]
122  double Gamma_R=Gamma_R0*pow((this->PPiStar(W,MN)/this->PPiStar(MR,MN)),3);
123 
124  // check for other option
125  if ( GetConfig().Exists("running-gamma") ) {
126 
127  string gamma_model = GetConfig().GetString("running-gamma");
128 
129  if ( gamma_model.find("Hagiwara") != string::npos )
130  {
131  // model of the running Gamma from Hagiwara et. al.
132  Gamma_R = Gamma_R0*MR/W*pow((this->PPiStar(W,MN)/this->PPiStar(MR,MN)),1);
133  } else
134  if ( gamma_model.find("Galster") != string::npos )
135  {
136  // model of the running Gamma similar to Galster-1972
137  double gtmp1 = TMath::Power( this->PPiStar(W,MN) / this->PPiStar(MR,MN), 3);
138  double gtmp2 = TMath::Power( this->PPiStar(W,MN) / this->PPiStar(MR,MN), 2);
139  Gamma_R = Gamma_R0*gtmp1/(1+gtmp2);
140  }
141  }
142  double Breit_Wigner = TMath::Power(W*W-MR2,2) + MR2 * TMath::Power(Gamma_R,2);
143 
144  //-- Include Pauli suppression [if the option was turned on by the user]
145  double pauli = 1.;
146  if(fTurnOnPauliCorrection) pauli = this->Pauli(Q2,W,MN);
147 
148  //-- Kinematic variables
149  double nu = this->Nu(Q2,W,MN);
150  double pq = MN*nu;
151  double qk = -(Q2+Mmu2)/2.;
152  double pk = MN*E;
153  double pq2 = TMath::Power(pq,2);
154  double pq3 = TMath::Power(pq,3);
155  double Q4 = TMath::Power(Q2,2);
156 
157  //-- Compute Wi's, i=1-5
158  double W1=0, W2=0, W3=0, W4=0, W5=0;
159 
160  W1 = 3.*(2*f5A2*MN2*MR2+2*f5A2*MN*MR3+2*f3A*f5A*MN2*MR*pq+2*f5A2*MR2*pq
161  +4*f3A*f5A*MN*MR2*pq+4*f4A*f5A*MN2*MR2*pq+2*f3A*f5A*MR3*pq
162  +4*f4A*f5A*MN*MR3*pq+2*f3A2*MN2*pq2+2*f3V2*MN2*pq2+2*f3A*f5A*MR*pq2
163  +2*f3A*f4A*MN2*MR*pq2+2*f3V*f4V*MN2*MR*pq2+2*f3V*f5V*MN2*MR*pq2
164  +2*f3A2*MR2*pq2+2*f3V2*MR2*pq2+4*f4A*f5A*MR2*pq2+4*f3A*f4A*MN*MR2*pq2
165  -4*f3V*f4V*MN*MR2*pq2-4*f3V*f5V*MN*MR2*pq2+2*f4A2*MN2*MR2*pq2+2*f4V2*MN2*MR2*pq2
166  +4*f4V*f5V*MN2*MR2*pq2+2*f5V2*MN2*MR2*pq2+2*f3A*f4A*MR3*pq2+2*f3V*f4V*MR3*pq2
167  +2*f3V*f5V*MR3*pq2+2*f4A2*MN*MR3*pq2-2*f4V2*MN*MR3*pq2-4*f4V*f5V*MN*MR3*pq2
168  -2*f5V2*MN*MR3*pq2+2*f3A2*pq3+2*f3V2*pq3+2*f3A*f4A*MR*pq3+2*f3V*f4V*MR*pq3
169  +2*f3V*f5V*MR*pq3+2*f4A2*MR2*pq3+2*f4V2*MR2*pq3+4*f4V*f5V*MR2*pq3+2*f5V2*MR2*pq3
170  -2*f3A*f5A*MN2*MR*Q2-4*f3A*f5A*MN*MR2*Q2+2*f3A2*MN2*MR2*Q2
171  +2*f3V2*MN2*MR2*Q2-4*f4A*f5A*MN2*MR2*Q2-2*f3A2*MN*MR3*Q2+2*f3V2*MN*MR3*Q2
172  -4*f4A*f5A*MN*MR3*Q2-4*f3A2*MN2*pq*Q2-4*f3V2*MN2*pq*Q2-2*f3A*f5A*MR*pq*Q2
173  -4*f3A*f4A*MN2*MR*pq*Q2-4*f3V*f4V*MN2*MR*pq*Q2-2*f3V*f5V*MN2*MR*pq*Q2
174  -4*f4A*f5A*MR2*pq*Q2-8*f3A*f4A*MN*MR2*pq*Q2+8*f3V*f4V*MN*MR2*pq*Q2
175  +4*f3V*f5V*MN*MR2*pq*Q2-4*f4A2*MN2*MR2*pq*Q2-4*f4V2*MN2*MR2*pq*Q2
176  -4*f4V*f5V*MN2*MR2*pq*Q2-2*f3A*f4A*MR3*pq*Q2-2*f3V*f4V*MR3*pq*Q2
177  -4*f4A2*MN*MR3*pq*Q2+4*f4V2*MN*MR3*pq*Q2+4*f4V*f5V*MN*MR3*pq*Q2
178  -4*f3A2*pq2*Q2-4*f3V2*pq2*Q2-4*f3A*f4A*MR*pq2*Q2-4*f3V*f4V*MR*pq2*Q2
179  -2*f3V*f5V*MR*pq2*Q2-4*f4A2*MR2*pq2*Q2-4*f4V2*MR2*pq2*Q2-4*f4V*f5V*MR2*pq2*Q2
180  +2*f3A2*MN2*Q4+2*f3V2*MN2*Q4+2*f3A*f4A*MN2*MR*Q4+2*f3V*f4V*MN2*MR*Q4
181  +4*f3A*f4A*MN*MR2*Q4-4*f3V*f4V*MN*MR2*Q4+2*f4A2*MN2*MR2*Q4+2*f4V2*MN2*MR2*Q4
182  +2*f4A2*MN*MR3*Q4-2*f4V2*MN*MR3*Q4+2*f3A2*pq*Q4+2*f3V2*pq*Q4+2*f3A*f4A*MR*pq*Q4
183  +2*f3V*f4V*MR*pq*Q4+2*f4A2*MR2*pq*Q4+2*f4V2*MR2*pq*Q4)/(3.*MR2);
184 
185  W2 = 3.*(2*(f5A2*MN2
186  +f5A2*MN*MR+f5A2*pq+f3A2*MN2*Q2+f3V2*MN2*Q2+f3A*f5A*MR*Q2+f3A*f4A*MN2*MR*Q2
187  +f3V*f4V*MN2*MR*Q2+f3V*f5V*MN2*MR*Q2+f3A2*MR2*Q2+f3V2*MR2*Q2
188  +2*f3A*f4A*MN*MR2*Q2-2*f3V*f4V*MN*MR2*Q2-2*f3V*f5V*MN*MR2*Q2
189  +f4A2*MN2*MR2*Q2+f4V2*MN2*MR2*Q2+2*f4V*f5V*MN2*MR2*Q2+f5V2*MN2*MR2*Q2+f3A*f4A*MR3*Q2
190  +f3V*f4V*MR3*Q2+f3V*f5V*MR3*Q2+f4A2*MN*MR3*Q2-f4V2*MN*MR3*Q2
191  -2*f4V*f5V*MN*MR3*Q2-f5V2*MN*MR3*Q2+f3A2*pq*Q2+f3V2*pq*Q2+f3A*f4A*MR*pq*Q2
192  +f3V*f4V*MR*pq*Q2+f3V*f5V*MR*pq*Q2+f4A2*MR2*pq*Q2+f4V2*MR2*pq*Q2
193  +2*f4V*f5V*MR2*pq*Q2+f5V2*MR2*pq*Q2+f5V2*MN2*Q4+f3V*f5V*MR*Q4
194  -f5V2*MN*MR*Q4+f5V2*pq*Q4))/(3.*MR2);
195 
196  W3 = 3.*((f3V4A*(Q2-pq)-f3V5A)*(2*MR2+2*MN*MR+Q2-pq)*4./3./MR
197  -(Q2-pq)*(f4V4A*(Q2-pq)-f4V5A)*4./3.);
198 
199 
200  W4 = 3.*(2*(f5A2*MN2+f5A2*MN*MR+f3A*f5A*MN2*MR
201  +2*f3A*f5A*MN*MR2-f3A2*MN2*MR2-f3V2*MN2*MR2+2*f4A*f5A*MN2*MR2-2*f5A*f6A*MN2*MR2
202  +f3A2*MN*MR3-f3V2*MN*MR3+2*f4A*f5A*MN*MR3-2*f5A*f6A*MN*MR3+f5A2*pq
203  +2*f3A2*MN2*pq+2*f3V2*MN2*pq+2*f5A*f6A*MN2*pq+2*f3A*f5A*MR*pq
204  +2*f5A*f6A*MN*MR*pq+2*f3A*f4A*MN2*MR*pq+2*f3V*f4V*MN2*MR*pq
205  +f3V*f5V*MN2*MR*pq-f3A*f6A*MN2*MR*pq+2*f4A*f5A*MR2*pq
206  -2*f5A*f6A*MR2*pq+4*f3A*f4A*MN*MR2*pq-4*f3V*f4V*MN*MR2*pq
207  -2*f3V*f5V*MN*MR2*pq-2*f3A*f6A*MN*MR2*pq+2*f4A2*MN2*MR2*pq
208  +2*f4V2*MN2*MR2*pq+2*f4V*f5V*MN2*MR2*pq-2*f4A*f6A*MN2*MR2*pq+f3A*f4A*MR3*pq
209  +f3V*f4V*MR3*pq-f3A*f6A*MR3*pq+2*f4A2*MN*MR3*pq-2*f4V2*MN*MR3*pq
210  -2*f4V*f5V*MN*MR3*pq-2*f4A*f6A*MN*MR3*pq+2*f3A2*pq2+2*f3V2*pq2
211  +2*f5A*f6A*pq2+f5V2*MN2*pq2+f6A2*MN2*pq2+2*f3A*f4A*MR*pq2+2*f3V*f4V*MR*pq2
212  +2*f3V*f5V*MR*pq2-f5V2*MN*MR*pq2+f6A2*MN*MR*pq2+2*f4A2*MR2*pq2+2*f4V2*MR2*pq2
213  +2*f4V*f5V*MR2*pq2-2*f4A*f6A*MR2*pq2+f5V2*pq3+f6A2*pq3-f3A2*MN2*Q2-f3V2*MN2*Q2
214  -2*f5A*f6A*MN2*Q2-2*f5A*f6A*MN*MR*Q2-f3A*f4A*MN2*MR*Q2
215  -f3V*f4V*MN2*MR*Q2-2*f3A*f4A*MN*MR2*Q2+2*f3V*f4V*MN*MR2*Q2
216  -f4A2*MN2*MR2*Q2-f4V2*MN2*MR2*Q2+f6A2*MN2*MR2*Q2-f4A2*MN*MR3*Q2+f4V2*MN*MR3*Q2
217  +f6A2*MN*MR3*Q2-f3A2*pq*Q2-f3V2*pq*Q2-2*f5A*f6A*pq*Q2-2*f6A2*MN2*pq*Q2
218  -f3A*f4A*MR*pq*Q2-f3V*f4V*MR*pq*Q2-f3A*f6A*MR*pq*Q2
219  -2*f6A2*MN*MR*pq*Q2-f4A2*MR2*pq*Q2-f4V2*MR2*pq*Q2+f6A2*MR2*pq*Q2
220  -2*f6A2*pq2*Q2+f6A2*MN2*Q4+f6A2*MN*MR*Q4+f6A2*pq*Q4))/(3.*MR2);
221 
222  W5 = 3.*(2*f5A2*MN2
223  +2*f5A2*MN*MR+f3A*f5A*MN2*MR+2*f3A*f5A*MN*MR2+2*f4A*f5A*MN2*MR2
224  +f3A*f5A*MR3+2*f4A*f5A*MN*MR3+2*f5A2*pq+2*f3A2*MN2*pq+2*f3V2*MN2*pq
225  +2*f5A*f6A*MN2*pq+2*f3A*f5A*MR*pq+2*f5A*f6A*MN*MR*pq
226  +2*f3A*f4A*MN2*MR*pq+2*f3V*f4V*MN2*MR*pq+2*f3V*f5V*MN2*MR*pq
227  +2*f3A2*MR2*pq+2*f3V2*MR2*pq+2*f4A*f5A*MR2*pq+4*f3A*f4A*MN*MR2*pq
228  -4*f3V*f4V*MN*MR2*pq-4*f3V*f5V*MN*MR2*pq+2*f4A2*MN2*MR2*pq
229  +2*f4V2*MN2*MR2*pq+4*f4V*f5V*MN2*MR2*pq+2*f5V2*MN2*MR2*pq+2*f3A*f4A*MR3*pq
230  +2*f3V*f4V*MR3*pq+2*f3V*f5V*MR3*pq+2*f4A2*MN*MR3*pq-2*f4V2*MN*MR3*pq
231  -4*f4V*f5V*MN*MR3*pq-2*f5V2*MN*MR3*pq+2*f3A2*pq2+2*f3V2*pq2+2*f5A*f6A*pq2
232  +2*f3A*f4A*MR*pq2+2*f3V*f4V*MR*pq2+2*f3V*f5V*MR*pq2+2*f4A2*MR2*pq2
233  +2*f4V2*MR2*pq2+4*f4V*f5V*MR2*pq2+2*f5V2*MR2*pq2-2*f5A*f6A*MN2*Q2+f3A*f5A*MR*Q2
234  -2*f5A*f6A*MN*MR*Q2-f3A*f6A*MN2*MR*Q2-2*f3A*f6A*MN*MR2*Q2
235  -2*f4A*f6A*MN2*MR2*Q2-f3A*f6A*MR3*Q2-2*f4A*f6A*MN*MR3*Q2
236  -2*f5A*f6A*pq*Q2+2*f5V2*MN2*pq*Q2+2*f3V*f5V*MR*pq*Q2
237  -2*f5V2*MN*MR*pq*Q2-2*f4A*f6A*MR2*pq*Q2+2*f5V2*pq2*Q2-f3A*f6A*MR*Q4)/(3.*MR2);
238 
239  double s1 = W1 * (Q2+Mmu2)
240  + W2 * (2*pk*pk-2*pq*pk+MN*qk)
241  - W3 * (pq*qk+Q2*pk)
242  + W4 * Mmu2*(Q2+Mmu2)/2.
243  - W5 * 2*Mmu2*pk;
244 
245  double xsec = kGF2/4./kPi*fCos28c/MN2/E2*W*MR*Gamma_R/kPi/Breit_Wigner*pauli*s1;
246 
247  //-- The algorithm computes d^2xsec/dWdQ2
248  // Check whether variable tranformation is needed
249  if(kps!=kPSWQ2fE) {
250  double J = utils::kinematics::Jacobian(interaction,kPSWQ2fE,kps);
251  xsec *= J;
252  }
253 
254  //-- If requested return the free nucleon xsec even for input nuclear tgt
255  if( interaction->TestBit(kIAssumeFreeNucleon) ) return xsec;
256 
257  //-- number of scattering centers in the target
258  bool isp = pdg::IsProton(target.HitNucPdg());
259  int NNucl = (isp) ? target.Z() : target.N();
260 
261  xsec*=NNucl; // nuclear xsec (no nuclear suppression factor)
262 
263  return xsec;
264 }
265 //____________________________________________________________________________
267  const Interaction * interaction) const
268 {
269  double xsec = fXSecIntegrator->Integrate(this,interaction);
270  return xsec;
271 }
272 //____________________________________________________________________________
274  const Interaction * interaction) const
275 {
276  if(interaction->TestBit(kISkipProcessChk)) return true;
277  return true;
278 }
279 //____________________________________________________________________________
281 {
282  Algorithm::Configure(config);
283  this->LoadConfig();
284 }
285 //____________________________________________________________________________
287 {
288  Algorithm::Configure(config);
289  this->LoadConfig();
290 }
291 //____________________________________________________________________________
293 {
294  GetParam( "RES-Ma", fMa ) ;
295  GetParam( "RES-Mv", fMv ) ;
296 
297  double thc ;
298  GetParam( "CabibboAngle", thc ) ;
299  fCos28c = TMath::Power( TMath::Cos(thc), 2 );
300 
301  GetParamDef( "TurnOnPauliSuppr", fTurnOnPauliCorrection, false ) ;
302 
303  //-- load the differential cross section integrator
305  dynamic_cast<const XSecIntegratorI *> (this->SubAlg("XSec-Integrator"));
307 }
308 //____________________________________________________________________________
309 double P33PaschosLalakulichPXSec::Pauli(double Q2, double W, double MN) const
310 {
311 // Pauli suppression for deuterium with Fermi momentum 0.160 GeV
312 
313  // ---remove--- this value from here & ask GENIE for D2 Fermi momentum
314  double qF=0.160; /* 0.160 deuterium */
315 
316  double Paulii = 0;
317 
318  double p_pi_star = this->PPiStar(W,MN);
319  double nu_star = this->NuStar(Q2,W,MN);
320 
321  double p_pi_star_2 = TMath::Power(p_pi_star, 2);
322  double p_pi_star_4 = TMath::Power(p_pi_star_2, 2);
323  double nu_star_2 = TMath::Power(nu_star, 2);
324 
325  double q3 = TMath::Sqrt(Q2+nu_star_2);
326  double q6 = TMath::Power(q3,2);
327  double q12 = TMath::Power(q6,2);
328 
329  double qF2 = TMath::Power(qF,2);
330  double qF3 = TMath::Power(qF,3);
331 
332  if ( q3+p_pi_star < 2*qF )
333  {
334  Paulii = ( (3*q6 + p_pi_star_2)/2/qF
335  -(5*q12+p_pi_star_4 + 10*q6*p_pi_star_2)/40/qF3
336  )/2/q3;
337  }
338  if ( (q3+p_pi_star > 2*qF) && (q3-p_pi_star < 2*qF) )
339  {
340  double tmp1 = TMath::Power( q3+p_pi_star, 2 );
341  double tmp2 = TMath::Power( q3-p_pi_star, 3 );
342  double tmp3 = TMath::Power( q3-p_pi_star, 5 );
343 
344  Paulii = (tmp1-4.0*qF2/5.0 - tmp2/2/qF + tmp3/40/qF3)/4/p_pi_star/q3;
345  }
346  if ( q3-p_pi_star > 2*qF )
347  {
348  Paulii = 1;
349  }
350 
351  return Paulii;
352 }
353 //____________________________________________________________________________
354 double P33PaschosLalakulichPXSec::Nu(double Q2, double W, double MN) const
355 {
356  return (TMath::Power(W,2) - TMath::Power(MN,2) + Q2)/2/MN;
357 }
358 //____________________________________________________________________________
359 double P33PaschosLalakulichPXSec::PPiStar(double W, double MN) const
360 {
361  double W2 = TMath::Power(W,2);
362  double a = TMath::Power(MN+kPionMass,2);
363  double b = TMath::Power(MN-kPionMass,2);
364 
365  return TMath::Sqrt( (W2-a)*(W2-b) )/2/W;
366 }
367 //____________________________________________________________________________
368 double P33PaschosLalakulichPXSec::NuStar(double Q2, double W, double MN) const
369 {
370  return (TMath::Power(W,2) - TMath::Power(MN,2) - Q2)/2/W;
371 }
372 //____________________________________________________________________________
373 
374 
Cross Section Calculation Interface.
const double kPi
double W(bool selected=false) const
Definition: Kinematics.cxx:167
Basic constants.
const XML_Char * target
Definition: expat.h:268
double J(double q0, double q3, double Enu, double ml)
Definition: MECUtils.cxx:141
THE MAIN GENIE PROJECT NAMESPACE
Definition: GeneratorBase.h:8
double PPiStar(double W, double MN) const
...
Cross Section Integrator Interface.
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:991
int HitNucPdg(void) const
Definition: Target.cxx:321
double XSec(const Interaction *i, KinePhaseSpace_t k) const
Compute the cross section for the input interaction.
double HitNucMass(void) const
Definition: Target.cxx:250
constexpr T pow(T x)
Definition: pow.h:75
Generated/set kinematical variables for an event.
Definition: Kinematics.h:40
double Mass(Resonance_t res)
resonance mass (GeV)
double NuStar(double Q2, double W, double MN) const
...
Definition: config.py:1
double Width(Resonance_t res)
resonance width (GeV)
enum genie::EKinePhaseSpace KinePhaseSpace_t
virtual const Registry & GetConfig(void) const
Definition: Algorithm.cxx:254
double Nu(double Q2, double W, double MN) const
kinematic variables
double Pauli(double Q2, double W, double MN) const
Pauli suppression for D2.
Summary information for an interaction.
Definition: Interaction.h:56
virtual bool ValidKinematics(const Interaction *i) const
Is the input kinematical point a physically allowed one?
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:299
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:97
Float_t E
Definition: plot.C:20
const double a
static const double kMuonMass2
Definition: Constants.h:85
A Neutrino Interaction Target. Is a transparent encapsulation of quite different physical systems suc...
Definition: Target.h:41
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:70
int Z(void) const
Definition: Target.h:69
Double_t xsec[nknots]
Definition: testXsec.C:47
double Integral(const Interaction *i) const
RgStr GetString(RgKey key) const
Definition: Registry.cxx:496
int N(void) const
Definition: Target.h:70
bool ValidProcess(const Interaction *i) const
Can this cross section algorithm handle the input process?
static const double kPionMass
Definition: Constants.h:74
Var Sqrt(const Var &v)
Use to take sqrt of a var.
Definition: Var.cxx:326
A registry. Provides the container for algorithm configuration parameters.
Definition: Registry.h:66
const UInt_t kIAssumeFreeNucleon
Definition: Interaction.h:49
virtual double Integrate(const XSecAlgorithmI *model, const Interaction *interaction) const =0
const hit & b
Definition: hits.cxx:21
assert(nhit_max >=nhit_nbins)
double Jacobian(const Interaction *const i, KinePhaseSpace_t f, KinePhaseSpace_t t)
Definition: KineUtils.cxx:128
double Q2(bool selected=false) const
Definition: Kinematics.cxx:135
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 Target & Tgt(void) const
Definition: InitialState.h:67
static const double kGF2
Definition: Constants.h:60
void kinematics()
Definition: kinematics.C:10
#define W(x)
double ProbeE(RefFrame_t rf) const
const UInt_t kISkipProcessChk
if set, skip process validity checks
Definition: Interaction.h:47
Initial State information.
Definition: InitialState.h:49
#define pDEBUG
Definition: Messenger.h:64
static const double kPionMass2
Definition: Constants.h:87
const Algorithm * SubAlg(const RgKey &registry_key) const
Definition: Algorithm.cxx:353