G4OpticalPhysicsMessenger Class Reference

#include <G4OpticalPhysicsMessenger.hh>

Inheritance diagram for G4OpticalPhysicsMessenger:

Collaboration 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
G4bool	CommandsShouldBeInMaster () 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
G4bool	commandsShouldBeInMaster

Detailed Description

Definition at line 76 of file G4OpticalPhysicsMessenger.hh.

Constructor & Destructor Documentation

G4OpticalPhysicsMessenger::G4OpticalPhysicsMessenger

(

G4OpticalPhysics *

opticalPhysics

)

Definition at line 60 of file G4OpticalPhysicsMessenger.cc.

  : G4UImessenger(),
    fOpticalPhysics(opticalPhysics),
    fSelectedProcessIndex(kNoProcess),
    fActivateProcessCmd(0),
    fSetOpProcessVerboseCmd(0),
    fSetCerenkovMaxPhotonsCmd(0),
    fSetCerenkovMaxBetaChangeCmd(0),
    fSetCerenkovStackPhotonsCmd(0),
    fSetScintillationYieldFactorCmd(0),
    fSetScintillationByParticleTypeCmd(0),
    fSetScintillationTrackInfoCmd(0),
    fSetScintillationStackPhotonsCmd(0),
    fSetWLSTimeProfileCmd(0),
    fSetTrackSecondariesFirstCmd(0),
    fSetFiniteRiseTimeCmd(0),
    fSetInvokeSDCmd(0)
{
    G4bool toBeBroadcasted = false;
    fDir = new G4UIdirectory("/process/optical/defaults/",toBeBroadcasted);
    fDir->SetGuidance("Commands related to the optical physics simulation engine.");
    fDir2 = new G4UIdirectory("/process/optical/",toBeBroadcasted);
    fDir2->SetGuidance("Commands related to the optical physics simulation engine.");

    fActivateProcessCmd= new G4UIcommand("/process/optical/processActivation", this);
    fActivateProcessCmd->SetGuidance("Activate/deactivate the specified optical process");
    G4UIparameter* par = new G4UIparameter("proc_name",'s',false);
    G4String candidates;
    for ( G4int i=0; i<kNoProcess; i++ ) {
        candidates += G4OpticalProcessName(i);
        candidates += G4String(" ");
    }
    par->SetParameterCandidates(candidates);
    par->SetGuidance("the process name");
    fActivateProcessCmd->SetParameter(par);
    par = new G4UIparameter("flag",'b',true);
    par->SetDefaultValue(true);
    par->SetGuidance("activation flag");
    fActivateProcessCmd->SetParameter(par);
    fActivateProcessCmd->AvailableForStates(G4State_PreInit);


    fSetOpProcessVerboseCmd = new G4UIcmdWithAnInteger("/process/optical/verbose", this);
    fSetOpProcessVerboseCmd->SetGuidance("Set default verbosity level for optical processes");
    fSetOpProcessVerboseCmd->SetParameterName("ver", true);
    fSetOpProcessVerboseCmd->SetDefaultValue(1);
    fSetOpProcessVerboseCmd->SetRange("ver>=0");
    fSetOpProcessVerboseCmd->AvailableForStates(G4State_PreInit);

    
    fSetTrackSecondariesFirstCmd = new G4UIcommand("/process/optical/setTrackSecondariesFirst", this);
    fSetTrackSecondariesFirstCmd->SetGuidance("Activate/deactivate tracking of secondaries before finishing their parent track");
    par = new G4UIparameter("proc_name",'s',false);
    par->SetParameterCandidates(candidates);
    fSetTrackSecondariesFirstCmd->SetParameter(par);
    par = new G4UIparameter("flag",'b',false);
    par->SetDefaultValue(true);
    fSetTrackSecondariesFirstCmd->SetParameter(par);
    fSetTrackSecondariesFirstCmd->AvailableForStates(G4State_PreInit);

    //This are repetition of process specific ui commands needed by ATLICE and VMC
    //(UI messages needed to exist in PreInit state before actual processes are instantiated)
    fSetCerenkovMaxPhotonsCmd = new G4UIcmdWithAnInteger("/process/optical/defaults/cerenkov/setMaxPhotons", this);
    fSetCerenkovMaxPhotonsCmd->SetGuidance("Set default maximum number of photons per step");
    fSetCerenkovMaxPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
    fSetCerenkovMaxPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
    fSetCerenkovMaxPhotonsCmd->SetParameterName("CerenkovMaxPhotons", false);
    fSetCerenkovMaxPhotonsCmd->SetRange("CerenkovMaxPhotons>=0");
    fSetCerenkovMaxPhotonsCmd->AvailableForStates(G4State_PreInit);

    fSetCerenkovMaxBetaChangeCmd = new G4UIcmdWithADouble("/process/optical/defaults/cerenkov/setMaxBetaChange", this);
    fSetCerenkovMaxBetaChangeCmd->SetGuidance("Set default maximum change of beta of parent particle per step");
    fSetCerenkovMaxBetaChangeCmd->SetGuidance("Note this command is used to set the default value,");
    fSetCerenkovMaxBetaChangeCmd->SetGuidance("if process is not active command will not have effect.");
    fSetCerenkovMaxBetaChangeCmd->SetParameterName("CerenkovMaxBetaChange", false);
    fSetCerenkovMaxBetaChangeCmd->SetRange("CerenkovMaxBetaChange>=0");
    fSetCerenkovMaxBetaChangeCmd->AvailableForStates(G4State_PreInit);

    fSetCerenkovStackPhotonsCmd = new G4UIcmdWithABool("/process/optical/defaults/cerenkov/setStackPhotons", this);
    fSetCerenkovStackPhotonsCmd->SetGuidance("Set default whether or not to stack secondary Cerenkov photons");
    fSetCerenkovStackPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
    fSetCerenkovStackPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
    fSetCerenkovStackPhotonsCmd->SetParameterName("CerenkovStackPhotons", true);
    fSetCerenkovStackPhotonsCmd->AvailableForStates(G4State_PreInit);

    fSetScintillationYieldFactorCmd = new G4UIcmdWithADouble("/process/optical/defaults/scintillation/setYieldFactor", this);
    fSetScintillationYieldFactorCmd->SetGuidance("Set scintillation yield factor");
    fSetScintillationYieldFactorCmd->SetGuidance("Note this command is used to set the default value,");
    fSetScintillationYieldFactorCmd->SetGuidance("if process is not active command will not have effect.");
    fSetScintillationYieldFactorCmd->SetParameterName("ScintillationYieldFactor", false);
    fSetScintillationYieldFactorCmd->SetRange("ScintillationYieldFactor>=0");
    fSetScintillationYieldFactorCmd->AvailableForStates(G4State_PreInit, G4State_Idle);

    fSetScintillationByParticleTypeCmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setByParticleType", this);
    fSetScintillationByParticleTypeCmd->SetGuidance("Activate/Inactivate scintillation process by particle type");
    fSetScintillationByParticleTypeCmd->SetGuidance("Note this command is used to set the default value,");
    fSetScintillationByParticleTypeCmd->SetGuidance("if process is not active command will not have effect.");
    fSetScintillationByParticleTypeCmd->SetParameterName("ScintillationByParticleTypeActivation", false);
    fSetScintillationByParticleTypeCmd->AvailableForStates(G4State_PreInit);

    fSetScintillationTrackInfoCmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setTrackInfo", this);
    fSetScintillationTrackInfoCmd->SetGuidance("Activate/Inactivate scintillation TrackInformation");
    fSetScintillationTrackInfoCmd->SetParameterName("ScintillationTrackInfo", false);
    fSetScintillationTrackInfoCmd->AvailableForStates(G4State_PreInit);

    fSetFiniteRiseTimeCmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setFiniteRiseTime", this);
    fSetFiniteRiseTimeCmd->SetGuidance("Set option of a finite rise-time for G4Scintillation");
    fSetFiniteRiseTimeCmd->SetGuidance("If set, the G4Scintillation process expects the user to have set the constant material property FAST/SLOWSCINTILLATIONRISETIME");
    fSetFiniteRiseTimeCmd->SetGuidance("Note this command is used to set the default value,");
    fSetFiniteRiseTimeCmd->SetGuidance("if process is not active command will not have effect.");
    fSetFiniteRiseTimeCmd->SetParameterName("FiniteRiseTime", false);
    fSetFiniteRiseTimeCmd->AvailableForStates(G4State_PreInit);

    fSetScintillationStackPhotonsCmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setStackPhotons", this);
    fSetScintillationStackPhotonsCmd->SetGuidance("Set default whether or not to stack secondary Scintillation photons");
    fSetScintillationStackPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
    fSetScintillationStackPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
    fSetScintillationStackPhotonsCmd->SetParameterName("ScintillationStackPhotons", true);
    fSetScintillationStackPhotonsCmd->AvailableForStates(G4State_PreInit);

    fSetWLSTimeProfileCmd = new G4UIcmdWithAString("/process/optical/defaults/wls/setTimeProfile", this);
    fSetWLSTimeProfileCmd->SetGuidance("Set the WLS time profile (delta or exponential)");
    fSetWLSTimeProfileCmd->SetParameterName("WLSTimeProfile", false);
    fSetWLSTimeProfileCmd->SetCandidates("delta exponential");
    fSetWLSTimeProfileCmd->AvailableForStates(G4State_PreInit);

    fSetInvokeSDCmd = new G4UIcmdWithABool("/process/optical/defaults/boundary/setInvokeSD", this);
    fSetInvokeSDCmd->SetGuidance("Set option for calling InvokeSD in G4OpBoundaryProcess");
    fSetInvokeSDCmd->SetParameterName("InvokeSD", false);
    fSetInvokeSDCmd->AvailableForStates(G4State_PreInit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4OpticalPhysicsMessenger::~G4OpticalPhysicsMessenger ( )

virtual

Definition at line 193 of file G4OpticalPhysicsMessenger.cc.

{
// Destructor

  delete fDir;
  delete fDir2;
  delete fActivateProcessCmd;
  delete fSetOpProcessVerboseCmd;
  delete fSetCerenkovMaxPhotonsCmd;
  delete fSetCerenkovMaxBetaChangeCmd;
  delete fSetCerenkovStackPhotonsCmd;
  delete fSetScintillationYieldFactorCmd;
  delete fSetScintillationByParticleTypeCmd;
  delete fSetScintillationTrackInfoCmd;
  delete fSetScintillationStackPhotonsCmd;
  delete fSetWLSTimeProfileCmd;
  delete fSetTrackSecondariesFirstCmd;
  delete fSetFiniteRiseTimeCmd;
  delete fSetInvokeSDCmd;
}

Member Function Documentation

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

virtual

Apply command to the associated object.

Reimplemented from G4UImessenger.

Definition at line 215 of file G4OpticalPhysicsMessenger.cc.

{
  if (command == fActivateProcessCmd) {
    std::istringstream is(newValue.data());
    G4String pn;
    G4String flag;
    is >> pn >> flag;
    if  ( pn == "Cerenkov" )        {
        fSelectedProcessIndex = kCerenkov;
    } else if ( pn == "Scintillation" ) {
        fSelectedProcessIndex = kScintillation;
    } else if ( pn == "OpAbsorption" )  {
        fSelectedProcessIndex = kAbsorption;
    } else if ( pn == "OpRayleigh" )    {
        fSelectedProcessIndex = kRayleigh;
    } else if ( pn == "OpMieHG" )       {
        fSelectedProcessIndex = kMieHG;
    } else if ( pn == "OpBoundary" )    {
        fSelectedProcessIndex = kBoundary;
    } else if ( pn == "OpWLS" )         {
        fSelectedProcessIndex = kWLS;
    } else {
        G4ExceptionDescription msg;
        msg << "Not allowed process name: "<<pn<<" (UI: "<<newValue<<")";
        G4Exception("G4OpticalPhysicsMessenger::SetNewValue(...)","Optical001",FatalException,msg);
    }
    G4bool value = G4UIcommand::ConvertToBool(flag);
    fOpticalPhysics->Configure(fSelectedProcessIndex,value);
  }
  else if (command == fSetTrackSecondariesFirstCmd )
  {
      std::istringstream is(newValue.data());
      G4String pn;
      G4String flag;
      is >> pn >> flag;
      if ( pn == "Cerenkov" )        {
        fSelectedProcessIndex = kCerenkov;
      } else if ( pn == "Scintillation" ) {
        fSelectedProcessIndex = kScintillation;
      } else if ( pn == "OpAbsorption" )  {
        fSelectedProcessIndex = kAbsorption;
      } else if ( pn == "OpRayleigh" )    {
        fSelectedProcessIndex = kRayleigh;
      } else if ( pn == "OpMieHG" )       {
        fSelectedProcessIndex = kMieHG;
      } else if ( pn == "OpBoundary" )    {
        fSelectedProcessIndex = kBoundary;
      } else if ( pn == "OpWLS" )         {
        fSelectedProcessIndex = kWLS;
      } else {
          G4ExceptionDescription msg;
          msg << "Not allowed process name: "<<pn<<" (UI: "<<newValue<<")";
          G4Exception("G4OpticalPhysicsMessenger::SetNewValue(...)","Optical001",FatalException,msg);
      }
      G4bool value = G4UIcommand::ConvertToBool(flag);
      fOpticalPhysics->SetTrackSecondariesFirst(fSelectedProcessIndex,value);
  }
  else if (command == fSetOpProcessVerboseCmd) {
        fOpticalPhysics->SetVerboseLevel(fSetOpProcessVerboseCmd->GetNewIntValue(newValue));
  }
  else if (command == fSetCerenkovMaxPhotonsCmd) {
    fOpticalPhysics
      ->SetMaxNumPhotonsPerStep(
          fSetCerenkovMaxPhotonsCmd->GetNewIntValue(newValue));
  }
  else if (command == fSetCerenkovMaxBetaChangeCmd) {
    fOpticalPhysics
      ->SetMaxBetaChangePerStep(
          fSetCerenkovMaxBetaChangeCmd->GetNewDoubleValue(newValue));
  }
  else if (command == fSetCerenkovStackPhotonsCmd) {
    fOpticalPhysics
     ->SetCerenkovStackPhotons(
          fSetCerenkovStackPhotonsCmd->GetNewBoolValue(newValue));
  }
  else if (command == fSetScintillationYieldFactorCmd) {
    fOpticalPhysics
      ->SetScintillationYieldFactor(
          fSetScintillationYieldFactorCmd->GetNewDoubleValue(newValue));
  }
  else if (command == fSetScintillationByParticleTypeCmd) {
    fOpticalPhysics
      ->SetScintillationByParticleType(
         fSetScintillationByParticleTypeCmd->GetNewBoolValue(newValue));
  }
  else if (command == fSetScintillationTrackInfoCmd) {
    fOpticalPhysics
      ->SetScintillationTrackInfo(
         fSetScintillationTrackInfoCmd->GetNewBoolValue(newValue));
  }
  else if (command == fSetFiniteRiseTimeCmd) {
    fOpticalPhysics
      ->SetFiniteRiseTime(
         fSetFiniteRiseTimeCmd->GetNewBoolValue(newValue));
  }
  else if (command == fSetScintillationStackPhotonsCmd) {
    fOpticalPhysics
     ->SetScintillationStackPhotons(
          fSetScintillationStackPhotonsCmd->GetNewBoolValue(newValue));
  }
  else if (command == fSetWLSTimeProfileCmd) {
    fOpticalPhysics->SetWLSTimeProfile(newValue);
  }
  else if (command == fSetInvokeSDCmd) {
    fOpticalPhysics
      ->SetInvokeSD(fSetInvokeSDCmd->GetNewBoolValue(newValue));
  }
}

Here is the call 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/G4OpticalPhysicsMessenger.hh
• geant4.10.03.p01/source/physics_lists/constructors/electromagnetic/src/G4OpticalPhysicsMessenger.cc