QPMDISPXSec.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: Costas Andreopoulos <costas.andreopoulos \at stfc.ac.uk>
8  University of Liverpool & STFC Rutherford Appleton Lab
9 
10  For the class documentation see the corresponding header file.
11 
12  Important revisions after version 2.0.0 :
13  @ Oct 09, 2009 - CA
14  Modified to handle charged lepton - nucleon(nucleus) scattering.
15  Renamed QPMDISPXSec from DISPartonModelPXSec following code reorganization.
16  @ Oct 11, 2009 - CA
17  Implemented ValidProcess()
18  @ Jan 29, 2013 - CA
19  Don't look-up depreciated $GDISABLECACHING environmental variable.
20  Use the RunOpt singleton instead.
21 
22 */
23 //____________________________________________________________________________
24 
25 #include <sstream>
26 
27 #include <TMath.h>
28 #include <TH1D.h>
29 
44 #include "Framework/Utils/RunOpt.h"
47 #include "Framework/Utils/Range1.h"
49 #include "Framework/Utils/Cache.h"
51 
52 using std::ostringstream;
53 
54 using namespace genie;
55 using namespace genie::constants;
56 //using namespace genie::units;
57 
58 //____________________________________________________________________________
60 XSecAlgorithmI("genie::QPMDISPXSec")
61 {
62  fInInitPhase = true;
63 }
64 //____________________________________________________________________________
66 XSecAlgorithmI("genie::QPMDISPXSec", config)
67 {
68  fInInitPhase = true;
69 }
70 //____________________________________________________________________________
72 {
73 
74 }
75 //____________________________________________________________________________
77  const Interaction * interaction, KinePhaseSpace_t kps) const
78 {
79  if(! this -> ValidProcess (interaction) ) return 0.;
80  if(! this -> ValidKinematics (interaction) ) return 0.;
81 
82  // Get kinematical & init-state parameters
83  const Kinematics & kinematics = interaction -> Kine();
84  const InitialState & init_state = interaction -> InitState();
85  const ProcessInfo & proc_info = interaction -> ProcInfo();
86 
87  double E = init_state.ProbeE(kRfHitNucRest);
88  double ml = interaction->FSPrimLepton()->Mass();
89  double Mnuc = init_state.Tgt().HitNucMass();
90  double x = kinematics.x();
91  double y = kinematics.y();
92 
93  double E2 = E * E;
94  double ml2 = ml * ml;
95  double ml4 = ml2 * ml2;
96  double Mnuc2 = Mnuc * Mnuc;
97 
98 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
99  LOG("DISPXSec", pDEBUG)
100  << "Computing d2xsec/dxdy @ E = " << E << ", x = " << x << ", y = " << y;
101 #endif
102 
103  // One of the xsec terms changes sign for antineutrinos @ DIS/CC
104 
105  bool is_nubar_cc = pdg::IsAntiNeutrino(init_state.ProbePdg()) &&
106  proc_info.IsWeakCC();
107  int sign = (is_nubar_cc) ? -1 : 1;
108 
109  // Calculate the DIS structure functions
110  fDISSF.Calculate(interaction);
111 
112 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
113  LOG("DISPXSec", pDEBUG) << fDISSF;
114 #endif
115 
116  //
117  // Compute the differential cross section
118  //
119 
120  double g2 = kGF2;
121  // For EM interaction replace G_{Fermi} with :
122  // a_{em} * pi / ( sqrt(2) * sin^2(theta_weinberg) * Mass_{W}^2 }
123  // See C.Quigg, Gauge Theories of the Strong, Weak and E/M Interactions,
124  // ISBN 0-8053-6021-2, p.112 (6.3.57)
125  // Also, take int account that the photon propagator is 1/p^2 but the
126  // W propagator is 1/(p^2-Mass_{W}^2), so weight the EM case with
127  // Mass_{W}^4 / q^4
128  // So, overall:
129  // G_{Fermi}^2 --> a_{em}^2 * pi^2 / (2 * sin^4(theta_weinberg) * q^{4})
130  //
131  double Q2 = utils::kinematics::XYtoQ2(E,Mnuc,x,y);
132  double Q4 = Q2*Q2;
133  if(proc_info.IsEM()) {
134  g2 = kAem2 * kPi2 / (2.0 * fSin48w * Q4);
135  }
136  if (proc_info.IsWeakCC()) {
137  g2 = kGF2 * kMw2 * kMw2 / TMath::Power((Q2 + kMw2), 2);
138  } else if (proc_info.IsWeakNC()) {
139  g2 = kGF2 * kMz2 * kMz2 / TMath::Power((Q2 + kMz2), 2);
140  }
141  double front_factor = (g2*Mnuc*E) / kPi;
142 
143  // Build all dxsec/dxdy terms
144  double term1 = y * ( x*y + ml2/(2*E*Mnuc) );
145  double term2 = 1 - y - Mnuc*x*y/(2*E) - ml2/(4*E2);
146  double term3 = sign * (x*y*(1-y/2) - y*ml2/(4*Mnuc*E));
147  double term4 = x*y*ml2/(2*Mnuc*E) + ml4/(4*Mnuc2*E2);
148  double term5 = -1.*ml2/(2*Mnuc*E);
149 
150 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
151  LOG("DISPXSec", pDEBUG)
152  << "\nd2xsec/dxdy ~ (" << term1 << ")*F1+(" << term2 << ")*F2+("
153  << term3 << ")*F3+(" << term4 << ")*F4+(" << term5 << ")*F5";
154 #endif
155 
156  term1 *= fDISSF.F1();
157  term2 *= fDISSF.F2();
158  term3 *= fDISSF.F3();
159  term4 *= fDISSF.F4();
160  term5 *= fDISSF.F5();
161 
162  double xsec = front_factor * (term1 + term2 + term3 + term4 + term5);
163  xsec = TMath::Max(xsec,0.);
164 
165 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
166  LOG("DISPXSec", pINFO)
167  << "d2xsec/dxdy[FreeN] (E= " << E
168  << ", x= " << x << ", y= " << y << ") = " << xsec;
169 #endif
170 
171  // If the DIS/RES joining scheme is enabled, modify the xsec accordingly
172  if(fUsingDisResJoin) {
173  double R = this->DISRESJoinSuppressionFactor(interaction);
174  xsec*=R;
175 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
176  LOG("DISPXSec", pINFO) << "D/R Join scheme - suppression factor R = " << R;;
177  LOG("DISPXSec", pINFO) << "d2xsec/dxdy[FreeN, D/R Join] " << xsec;
178 #endif
179  }
180 
181  // The algorithm computes d^2xsec/dxdy
182  // Check whether variable tranformation is needed
183  if(kps!=kPSxyfE) {
184  double J = utils::kinematics::Jacobian(interaction,kPSxyfE,kps);
185  xsec *= J;
186  }
187 
188  // If requested return the free nucleon xsec even for input nuclear tgt
189  if( interaction->TestBit(kIAssumeFreeNucleon) ) return xsec;
190 
191  // Compute nuclear cross section (simple scaling here, corrections must
192  // have been included in the structure functions)
193  const Target & target = init_state.Tgt();
194  int nucpdgc = target.HitNucPdg();
195  int NNucl = (pdg::IsProton(nucpdgc)) ? target.Z() : target.N();
196  xsec *= NNucl;
197 
198  // Apply scaling / if required to reach well known asymmptotic value
199  xsec *= fScale;
200 
201  // Subtract the inclusive charm production cross section
202  interaction->ExclTagPtr()->SetCharm();
203  double xsec_charm = fCharmProdModel->XSec(interaction,kps);
204  interaction->ExclTagPtr()->UnsetCharm();
205 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
206  LOG("DISPXSec", pINFO)
207  << "Subtracting charm piece: " << xsec_charm << " / out of " << xsec;
208 #endif
209  xsec = TMath::Max(0., xsec-xsec_charm);
210  return xsec;
211 }
212 //____________________________________________________________________________
213 double QPMDISPXSec::Integral(const Interaction * interaction) const
214 {
215  double xsec = fXSecIntegrator->Integrate(this,interaction);
216  return xsec;
217 }
218 //____________________________________________________________________________
219 bool QPMDISPXSec::ValidProcess(const Interaction * interaction) const
220 {
221  if(interaction->TestBit(kISkipProcessChk)) return true;
222 
223  const ProcessInfo & proc_info = interaction->ProcInfo();
224  if(!proc_info.IsDeepInelastic()) return false;
225 
226  const InitialState & init_state = interaction -> InitState();
227  int probe_pdg = init_state.ProbePdg();
228  if(!pdg::IsLepton(probe_pdg)) return false;
229 
230  if(! init_state.Tgt().HitNucIsSet()) return false;
231 
232  int hitnuc_pdg = init_state.Tgt().HitNucPdg();
233  if(!pdg::IsNeutronOrProton(hitnuc_pdg)) return false;
234 
235  return true;
236 }
237 //____________________________________________________________________________
239  const Interaction * in) const
240 {
241 // Computes suppression factors for the DIS xsec under the used DIS/RES join
242 // scheme. Since this is a 'low-level' algorithm that is being called many
243 // times per generated event or computed cross section spline, the suppression
244 // factors would be cached to avoid calling the hadronization model too often.
245 //
246  double R=0, Ro=0;
247 
248  const double Wmin = kNeutronMass + kPionMass + 1E-3;
249 
250  const InitialState & ist = in->InitState();
251  const ProcessInfo & pi = in->ProcInfo();
252 
253  double E = ist.ProbeE(kRfHitNucRest);
254  double Mnuc = ist.Tgt().HitNucMass();
255  double x = in->Kine().x();
256  double y = in->Kine().y();
257  double Wo = utils::kinematics::XYtoW(E,Mnuc,x,y);
258 
259  TH1D * mprob = 0;
260 
261  if(!fUseCache) {
262  // ** Compute the reduction factor at each call - no caching
263  //
264  mprob = fHadronizationModel->MultiplicityProb(in,"+LowMultSuppr");
265  R = 1;
266  if(mprob) {
267  R = mprob->Integral("width");
268  delete mprob;
269  }
270  }
271  else {
272 
273  // ** Precompute/cache the reduction factors and then use the
274  // ** cache to evaluate these factors
275 
276  // Access the cache branch. The branch key is formed as:
277  // algid/DIS-RES-Join/nu-pdg:N;hit-nuc-pdg:N/inttype
278  Cache * cache = Cache::Instance();
279  string algkey = this->Id().Key() + "/DIS-RES-Join";
280 
281  ostringstream ikey;
282  ikey << "nu-pdgc:" << ist.ProbePdg()
283  << ";hit-nuc-pdg:"<< ist.Tgt().HitNucPdg() << "/"
284  << pi.InteractionTypeAsString();
285 
286  string key = cache->CacheBranchKey(algkey, ikey.str());
287 
288  CacheBranchFx * cbr =
289  dynamic_cast<CacheBranchFx *> (cache->FindCacheBranch(key));
290 
291  // If it does't exist then create a new one
292  // and cache DIS xsec suppression factors
293  bool non_zero=false;
294  if(!cbr) {
295  LOG("DISXSec", pNOTICE)
296  << "\n ** Creating cache branch - key = " << key;
297 
298  cbr = new CacheBranchFx("DIS Suppr. Factors in DIS/RES Join Scheme");
299  Interaction interaction(*in);
300 
301  const int kN = 300;
302  double WminSpl = Wmin;
303  double WmaxSpl = fWcut + 0.1; // well into the area where scaling factor = 1
304  double dW = (WmaxSpl-WminSpl)/(kN-1);
305 
306  for(int i=0; i<kN; i++) {
307  double W = WminSpl+i*dW;
308  interaction.KinePtr()->SetW(W);
309  mprob = fHadronizationModel->MultiplicityProb(&interaction,"+LowMultSuppr");
310  R = 1;
311  if(mprob) {
312  R = mprob->Integral("width");
313  delete mprob;
314  }
315  // make sure that it takes enough samples where it is non-zero:
316  // modify the step and the sample counter once I've hit the first
317  // non-zero value
318  if(!non_zero && R>0) {
319  non_zero=true;
320  WminSpl=W;
321  i = 0;
322  dW = (WmaxSpl-WminSpl)/(kN-1);
323  }
324  LOG("DISXSec", pNOTICE)
325  << "Cached DIS XSec Suppr. factor (@ W=" << W << ") = " << R;
326 
327  cbr->AddValues(W,R);
328  }
329  cbr->CreateSpline();
330 
331  cache->AddCacheBranch(key, cbr);
332  assert(cbr);
333  } // cache data
334 
335  // get the reduction factor from the cache branch
336  if(Wo > Wmin && Wo < fWcut-1E-2) {
337  const CacheBranchFx & cache_branch = (*cbr);
338  R = cache_branch(Wo);
339  }
340  }
341 
342  // Now return the suppression factor
343  if (Wo > Wmin && Wo < fWcut-1E-2) Ro = R;
344  else if (Wo <= Wmin) Ro = 0.0;
345  else Ro = 1.0;
346 
347  LOG("DISXSec", pDEBUG)
348  << "DIS/RES Join: DIS xsec suppr. (W=" << Wo << ") = " << Ro;
349 
350  return Ro;
351 }
352 //____________________________________________________________________________
354 {
355  Algorithm::Configure(config);
356  this->LoadConfig();
357 }
358 //____________________________________________________________________________
360 {
361  Algorithm::Configure(config);
362 
363  Registry r( "QPMDISPXSec_specific", false ) ;
364 
365  RgKey xdefkey = "XSecModel@genie::EventGenerator/DIS-CC-CHARM";
366  RgKey local_key = "CharmXSec" ;
367  r.Set( local_key, AlgConfigPool::Instance() -> GlobalParameterList() -> GetAlg(xdefkey) ) ;
368 
370 
371  this->LoadConfig();
372 }
373 //____________________________________________________________________________
375 {
376  // Access global defaults to use in case of missing parameters
377 
378  fDISSFModel = 0;
379  fDISSFModel =
380  dynamic_cast<const DISStructureFuncModelI *> (this->SubAlg("SFAlg"));
382 
383  fDISSF.SetModel(fDISSFModel); // <-- attach algorithm
384 
385  GetParam( "UseDRJoinScheme", fUsingDisResJoin ) ;
386 
388  fWcut = 0.;
389 
390  if(fUsingDisResJoin) {
392  dynamic_cast<const HadronizationModelI *> (this->SubAlg("Hadronizer"));
394 
395  // Load Wcut determining the phase space area where the multiplicity prob.
396  // scaling factors would be applied -if requested-
397 
398  GetParam( "Wcut", fWcut ) ;
399 
400  }
401 
402  // Cross section scaling factor
403  GetParam( "DIS-XSecScale", fScale ) ;
404 
405  // sin^4(theta_weinberg)
406  double thw ;
407  GetParam( "WeinbergAngle", thw ) ;
408  fSin48w = TMath::Power( TMath::Sin(thw), 4 );
409 
410  // Caching the reduction factors used in the DIS/RES joing scheme?
411  // In normal event generation (1 config -> many calls) it is worth caching
412  // these suppression factors.
413  // Depending on the way this algorithm is used during event reweighting,
414  // precomputing (for all W's) & caching these factors might not be efficient.
415  // Here we provide the option to turn the caching off at run-time (default: on)
416 
417  bool cache_enabled = RunOpt::Instance()->BareXSecPreCalc();
418 
419  GetParamDef( "UseCache", fUseCache, true ) ;
420  fUseCache = fUseCache && cache_enabled;
421 
422  // Since this method would be called every time the current algorithm is
423  // reconfigured at run-time, remove all the data cached by this algorithm
424  // since they depend on the previous configuration
425 
426  if(!fInInitPhase) {
427  Cache * cache = Cache::Instance();
428  string keysubstr = this->Id().Key() + "/DIS-RES-Join";
429  cache->RmMatchedCacheBranches(keysubstr);
430  }
431  fInInitPhase = false;
432 
433  //-- load the differential cross section integrator
435  dynamic_cast<const XSecIntegratorI *> (this->SubAlg("XSec-Integrator"));
437 
438  // Load the charm production cross section model
439  RgKey local_key = "CharmXSec" ;
440  RgAlg xalg;
441  GetParam( local_key, xalg ) ;
442  LOG("DISXSec", pDEBUG)
443  << "Loading the cross section model: " << xalg;
444 
445  fCharmProdModel = dynamic_cast<const XSecAlgorithmI *> ( this -> SubAlg(local_key) ) ;
447 }
448 //____________________________________________________________________________
449 
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.
bool IsWeakCC(void) const
const XML_Char * target
Definition: expat.h:268
double F2(void) const
Get the computed structure function F2.
static const double kMw2
Definition: Constants.h:94
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
virtual double XSec(const Interaction *i, KinePhaseSpace_t k=kPSfE) const =0
Compute the cross section for the input interaction.
const DISStructureFuncModelI * fDISSFModel
SF model.
Definition: QPMDISPXSec.h:58
double HitNucMass(void) const
Definition: Target.cxx:250
static const double kMz2
Definition: Constants.h:95
Generated/set kinematical variables for an event.
Definition: Kinematics.h:40
double x(bool selected=false) const
Definition: Kinematics.cxx:109
Definition: config.py:1
enum genie::EKinePhaseSpace KinePhaseSpace_t
double XYtoW(double Ev, double M, double x, double y)
Definition: KineUtils.cxx:1087
double fSin48w
sin^4(Weingberg angle)
Definition: QPMDISPXSec.h:68
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 IsWeakNC(void) const
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
const XSecIntegratorI * fXSecIntegrator
diff. xsec integrator
Definition: QPMDISPXSec.h:60
Float_t E
Definition: plot.C:20
static const double kAem2
Definition: Constants.h:58
void Configure(const Registry &config)
A class encapsulating an enumeration of interaction types (EM, Weak-CC, Weak-NC) and scattering types...
Definition: ProcessInfo.h:44
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
bool IsAntiNeutrino(int pdgc)
Definition: PDGUtils.cxx:116
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
int ProbePdg(void) const
Definition: InitialState.h:65
static const double kNeutronMass
Definition: Constants.h:77
double fScale
cross section scaling factor
Definition: QPMDISPXSec.h:67
void LoadConfig(void)
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
DISStructureFunc fDISSF
Definition: QPMDISPXSec.h:55
Double_t xsec[nknots]
Definition: testXsec.C:47
bool ValidProcess(const Interaction *i) const
Can this cross section algorithm handle the input process?
CacheBranchI * FindCacheBranch(string key)
finding/adding cache branches
Definition: Cache.cxx:89
TParticlePDG * FSPrimLepton(void) const
final state primary lepton
double F5(void) const
Get the computed structure function F5.
bool IsEM(void) const
GENIE Cache Memory.
Definition: Cache.h:39
bool IsDeepInelastic(void) const
Definition: ProcessInfo.cxx:82
XclsTag * ExclTagPtr(void) const
Definition: Interaction.h:77
const XSecAlgorithmI * fCharmProdModel
Definition: QPMDISPXSec.h:62
double fWcut
apply DIS/RES joining scheme < Wcut
Definition: QPMDISPXSec.h:66
double F3(void) const
Get the computed structure function F3.
const HadronizationModelI * fHadronizationModel
hadronic multip. model
Definition: QPMDISPXSec.h:59
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 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
A registry. Provides the container for algorithm configuration parameters.
Definition: Registry.h:66
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
double XSec(const Interaction *i, KinePhaseSpace_t k) const
Compute the cross section for the input interaction.
Definition: QPMDISPXSec.cxx:76
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
virtual ~QPMDISPXSec()
Definition: QPMDISPXSec.cxx:71
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 fUseCache
cache reduction factors used in joining scheme
Definition: QPMDISPXSec.h:65
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
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
double Integral(const Interaction *i) const
double DISRESJoinSuppressionFactor(const Interaction *in) const
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
bool IsLepton(int pdgc)
Definition: PDGUtils.cxx:84
static const double kPi2
Definition: Constants.h:39
def sign(x)
Definition: canMan.py:197
const UInt_t kISkipProcessChk
if set, skip process validity checks
Definition: Interaction.h:47
static AlgConfigPool * Instance()
bool fUsingDisResJoin
use a DIS/RES joining scheme?
Definition: QPMDISPXSec.h:64
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