#include <G4Cerenkov.hh>

Inheritance diagram for G4Cerenkov:

Collaboration diagram for G4Cerenkov:

Public Member Functions
	G4Cerenkov (const G4String &processName="Cerenkov", G4ProcessType type=fElectromagnetic)

	~G4Cerenkov ()

	G4Cerenkov (const G4Cerenkov &right)

G4bool	IsApplicable (const G4ParticleDefinition &aParticleType)

void	BuildPhysicsTable (const G4ParticleDefinition &aParticleType)

G4double	GetMeanFreePath (const G4Track &aTrack, G4double, G4ForceCondition *)

G4double	PostStepGetPhysicalInteractionLength (const G4Track &aTrack, G4double, G4ForceCondition *)

G4VParticleChange *	PostStepDoIt (const G4Track &aTrack, const G4Step &aStep)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)

void	SetTrackSecondariesFirst (const G4bool state)

G4bool	GetTrackSecondariesFirst () const

void	SetMaxBetaChangePerStep (const G4double d)

G4double	GetMaxBetaChangePerStep () const

void	SetMaxNumPhotonsPerStep (const G4int NumPhotons)

G4int	GetMaxNumPhotonsPerStep () const

G4PhysicsTable *	GetPhysicsTable () const

void	DumpPhysicsTable () const

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Attributes
G4PhysicsTable *	thePhysicsTable

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Private Member Functions
G4Cerenkov &	operator= (const G4Cerenkov &right)

void	BuildThePhysicsTable ()

G4double	GetAverageNumberOfPhotons (const G4double charge, const G4double beta, const G4Material aMaterial, G4MaterialPropertyVector Rindex) const

Private Attributes
G4bool	fTrackSecondariesFirst

G4double	fMaxBetaChange

G4int	fMaxPhotons

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 81 of file G4Cerenkov.hh.

Constructor & Destructor Documentation

◆ G4Cerenkov() [1/2]

G4Cerenkov::G4Cerenkov	(	const G4String &	processName = `"Cerenkov"`,
		G4ProcessType	type = `fElectromagnetic`
	)

Definition at line 100 of file G4Cerenkov.cc.

            : G4VProcess(processName, type) ,
             fTrackSecondariesFirst(false),
             fMaxBetaChange(0),
             fMaxPhotons(0)
 {
         SetProcessSubType(fCerenkov);
 
         thePhysicsTable = NULL;
 
     if (verboseLevel>0) {
            G4cout << GetProcessName() << " is created " << G4endl;
     }
 }

Here is the call graph for this function:

◆ ~G4Cerenkov()

G4Cerenkov::~G4Cerenkov ( )

Definition at line 123 of file G4Cerenkov.cc.

 {
     if (thePhysicsTable != NULL) {
        thePhysicsTable->clearAndDestroy();
            delete thePhysicsTable;
     }
 }

Here is the call graph for this function:

◆ G4Cerenkov() [2/2]

G4Cerenkov::G4Cerenkov ( const G4Cerenkov & right )

Member Function Documentation

◆ AlongStepDoIt()

virtual G4VParticleChange* G4Cerenkov::AlongStepDoIt	(	const G4Track &	,
		const G4Step &
	)

inlinevirtual

Implements G4VProcess.

Definition at line 153 of file G4Cerenkov.hh.

156 {return 0;};

Here is the call graph for this function:

◆ AlongStepGetPhysicalInteractionLength()

virtual G4double G4Cerenkov::AlongStepGetPhysicalInteractionLength	(	const G4Track &	,
		G4double	,
		G4double	,
		G4double &	,
		G4GPILSelection *
	)

inlinevirtual

Implements G4VProcess.

Definition at line 134 of file G4Cerenkov.hh.

140 { return -1.0; };

◆ AtRestDoIt()

virtual G4VParticleChange* G4Cerenkov::AtRestDoIt	(	const G4Track &	,
		const G4Step &
	)

inlinevirtual

Implements G4VProcess.

Definition at line 148 of file G4Cerenkov.hh.

151 {return 0;};

◆ AtRestGetPhysicalInteractionLength()

virtual G4double G4Cerenkov::AtRestGetPhysicalInteractionLength	(	const G4Track &	,
		G4ForceCondition *
	)

inlinevirtual

Implements G4VProcess.

Definition at line 142 of file G4Cerenkov.hh.

145 { return -1.0; };

◆ BuildPhysicsTable()

void G4Cerenkov::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 161 of file G4Cerenkov.cc.

 {
     if (!thePhysicsTable) BuildThePhysicsTable();
 }

Here is the call graph for this function:

◆ BuildThePhysicsTable()

void G4Cerenkov::BuildThePhysicsTable ( )

private

Definition at line 393 of file G4Cerenkov.cc.

 {
     if (thePhysicsTable) return;
 
     const G4MaterialTable* theMaterialTable=
                    G4Material::GetMaterialTable();
     G4int numOfMaterials = G4Material::GetNumberOfMaterials();
 
     // create new physics table
     
     thePhysicsTable = new G4PhysicsTable(numOfMaterials);
 
     // loop for materials
 
     for (G4int i=0 ; i < numOfMaterials; i++)
     {
             G4PhysicsOrderedFreeVector* aPhysicsOrderedFreeVector = 0;
 
         // Retrieve vector of refraction indices for the material
         // from the material's optical properties table 
 
         G4Material* aMaterial = (*theMaterialTable)[i];
 
         G4MaterialPropertiesTable* aMaterialPropertiesTable =
                 aMaterial->GetMaterialPropertiesTable();
 
         if (aMaterialPropertiesTable) {
 
            aPhysicsOrderedFreeVector = new G4PhysicsOrderedFreeVector();
            G4MaterialPropertyVector* theRefractionIndexVector = 
                    aMaterialPropertiesTable->GetProperty("RINDEX");
 
            if (theRefractionIndexVector) {
         
               // Retrieve the first refraction index in vector
               // of (photon energy, refraction index) pairs 
 
                       G4double currentRI = (*theRefractionIndexVector)[0];
 
               if (currentRI > 1.0) {
 
              // Create first (photon energy, Cerenkov Integral)
              // pair  
 
                          G4double currentPM = theRefractionIndexVector->
                                                  Energy(0);
              G4double currentCAI = 0.0;
 
              aPhysicsOrderedFreeVector->
                  InsertValues(currentPM , currentCAI);
 
              // Set previous values to current ones prior to loop
 
              G4double prevPM  = currentPM;
              G4double prevCAI = currentCAI;
                      G4double prevRI  = currentRI;
 
              // loop over all (photon energy, refraction index)
              // pairs stored for this material  
 
                          for (size_t ii = 1;
                               ii < theRefractionIndexVector->GetVectorLength();
                               ++ii)
              {
                                 currentRI = (*theRefractionIndexVector)[ii];
                                 currentPM = theRefractionIndexVector->Energy(ii);
 
                 currentCAI = 0.5*(1.0/(prevRI*prevRI) +
                               1.0/(currentRI*currentRI));
 
                 currentCAI = prevCAI + 
                          (currentPM - prevPM) * currentCAI;
 
                 aPhysicsOrderedFreeVector->
                     InsertValues(currentPM, currentCAI);
 
                 prevPM  = currentPM;
                 prevCAI = currentCAI;
                 prevRI  = currentRI;
              }
 
               }
            }
         }
 
     // The Cerenkov integral for a given material
     // will be inserted in thePhysicsTable
     // according to the position of the material in
     // the material table. 
 
     thePhysicsTable->insertAt(i,aPhysicsOrderedFreeVector); 
 
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DumpPhysicsTable()

void G4Cerenkov::DumpPhysicsTable ( ) const

inline

Definition at line 245 of file G4Cerenkov.hh.

 {
         G4int PhysicsTableSize = thePhysicsTable->entries();
         G4PhysicsOrderedFreeVector *v;
 
         for (G4int i = 0 ; i < PhysicsTableSize ; i++ )
         {
             v = (G4PhysicsOrderedFreeVector*)(*thePhysicsTable)[i];
             v->DumpValues();
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAverageNumberOfPhotons()

G4double G4Cerenkov::GetAverageNumberOfPhotons	(	const G4double	charge,
		const G4double	beta,
		const G4Material *	aMaterial,
		G4MaterialPropertyVector *	Rindex
	)		const

private

Definition at line 615 of file G4Cerenkov.cc.

 {
     const G4double Rfact = 369.81/(eV * cm);
 
         if(beta <= 0.0)return 0.0;
 
         G4double BetaInverse = 1./beta;
 
     // Vectors used in computation of Cerenkov Angle Integral:
     //  - Refraction Indices for the current material
     //  - new G4PhysicsOrderedFreeVector allocated to hold CAI's
  
     G4int materialIndex = aMaterial->GetIndex();
 
     // Retrieve the Cerenkov Angle Integrals for this material  
 
     G4PhysicsOrderedFreeVector* CerenkovAngleIntegrals =
     (G4PhysicsOrderedFreeVector*)((*thePhysicsTable)(materialIndex));
 
         if(!(CerenkovAngleIntegrals->IsFilledVectorExist()))return 0.0;
 
     // Min and Max photon energies 
     G4double Pmin = Rindex->GetMinLowEdgeEnergy();
     G4double Pmax = Rindex->GetMaxLowEdgeEnergy();
 
     // Min and Max Refraction Indices 
     G4double nMin = Rindex->GetMinValue();  
     G4double nMax = Rindex->GetMaxValue();
 
     // Max Cerenkov Angle Integral 
     G4double CAImax = CerenkovAngleIntegrals->GetMaxValue();
 
     G4double dp, ge;
 
     // If n(Pmax) < 1/Beta -- no photons generated 
 
     if (nMax < BetaInverse) {
         dp = 0;
         ge = 0;
     } 
 
     // otherwise if n(Pmin) >= 1/Beta -- photons generated  
 
     else if (nMin > BetaInverse) {
         dp = Pmax - Pmin;   
         ge = CAImax; 
     } 
 
     // If n(Pmin) < 1/Beta, and n(Pmax) >= 1/Beta, then
     // we need to find a P such that the value of n(P) == 1/Beta.
     // Interpolation is performed by the GetEnergy() and
     // Value() methods of the G4MaterialPropertiesTable and
     // the GetValue() method of G4PhysicsVector.  
 
     else {
         Pmin = Rindex->GetEnergy(BetaInverse);
         dp = Pmax - Pmin;
 
         // need boolean for current implementation of G4PhysicsVector
         // ==> being phased out
         G4bool isOutRange;
         G4double CAImin = CerenkovAngleIntegrals->
                                   GetValue(Pmin, isOutRange);
         ge = CAImax - CAImin;
 
         if (verboseLevel>0) {
             G4cout << "CAImin = " << CAImin << G4endl;
             G4cout << "ge = " << ge << G4endl;
         }
     }
     
     // Calculate number of photons 
     G4double NumPhotons = Rfact * charge/eplus * charge/eplus *
                                  (dp - ge * BetaInverse*BetaInverse);
 
     return NumPhotons;      
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMaxBetaChangePerStep()

G4double G4Cerenkov::GetMaxBetaChangePerStep ( ) const

inline

Definition at line 233 of file G4Cerenkov.hh.

 {
         return fMaxBetaChange;
 }

Here is the caller graph for this function:

◆ GetMaxNumPhotonsPerStep()

G4int G4Cerenkov::GetMaxNumPhotonsPerStep ( ) const

inline

Definition at line 239 of file G4Cerenkov.hh.

 {
         return fMaxPhotons;
 }

Here is the caller graph for this function:

◆ GetMeanFreePath()

G4double G4Cerenkov::GetMeanFreePath	(	const G4Track &	aTrack,
		G4double	,
		G4ForceCondition *
	)

Definition at line 492 of file G4Cerenkov.cc.

 {
         return 1.;
 }

◆ GetPhysicsTable()

G4PhysicsTable * G4Cerenkov::GetPhysicsTable ( ) const

inline

Definition at line 258 of file G4Cerenkov.hh.

 {
   return thePhysicsTable;
 }

Here is the caller graph for this function:

◆ GetTrackSecondariesFirst()

G4bool G4Cerenkov::GetTrackSecondariesFirst ( ) const

inline

Definition at line 227 of file G4Cerenkov.hh.

 {
         return fTrackSecondariesFirst;
 }

Here is the caller graph for this function:

◆ IsApplicable()

G4bool G4Cerenkov::IsApplicable ( const G4ParticleDefinition & aParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 135 of file G4Cerenkov.cc.

 {
     G4bool result = false;
     if (aParticleType.GetPDGCharge() != 0.0 && 
     aParticleType.GetPDGMass() != 0.0 &&
     aParticleType.GetParticleName() != "chargedgeantino" &&
     !aParticleType.IsShortLived() ) { result = true; }
 
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

G4Cerenkov& G4Cerenkov::operator= ( const G4Cerenkov & right )

private

◆ PostStepDoIt()

G4VParticleChange * G4Cerenkov::PostStepDoIt	(	const G4Track &	aTrack,
		const G4Step &	aStep
	)

virtual

Implements G4VProcess.

Definition at line 170 of file G4Cerenkov.cc.

 {
     // Should we ensure that the material is dispersive?
 
         aParticleChange.Initialize(aTrack);
 
         const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
         const G4Material* aMaterial = aTrack.GetMaterial();
 
     G4StepPoint* pPreStepPoint  = aStep.GetPreStepPoint();
     G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();
 
     G4ThreeVector x0 = pPreStepPoint->GetPosition();
         G4ThreeVector p0 = aStep.GetDeltaPosition().unit();
     G4double t0 = pPreStepPoint->GetGlobalTime();
 
         G4MaterialPropertiesTable* aMaterialPropertiesTable =
                                aMaterial->GetMaterialPropertiesTable();
         if (!aMaterialPropertiesTable) return pParticleChange;
 
     G4MaterialPropertyVector* Rindex = 
                 aMaterialPropertiesTable->GetProperty("RINDEX"); 
         if (!Rindex) return pParticleChange;
 
         // particle charge
         G4double charge = aParticle->GetDefinition()->GetPDGCharge();
 
         // particle beta
         G4double beta = (pPreStepPoint ->GetBeta() +
              pPostStepPoint->GetBeta())*0.5;
 
     G4double MeanNumberOfPhotons = 
                  GetAverageNumberOfPhotons(charge,beta,aMaterial,Rindex);
 
         if (MeanNumberOfPhotons <= 0.0) {
 
                 // return unchanged particle and no secondaries
 
                 aParticleChange.SetNumberOfSecondaries(0);
  
                 return pParticleChange;
 
         }
 
         G4double step_length;
         step_length = aStep.GetStepLength();
 
     MeanNumberOfPhotons = MeanNumberOfPhotons * step_length;
 
     G4int NumPhotons = (G4int) G4Poisson(MeanNumberOfPhotons);
 
     if (NumPhotons <= 0) {
 
         // return unchanged particle and no secondaries  
 
         aParticleChange.SetNumberOfSecondaries(0);
         
                 return pParticleChange;
     }
 
 
     aParticleChange.SetNumberOfSecondaries(NumPhotons);
 
         if (fTrackSecondariesFirst) {
            if (aTrack.GetTrackStatus() == fAlive )
                    aParticleChange.ProposeTrackStatus(fSuspend);
         }
     
 
     G4double Pmin = Rindex->GetMinLowEdgeEnergy();
     G4double Pmax = Rindex->GetMaxLowEdgeEnergy();
     G4double dp = Pmax - Pmin;
 
     G4double nMax = Rindex->GetMaxValue();
 
         G4double BetaInverse = 1./beta;
 
     G4double maxCos = BetaInverse / nMax; 
     G4double maxSin2 = (1.0 - maxCos) * (1.0 + maxCos);
 
         G4double beta1 = pPreStepPoint ->GetBeta();
         G4double beta2 = pPostStepPoint->GetBeta();
 
         G4double MeanNumberOfPhotons1 =
                      GetAverageNumberOfPhotons(charge,beta1,aMaterial,Rindex);
         G4double MeanNumberOfPhotons2 =
                      GetAverageNumberOfPhotons(charge,beta2,aMaterial,Rindex);
     
     for (G4int i = 0; i < NumPhotons; i++) {
 
         // Determine photon energy
 
         G4double rand;
         G4double sampledEnergy, sampledRI; 
         G4double cosTheta, sin2Theta;
         
         // sample an energy
 
         do {
             rand = G4UniformRand(); 
             sampledEnergy = Pmin + rand * dp; 
             sampledRI = Rindex->Value(sampledEnergy);
             cosTheta = BetaInverse / sampledRI;  
 
             sin2Theta = (1.0 - cosTheta)*(1.0 + cosTheta);
             rand = G4UniformRand(); 
 
           // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
         } while (rand*maxSin2 > sin2Theta);
 
         // Generate random position of photon on cone surface 
         // defined by Theta 
 
         rand = G4UniformRand();
 
         G4double phi = twopi*rand;
         G4double sinPhi = std::sin(phi);
         G4double cosPhi = std::cos(phi);
 
         // calculate x,y, and z components of photon energy
         // (in coord system with primary particle direction 
         //  aligned with the z axis)
 
         G4double sinTheta = std::sqrt(sin2Theta); 
         G4double px = sinTheta*cosPhi;
         G4double py = sinTheta*sinPhi;
         G4double pz = cosTheta;
 
         // Create photon momentum direction vector 
         // The momentum direction is still with respect
         // to the coordinate system where the primary
         // particle direction is aligned with the z axis  
 
         G4ParticleMomentum photonMomentum(px, py, pz);
 
         // Rotate momentum direction back to global reference
         // system 
 
                 photonMomentum.rotateUz(p0);
 
         // Determine polarization of new photon 
 
         G4double sx = cosTheta*cosPhi;
         G4double sy = cosTheta*sinPhi; 
         G4double sz = -sinTheta;
 
         G4ThreeVector photonPolarization(sx, sy, sz);
 
         // Rotate back to original coord system 
 
                 photonPolarization.rotateUz(p0);
         
                 // Generate a new photon:
 
                 G4DynamicParticle* aCerenkovPhoton =
                   new G4DynamicParticle(G4OpticalPhoton::OpticalPhoton(), 
                                      photonMomentum);
         aCerenkovPhoton->SetPolarization
                      (photonPolarization.x(),
                       photonPolarization.y(),
                       photonPolarization.z());
 
         aCerenkovPhoton->SetKineticEnergy(sampledEnergy);
 
                 // Generate new G4Track object:
 
                 G4double NumberOfPhotons, N;
 
                 do {
                    rand = G4UniformRand();
                    NumberOfPhotons = MeanNumberOfPhotons1 - rand *
                                 (MeanNumberOfPhotons1-MeanNumberOfPhotons2);
                    N = G4UniformRand() *
                        std::max(MeanNumberOfPhotons1,MeanNumberOfPhotons2);
           // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
                 } while (N > NumberOfPhotons);
 
                 G4double delta = rand * aStep.GetStepLength();
 
                 G4double deltaTime = delta / (pPreStepPoint->GetVelocity()+
                                       rand*(pPostStepPoint->GetVelocity()-
                                             pPreStepPoint->GetVelocity())*0.5);
 
                 G4double aSecondaryTime = t0 + deltaTime;
 
                 G4ThreeVector aSecondaryPosition =
                                     x0 + rand * aStep.GetDeltaPosition();
 
         G4Track* aSecondaryTrack = 
         new G4Track(aCerenkovPhoton,aSecondaryTime,aSecondaryPosition);
 
                 aSecondaryTrack->SetTouchableHandle(
                                  aStep.GetPreStepPoint()->GetTouchableHandle());
 
                 aSecondaryTrack->SetParentID(aTrack.GetTrackID());
 
         aParticleChange.AddSecondary(aSecondaryTrack);
     }
 
     if (verboseLevel>0) {
        G4cout <<"\n Exiting from G4Cerenkov::DoIt -- NumberOfSecondaries = "
               << aParticleChange.GetNumberOfSecondaries() << G4endl;
     }
 
         return pParticleChange;
 }

Here is the call graph for this function:

◆ PostStepGetPhysicalInteractionLength()

G4double G4Cerenkov::PostStepGetPhysicalInteractionLength	(	const G4Track &	aTrack,
		G4double	,
		G4ForceCondition *	condition
	)

virtual

Implements G4VProcess.

Definition at line 499 of file G4Cerenkov.cc.

 {
         *condition = NotForced;
         G4double StepLimit = DBL_MAX;
 
         const G4Material* aMaterial = aTrack.GetMaterial();
     G4int materialIndex = aMaterial->GetIndex();
 
     // If Physics Vector is not defined no Cerenkov photons
     //    this check avoid string comparison below
     if(!(*thePhysicsTable)[materialIndex]) { return StepLimit; }
 
         const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
         const G4MaterialCutsCouple* couple = aTrack.GetMaterialCutsCouple();
 
         G4double kineticEnergy = aParticle->GetKineticEnergy();
         const G4ParticleDefinition* particleType = aParticle->GetDefinition();
         G4double mass = particleType->GetPDGMass();
 
         // particle beta
         G4double beta = aParticle->GetTotalMomentum() /
                     aParticle->GetTotalEnergy();
         // particle gamma
         G4double gamma = aParticle->GetTotalEnergy()/mass;
 
         G4MaterialPropertiesTable* aMaterialPropertiesTable =
                             aMaterial->GetMaterialPropertiesTable();
 
         G4MaterialPropertyVector* Rindex = NULL;
 
         if (aMaterialPropertiesTable)
                      Rindex = aMaterialPropertiesTable->GetProperty("RINDEX");
 
         G4double nMax;
         if (Rindex) {
            nMax = Rindex->GetMaxValue();
         } else {
            return StepLimit;
         }
 
         G4double BetaMin = 1./nMax;
         if ( BetaMin >= 1. ) return StepLimit;
 
         G4double GammaMin = 1./std::sqrt(1.-BetaMin*BetaMin);
 
         if (gamma < GammaMin ) return StepLimit;
 
         G4double kinEmin = mass*(GammaMin-1.);
 
         G4double RangeMin = G4LossTableManager::Instance()->
                                                    GetRange(particleType,
                                                             kinEmin,
                                                             couple);
         G4double Range    = G4LossTableManager::Instance()->
                                                    GetRange(particleType,
                                                             kineticEnergy,
                                                             couple);
 
         G4double Step = Range - RangeMin;
         if (Step < 1.*um ) return StepLimit;
 
         if (Step > 0. && Step < StepLimit) StepLimit = Step; 
 
         // If user has defined an average maximum number of photons to
         // be generated in a Step, then calculate the Step length for
         // that number of photons. 
  
         if (fMaxPhotons > 0) {
 
            // particle charge
            const G4double charge = aParticle->
                                    GetDefinition()->GetPDGCharge();
 
        G4double MeanNumberOfPhotons = 
                     GetAverageNumberOfPhotons(charge,beta,aMaterial,Rindex);
 
            Step = 0.;
            if (MeanNumberOfPhotons > 0.0) Step = fMaxPhotons /
                                                  MeanNumberOfPhotons;
 
            if (Step > 0. && Step < StepLimit) StepLimit = Step;
         }
 
         // If user has defined an maximum allowed change in beta per step
         if (fMaxBetaChange > 0.) {
 
            G4double dedx = G4LossTableManager::Instance()->
                                                    GetDEDX(particleType,
                                                            kineticEnergy,
                                                            couple);
 
            G4double deltaGamma = gamma - 
                                  1./std::sqrt(1.-beta*beta*
                                                  (1.-fMaxBetaChange)*
                                                  (1.-fMaxBetaChange));
 
            Step = mass * deltaGamma / dedx;
 
            if (Step > 0. && Step < StepLimit) StepLimit = Step;
 
         }
 
         *condition = StronglyForced;
         return StepLimit;
 }

Here is the call graph for this function:

◆ SetMaxBetaChangePerStep()

void G4Cerenkov::SetMaxBetaChangePerStep ( const G4double d )

Definition at line 151 of file G4Cerenkov.cc.

 {
         fMaxBetaChange = value*CLHEP::perCent;
 }

Here is the caller graph for this function:

◆ SetMaxNumPhotonsPerStep()

void G4Cerenkov::SetMaxNumPhotonsPerStep ( const G4int NumPhotons )

Definition at line 156 of file G4Cerenkov.cc.

 {
         fMaxPhotons = NumPhotons;
 }

Here is the caller graph for this function:

◆ SetTrackSecondariesFirst()

void G4Cerenkov::SetTrackSecondariesFirst ( const G4bool state )

Definition at line 146 of file G4Cerenkov.cc.

 {
         fTrackSecondariesFirst = state;
 }

Here is the caller graph for this function:

Member Data Documentation

◆ fMaxBetaChange

G4double G4Cerenkov::fMaxBetaChange

private

Definition at line 218 of file G4Cerenkov.hh.

◆ fMaxPhotons

G4int G4Cerenkov::fMaxPhotons

private

Definition at line 219 of file G4Cerenkov.hh.

◆ fTrackSecondariesFirst

G4bool G4Cerenkov::fTrackSecondariesFirst

private

Definition at line 217 of file G4Cerenkov.hh.

◆ thePhysicsTable

G4PhysicsTable* G4Cerenkov::thePhysicsTable

protected

Definition at line 210 of file G4Cerenkov.hh.

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

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Cerenkov() [1/2]

◆ ~G4Cerenkov()

◆ G4Cerenkov() [2/2]

Member Function Documentation

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ BuildPhysicsTable()

◆ BuildThePhysicsTable()

◆ DumpPhysicsTable()

◆ GetAverageNumberOfPhotons()

◆ GetMaxBetaChangePerStep()

◆ GetMaxNumPhotonsPerStep()

◆ GetMeanFreePath()

◆ GetPhysicsTable()

◆ GetTrackSecondariesFirst()

◆ IsApplicable()

◆ operator=()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ SetMaxBetaChangePerStep()

◆ SetMaxNumPhotonsPerStep()

◆ SetTrackSecondariesFirst()

Member Data Documentation

◆ fMaxBetaChange

◆ fMaxPhotons

◆ fTrackSecondariesFirst

◆ thePhysicsTable