#include <G4Cerenkov.hh>

Inheritance 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

void	PreparePhysicsTable (const G4ParticleDefinition &part) override

void	Initialise ()

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

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

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4VProcess &	operator= (const G4VProcess &)=delete

G4bool	operator== (const G4VProcess &right) const

G4bool	operator!= (const G4VProcess &right) const

virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0

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 G4bool	IsApplicable (const G4ParticleDefinition &)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

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

virtual void	ProcessDescription (std::ostream &outfile) 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 = nullptr

G4VParticleChange *	pParticleChange = nullptr

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft = -1.0

G4double	currentInteractionLength = -1.0

G4double	theInitialNumberOfInteractionLength = -1.0

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType = fNotDefined

G4int	theProcessSubType = -1

G4double	thePILfactor = 1.0

G4int	verboseLevel = 0

G4bool	enableAtRestDoIt = true

G4bool	enableAlongStepDoIt = true

G4bool	enablePostStepDoIt = true

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

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

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 66 of file G4Cerenkov.hh.

Constructor & Destructor Documentation

◆ G4Cerenkov() [1/2]

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

explicit

Definition at line 76 of file G4Cerenkov.cc.

  : G4VProcess(processName, type)
  , fNumPhotons(0)
{
  SetProcessSubType(fCerenkov);
 
  thePhysicsTable = nullptr;
 
  if(verboseLevel > 0)
  {
    G4cout << GetProcessName() << " is created." << G4endl;
  }
  Initialise();
}

◆ ~G4Cerenkov()

G4Cerenkov::~G4Cerenkov ( )

Definition at line 92 of file G4Cerenkov.cc.

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

◆ G4Cerenkov() [2/2]

G4Cerenkov::G4Cerenkov ( const G4Cerenkov & right )

explicit

Member Function Documentation

◆ AlongStepDoIt()

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 121 of file G4Cerenkov.hh.

  {
    return nullptr;
  };

◆ AlongStepGetPhysicalInteractionLength()

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 103 of file G4Cerenkov.hh.

  {
    return -1.0;
  };

◆ AtRestDoIt()

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 116 of file G4Cerenkov.hh.

  {
    return nullptr;
  };

◆ AtRestGetPhysicalInteractionLength()

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 109 of file G4Cerenkov.hh.

  {
    return -1.0;
  };

◆ BuildPhysicsTable()

void G4Cerenkov::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 124 of file G4Cerenkov.cc.

{
  if(thePhysicsTable)
    return;
 
  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  G4int numOfMaterials                    = G4Material::GetNumberOfMaterials();
 
  thePhysicsTable = new G4PhysicsTable(numOfMaterials);
 
  // loop over 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(kRINDEX);
 
      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 = prevCAI + (currentPM - prevPM) * 0.5 *
                                     (1.0 / (prevRI * prevRI) +
                                      1.0 / (currentRI * currentRI));
 
            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);
  }
}

◆ DumpPhysicsTable()

void G4Cerenkov::DumpPhysicsTable ( ) const

Definition at line 584 of file G4Cerenkov.cc.

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

◆ GetAverageNumberOfPhotons()

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

Definition at line 492 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.0;
    ge = 0.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 Value() method of G4PhysicsVector.
  else
  {
    Pmin = Rindex->GetEnergy(BetaInverse);
    dp   = Pmax - Pmin;
 
    G4double CAImin = CerenkovAngleIntegrals->Value(Pmin);
    ge              = CAImax - CAImin;
 
    if(verboseLevel > 1)
    {
      G4cout << "CAImin = " << CAImin << G4endl << "ge = " << ge << G4endl;
    }
  }
 
  // Calculate number of photons
  G4double NumPhotons = Rfact * charge / eplus * charge / eplus *
                        (dp - ge * BetaInverse * BetaInverse);
 
  return NumPhotons;
}

Referenced by PostStepDoIt(), and PostStepGetPhysicalInteractionLength().

◆ GetMaxBetaChangePerStep()

G4double G4Cerenkov::GetMaxBetaChangePerStep ( ) const

inline

Definition at line 189 of file G4Cerenkov.hh.

{
  return fMaxBetaChange;
}

◆ GetMaxNumPhotonsPerStep()

G4int G4Cerenkov::GetMaxNumPhotonsPerStep ( ) const

inline

Definition at line 194 of file G4Cerenkov.hh.

194{ return fMaxPhotons; }

◆ GetMeanFreePath()

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

Definition at line 384 of file G4Cerenkov.cc.

{
  return 1.;
}

◆ GetNumPhotons()

G4int G4Cerenkov::GetNumPhotons ( ) const

inline

Definition at line 203 of file G4Cerenkov.hh.

203{ return fNumPhotons; }

◆ GetPhysicsTable()

G4PhysicsTable * G4Cerenkov::GetPhysicsTable ( ) const

inline

Definition at line 205 of file G4Cerenkov.hh.

{
  return thePhysicsTable;
}

◆ GetStackPhotons()

G4bool G4Cerenkov::GetStackPhotons ( ) const

inline

Definition at line 201 of file G4Cerenkov.hh.

201{ return fStackingFlag; }

◆ GetTrackSecondariesFirst()

G4bool G4Cerenkov::GetTrackSecondariesFirst ( ) const

inline

Definition at line 184 of file G4Cerenkov.hh.

{
  return fTrackSecondariesFirst;
}

◆ Initialise()

void G4Cerenkov::Initialise ( )

Definition at line 113 of file G4Cerenkov.cc.

{
  G4OpticalParameters* params = G4OpticalParameters::Instance();
  SetMaxBetaChangePerStep(params->GetCerenkovMaxBetaChange());
  SetMaxNumPhotonsPerStep(params->GetCerenkovMaxPhotonsPerStep());
  SetTrackSecondariesFirst(params->GetCerenkovTrackSecondariesFirst());
  SetStackPhotons(params->GetCerenkovStackPhotons());
  SetVerboseLevel(params->GetCerenkovVerboseLevel());
}

Referenced by G4Cerenkov(), and PreparePhysicsTable().

◆ IsApplicable()

G4bool G4Cerenkov::IsApplicable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 102 of file G4Cerenkov.cc.

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

Referenced by G4OpticalPhysics::ConstructProcess().

◆ PostStepDoIt()

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

overridevirtual

Implements G4VProcess.

Definition at line 199 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* MPT = aMaterial->GetMaterialPropertiesTable();
  if(!MPT)
    return pParticleChange;
 
  G4MaterialPropertyVector* Rindex = MPT->GetProperty(kRINDEX);
  if(!Rindex)
    return pParticleChange;
 
  G4double charge = aParticle->GetDefinition()->GetPDGCharge();
  G4double beta = (pPreStepPoint->GetBeta() + pPostStepPoint->GetBeta()) * 0.5;
 
  // fNumPhotons = 0;  // in PostStepGetPhysicalInteractionLength()
 
  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);
 
    // 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
    rand              = G4UniformRand();
    G4double phi      = twopi * rand;
    G4double sinPhi   = std::sin(phi);
    G4double cosPhi   = std::cos(phi);
    G4double sinTheta = std::sqrt(sin2Theta);
    G4ParticleMomentum photonMomentum(sinTheta * cosPhi, sinTheta * sinPhi,
                                      cosTheta);
 
    // Rotate momentum direction back to global reference system
    photonMomentum.rotateUz(p0);
 
    // Determine polarization of new photon
    G4ThreeVector photonPolarization(cosTheta * cosPhi, cosTheta * sinPhi,
                                     -sinTheta);
 
    // Rotate back to original coord system
    photonPolarization.rotateUz(p0);
 
    // Generate a new photon:
    G4DynamicParticle* aCerenkovPhoton =
      new G4DynamicParticle(G4OpticalPhoton::OpticalPhoton(), photonMomentum);
 
    aCerenkovPhoton->SetPolarization(photonPolarization);
    aCerenkovPhoton->SetKineticEnergy(sampledEnergy);
 
    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();
 
    // Generate new G4Track object:
    G4Track* aSecondaryTrack =
      new G4Track(aCerenkovPhoton, aSecondaryTime, aSecondaryPosition);
 
    aSecondaryTrack->SetTouchableHandle(
      aStep.GetPreStepPoint()->GetTouchableHandle());
    aSecondaryTrack->SetParentID(aTrack.GetTrackID());
    aParticleChange.AddSecondary(aSecondaryTrack);
  }
 
  if(verboseLevel > 1)
  {
    G4cout << "\n Exiting from G4Cerenkov::DoIt -- NumberOfSecondaries = "
           << aParticleChange.GetNumberOfSecondaries() << G4endl;
  }
 
  return pParticleChange;
}

◆ PostStepGetPhysicalInteractionLength()

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

overridevirtual

Implements G4VProcess.

Definition at line 391 of file G4Cerenkov.cc.

{
  *condition         = NotForced;
  G4double StepLimit = DBL_MAX;
  fNumPhotons        = 0;
 
  const G4Material* aMaterial = aTrack.GetMaterial();
  G4int materialIndex         = aMaterial->GetIndex();
 
  // If Physics Vector is not defined no Cerenkov photons
  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();
 
  G4double beta  = aParticle->GetTotalMomentum() / aParticle->GetTotalEnergy();
  G4double gamma = aParticle->GetTotalEnergy() / mass;
 
  G4MaterialPropertiesTable* aMaterialPropertiesTable =
    aMaterial->GetMaterialPropertiesTable();
 
  G4MaterialPropertyVector* Rindex = nullptr;
 
  if(aMaterialPropertiesTable)
    Rindex = aMaterialPropertiesTable->GetProperty(kRINDEX);
 
  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 the step is smaller than 1e-16 mm, it may happen that the particle
  // does not move. See bug 1992.
  //  2019-03-11: change to 1e-15
  if(Step < 1.e-15 * mm)
    return StepLimit;
 
  if(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)
  {
    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;
}

◆ PreparePhysicsTable()

void G4Cerenkov::PreparePhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 378 of file G4Cerenkov.cc.

{
  Initialise();
}

◆ SetMaxBetaChangePerStep()

void G4Cerenkov::SetMaxBetaChangePerStep ( const G4double d )

Definition at line 572 of file G4Cerenkov.cc.

{
  fMaxBetaChange = value * CLHEP::perCent;
}

Referenced by Initialise().

◆ SetMaxNumPhotonsPerStep()

void G4Cerenkov::SetMaxNumPhotonsPerStep ( const G4int NumPhotons )

Definition at line 578 of file G4Cerenkov.cc.

{
  fMaxPhotons = NumPhotons;
}

Referenced by Initialise().

◆ SetStackPhotons()

void G4Cerenkov::SetStackPhotons ( const G4bool stackingFlag )

inline

Definition at line 196 of file G4Cerenkov.hh.

{
  fStackingFlag = stackingFlag;
}

Referenced by Initialise().

◆ SetTrackSecondariesFirst()

void G4Cerenkov::SetTrackSecondariesFirst ( const G4bool state )

Definition at line 566 of file G4Cerenkov.cc.

{
  fTrackSecondariesFirst = state;
}

Referenced by Initialise().

Member Data Documentation

◆ thePhysicsTable

G4PhysicsTable* G4Cerenkov::thePhysicsTable

protected

Definition at line 172 of file G4Cerenkov.hh.

Referenced by BuildPhysicsTable(), DumpPhysicsTable(), G4Cerenkov(), GetPhysicsTable(), PostStepGetPhysicalInteractionLength(), and ~G4Cerenkov().

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

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Cerenkov() [1/2]

◆ ~G4Cerenkov()

◆ G4Cerenkov() [2/2]

Member Function Documentation

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ BuildPhysicsTable()

◆ DumpPhysicsTable()

◆ GetAverageNumberOfPhotons()

◆ GetMaxBetaChangePerStep()

◆ GetMaxNumPhotonsPerStep()

◆ GetMeanFreePath()

◆ GetNumPhotons()

◆ GetPhysicsTable()

◆ GetStackPhotons()

◆ GetTrackSecondariesFirst()

◆ Initialise()

◆ IsApplicable()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PreparePhysicsTable()

◆ SetMaxBetaChangePerStep()

◆ SetMaxNumPhotonsPerStep()

◆ SetStackPhotons()

◆ SetTrackSecondariesFirst()

Member Data Documentation

◆ thePhysicsTable