G4QuasiCerenkov Class Reference

#include <G4QuasiCerenkov.hh>

Inheritance diagram for G4QuasiCerenkov:

Public Member Functions
	G4QuasiCerenkov (const G4String &processName="QuasiCerenkov", G4ProcessType type=fElectromagnetic)
	~G4QuasiCerenkov ()
	G4QuasiCerenkov (const G4QuasiCerenkov &right)
G4QuasiCerenkov &	operator= (const G4QuasiCerenkov &right)=delete
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
void	SetOffloadPhotons (const G4bool)
G4bool	GetOffloadPhotons () const
G4int	GetNumPhotons () const
G4PhysicsTable *	GetPhysicsTable () const
void	DumpPhysicsTable () const
G4double	GetAverageNumberOfPhotons (const G4double charge, const G4double beta, const G4Material *aMaterial, G4MaterialPropertyVector *Rindex) const
void	DumpInfo () const override
void	ProcessDescription (std::ostream &out) const override
void	SetVerboseLevel (G4int)
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
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	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 const G4VProcess *	GetCreatorProcess () const
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
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
std::map< std::size_t, std::size_t >	fIndexMPT
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 67 of file G4QuasiCerenkov.hh.

Constructor & Destructor Documentation

G4QuasiCerenkov() [1/2]

G4QuasiCerenkov::G4QuasiCerenkov ( const G4String & processName = "QuasiCerenkov", G4ProcessType type = fElectromagnetic )

explicit

Definition at line 49 of file G4QuasiCerenkov.cc.

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

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

~G4QuasiCerenkov()

G4QuasiCerenkov::~G4QuasiCerenkov

(

)

Definition at line 66 of file G4QuasiCerenkov.cc.

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

G4QuasiCerenkov() [2/2]

G4QuasiCerenkov::G4QuasiCerenkov ( const G4QuasiCerenkov & right )

explicit

Member Function Documentation

AlongStepDoIt()

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 120 of file G4QuasiCerenkov.hh.

  {
    return nullptr;
  };

AlongStepGetPhysicalInteractionLength()

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 102 of file G4QuasiCerenkov.hh.

  {
    return -1.0;
  };

AtRestDoIt()

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 115 of file G4QuasiCerenkov.hh.

  {
    return nullptr;
  };

AtRestGetPhysicalInteractionLength()

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

inlineoverridevirtual

Implements G4VProcess.

Definition at line 108 of file G4QuasiCerenkov.hh.

  {
    return -1.0;
  };

BuildPhysicsTable()

void G4QuasiCerenkov::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 115 of file G4QuasiCerenkov.cc.

{
  if(thePhysicsTable)
    return;
 
  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  std::size_t numOfMaterials              = G4Material::GetNumberOfMaterials();
 
  // Find the number of materials that have non-empty material property tables
  std::size_t numOfMaterialsWithMPT = 0;
  for(std::size_t i = 0; i < numOfMaterials; ++i)
  {
    if(((*theMaterialTable)[i])->GetMaterialPropertiesTable())
    {
       ++numOfMaterialsWithMPT;
    }
  }
 
  thePhysicsTable = new G4PhysicsTable(numOfMaterialsWithMPT);
 
  // loop over materials
  std::size_t indexMPT = 0;
  for(std::size_t i = 0; i < numOfMaterials; ++i)
  {
    G4PhysicsFreeVector* cerenkovIntegral = nullptr;
 
    // Retrieve vector of refraction indices for the material
    // from the material's optical properties table
    G4Material* aMaterial          = (*theMaterialTable)[i];
    G4MaterialPropertiesTable* MPT = aMaterial->GetMaterialPropertiesTable();
 
    if(MPT)
    {
      cerenkovIntegral                          = new G4PhysicsFreeVector();
      G4MaterialPropertyVector* refractiveIndex = MPT->GetProperty(kRINDEX);
 
      if(refractiveIndex)
      {
        // Retrieve the first refraction index in vector
        // of (photon energy, refraction index) pairs
        G4double currentRI = (*refractiveIndex)[0];
        if(currentRI > 1.0)
        {
          // Create first (photon energy, Cerenkov Integral) pair
          G4double currentPM  = refractiveIndex->Energy(0);
          G4double currentCAI = 0.0;
 
          cerenkovIntegral->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(std::size_t ii = 1; ii < refractiveIndex->GetVectorLength(); ++ii)
          {
            currentRI  = (*refractiveIndex)[ii];
            currentPM  = refractiveIndex->Energy(ii);
            currentCAI = prevCAI + (currentPM - prevPM) * 0.5 *
                                     (1.0 / (prevRI * prevRI) +
                                      1.0 / (currentRI * currentRI));
 
            cerenkovIntegral->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(indexMPT, cerenkovIntegral);
      fIndexMPT.insert(std::make_pair(i, indexMPT));
      ++indexMPT;
    }
  }
}

DumpInfo()

void G4QuasiCerenkov::DumpInfo ( ) const

inlineoverridevirtual

Reimplemented from G4VProcess.

Definition at line 176 of file G4QuasiCerenkov.hh.

{ProcessDescription(G4cout);};

DumpPhysicsTable()

void G4QuasiCerenkov::DumpPhysicsTable

(

)

const

Definition at line 639 of file G4QuasiCerenkov.cc.

{
  G4cout << "Dump Physics Table!" << G4endl;
  for(std::size_t i = 0; i < thePhysicsTable->entries(); ++i)
  {
    (*thePhysicsTable)[i]->DumpValues();
  }
}

GetAverageNumberOfPhotons()

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

Definition at line 516 of file G4QuasiCerenkov.cc.

{
  constexpr 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 G4PhysicsFreeVector allocated to hold CAI's
  std::size_t materialIndex = aMaterial->GetIndex();
 
  // Retrieve the Cerenkov Angle Integrals for this material
  auto it = fIndexMPT.find(materialIndex);
 
  std::size_t indexMPT = 0;
  if(it != fIndexMPT.end())
  {
    indexMPT = it->second;
  }
  else
  {
    G4ExceptionDescription ed;
    ed << "G4MaterialPropertiesTable for " << aMaterial->GetName()
       << " is not found!" << G4endl;
    G4Exception("G4QuasiCerenkov::GetAverageNumberOfPhotons",
        "QuasiCerenkovCerenkov01", FatalException, ed);
  }
 
  G4PhysicsVector* CerenkovAngleIntegrals = ((*thePhysicsTable)(indexMPT));
 
  std::size_t length = CerenkovAngleIntegrals->GetVectorLength();
  if(0 == length)
    return 0.0;
 
  // Min and Max photon energies
  G4double Pmin = Rindex->Energy(0);
  G4double Pmax = Rindex->GetMaxEnergy();
 
  // Min and Max Refraction Indices
  G4double nMin = Rindex->GetMinValue();
  G4double nMax = Rindex->GetMaxValue();
 
  // Max Cerenkov Angle Integral
  G4double CAImax = (*CerenkovAngleIntegrals)[length - 1];
 
  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 G4QuasiCerenkov::GetMaxBetaChangePerStep ( ) const

inline

Definition at line 205 of file G4QuasiCerenkov.hh.

{
  return fMaxBetaChange;
}

GetMaxNumPhotonsPerStep()

G4int G4QuasiCerenkov::GetMaxNumPhotonsPerStep ( ) const

inline

Definition at line 210 of file G4QuasiCerenkov.hh.

{ return fMaxPhotons; }

GetMeanFreePath()

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

Definition at line 404 of file G4QuasiCerenkov.cc.

{
  return 1.;
}

GetNumPhotons()

G4int G4QuasiCerenkov::GetNumPhotons ( ) const

inline

Definition at line 216 of file G4QuasiCerenkov.hh.

{ return fNumPhotons; }

GetOffloadPhotons()

G4bool G4QuasiCerenkov::GetOffloadPhotons ( ) const

inline

Definition at line 214 of file G4QuasiCerenkov.hh.

{ return fOffloadingFlag; }

GetPhysicsTable()

G4PhysicsTable * G4QuasiCerenkov::GetPhysicsTable ( ) const

inline

Definition at line 218 of file G4QuasiCerenkov.hh.

{
  return thePhysicsTable;
}

GetStackPhotons()

G4bool G4QuasiCerenkov::GetStackPhotons ( ) const

inline

Definition at line 212 of file G4QuasiCerenkov.hh.

{ return fStackingFlag; }

GetTrackSecondariesFirst()

G4bool G4QuasiCerenkov::GetTrackSecondariesFirst ( ) const

inline

Definition at line 200 of file G4QuasiCerenkov.hh.

{
  return fTrackSecondariesFirst;
}

Initialise()

void G4QuasiCerenkov::Initialise

(

)

Definition at line 103 of file G4QuasiCerenkov.cc.

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

Referenced by G4QuasiCerenkov(), and PreparePhysicsTable().

IsApplicable()

G4bool G4QuasiCerenkov::IsApplicable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 92 of file G4QuasiCerenkov.cc.

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

operator=()

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

delete

PostStepDoIt()

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

overridevirtual

Implements G4VProcess.

Definition at line 198 of file G4QuasiCerenkov.cc.

{
  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 beta1 = pPreStepPoint->GetBeta();
  G4double beta2 = pPostStepPoint->GetBeta();
  G4double beta = (beta1 + beta2) * 0.5;
 
  G4double MeanNumberOfPhotons =
    GetAverageNumberOfPhotons(charge, beta, aMaterial, Rindex);
  G4double MeanNumberOfPhotons1 =
    GetAverageNumberOfPhotons(charge, beta1, aMaterial, Rindex);
  G4double MeanNumberOfPhotons2 =
    GetAverageNumberOfPhotons(charge, beta2, aMaterial, Rindex);
 
  if(MeanNumberOfPhotons <= 0.0)
  {
    // return unchanged particle and no secondaries
    aParticleChange.SetNumberOfSecondaries(0);
    return pParticleChange;
  }
 
  MeanNumberOfPhotons *= aStep.GetStepLength();
  fNumPhotons         = (G4int) G4Poisson(MeanNumberOfPhotons);
 
  // third condition added to prevent infinite loop in do-while below,
  // see bugzilla 2555
  if(fNumPhotons <= 0 || !fStackingFlag ||
     std::max(MeanNumberOfPhotons1, MeanNumberOfPhotons2) < 1e-15)
  {
    // return unchanged particle and no secondaries
    aParticleChange.SetNumberOfSecondaries(0);
    return pParticleChange;
  }
 
  G4double deltaVelocity = pPostStepPoint->GetVelocity() -
    pPreStepPoint->GetVelocity();
  auto touchableHandle = aStep.GetPreStepPoint()->GetTouchableHandle();
 
  if(fOffloadingFlag)
  {
    // Create a G4DynamicParticle with G4QuasiOpticalPhoton
    auto quasiPhoton = new G4DynamicParticle(
      G4QuasiOpticalPhoton::QuasiOpticalPhotonDefinition(),
      aParticle->GetMomentum());
 
    // Create a new G4Track object with the quasi-optical photon
    G4Track* aSecondaryTrack = new G4Track(quasiPhoton, t0, x0);
    aSecondaryTrack->SetTouchableHandle(touchableHandle);
    aSecondaryTrack->SetParentID(aTrack.GetTrackID());
    aSecondaryTrack->SetCreatorModelID(secID);
 
    // Attach auxiliary track information with associated metadata
    G4QuasiOpticalData quasiTrackData{aMaterial->GetIndex(), fNumPhotons,
      charge, aStep.GetStepLength(), pPreStepPoint->GetVelocity(),
      deltaVelocity, aStep.GetDeltaPosition()};
    aSecondaryTrack->SetAuxiliaryTrackInformation(secID,
      new G4CerenkovQuasiTrackInfo(quasiTrackData,
        MeanNumberOfPhotons1, MeanNumberOfPhotons2));
    aParticleChange.AddSecondary(aSecondaryTrack);
 
    // Return early when offloading is enabled
    return pParticleChange;
  }
 
  ////////////////////////////////////////////////////////////////
  aParticleChange.SetNumberOfSecondaries(fNumPhotons);
 
  if(fTrackSecondariesFirst)
  {
    if(aTrack.GetTrackStatus() == fAlive)
      aParticleChange.ProposeTrackStatus(fSuspend);
  }
 
  ////////////////////////////////////////////////////////////////
  G4double Pmin = Rindex->Energy(0);
  G4double Pmax = Rindex->GetMaxEnergy();
  G4double dp   = Pmax - Pmin;
  G4double deltaNumberOfPhotons = MeanNumberOfPhotons1 - MeanNumberOfPhotons2;
  G4double maxNumberOfPhotons =
    std::max(MeanNumberOfPhotons1, MeanNumberOfPhotons2);
 
  G4double nMax        = Rindex->GetMaxValue();
  G4double BetaInverse = 1. / beta;
 
  G4double maxCos  = BetaInverse / nMax;
  G4double maxSin2 = 1.0 - maxCos * maxCos;
 
  for(G4int i = 0; i < fNumPhotons; ++i)
  {
    // Determine photon energy
    G4double rand;
    G4double sampledEnergy;
    G4double cosTheta, sin2Theta;
 
    // sample an energy
    do
    {
      rand          = G4UniformRand();
      sampledEnergy = Pmin + rand * dp;
      cosTheta      = BetaInverse / Rindex->Value(sampledEnergy);
 
      sin2Theta = 1.0 - cosTheta * 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:
    auto aCerenkovPhoton =
      new G4DynamicParticle(G4OpticalPhoton::OpticalPhoton(), photonMomentum);
 
    aCerenkovPhoton->SetPolarization(photonPolarization);
    aCerenkovPhoton->SetKineticEnergy(sampledEnergy);
 
    G4double NumberOfPhotons;
 
    do
    {
      rand            = G4UniformRand();
      NumberOfPhotons = MeanNumberOfPhotons1 - rand * deltaNumberOfPhotons;
      // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
    } while(G4UniformRand() * maxNumberOfPhotons > NumberOfPhotons);
 
    G4double delta = rand * aStep.GetStepLength();
    G4double deltaTime =
      delta / (pPreStepPoint->GetVelocity() + rand * deltaVelocity * 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(touchableHandle);
    aSecondaryTrack->SetParentID(aTrack.GetTrackID());
    aSecondaryTrack->SetCreatorModelID(secID);
    aParticleChange.AddSecondary(aSecondaryTrack);
  }
 
  if(verboseLevel > 1)
  {
    G4cout << "\n Exiting from G4QuasiCerenkov::DoIt -- NumberOfSecondaries = "
           << aParticleChange.GetNumberOfSecondaries() << G4endl;
  }
 
  return pParticleChange;
}

PostStepGetPhysicalInteractionLength()

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

overridevirtual

Implements G4VProcess.

Definition at line 411 of file G4QuasiCerenkov.cc.

{
  *condition         = NotForced;
  G4double StepLimit = DBL_MAX;
  fNumPhotons        = 0;
 
  const G4Material* aMaterial = aTrack.GetMaterial();
  std::size_t materialIndex   = aMaterial->GetIndex();
 
  // If Physics Vector is not defined no Cerenkov photons
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
  G4MaterialPropertiesTable* MPT =
    ((*materialTable)[materialIndex])->GetMaterialPropertiesTable();
  //  if(!(*thePhysicsTable)[materialIndex])
  if(!MPT)
  {
    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 G4ThreeVector::getTolerance(), it may happen
  // that the particle does not move. See bug 1992.
  static const G4double minAllowedStep = G4ThreeVector::getTolerance();
  if(Step < minAllowedStep)
    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 G4QuasiCerenkov::PreparePhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 398 of file G4QuasiCerenkov.cc.

{
  Initialise();
}

ProcessDescription()

void G4QuasiCerenkov::ProcessDescription ( std::ostream & out ) const

overridevirtual

Reimplemented from G4VProcess.

Definition at line 75 of file G4QuasiCerenkov.cc.

{
  out << "The Cerenkov effect simulates optical photons created by the\n";
  out << "passage of charged particles through matter. Materials need\n";
  out << "to have the property RINDEX (refractive index) defined.\n";
  G4VProcess::DumpInfo();
 
  G4OpticalParameters* params = G4OpticalParameters::Instance();
  out << "Maximum beta change per step: " << params->GetCerenkovMaxBetaChange();
  out << "Maximum photons per step: " << params->GetCerenkovMaxPhotonsPerStep();
  out << "Track secondaries first: "
      << params->GetCerenkovTrackSecondariesFirst();
  out << "Stack photons: " << params->GetCerenkovStackPhotons();
  out << "Verbose level: " << params->GetCerenkovVerboseLevel();
}

Referenced by DumpInfo().

SetMaxBetaChangePerStep()

void G4QuasiCerenkov::SetMaxBetaChangePerStep

(

const G4double

d

)

Definition at line 613 of file G4QuasiCerenkov.cc.

{
  fMaxBetaChange = value * CLHEP::perCent;
  G4OpticalParameters::Instance()->SetCerenkovMaxBetaChange(value);
}

Referenced by Initialise().

SetMaxNumPhotonsPerStep()

void G4QuasiCerenkov::SetMaxNumPhotonsPerStep

(

const G4int

NumPhotons

)

Definition at line 620 of file G4QuasiCerenkov.cc.

{
  fMaxPhotons = NumPhotons;
  G4OpticalParameters::Instance()->SetCerenkovMaxPhotonsPerStep(fMaxPhotons);
}

Referenced by Initialise().

SetOffloadPhotons()

void G4QuasiCerenkov::SetOffloadPhotons

(

const G4bool

offloadingFlag

)

Definition at line 632 of file G4QuasiCerenkov.cc.

{
  fOffloadingFlag = offloadingFlag;
  G4OpticalParameters::Instance()->SetCerenkovOffloadPhotons(fOffloadingFlag);
}

Referenced by Initialise().

SetStackPhotons()

void G4QuasiCerenkov::SetStackPhotons

(

const G4bool

stackingFlag

)

Definition at line 626 of file G4QuasiCerenkov.cc.

{
  fStackingFlag = stackingFlag;
  G4OpticalParameters::Instance()->SetCerenkovStackPhotons(fStackingFlag);
}

Referenced by Initialise().

SetTrackSecondariesFirst()

void G4QuasiCerenkov::SetTrackSecondariesFirst

(

const G4bool

state

)

Definition at line 605 of file G4QuasiCerenkov.cc.

{
  fTrackSecondariesFirst = state;
  G4OpticalParameters::Instance()->SetCerenkovTrackSecondariesFirst(
    fTrackSecondariesFirst);
}

Referenced by Initialise().

SetVerboseLevel()

void G4QuasiCerenkov::SetVerboseLevel

(

G4int

verbose

)

Definition at line 649 of file G4QuasiCerenkov.cc.

{
  verboseLevel = verbose;
  G4OpticalParameters::Instance()->SetCerenkovVerboseLevel(verboseLevel);
}

Referenced by Initialise().

Member Data Documentation

fIndexMPT

std::map<std::size_t, std::size_t> G4QuasiCerenkov::fIndexMPT

protected

Definition at line 184 of file G4QuasiCerenkov.hh.

Referenced by BuildPhysicsTable(), and GetAverageNumberOfPhotons().

thePhysicsTable

G4PhysicsTable* G4QuasiCerenkov::thePhysicsTable

protected

Definition at line 183 of file G4QuasiCerenkov.hh.

Referenced by BuildPhysicsTable(), DumpPhysicsTable(), G4QuasiCerenkov(), GetPhysicsTable(), and ~G4QuasiCerenkov().

---

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

• G4QuasiCerenkov.hh
• G4QuasiCerenkov.cc