| 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 "G4Pow.hh"
45 45
46 << 46 ///////////////////////////////////////////////////////////////////////////////
47 ////////////////////////////////////////////// <<
48 47
49 G4ComponentAntiNuclNuclearXS::G4ComponentAntiN 48 G4ComponentAntiNuclNuclearXS::G4ComponentAntiNuclNuclearXS()
50 : G4VComponentCrossSection("AntiAGlauber"), 49 : G4VComponentCrossSection("AntiAGlauber"),
51 fRadiusEff(0.0), << 50 // fUpperLimit(10000*GeV), fLowerLimit(10*MeV),
>> 51 fRadiusEff(0.0), fRadiusNN2(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
63 b0 = 11.92; // GeV^(-2) << 63 Mn = 0.93827231; // GeV
64 b2 = 0.3036; // GeV^(-2) << 64 b0 = 11.92; // GeV^(-2)
65 SqrtS0 = 20.74; // GeV << 65 b2 = 0.3036; // GeV^(-2)
66 S0 = 33.0625; // GeV^2 << 66 SqrtS0 = 20.74; // GeV
67 R0 = 1.0; // default va << 67 S0 = 33.0625; // GeV^2
>> 68 R0 = 1.0; // default value (V.Ivanchenko)
68 } 69 }
69 70
70 << 71 ///////////////////////////////////////////////////////////////////////////////////////
71 ////////////////////////////////////////////// << 72 //
>> 73 //
72 74
73 G4ComponentAntiNuclNuclearXS::~G4ComponentAnti 75 G4ComponentAntiNuclNuclearXS::~G4ComponentAntiNuclNuclearXS()
74 { 76 {
75 } 77 }
76 78
>> 79 ////////////////////////////////////////////////////////////////////////////////
77 80
78 ////////////////////////////////////////////// << 81
>> 82
>> 83 ////////////////////////////////////////////////////////////////////////////////
79 // 84 //
80 // Calculation of total CrossSection of Anti-N 85 // Calculation of total CrossSection of Anti-Nucleus - Nucleus
81 86
>> 87
82 G4double G4ComponentAntiNuclNuclearXS::GetTota 88 G4double G4ComponentAntiNuclNuclearXS::GetTotalElementCrossSection
83 (const G4ParticleDefinition* aParticle, G4doub 89 (const G4ParticleDefinition* aParticle, G4double kinEnergy, G4int Z, G4double A)
84 { 90 {
85 if ( aParticle == nullptr ) { << 91 G4double xsection, sigmaTotal, sigmaElastic;
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 92
96 // calculation of squared radius of NN-coll << 93 const G4ParticleDefinition* theParticle = aParticle;
97 G4int i(-1), j(-1); << 94
98 if ( theParticle == theAProton || << 95 sigmaTotal = GetAntiHadronNucleonTotCrSc(theParticle,kinEnergy);
99 theParticle == theANeutron ) { i=0; } << 96 sigmaElastic = GetAntiHadronNucleonElCrSc(theParticle,kinEnergy);
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 97
114 G4int intA = static_cast<G4int>( A ); << 98 // calculation of squared radius of NN-collision
>> 99 fRadiusNN2=sigmaTotal*sigmaTotal*0.1/(8.*sigmaElastic*pi) ; //fm^2
115 100
116 if ( Z == 1 && intA == 1 ) { j=0; } << 101 // calculation of effective nuclear radius for Pbar and Nbar interactions (can be changed)
117 else if ( Z == 1 && intA == 2 ) { j=1; } << 102
118 else if ( Z == 1 && intA == 3 ) { j=2; } << 103 //A.R. 29-Jan-2013 : use antiprotons/antineutrons as the default case,
119 else if ( Z == 2 && intA == 3 ) { j=3; } << 104 // to be used for instance, as first approximation
120 else if ( Z == 2 && intA == 4 ) { j=4; } << 105 // without validation, for anti-hyperons.
121 else {} << 106 //if ( (theParticle == theAProton) || (theParticle == theANeutron) ) {
122 << 107 if(A==1)
123 if ( i < 0 && j >= 0 ) { fRadiusEff = Ref << 108 { fTotalXsc = sigmaTotal * millibarn;
124 if ( i == 0 && j == 0 ) return sigmaTotal << 109 return fTotalXsc; }
125 if ( i >= 0 && j >= 0 ) { fRadiusEff = Ref << 110
126 << 111 fRadiusEff = 1.34*G4Pow::GetInstance()->powA(A,0.23)+1.35/G4Pow::GetInstance()->powA(A,1./3.); //fm
127 if ( j < 0 ) { << 112
128 if ( i == 0 ) { fRadiusEff = 1.34 * << 113 if( (Z==1) && (A==2) ) fRadiusEff = 3.800; //fm
129 + 1.35 / << 114 if( (Z==1) && (A==3) ) fRadiusEff = 3.300;
130 else if ( i == 1 ) { fRadiusEff = 1.46 * << 115 if( (Z==2) && (A==3) ) fRadiusEff = 3.300;
131 + 1.45 / << 116 if( (Z==2) && (A==4) ) fRadiusEff = 2.376;
132 else if ( i == 2 ) { fRadiusEff = 1.40 * << 117 //}
133 + 1.63 / << 118
134 else if ( i == 3 ) { fRadiusEff = 1.40 * << 119 //calculation of effective nuclear radius for AntiDeuteron interaction (can be changed)
135 + 1.63 / << 120 if (theParticle == theADeuteron)
136 else if ( i == 4 ) { fRadiusEff = 1.35 * << 121 { fRadiusEff = 1.46 * G4Pow::GetInstance()->powA(A,0.21) + 1.45 / G4Pow::GetInstance()->powA(A,1./3.);
137 + 1.10 / << 122
138 else if ( i < 0 ) { fRadiusEff = 1.35 * << 123 if( (Z==1) && (A==2) ) fRadiusEff = 3.238; //fm
139 + 1.10 / theG4P << 124 if( (Z==1) && (A==3) ) fRadiusEff = 3.144;
140 else {} << 125 if( (Z==2) && (A==3) ) fRadiusEff = 3.144;
>> 126 if( (Z==2) && (A==4) ) fRadiusEff = 2.544;
>> 127 }
>> 128 // calculation of effective nuclear radius for AntiHe3 interaction (can be changed)
>> 129
>> 130 if( (theParticle ==theAHe3) || (theParticle ==theATriton) )
>> 131 { fRadiusEff = 1.40* G4Pow::GetInstance()->powA(A,0.21)+1.63/G4Pow::GetInstance()->powA(A,1./3.);
>> 132
>> 133 if( (Z==1) && (A==2) ) fRadiusEff = 3.144; //fm
>> 134 if( (Z==1) && (A==3) ) fRadiusEff = 3.075;
>> 135 if( (Z==2) && (A==3) ) fRadiusEff = 3.075;
>> 136 if( (Z==2) && (A==4) ) fRadiusEff = 2.589;
141 } 137 }
142 138
143 G4double R2 = fRadiusEff*fRadiusEff; << 139 //calculation of effective nuclear radius for AntiAlpha interaction (can be changed)
144 G4double ApAt = std::abs(theParticle->GetBar << 140
>> 141 if (theParticle == theAAlpha)
>> 142 {
>> 143 fRadiusEff = 1.35* G4Pow::GetInstance()->powA(A,0.21)+1.1/G4Pow::GetInstance()->powA(A,1./3.);
>> 144
>> 145 if( (Z==1) && (A==2) ) fRadiusEff = 2.544; //fm
>> 146 if( (Z==1) && (A==3) ) fRadiusEff = 2.589;
>> 147 if( (Z==2) && (A==3) ) fRadiusEff = 2.589;
>> 148 if( (Z==2) && (A==4) ) fRadiusEff = 2.241;
>> 149
>> 150 }
145 151
146 G4double xsection = millibarn*2.*pi*R2*10.*G << 152 G4double R2 = fRadiusEff*fRadiusEff;
147 fTotalXsc = xsection; << 153 G4double REf2 = R2+fRadiusNN2;
>> 154 G4double ApAt = std::abs(theParticle->GetBaryonNumber()) * A;
>> 155
>> 156 xsection = 2*pi*REf2*10.*G4Log(1+(ApAt*sigmaTotal/(2*pi*REf2*10.))); //mb
>> 157 xsection =xsection *millibarn;
>> 158 fTotalXsc = xsection;
148 159
149 return fTotalXsc; 160 return fTotalXsc;
150 } 161 }
151 162
152 163
153 ////////////////////////////////////////////// << 164 ////////////////////////////////////////////////////////////////////////////////
154 // 165 //
155 // Calculation of total CrossSection of Anti-N 166 // Calculation of total CrossSection of Anti-Nucleus - Nucleus
156 << 167 //////////////////////////////////////////////////////////////////////////////
157 G4double G4ComponentAntiNuclNuclearXS::GetTota 168 G4double G4ComponentAntiNuclNuclearXS::GetTotalIsotopeCrossSection
158 (const G4ParticleDefinition* aParticle, G4doub 169 (const G4ParticleDefinition* aParticle, G4double kinEnergy, G4int Z, G4int A )
159 { << 170 { return GetTotalElementCrossSection(aParticle, kinEnergy, Z, (G4double) A); }
160 return GetTotalElementCrossSection(aParticle <<
161 } <<
162 <<
163 171
164 ////////////////////////////////////////////// << 172 ////////////////////////////////////////////////////////////////
165 // Calculation of inelastic CrossSection of An 173 // Calculation of inelastic CrossSection of Anti-Nucleus - Nucleus
>> 174 ////////////////////////////////////////////////////////////////
166 175
167 G4double G4ComponentAntiNuclNuclearXS::GetInel 176 G4double G4ComponentAntiNuclNuclearXS::GetInelasticElementCrossSection
168 (const G4ParticleDefinition* aParticle, G4doub 177 (const G4ParticleDefinition* aParticle, G4double kinEnergy, G4int Z, G4double A)
169 { 178 {
170 if ( aParticle == nullptr ) { << 179 G4double inelxsection, sigmaTotal, sigmaElastic;
171 G4ExceptionDescription ed; << 180
172 ed << "anti-nucleus with nullptr particle <<
173 G4Exception( "G4ComponentAntiNuclNuclearXS <<
174 "antiNuclNuclearXS003", JustW <<
175 return 0.0; <<
176 } <<
177 <<
178 const G4ParticleDefinition* theParticle = aP 181 const G4ParticleDefinition* theParticle = aParticle;
179 G4double sigmaTotal = GetAntiHadronNucleon << 182
180 G4double sigmaElastic = GetAntiHadronNucleon << 183 sigmaTotal = GetAntiHadronNucleonTotCrSc(theParticle,kinEnergy);
>> 184 sigmaElastic = GetAntiHadronNucleonElCrSc(theParticle,kinEnergy);
181 185
182 // calculation of sqr of radius NN-collision << 186 // calculation of sqr of radius NN-collision
183 G4int i(-1), j(-1); << 187 fRadiusNN2=sigmaTotal*sigmaTotal*0.1/(8.*sigmaElastic*pi); // fm^2
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 188
200 G4int intA = static_cast<G4int>( A ); <<
201 189
202 if ( Z == 1 && intA == 1 ) { j=0; } << 190 // calculation of effective nuclear radius for Pbar and Nbar interaction (can be changed)
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 191
229 G4double R2 = fRadiusEff*fRadiusEff; << 192 //A.R. 29-Jan-2013 : use antiprotons/antineutrons as the default case,
230 G4double ApAt = std::abs(theParticle->GetBar << 193 // to be used for instance, as first approximation
>> 194 // without validation, for anti-hyperons.
>> 195 //if ( (theParticle == theAProton) || (theParticle == theANeutron) ) {
>> 196 if (A==1)
>> 197 { fInelasticXsc = (sigmaTotal - sigmaElastic) * millibarn;
>> 198 return fInelasticXsc;
>> 199 }
>> 200 fRadiusEff = 1.31*G4Pow::GetInstance()->powA(A, 0.22)+0.9/G4Pow::GetInstance()->powA(A, 1./3.); //fm
>> 201
>> 202 if( (Z==1) && (A==2) ) fRadiusEff = 3.582; //fm
>> 203 if( (Z==1) && (A==3) ) fRadiusEff = 3.105;
>> 204 if( (Z==2) && (A==3) ) fRadiusEff = 3.105;
>> 205 if( (Z==2) && (A==4) ) fRadiusEff = 2.209;
>> 206 //}
231 207
232 G4double inelxsection = millibarn*pi*R2*10.* << 208 //calculation of effective nuclear radius for AntiDeuteron interaction (can be changed)
233 fInelasticXsc = inelxsection; <<
234 209
235 return fInelasticXsc; << 210 if (theParticle ==theADeuteron)
236 } << 211 {
>> 212 fRadiusEff = 1.38*G4Pow::GetInstance()->powA(A, 0.21)+1.55/G4Pow::GetInstance()->powA(A, 1./3.);
>> 213
>> 214 if( (Z==1) && (A==2) ) fRadiusEff = 3.169; //fm
>> 215 if( (Z==1) && (A==3) ) fRadiusEff = 3.066;
>> 216 if( (Z==2) && (A==3) ) fRadiusEff = 3.066;
>> 217 if( (Z==2) && (A==4) ) fRadiusEff = 2.498;
>> 218 }
>> 219
>> 220 //calculation of effective nuclear radius for AntiHe3 interaction (can be changed)
>> 221
>> 222 if( (theParticle ==theAHe3) || (theParticle ==theATriton) )
>> 223 {
>> 224 fRadiusEff = 1.34 * G4Pow::GetInstance()->powA(A, 0.21)+1.51/G4Pow::GetInstance()->powA(A, 1./3.);
>> 225
>> 226 if( (Z==1) && (A==2) ) fRadiusEff = 3.066; //fm
>> 227 if( (Z==1) && (A==3) ) fRadiusEff = 2.973;
>> 228 if( (Z==2) && (A==3) ) fRadiusEff = 2.973;
>> 229 if( (Z==2) && (A==4) ) fRadiusEff = 2.508;
>> 230
>> 231 }
>> 232
>> 233 //calculation of effective nuclear radius for AntiAlpha interaction (can be changed)
237 234
>> 235 if (theParticle == theAAlpha)
>> 236 {
>> 237 fRadiusEff = 1.3*G4Pow::GetInstance()->powA(A, 0.21)+1.05/G4Pow::GetInstance()->powA(A, 1./3.);
>> 238
>> 239 if( (Z==1) && (A==2) ) fRadiusEff = 2.498; //fm
>> 240 if( (Z==1) && (A==3) ) fRadiusEff = 2.508;
>> 241 if( (Z==2) && (A==3) ) fRadiusEff = 2.508;
>> 242 if( (Z==2) && (A==4) ) fRadiusEff = 2.158;
>> 243 }
>> 244 G4double R2 = fRadiusEff*fRadiusEff;
>> 245 G4double REf2 = R2+fRadiusNN2;
>> 246 G4double ApAt= std::abs(theParticle->GetBaryonNumber()) * A;
>> 247
>> 248 inelxsection = pi*REf2 *10* G4Log(1+(ApAt*sigmaTotal/(pi*REf2*10.))); //mb
>> 249 inelxsection = inelxsection * millibarn;
>> 250 fInelasticXsc = inelxsection;
>> 251 return fInelasticXsc;
>> 252 }
238 253
239 ////////////////////////////////////////////// << 254 ///////////////////////////////////////////////////////////////////////////////
240 // 255 //
241 // Calculates Inelastic Anti-nucleus-Nucleus c 256 // Calculates Inelastic Anti-nucleus-Nucleus cross-section
242 << 257 //
243 G4double G4ComponentAntiNuclNuclearXS::GetInel 258 G4double G4ComponentAntiNuclNuclearXS::GetInelasticIsotopeCrossSection
244 (const G4ParticleDefinition* aParticle, G4doub 259 (const G4ParticleDefinition* aParticle, G4double kinEnergy, G4int Z, G4int A)
245 { << 260 {return GetInelasticElementCrossSection(aParticle, kinEnergy, Z, (G4double) A); }
246 return GetInelasticElementCrossSection(aPart << 261
247 } <<
248 262
249 263
250 ////////////////////////////////////////////// << 264 ///////////////////////////////////////////////////////////////////////////////
251 // 265 //
252 // Calculates elastic Anti-nucleus-Nucleus cro 266 // Calculates elastic Anti-nucleus-Nucleus cross-section as Total - Inelastic
253 << 267 //
254 G4double G4ComponentAntiNuclNuclearXS::GetElas 268 G4double G4ComponentAntiNuclNuclearXS::GetElasticElementCrossSection
255 (const G4ParticleDefinition* aParticle, G4doub 269 (const G4ParticleDefinition* aParticle, G4double kinEnergy, G4int Z, G4double A)
256 { 270 {
257 fElasticXsc = GetTotalElementCrossSection(aP << 271 fElasticXsc = GetTotalElementCrossSection(aParticle, kinEnergy, Z, A)-
258 GetInelasticElementCrossSectio << 272 GetInelasticElementCrossSection(aParticle, kinEnergy, Z, A);
259 if (fElasticXsc < 0.) fElasticXsc = 0.; << 273
260 return fElasticXsc; << 274 if (fElasticXsc < 0.) fElasticXsc = 0.;
261 } <<
262 275
>> 276 return fElasticXsc;
>> 277 }
263 278
264 ////////////////////////////////////////////// << 279 ///////////////////////////////////////////////////////////////////////////////
265 // 280 //
266 // Calculates elastic Anti-nucleus-Nucleus cro 281 // Calculates elastic Anti-nucleus-Nucleus cross-section
267 << 282 //
268 G4double G4ComponentAntiNuclNuclearXS::GetElas 283 G4double G4ComponentAntiNuclNuclearXS::GetElasticIsotopeCrossSection
269 (const G4ParticleDefinition* aParticle, G4doub 284 (const G4ParticleDefinition* aParticle, G4double kinEnergy, G4int Z, G4int A)
270 { << 285 { return GetElasticElementCrossSection(aParticle, kinEnergy, Z, (G4double) A); }
271 return GetElasticElementCrossSection(aPartic <<
272 } <<
273 286
274 287
275 ////////////////////////////////////////////// << 288 ///////////////////////////////////////////////////////////////////////////////////
276 // Calculation of Antihadron - hadron Total C 289 // Calculation of Antihadron - hadron Total Cross-section
277 290
278 G4double G4ComponentAntiNuclNuclearXS::GetAnti 291 G4double G4ComponentAntiNuclNuclearXS::GetAntiHadronNucleonTotCrSc
279 (const G4ParticleDefinition* aParticle, G4doub 292 (const G4ParticleDefinition* aParticle, G4double kinEnergy)
280 { 293 {
281 G4double xsection, Pmass, Energy, momentum; 294 G4double xsection, Pmass, Energy, momentum;
282 const G4ParticleDefinition* theParticle = aP 295 const G4ParticleDefinition* theParticle = aParticle;
283 Pmass=theParticle->GetPDGMass(); 296 Pmass=theParticle->GetPDGMass();
284 Energy=Pmass+kinEnergy; 297 Energy=Pmass+kinEnergy;
285 momentum=std::sqrt(Energy*Energy-Pmass*Pmass 298 momentum=std::sqrt(Energy*Energy-Pmass*Pmass)/std::abs(theParticle->GetBaryonNumber());
286 G4double Plab = momentum / GeV; 299 G4double Plab = momentum / GeV;
287 300
288 G4double B, SigAss; << 301 G4double B, SigAss;
289 G4double C, d1, d2, d3; << 302 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 303
305 //xsection *= millibarn; << 304 Elab = std::sqrt(Mn*Mn + Plab*Plab); // GeV
306 fAntiHadronNucleonTotXsc = xsection; << 305 S = 2.*Mn*Mn + 2. *Mn*Elab; // GeV^2
>> 306 SqrtS = std::sqrt(S); // GeV
>> 307
>> 308 B = b0+b2*G4Log(SqrtS/SqrtS0)*G4Log(SqrtS/SqrtS0); //GeV^(-2)
>> 309 SigAss = 36.04 +0.304*G4Log(S/S0)*G4Log(S/S0); //mb
>> 310 R0 = std::sqrt(0.40874044*SigAss - B); //GeV^(-2)
>> 311
>> 312 C = 13.55;
>> 313 d1 = -4.47;
>> 314 d2 = 12.38;
>> 315 d3 = -12.43;
>> 316 xsection = SigAss*(1 + 1./(std::sqrt(S-4.*Mn*Mn)) / (G4Pow::GetInstance()->powA(R0, 3.))
>> 317 *C* (1+d1/SqrtS+d2/(G4Pow::GetInstance()->powA(SqrtS,2.))+d3/(G4Pow::GetInstance()->powA(SqrtS,3.)) ));
>> 318
>> 319 // xsection *= millibarn;
307 320
>> 321 fAntiHadronNucleonTotXsc = xsection;
308 return fAntiHadronNucleonTotXsc; 322 return fAntiHadronNucleonTotXsc;
309 } 323 }
310 324
311 325
312 // /////////////////////////////////////////// << 326 //
>> 327 // /////////////////////////////////////////////////////////////////////////////////
313 // Calculation of Antihadron - hadron Elastic 328 // Calculation of Antihadron - hadron Elastic Cross-section
314 329
315 G4double G4ComponentAntiNuclNuclearXS :: 330 G4double G4ComponentAntiNuclNuclearXS ::
316 GetAntiHadronNucleonElCrSc(const G4ParticleDef 331 GetAntiHadronNucleonElCrSc(const G4ParticleDefinition* aParticle, G4double kinEnergy)
317 { 332 {
318 G4double xsection; << 333 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 334
332 //xsection *= millibarn; << 335 G4double SigAss;
333 fAntiHadronNucleonElXsc = xsection; << 336 G4double C, d1, d2, d3 ;
334 337
335 return fAntiHadronNucleonElXsc; << 338 GetAntiHadronNucleonTotCrSc(aParticle,kinEnergy);
336 } << 339
>> 340 SigAss = 4.5 + 0.101*G4Log(S/S0)*G4Log(S/S0); //mb
>> 341
>> 342 C = 59.27;
>> 343 d1 = -6.95;
>> 344 d2 = 23.54;
>> 345 d3 = -25.34;
>> 346
>> 347 xsection = SigAss* (1 + 1. / (std::sqrt(S-4.*Mn*Mn)) / (G4Pow::GetInstance()->powA(R0, 3.))
>> 348 *C* ( 1+d1/SqrtS+d2/(G4Pow::GetInstance()->powA(SqrtS,2.))+d3/(G4Pow::GetInstance()->powA(SqrtS,3.)) ));
337 349
>> 350 // xsection *= millibarn;
338 351
339 ////////////////////////////////////////////// << 352 fAntiHadronNucleonElXsc = xsection;
>> 353 return fAntiHadronNucleonElXsc;
>> 354 }
340 355
341 void G4ComponentAntiNuclNuclearXS::CrossSectio 356 void G4ComponentAntiNuclNuclearXS::CrossSectionDescription(std::ostream& outFile) const
342 { 357 {
343 outFile << "The G4ComponentAntiNuclNuclearXS 358 outFile << "The G4ComponentAntiNuclNuclearXS calculates total,\n"
344 << "inelastic, elastic cross section 359 << "inelastic, elastic cross sections of anti-nucleons and light \n"
345 << "anti-nucleus interactions with n << 360 << "anti-nucleus interactions with nuclei using Glauber's approach.\n"
346 << "It uses parametrizations of anti 361 << "It uses parametrizations of antiproton-proton total and elastic \n"
347 << "cross sections and Wood-Saxon di << 362 << "cross sections and Wood-Saxon distribution of nuclear density.\n"
>> 363 << "The lower limit is 10 MeV, the upper limit is 10 TeV. \n"
348 << "See details in Phys.Lett. B705 ( 364 << "See details in Phys.Lett. B705 (2011) 235. \n";
349 } 365 }
350 <<
351 366