#include <G4OpticalPhysics.hh>

Inheritance diagram for G4OpticalPhysics:

Public Member Functions
	G4OpticalPhysics (G4int verbose=0, const G4String &name="Optical")

virtual	~G4OpticalPhysics ()

void	Configure (G4OpticalProcessIndex, G4bool)

void	SetProcessVerbose (G4int, G4int)

void	SetMaxNumPhotonsPerStep (G4int)

void	SetMaxBetaChangePerStep (G4double)

void	SetScintillationYieldFactor (G4double)

void	SetScintillationExcitationRatio (G4double)

void	SetWLSTimeProfile (G4String)

void	SetScintillationByParticleType (G4bool)

void	AddScintillationSaturation (G4EmSaturation *)

void	SetTrackSecondariesFirst (G4OpticalProcessIndex, G4bool)

void	SetFiniteRiseTime (G4bool)

Public Member Functions inherited from G4VPhysicsConstructor
	G4VPhysicsConstructor (const G4String &="")

	G4VPhysicsConstructor (const G4String &name, G4int physics_type)

virtual	~G4VPhysicsConstructor ()

void	SetPhysicsName (const G4String &="")

const G4String &	GetPhysicsName () const

void	SetPhysicsType (G4int)

G4int	GetPhysicsType () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

G4int	GetInstanceID () const

Protected Member Functions
virtual void	ConstructParticle ()

virtual void	ConstructProcess ()

Protected Member Functions inherited from G4VPhysicsConstructor
G4bool	RegisterProcess (G4VProcess process, G4ParticleDefinition particle)

Additional Inherited Members
Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManager &	GetSubInstanceManager ()

Protected Attributes inherited from G4VPhysicsConstructor
G4int	verboseLevel

G4String	namePhysics

G4int	typePhysics

G4ParticleTable *	theParticleTable

G4int	g4vpcInstanceID

Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager	subInstanceManager

Detailed Description

Definition at line 61 of file G4OpticalPhysics.hh.

Constructor & Destructor Documentation

G4OpticalPhysics::G4OpticalPhysics	(	G4int	verbose = `0`,
		const G4String &	name = `"Optical"`
	)

Definition at line 62 of file G4OpticalPhysics.cc.

References kNoProcess, and G4VPhysicsConstructor::verboseLevel.

   : G4VPhysicsConstructor(name),
 
     fMaxNumPhotons(100),
     fMaxBetaChange(10.0),
     fYieldFactor(1.),
     fExcitationRatio(0.0),
     fProfile("delta"),
     fFiniteRiseTime(false),
     fScintillationByParticleType(false)
 {
   verboseLevel = verbose;
   fMessenger = new G4OpticalPhysicsMessenger(this);
 
   for ( G4int i=0; i<kNoProcess; i++ ) {
     fProcessUse.push_back(true);
     fProcessVerbose.push_back(verbose);
     fProcessTrackSecondariesFirst.push_back(true);
   }
 }

G4OpticalPhysics::~G4OpticalPhysics ( )

virtual

Definition at line 85 of file G4OpticalPhysics.cc.

 {
   delete fMessenger;
 }

Member Function Documentation

void G4OpticalPhysics::AddScintillationSaturation ( G4EmSaturation * saturation )

Adds Birks Saturation to the G4Scintillation Process

Definition at line 294 of file G4OpticalPhysics.cc.

References G4Scintillation::AddSaturation().

 {
 /// Adds Birks Saturation to the G4Scintillation Process
   G4Scintillation::AddSaturation(saturation);
 }

void G4OpticalPhysics::Configure	(	G4OpticalProcessIndex	index,
		G4bool	isUse
	)

Definition at line 326 of file G4OpticalPhysics.cc.

 {
   // Configure the physics constructor to use/not use a selected process.
   // This method can only be called in PreInit> phase (before execution of
   // ConstructProcess). The process is not added to particle's process manager
   // and so it cannot be re-activated later in Idle> phase with the command
   // /process/activate.
 
   if ( index >= kNoProcess ) return;
   if ( fProcessUse[index] == isUse ) return;
   fProcessUse[index] = isUse;
 }

void G4OpticalPhysics::ConstructParticle ( void )

protectedvirtual

Instantiate particles.

Implements G4VPhysicsConstructor.

Definition at line 126 of file G4OpticalPhysics.cc.

References G4OpticalPhoton::OpticalPhotonDefinition().

 {
 /// Instantiate particles.
 
   // optical photon
   G4OpticalPhoton::OpticalPhotonDefinition();
 }

void G4OpticalPhysics::ConstructProcess ( void )

protectedvirtual

Implements G4VPhysicsConstructor.

Definition at line 140 of file G4OpticalPhysics.cc.

References G4ProcessManager::AddDiscreteProcess(), G4ProcessManager::AddProcess(), G4Scintillation::AddSaturation(), aParticleIterator, G4LossTableManager::EmSaturation(), FatalException, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), idxAtRest, idxPostStep, G4LossTableManager::Instance(), G4Cerenkov::IsApplicable(), G4Scintillation::IsApplicable(), G4Threading::IsWorkerThread(), kAbsorption, kBoundary, kCerenkov, kMieHG, kNoProcess, kRayleigh, kScintillation, kWLS, G4VPhysicsConstructor::namePhysics, G4OpticalPhoton::OpticalPhoton(), G4Scintillation::SetFiniteRiseTime(), G4Cerenkov::SetMaxBetaChangePerStep(), G4Cerenkov::SetMaxNumPhotonsPerStep(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToLast(), G4Scintillation::SetScintillationByParticleType(), G4Scintillation::SetScintillationExcitationRatio(), G4Scintillation::SetScintillationYieldFactor(), G4Scintillation::SetTrackSecondariesFirst(), G4Cerenkov::SetTrackSecondariesFirst(), G4OpWLS::UseTimeProfile(), and G4VPhysicsConstructor::verboseLevel.

 {
 // Construct optical processes.
 
   if(verboseLevel>0)
          G4cout <<"G4OpticalPhysics:: Add Optical Physics Processes"<< G4endl;
 
   // A vector of optical processes
   std::vector<G4VProcess*> OpProcesses;
 
   for ( G4int i=0; i<kNoProcess; i++ ) OpProcesses.push_back(NULL);
 
   // Add Optical Processes
 
   G4OpAbsorption* OpAbsorptionProcess  = new G4OpAbsorption();
   G4OpRayleigh* OpRayleighScatteringProcess = new G4OpRayleigh();
   G4OpMieHG* OpMieHGScatteringProcess = new G4OpMieHG();
 
   OpProcesses[kAbsorption] = OpAbsorptionProcess;
   OpProcesses[kRayleigh] = OpRayleighScatteringProcess;
   OpProcesses[kMieHG] = OpMieHGScatteringProcess;
 
   G4OpBoundaryProcess* OpBoundaryProcess = new G4OpBoundaryProcess();
 
   OpProcesses[kBoundary] = OpBoundaryProcess;
 
   G4OpWLS* OpWLSProcess = new G4OpWLS();
 
   OpProcesses[kWLS] = OpWLSProcess;
 
   G4ProcessManager * pManager = 0;
   pManager = G4OpticalPhoton::OpticalPhoton()->GetProcessManager();
 
   if (!pManager) {
      std::ostringstream o;
      o << "Optical Photon without a Process Manager";
      G4Exception("G4OpticalPhysics::ConstructProcess()","",
                   FatalException,o.str().c_str());
      return;
   }
 
   for ( G4int i=kAbsorption; i<=kWLS; i++ ) {
       if ( fProcessUse[i] ) {
          pManager->AddDiscreteProcess(OpProcesses[i]);
       }
   }
 
   G4Scintillation* ScintillationProcess = new G4Scintillation();
 
   OpProcesses[kScintillation] = ScintillationProcess;
 
   G4Cerenkov* CerenkovProcess = new G4Cerenkov();
   OpProcesses[kCerenkov] = CerenkovProcess;
 
   // static parameters - set only for masther thread
   if(!G4Threading::IsWorkerThread())
   {
     G4OpWLS::UseTimeProfile(fProfile);
 
     G4Scintillation::SetScintillationYieldFactor(fYieldFactor);
     G4Scintillation::SetScintillationExcitationRatio(fExcitationRatio);
     G4Scintillation::SetFiniteRiseTime(fFiniteRiseTime);
     G4Scintillation::SetScintillationByParticleType(fScintillationByParticleType);
     G4Scintillation::SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kScintillation]);
 
     // Use Birks Correction in the Scintillation process
     G4EmSaturation* emSaturation = G4LossTableManager::Instance()->EmSaturation();
     G4Scintillation::AddSaturation(emSaturation);
 
     G4Cerenkov::SetMaxNumPhotonsPerStep(fMaxNumPhotons);
     G4Cerenkov::SetMaxBetaChangePerStep(fMaxBetaChange);
     G4Cerenkov::SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kCerenkov]);
   }
 
   aParticleIterator->reset();
 
   while( (*aParticleIterator)() ){
 
     G4ParticleDefinition* particle = aParticleIterator->value();
     G4String particleName = particle->GetParticleName();
 
     pManager = particle->GetProcessManager();
     if (!pManager) {
        std::ostringstream o;
        o << "Particle " << particleName << "without a Process Manager";
        G4Exception("G4OpticalPhysics::ConstructProcess()","",
                     FatalException,o.str().c_str());
        return;                 // else coverity complains for pManager use below        
     }
 
     if( CerenkovProcess->IsApplicable(*particle) &&
         fProcessUse[kCerenkov] ) {
           pManager->AddProcess(CerenkovProcess);
           pManager->SetProcessOrdering(CerenkovProcess,idxPostStep);
     }
     if( ScintillationProcess->IsApplicable(*particle) &&
         fProcessUse[kScintillation] ){
           pManager->AddProcess(ScintillationProcess);
           pManager->SetProcessOrderingToLast(ScintillationProcess,idxAtRest);
           pManager->SetProcessOrderingToLast(ScintillationProcess,idxPostStep);
     }
 
   }
 
   // Add verbose
   for ( G4int i=0; i<kNoProcess; i++ ) {
     if ( fProcessUse[i] ) OpProcesses[i]->SetVerboseLevel(fProcessVerbose[i]);
   }
 
   if (verboseLevel > 1) PrintStatistics();
   if (verboseLevel > 0)
     G4cout << "### " << namePhysics << " physics constructed." << G4endl;
 }

void G4OpticalPhysics::SetFiniteRiseTime ( G4bool finiteRiseTime )

Definition at line 320 of file G4OpticalPhysics.cc.

References G4Scintillation::SetFiniteRiseTime().

Referenced by G4OpticalPhysicsMessenger::SetNewValue().

 {
   fFiniteRiseTime = finiteRiseTime;
   G4Scintillation::SetFiniteRiseTime(finiteRiseTime);
 } 

void G4OpticalPhysics::SetMaxBetaChangePerStep ( G4double maxBetaChange )

Limit step to the specified maximum change of beta of the parent particle

Definition at line 278 of file G4OpticalPhysics.cc.

References G4Cerenkov::SetMaxBetaChangePerStep().

Referenced by LXePhysicsList::LXePhysicsList(), and G4OpticalPhysicsMessenger::SetNewValue().

 {
 /// Limit step to the specified maximum change of beta of the parent particle
 
   fMaxBetaChange = maxBetaChange;
   G4Cerenkov::SetMaxBetaChangePerStep(maxBetaChange);
 }

void G4OpticalPhysics::SetMaxNumPhotonsPerStep ( G4int maxNumPhotons )

Limit step to the specified maximum number of Cherenkov photons

Definition at line 270 of file G4OpticalPhysics.cc.

References G4Cerenkov::SetMaxNumPhotonsPerStep().

Referenced by LXePhysicsList::LXePhysicsList(), and G4OpticalPhysicsMessenger::SetNewValue().

 {
 /// Limit step to the specified maximum number of Cherenkov photons
 
   fMaxNumPhotons = maxNumPhotons;
   G4Cerenkov::SetMaxNumPhotonsPerStep(maxNumPhotons);
 }

void G4OpticalPhysics::SetProcessVerbose	(	G4int	index,
		G4int	verbose
	)

Definition at line 339 of file G4OpticalPhysics.cc.

 {
   // Set new verbose level to a selected process
 
   if ( index >= kNoProcess ) return;
   if ( fProcessVerbose[index] == verbose ) return;
   fProcessVerbose[index] = verbose;
 }

void G4OpticalPhysics::SetScintillationByParticleType ( G4bool scintillationByParticleType )

Definition at line 301 of file G4OpticalPhysics.cc.

References G4Scintillation::SetScintillationByParticleType().

Referenced by G4OpticalPhysicsMessenger::SetNewValue().

 {
   fScintillationByParticleType = scintillationByParticleType;
   G4Scintillation::SetScintillationByParticleType(scintillationByParticleType);
 }

void G4OpticalPhysics::SetScintillationExcitationRatio ( G4double excitationRatio )

Set the scintillation excitation ratio

Definition at line 262 of file G4OpticalPhysics.cc.

References G4Scintillation::SetScintillationExcitationRatio().

Referenced by LXePhysicsList::LXePhysicsList().

 {
 /// Set the scintillation excitation ratio
 
   fExcitationRatio = excitationRatio;
   G4Scintillation::SetScintillationExcitationRatio(excitationRatio);
 }

void G4OpticalPhysics::SetScintillationYieldFactor ( G4double yieldFactor )

Set the scintillation yield factor

Definition at line 254 of file G4OpticalPhysics.cc.

References G4Scintillation::SetScintillationYieldFactor().

Referenced by LXePhysicsList::LXePhysicsList(), and G4OpticalPhysicsMessenger::SetNewValue().

 {
 /// Set the scintillation yield factor
 
   fYieldFactor = yieldFactor;
   G4Scintillation::SetScintillationYieldFactor(yieldFactor);
 }

void G4OpticalPhysics::SetTrackSecondariesFirst	(	G4OpticalProcessIndex	index,
		G4bool	trackSecondariesFirst
	)

Definition at line 307 of file G4OpticalPhysics.cc.

References kCerenkov, kScintillation, G4Scintillation::SetTrackSecondariesFirst(), and G4Cerenkov::SetTrackSecondariesFirst().

Referenced by LXePhysicsList::LXePhysicsList(), and G4OpticalPhysicsMessenger::SetNewValue().

 {
   if ( index >= kNoProcess ) return;
   if ( fProcessTrackSecondariesFirst[index] == trackSecondariesFirst ) return;
   fProcessTrackSecondariesFirst[index] = trackSecondariesFirst;
 
   if ( index == kCerenkov )
      G4Cerenkov::SetTrackSecondariesFirst(trackSecondariesFirst);
   if ( index == kScintillation)
      G4Scintillation::SetTrackSecondariesFirst(trackSecondariesFirst);
 }

void G4OpticalPhysics::SetWLSTimeProfile ( G4String profile )

Set the WLS time profile (delta or exponential)

Definition at line 286 of file G4OpticalPhysics.cc.

References profile(), and G4OpWLS::UseTimeProfile().

Referenced by LXePhysicsList::LXePhysicsList(), and G4OpticalPhysicsMessenger::SetNewValue().

 {
 /// Set the WLS time profile (delta or exponential)
 
   fProfile = profile;
   G4OpWLS::UseTimeProfile(profile);
 }

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation