| 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 26
27 27
28 #include "G4MuNeutrinoNucleusTotXsc.hh" 28 #include "G4MuNeutrinoNucleusTotXsc.hh"
29 #include "G4PhysicalConstants.hh" 29 #include "G4PhysicalConstants.hh"
30 #include "G4SystemOfUnits.hh" 30 #include "G4SystemOfUnits.hh"
31 #include "G4DynamicParticle.hh" 31 #include "G4DynamicParticle.hh"
32 #include "G4ParticleTable.hh" 32 #include "G4ParticleTable.hh"
33 #include "G4IonTable.hh" 33 #include "G4IonTable.hh"
34 #include "G4HadTmpUtil.hh" 34 #include "G4HadTmpUtil.hh"
35 #include "G4NistManager.hh" 35 #include "G4NistManager.hh"
36 #include "G4Material.hh" <<
37 #include "G4Element.hh" <<
38 #include "G4Isotope.hh" <<
39 #include "G4ElementVector.hh" <<
40 36
41 #include "G4MuonMinus.hh" 37 #include "G4MuonMinus.hh"
42 #include "G4MuonPlus.hh" 38 #include "G4MuonPlus.hh"
43 39
44 using namespace std; 40 using namespace std;
45 using namespace CLHEP; 41 using namespace CLHEP;
46 42
47 G4MuNeutrinoNucleusTotXsc::G4MuNeutrinoNucleus 43 G4MuNeutrinoNucleusTotXsc::G4MuNeutrinoNucleusTotXsc()
48 : G4VCrossSectionDataSet("NuMuNuclTotXsc") << 44 : G4VCrossSectionDataSet("NuElectronTotXsc")
49 { 45 {
50 fCofXsc = 1.e-38*cm2/GeV; 46 fCofXsc = 1.e-38*cm2/GeV;
51 47
52 // G4cout<<"fCofXsc = "<<fCofXsc*GeV/cm2<<" 48 // G4cout<<"fCofXsc = "<<fCofXsc*GeV/cm2<<" cm2/GeV"<<G4endl;
53 49
54 // PDG2016: sin^2 theta Weinberg 50 // PDG2016: sin^2 theta Weinberg
55 51
56 fSin2tW = 0.23129; // 0.2312; 52 fSin2tW = 0.23129; // 0.2312;
57 53
58 // 9 <-> 6, 5/9 or 5/6 ? 54 // 9 <-> 6, 5/9 or 5/6 ?
59 55
60 fCofS = 5.*fSin2tW*fSin2tW/9.; 56 fCofS = 5.*fSin2tW*fSin2tW/9.;
61 fCofL = 1. - fSin2tW + fCofS; 57 fCofL = 1. - fSin2tW + fCofS;
62 58
63 // G4cout<<"fCosL = "<<fCofL<<", fCofS = "<< << 59 G4cout<<"fCosL = "<<fCofL<<", fCofS = "<<fCofS<<G4endl;
64 60
65 fCutEnergy = 0.; // default value 61 fCutEnergy = 0.; // default value
66 62
67 fBiasingFactor = 1.; // default as physics 63 fBiasingFactor = 1.; // default as physics
68 fEmc = 0.2*GeV; <<
69 fIndex = 50; <<
70 64
71 fTotXsc = 0.; << 65 fIndex = 50;
72 fCcTotRatio = 0.75; // from nc/cc~0.33 ratio <<
73 fCcFactor = fNcFactor = 1.; <<
74 fQEratio = 0.5; // mean in the 1 GeV range <<
75 66
76 // theMuonMinus = G4MuonMinus::MuonMinus(); << 67 theMuonMinus = G4MuonMinus::MuonMinus();
77 // theMuonPlus = G4MuonPlus::MuonPlus(); << 68 theMuonPlus = G4MuonPlus::MuonPlus();
78 } 69 }
79 70
80 G4MuNeutrinoNucleusTotXsc::~G4MuNeutrinoNucleu 71 G4MuNeutrinoNucleusTotXsc::~G4MuNeutrinoNucleusTotXsc()
81 {} 72 {}
82 73
83 ////////////////////////////////////////////// 74 //////////////////////////////////////////////////////
84 75
85 G4bool 76 G4bool
86 G4MuNeutrinoNucleusTotXsc::IsIsoApplicable( co << 77 G4MuNeutrinoNucleusTotXsc::IsElementApplicable( const G4DynamicParticle* aPart, G4int, const G4Material*)
87 { 78 {
88 G4bool result = false; 79 G4bool result = false;
89 G4String pName = aPart->GetDefinition()->Get 80 G4String pName = aPart->GetDefinition()->GetParticleName();
90 G4double tKin = aPart->GetKineticEnergy(); << 81
91 << 82 if( pName == "nu_mu" || pName == "anti_nu_mu" )
92 if( ( pName == "nu_mu" || pName == "a <<
93 { 83 {
94 result = true; 84 result = true;
95 } 85 }
96 return result; 86 return result;
97 } 87 }
98 88
99 ////////////////////////////////////// <<
100 <<
101 G4double G4MuNeutrinoNucleusTotXsc::GetElement <<
102 G4int Z, const G4Material* <<
103 { <<
104 G4int Zi(0); <<
105 size_t i(0), j(0); <<
106 const G4ElementVector* theElementVector = ma <<
107 <<
108 for ( i = 0; i < theElementVector->size(); + <<
109 { <<
110 Zi = (*theElementVector)[i]->GetZasInt(); <<
111 if( Zi == Z ) break; <<
112 } <<
113 const G4Element* elm = (*theElementVector)[i <<
114 size_t nIso = elm->GetNumberOfIsotopes(); <<
115 G4double fact = 0.0; <<
116 G4double xsec = 0.0; <<
117 const G4Isotope* iso = nullptr; <<
118 const G4IsotopeVector* isoVector = elm->GetI <<
119 const G4double* abundVector = elm->GetRelati <<
120 <<
121 for (j = 0; j<nIso; ++j) <<
122 { <<
123 iso = (*isoVector)[j]; <<
124 G4int A = iso->GetN(); <<
125 <<
126 if( abundVector[j] > 0.0 && IsIsoApplicabl <<
127 { <<
128 fact += abundVector[j]; <<
129 xsec += abundVector[j]*GetIsoCrossSectio <<
130 } <<
131 } <<
132 if( fact > 0.0) { xsec /= fact; } <<
133 return xsec; <<
134 } <<
135 <<
136 ////////////////////////////////////////////// 89 ////////////////////////////////////////////////////
137 // 90 //
138 // 91 //
139 92
140 G4double G4MuNeutrinoNucleusTotXsc::GetIsoCros << 93 G4double G4MuNeutrinoNucleusTotXsc::GetIsoCrossSection(const G4DynamicParticle* aPart, G4int, G4int A,
141 const G4Isotope*, const G4Element* 94 const G4Isotope*, const G4Element*, const G4Material* )
142 { 95 {
143 fCcFactor = fNcFactor = 1.; <<
144 fCcTotRatio = 0.25; <<
145 <<
146 G4double ccnuXsc, ccanuXsc, ncXsc, totXsc(0. 96 G4double ccnuXsc, ccanuXsc, ncXsc, totXsc(0.);
147 97
148 G4double energy = aPart->GetTotalEnergy(); 98 G4double energy = aPart->GetTotalEnergy();
149 G4String pName = aPart->GetDefinition()->G 99 G4String pName = aPart->GetDefinition()->GetParticleName();
150 100
151 G4int index = GetEnergyIndex(energy); 101 G4int index = GetEnergyIndex(energy);
152 102
153 if( index >= fIndex ) << 103 ccnuXsc = GetNuMuTotCsXsc(index, energy);
154 { << 104 ccanuXsc = GetANuMuTotCsXsc(index, energy);
155 G4double pm = proton_mass_c2; <<
156 G4double s2 = 2.*energy*pm+pm*pm; <<
157 G4double aa = 1.; <<
158 G4double bb = 1.085; <<
159 G4double mw = 80.385*GeV; <<
160 fCcFactor = bb/(1.+ aa*s2/mw/mw); <<
161 <<
162 G4double mz = 91.1876*GeV; <<
163 fNcFactor = bb/(1.+ aa*s2/mz/mz); <<
164 } <<
165 ccnuXsc = GetNuMuTotCsXsc(index, energy, Z, <<
166 ccnuXsc *= fCcFactor; <<
167 ccanuXsc = GetANuMuTotCsXsc(index, energy, Z <<
168 ccanuXsc *= fCcFactor; <<
169 105
170 if( pName == "nu_mu" ) << 106 if( pName == "nu_mu")
171 { 107 {
172 ncXsc = fCofL*ccnuXsc + fCofS*ccanuXsc; 108 ncXsc = fCofL*ccnuXsc + fCofS*ccanuXsc;
173 ncXsc *= fNcFactor/fCcFactor; <<
174 totXsc = ccnuXsc + ncXsc; 109 totXsc = ccnuXsc + ncXsc;
175 if( totXsc > 0.) fCcTotRatio = ccnuXsc/tot <<
176 } 110 }
177 else if( pName == "anti_nu_mu" ) << 111 else if( pName == "anti_nu_mu")
178 { 112 {
179 ncXsc = fCofL*ccanuXsc + fCofS*ccnuXsc; 113 ncXsc = fCofL*ccanuXsc + fCofS*ccnuXsc;
180 ncXsc *= fNcFactor/fCcFactor; <<
181 totXsc = ccanuXsc + ncXsc; 114 totXsc = ccanuXsc + ncXsc;
182 if( totXsc > 0.) fCcTotRatio = ccanuXsc/to <<
183 } 115 }
184 else return totXsc; 116 else return totXsc;
185 117
186 totXsc *= fCofXsc; << 118 // totXsc -= ncXsc; // to test experimentally available cc part
187 totXsc *= energy; << 119
188 // totXsc *= A; // incoherent sum over all << 120 totXsc *= fCofXsc; //*energy;
>> 121 totXsc *= energy; // + 0.5*emass;
>> 122 totXsc *= A; // incoherent sum over all isotope nucleons
189 123
190 totXsc *= fBiasingFactor; // biasing up, if 124 totXsc *= fBiasingFactor; // biasing up, if set >1
191 125
192 fTotXsc = totXsc; <<
193 126
194 return totXsc; 127 return totXsc;
195 } 128 }
196 129
197 ////////////////////////////////////////////// 130 /////////////////////////////////////////////////////
198 // 131 //
199 // Return index of nu/anu energy array corresp 132 // Return index of nu/anu energy array corresponding to the neutrino energy
200 133
201 G4int G4MuNeutrinoNucleusTotXsc::GetEnergyInde 134 G4int G4MuNeutrinoNucleusTotXsc::GetEnergyIndex(G4double energy)
202 { 135 {
203 G4int i, eIndex = 0; 136 G4int i, eIndex = 0;
204 137
205 for( i = 0; i < fIndex; i++) 138 for( i = 0; i < fIndex; i++)
206 { 139 {
207 if( energy <= fNuMuEnergy[i]*GeV ) 140 if( energy <= fNuMuEnergy[i]*GeV )
208 { 141 {
209 eIndex = i; 142 eIndex = i;
210 break; 143 break;
211 } 144 }
212 } 145 }
213 if( i >= fIndex ) eIndex = i; 146 if( i >= fIndex ) eIndex = i;
214 // G4cout<<"eIndex = "<<eIndex<<G4endl; 147 // G4cout<<"eIndex = "<<eIndex<<G4endl;
215 return eIndex; 148 return eIndex;
216 } 149 }
217 150
218 ////////////////////////////////////////////// 151 /////////////////////////////////////////////////////
219 // 152 //
220 // nu_mu xsc for index-1, index linear over en 153 // nu_mu xsc for index-1, index linear over energy
221 154
222 G4double G4MuNeutrinoNucleusTotXsc::GetNuMuTot << 155 G4double G4MuNeutrinoNucleusTotXsc::GetNuMuTotCsXsc(G4int index, G4double energy)
223 { 156 {
224 G4double xsc(0.), qexsc(0.), inxsc(0.); << 157 G4double xsc(0.);
225 G4int nn = aa - zz; << 158
226 if(nn < 1) nn = 0; << 159 if( index <= 0 || energy < theMuonMinus->GetPDGMass() ) xsc = 0.;
227 << 160 else if (index >= fIndex) xsc = fNuMuTotXsc[fIndex-1];
228 // if( index <= 0 || energy < theMuonMinus-> <<
229 if( index <= 0 || energy < fEmc ) xsc = aa*f <<
230 else if (index >= fIndex) xsc = aa*fNuMuInXs <<
231 else 161 else
232 { 162 {
233 G4double x1 = fNuMuEnergy[index-1]*GeV; 163 G4double x1 = fNuMuEnergy[index-1]*GeV;
234 G4double x2 = fNuMuEnergy[index]*GeV; 164 G4double x2 = fNuMuEnergy[index]*GeV;
235 G4double y1 = fNuMuInXsc[index-1]; << 165 G4double y1 = fNuMuTotXsc[index-1];
236 G4double y2 = fNuMuInXsc[index]; << 166 G4double y2 = fNuMuTotXsc[index];
237 G4double z1 = fNuMuQeXsc[index-1]; <<
238 G4double z2 = fNuMuQeXsc[index]; <<
239 167
240 if(x1 >= x2) return aa*fNuMuInXsc[index] + << 168 if(x1 >= x2) return fNuMuTotXsc[index];
241 else 169 else
242 { 170 {
243 G4double angle = (y2-y1)/(x2-x1); 171 G4double angle = (y2-y1)/(x2-x1);
244 inxsc = y1 + (energy-x1)*angle; << 172 xsc = y1 + (energy-x1)*angle;
245 angle = (z2-z1)/(x2-x1); <<
246 qexsc = z1 + (energy-x1)*angle; <<
247 qexsc *= nn; <<
248 xsc = inxsc*aa + qexsc; <<
249 <<
250 if( xsc > 0.) fQEratio = qexsc/xsc; <<
251 } 173 }
252 } 174 }
253 return xsc; 175 return xsc;
254 } 176 }
255 177
256 ////////////////////////////////////////////// 178 /////////////////////////////////////////////////////
257 // 179 //
258 // anu_mu xsc for index-1, index linear over e 180 // anu_mu xsc for index-1, index linear over energy
259 181
260 G4double G4MuNeutrinoNucleusTotXsc::GetANuMuTo << 182 G4double G4MuNeutrinoNucleusTotXsc::GetANuMuTotCsXsc(G4int index, G4double energy)
261 { 183 {
262 G4double xsc(0.), qexsc(0.), inxsc(0.); << 184 G4double xsc(0.);
263 185
264 // if( index <= 0 || energy < theMuonPlus->G << 186 if( index <= 0 || energy < theMuonPlus->GetPDGMass() ) xsc = 0.;
265 if( index <= 0 || energy < fEmc ) xsc = aa*f << 187 else if (index >= fIndex) xsc = fANuMuTotXsc[fIndex-1];
266 else if (index >= fIndex) xsc = aa*fANuMuInX <<
267 else 188 else
268 { 189 {
269 G4double x1 = fNuMuEnergy[index-1]*GeV; 190 G4double x1 = fNuMuEnergy[index-1]*GeV;
270 G4double x2 = fNuMuEnergy[index]*GeV; 191 G4double x2 = fNuMuEnergy[index]*GeV;
271 G4double y1 = fANuMuInXsc[index-1]; << 192 G4double y1 = fANuMuTotXsc[index-1];
272 G4double y2 = fANuMuInXsc[index]; << 193 G4double y2 = fANuMuTotXsc[index];
273 G4double z1 = fANuMuQeXsc[index-1]; <<
274 G4double z2 = fANuMuQeXsc[index]; <<
275 194
276 if( x1 >= x2 ) return aa*fANuMuInXsc[index << 195 if( x1 >= x2 ) return fANuMuTotXsc[index];
277 else 196 else
278 { 197 {
279 G4double angle = (y2-y1)/(x2-x1); 198 G4double angle = (y2-y1)/(x2-x1);
280 inxsc = y1 + (energy-x1)*angle; << 199 xsc = y1 + (energy-x1)*angle;
281 <<
282 angle = (z2-z1)/(x2-x1); <<
283 qexsc = z1 + (energy-x1)*angle; <<
284 qexsc *= zz; <<
285 xsc = inxsc*aa + qexsc; <<
286 <<
287 if( xsc > 0.) fQEratio = qexsc/xsc; <<
288 } 200 }
289 } 201 }
290 return xsc; 202 return xsc;
291 } 203 }
292 204
293 ////////////////////////////////////////////// 205 ////////////////////////////////////////////////////////
294 // 206 //
295 // return fNuMuTotXsc[index] if the index is i 207 // return fNuMuTotXsc[index] if the index is in the array range
296 208
297 G4double G4MuNeutrinoNucleusTotXsc::GetNuMuTot 209 G4double G4MuNeutrinoNucleusTotXsc::GetNuMuTotCsArray( G4int index)
298 { 210 {
299 if( index >= 0 && index < fIndex) return fNu << 211 if( index >= 0 && index < fIndex) return fNuMuTotXsc[index];
300 else 212 else
301 { 213 {
302 G4cout<<"Improper index of fNuMuTotXsc arr << 214 G4cout<<"Inproper index of fNuMuTotXsc array"<<G4endl;
303 return 0.; 215 return 0.;
304 } 216 }
305 } 217 }
306 218
307 ////////////////////////////////////////////// 219 ////////////////////////////////////////////////////////
308 // 220 //
309 // return fANuMuTotXsc[index] if the index is 221 // return fANuMuTotXsc[index] if the index is in the array range
310 222
311 G4double G4MuNeutrinoNucleusTotXsc::GetANuMuTo 223 G4double G4MuNeutrinoNucleusTotXsc::GetANuMuTotCsArray( G4int index)
312 { 224 {
313 if( index >= 0 && index < fIndex) return fAN << 225 if( index >= 0 && index < fIndex) return fANuMuTotXsc[index];
314 else 226 else
315 { 227 {
316 G4cout<<"Improper index of fANuMuTotXsc ar << 228 G4cout<<"Inproper index of fANuMuTotXsc array"<<G4endl;
317 return 0.; 229 return 0.;
318 } 230 }
319 } 231 }
320 232
321 233
322 ////////////////////////////////////////////// 234 ///////////////////////////////////////////////////////
323 // 235 //
324 // E_nu in GeV, ( Eth = 111.603 MeV, EthW = 33 << 236 // E_nu in GeV
325 237
326 const G4double G4MuNeutrinoNucleusTotXsc::fNuM 238 const G4double G4MuNeutrinoNucleusTotXsc::fNuMuEnergy[50] =
327 { 239 {
328 0.12, 0.141136, 0.165996, 0.195233, 0.229621 << 240 0.112103, 0.117359, 0.123119, 0.129443, 0.136404,
329 0.270066, 0.317634, 0.373581, 0.439382, 0.51 << 241 0.144084, 0.152576, 0.161991, 0.172458, 0.184126,
330 0.607795, 0.714849, 0.84076, 0.988848, 1.163 << 242 0.197171, 0.211801, 0.228261, 0.24684, 0.267887,
331 1.36787, 1.6088, 1.89217, 2.22545, 2.61743, << 243 0.291816, 0.319125, 0.350417, 0.386422, 0.428032,
332 3.07845, 3.62068, 4.25841, 5.00847, 5.89065, << 244 0.47634, 0.532692, 0.598756, 0.676612, 0.768868,
333 6.9282, 8.14851, 9.58376, 11.2718, 13.2572, << 245 0.878812, 1.01062, 1.16963, 1.36271, 1.59876,
334 15.5922, 18.3386, 21.5687, 25.3677, 29.8359, << 246 1.88943, 2.25002, 2.70086, 3.26916, 3.99166,
335 35.0911, 41.2719, 48.5413, 57.0912, 67.147, << 247 4.91843, 6.11836, 7.6872, 9.75942, 12.5259,
336 78.974, 92.8842, 109.244, 128.486, 151.117, << 248 16.2605, 21.3615, 28.4141, 38.2903, 52.3062,
337 177.735, 209.04, 245.86, 289.164, 340.097 }; << 249 72.4763, 101.93, 145.6, 211.39, 312.172};
338 << 250
339 ////////////////////////////////////////////// << 251 /////////////////////////////////////////////////////////////
340 // << 252 //
341 // XS/E arrays in 10^-38cm2/GeV << 253 // nu_mu CC xsc_tot/E_nu, in 10^-38 cm2/GeV
342 << 254
343 const G4double G4MuNeutrinoNucleusTotXsc::fNuM << 255 const G4double G4MuNeutrinoNucleusTotXsc::fNuMuTotXsc[50] =
344 { << 256 {
345 0, 0, 0, 0, 0, << 257 0.0716001, 0.241013, 0.337793, 0.416033, 0.484616,
346 0, 0, 0.0166853, 0.0649693, 0.132346, << 258 0.546945, 0.604661, 0.658623, 0.709277, 0.756815,
347 0.209102, 0.286795, 0.3595, 0.423961, 0.479 << 259 0.801263, 0.842519, 0.880396, 0.914642, 0.944968,
348 0.524797, 0.562165, 0.592225, 0.61612, 0.63 << 260 0.971069, 0.992655, 1.00947, 1.02133, 1.02812,
349 0.649524, 0.660751, 0.669245, 0.675546, 0.68 << 261 1.02987, 1.02671, 1.01892, 1.00689, 0.991167,
350 0.683247, 0.685307, 0.686521, 0.687093, 0.68 << 262 0.972618, 0.951518, 0.928806, 0.90521, 0.881404,
351 0.686919, 0.686384, 0.685631, 0.684689, 0.68 << 263 0.857978, 0.835424, 0.814112, 0.794314, 0.776204,
352 0.682275, 0.680806, 0.67917, 0.677376, 0.675 << 264 0.759884, 0.745394, 0.732719, 0.721809, 0.712164,
353 0.673387, 0.671229, 0.668985, 0.666665, 0.66 << 265 0.704299, 0.697804, 0.692491, 0.688137, 0.68448,
354 0.661804, 0.65925, 0.656593, 0.65381, 0.6508 << 266 0.681232, 0.676128, 0.674154, 0.670553, 0.666034};
355 <<
356 const G4double G4MuNeutrinoNucleusTotXsc::fNuM <<
357 { <<
358 0.20787, 0.411055, 0.570762, 0.705379, 0.814 <<
359 0.89543, 0.944299, 0.959743, 0.942906, 0.897 <<
360 0.831331, 0.750948, 0.66443, 0.578191, 0.496 <<
361 0.423071, 0.358103, 0.302016, 0.254241, 0.21 <<
362 0.179971, 0.151527, 0.12769, 0.107706, 0.090 <<
363 0.0768491, 0.0649975, 0.0550143, 0.0465948, <<
364 0.0334782, 0.0283964, 0.0240945, 0.0204506, <<
365 0.0147437, 0.0125223, 0.0106374, 0.00903737, <<
366 0.00652531, 0.00554547, 0.0047131, 0.0040059 <<
367 0.00289436, 0.00246039, 0.00209155, 0.001778 <<
368 <<
369 <<
370 267
371 ////////////////////////////////////////////// <<
372 <<
373 const G4double G4MuNeutrinoNucleusTotXsc::fANu <<
374 { <<
375 0, 0, 0, 0, 0, <<
376 0, 0, 0.00437363, 0.0161485, 0.0333162, <<
377 0.0557621, 0.0814548, 0.108838, 0.136598, 0. <<
378 0.188908, 0.212041, 0.232727, 0.250872, 0.26 <<
379 0.279467, 0.290341, 0.299177, 0.306299, 0.31 <<
380 0.316108, 0.319378, 0.321892, 0.323583, 0.32 <<
381 0.325841, 0.326568, 0.327111, 0.327623, 0.32 <<
382 0.328412, 0.328704, 0.328988, 0.329326, 0.32 <<
383 0.329791, 0.330051, 0.330327, 0.33057, 0.330 <<
384 0.331115, 0.331416, 0.331678, 0.33192, 0.332 <<
385 <<
386 ////////////////////////////////////////////// <<
387 <<
388 const G4double G4MuNeutrinoNucleusTotXsc::fANu <<
389 { <<
390 0.0770264, 0.138754, 0.177006, 0.202417, 0.2 <<
391 0.225742, 0.227151, 0.223805, 0.21709, 0.208 <<
392 0.197763, 0.186496, 0.174651, 0.162429, 0.14 <<
393 0.137498, 0.125127, 0.113057, 0.101455, 0.09 <<
394 0.0801914, 0.0707075, 0.0620483, 0.0542192, <<
395 0.0409571, 0.0354377, 0.0305862, 0.0263422, <<
396 0.0194358, 0.0166585, 0.0142613, 0.0121968, <<
397 0.00889912, 0.00759389, 0.00647662, 0.005521 <<
398 0.00400791, 0.00341322, 0.00290607, 0.002473 <<
399 0.00179162, 0.00152441, 0.00129691, 0.001103 <<
400 268
401 //////////////////// <<
402 269
>> 270 /////////////////////////////////////////////////////////////
>> 271 //
>> 272 // anu_mu CC xsc_tot/E_nu, in 10^-38 cm2/GeV
>> 273
>> 274 const G4double G4MuNeutrinoNucleusTotXsc::fANuMuTotXsc[50] =
>> 275 {
>> 276 0.0291812, 0.0979725, 0.136884, 0.16794, 0.194698,
>> 277 0.218468, 0.23992, 0.259241, 0.27665, 0.292251,
>> 278 0.30612, 0.318314, 0.328886, 0.337885, 0.345464,
>> 279 0.351495, 0.356131, 0.359448, 0.361531, 0.362474,
>> 280 0.362382, 0.361365, 0.359538, 0.357024, 0.353943,
>> 281 0.350422, 0.346685, 0.342662, 0.338567, 0.334514,
>> 282 0.330612, 0.326966, 0.323668, 0.320805, 0.318451,
>> 283 0.316671, 0.315514, 0.315013, 0.315187, 0.316036,
>> 284 0.317541, 0.319667, 0.322362, 0.325556, 0.329159,
>> 285 0.332577, 0.337133, 0.341214, 0.345128, 0.347657};
403 286