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

void	BuildPhysicsTable (const G4ParticleDefinition &aParticleType)

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

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

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

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

G4bool	GetTrackSecondariesFirst () const

G4double	GetMaxBetaChangePerStep () const

G4int	GetMaxNumPhotonsPerStep () const

G4PhysicsTable *	GetPhysicsTable () const

void	DumpPhysicsTable () const

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

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

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

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

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

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

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

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Static Public Member Functions
static void	SetTrackSecondariesFirst (const G4bool state)

static void	SetMaxBetaChangePerStep (const G4double d)

static void	SetMaxNumPhotonsPerStep (const G4int NumPhotons)

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

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
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`
	)

Definition at line 100 of file G4Cerenkov.cc.

References fCerenkov, G4cout, G4endl, G4VProcess::GetProcessName(), G4VProcess::SetProcessSubType(), thePhysicsTable, and G4VProcess::verboseLevel.

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

G4Cerenkov::~G4Cerenkov ( )

Definition at line 120 of file G4Cerenkov.cc.

References G4PhysicsTable::clearAndDestroy(), and thePhysicsTable.

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

G4Cerenkov::G4Cerenkov ( const G4Cerenkov & right )

Member Function Documentation

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

inlinevirtual

Implements G4VProcess.

Definition at line 153 of file G4Cerenkov.hh.

156 {return 0;};

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

inlinevirtual

Implements G4VProcess.

Definition at line 134 of file G4Cerenkov.hh.

140 { return -1.0; };

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

inlinevirtual

Implements G4VProcess.

Definition at line 148 of file G4Cerenkov.hh.

151 {return 0;};

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

inlinevirtual

Implements G4VProcess.

Definition at line 142 of file G4Cerenkov.hh.

145 { return -1.0; };

void G4Cerenkov::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 158 of file G4Cerenkov.cc.

References thePhysicsTable.

 {
     if (!thePhysicsTable) BuildThePhysicsTable();
 }

void G4Cerenkov::DumpPhysicsTable ( ) const

inline

Definition at line 245 of file G4Cerenkov.hh.

References G4PhysicsOrderedFreeVector::DumpValues(), G4PhysicsTable::entries(), thePhysicsTable, and test::v.

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

G4double G4Cerenkov::GetMaxBetaChangePerStep ( ) const

inline

Definition at line 233 of file G4Cerenkov.hh.

 {
         return fMaxBetaChange;
 }

G4int G4Cerenkov::GetMaxNumPhotonsPerStep ( ) const

inline

Definition at line 239 of file G4Cerenkov.hh.

 {
         return fMaxPhotons;
 }

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

Definition at line 487 of file G4Cerenkov.cc.

 {
         return 1.;
 }

G4PhysicsTable * G4Cerenkov::GetPhysicsTable ( ) const

inline

Definition at line 258 of file G4Cerenkov.hh.

References thePhysicsTable.

 {
   return thePhysicsTable;
 }

G4bool G4Cerenkov::GetTrackSecondariesFirst ( ) const

inline

Definition at line 227 of file G4Cerenkov.hh.

 {
         return fTrackSecondariesFirst;
 }

G4bool G4Cerenkov::IsApplicable ( const G4ParticleDefinition & aParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 132 of file G4Cerenkov.cc.

References G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), and G4ParticleDefinition::IsShortLived().

Referenced by OpNovicePhysicsList::ConstructOp(), UltraPhysicsList::ConstructOp(), F04OpticalPhysics::ConstructProcess(), WLSOpticalPhysics::ConstructProcess(), and G4OpticalPhysics::ConstructProcess().

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

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

virtual

Implements G4VProcess.

Definition at line 167 of file G4Cerenkov.cc.

References G4ParticleChange::AddSecondary(), G4VProcess::aParticleChange, fAlive, fSuspend, G4cout, G4endl, G4Poisson(), G4UniformRand, G4StepPoint::GetBeta(), G4DynamicParticle::GetDefinition(), G4Step::GetDeltaPosition(), G4Track::GetDynamicParticle(), G4StepPoint::GetGlobalTime(), G4Track::GetMaterial(), G4Material::GetMaterialPropertiesTable(), G4PhysicsOrderedFreeVector::GetMaxLowEdgeEnergy(), G4PhysicsOrderedFreeVector::GetMaxValue(), G4PhysicsOrderedFreeVector::GetMinLowEdgeEnergy(), G4VParticleChange::GetNumberOfSecondaries(), G4ParticleDefinition::GetPDGCharge(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4MaterialPropertiesTable::GetProperty(), G4Step::GetStepLength(), G4StepPoint::GetTouchableHandle(), G4Track::GetTrackID(), G4Track::GetTrackStatus(), G4StepPoint::GetVelocity(), G4ParticleChange::Initialize(), G4INCL::Math::max(), N, G4OpticalPhoton::OpticalPhoton(), G4VProcess::pParticleChange, G4VParticleChange::ProposeTrackStatus(), CLHEP::Hep3Vector::rotateUz(), G4DynamicParticle::SetKineticEnergy(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetParentID(), G4DynamicParticle::SetPolarization(), G4Track::SetTouchableHandle(), python.hepunit::twopi, CLHEP::Hep3Vector::unit(), G4PhysicsVector::Value(), G4VProcess::verboseLevel, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
     //////////////////////////////////////////////////////
     // 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;
 }

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

virtual

Implements G4VProcess.

Definition at line 494 of file G4Cerenkov.cc.

References DBL_MAX, G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4Material::GetIndex(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetMaterial(), G4Track::GetMaterialCutsCouple(), G4Material::GetMaterialPropertiesTable(), G4PhysicsOrderedFreeVector::GetMaxValue(), G4ParticleDefinition::GetPDGMass(), G4MaterialPropertiesTable::GetProperty(), G4DynamicParticle::GetTotalEnergy(), G4DynamicParticle::GetTotalMomentum(), G4LossTableManager::Instance(), NotForced, StronglyForced, and thePhysicsTable.

 {
         *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;
 }

void G4Cerenkov::SetMaxBetaChangePerStep ( const G4double d )

static

Definition at line 148 of file G4Cerenkov.cc.

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

 {
         fMaxBetaChange = value*CLHEP::perCent;
 }

void G4Cerenkov::SetMaxNumPhotonsPerStep ( const G4int NumPhotons )

static

Definition at line 153 of file G4Cerenkov.cc.

Referenced by WLSOpticalPhysics::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), OpNovicePhysicsList::OpNovicePhysicsList(), G4OpticalPhysics::SetMaxNumPhotonsPerStep(), OpNovicePhysicsList::SetNbOfPhotonsCerenkov(), and WLSOpticalPhysics::SetNbOfPhotonsCerenkov().

 {
         fMaxPhotons = NumPhotons;
 }

void G4Cerenkov::SetTrackSecondariesFirst ( const G4bool state )

static

Definition at line 143 of file G4Cerenkov.cc.

Referenced by UltraPhysicsList::ConstructOp(), WLSOpticalPhysics::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), OpNovicePhysicsList::OpNovicePhysicsList(), and G4OpticalPhysics::SetTrackSecondariesFirst().

 {
         fTrackSecondariesFirst = state;
 }

Field Documentation

G4PhysicsTable* G4Cerenkov::thePhysicsTable

protected

Definition at line 210 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

Static Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation