#include <CMSmplIonisationWithDeltaModel.h>

Inheritance diagram for CMSmplIonisationWithDeltaModel:

Public Member Functions
	CMSmplIonisationWithDeltaModel (G4double mCharge, const G4String &nam="mplIonisationWithDelta")

G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double kineticEnergy, G4double Z, G4double A, G4double cutEnergy, G4double maxEnergy) override

virtual G4double	ComputeCrossSectionPerElectron (const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy, G4double maxEnergy)

G4double	ComputeDEDXPerVolume (const G4Material , const G4ParticleDefinition , G4double kineticEnergy, G4double cutEnergy) override

G4double	Dispersion (const G4Material , const G4DynamicParticle , G4double tmax, G4double length) override

void	Initialise (const G4ParticleDefinition *, const G4DataVector &) override

G4double	MinEnergyCut (const G4ParticleDefinition , const G4MaterialCutsCouple couple) override

G4double	SampleFluctuations (const G4MaterialCutsCouple , const G4DynamicParticle , G4double tmax, G4double length, G4double meanLoss) override

void	SampleSecondaries (std::vector< G4DynamicParticle * > , const G4MaterialCutsCouple , const G4DynamicParticle *, G4double tmin, G4double maxEnergy) override

void	SetParticle (const G4ParticleDefinition *p)

	~CMSmplIonisationWithDeltaModel () override

Protected Member Functions
G4double	MaxSecondaryEnergy (const G4ParticleDefinition *, G4double kinEnergy) override

Private Member Functions
G4double	ComputeDEDXAhlen (const G4Material *material, G4double bg2, G4double cut)

Private Attributes
G4double	beta2lim

G4double	betalim

G4double	betalow

G4double	bg2lim

G4double	chargeSquare

G4double	dedxlim

G4ParticleChangeForLoss *	fParticleChange

G4double	magCharge

G4double	mass

const G4ParticleDefinition *	monopole

G4int	nmpl

G4double	pi_hbarc2_over_mc2

G4ParticleDefinition *	theElectron

G4double	twoln10

Static Private Attributes
static std::vector< G4double > *	dedx0 = nullptr

Detailed Description

Definition at line 29 of file CMSmplIonisationWithDeltaModel.h.

Constructor & Destructor Documentation

◆ CMSmplIonisationWithDeltaModel()

CMSmplIonisationWithDeltaModel::CMSmplIonisationWithDeltaModel	(	G4double	mCharge,
		const G4String &	nam = `"mplIonisationWithDelta"`
	)

explicit

Definition at line 40 of file CMSmplIonisationWithDeltaModel.cc.

     : G4VEmModel(nam),
       G4VEmFluctuationModel(nam),
       magCharge(mCharge),
       twoln10(std::log(100.0)),
       betalow(0.01),
       betalim(0.1),
       beta2lim(betalim * betalim),
       bg2lim(beta2lim * (1.0 + beta2lim)) {
   nmpl = G4lrint(std::abs(magCharge) * 2 * fine_structure_const);
   if (nmpl > 6) {
     nmpl = 6;
   } else if (nmpl < 1) {
     nmpl = 1;
   }
   pi_hbarc2_over_mc2 = pi * hbarc * hbarc / electron_mass_c2;
   chargeSquare = magCharge * magCharge;
   dedxlim = 45. * nmpl * nmpl * GeV * cm2 / g;
   fParticleChange = nullptr;
   theElectron = G4Electron::Electron();
   G4cout << "### Monopole ionisation model with d-electron production, Gmag= " << magCharge / eplus << G4endl;
   monopole = nullptr;
   mass = 0.0;
 }

References funct::abs(), chargeSquare, dedxlim, nanoDQM_cff::Electron, fParticleChange, g, ecalTB2006H4_GenSimDigiReco_cfg::G4cout, GeV, hbarc, magCharge, mass, monopole, nmpl, pi, pi_hbarc2_over_mc2, and theElectron.

◆ ~CMSmplIonisationWithDeltaModel()

CMSmplIonisationWithDeltaModel::~CMSmplIonisationWithDeltaModel ( )

override

Definition at line 67 of file CMSmplIonisationWithDeltaModel.cc.

                                                                 {
   if (IsMaster()) {
     delete dedx0;
   }
 }

References dedx0.

Member Function Documentation

◆ ComputeCrossSectionPerAtom()

G4double CMSmplIonisationWithDeltaModel::ComputeCrossSectionPerAtom	(	const G4ParticleDefinition *	p,
		G4double	kineticEnergy,
		G4double	Z,
		G4double	A,
		G4double	cutEnergy,
		G4double	maxEnergy
	)

override

Definition at line 213 of file CMSmplIonisationWithDeltaModel.cc.

                                                                                         {
   G4double cross = Z * ComputeCrossSectionPerElectron(p, kineticEnergy, cutEnergy, maxEnergy);
   return cross;
 }

References ComputeCrossSectionPerElectron(), cross(), particleFlowClusterECALTimeSelected_cfi::maxEnergy, AlCaHLTBitMon_ParallelJobs::p, and BeamSpotPI::Z.

◆ ComputeCrossSectionPerElectron()

G4double CMSmplIonisationWithDeltaModel::ComputeCrossSectionPerElectron	(	const G4ParticleDefinition *	p,
		G4double	kineticEnergy,
		G4double	cutEnergy,
		G4double	maxEnergy
	)

virtual

Definition at line 196 of file CMSmplIonisationWithDeltaModel.cc.

                                                                                                {
   if (!monopole) {
     SetParticle(p);
   }
   G4double tmax = MaxSecondaryEnergy(p, kineticEnergy);
   G4double maxEnergy = std::min(tmax, maxKinEnergy);
   G4double cutEnergy = std::max(LowEnergyLimit(), cut);
   G4double cross =
       (cutEnergy < maxEnergy) ? (0.5 / cutEnergy - 0.5 / maxEnergy) * pi_hbarc2_over_mc2 * nmpl * nmpl : 0.0;
   return cross;
 }

References cross(), TkAlMuonSelectors_cfi::cut, SiStripPI::max, particleFlowClusterECALTimeSelected_cfi::maxEnergy, MaxSecondaryEnergy(), min(), monopole, nmpl, AlCaHLTBitMon_ParallelJobs::p, pi_hbarc2_over_mc2, SetParticle(), and tmax.

Referenced by ComputeCrossSectionPerAtom().

◆ ComputeDEDXAhlen()

G4double CMSmplIonisationWithDeltaModel::ComputeDEDXAhlen	(	const G4Material *	material,
		G4double	bg2,
		G4double	cut
	)

private

Definition at line 163 of file CMSmplIonisationWithDeltaModel.cc.

                                                                               {
   G4double eDensity = material->GetElectronDensity();
   G4double eexc = material->GetIonisation()->GetMeanExcitationEnergy();
  
   // Ahlen's formula for nonconductors, [1]p157, f(5.7)
   G4double dedx = 0.5 * (G4Log(2.0 * electron_mass_c2 * bg2 * cutEnergy / (eexc * eexc)) - 1.0);
  
   // Kazama et al. cross-section correction
   G4double k = 0.406;
   if (nmpl > 1) {
     k = 0.346;
   }
  
   // Bloch correction
   const G4double B[7] = {0.0, 0.248, 0.672, 1.022, 1.243, 1.464, 1.685};
  
   dedx += 0.5 * k - B[nmpl];
  
   // density effect correction
   G4double x = G4Log(bg2) / twoln10;
   dedx -= material->GetIonisation()->DensityCorrection(x);
  
   // now compute the total ionization loss
   dedx *= pi_hbarc2_over_mc2 * eDensity * nmpl * nmpl;
  
   dedx = std::max(dedx, 0.0);
   return dedx;
 }

References TtFullHadDaughter::B, dqmdumpme::k, SiStripPI::max, nmpl, pi_hbarc2_over_mc2, twoln10, and x.

Referenced by ComputeDEDXPerVolume().

◆ ComputeDEDXPerVolume()

G4double CMSmplIonisationWithDeltaModel::ComputeDEDXPerVolume	(	const G4Material *	material,
		const G4ParticleDefinition *	p,
		G4double	kineticEnergy,
		G4double	cutEnergy
	)

override

Definition at line 123 of file CMSmplIonisationWithDeltaModel.cc.

                                                                                   {
   if (!monopole) {
     SetParticle(p);
   }
   G4double tmax = MaxSecondaryEnergy(p, kineticEnergy);
   G4double cutEnergy = std::min(tmax, maxEnergy);
   cutEnergy = std::max(LowEnergyLimit(), cutEnergy);
   G4double tau = kineticEnergy / mass;
   G4double gam = tau + 1.0;
   G4double bg2 = tau * (tau + 2.0);
   G4double beta2 = bg2 / (gam * gam);
   G4double beta = sqrt(beta2);
  
   // low-energy asymptotic formula
   G4double dedx = (*dedx0)[CurrentCouple()->GetIndex()] * beta;
  
   // above asymptotic
   if (beta > betalow) {
     // high energy
     if (beta >= betalim) {
       dedx = ComputeDEDXAhlen(material, bg2, cutEnergy);
  
     } else {
       G4double dedx1 = (*dedx0)[CurrentCouple()->GetIndex()] * betalow;
       G4double dedx2 = ComputeDEDXAhlen(material, bg2lim, cutEnergy);
  
       // extrapolation between two formula
       G4double kapa2 = beta - betalow;
       G4double kapa1 = betalim - beta;
       dedx = (kapa1 * dedx1 + kapa2 * dedx2) / (kapa1 + kapa2);
     }
   }
   return dedx;
 }

References zMuMuMuonUserData::beta, betalim, betalow, bg2lim, ComputeDEDXAhlen(), mass, SiStripPI::max, particleFlowClusterECALTimeSelected_cfi::maxEnergy, MaxSecondaryEnergy(), min(), monopole, AlCaHLTBitMon_ParallelJobs::p, SetParticle(), mathSSE::sqrt(), metsig::tau, and tmax.

◆ Dispersion()

G4double CMSmplIonisationWithDeltaModel::Dispersion	(	const G4Material *	material,
		const G4DynamicParticle *	dp,
		G4double	tmax,
		G4double	length
	)

override

Definition at line 308 of file CMSmplIonisationWithDeltaModel.cc.

                                                                      {
   G4double siga = 0.0;
   G4double tau = dp->GetKineticEnergy() / mass;
   if (tau > 0.0) {
     G4double electronDensity = material->GetElectronDensity();
     G4double gam = tau + 1.0;
     G4double invbeta2 = (gam * gam) / (tau * (tau + 2.0));
     siga = (invbeta2 - 0.5) * twopi_mc2_rcl2 * tmax * length * electronDensity * chargeSquare;
   }
   return siga;
 }

References chargeSquare, Calorimetry_cff::dp, mass, metsig::tau, and tmax.

Referenced by SampleFluctuations().

◆ Initialise()

void CMSmplIonisationWithDeltaModel::Initialise	(	const G4ParticleDefinition *	p,
		const G4DataVector &
	)

override

Definition at line 86 of file CMSmplIonisationWithDeltaModel.cc.

                                                                                                   {
   if (!monopole) {
     SetParticle(p);
   }
   if (!fParticleChange) {
     fParticleChange = GetParticleChangeForLoss();
   }
   if (IsMaster()) {
     if (!dedx0) {
       dedx0 = new std::vector<G4double>;
     }
     G4ProductionCutsTable* theCoupleTable = G4ProductionCutsTable::GetProductionCutsTable();
     G4int numOfCouples = theCoupleTable->GetTableSize();
     G4int n = dedx0->size();
     if (n < numOfCouples) {
       dedx0->resize(numOfCouples);
     }
     G4Pow* g4calc = G4Pow::GetInstance();
  
     // initialise vector
     for (G4int i = 0; i < numOfCouples; ++i) {
       const G4Material* material = theCoupleTable->GetMaterialCutsCouple(i)->GetMaterial();
       G4double eDensity = material->GetElectronDensity();
       G4double vF2 = 2 * electron_Compton_length * g4calc->A13(3. * pi * pi * eDensity);
       (*dedx0)[i] = pi_hbarc2_over_mc2 * eDensity * nmpl * nmpl * (G4Log(vF2 / fine_structure_const) - 0.5) / vF2;
     }
   }
 }

References dedx0, fParticleChange, mps_fire::i, monopole, dqmiodumpmetadata::n, nmpl, AlCaHLTBitMon_ParallelJobs::p, pi, pi_hbarc2_over_mc2, and SetParticle().

◆ MaxSecondaryEnergy()

G4double CMSmplIonisationWithDeltaModel::MaxSecondaryEnergy	(	const G4ParticleDefinition *	,
		G4double	kinEnergy
	)

overrideprotected

Definition at line 325 of file CMSmplIonisationWithDeltaModel.cc.

                                                                                                            {
   G4double tau = kinEnergy / mass;
   return 2.0 * electron_mass_c2 * tau * (tau + 2.);
 }

References mass, and metsig::tau.

Referenced by ComputeCrossSectionPerElectron(), ComputeDEDXPerVolume(), and SampleSecondaries().

◆ MinEnergyCut()

G4double CMSmplIonisationWithDeltaModel::MinEnergyCut	(	const G4ParticleDefinition *	,
		const G4MaterialCutsCouple *	couple
	)

override

Definition at line 117 of file CMSmplIonisationWithDeltaModel.cc.

                                                                                                                      {
   return couple->GetMaterial()->GetIonisation()->GetMeanExcitationEnergy();
 }

◆ SampleFluctuations()

G4double CMSmplIonisationWithDeltaModel::SampleFluctuations	(	const G4MaterialCutsCouple *	couple,
		const G4DynamicParticle *	dp,
		G4double	tmax,
		G4double	length,
		G4double	meanLoss
	)

override

Definition at line 280 of file CMSmplIonisationWithDeltaModel.cc.

                                                                                {
   G4double siga = Dispersion(couple->GetMaterial(), dp, tmax, length);
   G4double loss = meanLoss;
   siga = sqrt(siga);
   G4double twomeanLoss = meanLoss + meanLoss;
  
   if (twomeanLoss < siga) {
     G4double x;
     do {
       loss = twomeanLoss * G4UniformRand();
       x = (loss - meanLoss) / siga;
       // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
     } while (1.0 - 0.5 * x * x < G4UniformRand());
   } else {
     do {
       loss = G4RandGauss::shoot(meanLoss, siga);
       // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
     } while (0.0 > loss || loss > twomeanLoss);
   }
   return loss;
 }

References Dispersion(), Calorimetry_cff::dp, mathSSE::sqrt(), tmax, and x.

◆ SampleSecondaries()

void CMSmplIonisationWithDeltaModel::SampleSecondaries	(	std::vector< G4DynamicParticle * > *	vdp,
		const G4MaterialCutsCouple *	,
		const G4DynamicParticle *	dp,
		G4double	tmin,
		G4double	maxEnergy
	)

override

Definition at line 225 of file CMSmplIonisationWithDeltaModel.cc.

                                                                            {
   G4double kineticEnergy = dp->GetKineticEnergy();
   G4double tmax = MaxSecondaryEnergy(dp->GetDefinition(), kineticEnergy);
  
   G4double maxKinEnergy = std::min(maxEnergy, tmax);
   if (minKinEnergy >= maxKinEnergy) {
     return;
   }
  
   //G4cout << "CMSmplIonisationWithDeltaModel::SampleSecondaries: E(GeV)= "
   //         << kineticEnergy/GeV << " M(GeV)= " << mass/GeV
   //         << " tmin(MeV)= " << minKinEnergy/MeV << G4endl;
  
   G4double totEnergy = kineticEnergy + mass;
   G4double etot2 = totEnergy * totEnergy;
   G4double beta2 = kineticEnergy * (kineticEnergy + 2.0 * mass) / etot2;
  
   // sampling without nuclear size effect
   G4double q = G4UniformRand();
   G4double deltaKinEnergy = minKinEnergy * maxKinEnergy / (minKinEnergy * (1.0 - q) + maxKinEnergy * q);
  
   // delta-electron is produced
   G4double totMomentum = totEnergy * sqrt(beta2);
   G4double deltaMomentum = sqrt(deltaKinEnergy * (deltaKinEnergy + 2.0 * electron_mass_c2));
   G4double cost = deltaKinEnergy * (totEnergy + electron_mass_c2) / (deltaMomentum * totMomentum);
   cost = std::min(cost, 1.0);
  
   G4double sint = sqrt((1.0 - cost) * (1.0 + cost));
  
   G4double phi = twopi * G4UniformRand();
  
   G4ThreeVector deltaDirection(sint * cos(phi), sint * sin(phi), cost);
   const G4ThreeVector& direction = dp->GetMomentumDirection();
   deltaDirection.rotateUz(direction);
  
   // create G4DynamicParticle object for delta ray
   G4DynamicParticle* delta = new G4DynamicParticle(theElectron, deltaDirection, deltaKinEnergy);
  
   vdp->push_back(delta);
  
   // Change kinematics of primary particle
   kineticEnergy -= deltaKinEnergy;
   G4ThreeVector finalP = direction * totMomentum - deltaDirection * deltaMomentum;
   finalP = finalP.unit();
  
   fParticleChange->SetProposedKineticEnergy(kineticEnergy);
   fParticleChange->SetProposedMomentumDirection(finalP);
 }

References funct::cos(), dumpMFGeometry_cfg::delta, Calorimetry_cff::dp, fParticleChange, mass, particleFlowClusterECALTimeSelected_cfi::maxEnergy, MaxSecondaryEnergy(), min(), phi, submitPVResolutionJobs::q, funct::sin(), mathSSE::sqrt(), theElectron, and tmax.

◆ SetParticle()

void CMSmplIonisationWithDeltaModel::SetParticle ( const G4ParticleDefinition * p )

Definition at line 75 of file CMSmplIonisationWithDeltaModel.cc.

                                                                               {
   monopole = p;
   mass = monopole->GetPDGMass();
   G4double emin = std::min(LowEnergyLimit(), 0.1 * mass * (1. / sqrt(1. - betalow * betalow) - 1.));
   G4double emax = std::max(HighEnergyLimit(), 10 * mass * (1. / sqrt(1. - beta2lim) - 1.));
   SetLowEnergyLimit(emin);
   SetHighEnergyLimit(emax);
 }