UIhelpers Namespace Reference

Functions
template<class T >
void	buildCommands (T *proc, const char *dir, const char *guidance)
void	buildCommands (G4OpWLS *op)
void	buildCommands (G4Scintillation *ScintillationProcess)
void	buildCommands (G4Cerenkov *CerenkovProcess)

Function Documentation

template<class T >

void UIhelpers::buildCommands	(	T *	proc,
		const char *	dir,
		const char *	guidance
	)

Definition at line 157 of file G4OpticalPhysics.cc.

    {
        //Generic function to add a "verbose" command for a process
        G4GenericMessenger* mess = new G4GenericMessenger(proc,dir,guidance);
        G4AutoDelete::Register(mess);
        G4GenericMessenger::Command& wlscmd4 = mess->DeclareMethod("verbose",&T::SetVerboseLevel,
                                                                   "Set the verbose level");
        wlscmd4.SetParameterName("ver",true);
        wlscmd4.SetDefaultValue("1");
        wlscmd4.SetStates(G4State_Idle);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void UIhelpers::buildCommands

(

G4OpWLS *

op

)

Definition at line 169 of file G4OpticalPhysics.cc.

    {
        //Build UI commands for WLS
        G4GenericMessenger* mess = new G4GenericMessenger(op,DIR_CMDS"/wls/",GUIDANCE" for WLS process.");
        G4AutoDelete::Register(mess);
        //Here, more correctly DeclareProperty should be used, but to do that, I would need public/friend
        //access of G4GenericMessenger to private members of G4Scintillation. Thus I use the approach
        //of DeclareMethod, that has a draw back: range checking does not work
        G4GenericMessenger::Command& wlscmd1 = mess->DeclareMethod("setTimeProfile",&G4OpWLS::UseTimeProfile,
                                                                   "Set the WLS time profile (delta or exponential)");
        wlscmd1.SetParameterName("profile",false);
        wlscmd1.SetCandidates("delta exponential");
        wlscmd1.SetStates(G4State_Idle);
        buildCommands(op,DIR_CMDS"/wls/",GUIDANCE" for WLS process.");
    }

Here is the call graph for this function:

void UIhelpers::buildCommands

(

G4Scintillation *

ScintillationProcess

)

Definition at line 185 of file G4OpticalPhysics.cc.

    {
        //Build UI commands for scintillation
        G4GenericMessenger* mess = new G4GenericMessenger(ScintillationProcess,DIR_CMDS"/scintillation/",GUIDANCE" for scintillation process.");
        G4AutoDelete::Register(mess);
        G4GenericMessenger::Command& sccmd1 = mess->DeclareMethod("setFiniteRiseTime",
                                                                  &G4Scintillation::SetFiniteRiseTime,
                                                                  "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");
        sccmd1.SetParameterName("time",false);
        sccmd1.SetStates(G4State_Idle);
        
        G4GenericMessenger::Command& sccmd2 = mess->DeclareMethod("setYieldFactor",
                                                                  &G4Scintillation::SetScintillationYieldFactor,
                                                                  "Set scintillation yield factor");
        sccmd2.SetParameterName("factor",false);
        //sccmd2.SetRange("factor>=0."); //LIMITATION: w/ DeclareMethod range checking does not work
        sccmd2.SetStates(G4State_Idle);
        
        G4GenericMessenger::Command& sccmd3 = mess->DeclareMethod("setExcitationRatio",
                                                                  &G4Scintillation::SetScintillationExcitationRatio,
                                                                  "Set scintillation excitation ratio");
        sccmd3.SetParameterName("ratio",false);
        //sccmd3.SetRange("ratio>=0.&&ratio<=1.");//LIMITATION: w/ DeclareMethod range checking does not work
        sccmd3.SetStates(G4State_Idle);

        G4GenericMessenger::Command& sccmd4 = mess->DeclareMethod("setByParticleType",
                                                                  &G4Scintillation::SetScintillationByParticleType,
                                                                  "Activate/Inactivate scintillation process by particle type");
        sccmd4.SetParameterName("flag", false);
        sccmd4.SetStates(G4State_Idle);

        G4GenericMessenger::Command& sccmd5 = mess->DeclareMethod("setTrackInfo",
                                                                  &G4Scintillation::SetScintillationTrackInfo,
                                                                  "Activate/Inactivate scintillation track info");
        sccmd5.SetParameterName("flag", false);
        sccmd5.SetStates(G4State_Idle);
        
        G4GenericMessenger::Command& sccmd6 = mess->DeclareMethod("setTrackSecondariesFirst",
                                                                  &G4Scintillation::SetTrackSecondariesFirst,
                                                                  "Set option to track secondaries before finishing their parent track");
        sccmd6.SetParameterName("flag",false);
        sccmd6.SetStates(G4State_Idle);
        
        buildCommands(ScintillationProcess,DIR_CMDS"/scintillation/",GUIDANCE" for scintillation process.");
    }

Here is the call graph for this function:

void UIhelpers::buildCommands

(

G4Cerenkov *

CerenkovProcess

)

Definition at line 231 of file G4OpticalPhysics.cc.

    {
        //BUild UI commands for cerenkov
        G4GenericMessenger* mess = new G4GenericMessenger(CerenkovProcess,DIR_CMDS"/cerenkov/",GUIDANCE" for Cerenkov process.");
        G4AutoDelete::Register(mess);
        G4GenericMessenger::Command& cecmd1 = mess->DeclareMethod("setMaxPhotons",
                                                                  &G4Cerenkov::SetMaxNumPhotonsPerStep,
                                                                  "Set maximum number of photons per step");
        cecmd1.SetParameterName("max",false);
        //cecmd1.SetRange("max>=0");//LIMITATION: w/ DeclareMethod range checking does not work
        cecmd1.SetStates(G4State_Idle);
        
        G4GenericMessenger::Command& cecmd2 = mess->DeclareMethod("setMaxBetaChange",
                                                                  &G4Cerenkov::SetMaxBetaChangePerStep,
                                                                  "Set maximum change of beta of parent particle per step");
        cecmd2.SetParameterName("max",false);
        //cecmd2.SetRange("max>=0.");//LIMITATION: w/ DeclareMethod range checking does not work
        cecmd2.SetStates(G4State_Idle);
        
        G4GenericMessenger::Command& cecmd3 = mess->DeclareMethod("setTrackSecondariesFirst",
                                                                  &G4Cerenkov::SetTrackSecondariesFirst,
                                                                  "Set option to track secondaries before finishing their parent track");
        cecmd3.SetParameterName("flag",false);
        cecmd3.SetStates(G4State_Idle);
        
        buildCommands(CerenkovProcess,DIR_CMDS"/cerenkov/",GUIDANCE" for Cerenkov process.");
    }

Here is the call graph for this function: