GENIEGenerator
Loading...
Searching...
No Matches
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:
[legend]
Collaboration diagram for genie::RSHelicityAmplModelNCn:
[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.
virtual AlgStatus_t GetStatus (void) const
 Get algorithm status.
virtual bool AllowReconfig (void) const
virtual AlgCmp_t Compare (const Algorithm *alg) const
 Compare with input algorithm.
virtual void SetId (const AlgId &id)
 Set algorithm ID.
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.

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.
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.
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.
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
int AddLowRegistry (Registry *rp, bool owns=true)
 add registry with lowest priority, also update ownership
int MergeTopRegistry (const Registry &r)
int AddTopRegisties (const vector< Registry * > &rs, bool owns=false)
 Add registries with top priority, also udated Ownerships.
Protected Attributes inherited from genie::Algorithm
bool fAllowReconfig
bool fOwnsSubstruc
 true if it owns its substructure (sub-algs,...)
AlgId fID
 algorithm name and configuration set
vector< Registry * > fConfVect
vector< bool > fOwnerships
 ownership for every registry in fConfVect
AlgStatus_t fStatus
 algorithm execution status
AlgMap * fOwnedSubAlgMp
 local pool for owned sub-algs (taken out of the factory pool)

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 \at cern.ch> University of Liverpool
Created:\n May 03, 2004
License:\n Copyright (c) 2003-2025, 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() [1/2]

RSHelicityAmplModelNCn::RSHelicityAmplModelNCn ( )

Definition at line 23 of file RSHelicityAmplModelNCn.cxx.

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

References genie::RSHelicityAmplModelI::RSHelicityAmplModelI().

◆ RSHelicityAmplModelNCn() [2/2]

RSHelicityAmplModelNCn::RSHelicityAmplModelNCn ( string config)

Definition at line 29 of file RSHelicityAmplModelNCn.cxx.

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

References genie::RSHelicityAmplModelI::RSHelicityAmplModelI().

◆ ~RSHelicityAmplModelNCn()

RSHelicityAmplModelNCn::~RSHelicityAmplModelNCn ( )
virtual

Definition at line 35 of file RSHelicityAmplModelNCn.cxx.

36{
37
38}

Member Function Documentation

◆ Compute()

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

Implements genie::RSHelicityAmplModelI.

Definition at line 41 of file RSHelicityAmplModelNCn.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 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}
LOG
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE,...
Definition Messenger.h:96
pWARN
#define pWARN
Definition Messenger.h:60
genie::FKR::C
double C
Definition FKR.h:44
genie::FKR::T
double T
Definition FKR.h:46
genie::FKR::Tplus
double Tplus
Definition FKR.h:47
genie::FKR::S
double S
Definition FKR.h:40
genie::FKR::Tminus
double Tminus
Definition FKR.h:48
genie::FKR::Rminus
double Rminus
Definition FKR.h:50
genie::FKR::Rplus
double Rplus
Definition FKR.h:49
genie::FKR::R
double R
Definition FKR.h:45
genie::FKR::Lamda
double Lamda
Definition FKR.h:37
genie::FKR::B
double B
Definition FKR.h:43
a
const double a
Definition gUpMuFluxGen.cxx:164

References a, genie::FKR::B, genie::FKR::C, fAmpl, 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.

◆ Configure() [1/2]

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.

354{
355 Algorithm::Configure(config);
356 this->LoadConfig();
357}
genie::Algorithm::Configure
virtual void Configure(const Registry &config)
Definition Algorithm.cxx:62

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

◆ Configure() [2/2]

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.

360{
361 Algorithm::Configure(config);
362 this->LoadConfig();
363}

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

◆ LoadConfig()

void RSHelicityAmplModelNCn::LoadConfig ( void )
private

Definition at line 365 of file RSHelicityAmplModelNCn.cxx.

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

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

Referenced by Configure(), and Configure().

Member Data Documentation

◆ fAmpl

RSHelicityAmpl genie::RSHelicityAmplModelNCn::fAmpl
mutableprivate

Definition at line 46 of file RSHelicityAmplModelNCn.h.

Referenced by Compute().

◆ fSin28w

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 for GENIEGenerator by doxygen 1.14.0