Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4LivermoreNuclearGammaConversionModel Class Reference

#include <G4LivermoreNuclearGammaConversionModel.hh>

+ Inheritance diagram for G4LivermoreNuclearGammaConversionModel:

Public Member Functions

 G4LivermoreNuclearGammaConversionModel (const G4ParticleDefinition *p=nullptr, const G4String &nam="LivermoreNuclearConversion")
 
virtual ~G4LivermoreNuclearGammaConversionModel ()
 
void Initialise (const G4ParticleDefinition *, const G4DataVector &) override
 
void InitialiseLocal (const G4ParticleDefinition *, G4VEmModel *masterModel) override
 
void InitialiseForElement (const G4ParticleDefinition *, G4int Z) override
 
G4double ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A=0, G4double cut=0, G4double emax=DBL_MAX) override
 
void SampleSecondaries (std::vector< G4DynamicParticle * > *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin, G4double maxEnergy) override
 
G4double MinPrimaryEnergy (const G4Material *, const G4ParticleDefinition *, G4double) override
 
G4LivermoreNuclearGammaConversionModel & operator= (const G4LivermoreNuclearGammaConversionModel &right)=delete
 
 G4LivermoreNuclearGammaConversionModel (const G4LivermoreNuclearGammaConversionModel &)=delete
 
- Public Member Functions inherited from G4VEmModel
 G4VEmModel (const G4String &nam)
 
virtual ~G4VEmModel ()
 
virtual void Initialise (const G4ParticleDefinition *, const G4DataVector &)=0
 
virtual void SampleSecondaries (std::vector< G4DynamicParticle * > *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin=0.0, G4double tmax=DBL_MAX)=0
 
virtual void InitialiseLocal (const G4ParticleDefinition *, G4VEmModel *masterModel)
 
virtual void InitialiseForMaterial (const G4ParticleDefinition *, const G4Material *)
 
virtual void InitialiseForElement (const G4ParticleDefinition *, G4int Z)
 
virtual G4double ComputeDEDXPerVolume (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=DBL_MAX)
 
virtual G4double CrossSectionPerVolume (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
virtual G4double GetPartialCrossSection (const G4Material *, G4int level, const G4ParticleDefinition *, G4double kineticEnergy)
 
virtual G4double ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A=0., G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
virtual G4double ComputeCrossSectionPerShell (const G4ParticleDefinition *, G4int Z, G4int shellIdx, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
virtual G4double ChargeSquareRatio (const G4Track &)
 
virtual G4double GetChargeSquareRatio (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
 
virtual G4double GetParticleCharge (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
 
virtual void StartTracking (G4Track *)
 
virtual void CorrectionsAlongStep (const G4MaterialCutsCouple *, const G4DynamicParticle *, const G4double &length, G4double &eloss)
 
virtual G4double Value (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy)
 
virtual G4double MinPrimaryEnergy (const G4Material *, const G4ParticleDefinition *, G4double cut=0.0)
 
virtual G4double MinEnergyCut (const G4ParticleDefinition *, const G4MaterialCutsCouple *)
 
virtual void SetupForMaterial (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
 
virtual void DefineForRegion (const G4Region *)
 
virtual void FillNumberOfSecondaries (G4int &numberOfTriplets, G4int &numberOfRecoil)
 
virtual void ModelDescription (std::ostream &outFile) const
 
void InitialiseElementSelectors (const G4ParticleDefinition *, const G4DataVector &)
 
std::vector< G4EmElementSelector * > * GetElementSelectors ()
 
void SetElementSelectors (std::vector< G4EmElementSelector * > *)
 
G4double ComputeDEDX (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=DBL_MAX)
 
G4double CrossSection (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
G4double ComputeMeanFreePath (const G4ParticleDefinition *, G4double kineticEnergy, const G4Material *, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
G4double ComputeCrossSectionPerAtom (const G4ParticleDefinition *, const G4Element *, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
const G4Element * SelectRandomAtom (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
const G4Element * SelectTargetAtom (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double logKineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
const G4Element * SelectRandomAtom (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
const G4Element * GetCurrentElement (const G4Material *mat=nullptr) const
 
G4int SelectRandomAtomNumber (const G4Material *) const
 
const G4Isotope * GetCurrentIsotope (const G4Element *elm=nullptr) const
 
G4int SelectIsotopeNumber (const G4Element *) const
 
void SetParticleChange (G4VParticleChange *, G4VEmFluctuationModel *f=nullptr)
 
void SetCrossSectionTable (G4PhysicsTable *, G4bool isLocal)
 
G4ElementData * GetElementData ()
 
G4PhysicsTable * GetCrossSectionTable ()
 
G4VEmFluctuationModel * GetModelOfFluctuations ()
 
G4VEmAngularDistribution * GetAngularDistribution ()
 
G4VEmModel * GetTripletModel ()
 
void SetTripletModel (G4VEmModel *)
 
void SetAngularDistribution (G4VEmAngularDistribution *)
 
G4double HighEnergyLimit () const
 
G4double LowEnergyLimit () const
 
G4double HighEnergyActivationLimit () const
 
G4double LowEnergyActivationLimit () const
 
G4double PolarAngleLimit () const
 
G4double SecondaryThreshold () const
 
G4bool LPMFlag () const
 
G4bool DeexcitationFlag () const
 
G4bool ForceBuildTableFlag () const
 
G4bool UseAngularGeneratorFlag () const
 
void SetAngularGeneratorFlag (G4bool)
 
void SetHighEnergyLimit (G4double)
 
void SetLowEnergyLimit (G4double)
 
void SetActivationHighEnergyLimit (G4double)
 
void SetActivationLowEnergyLimit (G4double)
 
G4bool IsActive (G4double kinEnergy) const
 
void SetPolarAngleLimit (G4double)
 
void SetSecondaryThreshold (G4double)
 
void SetLPMFlag (G4bool val)
 
void SetDeexcitationFlag (G4bool val)
 
void SetForceBuildTable (G4bool val)
 
void SetFluctuationFlag (G4bool val)
 
void SetMasterThread (G4bool val)
 
G4bool IsMaster () const
 
void SetUseBaseMaterials (G4bool val)
 
G4bool UseBaseMaterials () const
 
G4double MaxSecondaryKinEnergy (const G4DynamicParticle *dynParticle)
 
const G4String & GetName () const
 
void SetCurrentCouple (const G4MaterialCutsCouple *)
 
G4bool IsLocked () const
 
void SetLocked (G4bool)
 
G4VEmModel & operator= (const G4VEmModel &right)=delete
 
 G4VEmModel (const G4VEmModel &)=delete
 

Additional Inherited Members

- Protected Member Functions inherited from G4VEmModel
G4ParticleChangeForLoss * GetParticleChangeForLoss ()
 
G4ParticleChangeForGamma * GetParticleChangeForGamma ()
 
virtual G4double MaxSecondaryEnergy (const G4ParticleDefinition *, G4double kineticEnergy)
 
const G4MaterialCutsCouple * CurrentCouple () const
 
void SetCurrentElement (const G4Element *)
 
- Protected Attributes inherited from G4VEmModel
G4ElementData * fElementData = nullptr
 
G4VParticleChange * pParticleChange = nullptr
 
G4PhysicsTable * xSectionTable = nullptr
 
const G4Material * pBaseMaterial = nullptr
 
const std::vector< G4double > * theDensityFactor = nullptr
 
const std::vector< G4int > * theDensityIdx = nullptr
 
G4double inveplus
 
G4double pFactor = 1.0
 
size_t currentCoupleIndex = 0
 
size_t basedCoupleIndex = 0
 
G4bool lossFlucFlag = true
 

Detailed Description

Definition at line 38 of file G4LivermoreNuclearGammaConversionModel.hh.

Constructor & Destructor Documentation

◆ G4LivermoreNuclearGammaConversionModel() [1/2]

G4LivermoreNuclearGammaConversionModel::G4LivermoreNuclearGammaConversionModel ( const G4ParticleDefinition *  p = nullptr,
const G4String &  nam = "LivermoreNuclearConversion" 
)
explicit

Definition at line 47 of file G4LivermoreNuclearGammaConversionModel.cc.

49 :G4VEmModel(nam),smallEnergy(2.*MeV),
50 isInitialised(false)
51{
52 fParticleChange = nullptr;
53
54 lowEnergyLimit = 2.0*electron_mass_c2;
55
56 verboseLevel= 0;
57 // Verbosity scale for debugging purposes:
58 // 0 = nothing
59 // 1 = calculation of cross sections, file openings...
60 // 2 = entering in methods
61
62 if(verboseLevel > 0)
63 {
64 G4cout << "G4LivermoreNuclearGammaConversionModel is constructed " << G4endl;
65 }
66}
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout

◆ ~G4LivermoreNuclearGammaConversionModel()

G4LivermoreNuclearGammaConversionModel::~G4LivermoreNuclearGammaConversionModel ( )
virtual

Definition at line 70 of file G4LivermoreNuclearGammaConversionModel.cc.

71{
72 if(IsMaster()) {
73 for(G4int i=0; i<maxZ; ++i) {
74 if(data[i]) {
75 delete data[i];
76 data[i] = 0;
77 }
78 }
79 }
80}
G4int
int G4int
Definition: G4Types.hh:85
G4VEmModel::IsMaster
G4bool IsMaster() const
Definition: G4VEmModel.hh:725

◆ G4LivermoreNuclearGammaConversionModel() [2/2]

G4LivermoreNuclearGammaConversionModel::G4LivermoreNuclearGammaConversionModel ( const G4LivermoreNuclearGammaConversionModel &  )
delete

Member Function Documentation

◆ ComputeCrossSectionPerAtom()

G4double G4LivermoreNuclearGammaConversionModel::ComputeCrossSectionPerAtom ( const G4ParticleDefinition *  ,
G4double  kinEnergy,
G4double  Z,
G4double  A = 0,
G4double  cut = 0,
G4double  emax = DBL_MAX 
)
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 210 of file G4LivermoreNuclearGammaConversionModel.cc.

214{
215 if (verboseLevel > 1)
216 {
217 G4cout << "Calling ComputeCrossSectionPerAtom() of G4LivermoreNuclearGammaConversionModel"
218 << G4endl;
219 }
220
221 if (GammaEnergy < lowEnergyLimit) { return 0.0; }
222
223 G4double xs = 0.0;
224
225 G4int intZ=G4int(Z);
226
227 if(intZ < 1 || intZ > maxZ) { return xs; }
228
229 G4PhysicsFreeVector* pv = data[intZ];
230
231 // if element was not initialised
232 // do initialisation safely for MT mode
233 if(!pv)
234 {
235 InitialiseForElement(0, intZ);
236 pv = data[intZ];
237 if(!pv) { return xs; }
238 }
239 // x-section is taken from the table
240 xs = pv->Value(GammaEnergy);
241
242 if(verboseLevel > 0)
243 {
244 std::size_t n = pv->GetVectorLength() - 1;
245 G4cout << "****** DEBUG: tcs value for Z=" << Z << " at energy (MeV)="
246 << GammaEnergy/MeV << G4endl;
247 G4cout << " cs (Geant4 internal unit)=" << xs << G4endl;
248 G4cout << " -> first cs value in EADL data file (iu) =" << (*pv)[0] << G4endl;
249 G4cout << " -> last cs value in EADL data file (iu) =" << (*pv)[n] << G4endl;
250 G4cout << "*********************************************************" << G4endl;
251 }
252 return xs;
253}
G4double
double G4double
Definition: G4Types.hh:83
Z
const G4int Z[17]
Definition: G4WaterStopping.cc:51
G4LivermoreNuclearGammaConversionModel::InitialiseForElement
void InitialiseForElement(const G4ParticleDefinition *, G4int Z) override
Definition: G4LivermoreNuclearGammaConversionModel.cc:456
G4PhysicsVector::Value
G4double Value(const G4double energy, std::size_t &lastidx) const
G4PhysicsVector::GetVectorLength
std::size_t GetVectorLength() const

◆ Initialise()

void G4LivermoreNuclearGammaConversionModel::Initialise ( const G4ParticleDefinition *  particle,
const G4DataVector &  cuts 
)
overridevirtual

Implements G4VEmModel.

Definition at line 84 of file G4LivermoreNuclearGammaConversionModel.cc.

87{
88 if (verboseLevel > 1)
89 {
90 G4cout << "Calling Initialise() of G4LivermoreNuclearGammaConversionModel."
91 << G4endl
92 << "Energy range: "
93 << LowEnergyLimit() / MeV << " MeV - "
94 << HighEnergyLimit() / GeV << " GeV"
95 << G4endl;
96 }
97
98 if(IsMaster())
99 {
100
101 // Initialise element selector
102 InitialiseElementSelectors(particle, cuts);
103
104 // Access to elements
105 const char* path = G4FindDataDir("G4LEDATA");
106
107 G4ProductionCutsTable* theCoupleTable =
108 G4ProductionCutsTable::GetProductionCutsTable();
109
110 G4int numOfCouples = (G4int)theCoupleTable->GetTableSize();
111
112 for(G4int i=0; i<numOfCouples; ++i)
113 {
114 const G4Material* material =
115 theCoupleTable->GetMaterialCutsCouple(i)->GetMaterial();
116 const G4ElementVector* theElementVector = material->GetElementVector();
117 std::size_t nelm = material->GetNumberOfElements();
118
119 for (std::size_t j=0; j<nelm; ++j)
120 {
121 G4int Z = (G4int)(*theElementVector)[j]->GetZ();
122 if(Z < 1) { Z = 1; }
123 else if(Z > maxZ) { Z = maxZ; }
124 if(!data[Z]) { ReadData(Z, path); }
125 }
126 }
127 }
128 if(isInitialised) { return; }
129 fParticleChange = GetParticleChangeForGamma();
130 isInitialised = true;
131}
G4ElementVector
std::vector< const G4Element * > G4ElementVector
Definition: G4ElementVector.hh:44
G4FindDataDir
const char * G4FindDataDir(const char *)
Definition: G4FindDataDir.cc:93
G4MaterialCutsCouple::GetMaterial
const G4Material * GetMaterial() const
Definition: G4MaterialCutsCouple.hh:166
G4Material::GetElementVector
const G4ElementVector * GetElementVector() const
Definition: G4Material.hh:185
G4Material::GetNumberOfElements
size_t GetNumberOfElements() const
Definition: G4Material.hh:181
G4ProductionCutsTable::GetMaterialCutsCouple
const G4MaterialCutsCouple * GetMaterialCutsCouple(G4int i) const
Definition: G4ProductionCutsTable.hh:246
G4ProductionCutsTable::GetTableSize
std::size_t GetTableSize() const
Definition: G4ProductionCutsTable.hh:239
G4ProductionCutsTable::GetProductionCutsTable
static G4ProductionCutsTable * GetProductionCutsTable()
Definition: G4ProductionCutsTable.cc:58
G4VEmModel::GetParticleChangeForGamma
G4ParticleChangeForGamma * GetParticleChangeForGamma()
Definition: G4VEmModel.cc:124
G4VEmModel::LowEnergyLimit
G4double LowEnergyLimit() const
Definition: G4VEmModel.hh:641
G4VEmModel::HighEnergyLimit
G4double HighEnergyLimit() const
Definition: G4VEmModel.hh:634
G4VEmModel::InitialiseElementSelectors
void InitialiseElementSelectors(const G4ParticleDefinition *, const G4DataVector &)
Definition: G4VEmModel.cc:139

◆ InitialiseForElement()

void G4LivermoreNuclearGammaConversionModel::InitialiseForElement ( const G4ParticleDefinition *  ,
G4int  Z 
)
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 456 of file G4LivermoreNuclearGammaConversionModel.cc.

459{
460 G4AutoLock l(&LivermoreNuclearGammaConversionModelMutex);
461 if(!data[Z]) { ReadData(Z); }
462 l.unlock();
463}

Referenced by ComputeCrossSectionPerAtom().

◆ InitialiseLocal()

void G4LivermoreNuclearGammaConversionModel::InitialiseLocal ( const G4ParticleDefinition *  ,
G4VEmModel *  masterModel 
)
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 135 of file G4LivermoreNuclearGammaConversionModel.cc.

137{
138 SetElementSelectors(masterModel->GetElementSelectors());
139}
G4VEmModel::SetElementSelectors
void SetElementSelectors(std::vector< G4EmElementSelector * > *)
Definition: G4VEmModel.hh:831
G4VEmModel::GetElementSelectors
std::vector< G4EmElementSelector * > * GetElementSelectors()
Definition: G4VEmModel.hh:823

◆ MinPrimaryEnergy()

G4double G4LivermoreNuclearGammaConversionModel::MinPrimaryEnergy ( const G4Material *  ,
const G4ParticleDefinition *  ,
G4double   
)
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 144 of file G4LivermoreNuclearGammaConversionModel.cc.

147{
148 return lowEnergyLimit;
149}

◆ operator=()

G4LivermoreNuclearGammaConversionModel & G4LivermoreNuclearGammaConversionModel::operator= ( const G4LivermoreNuclearGammaConversionModel &  right)
delete

◆ SampleSecondaries()

void G4LivermoreNuclearGammaConversionModel::SampleSecondaries ( std::vector< G4DynamicParticle * > *  fvect,
const G4MaterialCutsCouple *  couple,
const G4DynamicParticle *  aDynamicGamma,
G4double  tmin,
G4double  maxEnergy 
)
overridevirtual

Implements G4VEmModel.

Definition at line 257 of file G4LivermoreNuclearGammaConversionModel.cc.

262{
263 // The energies of the e+ e- secondaries are sampled using the Bethe - Heitler
264 // cross sections with Coulomb correction. A modified version of the random
265 // number techniques of Butcher & Messel is used (Nuc Phys 20(1960),15).
266
267 // Note 1 : Effects due to the breakdown of the Born approximation at low
268 // energy are ignored.
269 // Note 2 : The differential cross section implicitly takes account of
270 // pair creation in both nuclear and atomic electron fields. However triplet
271 // prodution is not generated.
272
273 if (verboseLevel > 1) {
274 G4cout << "Calling SampleSecondaries() of G4LivermoreNuclearGammaConversionModel"
275 << G4endl;
276 }
277
278 G4double photonEnergy = aDynamicGamma->GetKineticEnergy();
279 G4ParticleMomentum photonDirection = aDynamicGamma->GetMomentumDirection();
280
281 G4double epsilon ;
282 G4double epsilon0Local = electron_mass_c2 / photonEnergy ;
283
284 // Do it fast if photon energy < 2. MeV
285 if (photonEnergy < smallEnergy )
286 {
287 epsilon = epsilon0Local + (0.5 - epsilon0Local) * G4UniformRand();
288 }
289 else
290 {
291 // Select randomly one element in the current material
292 const G4ParticleDefinition* particle = aDynamicGamma->GetDefinition();
293 const G4Element* element = SelectRandomAtom(couple,particle,photonEnergy);
294
295 if (element == nullptr)
296 {
297 G4cout << "G4LivermoreNuclearGammaConversionModel::SampleSecondaries - element = 0"
298 << G4endl;
299 return;
300 }
301 G4IonisParamElm* ionisation = element->GetIonisation();
302 if (ionisation == nullptr)
303 {
304 G4cout << "G4LivermoreNuclearGammaConversionModel::SampleSecondaries - ionisation = 0"
305 << G4endl;
306 return;
307 }
308
309 // Extract Coulomb factor for this Elements
310 G4double fZ = 8. * (ionisation->GetlogZ3());
311 if (photonEnergy > 50. * MeV) fZ += 8. * (element->GetfCoulomb());
312
313 // Limits of the screening variable
314 G4double screenFactor = 136. * epsilon0Local / (element->GetIonisation()->GetZ3()) ;
315 G4double screenMax = G4Exp ((42.24 - fZ)/8.368) - 0.952 ;
316 G4double screenMin = std::min(4.*screenFactor,screenMax) ;
317
318 // Limits of the energy sampling
319 G4double epsilon1 = 0.5 - 0.5 * std::sqrt(1. - screenMin / screenMax) ;
320 G4double epsilonMin = std::max(epsilon0Local,epsilon1);
321 G4double epsilonRange = 0.5 - epsilonMin ;
322
323 // Sample the energy rate of the created electron (or positron)
324 G4double screen;
325 G4double gReject ;
326
327 G4double f10 = ScreenFunction1(screenMin) - fZ;
328 G4double f20 = ScreenFunction2(screenMin) - fZ;
329 G4double normF1 = std::max(f10 * epsilonRange * epsilonRange,0.);
330 G4double normF2 = std::max(1.5 * f20,0.);
331
332 do
333 {
334 if (normF1 / (normF1 + normF2) > G4UniformRand() )
335 {
336 epsilon = 0.5 - epsilonRange * std::pow(G4UniformRand(), 0.333333) ;
337 screen = screenFactor / (epsilon * (1. - epsilon));
338 gReject = (ScreenFunction1(screen) - fZ) / f10 ;
339 }
340 else
341 {
342 epsilon = epsilonMin + epsilonRange * G4UniformRand();
343 screen = screenFactor / (epsilon * (1 - epsilon));
344 gReject = (ScreenFunction2(screen) - fZ) / f20 ;
345 }
346 } while ( gReject < G4UniformRand() );
347 } // End of epsilon sampling
348
349 // Fix charges randomly
350 G4double electronTotEnergy;
351 G4double positronTotEnergy;
352
353 if (G4UniformRand() > 0.5)
354 {
355 electronTotEnergy = (1. - epsilon) * photonEnergy;
356 positronTotEnergy = epsilon * photonEnergy;
357 }
358 else
359 {
360 positronTotEnergy = (1. - epsilon) * photonEnergy;
361 electronTotEnergy = epsilon * photonEnergy;
362 }
363
364 // Scattered electron (positron) angles. ( Z - axis along the parent photon)
365 // Universal distribution suggested by L. Urban (Geant3 manual (1993) Phys211),
366 // derived from Tsai distribution (Rev. Mod. Phys. 49, 421 (1977)
367
368 G4double u;
369 const G4double a1 = 0.625;
370 G4double a2 = 3. * a1;
371
372 if (0.25 > G4UniformRand())
373 {
374 u = - G4Log(G4UniformRand() * G4UniformRand()) / a1 ;
375 }
376 else
377 {
378 u = - G4Log(G4UniformRand() * G4UniformRand()) / a2 ;
379 }
380
381 G4double thetaEle = u*electron_mass_c2/electronTotEnergy;
382 G4double thetaPos = u*electron_mass_c2/positronTotEnergy;
383 G4double phi = twopi * G4UniformRand();
384
385 G4double dxEle= std::sin(thetaEle)*std::cos(phi),dyEle= std::sin(thetaEle)*std::sin(phi),dzEle=std::cos(thetaEle);
386 G4double dxPos=-std::sin(thetaPos)*std::cos(phi),dyPos=-std::sin(thetaPos)*std::sin(phi),dzPos=std::cos(thetaPos);
387
388 // Kinematics of the created pair:
389 // the electron and positron are assumed to have a symetric angular
390 // distribution with respect to the Z axis along the parent photon
391
392 G4double electronKineEnergy = std::max(0.,electronTotEnergy - electron_mass_c2) ;
393
394 G4ThreeVector electronDirection (dxEle, dyEle, dzEle);
395 electronDirection.rotateUz(photonDirection);
396
397 G4DynamicParticle* particle1 = new G4DynamicParticle (G4Electron::Electron(),
398 electronDirection,
399 electronKineEnergy);
400
401 // The e+ is always created
402 G4double positronKineEnergy = std::max(0.,positronTotEnergy - electron_mass_c2) ;
403
404 G4ThreeVector positronDirection (dxPos, dyPos, dzPos);
405 positronDirection.rotateUz(photonDirection);
406
407 // Create G4DynamicParticle object for the particle2
408 G4DynamicParticle* particle2 = new G4DynamicParticle(G4Positron::Positron(),
409 positronDirection,
410 positronKineEnergy);
411 // Fill output vector
412 fvect->push_back(particle1);
413 fvect->push_back(particle2);
414
415 // kill incident photon
416 fParticleChange->SetProposedKineticEnergy(0.);
417 fParticleChange->ProposeTrackStatus(fStopAndKill);
418
419}
epsilon
G4double epsilon(G4double density, G4double temperature)
Definition: G4DNAElectronHoleRecombination.cc:95
G4Exp
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:180
G4Log
G4double G4Log(G4double x)
Definition: G4Log.hh:227
fStopAndKill
@ fStopAndKill
Definition: G4TrackStatus.hh:46
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:52
G4DynamicParticle::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4DynamicParticle::GetDefinition
G4ParticleDefinition * GetDefinition() const
G4DynamicParticle::GetKineticEnergy
G4double GetKineticEnergy() const
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:93
G4Element::GetfCoulomb
G4double GetfCoulomb() const
Definition: G4Element.hh:190
G4Element::GetIonisation
G4IonisParamElm * GetIonisation() const
Definition: G4Element.hh:198
G4IonisParamElm::GetlogZ3
G4double GetlogZ3() const
Definition: G4IonisParamElm.hh:62
G4IonisParamElm::GetZ3
G4double GetZ3() const
Definition: G4IonisParamElm.hh:60
G4ParticleChangeForGamma::SetProposedKineticEnergy
void SetProposedKineticEnergy(G4double proposedKinEnergy)
Definition: G4ParticleChangeForGamma.hh:106
G4Positron::Positron
static G4Positron * Positron()
Definition: G4Positron.cc:93
G4VEmModel::SelectRandomAtom
const G4Element * SelectRandomAtom(const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.hh:561
G4VParticleChange::ProposeTrackStatus
void ProposeTrackStatus(G4TrackStatus status)
The documentation for this class was generated from the following files: