| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 24.04.20 V. Grichine 26 // 24.04.20 V. Grichine
27 // 27 //
28 // (nu_e,anti_nu_e)-nucleus xsc 28 // (nu_e,anti_nu_e)-nucleus xsc
29 29
30 30
31 31
32 #include "G4ElNeutrinoNucleusTotXsc.hh" 32 #include "G4ElNeutrinoNucleusTotXsc.hh"
33 #include "G4PhysicalConstants.hh" 33 #include "G4PhysicalConstants.hh"
34 #include "G4SystemOfUnits.hh" 34 #include "G4SystemOfUnits.hh"
35 #include "G4DynamicParticle.hh" 35 #include "G4DynamicParticle.hh"
36 #include "G4ParticleTable.hh" 36 #include "G4ParticleTable.hh"
37 #include "G4IonTable.hh" 37 #include "G4IonTable.hh"
38 #include "G4HadTmpUtil.hh" 38 #include "G4HadTmpUtil.hh"
39 #include "G4NistManager.hh" 39 #include "G4NistManager.hh"
40 #include "G4Material.hh" 40 #include "G4Material.hh"
41 #include "G4Element.hh" 41 #include "G4Element.hh"
42 #include "G4Isotope.hh" 42 #include "G4Isotope.hh"
43 #include "G4ElementVector.hh" 43 #include "G4ElementVector.hh"
44 44
45 #include "G4Electron.hh" 45 #include "G4Electron.hh"
46 #include "G4Positron.hh" 46 #include "G4Positron.hh"
47 47
48 using namespace std; 48 using namespace std;
49 using namespace CLHEP; 49 using namespace CLHEP;
50 50
51 G4ElNeutrinoNucleusTotXsc::G4ElNeutrinoNucleus 51 G4ElNeutrinoNucleusTotXsc::G4ElNeutrinoNucleusTotXsc()
52 : G4VCrossSectionDataSet("NuElNuclTotXsc") 52 : G4VCrossSectionDataSet("NuElNuclTotXsc")
53 { 53 {
54 fCofXsc = 1.e-38*cm2/GeV; 54 fCofXsc = 1.e-38*cm2/GeV;
55 55
56 // G4cout<<"fCofXsc = "<<fCofXsc*GeV/cm2<<" 56 // G4cout<<"fCofXsc = "<<fCofXsc*GeV/cm2<<" cm2/GeV"<<G4endl;
57 57
58 // PDG2016: sin^2 theta Weinberg 58 // PDG2016: sin^2 theta Weinberg
59 59
60 fSin2tW = 0.23129; // 0.2312; 60 fSin2tW = 0.23129; // 0.2312;
61 61
62 // 9 <-> 6, 5/9 or 5/6 ? 62 // 9 <-> 6, 5/9 or 5/6 ?
63 63
64 fCofS = 5.*fSin2tW*fSin2tW/9.; 64 fCofS = 5.*fSin2tW*fSin2tW/9.;
65 fCofL = 1. - fSin2tW + fCofS; 65 fCofL = 1. - fSin2tW + fCofS;
66 66
67 // G4cout<<"fCosL = "<<fCofL<<", fCofS = "<< 67 // G4cout<<"fCosL = "<<fCofL<<", fCofS = "<<fCofS<<G4endl;
68 68
69 fCutEnergy = 0.; // default value 69 fCutEnergy = 0.; // default value
70 70
71 fBiasingFactor = 1.; // default as physics 71 fBiasingFactor = 1.; // default as physics
72 72
73 fIndex = 50; 73 fIndex = 50;
74 74
75 fTotXsc = 0.; 75 fTotXsc = 0.;
76 fCcTotRatio = 0.75; // from nc/cc~0.33 ratio 76 fCcTotRatio = 0.75; // from nc/cc~0.33 ratio
77 fCcFactor = fNcFactor = 1.; 77 fCcFactor = fNcFactor = 1.;
78 78
79 theElectron = G4Electron::Electron(); 79 theElectron = G4Electron::Electron();
80 thePositron = G4Positron::Positron(); 80 thePositron = G4Positron::Positron();
81 } 81 }
82 82
83 G4ElNeutrinoNucleusTotXsc::~G4ElNeutrinoNucleu 83 G4ElNeutrinoNucleusTotXsc::~G4ElNeutrinoNucleusTotXsc()
84 {} 84 {}
85 85
86 ////////////////////////////////////////////// 86 //////////////////////////////////////////////////////
87 87
88 << 88 /*
89 G4bool 89 G4bool
90 G4ElNeutrinoNucleusTotXsc::IsIsoApplicable( co 90 G4ElNeutrinoNucleusTotXsc::IsIsoApplicable( const G4DynamicParticle* aPart, G4int, G4int, const G4Element*, const G4Material*)
91 { 91 {
92 G4bool result = false; 92 G4bool result = false;
93 G4String pName = aPart->GetDefinition()->Get 93 G4String pName = aPart->GetDefinition()->GetParticleName();
94 94
95 if( pName == "nu_e" || pName == "anti 95 if( pName == "nu_e" || pName == "anti_nu_e" )
96 { 96 {
97 result = true; 97 result = true;
98 } 98 }
99 return result; 99 return result;
100 } 100 }
101 101
102 ////////////////////////////////////// 102 //////////////////////////////////////
103 103
104 G4double G4ElNeutrinoNucleusTotXsc::GetElement 104 G4double G4ElNeutrinoNucleusTotXsc::GetElementCrossSection(const G4DynamicParticle* part,
105 G4int Z, const G4Material* 105 G4int Z, const G4Material* mat )
106 { 106 {
107 G4int Zi(0); 107 G4int Zi(0);
108 size_t i(0), j(0); 108 size_t i(0), j(0);
109 const G4ElementVector* theElementVector = ma 109 const G4ElementVector* theElementVector = mat->GetElementVector();
110 110
111 for ( i = 0; i < theElementVector->size(); + 111 for ( i = 0; i < theElementVector->size(); ++i )
112 { 112 {
113 Zi = (*theElementVector)[i]->GetZasInt(); 113 Zi = (*theElementVector)[i]->GetZasInt();
114 if( Zi == Z ) break; 114 if( Zi == Z ) break;
115 } 115 }
116 const G4Element* elm = (*theElementVector)[i 116 const G4Element* elm = (*theElementVector)[i];
117 size_t nIso = elm->GetNumberOfIsotopes(); 117 size_t nIso = elm->GetNumberOfIsotopes();
118 G4double fact = 0.0; 118 G4double fact = 0.0;
119 G4double xsec = 0.0; 119 G4double xsec = 0.0;
120 const G4Isotope* iso = nullptr; 120 const G4Isotope* iso = nullptr;
121 const G4IsotopeVector* isoVector = elm->GetI 121 const G4IsotopeVector* isoVector = elm->GetIsotopeVector();
122 const G4double* abundVector = elm->GetRelati 122 const G4double* abundVector = elm->GetRelativeAbundanceVector();
123 123
124 for (j = 0; j<nIso; ++j) 124 for (j = 0; j<nIso; ++j)
125 { 125 {
126 iso = (*isoVector)[j]; 126 iso = (*isoVector)[j];
127 G4int A = iso->GetN(); 127 G4int A = iso->GetN();
128 128
129 if( abundVector[j] > 0.0 && IsIsoApplicabl 129 if( abundVector[j] > 0.0 && IsIsoApplicable(part, Z, A, elm, mat) )
130 { 130 {
131 fact += abundVector[j]; 131 fact += abundVector[j];
132 xsec += abundVector[j]*GetIsoCrossSectio 132 xsec += abundVector[j]*GetIsoCrossSection( part, Z, A, iso, elm, mat);
133 } 133 }
134 } 134 }
135 if( fact > 0.0) { xsec /= fact; } 135 if( fact > 0.0) { xsec /= fact; }
136 return xsec; 136 return xsec;
137 } 137 }
138 << 138 */
139 139
140 ////////////////////////////////////////////// 140 ////////////////////////////////////////////////////
141 // 141 //
142 // 142 //
143 143
144 G4double G4ElNeutrinoNucleusTotXsc::GetIsoCros 144 G4double G4ElNeutrinoNucleusTotXsc::GetIsoCrossSection(const G4DynamicParticle* aPart, G4int, G4int A,
145 const G4Isotope*, const G4Element* 145 const G4Isotope*, const G4Element*, const G4Material* )
146 { 146 {
147 fCcFactor = fNcFactor = 1.; 147 fCcFactor = fNcFactor = 1.;
148 fCcTotRatio = 0.25; 148 fCcTotRatio = 0.25;
149 149
150 G4double ccnuXsc, ccanuXsc, ncXsc, totXsc(0. 150 G4double ccnuXsc, ccanuXsc, ncXsc, totXsc(0.);
151 151
152 G4double energy = aPart->GetTotalEnergy(); 152 G4double energy = aPart->GetTotalEnergy();
153 G4String pName = aPart->GetDefinition()->G 153 G4String pName = aPart->GetDefinition()->GetParticleName();
154 154
155 G4int index = GetEnergyIndex(energy); 155 G4int index = GetEnergyIndex(energy);
156 156
157 if( index >= fIndex ) 157 if( index >= fIndex )
158 { 158 {
159 G4double pm = proton_mass_c2; 159 G4double pm = proton_mass_c2;
160 G4double s2 = 2.*energy*pm+pm*pm; 160 G4double s2 = 2.*energy*pm+pm*pm;
161 G4double aa = 1.; 161 G4double aa = 1.;
162 G4double bb = 1.085; 162 G4double bb = 1.085;
163 G4double mw = 80.385*GeV; 163 G4double mw = 80.385*GeV;
164 fCcFactor = bb/(1.+ aa*s2/mw/mw); 164 fCcFactor = bb/(1.+ aa*s2/mw/mw);
165 165
166 G4double mz = 91.1876*GeV; 166 G4double mz = 91.1876*GeV;
167 fNcFactor = bb/(1.+ aa*s2/mz/mz); 167 fNcFactor = bb/(1.+ aa*s2/mz/mz);
168 } 168 }
169 ccnuXsc = GetNuElTotCsXsc(index, energy); 169 ccnuXsc = GetNuElTotCsXsc(index, energy);
170 ccnuXsc *= fCcFactor; 170 ccnuXsc *= fCcFactor;
171 ccanuXsc = GetANuElTotCsXsc(index, energy); 171 ccanuXsc = GetANuElTotCsXsc(index, energy);
172 ccanuXsc *= fCcFactor; 172 ccanuXsc *= fCcFactor;
173 173
174 if( pName == "nu_e") 174 if( pName == "nu_e")
175 { 175 {
176 ncXsc = fCofL*ccnuXsc + fCofS*ccanuXsc; 176 ncXsc = fCofL*ccnuXsc + fCofS*ccanuXsc;
177 ncXsc *= fNcFactor/fCcFactor; 177 ncXsc *= fNcFactor/fCcFactor;
178 totXsc = ccnuXsc + ncXsc; 178 totXsc = ccnuXsc + ncXsc;
179 if( totXsc > 0.) fCcTotRatio = ccnuXsc/tot 179 if( totXsc > 0.) fCcTotRatio = ccnuXsc/totXsc;
180 } 180 }
181 else if( pName == "anti_nu_e") 181 else if( pName == "anti_nu_e")
182 { 182 {
183 ncXsc = fCofL*ccanuXsc + fCofS*ccnuXsc; 183 ncXsc = fCofL*ccanuXsc + fCofS*ccnuXsc;
184 ncXsc *= fNcFactor/fCcFactor; 184 ncXsc *= fNcFactor/fCcFactor;
185 totXsc = ccanuXsc + ncXsc; 185 totXsc = ccanuXsc + ncXsc;
186 if( totXsc > 0.) fCcTotRatio = ccanuXsc/to 186 if( totXsc > 0.) fCcTotRatio = ccanuXsc/totXsc;
187 } 187 }
188 else return totXsc; 188 else return totXsc;
189 189
190 totXsc *= fCofXsc; 190 totXsc *= fCofXsc;
191 totXsc *= energy; 191 totXsc *= energy;
192 totXsc *= A; // incoherent sum over all is 192 totXsc *= A; // incoherent sum over all isotope nucleons
193 193
194 totXsc *= fBiasingFactor; // biasing up, if 194 totXsc *= fBiasingFactor; // biasing up, if set >1
195 195
196 fTotXsc = totXsc; 196 fTotXsc = totXsc;
197 197
198 return totXsc; 198 return totXsc;
199 } 199 }
200 200
201 ////////////////////////////////////////////// 201 /////////////////////////////////////////////////////
202 // 202 //
203 // Return index of nu/anu energy array corresp 203 // Return index of nu/anu energy array corresponding to the neutrino energy
204 204
205 G4int G4ElNeutrinoNucleusTotXsc::GetEnergyInde 205 G4int G4ElNeutrinoNucleusTotXsc::GetEnergyIndex(G4double energy)
206 { 206 {
207 G4int i, eIndex = 0; 207 G4int i, eIndex = 0;
208 208
209 for( i = 0; i < fIndex; i++) 209 for( i = 0; i < fIndex; i++)
210 { 210 {
211 if( energy <= fNuElEnergy[i]*GeV ) 211 if( energy <= fNuElEnergy[i]*GeV )
212 { 212 {
213 eIndex = i; 213 eIndex = i;
214 break; 214 break;
215 } 215 }
216 } 216 }
217 if( i >= fIndex-1 ) eIndex = fIndex-1; 217 if( i >= fIndex-1 ) eIndex = fIndex-1;
218 // G4cout<<"eIndex = "<<eIndex<<G4endl; 218 // G4cout<<"eIndex = "<<eIndex<<G4endl;
219 return eIndex; 219 return eIndex;
220 } 220 }
221 221
222 ////////////////////////////////////////////// 222 /////////////////////////////////////////////////////
223 // 223 //
224 // nu_e xsc for index-1, index linear over ene 224 // nu_e xsc for index-1, index linear over energy
225 225
226 G4double G4ElNeutrinoNucleusTotXsc::GetNuElTot 226 G4double G4ElNeutrinoNucleusTotXsc::GetNuElTotCsXsc(G4int index, G4double energy)
227 { 227 {
228 G4double xsc(0.); 228 G4double xsc(0.);
229 229
230 if( index <= 0 || energy < theElectron->GetP 230 if( index <= 0 || energy < theElectron->GetPDGMass() ) xsc = fNuElTotXsc[0];
231 else if (index >= fIndex) xsc = fNuElTotXsc[ 231 else if (index >= fIndex) xsc = fNuElTotXsc[fIndex-1];
232 else 232 else
233 { 233 {
234 G4double x1 = fNuElEnergy[index-1]*GeV; 234 G4double x1 = fNuElEnergy[index-1]*GeV;
235 G4double x2 = fNuElEnergy[index]*GeV; 235 G4double x2 = fNuElEnergy[index]*GeV;
236 G4double y1 = fNuElTotXsc[index-1]; 236 G4double y1 = fNuElTotXsc[index-1];
237 G4double y2 = fNuElTotXsc[index]; 237 G4double y2 = fNuElTotXsc[index];
238 238
239 if(x1 >= x2) return fNuElTotXsc[index]; 239 if(x1 >= x2) return fNuElTotXsc[index];
240 else 240 else
241 { 241 {
242 G4double angle = (y2-y1)/(x2-x1); 242 G4double angle = (y2-y1)/(x2-x1);
243 xsc = y1 + (energy-x1)*angle; 243 xsc = y1 + (energy-x1)*angle;
244 } 244 }
245 } 245 }
246 return xsc; 246 return xsc;
247 } 247 }
248 248
249 ////////////////////////////////////////////// 249 /////////////////////////////////////////////////////
250 // 250 //
251 // anu_e xsc for index-1, index linear over en 251 // anu_e xsc for index-1, index linear over energy
252 252
253 G4double G4ElNeutrinoNucleusTotXsc::GetANuElTo 253 G4double G4ElNeutrinoNucleusTotXsc::GetANuElTotCsXsc(G4int index, G4double energy)
254 { 254 {
255 G4double xsc(0.); 255 G4double xsc(0.);
256 256
257 if( index <= 0 || energy < thePositron->GetP 257 if( index <= 0 || energy < thePositron->GetPDGMass() ) xsc = fANuElTotXsc[0];
258 else if (index >= fIndex) xsc = fANuElTotXsc 258 else if (index >= fIndex) xsc = fANuElTotXsc[fIndex-1];
259 else 259 else
260 { 260 {
261 G4double x1 = fNuElEnergy[index-1]*GeV; 261 G4double x1 = fNuElEnergy[index-1]*GeV;
262 G4double x2 = fNuElEnergy[index]*GeV; 262 G4double x2 = fNuElEnergy[index]*GeV;
263 G4double y1 = fANuElTotXsc[index-1]; 263 G4double y1 = fANuElTotXsc[index-1];
264 G4double y2 = fANuElTotXsc[index]; 264 G4double y2 = fANuElTotXsc[index];
265 265
266 if( x1 >= x2 ) return fANuElTotXsc[index]; 266 if( x1 >= x2 ) return fANuElTotXsc[index];
267 else 267 else
268 { 268 {
269 G4double angle = (y2-y1)/(x2-x1); 269 G4double angle = (y2-y1)/(x2-x1);
270 xsc = y1 + (energy-x1)*angle; 270 xsc = y1 + (energy-x1)*angle;
271 } 271 }
272 } 272 }
273 return xsc; 273 return xsc;
274 } 274 }
275 275
276 ////////////////////////////////////////////// 276 ////////////////////////////////////////////////////////
277 // 277 //
278 // return fNuElTotXsc[index] if the index is i 278 // return fNuElTotXsc[index] if the index is in the array range
279 279
280 G4double G4ElNeutrinoNucleusTotXsc::GetNuElTot 280 G4double G4ElNeutrinoNucleusTotXsc::GetNuElTotCsArray( G4int index)
281 { 281 {
282 if( index >= 0 && index < fIndex) return fNu 282 if( index >= 0 && index < fIndex) return fNuElTotXsc[index];
283 else 283 else
284 { 284 {
285 G4cout<<"Improper index of fNuElTotXsc arr 285 G4cout<<"Improper index of fNuElTotXsc array"<<G4endl;
286 return 0.; 286 return 0.;
287 } 287 }
288 } 288 }
289 289
290 ////////////////////////////////////////////// 290 ////////////////////////////////////////////////////////
291 // 291 //
292 // return fANuElTotXsc[index] if the index is 292 // return fANuElTotXsc[index] if the index is in the array range
293 293
294 G4double G4ElNeutrinoNucleusTotXsc::GetANuElTo 294 G4double G4ElNeutrinoNucleusTotXsc::GetANuElTotCsArray( G4int index)
295 { 295 {
296 if( index >= 0 && index < fIndex) return fAN 296 if( index >= 0 && index < fIndex) return fANuElTotXsc[index];
297 else 297 else
298 { 298 {
299 G4cout<<"Improper index of fANuElTotXsc ar 299 G4cout<<"Improper index of fANuElTotXsc array"<<G4endl;
300 return 0.; 300 return 0.;
301 } 301 }
302 } 302 }
303 303
304 304
305 ////////////////////////////////////////////// 305 ///////////////////////////////////////////////////////
306 // 306 //
307 // E_nu in GeV 307 // E_nu in GeV
308 308
309 const G4double G4ElNeutrinoNucleusTotXsc::fNuE 309 const G4double G4ElNeutrinoNucleusTotXsc::fNuElEnergy[50] =
310 { 310 {
311 0.000561138, 0.000735091, 0.000962969, 0.001 311 0.000561138, 0.000735091, 0.000962969, 0.00126149, 0.00165255,
312 0.00216484, 0.00283594, 0.00371508, 0.004866 312 0.00216484, 0.00283594, 0.00371508, 0.00486676, 0.00637546,
313 0.00835185, 0.0109409, 0.0143326, 0.0187757, 313 0.00835185, 0.0109409, 0.0143326, 0.0187757, 0.0245962,
314 0.032221, 0.0422095, 0.0552945, 0.0724358, 0 314 0.032221, 0.0422095, 0.0552945, 0.0724358, 0.0948908,
315 0.124307, 0.162842, 0.213323, 0.279453, 0.36 315 0.124307, 0.162842, 0.213323, 0.279453, 0.366084,
316 0.47957, 0.628237, 0.82299, 1.07812, 1.41233 316 0.47957, 0.628237, 0.82299, 1.07812, 1.41233,
317 1.85016, 2.42371, 3.17505, 4.15932, 5.44871, 317 1.85016, 2.42371, 3.17505, 4.15932, 5.44871,
318 7.13781, 9.35053, 12.2492, 16.0464, 21.0208, 318 7.13781, 9.35053, 12.2492, 16.0464, 21.0208,
319 27.5373, 36.0739, 47.2568, 61.9064, 81.0973, 319 27.5373, 36.0739, 47.2568, 61.9064, 81.0973,
320 106.238, 139.171, 182.314, 238.832, 312.869 320 106.238, 139.171, 182.314, 238.832, 312.869
321 }; 321 };
322 322
323 ////////////////////////////////////////////// 323 /////////////////////////////////////////////////////////////
324 // 324 //
325 // nu_e CC xsc_tot/E_nu, in 10^-38 cm2/GeV 325 // nu_e CC xsc_tot/E_nu, in 10^-38 cm2/GeV
326 326
327 const G4double G4ElNeutrinoNucleusTotXsc::fNuE 327 const G4double G4ElNeutrinoNucleusTotXsc::fNuElTotXsc[50] =
328 { 328 {
329 0.0026484, 0.00609503, 0.00939421, 0.0132163 329 0.0026484, 0.00609503, 0.00939421, 0.0132163, 0.0178983,
330 0.0237692, 0.0312066, 0.0406632, 0.0526867, 330 0.0237692, 0.0312066, 0.0406632, 0.0526867, 0.0679357,
331 0.0871913, 0.111359, 0.141458, 0.178584, 0.2 331 0.0871913, 0.111359, 0.141458, 0.178584, 0.223838,
332 0.27822, 0.342461, 0.416865, 0.501361, 0.596 332 0.27822, 0.342461, 0.416865, 0.501361, 0.596739,
333 0.713623, 0.905749, 1.20718, 1.52521, 1.7528 333 0.713623, 0.905749, 1.20718, 1.52521, 1.75286,
334 1.82072, 1.67119, 1.50074, 1.3077, 1.14923, 334 1.82072, 1.67119, 1.50074, 1.3077, 1.14923,
335 1.0577, 0.977911, 0.918526, 0.792889, 0.7022 335 1.0577, 0.977911, 0.918526, 0.792889, 0.702282,
336 0.678615, 0.687099, 0.725167, 0.706795, 0.67 336 0.678615, 0.687099, 0.725167, 0.706795, 0.678045,
337 0.649791, 0.651328, 0.651934, 0.658062, 0.66 337 0.649791, 0.651328, 0.651934, 0.658062, 0.660659,
338 0.662534, 0.662601, 0.660261, 0.656724, 0.65 338 0.662534, 0.662601, 0.660261, 0.656724, 0.65212
339 }; 339 };
340 340
341 341
342 342
343 ////////////////////////////////////////////// 343 /////////////////////////////////////////////////////////////
344 // 344 //
345 // anu_e CC xsc_tot/E_nu, in 10^-38 cm2/GeV 345 // anu_e CC xsc_tot/E_nu, in 10^-38 cm2/GeV
346 346
347 const G4double G4ElNeutrinoNucleusTotXsc::fANu 347 const G4double G4ElNeutrinoNucleusTotXsc::fANuElTotXsc[50] =
348 { 348 {
349 0.00103385, 0.00237807, 0.00366358, 0.005151 349 0.00103385, 0.00237807, 0.00366358, 0.00515192, 0.00697434,
350 0.00925859, 0.0121508, 0.0158252, 0.0204908, 350 0.00925859, 0.0121508, 0.0158252, 0.0204908, 0.0263959,
351 0.0338304, 0.0431234, 0.0546346, 0.068735, 0 351 0.0338304, 0.0431234, 0.0546346, 0.068735, 0.0857738,
352 0.106025, 0.129614, 0.15643, 0.186063, 0.217 352 0.106025, 0.129614, 0.15643, 0.186063, 0.21784,
353 0.251065, 0.28525, 0.319171, 0.348995, 0.369 353 0.251065, 0.28525, 0.319171, 0.348995, 0.369448,
354 0.378165, 0.377353, 0.371224, 0.363257, 0.35 354 0.378165, 0.377353, 0.371224, 0.363257, 0.355433,
355 0.348618, 0.343082, 0.338825, 0.33574, 0.333 355 0.348618, 0.343082, 0.338825, 0.33574, 0.333684,
356 0.332504, 0.332052, 0.332187, 0.332781, 0.33 356 0.332504, 0.332052, 0.332187, 0.332781, 0.333716,
357 0.33489, 0.336213, 0.337608, 0.339008, 0.340 357 0.33489, 0.336213, 0.337608, 0.339008, 0.340362,
358 0.341606, 0.342706, 0.343628, 0.344305, 0.34 358 0.341606, 0.342706, 0.343628, 0.344305, 0.344675
359 }; 359 };
360 360