SmithMonizQELCCPXSec.cxx
Go to the documentation of this file.
1 //____________________________________________________________________________
2 /*
3  Copyright (c) 2003-2017, GENIE Neutrino MC Generator Collaboration
4  For the full text of the license visit http://copyright.genie-mc.org
5  or see $GENIE/LICENSE
6 
7  Author: Igor Kakorin <kakorin@jinr.ru>, Joint Institute for Nuclear Research
8  adapted from fortran code provided by
9  Konstantin Kuzmin <kkuzmin@theor.jinr.ru>,
10  Joint Institute for Nuclear Research, Institute for Theoretical and Experimental Physics
11  Vladimir Lyubushkin,
12  Joint Institute for Nuclear Research
13  Vadim Naumov <vnaumov@theor.jinr.ru>,
14  Joint Institute for Nuclear Research
15  based on code of Costas Andreopoulos <costas.andreopoulos \at stfc.ac.uk>
16  University of Liverpool & STFC Rutherford Appleton Lab
17 
18  For the class documentation see the corresponding header file.
19 
20 */
21 //____________________________________________________________________________
22 #include <sstream>
23 
24 #include <TMath.h>
25 
26 
40 #include "Framework/Utils/Range1.h"
42 
43 using namespace genie;
44 using namespace genie::constants;
45 using namespace genie::utils;
46 using std::ostringstream;
47 
48 //____________________________________________________________________________
50 XSecAlgorithmI("genie::SmithMonizQELCCPXSec")
51 {
52 
53 }
54 //____________________________________________________________________________
56 XSecAlgorithmI("genie::SmithMonizQELCCPXSec", config)
57 {
58 
59 }
60 //____________________________________________________________________________
62 {
63 
64 }
65 //____________________________________________________________________________
67  const Interaction * interaction, KinePhaseSpace_t kps) const
68 {
69 
70  if(kps == kPSQ2fE) {
71  return this->dsQES_dQ2_SM(interaction);
72  }
73 
74  if(kps == kPSQ2vfE) {
75  return this->d2sQES_dQ2dv_SM(interaction);
76  }
77 
78  return 0;
79 
80 }
81 //____________________________________________________________________________
83 {
84  return fXSecIntegrator->Integrate(this,in);
85 
86 }
87 //____________________________________________________________________________
88 bool SmithMonizQELCCPXSec::ValidProcess(const Interaction * interaction) const
89 {
90  if(interaction->TestBit(kISkipProcessChk)) return true;
91 
92  const InitialState & init_state = interaction->InitState();
93  const ProcessInfo & proc_info = interaction->ProcInfo();
94 
95  if(!proc_info.IsQuasiElastic()) return false;
96 
97  int nuc = init_state.Tgt().HitNucPdg();
98  int nu = init_state.ProbePdg();
99 
100  bool isP = pdg::IsProton(nuc);
101  bool isN = pdg::IsNeutron(nuc);
102  bool isnu = pdg::IsNeutrino(nu);
103  bool isnub = pdg::IsAntiNeutrino(nu);
104 
105  bool prcok = proc_info.IsWeakCC() && ((isP&&isnub) || (isN&&isnu));
106  if(!prcok) return false;
107 
108  return true;
109 }
110 //____________________________________________________________________________
112 {
113  Algorithm::Configure(config);
114  this->LoadConfig();
115 }
116 //____________________________________________________________________________
118 {
119  Algorithm::Configure(config);
120 
121  Registry r( "SmithMonizQELCCPXSec_specific", false ) ;
122  r.Set("sm_utils_algo", RgAlg("genie::SmithMonizUtils","Default") ) ;
123 
125 
126  this->LoadConfig();
127 }
128 //____________________________________________________________________________
130 {
131 
132  // Cross section scaling factor
133  GetParamDef( "QEL-CC-XSecScale", fXSecScale, 1. ) ;
134 
135  double Vud;
136  GetParam( "CKM-Vud", Vud ) ;
137  fVud2 = TMath::Power( Vud, 2 );
138 
139  // load QEL form factors model
140  fFormFactorsModel = dynamic_cast<const QELFormFactorsModelI *> (
141  this->SubAlg("FormFactorsAlg"));
143  fFormFactors.SetModel(fFormFactorsModel); // <-- attach algorithm
144 
145  // load XSec Integrators
147  dynamic_cast<const XSecIntegratorI *> (this->SubAlg("XSec-Integrator"));
149 
150  sm_utils = const_cast<genie::SmithMonizUtils *>(
151  dynamic_cast<const genie::SmithMonizUtils *>(
152  this -> SubAlg( "sm_utils_algo" ) ) ) ;
153 
154 }
155 //____________________________________________________________________________
156 double SmithMonizQELCCPXSec::d3sQES_dQ2dvdkF_SM(const Interaction * interaction) const
157 {
158  // Get kinematics & init-state parameters
159  const Kinematics & kinematics = interaction -> Kine();
160 
161  double kF = kinematics.GetKV(kKVPn);
162  double kkF = kF*kF;
163  double P_Fermi, E_nuBIN;
164 
165  E_nuBIN = sm_utils->GetBindingEnergy();
166 
167  double E_p = TMath::Sqrt(fmm_ini+kkF)-E_nuBIN;
168  double cosT_p = ((fv-E_nuBIN)*(2*E_p+fv+E_nuBIN)-fqqv+fmm_ini-fmm_fin)/(2*kF*fqv); //\cos\theta_p
169  double pF = TMath::Sqrt(kkF+(2*kF*fqv)*cosT_p+fqqv);
170  double b2_flux = (E_p-kF*fcosT_k*cosT_p)*(E_p-kF*fcosT_k*cosT_p);
171  double c2_flux = kkF*(1-cosT_p*cosT_p)*(1-fcosT_k*fcosT_k);
172 
173  P_Fermi = sm_utils->GetFermiMomentum();
174  double FV_SM = 4.0*TMath::Pi()/3*TMath::Power(P_Fermi, 3);
175  double factor = fk1*(fm_tar*kF/(FV_SM*fqv*TMath::Sqrt(b2_flux-c2_flux)))*SmithMonizUtils::rho(P_Fermi, 0.0, kF)*(1-SmithMonizUtils::rho(P_Fermi, 0.01, pF));
176 
177  double a2 = kkF/kNucleonMass2;
178  double a3 = a2*cosT_p*cosT_p;
179  double a6 = kF*cosT_p/kNucleonMass;
180  double a7 = E_p/kNucleonMass;
181  double a4 = a7*a7;
182  double a5 = 2*a7*a6;
183 
184  double k3 = fv/fqv;
185  double k4 = (3*a3-a2)/fqqv;
186  double k5 = (a7-a6*k3)*fm_tar/kNucleonMass;
187 
188  double T_1 = 1.0*fW_1+(a2-a3)*0.5*fW_2; //Ref.[1], W_1
189  double T_2 = ((a2-a3)*fQ2/(2*fqqv)+a4-k3*(a5-k3*a3))*fW_2; //Ref.[1], W_2
190  double T_3 = k5*fW_3; //Ref.[1], W_8
191  double T_4 = fmm_tar*(0.5*fW_2*k4+1.0*fW_4/kNucleonMass2+a6*fW_5/(kNucleonMass*fqv)); //Ref.[1], W_\alpha
192  double T_5 = k5*fW_5+fm_tar*(a5/fqv-fv*k4)*fW_2;
193 
194  double xsec = kGF2*factor*((fE_lep-fk7)*(T_1+fk2*T_4)/fm_tar+(fE_lep+fk7)*T_2/(2*fm_tar)
195  +fn_NT*T_3*((fE_nu+fE_lep)*(fE_lep-fk7)/(2*fmm_tar)-fk2)-fk2*T_5)
196  *(kMw2/(kMw2+fQ2))*(kMw2/(kMw2+fQ2))/fE_nu/kPi;
197  return xsec;
198 
199 
200 }
201 //____________________________________________________________________________
202 double SmithMonizQELCCPXSec::d2sQES_dQ2dv_SM(const Interaction * interaction) const
203 {
204  Kinematics * kinematics = interaction -> KinePtr();
205  sm_utils->SetInteraction(interaction);
206  fQ2 = kinematics->GetKV(kKVQ2);
207  fv = kinematics->GetKV(kKVv);
209 
210  const InitialState & init_state = interaction -> InitState();
211  const Target & target = init_state.Tgt();
212  PDGLibrary * pdglib = PDGLibrary::Instance();
213 
214  // One of the xsec terms changes sign for antineutrinos
215  bool is_neutrino = pdg::IsNeutrino(init_state.ProbePdg());
216  fn_NT = (is_neutrino) ? +1 : -1;
217 
218  int nucl_pdg_ini = target.HitNucPdg();
219  double m_ini = target.HitNucMass();
220  fmm_ini = TMath::Power(m_ini, 2);
221  int nucl_pdg_fin = genie::pdg::SwitchProtonNeutron(nucl_pdg_ini);
222  TParticlePDG * nucl_fin = pdglib->Find( nucl_pdg_fin );
223  double m_fin = nucl_fin -> Mass(); // Mass of final hadron or hadron system (GeV)
224  fmm_fin = TMath::Power(m_fin, 2);
225  fm_tar = target.Mass(); // Mass of target nucleus (GeV)
226  fmm_tar = TMath::Power(fm_tar, 2);
227 
228  fE_nu = init_state.ProbeE(kRfLab);
229  fE_lep = fE_nu-fv;
230  double m_lep = interaction->FSPrimLepton()->Mass();
231  double mm_lep = m_lep*m_lep;
232  double P_lep = TMath::Sqrt(fE_lep*fE_lep-mm_lep);
233  double k6 = (fQ2+mm_lep)/(2*fE_nu);
234  double cosT_lep= (fE_lep-k6)/P_lep;
235 
236  //|\vec{q}|
237  fqqv = fv*fv+fQ2;
238  fqv = TMath::Sqrt(fqqv);
239  fcosT_k = (fv+k6)/fqv;
240 
242  fk2 = mm_lep/(2*fmm_tar);
243  fk7 = P_lep*cosT_lep;
244 
245 
246  // Calculate the QEL form factors
247  fFormFactors.Calculate(interaction);
248  fF_V = fFormFactors.F1V();
249  fF_M = fFormFactors.xiF2V();
250  fF_A = fFormFactors.FA();
251  fF_P = fFormFactors.Fp();
252  fFF_V = fF_V*fF_V;
253  fFF_M = fF_M*fF_M;
254  fFF_A = fF_A*fF_A;
255 
256  double t = fQ2/(4*kNucleonMass2);
257  fW_1 = fFF_A*(1+t)+t*(fF_V+fF_M)*(fF_V+fF_M); //Ref.[1], \tilde{T}_1
258  fW_2 = fFF_A+fFF_V+t*fFF_M; //Ref.[1], \tilde{T}_2
259  fW_3 =-2*fF_A*(fF_V+fF_M); //Ref.[1], \tilde{T}_8
260  fW_4 =-0.5*fF_V*fF_M-fF_A*fF_P+t*fF_P*fF_P-0.25*(1-t)*fFF_M; //Ref.[1], \tilde{T}_\alpha
261  fW_5 = fFF_V+t*fFF_M+fFF_A;
262 
263 // Gaussian quadratures integrate over Fermi momentum
264  double R[48]= { 0.16276744849602969579e-1,0.48812985136049731112e-1,
265  0.81297495464425558994e-1,1.13695850110665920911e-1,
266  1.45973714654896941989e-1,1.78096882367618602759e-1,
267  2.10031310460567203603e-1,2.41743156163840012328e-1,
268  2.73198812591049141487e-1,3.04364944354496353024e-1,
269  3.35208522892625422616e-1,3.65696861472313635031e-1,
270  3.95797649828908603285e-1,4.25478988407300545365e-1,
271  4.54709422167743008636e-1,4.83457973920596359768e-1,
272  5.11694177154667673586e-1,5.39388108324357436227e-1,
273  5.66510418561397168404e-1,5.93032364777572080684e-1,
274  6.18925840125468570386e-1,6.44163403784967106798e-1,
275  6.68718310043916153953e-1,6.92564536642171561344e-1,
276  7.15676812348967626225e-1,7.38030643744400132851e-1,
277  7.59602341176647498703e-1,7.80369043867433217604e-1,
278  8.00308744139140817229e-1,8.19400310737931675539e-1,
279  8.37623511228187121494e-1,8.54959033434601455463e-1,
280  8.71388505909296502874e-1,8.86894517402420416057e-1,
281  9.01460635315852341319e-1,9.15071423120898074206e-1,
282  9.27712456722308690965e-1,9.39370339752755216932e-1,
283  9.50032717784437635756e-1,9.59688291448742539300e-1,
284  9.68326828463264212174e-1,9.75939174585136466453e-1,
285  9.82517263563014677447e-1,9.88054126329623799481e-1,
286  9.92543900323762624572e-1,9.95981842987209290650e-1,
287  9.98364375863181677724e-1,9.99689503883230766828e-1};
288 
289  double W[48]= { 0.00796792065552012429e-1,0.01853960788946921732e-1,
290  0.02910731817934946408e-1,0.03964554338444686674e-1,
291  0.05014202742927517693e-1,0.06058545504235961683e-1,
292  0.07096470791153865269e-1,0.08126876925698759217e-1,
293  0.09148671230783386633e-1,0.10160770535008415758e-1,
294  0.11162102099838498591e-1,0.12151604671088319635e-1,
295  0.13128229566961572637e-1,0.14090941772314860916e-1,
296  0.15038721026994938006e-1,0.15970562902562291381e-1,
297  0.16885479864245172450e-1,0.17782502316045260838e-1,
298  0.18660679627411467395e-1,0.19519081140145022410e-1,
299  0.20356797154333324595e-1,0.21172939892191298988e-1,
300  0.21966644438744349195e-1,0.22737069658329374001e-1,
301  0.23483399085926219842e-1,0.24204841792364691282e-1,
302  0.24900633222483610288e-1,0.25570036005349361499e-1,
303  0.26212340735672413913e-1,0.26826866725591762198e-1,
304  0.27412962726029242823e-1,0.27970007616848334440e-1,
305  0.28497411065085385646e-1,0.28994614150555236543e-1,
306  0.29461089958167905970e-1,0.29896344136328385984e-1,
307  0.30299915420827593794e-1,0.30671376123669149014e-1,
308  0.31010332586313837423e-1,0.31316425596861355813e-1,
309  0.31589330770727168558e-1,0.31828758894411006535e-1,
310  0.32034456231992663218e-1,0.32206204794030250669e-1,
311  0.32343822568575928429e-1,0.32447163714064269364e-1,
312  0.32516118713868835987e-1,0.32550614492363166242e-1};
313 
314  double Sum = 0;
315  for(int i = 0;i<48;i++)
316  {
317  double kF = 0.5*(-R[i]*(rkF.max-rkF.min)+rkF.min+rkF.max);
318  kinematics->SetKV(kKVPn, kF);
319  Sum+=d3sQES_dQ2dvdkF_SM(interaction)*W[47-i];
320  kF = 0.5*(R[i]*(rkF.max-rkF.min)+rkF.min+rkF.max);
321  kinematics->SetKV(kKVPn, kF);
322  Sum+=d3sQES_dQ2dvdkF_SM(interaction)*W[47-i];
323  }
324 
325  double xsec = 0.5*Sum*(rkF.max-rkF.min);
326 
327  int nucpdgc = target.HitNucPdg();
328  int NNucl = (pdg::IsProton(nucpdgc)) ? target.Z() : target.N();
329 
330  xsec *= NNucl; // nuclear xsec
331 
332  // Apply given scaling factor
333  xsec *= fXSecScale;
334 
335  return xsec;
336 
337 }
338 //____________________________________________________________________________
339 double SmithMonizQELCCPXSec::dsQES_dQ2_SM(const Interaction * interaction) const
340 {
341  // Get kinematics & init-state parameters
342  const Kinematics & kinematics = interaction -> Kine();
343  const InitialState & init_state = interaction -> InitState();
344  const Target & target = init_state.Tgt();
345 
346  double E = init_state.ProbeE(kRfHitNucRest);
347  double E2 = TMath::Power(E,2);
348  double ml = interaction->FSPrimLepton()->Mass();
349  double M = target.HitNucMass();
350  double q2 = kinematics.q2();
351 
352  // One of the xsec terms changes sign for antineutrinos
353  bool is_neutrino = pdg::IsNeutrino(init_state.ProbePdg());
354  int sign = (is_neutrino) ? -1 : 1;
355 
356  // Calculate the QEL form factors
357  fFormFactors.Calculate(interaction);
358 
359  double F1V = fFormFactors.F1V();
360  double xiF2V = fFormFactors.xiF2V();
361  double FA = fFormFactors.FA();
362  double Fp = fFormFactors.Fp();
363 
364 
365  // Calculate auxiliary parameters
366  double ml2 = TMath::Power(ml, 2);
367  double M2 = TMath::Power(M, 2);
368  double M4 = TMath::Power(M2, 2);
369  double FA2 = TMath::Power(FA, 2);
370  double Fp2 = TMath::Power(Fp, 2);
371  double F1V2 = TMath::Power(F1V, 2);
372  double xiF2V2 = TMath::Power(xiF2V, 2);
373  double Gfactor = M2*kGF2*fVud2*(kMw2/(kMw2-q2))*(kMw2/(kMw2-q2)) / (8*kPi*E2);
374  double s_u = 4*E*M + q2 - ml2;
375  double q2_M2 = q2/M2;
376 
377  // Compute free nucleon differential cross section
378  double A = (0.25*(ml2-q2)/M2) * (
379  (4-q2_M2)*FA2 - (4+q2_M2)*F1V2 - q2_M2*xiF2V2*(1+0.25*q2_M2)
380  -4*q2_M2*F1V*xiF2V - (ml2/M2)*(
381  (F1V2+xiF2V2+2*F1V*xiF2V)+(FA2+4*Fp2+4*FA*Fp)+(q2_M2-4)*Fp2));
382  double B = -1 * q2_M2 * FA*(F1V+xiF2V);
383  double C = 0.25*(FA2 + F1V2 - 0.25*q2_M2*xiF2V2);
384 
385  double xsec = Gfactor * (A + sign*B*s_u/M2 + C*s_u*s_u/M4);
386 
387  // Apply given scaling factor
388  xsec *= fXSecScale;
389 
390  // Deuterium and tritium is a special case
391  if (target.A()>1 && target.A()<4)
392  {
393  double Q2 = -q2;
394  double fQES_Pauli = 1.0-0.529*TMath::Exp((Q2*(228.0-531.0*Q2)-48.0)*Q2);
395  xsec *= fQES_Pauli;
396  }
397 
398  int nucpdgc = target.HitNucPdg();
399  int NNucl = (pdg::IsProton(nucpdgc)) ? target.Z() : target.N();
400 
401  xsec *= NNucl; // nuclear xsec
402 
403  // Apply radiative correction to the cross section for IBD processes
404  // Refs:
405  // 1) I.S. Towner, Phys. Rev. C 58 (1998) 1288;
406  // 2) J.F. Beacom, S.J. Parke, Phys. Rev. D 64 (2001) 091302;
407  // 3) A. Kurylov, M.J. Ramsey-Musolf, P. Vogel, Phys. Rev. C 65 (2002) 055501;
408  // 4) A. Kurylov, M.J. Ramsey-Musolf, P. Vogel, Phys. Rev. C 67 (2003) 035502.
409  double rc = 1.0;
410  if ( (target.IsProton() && pdg::IsAntiNuE(init_state.ProbePdg())) || (target.IsNeutron() && pdg::IsNuE(init_state.ProbePdg()) ))
411  {
412  const double mp = kProtonMass;
413  const double mp2 = kProtonMass2;
414  const double mn2 = kNeutronMass2;
415  const double Ee = E + ( (q2 - mn2 + mp2) / 2.0 / mp );
416  assert(Ee > 0.0); // must be non-zero and positive
417  rc = 6.0 + (1.5 * TMath::Log(kProtonMass / 2.0 / Ee));
418  rc += 1.2 * TMath::Power((kElectronMass / Ee), 1.5);
419  rc *= kAem / kPi;
420  rc += 1.0;
421  }
422 
423  xsec *= rc;
424  return xsec;
425 }
426 
void SetInteraction(const Interaction *i)
Cross Section Calculation Interface.
const double kPi
Basic constants.
TH1F * a3
Definition: f2_nu.C:606
bool IsWeakCC(void) const
bool IsNeutrino(int pdgc)
Definition: PDGUtils.cxx:108
const XML_Char * target
Definition: expat.h:268
TH1F * a2
Definition: f2_nu.C:545
static const double kMw2
Definition: Constants.h:94
THE MAIN GENIE PROJECT NAMESPACE
Definition: GeneratorBase.h:8
Cross Section Integrator Interface.
static const double kNucleonMass
Definition: Constants.h:78
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:991
int HitNucPdg(void) const
Definition: Target.cxx:321
void Configure(const Registry &config)
bool IsNeutron(void) const
Definition: Target.cxx:284
double Integral(const Interaction *i) const
double fXSecScale
external xsec scaling factor
int A(void) const
Definition: Target.h:71
A simple [min,max] interval for doubles.
Definition: Range1.h:43
void SetModel(const QELFormFactorsModelI *model)
Attach an algorithm.
bool IsQuasiElastic(void) const
Definition: ProcessInfo.cxx:67
double HitNucMass(void) const
Definition: Target.cxx:250
double d2sQES_dQ2dv_SM(const Interaction *i) const
Generated/set kinematical variables for an event.
Definition: Kinematics.h:40
bool IsNuE(int pdgc)
Definition: PDGUtils.cxx:150
int SwitchProtonNeutron(int pdgc)
Definition: PDGUtils.cxx:319
double d3sQES_dQ2dvdkF_SM(const Interaction *interaction) const
double Mass(Resonance_t res)
resonance mass (GeV)
Definition: config.py:1
enum genie::EKinePhaseSpace KinePhaseSpace_t
double Mass(void) const
Definition: Target.cxx:241
static const double kElectronMass
Definition: Constants.h:71
double GetBindingEnergy(void) const
static const double kAem
Definition: Constants.h:57
Double_t q2[12][num]
Definition: f2_nu.C:137
const double C
bool IsNeutron(int pdgc)
Definition: PDGUtils.cxx:304
Summary information for an interaction.
Definition: Interaction.h:56
Range1D_t kFQES_SM_lim(double nu, double Q2) const
double q2(bool selected=false) const
Definition: Kinematics.cxx:151
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:299
Pure abstract base class. Defines the QELFormFactorsModelI interface to be implemented by any algorit...
Float_t E
Definition: plot.C:20
A class encapsulating an enumeration of interaction types (EM, Weak-CC, Weak-NC) and scattering types...
Definition: ProcessInfo.h:44
bool IsAntiNeutrino(int pdgc)
Definition: PDGUtils.cxx:116
const QELFormFactorsModelI * fFormFactorsModel
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 ProbePdg(void) const
Definition: InitialState.h:65
TString mp
Definition: loadincs.C:4
#define R(x)
int Z(void) const
Definition: Target.h:69
double GetKV(KineVar_t kv) const
Definition: Kinematics.cxx:333
double XSec(const Interaction *i, KinePhaseSpace_t kps) const
Compute the cross section for the input interaction.
static const double kNucleonMass2
Definition: Constants.h:90
double xiF2V(void) const
Get the computed form factor xi*F2V.
Double_t xsec[nknots]
Definition: testXsec.C:47
TParticlePDG * FSPrimLepton(void) const
final state primary lepton
void Calculate(const Interaction *interaction)
Compute the form factors for the input interaction using the attached model.
void SetKV(KineVar_t kv, double value)
Definition: Kinematics.cxx:345
const XSecIntegratorI * fXSecIntegrator
static const double A
Definition: Units.h:82
double max
Definition: Range1.h:54
ifstream in
Definition: comparison.C:7
int N(void) const
Definition: Target.h:70
static PDGLibrary * Instance(void)
Definition: PDGLibrary.cxx:43
Contains auxiliary functions for Smith-Moniz model. Is a concrete implementation of the XSecAlgorit...
static double rho(double P_Fermi, double T_Fermi, double p)
Singleton class to load & serve a TDatabasePDG.
Definition: PDGLibrary.h:30
Var Sqrt(const Var &v)
Use to take sqrt of a var.
Definition: Var.cxx:326
bool ValidProcess(const Interaction *i) const
Can this cross section algorithm handle the input process?
A registry. Provides the container for algorithm configuration parameters.
Definition: Registry.h:66
double fVud2
|Vud|^2(square of magnitude ud-element of CKM-matrix)
TParticlePDG * Find(int pdgc)
Definition: PDGLibrary.cxx:61
virtual double Integrate(const XSecAlgorithmI *model, const Interaction *interaction) const =0
TH1F * a4
Definition: f2_nu.C:666
assert(nhit_max >=nhit_nbins)
TRandom3 r(0)
const InitialState & InitState(void) const
Definition: Interaction.h:69
const ProcessInfo & ProcInfo(void) const
Definition: Interaction.h:70
double min
Definition: Range1.h:53
double F1V(void) const
Get the computed form factor F1V.
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
double dsQES_dQ2_SM(const Interaction *interaction) const
static const double kProtonMass2
Definition: Constants.h:88
static const double kGF2
Definition: Constants.h:60
double Fp(void) const
Get the computed form factor Fp.
static const double kNeutronMass2
Definition: Constants.h:89
void kinematics()
Definition: kinematics.C:10
void Set(RgIMapPair entry)
Definition: Registry.cxx:282
#define W(x)
bool IsProton(void) const
Definition: Target.cxx:279
double ProbeE(RefFrame_t rf) const
double FA(void) const
Get the computed form factor FA.
bool IsAntiNuE(int pdgc)
Definition: PDGUtils.cxx:165
static const double kProtonMass
Definition: Constants.h:76
Root of GENIE utility namespaces.
def sign(x)
Definition: canMan.py:197
const UInt_t kISkipProcessChk
if set, skip process validity checks
Definition: Interaction.h:47
double GetFermiMomentum(void) const
Initial State information.
Definition: InitialState.h:49
const Algorithm * SubAlg(const RgKey &registry_key) const
Definition: Algorithm.cxx:353