Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4SynchrotronRadiationInMat.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 // $Id: G4SynchrotronRadiationInMat.cc 97385 2016-06-02 09:59:53Z gcosmo $
28 //
29 // --------------------------------------------------------------
30 // GEANT 4 class implementation file
31 // CERN Geneva Switzerland
32 //
33 // History: first implementation,
34 // 21-5-98 V.Grichine
35 // 28-05-01, V.Ivanchenko minor changes to provide ANSI -wall compilation
36 // 04.03.05, V.Grichine: get local field interface
37 // 19-05-06, V.Ivanchenko rename from G4SynchrotronRadiation
38 //
39 //
41 
43 #include "G4PhysicalConstants.hh"
44 #include "G4SystemOfUnits.hh"
45 #include "G4Integrator.hh"
46 #include "G4EmProcessSubType.hh"
47 
49 //
50 // Constant for calculation of mean free path
51 //
52 
53 const G4double
54 G4SynchrotronRadiationInMat::fLambdaConst = std::sqrt(3.0)*electron_mass_c2/
56 
58 //
59 // Constant for calculation of characterictic energy
60 //
61 
62 const G4double
63 G4SynchrotronRadiationInMat::fEnergyConst = 1.5*c_light*c_light*eplus*hbar_Planck/
65 
67 //
68 // Array of integral probability of synchrotron photons:
69 //
70 // the corresponding energy = 0.0001*i*i*(characteristic energy)
71 //
72 
73 const G4double
74 G4SynchrotronRadiationInMat::fIntegralProbabilityOfSR[200] =
75 {
76  1.000000e+00, 9.428859e-01, 9.094095e-01, 8.813971e-01, 8.565154e-01,
77  8.337008e-01, 8.124961e-01, 7.925217e-01, 7.735517e-01, 7.554561e-01,
78  7.381233e-01, 7.214521e-01, 7.053634e-01, 6.898006e-01, 6.747219e-01,
79  6.600922e-01, 6.458793e-01, 6.320533e-01, 6.185872e-01, 6.054579e-01,
80  5.926459e-01, 5.801347e-01, 5.679103e-01, 5.559604e-01, 5.442736e-01,
81  5.328395e-01, 5.216482e-01, 5.106904e-01, 4.999575e-01, 4.894415e-01,
82  4.791351e-01, 4.690316e-01, 4.591249e-01, 4.494094e-01, 4.398800e-01,
83  4.305320e-01, 4.213608e-01, 4.123623e-01, 4.035325e-01, 3.948676e-01,
84  3.863639e-01, 3.780179e-01, 3.698262e-01, 3.617858e-01, 3.538933e-01,
85  3.461460e-01, 3.385411e-01, 3.310757e-01, 3.237474e-01, 3.165536e-01,
86  3.094921e-01, 3.025605e-01, 2.957566e-01, 2.890784e-01, 2.825237e-01,
87  2.760907e-01, 2.697773e-01, 2.635817e-01, 2.575020e-01, 2.515365e-01,
88  2.456834e-01, 2.399409e-01, 2.343074e-01, 2.287812e-01, 2.233607e-01,
89  2.180442e-01, 2.128303e-01, 2.077174e-01, 2.027040e-01, 1.977885e-01,
90  1.929696e-01, 1.882457e-01, 1.836155e-01, 1.790775e-01, 1.746305e-01,
91  1.702730e-01, 1.660036e-01, 1.618212e-01, 1.577243e-01, 1.537117e-01,
92  1.497822e-01, 1.459344e-01, 1.421671e-01, 1.384791e-01, 1.348691e-01,
93  1.313360e-01, 1.278785e-01, 1.244956e-01, 1.211859e-01, 1.179483e-01,
94  1.147818e-01, 1.116850e-01, 1.086570e-01, 1.056966e-01, 1.028026e-01,
95  9.997405e-02, 9.720975e-02, 9.450865e-02, 9.186969e-02, 8.929179e-02,
96  8.677391e-02, 8.431501e-02, 8.191406e-02, 7.957003e-02, 7.728192e-02,
97  7.504872e-02, 7.286944e-02, 7.074311e-02, 6.866874e-02, 6.664538e-02,
98  6.467208e-02, 6.274790e-02, 6.087191e-02, 5.904317e-02, 5.726079e-02,
99  5.552387e-02, 5.383150e-02, 5.218282e-02, 5.057695e-02, 4.901302e-02,
100  4.749020e-02, 4.600763e-02, 4.456450e-02, 4.315997e-02, 4.179325e-02,
101  4.046353e-02, 3.917002e-02, 3.791195e-02, 3.668855e-02, 3.549906e-02,
102  3.434274e-02, 3.321884e-02, 3.212665e-02, 3.106544e-02, 3.003452e-02,
103  2.903319e-02, 2.806076e-02, 2.711656e-02, 2.619993e-02, 2.531021e-02,
104  2.444677e-02, 2.360897e-02, 2.279620e-02, 2.200783e-02, 2.124327e-02,
105  2.050194e-02, 1.978324e-02, 1.908662e-02, 1.841151e-02, 1.775735e-02,
106  1.712363e-02, 1.650979e-02, 1.591533e-02, 1.533973e-02, 1.478250e-02,
107  1.424314e-02, 1.372117e-02, 1.321613e-02, 1.272755e-02, 1.225498e-02,
108  1.179798e-02, 1.135611e-02, 1.092896e-02, 1.051609e-02, 1.011712e-02,
109  9.731635e-03, 9.359254e-03, 8.999595e-03, 8.652287e-03, 8.316967e-03,
110  7.993280e-03, 7.680879e-03, 7.379426e-03, 7.088591e-03, 6.808051e-03,
111  6.537491e-03, 6.276605e-03, 6.025092e-03, 5.782661e-03, 5.549027e-03,
112  5.323912e-03, 5.107045e-03, 4.898164e-03, 4.697011e-03, 4.503336e-03,
113  4.316896e-03, 4.137454e-03, 3.964780e-03, 3.798649e-03, 3.638843e-03,
114  3.485150e-03, 3.337364e-03, 3.195284e-03, 3.058715e-03, 2.927469e-03,
115  2.801361e-03, 2.680213e-03, 2.563852e-03, 2.452110e-03, 2.344824e-03
116 };
117 
119 //
120 // Constructor
121 //
122 
124  G4ProcessType type):G4VDiscreteProcess (processName, type),
125  LowestKineticEnergy (10.*keV),
126  //HighestKineticEnergy (100.*TeV),
127  //TotBin(200),
128  theGamma (G4Gamma::Gamma() ),
129  theElectron ( G4Electron::Electron() ),
130  thePositron ( G4Positron::Positron() ),
131  //GammaCutInKineticEnergy(nullptr),
132  //ElectronCutInKineticEnergy(nullptr),
133  //PositronCutInKineticEnergy(nullptr),
134  //ParticleCutInKineticEnergy(nullptr),
135  fAlpha(0.0), fRootNumber(80),
136  fVerboseLevel( verboseLevel )
137 {
139 
140  fFieldPropagator = transportMgr->GetPropagatorInField();
142  CutInRange = GammaCutInKineticEnergyNow = ElectronCutInKineticEnergyNow =
143  PositronCutInKineticEnergyNow = ParticleCutInKineticEnergyNow = fKsi =
144  fPsiGamma = fEta = fOrderAngleK = 0.0;
145 }
146 
148 //
149 // Destructor
150 //
151 
153 {}
154 
155 
156 G4bool
158 {
159 
160  return ( ( &particle == (const G4ParticleDefinition *)theElectron ) ||
161  ( &particle == (const G4ParticleDefinition *)thePositron ) );
162 
163 }
164 
166 //
167 //
168 // Production of synchrotron X-ray photon
169 // GEANT4 internal units.
170 //
171 
172 
173 G4double
175  G4double,
177 {
178  // gives the MeanFreePath in GEANT4 internal units
179  G4double MeanFreePath;
180 
181  const G4DynamicParticle* aDynamicParticle = trackData.GetDynamicParticle();
182  // G4Material* aMaterial = trackData.GetMaterial();
183 
184  //G4bool isOutRange ;
185 
186  *condition = NotForced ;
187 
188  G4double gamma = aDynamicParticle->GetTotalEnergy()/
189  aDynamicParticle->GetMass();
190 
191  G4double particleCharge = aDynamicParticle->GetDefinition()->GetPDGCharge();
192 
193  G4double KineticEnergy = aDynamicParticle->GetKineticEnergy();
194 
195  if ( KineticEnergy < LowestKineticEnergy || gamma < 1.0e3 ) MeanFreePath = DBL_MAX;
196  else
197  {
198 
199  G4ThreeVector FieldValue;
200  const G4Field* pField = nullptr;
201 
202  G4FieldManager* fieldMgr=nullptr;
203  G4bool fieldExertsForce = false;
204 
205  if( (particleCharge != 0.0) )
206  {
207  fieldMgr = fFieldPropagator->FindAndSetFieldManager( trackData.GetVolume() );
208 
209  if ( fieldMgr != nullptr )
210  {
211  // If the field manager has no field, there is no field !
212 
213  fieldExertsForce = ( fieldMgr->GetDetectorField() != nullptr );
214  }
215  }
216  if ( fieldExertsForce )
217  {
218  pField = fieldMgr->GetDetectorField() ;
219  G4ThreeVector globPosition = trackData.GetPosition();
220 
221  G4double globPosVec[4], FieldValueVec[6];
222 
223  globPosVec[0] = globPosition.x();
224  globPosVec[1] = globPosition.y();
225  globPosVec[2] = globPosition.z();
226  globPosVec[3] = trackData.GetGlobalTime();
227 
228  pField->GetFieldValue( globPosVec, FieldValueVec );
229 
230  FieldValue = G4ThreeVector( FieldValueVec[0],
231  FieldValueVec[1],
232  FieldValueVec[2] );
233 
234 
235 
236  G4ThreeVector unitMomentum = aDynamicParticle->GetMomentumDirection();
237  G4ThreeVector unitMcrossB = FieldValue.cross(unitMomentum) ;
238  G4double perpB = unitMcrossB.mag() ;
239  G4double beta = aDynamicParticle->GetTotalMomentum()/
240  (aDynamicParticle->GetTotalEnergy() );
241 
242  if( perpB > 0.0 ) MeanFreePath = fLambdaConst*beta/perpB;
243  else MeanFreePath = DBL_MAX;
244  }
245  else MeanFreePath = DBL_MAX;
246  }
247  if(fVerboseLevel > 0)
248  {
249  G4cout<<"G4SynchrotronRadiationInMat::MeanFreePath = "<<MeanFreePath/m<<" m"<<G4endl;
250  }
251  return MeanFreePath;
252 }
253 
255 //
256 //
257 
260  const G4Step& stepData )
261 
262 {
263  aParticleChange.Initialize(trackData);
264 
265  const G4DynamicParticle* aDynamicParticle=trackData.GetDynamicParticle();
266 
267  G4double gamma = aDynamicParticle->GetTotalEnergy()/
268  (aDynamicParticle->GetMass() );
269 
270  if(gamma <= 1.0e3 )
271  {
272  return G4VDiscreteProcess::PostStepDoIt(trackData,stepData);
273  }
274  G4double particleCharge = aDynamicParticle->GetDefinition()->GetPDGCharge();
275 
276  G4ThreeVector FieldValue;
277  const G4Field* pField = nullptr ;
278 
279  G4FieldManager* fieldMgr=nullptr;
280  G4bool fieldExertsForce = false;
281 
282  if( (particleCharge != 0.0) )
283  {
284  fieldMgr = fFieldPropagator->FindAndSetFieldManager( trackData.GetVolume() );
285  if ( fieldMgr != nullptr )
286  {
287  // If the field manager has no field, there is no field !
288 
289  fieldExertsForce = ( fieldMgr->GetDetectorField() != nullptr );
290  }
291  }
292  if ( fieldExertsForce )
293  {
294  pField = fieldMgr->GetDetectorField() ;
295  G4ThreeVector globPosition = trackData.GetPosition() ;
296  G4double globPosVec[4], FieldValueVec[6] ;
297  globPosVec[0] = globPosition.x() ;
298  globPosVec[1] = globPosition.y() ;
299  globPosVec[2] = globPosition.z() ;
300  globPosVec[3] = trackData.GetGlobalTime();
301 
302  pField->GetFieldValue( globPosVec, FieldValueVec ) ;
303  FieldValue = G4ThreeVector( FieldValueVec[0],
304  FieldValueVec[1],
305  FieldValueVec[2] );
306 
307  G4ThreeVector unitMomentum = aDynamicParticle->GetMomentumDirection();
308  G4ThreeVector unitMcrossB = FieldValue.cross(unitMomentum);
309  G4double perpB = unitMcrossB.mag() ;
310  if(perpB > 0.0)
311  {
312  // M-C of synchrotron photon energy
313 
314  G4double energyOfSR = GetRandomEnergySR(gamma,perpB);
315 
316  if(fVerboseLevel > 0)
317  {
318  G4cout<<"SR photon energy = "<<energyOfSR/keV<<" keV"<<G4endl;
319  }
320  // check against insufficient energy
321 
322  if( energyOfSR <= 0.0 )
323  {
324  return G4VDiscreteProcess::PostStepDoIt(trackData,stepData);
325  }
326  G4double kineticEnergy = aDynamicParticle->GetKineticEnergy();
328  particleDirection = aDynamicParticle->GetMomentumDirection();
329 
330  // M-C of its direction, simplified dipole busted approach
331 
332  // G4double Teta = G4UniformRand()/gamma ; // Very roughly
333 
334  G4double cosTheta, sinTheta, fcos, beta;
335 
336  do
337  {
338  cosTheta = 1. - 2.*G4UniformRand();
339  fcos = (1 + cosTheta*cosTheta)*0.5;
340  }
341  // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
342  while( fcos < G4UniformRand() );
343 
344  beta = std::sqrt(1. - 1./(gamma*gamma));
345 
346  cosTheta = (cosTheta + beta)/(1. + beta*cosTheta);
347 
348  if( cosTheta > 1. ) cosTheta = 1.;
349  if( cosTheta < -1. ) cosTheta = -1.;
350 
351  sinTheta = std::sqrt(1. - cosTheta*cosTheta );
352 
353  G4double Phi = twopi * G4UniformRand() ;
354 
355  G4double dirx = sinTheta*std::cos(Phi) ,
356  diry = sinTheta*std::sin(Phi) ,
357  dirz = cosTheta;
358 
359  G4ThreeVector gammaDirection ( dirx, diry, dirz);
360  gammaDirection.rotateUz(particleDirection);
361 
362  // polarization of new gamma
363 
364  // G4double sx = std::cos(Teta)*std::cos(Phi);
365  // G4double sy = std::cos(Teta)*std::sin(Phi);
366  // G4double sz = -std::sin(Teta);
367 
368  G4ThreeVector gammaPolarization = FieldValue.cross(gammaDirection);
369  gammaPolarization = gammaPolarization.unit();
370 
371  // (sx, sy, sz);
372  // gammaPolarization.rotateUz(particleDirection);
373 
374  // create G4DynamicParticle object for the SR photon
375 
377  gammaDirection,
378  energyOfSR );
379  aGamma->SetPolarization( gammaPolarization.x(),
380  gammaPolarization.y(),
381  gammaPolarization.z() );
382 
383 
385  aParticleChange.AddSecondary(aGamma);
386 
387  // Update the incident particle
388 
389  G4double newKinEnergy = kineticEnergy - energyOfSR ;
390 
391  if (newKinEnergy > 0.)
392  {
393  aParticleChange.ProposeMomentumDirection( particleDirection );
394  aParticleChange.ProposeEnergy( newKinEnergy );
396  }
397  else
398  {
401  G4double charge = aDynamicParticle->GetDefinition()->GetPDGCharge();
402  if (charge<0.)
403  {
405  }
406  else
407  {
409  }
410  }
411  }
412  else
413  {
414  return G4VDiscreteProcess::PostStepDoIt(trackData,stepData);
415  }
416  }
417  return G4VDiscreteProcess::PostStepDoIt(trackData,stepData);
418 }
419 
420 
421 G4double
423  const G4Step& )
424 
425 {
426  G4int i ;
427  G4double energyOfSR = -1.0 ;
428  //G4Material* aMaterial=trackData.GetMaterial() ;
429 
430  const G4DynamicParticle* aDynamicParticle=trackData.GetDynamicParticle();
431 
432  G4double gamma = aDynamicParticle->GetTotalEnergy()/
433  (aDynamicParticle->GetMass() ) ;
434 
435  G4double particleCharge = aDynamicParticle->GetDefinition()->GetPDGCharge();
436 
437  G4ThreeVector FieldValue;
438  const G4Field* pField = nullptr ;
439 
440  G4FieldManager* fieldMgr=nullptr;
441  G4bool fieldExertsForce = false;
442 
443  if( (particleCharge != 0.0) )
444  {
445  fieldMgr = fFieldPropagator->FindAndSetFieldManager( trackData.GetVolume() );
446  if ( fieldMgr != nullptr )
447  {
448  // If the field manager has no field, there is no field !
449 
450  fieldExertsForce = ( fieldMgr->GetDetectorField() != 0 );
451  }
452  }
453  if ( fieldExertsForce )
454  {
455  pField = fieldMgr->GetDetectorField();
456  G4ThreeVector globPosition = trackData.GetPosition();
457  G4double globPosVec[3], FieldValueVec[3];
458 
459  globPosVec[0] = globPosition.x();
460  globPosVec[1] = globPosition.y();
461  globPosVec[2] = globPosition.z();
462 
463  pField->GetFieldValue( globPosVec, FieldValueVec );
464  FieldValue = G4ThreeVector( FieldValueVec[0],
465  FieldValueVec[1],
466  FieldValueVec[2] );
467 
468  G4ThreeVector unitMomentum = aDynamicParticle->GetMomentumDirection();
469  G4ThreeVector unitMcrossB = FieldValue.cross(unitMomentum) ;
470  G4double perpB = unitMcrossB.mag();
471  if( perpB > 0.0 )
472  {
473  // M-C of synchrotron photon energy
474 
475  G4double random = G4UniformRand() ;
476  for(i=0;i<200;i++)
477  {
478  if(random >= fIntegralProbabilityOfSR[i]) break ;
479  }
480  energyOfSR = 0.0001*i*i*fEnergyConst*gamma*gamma*perpB ;
481 
482  // check against insufficient energy
483 
484  if(energyOfSR <= 0.0)
485  {
486  return -1.0 ;
487  }
488  //G4double kineticEnergy = aDynamicParticle->GetKineticEnergy();
489  //G4ParticleMomentum
490  //particleDirection = aDynamicParticle->GetMomentumDirection();
491 
492  // Gamma production cut in this material
493  //G4double
494  //gammaEnergyCut = (G4Gamma::GetCutsInEnergy())[aMaterial->GetIndex()];
495 
496  // SR photon has energy more than the current material cut
497  // M-C of its direction
498 
499  //G4double Teta = G4UniformRand()/gamma ; // Very roughly
500 
501  //G4double Phi = twopi * G4UniformRand() ;
502  }
503  else
504  {
505  return -1.0 ;
506  }
507  }
508  return energyOfSR ;
509 }
510 
512 //
513 //
514 
516 {
517  G4int i, iMax;
518  G4double energySR, random, position;
519 
520  iMax = 200;
521  random = G4UniformRand();
522 
523  for( i = 0; i < iMax; i++ )
524  {
525  if( random >= fIntegralProbabilityOfSR[i] ) break;
526  }
527  if(i <= 0 ) position = G4UniformRand(); // 0.
528  else if( i>= iMax) position = G4double(iMax);
529  else position = i + G4UniformRand(); // -1
530  //
531  // it was in initial implementation:
532  // energyOfSR = 0.0001*i*i*fEnergyConst*gamma*gamma*perpB ;
533 
534  energySR = 0.0001*position*position*fEnergyConst*gamma*gamma*perpB;
535 
536  if( energySR < 0. ) energySR = 0.;
537 
538  return energySR;
539 }
540 
542 //
543 // return
544 
546 {
547  G4double result, hypCos2, hypCos=std::cosh(t);
548 
549  hypCos2 = hypCos*hypCos;
550  result = std::cosh(5.*t/3.)*std::exp(t-fKsi*hypCos); // fKsi > 0. !
551  result /= hypCos2;
552  return result;
553 }
554 
556 //
557 // return the probability to emit SR photon with relative energy
558 // energy/energy_c >= ksi
559 // for ksi <= 0. P = 1., however the method works for ksi > 0 only!
560 
562 {
563  if (ksi <= 0.) return 1.0;
564  fKsi = ksi; // should be > 0. !
565  G4int n;
566  G4double result, a;
567 
568  a = fAlpha; // always = 0.
569  n = fRootNumber; // around default = 80
570 
572 
573  result = integral.Laguerre(this,
575 
576  result *= 3./5./pi;
577 
578  return result;
579 }
580 
582 //
583 // return an auxiliary function for K_5/3 integral representation
584 
586 {
587  G4double result, hypCos=std::cosh(t);
588 
589  result = std::cosh(5.*t/3.)*std::exp(t - fKsi*hypCos); // fKsi > 0. !
590  result /= hypCos;
591  return result;
592 }
593 
595 //
596 // return the probability to emit SR photon energy with relative energy
597 // energy/energy_c >= ksi
598 // for ksi <= 0. P = 1., however the method works for ksi > 0 only!
599 
601 {
602  if (ksi <= 0.) return 1.0;
603  fKsi = ksi; // should be > 0. !
604  G4int n;
605  G4double result, a;
606 
607  a = fAlpha; // always = 0.
608  n = fRootNumber; // around default = 80
609 
611 
612  result = integral.Laguerre(this,
614 
615  result *= 9.*std::sqrt(3.)*ksi/8./pi;
616 
617  return result;
618 }
619 
621 //
622 //
623 
625 {
626  G4double result, hypCos=std::cosh(t);
627 
628  result = std::cosh(fOrderAngleK*t)*std::exp(t - fEta*hypCos); // fEta > 0. !
629  result /= hypCos;
630  return result;
631 }
632 
634 //
635 // Return K 1/3 or 2/3 for angular distribution
636 
638 {
639  fEta = eta; // should be > 0. !
640  G4int n;
641  G4double result, a;
642 
643  a = fAlpha; // always = 0.
644  n = fRootNumber; // around default = 80
645 
647 
648  result = integral.Laguerre(this,
650 
651  return result;
652 }
653 
655 //
656 // Relative angle diff distribution for given fKsi, which is set externally
657 
659 {
660  G4double result, funK, funK2, gpsi2 = gpsi*gpsi;
661 
662  fPsiGamma = gpsi;
663  fEta = 0.5*fKsi*(1. + gpsi2)*std::sqrt(1. + gpsi2);
664 
665  fOrderAngleK = 1./3.;
666  funK = GetAngleK(fEta);
667  funK2 = funK*funK;
668 
669  result = gpsi2*funK2/(1. + gpsi2);
670 
671  fOrderAngleK = 2./3.;
672  funK = GetAngleK(fEta);
673  funK2 = funK*funK;
674 
675  result += funK2;
676  result *= (1. + gpsi2)*fKsi;
677 
678  return result;
679 }
680 
681 
683 
G4double G4ParticleHPJENDLHEData::G4double result
G4double condition(const G4ErrorSymMatrix &m)
G4VParticleChange * PostStepDoIt(const G4Track &track, const G4Step &Step) override
G4double GetKineticEnergy() const
CLHEP::Hep3Vector G4ThreeVector
G4double GetTotalEnergy() const
virtual void GetFieldValue(const double Point[4], double *fieldArr) const =0
double x() const
const G4DynamicParticle * GetDynamicParticle() const
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33
const G4ThreeVector & GetPosition() const
G4ParticleDefinition * GetDefinition() const
G4double GetMeanFreePath(const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
G4double fcos(G4double arg)
int G4int
Definition: G4Types.hh:78
double z() const
void ProposeLocalEnergyDeposit(G4double anEnergyPart)
static constexpr double twopi
Definition: G4SIunits.hh:76
G4double GetTotalMomentum() const
G4bool IsApplicable(const G4ParticleDefinition &) override
#define position
Definition: xmlparse.cc:622
#define G4UniformRand()
Definition: Randomize.hh:97
G4SynchrotronRadiationInMat(const G4String &processName="SynchrotronRadiation", G4ProcessType type=fElectromagnetic)
G4GLOB_DLL std::ostream G4cout
static constexpr double m
Definition: G4SIunits.hh:129
G4double GetPhotonEnergy(const G4Track &trackData, const G4Step &stepData)
G4double GetMass() const
bool G4bool
Definition: G4Types.hh:79
const G4ThreeVector & GetMomentumDirection() const
Hep3Vector & rotateUz(const Hep3Vector &)
Definition: ThreeVector.cc:38
static constexpr double eplus
Definition: G4SIunits.hh:199
void SetProcessSubType(G4int)
Definition: G4VProcess.hh:432
float electron_mass_c2
Definition: hepunit.py:274
Definition: G4Step.hh:76
const G4int n
G4double GetGlobalTime() const
void SetPolarization(G4double polX, G4double polY, G4double polZ)
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86
G4FieldManager * FindAndSetFieldManager(G4VPhysicalVolume *pCurrentPhysVol)
static G4TransportationManager * GetTransportationManager()
virtual void Initialize(const G4Track &)
void SetNumberOfSecondaries(G4int totSecondaries)
Hep3Vector unit() const
double y() const
void ProposeEnergy(G4double finalEnergy)
G4ParticleChange aParticleChange
Definition: G4VProcess.hh:289
G4VPhysicalVolume * GetVolume() const
void AddSecondary(G4Track *aSecondary)
#define G4endl
Definition: G4ios.hh:61
static constexpr double pi
Definition: G4SIunits.hh:75
Hep3Vector cross(const Hep3Vector &) const
void ProposeMomentumDirection(G4double Px, G4double Py, G4double Pz)
double G4double
Definition: G4Types.hh:76
void ProposeTrackStatus(G4TrackStatus status)
const G4Field * GetDetectorField() const
G4ForceCondition
G4double GetPDGCharge() const
G4double GetRandomEnergySR(G4double, G4double)
G4PropagatorInField * GetPropagatorInField() const
double mag() const
#define DBL_MAX
Definition: templates.hh:83
static constexpr double keV
Definition: G4SIunits.hh:216
virtual G4VParticleChange * PostStepDoIt(const G4Track &, const G4Step &)
float c_light
Definition: hepunit.py:257
G4ProcessType
G4double Laguerre(T &typeT, F f, G4double alpha, G4int n)