G4OpticalPhysics Class Reference

#include <G4OpticalPhysics.hh>

Inheritance diagram for G4OpticalPhysics:

Collaboration diagram for G4OpticalPhysics:

Public Member Functions
	G4OpticalPhysics (G4int verbose=0, const G4String &name="Optical")
virtual	~G4OpticalPhysics ()
void	Configure (G4OpticalProcessIndex, G4bool)
void	SetMaxNumPhotonsPerStep (G4int)
void	SetMaxBetaChangePerStep (G4double)
void	SetScintillationYieldFactor (G4double)
void	SetScintillationExcitationRatio (G4double)
void	SetWLSTimeProfile (G4String)
void	SetScintillationByParticleType (G4bool)
void	SetScintillationTrackInfo (G4bool)
void	SetTrackSecondariesFirst (G4OpticalProcessIndex, G4bool)
void	SetFiniteRiseTime (G4bool)
void	SetCerenkovStackPhotons (G4bool)
void	SetScintillationStackPhotons (G4bool)
void	SetInvokeSD (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)
G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const

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 64 of file G4OpticalPhysics.cc.

  : G4VPhysicsConstructor(name),

    fMaxNumPhotons(100),
    fMaxBetaChange(10.0),
    fYieldFactor(1.),
    fExcitationRatio(0.0),
    fProfile("delta"),
    fFiniteRiseTime(false),
    fScintillationByParticleType(false),
    fScintillationTrackInfo(false),
    fInvokeSD(true),
    fCerenkovStackPhotons(true),
    fScintillationStackPhotons(true)
{
  verboseLevel = verbose;
  fMessenger = new G4OpticalPhysicsMessenger(this);

  for ( G4int i=0; i<kNoProcess; i++ ) {
    fProcessUse.push_back(true);
    fProcessTrackSecondariesFirst.push_back(true);
  }
}

G4OpticalPhysics::~G4OpticalPhysics ( )

virtual

Definition at line 90 of file G4OpticalPhysics.cc.

{
  delete fMessenger;
}

Member Function Documentation

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

Definition at line 475 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;
}

Here is the caller graph for this function:

void G4OpticalPhysics::ConstructParticle ( )

protectedvirtual

Instantiate particles.

Implements G4VPhysicsConstructor.

Definition at line 141 of file G4OpticalPhysics.cc.

{

  // optical photon
  G4OpticalPhoton::OpticalPhotonDefinition();
}

Here is the call graph for this function:

void G4OpticalPhysics::ConstructProcess ( )

protectedvirtual

Implements G4VPhysicsConstructor.

Definition at line 268 of file G4OpticalPhysics.cc.

{
// 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();
  UIhelpers::buildCommands(OpAbsorptionProcess,DIR_CMDS"/absorption/",GUIDANCE" for absorption process");
  OpProcesses[kAbsorption] = OpAbsorptionProcess;

  G4OpRayleigh* OpRayleighScatteringProcess = new G4OpRayleigh();
  UIhelpers::buildCommands(OpRayleighScatteringProcess,DIR_CMDS"/rayleigh/",GUIDANCE" for Reyleigh scattering process");
  OpProcesses[kRayleigh] = OpRayleighScatteringProcess;
    
  G4OpMieHG* OpMieHGScatteringProcess = new G4OpMieHG();
  UIhelpers::buildCommands(OpMieHGScatteringProcess,DIR_CMDS"/mie/",GUIDANCE" for Mie cattering process");
  OpProcesses[kMieHG] = OpMieHGScatteringProcess;

  G4OpBoundaryProcess* OpBoundaryProcess = new G4OpBoundaryProcess();
  UIhelpers::buildCommands(OpBoundaryProcess,DIR_CMDS"/boundary/",GUIDANCE" for boundary process");
  OpBoundaryProcess->SetInvokeSD(fInvokeSD);
  OpProcesses[kBoundary] = OpBoundaryProcess;

  G4OpWLS* OpWLSProcess = new G4OpWLS();
  OpWLSProcess->UseTimeProfile(fProfile);
  UIhelpers::buildCommands(OpWLSProcess);
  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();
  ScintillationProcess->SetScintillationYieldFactor(fYieldFactor);
  ScintillationProcess->SetScintillationExcitationRatio(fExcitationRatio);
  ScintillationProcess->SetFiniteRiseTime(fFiniteRiseTime);
  ScintillationProcess->SetScintillationByParticleType(fScintillationByParticleType);
  ScintillationProcess->SetScintillationTrackInfo(fScintillationTrackInfo);
  ScintillationProcess->SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kScintillation]);
  ScintillationProcess->SetStackPhotons(fScintillationStackPhotons);
  G4EmSaturation* emSaturation = G4LossTableManager::Instance()->EmSaturation();
  ScintillationProcess->AddSaturation(emSaturation);
  UIhelpers::buildCommands(ScintillationProcess);
  OpProcesses[kScintillation] = ScintillationProcess;
    
  G4Cerenkov* CerenkovProcess = new G4Cerenkov();
  CerenkovProcess->SetMaxNumPhotonsPerStep(fMaxNumPhotons);
  CerenkovProcess->SetMaxBetaChangePerStep(fMaxBetaChange);
  CerenkovProcess->SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kCerenkov]);
  CerenkovProcess->SetStackPhotons(fCerenkovStackPhotons);
  UIhelpers::buildCommands(CerenkovProcess);
  OpProcesses[kCerenkov] = CerenkovProcess;

  auto myParticleIterator=GetParticleIterator();
  myParticleIterator->reset();

  while( (*myParticleIterator)() ){

    G4ParticleDefinition* particle = myParticleIterator->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(verboseLevel);
  }

    if (verboseLevel > 1) PrintStatistics();
  if (verboseLevel > 0)
    G4cout << "### " << namePhysics << " physics constructed." << G4endl;
}

Here is the call graph for this function:

void G4OpticalPhysics::SetCerenkovStackPhotons

(

G4bool

stackingFlag

)

Definition at line 465 of file G4OpticalPhysics.cc.

{
  fCerenkovStackPhotons = stackingFlag;
}

Here is the caller graph for this function:

void G4OpticalPhysics::SetFiniteRiseTime

(

G4bool

finiteRiseTime

)

Definition at line 454 of file G4OpticalPhysics.cc.

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

Here is the caller graph for this function:

void G4OpticalPhysics::SetInvokeSD

(

G4bool

invokeSD

)

Definition at line 460 of file G4OpticalPhysics.cc.

{
  fInvokeSD = invokeSD;
}

Here is the caller graph for this function:

void G4OpticalPhysics::SetMaxBetaChangePerStep

(

G4double

maxBetaChange

)

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

Definition at line 407 of file G4OpticalPhysics.cc.

{

  fMaxBetaChange = maxBetaChange;
//  G4Cerenkov::SetMaxBetaChangePerStep(maxBetaChange);
}

Here is the caller graph for this function:

void G4OpticalPhysics::SetMaxNumPhotonsPerStep

(

G4int

maxNumPhotons

)

Limit step to the specified maximum number of Cherenkov photons

Definition at line 399 of file G4OpticalPhysics.cc.

{

  fMaxNumPhotons = maxNumPhotons;
//  G4Cerenkov::SetMaxNumPhotonsPerStep(maxNumPhotons);
}

Here is the caller graph for this function:

void G4OpticalPhysics::SetScintillationByParticleType

(

G4bool

scintillationByParticleType

)

Definition at line 428 of file G4OpticalPhysics.cc.

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

Here is the caller graph for this function:

void G4OpticalPhysics::SetScintillationExcitationRatio

(

G4double

excitationRatio

)

Set the scintillation excitation ratio

Definition at line 391 of file G4OpticalPhysics.cc.

{

  fExcitationRatio = excitationRatio;
//  G4Scintillation::SetScintillationExcitationRatio(excitationRatio);
}

void G4OpticalPhysics::SetScintillationStackPhotons

(

G4bool

stackingFlag

)

Definition at line 470 of file G4OpticalPhysics.cc.

{
  fScintillationStackPhotons = stackingFlag;
}

Here is the caller graph for this function:

void G4OpticalPhysics::SetScintillationTrackInfo

(

G4bool

scintillationTrackInfo

)

Definition at line 435 of file G4OpticalPhysics.cc.

{
  fScintillationTrackInfo = scintillationTrackInfo;
  //G4Scintillation::SetScintillationTrackInfo(scintillationTrackInfo);
}

Here is the caller graph for this function:

void G4OpticalPhysics::SetScintillationYieldFactor

(

G4double

yieldFactor

)

Set the scintillation yield factor

Definition at line 383 of file G4OpticalPhysics.cc.

{

  fYieldFactor = yieldFactor;
  //G4Scintillation::SetScintillationYieldFactor(yieldFactor);
}

Here is the caller graph for this function:

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

Definition at line 441 of file G4OpticalPhysics.cc.

{
  if ( index >= kNoProcess ) return;
  if ( fProcessTrackSecondariesFirst[index] == trackSecondariesFirst ) return;
  fProcessTrackSecondariesFirst[index] = trackSecondariesFirst;

//  if ( index == kCerenkov )
//     G4Cerenkov::SetTrackSecondariesFirst(trackSecondariesFirst);
//  if ( index == kScintillation)
//      G4Scintillation::SetTrackSecondariesFirst(trackSecondariesFirst);
}

Here is the caller graph for this function:

void G4OpticalPhysics::SetWLSTimeProfile

(

G4String

profile

)

Set the WLS time profile (delta or exponential)

Definition at line 415 of file G4OpticalPhysics.cc.

{
  fProfile = profile;
}

Here is the caller graph for this function:

---

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

• geant4.10.03.p01/source/physics_lists/constructors/electromagnetic/include/G4OpticalPhysics.hh
• geant4.10.03.p01/source/physics_lists/constructors/electromagnetic/src/G4OpticalPhysics.cc