G4OpticalPhysicsMessenger Class Reference

#include <G4OpticalPhysicsMessenger.hh>

Inheritance diagram for G4OpticalPhysicsMessenger:

Public Member Functions
	G4OpticalPhysicsMessenger (G4OpticalPhysics *)
virtual	~G4OpticalPhysicsMessenger ()
virtual void	SetNewValue (G4UIcommand *, G4String)
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
virtual G4String	GetCurrentValue (G4UIcommand *command)
G4bool	operator== (const G4UImessenger &messenger) const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (G4String s)
G4double	StoD (G4String s)
G4bool	StoB (G4String s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir
G4String	baseDirName

Detailed Description

Definition at line 74 of file G4OpticalPhysicsMessenger.hh.

Constructor & Destructor Documentation

G4OpticalPhysicsMessenger::G4OpticalPhysicsMessenger

(

G4OpticalPhysics *

opticalPhysics

)

Definition at line 59 of file G4OpticalPhysicsMessenger.cc.

References G4UIcommand::AvailableForStates(), G4OpticalPhysicsMessenger(), G4OpticalProcessName(), G4State_Idle, G4State_PreInit, kNoProcess, G4UIcmdWithAString::SetCandidates(), G4UIcmdWithAnInteger::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcmdWithAString::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithABool::SetParameterName(), and G4UIcommand::SetRange().

Referenced by G4OpticalPhysicsMessenger().

  : G4UImessenger(),
    fOpticalPhysics(opticalPhysics),
    fSelectedProcessIndex(kNoProcess),
    fSelectOpProcessCmd(0),
    fSetOpProcessUseCmd(0),
    fSetOpProcessVerboseCmd(0),
    fSetCerenkovMaxPhotonsCmd(0),
    fSetCerenkovMaxBetaChangeCmd(0),
    fSetScintillationYieldFactorCmd(0),
    fSetScintillationByParticleTypeCmd(0),
//    fSetOpticalSurfaceModelCmd(0),
    fSetWLSTimeProfileCmd(0),
    fSetTrackSecondariesFirstCmd(0),
    fSetFiniteRiseTimeCmd(0)
{
  fDir = new G4UIdirectory("/optics_engine/");
  fDir->
    SetGuidance("Commands related to the optical physics simulation engine.");

  fSelectOpProcessCmd
   = new G4UIcmdWithAString("/optics_engine/selectOpProcess", this);
  fSelectOpProcessCmd
   ->SetGuidance("Select optical process for applying use/verbose/trackfirst commands");
  fSelectOpProcessCmd->SetParameterName("OpProcess", false);
  G4String candidates;
  for ( G4int i=0; i<kNoProcess; i++ ) {
      candidates += G4OpticalProcessName(i);
      candidates += G4String(" ");
  }
  fSelectOpProcessCmd->SetCandidates(candidates);
  fSelectOpProcessCmd->AvailableForStates(G4State_PreInit, G4State_Idle);

  fSetOpProcessUseCmd
   = new G4UIcmdWithABool("/optics_engine/setOpProcessUse", this);
  fSetOpProcessUseCmd->SetGuidance("Use/Not use selected optical process");
  fSetOpProcessUseCmd->SetParameterName("OpProcessUse", false);
  fSetOpProcessUseCmd->AvailableForStates(G4State_PreInit);

  fSetOpProcessVerboseCmd
    = new G4UIcmdWithAnInteger("/optics_engine/setOpProcessVerbose", this);
  fSetOpProcessVerboseCmd->SetGuidance("Set verbosity level for selected optical process");
  fSetOpProcessVerboseCmd->SetParameterName("OpProcessVerbose", true);
  fSetOpProcessVerboseCmd->SetDefaultValue(1);
  fSetOpProcessVerboseCmd->SetRange("OpProcessVerbose>=0");
  fSetOpProcessVerboseCmd->AvailableForStates(G4State_PreInit);

  fSetCerenkovMaxPhotonsCmd
    = new G4UIcmdWithAnInteger("/optics_engine/setCerenkovMaxPhotons", this);
  fSetCerenkovMaxPhotonsCmd->SetGuidance("Set maximum number of photons per step");
  fSetCerenkovMaxPhotonsCmd->SetParameterName("CerenkovMaxPhotons", false);
  fSetCerenkovMaxPhotonsCmd->SetRange("CerenkovMaxPhotons>=0");
  fSetCerenkovMaxPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);

  fSetCerenkovMaxBetaChangeCmd
    = new G4UIcmdWithADouble("/optics_engine/setCerenkovMaxBetaChange", this);
  fSetCerenkovMaxBetaChangeCmd
    ->SetGuidance("Set maximum change of beta of parent particle per step");
  fSetCerenkovMaxBetaChangeCmd->
                             SetParameterName("CerenkovMaxBetaChange", false);
  fSetCerenkovMaxBetaChangeCmd->SetRange("CerenkovMaxBetaChange>=0");
  fSetCerenkovMaxBetaChangeCmd->
                            AvailableForStates(G4State_PreInit, G4State_Idle);

  fSetScintillationYieldFactorCmd
   = new G4UIcmdWithADouble("/optics_engine/setScintillationYieldFactor", this);
  fSetScintillationYieldFactorCmd->
                                SetGuidance("Set scintillation yield factor");
  fSetScintillationYieldFactorCmd->
                          SetParameterName("ScintillationYieldFactor", false);
  fSetScintillationYieldFactorCmd->SetRange("ScintillationYieldFactor>=0");
  fSetScintillationYieldFactorCmd->
                            AvailableForStates(G4State_PreInit, G4State_Idle);

  fSetScintillationByParticleTypeCmd
  = new G4UIcmdWithABool("/optics_engine/setScintillationByParticleType", this);
  fSetScintillationByParticleTypeCmd->
    SetGuidance("Activate/Inactivate scintillation process by particle type");
  fSetScintillationByParticleTypeCmd->
             SetParameterName("ScintillationByParticleTypeActivation", false);
  fSetScintillationByParticleTypeCmd->
                            AvailableForStates(G4State_PreInit, G4State_Idle);

//  fSetOpticalSurfaceModelCmd
//    = new G4UIcmdWithAString("/optics_engine/setOpticalSurfaceModel", this);
//  fSetOpticalSurfaceModelCmd
//    ->SetGuidance("Set optical surface model (glisur or unified)");
//  fSetOpticalSurfaceModelCmd->SetParameterName("OpticalSurfaceModel", false);
//  fSetOpticalSurfaceModelCmd->SetCandidates("glisur unified");
//  fSetOpticalSurfaceModelCmd->
//                             AvailableForStates(G4State_PreInit, G4State_Idle);

  fSetWLSTimeProfileCmd
    = new G4UIcmdWithAString("/optics_engine/setWLSTimeProfile", this);
  fSetWLSTimeProfileCmd
    ->SetGuidance("Set the WLS time profile (delta or exponential)");
  fSetWLSTimeProfileCmd->SetParameterName("WLSTimeProfile", false);
  fSetWLSTimeProfileCmd->SetCandidates("delta exponential");
  fSetWLSTimeProfileCmd->AvailableForStates(G4State_PreInit, G4State_Idle);

  fSetTrackSecondariesFirstCmd
    = new G4UIcmdWithABool("/optics_engine/setTrackSecondariesFirst", this);
  fSetTrackSecondariesFirstCmd
    ->SetGuidance("Set option to track secondaries before finishing their parent track");
  fSetTrackSecondariesFirstCmd->
                             SetParameterName("TrackSecondariesFirst", false);
  fSetTrackSecondariesFirstCmd->
                            AvailableForStates(G4State_PreInit, G4State_Idle);

  fSetFiniteRiseTimeCmd
    = new G4UIcmdWithABool("/optics_engine/setFiniteRiseTime", this);
  fSetFiniteRiseTimeCmd
     ->SetGuidance("Set option of a finite rise-time for G4Scintillation - If set, the G4Scintillation process expects the user to have set the constant material property FAST/SLOWSCINTILLATIONRISETIME");
  fSetFiniteRiseTimeCmd->SetParameterName("FiniteRiseTime", false);
  fSetFiniteRiseTimeCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
}

G4OpticalPhysicsMessenger::~G4OpticalPhysicsMessenger ( )

virtual

Definition at line 177 of file G4OpticalPhysicsMessenger.cc.

{
// Destructor

  delete fDir;
  delete fSelectOpProcessCmd;
  delete fSetOpProcessUseCmd;
  delete fSetOpProcessVerboseCmd;
  delete fSetCerenkovMaxPhotonsCmd;
  delete fSetCerenkovMaxBetaChangeCmd;
  delete fSetScintillationYieldFactorCmd;
  delete fSetScintillationByParticleTypeCmd;
//  delete fSetOpticalSurfaceModelCmd;
  delete fSetWLSTimeProfileCmd;
  delete fSetTrackSecondariesFirstCmd;
  delete fSetFiniteRiseTimeCmd;
}

Member Function Documentation

void G4OpticalPhysicsMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValue  )

virtual

Apply command to the associated object.

Reimplemented from G4UImessenger.

Definition at line 195 of file G4OpticalPhysicsMessenger.cc.

References Lesson1::Configure(), G4UIcmdWithABool::GetNewBoolValue(), G4UIcmdWithADouble::GetNewDoubleValue(), G4UIcmdWithAnInteger::GetNewIntValue(), kAbsorption, kBoundary, kCerenkov, kMieHG, kNoProcess, kRayleigh, kScintillation, kWLS, G4OpticalPhysics::SetFiniteRiseTime(), G4OpticalPhysics::SetMaxBetaChangePerStep(), G4OpticalPhysics::SetMaxNumPhotonsPerStep(), G4OpticalPhysics::SetScintillationByParticleType(), G4OpticalPhysics::SetScintillationYieldFactor(), G4OpticalPhysics::SetTrackSecondariesFirst(), and G4OpticalPhysics::SetWLSTimeProfile().

{
/// Apply command to the associated object.

  if (command == fSelectOpProcessCmd) {
    if      ( newValue == "Cerenkov" )        {
            fSelectedProcessIndex = kCerenkov;
    } else if ( newValue == "Scintillation" ) {
            fSelectedProcessIndex = kScintillation;
    } else if ( newValue == "OpAbsorption" )  {
            fSelectedProcessIndex = kAbsorption;
    } else if ( newValue == "OpRayleigh" )    {
            fSelectedProcessIndex = kRayleigh;
    } else if ( newValue == "OpMieHG" )       {
            fSelectedProcessIndex = kMieHG;
    } else if ( newValue == "OpBoundary" )    {
           fSelectedProcessIndex = kBoundary;
    } else if ( newValue == "OpWLS" )         {
           fSelectedProcessIndex = kWLS;
    }
  }
  else if (command == fSetOpProcessUseCmd) {
    fOpticalPhysics->
       Configure(fSelectedProcessIndex,
                 fSetOpProcessUseCmd->GetNewBoolValue(newValue));
  }
  else if (command == fSetOpProcessVerboseCmd) {
    if ( fSelectedProcessIndex < kNoProcess ) {
       fOpticalPhysics->
          SetProcessVerbose(fSelectedProcessIndex,
                            fSetOpProcessVerboseCmd->GetNewIntValue(newValue));
    } else {
      for ( G4int i=0; i<kNoProcess; i++ ) {
        fOpticalPhysics->
        SetProcessVerbose(i,fSetOpProcessVerboseCmd->GetNewIntValue(newValue));
      }
    }
  }
  else if (command == fSetCerenkovMaxPhotonsCmd) {
    fOpticalPhysics
      ->SetMaxNumPhotonsPerStep(
          fSetCerenkovMaxPhotonsCmd->GetNewIntValue(newValue));
  }
  else if (command == fSetCerenkovMaxBetaChangeCmd) {
    fOpticalPhysics
      ->SetMaxBetaChangePerStep(
          fSetCerenkovMaxBetaChangeCmd->GetNewDoubleValue(newValue));
  }
  else if (command == fSetScintillationYieldFactorCmd) {
    fOpticalPhysics
      ->SetScintillationYieldFactor(
          fSetScintillationYieldFactorCmd->GetNewDoubleValue(newValue));
  }
  else if (command == fSetScintillationByParticleTypeCmd) {
    fOpticalPhysics
      ->SetScintillationByParticleType(
         fSetScintillationByParticleTypeCmd->GetNewBoolValue(newValue));
  }
  else if (command == fSetFiniteRiseTimeCmd) {
    fOpticalPhysics
      ->SetFiniteRiseTime(
         fSetFiniteRiseTimeCmd->GetNewBoolValue(newValue));
  }
//  else if (command == fSetOpticalSurfaceModelCmd) {
//    if ( newValue == "glisur" ) {
//      fOpticalPhysics
//        ->SetOpticalSurfaceModel(glisur);
//    }
//    if ( newValue == "unified" ) {
//      fOpticalPhysics
//        ->SetOpticalSurfaceModel(unified);
//    }
//  }
  else if (command == fSetWLSTimeProfileCmd) {
    if ( newValue == "delta" ) {
      fOpticalPhysics
        ->SetWLSTimeProfile("delta");     }
    if ( newValue == "exponential" ) {
      fOpticalPhysics
        ->SetWLSTimeProfile("exponential");
    }
  }
  else if (command == fSetTrackSecondariesFirstCmd) {
    fOpticalPhysics->SetTrackSecondariesFirst(fSelectedProcessIndex,
                                              fSetTrackSecondariesFirstCmd->
                                                    GetNewBoolValue(newValue));
  }
}

---

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

• G4OpticalPhysicsMessenger.hh
• G4OpticalPhysicsMessenger.cc