1 | // |
---|
2 | // ******************************************************************** |
---|
3 | // * License and Disclaimer * |
---|
4 | // * * |
---|
5 | // * The Geant4 software is copyright of the Copyright Holders of * |
---|
6 | // * the Geant4 Collaboration. It is provided under the terms and * |
---|
7 | // * conditions of the Geant4 Software License, included in the file * |
---|
8 | // * LICENSE and available at http://cern.ch/geant4/license . These * |
---|
9 | // * include a list of copyright holders. * |
---|
10 | // * * |
---|
11 | // * Neither the authors of this software system, nor their employing * |
---|
12 | // * institutes,nor the agencies providing financial support for this * |
---|
13 | // * work make any representation or warranty, express or implied, * |
---|
14 | // * regarding this software system or assume any liability for its * |
---|
15 | // * use. Please see the license in the file LICENSE and URL above * |
---|
16 | // * for the full disclaimer and the limitation of liability. * |
---|
17 | // * * |
---|
18 | // * This code implementation is the result of the scientific and * |
---|
19 | // * technical work of the GEANT4 collaboration. * |
---|
20 | // * By using, copying, modifying or distributing the software (or * |
---|
21 | // * any work based on the software) you agree to acknowledge its * |
---|
22 | // * use in resulting scientific publications, and indicate your * |
---|
23 | // * acceptance of all terms of the Geant4 Software license. * |
---|
24 | // ******************************************************************** |
---|
25 | // |
---|
26 | // |
---|
27 | // $Id: G4QNeutronCaptureRatio.cc,v 1.1 2009/11/16 18:15:43 mkossov Exp $ |
---|
28 | // GEANT4 tag $Name: geant4-09-03-cand-01 $ |
---|
29 | // |
---|
30 | // |
---|
31 | // G4 Physics class: G4QNeutronCaptureRatio for N+A Diffraction Interactions |
---|
32 | // Created: M.V. Kossov, CERN/ITEP(Moscow), 10-OCT-01 |
---|
33 | // The last update: M.V. Kossov, CERN/ITEP (Moscow) 15-Oct-06 |
---|
34 | // |
---|
35 | //======================================================================= |
---|
36 | // Short description: (n,gamma) capture is a part of the incoherent |
---|
37 | // (inelastic) interaction. This part is calculated in the class. |
---|
38 | // ---------------------------------------------------------------------- |
---|
39 | |
---|
40 | //#define debug |
---|
41 | //#define pdebug |
---|
42 | //#define fdebug |
---|
43 | //#define nandebug |
---|
44 | |
---|
45 | #include "G4QNeutronCaptureRatio.hh" |
---|
46 | |
---|
47 | // Returns Pointer to the class G4QNeutronCaptureRatio |
---|
48 | G4QNeutronCaptureRatio* G4QNeutronCaptureRatio::GetPointer() |
---|
49 | { |
---|
50 | static G4QNeutronCaptureRatio theRatios; // *** Static body of the NeutCaptureRatio *** |
---|
51 | return &theRatios; |
---|
52 | } |
---|
53 | |
---|
54 | // Calculation of netronCapture/inelastic ratio |
---|
55 | G4double G4QNeutronCaptureRatio::GetRatio(G4double pIU, G4int tgZ, G4int tgN) |
---|
56 | { |
---|
57 | // Table parameters |
---|
58 | static const G4int npp=100; // Number of steps in the R(s) LinTable |
---|
59 | static const G4int mpp=npp+1; // Number of elements in the R(s) LinTable |
---|
60 | static const G4double pma=6.; // The first LinTabEl(mom=0)=1., mom>pma -> logTab |
---|
61 | static const G4double dp=pma/npp; // Step of the linear Table |
---|
62 | static const G4int nls=150; // Number of steps in the R(lns) logTable |
---|
63 | static const G4int mls=nls+1; // Number of elements in the R(lns) logTable |
---|
64 | static const G4double lpi=1.79; // The min ln(p) logTabEl(p=5.99 < pma=6.) |
---|
65 | static const G4double lpa=8.; // The max ln(p) logTabEl(p=5.99 - 2981 GeV) |
---|
66 | static const G4double mi=std::exp(lpi);// The min mom of logTabEl(~ 5.99 GeV) |
---|
67 | static const G4double ms=std::exp(lpa);// The max mom of logTabEl(~ 2981 GeV) |
---|
68 | static const G4double dl=(lpa-lpi)/nls;// Step of the logarithmic Table |
---|
69 | static const G4double edl=std::exp(dl);// Multiplication step of the logarithmic Table |
---|
70 | static const G4double toler=.0001; // Tolarence (GeV) defining the same momentum |
---|
71 | static G4double lastP=0.; // Last mometum value for which R was calculated |
---|
72 | static G4double lastR=0.; // Last ratio R which was calculated |
---|
73 | // Local Associative Data Base: |
---|
74 | static std::vector<G4int> vZ; // Vector of calculated Z (target) |
---|
75 | static std::vector<G4int> vN; // Vector of calculated N (target) |
---|
76 | static std::vector<G4double> vH; // Vector of max mom initialized in the LinTable |
---|
77 | static std::vector<G4int> vJ; // Vector of topBin number initialized in LinTable |
---|
78 | static std::vector<G4double> vM; // Vector of relMax ln(p) initialized in LogTable |
---|
79 | static std::vector<G4int> vK; // Vector of topBin number initialized in LogTable |
---|
80 | static std::vector<G4double*> vT; // Vector of pointers to LinTable in C++ heap |
---|
81 | static std::vector<G4double*> vL; // Vector of pointers to LogTable in C++ heap |
---|
82 | // Last values of the Associative Data Base: |
---|
83 | static G4int lastZ=0; // theLast of calculated A |
---|
84 | static G4int lastN=0; // theLast of calculated A |
---|
85 | static G4double lastH=0.; // theLast of max mom initialized in the LinTable |
---|
86 | static G4int lastJ=0; // theLast of topBinNumber initialized in LinTable |
---|
87 | static G4double lastM=0.; // theLast of relMax ln(p) initialized in LogTab. |
---|
88 | static G4int lastK=0; // theLast of topBinNumber initialized in LogTable |
---|
89 | static G4double* lastT=0; // theLast of pointer to LinTable in the C++ heap |
---|
90 | static G4double* lastL=0; // theLast of pointer to LogTable in the C++ heap |
---|
91 | // LogTable is created only if necessary. R(p>2981GeV) calcul by formula for any nuclei |
---|
92 | G4int A=tgN+tgZ; |
---|
93 | if(pIU<toler || A<1) return 1.; // Fake use of toler as non zero number |
---|
94 | if(A>247) |
---|
95 | { |
---|
96 | G4cout<<"-*-Warning-*-G4QuasiFreeRatio::GetRatio: A="<<A<<">247, return zero"<<G4endl; |
---|
97 | return 0.; |
---|
98 | } |
---|
99 | G4int nDB=vZ.size(); // A number of nuclei already initialized in AMDB |
---|
100 | if(nDB && lastZ==tgZ && lastN==tgN && std::fabs(pIU-lastP)<toler) return lastR; |
---|
101 | if(pIU>ms) |
---|
102 | { |
---|
103 | lastR=CalcCap2In_Ratio(s,tgZ,tgN); //@@ Probably user ought to be notified about bigP |
---|
104 | return lastR; |
---|
105 | } |
---|
106 | G4bool found=false; |
---|
107 | G4int i=-1; |
---|
108 | if(nDB) for (i=0; i<nDB; i++) if(tgZ==vZ[i] && tgN==vN[i]) // Sirch for this Z,N in AMDB |
---|
109 | { |
---|
110 | found=true; // The (Z,N) is found |
---|
111 | break; |
---|
112 | } |
---|
113 | if(!nDB || !found) // Create new line in the AMDB |
---|
114 | { |
---|
115 | lastZ = tgZ; |
---|
116 | lastN = tgN; |
---|
117 | lastT = new G4double[mpp]; // Create the linear Table |
---|
118 | lastJ = static_cast<int>(pIU/dp)+1; // MaxBin to be initialized |
---|
119 | if(lastJ>npp) |
---|
120 | { |
---|
121 | lastJ=npp; |
---|
122 | lastH=pma; |
---|
123 | } |
---|
124 | else lastH = lastJ*dp; // Calculate max initialized s for LinTab |
---|
125 | G4double pv=0; |
---|
126 | lastT[0]=1.; |
---|
127 | for(G4int j=1; j<=lastJ; j++) // Calculate LinTab values |
---|
128 | { |
---|
129 | pv+=dp; |
---|
130 | lastT[j]=CalcCap2In_Ratio(pv,tgZ,tgN); // ?? |
---|
131 | } |
---|
132 | lastL=new G4double[mls]; // Create the logarithmic Table |
---|
133 | G4double ls=std::log(s); |
---|
134 | lastK = static_cast<int>((ls-lpi)/dl)+1; // MaxBin to be initialized in LogTaB |
---|
135 | if(lastK>nls) |
---|
136 | { |
---|
137 | lastK=nls; |
---|
138 | lastM=lpa-lpi; |
---|
139 | } |
---|
140 | else lastM = lastK*dl; // Calculate max initialized ln(s)-lpi for LogTab |
---|
141 | pv=mi; |
---|
142 | for(G4int j=0; j<=lastK; j++) // Calculate LogTab values |
---|
143 | { |
---|
144 | lastL[j]=CalcCap2In_Ratio(pv,tgZ,tgN); |
---|
145 | if(j!=lastK) pv*=edl; |
---|
146 | } |
---|
147 | i++; // Make a new record to AMDB and position on it |
---|
148 | vZ.push_back(lastZ); |
---|
149 | vN.push_back(lastN); |
---|
150 | vH.push_back(lastH); |
---|
151 | vJ.push_back(lastJ); |
---|
152 | vM.push_back(lastM); |
---|
153 | vK.push_back(lastK); |
---|
154 | vT.push_back(lastT); |
---|
155 | vL.push_back(lastL); |
---|
156 | } |
---|
157 | else // The A value was found in AMDB |
---|
158 | { |
---|
159 | lastZ=vZ[i]; |
---|
160 | lastN=vN[i]; |
---|
161 | lastH=vH[i]; |
---|
162 | lastJ=vJ[i]; |
---|
163 | lastM=vM[i]; |
---|
164 | lastK=vK[i]; |
---|
165 | lastT=vT[i]; |
---|
166 | lastL=vL[i]; |
---|
167 | if(s>lastM) // At least LinTab must be updated |
---|
168 | { |
---|
169 | G4int nextN=lastJ+1; // The next bin to be initialized |
---|
170 | if(lastJ<npp) |
---|
171 | { |
---|
172 | lastJ = static_cast<int>(pIU/dp)+1;// MaxBin to be initialized |
---|
173 | if(lastJ>npp) |
---|
174 | { |
---|
175 | lastJ=npp; |
---|
176 | lastH=pma; |
---|
177 | } |
---|
178 | else lastH = lastJ*dp; // Calculate max initialized s for LinTab |
---|
179 | G4double pv=lastM; |
---|
180 | for(G4int j=nextN; j<=lastJ; j++)// Calculate LogTab values |
---|
181 | { |
---|
182 | pv+=dp; |
---|
183 | lastT[j]=CalcCap2In_Ratio(pv,tgZ,tgN); |
---|
184 | } |
---|
185 | } // End of LinTab update |
---|
186 | if(lastJ>=nextN) |
---|
187 | { |
---|
188 | vH[i]=lastH; |
---|
189 | vJ[i]=lastJ; |
---|
190 | } |
---|
191 | G4int nextK=lastK+1; |
---|
192 | if(pIU>pma && lastK<nls) // LogTab must be updated |
---|
193 | { |
---|
194 | G4double pv=std::exp(lastM+lpi); // Define starting poit (lastM will be changed) |
---|
195 | G4double ls=std::log(s); |
---|
196 | lastK = static_cast<int>((ls-lpi)/dl)+1; // MaxBin to be initialized in LogTaB |
---|
197 | if(lastK>nls) |
---|
198 | { |
---|
199 | lastK=nls; |
---|
200 | lastM=lpa-lpi; |
---|
201 | } |
---|
202 | else lastM = lastK*dl; // Calculate max initialized ln(p)-lpi for LogTab |
---|
203 | for(G4int j=nextK; j<=lastK; j++)// Calculate LogTab values |
---|
204 | { |
---|
205 | pv*=edl; |
---|
206 | lastL[j]=CalcCap2In_Ratio(pv,tgZ,tgN); |
---|
207 | } |
---|
208 | } // End of LogTab update |
---|
209 | if(lastK>=nextK) |
---|
210 | { |
---|
211 | vM[i]=lastM; |
---|
212 | vK[i]=lastK; |
---|
213 | } |
---|
214 | } |
---|
215 | } |
---|
216 | // Now one can use tabeles to calculate the value |
---|
217 | if(pIU<pma) // Use linear table |
---|
218 | { |
---|
219 | G4int n=static_cast<int>(pIU/dp); // Low edge number of the bin |
---|
220 | G4double d=s-n*dp; // Linear shift |
---|
221 | G4double v=lastT[n]; // Base |
---|
222 | lastR=v+d*(lastT[n+1]-v)/dp; // Result |
---|
223 | } |
---|
224 | else // Use log table |
---|
225 | { |
---|
226 | G4double ls=std::log(pIU)-lpi; // ln(p)-l_min |
---|
227 | G4int n=static_cast<int>(ls/dl); // Low edge number of the bin |
---|
228 | G4double d=ls-n*dl; // Log shift |
---|
229 | G4double v=lastL[n]; // Base |
---|
230 | lastR=v+d*(lastL[n+1]-v)/dl; // Result |
---|
231 | } |
---|
232 | if(lastR<0.) lastR=0.; |
---|
233 | if(lastR>1.) lastR=1.; |
---|
234 | return lastR; |
---|
235 | } // End of GetRatio |
---|
236 | |
---|
237 | // Calculate Capture/Inelastic Ratio as a function of total momentum (in GeV/c) |
---|
238 | G4double G4QNeutronCaptureRatio::CalcCap2In_Ratio(G4double p, G4int Z, G4int N) |
---|
239 | { |
---|
240 | //==> n (Z=0) |
---|
241 | static const G4int N0=1; |
---|
242 | static const G4double pZ0N1[5]={.0001, 40., 0., 0., 1.}; // *** No Capture ? |
---|
243 | static const std::pair<G4int, const G4double*> Z0N1=std::make_pair(1,pZ0N1); |
---|
244 | static const std::pair<G4int, const G4double*> Z0[N0]={Z0N1}; |
---|
245 | //==> H (Z=1) *** no protons, which are treated separately *** |
---|
246 | static const G4int N1=2; |
---|
247 | static const G4double pZ1N1[5]={.07, 40., .0006, .0001, .01}; |
---|
248 | static const std::pair<G4int, const G4double*> Z1N1=std::make_pair(1,pZ1N1); |
---|
249 | static const G4double pZ1N2[5]={.0001, 40., 0., 0., 1.}; // *** No Capture ? |
---|
250 | static const std::pair<G4int, const G4double*> Z1N2=std::make_pair(2,pZ1N2); |
---|
251 | static const std::pair<G4int, const G4double*> Z1[N1]={Z1N1, Z1N2}; |
---|
252 | //==> He(Z=2) |
---|
253 | static const G4int N2=2; |
---|
254 | static const G4double pZ2N1[5]={.1, 40., 0., 0., 1.}; // *** Unknown threshold |
---|
255 | static const std::pair<G4int, const G4double*> Z2N1=std::make_pair(1,pZ2N1); |
---|
256 | static const G4double pZ2N2[5]={.0001, 40., 0., 0., 1.}; // *** No Capture ? |
---|
257 | static const std::pair<G4int, const G4double*> Z2N2=std::make_pair(2,pZ2N2); |
---|
258 | static const std::pair<G4int, const G4double*> Z2[N2]={Z2N1, Z2N2}; |
---|
259 | //==> Li(Z=3) |
---|
260 | static const G4int N3=2; |
---|
261 | static const G4double pZ3N3[5]={.001, 40., 3.E-5, .0001, .1}; |
---|
262 | static const std::pair<G4int, const G4double*> Z3N1=std::make_pair(3,pZ3N3); |
---|
263 | static const G4double pZ3N4[5]={.022, 19., 3.E-5, .0001, .04}; |
---|
264 | static const std::pair<G4int, const G4double*> Z3N2=std::make_pair(4,pZ3N4); |
---|
265 | static const std::pair<G4int, const G4double*> Z3[N3]={Z3N1, Z3N2}; |
---|
266 | //==> Be(Z=4) |
---|
267 | static const G4int N4=1; |
---|
268 | static const G4double pZ4N5[5]={.0004, 40., 0., 0., 1.}; |
---|
269 | static const std::pair<G4int, const G4double*> Z4N5=std::make_pair(5,pZ4N5); |
---|
270 | static const std::pair<G4int, const G4double*> Z4[N4]={Z4N5}; |
---|
271 | //==> B (Z=5) |
---|
272 | static const G4int N5=2; |
---|
273 | static const G4double pZ5N5[5]={.011, 9., .0002, .0001, .002}; |
---|
274 | static const std::pair<G4int, const G4double*> Z5N5=std::make_pair(5,pZ5N5); |
---|
275 | static const G4double pZ5N6[5]={.027, 9., 0., 0., 1.}; |
---|
276 | static const std::pair<G4int, const G4double*> Z5N6=std::make_pair(6,pZ5N6); |
---|
277 | static const std::pair<G4int, const G4double*> Z5[N5]={Z5N5, Z5N6}; |
---|
278 | //==> C (Z=6) |
---|
279 | static const G4int N6=2; |
---|
280 | static const G4double pZ6N6[5]={.08, 40., .0003, .0001, .07}; // *** Only Nat Mix *** |
---|
281 | static const std::pair<G4int, const G4double*> Z6N6=std::make_pair(6,pZ6N6); |
---|
282 | static const G4double pZ6N7[5]={.08, 40., .0003, .0001, .07}; // *** Only Nat Mix *** |
---|
283 | static const std::pair<G4int, const G4double*> Z6N7=std::make_pair(7,pZ6N7); |
---|
284 | static const std::pair<G4int, const G4double*> Z6[N6]={Z6N6, Z6N7}; |
---|
285 | //==> N (Z=7) |
---|
286 | static const G4int N7=2; |
---|
287 | static const G4double pZ7N7[5]={.005, 3., 0., 0., 1.}; |
---|
288 | static const std::pair<G4int, const G4double*> Z7N7=std::make_pair(7,pZ7N7); |
---|
289 | static const G4double pZ7N8[5]={.084, 40., .0001, .0001, .015}; |
---|
290 | static const std::pair<G4int, const G4double*> Z7N8=std::make_pair(8,pZ7N8); |
---|
291 | static const std::pair<G4int, const G4double*> Z7[N7]={Z7N7, Z7N8}; |
---|
292 | //==> O (Z=8) |
---|
293 | static const G4int N8=3; |
---|
294 | static const G4double pZ8N8[5]={.08, 40., 0., 0., 1.}; |
---|
295 | static const std::pair<G4int, const G4double*> Z8N8=std::make_pair(8,pZ8N8); |
---|
296 | static const G4double pZ8N9[5]={.0065, 5., .0013, .0001, .02}; |
---|
297 | static const std::pair<G4int, const G4double*> Z8N9=std::make_pair(9,pZ8N9); |
---|
298 | static const G4double pZ8N10[5]={.01, 27., 0., 0., 1.}; // *** No DATA *** |
---|
299 | static const std::pair<G4int, const G4double*> Z8N10=std::make_pair(10,pZ8N10); |
---|
300 | static const std::pair<G4int, const G4double*> Z8[N8]={Z8N8, Z8N9, Z8N10}; |
---|
301 | //==> F (Z=9) |
---|
302 | static const G4int N9=1; |
---|
303 | static const G4double pZ9N10[5]={.013, 27., .0001, .0001, .02}; |
---|
304 | static const std::pair<G4int, const G4double*> Z9N10=std::make_pair(10,pZ9N10); |
---|
305 | static const std::pair<G4int, const G4double*> Z9[N9]={Z9N10}; |
---|
306 | //==> Ne(Z=10) |
---|
307 | static const G4int N10=3; |
---|
308 | static const G4double pZ10N10[5]={.01, 27., 0., 0., 1.}; // *** No DATA *** |
---|
309 | static const std::pair<G4int, const G4double*> Z10N10=std::make_pair(10,pZ10N10); |
---|
310 | static const G4double pZ10N11[5]={.01, 27., 0., 0., 1.}; // *** No DATA *** |
---|
311 | static const std::pair<G4int, const G4double*> Z10N11=std::make_pair(11,pZ10N11); |
---|
312 | static const G4double pZ10N12[5]={.01, 27., 0., 0., 1.}; // *** No DATA *** |
---|
313 | static const std::pair<G4int, const G4double*> Z10N12=std::make_pair(12,pZ10N12); |
---|
314 | static const std::pair<G4int, const G4double*> Z10[N10]={Z10N10, Z10N11, Z10N12}; |
---|
315 | //==> Na(Z=11) |
---|
316 | static const G4int N11=1; |
---|
317 | static const G4double pZ11N12[5]={.024, 17., .0005, .0001, .03}; |
---|
318 | static const std::pair<G4int, const G4double*> Z11N12=std::make_pair(12,pZ11N12); |
---|
319 | static const std::pair<G4int, const G4double*> Z11[N11]={Z11N12}; |
---|
320 | //==> Mg(Z=12) |
---|
321 | static const G4int N12=3; |
---|
322 | static const G4double pZ12N12[5]={.045, 40., .0003, .0001, .02}; |
---|
323 | static const std::pair<G4int, const G4double*> Z12N12=std::make_pair(12,pZ12N12); |
---|
324 | static const G4double pZ12N13[5]={.019, 7., .0002, .0001, .01}; |
---|
325 | static const std::pair<G4int, const G4double*> Z12N13=std::make_pair(13,pZ12N13); |
---|
326 | static const G4double pZ12N14[5]={.053, 40., .0006, .0001, .007}; |
---|
327 | static const std::pair<G4int, const G4double*> Z12N14=std::make_pair(14,pZ12N14); |
---|
328 | static const std::pair<G4int, const G4double*> Z12[N12]={Z12N12, Z12N13, Z12N14}; |
---|
329 | //==> Al(Z=13) |
---|
330 | static const G4int N13=1; |
---|
331 | static const G4double pZ13N14[5]={.035, 17., .001, .03, 1.}; |
---|
332 | static const std::pair<G4int, const G4double*> Z13N14=std::make_pair(14,pZ13N14); |
---|
333 | static const std::pair<G4int, const G4double*> Z13[N13]={Z13N14}; |
---|
334 | //==> Si(Z=14) |
---|
335 | static const G4int N14=3; |
---|
336 | static const G4double pZ14N14[5]={.052, 40., .002, .0001, .008}; |
---|
337 | static const std::pair<G4int, const G4double*> Z14N14=std::make_pair(14,pZ14N14); |
---|
338 | static const G4double pZ14N15[5]={.048, 40., .0001, .0004, .02}; |
---|
339 | static const std::pair<G4int, const G4double*> Z14N15=std::make_pair(15,pZ14N15); |
---|
340 | static const G4double pZ14N16[5]={.06, 40., .0015, .0001, .01}; |
---|
341 | static const std::pair<G4int, const G4double*> Z14N16=std::make_pair(16,pZ14N16); |
---|
342 | static const std::pair<G4int, const G4double*> Z14[N14]={Z14N14, Z14N15, Z14N16}; |
---|
343 | //==> P (Z=15) |
---|
344 | static const G4int N15=1; |
---|
345 | static const G4double pZ15N16[5]={.024, 7., .0008, .0001, .03}; |
---|
346 | static const std::pair<G4int, const G4double*> Z15N16=std::make_pair(16,pZ15N16); |
---|
347 | static const std::pair<G4int, const G4double*> Z15[N15]={Z15N16}; |
---|
348 | //==> S (Z=16) |
---|
349 | static const G4int N16=4; |
---|
350 | static const G4double pZ16N16[5]={.036, 12., .0003, .03, .004}; |
---|
351 | static const std::pair<G4int, const G4double*> Z16N16=std::make_pair(16,pZ16N16); |
---|
352 | static const G4double pZ16N17[5]={.018, 40., .0033, .0001, .002}; |
---|
353 | static const std::pair<G4int, const G4double*> Z16N17=std::make_pair(17,pZ16N17); |
---|
354 | static const G4double pZ16N18[5]={.053, 25., .002, .0001, .0043}; |
---|
355 | static const std::pair<G4int, const G4double*> Z16N18=std::make_pair(18,pZ16N18); |
---|
356 | static const G4double pZ16N20[5]={.065, 25., .002, .0001, .0043}; |
---|
357 | static const std::pair<G4int, const G4double*> Z16N20=std::make_pair(20,pZ16N20); |
---|
358 | static const std::pair<G4int, const G4double*> Z16[N16]={Z16N16, Z16N17, Z16N18, Z16N20}; |
---|
359 | //==> Cl(Z=17) |
---|
360 | static const G4int N17=2; |
---|
361 | static const G4double pZ17N18[5]={.014, 4., .0004, .175, .002}; |
---|
362 | static const std::pair<G4int, const G4double*> Z17N18=std::make_pair(18,pZ17N18); |
---|
363 | static const G4double pZ17N20[5]={.035, 8., .008, 18., .0005}; |
---|
364 | static const std::pair<G4int, const G4double*> Z17N20=std::make_pair(20,pZ17N20); |
---|
365 | static const std::pair<G4int, const G4double*> Z17[N17]={Z17N18, Z17N20}; |
---|
366 | //==> Ar(Z=18) |
---|
367 | static const G4int N18=3; |
---|
368 | static const G4double pZ18N18[5]={.036, 8., .0005, .1, .01}; |
---|
369 | static const std::pair<G4int, const G4double*> Z18N18=std::make_pair(18,pZ18N18); |
---|
370 | static const G4double pZ18N20[5]={.025, 6., .0027, .19, .0003}; |
---|
371 | static const std::pair<G4int, const G4double*> Z18N20=std::make_pair(20,pZ18N20); |
---|
372 | static const G4double pZ18N22[5]={.028, 6., .001, .19, .0003}; |
---|
373 | static const std::pair<G4int, const G4double*> Z18N22=std::make_pair(22,pZ18N22); |
---|
374 | static const std::pair<G4int, const G4double*> Z18[N18]={Z18N18, Z18N20, Z18N22}; |
---|
375 | //==> K (Z=19) |
---|
376 | static const G4int N19=3; |
---|
377 | static const G4double pZ19N20[5]={.04, 8., 0., 0., 1.}; |
---|
378 | static const std::pair<G4int, const G4double*> Z19N20=std::make_pair(20,pZ19N20); |
---|
379 | static const G4double pZ19N21[5]={.049, 5., 0., 0., 1.}; |
---|
380 | static const std::pair<G4int, const G4double*> Z19N21=std::make_pair(21,pZ19N21); |
---|
381 | static const G4double pZ19N22[5]={.04, 11., .005, .0001, .005}; |
---|
382 | static const std::pair<G4int, const G4double*> Z19N22=std::make_pair(22,pZ19N22); |
---|
383 | static const std::pair<G4int, const G4double*> Z19[N19]={Z19N20, Z19N21, Z19N22}; |
---|
384 | //==> Ca(Z=20) |
---|
385 | static const G4int N20=6; |
---|
386 | static const G4double pZ20N20[5]={.05, 14., .0006, .09, .009}; |
---|
387 | static const std::pair<G4int, const G4double*> Z20N20=std::make_pair(20,pZ20N20); |
---|
388 | static const G4double pZ20N22[5]={.047, 30., .003, .0001, .014}; |
---|
389 | static const std::pair<G4int, const G4double*> Z20N22=std::make_pair(22,pZ20N22); |
---|
390 | static const G4double pZ20N23[5]={.01, 3.5, .0015, .16, .002}; |
---|
391 | static const std::pair<G4int, const G4double*> Z20N23=std::make_pair(23,pZ20N23); |
---|
392 | static const G4double pZ20N24[5]={.04, 30., .002, .0001, .008}; |
---|
393 | static const std::pair<G4int, const G4double*> Z20N24=std::make_pair(24,pZ20N24); |
---|
394 | static const G4double pZ20N26[5]={.044, 40., .001, .0001, .01}; |
---|
395 | static const std::pair<G4int, const G4double*> Z20N26=std::make_pair(26,pZ20N26); |
---|
396 | static const G4double pZ20N28[5]={.055, 14., .001, .18, .001}; |
---|
397 | static const std::pair<G4int, const G4double*> Z20N28=std::make_pair(28,pZ20N28); |
---|
398 | static const std::pair<G4int, const G4double*> Z20[N20]={Z20N20, Z20N22, Z20N23, |
---|
399 | Z20N24, Z20N26, Z20N28}; |
---|
400 | //==> Sc(Z=21) |
---|
401 | static const G4int N21=1; |
---|
402 | static const G4double pZ21N24[5]={.014, 4., 0., 0., 1.}; |
---|
403 | static const std::pair<G4int, const G4double*> Z21N24=std::make_pair(24,pZ21N24); |
---|
404 | static const std::pair<G4int, const G4double*> Z21[N21]={Z21N24}; |
---|
405 | //==> Ti(Z=22) |
---|
406 | static const G4int N22=5; |
---|
407 | static const G4double pZ22N24[5]={.036, 27., .007, .0001, .005}; |
---|
408 | static const std::pair<G4int, const G4double*> Z22N24=std::make_pair(24,pZ22N24); |
---|
409 | static const G4double pZ22N25[5]={.013, 9., .017, .0001, .005}; |
---|
410 | static const std::pair<G4int, const G4double*> Z22N25=std::make_pair(25,pZ22N25); |
---|
411 | static const G4double pZ22N26[5]={.043, 40., .002, .0001, .01}; |
---|
412 | static const std::pair<G4int, const G4double*> Z22N26=std::make_pair(26,pZ22N26); |
---|
413 | static const G4double pZ22N27[5]={.047, 30., .007, .0001, .01}; |
---|
414 | static const std::pair<G4int, const G4double*> Z22N27=std::make_pair(27,pZ22N27); |
---|
415 | static const G4double pZ22N28[5]={.052, 40., .0005, .0001, .01}; |
---|
416 | static const std::pair<G4int, const G4double*> Z22N28=std::make_pair(28,pZ22N28); |
---|
417 | static const std::pair<G4int, const G4double*> Z22[N22]={Z22N24, Z22N25, Z22N26, |
---|
418 | Z22N27, Z22N28}; |
---|
419 | //==> V (Z=23) |
---|
420 | static const G4int N23=2; |
---|
421 | static const G4double pZ23N27[5]={.023, 30., .01, .0001, .003}; // *** Only Nat mix *** |
---|
422 | static const std::pair<G4int, const G4double*> Z23N27=std::make_pair(27,pZ23N27); |
---|
423 | static const G4double pZ23N28[5]={.023, 30., .01, .0001, .003}; // *** Only Nat mix *** |
---|
424 | static const std::pair<G4int, const G4double*> Z23N28=std::make_pair(28,pZ23N28); |
---|
425 | static const std::pair<G4int, const G4double*> Z23[N23]={Z23N27, Z23N28}; |
---|
426 | //==> Cr(Z=24) |
---|
427 | static const G4int N24=4; |
---|
428 | static const G4double pZ24N26[5]={.035, 27., .004, .0001, .01}; |
---|
429 | static const std::pair<G4int, const G4double*> Z24N26=std::make_pair(26,pZ24N26); |
---|
430 | static const G4double pZ24N28[5]={.049, 40., .001, .0001, .016}; |
---|
431 | static const std::pair<G4int, const G4double*> Z24N28=std::make_pair(28,pZ24N28); |
---|
432 | static const G4double pZ24N29[5]={.032, 30., .005, .0001, .005}; |
---|
433 | static const std::pair<G4int, const G4double*> Z24N29=std::make_pair(29,pZ24N29); |
---|
434 | static const G4double pZ24N30[5]={.034, 30., .002, .0001, .008}; |
---|
435 | static const std::pair<G4int, const G4double*> Z24N30=std::make_pair(30,pZ24N30); |
---|
436 | static const std::pair<G4int, const G4double*> Z24[N24]={Z24N26, Z24N28, Z24N29, Z24N30}; |
---|
437 | //==> Mn(Z=25) |
---|
438 | static const G4int N25=1; |
---|
439 | static const G4double pZ25N30[5]={.0145, 10., .01, .0001, .003}; |
---|
440 | static const std::pair<G4int, const G4double*> Z25N30=std::make_pair(30,pZ25N30); |
---|
441 | static const std::pair<G4int, const G4double*> Z25[N25]={Z25N30}; |
---|
442 | //==> Fe(Z=26) |
---|
443 | static const G4int N26=4; |
---|
444 | static const G4double pZ26N28[5]={.048, 27., .0016, .0001, .016}; |
---|
445 | static const std::pair<G4int, const G4double*> Z26N28=std::make_pair(28,pZ26N28); |
---|
446 | static const G4double pZ26N30[5]={.036, 27., .004, .0001, .006}; |
---|
447 | static const std::pair<G4int, const G4double*> Z26N30=std::make_pair(30,pZ26N30); |
---|
448 | static const G4double pZ26N31[5]={.036, 27., .005, .0001, .005}; |
---|
449 | static const std::pair<G4int, const G4double*> Z26N31=std::make_pair(31,pZ26N31); |
---|
450 | static const G4double pZ26N32[5]={.036, 27., .005, .0001, .007}; |
---|
451 | static const std::pair<G4int, const G4double*> Z26N32=std::make_pair(32,pZ26N32); |
---|
452 | static const std::pair<G4int, const G4double*> Z26[N26]={Z26N28, Z26N30, Z26N31, Z26N32}; |
---|
453 | //==> Co(Z=27) |
---|
454 | static const G4int N27=1; |
---|
455 | static const G4double pZ27N32[5]={.044, 22., .002, .0001, .016}; |
---|
456 | static const std::pair<G4int, const G4double*> Z27N32=std::make_pair(32,pZ27N32); |
---|
457 | static const std::pair<G4int, const G4double*> Z27[N27]={Z27N32}; |
---|
458 | //==> Ni(Z=28) |
---|
459 | static const G4int N28=5; |
---|
460 | static const G4double pZ28N30[5]={.045, 20., .003, .0001, .01}; |
---|
461 | static const std::pair<G4int, const G4double*> Z28N30=std::make_pair(30,pZ28N30); |
---|
462 | static const G4double pZ28N32[5]={.046, 20., .016, .0001, .01}; |
---|
463 | static const std::pair<G4int, const G4double*> Z28N32=std::make_pair(32,pZ28N32); |
---|
464 | static const G4double pZ28N33[5]={.046, 20., .016, .0001, .01}; |
---|
465 | static const std::pair<G4int, const G4double*> Z28N33=std::make_pair(33,pZ28N33); |
---|
466 | static const G4double pZ28N34[5]={.045, 20., .005, .0001, .007}; |
---|
467 | static const std::pair<G4int, const G4double*> Z28N34=std::make_pair(34,pZ28N34); |
---|
468 | static const G4double pZ28N36[5]={.045, 20., .005, .0001, .007}; |
---|
469 | static const std::pair<G4int, const G4double*> Z28N36=std::make_pair(36,pZ28N36); |
---|
470 | static const std::pair<G4int, const G4double*> Z28[N28]={Z28N30, Z28N32, Z28N33, |
---|
471 | Z28N34, Z28N36}; |
---|
472 | //==> Cu(Z=29) |
---|
473 | static const G4int N29=2; |
---|
474 | static const G4double pZ29N34[5]={.035, 15., .008, .0001, .015}; |
---|
475 | static const std::pair<G4int, const G4double*> Z29N34=std::make_pair(34,pZ29N34); |
---|
476 | static const G4double pZ29N36[5]={.036, 15., .003, .0001, .013}; |
---|
477 | static const std::pair<G4int, const G4double*> Z29N36=std::make_pair(36,pZ29N36); |
---|
478 | static const std::pair<G4int, const G4double*> Z29[N29]={Z29N34, Z29N34}; |
---|
479 | //==> Zn(Z=30) |
---|
480 | static const G4int N30=5; |
---|
481 | static const G4double pZ30N34[5]={.041, 20., .008, .0001, .02}; // *** only NAT mix *** |
---|
482 | static const std::pair<G4int, const G4double*> Z30N34=std::make_pair(34,pZ30N34); |
---|
483 | static const G4double pZ30N36[5]={.041, 20., .008, .0001, .02}; // *** only NAT mix *** |
---|
484 | static const std::pair<G4int, const G4double*> Z30N36=std::make_pair(36,pZ30N36); |
---|
485 | static const G4double pZ30N37[5]={.041, 20., .008, .0001, .02}; // *** only NAT mix *** |
---|
486 | static const std::pair<G4int, const G4double*> Z30N37=std::make_pair(37,pZ30N37); |
---|
487 | static const G4double pZ30N38[5]={.041, 20., .008, .0001, .02}; // *** only NAT mix *** |
---|
488 | static const std::pair<G4int, const G4double*> Z30N38=std::make_pair(38,pZ30N38); |
---|
489 | static const G4double pZ30N40[5]={.041, 20., .008, .0001, .02}; // *** only NAT mix *** |
---|
490 | static const std::pair<G4int, const G4double*> Z30N40=std::make_pair(40,pZ30N40); |
---|
491 | static const std::pair<G4int, const G4double*> Z30[N30]={Z30N34, Z30N36, Z30N37, |
---|
492 | Z30N38, Z30N40}; |
---|
493 | //==> Ga(Z=31) |
---|
494 | static const G4int N31=2; |
---|
495 | static const G4double pZ31N38[5]={.024, 7., .03, .01, .003}; |
---|
496 | static const std::pair<G4int, const G4double*> Z31N38=std::make_pair(38,pZ31N38); |
---|
497 | static const G4double pZ31N40[5]={.026, 9., .015, .01, .003}; |
---|
498 | static const std::pair<G4int, const G4double*> Z31N40=std::make_pair(40,pZ31N40); |
---|
499 | static const std::pair<G4int, const G4double*> Z31[N31]={Z31N38, Z31N40}; |
---|
500 | //==> Ge(Z=32) |
---|
501 | static const G4int N32=5; |
---|
502 | static const G4double pZ32N38[5]={.037, 12., .15, .025, .003}; |
---|
503 | static const std::pair<G4int, const G4double*> Z32N38=std::make_pair(38,pZ32N38); |
---|
504 | static const G4double pZ32N40[5]={.035, 20., .015, .01, .0035}; |
---|
505 | static const std::pair<G4int, const G4double*> Z32N40=std::make_pair(40,pZ32N40); |
---|
506 | static const G4double pZ32N41[5]={.009, 3., .02, .03, .0001}; |
---|
507 | static const std::pair<G4int, const G4double*> Z32N41=std::make_pair(41,pZ32N41); |
---|
508 | static const G4double pZ32N42[5]={.027, 12., .003, .0001, .01}; |
---|
509 | static const std::pair<G4int, const G4double*> Z32N42=std::make_pair(42,pZ32N42); |
---|
510 | static const G4double pZ32N44[5]={.031, 20., .025, .0005, .0045}; |
---|
511 | static const std::pair<G4int, const G4double*> Z32N44=std::make_pair(44,pZ32N44); |
---|
512 | static const std::pair<G4int, const G4double*> Z32[N32]={Z32N38, Z32N40, Z32N41, |
---|
513 | Z32N42, Z32N44}; |
---|
514 | //==> As(Z=33) |
---|
515 | static const G4int N33=1; |
---|
516 | static const G4double pZ33N42[5]={.017, 5., .004, .05, .006}; |
---|
517 | static const std::pair<G4int, const G4double*> Z33N42=std::make_pair(42,pZ33N42); |
---|
518 | static const std::pair<G4int, const G4double*> Z33[N33]={Z33N42}; |
---|
519 | //==> Se(Z=34) |
---|
520 | static const G4int N34=6; |
---|
521 | static const G4double pZ34N40[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
522 | static const std::pair<G4int, const G4double*> Z34N40=std::make_pair(40,pZ34N40); |
---|
523 | static const G4double pZ34N42[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
524 | static const std::pair<G4int, const G4double*> Z34N42=std::make_pair(42,pZ34N42); |
---|
525 | static const G4double pZ34N43[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
526 | static const std::pair<G4int, const G4double*> Z34N43=std::make_pair(43,pZ34N43); |
---|
527 | static const G4double pZ34N44[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
528 | static const std::pair<G4int, const G4double*> Z34N44=std::make_pair(44,pZ34N44); |
---|
529 | static const G4double pZ34N46[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
530 | static const std::pair<G4int, const G4double*> Z34N46=std::make_pair(46,pZ34N46); |
---|
531 | static const G4double pZ34N48[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
532 | static const std::pair<G4int, const G4double*> Z34N48=std::make_pair(48,pZ34N48); |
---|
533 | static const std::pair<G4int, const G4double*> Z34[N34]={Z34N40, Z34N42, Z34N43, |
---|
534 | Z34N44, Z34N46, Z34N48}; |
---|
535 | //==> Br(Z=35) |
---|
536 | static const G4int N35=2; |
---|
537 | static const G4double pZ35N44[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
538 | static const std::pair<G4int, const G4double*> Z35N44=std::make_pair(44,pZ35N44); |
---|
539 | static const G4double pZ35N46[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
540 | static const std::pair<G4int, const G4double*> Z35N46=std::make_pair(46,pZ35N46); |
---|
541 | static const std::pair<G4int, const G4double*> Z35[N35]={Z35N44, Z35N46}; |
---|
542 | //==> Kr(Z=36) |
---|
543 | static const G4int N36=6; |
---|
544 | static const G4double pZ36N42[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
545 | static const std::pair<G4int, const G4double*> Z36N42=std::make_pair(42,pZ36N42); |
---|
546 | static const G4double pZ36N44[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
547 | static const std::pair<G4int, const G4double*> Z36N44=std::make_pair(44,pZ36N44); |
---|
548 | static const G4double pZ36N46[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
549 | static const std::pair<G4int, const G4double*> Z36N46=std::make_pair(46,pZ36N46); |
---|
550 | static const G4double pZ36N47[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
551 | static const std::pair<G4int, const G4double*> Z36N47=std::make_pair(47,pZ36N47); |
---|
552 | static const G4double pZ36N48[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
553 | static const std::pair<G4int, const G4double*> Z36N48=std::make_pair(48,pZ36N48); |
---|
554 | static const G4double pZ36N50[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
555 | static const std::pair<G4int, const G4double*> Z36N50=std::make_pair(50,pZ36N50); |
---|
556 | static const std::pair<G4int, const G4double*> Z36[N36]={Z36N42, Z36N44, Z36N46, |
---|
557 | Z36N47, Z36N48, Z36N50}; |
---|
558 | //==> Rb(Z=37) |
---|
559 | static const G4int N37=2; |
---|
560 | static const G4double pZ37N48[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
561 | static const std::pair<G4int, const G4double*> Z37N48=std::make_pair(48,pZ37N48); |
---|
562 | static const G4double pZ37N50[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
563 | static const std::pair<G4int, const G4double*> Z37N50=std::make_pair(50,pZ37N50); |
---|
564 | static const std::pair<G4int, const G4double*> Z37[N37]={Z37N48, Z37N50}; |
---|
565 | //==> Sr(Z=38) |
---|
566 | static const G4int N38=4; |
---|
567 | static const G4double pZ38N46[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
568 | static const std::pair<G4int, const G4double*> Z38N46=std::make_pair(46,pZ38N46); |
---|
569 | static const G4double pZ38N48[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
570 | static const std::pair<G4int, const G4double*> Z38N48=std::make_pair(48,pZ38N48); |
---|
571 | static const G4double pZ38N49[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
572 | static const std::pair<G4int, const G4double*> Z38N49=std::make_pair(49,pZ38N49); |
---|
573 | static const G4double pZ38N50[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
574 | static const std::pair<G4int, const G4double*> Z38N50=std::make_pair(50,pZ38N50); |
---|
575 | static const std::pair<G4int, const G4double*> Z38[N38]={Z38N46, Z38N48, Z38N49, Z38N50}; |
---|
576 | //==> Y (Z=39) |
---|
577 | static const G4int N39=1; |
---|
578 | static const G4double pZ39N50[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
579 | static const std::pair<G4int, const G4double*> Z39N50=std::make_pair(50,pZ39N50); |
---|
580 | static const std::pair<G4int, const G4double*> Z39[N39]={Z39N50}; |
---|
581 | //==> Zr(Z=40) |
---|
582 | static const G4int N40=5; |
---|
583 | static const G4double pZ40N50[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
584 | static const std::pair<G4int, const G4double*> Z40N50=std::make_pair(50,pZ40N50); |
---|
585 | static const G4double pZ40N51[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
586 | static const std::pair<G4int, const G4double*> Z40N51=std::make_pair(51,pZ40N51); |
---|
587 | static const G4double pZ40N52[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
588 | static const std::pair<G4int, const G4double*> Z40N52=std::make_pair(52,pZ40N52); |
---|
589 | static const G4double pZ40N54[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
590 | static const std::pair<G4int, const G4double*> Z40N54=std::make_pair(54,pZ40N54); |
---|
591 | static const G4double pZ40N56[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
592 | static const std::pair<G4int, const G4double*> Z40N56=std::make_pair(56,pZ40N56); |
---|
593 | static const std::pair<G4int, const G4double*> Z40[N40]={Z40N50, Z40N51, Z40N52, |
---|
594 | Z40N54, Z40N56}; |
---|
595 | //==> Nb(Z=41) |
---|
596 | static const G4int N41=1; |
---|
597 | static const G4double pZ41N52[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
598 | static const std::pair<G4int, const G4double*> Z41N52=std::make_pair(52,pZ41N52); |
---|
599 | static const std::pair<G4int, const G4double*> Z41[N41]={Z41N52}; |
---|
600 | //==> Mo(Z=42) |
---|
601 | static const G4int N42=7; |
---|
602 | static const G4double pZ42N50[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
603 | static const std::pair<G4int, const G4double*> Z42N50=std::make_pair(50,pZ42N50); |
---|
604 | static const G4double pZ42N52[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
605 | static const std::pair<G4int, const G4double*> Z42N52=std::make_pair(52,pZ42N52); |
---|
606 | static const G4double pZ42N53[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
607 | static const std::pair<G4int, const G4double*> Z42N53=std::make_pair(53,pZ42N53); |
---|
608 | static const G4double pZ42N54[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
609 | static const std::pair<G4int, const G4double*> Z42N54=std::make_pair(54,pZ42N54); |
---|
610 | static const G4double pZ42N55[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
611 | static const std::pair<G4int, const G4double*> Z42N55=std::make_pair(55,pZ42N55); |
---|
612 | static const G4double pZ42N56[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
613 | static const std::pair<G4int, const G4double*> Z42N56=std::make_pair(56,pZ42N56); |
---|
614 | static const G4double pZ42N58[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
615 | static const std::pair<G4int, const G4double*> Z42N58=std::make_pair(58,pZ42N58); |
---|
616 | static const std::pair<G4int, const G4double*> Z42[N42]={Z42N50, Z42N52, Z42N53, Z42N54, |
---|
617 | Z42N55, Z42N56, Z42N58}; |
---|
618 | //==> Mo(Z=43) |
---|
619 | static const G4int N43=1; |
---|
620 | static const G4double pZ43N0[5]={.018, 5., .1, .03, .002}; // *** NoStableIsotopes *** |
---|
621 | static const std::pair<G4int, const G4double*> Z43N0=std::make_pair(0,pZ43N0); |
---|
622 | static const std::pair<G4int, const G4double*> Z43[N43]={Z43N0}; |
---|
623 | //==> Ru(Z=44) |
---|
624 | static const G4int N44=7; |
---|
625 | static const G4double pZ44N52[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
626 | static const std::pair<G4int, const G4double*> Z44N52=std::make_pair(52,pZ44N52); |
---|
627 | static const G4double pZ44N54[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
628 | static const std::pair<G4int, const G4double*> Z44N54=std::make_pair(54,pZ44N54); |
---|
629 | static const G4double pZ44N55[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
630 | static const std::pair<G4int, const G4double*> Z44N55=std::make_pair(55,pZ44N55); |
---|
631 | static const G4double pZ44N56[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
632 | static const std::pair<G4int, const G4double*> Z44N56=std::make_pair(56,pZ44N56); |
---|
633 | static const G4double pZ44N57[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
634 | static const std::pair<G4int, const G4double*> Z44N57=std::make_pair(57,pZ44N57); |
---|
635 | static const G4double pZ44N58[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
636 | static const std::pair<G4int, const G4double*> Z44N58=std::make_pair(58,pZ44N58); |
---|
637 | static const G4double pZ44N60[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
638 | static const std::pair<G4int, const G4double*> Z44N60=std::make_pair(60,pZ44N60); |
---|
639 | static const std::pair<G4int, const G4double*> Z44[N44]={Z44N52, Z44N54, Z44N55, Z44N56, |
---|
640 | Z44N57, Z44N58, Z44N60}; |
---|
641 | //==> Rh(Z=45) |
---|
642 | static const G4int N45=1; |
---|
643 | static const G4double pZ45N58[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
644 | static const std::pair<G4int, const G4double*> Z45N58=std::make_pair(58,pZ45N58); |
---|
645 | static const std::pair<G4int, const G4double*> Z45[N45]={Z45N58}; |
---|
646 | //==> Pd(Z=46) |
---|
647 | static const G4int N46=6; |
---|
648 | static const G4double pZ46N56[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
649 | static const std::pair<G4int, const G4double*> Z46N56=std::make_pair(56,pZ46N56); |
---|
650 | static const G4double pZ46N58[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
651 | static const std::pair<G4int, const G4double*> Z46N58=std::make_pair(58,pZ46N58); |
---|
652 | static const G4double pZ46N59[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
653 | static const std::pair<G4int, const G4double*> Z46N59=std::make_pair(59,pZ46N59); |
---|
654 | static const G4double pZ46N60[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
655 | static const std::pair<G4int, const G4double*> Z46N60=std::make_pair(60,pZ46N60); |
---|
656 | static const G4double pZ46N62[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
657 | static const std::pair<G4int, const G4double*> Z46N62=std::make_pair(62,pZ46N62); |
---|
658 | static const G4double pZ46N64[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
659 | static const std::pair<G4int, const G4double*> Z46N64=std::make_pair(64,pZ46N64); |
---|
660 | static const std::pair<G4int, const G4double*> Z46[N46]={Z46N56, Z46N58, Z46N59, |
---|
661 | Z46N60, Z46N62, Z46N64}; |
---|
662 | //==> Ag(Z=47) |
---|
663 | static const G4int N47=2; |
---|
664 | static const G4double pZ47N60[5]={.018, 5., .1, .004, .003}; |
---|
665 | static const std::pair<G4int, const G4double*> Z47N60=std::make_pair(48,pZ47N60); |
---|
666 | static const G4double pZ47N62[5]={.018, 4., .015, .06, .0008}; |
---|
667 | static const std::pair<G4int, const G4double*> Z47N62=std::make_pair(50,pZ47N62); |
---|
668 | static const std::pair<G4int, const G4double*> Z47[N47]={Z47N60, Z47N62}; |
---|
669 | //==> Cd(Z=48) |
---|
670 | static const G4int N48=8; |
---|
671 | static const G4double pZ48N58[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
672 | static const std::pair<G4int, const G4double*> Z48N58=std::make_pair(58,pZ48N58); |
---|
673 | static const G4double pZ48N60[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
674 | static const std::pair<G4int, const G4double*> Z48N60=std::make_pair(60,pZ48N60); |
---|
675 | static const G4double pZ48N62[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
676 | static const std::pair<G4int, const G4double*> Z48N62=std::make_pair(62,pZ48N62); |
---|
677 | static const G4double pZ48N63[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
678 | static const std::pair<G4int, const G4double*> Z48N63=std::make_pair(63,pZ48N63); |
---|
679 | static const G4double pZ48N64[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
680 | static const std::pair<G4int, const G4double*> Z48N64=std::make_pair(64,pZ48N64); |
---|
681 | static const G4double pZ48N65[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
682 | static const std::pair<G4int, const G4double*> Z48N65=std::make_pair(65,pZ48N65); |
---|
683 | static const G4double pZ48N66[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
684 | static const std::pair<G4int, const G4double*> Z48N66=std::make_pair(66,pZ48N66); |
---|
685 | static const G4double pZ48N68[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
686 | static const std::pair<G4int, const G4double*> Z48N68=std::make_pair(68,pZ48N68); |
---|
687 | static const std::pair<G4int, const G4double*> Z48[N48]={Z48N58, Z48N60, Z48N62, Z48N63, |
---|
688 | Z48N64, Z48N65, Z48N66, Z48N68}; |
---|
689 | //==> In(Z=49) |
---|
690 | static const G4int N49=2; |
---|
691 | static const G4double pZ49N64[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
692 | static const std::pair<G4int, const G4double*> Z49N64=std::make_pair(64,pZ49N64); |
---|
693 | static const G4double pZ49N66[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
694 | static const std::pair<G4int, const G4double*> Z49N66=std::make_pair(66,pZ49N66); |
---|
695 | static const std::pair<G4int, const G4double*> Z49[N49]={Z49N64, Z49N66}; |
---|
696 | //==> Sn(Z=50) |
---|
697 | static const G4int N50=10; |
---|
698 | static const G4double pZ50N62[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
699 | static const std::pair<G4int, const G4double*> Z50N62=std::make_pair(62,pZ50N62); |
---|
700 | static const G4double pZ50N64[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
701 | static const std::pair<G4int, const G4double*> Z50N64=std::make_pair(64,pZ50N64); |
---|
702 | static const G4double pZ50N65[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
703 | static const std::pair<G4int, const G4double*> Z50N65=std::make_pair(65,pZ50N65); |
---|
704 | static const G4double pZ50N66[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
705 | static const std::pair<G4int, const G4double*> Z50N66=std::make_pair(66,pZ50N66); |
---|
706 | static const G4double pZ50N67[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
707 | static const std::pair<G4int, const G4double*> Z50N67=std::make_pair(67,pZ50N67); |
---|
708 | static const G4double pZ50N68[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
709 | static const std::pair<G4int, const G4double*> Z50N68=std::make_pair(68,pZ50N68); |
---|
710 | static const G4double pZ50N69[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
711 | static const std::pair<G4int, const G4double*> Z50N69=std::make_pair(69,pZ50N69); |
---|
712 | static const G4double pZ50N70[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
713 | static const std::pair<G4int, const G4double*> Z50N70=std::make_pair(70,pZ50N70); |
---|
714 | static const G4double pZ50N72[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
715 | static const std::pair<G4int, const G4double*> Z50N72=std::make_pair(72,pZ50N72); |
---|
716 | static const G4double pZ50N74[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
717 | static const std::pair<G4int, const G4double*> Z50N74=std::make_pair(74,pZ50N74); |
---|
718 | static const std::pair<G4int, const G4double*> Z50[N50]={Z50N62, Z50N64, Z50N65, Z50N66, |
---|
719 | Z50N67, Z50N68, Z50N69, Z50N70, |
---|
720 | Z50N72, Z50N74}; |
---|
721 | //==> Sb(Z=51) |
---|
722 | static const G4int N51=2; |
---|
723 | static const G4double pZ51N70[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
724 | static const std::pair<G4int, const G4double*> Z51N70=std::make_pair(70,pZ51N70); |
---|
725 | static const G4double pZ51N72[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
726 | static const std::pair<G4int, const G4double*> Z51N72=std::make_pair(72,pZ51N72); |
---|
727 | static const std::pair<G4int, const G4double*> Z51[N51]={Z51N70, Z51N72}; |
---|
728 | //==> Te(Z=52) |
---|
729 | static const G4int N52=8; |
---|
730 | static const G4double pZ52N68[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
731 | static const std::pair<G4int, const G4double*> Z52N68=std::make_pair(68,pZ52N68); |
---|
732 | static const G4double pZ52N70[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
733 | static const std::pair<G4int, const G4double*> Z52N70=std::make_pair(70,pZ52N70); |
---|
734 | static const G4double pZ52N71[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
735 | static const std::pair<G4int, const G4double*> Z52N71=std::make_pair(71,pZ52N71); |
---|
736 | static const G4double pZ52N72[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
737 | static const std::pair<G4int, const G4double*> Z52N72=std::make_pair(72,pZ52N72); |
---|
738 | static const G4double pZ52N73[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
739 | static const std::pair<G4int, const G4double*> Z52N73=std::make_pair(73,pZ52N73); |
---|
740 | static const G4double pZ52N74[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
741 | static const std::pair<G4int, const G4double*> Z52N74=std::make_pair(74,pZ52N74); |
---|
742 | static const G4double pZ52N76[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
743 | static const std::pair<G4int, const G4double*> Z52N76=std::make_pair(76,pZ52N76); |
---|
744 | static const G4double pZ52N78[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
745 | static const std::pair<G4int, const G4double*> Z52N78=std::make_pair(78,pZ52N78); |
---|
746 | static const std::pair<G4int, const G4double*> Z52[N52]={Z52N68, Z52N70, Z52N71, Z52N72, |
---|
747 | Z52N73, Z52N74, Z52N76, Z52N78}; |
---|
748 | //==> I (Z=53) |
---|
749 | static const G4int N53=1; |
---|
750 | static const G4double pZ53N74[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
751 | static const std::pair<G4int, const G4double*> Z53N74=std::make_pair(74,pZ53N74); |
---|
752 | static const std::pair<G4int, const G4double*> Z53[N53]={Z53N74}; |
---|
753 | //==> Xe(Z=54) |
---|
754 | static const G4int N54=9; |
---|
755 | static const G4double pZ54N70[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
756 | static const std::pair<G4int, const G4double*> Z54N70=std::make_pair(70,pZ54N70); |
---|
757 | static const G4double pZ54N72[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
758 | static const std::pair<G4int, const G4double*> Z54N72=std::make_pair(72,pZ54N72); |
---|
759 | static const G4double pZ54N74[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
760 | static const std::pair<G4int, const G4double*> Z54N74=std::make_pair(74,pZ54N74); |
---|
761 | static const G4double pZ54N75[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
762 | static const std::pair<G4int, const G4double*> Z54N75=std::make_pair(75,pZ54N75); |
---|
763 | static const G4double pZ54N76[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
764 | static const std::pair<G4int, const G4double*> Z54N76=std::make_pair(76,pZ54N76); |
---|
765 | static const G4double pZ54N77[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
766 | static const std::pair<G4int, const G4double*> Z54N77=std::make_pair(77,pZ54N77); |
---|
767 | static const G4double pZ54N78[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
768 | static const std::pair<G4int, const G4double*> Z54N78=std::make_pair(78,pZ54N78); |
---|
769 | static const G4double pZ54N80[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
770 | static const std::pair<G4int, const G4double*> Z54N80=std::make_pair(80,pZ54N80); |
---|
771 | static const G4double pZ54N82[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
772 | static const std::pair<G4int, const G4double*> Z54N82=std::make_pair(82,pZ54N82); |
---|
773 | static const std::pair<G4int, const G4double*> Z54[N54]={Z54N70, Z54N72, Z54N74, |
---|
774 | Z54N75, Z54N76, Z54N77, |
---|
775 | Z54N78, Z54N80, Z54N82}; |
---|
776 | //==> Cs(Z=55) |
---|
777 | static const G4int N55=1; |
---|
778 | static const G4double pZ55N78[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
779 | static const std::pair<G4int, const G4double*> Z55N78=std::make_pair(78,pZ55N78); |
---|
780 | static const std::pair<G4int, const G4double*> Z55[N55]={Z55N78}; |
---|
781 | //==> Ba(Z=56) |
---|
782 | static const G4int N56=7; |
---|
783 | static const G4double pZ56N74[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
784 | static const std::pair<G4int, const G4double*> Z56N74=std::make_pair(70,pZ56N74); |
---|
785 | static const G4double pZ56N76[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
786 | static const std::pair<G4int, const G4double*> Z56N76=std::make_pair(71,pZ56N76); |
---|
787 | static const G4double pZ56N78[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
788 | static const std::pair<G4int, const G4double*> Z56N78=std::make_pair(72,pZ56N78); |
---|
789 | static const G4double pZ56N79[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
790 | static const std::pair<G4int, const G4double*> Z56N79=std::make_pair(73,pZ56N79); |
---|
791 | static const G4double pZ56N80[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
792 | static const std::pair<G4int, const G4double*> Z56N80=std::make_pair(74,pZ56N80); |
---|
793 | static const G4double pZ56N81[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
794 | static const std::pair<G4int, const G4double*> Z56N81=std::make_pair(76,pZ56N81); |
---|
795 | static const G4double pZ56N82[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
796 | static const std::pair<G4int, const G4double*> Z56N82=std::make_pair(78,pZ56N82); |
---|
797 | static const std::pair<G4int, const G4double*> Z56[N56]={Z56N74, Z56N76, Z56N78, Z56N79, |
---|
798 | Z56N80, Z56N81, Z56N82}; |
---|
799 | //==> La(Z=57) |
---|
800 | static const G4int N57=2; |
---|
801 | static const G4double pZ57N81[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
802 | static const std::pair<G4int, const G4double*> Z57N81=std::make_pair(81,pZ57N81); |
---|
803 | static const G4double pZ57N82[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
804 | static const std::pair<G4int, const G4double*> Z57N82=std::make_pair(82,pZ57N82); |
---|
805 | static const std::pair<G4int, const G4double*> Z57[N57]={Z57N81, Z57N82}; |
---|
806 | //==> Ce(Z=58) |
---|
807 | static const G4int N58=4; |
---|
808 | static const G4double pZ58N78[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
809 | static const std::pair<G4int, const G4double*> Z58N78=std::make_pair(78,pZ58N78); |
---|
810 | static const G4double pZ58N80[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
811 | static const std::pair<G4int, const G4double*> Z58N80=std::make_pair(80,pZ58N80); |
---|
812 | static const G4double pZ58N82[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
813 | static const std::pair<G4int, const G4double*> Z58N82=std::make_pair(82,pZ58N82); |
---|
814 | static const G4double pZ58N84[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
815 | static const std::pair<G4int, const G4double*> Z58N84=std::make_pair(84,pZ58N84); |
---|
816 | static const std::pair<G4int, const G4double*> Z58[N58]={Z58N78, Z58N80, Z58N82, Z58N84}; |
---|
817 | //==> Pr(Z=59) |
---|
818 | static const G4int N59=1; |
---|
819 | static const G4double pZ59N82[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
820 | static const std::pair<G4int, const G4double*> Z59N82=std::make_pair(82,pZ59N82); |
---|
821 | static const std::pair<G4int, const G4double*> Z59[N59]={Z59N82}; |
---|
822 | //==> Nd(Z=60) |
---|
823 | static const G4int N60=7; |
---|
824 | static const G4double pZ60N82[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
825 | static const std::pair<G4int, const G4double*> Z60N82=std::make_pair(82,pZ60N82); |
---|
826 | static const G4double pZ60N83[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
827 | static const std::pair<G4int, const G4double*> Z60N83=std::make_pair(83,pZ60N83); |
---|
828 | static const G4double pZ60N84[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
829 | static const std::pair<G4int, const G4double*> Z60N84=std::make_pair(84,pZ60N84); |
---|
830 | static const G4double pZ60N85[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
831 | static const std::pair<G4int, const G4double*> Z60N85=std::make_pair(85,pZ60N85); |
---|
832 | static const G4double pZ60N86[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
833 | static const std::pair<G4int, const G4double*> Z60N86=std::make_pair(86,pZ60N86); |
---|
834 | static const G4double pZ60N88[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
835 | static const std::pair<G4int, const G4double*> Z60N88=std::make_pair(88,pZ60N88); |
---|
836 | static const G4double pZ60N90[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
837 | static const std::pair<G4int, const G4double*> Z60N90=std::make_pair(90,pZ60N90); |
---|
838 | static const std::pair<G4int, const G4double*> Z60[N60]={Z60N82, Z60N83, Z60N84, Z60N85, |
---|
839 | Z60N86, Z60N88, Z60N90}; |
---|
840 | //==> Mo(Z=61) |
---|
841 | static const G4int N61=1; |
---|
842 | static const G4double pZ61N0[5]={.018, 5., .1, .03, .002}; // *** NoStableIsotopes *** |
---|
843 | static const std::pair<G4int, const G4double*> Z61N0=std::make_pair(0,pZ61N0); |
---|
844 | static const std::pair<G4int, const G4double*> Z61[N61]={Z61N0}; |
---|
845 | //==> Sm(Z=62) |
---|
846 | static const G4int N62=7; |
---|
847 | static const G4double pZ62N82[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
848 | static const std::pair<G4int, const G4double*> Z62N82=std::make_pair(82,pZ62N82); |
---|
849 | static const G4double pZ62N85[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
850 | static const std::pair<G4int, const G4double*> Z62N85=std::make_pair(85,pZ62N85); |
---|
851 | static const G4double pZ62N86[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
852 | static const std::pair<G4int, const G4double*> Z62N86=std::make_pair(86,pZ62N86); |
---|
853 | static const G4double pZ62N87[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
854 | static const std::pair<G4int, const G4double*> Z62N87=std::make_pair(87,pZ62N87); |
---|
855 | static const G4double pZ62N88[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
856 | static const std::pair<G4int, const G4double*> Z62N88=std::make_pair(88,pZ62N88); |
---|
857 | static const G4double pZ62N90[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
858 | static const std::pair<G4int, const G4double*> Z62N90=std::make_pair(90,pZ62N90); |
---|
859 | static const G4double pZ62N92[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
860 | static const std::pair<G4int, const G4double*> Z62N92=std::make_pair(92,pZ62N92); |
---|
861 | static const std::pair<G4int, const G4double*> Z62[N62]={Z62N82, Z62N85, Z62N86, Z62N87, |
---|
862 | Z62N88, Z62N90, Z62N92}; |
---|
863 | //==> Eu(Z=63) |
---|
864 | static const G4int N63=2; |
---|
865 | static const G4double pZ63N88[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
866 | static const std::pair<G4int, const G4double*> Z63N88=std::make_pair(88,pZ63N88); |
---|
867 | static const G4double pZ63N90[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
868 | static const std::pair<G4int, const G4double*> Z63N90=std::make_pair(90,pZ63N90); |
---|
869 | static const std::pair<G4int, const G4double*> Z63[N63]={Z63N88, Z63N90}; |
---|
870 | //==> Gd(Z=64) |
---|
871 | static const G4int N64=7; |
---|
872 | static const G4double pZ64N88[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
873 | static const std::pair<G4int, const G4double*> Z64N88=std::make_pair(88,pZ64N88); |
---|
874 | static const G4double pZ64N90[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
875 | static const std::pair<G4int, const G4double*> Z64N90=std::make_pair(90,pZ64N90); |
---|
876 | static const G4double pZ64N91[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
877 | static const std::pair<G4int, const G4double*> Z64N91=std::make_pair(91,pZ64N91); |
---|
878 | static const G4double pZ64N92[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
879 | static const std::pair<G4int, const G4double*> Z64N92=std::make_pair(92,pZ64N92); |
---|
880 | static const G4double pZ64N93[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
881 | static const std::pair<G4int, const G4double*> Z64N93=std::make_pair(93,pZ64N93); |
---|
882 | static const G4double pZ64N94[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
883 | static const std::pair<G4int, const G4double*> Z64N94=std::make_pair(94,pZ64N94); |
---|
884 | static const G4double pZ64N96[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
885 | static const std::pair<G4int, const G4double*> Z64N96=std::make_pair(96,pZ64N96); |
---|
886 | static const std::pair<G4int, const G4double*> Z64[N64]={Z64N88, Z64N90, Z64N91, Z64N92, |
---|
887 | Z64N93, Z64N94, Z64N96}; |
---|
888 | //==> Tb(Z=65) |
---|
889 | static const G4int N65=1; |
---|
890 | static const G4double pZ65N94[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
891 | static const std::pair<G4int, const G4double*> Z65N94=std::make_pair(82,pZ65N94); |
---|
892 | static const std::pair<G4int, const G4double*> Z65[N65]={Z65N94}; |
---|
893 | //==> Dy(Z=66) |
---|
894 | static const G4int N66=7; |
---|
895 | static const G4double pZ66N90[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
896 | static const std::pair<G4int, const G4double*> Z66N90=std::make_pair(90,pZ66N90); |
---|
897 | static const G4double pZ66N92[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
898 | static const std::pair<G4int, const G4double*> Z66N92=std::make_pair(92,pZ66N92); |
---|
899 | static const G4double pZ66N94[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
900 | static const std::pair<G4int, const G4double*> Z66N94=std::make_pair(94,pZ66N94); |
---|
901 | static const G4double pZ66N95[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
902 | static const std::pair<G4int, const G4double*> Z66N95=std::make_pair(95,pZ66N95); |
---|
903 | static const G4double pZ66N96[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
904 | static const std::pair<G4int, const G4double*> Z66N96=std::make_pair(96,pZ66N96); |
---|
905 | static const G4double pZ66N97[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
906 | static const std::pair<G4int, const G4double*> Z66N97=std::make_pair(97,pZ66N97); |
---|
907 | static const G4double pZ66N98[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
908 | static const std::pair<G4int, const G4double*> Z66N98=std::make_pair(98,pZ66N98); |
---|
909 | static const std::pair<G4int, const G4double*> Z66[N66]={Z66N90, Z66N92, Z66N94, Z66N95, |
---|
910 | Z66N96, Z66N97, Z66N98}; |
---|
911 | //==> Ho(Z=67) |
---|
912 | static const G4int N67=1; |
---|
913 | static const G4double pZ67N98[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
914 | static const std::pair<G4int, const G4double*> Z67N98=std::make_pair(98,pZ67N98); |
---|
915 | static const std::pair<G4int, const G4double*> Z67[N67]={Z67N98}; |
---|
916 | //==> Er(Z=68) |
---|
917 | static const G4int N68=6; |
---|
918 | static const G4double pZ68N94[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
919 | static const std::pair<G4int, const G4double*> Z68N94=std::make_pair(94,pZ68N94); |
---|
920 | static const G4double pZ68N96[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
921 | static const std::pair<G4int, const G4double*> Z68N96=std::make_pair(96,pZ68N96); |
---|
922 | static const G4double pZ68N98[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
923 | static const std::pair<G4int, const G4double*> Z68N98=std::make_pair(98,pZ68N98); |
---|
924 | static const G4double pZ68N99[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
925 | static const std::pair<G4int, const G4double*> Z68N99=std::make_pair(99,pZ68N99); |
---|
926 | static const G4double pZ68N100[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
927 | static const std::pair<G4int, const G4double*> Z68N100=std::make_pair(100,pZ68N100); |
---|
928 | static const G4double pZ68N102[5]={.01, 27., 0., 0., 1.}; // *** NotImplemented *** |
---|
929 | static const std::pair<G4int, const G4double*> Z68N102=std::make_pair(102,pZ68N102); |
---|
930 | static const std::pair<G4int, const G4double*> Z68[N68]={Z68N94, Z68N96, Z68N98, |
---|
931 | Z68N99, Z68N100, Z68N102}; |
---|
932 | //==> Tm(Z=69) |
---|
933 | static const G4int N69=1; |
---|
934 | static const G4double pZ69N100[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
935 | static const std::pair<G4int, const G4double*> Z69N100=std::make_pair(100,pZ69N100); |
---|
936 | static const std::pair<G4int, const G4double*> Z69[N69]={Z69N100}; |
---|
937 | //==> Yb(Z=70) |
---|
938 | static const G4int N70=7; |
---|
939 | static const G4double pZ70N98[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
940 | static const std::pair<G4int, const G4double*> Z70N98=std::make_pair(98,pZ70N98); |
---|
941 | static const G4double pZ70N100[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
942 | static const std::pair<G4int, const G4double*> Z70N100=std::make_pair(100,pZ70N100); |
---|
943 | static const G4double pZ70N101[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
944 | static const std::pair<G4int, const G4double*> Z70N101=std::make_pair(101,pZ70N101); |
---|
945 | static const G4double pZ70N102[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
946 | static const std::pair<G4int, const G4double*> Z70N102=std::make_pair(102,pZ70N102); |
---|
947 | static const G4double pZ70N103[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
948 | static const std::pair<G4int, const G4double*> Z70N103=std::make_pair(103,pZ70N103); |
---|
949 | static const G4double pZ70N104[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
950 | static const std::pair<G4int, const G4double*> Z70N104=std::make_pair(104,pZ70N104); |
---|
951 | static const G4double pZ70N106[5]={.01, 27., 0., 0., 1.}; // *** No DATA *** |
---|
952 | static const std::pair<G4int, const G4double*> Z70N106=std::make_pair(106,pZ70N106); |
---|
953 | static const std::pair<G4int, const G4double*> Z70[N70]={Z70N98, Z70N100, Z70N101, |
---|
954 | Z70N102, Z70N103, Z70N104, |
---|
955 | Z70N106}; |
---|
956 | //==> Lu(Z=71) |
---|
957 | static const G4int N71=2; |
---|
958 | static const G4double pZ71N104[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
959 | static const std::pair<G4int, const G4double*> Z71N104=std::make_pair(104,pZ71N104); |
---|
960 | static const G4double pZ71N105[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
961 | static const std::pair<G4int, const G4double*> Z71N105=std::make_pair(105,pZ71N105); |
---|
962 | static const std::pair<G4int, const G4double*> Z71[N71]={Z71N104, Z71N105}; |
---|
963 | //==> Hf(Z=72) |
---|
964 | static const G4int N72=6; |
---|
965 | static const G4double pZ72N102[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
966 | static const std::pair<G4int, const G4double*> Z72N102=std::make_pair(102,pZ72N102); |
---|
967 | static const G4double pZ72N104[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
968 | static const std::pair<G4int, const G4double*> Z72N104=std::make_pair(104,pZ72N104); |
---|
969 | static const G4double pZ72N105[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
970 | static const std::pair<G4int, const G4double*> Z72N105=std::make_pair(105,pZ72N105); |
---|
971 | static const G4double pZ72N106[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
972 | static const std::pair<G4int, const G4double*> Z72N106=std::make_pair(106,pZ72N106); |
---|
973 | static const G4double pZ72N107[5]={.018, 5., .1, .03, .002}; // *** NotImplemented *** |
---|
974 | static const std::pair<G4int, const G4double*> Z72N107=std::make_pair(107,pZ72N107); |
---|
975 | static const G4double pZ72N108[5]={.01, 27., 0., 0., 1.}; // *** NotImplemented *** |
---|
976 | static const std::pair<G4int, const G4double*> Z72N108=std::make_pair(108,pZ72N108); |
---|
977 | static const std::pair<G4int, const G4double*> Z72[N72]={Z72N102, Z72N104, Z72N105, |
---|
978 | Z72N106, Z72N107, Z72N108}; |
---|
979 | //==> Ta(Z=73) |
---|
980 | static const G4int N73=1; |
---|
981 | static const G4double pZ73N108[5]={.0065, 2., .15, .001, .0012}; |
---|
982 | static const std::pair<G4int, const G4double*> Z73N108=std::make_pair(108,pZ73N108); |
---|
983 | static const std::pair<G4int, const G4double*> Z73[N73]={Z73N108}; |
---|
984 | //==> W (Z=74) |
---|
985 | static const G4int N74=5; |
---|
986 | static const G4double pZ74N106[5]={.014, 5., .03, .04, .001}; // *** No DATA *** |
---|
987 | static const std::pair<G4int, const G4double*> Z74N106=std::make_pair(106,pZ74N106); |
---|
988 | static const G4double pZ74N108[5]={.013, 4.5, .35, .045, .001}; |
---|
989 | static const std::pair<G4int, const G4double*> Z74N108=std::make_pair(108,pZ74N108); |
---|
990 | static const G4double pZ74N109[5]={.012, 4., .02, .04, .001}; |
---|
991 | static const std::pair<G4int, const G4double*> Z74N109=std::make_pair(109,pZ74N109); |
---|
992 | static const G4double pZ74N110[5]={.014, 6., .02, .03, .0015}; |
---|
993 | static const std::pair<G4int, const G4double*> Z74N110=std::make_pair(110,pZ74N110); |
---|
994 | static const G4double pZ74N112[5]={.014, 6., .02, .03, .0015}; |
---|
995 | static const std::pair<G4int, const G4double*> Z74N112=std::make_pair(112,pZ74N112); |
---|
996 | static const std::pair<G4int, const G4double*> Z74[N74]={Z74N106, Z74N108, Z74N109, |
---|
997 | Z74N110, Z74N112}; |
---|
998 | //==> Re(Z=75) |
---|
999 | static const G4int N75=2; |
---|
1000 | static const G4double pZ75N110[5]={.015, 4., .2, .0001, .0021}; |
---|
1001 | static const std::pair<G4int, const G4double*> Z75N110=std::make_pair(110,pZ75N110); |
---|
1002 | static const G4double pZ75N112[5]={.015, 4., .1, .0001, .002}; |
---|
1003 | static const std::pair<G4int, const G4double*> Z75N112=std::make_pair(112,pZ75N112); |
---|
1004 | static const std::pair<G4int, const G4double*> Z75[N75]={Z75N110, Z75N112}; |
---|
1005 | //==> Os(Z=76) |
---|
1006 | static const G4int N76=7; |
---|
1007 | static const G4double pZ76N108[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1008 | static const std::pair<G4int, const G4double*> Z76N108=std::make_pair(108,pZ76N108); |
---|
1009 | static const G4double pZ76N110[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1010 | static const std::pair<G4int, const G4double*> Z76N110=std::make_pair(110,pZ76N110); |
---|
1011 | static const G4double pZ76N111[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1012 | static const std::pair<G4int, const G4double*> Z76N111=std::make_pair(111,pZ76N111); |
---|
1013 | static const G4double pZ76N112[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1014 | static const std::pair<G4int, const G4double*> Z76N112=std::make_pair(112,pZ76N112); |
---|
1015 | static const G4double pZ76N113[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1016 | static const std::pair<G4int, const G4double*> Z76N113=std::make_pair(113,pZ76N113); |
---|
1017 | static const G4double pZ76N114[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1018 | static const std::pair<G4int, const G4double*> Z76N114=std::make_pair(114,pZ76N114); |
---|
1019 | static const G4double pZ76N116[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1020 | static const std::pair<G4int, const G4double*> Z76N116=std::make_pair(116,pZ76N116); |
---|
1021 | static const std::pair<G4int, const G4double*> Z76[N76]={Z76N108, Z76N110, Z76N111, |
---|
1022 | Z76N112, Z76N113, Z76N114, |
---|
1023 | Z76N116}; |
---|
1024 | //==> Ir(Z=77) |
---|
1025 | static const G4int N77=2; |
---|
1026 | static const G4double pZ77N114[5]={.012, 3., .1, .0001, .003}; |
---|
1027 | static const std::pair<G4int, const G4double*> Z77N114=std::make_pair(114,pZ77N114); |
---|
1028 | static const G4double pZ77N116[5]={.012, 3., .08, .0001, .002}; |
---|
1029 | static const std::pair<G4int, const G4double*> Z77N116=std::make_pair(116,pZ77N116); |
---|
1030 | static const std::pair<G4int, const G4double*> Z77[N77]={Z77N114, Z77N116}; |
---|
1031 | //==> Pt(Z=78) |
---|
1032 | static const G4int N78=6; |
---|
1033 | static const G4double pZ78N112[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1034 | static const std::pair<G4int, const G4double*> Z78N112=std::make_pair(112,pZ78N112); |
---|
1035 | static const G4double pZ78N114[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1036 | static const std::pair<G4int, const G4double*> Z78N114=std::make_pair(114,pZ78N114); |
---|
1037 | static const G4double pZ78N116[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1038 | static const std::pair<G4int, const G4double*> Z78N116=std::make_pair(116,pZ78N116); |
---|
1039 | static const G4double pZ78N117[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1040 | static const std::pair<G4int, const G4double*> Z78N117=std::make_pair(117,pZ78N117); |
---|
1041 | static const G4double pZ78N118[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1042 | static const std::pair<G4int, const G4double*> Z78N118=std::make_pair(118,pZ78N118); |
---|
1043 | static const G4double pZ78N120[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1044 | static const std::pair<G4int, const G4double*> Z78N120=std::make_pair(120,pZ78N120); |
---|
1045 | static const std::pair<G4int, const G4double*> Z78[N78]={Z78N112, Z78N114, Z78N116, |
---|
1046 | Z78N117, Z78N118, Z78N120}; |
---|
1047 | //==> Au(Z=79) |
---|
1048 | static const G4int N79=1; |
---|
1049 | static const G4double pZ79N118[5]={.012, 4., .2, .0001, .002}; |
---|
1050 | static const std::pair<G4int, const G4double*> Z79N118=std::make_pair(118,pZ79N118); |
---|
1051 | static const std::pair<G4int, const G4double*> Z79[N79]={Z79N118}; |
---|
1052 | //==> Hg(Z=80) |
---|
1053 | static const G4int N80=7; |
---|
1054 | static const G4double pZ80N116[5]={.022, 11., .006, .044, .001}; |
---|
1055 | static const std::pair<G4int, const G4double*> Z80N116=std::make_pair(116,pZ80N116); |
---|
1056 | static const G4double pZ80N118[5]={.024, 10., .04, .018, .0016}; |
---|
1057 | static const std::pair<G4int, const G4double*> Z80N118=std::make_pair(118,pZ80N118); |
---|
1058 | static const G4double pZ80N119[5]={.017, 8., .02, .02, .0016}; |
---|
1059 | static const std::pair<G4int, const G4double*> Z80N119=std::make_pair(119,pZ80N119); |
---|
1060 | static const G4double pZ80N120[5]={.021, 9., .03, .02, .0016}; |
---|
1061 | static const std::pair<G4int, const G4double*> Z80N120=std::make_pair(120,pZ80N120); |
---|
1062 | static const G4double pZ80N121[5]={.01, 7., .025, .025, .0016}; |
---|
1063 | static const std::pair<G4int, const G4double*> Z80N121=std::make_pair(121,pZ80N121); |
---|
1064 | static const G4double pZ80N122[5]={.023, 9., .008, .045, .0012}; |
---|
1065 | static const std::pair<G4int, const G4double*> Z80N122=std::make_pair(122,pZ80N122); |
---|
1066 | static const G4double pZ80N124[5]={.018, 8., .007, .04, .0013}; |
---|
1067 | static const std::pair<G4int, const G4double*> Z80N124=std::make_pair(124,pZ80N124); |
---|
1068 | static const std::pair<G4int, const G4double*> Z80[N80]={Z80N116, Z80N118, Z80N119, |
---|
1069 | Z80N120, Z80N121, Z80N122, |
---|
1070 | Z80N124}; |
---|
1071 | //==> Tl(Z=81) |
---|
1072 | static const G4int N81=2; |
---|
1073 | static const G4double pZ81N122[5]={.018, 5., .1, .03, .002}; // *** No DATA *** |
---|
1074 | static const std::pair<G4int, const G4double*> Z81N122=std::make_pair(122,pZ81N122); |
---|
1075 | static const G4double pZ81N124[5]={.01, 27., 0., 0., 1.}; // *** No DATA *** |
---|
1076 | static const std::pair<G4int, const G4double*> Z81N124=std::make_pair(124,pZ81N124); |
---|
1077 | static const std::pair<G4int, const G4double*> Z81[N81]={Z81N122, Z81N124}; |
---|
1078 | //==> Pb(Z=82) |
---|
1079 | static const G4int N82=4; |
---|
1080 | static const G4double pZ82N122[5]={.032, 9., .001, .13, .004}; |
---|
1081 | static const std::pair<G4int, const G4double*> Z82N122=std::make_pair(122,pZ82N122); |
---|
1082 | static const G4double pZ82N124[5]={.02, 7., .005, .14, .002}; |
---|
1083 | static const std::pair<G4int, const G4double*> Z82N124=std::make_pair(124,pZ82N124); |
---|
1084 | static const G4double pZ82N125[5]={.021, 9., .0012, .05, .01}; |
---|
1085 | static const std::pair<G4int, const G4double*> Z82N125=std::make_pair(125,pZ82N125); |
---|
1086 | static const G4double pZ82N126[5]={.049, 14., .0007, .145, .001}; |
---|
1087 | static const std::pair<G4int, const G4double*> Z82N126=std::make_pair(126,pZ82N126); |
---|
1088 | static const std::pair<G4int, const G4double*> Z82[N82]={Z82N122, Z82N124, Z82N125, |
---|
1089 | Z82N126}; |
---|
1090 | //==> Bi(Z=83) |
---|
1091 | static const G4int N83=1; |
---|
1092 | static const G4double pZ83N126[5]={.033, 10., .001, .13, .006}; |
---|
1093 | static const std::pair<G4int, const G4double*> Z83N126=std::make_pair(126,pZ83N126); |
---|
1094 | static const std::pair<G4int, const G4double*> Z83[N83]={Z83N126}; |
---|
1095 | //==> Po(Z=84) |
---|
1096 | static const G4int N84=1; |
---|
1097 | static const G4double pZ84N0[5]={.01, 27., 0., 0., 1.}; // *** NoStableIsotopes *** |
---|
1098 | static const std::pair<G4int, const G4double*> Z84N0=std::make_pair(0,pZ84N0); |
---|
1099 | static const std::pair<G4int, const G4double*> Z84[N84]={Z84N0}; |
---|
1100 | //==> At(Z=85) |
---|
1101 | static const G4int N85=1; |
---|
1102 | static const G4double pZ85N0[5]={.018, 5., .1, .03, .002}; // *** NoStableIsotopes *** |
---|
1103 | static const std::pair<G4int, const G4double*> Z85N0=std::make_pair(0,pZ85N0); |
---|
1104 | static const std::pair<G4int, const G4double*> Z85[N85]={Z85N0}; |
---|
1105 | //==> Rn(Z=86) |
---|
1106 | static const G4int N86=1; |
---|
1107 | static const G4double pZ86N0[5]={.018, 5., .1, .03, .002}; // *** NoStableIsotopes *** |
---|
1108 | static const std::pair<G4int, const G4double*> Z86N0=std::make_pair(0,pZ86N0); |
---|
1109 | static const std::pair<G4int, const G4double*> Z86[N86]={Z86N0}; |
---|
1110 | //==> Fr(Z=87) |
---|
1111 | static const G4int N87=1; |
---|
1112 | static const G4double pZ87N0[5]={.018, 5., .1, .03, .002}; // *** NoStableIsotopes *** |
---|
1113 | static const std::pair<G4int, const G4double*> Z87N0=std::make_pair(0,pZ87N0); |
---|
1114 | static const std::pair<G4int, const G4double*> Z87[N87]={Z87N0}; |
---|
1115 | //==> Ra(Z=88) |
---|
1116 | static const G4int N88=1; |
---|
1117 | static const G4double pZ88N138[5]={.012, 4.4, .068, .051, .0008}; |
---|
1118 | static const std::pair<G4int, const G4double*> Z88N138=std::make_pair(138,pZ88N138); |
---|
1119 | static const std::pair<G4int, const G4double*> Z88[N88]={Z88N138}; |
---|
1120 | //==> Ac(Z=89) |
---|
1121 | static const G4int N89=1; |
---|
1122 | static const G4double pZ89N0[5]={.018, 5., .1, .03, .002}; // *** NoStableIsotopes *** |
---|
1123 | static const std::pair<G4int, const G4double*> Z89N0=std::make_pair(0,pZ89N0); |
---|
1124 | static const std::pair<G4int, const G4double*> Z89[N89]={Z89N0}; |
---|
1125 | //==> Th(Z=90) |
---|
1126 | static const G4int N90=1; |
---|
1127 | static const G4double pZ90N142[5]={.01, 3.6, .07, .029, .0009}; |
---|
1128 | static const std::pair<G4int, const G4double*> Z90N142=std::make_pair(142,pZ90N142); |
---|
1129 | static const std::pair<G4int, const G4double*> Z90[N90]={Z90N142}; |
---|
1130 | //==> Pa(Z=91) |
---|
1131 | static const G4int N91=1; |
---|
1132 | static const G4double pZ91N0[5]={.01, 27., 0., 0., 1.}; // *** NoStableIsotopes *** |
---|
1133 | static const std::pair<G4int, const G4double*> Z91N0=std::make_pair(0,pZ91N0); |
---|
1134 | static const std::pair<G4int, const G4double*> Z91[N91]={Z91N0}; |
---|
1135 | //==> U (Z=92) |
---|
1136 | static const G4int N92=2; |
---|
1137 | static const G4double pZ92N143[5]={.005, 2.5, .06, .008, .002}; |
---|
1138 | static const std::pair<G4int, const G4double*> Z92N143=std::make_pair(143,pZ92N143); |
---|
1139 | static const G4double pZ92N146[5]={.009, 3.1, .04, .025, .001}; |
---|
1140 | static const std::pair<G4int, const G4double*> Z92N146=std::make_pair(146,pZ92N146); |
---|
1141 | static const std::pair<G4int, const G4double*> Z92[N92]={Z92N143, Z92N146}; |
---|
1142 | //==> Np(Z=93) |
---|
1143 | static const G4int N93=1; |
---|
1144 | static const G4double pZ93N144[5]={.009, 2.35, .35, .003, .0007}; |
---|
1145 | static const std::pair<G4int, const G4double*> Z93N144=std::make_pair(144,pZ93N144); |
---|
1146 | static const std::pair<G4int, const G4double*> Z93[N93]={Z93N144}; |
---|
1147 | //==> Pu(Z=94) |
---|
1148 | static const G4int N94=3; |
---|
1149 | static const G4double pZ94N145[5]={.005, 2.6, .04, .023, .0002}; // *** Artificial *** |
---|
1150 | static const std::pair<G4int, const G4double*> Z94N145=std::make_pair(145,pZ94N145); |
---|
1151 | static const G4double pZ94N148[5]={.009, 3.1, .06, .02, .001}; // *** Artificial *** |
---|
1152 | static const std::pair<G4int, const G4double*> Z94N148=std::make_pair(148,pZ94N148); |
---|
1153 | static const G4double pZ94N150[5]={.01, 27., 0., 0., 1.}; |
---|
1154 | static const std::pair<G4int, const G4double*> Z94N150=std::make_pair(150,pZ94N150); |
---|
1155 | static const std::pair<G4int, const G4double*> Z94[N94]={Z94N145, Z94N148, Z94N150}; |
---|
1156 | //==> Am(Z=95) |
---|
1157 | static const G4int N95=1; |
---|
1158 | static const G4double pZ95N0[5]={.018, 5., .1, .03, .002}; // *** NoStableIsotopes *** |
---|
1159 | static const std::pair<G4int, const G4double*> Z95N0=std::make_pair(0,pZ95N0); |
---|
1160 | static const std::pair<G4int, const G4double*> Z95[N95]={Z95N0}; |
---|
1161 | //==> Cm(Z=96) |
---|
1162 | static const G4int N96=1; |
---|
1163 | static const G4double pZ96N151[5]={.005, 2.5, .07, .027, .0009}; |
---|
1164 | static const std::pair<G4int, const G4double*> Z96N151=std::make_pair(151,pZ96N151); |
---|
1165 | static const std::pair<G4int, const G4double*> Z96[N96]={Z96N151}; |
---|
1166 | |
---|
1167 | static const G4int NZ=97; // #of Elements covered by CHIPS |
---|
1168 | static const std::pair<G4int, const G4double*>* Pars[NZ]={Z0,Z1,Z2,Z3,Z4,Z5,Z6,Z7,Z8,Z9, |
---|
1169 | Z10,Z11,Z12,Z13,Z14,Z15,Z16,Z17,Z18,Z19,Z20,Z21,Z22,Z23,Z24,Z25,Z26,Z27,Z28,Z29,Z30, |
---|
1170 | Z31,Z32,Z33,Z34,Z35,Z36,Z37,Z38,Z39,Z40,Z41,Z42,Z43,Z44,Z45,Z46,Z47,Z48,Z49,Z50,Z51, |
---|
1171 | Z52,Z53,Z54,Z55,Z56,Z57,Z58,Z59,Z60,Z61,Z62,Z63,Z64,Z65,Z66,Z67,Z68,Z69,Z70,Z71,Z72, |
---|
1172 | Z73,Z74,Z75,Z76,Z77,Z78,Z79,Z80,Z81,Z82,Z83,Z84,Z85,Z86,Z87,Z88,Z89,Z90,Z91,Z92,Z93, |
---|
1173 | Z94,Z95,Z96}; |
---|
1174 | static const G4int NIso[NZ]={N0,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,N12,N13,N14,N15,N16, |
---|
1175 | N17,N18,N19,N20,N21,N22,N23,N24,N25,N26,N27,N28,N29,N30,N31,N32,N33,N34,N35,N36,N37, |
---|
1176 | N38,N39,N40,N41,N42,N43,N44,N45,N46,N47,N48,N49,N50,N51,N52,N53,N54,N55,N56,N57,N58, |
---|
1177 | N59,N60,N61,N62,N63,N64,N65,N66,N67,N68,N69,N70,N71,N72,N73,N74,N75,N76,N77,N78,N79, |
---|
1178 | N80,N81,N82,N83,N84,N85,N86,N87,N88,N89,N90,N91,N92,N93,N94,N95,N96}; |
---|
1179 | static G4int mZ=0; |
---|
1180 | static G4int mN=0; |
---|
1181 | static G4double P=.1; // s=SQRT(M_N^2+M_h^2+2*E_h*M_N) |
---|
1182 | static G4double R=0.; // Prototype of the result |
---|
1183 | static G4double p0=0.; |
---|
1184 | static G4double p1=0.; |
---|
1185 | static G4double p2=0.; |
---|
1186 | static G4double p3=0.; |
---|
1187 | static G4double p4=0.; |
---|
1188 | G4int A=Z+N; |
---|
1189 | if(A<=1) return 0.; |
---|
1190 | if(p<=0.001) return 1.; |
---|
1191 | if(Z!=mZ || N!=mN) // Recalculate the parameters for different isotope |
---|
1192 | { |
---|
1193 | mZ=Z; |
---|
1194 | mN=N; |
---|
1195 | P=p; |
---|
1196 | if(Z<97 && N<248) // General solution (*** Z/A limits ***) |
---|
1197 | { |
---|
1198 | p0=.01; // Default guess if there is no data |
---|
1199 | p1=0.; |
---|
1200 | p2=27.; |
---|
1201 | p3=0.; |
---|
1202 | p4=1.; |
---|
1203 | G4int nn=NIso[Z]; |
---|
1204 | G4bool nfound=true; |
---|
1205 | if(nn) for (G4int in=0; in<nn; in++) |
---|
1206 | { |
---|
1207 | std::pair<G4int, const G4double*> curIs=Pars[Z][in]; |
---|
1208 | if(curIs.first == N) |
---|
1209 | { |
---|
1210 | const G4double* curT=curIs.second; |
---|
1211 | p0 = curT[0]; |
---|
1212 | if(p < p0) |
---|
1213 | { |
---|
1214 | R=1.; |
---|
1215 | return R; |
---|
1216 | } |
---|
1217 | p1 = curT[1]; |
---|
1218 | p2 = curT[2]; |
---|
1219 | p3 = curT[3]; |
---|
1220 | p4 = curT[4]; |
---|
1221 | nfound = false; |
---|
1222 | break; |
---|
1223 | } |
---|
1224 | } |
---|
1225 | if(nfound) G4cout<<"-Warning-G4QNeutronCaptureRatio::CSLin: Z="<<Z<<", N=" |
---|
1226 | <<N<<" isotope is not implemented in CHIPS"<<G4endl; |
---|
1227 | R=std::pow(p0/p,p1); |
---|
1228 | if(p2>0.) |
---|
1229 | { |
---|
1230 | G4double dp=p-p3; |
---|
1231 | R+=p2*std::exp(-dp*dp/p4); |
---|
1232 | } |
---|
1233 | if(R>1.) R=1.; |
---|
1234 | } |
---|
1235 | else G4cerr<<"-Warning-G4QNeutronCaptureRatio::CalcR:*Bad A* Z="<<Z<<", N="<<N<<G4endl; |
---|
1236 | } |
---|
1237 | else if(std::fabs(p-P)/P<.0001) return R; // Normally used at high energies (direct) only |
---|
1238 | return R; |
---|
1239 | } // End of CalcCap2IN_Ratio |
---|