G4Cerenkov Class Reference

#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)
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)
void	SetMaxBetaChangePerStep (const G4double d)
void	SetMaxNumPhotonsPerStep (const G4int NumPhotons)
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
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
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

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() [1/2]

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

Definition at line 92 of file G4Cerenkov.cc.

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

~G4Cerenkov()

G4Cerenkov::~G4Cerenkov

(

)

Definition at line 118 of file G4Cerenkov.cc.

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

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 150 of file G4Cerenkov.hh.

                                {return 0;};

AlongStepGetPhysicalInteractionLength()

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

inlinevirtual

Implements G4VProcess.

Definition at line 131 of file G4Cerenkov.hh.

                                { return -1.0; };

AtRestDoIt()

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

inlinevirtual

Implements G4VProcess.

Definition at line 145 of file G4Cerenkov.hh.

                                {return 0;};

AtRestGetPhysicalInteractionLength()

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

inlinevirtual

Implements G4VProcess.

Definition at line 139 of file G4Cerenkov.hh.

                                { return -1.0; };

DumpPhysicsTable()

void G4Cerenkov::DumpPhysicsTable ( ) const

inline

Definition at line 241 of file G4Cerenkov.hh.

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

GetMeanFreePath()

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

Definition at line 454 of file G4Cerenkov.cc.

{
        return 1.;
}

GetPhysicsTable()

G4PhysicsTable * G4Cerenkov::GetPhysicsTable ( ) const

inline

Definition at line 254 of file G4Cerenkov.hh.

{
  return thePhysicsTable;
}

IsApplicable()

G4bool G4Cerenkov::IsApplicable ( const G4ParticleDefinition &  aParticleType )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 214 of file G4Cerenkov.hh.

{
   if (aParticleType.GetParticleName() == "chargedgeantino") return false;
   if (aParticleType.IsShortLived()) return false;
 
   return (aParticleType.GetPDGCharge() != 0);
}

Referenced by G4OpticalPhysics::ConstructProcess().

PostStepDoIt()

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

virtual

Implements G4VProcess.

Definition at line 134 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
        const G4double charge = aParticle->GetDefinition()->GetPDGCharge();
 
        // particle beta
        const G4double beta = (pPreStepPoint ->GetBeta() +
                               pPostStepPoint->GetBeta())/2.;
 
    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);
 
        const G4double beta1 = pPreStepPoint ->GetBeta();
        const 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(); 
 
        } 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 delta, NumberOfPhotons, N;
 
                do {
                   rand = G4UniformRand();
                   delta = rand * aStep.GetStepLength();
                   NumberOfPhotons = MeanNumberOfPhotons1 - delta *
                                (MeanNumberOfPhotons1-MeanNumberOfPhotons2)/
                                              aStep.GetStepLength();
                   N = G4UniformRand() *
                       std::max(MeanNumberOfPhotons1,MeanNumberOfPhotons2);
                } while (N > NumberOfPhotons);
 
        G4double deltaTime = delta /
                       ((pPreStepPoint->GetVelocity()+
                         pPostStepPoint->GetVelocity())/2.);
 
                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;
}

PostStepGetPhysicalInteractionLength()

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

virtual

Implements G4VProcess.

Definition at line 461 of file G4Cerenkov.cc.

{
        *condition = NotForced;
        G4double StepLimit = DBL_MAX;
 
        const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
        const G4Material* aMaterial = aTrack.GetMaterial();
        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;
}

SetMaxBetaChangePerStep()

void G4Cerenkov::SetMaxBetaChangePerStep ( const G4double  d )

inline

Definition at line 229 of file G4Cerenkov.hh.

{
        fMaxBetaChange = value*CLHEP::perCent;
}

Referenced by G4OpticalPhysics::ConstructProcess(), and G4OpticalPhysics::SetMaxBetaChangePerStep().

SetMaxNumPhotonsPerStep()

void G4Cerenkov::SetMaxNumPhotonsPerStep ( const G4int  NumPhotons )

inline

Definition at line 235 of file G4Cerenkov.hh.

{ 
    fMaxPhotons = NumPhotons;
}

Referenced by G4OpticalPhysics::ConstructProcess(), and G4OpticalPhysics::SetMaxNumPhotonsPerStep().

SetTrackSecondariesFirst()

void G4Cerenkov::SetTrackSecondariesFirst ( const G4bool  state )

inline

Definition at line 223 of file G4Cerenkov.hh.

{ 
    fTrackSecondariesFirst = state;
}

Referenced by G4OpticalPhysics::SetTrackSecondariesFirst().

Member Data Documentation

thePhysicsTable

G4PhysicsTable* G4Cerenkov::thePhysicsTable

protected

Definition at line 197 of file G4Cerenkov.hh.

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

---

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

• G4Cerenkov.hh
• G4Cerenkov.cc