| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // Calculation of the total, elastic and inel
27 // of anti-nucleon and anti-nucleus interacti
28 // based on Glauber approach and V. Grishine
29 // interpolations (ref. V.M.Grichine, Eur.Phy
30 // NIM, B267 (2009) 2460) and our parametriza
31 // cross-sections
32 //
33 //
34 // Created by A.Galoyan and V. Uzhinsky, 18.
35
36
37 #include "G4ComponentAntiNuclNuclearXS.hh"
38
39 #include "G4PhysicalConstants.hh"
40 #include "G4SystemOfUnits.hh"
41 #include "G4ParticleTable.hh"
42 #include "G4IonTable.hh"
43 #include "G4ParticleDefinition.hh"
44 #include "G4HadronicException.hh"
45
46
47 //////////////////////////////////////////////
48
49 G4ComponentAntiNuclNuclearXS::G4ComponentAntiN
50 : G4VComponentCrossSection("AntiAGlauber"),
51 fRadiusEff(0.0),
52 fTotalXsc(0.0), fElasticXsc(0.0), fInelastic
53 fAntiHadronNucleonTotXsc(0.0), fAntiHadronNu
54 Elab(0.0), S(0.0), SqrtS(0)
55 {
56 theAProton = G4AntiProton::AntiProton();
57 theANeutron = G4AntiNeutron::AntiNeutron();
58 theADeuteron = G4AntiDeuteron::AntiDeuteron(
59 theATriton = G4AntiTriton::AntiTriton();
60 theAAlpha = G4AntiAlpha::AntiAlpha();
61 theAHe3 = G4AntiHe3::AntiHe3();
62 Mn = 0.93827231; // GeV
63 b0 = 11.92; // GeV^(-2)
64 b2 = 0.3036; // GeV^(-2)
65 SqrtS0 = 20.74; // GeV
66 S0 = 33.0625; // GeV^2
67 R0 = 1.0; // default va
68 }
69
70
71 //////////////////////////////////////////////
72
73 G4ComponentAntiNuclNuclearXS::~G4ComponentAnti
74 {
75 }
76
77
78 //////////////////////////////////////////////
79 //
80 // Calculation of total CrossSection of Anti-N
81
82 G4double G4ComponentAntiNuclNuclearXS::GetTota
83 (const G4ParticleDefinition* aParticle, G4doub
84 {
85 if ( aParticle == nullptr ) {
86 G4ExceptionDescription ed;
87 ed << "anti-nucleus with nullptr particle
88 G4Exception( "G4ComponentAntiNuclNuclearXS
89 "antiNuclNuclearXS001", JustW
90 return 0.0;
91 }
92
93 const G4ParticleDefinition* theParticle = aP
94 G4double sigmaTotal = GetAntiHadronNucleonTo
95
96 // calculation of squared radius of NN-coll
97 G4int i(-1), j(-1);
98 if ( theParticle == theAProton ||
99 theParticle == theANeutron ) { i=0; }
100 else if ( theParticle == theADeuteron ) { i=
101 else if ( theParticle == theATriton ) { i=
102 else if ( theParticle == theAHe3 ) { i=
103 else if ( theParticle == theAAlpha ) { i=
104 else {};
105
106 if ( i < 0 && ( ! theParticle->IsAntiHypern
107 G4ExceptionDescription ed;
108 ed << "Unknown anti-nucleus : " << thePart
109 << "Target (Z, A)=(" << Z << "," << A <
110 G4Exception( "G4ComponentAntiNuclNuclearXS
111 "antiNuclNuclearXS002", JustW
112 }
113
114 G4int intA = static_cast<G4int>( A );
115
116 if ( Z == 1 && intA == 1 ) { j=0; }
117 else if ( Z == 1 && intA == 2 ) { j=1; }
118 else if ( Z == 1 && intA == 3 ) { j=2; }
119 else if ( Z == 2 && intA == 3 ) { j=3; }
120 else if ( Z == 2 && intA == 4 ) { j=4; }
121 else {}
122
123 if ( i < 0 && j >= 0 ) { fRadiusEff = Ref
124 if ( i == 0 && j == 0 ) return sigmaTotal
125 if ( i >= 0 && j >= 0 ) { fRadiusEff = Ref
126
127 if ( j < 0 ) {
128 if ( i == 0 ) { fRadiusEff = 1.34 *
129 + 1.35 /
130 else if ( i == 1 ) { fRadiusEff = 1.46 *
131 + 1.45 /
132 else if ( i == 2 ) { fRadiusEff = 1.40 *
133 + 1.63 /
134 else if ( i == 3 ) { fRadiusEff = 1.40 *
135 + 1.63 /
136 else if ( i == 4 ) { fRadiusEff = 1.35 *
137 + 1.10 /
138 else if ( i < 0 ) { fRadiusEff = 1.35 *
139 + 1.10 / theG4P
140 else {}
141 }
142
143 G4double R2 = fRadiusEff*fRadiusEff;
144 G4double ApAt = std::abs(theParticle->GetBar
145
146 G4double xsection = millibarn*2.*pi*R2*10.*G
147 fTotalXsc = xsection;
148
149 return fTotalXsc;
150 }
151
152
153 //////////////////////////////////////////////
154 //
155 // Calculation of total CrossSection of Anti-N
156
157 G4double G4ComponentAntiNuclNuclearXS::GetTota
158 (const G4ParticleDefinition* aParticle, G4doub
159 {
160 return GetTotalElementCrossSection(aParticle
161 }
162
163
164 //////////////////////////////////////////////
165 // Calculation of inelastic CrossSection of An
166
167 G4double G4ComponentAntiNuclNuclearXS::GetInel
168 (const G4ParticleDefinition* aParticle, G4doub
169 {
170 if ( aParticle == nullptr ) {
171 G4ExceptionDescription ed;
172 ed << "anti-nucleus with nullptr particle
173 G4Exception( "G4ComponentAntiNuclNuclearXS
174 "antiNuclNuclearXS003", JustW
175 return 0.0;
176 }
177
178 const G4ParticleDefinition* theParticle = aP
179 G4double sigmaTotal = GetAntiHadronNucleon
180 G4double sigmaElastic = GetAntiHadronNucleon
181
182 // calculation of sqr of radius NN-collision
183 G4int i(-1), j(-1);
184 if ( theParticle == theAProton ||
185 theParticle == theANeutron ) { i=0; }
186 else if ( theParticle == theADeuteron ) { i=
187 else if ( theParticle == theATriton ) { i=
188 else if ( theParticle == theAHe3 ) { i=
189 else if ( theParticle == theAAlpha ) { i=
190 else {};
191
192 if ( i < 0 && ( ! theParticle->IsAntiHypern
193 G4ExceptionDescription ed;
194 ed << "Unknown anti-nucleus : " << thePart
195 << "Target (Z, A)=(" << Z << "," << A <
196 G4Exception( "G4ComponentAntiNuclNuclearXS
197 "antiNuclNuclearXS004", JustW
198 }
199
200 G4int intA = static_cast<G4int>( A );
201
202 if ( Z == 1 && intA == 1 ) { j=0; }
203 else if ( Z == 1 && intA == 2 ) { j=1; }
204 else if ( Z == 1 && intA == 3 ) { j=2; }
205 else if ( Z == 2 && intA == 3 ) { j=3; }
206 else if ( Z == 2 && intA == 4 ) { j=4; }
207 else {}
208
209 if ( i < 0 && j >= 0 ) { fRadiusEff = Ref
210 if ( i == 0 && j == 0 ) return (sigmaTotal
211 if ( i >= 0 && j >= 0 ) { fRadiusEff = Ref
212
213 if ( j < 0) {
214 if ( i == 0 ) { fRadiusEff = 1.31*th
215 + 0.90/th
216 else if ( i == 1 ) { fRadiusEff = 1.38*th
217 + 1.55/th
218 else if ( i == 2 ) { fRadiusEff = 1.34*th
219 + 1.51/th
220 else if ( i == 3 ) { fRadiusEff = 1.34*th
221 + 1.51/th
222 else if ( i == 4 ) { fRadiusEff = 1.30*th
223 + 1.05/th
224 else if ( i < 0 ) { fRadiusEff = 1.30*th
225 + 1.05/th
226 else {}
227 }
228
229 G4double R2 = fRadiusEff*fRadiusEff;
230 G4double ApAt = std::abs(theParticle->GetBar
231
232 G4double inelxsection = millibarn*pi*R2*10.*
233 fInelasticXsc = inelxsection;
234
235 return fInelasticXsc;
236 }
237
238
239 //////////////////////////////////////////////
240 //
241 // Calculates Inelastic Anti-nucleus-Nucleus c
242
243 G4double G4ComponentAntiNuclNuclearXS::GetInel
244 (const G4ParticleDefinition* aParticle, G4doub
245 {
246 return GetInelasticElementCrossSection(aPart
247 }
248
249
250 //////////////////////////////////////////////
251 //
252 // Calculates elastic Anti-nucleus-Nucleus cro
253
254 G4double G4ComponentAntiNuclNuclearXS::GetElas
255 (const G4ParticleDefinition* aParticle, G4doub
256 {
257 fElasticXsc = GetTotalElementCrossSection(aP
258 GetInelasticElementCrossSectio
259 if (fElasticXsc < 0.) fElasticXsc = 0.;
260 return fElasticXsc;
261 }
262
263
264 //////////////////////////////////////////////
265 //
266 // Calculates elastic Anti-nucleus-Nucleus cro
267
268 G4double G4ComponentAntiNuclNuclearXS::GetElas
269 (const G4ParticleDefinition* aParticle, G4doub
270 {
271 return GetElasticElementCrossSection(aPartic
272 }
273
274
275 //////////////////////////////////////////////
276 // Calculation of Antihadron - hadron Total C
277
278 G4double G4ComponentAntiNuclNuclearXS::GetAnti
279 (const G4ParticleDefinition* aParticle, G4doub
280 {
281 G4double xsection, Pmass, Energy, momentum;
282 const G4ParticleDefinition* theParticle = aP
283 Pmass=theParticle->GetPDGMass();
284 Energy=Pmass+kinEnergy;
285 momentum=std::sqrt(Energy*Energy-Pmass*Pmass
286 G4double Plab = momentum / GeV;
287
288 G4double B, SigAss;
289 G4double C, d1, d2, d3;
290 Elab = std::sqrt(Mn*Mn + Plab*Plab); /
291 S = 2.*Mn*Mn + 2. *Mn*Elab; /
292 SqrtS = std::sqrt(S); /
293 B = b0+b2*G4Log(SqrtS/SqrtS0)*G4Log(S
294 SigAss = 36.04 +0.304*G4Log(S/S0)*G4Log(S/
295 R0 = std::sqrt(0.40874044*SigAss - B);
296 C = 13.55;
297 d1 = -4.47;
298 d2 = 12.38;
299 d3 = -12.43;
300
301 xsection = SigAss * ( 1 + 1./(std::sqrt(S-4.
302 * C * ( 1 + d1/SqrtS +
303 + d3/(theG4Pow
304
305 //xsection *= millibarn;
306 fAntiHadronNucleonTotXsc = xsection;
307
308 return fAntiHadronNucleonTotXsc;
309 }
310
311
312 // ///////////////////////////////////////////
313 // Calculation of Antihadron - hadron Elastic
314
315 G4double G4ComponentAntiNuclNuclearXS ::
316 GetAntiHadronNucleonElCrSc(const G4ParticleDef
317 {
318 G4double xsection;
319 G4double SigAss;
320 G4double C, d1, d2, d3;
321 GetAntiHadronNucleonTotCrSc(aParticle,kinEne
322 SigAss = 4.5 + 0.101*G4Log(S/S0)*G4Log(S/S
323 C = 59.27;
324 d1 = -6.95;
325 d2 = 23.54;
326 d3 = -25.34;
327
328 xsection = SigAss * ( 1 + 1. / (std::sqrt(S-
329 * C * ( 1 + d1/SqrtS +
330 + d3/(theG4Pow
331
332 //xsection *= millibarn;
333 fAntiHadronNucleonElXsc = xsection;
334
335 return fAntiHadronNucleonElXsc;
336 }
337
338
339 //////////////////////////////////////////////
340
341 void G4ComponentAntiNuclNuclearXS::CrossSectio
342 {
343 outFile << "The G4ComponentAntiNuclNuclearXS
344 << "inelastic, elastic cross section
345 << "anti-nucleus interactions with n
346 << "It uses parametrizations of anti
347 << "cross sections and Wood-Saxon di
348 << "See details in Phys.Lett. B705 (
349 }
350
351