| 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 // 24.11.08 V. Grichine - first implementation 26 // 24.11.08 V. Grichine - first implementation
27 // 27 //
28 // 04.09.18 V. Ivantchenko Major revision of i <<
29 // 27.05.19 V. Ivantchenko Removed obsolete me <<
30 28
31 #include "G4ComponentGGNuclNuclXsc.hh" 29 #include "G4ComponentGGNuclNuclXsc.hh"
32 30
33 #include "G4PhysicalConstants.hh" 31 #include "G4PhysicalConstants.hh"
34 #include "G4SystemOfUnits.hh" 32 #include "G4SystemOfUnits.hh"
35 #include "G4NucleiProperties.hh" << 33 #include "G4ParticleTable.hh"
>> 34 #include "G4IonTable.hh"
36 #include "G4ParticleDefinition.hh" 35 #include "G4ParticleDefinition.hh"
>> 36 #include "G4HadTmpUtil.hh"
37 #include "G4HadronNucleonXsc.hh" 37 #include "G4HadronNucleonXsc.hh"
38 #include "G4ComponentGGHadronNucleusXsc.hh" <<
39 #include "G4NuclearRadii.hh" <<
40 #include "G4Pow.hh" <<
41 38
42 namespace <<
43 { <<
44 const G4double inve = 1./CLHEP::eplus; <<
45 } <<
46 39
47 G4ComponentGGNuclNuclXsc::G4ComponentGGNuclNuc 40 G4ComponentGGNuclNuclXsc::G4ComponentGGNuclNuclXsc()
48 : G4VComponentCrossSection("Glauber-Gribov Nu << 41 : G4VComponentCrossSection("Glauber-Gribov nucleus nucleus"),
>> 42 // fUpperLimit(100000*GeV),
>> 43 fLowerLimit(0.1*MeV),
>> 44 fRadiusConst(1.08*fermi), // 1.1, 1.3 ?
>> 45 fTotalXsc(0.0), fElasticXsc(0.0), fInelasticXsc(0.0), fProductionXsc(0.0),
>> 46 fDiffractionXsc(0.0),
>> 47 cacheDP(G4Proton::Proton(),G4ParticleMomentum(1.,0,0),0),
>> 48 dProton(G4Proton::Proton(),G4ParticleMomentum(1.,0,0),0),
>> 49 dNeutron(G4Neutron::Neutron(),G4ParticleMomentum(1.,0,0),0)
>> 50 // , fHadronNucleonXsc(0.0)
49 { 51 {
50 theProton = G4Proton::Proton(); 52 theProton = G4Proton::Proton();
51 theNeutron = G4Neutron::Neutron(); 53 theNeutron = G4Neutron::Neutron();
52 theLambda = G4Lambda::Lambda(); << 54 hnXsc = new G4HadronNucleonXsc();
53 fHNXsc = new G4HadronNucleonXsc(); <<
54 fHadrNucl = new G4ComponentGGHadronNucleusXs <<
55 } 55 }
56 56
>> 57
57 G4ComponentGGNuclNuclXsc::~G4ComponentGGNuclNu 58 G4ComponentGGNuclNuclXsc::~G4ComponentGGNuclNuclXsc()
58 { 59 {
59 delete fHNXsc; << 60 delete hnXsc;
60 } 61 }
61 62
62 ////////////////////////////////////////////// << 63 ////////////////////////////////////////////////////////////////////
63 64
64 G4double G4ComponentGGNuclNuclXsc::GetTotalEle << 65 G4double G4ComponentGGNuclNuclXsc::GetTotalIsotopeCrossSection(const G4ParticleDefinition* aParticle,
65 const G4ParticleDefinition* aParticle << 66 G4double kinEnergy,
66 G4int Z, G4double A) << 67 G4int Z, G4int A)
67 { << 68 {
68 ComputeCrossSections(aParticle, kinEnergy, Z << 69 cacheDP.SetDefinition(aParticle);
>> 70 cacheDP.SetKineticEnergy(kinEnergy);
>> 71 fInelasticXsc = GetZandACrossSection(&cacheDP, Z, A);
69 return fTotalXsc; 72 return fTotalXsc;
70 } 73 }
71 74
72 ////////////////////////////////////////////// << 75 //////////////////////////////////////////////////////////////////////
73 76
74 G4double G4ComponentGGNuclNuclXsc::GetTotalIso << 77 G4double G4ComponentGGNuclNuclXsc::GetTotalElementCrossSection(const G4ParticleDefinition* aParticle,
75 const G4ParticleDefinition* aParticle << 78 G4double kinEnergy,
76 G4int Z, G4int A) << 79 G4int Z, G4double A)
77 { << 80 {
78 ComputeCrossSections(aParticle, kinEnergy, Z << 81 cacheDP.SetDefinition(aParticle);
>> 82 cacheDP.SetKineticEnergy(kinEnergy);
>> 83 fInelasticXsc = GetZandACrossSection(&cacheDP, Z, G4int(A));
79 return fTotalXsc; 84 return fTotalXsc;
80 } 85 }
81 86
82 ////////////////////////////////////////////// << 87 ////////////////////////////////////////////////////////////////////
83 88
84 G4double G4ComponentGGNuclNuclXsc::GetInelasti << 89 G4double G4ComponentGGNuclNuclXsc::GetInelasticIsotopeCrossSection(const G4ParticleDefinition* aParticle,
85 const G4ParticleDefinition* aParticle << 90 G4double kinEnergy,
86 G4int Z, G4double A) << 91 G4int Z, G4int A)
87 { << 92 {
88 ComputeCrossSections(aParticle, kinEnergy, Z << 93 cacheDP.SetDefinition(aParticle);
>> 94 cacheDP.SetKineticEnergy(kinEnergy);
>> 95 fInelasticXsc = GetZandACrossSection(&cacheDP, Z, A);
89 return fInelasticXsc; 96 return fInelasticXsc;
90 } 97 }
91 98
92 ////////////////////////////////////////////// << 99 /////////////////////////////////////////////////////////////////////
93 100
94 G4double G4ComponentGGNuclNuclXsc::GetInelasti << 101 G4double G4ComponentGGNuclNuclXsc::GetInelasticElementCrossSection(const G4ParticleDefinition* aParticle,
95 const G4ParticleDefinition* aParticle << 102 G4double kinEnergy,
96 G4int Z, G4int A) << 103 G4int Z, G4double A)
97 { << 104 {
98 ComputeCrossSections(aParticle, kinEnergy, Z << 105 cacheDP.SetDefinition(aParticle);
>> 106 cacheDP.SetKineticEnergy(kinEnergy);
>> 107 fInelasticXsc = GetZandACrossSection(&cacheDP, Z, G4int(A));
99 return fInelasticXsc; 108 return fInelasticXsc;
100 } 109 }
101 110
102 ////////////////////////////////////////////// 111 //////////////////////////////////////////////////////////////////
103 112
104 G4double G4ComponentGGNuclNuclXsc::GetElasticE << 113 G4double G4ComponentGGNuclNuclXsc::GetElasticElementCrossSection(const G4ParticleDefinition* aParticle,
105 const G4ParticleDefinition* aParticle << 114 G4double kinEnergy,
106 G4int Z, G4double A) << 115 G4int Z, G4double A)
107 { << 116 {
108 ComputeCrossSections(aParticle, kinEnergy, Z << 117 cacheDP.SetDefinition(aParticle);
>> 118 cacheDP.SetKineticEnergy(kinEnergy);
>> 119 fInelasticXsc = GetZandACrossSection(&cacheDP, Z, G4int(A));
109 return fElasticXsc; 120 return fElasticXsc;
110 } 121 }
111 122
112 ////////////////////////////////////////////// 123 ///////////////////////////////////////////////////////////////////
113 124
114 G4double G4ComponentGGNuclNuclXsc::GetElasticI << 125 G4double G4ComponentGGNuclNuclXsc::GetElasticIsotopeCrossSection(const G4ParticleDefinition* aParticle,
115 const G4ParticleDefinition* aParticle << 126 G4double kinEnergy,
116 G4int Z, G4int A) << 127 G4int Z, G4int A)
117 { << 128 {
118 ComputeCrossSections(aParticle, kinEnergy, Z << 129 cacheDP.SetDefinition(aParticle);
>> 130 cacheDP.SetKineticEnergy(kinEnergy);
>> 131 fInelasticXsc = GetZandACrossSection(&cacheDP, Z, A);
119 return fElasticXsc; 132 return fElasticXsc;
120 } 133 }
121 134
122 ////////////////////////////////////////////// 135 ////////////////////////////////////////////////////////////////
123 136
124 G4double G4ComponentGGNuclNuclXsc::ComputeQuas << 137 G4double G4ComponentGGNuclNuclXsc::ComputeQuasiElasticRatio(const G4ParticleDefinition* aParticle,
125 const G4ParticleDefinition* aParticle << 138 G4double kinEnergy,
126 G4int Z, G4int A) << 139 G4int Z, G4int A)
127 { << 140 {
128 ComputeCrossSections(aParticle, kinEnergy, Z << 141 cacheDP.SetDefinition(aParticle);
129 return (fInelasticXsc > fProductionXsc) << 142 cacheDP.SetKineticEnergy(kinEnergy);
130 ? (fInelasticXsc - fProductionXsc)/fInelas << 143 fInelasticXsc = GetZandACrossSection(&cacheDP, Z, A);
131 } << 144 G4double ratio = 0.;
132 145
133 ////////////////////////////////////////////// << 146 if(fInelasticXsc > 0.)
>> 147 {
>> 148 ratio = (fInelasticXsc - fProductionXsc)/fInelasticXsc;
>> 149 if(ratio < 0.) ratio = 0.;
>> 150 }
>> 151 return ratio;
>> 152 }
134 153
135 void G4ComponentGGNuclNuclXsc::BuildPhysicsTab <<
136 {} <<
137 <<
138 ////////////////////////////////////////////// 154 //////////////////////////////////////////////////////////////////////
139 155
140 void G4ComponentGGNuclNuclXsc::DumpPhysicsTabl << 156 void
>> 157 G4ComponentGGNuclNuclXsc::CrossSectionDescription(std::ostream& outFile) const
141 { 158 {
142 G4cout << "G4ComponentGGNuclNuclXsc: uses Gl << 159 outFile << "G4ComponentGGNuclNuclXsc calculates total, inelastic and\n"
>> 160 << "elastic cross sections for nucleus-nucleus collisions using\n"
>> 161 << "the Glauber model with Gribov corrections. It is valid for\n"
>> 162 << "all incident energies above 100 keV./n";
143 } 163 }
144 164
145 ////////////////////////////////////////////// << 165 /////////////////////////////////////////////////////////////////////
146 166
147 void G4ComponentGGNuclNuclXsc::Description(std << 167 G4bool
>> 168 G4ComponentGGNuclNuclXsc::IsElementApplicable(const G4DynamicParticle* aDP,
>> 169 G4int Z, const G4Material*)
148 { 170 {
149 outFile << "G4ComponentGGNuclNuclXsc calcula << 171 G4bool applicable = false;
150 << "elastic cross sections for nucle << 172 G4double kineticEnergy = aDP->GetKineticEnergy();
151 << "the Glauber model with Gribov co << 173
152 << "all incident energies above 100 << 174 if (kineticEnergy >= fLowerLimit && Z > 1) applicable = true;
153 << "For the hydrogen target G4HadronNucleo << 175 return applicable;
>> 176 }
>> 177
>> 178 ///////////////////////////////////////////////////////////////////////////////
>> 179 //
>> 180 // Calculates total and inelastic Xsc, derives elastic as total - inelastic
>> 181 // accordong to Glauber model with Gribov correction calculated in the dipole
>> 182 // approximation on light cone. Gaussian density helps to calculate rest
>> 183 // integrals of the model. [1] B.Z. Kopeliovich, nucl-th/0306044
>> 184
>> 185
>> 186 G4double G4ComponentGGNuclNuclXsc::
>> 187 GetElementCrossSection(const G4DynamicParticle* aParticle, G4int Z,
>> 188 const G4Material*)
>> 189 {
>> 190 G4int A = G4lrint(G4NistManager::Instance()->GetAtomicMassAmu(Z));
>> 191 return GetZandACrossSection(aParticle, Z, A);
154 } 192 }
155 193
156 ////////////////////////////////////////////// 194 ///////////////////////////////////////////////////////////////////////////////
157 // 195 //
158 // Calculates total and inelastic Xsc, derives 196 // Calculates total and inelastic Xsc, derives elastic as total - inelastic
159 // accordong to Glauber model with Gribov corr 197 // accordong to Glauber model with Gribov correction calculated in the dipole
160 // approximation on light cone. Gaussian densi 198 // approximation on light cone. Gaussian density of point-like nucleons helps
161 // to calculate rest integrals of the model. [ 199 // to calculate rest integrals of the model. [1] B.Z. Kopeliovich,
162 // nucl-th/0306044 + simplification above 200 // nucl-th/0306044 + simplification above
163 201
164 void G4ComponentGGNuclNuclXsc::ComputeCrossSec <<
165 const G4ParticleDefinition* aParticle, G4 <<
166 G4int Z, G4int A) <<
167 { <<
168 // check cache <<
169 if(aParticle == fParticle && fZ == Z && fA = <<
170 { return; } <<
171 fParticle = aParticle; <<
172 fZ = Z; <<
173 fA = A; <<
174 fEnergy = kinEnergy; <<
175 G4Pow* pG4Pow = G4Pow::GetInstance(); <<
176 <<
177 G4int pZ = G4lrint(aParticle->GetPDGCharge() <<
178 G4int pA = aParticle->GetBaryonNumber(); <<
179 G4int pL = aParticle->GetNumberOfLambdasInHy <<
180 G4bool pHN = aParticle->IsHypernucleus(); <<
181 G4double cHN(0.88); <<
182 <<
183 // hydrogen <<
184 if(1 == Z && 1 == A) { <<
185 G4double e = kinEnergy*CLHEP::proton_mass_ <<
186 fHadrNucl->ComputeCrossSections( theProton <<
187 fTotalXsc = fHadrNucl->GetTotalGlauberGrib <<
188 fElasticXsc = fHadrNucl->GetElasticGlauber <<
189 fInelasticXsc = fHadrNucl->GetInelasticGla <<
190 fProductionXsc = fHadrNucl->GetProductionG <<
191 fDiffractionXsc = fHadrNucl->GetDiffractio <<
192 return; <<
193 } <<
194 static const G4double cofInelastic = 2.4; <<
195 static const G4double cofTotal = 2.0; <<
196 202
197 G4double pTkin = kinEnergy/(G4double)pA; << 203 G4double G4ComponentGGNuclNuclXsc::
>> 204 GetZandACrossSection(const G4DynamicParticle* aParticle,
>> 205 G4int tZ, G4int tA)
>> 206 {
>> 207 G4double xsection;
>> 208 G4double sigma;
>> 209 G4double cofInelastic = 2.4;
>> 210 G4double cofTotal = 2.0;
>> 211 G4double nucleusSquare;
>> 212 G4double cB;
>> 213 G4double ratio;
>> 214
>> 215 G4double pZ = aParticle->GetDefinition()->GetPDGCharge();
>> 216 G4double pA = aParticle->GetDefinition()->GetBaryonNumber();
>> 217
>> 218 G4double pTkin = aParticle->GetKineticEnergy();
>> 219 pTkin /= pA;
>> 220
>> 221 G4double pN = pA - pZ;
>> 222 if( pN < 0. ) pN = 0.;
198 223
199 G4int pN = pA - pZ; << 224 G4double tN = tA - tZ;
200 G4int tN = A - Z; << 225 if( tN < 0. ) tN = 0.;
201 226
202 G4double tR = G4NuclearRadii::Radius(Z, A); << 227 G4double tR = GetNucleusRadius( G4double(tZ),G4double(tA) );
203 G4double pR = G4NuclearRadii::Radius(pZ, pA) << 228 G4double pR = GetNucleusRadius(pZ,pA);
204 << 229
205 if(pHN) << 230 cB = GetCoulombBarier(aParticle, G4double(tZ), G4double(tA), pR, tR);
206 pR *= std::sqrt( pG4Pow->Z23( pA - pL ) + <<
207 <<
208 G4double cB = ComputeCoulombBarier(aParticle <<
209 231
210 if ( cB > 0. ) 232 if ( cB > 0. )
211 { 233 {
212 G4double sigma = (pZ*Z+pN*tN)*fHNXsc->Hadr << 234 dProton.SetKineticEnergy(pTkin);
213 if(pHN) sigma += pL*A*fHNXsc->HadronNucleo << 235 dNeutron.SetKineticEnergy(pTkin);
214 G4double ppInXsc = fHNXsc->GetInelasticHad << 236
215 << 237 sigma = (pZ*tZ+pN*tN)*hnXsc->GetHadronNucleonXscNS(&dProton, theProton);
216 sigma += (pZ*tN+pN*Z)*fHNXsc->HadronNucleo << 238
217 G4double npInXsc = fHNXsc->GetInelasticHad << 239 G4double ppInXsc = hnXsc->GetInelasticHadronNucleonXsc();
218 << 240
219 G4double nucleusSquare = cofTotal*CLHEP::p << 241 sigma += (pZ*tN+pN*tZ)*hnXsc->GetHadronNucleonXscNS(&dNeutron, theProton);
220 << 242
221 G4double ratio= sigma/nucleusSquare; << 243 G4double npInXsc = hnXsc->GetInelasticHadronNucleonXsc();
222 fTotalXsc = nucleusSquare*G4Log( 1. + << 244
223 fInelasticXsc = nucleusSquare*G4Log( 1. + << 245 // G4cout<<"ppInXsc = "<<ppInXsc/millibarn<<"; npInXsc = "<<npInXsc/millibarn<<G4endl;
224 fElasticXsc = std::max(fTotalXsc - fInel << 246 // G4cout<<"npTotXsc = "<<hnXsc->GetTotalHadronNucleonXsc()/millibarn<<"; npElXsc = "
>> 247 // <<hnXsc->GetElasticHadronNucleonXsc()/millibarn<<G4endl;
225 248
>> 249 nucleusSquare = cofTotal*pi*( pR*pR + tR*tR ); // basically 2piRR
>> 250
>> 251 ratio = sigma/nucleusSquare;
>> 252 xsection = nucleusSquare*G4Log( 1. + ratio );
>> 253 fTotalXsc = xsection;
>> 254 fTotalXsc *= cB;
>> 255
>> 256 fInelasticXsc = nucleusSquare*G4Log( 1. + cofInelastic*ratio )/cofInelastic;
>> 257
>> 258 fInelasticXsc *= cB;
>> 259 fElasticXsc = fTotalXsc - fInelasticXsc;
>> 260
>> 261 // if (fElasticXsc < DBL_MIN) fElasticXsc = DBL_MIN;
>> 262 /*
226 G4double difratio = ratio/(1.+ratio); 263 G4double difratio = ratio/(1.+ratio);
>> 264
227 fDiffractionXsc = 0.5*nucleusSquare*( difr 265 fDiffractionXsc = 0.5*nucleusSquare*( difratio - G4Log( 1. + difratio ) );
>> 266 */
>> 267 // production to be checked !!! edit MK xsc
>> 268
>> 269 //sigma = (pZ*tZ+pN*tN)*GetHadronNucleonXscMK(theProton, pTkin, theProton) +
>> 270 // (pZ*tN+pN*tZ)*GetHadronNucleonXscMK(theProton, pTkin, theNeutron);
>> 271
>> 272 sigma = (pZ*tZ+pN*tN)*ppInXsc + (pZ*tN+pN*tZ)*npInXsc;
>> 273
>> 274 ratio = sigma/nucleusSquare;
>> 275 fProductionXsc = nucleusSquare*G4Log( 1. + cofInelastic*ratio )/cofInelastic;
228 276
229 G4double xratio= ((pZ*Z+pN*tN)*ppInXsc + ( << 277 if (fElasticXsc < 0.) fElasticXsc = 0.;
230 fProductionXsc = nucleusSquare*G4Log( 1. + <<
231 fProductionXsc = std::min(fProductionXsc, <<
232 } 278 }
233 else 279 else
234 { 280 {
235 fInelasticXsc = fTotalXsc = fElasticXsc = << 281 fInelasticXsc = 0.;
>> 282 fTotalXsc = 0.;
>> 283 fElasticXsc = 0.;
>> 284 fProductionXsc = 0.;
236 } 285 }
>> 286 return fInelasticXsc; // xsection;
237 } 287 }
238 288
239 ////////////////////////////////////////////// 289 ///////////////////////////////////////////////////////////////////////////////
>> 290 //
>> 291 //
240 292
241 G4double G4ComponentGGNuclNuclXsc::ComputeCoul << 293 G4double G4ComponentGGNuclNuclXsc::
242 const G4ParticleDefinitio << 294 GetCoulombBarier(const G4DynamicParticle* aParticle, G4double tZ, G4double tA,
243 G4double pTkin, G4int Z, G4int A, << 295 G4double pR, G4double tR)
244 G4double pR, G4double tR) << 296 {
245 { << 297 G4double ratio;
246 G4int pZ = aParticle->GetPDGCharge()*inve; << 298 G4double pZ = aParticle->GetDefinition()->GetPDGCharge();
247 G4double pM = aParticle->GetPDGMass(); << 299
248 G4double tM = G4NucleiProperties::GetNuclear << 300 G4double pTkin = aParticle->GetKineticEnergy();
>> 301 // G4double pPlab = aParticle->GetTotalMomentum();
>> 302 G4double pM = aParticle->GetDefinition()->GetPDGMass();
>> 303 // G4double tM = tZ*proton_mass_c2 + (tA-tZ)*neutron_mass_c2; // ~ 1% accuracy
>> 304 G4double tM = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass( G4int(tZ), G4int(tA) );
249 G4double pElab = pTkin + pM; 305 G4double pElab = pTkin + pM;
250 G4double totEcm = std::sqrt(pM*pM + tM*tM + << 306 G4double totEcm = std::sqrt(pM*pM + tM*tM + 2.*pElab*tM);
251 G4double totTcm = totEcm - pM -tM; << 307 // G4double pPcm = pPlab*tM/totEcm;
>> 308 // G4double pTcm = std::sqrt(pM*pM + pPcm*pPcm) - pM;
>> 309 G4double totTcm = totEcm - pM -tM;
252 310
253 // 0.5 defines shape of Cross section correc << 311 G4double bC = fine_structure_const*hbarc*pZ*tZ;
254 // at cB = totTcm it become zero << 312 bC /= pR + tR;
255 static const G4double qfact = 0.5*CLHEP::elm << 313 bC /= 2.; // 4., 2. parametrisation cof ??? vmg
256 G4double bC = qfact*pZ*Z/(pR + tR); << 314
257 << 315 // G4cout<<"pTkin = "<<pTkin/GeV<<"; pPlab = "
258 G4double ratio = (totTcm <= bC) ? 0. : 1. - << 316 // <<pPlab/GeV<<"; bC = "<<bC/GeV<<"; pTcm = "<<pTcm/GeV<<G4endl;
259 << 317
260 #ifdef G4VERBOSE << 318 if( totTcm <= bC ) ratio = 0.;
261 if (GetVerboseLevel() > 1) { << 319 else ratio = 1. - bC/totTcm;
262 G4cout << "G4ComponentGGNuclNuclXsc::Compu << 320
263 << "; pTkin(GeV)=" << pTkin/CLHEP::MeV << 321 // if(ratio < DBL_MIN) ratio = DBL_MIN;
264 << " totTcm= " << totTcm/CLHEP::MeV<< "; << 322 if( ratio < 0.) ratio = 0.;
265 << G4endl; << 323
266 } << 324 // G4cout <<"ratio = "<<ratio<<G4endl;
267 #endif <<
268 return ratio; 325 return ratio;
269 } 326 }
270 327
>> 328
271 ////////////////////////////////////////////// 329 //////////////////////////////////////////////////////////////////////////
272 // 330 //
273 // Return single-diffraction/inelastic cross-s 331 // Return single-diffraction/inelastic cross-section ratio
274 332
275 G4double G4ComponentGGNuclNuclXsc::GetRatioSD( << 333 G4double G4ComponentGGNuclNuclXsc::
276 const G4DynamicParticle* aParticle, G << 334 GetRatioSD(const G4DynamicParticle* aParticle, G4double tA, G4double tZ)
277 { 335 {
278 ComputeCrossSections(aParticle->GetDefinitio << 336 G4double sigma, cofInelastic = 2.4, cofTotal = 2.0, nucleusSquare, ratio;
279 aParticle->GetKineticEn << 337
280 G4lrint(tZ), G4lrint(tA)); << 338 G4double pZ = aParticle->GetDefinition()->GetPDGCharge();
>> 339 G4double pA = aParticle->GetDefinition()->GetBaryonNumber();
>> 340
>> 341 G4double pTkin = aParticle->GetKineticEnergy();
>> 342 pTkin /= pA;
>> 343
>> 344 G4double pN = pA - pZ;
>> 345 if( pN < 0. ) pN = 0.;
>> 346
>> 347 G4double tN = tA - tZ;
>> 348 if( tN < 0. ) tN = 0.;
>> 349
>> 350 G4double tR = GetNucleusRadius(tZ,tA);
>> 351 G4double pR = GetNucleusRadius(pZ,pA);
281 352
282 return (fInelasticXsc > 0.0) ? fDiffractionX << 353 sigma = (pZ*tZ+pN*tN)*GetHadronNucleonXscNS(theProton, pTkin, theProton) +
>> 354 (pZ*tN+pN*tZ)*GetHadronNucleonXscNS(theProton, pTkin, theNeutron);
>> 355
>> 356 nucleusSquare = cofTotal*pi*( pR*pR + tR*tR ); // basically 2piRR
>> 357 ratio = sigma/nucleusSquare;
>> 358 fInelasticXsc = nucleusSquare*G4Log(1. + cofInelastic*ratio)/cofInelastic;
>> 359 G4double difratio = ratio/(1.+ratio);
>> 360
>> 361 fDiffractionXsc = 0.5*nucleusSquare*( difratio - G4Log( 1. + difratio ) );
>> 362
>> 363 if (fInelasticXsc > 0.) ratio = fDiffractionXsc/fInelasticXsc;
>> 364 else ratio = 0.;
>> 365
>> 366 return ratio;
283 } 367 }
284 368
285 ////////////////////////////////////////////// 369 //////////////////////////////////////////////////////////////////////////
286 // 370 //
287 // Return quasi-elastic/inelastic cross-sectio 371 // Return quasi-elastic/inelastic cross-section ratio
288 372
289 G4double G4ComponentGGNuclNuclXsc::GetRatioQE( << 373 G4double G4ComponentGGNuclNuclXsc::
290 const G4DynamicParticle* aParticle, G << 374 GetRatioQE(const G4DynamicParticle* aParticle, G4double tA, G4double tZ)
>> 375 {
>> 376 G4double sigma, cofInelastic = 2.4, cofTotal = 2.0, nucleusSquare, ratio;
>> 377
>> 378 G4double pZ = aParticle->GetDefinition()->GetPDGCharge();
>> 379 G4double pA = aParticle->GetDefinition()->GetBaryonNumber();
>> 380
>> 381 G4double pTkin = aParticle->GetKineticEnergy();
>> 382 pTkin /= pA;
>> 383
>> 384 G4double pN = pA - pZ;
>> 385 if( pN < 0. ) pN = 0.;
>> 386
>> 387 G4double tN = tA - tZ;
>> 388 if( tN < 0. ) tN = 0.;
>> 389
>> 390 G4double tR = GetNucleusRadius(tZ,tA);
>> 391 G4double pR = GetNucleusRadius(pZ,pA);
>> 392
>> 393 sigma = (pZ*tZ+pN*tN)*GetHadronNucleonXscNS(theProton, pTkin, theProton) +
>> 394 (pZ*tN+pN*tZ)*GetHadronNucleonXscNS(theProton, pTkin, theNeutron);
>> 395
>> 396 nucleusSquare = cofTotal*pi*( pR*pR + tR*tR ); // basically 2piRR
>> 397 ratio = sigma/nucleusSquare;
>> 398 fInelasticXsc = nucleusSquare*G4Log(1. + cofInelastic*ratio)/cofInelastic;
>> 399
>> 400 // sigma = GetHNinelasticXsc(aParticle, tA, tZ);
>> 401 ratio = sigma/nucleusSquare;
>> 402 fProductionXsc = nucleusSquare*G4Log(1. + cofInelastic*ratio)/cofInelastic;
>> 403
>> 404 if (fInelasticXsc > fProductionXsc) ratio = (fInelasticXsc-fProductionXsc)/fInelasticXsc;
>> 405 else ratio = 0.;
>> 406 if ( ratio < 0. ) ratio = 0.;
>> 407
>> 408 return ratio;
>> 409 }
>> 410
>> 411 ///////////////////////////////////////////////////////////////////////////////
>> 412 //
>> 413 // Returns hadron-nucleon Xsc according to differnt parametrisations:
>> 414 // [2] E. Levin, hep-ph/9710546
>> 415 // [3] U. Dersch, et al, hep-ex/9910052
>> 416 // [4] M.J. Longo, et al, Phys.Rev.Lett. 33 (1974) 725
>> 417
>> 418 G4double
>> 419 G4ComponentGGNuclNuclXsc::GetHadronNucleonXsc(const G4DynamicParticle* aParticle,
>> 420 const G4Element* anElement)
>> 421 {
>> 422 G4int At = G4lrint(anElement->GetN()); // number of nucleons
>> 423 G4int Zt = G4lrint(anElement->GetZ()); // number of protons
>> 424 return GetHadronNucleonXsc(aParticle, At, Zt);
>> 425 }
>> 426
>> 427
>> 428
>> 429
>> 430 ///////////////////////////////////////////////////////////////////////////////
>> 431 //
>> 432 // Returns hadron-nucleon Xsc according to differnt parametrisations:
>> 433 // [2] E. Levin, hep-ph/9710546
>> 434 // [3] U. Dersch, et al, hep-ex/9910052
>> 435 // [4] M.J. Longo, et al, Phys.Rev.Lett. 33 (1974) 725
>> 436
>> 437 G4double
>> 438 G4ComponentGGNuclNuclXsc::GetHadronNucleonXsc(const G4DynamicParticle* aParticle,
>> 439 G4int At, G4int Zt)
>> 440 {
>> 441 G4double xsection = 0.;
>> 442
>> 443 G4double targ_mass = G4ParticleTable::GetParticleTable()->
>> 444 GetIonTable()->GetIonMass(Zt, At);
>> 445 targ_mass = 0.939*GeV; // ~mean neutron and proton ???
>> 446
>> 447 G4double proj_mass = aParticle->GetMass();
>> 448 G4double proj_momentum = aParticle->GetMomentum().mag();
>> 449 G4double sMand = CalcMandelstamS ( proj_mass , targ_mass , proj_momentum );
>> 450
>> 451 sMand /= GeV*GeV; // in GeV for parametrisation
>> 452 proj_momentum /= GeV;
>> 453 const G4ParticleDefinition* pParticle = aParticle->GetDefinition();
>> 454
>> 455 if(pParticle == theNeutron) // as proton ???
>> 456 {
>> 457 xsection = G4double(At)*(21.70*G4Pow::GetInstance()->powA(sMand,0.0808) + 56.08*G4Pow::GetInstance()->powA(sMand,-0.4525));
>> 458 }
>> 459 else if(pParticle == theProton)
>> 460 {
>> 461 xsection = G4double(At)*(21.70*G4Pow::GetInstance()->powA(sMand,0.0808) + 56.08*G4Pow::GetInstance()->powA(sMand,-0.4525));
>> 462 }
>> 463
>> 464 xsection *= millibarn;
>> 465 return xsection;
>> 466 }
>> 467
>> 468
>> 469
>> 470 ///////////////////////////////////////////////////////////////////////////////
>> 471 //
>> 472 // Returns hadron-nucleon Xsc according to PDG parametrisation (2005):
>> 473 // http://pdg.lbl.gov/2006/reviews/hadronicrpp.pdf
>> 474 // At = number of nucleons, Zt = number of protons
>> 475
>> 476 G4double
>> 477 G4ComponentGGNuclNuclXsc::GetHadronNucleonXscPDG(const G4ParticleDefinition* pParticle,
>> 478 G4double sMand,
>> 479 const G4ParticleDefinition* tParticle)
>> 480 {
>> 481 G4double xsection = 0.;
>> 482 // G4bool pORn = (tParticle == theProton || nucleon == theNeutron );
>> 483 G4bool proton = (tParticle == theProton);
>> 484 G4bool neutron = (tParticle == theNeutron);
>> 485
>> 486 // General PDG fit constants
>> 487
>> 488 G4double s0 = 5.38*5.38; // in Gev^2
>> 489 G4double eta1 = 0.458;
>> 490 G4double eta2 = 0.458;
>> 491 G4double B = 0.308;
>> 492
>> 493 // const G4ParticleDefinition* pParticle = aParticle->GetDefinition();
>> 494
>> 495 if(pParticle == theNeutron) // proton-neutron fit
>> 496 {
>> 497 if ( proton )
>> 498 {
>> 499 xsection = ( 35.80 + B*G4Pow::GetInstance()->powA(G4Log(sMand/s0),2.)
>> 500 + 40.15*G4Pow::GetInstance()->powA(sMand,-eta1) - 30.*G4Pow::GetInstance()->powA(sMand,-eta2));
>> 501 }
>> 502 if ( neutron )
>> 503 {
>> 504 xsection = (35.45 + B*G4Pow::GetInstance()->powA(G4Log(sMand/s0),2.)
>> 505 + 42.53*G4Pow::GetInstance()->powA(sMand,-eta1) - 33.34*G4Pow::GetInstance()->powA(sMand,-eta2)); // pp for nn
>> 506 }
>> 507 }
>> 508 else if(pParticle == theProton)
>> 509 {
>> 510 if ( proton )
>> 511 {
>> 512 xsection = (35.45 + B*G4Pow::GetInstance()->powA(G4Log(sMand/s0),2.)
>> 513 + 42.53*G4Pow::GetInstance()->powA(sMand,-eta1) - 33.34*G4Pow::GetInstance()->powA(sMand,-eta2));
>> 514
>> 515 }
>> 516 if ( neutron )
>> 517 {
>> 518 xsection = (35.80 + B*G4Pow::GetInstance()->powA(G4Log(sMand/s0),2.)
>> 519 + 40.15*G4Pow::GetInstance()->powA(sMand,-eta1) - 30.*G4Pow::GetInstance()->powA(sMand,-eta2));
>> 520 }
>> 521 }
>> 522 xsection *= millibarn; // parametrised in mb
>> 523 return xsection;
>> 524 }
>> 525
>> 526
>> 527 ///////////////////////////////////////////////////////////////////////////////
>> 528 //
>> 529 // Returns nucleon-nucleon cross-section based on N. Starkov parametrisation of
>> 530 // data from mainly http://wwwppds.ihep.su:8001/c5-6A.html database
>> 531 // projectile nucleon is pParticle with pTkin shooting target nucleon tParticle
>> 532
>> 533 G4double
>> 534 G4ComponentGGNuclNuclXsc::GetHadronNucleonXscNS(const G4ParticleDefinition* pParticle,
>> 535 G4double pTkin,
>> 536 const G4ParticleDefinition* tParticle)
>> 537 {
>> 538 G4double xsection(0);
>> 539 // G4double Delta; DHW 19 May 2011: variable set but not used
>> 540 G4double A0, B0;
>> 541 G4double hpXscv(0);
>> 542 G4double hnXscv(0);
>> 543
>> 544 G4double targ_mass = tParticle->GetPDGMass();
>> 545 G4double proj_mass = pParticle->GetPDGMass();
>> 546
>> 547 G4double proj_energy = proj_mass + pTkin;
>> 548 G4double proj_momentum = std::sqrt(pTkin*(pTkin+2*proj_mass));
>> 549
>> 550 G4double sMand = CalcMandelstamS ( proj_mass , targ_mass , proj_momentum );
>> 551
>> 552 sMand /= GeV*GeV; // in GeV for parametrisation
>> 553 proj_momentum /= GeV;
>> 554 proj_energy /= GeV;
>> 555 proj_mass /= GeV;
>> 556
>> 557 // General PDG fit constants
>> 558
>> 559 // G4double s0 = 5.38*5.38; // in Gev^2
>> 560 // G4double eta1 = 0.458;
>> 561 // G4double eta2 = 0.458;
>> 562 // G4double B = 0.308;
>> 563
>> 564 if( proj_momentum >= 373.)
>> 565 {
>> 566 return GetHadronNucleonXscPDG(pParticle,sMand,tParticle);
>> 567 }
>> 568 else if( proj_momentum >= 10. ) // high energy: pp = nn = np
>> 569 // if( proj_momentum >= 2.)
>> 570 {
>> 571 // Delta = 1.; // DHW 19 May 2011: variable set but not used
>> 572 // if (proj_energy < 40.) Delta = 0.916+0.0021*proj_energy;
>> 573
>> 574 //AR-12Aug2016 if (proj_momentum >= 10.) {
>> 575 B0 = 7.5;
>> 576 A0 = 100. - B0*G4Log(3.0e7);
>> 577
>> 578 xsection = A0 + B0*G4Log(proj_energy) - 11
>> 579 + 103*G4Pow::GetInstance()->powA(2*0.93827*proj_energy + proj_mass*proj_mass+
>> 580 0.93827*0.93827,-0.165); // mb
>> 581 //AR-12Aug2016 }
>> 582 }
>> 583 else // low energy pp = nn != np
>> 584 {
>> 585 if(pParticle == tParticle) // pp or nn // nn to be pp
>> 586 {
>> 587 if( proj_momentum < 0.73 )
>> 588 {
>> 589 hnXscv = 23 + 50*( G4Pow::GetInstance()->powA( G4Log(0.73/proj_momentum), 3.5 ) );
>> 590 }
>> 591 else if( proj_momentum < 1.05 )
>> 592 {
>> 593 hnXscv = 23 + 40*(G4Log(proj_momentum/0.73))*
>> 594 (G4Log(proj_momentum/0.73));
>> 595 }
>> 596 else // if( proj_momentum < 10. )
>> 597 {
>> 598 hnXscv = 39.0 +
>> 599 75*(proj_momentum - 1.2)/(G4Pow::GetInstance()->powA(proj_momentum,3.0) + 0.15);
>> 600 }
>> 601 xsection = hnXscv;
>> 602 }
>> 603 else // pn to be np
>> 604 {
>> 605 if( proj_momentum < 0.8 )
>> 606 {
>> 607 hpXscv = 33+30*G4Pow::GetInstance()->powA(G4Log(proj_momentum/1.3),4.0);
>> 608 }
>> 609 else if( proj_momentum < 1.4 )
>> 610 {
>> 611 hpXscv = 33+30*G4Pow::GetInstance()->powA(G4Log(proj_momentum/0.95),2.0);
>> 612 }
>> 613 else // if( proj_momentum < 10. )
>> 614 {
>> 615 hpXscv = 33.3+
>> 616 20.8*(G4Pow::GetInstance()->powA(proj_momentum,2.0)-1.35)/
>> 617 (G4Pow::GetInstance()->powA(proj_momentum,2.50)+0.95);
>> 618 }
>> 619 xsection = hpXscv;
>> 620 }
>> 621 }
>> 622 xsection *= millibarn; // parametrised in mb
>> 623 return xsection;
>> 624 }
>> 625
>> 626 /////////////////////////////////////////////////////////////////////////////////
>> 627 //
>> 628 // Returns hadron-nucleon inelastic cross-section based on FTF-parametrisation
>> 629
>> 630 G4double
>> 631 G4ComponentGGNuclNuclXsc::GetHNinelasticXscVU(const G4DynamicParticle* aParticle,
>> 632 G4int At, G4int Zt)
>> 633 {
>> 634 G4int PDGcode = aParticle->GetDefinition()->GetPDGEncoding();
>> 635 G4int absPDGcode = std::abs(PDGcode);
>> 636 G4double Elab = aParticle->GetTotalEnergy();
>> 637 // (s - 2*0.88*GeV*GeV)/(2*0.939*GeV)/GeV;
>> 638 G4double Plab = aParticle->GetMomentum().mag();
>> 639 // std::sqrt(Elab * Elab - 0.88);
>> 640
>> 641 Elab /= GeV;
>> 642 Plab /= GeV;
>> 643
>> 644 G4double LogPlab = G4Log( Plab );
>> 645 G4double sqrLogPlab = LogPlab * LogPlab;
>> 646
>> 647 //G4cout<<"Plab = "<<Plab<<G4endl;
>> 648
>> 649 G4double NumberOfTargetProtons = Zt;
>> 650 G4double NumberOfTargetNucleons = At;
>> 651 G4double NumberOfTargetNeutrons = NumberOfTargetNucleons - NumberOfTargetProtons;
>> 652
>> 653 if(NumberOfTargetNeutrons < 0.) NumberOfTargetNeutrons = 0.;
>> 654
>> 655 G4double Xtotal = 0., Xelastic = 0., Xinelastic =0.;
>> 656
>> 657 if( absPDGcode > 1000 ) //------Projectile is baryon --------
>> 658 {
>> 659 G4double XtotPP = 48.0 + 0. *G4Pow::GetInstance()->powA(Plab, 0. ) +
>> 660 0.522*sqrLogPlab - 4.51*LogPlab;
>> 661
>> 662 G4double XtotPN = 47.3 + 0. *G4Pow::GetInstance()->powA(Plab, 0. ) +
>> 663 0.513*sqrLogPlab - 4.27*LogPlab;
>> 664
>> 665 G4double XelPP = 11.9 + 26.9*G4Pow::GetInstance()->powA(Plab,-1.21) +
>> 666 0.169*sqrLogPlab - 1.85*LogPlab;
>> 667
>> 668 G4double XelPN = 11.9 + 26.9*G4Pow::GetInstance()->powA(Plab,-1.21) +
>> 669 0.169*sqrLogPlab - 1.85*LogPlab;
>> 670
>> 671 Xtotal = ( NumberOfTargetProtons * XtotPP +
>> 672 NumberOfTargetNeutrons * XtotPN );
>> 673
>> 674 Xelastic = ( NumberOfTargetProtons * XelPP +
>> 675 NumberOfTargetNeutrons * XelPN );
>> 676 }
>> 677
>> 678 Xinelastic = Xtotal - Xelastic;
>> 679 if(Xinelastic < 0.) Xinelastic = 0.;
>> 680
>> 681 return Xinelastic*= millibarn;
>> 682 }
>> 683
>> 684 ///////////////////////////////////////////////////////////////////////////////
>> 685 //
>> 686 //
>> 687
>> 688 G4double
>> 689 G4ComponentGGNuclNuclXsc::GetNucleusRadius(const G4DynamicParticle* ,
>> 690 const G4Element* anElement)
>> 691 {
>> 692 G4double At = anElement->GetN();
>> 693 G4double oneThird = 1.0/3.0;
>> 694 G4double cubicrAt = G4Pow::GetInstance()->powA (At, oneThird);
>> 695
>> 696 G4double R; // = fRadiusConst*cubicrAt;
>> 697 R = fRadiusConst*cubicrAt;
>> 698
>> 699 G4double meanA = 21.;
>> 700 G4double tauA1 = 40.;
>> 701 G4double tauA2 = 10.;
>> 702 G4double tauA3 = 5.;
>> 703
>> 704 G4double a1 = 0.85;
>> 705 G4double b1 = 1. - a1;
>> 706
>> 707 G4double b2 = 0.3;
>> 708 G4double b3 = 4.;
>> 709
>> 710 if (At > 20.) // 20.
>> 711 {
>> 712 R *= ( a1 + b1*G4Exp( -(At - meanA)/tauA1) );
>> 713 }
>> 714 else if (At > 3.5)
>> 715 {
>> 716 R *= ( 1.0 + b2*( 1. - G4Exp( (At - meanA)/tauA2) ) );
>> 717 }
>> 718 else
>> 719 {
>> 720 R *= ( 1.0 + b3*( 1. - G4Exp( (At - meanA)/tauA3) ) );
>> 721 }
>> 722
>> 723 return R;
>> 724 }
>> 725
>> 726 ///////////////////////////////////////////////////////////////////////////////
>> 727 //
>> 728 //
>> 729
>> 730 G4double
>> 731 G4ComponentGGNuclNuclXsc::GetNucleusRadius(G4double Zt, G4double At)
>> 732 {
>> 733 G4double R;
>> 734 R = GetNucleusRadiusDE(Zt,At);
>> 735 // R = GetNucleusRadiusRMS(Zt,At);
>> 736
>> 737 return R;
>> 738 }
>> 739
>> 740 ///////////////////////////////////////////////////////////////////
>> 741
>> 742 G4double
>> 743 G4ComponentGGNuclNuclXsc::GetNucleusRadiusGG(G4double At)
>> 744 {
>> 745 G4double oneThird = 1.0/3.0;
>> 746 G4double cubicrAt = G4Pow::GetInstance()->powA (At, oneThird);
>> 747
>> 748 G4double R; // = fRadiusConst*cubicrAt;
>> 749 R = fRadiusConst*cubicrAt;
>> 750
>> 751 G4double meanA = 20.;
>> 752 G4double tauA = 20.;
>> 753
>> 754 if ( At > 20.) // 20.
>> 755 {
>> 756 R *= ( 0.8 + 0.2*G4Exp( -(At - meanA)/tauA) );
>> 757 }
>> 758 else
>> 759 {
>> 760 R *= ( 1.0 + 0.1*( 1. - G4Exp( (At - meanA)/tauA) ) );
>> 761 }
>> 762
>> 763 return R;
>> 764 }
>> 765
>> 766 /////////////////////////////////////////////////////////////////////////////
>> 767 //
>> 768 //
>> 769
>> 770 G4double
>> 771 G4ComponentGGNuclNuclXsc::GetNucleusRadiusDE(G4double Z, G4double A)
>> 772 {
>> 773 // algorithm from diffuse-elastic
>> 774
>> 775 G4double R, r0, a11, a12, a13, a2, a3;
>> 776
>> 777 a11 = 1.26; // 1.08, 1.16
>> 778 a12 = 1.; // 1.08, 1.16
>> 779 a13 = 1.12; // 1.08, 1.16
>> 780 a2 = 1.1;
>> 781 a3 = 1.;
>> 782
>> 783 // Special rms radii for light nucleii
>> 784
>> 785 if (A < 50.)
>> 786 {
>> 787 if (std::abs(A-1.) < 0.5) return 0.89*fermi; // p
>> 788 else if(std::abs(A-2.) < 0.5) return 2.13*fermi; // d
>> 789 else if(std::abs(Z-1.) < 0.5 && std::abs(A-3.) < 0.5) return 1.80*fermi; // t
>> 790
>> 791 else if(std::abs(Z-2.) < 0.5 && std::abs(A-3.) < 0.5) return 1.96*fermi; // He3
>> 792 else if(std::abs(Z-2.) < 0.5 && std::abs(A-4.) < 0.5) return 1.68*fermi; // He4
>> 793
>> 794 else if(std::abs(Z-3.) < 0.5) return 2.40*fermi; // Li7
>> 795 else if(std::abs(Z-4.) < 0.5) return 2.51*fermi; // Be9
>> 796
>> 797 else if( 10. < A && A <= 16. ) r0 = a11*( 1 - G4Pow::GetInstance()->powA(A, -2./3.) )*fermi; // 1.08*fermi;
>> 798 else if( 15. < A && A <= 20. ) r0 = a12*( 1 - G4Pow::GetInstance()->powA(A, -2./3.) )*fermi;
>> 799 else if( 20. < A && A <= 30. ) r0 = a13*( 1 - G4Pow::GetInstance()->powA(A, -2./3.) )*fermi;
>> 800 else r0 = a2*fermi;
>> 801
>> 802 R = r0*G4Pow::GetInstance()->powA( A, 1./3. );
>> 803 }
>> 804 else
>> 805 {
>> 806 r0 = a3*fermi;
>> 807
>> 808 R = r0*G4Pow::GetInstance()->powA(A, 0.27);
>> 809 }
>> 810 return R;
>> 811 }
>> 812
>> 813
>> 814 /////////////////////////////////////////////////////////////////////////////
>> 815 //
>> 816 // RMS radii from e-A scattering data
>> 817
>> 818 G4double
>> 819 G4ComponentGGNuclNuclXsc::GetNucleusRadiusRMS(G4double Z, G4double A)
291 { 820 {
292 ComputeCrossSections(aParticle->GetDefinitio <<
293 aParticle->GetKineticEn <<
294 G4lrint(tZ), G4lrint(tA)); <<
295 821
296 return (fInelasticXsc > 0.0) ? 1.0 - fProduc << 822 if (std::abs(A-1.) < 0.5) return 0.89*fermi; // p
>> 823 else if(std::abs(A-2.) < 0.5) return 2.13*fermi; // d
>> 824 else if(std::abs(Z-1.) < 0.5 && std::abs(A-3.) < 0.5) return 1.80*fermi; // t
>> 825
>> 826 else if(std::abs(Z-2.) < 0.5 && std::abs(A-3.) < 0.5) return 1.96*fermi; // He3
>> 827 else if(std::abs(Z-2.) < 0.5 && std::abs(A-4.) < 0.5) return 1.68*fermi; // He4
>> 828
>> 829 else if(std::abs(Z-3.) < 0.5) return 2.40*fermi; // Li7
>> 830 else if(std::abs(Z-4.) < 0.5) return 2.51*fermi; // Be9
>> 831
>> 832 else return 1.24*G4Pow::GetInstance()->powA(A, 0.28 )*fermi; // A > 9
297 } 833 }
298 834
>> 835
>> 836 ///////////////////////////////////////////////////////////////////////////////
>> 837 //
>> 838 //
>> 839
>> 840 G4double G4ComponentGGNuclNuclXsc::CalculateEcmValue(const G4double mp,
>> 841 const G4double mt,
>> 842 const G4double Plab)
>> 843 {
>> 844 G4double Elab = std::sqrt ( mp * mp + Plab * Plab );
>> 845 G4double Ecm = std::sqrt ( mp * mp + mt * mt + 2 * Elab * mt );
>> 846 // G4double Pcm = Plab * mt / Ecm;
>> 847 // G4double KEcm = std::sqrt ( Pcm * Pcm + mp * mp ) - mp;
>> 848
>> 849 return Ecm ; // KEcm;
>> 850 }
>> 851
>> 852
>> 853 ///////////////////////////////////////////////////////////////////////////////
>> 854 //
>> 855 //
>> 856
>> 857 G4double G4ComponentGGNuclNuclXsc::CalcMandelstamS(const G4double mp,
>> 858 const G4double mt,
>> 859 const G4double Plab)
>> 860 {
>> 861 G4double Elab = std::sqrt ( mp * mp + Plab * Plab );
>> 862 G4double sMand = mp*mp + mt*mt + 2*Elab*mt ;
>> 863
>> 864 return sMand;
>> 865 }
>> 866
>> 867 //
>> 868 //
299 ////////////////////////////////////////////// 869 ///////////////////////////////////////////////////////////////////////////////
300 870