| 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 28 // 04.09.18 V. Ivantchenko Major revision of interfaces and implementation
29 // 27.05.19 V. Ivantchenko Removed obsolete me 29 // 27.05.19 V. Ivantchenko Removed obsolete methods and members
30 30
31 #include "G4ComponentGGNuclNuclXsc.hh" 31 #include "G4ComponentGGNuclNuclXsc.hh"
32 32
33 #include "G4PhysicalConstants.hh" 33 #include "G4PhysicalConstants.hh"
34 #include "G4SystemOfUnits.hh" 34 #include "G4SystemOfUnits.hh"
35 #include "G4NucleiProperties.hh" 35 #include "G4NucleiProperties.hh"
36 #include "G4ParticleDefinition.hh" 36 #include "G4ParticleDefinition.hh"
37 #include "G4HadronNucleonXsc.hh" 37 #include "G4HadronNucleonXsc.hh"
38 #include "G4ComponentGGHadronNucleusXsc.hh" 38 #include "G4ComponentGGHadronNucleusXsc.hh"
39 #include "G4NuclearRadii.hh" 39 #include "G4NuclearRadii.hh"
40 #include "G4Pow.hh" 40 #include "G4Pow.hh"
41 41
42 namespace << 42 static const G4double inve = 1./CLHEP::eplus;
43 { <<
44 const G4double inve = 1./CLHEP::eplus; <<
45 } <<
46 43
47 G4ComponentGGNuclNuclXsc::G4ComponentGGNuclNuc 44 G4ComponentGGNuclNuclXsc::G4ComponentGGNuclNuclXsc()
48 : G4VComponentCrossSection("Glauber-Gribov Nu << 45 : G4VComponentCrossSection("Glauber-Gribov Nucl-nucl"),
>> 46 fTotalXsc(0.0), fElasticXsc(0.0), fInelasticXsc(0.0), fProductionXsc(0.0),
>> 47 fDiffractionXsc(0.0), fEnergy(0.0), fParticle(nullptr), fZ(0), fA(0)
49 { 48 {
50 theProton = G4Proton::Proton(); 49 theProton = G4Proton::Proton();
51 theNeutron = G4Neutron::Neutron(); 50 theNeutron = G4Neutron::Neutron();
52 theLambda = G4Lambda::Lambda(); 51 theLambda = G4Lambda::Lambda();
53 fHNXsc = new G4HadronNucleonXsc(); 52 fHNXsc = new G4HadronNucleonXsc();
54 fHadrNucl = new G4ComponentGGHadronNucleusXs 53 fHadrNucl = new G4ComponentGGHadronNucleusXsc();
55 } 54 }
56 55
57 G4ComponentGGNuclNuclXsc::~G4ComponentGGNuclNu 56 G4ComponentGGNuclNuclXsc::~G4ComponentGGNuclNuclXsc()
58 { 57 {
59 delete fHNXsc; 58 delete fHNXsc;
60 } 59 }
61 60
62 ////////////////////////////////////////////// 61 //////////////////////////////////////////////////////////////////////
63 62
64 G4double G4ComponentGGNuclNuclXsc::GetTotalEle 63 G4double G4ComponentGGNuclNuclXsc::GetTotalElementCrossSection(
65 const G4ParticleDefinition* aParticle 64 const G4ParticleDefinition* aParticle, G4double kinEnergy,
66 G4int Z, G4double A) 65 G4int Z, G4double A)
67 { 66 {
68 ComputeCrossSections(aParticle, kinEnergy, Z 67 ComputeCrossSections(aParticle, kinEnergy, Z, G4lrint(A));
69 return fTotalXsc; 68 return fTotalXsc;
70 } 69 }
71 70
72 ////////////////////////////////////////////// 71 ////////////////////////////////////////////////////////////////////
73 72
74 G4double G4ComponentGGNuclNuclXsc::GetTotalIso 73 G4double G4ComponentGGNuclNuclXsc::GetTotalIsotopeCrossSection(
75 const G4ParticleDefinition* aParticle 74 const G4ParticleDefinition* aParticle, G4double kinEnergy,
76 G4int Z, G4int A) 75 G4int Z, G4int A)
77 { 76 {
78 ComputeCrossSections(aParticle, kinEnergy, Z 77 ComputeCrossSections(aParticle, kinEnergy, Z, A);
79 return fTotalXsc; 78 return fTotalXsc;
80 } 79 }
81 80
82 ////////////////////////////////////////////// 81 /////////////////////////////////////////////////////////////////////
83 82
84 G4double G4ComponentGGNuclNuclXsc::GetInelasti 83 G4double G4ComponentGGNuclNuclXsc::GetInelasticElementCrossSection(
85 const G4ParticleDefinition* aParticle 84 const G4ParticleDefinition* aParticle, G4double kinEnergy,
86 G4int Z, G4double A) 85 G4int Z, G4double A)
87 { 86 {
88 ComputeCrossSections(aParticle, kinEnergy, Z 87 ComputeCrossSections(aParticle, kinEnergy, Z, G4lrint(A));
89 return fInelasticXsc; 88 return fInelasticXsc;
90 } 89 }
91 90
92 ////////////////////////////////////////////// 91 ////////////////////////////////////////////////////////////////////
93 92
94 G4double G4ComponentGGNuclNuclXsc::GetInelasti 93 G4double G4ComponentGGNuclNuclXsc::GetInelasticIsotopeCrossSection(
95 const G4ParticleDefinition* aParticle 94 const G4ParticleDefinition* aParticle, G4double kinEnergy,
96 G4int Z, G4int A) 95 G4int Z, G4int A)
97 { 96 {
98 ComputeCrossSections(aParticle, kinEnergy, Z 97 ComputeCrossSections(aParticle, kinEnergy, Z, A);
99 return fInelasticXsc; 98 return fInelasticXsc;
100 } 99 }
101 100
102 ////////////////////////////////////////////// 101 //////////////////////////////////////////////////////////////////
103 102
104 G4double G4ComponentGGNuclNuclXsc::GetElasticE 103 G4double G4ComponentGGNuclNuclXsc::GetElasticElementCrossSection(
105 const G4ParticleDefinition* aParticle 104 const G4ParticleDefinition* aParticle, G4double kinEnergy,
106 G4int Z, G4double A) 105 G4int Z, G4double A)
107 { 106 {
108 ComputeCrossSections(aParticle, kinEnergy, Z 107 ComputeCrossSections(aParticle, kinEnergy, Z, G4lrint(A));
109 return fElasticXsc; 108 return fElasticXsc;
110 } 109 }
111 110
112 ////////////////////////////////////////////// 111 ///////////////////////////////////////////////////////////////////
113 112
114 G4double G4ComponentGGNuclNuclXsc::GetElasticI 113 G4double G4ComponentGGNuclNuclXsc::GetElasticIsotopeCrossSection(
115 const G4ParticleDefinition* aParticle 114 const G4ParticleDefinition* aParticle, G4double kinEnergy,
116 G4int Z, G4int A) 115 G4int Z, G4int A)
117 { 116 {
118 ComputeCrossSections(aParticle, kinEnergy, Z 117 ComputeCrossSections(aParticle, kinEnergy, Z, A);
119 return fElasticXsc; 118 return fElasticXsc;
120 } 119 }
121 120
122 ////////////////////////////////////////////// 121 ////////////////////////////////////////////////////////////////
123 122
124 G4double G4ComponentGGNuclNuclXsc::ComputeQuas 123 G4double G4ComponentGGNuclNuclXsc::ComputeQuasiElasticRatio(
125 const G4ParticleDefinition* aParticle 124 const G4ParticleDefinition* aParticle, G4double kinEnergy,
126 G4int Z, G4int A) 125 G4int Z, G4int A)
127 { 126 {
128 ComputeCrossSections(aParticle, kinEnergy, Z 127 ComputeCrossSections(aParticle, kinEnergy, Z, A);
129 return (fInelasticXsc > fProductionXsc) 128 return (fInelasticXsc > fProductionXsc)
130 ? (fInelasticXsc - fProductionXsc)/fInelas 129 ? (fInelasticXsc - fProductionXsc)/fInelasticXsc : 0.0;
131 } 130 }
132 131
133 ////////////////////////////////////////////// 132 //////////////////////////////////////////////////////////////////////
134 133
135 void G4ComponentGGNuclNuclXsc::BuildPhysicsTab 134 void G4ComponentGGNuclNuclXsc::BuildPhysicsTable(const G4ParticleDefinition&)
136 {} 135 {}
137 136
138 ////////////////////////////////////////////// 137 //////////////////////////////////////////////////////////////////////
139 138
140 void G4ComponentGGNuclNuclXsc::DumpPhysicsTabl 139 void G4ComponentGGNuclNuclXsc::DumpPhysicsTable(const G4ParticleDefinition&)
141 { 140 {
142 G4cout << "G4ComponentGGNuclNuclXsc: uses Gl 141 G4cout << "G4ComponentGGNuclNuclXsc: uses Glauber-Gribov formula" << G4endl;
143 } 142 }
144 143
145 ////////////////////////////////////////////// 144 //////////////////////////////////////////////////////////////////////
146 145
147 void G4ComponentGGNuclNuclXsc::Description(std 146 void G4ComponentGGNuclNuclXsc::Description(std::ostream& outFile) const
148 { 147 {
149 outFile << "G4ComponentGGNuclNuclXsc calcula 148 outFile << "G4ComponentGGNuclNuclXsc calculates total, inelastic and\n"
150 << "elastic cross sections for nucle 149 << "elastic cross sections for nucleus-nucleus collisions using\n"
151 << "the Glauber model with Gribov co 150 << "the Glauber model with Gribov corrections. It is valid for\n"
152 << "all incident energies above 100 151 << "all incident energies above 100 keV./n"
153 << "For the hydrogen target G4HadronNucleo 152 << "For the hydrogen target G4HadronNucleonXsc class is used.\n";
154 } 153 }
155 154
156 ////////////////////////////////////////////// 155 ///////////////////////////////////////////////////////////////////////////////
157 // 156 //
158 // Calculates total and inelastic Xsc, derives 157 // Calculates total and inelastic Xsc, derives elastic as total - inelastic
159 // accordong to Glauber model with Gribov corr 158 // accordong to Glauber model with Gribov correction calculated in the dipole
160 // approximation on light cone. Gaussian densi 159 // approximation on light cone. Gaussian density of point-like nucleons helps
161 // to calculate rest integrals of the model. [ 160 // to calculate rest integrals of the model. [1] B.Z. Kopeliovich,
162 // nucl-th/0306044 + simplification above 161 // nucl-th/0306044 + simplification above
163 162
164 void G4ComponentGGNuclNuclXsc::ComputeCrossSec 163 void G4ComponentGGNuclNuclXsc::ComputeCrossSections(
165 const G4ParticleDefinition* aParticle, G4 164 const G4ParticleDefinition* aParticle, G4double kinEnergy,
166 G4int Z, G4int A) 165 G4int Z, G4int A)
167 { 166 {
168 // check cache 167 // check cache
169 if(aParticle == fParticle && fZ == Z && fA = 168 if(aParticle == fParticle && fZ == Z && fA == A && kinEnergy == fEnergy)
170 { return; } 169 { return; }
171 fParticle = aParticle; 170 fParticle = aParticle;
172 fZ = Z; 171 fZ = Z;
173 fA = A; 172 fA = A;
174 fEnergy = kinEnergy; 173 fEnergy = kinEnergy;
175 G4Pow* pG4Pow = G4Pow::GetInstance(); << 174 G4Pow* pG4Pow=G4Pow::GetInstance();
176 175
177 G4int pZ = G4lrint(aParticle->GetPDGCharge() 176 G4int pZ = G4lrint(aParticle->GetPDGCharge()*inve);
178 G4int pA = aParticle->GetBaryonNumber(); 177 G4int pA = aParticle->GetBaryonNumber();
179 G4int pL = aParticle->GetNumberOfLambdasInHy 178 G4int pL = aParticle->GetNumberOfLambdasInHypernucleus();
180 G4bool pHN = aParticle->IsHypernucleus(); 179 G4bool pHN = aParticle->IsHypernucleus();
181 G4double cHN(0.88); 180 G4double cHN(0.88);
182 181
183 // hydrogen 182 // hydrogen
184 if(1 == Z && 1 == A) { 183 if(1 == Z && 1 == A) {
185 G4double e = kinEnergy*CLHEP::proton_mass_ 184 G4double e = kinEnergy*CLHEP::proton_mass_c2/aParticle->GetPDGMass();
186 fHadrNucl->ComputeCrossSections( theProton 185 fHadrNucl->ComputeCrossSections( theProton, e, pZ, pA, pL );
187 fTotalXsc = fHadrNucl->GetTotalGlauberGrib 186 fTotalXsc = fHadrNucl->GetTotalGlauberGribovXsc();
188 fElasticXsc = fHadrNucl->GetElasticGlauber 187 fElasticXsc = fHadrNucl->GetElasticGlauberGribovXsc();
189 fInelasticXsc = fHadrNucl->GetInelasticGla 188 fInelasticXsc = fHadrNucl->GetInelasticGlauberGribovXsc();
190 fProductionXsc = fHadrNucl->GetProductionG 189 fProductionXsc = fHadrNucl->GetProductionGlauberGribovXsc();
191 fDiffractionXsc = fHadrNucl->GetDiffractio 190 fDiffractionXsc = fHadrNucl->GetDiffractionGlauberGribovXsc();
192 return; 191 return;
193 } 192 }
194 static const G4double cofInelastic = 2.4; 193 static const G4double cofInelastic = 2.4;
195 static const G4double cofTotal = 2.0; 194 static const G4double cofTotal = 2.0;
196 195
197 G4double pTkin = kinEnergy/(G4double)pA; 196 G4double pTkin = kinEnergy/(G4double)pA;
198 197
199 G4int pN = pA - pZ; 198 G4int pN = pA - pZ;
200 G4int tN = A - Z; 199 G4int tN = A - Z;
201 200
202 G4double tR = G4NuclearRadii::Radius(Z, A); 201 G4double tR = G4NuclearRadii::Radius(Z, A);
203 G4double pR = G4NuclearRadii::Radius(pZ, pA) 202 G4double pR = G4NuclearRadii::Radius(pZ, pA);
204 203
205 if(pHN) << 204 if(pHN) pR *= std::sqrt( pG4Pow->Z23( pA - pL ) + cHN*pG4Pow->Z23( pL ) )/pG4Pow->Z13(pA);
206 pR *= std::sqrt( pG4Pow->Z23( pA - pL ) + <<
207 205
208 G4double cB = ComputeCoulombBarier(aParticle 206 G4double cB = ComputeCoulombBarier(aParticle, kinEnergy, Z, A, pR, tR);
209 207
210 if ( cB > 0. ) 208 if ( cB > 0. )
211 { 209 {
212 G4double sigma = (pZ*Z+pN*tN)*fHNXsc->Hadr 210 G4double sigma = (pZ*Z+pN*tN)*fHNXsc->HadronNucleonXscNS(theProton, theProton, pTkin);
213 if(pHN) sigma += pL*A*fHNXsc->HadronNucleo 211 if(pHN) sigma += pL*A*fHNXsc->HadronNucleonXsc(theLambda, theProton, pTkin);
214 G4double ppInXsc = fHNXsc->GetInelasticHad 212 G4double ppInXsc = fHNXsc->GetInelasticHadronNucleonXsc();
215 213
216 sigma += (pZ*tN+pN*Z)*fHNXsc->HadronNucleo 214 sigma += (pZ*tN+pN*Z)*fHNXsc->HadronNucleonXscNS(theNeutron, theProton, pTkin);
217 G4double npInXsc = fHNXsc->GetInelasticHad 215 G4double npInXsc = fHNXsc->GetInelasticHadronNucleonXsc();
218 216
>> 217 // G4cout<<"ppInXsc = "<<ppInXsc/millibarn<<"; npInXsc = "<<npInXsc/millibarn<<G4endl;
>> 218 // G4cout<<"npTotXsc = "<<fHNXsc->GetTotalHadronNucleonXsc()/millibarn<<"; npElXsc = "
>> 219 // <<fHNXsc->GetElasticHadronNucleonXsc()/millibarn<<G4endl;
>> 220
219 G4double nucleusSquare = cofTotal*CLHEP::p 221 G4double nucleusSquare = cofTotal*CLHEP::pi*( pR*pR + tR*tR ); // basically 2piRR
220 222
221 G4double ratio= sigma/nucleusSquare; 223 G4double ratio= sigma/nucleusSquare;
222 fTotalXsc = nucleusSquare*G4Log( 1. + 224 fTotalXsc = nucleusSquare*G4Log( 1. + ratio )*cB;
223 fInelasticXsc = nucleusSquare*G4Log( 1. + 225 fInelasticXsc = nucleusSquare*G4Log( 1. + cofInelastic*ratio )*cB/cofInelastic;
224 fElasticXsc = std::max(fTotalXsc - fInel 226 fElasticXsc = std::max(fTotalXsc - fInelasticXsc, 0.0);
225 227
226 G4double difratio = ratio/(1.+ratio); 228 G4double difratio = ratio/(1.+ratio);
227 fDiffractionXsc = 0.5*nucleusSquare*( difr 229 fDiffractionXsc = 0.5*nucleusSquare*( difratio - G4Log( 1. + difratio ) );
228 230
229 G4double xratio= ((pZ*Z+pN*tN)*ppInXsc + ( 231 G4double xratio= ((pZ*Z+pN*tN)*ppInXsc + (pZ*tN+pN*Z)*npInXsc)/nucleusSquare;
230 fProductionXsc = nucleusSquare*G4Log( 1. + 232 fProductionXsc = nucleusSquare*G4Log( 1. + cofInelastic*xratio)*cB/cofInelastic;
231 fProductionXsc = std::min(fProductionXsc, 233 fProductionXsc = std::min(fProductionXsc, fInelasticXsc);
232 } 234 }
233 else 235 else
234 { 236 {
235 fInelasticXsc = fTotalXsc = fElasticXsc = << 237 fInelasticXsc = 0.;
>> 238 fTotalXsc = 0.;
>> 239 fElasticXsc = 0.;
>> 240 fProductionXsc = 0.;
>> 241 fDiffractionXsc= 0.;
236 } 242 }
237 } 243 }
238 244
239 ////////////////////////////////////////////// 245 ///////////////////////////////////////////////////////////////////////////////
240 246
241 G4double G4ComponentGGNuclNuclXsc::ComputeCoul 247 G4double G4ComponentGGNuclNuclXsc::ComputeCoulombBarier(
242 const G4ParticleDefinitio 248 const G4ParticleDefinition* aParticle,
243 G4double pTkin, G4int Z, G4int A, 249 G4double pTkin, G4int Z, G4int A,
244 G4double pR, G4double tR) 250 G4double pR, G4double tR)
245 { 251 {
246 G4int pZ = aParticle->GetPDGCharge()*inve; 252 G4int pZ = aParticle->GetPDGCharge()*inve;
247 G4double pM = aParticle->GetPDGMass(); 253 G4double pM = aParticle->GetPDGMass();
248 G4double tM = G4NucleiProperties::GetNuclear 254 G4double tM = G4NucleiProperties::GetNuclearMass(A, Z);
249 G4double pElab = pTkin + pM; 255 G4double pElab = pTkin + pM;
250 G4double totEcm = std::sqrt(pM*pM + tM*tM + 256 G4double totEcm = std::sqrt(pM*pM + tM*tM + 2.*pElab*tM);
251 G4double totTcm = totEcm - pM -tM; 257 G4double totTcm = totEcm - pM -tM;
252 258
253 // 0.5 defines shape of Cross section correc << 259 static const G4double qfact = CLHEP::fine_structure_const*CLHEP::hbarc;
254 // at cB = totTcm it become zero << 260 G4double bC = qfact*pZ*Z*0.5/(pR + tR);
255 static const G4double qfact = 0.5*CLHEP::elm << 261
256 G4double bC = qfact*pZ*Z/(pR + tR); << 262 G4double ratio = (totTcm <= bC ) ? 0. : 1. - bC/totTcm;
257 << 263 // G4cout<<"G4ComponentGGNuclNuclXsc::ComputeCoulombBarier= "<<ratio
258 G4double ratio = (totTcm <= bC) ? 0. : 1. - << 264 // <<"; pTkin(GeV)= " <<pTkin/GeV<<";
259 << 265 // " pPlab = "<<pPlab/GeV<<"; bC = "<<bC/GeV<<"; pTcm = "
260 #ifdef G4VERBOSE << 266 // <<pTcm/GeV<<G4endl;
261 if (GetVerboseLevel() > 1) { <<
262 G4cout << "G4ComponentGGNuclNuclXsc::Compu <<
263 << "; pTkin(GeV)=" << pTkin/CLHEP::MeV <<
264 << " totTcm= " << totTcm/CLHEP::MeV<< "; <<
265 << G4endl; <<
266 } <<
267 #endif <<
268 return ratio; 267 return ratio;
269 } 268 }
270 269
271 ////////////////////////////////////////////// 270 //////////////////////////////////////////////////////////////////////////
272 // 271 //
273 // Return single-diffraction/inelastic cross-s 272 // Return single-diffraction/inelastic cross-section ratio
274 273
275 G4double G4ComponentGGNuclNuclXsc::GetRatioSD( 274 G4double G4ComponentGGNuclNuclXsc::GetRatioSD(
276 const G4DynamicParticle* aParticle, G 275 const G4DynamicParticle* aParticle, G4double tA, G4double tZ)
277 { 276 {
278 ComputeCrossSections(aParticle->GetDefinitio 277 ComputeCrossSections(aParticle->GetDefinition(),
279 aParticle->GetKineticEn 278 aParticle->GetKineticEnergy(),
280 G4lrint(tZ), G4lrint(tA)); 279 G4lrint(tZ), G4lrint(tA));
281 280
282 return (fInelasticXsc > 0.0) ? fDiffractionX 281 return (fInelasticXsc > 0.0) ? fDiffractionXsc/fInelasticXsc : 0.0;
283 } 282 }
284 283
285 ////////////////////////////////////////////// 284 //////////////////////////////////////////////////////////////////////////
286 // 285 //
287 // Return quasi-elastic/inelastic cross-sectio 286 // Return quasi-elastic/inelastic cross-section ratio
288 287
289 G4double G4ComponentGGNuclNuclXsc::GetRatioQE( 288 G4double G4ComponentGGNuclNuclXsc::GetRatioQE(
290 const G4DynamicParticle* aParticle, G 289 const G4DynamicParticle* aParticle, G4double tA, G4double tZ)
291 { 290 {
292 ComputeCrossSections(aParticle->GetDefinitio 291 ComputeCrossSections(aParticle->GetDefinition(),
293 aParticle->GetKineticEn 292 aParticle->GetKineticEnergy(),
294 G4lrint(tZ), G4lrint(tA)); 293 G4lrint(tZ), G4lrint(tA));
295 294
296 return (fInelasticXsc > 0.0) ? 1.0 - fProduc 295 return (fInelasticXsc > 0.0) ? 1.0 - fProductionXsc/fInelasticXsc : 0.0;
297 } 296 }
298 297
299 ////////////////////////////////////////////// 298 ///////////////////////////////////////////////////////////////////////////////
300 299