| 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" 36 #include "G4Material.hh"
37 #include "G4Element.hh" 37 #include "G4Element.hh"
38 #include "G4Isotope.hh" 38 #include "G4Isotope.hh"
39 #include "G4ElementVector.hh" 39 #include "G4ElementVector.hh"
40 40
41 #include "G4MuonMinus.hh" 41 #include "G4MuonMinus.hh"
42 #include "G4MuonPlus.hh" 42 #include "G4MuonPlus.hh"
43 43
44 using namespace std; 44 using namespace std;
45 using namespace CLHEP; 45 using namespace CLHEP;
46 46
47 G4MuNeutrinoNucleusTotXsc::G4MuNeutrinoNucleus 47 G4MuNeutrinoNucleusTotXsc::G4MuNeutrinoNucleusTotXsc()
48 : G4VCrossSectionDataSet("NuMuNuclTotXsc") 48 : G4VCrossSectionDataSet("NuMuNuclTotXsc")
49 { 49 {
50 fCofXsc = 1.e-38*cm2/GeV; 50 fCofXsc = 1.e-38*cm2/GeV;
51 51
52 // G4cout<<"fCofXsc = "<<fCofXsc*GeV/cm2<<" 52 // G4cout<<"fCofXsc = "<<fCofXsc*GeV/cm2<<" cm2/GeV"<<G4endl;
53 53
54 // PDG2016: sin^2 theta Weinberg 54 // PDG2016: sin^2 theta Weinberg
55 55
56 fSin2tW = 0.23129; // 0.2312; 56 fSin2tW = 0.23129; // 0.2312;
57 57
58 // 9 <-> 6, 5/9 or 5/6 ? 58 // 9 <-> 6, 5/9 or 5/6 ?
59 59
60 fCofS = 5.*fSin2tW*fSin2tW/9.; 60 fCofS = 5.*fSin2tW*fSin2tW/9.;
61 fCofL = 1. - fSin2tW + fCofS; 61 fCofL = 1. - fSin2tW + fCofS;
62 62
63 // G4cout<<"fCosL = "<<fCofL<<", fCofS = "<< 63 // G4cout<<"fCosL = "<<fCofL<<", fCofS = "<<fCofS<<G4endl;
64 64
65 fCutEnergy = 0.; // default value 65 fCutEnergy = 0.; // default value
66 66
67 fBiasingFactor = 1.; // default as physics 67 fBiasingFactor = 1.; // default as physics
68 fEmc = 0.2*GeV; << 68
69 fIndex = 50; 69 fIndex = 50;
70 70
71 fTotXsc = 0.; 71 fTotXsc = 0.;
72 fCcTotRatio = 0.75; // from nc/cc~0.33 ratio 72 fCcTotRatio = 0.75; // from nc/cc~0.33 ratio
73 fCcFactor = fNcFactor = 1.; 73 fCcFactor = fNcFactor = 1.;
74 fQEratio = 0.5; // mean in the 1 GeV range <<
75 74
76 // theMuonMinus = G4MuonMinus::MuonMinus(); << 75 theMuonMinus = G4MuonMinus::MuonMinus();
77 // theMuonPlus = G4MuonPlus::MuonPlus(); << 76 theMuonPlus = G4MuonPlus::MuonPlus();
78 } 77 }
79 78
80 G4MuNeutrinoNucleusTotXsc::~G4MuNeutrinoNucleu 79 G4MuNeutrinoNucleusTotXsc::~G4MuNeutrinoNucleusTotXsc()
81 {} 80 {}
82 81
83 ////////////////////////////////////////////// 82 //////////////////////////////////////////////////////
84 83
85 G4bool 84 G4bool
86 G4MuNeutrinoNucleusTotXsc::IsIsoApplicable( co 85 G4MuNeutrinoNucleusTotXsc::IsIsoApplicable( const G4DynamicParticle* aPart, G4int, G4int, const G4Element*, const G4Material*)
87 { 86 {
88 G4bool result = false; 87 G4bool result = false;
89 G4String pName = aPart->GetDefinition()->Get 88 G4String pName = aPart->GetDefinition()->GetParticleName();
90 G4double tKin = aPart->GetKineticEnergy(); << 89
91 << 90 if( pName == "nu_mu" || pName == "anti_nu_mu" )
92 if( ( pName == "nu_mu" || pName == "a <<
93 { 91 {
94 result = true; 92 result = true;
95 } 93 }
96 return result; 94 return result;
97 } 95 }
98 96
99 ////////////////////////////////////// 97 //////////////////////////////////////
100 98
101 G4double G4MuNeutrinoNucleusTotXsc::GetElement 99 G4double G4MuNeutrinoNucleusTotXsc::GetElementCrossSection(const G4DynamicParticle* part,
102 G4int Z, const G4Material* 100 G4int Z, const G4Material* mat )
103 { 101 {
104 G4int Zi(0); 102 G4int Zi(0);
105 size_t i(0), j(0); 103 size_t i(0), j(0);
106 const G4ElementVector* theElementVector = ma 104 const G4ElementVector* theElementVector = mat->GetElementVector();
107 105
108 for ( i = 0; i < theElementVector->size(); + 106 for ( i = 0; i < theElementVector->size(); ++i )
109 { 107 {
110 Zi = (*theElementVector)[i]->GetZasInt(); 108 Zi = (*theElementVector)[i]->GetZasInt();
111 if( Zi == Z ) break; 109 if( Zi == Z ) break;
112 } 110 }
113 const G4Element* elm = (*theElementVector)[i 111 const G4Element* elm = (*theElementVector)[i];
114 size_t nIso = elm->GetNumberOfIsotopes(); 112 size_t nIso = elm->GetNumberOfIsotopes();
115 G4double fact = 0.0; 113 G4double fact = 0.0;
116 G4double xsec = 0.0; 114 G4double xsec = 0.0;
117 const G4Isotope* iso = nullptr; 115 const G4Isotope* iso = nullptr;
118 const G4IsotopeVector* isoVector = elm->GetI 116 const G4IsotopeVector* isoVector = elm->GetIsotopeVector();
119 const G4double* abundVector = elm->GetRelati 117 const G4double* abundVector = elm->GetRelativeAbundanceVector();
120 118
121 for (j = 0; j<nIso; ++j) 119 for (j = 0; j<nIso; ++j)
122 { 120 {
123 iso = (*isoVector)[j]; 121 iso = (*isoVector)[j];
124 G4int A = iso->GetN(); 122 G4int A = iso->GetN();
125 123
126 if( abundVector[j] > 0.0 && IsIsoApplicabl 124 if( abundVector[j] > 0.0 && IsIsoApplicable(part, Z, A, elm, mat) )
127 { 125 {
128 fact += abundVector[j]; 126 fact += abundVector[j];
129 xsec += abundVector[j]*GetIsoCrossSectio 127 xsec += abundVector[j]*GetIsoCrossSection( part, Z, A, iso, elm, mat);
130 } 128 }
131 } 129 }
132 if( fact > 0.0) { xsec /= fact; } 130 if( fact > 0.0) { xsec /= fact; }
133 return xsec; 131 return xsec;
134 } 132 }
135 133
136 ////////////////////////////////////////////// 134 ////////////////////////////////////////////////////
137 // 135 //
138 // 136 //
139 137
140 G4double G4MuNeutrinoNucleusTotXsc::GetIsoCros << 138 G4double G4MuNeutrinoNucleusTotXsc::GetIsoCrossSection(const G4DynamicParticle* aPart, G4int, G4int A,
141 const G4Isotope*, const G4Element* 139 const G4Isotope*, const G4Element*, const G4Material* )
142 { 140 {
143 fCcFactor = fNcFactor = 1.; 141 fCcFactor = fNcFactor = 1.;
144 fCcTotRatio = 0.25; 142 fCcTotRatio = 0.25;
145 143
146 G4double ccnuXsc, ccanuXsc, ncXsc, totXsc(0. 144 G4double ccnuXsc, ccanuXsc, ncXsc, totXsc(0.);
147 145
148 G4double energy = aPart->GetTotalEnergy(); 146 G4double energy = aPart->GetTotalEnergy();
149 G4String pName = aPart->GetDefinition()->G 147 G4String pName = aPart->GetDefinition()->GetParticleName();
150 148
151 G4int index = GetEnergyIndex(energy); 149 G4int index = GetEnergyIndex(energy);
152 150
153 if( index >= fIndex ) 151 if( index >= fIndex )
154 { 152 {
155 G4double pm = proton_mass_c2; 153 G4double pm = proton_mass_c2;
156 G4double s2 = 2.*energy*pm+pm*pm; 154 G4double s2 = 2.*energy*pm+pm*pm;
157 G4double aa = 1.; 155 G4double aa = 1.;
158 G4double bb = 1.085; 156 G4double bb = 1.085;
159 G4double mw = 80.385*GeV; 157 G4double mw = 80.385*GeV;
160 fCcFactor = bb/(1.+ aa*s2/mw/mw); 158 fCcFactor = bb/(1.+ aa*s2/mw/mw);
161 159
162 G4double mz = 91.1876*GeV; 160 G4double mz = 91.1876*GeV;
163 fNcFactor = bb/(1.+ aa*s2/mz/mz); 161 fNcFactor = bb/(1.+ aa*s2/mz/mz);
164 } 162 }
165 ccnuXsc = GetNuMuTotCsXsc(index, energy, Z, << 163 ccnuXsc = GetNuMuTotCsXsc(index, energy);
166 ccnuXsc *= fCcFactor; 164 ccnuXsc *= fCcFactor;
167 ccanuXsc = GetANuMuTotCsXsc(index, energy, Z << 165 ccanuXsc = GetANuMuTotCsXsc(index, energy);
168 ccanuXsc *= fCcFactor; 166 ccanuXsc *= fCcFactor;
169 167
170 if( pName == "nu_mu" ) << 168 if( pName == "nu_mu")
171 { 169 {
172 ncXsc = fCofL*ccnuXsc + fCofS*ccanuXsc; 170 ncXsc = fCofL*ccnuXsc + fCofS*ccanuXsc;
173 ncXsc *= fNcFactor/fCcFactor; 171 ncXsc *= fNcFactor/fCcFactor;
174 totXsc = ccnuXsc + ncXsc; 172 totXsc = ccnuXsc + ncXsc;
175 if( totXsc > 0.) fCcTotRatio = ccnuXsc/tot 173 if( totXsc > 0.) fCcTotRatio = ccnuXsc/totXsc;
176 } 174 }
177 else if( pName == "anti_nu_mu" ) << 175 else if( pName == "anti_nu_mu")
178 { 176 {
179 ncXsc = fCofL*ccanuXsc + fCofS*ccnuXsc; 177 ncXsc = fCofL*ccanuXsc + fCofS*ccnuXsc;
180 ncXsc *= fNcFactor/fCcFactor; 178 ncXsc *= fNcFactor/fCcFactor;
181 totXsc = ccanuXsc + ncXsc; 179 totXsc = ccanuXsc + ncXsc;
182 if( totXsc > 0.) fCcTotRatio = ccanuXsc/to 180 if( totXsc > 0.) fCcTotRatio = ccanuXsc/totXsc;
183 } 181 }
184 else return totXsc; 182 else return totXsc;
185 183
186 totXsc *= fCofXsc; 184 totXsc *= fCofXsc;
187 totXsc *= energy; 185 totXsc *= energy;
188 // totXsc *= A; // incoherent sum over all << 186 totXsc *= A; // incoherent sum over all isotope nucleons
189 187
190 totXsc *= fBiasingFactor; // biasing up, if 188 totXsc *= fBiasingFactor; // biasing up, if set >1
191 189
192 fTotXsc = totXsc; 190 fTotXsc = totXsc;
193 191
194 return totXsc; 192 return totXsc;
195 } 193 }
196 194
197 ////////////////////////////////////////////// 195 /////////////////////////////////////////////////////
198 // 196 //
199 // Return index of nu/anu energy array corresp 197 // Return index of nu/anu energy array corresponding to the neutrino energy
200 198
201 G4int G4MuNeutrinoNucleusTotXsc::GetEnergyInde 199 G4int G4MuNeutrinoNucleusTotXsc::GetEnergyIndex(G4double energy)
202 { 200 {
203 G4int i, eIndex = 0; 201 G4int i, eIndex = 0;
204 202
205 for( i = 0; i < fIndex; i++) 203 for( i = 0; i < fIndex; i++)
206 { 204 {
207 if( energy <= fNuMuEnergy[i]*GeV ) 205 if( energy <= fNuMuEnergy[i]*GeV )
208 { 206 {
209 eIndex = i; 207 eIndex = i;
210 break; 208 break;
211 } 209 }
212 } 210 }
213 if( i >= fIndex ) eIndex = i; 211 if( i >= fIndex ) eIndex = i;
214 // G4cout<<"eIndex = "<<eIndex<<G4endl; 212 // G4cout<<"eIndex = "<<eIndex<<G4endl;
215 return eIndex; 213 return eIndex;
216 } 214 }
217 215
218 ////////////////////////////////////////////// 216 /////////////////////////////////////////////////////
219 // 217 //
220 // nu_mu xsc for index-1, index linear over en 218 // nu_mu xsc for index-1, index linear over energy
221 219
222 G4double G4MuNeutrinoNucleusTotXsc::GetNuMuTot << 220 G4double G4MuNeutrinoNucleusTotXsc::GetNuMuTotCsXsc(G4int index, G4double energy)
223 { 221 {
224 G4double xsc(0.), qexsc(0.), inxsc(0.); << 222 G4double xsc(0.);
225 G4int nn = aa - zz; << 223
226 if(nn < 1) nn = 0; << 224 if( index <= 0 || energy < theMuonMinus->GetPDGMass() ) xsc = fNuMuTotXsc[0];
227 << 225 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 226 else
232 { 227 {
233 G4double x1 = fNuMuEnergy[index-1]*GeV; 228 G4double x1 = fNuMuEnergy[index-1]*GeV;
234 G4double x2 = fNuMuEnergy[index]*GeV; 229 G4double x2 = fNuMuEnergy[index]*GeV;
235 G4double y1 = fNuMuInXsc[index-1]; << 230 G4double y1 = fNuMuTotXsc[index-1];
236 G4double y2 = fNuMuInXsc[index]; << 231 G4double y2 = fNuMuTotXsc[index];
237 G4double z1 = fNuMuQeXsc[index-1]; <<
238 G4double z2 = fNuMuQeXsc[index]; <<
239 232
240 if(x1 >= x2) return aa*fNuMuInXsc[index] + << 233 if(x1 >= x2) return fNuMuTotXsc[index];
241 else 234 else
242 { 235 {
243 G4double angle = (y2-y1)/(x2-x1); 236 G4double angle = (y2-y1)/(x2-x1);
244 inxsc = y1 + (energy-x1)*angle; << 237 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 } 238 }
252 } 239 }
253 return xsc; 240 return xsc;
254 } 241 }
255 242
256 ////////////////////////////////////////////// 243 /////////////////////////////////////////////////////
257 // 244 //
258 // anu_mu xsc for index-1, index linear over e 245 // anu_mu xsc for index-1, index linear over energy
259 246
260 G4double G4MuNeutrinoNucleusTotXsc::GetANuMuTo << 247 G4double G4MuNeutrinoNucleusTotXsc::GetANuMuTotCsXsc(G4int index, G4double energy)
261 { 248 {
262 G4double xsc(0.), qexsc(0.), inxsc(0.); << 249 G4double xsc(0.);
263 250
264 // if( index <= 0 || energy < theMuonPlus->G << 251 if( index <= 0 || energy < theMuonPlus->GetPDGMass() ) xsc = fANuMuTotXsc[0];
265 if( index <= 0 || energy < fEmc ) xsc = aa*f << 252 else if (index >= fIndex) xsc = fANuMuTotXsc[fIndex-1];
266 else if (index >= fIndex) xsc = aa*fANuMuInX <<
267 else 253 else
268 { 254 {
269 G4double x1 = fNuMuEnergy[index-1]*GeV; 255 G4double x1 = fNuMuEnergy[index-1]*GeV;
270 G4double x2 = fNuMuEnergy[index]*GeV; 256 G4double x2 = fNuMuEnergy[index]*GeV;
271 G4double y1 = fANuMuInXsc[index-1]; << 257 G4double y1 = fANuMuTotXsc[index-1];
272 G4double y2 = fANuMuInXsc[index]; << 258 G4double y2 = fANuMuTotXsc[index];
273 G4double z1 = fANuMuQeXsc[index-1]; <<
274 G4double z2 = fANuMuQeXsc[index]; <<
275 259
276 if( x1 >= x2 ) return aa*fANuMuInXsc[index << 260 if( x1 >= x2 ) return fANuMuTotXsc[index];
277 else 261 else
278 { 262 {
279 G4double angle = (y2-y1)/(x2-x1); 263 G4double angle = (y2-y1)/(x2-x1);
280 inxsc = y1 + (energy-x1)*angle; << 264 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 } 265 }
289 } 266 }
290 return xsc; 267 return xsc;
291 } 268 }
292 269
293 ////////////////////////////////////////////// 270 ////////////////////////////////////////////////////////
294 // 271 //
295 // return fNuMuTotXsc[index] if the index is i 272 // return fNuMuTotXsc[index] if the index is in the array range
296 273
297 G4double G4MuNeutrinoNucleusTotXsc::GetNuMuTot 274 G4double G4MuNeutrinoNucleusTotXsc::GetNuMuTotCsArray( G4int index)
298 { 275 {
299 if( index >= 0 && index < fIndex) return fNu << 276 if( index >= 0 && index < fIndex) return fNuMuTotXsc[index];
300 else 277 else
301 { 278 {
302 G4cout<<"Improper index of fNuMuTotXsc arr 279 G4cout<<"Improper index of fNuMuTotXsc array"<<G4endl;
303 return 0.; 280 return 0.;
304 } 281 }
305 } 282 }
306 283
307 ////////////////////////////////////////////// 284 ////////////////////////////////////////////////////////
308 // 285 //
309 // return fANuMuTotXsc[index] if the index is 286 // return fANuMuTotXsc[index] if the index is in the array range
310 287
311 G4double G4MuNeutrinoNucleusTotXsc::GetANuMuTo 288 G4double G4MuNeutrinoNucleusTotXsc::GetANuMuTotCsArray( G4int index)
312 { 289 {
313 if( index >= 0 && index < fIndex) return fAN << 290 if( index >= 0 && index < fIndex) return fANuMuTotXsc[index];
314 else 291 else
315 { 292 {
316 G4cout<<"Improper index of fANuMuTotXsc ar 293 G4cout<<"Improper index of fANuMuTotXsc array"<<G4endl;
317 return 0.; 294 return 0.;
318 } 295 }
319 } 296 }
320 297
321 298
322 ////////////////////////////////////////////// 299 ///////////////////////////////////////////////////////
323 // 300 //
324 // E_nu in GeV, ( Eth = 111.603 MeV, EthW = 33 << 301 // E_nu in GeV
325 302
326 const G4double G4MuNeutrinoNucleusTotXsc::fNuM 303 const G4double G4MuNeutrinoNucleusTotXsc::fNuMuEnergy[50] =
327 { 304 {
328 0.12, 0.141136, 0.165996, 0.195233, 0.229621 << 305 0.112103, 0.117359, 0.123119, 0.129443, 0.136404,
329 0.270066, 0.317634, 0.373581, 0.439382, 0.51 << 306 0.144084, 0.152576, 0.161991, 0.172458, 0.184126,
330 0.607795, 0.714849, 0.84076, 0.988848, 1.163 << 307 0.197171, 0.211801, 0.228261, 0.24684, 0.267887,
331 1.36787, 1.6088, 1.89217, 2.22545, 2.61743, << 308 0.291816, 0.319125, 0.350417, 0.386422, 0.428032,
332 3.07845, 3.62068, 4.25841, 5.00847, 5.89065, << 309 0.47634, 0.532692, 0.598756, 0.676612, 0.768868,
333 6.9282, 8.14851, 9.58376, 11.2718, 13.2572, << 310 0.878812, 1.01062, 1.16963, 1.36271, 1.59876,
334 15.5922, 18.3386, 21.5687, 25.3677, 29.8359, << 311 1.88943, 2.25002, 2.70086, 3.26916, 3.99166,
335 35.0911, 41.2719, 48.5413, 57.0912, 67.147, << 312 4.91843, 6.11836, 7.6872, 9.75942, 12.5259,
336 78.974, 92.8842, 109.244, 128.486, 151.117, << 313 16.2605, 21.3615, 28.4141, 38.2903, 52.3062,
337 177.735, 209.04, 245.86, 289.164, 340.097 }; << 314 72.4763, 101.93, 145.6, 211.39, 312.172};
338 315
339 ////////////////////////////////////////////// << 316 /////////////////////////////////////////////////////////////
340 // 317 //
341 // XS/E arrays in 10^-38cm2/GeV << 318 // nu_mu CC xsc_tot/E_nu, in 10^-38 cm2/GeV
342 319
343 const G4double G4MuNeutrinoNucleusTotXsc::fNuM << 320 const G4double G4MuNeutrinoNucleusTotXsc::fNuMuTotXsc[50] =
344 { 321 {
345 0, 0, 0, 0, 0, << 322 0.0716001, 0.241013, 0.337793, 0.416033, 0.484616,
346 0, 0, 0.0166853, 0.0649693, 0.132346, << 323 0.546945, 0.604661, 0.658623, 0.709277, 0.756815,
347 0.209102, 0.286795, 0.3595, 0.423961, 0.479 << 324 0.801263, 0.842519, 0.880396, 0.914642, 0.944968,
348 0.524797, 0.562165, 0.592225, 0.61612, 0.63 << 325 0.971069, 0.992655, 1.00947, 1.02133, 1.02812,
349 0.649524, 0.660751, 0.669245, 0.675546, 0.68 << 326 1.02987, 1.02671, 1.01892, 1.00689, 0.991167,
350 0.683247, 0.685307, 0.686521, 0.687093, 0.68 << 327 0.972618, 0.951518, 0.928806, 0.90521, 0.881404,
351 0.686919, 0.686384, 0.685631, 0.684689, 0.68 << 328 0.857978, 0.835424, 0.814112, 0.794314, 0.776204,
352 0.682275, 0.680806, 0.67917, 0.677376, 0.675 << 329 0.759884, 0.745394, 0.732719, 0.721809, 0.712164,
353 0.673387, 0.671229, 0.668985, 0.666665, 0.66 << 330 0.704299, 0.697804, 0.692491, 0.688137, 0.68448,
354 0.661804, 0.65925, 0.656593, 0.65381, 0.6508 << 331 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 332
370 333
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 334
401 //////////////////// << 335 /////////////////////////////////////////////////////////////
>> 336 //
>> 337 // anu_mu CC xsc_tot/E_nu, in 10^-38 cm2/GeV
402 338
>> 339 const G4double G4MuNeutrinoNucleusTotXsc::fANuMuTotXsc[50] =
>> 340 {
>> 341 0.0291812, 0.0979725, 0.136884, 0.16794, 0.194698,
>> 342 0.218468, 0.23992, 0.259241, 0.27665, 0.292251,
>> 343 0.30612, 0.318314, 0.328886, 0.337885, 0.345464,
>> 344 0.351495, 0.356131, 0.359448, 0.361531, 0.362474,
>> 345 0.362382, 0.361365, 0.359538, 0.357024, 0.353943,
>> 346 0.350422, 0.346685, 0.342662, 0.338567, 0.334514,
>> 347 0.330612, 0.326966, 0.323668, 0.320805, 0.318451,
>> 348 0.316671, 0.315514, 0.315013, 0.315187, 0.316036,
>> 349 0.317541, 0.319667, 0.322362, 0.325556, 0.329159,
>> 350 0.332577, 0.337133, 0.341214, 0.345128, 0.347657 };
403 351