| 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 // 26 //
27 // Geant4 Header : G4NeutronElectronElModel 27 // Geant4 Header : G4NeutronElectronElModel
28 // 28 //
29 // 16.5.17: V.Grichine 29 // 16.5.17: V.Grichine
30 // 30 //
31 31
32 #include "G4NeutronElectronElModel.hh" 32 #include "G4NeutronElectronElModel.hh"
33 #include "G4SystemOfUnits.hh" 33 #include "G4SystemOfUnits.hh"
34 #include "G4ParticleTable.hh" 34 #include "G4ParticleTable.hh"
35 #include "G4ParticleDefinition.hh" 35 #include "G4ParticleDefinition.hh"
36 #include "G4IonTable.hh" 36 #include "G4IonTable.hh"
37 #include "Randomize.hh" 37 #include "Randomize.hh"
38 #include "G4Integrator.hh" 38 #include "G4Integrator.hh"
39 #include "G4Electron.hh" 39 #include "G4Electron.hh"
40 #include "G4PhysicsTable.hh" 40 #include "G4PhysicsTable.hh"
41 #include "G4PhysicsLogVector.hh" 41 #include "G4PhysicsLogVector.hh"
42 #include "G4PhysicsFreeVector.hh" 42 #include "G4PhysicsFreeVector.hh"
43 #include "G4PhysicsModelCatalog.hh" <<
44 43
45 44
46 using namespace std; 45 using namespace std;
47 using namespace CLHEP; 46 using namespace CLHEP;
48 47
49 G4NeutronElectronElModel::G4NeutronElectronElM 48 G4NeutronElectronElModel::G4NeutronElectronElModel(const G4String& name)
50 : G4HadronElastic(name) 49 : G4HadronElastic(name)
51 { 50 {
52 secID = G4PhysicsModelCatalog::GetModelID( " <<
53 <<
54 // neutron magneton squared 51 // neutron magneton squared
55 52
56 fM = neutron_mass_c2; // neutron mass 53 fM = neutron_mass_c2; // neutron mass
57 fM2 = fM*fM; 54 fM2 = fM*fM;
58 fme = electron_mass_c2; 55 fme = electron_mass_c2;
59 fme2 = fme*fme; 56 fme2 = fme*fme;
60 fMv2 = 0.7056*GeV*GeV; 57 fMv2 = 0.7056*GeV*GeV;
61 58
62 SetMinEnergy( 0.001*GeV ); 59 SetMinEnergy( 0.001*GeV );
63 SetMaxEnergy( 10.*TeV ); 60 SetMaxEnergy( 10.*TeV );
64 SetLowestEnergyLimit(1.e-6*eV); 61 SetLowestEnergyLimit(1.e-6*eV);
65 62
66 theElectron = G4Electron::Electron(); 63 theElectron = G4Electron::Electron();
67 // PDG2016: sin^2 theta Weinberg 64 // PDG2016: sin^2 theta Weinberg
68 65
69 fEnergyBin = 200; 66 fEnergyBin = 200;
70 fMinEnergy = 1.*MeV; 67 fMinEnergy = 1.*MeV;
71 fMaxEnergy = 10000.*GeV; 68 fMaxEnergy = 10000.*GeV;
72 fEnergyVector = new G4PhysicsLogVector(fMinE << 69 fEnergyVector = new G4PhysicsLogVector(fMinEnergy, fMaxEnergy, fEnergyBin);
73 70
74 fAngleBin = 500; 71 fAngleBin = 500;
75 fAngleTable = 0; 72 fAngleTable = 0;
76 73
77 fCutEnergy = 0.; // default value 74 fCutEnergy = 0.; // default value
78 75
79 Initialise(); 76 Initialise();
80 } 77 }
81 78
82 ////////////////////////////////////////////// 79 ////////////////////////////////////////////////
83 80
84 G4NeutronElectronElModel::~G4NeutronElectronEl 81 G4NeutronElectronElModel::~G4NeutronElectronElModel()
85 { 82 {
86 if( fEnergyVector ) 83 if( fEnergyVector )
87 { 84 {
88 delete fEnergyVector; 85 delete fEnergyVector;
89 fEnergyVector = nullptr; << 86 fEnergyVector = 0;
90 } 87 }
91 if( fAngleTable ) 88 if( fAngleTable )
92 { 89 {
93 fAngleTable->clearAndDestroy(); 90 fAngleTable->clearAndDestroy();
94 delete fAngleTable; 91 delete fAngleTable;
95 fAngleTable = nullptr; 92 fAngleTable = nullptr;
96 } 93 }
97 } 94 }
98 95
99 ///////////////////////////////////////// 96 /////////////////////////////////////////
100 97
101 void G4NeutronElectronElModel::ModelDescriptio 98 void G4NeutronElectronElModel::ModelDescription(std::ostream& outFile) const
102 { 99 {
103 outFile << "G4NeutronElectronElModel is a ne << 100
104 << "model which uses the standard model \n << 101 outFile << "G4NeutronElectronElModel is a neutrino-electron (neutral current) elastic scattering\n"
105 << "transfer parameterization. The model << 102 << "model which uses the standard model \n"
>> 103 << "transfer parameterization. The model is fully relativistic\n";
>> 104
106 } 105 }
107 106
108 ////////////////////////////////////////////// 107 /////////////////////////////////////////////////////////
109 108
110 G4bool G4NeutronElectronElModel::IsApplicable( << 109 G4bool G4NeutronElectronElModel::IsApplicable(const G4HadProjectile & aTrack,
>> 110 G4Nucleus & targetNucleus)
111 { 111 {
>> 112 G4bool result = false;
112 G4String pName = aTrack.GetDefinition()->Get 113 G4String pName = aTrack.GetDefinition()->GetParticleName();
>> 114 // G4double minEnergy = 0.;
113 G4double energy = aTrack.GetTotalEnergy(); 115 G4double energy = aTrack.GetTotalEnergy();
114 116
115 return (pName == "neutron" && energy >= fMin << 117 if( fCutEnergy > 0. ) // min detected recoil electron energy
>> 118 {
>> 119 // minEnergy = 0.5*(fCutEnergy+sqrt(fCutEnergy*(fCutEnergy+2.*electron_mass_c2)));
>> 120 }
>> 121 if( pName == "neutron" &&
>> 122 energy >= fMinEnergy && energy <= fMaxEnergy )
>> 123 {
>> 124 result = true;
>> 125 }
>> 126 G4int Z = targetNucleus.GetZ_asInt();
>> 127 Z *= 1;
>> 128
>> 129 return result;
116 } 130 }
117 131
118 ////////////////////////////////////////////// 132 ////////////////////////////////////////////////////
119 133
120 void G4NeutronElectronElModel::Initialise() 134 void G4NeutronElectronElModel::Initialise()
121 { 135 {
122 G4double result = 0., sum, Tkin, dt, t1, t2; 136 G4double result = 0., sum, Tkin, dt, t1, t2;
123 G4int iTkin, jTransfer; 137 G4int iTkin, jTransfer;
124 G4Integrator<G4NeutronElectronElModel, G4dou 138 G4Integrator<G4NeutronElectronElModel, G4double(G4NeutronElectronElModel::*)(G4double)> integral;
125 139
126 fAngleTable = new G4PhysicsTable(fEnergyBin) 140 fAngleTable = new G4PhysicsTable(fEnergyBin);
127 141
128 for( iTkin = 0; iTkin < fEnergyBin; iTkin++) 142 for( iTkin = 0; iTkin < fEnergyBin; iTkin++)
129 { 143 {
130 Tkin = fEnergyVector->GetLowEdgeEnergy(iT 144 Tkin = fEnergyVector->GetLowEdgeEnergy(iTkin);
131 fAm = CalculateAm(Tkin); 145 fAm = CalculateAm(Tkin);
132 dt = 1./fAngleBin; 146 dt = 1./fAngleBin;
133 147
134 G4PhysicsFreeVector* vectorT = new G4Physi 148 G4PhysicsFreeVector* vectorT = new G4PhysicsFreeVector(fAngleBin);
135 149
136 sum = 0.; 150 sum = 0.;
137 151
138 for( jTransfer = 0; jTransfer < fAngleBin; 152 for( jTransfer = 0; jTransfer < fAngleBin; jTransfer++)
139 { 153 {
140 t1 = dt*jTransfer; 154 t1 = dt*jTransfer;
141 t2 = t1 + dt; 155 t2 = t1 + dt;
142 156
143 result = integral.Legendre96( this, &G4N 157 result = integral.Legendre96( this, &G4NeutronElectronElModel::XscIntegrand, t1, t2 );
144 158
145 sum += result; 159 sum += result;
146 // G4cout<<sum<<", "; 160 // G4cout<<sum<<", ";
147 vectorT->PutValue(jTransfer, t1, sum); 161 vectorT->PutValue(jTransfer, t1, sum);
148 } 162 }
149 // G4cout<<G4endl; 163 // G4cout<<G4endl;
150 fAngleTable->insertAt(iTkin,vectorT); 164 fAngleTable->insertAt(iTkin,vectorT);
151 } 165 }
152 return; 166 return;
153 } 167 }
154 168
155 ////////////////////////////////////////////// 169 //////////////////////////////////////////////////////
156 // 170 //
157 // sample recoil electron energy in lab frame 171 // sample recoil electron energy in lab frame
158 172
159 G4double G4NeutronElectronElModel::SampleSin2H 173 G4double G4NeutronElectronElModel::SampleSin2HalfTheta(G4double Tkin)
160 { 174 {
161 G4double result = 0., position; 175 G4double result = 0., position;
162 G4int iTkin, iTransfer; 176 G4int iTkin, iTransfer;
163 177
164 for( iTkin = 0; iTkin < fEnergyBin; iTkin++) 178 for( iTkin = 0; iTkin < fEnergyBin; iTkin++)
165 { 179 {
166 if( Tkin < fEnergyVector->Energy(iTkin) ) << 180 if( Tkin < fEnergyVector->GetLowEdgeEnergy(iTkin) ) break;
167 } 181 }
168 if ( iTkin >= fEnergyBin ) iTkin = fEnergyBi 182 if ( iTkin >= fEnergyBin ) iTkin = fEnergyBin-1; // Tkin is more then theMaxEnergy
169 if ( iTkin < 0 ) iTkin = 0; // aga 183 if ( iTkin < 0 ) iTkin = 0; // against negative index, Tkin < theMinEnergy
170 184
171 position = (*(*fAngleTable)(iTkin))(fAngle 185 position = (*(*fAngleTable)(iTkin))(fAngleBin-1)*G4UniformRand();
172 186
173 // G4cout<<"position = "<<position<<G4endl 187 // G4cout<<"position = "<<position<<G4endl;
174 188
175 for( iTransfer = 0; iTransfer < fAngleBin; 189 for( iTransfer = 0; iTransfer < fAngleBin; iTransfer++)
176 { 190 {
177 if( position <= (*(*fAngleTable)(iTkin)) 191 if( position <= (*(*fAngleTable)(iTkin))(iTransfer) ) break;
178 } 192 }
179 if (iTransfer >= fAngleBin-1) iTransfer = 193 if (iTransfer >= fAngleBin-1) iTransfer = fAngleBin-1;
180 194
181 // G4cout<<"iTransfer = "<<iTransfer<<G4en 195 // G4cout<<"iTransfer = "<<iTransfer<<G4endl;
182 196
183 result = GetTransfer(iTkin, iTransfer, pos 197 result = GetTransfer(iTkin, iTransfer, position);
184 198
185 // G4cout<<"t = "<<t<<G4endl; 199 // G4cout<<"t = "<<t<<G4endl;
186 200
187 201
188 return result; 202 return result;
189 } 203 }
190 204
191 ////////////////////////////////////////////// 205 /////////////////////////////////////////////////
192 206
193 G4double 207 G4double
194 G4NeutronElectronElModel:: GetTransfer( G4int 208 G4NeutronElectronElModel:: GetTransfer( G4int iTkin, G4int iTransfer, G4double position )
195 { 209 {
196 G4double x1, x2, y1, y2, randTransfer, delta 210 G4double x1, x2, y1, y2, randTransfer, delta, mean, epsilon = 1.e-6;
197 211
198 if( iTransfer == 0 || iTransfer == fAngleBi 212 if( iTransfer == 0 || iTransfer == fAngleBin-1 )
199 { 213 {
200 randTransfer = (*fAngleTable)(iTkin)->Ener << 214 randTransfer = (*fAngleTable)(iTkin)->GetLowEdgeEnergy(iTransfer);
>> 215 // iTransfer++;
201 } 216 }
202 else 217 else
203 { 218 {
204 if ( iTransfer >= G4int((*fAngleTable)(iTk 219 if ( iTransfer >= G4int((*fAngleTable)(iTkin)->GetVectorLength()) )
205 { 220 {
206 iTransfer = G4int((*fAngleTable)(iTkin)- << 221 iTransfer = (*fAngleTable)(iTkin)->GetVectorLength() - 1;
207 } 222 }
208 y1 = (*(*fAngleTable)(iTkin))(iTransfer-1) 223 y1 = (*(*fAngleTable)(iTkin))(iTransfer-1);
209 y2 = (*(*fAngleTable)(iTkin))(iTransfer); 224 y2 = (*(*fAngleTable)(iTkin))(iTransfer);
210 225
211 x1 = (*fAngleTable)(iTkin)->Energy(iTransf << 226 x1 = (*fAngleTable)(iTkin)->GetLowEdgeEnergy(iTransfer-1);
212 x2 = (*fAngleTable)(iTkin)->Energy(iTransf << 227 x2 = (*fAngleTable)(iTkin)->GetLowEdgeEnergy(iTransfer);
213 228
214 delta = y2 - y1; 229 delta = y2 - y1;
215 mean = y2 + y1; 230 mean = y2 + y1;
216 231
217 if ( x1 == x2 ) randTransfer = x2; 232 if ( x1 == x2 ) randTransfer = x2;
218 else 233 else
219 { 234 {
>> 235 // if ( y1 == y2 )
>> 236
220 if ( delta < epsilon*mean ) 237 if ( delta < epsilon*mean )
221 { 238 {
222 randTransfer = x1 + ( x2 - x1 )*G4Unif 239 randTransfer = x1 + ( x2 - x1 )*G4UniformRand();
223 } 240 }
224 else 241 else
225 { 242 {
226 randTransfer = x1 + ( position - y1 )* 243 randTransfer = x1 + ( position - y1 )*( x2 - x1 )/delta; // ( y2 - y1 );
227 } 244 }
228 } 245 }
229 } 246 }
230 return randTransfer; 247 return randTransfer;
231 } 248 }
232 249
233 ////////////////////////////////////////////// 250 //////////////////////////////////////////////////////////////
234 // 251 //
235 // Rosenbluth relation (ultra-relativistic!) i 252 // Rosenbluth relation (ultra-relativistic!) in the neutron rest frame,
236 // x = sin^2(theta/2), theta is the electron s 253 // x = sin^2(theta/2), theta is the electron scattering angle
237 // Magnetic form factor in the dipole approxim 254 // Magnetic form factor in the dipole approximation.
238 255
239 G4double G4NeutronElectronElModel::XscIntegran 256 G4double G4NeutronElectronElModel::XscIntegrand(G4double x)
240 { 257 {
241 G4double result = 1., q2, znq2, znf, znf2, z 258 G4double result = 1., q2, znq2, znf, znf2, znf4;
242 259
243 znq2 = 1. + 2.*fee*x/fM; 260 znq2 = 1. + 2.*fee*x/fM;
244 261
245 q2 = 4.*fee2*x/znq2; 262 q2 = 4.*fee2*x/znq2;
246 263
247 znf = 1 + q2/fMv2; 264 znf = 1 + q2/fMv2;
248 znf2 = znf*znf; 265 znf2 = znf*znf;
249 znf4 = znf2*znf2; 266 znf4 = znf2*znf2;
250 267
251 result /= ( x + fAm )*znq2*znq2*znf4; 268 result /= ( x + fAm )*znq2*znq2*znf4;
252 269
253 result *= ( 1 - x )/( 1 + q2/4./fM2 ) + 2.*x 270 result *= ( 1 - x )/( 1 + q2/4./fM2 ) + 2.*x;
254 271
255 return result; 272 return result;
256 } 273 }
257 274
258 ////////////////////////////////////////////// 275 ////////////////////////////////////////////////
259 // 276 //
260 // 277 //
261 278
262 G4HadFinalState* G4NeutronElectronElModel::App 279 G4HadFinalState* G4NeutronElectronElModel::ApplyYourself(
263 const G4HadProjectile& aTrack, G4Nucleus& << 280 const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
264 { 281 {
265 theParticleChange.Clear(); 282 theParticleChange.Clear();
266 283
267 const G4HadProjectile* aParticle = &aTrack; 284 const G4HadProjectile* aParticle = &aTrack;
268 G4double Tkin = aParticle->GetKineticEnergy( 285 G4double Tkin = aParticle->GetKineticEnergy();
269 fAm = CalculateAm( Tkin); 286 fAm = CalculateAm( Tkin);
270 // G4double En = aParticle->GetTotalEnergy 287 // G4double En = aParticle->GetTotalEnergy();
271 288
272 if( Tkin <= LowestEnergyLimit() ) 289 if( Tkin <= LowestEnergyLimit() )
273 { 290 {
274 theParticleChange.SetEnergyChange(Tkin); 291 theParticleChange.SetEnergyChange(Tkin);
275 theParticleChange.SetMomentumChange(aTrack 292 theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
276 return &theParticleChange; 293 return &theParticleChange;
277 } 294 }
278 // sample e-scattering angle and make final 295 // sample e-scattering angle and make final state in lab frame
279 296
280 G4double sin2ht = SampleSin2HalfTheta( Tkin) 297 G4double sin2ht = SampleSin2HalfTheta( Tkin); // in n-rrest frame
281 298
282 // G4cout<<"sin2ht = "<<sin2ht<<G4endl; 299 // G4cout<<"sin2ht = "<<sin2ht<<G4endl;
283 300
284 G4double eTkin = fee; // fM; 301 G4double eTkin = fee; // fM;
285 302
286 eTkin /= 1.+2.*fee*sin2ht/fM; // fme/En + 2* 303 eTkin /= 1.+2.*fee*sin2ht/fM; // fme/En + 2*sin2ht;
287 304
288 eTkin -= fme; 305 eTkin -= fme;
289 306
290 // G4cout<<"eTkin = "<<eTkin<<G4endl; 307 // G4cout<<"eTkin = "<<eTkin<<G4endl;
291 308
292 if( eTkin > fCutEnergy ) 309 if( eTkin > fCutEnergy )
293 { 310 {
294 G4double ePlab = sqrt( eTkin*(eTkin + 2.*f 311 G4double ePlab = sqrt( eTkin*(eTkin + 2.*fme) );
295 312
296 // G4cout<<"ePlab = "<<ePlab<<G4endl; 313 // G4cout<<"ePlab = "<<ePlab<<G4endl;
297 314
298 G4double cost = 1. - 2*sin2ht; 315 G4double cost = 1. - 2*sin2ht;
299 316
300 if( cost > 1. ) cost = 1.; 317 if( cost > 1. ) cost = 1.;
301 if( cost < -1. ) cost = -1.; 318 if( cost < -1. ) cost = -1.;
302 319
303 G4double sint = std::sqrt( (1.0 - cost)*(1 320 G4double sint = std::sqrt( (1.0 - cost)*(1.0 + cost) );
304 G4double phi = G4UniformRand()*CLHEP::two 321 G4double phi = G4UniformRand()*CLHEP::twopi;
305 322
306 G4ThreeVector eP( sint*std::cos(phi), sint 323 G4ThreeVector eP( sint*std::cos(phi), sint*std::sin(phi), cost );
307 eP *= ePlab; 324 eP *= ePlab;
308 G4LorentzVector lvt2( eP, eTkin + electron 325 G4LorentzVector lvt2( eP, eTkin + electron_mass_c2 ); // recoil e- in n-rest frame
309 326
310 G4LorentzVector lvp1 = aParticle->Get4Mome 327 G4LorentzVector lvp1 = aParticle->Get4Momentum();
311 G4LorentzVector lvt1(0.,0.,0.,electron_mas 328 G4LorentzVector lvt1(0.,0.,0.,electron_mass_c2);
312 G4LorentzVector lvsum = lvp1+lvt1; 329 G4LorentzVector lvsum = lvp1+lvt1;
313 330
314 G4ThreeVector bst = lvp1.boostVector(); 331 G4ThreeVector bst = lvp1.boostVector();
315 lvt2.boost(bst); 332 lvt2.boost(bst);
316 333
317 // G4cout<<"lvt2 = "<<lvt2<<G4endl; 334 // G4cout<<"lvt2 = "<<lvt2<<G4endl;
318 335
319 G4DynamicParticle * aSec = new G4DynamicPa 336 G4DynamicParticle * aSec = new G4DynamicParticle( theElectron, lvt2 );
320 theParticleChange.AddSecondary( aSec, secI << 337 theParticleChange.AddSecondary( aSec );
321 338
322 G4LorentzVector lvp2 = lvsum-lvt2; 339 G4LorentzVector lvp2 = lvsum-lvt2;
323 340
324 // G4cout<<"lvp2 = "<<lvp2<<G4endl; 341 // G4cout<<"lvp2 = "<<lvp2<<G4endl;
325 342
326 G4double Tkin2 = lvp2.e()-aParticle->GetDe 343 G4double Tkin2 = lvp2.e()-aParticle->GetDefinition()->GetPDGMass();
327 theParticleChange.SetEnergyChange(Tkin2); 344 theParticleChange.SetEnergyChange(Tkin2);
328 theParticleChange.SetMomentumChange(lvp2.v 345 theParticleChange.SetMomentumChange(lvp2.vect().unit());
329 } 346 }
330 else if( eTkin > 0.0 ) 347 else if( eTkin > 0.0 )
331 { 348 {
332 theParticleChange.SetLocalEnergyDeposit( e 349 theParticleChange.SetLocalEnergyDeposit( eTkin );
333 Tkin -= eTkin; 350 Tkin -= eTkin;
334 351
335 if( Tkin > 0. ) 352 if( Tkin > 0. )
336 { 353 {
337 theParticleChange.SetEnergyChange( Tkin 354 theParticleChange.SetEnergyChange( Tkin );
338 theParticleChange.SetMomentumChange( aTr 355 theParticleChange.SetMomentumChange( aTrack.Get4Momentum().vect().unit() );
339 } 356 }
340 } 357 }
341 else 358 else
342 { 359 {
343 theParticleChange.SetEnergyChange( Tkin ); 360 theParticleChange.SetEnergyChange( Tkin );
344 theParticleChange.SetMomentumChange( aTrac 361 theParticleChange.SetMomentumChange( aTrack.Get4Momentum().vect().unit() );
345 } 362 }
>> 363 G4int Z = targetNucleus.GetZ_asInt();
>> 364 Z *= 1;
>> 365
346 return &theParticleChange; 366 return &theParticleChange;
347 } 367 }
348 368
349 // 369 //
350 // 370 //
351 /////////////////////////// 371 ///////////////////////////
352 372