Geant4 11.3.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
G4RiGeMuPairProductionModel Class Reference

#include <G4RiGeMuPairProductionModel.hh>

+ Inheritance diagram for G4RiGeMuPairProductionModel:

Public Member Functions

 G4RiGeMuPairProductionModel (const G4ParticleDefinition *p=nullptr)
 
 ~G4RiGeMuPairProductionModel () override=default
 
void Initialise (const G4ParticleDefinition *, const G4DataVector &) override
 
void InitialiseLocal (const G4ParticleDefinition *, G4VEmModel *masterModel) override
 
G4double ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double kineticEnergy, G4double Z, G4double A, G4double cutEnergy, G4double maxEnergy) override
 
G4double ComputeDEDXPerVolume (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy) override
 
void SampleSecondaries (std::vector< G4DynamicParticle * > *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin, G4double maxEnergy) override
 
G4double MinPrimaryEnergy (const G4Material *, const G4ParticleDefinition *, G4double) override
 
G4double ComputeDMicroscopicCrossSection (G4double tkin, G4double Z, G4double pairEnergy)
 
void SetLowestKineticEnergy (G4double e)
 
void SetParticle (const G4ParticleDefinition *)
 
G4RiGeMuPairProductionModel & operator= (const G4RiGeMuPairProductionModel &right)=delete
 
 G4RiGeMuPairProductionModel (const G4RiGeMuPairProductionModel &)=delete
 
- Public Member Functions inherited from G4VEmModel
 G4VEmModel (const G4String &nam)
 
virtual ~G4VEmModel ()
 
virtual void InitialiseForMaterial (const G4ParticleDefinition *, const G4Material *)
 
virtual void InitialiseForElement (const G4ParticleDefinition *, G4int Z)
 
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 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 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 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 SetDeexcitationFlag (G4bool val)
 
void SetForceBuildTable (G4bool val)
 
void SetFluctuationFlag (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)
 
void SetLPMFlag (G4bool)
 
void SetMasterThread (G4bool)
 
G4VEmModel & operator= (const G4VEmModel &right)=delete
 
 G4VEmModel (const G4VEmModel &)=delete
 

Protected Member Functions

G4double ComputMuPairLoss (G4double Z, G4double tkin, G4double cut, G4double tmax)
 
G4double ComputeMicroscopicCrossSection (G4double tkin, G4double Z, G4double cut)
 
G4double FindScaledEnergy (G4int Z, G4double rand, G4double logTkin, G4double yymin, G4double yymax)
 
G4double MaxSecondaryEnergyForElement (G4double kineticEnergy, G4double Z)
 
void MakeSamplingTables ()
 
void StoreTables () const
 
G4bool RetrieveTables ()
 
virtual void DataCorrupted (G4int Z, G4double logTkin) const
 
- 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

G4ParticleChangeForLoss * fParticleChange = nullptr
 
const G4ParticleDefinition * particle = nullptr
 
G4NistManager * nist = nullptr
 
G4double factorForCross
 
G4double sqrte
 
G4double particleMass = 0.0
 
G4double z13 = 0.0
 
G4double z23 = 0.0
 
G4double lnZ = 0.0
 
G4double minPairEnergy
 
G4double lowestKinEnergy
 
G4double emin
 
G4double emax
 
G4double ymin = -5.0
 
G4double dy = 0.005
 
G4double randNumbs [9]
 
G4int currentZ = 0
 
G4int nYBinPerDecade = 4
 
std::size_t nbiny = 1000
 
std::size_t nbine = 0
 
G4bool fTableToFile = false
 
- 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
 
std::size_t currentCoupleIndex = 0
 
std::size_t basedCoupleIndex = 0
 
G4bool lossFlucFlag = true
 

Static Protected Attributes

static const G4int NZDATPAIR = 5
 
static const G4int NINTPAIR = 8
 
static const G4int ZDATPAIR [NZDATPAIR] = {1, 4, 13, 29, 92}
 
static const G4double xgi [NINTPAIR]
 
static const G4double wgi [NINTPAIR]
 

Detailed Description

Definition at line 56 of file G4RiGeMuPairProductionModel.hh.

Constructor & Destructor Documentation

◆ G4RiGeMuPairProductionModel() [1/2]

G4RiGeMuPairProductionModel::G4RiGeMuPairProductionModel ( const G4ParticleDefinition * p = nullptr)
explicit

Definition at line 94 of file G4RiGeMuPairProductionModel.cc.

95 : G4VEmModel("muPairProdRiGe"),
96 factorForCross(CLHEP::fine_structure_const*CLHEP::fine_structure_const*
97 CLHEP::classic_electr_radius*CLHEP::classic_electr_radius*
98 4./(3.*CLHEP::pi)),
99 sqrte(std::sqrt(G4Exp(1.))),
100 minPairEnergy(4.*CLHEP::electron_mass_c2),
101 lowestKinEnergy(0.85*CLHEP::GeV)
102{
103 nist = G4NistManager::Instance();
104
105 theElectron = G4Electron::Electron();
106 thePositron = G4Positron::Positron();
107
108 if (nullptr != p) {
109 SetParticle(p);
110 lowestKinEnergy = std::max(lowestKinEnergy, p->GetPDGMass()*8.0);
111 }
112 emin = lowestKinEnergy;
113 emax = emin*10000.;
114 fAngularGenerator = new G4RiGeAngularGenerator();
115 SetAngularDistribution(fAngularGenerator);
116 for (G4int i=0; i<9; ++i) { randNumbs[i] = 0.0; }
117}
G4Exp
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition G4Exp.hh:180
G4int
int G4int
Definition G4Types.hh:85
G4Electron::Electron
static G4Electron * Electron()
Definition G4Electron.cc:91
G4NistManager::Instance
static G4NistManager * Instance()
Definition G4NistManager.cc:57
G4Positron::Positron
static G4Positron * Positron()
Definition G4Positron.cc:90
G4RiGeMuPairProductionModel::SetParticle
void SetParticle(const G4ParticleDefinition *)
Definition G4RiGeMuPairProductionModel.hh:180
G4VEmModel::G4VEmModel
G4VEmModel(const G4String &nam)
Definition G4VEmModel.cc:67
G4VEmModel::SetAngularDistribution
void SetAngularDistribution(G4VEmAngularDistribution *)
Definition G4VEmModel.hh:606

Referenced by G4RiGeMuPairProductionModel(), and operator=().

◆ ~G4RiGeMuPairProductionModel()

G4RiGeMuPairProductionModel::~G4RiGeMuPairProductionModel ( )
overridedefault

◆ G4RiGeMuPairProductionModel() [2/2]

G4RiGeMuPairProductionModel::G4RiGeMuPairProductionModel ( const G4RiGeMuPairProductionModel & )
delete

Member Function Documentation

◆ ComputeCrossSectionPerAtom()

G4double G4RiGeMuPairProductionModel::ComputeCrossSectionPerAtom ( const G4ParticleDefinition * ,
G4double kineticEnergy,
G4double Z,
G4double A,
G4double cutEnergy,
G4double maxEnergy )
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 434 of file G4RiGeMuPairProductionModel.cc.

439{
440 G4double cross = 0.0;
441 if (kineticEnergy <= lowestKinEnergy) { return cross; }
442
443 G4double maxPairEnergy = MaxSecondaryEnergyForElement(kineticEnergy, Z);
444 G4double tmax = std::min(maxEnergy, maxPairEnergy);
445 G4double cut = std::max(cutEnergy, minPairEnergy);
446 if (cut >= tmax) { return cross; }
447
448 cross = ComputeMicroscopicCrossSection(kineticEnergy, Z, cut);
449 if(tmax < kineticEnergy) {
450 cross -= ComputeMicroscopicCrossSection(kineticEnergy, Z, tmax);
451 }
452 return cross;
453}
G4double
double G4double
Definition G4Types.hh:83
G4RiGeMuPairProductionModel::MaxSecondaryEnergyForElement
G4double MaxSecondaryEnergyForElement(G4double kineticEnergy, G4double Z)
Definition G4RiGeMuPairProductionModel.hh:191
G4RiGeMuPairProductionModel::ComputeMicroscopicCrossSection
G4double ComputeMicroscopicCrossSection(G4double tkin, G4double Z, G4double cut)
Definition G4RiGeMuPairProductionModel.cc:266

◆ ComputeDEDXPerVolume()

G4double G4RiGeMuPairProductionModel::ComputeDEDXPerVolume ( const G4Material * material,
const G4ParticleDefinition * ,
G4double kineticEnergy,
G4double cutEnergy )
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 207 of file G4RiGeMuPairProductionModel.cc.

211{
212 G4double dedx = 0.0;
213 if (cutEnergy <= minPairEnergy || kineticEnergy <= lowestKinEnergy)
214 { return dedx; }
215
216 const G4ElementVector* theElementVector = material->GetElementVector();
217 const G4double* theAtomicNumDensityVector =
218 material->GetAtomicNumDensityVector();
219
220 // loop for elements in the material
221 for (std::size_t i=0; i<material->GetNumberOfElements(); ++i) {
222 G4double Z = (*theElementVector)[i]->GetZ();
223 G4double tmax = MaxSecondaryEnergyForElement(kineticEnergy, Z);
224 G4double loss = ComputMuPairLoss(Z, kineticEnergy, cutEnergy, tmax);
225 dedx += loss*theAtomicNumDensityVector[i];
226 }
227 dedx = std::max(dedx, 0.0);
228 return dedx;
229}
G4ElementVector
std::vector< const G4Element * > G4ElementVector
Definition G4ElementVector.hh:33
G4Material::GetElementVector
const G4ElementVector * GetElementVector() const
Definition G4Material.hh:183
G4Material::GetAtomicNumDensityVector
const G4double * GetAtomicNumDensityVector() const
Definition G4Material.hh:202
G4Material::GetNumberOfElements
std::size_t GetNumberOfElements() const
Definition G4Material.hh:180
G4RiGeMuPairProductionModel::ComputMuPairLoss
G4double ComputMuPairLoss(G4double Z, G4double tkin, G4double cut, G4double tmax)
Definition G4RiGeMuPairProductionModel.cc:233

◆ ComputeDMicroscopicCrossSection()

G4double G4RiGeMuPairProductionModel::ComputeDMicroscopicCrossSection ( G4double tkin,
G4double Z,
G4double pairEnergy )

Definition at line 297 of file G4RiGeMuPairProductionModel.cc.

304{
305 static const G4double bbbtf= 183. ;
306 static const G4double bbbh = 202.4 ;
307 static const G4double g1tf = 1.95e-5 ;
308 static const G4double g2tf = 5.3e-5 ;
309 static const G4double g1h = 4.4e-5 ;
310 static const G4double g2h = 4.8e-5 ;
311
312 if (pairEnergy <= minPairEnergy)
313 return 0.0;
314
315 G4double totalEnergy = tkin + particleMass;
316 G4double residEnergy = totalEnergy - pairEnergy;
317
318 if (residEnergy <= 0.75*sqrte*z13*particleMass)
319 return 0.0;
320
321 G4double a0 = 1.0 / (totalEnergy * residEnergy);
322 G4double alf = 4.0 * electron_mass_c2 / pairEnergy;
323 G4double rt = std::sqrt(1.0 - alf);
324 G4double delta = 6.0 * particleMass * particleMass * a0;
325 G4double tmnexp = alf/(1.0 + rt) + delta*rt;
326
327 if(tmnexp >= 1.0) { return 0.0; }
328
329 G4double tmn = G4Log(tmnexp);
330
331 G4double massratio = particleMass/CLHEP::electron_mass_c2;
332 G4double massratio2 = massratio*massratio;
333 G4double inv_massratio2 = 1.0 / massratio2;
334
335 // zeta calculation
336 G4double bbb,g1,g2;
337 if( Z < 1.5 ) { bbb = bbbh ; g1 = g1h ; g2 = g2h ; }
338 else { bbb = bbbtf; g1 = g1tf; g2 = g2tf; }
339
340 G4double zeta = 0.0;
341 G4double z1exp = totalEnergy / (particleMass + g1*z23*totalEnergy);
342
343 // 35.221047195922 is the root of zeta1(x) = 0.073 * log(x) - 0.26, so the
344 // condition below is the same as zeta1 > 0.0, but without calling log(x)
345 if (z1exp > 35.221047195922)
346 {
347 G4double z2exp = totalEnergy / (particleMass + g2*z13*totalEnergy);
348 zeta = (0.073 * G4Log(z1exp) - 0.26) / (0.058 * G4Log(z2exp) - 0.14);
349 }
350
351 G4double z2 = Z*(Z+zeta);
352 G4double screen0 = 2.*electron_mass_c2*sqrte*bbb/(z13*pairEnergy);
353 G4double beta = 0.5*pairEnergy*pairEnergy*a0;
354 G4double xi0 = 0.5*massratio2*beta;
355
356 // Gaussian integration in ln(1-ro) ( with 8 points)
357 G4double rho[NINTPAIR];
358 G4double rho2[NINTPAIR];
359 G4double xi[NINTPAIR];
360 G4double xi1[NINTPAIR];
361 G4double xii[NINTPAIR];
362
363 for (G4int i = 0; i < NINTPAIR; ++i)
364 {
365 rho[i] = G4Exp(tmn*xgi[i]) - 1.0; // rho = -asymmetry
366 rho2[i] = rho[i] * rho[i];
367 xi[i] = xi0*(1.0-rho2[i]);
368 xi1[i] = 1.0 + xi[i];
369 xii[i] = 1.0 / xi[i];
370 }
371
372 G4double ye1[NINTPAIR];
373 G4double ym1[NINTPAIR];
374
375 G4double b40 = 4.0 * beta;
376 G4double b62 = 6.0 * beta + 2.0;
377
378 for (G4int i = 0; i < NINTPAIR; ++i)
379 {
380 G4double yeu = (b40 + 5.0) + (b40 - 1.0) * rho2[i];
381 G4double yed = b62*G4Log(3.0 + xii[i]) + (2.0 * beta - 1.0)*rho2[i] - b40;
382
383 G4double ymu = b62 * (1.0 + rho2[i]) + 6.0;
384 G4double ymd = (b40 + 3.0)*(1.0 + rho2[i])*G4Log(3.0 + xi[i])
385 + 2.0 - 3.0 * rho2[i];
386
387 ye1[i] = 1.0 + yeu / yed;
388 ym1[i] = 1.0 + ymu / ymd;
389 }
390
391 G4double be[NINTPAIR];
392 G4double bm[NINTPAIR];
393
394 for(G4int i = 0; i < NINTPAIR; ++i) {
395 if(xi[i] <= 1000.0) {
396 be[i] = ((2.0 + rho2[i])*(1.0 + beta) +
397 xi[i]*(3.0 + rho2[i]))*G4Log(1.0 + xii[i]) +
398 (1.0 - rho2[i] - beta)/xi1[i] - (3.0 + rho2[i]);
399 } else {
400 be[i] = 0.5*(3.0 - rho2[i] + 2.0*beta*(1.0 + rho2[i]))*xii[i];
401 }
402
403 if(xi[i] >= 0.001) {
404 G4double a10 = (1.0 + 2.0 * beta) * (1.0 - rho2[i]);
405 bm[i] = ((1.0 + rho2[i])*(1.0 + 1.5 * beta) - a10*xii[i])*G4Log(xi1[i]) +
406 xi[i] * (1.0 - rho2[i] - beta)/xi1[i] + a10;
407 } else {
408 bm[i] = 0.5*(5.0 - rho2[i] + beta * (3.0 + rho2[i]))*xi[i];
409 }
410 }
411
412 G4double sum = 0.0;
413
414 for (G4int i = 0; i < NINTPAIR; ++i) {
415 G4double screen = screen0*xi1[i]/(1.0 - rho2[i]);
416 G4double ale = G4Log(bbb/z13*std::sqrt(xi1[i]*ye1[i])/(1. + screen*ye1[i]));
417 G4double cre = 0.5*G4Log(1. + 2.25*z23*xi1[i]*ye1[i]*inv_massratio2);
418
419 G4double fe = (ale-cre)*be[i];
420 fe = std::max(fe, 0.0);
421
422 G4double alm_crm = G4Log(bbb*massratio/(1.5*z23*(1. + screen*ym1[i])));
423 G4double fm = std::max(alm_crm*bm[i], 0.0)*inv_massratio2;
424
425 sum += wgi[i]*(1.0 + rho[i])*(fe + fm);
426 }
427
428 return -tmn*sum*factorForCross*z2*residEnergy/(totalEnergy*pairEnergy);
429}
a0
const G4double a0
Definition G4IonCoulombCrossSection.cc:68
fe
G4fissionEvent * fe
Definition G4LLNLFission.cc:62
G4Log
G4double G4Log(G4double x)
Definition G4Log.hh:227
G4RiGeMuPairProductionModel::wgi
static const G4double wgi[NINTPAIR]
Definition G4RiGeMuPairProductionModel.hh:76
G4RiGeMuPairProductionModel::xgi
static const G4double xgi[NINTPAIR]
Definition G4RiGeMuPairProductionModel.hh:71

Referenced by ComputeMicroscopicCrossSection(), ComputMuPairLoss(), and MakeSamplingTables().

◆ ComputeMicroscopicCrossSection()

G4double G4RiGeMuPairProductionModel::ComputeMicroscopicCrossSection ( G4double tkin,
G4double Z,
G4double cut )
protected

Definition at line 266 of file G4RiGeMuPairProductionModel.cc.

269{
270 G4double cross = 0.;
271 G4double tmax = MaxSecondaryEnergyForElement(tkin, Z);
272 G4double cut = std::max(cutEnergy, minPairEnergy);
273 if (tmax <= cut) { return cross; }
274
275 G4double aaa = G4Log(cut);
276 G4double bbb = G4Log(tmax);
277 G4int kkk = std::min(std::max(G4lrint((bbb-aaa)/ak1 + ak2), 8), 1);
278
279 G4double hhh = (bbb-aaa)/(kkk);
280 G4double x = aaa;
281
282 for (G4int l=0; l<kkk; ++l) {
283 for (G4int i=0; i<NINTPAIR; ++i) {
284 G4double ep = G4Exp(x + xgi[i]*hhh);
285 cross += ep*wgi[i]*ComputeDMicroscopicCrossSection(tkin, Z, ep);
286 }
287 x += hhh;
288 }
289
290 cross *= hhh;
291 cross = std::max(cross, 0.0);
292 return cross;
293}
G4RiGeMuPairProductionModel::ComputeDMicroscopicCrossSection
G4double ComputeDMicroscopicCrossSection(G4double tkin, G4double Z, G4double pairEnergy)
Definition G4RiGeMuPairProductionModel.cc:297
G4lrint
int G4lrint(double ad)
Definition templates.hh:134

Referenced by ComputeCrossSectionPerAtom().

◆ ComputMuPairLoss()

G4double G4RiGeMuPairProductionModel::ComputMuPairLoss ( G4double Z,
G4double tkin,
G4double cut,
G4double tmax )
protected

Definition at line 233 of file G4RiGeMuPairProductionModel.cc.

236{
237 G4double loss = 0.0;
238
239 G4double cut = std::min(cutEnergy, tmax);
240 if(cut <= minPairEnergy) { return loss; }
241
242 // calculate the rectricted loss
243 // numerical integration in log(PairEnergy)
244 G4double aaa = G4Log(minPairEnergy);
245 G4double bbb = G4Log(cut);
246
247 G4int kkk = std::min(std::max(G4lrint((bbb-aaa)/ak1 + ak2), 8), 1);
248 G4double hhh = (bbb-aaa)/kkk;
249 G4double x = aaa;
250
251 for (G4int l=0 ; l<kkk; ++l) {
252 for (G4int ll=0; ll<NINTPAIR; ++ll) {
253 G4double ep = G4Exp(x+xgi[ll]*hhh);
254 loss += wgi[ll]*ep*ep*ComputeDMicroscopicCrossSection(tkin, Z, ep);
255 }
256 x += hhh;
257 }
258 loss *= hhh;
259 loss = std::max(loss, 0.0);
260 return loss;
261}

Referenced by ComputeDEDXPerVolume().

◆ DataCorrupted()

void G4RiGeMuPairProductionModel::DataCorrupted ( G4int Z,
G4double logTkin ) const
protectedvirtual

Definition at line 949 of file G4RiGeMuPairProductionModel.cc.

950{
951 G4ExceptionDescription ed;
952 ed << "G4ElementData is not properly initialized Z= " << Z
953 << " Ekin(MeV)= " << G4Exp(logTkin)
954 << " IsMasterThread= " << IsMaster()
955 << " Model " << GetName();
956 G4Exception("G4RiGeMuPairProductionModel::()", "em0033", FatalException, ed, "");
957}
FatalException
@ FatalException
Definition G4ExceptionSeverity.hh:67
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition G4Exception.hh:40
G4VEmModel::IsMaster
G4bool IsMaster() const
Definition G4VEmModel.hh:710
G4VEmModel::GetName
const G4String & GetName() const
Definition G4VEmModel.hh:794

Referenced by FindScaledEnergy(), and StoreTables().

◆ FindScaledEnergy()

G4double G4RiGeMuPairProductionModel::FindScaledEnergy ( G4int Z,
G4double rand,
G4double logTkin,
G4double yymin,
G4double yymax )
protected

Definition at line 929 of file G4RiGeMuPairProductionModel.cc.

932{
933 G4double res = yymin;
934 G4Physics2DVector* pv = fElementData->GetElement2DData(iz);
935 if (nullptr != pv) {
936 G4double pmin = pv->Value(yymin, logTkin);
937 G4double pmax = pv->Value(yymax, logTkin);
938 G4double p0 = pv->Value(0.0, logTkin);
939 if(p0 <= 0.0) { DataCorrupted(ZDATPAIR[iz], logTkin); }
940 else { res = pv->FindLinearX((pmin + rand*(pmax - pmin))/p0, logTkin); }
941 } else {
942 DataCorrupted(ZDATPAIR[iz], logTkin);
943 }
944 return res;
945}
G4Physics2DVector::Value
G4double Value(G4double x, G4double y, std::size_t &lastidx, std::size_t &lastidy) const
Definition G4Physics2DVector.cc:146
G4Physics2DVector::FindLinearX
G4double FindLinearX(G4double rand, G4double y, std::size_t &lastidy) const
Definition G4Physics2DVector.cc:387
G4RiGeMuPairProductionModel::ZDATPAIR
static const G4int ZDATPAIR[NZDATPAIR]
Definition G4RiGeMuPairProductionModel.hh:69
G4RiGeMuPairProductionModel::DataCorrupted
virtual void DataCorrupted(G4int Z, G4double logTkin) const
Definition G4RiGeMuPairProductionModel.cc:949
G4VEmModel::fElementData
G4ElementData * fElementData
Definition G4VEmModel.hh:420

Referenced by SampleSecondaries().

◆ Initialise()

void G4RiGeMuPairProductionModel::Initialise ( const G4ParticleDefinition * p,
const G4DataVector & cuts )
overridevirtual

Implements G4VEmModel.

Definition at line 131 of file G4RiGeMuPairProductionModel.cc.

133{
134 SetParticle(p);
135
136 if (nullptr == fParticleChange) {
137 fParticleChange = GetParticleChangeForLoss();
138
139 // define scale of internal table for each thread only once
140 if (0 == nbine) {
141 emin = std::max(lowestKinEnergy, LowEnergyLimit());
142 emax = std::max(HighEnergyLimit(), emin*2);
143 nbine = std::size_t(nYBinPerDecade*std::log10(emax/emin));
144 if(nbine < 3) { nbine = 3; }
145
146 ymin = G4Log(minPairEnergy/emin);
147 dy = -ymin/G4double(nbiny);
148 }
149 if (p == particle) {
150 G4int pdg = std::abs(p->GetPDGEncoding());
151 if (pdg == 2212) {
152 dataName = "pEEPairProd";
153 } else if (pdg == 321) {
154 dataName = "kaonEEPairProd";
155 } else if (pdg == 211) {
156 dataName = "pionEEPairProd";
157 } else if (pdg == 11) {
158 dataName = "eEEPairProd";
159 } else if (pdg == 13) {
160 if (GetName() == "muToMuonPairProd") {
161 dataName = "muMuMuPairProd";
162 } else {
163 dataName = "muEEPairProd";
164 }
165 }
166 }
167 }
168
169 // for low-energy application this process should not work
170 if(lowestKinEnergy >= HighEnergyLimit()) { return; }
171
172 if (p == particle) {
173 auto data = G4ElementDataRegistry::Instance();
174 fElementData = data->GetElementDataByName(dataName);
175 if (nullptr == fElementData) {
176 G4AutoLock l(&theRiGeMuPairMutex);
177 fElementData = data->GetElementDataByName(dataName);
178 if (nullptr == fElementData) {
179 fElementData = new G4ElementData(NZDATPAIR);
180 fElementData->SetName(dataName);
181 }
182 G4bool useDataFile = G4EmParameters::Instance()->RetrieveMuDataFromFile();
183 if (useDataFile) { useDataFile = RetrieveTables(); }
184 if (!useDataFile) { MakeSamplingTables(); }
185 if (fTableToFile) { StoreTables(); }
186 l.unlock();
187 }
188 if (IsMaster()) {
189 InitialiseElementSelectors(p, cuts);
190 }
191 }
192}
G4AutoLock
G4TemplateAutoLock< G4Mutex > G4AutoLock
Definition G4AutoLock.hh:582
G4bool
bool G4bool
Definition G4Types.hh:86
G4ElementDataRegistry::Instance
static G4ElementDataRegistry * Instance()
Definition G4ElementDataRegistry.cc:40
G4EmParameters::Instance
static G4EmParameters * Instance()
Definition G4EmParameters.cc:70
G4EmParameters::RetrieveMuDataFromFile
G4bool RetrieveMuDataFromFile() const
Definition G4EmParameters.cc:488
G4RiGeMuPairProductionModel::particle
const G4ParticleDefinition * particle
Definition G4RiGeMuPairProductionModel.hh:127
G4RiGeMuPairProductionModel::fParticleChange
G4ParticleChangeForLoss * fParticleChange
Definition G4RiGeMuPairProductionModel.hh:126
G4VEmModel::LowEnergyLimit
G4double LowEnergyLimit() const
Definition G4VEmModel.hh:640
G4VEmModel::HighEnergyLimit
G4double HighEnergyLimit() const
Definition G4VEmModel.hh:633
G4VEmModel::InitialiseElementSelectors
void InitialiseElementSelectors(const G4ParticleDefinition *, const G4DataVector &)
Definition G4VEmModel.cc:136
G4VEmModel::GetParticleChangeForLoss
G4ParticleChangeForLoss * GetParticleChangeForLoss()
Definition G4VEmModel.cc:106

◆ InitialiseLocal()

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

Reimplemented from G4VEmModel.

Definition at line 196 of file G4RiGeMuPairProductionModel.cc.

198{
199 if(p == particle && lowestKinEnergy < HighEnergyLimit()) {
200 SetElementSelectors(masterModel->GetElementSelectors());
201 }
202}
G4VEmModel::SetElementSelectors
void SetElementSelectors(std::vector< G4EmElementSelector * > *)
Definition G4VEmModel.hh:809
G4VEmModel::GetElementSelectors
std::vector< G4EmElementSelector * > * GetElementSelectors()
Definition G4VEmModel.hh:801

◆ MakeSamplingTables()

void G4RiGeMuPairProductionModel::MakeSamplingTables ( )
protected

Definition at line 457 of file G4RiGeMuPairProductionModel.cc.

458{
459 G4double factore = G4Exp(G4Log(emax/emin)/G4double(nbine));
460
461 for (G4int iz=0; iz<NZDATPAIR; ++iz) {
462
463 G4double Z = ZDATPAIR[iz];
464 G4Physics2DVector* pv = new G4Physics2DVector(nbiny+1,nbine+1);
465 G4double kinEnergy = emin;
466
467 for (std::size_t it=0; it<=nbine; ++it) {
468
469 pv->PutY(it, G4Log(kinEnergy/CLHEP::MeV));
470 G4double maxPairEnergy = MaxSecondaryEnergyForElement(kinEnergy, Z);
471 /*
472 G4cout << "it= " << it << " E= " << kinEnergy
473 << " " << particle->GetParticleName()
474 << " maxE= " << maxPairEnergy << " minE= " << minPairEnergy
475 << " ymin= " << ymin << G4endl;
476 */
477 G4double coef = G4Log(minPairEnergy/kinEnergy)/ymin;
478 G4double ymax = G4Log(maxPairEnergy/kinEnergy)/coef;
479 G4double fac = (ymax - ymin)/dy;
480 std::size_t imax = (std::size_t)fac;
481 fac -= (G4double)imax;
482
483 G4double xSec = 0.0;
484 G4double x = ymin;
485 /*
486 G4cout << "Z= " << currentZ << " z13= " << z13
487 << " mE= " << maxPairEnergy << " ymin= " << ymin
488 << " dy= " << dy << " c= " << coef << G4endl;
489 */
490 // start from zero
491 pv->PutValue(0, it, 0.0);
492 if(0 == it) { pv->PutX(nbiny, 0.0); }
493
494 for (std::size_t i=0; i<nbiny; ++i) {
495
496 if(0 == it) { pv->PutX(i, x); }
497
498 if(i < imax) {
499 G4double ep = kinEnergy*G4Exp(coef*(x + dy*0.5));
500
501 // not multiplied by interval, because table
502 // will be used only for sampling
503 //G4cout << "i= " << i << " x= " << x << "E= " << kinEnergy
504 // << " Egamma= " << ep << G4endl;
505 xSec += ep*ComputeDMicroscopicCrossSection(kinEnergy, Z, ep);
506
507 // last bin before the kinematic limit
508 } else if(i == imax) {
509 G4double ep = kinEnergy*G4Exp(coef*(x + fac*dy*0.5));
510 xSec += ep*fac*ComputeDMicroscopicCrossSection(kinEnergy, Z, ep);
511 }
512 pv->PutValue(i + 1, it, xSec);
513 x += dy;
514 }
515 kinEnergy *= factore;
516
517 // to avoid precision lost
518 if(it+1 == nbine) { kinEnergy = emax; }
519 }
520 fElementData->InitialiseForElement(iz, pv);
521 }
522}
G4Physics2DVector::PutY
void PutY(std::size_t idy, G4double value)
G4Physics2DVector::PutValue
void PutValue(std::size_t idx, std::size_t idy, G4double value)
G4Physics2DVector::PutX
void PutX(std::size_t idx, G4double value)

Referenced by Initialise().

◆ MaxSecondaryEnergyForElement()

G4double G4RiGeMuPairProductionModel::MaxSecondaryEnergyForElement ( G4double kineticEnergy,
G4double Z )
inlineprotected

Definition at line 191 of file G4RiGeMuPairProductionModel.hh.

193{
194 G4int Z = G4lrint(ZZ);
195 if(Z != currentZ) {
196 currentZ = Z;
197 z13 = nist->GetZ13(Z);
198 z23 = z13*z13;
199 lnZ = nist->GetLOGZ(Z);
200 }
201 return kineticEnergy + particleMass*(1.0 - 0.75*sqrte*z13);
202}

Referenced by ComputeCrossSectionPerAtom(), ComputeDEDXPerVolume(), ComputeMicroscopicCrossSection(), MakeSamplingTables(), and SampleSecondaries().

◆ MinPrimaryEnergy()

G4double G4RiGeMuPairProductionModel::MinPrimaryEnergy ( const G4Material * ,
const G4ParticleDefinition * ,
G4double cut )
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 122 of file G4RiGeMuPairProductionModel.cc.

125{
126 return std::max(lowestKinEnergy, cut);
127}

◆ operator=()

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

◆ RetrieveTables()

G4bool G4RiGeMuPairProductionModel::RetrieveTables ( )
protected

Definition at line 979 of file G4RiGeMuPairProductionModel.cc.

980{
981 for (G4int iz=0; iz<NZDATPAIR; ++iz) {
982 G4double Z = ZDATPAIR[iz];
983 G4Physics2DVector* pv = new G4Physics2DVector(nbiny+1,nbine+1);
984 std::ostringstream ss;
985 ss << G4EmParameters::Instance()->GetDirLEDATA() << "/mupair/"
986 << particle->GetParticleName() << Z << ".dat";
987 std::ifstream infile(ss.str(), std::ios::in);
988 if(!pv->Retrieve(infile)) {
989 delete pv;
990 return false;
991 }
992 fElementData->InitialiseForElement(iz, pv);
993 }
994 return true;
995}
G4EmParameters::GetDirLEDATA
const G4String & GetDirLEDATA() const
Definition G4EmParameters.cc:1363
G4Physics2DVector::Retrieve
G4bool Retrieve(std::ifstream &fIn)
Definition G4Physics2DVector.cc:319

Referenced by Initialise().

◆ SampleSecondaries()

void G4RiGeMuPairProductionModel::SampleSecondaries ( std::vector< G4DynamicParticle * > * vdp,
const G4MaterialCutsCouple * couple,
const G4DynamicParticle * aDynamicParticle,
G4double tmin,
G4double maxEnergy )
overridevirtual

Implements G4VEmModel.

Definition at line 526 of file G4RiGeMuPairProductionModel.cc.

531{
532 G4double eMass = CLHEP::electron_mass_c2;
533 G4double eMass2 = eMass*eMass;
534
535 // Energy and momentum of the pramary particle
536 G4double kinEnergy = aDynamicParticle->GetKineticEnergy();
537 G4double particleMomentum = aDynamicParticle->GetTotalMomentum();
538 G4ThreeVector particleMomentumVector = aDynamicParticle->GetMomentum();
539 G4ThreeVector partDirection = aDynamicParticle->GetMomentumDirection();
540
541 G4double minQ2 = 4.*eMass2;
542 G4double maxQ2 = (kinEnergy - particleMass)*(kinEnergy - particleMass);
543 G4double intervalQ2 = G4Log(maxQ2/minQ2);
544
545 // Square invariant of mass of the pair
546 G4double Q2 = minQ2*G4Exp(intervalQ2*randNumbs[4]);
547
548 G4double mingEnergy = std::sqrt(Q2);
549 G4double maxgEnergy = kinEnergy - particleMass;
550 G4double intervalgEnergy = maxgEnergy - mingEnergy;
551
552 // Energy of virtual gamma
553 G4double gEnergy = mingEnergy + intervalgEnergy*randNumbs[5];
554
555 // Momentum module of the virtual gamma
556 G4double gMomentum = std::sqrt(gEnergy*gEnergy - Q2);
557
558 // Energy and momentum module of the outgoing parent particle
559 G4double particleFinalEnergy = kinEnergy - gEnergy;
560 G4double particleFinalMomentum = std::sqrt(particleFinalEnergy*particleFinalEnergy -
561 particleMass*particleMass);
562
563 G4double mint3 = 0.;
564 G4double maxt3 = CLHEP::pi;
565 G4double Cmin = std::cos(maxt3);
566 G4double Cmax = std::cos(mint3);
567
568 //G4cout << "------- G4RiGeMuPairProductionModel::SampleSecondaries E(MeV)= "
569 // << kinEnergy << " "
570 // << aDynamicParticle->GetDefinition()->GetParticleName() << G4endl;
571
572 // select randomly one element constituing the material
573 const G4Element* anElement = SelectRandomAtom(couple,particle,kinEnergy);
574
575 // define interval of energy transfer
576 G4double maxPairEnergy = MaxSecondaryEnergyForElement(kinEnergy,
577 anElement->GetZ());
578 G4double maxEnergy = std::min(tmax, maxPairEnergy);
579 G4double minEnergy = std::max(tmin, minPairEnergy);
580
581 if (minEnergy >= maxEnergy) { return; }
582
583 //G4cout << "emin= " << minEnergy << " emax= " << maxEnergy
584 // << " minPair= " << minPairEnergy << " maxpair= " << maxPairEnergy
585 // << " ymin= " << ymin << " dy= " << dy << G4endl;
586
587 CLHEP::HepRandomEngine* rndmEngine = G4Random::getTheEngine();
588
589 G4double coeff = G4Log(minPairEnergy/kinEnergy)/ymin;
590
591 // compute limits
592 G4double yymin = G4Log(minEnergy/kinEnergy)/coeff;
593 G4double yymax = G4Log(maxEnergy/kinEnergy)/coeff;
594
595 //G4cout << "yymin= " << yymin << " yymax= " << yymax << G4endl;
596
597 // units should not be used, bacause table was built without
598 G4double logTkin = G4Log(kinEnergy/CLHEP::MeV);
599
600 // sample e-e+ energy, pair energy first
601
602 // select sample table via Z
603 G4int iz1(0), iz2(0);
604 for (G4int iz=0; iz<NZDATPAIR; ++iz) {
605 if(currentZ == ZDATPAIR[iz]) {
606 iz1 = iz2 = iz;
607 break;
608 } else if(currentZ < ZDATPAIR[iz]) {
609 iz2 = iz;
610 if(iz > 0) { iz1 = iz-1; }
611 else { iz1 = iz2; }
612 break;
613 }
614 }
615 if (0 == iz1) { iz1 = iz2 = NZDATPAIR-1; }
616
617 G4double pairEnergy = 0.0;
618 G4int count = 0;
619 //G4cout << "start loop Z1= " << iz1 << " Z2= " << iz2 << G4endl;
620 do {
621 ++count;
622 // sampling using only one random number
623 G4double rand = rndmEngine->flat();
624
625 G4double x = FindScaledEnergy(iz1, rand, logTkin, yymin, yymax);
626 if(iz1 != iz2) {
627 G4double x2 = FindScaledEnergy(iz2, rand, logTkin, yymin, yymax);
628 G4double lz1= nist->GetLOGZ(ZDATPAIR[iz1]);
629 G4double lz2= nist->GetLOGZ(ZDATPAIR[iz2]);
630 //G4cout << count << ". x= " << x << " x2= " << x2
631 // << " Z1= " << iz1 << " Z2= " << iz2 << G4endl;
632 x += (x2 - x)*(lnZ - lz1)/(lz2 - lz1);
633 }
634 //G4cout << "x= " << x << " coeff= " << coeff << G4endl;
635 pairEnergy = kinEnergy*G4Exp(x*coeff);
636
637 // Loop checking, 30-Oct-2024, Vladimir Ivanchenko
638 } while((pairEnergy < minEnergy || pairEnergy > maxEnergy) && 50 > count);
639
640 //G4cout << "## pairEnergy(GeV)= " << pairEnergy/GeV
641 // << " Etot(GeV)= " << totalEnergy/GeV << G4endl;
642 rndmEngine->flatArray(9, randNumbs);
643 G4double phi3 = CLHEP::twopi*randNumbs[0];
644 fAngularGenerator->PhiRotation(partDirection, phi3);
645
646 G4LorentzVector muF;
647 G4ThreeVector eDirection, pDirection;
648 G4double eEnergy, pEnergy;
649
650 if (randNumbs[7] < W[0]) {
651 G4double A1 = -(Q2 - 2.*kinEnergy*gEnergy);
652 G4double B1 = -(2.*gMomentum*particleMomentum);
653 G4double tginterval = G4Log((A1 + B1)/(A1 - B1))/B1;
654
655 G4double costg = (-A1 + (A1 - B1)*G4Exp(B1*tginterval*randNumbs[1]))/B1;
656 G4double sintg = std::sqrt((1.0 - costg)*(1.0 + costg));
657 G4double phig = CLHEP::twopi*randNumbs[2];
658 G4double sinpg = std::sin(phig);
659 G4double cospg = std::cos(phig);
660
661 G4ThreeVector dirGamma;
662 dirGamma.set(sintg*cospg, sintg*sinpg, costg);
663 G4LorentzVector gFourMomentum(gEnergy, dirGamma*gMomentum);
664
665 G4double Ap = particleMomentum*particleMomentum +
666 particleFinalMomentum*particleFinalMomentum + gMomentum*gMomentum;
667 G4double A = Ap - 2.*particleMomentum*gMomentum*costg;
668 G4double B = 2.*particleMomentum*gMomentum*sintg*cospg;
669 G4double C = 2.*particleFinalMomentum*gMomentum*costg -
670 2.*particleMomentum*particleFinalMomentum;
671 G4double absB = std::abs(B);
672 G4double t1interval = (1./(A + C + absB*mint3) - 1./(A + C + absB*maxt3))/absB;
673 G4double t1 = (-(A + C) + 1./(1./(A + C + absB*mint3) - absB*t1interval*randNumbs[0]))/absB;
674 G4double sint1 = std::sin(t1);
675 G4double cost1 = std::cos(t1);
676
677 // Ingoing parent particle change
678 G4double Phi = CLHEP::twopi*randNumbs[3];
679 partDirection.set(sint1, 0., cost1);
680 fAngularGenerator->PhiRotation(partDirection, Phi);
681 kinEnergy = particleFinalEnergy;
682
683 G4double cost5 = -1. + 2.*randNumbs[6];
684 G4double phi5 = CLHEP::twopi*randNumbs[8];
685
686 G4LorentzVector eFourMomentumMQ = fAngularGenerator->eDP2(Q2, eMass2, eMass2, cost5, phi5);
687 G4LorentzVector pFourMomentumMQ = fAngularGenerator->pDP2(eMass2, eFourMomentumMQ);
688
689 G4LorentzVector eFourMomentum = eFourMomentumMQ.boost(gFourMomentum.boostVector());
690 G4LorentzVector pFourMomentum = pFourMomentumMQ.boost(gFourMomentum.boostVector());
691
692 eEnergy = eFourMomentum.t();
693 pEnergy = pFourMomentum.t();
694
695 } else if (randNumbs[7] >= W[0] && randNumbs[7] < W[1]) {
696 G4double A3 = Q2 + 2.*gEnergy*particleFinalEnergy;
697 G4double B3 = -2.*gMomentum*particleFinalMomentum;
698
699 G4double tQ3interval = G4Log((A3 + B3)/(A3 - B3))/B3;
700 G4double tQMG = (-A3 + (A3 - B3)*G4Exp(B3*tQ3interval*randNumbs[0]))/B3;
701 G4double phiQP = CLHEP::twopi*randNumbs[2];
702
703 G4double sintQ3 = std::sqrt(1. - tQMG*tQMG);
704 G4double cospQP = std::cos(phiQP);
705 G4double sinpQP = std::sin(phiQP);
706
707 G4double Ap = particleMomentum*particleMomentum +
708 particleFinalMomentum*particleFinalMomentum + gMomentum*gMomentum;
709 G4double A = Ap + 2.*particleFinalMomentum*gMomentum*tQMG;
710 G4double B = -2.*particleMomentum*gMomentum*sintQ3*cospQP;
711 G4double C = -2.*particleMomentum*gMomentum*tQMG - 2.*particleMomentum*particleFinalMomentum;
712
713 G4double absB = std::abs(B);
714 G4double t3interval = (1./(A + C + absB*mint3) - 1./(A + C + absB*maxt3))/absB;
715 G4double t3 = (-(A + C) + 1./(1./(A + C + absB*mint3) - absB*t3interval*randNumbs[0]))/absB;
716 G4double sint3 = std::sin(t3);
717 G4double cost3 = std::cos(t3);
718
719 G4double cost = -sint3*sintQ3*cospQP + cost3*tQMG;
720 G4double sint = std::sqrt((1. + cost)*(1. - cost));
721 G4double cosp = (sintQ3*cospQP*cost3 + sint3*tQMG)/sint;
722 G4double sinp = sintQ3*sinpQP/sint;
723
724 G4ThreeVector dirGamma;
725 dirGamma.set(sint*cosp, sint*sinp, cost);
726 G4LorentzVector gFourMomentum(gEnergy, dirGamma*gMomentum);
727
728 // Ingoing parent particle change
729 G4double Phi = CLHEP::twopi*randNumbs[3];
730 partDirection.set(sint3, 0., cost3);
731 fAngularGenerator->PhiRotation(partDirection, Phi);
732 kinEnergy = particleFinalEnergy;
733
734 G4double cost5 = -1. + 2.*randNumbs[6];
735 G4double phi5 = CLHEP::twopi*randNumbs[8];
736
737 G4LorentzVector eFourMomentumMQ = fAngularGenerator->eDP2(Q2, eMass2, eMass2, cost5, phi5);
738 G4LorentzVector pFourMomentumMQ = fAngularGenerator->pDP2(eMass2, eFourMomentumMQ);
739
740 G4LorentzVector eFourMomentum = eFourMomentumMQ.boost(gFourMomentum.boostVector());
741 G4LorentzVector pFourMomentum = pFourMomentumMQ.boost(gFourMomentum.boostVector());
742
743 eEnergy = eFourMomentum.t();
744 pEnergy = pFourMomentum.t();
745
746 } else if (randNumbs[7] >= W[1] && randNumbs[7] < W[2]) {
747 G4double phi5 = CLHEP::twopi*randNumbs[1];
748 G4double phi6 = CLHEP::twopi*randNumbs[2];
749 G4double muEnergyInterval = kinEnergy - 2.*eMass - particleMass;
750 particleFinalEnergy = particleMass + muEnergyInterval*randNumbs[3];
751 particleFinalMomentum = std::sqrt(particleFinalEnergy*particleFinalEnergy -
752 particleMass*particleMass);
753
754 G4double mineEnergy = eMass;
755 G4double maxeEnergy = kinEnergy - particleFinalEnergy - eMass;
756 G4double eEnergyinterval = maxeEnergy - mineEnergy;
757 eEnergy = mineEnergy + eEnergyinterval*randNumbs[4];
758
759 G4double cosp3 = 1.;
760 G4double sinp3 = 0.;
761 G4double cosp5 = std::cos(phi5);
762 G4double sinp5 = std::sin(phi5);
763 G4double cosp6 = std::cos(phi6);
764 G4double sinp6 = std::sin(phi6);
765
766 G4double eMomentum = std::sqrt(eEnergy*eEnergy - eMass*eMass);
767 pEnergy = kinEnergy - particleFinalEnergy - eEnergy;
768 G4double pMomentum = std::sqrt(pEnergy*pEnergy - eMass*eMass);
769
770 G4double A3 = -2.*particleMass*particleMass + 2.*kinEnergy*particleFinalEnergy;
771 G4double B3 = -2.*particleMomentum*particleFinalMomentum;
772 G4double cost3interval = G4Log((A3 + B3*Cmax)/(A3 + B3*Cmin))/B3;
773 G4double expanCost3r6 = G4Exp(B3*cost3interval*randNumbs[5]);
774 G4double cost3 = A3*(expanCost3r6 - 1.)/B3 + Cmin*expanCost3r6;
775 G4double sint3 = std::sqrt((1. - cost3)*(1. + cost3));
776
777 partDirection.set(sint3, 0., cost3);
778
779 G4ThreeVector muFinalMomentumVector;
780 muFinalMomentumVector.set(particleFinalMomentum*sint3, 0., particleFinalMomentum*cost3);
781
782 G4LorentzVector muFourMomentum(particleMomentum, particleMomentumVector);
783 G4LorentzVector muFinalFourMomentum(particleFinalEnergy, muFinalMomentumVector);
784 G4LorentzVector auxVec1 = muFourMomentum - muFinalFourMomentum;
785 G4double A5 = auxVec1.mag2() - 2.*eEnergy*(kinEnergy - particleFinalEnergy) +
786 2.*particleMomentumVector[2]*eMomentum - 2.*particleFinalMomentum*eMomentum*cost3;
787 G4double B5 = -2.*particleFinalMomentum*eMomentum*(sint3*cosp3*cosp5 + sint3*sinp3*sinp5);
788 G4double absA5 = std::abs(A5);
789 G4double absB5 = std::abs(B5);
790 G4double mint5 = 0.;
791 G4double maxt5 = CLHEP::pi;
792 G4double t5interval = G4Log((absA5 + absB5*maxt5)/(absA5 + absB5*mint5))/absB5;
793 G4double argexp = absB5*t5interval*randNumbs[6] + G4Log(absA5 + absB5*mint5);
794 G4double t5 = -absA5/absB5 + G4Exp(argexp)/absB5;
795 G4double sint5 = std::sin(t5);
796 G4double cost5 = std::cos(t5);
797
798 eDirection.set(sint5*cosp5, sint5*sinp5, cost5);
799 G4ThreeVector eMomentumVector = eMomentum*eDirection;
800
801 G4ThreeVector auxVec2 = particleMomentumVector - muFinalMomentumVector - eMomentumVector;
802 G4double p1mp3mp52 = auxVec2.dot(auxVec2);
803 G4double Bp = particleFinalMomentum*(sint3*cosp3*cosp6 + sint3*sinp3*sinp6) +
804 eMomentum*(sint5*cosp5*cosp6 + sint5*sinp5*sinp6);
805 G4double Cp = -particleMomentum + particleFinalMomentum*cost3 + eMomentum*cost5;
806 G4double A6 = p1mp3mp52 + pMomentum*pMomentum;
807 G4double B6 = 2.*pMomentum*Bp;
808 G4double C6 = 2.*pMomentum*Cp;
809 G4double mint6 = 0.;
810 G4double maxt6 = CLHEP::pi;
811 G4double absA6C6 = std::abs(A6 + C6);
812 G4double absB6 = std::abs(B6);
813 G4double t6interval = (1./(absA6C6 + absB6*mint6) - 1./(absA6C6 + absB6*maxt6))/absB6;
814 G4double t6 = (-absA6C6 + 1./(1./(absA6C6 + absB6*mint6) - absB6*t6interval*randNumbs[8]))/absB6;
815 G4double sint6 = std::sin(t6);
816 G4double cost6 = std::cos(t6);
817
818 pDirection.set(sint6*cosp6, sint6*sinp6, cost6);
819
820 } else {
821 G4double phi6 = CLHEP::twopi*randNumbs[1];
822 G4double phi5 = CLHEP::twopi*randNumbs[2];
823 G4double muFinalEnergyinterval = kinEnergy - 2.*eMass - particleMass;
824 particleFinalEnergy = particleMass + muFinalEnergyinterval*randNumbs[3];
825 particleFinalMomentum = std::sqrt(particleFinalEnergy*particleFinalEnergy -
826 particleMass*particleMass);
827
828 G4double maxpEnergy = kinEnergy - particleFinalEnergy - eMass;
829 G4double pEnergyinterval = maxpEnergy - eMass;
830 pEnergy = eMass + pEnergyinterval*randNumbs[4];
831
832 G4double cosp3 = 1.;
833 G4double sinp3 = 0.;
834 G4double cosp5 = std::cos(phi5);
835 G4double sinp5 = std::sin(phi5);
836 G4double cosp6 = std::cos(phi6);
837 G4double sinp6 = std::sin(phi6);
838
839 G4double pMomentum = std::sqrt(pEnergy*pEnergy - eMass*eMass);
840 eEnergy = kinEnergy - particleFinalEnergy - pEnergy;
841 G4double eMomentum = std::sqrt(eEnergy*eEnergy - eMass*eMass);
842
843 G4double A3 = -2.*particleMass*particleMass + 2.*kinEnergy*particleFinalEnergy;
844 G4double B3 = -2.*particleMomentum*particleFinalMomentum;
845 G4double cost3interval = G4Log((A3 + B3*Cmax)/(A3 + B3*Cmin))/B3;
846 G4double expanCost3r6 = G4Exp(B3*cost3interval*randNumbs[5]);
847 G4double cost3 = A3*(expanCost3r6 - 1.)/B3 + Cmin*expanCost3r6;
848 G4double sint3 = std::sqrt((1. - cost3)*(1. + cost3));
849
850 partDirection.set(sint3*cosp3, sint3*sinp3, cost3);
851
852 G4ThreeVector muFinalMomentumVector;
853 muFinalMomentumVector.set(particleFinalMomentum*sint3*cosp3,
854 particleFinalMomentum*sint3*sinp3,
855 particleFinalMomentum*cost3);
856
857 G4LorentzVector muFourMomentum(particleMomentum, particleMomentumVector);
858 G4LorentzVector muFinalFourMomentum(particleFinalEnergy, muFinalMomentumVector);
859 G4LorentzVector auxVec1 = muFourMomentum - muFinalFourMomentum;
860 G4double A6 = auxVec1.mag2() -
861 2.*pEnergy*(kinEnergy - particleFinalEnergy) + 2.*particleMomentumVector[2]*pMomentum -
862 2.*particleFinalMomentum*pMomentum*cost3;
863 G4double B6 = -2.*particleFinalMomentum*pMomentum*(sint3*cosp3*cosp6 + sint3*sinp3*sinp6);
864 G4double absA6 = std::abs(A6);
865 G4double absB6 = std::abs(B6);
866 G4double mint6 = 0.;
867 G4double maxt6 = CLHEP::pi;
868 G4double t6interval = G4Log((absA6 + absB6*maxt6)/(absA6 + absB6*mint6))/absB6;
869 G4double argexp = absB6*t6interval*randNumbs[6] + G4Log(absA6 + absB6*mint6);
870 G4double t6 = -absA6/absB6 + G4Exp(argexp)/absB6;
871 G4double sint6 = std::sin(t6);
872 G4double cost6 = std::cos(t6);
873
874 pDirection.set(sint6*cosp6, sint6*sinp6, cost6);
875 G4ThreeVector pMomentumVector = pMomentum*pDirection;
876
877 G4ThreeVector auxVec2 = particleMomentumVector - muFinalMomentumVector - pMomentumVector;
878 G4double p1mp3mp62 = auxVec2.dot(auxVec2);
879 G4double Bp = particleFinalMomentum*(sint3*cosp3*cosp5 + sint3*sinp3*sinp5) +
880 pMomentum*(sint6*cosp6*cosp5 + sint6*sinp6*sinp5);
881 G4double Cp = -particleMomentum + particleFinalMomentum*cost3 + pMomentum*cost6;
882 G4double A5 = p1mp3mp62 + eMomentum*eMomentum;
883 G4double B5 = 2.*eMomentum*Bp;
884 G4double C5 = 2.*eMomentum*Cp;
885 G4double mint5 = 0.;
886 G4double maxt5 = CLHEP::pi;
887 G4double absA5C5 = std::abs(A5 + C5);
888 G4double absB5 = std::abs(B5);
889 G4double t5interval = (1./(absA5C5 + absB5*mint5) - 1./(absA5C5 + absB5*maxt5))/absB5;
890 G4double t5 = (-absA5C5 + 1./(1./(absA5C5 + absB5*mint5) - absB5*t5interval*randNumbs[8]))/absB5;
891 G4double sint5 = std::sin(t5);
892 G4double cost5 = std::cos(t5);
893
894 eDirection.set(sint5*cosp5, sint5*sinp5, cost5);
895 }
896
897 fAngularGenerator->Sample5DPairDirections(aDynamicParticle, eDirection, pDirection,
898 gEnergy, Q2, gMomentum,
899 particleFinalMomentum,
900 particleFinalEnergy,
901 randNumbs, W);
902
903 // create G4DynamicParticle object for e+e-
904 auto aParticle1 = new G4DynamicParticle(theElectron, eDirection, eEnergy);
905 auto aParticle2 = new G4DynamicParticle(thePositron, pDirection, pEnergy);
906
907 // Fill output vector
908 vdp->push_back(aParticle1);
909 vdp->push_back(aParticle2);
910
911 // if energy transfer is higher than threshold (very high by default)
912 // then stop tracking the primary particle and create a new secondary
913 if (pairEnergy > SecondaryThreshold()) {
914 fParticleChange->ProposeTrackStatus(fStopAndKill);
915 fParticleChange->SetProposedKineticEnergy(0.0);
916 auto newdp = new G4DynamicParticle(particle, muF);
917 vdp->push_back(newdp);
918 } else { // continue tracking the primary e-/e+ otherwise
919 fParticleChange->SetProposedMomentumDirection(muF.vect().unit());
920 G4double ekin = std::max(muF.e() - particleMass, 0.0);
921 fParticleChange->SetProposedKineticEnergy(ekin);
922 }
923 //G4cout << "-- G4RiGeMuPairProductionModel::SampleSecondaries done" << G4endl;
924}
C
G4double C(G4double temp)
Definition G4DNAElectronHoleRecombination.cc:88
B
G4double B(G4double temperature)
Definition G4DNAElectronHoleRecombination.cc:71
G4LorentzVector
CLHEP::HepLorentzVector G4LorentzVector
Definition G4LorentzVector.hh:33
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition G4ThreeVector.hh:36
fStopAndKill
@ fStopAndKill
Definition G4TrackStatus.hh:46
A
const G4double A[17]
Definition G4WaterStopping.cc:53
C5
#define C5
CLHEP::Hep3Vector::unit
Hep3Vector unit() const
CLHEP::Hep3Vector::dot
double dot(const Hep3Vector &) const
CLHEP::Hep3Vector::set
void set(double x, double y, double z)
CLHEP::HepLorentzVector::boost
HepLorentzVector & boost(double, double, double)
Definition LorentzVector.cc:55
CLHEP::HepLorentzVector::vect
Hep3Vector vect() const
CLHEP::HepRandomEngine::flat
virtual double flat()=0
CLHEP::HepRandomEngine::flatArray
virtual void flatArray(const int size, double *vect)=0
G4DynamicParticle::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4DynamicParticle::GetKineticEnergy
G4double GetKineticEnergy() const
G4DynamicParticle::GetMomentum
G4ThreeVector GetMomentum() const
G4DynamicParticle::GetTotalMomentum
G4double GetTotalMomentum() const
G4Element::GetZ
G4double GetZ() const
Definition G4Element.hh:119
G4RiGeMuPairProductionModel::FindScaledEnergy
G4double FindScaledEnergy(G4int Z, G4double rand, G4double logTkin, G4double yymin, G4double yymax)
Definition G4RiGeMuPairProductionModel.cc:929
G4VEmModel::SelectRandomAtom
const G4Element * SelectRandomAtom(const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition G4VEmModel.hh:560
G4VEmModel::SecondaryThreshold
G4double SecondaryThreshold() const
Definition G4VEmModel.hh:668
W
#define W
Definition crc32.c:85

◆ SetLowestKineticEnergy()

void G4RiGeMuPairProductionModel::SetLowestKineticEnergy ( G4double e)
inline

Definition at line 172 of file G4RiGeMuPairProductionModel.hh.

173{
174 lowestKinEnergy = e;
175}

◆ SetParticle()

void G4RiGeMuPairProductionModel::SetParticle ( const G4ParticleDefinition * p)
inline

Definition at line 180 of file G4RiGeMuPairProductionModel.hh.

181{
182 if(nullptr == particle) {
183 particle = p;
184 particleMass = particle->GetPDGMass();
185 }
186}

Referenced by G4RiGeMuPairProductionModel(), and Initialise().

◆ StoreTables()

void G4RiGeMuPairProductionModel::StoreTables ( ) const
protected

Definition at line 961 of file G4RiGeMuPairProductionModel.cc.

962{
963 for (G4int iz=0; iz<NZDATPAIR; ++iz) {
964 G4int Z = ZDATPAIR[iz];
965 G4Physics2DVector* pv = fElementData->GetElement2DData(Z);
966 if(nullptr == pv) {
967 DataCorrupted(Z, 1.0);
968 return;
969 }
970 std::ostringstream ss;
971 ss << "mupair/" << particle->GetParticleName() << Z << ".dat";
972 std::ofstream outfile(ss.str());
973 pv->Store(outfile);
974 }
975}
G4Physics2DVector::Store
void Store(std::ofstream &fOut) const
Definition G4Physics2DVector.cc:286

Referenced by Initialise().

Member Data Documentation

◆ currentZ

G4int G4RiGeMuPairProductionModel::currentZ = 0
protected

Definition at line 148 of file G4RiGeMuPairProductionModel.hh.

Referenced by MaxSecondaryEnergyForElement(), and SampleSecondaries().

◆ dy

G4double G4RiGeMuPairProductionModel::dy = 0.005
protected

Definition at line 143 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise(), and MakeSamplingTables().

◆ emax

G4double G4RiGeMuPairProductionModel::emax
protected

Definition at line 141 of file G4RiGeMuPairProductionModel.hh.

Referenced by G4RiGeMuPairProductionModel(), Initialise(), and MakeSamplingTables().

◆ emin

G4double G4RiGeMuPairProductionModel::emin
protected

Definition at line 140 of file G4RiGeMuPairProductionModel.hh.

Referenced by G4RiGeMuPairProductionModel(), Initialise(), and MakeSamplingTables().

◆ factorForCross

G4double G4RiGeMuPairProductionModel::factorForCross
protected

Definition at line 130 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeDMicroscopicCrossSection(), and G4RiGeMuPairProductionModel().

◆ fParticleChange

G4ParticleChangeForLoss* G4RiGeMuPairProductionModel::fParticleChange = nullptr
protected

Definition at line 126 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise(), and SampleSecondaries().

◆ fTableToFile

G4bool G4RiGeMuPairProductionModel::fTableToFile = false
protected

Definition at line 153 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise().

◆ lnZ

G4double G4RiGeMuPairProductionModel::lnZ = 0.0
protected

Definition at line 135 of file G4RiGeMuPairProductionModel.hh.

Referenced by MaxSecondaryEnergyForElement(), and SampleSecondaries().

◆ lowestKinEnergy

G4double G4RiGeMuPairProductionModel::lowestKinEnergy
protected

Definition at line 138 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeCrossSectionPerAtom(), ComputeDEDXPerVolume(), G4RiGeMuPairProductionModel(), Initialise(), InitialiseLocal(), MinPrimaryEnergy(), and SetLowestKineticEnergy().

◆ minPairEnergy

G4double G4RiGeMuPairProductionModel::minPairEnergy
protected

Definition at line 137 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeCrossSectionPerAtom(), ComputeDEDXPerVolume(), ComputeDMicroscopicCrossSection(), ComputeMicroscopicCrossSection(), ComputMuPairLoss(), G4RiGeMuPairProductionModel(), Initialise(), MakeSamplingTables(), and SampleSecondaries().

◆ nbine

std::size_t G4RiGeMuPairProductionModel::nbine = 0
protected

Definition at line 151 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise(), MakeSamplingTables(), and RetrieveTables().

◆ nbiny

std::size_t G4RiGeMuPairProductionModel::nbiny = 1000
protected

Definition at line 150 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise(), MakeSamplingTables(), and RetrieveTables().

◆ NINTPAIR

const G4int G4RiGeMuPairProductionModel::NINTPAIR = 8
staticprotected

Definition at line 157 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeDMicroscopicCrossSection(), ComputeMicroscopicCrossSection(), and ComputMuPairLoss().

◆ nist

G4NistManager* G4RiGeMuPairProductionModel::nist = nullptr
protected

Definition at line 128 of file G4RiGeMuPairProductionModel.hh.

Referenced by G4RiGeMuPairProductionModel(), MaxSecondaryEnergyForElement(), and SampleSecondaries().

◆ nYBinPerDecade

G4int G4RiGeMuPairProductionModel::nYBinPerDecade = 4
protected

Definition at line 149 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise().

◆ NZDATPAIR

const G4int G4RiGeMuPairProductionModel::NZDATPAIR = 5
staticprotected

Definition at line 156 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise(), MakeSamplingTables(), RetrieveTables(), SampleSecondaries(), and StoreTables().

◆ particle

const G4ParticleDefinition* G4RiGeMuPairProductionModel::particle = nullptr
protected

Definition at line 127 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise(), InitialiseLocal(), RetrieveTables(), SampleSecondaries(), SetParticle(), and StoreTables().

◆ particleMass

G4double G4RiGeMuPairProductionModel::particleMass = 0.0
protected

Definition at line 132 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeDMicroscopicCrossSection(), MaxSecondaryEnergyForElement(), SampleSecondaries(), and SetParticle().

◆ randNumbs

G4double G4RiGeMuPairProductionModel::randNumbs[9]
protected

Definition at line 146 of file G4RiGeMuPairProductionModel.hh.

Referenced by G4RiGeMuPairProductionModel(), and SampleSecondaries().

◆ sqrte

G4double G4RiGeMuPairProductionModel::sqrte
protected

Definition at line 131 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeDMicroscopicCrossSection(), G4RiGeMuPairProductionModel(), and MaxSecondaryEnergyForElement().

◆ wgi

const G4double G4RiGeMuPairProductionModel::wgi
staticprotected
Initial value:
= {
0.0506142681451880, 0.1111905172266870, 0.1568533229389435, 0.1813418916891810,
0.1813418916891810, 0.1568533229389435, 0.1111905172266870, 0.0506142681451880
}

Definition at line 76 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeDMicroscopicCrossSection(), ComputeMicroscopicCrossSection(), and ComputMuPairLoss().

◆ xgi

const G4double G4RiGeMuPairProductionModel::xgi
staticprotected
Initial value:
= {
0.0198550717512320, 0.1016667612931865, 0.2372337950418355, 0.4082826787521750,
0.5917173212478250, 0.7627662049581645, 0.8983332387068135, 0.9801449282487680
}

Definition at line 71 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeDMicroscopicCrossSection(), ComputeMicroscopicCrossSection(), and ComputMuPairLoss().

◆ ymin

G4double G4RiGeMuPairProductionModel::ymin = -5.0
protected

Definition at line 142 of file G4RiGeMuPairProductionModel.hh.

Referenced by Initialise(), MakeSamplingTables(), and SampleSecondaries().

◆ z13

G4double G4RiGeMuPairProductionModel::z13 = 0.0
protected

Definition at line 133 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeDMicroscopicCrossSection(), and MaxSecondaryEnergyForElement().

◆ z23

G4double G4RiGeMuPairProductionModel::z23 = 0.0
protected

Definition at line 134 of file G4RiGeMuPairProductionModel.hh.

Referenced by ComputeDMicroscopicCrossSection(), and MaxSecondaryEnergyForElement().

◆ ZDATPAIR

const G4int G4RiGeMuPairProductionModel::ZDATPAIR = {1, 4, 13, 29, 92}
staticprotected

Definition at line 69 of file G4RiGeMuPairProductionModel.hh.

Referenced by FindScaledEnergy(), MakeSamplingTables(), RetrieveTables(), SampleSecondaries(), and StoreTables().

The documentation for this class was generated from the following files: