GENIEGenerator
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
QPMDMDISStrucFuncBase.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 
7  Costas Andreopoulos <c.andreopoulos \at cern.ch>
8  University of Liverpool
9 
10  This GENIE code was adapted from the neugen3 code co-authored by
11  Donna Naples (Pittsburgh U.), Hugh Gallagher (Tufts U), and
12  Costas Andreopoulos (RAL)
13 
14  A fix was installed (Aug 12, 2014) by Brian Tice (Rochester) so that
15  the nuclear modification to the pdf should be calculated in terms
16  of the experimental x, not the rescaled x. The same goes for R(x,Q2).
17 
18  A fix of the scaling variable used for the relations between structure
19  functions was installed by C. Bronner and J. Morrison Jun 06, 2016
20  after it was confirmed by A. Bodek that x and not the modified
21  scaling variable should be used there.
22 
23  Changes required to implement the GENIE Boosted Dark Matter module
24  were installed by Josh Berger (Univ. of Wisconsin)
25 */
26 //____________________________________________________________________________
27 
28 #include <TMath.h>
29 
31 #include "Framework/Conventions/GBuild.h"
41 
42 using namespace genie;
43 using namespace genie::constants;
44 
45 //____________________________________________________________________________
48 {
49  this->InitPDF();
50 }
51 //____________________________________________________________________________
54 {
55  this->InitPDF();
56 }
57 //____________________________________________________________________________
59 DISStructureFuncModelI(name, config)
60 {
61  this->InitPDF();
62 }
63 //____________________________________________________________________________
65 {
66  delete fPDF;
67  delete fPDFc;
68 }
69 //____________________________________________________________________________
71 {
72  Algorithm::Configure(config);
73  this->LoadConfig();
74 }
75 //____________________________________________________________________________
76 void QPMDMDISStrucFuncBase::Configure(string param_set)
77 {
78  Algorithm::Configure(param_set);
79  this->LoadConfig();
80 }
81 //____________________________________________________________________________
83 {
84  LOG("DISSF", pDEBUG) << "Loading configuration...";
85 
86  //-- pdf
87  const PDFModelI * pdf_model =
88  dynamic_cast<const PDFModelI *> (this->SubAlg("PDF-Set"));
89  fPDF -> SetModel(pdf_model);
90  fPDFc -> SetModel(pdf_model);
91 
92  //-- charm mass
93  GetParam( "Charm-Mass", fMc ) ;
94 
95  //-- min Q2 for PDF evaluation
96  GetParam( "PDF-Q2min", fQ2min ) ;
97 
98  //-- include R (~FL)?
99  GetParam( "IncludeR", fIncludeR ) ;
100 
101  //-- include nuclear factor (shadowing / anti-shadowing / ...)
102  GetParam( "IncludeNuclMod", fIncludeNuclMod ) ;
103 
104  //-- Use 2016 SF relation corrections
105  GetParam( "Use2016Corrections", fUse2016Corrections ) ;
106 
107  //-- Set min for relation between 2xF1 and F2
108  GetParam( "LowQ2CutoffF1F2", fLowQ2CutoffF1F2 ) ;
109 
110  //-- turn charm production off?
111  GetParamDef( "Charm-Prod-Off", fCharmOff, false ) ;
112 
113  //-- dark matter couplings
114  GetParam( "UpLeftCharge", fQuL );
115  GetParam( "UpRightCharge", fQuR );
116  GetParam( "CharmLeftCharge", fQcL );
117  GetParam( "CharmRightCharge", fQcR );
118  GetParam( "DownLeftCharge", fQdL );
119  GetParam( "DownRightCharge", fQdR );
120  GetParam( "StrangeLeftCharge", fQsL );
121  GetParam( "StrangeRightCharge", fQsR );
122 
123  LOG("DISSF", pDEBUG) << "Done loading configuration";
124 }
125 //____________________________________________________________________________
127 {
128  // evaluated at:
129  fPDF = new PDF(); // x = computed (+/-corrections) scaling var, Q2
130  fPDFc = new PDF(); // x = computed charm slow re-scaling var, Q2
131 }
132 //____________________________________________________________________________
133 void QPMDMDISStrucFuncBase::Calculate(const Interaction * interaction) const
134 {
135  // Reset mutable members
136  fF1 = 0;
137  fF2 = 0;
138  fF3 = 0;
139  fF4 = 0;
140  fF5 = 0;
141  fF6 = 0;
142 
143  // Get process info & perform various checks
144  const ProcessInfo & proc_info = interaction->ProcInfo();
145  const InitialState & init_state = interaction->InitState();
146  const Target & tgt = init_state.Tgt();
147 
148  int nuc_pdgc = tgt.HitNucPdg();
149  int probe_pdgc = init_state.ProbePdg();
150  bool is_p = pdg::IsProton ( nuc_pdgc );
151  bool is_n = pdg::IsNeutron ( nuc_pdgc );
152  bool is_dm = pdg::IsDarkMatter ( probe_pdgc );
153  bool is_dmb = pdg::IsAntiDarkMatter ( probe_pdgc );
154  bool is_dmi = proc_info.IsDarkMatter();
155 
156  if ( !is_dm && !is_dmb ) return;
157  if ( !is_p && !is_n ) return;
158  if ( tgt.N() == 0 && is_n ) return;
159  if ( tgt.Z() == 0 && is_p ) return;
160 
161  // Flags switching on/off quark contributions so that this algorithm can be
162  // used for both l + N -> l' + X, and l + q -> l' + q' level calculations
163 
164  double switch_uv = 1.;
165  double switch_us = 1.;
166  double switch_ubar = 1.;
167  double switch_dv = 1.;
168  double switch_ds = 1.;
169  double switch_dbar = 1.;
170  double switch_s = 1.;
171  double switch_sbar = 1.;
172  double switch_c = 1.;
173  double switch_cbar = 1.;
174 
175  if(tgt.HitQrkIsSet()) {
176 
177  switch_uv = 0.;
178  switch_us = 0.;
179  switch_ubar = 0.;
180  switch_dv = 0.;
181  switch_ds = 0.;
182  switch_dbar = 0.;
183  switch_s = 0.;
184  switch_sbar = 0.;
185  switch_c = 0.;
186  switch_cbar = 0.;
187 
188  int qpdg = tgt.HitQrkPdg();
189  bool sea = tgt.HitSeaQrk();
190 
191  bool is_u = pdg::IsUQuark (qpdg);
192  bool is_ubar = pdg::IsAntiUQuark (qpdg);
193  bool is_d = pdg::IsDQuark (qpdg);
194  bool is_dbar = pdg::IsAntiDQuark (qpdg);
195  bool is_s = pdg::IsSQuark (qpdg);
196  bool is_sbar = pdg::IsAntiSQuark (qpdg);
197  bool is_c = pdg::IsCQuark (qpdg);
198  bool is_cbar = pdg::IsAntiCQuark (qpdg);
199 
200  if (!sea && is_u ) { switch_uv = 1; }
201  else if ( sea && is_u ) { switch_us = 1; }
202  else if ( sea && is_ubar) { switch_ubar = 1; }
203  else if (!sea && is_d ) { switch_dv = 1; }
204  else if ( sea && is_d ) { switch_ds = 1; }
205  else if ( sea && is_dbar) { switch_dbar = 1; }
206  else if ( sea && is_s ) { switch_s = 1; }
207  else if ( sea && is_sbar) { switch_sbar = 1; }
208  else if ( sea && is_c ) { switch_c = 1; }
209  else if ( sea && is_cbar) { switch_cbar = 1; }
210  else return;
211 
212  }
213 
214  // Compute PDFs [both at (scaling-var,Q2) and (slow-rescaling-var,Q2)
215  // Applying all PDF K-factors abd scaling variable corrections
216 
217  this -> CalcPDFs (interaction);
218 
219  //
220  // Compute structure functions for the EM, NC and CC cases
221  //
222 
223  double F2val=0, xF3val=0;
224 
225  // *** DARK MATTER
226  if(is_dmi) {
227 
228  if(!is_dm && !is_dmb) return;
229 
230  double gvu = 0.5 * (fQuL + fQuR);
231  double gau = 0.5 * (fQuL - fQuR);
232  double gvc = 0.5 * (fQcL + fQcR);
233  double gac = 0.5 * (fQcL - fQcR);
234  double gvd = 0.5 * (fQdL + fQdR);
235  double gad = 0.5 * (fQdL - fQdR);
236  double gvs = 0.5 * (fQsL + fQsR);
237  double gas = 0.5 * (fQsL - fQsR);
238  double gvu2 = TMath::Power(gvu, 2.);
239  double gau2 = TMath::Power(gau, 2.);
240  double gvc2 = TMath::Power(gvc, 2.);
241  double gac2 = TMath::Power(gac, 2.);
242  double gvd2 = TMath::Power(gvd, 2.);
243  double gad2 = TMath::Power(gad, 2.);
244  double gvs2 = TMath::Power(gvs, 2.);
245  double gas2 = TMath::Power(gas, 2.);
246 
247  double q2 = 4.0 * ((switch_uv * fuv + switch_us * fus) * (gvu2+gau2) + switch_c * fc * (gvc2+gac2) +
248  (switch_dv * fdv + switch_ds * fds) * (gvd2+gad2) + switch_s * fs * (gvs2+gas2));
249  double q3 = 4.0 * ((switch_uv * fuv + switch_us * fus) * (2*gvu*gau) + switch_c * fc * (2*gvc*gac) +
250  (switch_dv * fdv + switch_ds * fds) * (2*gvd*gad) + switch_s * fs * (2*gvs*gas));
251 
252  double qb2 = 4.0 * (switch_ubar * fus * (gvu2+gau2) + switch_cbar * fc * (gvc2+gac2) +
253  switch_dbar * fds * (gvd2+gad2) + switch_sbar * fs * (gvs2+gas2));
254  double qb3 = 4.0 * (switch_ubar * fus * (2*gvu*gau) + switch_cbar * fc * (2*gvc*gac) +
255  switch_dbar * fds * (2*gvd*gad) + switch_sbar * fs * (2*gvs*gas));
256 
257 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
258  LOG("DISSF", pINFO) << "f2 : q = " << q2 << ", bar{q} = " << qb2;
259  LOG("DISSF", pINFO) << "xf3: q = " << q3 << ", bar{q} = " << qb3;
260 #endif
261 
262  F2val = q2+qb2;
263  xF3val = q3-qb3;
264  }
265 
266  double Q2val = this->Q2 (interaction);
267  double x = this->ScalingVar(interaction);
268  double f = this->NuclMod (interaction); // nuclear modification
269  double r = this->R (interaction); // R ~ FL
270 
271 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
272  LOG("DISSF", pDEBUG) << "Nucl. mod = " << f;
273  LOG("DISSF", pDEBUG) << "R(=FL/2xF1) = " << r;
274 #endif
275 
276  if(fUse2016Corrections) {
277  //It was confirmed by A.Bodek that the modified scaling variable
278  //should just be used to compute the strucure functions F2 and xF3,
279  //but that the usual Bjorken x should be used for the relations
280  //between the structure functions.
281  //For the same reason remove the freezing of Q2 at 0.8 for those relations,
282  //although it has not been explicitly asked to A.Bodek if it should be done.
283 
284  const Kinematics & kinematics = interaction->Kine();
285  double bjx = kinematics.x();
286 
287  double a = TMath::Power(bjx,2.) / TMath::Max(Q2val, fLowQ2CutoffF1F2);
288  double c = (1. + 4. * kNucleonMass2 * a) / (1.+r);
289 
290  fF3 = f * xF3val/bjx;
291  fF2 = f * F2val;
292  fF1 = fF2 * 0.5*c/bjx;
293  fF5 = fF2/bjx; // Albright-Jarlskog relation
294  fF4 = 0.; // Nucl.Phys.B 84, 467 (1975)
295  }
296  else {
297  double a = TMath::Power(x,2.) / TMath::Max(Q2val, fLowQ2CutoffF1F2);
298  double c = (1. + 4. * kNucleonMass2 * a) / (1.+r);
299  //double a = TMath::Power(x,2.) / Q2val;
300  //double c = (1. + 4. * kNucleonMass * a) / (1.+r);
301 
302  fF3 = f * xF3val / x;
303  fF2 = f * F2val;
304  fF1 = fF2 * 0.5 * c / x;
305  fF5 = fF2 / x; // Albright-Jarlskog relation
306  fF4 = 0.; // Nucl.Phys.B 84, 467 (1975)
307  }
308 
309 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
310  LOG("DISSF", pDEBUG)
311  << "F1-F5 = "
312  << fF1 << ", " << fF2 << ", " << fF3 << ", " << fF4 << ", " << fF5;
313 #endif
314 }
315 //____________________________________________________________________________
316 double QPMDMDISStrucFuncBase::Q2(const Interaction * interaction) const
317 {
318 // Return Q2 from the kinematics or, if not set, compute it from x,y
319 // The x might be corrected
320 
321  const Kinematics & kinematics = interaction->Kine();
322 
323  // if Q2 (or q2) is set then prefer this value
324  if (kinematics.KVSet(kKVQ2) || kinematics.KVSet(kKVq2)) {
325  double Q2val = kinematics.Q2();
326  return Q2val;
327  }
328  // if Q2 was not set, then compute it from x,y,Ev,Mnucleon
329  if (kinematics.KVSet(kKVy)) {
330  const InitialState & init_state = interaction->InitState();
331  double Mn = init_state.Tgt().HitNucP4Ptr()->M(); // could be off-shell
332  //double x = this->ScalingVar(interaction); // could be redefined
333  double x = kinematics.x();
334  double y = kinematics.y();
335  double Ev = init_state.ProbeE(kRfHitNucRest);
336  double Q2val = 2*Mn*Ev*x*y;
337  return Q2val;
338  }
339  LOG("DISSF", pERROR) << "Could not compute Q2!";
340  return 0;
341 }
342 //____________________________________________________________________________
343 double QPMDMDISStrucFuncBase::ScalingVar(const Interaction* interaction) const
344 {
345 // The scaling variable is set to the normal Bjorken x.
346 // Override DISStructureFuncModel::ScalingVar() to compute corrections
347 
348  return interaction->Kine().x();
349 }
350 //____________________________________________________________________________
352  double & kuv, double & kdv, double & kus, double & kds) const
353 {
354 // This is an abstract class: no model-specific correction
355 // The PDF scaling variables are set to 1
356 // Override this method to compute model-dependent corrections
357 
358  kuv = 1.;
359  kdv = 1.;
360  kus = 1.;
361  kds = 1.;
362 }
363 //____________________________________________________________________________
364 double QPMDMDISStrucFuncBase::NuclMod(const Interaction * interaction) const
365 {
366 // Nuclear modification to Fi
367 // The scaling variable can be overwritten to include corrections
368 
369  if( interaction->TestBit(kIAssumeFreeNucleon) ) return 1.0;
370  if( interaction->TestBit(kINoNuclearCorrection) ) return 1.0;
371 
372  double f = 1.;
373  if(fIncludeNuclMod) {
374  const Target & tgt = interaction->InitState().Tgt();
375 
376 // The x used for computing the DIS Nuclear correction factor should be the
377 // experimental x, not the rescaled x or off-shell-rest-frame version of x
378 // (i.e. selected x). Since we do not have access to experimental x at this
379 // point in the calculation, just use selected x.
380  const Kinematics & kine = interaction->Kine();
381  double x = kine.x();
382  int A = tgt.A();
384 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
385  LOG("DISSF", pDEBUG) << "Nuclear factor for x of " << x << " = " << f;
386 #endif
387  }
388 
389  return f;
390 }
391 //____________________________________________________________________________
392 double QPMDMDISStrucFuncBase::R(const Interaction * interaction) const
393 {
394 // Computes R ( ~ longitudinal structure function FL = R * 2xF1)
395 // The scaling variable can be overwritten to include corrections
396 
397 // The x used for computing the DIS Nuclear correction factor should be the
398 // experimental x, not the rescaled x or off-shell-rest-frame version of x
399 // (i.e. selected x). Since we do not have access to experimental x at this
400 // point in the calculation, just use selected x.
401  if(fIncludeR) {
402  const Kinematics & kine = interaction->Kine();
403  double x = kine.x();
404 // double x = this->ScalingVar(interaction);
405  double Q2val = this->Q2(interaction);
406  double Rval = utils::phys::RWhitlow(x, Q2val);
407  return Rval;
408  }
409  return 0;
410 }
411 //____________________________________________________________________________
412 void QPMDMDISStrucFuncBase::CalcPDFs(const Interaction * interaction) const
413 {
414  // Clean-up previous calculation
415  fPDF -> Reset();
416  fPDFc -> Reset();
417 
418  // Get the kinematical variables x,Q2 (could include corrections)
419  double x = this->ScalingVar(interaction);
420  double Q2val = this->Q2(interaction);
421 
422  // Get the hit nucleon mass (could be off-shell)
423  const Target & tgt = interaction->InitState().Tgt();
424  double M = tgt.HitNucP4().M();
425 
426  // Get the Q2 for which PDFs will be evaluated
427  double Q2pdf = TMath::Max(Q2val, fQ2min);
428 
429  // Compute PDFs at (x,Q2)
430 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
431  LOG("DISSF", pDEBUG) << "Calculating PDFs @ x = " << x << ", Q2 = " << Q2pdf;
432 #endif
433  fPDF->Calculate(x, Q2pdf);
434 
435  // Check whether it is above charm threshold
436  bool above_charm =
438  if(above_charm) {
439 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
440  LOG("DISSF", pDEBUG)
441  << "The event is above the charm threshold (mcharm = " << fMc << ")";
442 #endif
443  if(fCharmOff) {
444  LOG("DISSF", pINFO) << "Charm production is turned off";
445  } else {
446  // compute the slow rescaling var
447  double xc = utils::kinematics::SlowRescalingVar(x, Q2val, M, fMc);
448  if(xc<0 || xc>1) {
449  LOG("DISSF", pINFO) << "Unphys. slow rescaling var: xc = " << xc;
450  } else {
451  // compute PDFs at (xc,Q2)
452 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
453  LOG("DISSF", pDEBUG)
454  << "Calculating PDFs @ xc (slow rescaling) = " << x << ", Q2 = " << Q2val;
455 #endif
456  fPDFc->Calculate(xc, Q2pdf);
457  }
458  }// charm off?
459  }//above charm thr?
460  else {
461  LOG("DISSF", pDEBUG)
462  << "The event is below the charm threshold (mcharm = " << fMc << ")";
463  }
464 
465  // Compute the K factors
466  double kval_u = 1.;
467  double kval_d = 1.;
468  double ksea_u = 1.;
469  double ksea_d = 1.;
470 
471  this->KFactors(interaction, kval_u, kval_d, ksea_u, ksea_d);
472 
473 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
474  LOG("DISSF", pDEBUG) << "K-Factors:";
475  LOG("DISSF", pDEBUG) << "U: Kval = " << kval_u << ", Ksea = " << ksea_u;
476  LOG("DISSF", pDEBUG) << "D: Kval = " << kval_d << ", Ksea = " << ksea_d;
477 #endif
478 
479  // Apply the K factors
480  //
481  // Always scale d pdfs with d kfactors and u pdfs with u kfactors.
482  // Don't swap the applied kfactors for neutrons.
483  // Debdatta & Donna noted (Sep.2006) that a similar swap in the neugen
484  // implementation was the cause of the difference in nu and nubar F2
485  //
486  fPDF->ScaleUpValence (kval_u);
487  fPDF->ScaleDownValence (kval_d);
488  fPDF->ScaleUpSea (ksea_u);
489  fPDF->ScaleDownSea (ksea_d);
490  fPDF->ScaleStrange (ksea_d);
491  fPDF->ScaleCharm (ksea_u);
492  if(above_charm) {
493  fPDFc->ScaleUpValence (kval_u);
494  fPDFc->ScaleDownValence (kval_d);
495  fPDFc->ScaleUpSea (ksea_u);
496  fPDFc->ScaleDownSea (ksea_d);
497  fPDFc->ScaleStrange (ksea_d);
498  fPDFc->ScaleCharm (ksea_u);
499  }
500 
501  // Rules of thumb
502  // ---------------------------------------
503  // - For W+ exchange use: -1/3|e| quarks and -2/3|e| antiquarks
504  // - For W- exchange use: 2/3|e| quarks and 1/3|e| antiquarks
505  // - For each qi -> qj transition multiply with the (ij CKM element)^2
506  // - Use isospin symmetry to get neutron's u,d from proton's u,d
507  // -- neutron d = proton u
508  // -- neutron u = proton d
509  // - Use u = usea + uvalence. Same for d
510  // - For s,c use q=qbar
511  // - For t,b use q=qbar=0
512 
513  fuv = fPDF -> UpValence();
514  fus = fPDF -> UpSea();
515  fdv = fPDF -> DownValence();
516  fds = fPDF -> DownSea();
517  fs = fPDF -> Strange();
518  fc = 0.;
519  fuv_c = fPDFc -> UpValence(); // will be 0 if < charm threshold
520  fus_c = fPDFc -> UpSea(); // ...
521  fdv_c = fPDFc -> DownValence(); // ...
522  fds_c = fPDFc -> DownSea(); // ...
523  fs_c = fPDFc -> Strange(); // ...
524  fc_c = fPDFc -> Charm(); // ...
525 
526  // The above are the proton parton density function. Get the PDFs for the
527  // hit nucleon (p or n) by swapping u<->d if necessary
528 
529  int nuc_pdgc = tgt.HitNucPdg();
530  bool isP = pdg::IsProton (nuc_pdgc);
531  bool isN = pdg::IsNeutron (nuc_pdgc);
532  assert(isP || isN);
533 
534  double tmp = 0;
535  if (isN) { // swap u <-> d
536  tmp = fuv; fuv = fdv; fdv = tmp;
537  tmp = fus; fus = fds; fds = tmp;
538  tmp = fuv_c; fuv_c = fdv_c; fdv_c = tmp;
539  tmp = fus_c; fus_c = fds_c; fds_c = tmp;
540  }
541 
542 }
543 //____________________________________________________________________________
Pure Abstract Base Class. Defines the DISStructureFuncModelI interface to be implemented by any algor...
bool HitSeaQrk(void) const
Definition: Target.cxx:299
#define pERROR
Definition: Messenger.h:59
bool IsUQuark(int pdgc)
Definition: PDGUtils.cxx:266
int HitNucPdg(void) const
Definition: Target.cxx:304
virtual double NuclMod(const Interaction *i) const
int A(void) const
Definition: Target.h:70
double fQuR
Up Right Dark Matter Coupling.
int HitQrkPdg(void) const
Definition: Target.cxx:242
virtual void KFactors(const Interaction *i, double &kuv, double &kdv, double &kus, double &kds) const
A class to store PDFs.
Definition: PDF.h:37
double fQdR
Down Right Dark Matter Coupling.
double fQcR
Charm Right Dark Matter Coupling.
Generated/set kinematical variables for an event.
Definition: Kinematics.h:39
bool IsDarkMatter(int pdgc)
Definition: PDGUtils.cxx:127
double x(bool selected=false) const
Definition: Kinematics.cxx:99
virtual void CalcPDFs(const Interaction *i) const
bool IsSQuark(int pdgc)
Definition: PDGUtils.cxx:276
bool IsAntiSQuark(int pdgc)
Definition: PDGUtils.cxx:306
double fQsR
Strange Right Dark Matter Coupling.
Pure abstract base class. Defines the PDFModelI interface to be implemented by wrapper classes to exi...
Definition: PDFModelI.h:28
virtual double R(const Interaction *i) const
bool IsAntiDQuark(int pdgc)
Definition: PDGUtils.cxx:301
void ScaleDownValence(double kscale)
Definition: PDF.cxx:86
double y(bool selected=false) const
Definition: Kinematics.cxx:112
void Configure(const Registry &config)
bool IsNeutron(int pdgc)
Definition: PDGUtils.cxx:341
Summary information for an interaction.
Definition: Interaction.h:56
const TLorentzVector & HitNucP4(void) const
Definition: Target.h:91
double SlowRescalingVar(double x, double Q2, double M, double mc)
Definition: KineUtils.cxx:1257
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:336
const UInt_t kINoNuclearCorrection
if set, inhibit nuclear corrections
Definition: Interaction.h:51
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:96
bool KVSet(KineVar_t kv) const
Definition: Kinematics.cxx:317
bool IsAntiDarkMatter(int pdgc)
Definition: PDGUtils.cxx:133
virtual double Q2(const Interaction *i) const
bool fIncludeNuclMod
include nuclear factor (shadowing, anti-shadowing,...)?
PDF * fPDF
computed PDFs @ (x,Q2)
static constexpr double A
Definition: Units.h:74
A class encapsulating an enumeration of interaction types (EM, Weak-CC, Weak-NC) and scattering types...
Definition: ProcessInfo.h:46
const double a
bool fIncludeR
include R (~FL) in DIS SF calculation?
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:40
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
int ProbePdg(void) const
Definition: InitialState.h:64
int Z(void) const
Definition: Target.h:68
bool IsAboveCharmThreshold(double x, double Q2, double M, double mc)
Definition: KineUtils.cxx:1238
#define pINFO
Definition: Messenger.h:62
static const double kNucleonMass2
void Calculate(double x, double q2)
Definition: PDF.cxx:49
bool fUse2016Corrections
Use 2016 SF relation corrections.
double fQuL
Up Left Dark Matter Coupling.
double fLowQ2CutoffF1F2
Set min for relation between 2xF1 and F2.
PDF * fPDFc
computed PDFs @ (slow-rescaling-var,Q2)
void ScaleUpValence(double kscale)
Definition: PDF.cxx:81
int N(void) const
Definition: Target.h:69
TLorentzVector * HitNucP4Ptr(void) const
Definition: Target.cxx:247
bool fCharmOff
turn charm production off?
bool IsCQuark(int pdgc)
Definition: PDGUtils.cxx:281
bool HitQrkIsSet(void) const
Definition: Target.cxx:292
virtual void Calculate(const Interaction *interaction) const
Calculate the structure functions F1-F6 for the input interaction.
bool IsDarkMatter(void) const
A registry. Provides the container for algorithm configuration parameters.
Definition: Registry.h:65
const UInt_t kIAssumeFreeNucleon
Definition: Interaction.h:49
bool IsAntiCQuark(int pdgc)
Definition: PDGUtils.cxx:311
bool IsDQuark(int pdgc)
Definition: PDGUtils.cxx:271
const InitialState & InitState(void) const
Definition: Interaction.h:69
const ProcessInfo & ProcInfo(void) const
Definition: Interaction.h:70
double Q2(bool selected=false) const
Definition: Kinematics.cxx:125
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:66
void ScaleUpSea(double kscale)
Definition: PDF.cxx:91
void ScaleCharm(double kscale)
Definition: PDF.cxx:106
double DISNuclFactor(double x, int A)
double RWhitlow(double x, double Q2)
Definition: PhysUtils.cxx:75
virtual double ScalingVar(const Interaction *i) const
double fQsL
Strange Left Dark Matter Coupling.
void ScaleDownSea(double kscale)
Definition: PDF.cxx:96
double ProbeE(RefFrame_t rf) const
double fQ2min
min Q^2 allowed for PDFs: PDF(Q2&lt;Q2min):=PDF(Q2min)
bool IsAntiUQuark(int pdgc)
Definition: PDGUtils.cxx:296
Initial State information.
Definition: InitialState.h:48
double fQdL
Down Left Dark Matter Coupling.
#define pDEBUG
Definition: Messenger.h:63
void ScaleStrange(double kscale)
Definition: PDF.cxx:101
double fQcL
Charm Left Dark Matter Coupling.
const Algorithm * SubAlg(const RgKey &registry_key) const
Definition: Algorithm.cxx:345