Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
genie::QPMDISStrucFuncBase Class Reference

Abstract base class. Provides common implementation for concrete objects implementing the DISStructureFuncModelI interface. More...

#include <QPMDISStrucFuncBase.h>

Inheritance diagram for genie::QPMDISStrucFuncBase:
genie::DISStructureFuncModelI genie::Algorithm genie::BYStrucFunc genie::QPMDISStrucFunc

Public Member Functions

virtual ~QPMDISStrucFuncBase ()
 
virtual double F1 (void) const
 Get the computed structure function F1. More...
 
virtual double F2 (void) const
 Get the computed structure function F2. More...
 
virtual double F3 (void) const
 Get the computed structure function F3. More...
 
virtual double F4 (void) const
 Get the computed structure function F4. More...
 
virtual double F5 (void) const
 Get the computed structure function F5. More...
 
virtual double F6 (void) const
 Get the computed structure function F6. More...
 
virtual void Calculate (const Interaction *interaction) const
 Calculate the structure functions F1-F6 for the input interaction. More...
 
void Configure (const Registry &config)
 
void Configure (string param_set)
 
- Public Member Functions inherited from genie::DISStructureFuncModelI
virtual ~DISStructureFuncModelI ()
 
- Public Member Functions inherited from genie::Algorithm
virtual ~Algorithm ()
 
virtual void FindConfig (void)
 
virtual const RegistryGetConfig (void) const
 
RegistryGetOwnedConfig (void)
 
virtual const AlgIdId (void) const
 Get algorithm ID. More...
 
virtual AlgStatus_t GetStatus (void) const
 Get algorithm status. More...
 
virtual bool AllowReconfig (void) const
 
virtual AlgCmp_t Compare (const Algorithm *alg) const
 Compare with input algorithm. More...
 
virtual void SetId (const AlgId &id)
 Set algorithm ID. More...
 
virtual void SetId (string name, string config)
 
const AlgorithmSubAlg (const RgKey &registry_key) const
 
void AdoptConfig (void)
 
void AdoptSubstructure (void)
 
virtual void Print (ostream &stream) const
 Print algorithm info. More...
 

Protected Member Functions

 QPMDISStrucFuncBase ()
 
 QPMDISStrucFuncBase (string name)
 
 QPMDISStrucFuncBase (string name, string config)
 
virtual void LoadConfig (void)
 
virtual void InitPDF (void)
 
virtual double Q2 (const Interaction *i) const
 
virtual double ScalingVar (const Interaction *i) const
 
virtual void CalcPDFs (const Interaction *i) const
 
virtual double NuclMod (const Interaction *i) const
 
virtual double R (const Interaction *i) const
 
virtual void KFactors (const Interaction *i, double &kuv, double &kdv, double &kus, double &kds) const
 
- Protected Member Functions inherited from genie::DISStructureFuncModelI
 DISStructureFuncModelI ()
 
 DISStructureFuncModelI (string name)
 
 DISStructureFuncModelI (string name, string config)
 
- Protected Member Functions inherited from genie::Algorithm
 Algorithm ()
 
 Algorithm (string name)
 
 Algorithm (string name, string config)
 
void Initialize (void)
 
void DeleteConfig (void)
 
void DeleteSubstructure (void)
 
RegistryExtractLocalConfig (const Registry &in) const
 
RegistryExtractLowerConfig (const Registry &in, const string &alg_key) const
 Split an incoming configuration Registry into a block valid for the sub-algo identified by alg_key. More...
 
template<class T >
bool GetParam (const RgKey &name, T &p, bool is_top_call=true) const
 
template<class T >
bool GetParamDef (const RgKey &name, T &p, const T &def) const
 
template<class T >
int GetParamVect (const std::string &comm_name, std::vector< T > &v, bool is_top_call=true) const
 Handle to load vectors of parameters. More...
 
int GetParamVectKeys (const std::string &comm_name, std::vector< RgKey > &k, bool is_top_call=true) const
 
int AddTopRegistry (Registry *rp, bool owns=true)
 add registry with top priority, also update ownership More...
 
int AddLowRegistry (Registry *rp, bool owns=true)
 add registry with lowest priority, also update ownership More...
 
int MergeTopRegistry (const Registry &r)
 
int AddTopRegisties (const vector< Registry * > &rs, bool owns=false)
 Add registries with top priority, also udated Ownerships. More...
 

Protected Attributes

double fQ2min
 min Q^2 allowed for PDFs: PDF(Q2<Q2min):=PDF(Q2min) More...
 
bool fCharmOff
 turn charm production off? More...
 
bool fIncludeR
 include R (~FL) in DIS SF calculation? More...
 
bool fIncludeNuclMod
 include nuclear factor (shadowing, anti-shadowing,...)? More...
 
double fMc
 charm mass used More...
 
double fVcd
 CKM element Vcd used. More...
 
double fVcs
 CKM element Vcs used. More...
 
double fVud
 CKM element Vud used. More...
 
double fVus
 CKM element Vcs used. More...
 
double fVcd2
 
double fVcs2
 
double fVud2
 
double fVus2
 
double fSin2thw
 
bool fUse2016Corrections
 Use 2016 SF relation corrections. More...
 
double fLowQ2CutoffF1F2
 Set min for relation between 2xF1 and F2. More...
 
double fF1
 
double fF2
 
double fF3
 
double fF4
 
double fF5
 
double fF6
 
PDFfPDF
 computed PDFs @ (x,Q2) More...
 
PDFfPDFc
 computed PDFs @ (slow-rescaling-var,Q2) More...
 
double fuv
 
double fus
 
double fdv
 
double fds
 
double fs
 
double fc
 
double fuv_c
 
double fus_c
 
double fdv_c
 
double fds_c
 
double fs_c
 
double fc_c
 
- Protected Attributes inherited from genie::Algorithm
bool fAllowReconfig
 
bool fOwnsSubstruc
 true if it owns its substructure (sub-algs,...) More...
 
AlgId fID
 algorithm name and configuration set More...
 
vector< Registry * > fConfVect
 
vector< boolfOwnerships
 ownership for every registry in fConfVect More...
 
AlgStatus_t fStatus
 algorithm execution status More...
 
AlgMapfOwnedSubAlgMp
 local pool for owned sub-algs (taken out of the factory pool) More...
 

Additional Inherited Members

- Static Public Member Functions inherited from genie::Algorithm
static string BuildParamVectKey (const std::string &comm_name, unsigned int i)
 
static string BuildParamVectSizeKey (const std::string &comm_name)
 

Detailed Description

Abstract base class. Provides common implementation for concrete objects implementing the DISStructureFuncModelI interface.

For a discussion of DIS SF see for example E.A.Paschos and J.Y.Yu, Phys.Rev.D 65.033002 and R.Devenish and A.Cooper-Sarkar, OUP 2004.

Author
Costas Andreopoulos <constantinos.andreopoulos cern.ch> University of Liverpool & STFC Rutherford Appleton Laboratory

Adapted from neugen 3. Primary authors: D.Naples (Pittsburgh U.), H.Gallagher (Tufts U), CA (RAL)

May 03, 2004

Copyright (c) 2003-2020, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 36 of file QPMDISStrucFuncBase.h.

Constructor & Destructor Documentation

QPMDISStrucFuncBase::~QPMDISStrucFuncBase ( )
virtual

Definition at line 62 of file QPMDISStrucFuncBase.cxx.

63 {
64  delete fPDF;
65  delete fPDFc;
66 }
PDF * fPDFc
computed PDFs @ (slow-rescaling-var,Q2)
PDF * fPDF
computed PDFs @ (x,Q2)
QPMDISStrucFuncBase::QPMDISStrucFuncBase ( )
protected

Definition at line 44 of file QPMDISStrucFuncBase.cxx.

44  :
46 {
47  this->InitPDF();
48 }
QPMDISStrucFuncBase::QPMDISStrucFuncBase ( string  name)
protected

Definition at line 50 of file QPMDISStrucFuncBase.cxx.

50  :
52 {
53  this->InitPDF();
54 }
static QCString name
Definition: declinfo.cpp:673
QPMDISStrucFuncBase::QPMDISStrucFuncBase ( string  name,
string  config 
)
protected

Definition at line 56 of file QPMDISStrucFuncBase.cxx.

56  :
58 {
59  this->InitPDF();
60 }
static QCString name
Definition: declinfo.cpp:673
static Config * config
Definition: config.cpp:1054

Member Function Documentation

void QPMDISStrucFuncBase::CalcPDFs ( const Interaction i) const
protectedvirtual

Definition at line 495 of file QPMDISStrucFuncBase.cxx.

496 {
497  // Clean-up previous calculation
498  fPDF -> Reset();
499  fPDFc -> Reset();
500 
501  // Get the kinematical variables x,Q2 (could include corrections)
502  double x = this->ScalingVar(interaction);
503  double Q2val = this->Q2(interaction);
504 
505  // Get the hit nucleon mass (could be off-shell)
506  const Target & tgt = interaction->InitState().Tgt();
507  double M = tgt.HitNucP4().M();
508 
509  // Get the Q2 for which PDFs will be evaluated
510  double Q2pdf = TMath::Max(Q2val, fQ2min);
511 
512  // Compute PDFs at (x,Q2)
513 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
514  LOG("DISSF", pDEBUG) << "Calculating PDFs @ x = " << x << ", Q2 = " << Q2pdf;
515 #endif
516  fPDF->Calculate(x, Q2pdf);
517 
518  // Check whether it is above charm threshold
519  bool above_charm =
521  if(above_charm) {
522 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
523  LOG("DISSF", pDEBUG)
524  << "The event is above the charm threshold (mcharm = " << fMc << ")";
525 #endif
526  if(fCharmOff) {
527  LOG("DISSF", pINFO) << "Charm production is turned off";
528  } else {
529  // compute the slow rescaling var
530  double xc = utils::kinematics::SlowRescalingVar(x, Q2val, M, fMc);
531  if(xc<0 || xc>1) {
532  LOG("DISSF", pINFO) << "Unphys. slow rescaling var: xc = " << xc;
533  } else {
534  // compute PDFs at (xc,Q2)
535 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
536  LOG("DISSF", pDEBUG)
537  << "Calculating PDFs @ xc (slow rescaling) = " << x << ", Q2 = " << Q2val;
538 #endif
539  fPDFc->Calculate(xc, Q2pdf);
540  }
541  }// charm off?
542  }//above charm thr?
543  else {
544  LOG("DISSF", pDEBUG)
545  << "The event is below the charm threshold (mcharm = " << fMc << ")";
546  }
547 
548  // Compute the K factors
549  double kval_u = 1.;
550  double kval_d = 1.;
551  double ksea_u = 1.;
552  double ksea_d = 1.;
553 
554  this->KFactors(interaction, kval_u, kval_d, ksea_u, ksea_d);
555 
556 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
557  LOG("DISSF", pDEBUG) << "K-Factors:";
558  LOG("DISSF", pDEBUG) << "U: Kval = " << kval_u << ", Ksea = " << ksea_u;
559  LOG("DISSF", pDEBUG) << "D: Kval = " << kval_d << ", Ksea = " << ksea_d;
560 #endif
561 
562  // Apply the K factors
563  //
564  // Always scale d pdfs with d kfactors and u pdfs with u kfactors.
565  // Don't swap the applied kfactors for neutrons.
566  // Debdatta & Donna noted (Sep.2006) that a similar swap in the neugen
567  // implementation was the cause of the difference in nu and nubar F2
568  //
569  fPDF->ScaleUpValence (kval_u);
570  fPDF->ScaleDownValence (kval_d);
571  fPDF->ScaleUpSea (ksea_u);
572  fPDF->ScaleDownSea (ksea_d);
573  fPDF->ScaleStrange (ksea_d);
574  fPDF->ScaleCharm (ksea_u);
575  if(above_charm) {
576  fPDFc->ScaleUpValence (kval_u);
577  fPDFc->ScaleDownValence (kval_d);
578  fPDFc->ScaleUpSea (ksea_u);
579  fPDFc->ScaleDownSea (ksea_d);
580  fPDFc->ScaleStrange (ksea_d);
581  fPDFc->ScaleCharm (ksea_u);
582  }
583 
584  // Rules of thumb
585  // ---------------------------------------
586  // - For W+ exchange use: -1/3|e| quarks and -2/3|e| antiquarks
587  // - For W- exchange use: 2/3|e| quarks and 1/3|e| antiquarks
588  // - For each qi -> qj transition multiply with the (ij CKM element)^2
589  // - Use isospin symmetry to get neutron's u,d from proton's u,d
590  // -- neutron d = proton u
591  // -- neutron u = proton d
592  // - Use u = usea + uvalence. Same for d
593  // - For s,c use q=qbar
594  // - For t,b use q=qbar=0
595 
596  fuv = fPDF -> UpValence();
597  fus = fPDF -> UpSea();
598  fdv = fPDF -> DownValence();
599  fds = fPDF -> DownSea();
600  fs = fPDF -> Strange();
601  fc = 0.;
602  fuv_c = fPDFc -> UpValence(); // will be 0 if < charm threshold
603  fus_c = fPDFc -> UpSea(); // ...
604  fdv_c = fPDFc -> DownValence(); // ...
605  fds_c = fPDFc -> DownSea(); // ...
606  fs_c = fPDFc -> Strange(); // ...
607  fc_c = fPDFc -> Charm(); // ...
608 
609  // The above are the proton parton density function. Get the PDFs for the
610  // hit nucleon (p or n) by swapping u<->d if necessary
611 
612  int nuc_pdgc = tgt.HitNucPdg();
613  bool isP = pdg::IsProton (nuc_pdgc);
614  bool isN = pdg::IsNeutron (nuc_pdgc);
615  assert(isP || isN);
616 
617  double tmp = 0;
618  if (isN) { // swap u <-> d
619  tmp = fuv; fuv = fdv; fdv = tmp;
620  tmp = fus; fus = fds; fds = tmp;
621  tmp = fuv_c; fuv_c = fdv_c; fdv_c = tmp;
622  tmp = fus_c; fus_c = fds_c; fds_c = tmp;
623  }
624 
625 }
double fQ2min
min Q^2 allowed for PDFs: PDF(Q2<Q2min):=PDF(Q2min)
int HitNucPdg(void) const
Definition: Target.cxx:304
PDF * fPDFc
computed PDFs @ (slow-rescaling-var,Q2)
double fMc
charm mass used
PDF * fPDF
computed PDFs @ (x,Q2)
void ScaleDownValence(double kscale)
Definition: PDF.cxx:86
bool IsNeutron(int pdgc)
Definition: PDGUtils.cxx:338
const TLorentzVector & HitNucP4(void) const
Definition: Target.h:91
double SlowRescalingVar(double x, double Q2, double M, double mc)
Definition: KineUtils.cxx:1244
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:333
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:96
virtual double Q2(const Interaction *i) const
A Neutrino Interaction Target. Is a transparent encapsulation of quite different physical systems suc...
Definition: Target.h:40
bool IsAboveCharmThreshold(double x, double Q2, double M, double mc)
Definition: KineUtils.cxx:1225
bool fCharmOff
turn charm production off?
#define pINFO
Definition: Messenger.h:62
string tmp
Definition: languages.py:63
virtual double ScalingVar(const Interaction *i) const
void Calculate(double x, double q2)
Definition: PDF.cxx:49
virtual void KFactors(const Interaction *i, double &kuv, double &kdv, double &kus, double &kds) const
void ScaleUpValence(double kscale)
Definition: PDF.cxx:81
list x
Definition: train.py:276
void ScaleUpSea(double kscale)
Definition: PDF.cxx:91
void ScaleCharm(double kscale)
Definition: PDF.cxx:106
void ScaleDownSea(double kscale)
Definition: PDF.cxx:96
#define pDEBUG
Definition: Messenger.h:63
void ScaleStrange(double kscale)
Definition: PDF.cxx:101
void QPMDISStrucFuncBase::Calculate ( const Interaction interaction) const
virtual

Calculate the structure functions F1-F6 for the input interaction.

Implements genie::DISStructureFuncModelI.

Definition at line 137 of file QPMDISStrucFuncBase.cxx.

138 {
139  // Reset mutable members
140  fF1 = 0;
141  fF2 = 0;
142  fF3 = 0;
143  fF4 = 0;
144  fF5 = 0;
145  fF6 = 0;
146 
147  // Get process info & perform various checks
148  const ProcessInfo & proc_info = interaction->ProcInfo();
149  const InitialState & init_state = interaction->InitState();
150  const Target & tgt = init_state.Tgt();
151 
152  int nuc_pdgc = tgt.HitNucPdg();
153  int probe_pdgc = init_state.ProbePdg();
154  bool is_p = pdg::IsProton ( nuc_pdgc );
155  bool is_n = pdg::IsNeutron ( nuc_pdgc );
156  bool is_nu = pdg::IsNeutrino ( probe_pdgc );
157  bool is_nubar = pdg::IsAntiNeutrino ( probe_pdgc );
158  bool is_lepton = pdg::IsLepton ( probe_pdgc );
159  bool is_dm = pdg::IsDarkMatter ( probe_pdgc );
160  bool is_CC = proc_info.IsWeakCC();
161  bool is_NC = proc_info.IsWeakNC();
162  bool is_EM = proc_info.IsEM();
163  bool is_dmi = proc_info.IsDarkMatter();
164 
165  if ( !is_lepton && !is_dm ) return;
166  if ( !is_p && !is_n ) return;
167  if ( tgt.N() == 0 && is_n ) return;
168  if ( tgt.Z() == 0 && is_p ) return;
169 
170  // Flags switching on/off quark contributions so that this algorithm can be
171  // used for both l + N -> l' + X, and l + q -> l' + q' level calculations
172 
173  double switch_uv = 1.;
174  double switch_us = 1.;
175  double switch_ubar = 1.;
176  double switch_dv = 1.;
177  double switch_ds = 1.;
178  double switch_dbar = 1.;
179  double switch_s = 1.;
180  double switch_sbar = 1.;
181  double switch_c = 1.;
182  double switch_cbar = 1.;
183 
184  if(tgt.HitQrkIsSet()) {
185 
186  switch_uv = 0.;
187  switch_us = 0.;
188  switch_ubar = 0.;
189  switch_dv = 0.;
190  switch_ds = 0.;
191  switch_dbar = 0.;
192  switch_s = 0.;
193  switch_sbar = 0.;
194  switch_c = 0.;
195  switch_cbar = 0.;
196 
197  int qpdg = tgt.HitQrkPdg();
198  bool sea = tgt.HitSeaQrk();
199 
200  bool is_u = pdg::IsUQuark (qpdg);
201  bool is_ubar = pdg::IsAntiUQuark (qpdg);
202  bool is_d = pdg::IsDQuark (qpdg);
203  bool is_dbar = pdg::IsAntiDQuark (qpdg);
204  bool is_s = pdg::IsSQuark (qpdg);
205  bool is_sbar = pdg::IsAntiSQuark (qpdg);
206  bool is_c = pdg::IsCQuark (qpdg);
207  bool is_cbar = pdg::IsAntiCQuark (qpdg);
208 
209  if (!sea && is_u ) { switch_uv = 1; }
210  else if ( sea && is_u ) { switch_us = 1; }
211  else if ( sea && is_ubar) { switch_ubar = 1; }
212  else if (!sea && is_d ) { switch_dv = 1; }
213  else if ( sea && is_d ) { switch_ds = 1; }
214  else if ( sea && is_dbar) { switch_dbar = 1; }
215  else if ( sea && is_s ) { switch_s = 1; }
216  else if ( sea && is_sbar) { switch_sbar = 1; }
217  else if ( sea && is_c ) { switch_c = 1; }
218  else if ( sea && is_cbar) { switch_cbar = 1; }
219  else return;
220 
221  // make sure user inputs make sense
222  if(is_nu && is_CC && is_u ) return;
223  if(is_nu && is_CC && is_c ) return;
224  if(is_nu && is_CC && is_dbar) return;
225  if(is_nu && is_CC && is_sbar) return;
226  if(is_nubar && is_CC && is_ubar) return;
227  if(is_nubar && is_CC && is_cbar) return;
228  if(is_nubar && is_CC && is_d ) return;
229  if(is_nubar && is_CC && is_s ) return;
230  }
231 
232  // Compute PDFs [both at (scaling-var,Q2) and (slow-rescaling-var,Q2)
233  // Applying all PDF K-factors abd scaling variable corrections
234 
235  this -> CalcPDFs (interaction);
236 
237  //
238  // Compute structure functions for the EM, NC and CC cases
239  //
240 
241  double F2val=0, xF3val=0;
242 
243  // *** NEUTRAL CURRENT
244 
245  // Include DM in NC
246  if(is_NC || is_dmi) {
247 
248  if(!is_nu && !is_nubar && !is_dm) return;
249 
250  double GL = (is_nu) ? ( 0.5 - (2./3.)*fSin2thw) : ( - (2./3.)*fSin2thw); // clu
251  double GR = (is_nu) ? ( - (2./3.)*fSin2thw) : ( 0.5 - (2./3.)*fSin2thw); // cru
252  double GLp = (is_nu) ? (-0.5 + (1./3.)*fSin2thw) : ( (1./3.)*fSin2thw); // cld
253  double GRp = (is_nu) ? ( (1./3.)*fSin2thw) : (-0.5 + (1./3.)*fSin2thw); // crd
254  // Set the couplings to up and down quarks to be axial for DM
255  if (is_dm) {
256  GL = -1.;
257  GR = 1.;
258  GLp = -1.;
259  GRp = 1.;
260  }
261  double gvu = GL + GR;
262  double gau = GL - GR;
263  double gvd = GLp + GRp;
264  double gad = GLp - GRp;
265  double gvu2 = TMath::Power(gvu, 2.);
266  double gau2 = TMath::Power(gau, 2.);
267  double gvd2 = TMath::Power(gvd, 2.);
268  double gad2 = TMath::Power(gad, 2.);
269 
270  double q2 = (switch_uv * fuv + switch_us * fus + switch_c * fc) * (gvu2+gau2) +
271  (switch_dv * fdv + switch_ds * fds + switch_s * fs) * (gvd2+gad2);
272  double q3 = (switch_uv * fuv + switch_us * fus + switch_c * fc) * (2*gvu*gau) +
273  (switch_dv * fdv + switch_ds * fds + switch_s * fs) * (2*gvd*gad);
274 
275  double qb2 = (switch_ubar * fus + switch_cbar * fc) * (gvu2+gau2) +
276  (switch_dbar * fds + switch_sbar * fs) * (gvd2+gad2);
277  double qb3 = (switch_ubar * fus + switch_cbar * fc) * (2*gvu*gau) +
278  (switch_dbar * fds + switch_sbar * fs) * (2*gvd*gad);
279 
280 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
281  LOG("DISSF", pINFO) << "f2 : q = " << q2 << ", bar{q} = " << qb2;
282  LOG("DISSF", pINFO) << "xf3: q = " << q3 << ", bar{q} = " << qb3;
283 #endif
284 
285  F2val = q2+qb2;
286  xF3val = q3-qb3;
287  }
288 
289  // *** CHARGED CURRENT
290 
291  if(is_CC) {
292  double q=0, qbar=0;
293 
294  if (is_nu) {
295  q = ( switch_dv * fdv + switch_ds * fds ) * fVud2 +
296  ( switch_s * fs ) * fVus2 +
297  ( switch_dv * fdv_c + switch_ds * fds_c ) * fVcd2 +
298  ( switch_s * fs_c ) * fVcs2;
299 
300  qbar = ( switch_ubar * fus ) * fVud2 +
301  ( switch_ubar * fus ) * fVus2 +
302  ( switch_cbar * fc_c ) * fVcd2 +
303  ( switch_cbar * fc_c ) * fVcs2;
304  }
305  else
306  if (is_nubar) {
307  q = ( switch_uv * fuv + switch_us * fus ) * fVud2 +
308  ( switch_uv * fuv + switch_us * fus ) * fVus2 +
309  ( switch_c * fc_c ) * fVcd2 +
310  ( switch_c * fc_c ) * fVcs2;
311 
312  qbar = ( switch_dbar * fds_c ) * fVcd2 +
313  ( switch_dbar * fds ) * fVud2 +
314  ( switch_sbar * fs ) * fVus2 +
315  ( switch_sbar * fs_c ) * fVcs2;
316  }
317  else {
318  return;
319  }
320 
321  F2val = 2*(q+qbar);
322  xF3val = 2*(q-qbar);
323  }
324 
325  // *** ELECTROMAGNETIC
326 
327  if(is_EM) {
328 
329  if(!pdg::IsChargedLepton(probe_pdgc)) return;
330 
331  double sq23 = TMath::Power(2./3., 2.);
332  double sq13 = TMath::Power(1./3., 2.);
333 
334  double qu = sq23 * ( switch_uv * fuv + switch_us * fus );
335  double qd = sq13 * ( switch_dv * fdv + switch_ds * fds );
336  double qs = sq13 * ( switch_s * fs );
337  double qbu = sq23 * ( switch_ubar * fus );
338  double qbd = sq13 * ( switch_dbar * fds );
339  double qbs = sq13 * ( switch_sbar * fs );
340 
341  double q = qu + qd + qs;
342  double qbar = qbu + qbd + qbs;
343 
344  F2val = q + qbar;;
345  xF3val = 0.;
346 
347  }
348 
349  double Q2val = this->Q2 (interaction);
350  double x = this->ScalingVar(interaction);
351  double f = this->NuclMod (interaction); // nuclear modification
352  double r = this->R (interaction); // R ~ FL
353 
354 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
355  LOG("DISSF", pDEBUG) << "Nucl. mod = " << f;
356  LOG("DISSF", pDEBUG) << "R(=FL/2xF1) = " << r;
357 #endif
358 
359  if(fUse2016Corrections) {
360  //It was confirmed by A.Bodek that the modified scaling variable
361  //should just be used to compute the strucure functions F2 and xF3,
362  //but that the usual Bjorken x should be used for the relations
363  //between the structure functions.
364  //For the same reason remove the freezing of Q2 at 0.8 for those relations,
365  //although it has not been explicitly asked to A.Bodek if it should be done.
366 
367  const Kinematics & kinematics = interaction->Kine();
368  double bjx = kinematics.x();
369 
370  double a = TMath::Power(bjx,2.) / TMath::Max(Q2val, fLowQ2CutoffF1F2);
371  double c = (1. + 4. * kNucleonMass2 * a) / (1.+r);
372 
373  fF3 = f * xF3val/bjx;
374  fF2 = f * F2val;
375  fF1 = fF2 * 0.5*c/bjx;
376  fF5 = fF2/bjx; // Albright-Jarlskog relation
377  fF4 = 0.; // Nucl.Phys.B 84, 467 (1975)
378  }
379  else {
380  double a = TMath::Power(x,2.) / TMath::Max(Q2val, fLowQ2CutoffF1F2);
381  double c = (1. + 4. * kNucleonMass2 * a) / (1.+r);
382  //double a = TMath::Power(x,2.) / Q2val;
383  //double c = (1. + 4. * kNucleonMass * a) / (1.+r);
384 
385  fF3 = f * xF3val / x;
386  fF2 = f * F2val;
387  fF1 = fF2 * 0.5 * c / x;
388  fF5 = fF2 / x; // Albright-Jarlskog relation
389  fF4 = 0.; // Nucl.Phys.B 84, 467 (1975)
390  }
391 
392 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
393  LOG("DISSF", pDEBUG)
394  << "F1-F5 = "
395  << fF1 << ", " << fF2 << ", " << fF3 << ", " << fF4 << ", " << fF5;
396 #endif
397 }
bool HitSeaQrk(void) const
Definition: Target.cxx:299
bool IsWeakCC(void) const
bool IsNeutrino(int pdgc)
Definition: PDGUtils.cxx:107
bool IsUQuark(int pdgc)
Definition: PDGUtils.cxx:263
int HitNucPdg(void) const
Definition: Target.cxx:304
int HitQrkPdg(void) const
Definition: Target.cxx:242
Generated/set kinematical variables for an event.
Definition: Kinematics.h:39
bool IsDarkMatter(int pdgc)
Definition: PDGUtils.cxx:124
bool IsChargedLepton(int pdgc)
Definition: PDGUtils.cxx:98
double x(bool selected=false) const
Definition: Kinematics.cxx:99
bool IsSQuark(int pdgc)
Definition: PDGUtils.cxx:273
bool IsAntiSQuark(int pdgc)
Definition: PDGUtils.cxx:303
bool IsAntiDQuark(int pdgc)
Definition: PDGUtils.cxx:298
bool IsNeutron(int pdgc)
Definition: PDGUtils.cxx:338
virtual double NuclMod(const Interaction *i) const
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:333
bool IsWeakNC(void) const
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:96
virtual double Q2(const Interaction *i) const
A class encapsulating an enumeration of interaction types (EM, Weak-CC, Weak-NC) and scattering types...
Definition: ProcessInfo.h:46
const double a
bool IsAntiNeutrino(int pdgc)
Definition: PDGUtils.cxx:115
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
int ProbePdg(void) const
Definition: InitialState.h:64
int Z(void) const
Definition: Target.h:68
#define pINFO
Definition: Messenger.h:62
static const double kNucleonMass2
Definition: Constants.h:89
virtual double ScalingVar(const Interaction *i) const
double fLowQ2CutoffF1F2
Set min for relation between 2xF1 and F2.
bool IsEM(void) const
int N(void) const
Definition: Target.h:69
bool IsCQuark(int pdgc)
Definition: PDGUtils.cxx:278
bool HitQrkIsSet(void) const
Definition: Target.cxx:292
bool IsDarkMatter(void) const
bool IsAntiCQuark(int pdgc)
Definition: PDGUtils.cxx:308
virtual double R(const Interaction *i) const
bool IsDQuark(int pdgc)
Definition: PDGUtils.cxx:268
const InitialState & InitState(void) const
Definition: Interaction.h:69
const ProcessInfo & ProcInfo(void) const
Definition: Interaction.h:70
list x
Definition: train.py:276
const Target & Tgt(void) const
Definition: InitialState.h:66
virtual void CalcPDFs(const Interaction *i) const
bool fUse2016Corrections
Use 2016 SF relation corrections.
bool IsLepton(int pdgc)
Definition: PDGUtils.cxx:83
bool IsAntiUQuark(int pdgc)
Definition: PDGUtils.cxx:293
Initial State information.
Definition: InitialState.h:48
#define pDEBUG
Definition: Messenger.h:63
void QPMDISStrucFuncBase::Configure ( const Registry config)
virtual

Configure the algorithm with an external registry The registry is merged with the top level registry if it is owned, Otherwise a copy of it is added with the highest priority

Reimplemented from genie::Algorithm.

Definition at line 68 of file QPMDISStrucFuncBase.cxx.

69 {
70  Algorithm::Configure(config);
71  this->LoadConfig();
72 }
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
void QPMDISStrucFuncBase::Configure ( string  config)
virtual

Configure the algorithm from the AlgoConfigPool based on param_set string given in input An algorithm contains a vector of registries coming from different xml configuration files, which are loaded according a very precise prioriy This methods will load a number registries in order of priority: 1) "Tunable" parameter set from CommonParametes. This is loaded with the highest prioriry and it is designed to be used for tuning procedure Usage not expected from the user. 2) For every string defined in "CommonParame" the corresponding parameter set will be loaded from CommonParameter.xml 3) parameter set specified by the config string and defined in the xml file of the algorithm 4) if config is not "Default" also the Default parameter set from the same xml file will be loaded Effectively this avoids the repetion of a parameter when it is not changed in the requested configuration

Reimplemented from genie::Algorithm.

Definition at line 74 of file QPMDISStrucFuncBase.cxx.

75 {
76  Algorithm::Configure(param_set);
77  this->LoadConfig();
78 }
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
virtual double genie::QPMDISStrucFuncBase::F1 ( void  ) const
inlinevirtual

Get the computed structure function F1.

Implements genie::DISStructureFuncModelI.

Definition at line 42 of file QPMDISStrucFuncBase.h.

42 { return fF1; }
virtual double genie::QPMDISStrucFuncBase::F2 ( void  ) const
inlinevirtual

Get the computed structure function F2.

Implements genie::DISStructureFuncModelI.

Definition at line 43 of file QPMDISStrucFuncBase.h.

43 { return fF2; }
virtual double genie::QPMDISStrucFuncBase::F3 ( void  ) const
inlinevirtual

Get the computed structure function F3.

Implements genie::DISStructureFuncModelI.

Definition at line 44 of file QPMDISStrucFuncBase.h.

44 { return fF3; }
virtual double genie::QPMDISStrucFuncBase::F4 ( void  ) const
inlinevirtual

Get the computed structure function F4.

Implements genie::DISStructureFuncModelI.

Definition at line 45 of file QPMDISStrucFuncBase.h.

45 { return fF4; }
virtual double genie::QPMDISStrucFuncBase::F5 ( void  ) const
inlinevirtual

Get the computed structure function F5.

Implements genie::DISStructureFuncModelI.

Definition at line 46 of file QPMDISStrucFuncBase.h.

46 { return fF5; }
virtual double genie::QPMDISStrucFuncBase::F6 ( void  ) const
inlinevirtual

Get the computed structure function F6.

Implements genie::DISStructureFuncModelI.

Definition at line 47 of file QPMDISStrucFuncBase.h.

47 { return fF6; }
void QPMDISStrucFuncBase::InitPDF ( void  )
protectedvirtual

Definition at line 130 of file QPMDISStrucFuncBase.cxx.

131 {
132  // evaluated at:
133  fPDF = new PDF(); // x = computed (+/-corrections) scaling var, Q2
134  fPDFc = new PDF(); // x = computed charm slow re-scaling var, Q2
135 }
PDF * fPDFc
computed PDFs @ (slow-rescaling-var,Q2)
PDF * fPDF
computed PDFs @ (x,Q2)
static QChar PDF((ushort) 0x202c)
void QPMDISStrucFuncBase::KFactors ( const Interaction i,
double &  kuv,
double &  kdv,
double &  kus,
double &  kds 
) const
protectedvirtual

Reimplemented in genie::BYStrucFunc.

Definition at line 434 of file QPMDISStrucFuncBase.cxx.

436 {
437 // This is an abstract class: no model-specific correction
438 // The PDF scaling variables are set to 1
439 // Override this method to compute model-dependent corrections
440 
441  kuv = 1.;
442  kdv = 1.;
443  kus = 1.;
444  kds = 1.;
445 }
void QPMDISStrucFuncBase::LoadConfig ( void  )
protectedvirtual

Definition at line 80 of file QPMDISStrucFuncBase.cxx.

81 {
82  LOG("DISSF", pDEBUG) << "Loading configuration...";
83 
84  //-- pdf
85  const PDFModelI * pdf_model =
86  dynamic_cast<const PDFModelI *> (this->SubAlg("PDF-Set"));
87  fPDF -> SetModel(pdf_model);
88  fPDFc -> SetModel(pdf_model);
89 
90  //-- get CKM elements
91  GetParam( "CKM-Vcd", fVcd ) ;
92  GetParam( "CKM-Vcs", fVcs ) ;
93  GetParam( "CKM-Vud", fVud ) ;
94  GetParam( "CKM-Vus", fVus ) ;
95 
96  fVcd2 = TMath::Power( fVcd, 2 );
97  fVcs2 = TMath::Power( fVcs, 2 );
98  fVud2 = TMath::Power( fVud, 2 );
99  fVus2 = TMath::Power( fVus, 2 );
100 
101  //-- charm mass
102  GetParam( "Charm-Mass", fMc ) ;
103 
104  //-- min Q2 for PDF evaluation
105  GetParam( "PDF-Q2min", fQ2min ) ;
106 
107  //-- include R (~FL)?
108  GetParam( "IncludeR", fIncludeR ) ;
109 
110  //-- include nuclear factor (shadowing / anti-shadowing / ...)
111  GetParam( "IncludeNuclMod", fIncludeNuclMod ) ;
112 
113  //-- Use 2016 SF relation corrections
114  GetParam( "Use2016Corrections", fUse2016Corrections ) ;
115 
116  //-- Set min for relation between 2xF1 and F2
117  GetParam( "LowQ2CutoffF1F2", fLowQ2CutoffF1F2 ) ;
118 
119  //-- turn charm production off?
120  GetParamDef( "Charm-Prod-Off", fCharmOff, false ) ;
121 
122  //-- weinberg angle
123  double thw ;
124  GetParam( "WeinbergAngle", thw ) ;
125  fSin2thw = TMath::Power(TMath::Sin(thw), 2);
126 
127  LOG("DISSF", pDEBUG) << "Done loading configuration";
128 }
double fVcd
CKM element Vcd used.
double fQ2min
min Q^2 allowed for PDFs: PDF(Q2<Q2min):=PDF(Q2min)
PDF * fPDFc
computed PDFs @ (slow-rescaling-var,Q2)
double fVud
CKM element Vud used.
bool fIncludeNuclMod
include nuclear factor (shadowing, anti-shadowing,...)?
double fMc
charm mass used
Pure abstract base class. Defines the PDFModelI interface to be implemented by wrapper classes to exi...
Definition: PDFModelI.h:28
PDF * fPDF
computed PDFs @ (x,Q2)
bool fIncludeR
include R (~FL) in DIS SF calculation?
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:96
bool fCharmOff
turn charm production off?
double fLowQ2CutoffF1F2
Set min for relation between 2xF1 and F2.
double fVus
CKM element Vcs used.
double fVcs
CKM element Vcs used.
bool GetParamDef(const RgKey &name, T &p, const T &def) const
bool GetParam(const RgKey &name, T &p, bool is_top_call=true) const
bool fUse2016Corrections
Use 2016 SF relation corrections.
#define pDEBUG
Definition: Messenger.h:63
const Algorithm * SubAlg(const RgKey &registry_key) const
Definition: Algorithm.cxx:345
double QPMDISStrucFuncBase::NuclMod ( const Interaction i) const
protectedvirtual

Definition at line 447 of file QPMDISStrucFuncBase.cxx.

448 {
449 // Nuclear modification to Fi
450 // The scaling variable can be overwritten to include corrections
451 
452  if( interaction->TestBit(kIAssumeFreeNucleon) ) return 1.0;
453  if( interaction->TestBit(kINoNuclearCorrection) ) return 1.0;
454 
455  double f = 1.;
456  if(fIncludeNuclMod) {
457  const Target & tgt = interaction->InitState().Tgt();
458 
459 // The x used for computing the DIS Nuclear correction factor should be the
460 // experimental x, not the rescaled x or off-shell-rest-frame version of x
461 // (i.e. selected x). Since we do not have access to experimental x at this
462 // point in the calculation, just use selected x.
463  const Kinematics & kine = interaction->Kine();
464  double x = kine.x();
465  int A = tgt.A();
467 #ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
468  LOG("DISSF", pDEBUG) << "Nuclear factor for x of " << x << " = " << f;
469 #endif
470  }
471 
472  return f;
473 }
int A(void) const
Definition: Target.h:70
Generated/set kinematical variables for an event.
Definition: Kinematics.h:39
double x(bool selected=false) const
Definition: Kinematics.cxx:99
bool fIncludeNuclMod
include nuclear factor (shadowing, anti-shadowing,...)?
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
A Neutrino Interaction Target. Is a transparent encapsulation of quite different physical systems suc...
Definition: Target.h:40
const UInt_t kIAssumeFreeNucleon
Definition: Interaction.h:49
#define A
Definition: memgrp.cpp:38
list x
Definition: train.py:276
double DISNuclFactor(double x, int A)
#define pDEBUG
Definition: Messenger.h:63
double QPMDISStrucFuncBase::Q2 ( const Interaction i) const
protectedvirtual

Definition at line 399 of file QPMDISStrucFuncBase.cxx.

400 {
401 // Return Q2 from the kinematics or, if not set, compute it from x,y
402 // The x might be corrected
403 
404  const Kinematics & kinematics = interaction->Kine();
405 
406  // if Q2 (or q2) is set then prefer this value
407  if (kinematics.KVSet(kKVQ2) || kinematics.KVSet(kKVq2)) {
408  double Q2val = kinematics.Q2();
409  return Q2val;
410  }
411  // if Q2 was not set, then compute it from x,y,Ev,Mnucleon
412  if (kinematics.KVSet(kKVy)) {
413  const InitialState & init_state = interaction->InitState();
414  double Mn = init_state.Tgt().HitNucP4Ptr()->M(); // could be off-shell
415  //double x = this->ScalingVar(interaction); // could be redefined
416  double x = kinematics.x();
417  double y = kinematics.y();
418  double Ev = init_state.ProbeE(kRfHitNucRest);
419  double Q2val = 2*Mn*Ev*x*y;
420  return Q2val;
421  }
422  LOG("DISSF", pERROR) << "Could not compute Q2!";
423  return 0;
424 }
#define pERROR
Definition: Messenger.h:59
Generated/set kinematical variables for an event.
Definition: Kinematics.h:39
double x(bool selected=false) const
Definition: Kinematics.cxx:99
double y(bool selected=false) const
Definition: Kinematics.cxx:112
#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
TLorentzVector * HitNucP4Ptr(void) const
Definition: Target.cxx:247
list x
Definition: train.py:276
double Q2(bool selected=false) const
Definition: Kinematics.cxx:125
const Target & Tgt(void) const
Definition: InitialState.h:66
double ProbeE(RefFrame_t rf) const
Initial State information.
Definition: InitialState.h:48
double QPMDISStrucFuncBase::R ( const Interaction i) const
protectedvirtual

Definition at line 475 of file QPMDISStrucFuncBase.cxx.

476 {
477 // Computes R ( ~ longitudinal structure function FL = R * 2xF1)
478 // The scaling variable can be overwritten to include corrections
479 
480 // The x used for computing the DIS Nuclear correction factor should be the
481 // experimental x, not the rescaled x or off-shell-rest-frame version of x
482 // (i.e. selected x). Since we do not have access to experimental x at this
483 // point in the calculation, just use selected x.
484  if(fIncludeR) {
485  const Kinematics & kine = interaction->Kine();
486  double x = kine.x();
487 // double x = this->ScalingVar(interaction);
488  double Q2val = this->Q2(interaction);
489  double Rval = utils::phys::RWhitlow(x, Q2val);
490  return Rval;
491  }
492  return 0;
493 }
Generated/set kinematical variables for an event.
Definition: Kinematics.h:39
double x(bool selected=false) const
Definition: Kinematics.cxx:99
bool fIncludeR
include R (~FL) in DIS SF calculation?
virtual double Q2(const Interaction *i) const
list x
Definition: train.py:276
double RWhitlow(double x, double Q2)
Definition: PhysUtils.cxx:75
double QPMDISStrucFuncBase::ScalingVar ( const Interaction i) const
protectedvirtual

Reimplemented in genie::BYStrucFunc.

Definition at line 426 of file QPMDISStrucFuncBase.cxx.

427 {
428 // The scaling variable is set to the normal Bjorken x.
429 // Override DISStructureFuncModel::ScalingVar() to compute corrections
430 
431  return interaction->Kine().x();
432 }

Member Data Documentation

double genie::QPMDISStrucFuncBase::fc
mutableprotected

Definition at line 104 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fc_c
mutableprotected

Definition at line 110 of file QPMDISStrucFuncBase.h.

bool genie::QPMDISStrucFuncBase::fCharmOff
protected

turn charm production off?

Definition at line 75 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fds
mutableprotected

Definition at line 102 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fds_c
mutableprotected

Definition at line 108 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fdv
mutableprotected

Definition at line 101 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fdv_c
mutableprotected

Definition at line 107 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fF1
mutableprotected

Definition at line 91 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fF2
mutableprotected

Definition at line 92 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fF3
mutableprotected

Definition at line 93 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fF4
mutableprotected

Definition at line 94 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fF5
mutableprotected

Definition at line 95 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fF6
mutableprotected

Definition at line 96 of file QPMDISStrucFuncBase.h.

bool genie::QPMDISStrucFuncBase::fIncludeNuclMod
protected

include nuclear factor (shadowing, anti-shadowing,...)?

Definition at line 77 of file QPMDISStrucFuncBase.h.

bool genie::QPMDISStrucFuncBase::fIncludeR
protected

include R (~FL) in DIS SF calculation?

Definition at line 76 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fLowQ2CutoffF1F2
protected

Set min for relation between 2xF1 and F2.

Definition at line 89 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fMc
protected

charm mass used

Definition at line 78 of file QPMDISStrucFuncBase.h.

PDF* genie::QPMDISStrucFuncBase::fPDF
protected

computed PDFs @ (x,Q2)

Definition at line 97 of file QPMDISStrucFuncBase.h.

PDF* genie::QPMDISStrucFuncBase::fPDFc
protected

computed PDFs @ (slow-rescaling-var,Q2)

Definition at line 98 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fQ2min
protected

min Q^2 allowed for PDFs: PDF(Q2<Q2min):=PDF(Q2min)

Definition at line 74 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fs
mutableprotected

Definition at line 103 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fs_c
mutableprotected

Definition at line 109 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fSin2thw
protected

Definition at line 87 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fus
mutableprotected

Definition at line 100 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fus_c
mutableprotected

Definition at line 106 of file QPMDISStrucFuncBase.h.

bool genie::QPMDISStrucFuncBase::fUse2016Corrections
protected

Use 2016 SF relation corrections.

Definition at line 88 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fuv
mutableprotected

Definition at line 99 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fuv_c
mutableprotected

Definition at line 105 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fVcd
protected

CKM element Vcd used.

Definition at line 79 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fVcd2
protected

Definition at line 83 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fVcs
protected

CKM element Vcs used.

Definition at line 80 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fVcs2
protected

Definition at line 84 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fVud
protected

CKM element Vud used.

Definition at line 81 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fVud2
protected

Definition at line 85 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fVus
protected

CKM element Vcs used.

Definition at line 82 of file QPMDISStrucFuncBase.h.

double genie::QPMDISStrucFuncBase::fVus2
protected

Definition at line 86 of file QPMDISStrucFuncBase.h.


The documentation for this class was generated from the following files: