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