GENIEGenerator
Loading...
Searching...
No Matches
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:
[legend]
Collaboration diagram for genie::RSHelicityAmplModelNCp:
[legend]

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.
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 protons, 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 RSHelicityAmplModelNCp.h.

Constructor & Destructor Documentation

◆ RSHelicityAmplModelNCp() [1/2]

RSHelicityAmplModelNCp::RSHelicityAmplModelNCp ( )

Definition at line 23 of file RSHelicityAmplModelNCp.cxx.

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

References genie::RSHelicityAmplModelI::RSHelicityAmplModelI().

◆ RSHelicityAmplModelNCp() [2/2]

RSHelicityAmplModelNCp::RSHelicityAmplModelNCp ( string config)

Definition at line 29 of file RSHelicityAmplModelNCp.cxx.

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

References genie::RSHelicityAmplModelI::RSHelicityAmplModelI().

◆ ~RSHelicityAmplModelNCp()

RSHelicityAmplModelNCp::~RSHelicityAmplModelNCp ( )
virtual

Definition at line 35 of file RSHelicityAmplModelNCp.cxx.

36{
37
38}

Member Function Documentation

◆ Compute()

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}
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::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 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

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

◆ Configure() [2/2]

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}

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

◆ LoadConfig()

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

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

Referenced by Configure(), and Configure().

Member Data Documentation

◆ fAmpl

RSHelicityAmpl genie::RSHelicityAmplModelNCp::fAmpl
mutableprivate

Definition at line 46 of file RSHelicityAmplModelNCp.h.

Referenced by Compute().

◆ fSin28w

double genie::RSHelicityAmplModelNCp::fSin28w
private

Definition at line 48 of file RSHelicityAmplModelNCp.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