#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) override

void	BuildPhysicsTable (const G4ParticleDefinition &aParticleType) override

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

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

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

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *) override

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

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

void	SetTrackSecondariesFirst (const G4bool state)

G4bool	GetTrackSecondariesFirst () const

void	SetMaxBetaChangePerStep (const G4double d)

G4double	GetMaxBetaChangePerStep () const

void	SetMaxNumPhotonsPerStep (const G4int NumPhotons)

G4int	GetMaxNumPhotonsPerStep () const

void	SetStackPhotons (const G4bool)

G4bool	GetStackPhotons () const

G4int	GetNumPhotons () 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

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::G4Cerenkov	(	const G4String &	processName = `"Cerenkov"`,
		G4ProcessType	type = `fElectromagnetic`
	)

explicit

Definition at line 96 of file G4Cerenkov.cc.

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

Here is the call graph for this function:

G4Cerenkov::~G4Cerenkov ( )

Definition at line 121 of file G4Cerenkov.cc.

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

Here is the call graph for this function:

G4Cerenkov::G4Cerenkov ( const G4Cerenkov & right )

explicit

Member Function Documentation

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 148 of file G4Cerenkov.hh.

149 {return nullptr;};

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 133 of file G4Cerenkov.hh.

138 { return -1.0; };

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 145 of file G4Cerenkov.hh.

146 {return nullptr;};

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 140 of file G4Cerenkov.hh.

142 { return -1.0; };

void G4Cerenkov::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 160 of file G4Cerenkov.cc.

 {
   if (!thePhysicsTable) BuildThePhysicsTable();
 }

void G4Cerenkov::DumpPhysicsTable ( ) const

inline

Definition at line 269 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:

G4double G4Cerenkov::GetMaxBetaChangePerStep ( ) const

inline

Definition at line 239 of file G4Cerenkov.hh.

 {
   return fMaxBetaChange;
 }

G4int G4Cerenkov::GetMaxNumPhotonsPerStep ( ) const

inline

Definition at line 245 of file G4Cerenkov.hh.

 {
   return fMaxPhotons;
 }

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

Definition at line 485 of file G4Cerenkov.cc.

 {
   return 1.;
 }

G4int G4Cerenkov::GetNumPhotons ( ) const

inline

Definition at line 263 of file G4Cerenkov.hh.

 {
         return fNumPhotons;
 }

G4PhysicsTable * G4Cerenkov::GetPhysicsTable ( ) const

inline

Definition at line 281 of file G4Cerenkov.hh.

 {
   return thePhysicsTable;
 }

G4bool G4Cerenkov::GetStackPhotons ( ) const

inline

Definition at line 257 of file G4Cerenkov.hh.

 {
         return fStackingFlag;
 }

G4bool G4Cerenkov::GetTrackSecondariesFirst ( ) const

inline

Definition at line 233 of file G4Cerenkov.hh.

 {
   return fTrackSecondariesFirst;
 }

G4bool G4Cerenkov::IsApplicable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 133 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:

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

overridevirtual

Implements G4VProcess.

Definition at line 169 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;
 
   fNumPhotons = 0;
 
   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 = aStep.GetStepLength();
 
   MeanNumberOfPhotons = MeanNumberOfPhotons * step_length;
 
   fNumPhotons = (G4int) G4Poisson(MeanNumberOfPhotons);
 
   if ( fNumPhotons <= 0 || !fStackingFlag ) {
 
      // return unchanged particle and no secondaries  
 
      aParticleChange.SetNumberOfSecondaries(0);
 
      return pParticleChange;
 
   }
 
 
   aParticleChange.SetNumberOfSecondaries(fNumPhotons);
 
   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 < fNumPhotons; 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:

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

overridevirtual

Implements G4VProcess.

Definition at line 492 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:

void G4Cerenkov::SetMaxBetaChangePerStep ( const G4double d )

Definition at line 150 of file G4Cerenkov.cc.

 {
   fMaxBetaChange = value*CLHEP::perCent;
 }

Here is the caller graph for this function:

void G4Cerenkov::SetMaxNumPhotonsPerStep ( const G4int NumPhotons )

Definition at line 155 of file G4Cerenkov.cc.

 {
   fMaxPhotons = NumPhotons;
 }

Here is the caller graph for this function:

void G4Cerenkov::SetStackPhotons ( const G4bool stackingFlag )

inline

Definition at line 251 of file G4Cerenkov.hh.

 {
         fStackingFlag = stackingFlag;
 }

Here is the caller graph for this function:

void G4Cerenkov::SetTrackSecondariesFirst ( const G4bool state )

Definition at line 145 of file G4Cerenkov.cc.

 {
   fTrackSecondariesFirst = state;
 }

Here is the caller graph for this function:

Member Data Documentation

G4PhysicsTable* G4Cerenkov::thePhysicsTable

protected

Definition at line 212 of file G4Cerenkov.hh.

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

geant4.10.03.p01/source/processes/electromagnetic/xrays/include/G4Cerenkov.hh
geant4.10.03.p01/source/processes/electromagnetic/xrays/src/G4Cerenkov.cc

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation