GENIEGenerator
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Private Member Functions | Private Attributes | List of all members
genie::RSHelicityAmplModelNCn Class Reference

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

#include <RSHelicityAmplModelNCn.h>

Inheritance diagram for genie::RSHelicityAmplModelNCn:
Inheritance graph
[legend]
Collaboration diagram for genie::RSHelicityAmplModelNCn:
Collaboration graph
[legend]

Public Member Functions

 RSHelicityAmplModelNCn ()
 
 RSHelicityAmplModelNCn (string config)
 
virtual ~RSHelicityAmplModelNCn ()
 
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)
 
static string BuildParamMatKey (const std::string &comm_name, unsigned int i, unsigned int j)
 
static string BuildParamMatRowSizeKey (const std::string &comm_name)
 
static string BuildParamMatColSizeKey (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
 
template<class T >
int GetParamMat (const std::string &comm_name, TMatrixT< T > &mat, bool is_top_call=true) const
 Handle to load matrix of parameters. More...
 
template<class T >
int GetParamMatSym (const std::string &comm_name, TMatrixTSym< T > &mat, bool is_top_call=true) const
 
int GetParamMatKeys (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 neutrons, as computed in the Rein-Sehgal's paper. 

      Concrete implementation of the RSHelicityAmplModelI interface.
Author
Costas Andreopoulos <c.andreopoulos cern.ch> University of Liverpool
Created:
May 03, 2004
License:
Copyright (c) 2003-2024, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 28 of file RSHelicityAmplModelNCn.h.

Constructor & Destructor Documentation

RSHelicityAmplModelNCn::RSHelicityAmplModelNCn ( )

Definition at line 23 of file RSHelicityAmplModelNCn.cxx.

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

Definition at line 29 of file RSHelicityAmplModelNCn.cxx.

29  :
30 RSHelicityAmplModelI("genie::RSHelicityAmplModelNCn", config)
31 {
32 
33 }
RSHelicityAmplModelNCn::~RSHelicityAmplModelNCn ( )
virtual

Definition at line 35 of file RSHelicityAmplModelNCn.cxx.

36 {
37 
38 }

Member Function Documentation

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

Implements genie::RSHelicityAmplModelI.

Definition at line 41 of file RSHelicityAmplModelNCn.cxx.

References a, genie::FKR::B, genie::units::b, genie::FKR::C, genie::RSHelicityAmpl::f0Minus, genie::RSHelicityAmpl::f0Plus, fAmpl, genie::RSHelicityAmpl::fMinus1, genie::RSHelicityAmpl::fMinus3, genie::RSHelicityAmpl::fPlus1, genie::RSHelicityAmpl::fPlus3, fSin28w, genie::constants::k1_Sqrt120, genie::constants::k1_Sqrt15, genie::constants::k1_Sqrt2, genie::constants::k1_Sqrt24, genie::constants::k1_Sqrt3, genie::constants::k1_Sqrt30, genie::constants::k1_Sqrt35, genie::constants::k1_Sqrt5, genie::constants::k1_Sqrt6, genie::constants::k2_Sqrt3, genie::constants::k2_Sqrt35, genie::constants::k3_Sqrt2, genie::constants::k3_Sqrt20, genie::constants::k3_Sqrt40, genie::kD13_1520, genie::kD13_1700, genie::kD15_1675, genie::kD33_1700, genie::kF15_1680, genie::kF17_1970, genie::kF35_1905, genie::kF37_1950, genie::kP11_1440, genie::kP11_1710, genie::kP13_1720, genie::kP31_1910, genie::kP33_1232, genie::kP33_1600, genie::kP33_1920, genie::kS11_1535, genie::kS11_1650, genie::kS31_1620, genie::constants::kSqrt15, genie::constants::kSqrt18_20, genie::constants::kSqrt18_35, genie::constants::kSqrt2, genie::constants::kSqrt27_40, genie::constants::kSqrt2_3, genie::constants::kSqrt2_7, genie::constants::kSqrt3, genie::constants::kSqrt3_10, genie::constants::kSqrt3_2, genie::constants::kSqrt3_20, genie::constants::kSqrt3_40, genie::constants::kSqrt3_8, genie::constants::kSqrt4_15, genie::constants::kSqrt5_12, genie::constants::kSqrt5_8, genie::constants::kSqrt6, genie::constants::kSqrt6_35, genie::constants::kSqrt9_40, genie::FKR::Lamda, LOG, pWARN, genie::FKR::R, genie::FKR::Rminus, genie::FKR::Rplus, genie::FKR::S, genie::FKR::T, genie::FKR::Tminus, and genie::FKR::Tplus.

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

References genie::Algorithm::Configure(), and LoadConfig().

354 {
355  Algorithm::Configure(config);
356  this->LoadConfig();
357 }
genie::Algorithm::Configure
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
void RSHelicityAmplModelNCn::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 359 of file RSHelicityAmplModelNCn.cxx.

References genie::Algorithm::Configure(), and LoadConfig().

360 {
361  Algorithm::Configure(config);
362  this->LoadConfig();
363 }
genie::Algorithm::Configure
virtual void Configure(const Registry &config)
Definition: Algorithm.cxx:62
void RSHelicityAmplModelNCn::LoadConfig ( void  )
private

Definition at line 365 of file RSHelicityAmplModelNCn.cxx.

References fSin28w, and genie::Algorithm::GetParam().

Referenced by Configure().

366 {
367  double thw ;
368  GetParam( "WeinbergAngle", thw ) ;
369  fSin28w = TMath::Power( TMath::Sin(thw), 2 );
370 }
genie::Algorithm::GetParam
bool GetParam(const RgKey &name, T &p, bool is_top_call=true) const

Member Data Documentation

RSHelicityAmpl genie::RSHelicityAmplModelNCn::fAmpl
mutableprivate

Definition at line 46 of file RSHelicityAmplModelNCn.h.

Referenced by Compute().

double genie::RSHelicityAmplModelNCn::fSin28w
private

Definition at line 47 of file RSHelicityAmplModelNCn.h.

Referenced by Compute(), and LoadConfig().

The documentation for this class was generated from the following files:
Generated on Wed Jul 17 2024 14:47:03 for GENIEGenerator by   doxygen 1.8.5