QPMDMDISPXSec.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: Joshua Berger <jberger \at physics.wisc.edu>
8  University of Wisconsin-Madison
9 
10  Costas Andreopoulos <costas.andreopoulos \at stfc.ac.uk>
11  University of Liverpool & STFC Rutherford Appleton Lab
12 */
13 //____________________________________________________________________________
14 
15 #include <sstream>
16 
17 #include <TMath.h>
18 #include <TH1D.h>
19 
35 #include "Framework/Utils/RunOpt.h"
38 #include "Framework/Utils/Range1.h"
40 #include "Framework/Utils/Cache.h"
42 
43 using std::ostringstream;
44 
45 using namespace genie;
46 using namespace genie::constants;
47 //using namespace genie::units;
48 
49 //____________________________________________________________________________
51 XSecAlgorithmI("genie::QPMDMDISPXSec")
52 {
53  fInInitPhase = true;
54 }
55 //____________________________________________________________________________
57 XSecAlgorithmI("genie::QPMDMDISPXSec", config)
58 {
59  fInInitPhase = true;
60 }
61 //____________________________________________________________________________
63 {
64 
65 }
66 //____________________________________________________________________________
68  const Interaction * interaction, KinePhaseSpace_t kps) const
69 {
70  if(! this -> ValidProcess (interaction) ) return 0.;
71  if(! this -> ValidKinematics (interaction) ) return 0.;
72 
73  // Get kinematical & init-state parameters
74  const Kinematics & kinematics = interaction -> Kine();
75  const InitialState & init_state = interaction -> InitState();
76  // const ProcessInfo & proc_info = interaction -> ProcInfo(); // comment-out unused variable to eliminate warnings
77 
78  LOG("DMDISPXSec", pDEBUG) << "Using v^" << fVelMode << " dependence";
79 
80  double E = init_state.ProbeE(kRfHitNucRest);
81  double ml = interaction->FSPrimLepton()->Mass();
82  double Mnuc = init_state.Tgt().HitNucMass();
83  double x = kinematics.x();
84  double y = kinematics.y();
85 
86  double E2 = E * E;
87  double ml2 = ml * ml;
88  // double ml4 = ml2 * ml2; // comment-out unused variable to eliminate warnings
89  // double Mnuc2 = Mnuc * Mnuc; // comment-out unused variable to eliminate warnings
90 
91  #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
92  LOG("DMDISPXSec", pDEBUG)
93  << "Computing d2xsec/dxdy @ E = " << E << ", x = " << x << ", y = " << y;
94  #endif
95 
96  // One of the xsec terms changes sign for antineutrinos @ DMDIS/CC
97 
98  // bool is_nubar_cc = pdg::IsAntiNeutrino(init_state.ProbePdg()) &&
99  // proc_info.IsWeakCC(); // // comment-out unused variable to eliminate warnings
100  // int sign = (is_nubar_cc) ? -1 : 1; // comment-out unused variable to eliminate warnings
101 
102  // Calculate the DMDIS structure functions
103  fDISSF.Calculate(interaction);
104 
105  #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
106  LOG("DMDISPXSec", pDEBUG) << fDISSF;
107  #endif
108 
109  //
110  // Compute the differential cross section
111  //
112 
113  double g2 = kGF2;
114  // For EM interaction replace G_{Fermi} with :
115  // a_{em} * pi / ( sqrt(2) * sin^2(theta_weinberg) * Mass_{W}^2 }
116  // See C.Quigg, Gauge Theories of the Strong, Weak and E/M Interactions,
117  // ISBN 0-8053-6021-2, p.112 (6.3.57)
118  // Also, take int account that the photon propagator is 1/p^2 but the
119  // W propagator is 1/(p^2-Mass_{W}^2), so weight the EM case with
120  // Mass_{W}^4 / q^4
121  // So, overall:
122  // G_{Fermi}^2 --> a_{em}^2 * pi^2 / (2 * sin^4(theta_weinberg) * q^{4})
123  //
124  double Q2 = utils::kinematics::XYtoQ2(E,Mnuc,x,y);
125  // double Q4 = Q2*Q2; // comment-out unused variable to eliminate warnings
126  // temp: set the Z' mass to MZ and g' = 1 for now
127  LOG("DMDISPXSec", pDEBUG)
128  << "Using a mediator mass " << fMedMass;
129  double Mzp2 = TMath::Power(fMedMass,2);
130  // double gzp = RunOpt::Instance()->ZpCoupling();
131  double gzp = fgzp;
132  double gzp4 = TMath::Power(gzp,4);
133  g2 = gzp4 / TMath::Power((Q2 + Mzp2), 2);
134  double p2 = TMath::Max(E2 - ml2,0.);
135  double front_factor = (g2*Mnuc*E) / kPi * (E2 / p2);
136 
137  // Build all dxsec/dxdy terms
138  double term1 = 0.;
139  double term2 = 0.;
140  double term3 = 0.;
141  double term4 = 0.;
142  double term5 = 0.;
143  // The cross-check of these expressions is that they should
144  // give the elastic cross-section in the limit x -> 1, PDF -> 1,
145  // and absent nuclear effects
146  switch (fVelMode) {
147  case 0:
148  // Second lines contain longitudinal Z' coupling
149  // If the mediator is relatively light, these terms are important
150  // and can't be neglected like they are in the SM
151  term1 = 0.125 * y * ( x*y + 3.*ml2/(E*Mnuc) );
152  term1 += ml2*x*y*y/(2*Mzp2) * (1. + Mnuc*E*x*y / Mzp2);
153  term2 = 0.125 * (1 - y - Mnuc*x*y/(2*E) - ml2/E2);
154  term2 += ml2*y*y/(4*Mzp2) * (1. + Mnuc*E*x*y / Mzp2);
155  term4 = x*y*ml2/(4*Mnuc*E);
156  term4 += ml2*x*x*y*y/Mzp2 * (1. + Mnuc*E*x*y / Mzp2);
157  term5 = -y*ml2/(8*Mnuc*E);
158  term5 += -ml2*x*y*y/(2*Mzp2) * (1. + Mnuc*E*x*y / Mzp2);
159  break;
160  case 2:
161  // Scalar case has no longitudinal Z' coupling
162  term1 = -0.125 * y * (0.5 * x * y + ml2/(E*Mnuc));
163  term2 = 0.125 * (1. - y + 0.25 * y * y);
164  }
165 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
166  LOG("DMDISPXSec", pDEBUG)
167  << "\nd2xsec/dxdy ~ (" << term1 << ")*F1+(" << term2 << ")*F2+("
168  << term3 << ")*F3+(" << term4 << ")*F4+(" << term5 << ")*F5";
169 #endif
170 
171  term1 *= fDISSF.F1();
172  term2 *= fDISSF.F2();
173  term3 *= fDISSF.F3();
174  term4 *= fDISSF.F4();
175  term5 *= fDISSF.F5();
176 
177  LOG("DMDISPXSec", pDEBUG)
178  << "\nd2xsec/dxdy ~ (" << term1 << ")+(" << term2 << ")+("
179  << term3 << ")+(" << term4 << ")+(" << term5 << ")";
180 
181 
182  double xsec = front_factor * (term1 + term2 + term3 + term4 + term5);
183  xsec = TMath::Max(xsec,0.);
184 
185 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
186  LOG("DMDISPXSec", pINFO)
187  << "d2xsec/dxdy[FreeN] (E= " << E
188  << ", x= " << x << ", y= " << y << ") = " << xsec;
189 #endif
190 
191  // If the DMDIS/RES joining scheme is enabled, modify the xsec accordingly
192  if(fUsingDisResJoin) {
193  double R = this->DMDISRESJoinSuppressionFactor(interaction);
194  xsec*=R;
195  #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
196  LOG("DMDISPXSec", pINFO) << "D/R Join scheme - suppression factor R = " << R;;
197  LOG("DMDISPXSec", pINFO) << "d2xsec/dxdy[FreeN, D/R Join] " << xsec;
198  #endif
199  }
200 
201  // The algorithm computes d^2xsec/dxdy
202  // Check whether variable tranformation is needed
203  if(kps!=kPSxyfE) {
204  double J = utils::kinematics::Jacobian(interaction,kPSxyfE,kps);
205  xsec *= J;
206  }
207 
208  // If requested return the free nucleon xsec even for input nuclear tgt
209  if( interaction->TestBit(kIAssumeFreeNucleon) ) return xsec;
210 
211  // Compute nuclear cross section (simple scaling here, corrections must
212  // have been included in the structure functions)
213  const Target & target = init_state.Tgt();
214  int nucpdgc = target.HitNucPdg();
215  int NNucl = (pdg::IsProton(nucpdgc)) ? target.Z() : target.N();
216  xsec *= NNucl;
217 
218  // Apply scaling / if required to reach well known asymmptotic value
219  xsec *= fScale;
220 
221  // Subtract the inclusive charm production cross section
222  interaction->ExclTagPtr()->SetCharm();
223  double xsec_charm = fCharmProdModel->XSec(interaction,kps);
224  interaction->ExclTagPtr()->UnsetCharm();
225 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
226  LOG("DMDISPXSec", pINFO)
227  << "Subtracting charm piece: " << xsec_charm << " / out of " << xsec;
228 #endif
229  xsec = TMath::Max(0., xsec-xsec_charm);
230  return xsec;
231 }
232 //____________________________________________________________________________
233 double QPMDMDISPXSec::Integral(const Interaction * interaction) const
234 {
235  double xsec = fXSecIntegrator->Integrate(this,interaction);
236  return xsec;
237 }
238 //____________________________________________________________________________
239 bool QPMDMDISPXSec::ValidProcess(const Interaction * interaction) const
240 {
241  if(interaction->TestBit(kISkipProcessChk)) return true;
242 
243  const ProcessInfo & proc_info = interaction->ProcInfo();
244  if(!proc_info.IsDarkMatterDeepInelastic()) return false;
245 
246  const InitialState & init_state = interaction -> InitState();
247  int probe_pdg = init_state.ProbePdg();
248  if(!pdg::IsDarkMatter(probe_pdg)) return false;
249 
250  if(! init_state.Tgt().HitNucIsSet()) return false;
251 
252  int hitnuc_pdg = init_state.Tgt().HitNucPdg();
253  if(!pdg::IsNeutronOrProton(hitnuc_pdg)) return false;
254 
255  return true;
256 }
257 //____________________________________________________________________________
259  const Interaction * in) const
260 {
261 // Computes suppression factors for the DMDIS xsec under the used DMDIS/RES join
262 // scheme. Since this is a 'low-level' algorithm that is being called many
263 // times per generated event or computed cross section spline, the suppression
264 // factors would be cached to avoid calling the hadronization model too often.
265 //
266  double R=0, Ro=0;
267 
268  const double Wmin = kNeutronMass + kPionMass + 1E-3;
269 
270  const InitialState & ist = in->InitState();
271  const ProcessInfo & pi = in->ProcInfo();
272 
273  double E = ist.ProbeE(kRfHitNucRest);
274  double Mnuc = ist.Tgt().HitNucMass();
275  double x = in->Kine().x();
276  double y = in->Kine().y();
277  double Wo = utils::kinematics::XYtoW(E,Mnuc,x,y);
278 
279  TH1D * mprob = 0;
280 
281  if(!fUseCache) {
282  // ** Compute the reduction factor at each call - no caching
283  //
284  mprob = fHadronizationModel->MultiplicityProb(in,"+LowMultSuppr");
285  R = 1;
286  if(mprob) {
287  R = mprob->Integral("width");
288  delete mprob;
289  }
290  }
291  else {
292 
293  // ** Precompute/cache the reduction factors and then use the
294  // ** cache to evaluate these factors
295 
296  // Access the cache branch. The branch key is formed as:
297  // algid/DMDIS-RES-Join/nu-pdg:N;hit-nuc-pdg:N/inttype
298  Cache * cache = Cache::Instance();
299  string algkey = this->Id().Key() + "/DMDIS-RES-Join";
300 
301  ostringstream ikey;
302  ikey << "nu-pdgc:" << ist.ProbePdg()
303  << ";hit-nuc-pdg:"<< ist.Tgt().HitNucPdg() << "/"
304  << pi.InteractionTypeAsString();
305 
306  string key = cache->CacheBranchKey(algkey, ikey.str());
307 
308  CacheBranchFx * cbr =
309  dynamic_cast<CacheBranchFx *> (cache->FindCacheBranch(key));
310 
311  // If it does't exist then create a new one
312  // and cache DMDIS xsec suppression factors
313  bool non_zero=false;
314  if(!cbr) {
315  LOG("DMDISXSec", pNOTICE)
316  << "\n ** Creating cache branch - key = " << key;
317 
318  cbr = new CacheBranchFx("DMDIS Suppr. Factors in DMDIS/RES Join Scheme");
319  Interaction interaction(*in);
320 
321  const int kN = 300;
322  double WminSpl = Wmin;
323  double WmaxSpl = fWcut + 0.1; // well into the area where scaling factor = 1
324  double dW = (WmaxSpl-WminSpl)/(kN-1);
325 
326  for(int i=0; i<kN; i++) {
327  double W = WminSpl+i*dW;
328  interaction.KinePtr()->SetW(W);
329  mprob = fHadronizationModel->MultiplicityProb(&interaction,"+LowMultSuppr");
330  R = 1;
331  if(mprob) {
332  R = mprob->Integral("width");
333  delete mprob;
334  }
335  // make sure that it takes enough samples where it is non-zero:
336  // modify the step and the sample counter once I've hit the first
337  // non-zero value
338  if(!non_zero && R>0) {
339  non_zero=true;
340  WminSpl=W;
341  i = 0;
342  dW = (WmaxSpl-WminSpl)/(kN-1);
343  }
344  LOG("DMDISXSec", pNOTICE)
345  << "Cached DMDIS XSec Suppr. factor (@ W=" << W << ") = " << R;
346 
347  cbr->AddValues(W,R);
348  }
349  cbr->CreateSpline();
350 
351  cache->AddCacheBranch(key, cbr);
352  assert(cbr);
353  } // cache data
354 
355  // get the reduction factor from the cache branch
356  if(Wo > Wmin && Wo < fWcut-1E-2) {
357  const CacheBranchFx & cache_branch = (*cbr);
358  R = cache_branch(Wo);
359  }
360  }
361 
362  // Now return the suppression factor
363  if (Wo > Wmin && Wo < fWcut-1E-2) Ro = R;
364  else if (Wo <= Wmin) Ro = 0.0;
365  else Ro = 1.0;
366 
367  LOG("DMDISXSec", pDEBUG)
368  << "DMDIS/RES Join: DMDIS xsec suppr. (W=" << Wo << ") = " << Ro;
369 
370  return Ro;
371 }
372 //____________________________________________________________________________
374 {
375  Algorithm::Configure(config);
376  this->LoadConfig();
377 }
378 //____________________________________________________________________________
380 {
381  Algorithm::Configure(config);
382 
383  Registry r( "QPMDMDISPXSec_specific", false ) ;
384 
385  std::string key = "XSecModel@genie::EventGenerator/DIS-CC-CHARM" ;
386  RgKey local_key = "CharmXSec" ;
387  r.Set( local_key , AlgConfigPool::Instance() -> GlobalParameterList() -> GetAlg(key) ) ;
388 
390 
391  this->LoadConfig();
392 }
393 //____________________________________________________________________________
395 {
396  // Access global defaults to use in case of missing parameters
397 
398  fDISSFModel = 0;
399  fDISSFModel =
400  dynamic_cast<const DISStructureFuncModelI *> (this->SubAlg("SFAlg"));
402 
403  fDISSF.SetModel(fDISSFModel); // <-- attach algorithm
404 
405  this->GetParam( "UseDRJoinScheme", fUsingDisResJoin ) ;
406 
408  fWcut = 0.;
409 
410  if(fUsingDisResJoin) {
412  dynamic_cast<const HadronizationModelI *> (this->SubAlg("Hadronizer"));
414 
415  // Load Wcut determining the phase space area where the multiplicity prob.
416  // scaling factors would be applied -if requested-
417  this->GetParam( "Wcut", fWcut ) ;
418  }
419 
420  // Cross section scaling factor
421  this->GetParam( "DIS-XSecScale", fScale ) ;
422 
423  // sin^4(theta_weinberg)
424  double thw ;
425  this->GetParam( "WeinbergAngle", thw ) ;
426  fSin48w = TMath::Power( TMath::Sin(thw), 4 );
427 
428  // Caching the reduction factors used in the DMDIS/RES joing scheme?
429  // In normal event generation (1 config -> many calls) it is worth caching
430  // these suppression factors.
431  // Depending on the way this algorithm is used during event reweighting,
432  // precomputing (for all W's) & caching these factors might not be efficient.
433  // Here we provide the option to turn the caching off at run-time (default: on)
434 
435  bool cache_enabled = RunOpt::Instance()->BareXSecPreCalc();
436 
437  this->GetParamDef( "UseCache", fUseCache, true ) ;
438  fUseCache = fUseCache && cache_enabled;
439 
440  // Since this method would be called every time the current algorithm is
441  // reconfigured at run-time, remove all the data cached by this algorithm
442  // since they depend on the previous configuration
443 
444  if(!fInInitPhase) {
445  Cache * cache = Cache::Instance();
446  string keysubstr = this->Id().Key() + "/DMDIS-RES-Join";
447  cache->RmMatchedCacheBranches(keysubstr);
448  }
449  fInInitPhase = false;
450 
451  // velocity dependence of the interaction
452  this->GetParamDef("velocity-mode", fVelMode, 0);
453 
454  // mediator coupling
455  this->GetParam("ZpCoupling", fgzp);
456 
457  // mediator mass ratio and mediator mass
459 
460  //-- load the differential cross section integrator
462  dynamic_cast<const XSecIntegratorI *> (this->SubAlg("XSec-Integrator"));
464 
465  RgKey xdefkey = "CharmXSec" ;
466  RgAlg xalg ;
467  GetParam( xdefkey, xalg) ;
468  LOG("DMDISXSec", pDEBUG)
469  << "Loading the cross section model: " << xalg;
470  fCharmProdModel = dynamic_cast<const XSecAlgorithmI *> ( this -> SubAlg(xdefkey) ) ;
472 }
473 //____________________________________________________________________________
474 
void SetModel(const DISStructureFuncModelI *model)
Attach an algorithm.
Cross Section Calculation Interface.
const double kPi
Pure Abstract Base Class. Defines the DISStructureFuncModelI interface to be implemented by any algor...
Basic constants.
const HadronizationModelI * fHadronizationModel
hadronic multip. model
Definition: QPMDMDISPXSec.h:62
double fgzp
Coupling to the mediator Zprime.
Definition: QPMDMDISPXSec.h:74
const XML_Char * target
Definition: expat.h:268
double F2(void) const
Get the computed structure function F2.
double J(double q0, double q3, double Enu, double ml)
Definition: MECUtils.cxx:141
THE MAIN GENIE PROJECT NAMESPACE
Definition: GeneratorBase.h:8
Cross Section Integrator Interface.
double Q2(const Interaction *const i)
Definition: KineUtils.cxx:991
int HitNucPdg(void) const
Definition: Target.cxx:321
Kinematics * KinePtr(void) const
Definition: Interaction.h:76
const int kPdgMediator
Definition: PDGCodes.h:196
virtual double XSec(const Interaction *i, KinePhaseSpace_t k=kPSfE) const =0
Compute the cross section for the input interaction.
double HitNucMass(void) const
Definition: Target.cxx:250
double fSin48w
sin^4(Weingberg angle)
Definition: QPMDMDISPXSec.h:71
double DMDISRESJoinSuppressionFactor(const Interaction *in) const
Generated/set kinematical variables for an event.
Definition: Kinematics.h:40
bool IsDarkMatter(int pdgc)
Definition: PDGUtils.cxx:125
double x(bool selected=false) const
Definition: Kinematics.cxx:109
Definition: config.py:1
int fVelMode
velcoity dependence for xsec
Definition: QPMDMDISPXSec.h:72
double Integral(const Interaction *i) const
enum genie::EKinePhaseSpace KinePhaseSpace_t
const XSecAlgorithmI * fCharmProdModel
Definition: QPMDMDISPXSec.h:65
bool ValidProcess(const Interaction *i) const
Can this cross section algorithm handle the input process?
double XYtoW(double Ev, double M, double x, double y)
Definition: KineUtils.cxx:1087
void AddCacheBranch(string key, CacheBranchI *branch)
Definition: Cache.cxx:97
void SetCharm(int charm_pdgc=0)
Definition: XclsTag.cxx:68
double y(bool selected=false) const
Definition: Kinematics.cxx:122
double F4(void) const
Get the computed structure function F4.
Summary information for an interaction.
Definition: Interaction.h:56
double F1(void) const
Get the computed structure function F1.
void AddValues(double x, double y)
virtual bool ValidKinematics(const Interaction *i) const
Is the input kinematical point a physically allowed one?
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:299
bool BareXSecPreCalc(void) const
Definition: RunOpt.h:52
#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
A class encapsulating an enumeration of interaction types (EM, Weak-CC, Weak-NC) and scattering types...
Definition: ProcessInfo.h:44
const DISStructureFuncModelI * fDISSFModel
SF model.
Definition: QPMDMDISPXSec.h:61
string CacheBranchKey(string k0, string k1="", string k2="") const
Definition: Cache.cxx:102
double XYtoQ2(double Ev, double M, double x, double y)
Definition: KineUtils.cxx:1103
const Kinematics & Kine(void) const
Definition: Interaction.h:71
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
double fMedMass
Mediator mass.
Definition: QPMDMDISPXSec.h:73
int ProbePdg(void) const
Definition: InitialState.h:65
static const double kNeutronMass
Definition: Constants.h:77
DISStructureFunc fDISSF
Definition: QPMDMDISPXSec.h:58
string InteractionTypeAsString(void) const
#define R(x)
int Z(void) const
Definition: Target.h:69
#define pINFO
Definition: Messenger.h:63
virtual TH1D * MultiplicityProb(const Interaction *, Option_t *opt="") const =0
bool fUseCache
cache reduction factors used in joining scheme
Definition: QPMDMDISPXSec.h:68
Double_t xsec[nknots]
Definition: testXsec.C:47
double fScale
cross section scaling factor
Definition: QPMDMDISPXSec.h:70
CacheBranchI * FindCacheBranch(string key)
finding/adding cache branches
Definition: Cache.cxx:89
TParticlePDG * FSPrimLepton(void) const
final state primary lepton
const XSecIntegratorI * fXSecIntegrator
diff. xsec integrator
Definition: QPMDMDISPXSec.h:63
double F5(void) const
Get the computed structure function F5.
GENIE Cache Memory.
Definition: Cache.h:39
XclsTag * ExclTagPtr(void) const
Definition: Interaction.h:77
double F3(void) const
Get the computed structure function F3.
virtual const AlgId & Id(void) const
Get algorithm ID.
Definition: Algorithm.h:98
void SetW(double W, bool selected=false)
Definition: Kinematics.cxx:289
ifstream in
Definition: comparison.C:7
int N(void) const
Definition: Target.h:70
static PDGLibrary * Instance(void)
Definition: PDGLibrary.cxx:43
static RunOpt * Instance(void)
Definition: RunOpt.cxx:62
static const double kPionMass
Definition: Constants.h:74
bool HitNucIsSet(void) const
Definition: Target.cxx:300
string RgKey
void Configure(const Registry &config)
A registry. Provides the container for algorithm configuration parameters.
Definition: Registry.h:66
double fWcut
apply DMDIS/RES joining scheme < Wcut
Definition: QPMDMDISPXSec.h:69
const UInt_t kIAssumeFreeNucleon
Definition: Interaction.h:49
Pure abstract base class. Defines the HadronizationModelI interface to be implemented by any algorith...
bool IsNeutronOrProton(int pdgc)
Definition: PDGUtils.cxx:314
TParticlePDG * Find(int pdgc)
Definition: PDGLibrary.cxx:61
virtual double Integrate(const XSecAlgorithmI *model, const Interaction *interaction) const =0
void UnsetCharm(void)
Definition: XclsTag.cxx:74
assert(nhit_max >=nhit_nbins)
TRandom3 r(0)
double Jacobian(const Interaction *const i, KinePhaseSpace_t f, KinePhaseSpace_t t)
Definition: KineUtils.cxx:128
const InitialState & InitState(void) const
Definition: Interaction.h:69
const ProcessInfo & ProcInfo(void) const
Definition: Interaction.h:70
double Wmin[kNWBins]
void Calculate(const Interaction *interaction)
Calculate the S/F&#39;s for the input interaction using the attached algorithm.
bool fUsingDisResJoin
use a DMDIS/RES joining scheme?
Definition: QPMDMDISPXSec.h:67
void RmMatchedCacheBranches(string key_substring)
Definition: Cache.cxx:136
#define pNOTICE
Definition: Messenger.h:62
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 XSec(const Interaction *i, KinePhaseSpace_t k) const
Compute the cross section for the input interaction.
static const double kGF2
Definition: Constants.h:60
static Cache * Instance(void)
Definition: Cache.cxx:76
A simple cache branch storing the cached data in a TNtuple.
Definition: CacheBranchFx.h:38
bool IsDarkMatterDeepInelastic(void) const
Definition: ProcessInfo.cxx:87
void kinematics()
Definition: kinematics.C:10
void Set(RgIMapPair entry)
Definition: Registry.cxx:282
#define W(x)
double ProbeE(RefFrame_t rf) const
Most commonly used PDG codes. A set of utility functions to handle PDG codes is provided in PDGUtils...
string Key(void) const
Definition: AlgId.h:47
const UInt_t kISkipProcessChk
if set, skip process validity checks
Definition: Interaction.h:47
static AlgConfigPool * Instance()
Initial State information.
Definition: InitialState.h:49
#define pDEBUG
Definition: Messenger.h:64
const Algorithm * SubAlg(const RgKey &registry_key) const
Definition: Algorithm.cxx:353
enum BeamMode string