Public Member Functions | Private Member Functions | Private Attributes | List of all members
genie::RSHelicityAmplModelNCp Class Reference

The Helicity Amplitudes, for all baryon resonances, for NC neutrino interactions on free protons, as computed in the Rein-Sehgal's paper. More...

#include <RSHelicityAmplModelNCp.h>

Inheritance diagram for genie::RSHelicityAmplModelNCp:
genie::RSHelicityAmplModelI genie::Algorithm

Public Member Functions

 RSHelicityAmplModelNCp ()
 
 RSHelicityAmplModelNCp (string config)
 
virtual ~RSHelicityAmplModelNCp ()
 
const RSHelicityAmpl & Compute (Resonance_t res, const FKR &fkr) const
 
void Configure (const Registry &config)
 
void Configure (string config)
 
- Public Member Functions inherited from genie::RSHelicityAmplModelI
virtual ~RSHelicityAmplModelI ()
 
- Public Member Functions inherited from genie::Algorithm
virtual ~Algorithm ()
 
virtual void FindConfig (void)
 
virtual const Registry & GetConfig (void) const
 
Registry * GetOwnedConfig (void)
 
virtual const AlgId & Id (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 Algorithm * SubAlg (const RgKey &registry_key) const
 
void AdoptConfig (void)
 
void AdoptSubstructure (void)
 
virtual void Print (ostream &stream) const
 Print algorithm info. More...
 

Private Member Functions

void LoadConfig (void)
 

Private Attributes

RSHelicityAmpl fAmpl
 
double fSin28w
 

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)
 
- Protected Member Functions inherited from genie::RSHelicityAmplModelI
 RSHelicityAmplModelI ()
 
 RSHelicityAmplModelI (string name)
 
 RSHelicityAmplModelI (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)
 
Registry * ExtractLocalConfig (const Registry &in) const
 
Registry * ExtractLowerConfig (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 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< bool > fOwnerships
 ownership for every registry in fConfVect More...
 
AlgStatus_t fStatus
 algorithm execution status More...
 
AlgMap * fOwnedSubAlgMp
 local pool for owned sub-algs (taken out of the factory pool) More...
 

Detailed Description

The Helicity Amplitudes, for all baryon resonances, for NC neutrino interactions on free protons, as computed in the Rein-Sehgal's paper.

Concrete implementation of the RSHelicityAmplModelI interface.

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

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 28 of file RSHelicityAmplModelNCp.h.

Constructor & Destructor Documentation

RSHelicityAmplModelNCp::RSHelicityAmplModelNCp ( )

Definition at line 23 of file RSHelicityAmplModelNCp.cxx.

23  :
24 RSHelicityAmplModelI("genie::RSHelicityAmplModelNCp")
25 {
26 
27 }
RSHelicityAmplModelNCp::RSHelicityAmplModelNCp ( string  config)

Definition at line 29 of file RSHelicityAmplModelNCp.cxx.

29  :
30 RSHelicityAmplModelI("genie::RSHelicityAmplModelNCp", config)
31 {
32 
33 }
config
static Config * config
Definition: config.cpp:1054
RSHelicityAmplModelNCp::~RSHelicityAmplModelNCp ( )
virtual

Definition at line 35 of file RSHelicityAmplModelNCp.cxx.

36 {
37 
38 }

Member Function Documentation

const RSHelicityAmpl & RSHelicityAmplModelNCp::Compute ( Resonance_t  res,
const FKR &  fkr 
) const
virtual

Implements genie::RSHelicityAmplModelI.

Definition at line 41 of file RSHelicityAmplModelNCp.cxx.

43 {
44  double xi = fSin28w;
45 
46  switch(res) {
47 
48  case (kP33_1232) :
49  {
50  double rx = 2 * xi * fkr.R;
51  double Rm2xiR = fkr.Rminus + rx;
52  double Rp2xiR = fkr.Rplus + rx;
53 
54  fAmpl.fMinus1 = -kSqrt2 * Rm2xiR;
55  fAmpl.fPlus1 = kSqrt2 * Rp2xiR;
56  fAmpl.fMinus3 = -kSqrt6 * Rm2xiR;
57  fAmpl.fPlus3 = kSqrt6 * Rp2xiR;
58  fAmpl.f0Minus = 2*kSqrt2 * fkr.C;
59  fAmpl.f0Plus = fAmpl.f0Minus;
60  break;
61  }
62  case (kS11_1535) :
63  {
64  double xr = 3*xi*fkr.R;
65  double xt = 2*xi*fkr.T;
66  double Tm2xiT = fkr.Tminus + xt;
67  double Tp2xiT = fkr.Tplus + xt;
68  double LRm3xiR = fkr.Lamda * (fkr.Rminus + xr);
69  double LRp3xiR = fkr.Lamda * (fkr.Rplus + xr);
70  double a = kSqrt3_2 * (1-2*xi) * fkr.Lamda * fkr.S;
71  double b = kSqrt2_3 * (fkr.Lamda * fkr.C - 3*fkr.B);
72 
73  fAmpl.fMinus1 = kSqrt3 * Tm2xiT + kSqrt2_3 * LRm3xiR;
74  fAmpl.fPlus1 = -1.*kSqrt3 * Tp2xiT - kSqrt2_3 * LRp3xiR;
75  fAmpl.fMinus3 = 0.;
76  fAmpl.fPlus3 = 0.;
77  fAmpl.f0Minus = -a + b;
78  fAmpl.f0Plus = a + b;
79  break;
80  }
81  case (kD13_1520) :
82  {
83  double xr = 3*xi*fkr.R;
84  double xt = 2*xi*fkr.T;
85  double Tm2xiT = fkr.Tminus + xt;
86  double Tp2xiT = fkr.Tplus + xt;
87  double LRm3xiR = fkr.Lamda * (fkr.Rminus + xr);
88  double LRp3xiR = fkr.Lamda * (fkr.Rplus + xr);
89  double a = kSqrt3 * (1-2*xi) * fkr.Lamda * fkr.S;
90  double b = (2./kSqrt3) * fkr.Lamda * fkr.C;
91 
92  fAmpl.fMinus1 = kSqrt3_2 * Tm2xiT - k2_Sqrt3 * LRm3xiR;
93  fAmpl.fPlus1 = kSqrt3_2 * Tp2xiT - k2_Sqrt3 * LRp3xiR;
94  fAmpl.fMinus3 = k3_Sqrt2 * Tm2xiT;
95  fAmpl.fPlus3 = k3_Sqrt2 * Tp2xiT;
96  fAmpl.f0Minus = -a + b;
97  fAmpl.f0Plus = -a - b;
98  break;
99  }
100  case (kS11_1650) :
101  {
102  fAmpl.fMinus1 = k1_Sqrt24 * fkr.Lamda * fkr.Rminus;
103  fAmpl.fPlus1 = -k1_Sqrt24 * fkr.Lamda * fkr.Rplus;
104  fAmpl.fMinus3 = 0.;
105  fAmpl.fPlus3 = 0.;
106  fAmpl.f0Minus = -k1_Sqrt6 * (fkr.Lamda * fkr.C - 3*fkr.B);
107  fAmpl.f0Plus = fAmpl.f0Minus;
108  break;
109  }
110  case (kD13_1700) :
111  {
112  double LRm = fkr.Lamda * fkr.Rminus;
113  double LRp = fkr.Lamda * fkr.Rplus;
114 
115  fAmpl.fMinus1 = k1_Sqrt120 * LRm;
116  fAmpl.fPlus1 = k1_Sqrt120 * LRp;
117  fAmpl.fMinus3 = k3_Sqrt40 * LRm;
118  fAmpl.fPlus3 = k3_Sqrt40 * LRp;
119  fAmpl.f0Minus = k1_Sqrt30 * fkr.Lamda * fkr.C;
120  fAmpl.f0Plus = -1.* fAmpl.f0Minus;
121  break;
122  }
123  case (kD15_1675) :
124  {
125  double LRm = fkr.Lamda * fkr.Rminus;
126  double LRp = fkr.Lamda * fkr.Rplus;
127 
128  fAmpl.fMinus1 = -kSqrt3_40 * LRm;
129  fAmpl.fPlus1 = kSqrt3_40 * LRp;
130  fAmpl.fMinus3 = -kSqrt3_20 * LRm;
131  fAmpl.fPlus3 = kSqrt3_20 * LRp;
132  fAmpl.f0Minus = kSqrt3_10 * fkr.Lamda * fkr.C;
133  fAmpl.f0Plus = fAmpl.f0Minus;
134  break;
135  }
136  case (kS31_1620) :
137  {
138  double xt = 2*xi*fkr.T;
139  double xr = 2*xi*fkr.R;
140  double Tm2xiT = fkr.Tminus + xt;
141  double Tp2xiT = fkr.Tplus + xt;
142  double LRm2xiR = fkr.Lamda * (fkr.Rminus + xr);
143  double LRp2xiR = fkr.Lamda * (fkr.Rplus + xr);
144  double a = kSqrt3_2 * (1-2*xi) * fkr.Lamda * fkr.S;
145  double b = k1_Sqrt6 * (fkr.Lamda * fkr.C - 3*fkr.B);
146 
147  fAmpl.fMinus1 = kSqrt3 * Tm2xiT - k1_Sqrt6 * LRm2xiR;
148  fAmpl.fPlus1 = -kSqrt3 * Tp2xiT + k1_Sqrt6 * LRp2xiR;
149  fAmpl.fMinus3 = 0.;
150  fAmpl.fPlus3 = 0.;
151  fAmpl.f0Minus = -a-b;
152  fAmpl.f0Plus = a-b;
153  break;
154  }
155  case (kD33_1700) :
156  {
157  double xt = 2*xi*fkr.T;
158  double xr = 2*xi*fkr.R;
159  double Tm2xiT = fkr.Tminus + xt;
160  double Tp2xiT = fkr.Tplus + xt;
161  double LRm2xiR = fkr.Lamda * (fkr.Rminus + xr);
162  double LRp2xiR = fkr.Lamda * (fkr.Rplus + xr);
163  double a = kSqrt3 * (1-2*xi) * fkr.Lamda * fkr.S;
164  double b = k1_Sqrt3 * fkr.Lamda * fkr.C;
165 
166  fAmpl.fMinus1 = kSqrt3_2 * Tm2xiT + k1_Sqrt3 * LRm2xiR;
167  fAmpl.fPlus1 = kSqrt3_2 * Tp2xiT + k1_Sqrt3 * LRp2xiR;
168  fAmpl.fMinus3 = k3_Sqrt2 * Tm2xiT;
169  fAmpl.fPlus3 = k3_Sqrt2 * Tp2xiT;
170  fAmpl.f0Minus = -a-b;
171  fAmpl.f0Plus = -a+b;
172  break;
173  }
174  case (kP11_1440) :
175  {
176  double c = (5./12.)*kSqrt3;
177  double xr = (12./5.)*xi*fkr.R;
178  double L2 = TMath::Power(fkr.Lamda, 2);
179  double L2RmxiR = L2 * (fkr.Rminus + xr);
180  double L2RpxiR = L2 * (fkr.Rplus + xr);
181  double a = 0.25 * kSqrt3 * (1-4*xi) * L2 * fkr.S;
182  double b = c * (L2 * fkr.C - 2 * fkr.Lamda * fkr.B);
183 
184  fAmpl.fMinus1 = -c * L2RmxiR;
185  fAmpl.fPlus1 = -c * L2RpxiR;
186  fAmpl.fMinus3 = 0.;
187  fAmpl.fPlus3 = 0.;
188  fAmpl.f0Minus = -a+b;
189  fAmpl.f0Plus = -a-b;
190  break;
191  }
192  case (kP33_1600) :
193  {
194  double xr = 2*xi*fkr.R;
195  double L2 = TMath::Power(fkr.Lamda, 2);
196  double L2RmxiR = L2 * (fkr.Rminus + xr);
197  double L2RpxiR = L2 * (fkr.Rplus + xr);
198 
199  fAmpl.fMinus1 = k1_Sqrt6 * L2RmxiR;
200  fAmpl.fPlus1 = -k1_Sqrt6 * L2RpxiR;
201  fAmpl.fMinus3 = k1_Sqrt2 * L2RmxiR;
202  fAmpl.fPlus3 = -k1_Sqrt2 * L2RpxiR;
203  fAmpl.f0Minus = -kSqrt2_3 * (L2 * fkr.C - 2 * fkr.Lamda * fkr.B);
204  fAmpl.f0Plus = fAmpl.f0Minus;
205  break;
206  }
207  case (kP13_1720) :
208  {
209  double xt = 4*xi*fkr.T;
210  double xr = (12./5.)*xi*fkr.R;
211  double L2 = TMath::Power(fkr.Lamda, 2);
212  double LTm4xiT = fkr.Lamda * (fkr.Tminus + xt);
213  double LTp4xiT = fkr.Lamda * (fkr.Tplus + xt);
214  double L2RmxiR = L2 * (fkr.Rminus + xr);
215  double L2RpxiR = L2 * (fkr.Rplus + xr);
216  double a = kSqrt3_20 * (1-4*xi) * L2 * fkr.S;
217  double b = kSqrt5_12 * (L2 * fkr.C - 5 * fkr.Lamda * fkr.B);
218 
219  fAmpl.fMinus1 = -kSqrt27_40 * LTm4xiT - kSqrt5_12 * L2RmxiR;
220  fAmpl.fPlus1 = kSqrt27_40 * LTp4xiT + kSqrt5_12 * L2RpxiR;
221  fAmpl.fMinus3 = k3_Sqrt40 * LTm4xiT;
222  fAmpl.fPlus3 = -k3_Sqrt40 * LTp4xiT;
223  fAmpl.f0Minus = a-b;
224  fAmpl.f0Plus = -a-b;
225  break;
226  }
227  case (kF15_1680) :
228  {
229  double xt = 4. * xi *fkr.T;
230  double xr = (12./5.) * xi * fkr.R;
231  double L2 = TMath::Power(fkr.Lamda, 2);
232  double LTm4xiT = fkr.Lamda * (fkr.Tminus + xt);
233  double LTp4xiT = fkr.Lamda * (fkr.Tplus + xt);
234  double L2RmxiR = L2 * (fkr.Rminus + xr);
235  double L2RpxiR = L2 * (fkr.Rplus + xr);
236  double a = k3_Sqrt40 * (1-4*xi)* L2 * fkr.S;
237  double b = kSqrt5_8 * L2 * fkr.C;
238 
239  fAmpl.fMinus1 = -k3_Sqrt20 * LTm4xiT + kSqrt5_8 * L2RmxiR;
240  fAmpl.fPlus1 = -k3_Sqrt20 * LTp4xiT + kSqrt5_8 * L2RpxiR;
241  fAmpl.fMinus3 = -kSqrt18_20 * LTm4xiT;
242  fAmpl.fPlus3 = -kSqrt18_20 * LTp4xiT;
243  fAmpl.f0Minus = a - b;
244  fAmpl.f0Plus = a + b;
245  break;
246  }
247  case (kP31_1910) :
248  {
249  double xr = 2*xi*fkr.R;
250  double L2 = TMath::Power(fkr.Lamda, 2);
251 
252  fAmpl.fMinus1 = -k1_Sqrt15 * L2 * (fkr.Rminus + xr);
253  fAmpl.fPlus1 = -k1_Sqrt15 * L2 * (fkr.Rplus + xr);
254  fAmpl.fMinus3 = 0.;
255  fAmpl.fPlus3 = 0.;
256  fAmpl.f0Minus = -kSqrt4_15 * (L2 * fkr.C - 5 * fkr.Lamda * fkr.B);
257  fAmpl.f0Plus = -1.* fAmpl.f0Minus;
258  break;
259  }
260  case (kP33_1920) :
261  {
262  double xr = 2*xi*fkr.R;
263  double L2 = TMath::Power(fkr.Lamda, 2);
264  double L2Rm2xiR = L2 * (fkr.Rminus + xr);
265  double L2Rp2xiR = L2 * (fkr.Rplus + xr);
266 
267  fAmpl.fMinus1 = k1_Sqrt15 * L2Rm2xiR;
268  fAmpl.fPlus1 = -k1_Sqrt15 * L2Rp2xiR;
269  fAmpl.fMinus3 = -k1_Sqrt5 * L2Rm2xiR;
270  fAmpl.fPlus3 = k1_Sqrt5 * L2Rp2xiR;
271  fAmpl.f0Minus = -(2./kSqrt15) * (L2 * fkr.C - 5 * fkr.Lamda * fkr.B);
272  fAmpl.f0Plus = fAmpl.f0Minus;
273  break;
274  }
275  case (kF35_1905) :
276  {
277  double xr = 2*xi*fkr.R;
278  double L2 = TMath::Power(fkr.Lamda, 2);
279  double L2Rm2xiR = L2 * (fkr.Rminus + xr);
280  double L2Rp2xiR = L2 * (fkr.Rplus + xr);
281 
282  fAmpl.fMinus1 = k1_Sqrt35 * L2Rm2xiR;
283  fAmpl.fPlus1 = k1_Sqrt35 * L2Rp2xiR;
284  fAmpl.fMinus3 = kSqrt18_35 * L2Rm2xiR;
285  fAmpl.fPlus3 = kSqrt18_35 * L2Rp2xiR;
286  fAmpl.f0Minus = k2_Sqrt35 * L2 * fkr.C;
287  fAmpl.f0Plus = -1. * fAmpl.f0Minus;
288  break;
289  }
290  case (kF37_1950) :
291  {
292  double xr = 2*xi*fkr.R;
293  double L2 = TMath::Power(fkr.Lamda, 2);
294  double L2Rm2xiR = L2 * (fkr.Rminus + xr);
295  double L2Rp2xiR = L2 * (fkr.Rplus + xr);
296 
297  fAmpl.fMinus1 = -kSqrt6_35 * L2Rm2xiR;
298  fAmpl.fPlus1 = kSqrt6_35 * L2Rp2xiR;
299  fAmpl.fMinus3 = -kSqrt2_7 * L2Rm2xiR;
300  fAmpl.fPlus3 = kSqrt2_7 * L2Rp2xiR;
301  fAmpl.f0Minus = 2*kSqrt6_35 * L2 * fkr.C;
302  fAmpl.f0Plus = fAmpl.f0Minus;
303  break;
304  }
305  case (kP11_1710) :
306  {
307  double L2 = TMath::Power(fkr.Lamda, 2);
308  double Rm3xiR = fkr.Rminus + 3*xi*fkr.R;
309  double Rp3xiR = fkr.Rplus + 3*xi*fkr.R;
310  double a = kSqrt3_8 * (1-2*xi) * L2 * fkr.S;
311  double b = k1_Sqrt6 * (L2 * fkr.C - 2 * fkr.Lamda * fkr.B);
312 
313  fAmpl.fMinus1 = k1_Sqrt6 * L2 * Rm3xiR;
314  fAmpl.fPlus1 = k1_Sqrt6 * L2 * Rp3xiR;
315  fAmpl.fMinus3 = 0.;
316  fAmpl.fPlus3 = 0.;
317  fAmpl.f0Minus = a-b;
318  fAmpl.f0Plus = a+b;
319  break;
320  }
321  case (kF17_1970) :
322  {
323  fAmpl.fMinus1 = 0.;
324  fAmpl.fPlus1 = 0.;
325  fAmpl.fMinus3 = 0.;
326  fAmpl.fPlus3 = 0.;
327  fAmpl.f0Minus = 0.;
328  fAmpl.f0Plus = 0.;
329  break;
330  }
331  default:
332  {
333  LOG("RSHAmpl", pWARN) << "*** UNRECOGNIZED RESONANCE!";
334  fAmpl.fMinus1 = 0.;
335  fAmpl.fPlus1 = 0.;
336  fAmpl.fMinus3 = 0.;
337  fAmpl.fPlus3 = 0.;
338  fAmpl.f0Minus = 0.;
339  fAmpl.f0Plus = 0.;
340  break;
341  }
342 
343  }//switch
344 
345  return fAmpl;
346 }
genie::constants::kSqrt3_40
static const double kSqrt3_40
Definition: Constants.h:169
genie::constants::kSqrt3
static const double kSqrt3
Definition: Constants.h:116
genie::constants::kSqrt2
static const double kSqrt2
Definition: Constants.h:115
genie::constants::kSqrt15
static const double kSqrt15
Definition: Constants.h:125
genie::FKR::Rminus
double Rminus
Definition: FKR.h:50
genie::constants::kSqrt6
static const double kSqrt6
Definition: Constants.h:119
genie::constants::k1_Sqrt5
static const double k1_Sqrt5
Definition: Constants.h:137
genie::FKR::Lamda
double Lamda
Definition: FKR.h:37
genie::FKR::R
double R
Definition: FKR.h:45
genie::constants::k1_Sqrt3
static const double k1_Sqrt3
Definition: Constants.h:136
genie::constants::k1_Sqrt6
static const double k1_Sqrt6
Definition: Constants.h:138
genie::constants::kSqrt27_40
static const double kSqrt27_40
Definition: Constants.h:184
genie::constants::kSqrt5_12
static const double kSqrt5_12
Definition: Constants.h:174
genie::constants::k3_Sqrt2
static const double k3_Sqrt2
Definition: Constants.h:151
LOG
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:96
genie::constants::k1_Sqrt120
static const double k1_Sqrt120
Definition: Constants.h:146
a
const double a
Definition: gUpMuFluxGen.cxx:164
genie::constants::kSqrt18_20
static const double kSqrt18_20
Definition: Constants.h:180
genie::FKR::T
double T
Definition: FKR.h:46
genie::constants::kSqrt2_7
static const double kSqrt2_7
Definition: Constants.h:159
genie::constants::k3_Sqrt40
static const double k3_Sqrt40
Definition: Constants.h:155
genie::constants::k1_Sqrt35
static const double k1_Sqrt35
Definition: Constants.h:144
genie::constants::kSqrt3_10
static const double kSqrt3_10
Definition: Constants.h:165
genie::constants::k1_Sqrt24
static const double k1_Sqrt24
Definition: Constants.h:142
genie::constants::kSqrt3_8
static const double kSqrt3_8
Definition: Constants.h:164
genie::constants::kSqrt3_2
static const double kSqrt3_2
Definition: Constants.h:161
genie::constants::k2_Sqrt3
static const double k2_Sqrt3
Definition: Constants.h:147
pWARN
#define pWARN
Definition: Messenger.h:60
genie::constants::kSqrt4_15
static const double kSqrt4_15
Definition: Constants.h:170
genie::constants::k1_Sqrt15
static const double k1_Sqrt15
Definition: Constants.h:141
genie::FKR::C
double C
Definition: FKR.h:44
genie::FKR::Tplus
double Tplus
Definition: FKR.h:47
genie::constants::kSqrt5_8
static const double kSqrt5_8
Definition: Constants.h:173
genie::FKR::B
double B
Definition: FKR.h:43
genie::FKR::Rplus
double Rplus
Definition: FKR.h:49
genie::FKR::Tminus
double Tminus
Definition: FKR.h:48
genie::constants::kSqrt2_3
static const double kSqrt2_3
Definition: Constants.h:156
b
static bool * b
Definition: config.cpp:1043
genie::constants::k3_Sqrt20
static const double k3_Sqrt20
Definition: Constants.h:154
genie::constants::k2_Sqrt35
static const double k2_Sqrt35
Definition: Constants.h:150
genie::constants::k1_Sqrt2
static const double k1_Sqrt2
Definition: Constants.h:135
genie::constants::k1_Sqrt30
static const double k1_Sqrt30
Definition: Constants.h:143
genie::constants::kSqrt3_20
static const double kSqrt3_20
Definition: Constants.h:167
genie::FKR::S
double S
Definition: FKR.h:40
genie::constants::kSqrt6_35
static const double kSqrt6_35
Definition: Constants.h:176
genie::constants::kSqrt18_35
static const double kSqrt18_35
Definition: Constants.h:181
void RSHelicityAmplModelNCp::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 348 of file RSHelicityAmplModelNCp.cxx.

349 {
350  Algorithm::Configure(config);
351  this->LoadConfig();
352 }
genie::Algorithm::Configure
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
void RSHelicityAmplModelNCp::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 354 of file RSHelicityAmplModelNCp.cxx.

355 {
356  Algorithm::Configure(config);
357  this->LoadConfig();
358 }
config
static Config * config
Definition: config.cpp:1054
genie::Algorithm::Configure
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
void RSHelicityAmplModelNCp::LoadConfig ( void  )
private

Definition at line 360 of file RSHelicityAmplModelNCp.cxx.

361 {
362  double thw ;
363  GetParam( "WeinbergAngle", thw ) ;
364  fSin28w = TMath::Power( TMath::Sin(thw), 2 );
365 }
genie::Algorithm::GetParam
bool GetParam(const RgKey &name, T &p, bool is_top_call=true) const

Member Data Documentation

RSHelicityAmpl genie::RSHelicityAmplModelNCp::fAmpl
mutableprivate

Definition at line 46 of file RSHelicityAmplModelNCp.h.

double genie::RSHelicityAmplModelNCp::fSin28w
private

Definition at line 48 of file RSHelicityAmplModelNCp.h.

The documentation for this class was generated from the following files:
Generated by   doxygen 1.8.11