CexmcRunManagerMessenger Class Reference

#include <CexmcRunManagerMessenger.hh>

Inheritance diagram for CexmcRunManagerMessenger:

Public Member Functions
	CexmcRunManagerMessenger (CexmcRunManager *runManager)
	~CexmcRunManagerMessenger ()
void	SetNewValue (G4UIcommand *cmd, G4String value)
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 57 of file CexmcRunManagerMessenger.hh.

Constructor & Destructor Documentation

CexmcRunManagerMessenger::CexmcRunManagerMessenger ( CexmcRunManager *  runManager )

explicit

Definition at line 53 of file CexmcRunManagerMessenger.cc.

References G4UIcommand::AvailableForStates(), G4State_Idle, G4State_PreInit, CexmcMessenger::geometryDirName, CexmcMessenger::physicsDirName, CexmcMessenger::runDirName, G4UIcmdWithAString::SetCandidates(), G4UIcmdWithAString::SetDefaultValue(), G4UIcmdWithABool::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcmdWithAString::SetParameterName(), G4UIcmdWithABool::SetParameterName(), and CexmcMessenger::visDirName.

                                                                :
    runManager( runManager ), setProductionModel( NULL ), setGdmlFile( NULL ),
    setGuiMacro( NULL ), setEventCountPolicy( NULL ),
    setEventDataVerboseLevel( NULL ),
#ifdef CEXMC_USE_PERSISTENCY
    replayEvents( NULL ), seekTo( NULL ), skipInteractionsWithoutEDT( NULL ), 
#endif
    registerScenePrimitives( NULL ), validateGdmlFile( NULL )
{
    setProductionModel = new G4UIcmdWithAString(
        ( CexmcMessenger::physicsDirName + "productionModel" ).c_str(), this );
    setProductionModel->SetGuidance( "Set production model (e.g. pi0 or eta)" );
    setProductionModel->SetParameterName( "ProductionModel", false );
    setProductionModel->SetCandidates( "pi0 eta" );
    setProductionModel->AvailableForStates( G4State_PreInit );

    setGdmlFile = new G4UIcmdWithAString(
        ( CexmcMessenger::geometryDirName + "gdmlFile" ).c_str(), this );
    setGdmlFile->SetGuidance( "GDML file to read geometry from" );
    setGdmlFile->SetParameterName( "GdmlFile", false );
    setGdmlFile->AvailableForStates( G4State_PreInit );

    setGuiMacro = new G4UIcmdWithAString(
        ( CexmcMessenger::runDirName + "guiMacro" ).c_str(), this );
    setGuiMacro->SetGuidance( "Set Gui macro file" );
    setGuiMacro->SetParameterName( "GuiMacro", false );
    setGuiMacro->AvailableForStates( G4State_PreInit, G4State_Idle );

    setEventCountPolicy = new G4UIcmdWithAString(
        ( CexmcMessenger::runDirName + "eventCountPolicy" ).c_str(), this );
    setEventCountPolicy->SetGuidance( "How number of events is interpreted.\n"
            "    all - all events are accounted,\n"
            "    interaction - events with studied interaction triggered,\n"
            "    trigger - only events with trigger" );
    setEventCountPolicy->SetParameterName( "EventCountPolicy", false );
    setEventCountPolicy->SetCandidates( "all interaction trigger" );
    setEventCountPolicy->SetDefaultValue( "all" );
    setEventCountPolicy->AvailableForStates( G4State_PreInit, G4State_Idle );

    setEventDataVerboseLevel = new G4UIcmdWithAString(
        ( CexmcMessenger::runDirName + "eventDataVerboseLevel" ).c_str(),
        this );
    setEventDataVerboseLevel->SetGuidance( "When events will be saved.\n"
            "    nosave - never,\n"
            "    trigger - when energy deposit triggered (EDT),\n"
            "    interaction - when studied interaction triggered (TPT)" );
    setEventDataVerboseLevel->SetParameterName( "EventDataVerboseLevel",
                                                false );
    setEventDataVerboseLevel->SetCandidates( "nosave trigger interaction" );
    setEventDataVerboseLevel->SetDefaultValue( "trigger" );
    setEventDataVerboseLevel->AvailableForStates( G4State_PreInit,
                                                  G4State_Idle );

#ifdef CEXMC_USE_PERSISTENCY
    replayEvents = new G4UIcmdWithAnInteger(
        ( CexmcMessenger::runDirName + "replay" ).c_str(), this );
    replayEvents->SetGuidance( "Replay specified number of events "
           "\n    (available only if a project is read)."
           "\n    If number of events is 0 (or not specified) then all"
           "\n    run will be replayed" );
    replayEvents->SetParameterName( "ReplayEvents", true );
    replayEvents->SetRange( "ReplayEvents >= 0" );
    replayEvents->SetDefaultValue( 0 );
    replayEvents->AvailableForStates( G4State_PreInit, G4State_Idle );

    seekTo = new G4UIcmdWithAnInteger(
        ( CexmcMessenger::runDirName + "seekto" ).c_str(), this );
    seekTo->SetGuidance( "Seek to specified event id "
           "(available only if a project is read)."
           "\n    'seekto 0' brings to the start of run, 'seekto 4' - to the"
           "\n    first recorded event with interaction after fourth recorded"
           "\n    event with trigger" );
    seekTo->SetParameterName( "SeekTo", false );
    seekTo->SetRange( "SeekTo >= 0" );
    seekTo->SetDefaultValue( 0 );
    seekTo->AvailableForStates( G4State_PreInit, G4State_Idle );

    skipInteractionsWithoutEDT = new G4UIcmdWithABool(
        ( CexmcMessenger::runDirName + "skipInteractionsWithoutEDT" ).c_str(),
        this );
    skipInteractionsWithoutEDT->SetGuidance( "Do not write interactions into "
        ".fdb file\n    if event was not triggered (effective only when a "
        "project is read and then\n    written to another project and only if "
        "event data verbose level is\n    'trigger')" );
    skipInteractionsWithoutEDT->SetParameterName( "skipInteractionsWithoutEDT",
                                                  true );
    skipInteractionsWithoutEDT->SetDefaultValue( true );
    skipInteractionsWithoutEDT->AvailableForStates( G4State_PreInit,
                                                    G4State_Idle );
#endif

    registerScenePrimitives = new G4UIcmdWithoutParameter(
        ( CexmcMessenger::visDirName + "registerScenePrimitives" ).c_str(),
        this );
    registerScenePrimitives->SetGuidance( "Register custom scene primitives "
        "(radial lines,\n    inner crystals highlights etc.)" );
    registerScenePrimitives->AvailableForStates( G4State_PreInit,
                                                 G4State_Idle );

    validateGdmlFile = new G4UIcmdWithABool(
        ( CexmcMessenger::geometryDirName + "validateGdmlFile" ).c_str(),
        this );
    validateGdmlFile->SetGuidance( "If GDML file will be validated or not" );
    validateGdmlFile->SetParameterName( "ValidateGdmlFile", true );
    validateGdmlFile->SetDefaultValue( true );
    validateGdmlFile->AvailableForStates( G4State_PreInit );
}

CexmcRunManagerMessenger::~CexmcRunManagerMessenger

(

)

Definition at line 163 of file CexmcRunManagerMessenger.cc.

{
    delete setProductionModel;
    delete setGdmlFile;
    delete setGuiMacro;
    delete setEventCountPolicy;
    delete setEventDataVerboseLevel;
#ifdef CEXMC_USE_PERSISTENCY
    delete replayEvents;
    delete seekTo;
    delete skipInteractionsWithoutEDT;
#endif
    delete registerScenePrimitives;
    delete validateGdmlFile;
}

Member Function Documentation

void CexmcRunManagerMessenger::SetNewValue ( G4UIcommand *  cmd, G4String  value  )

virtual

Reimplemented from G4UImessenger.

Definition at line 180 of file CexmcRunManagerMessenger.cc.

References CexmcCountAllEvents, CexmcCountEventsWithInteraction, CexmcCountEventsWithTrigger, CexmcEtaProduction, CexmcPionZeroProduction, CexmcUnknownProductionModel, CexmcWriteEventDataOnEveryEDT, CexmcWriteEventDataOnEveryTPT, CexmcWriteNoEventData, G4UIcmdWithABool::GetNewBoolValue(), G4UIcmdWithAnInteger::GetNewIntValue(), CexmcRunManager::RegisterScenePrimitives(), CexmcRunManager::SetEventCountPolicy(), CexmcRunManager::SetEventDataVerboseLevel(), CexmcRunManager::SetGdmlFileName(), CexmcRunManager::SetGdmlFileValidation(), CexmcRunManager::SetGuiMacroName(), and CexmcRunManager::SetProductionModelType().

{
    do
    {
        if ( cmd == setProductionModel )
        {
            CexmcProductionModelType  productionModelType(
                                                CexmcUnknownProductionModel );
            do
            {
                if ( value == "pi0" )
                {
                    productionModelType = CexmcPionZeroProduction;
                    break;
                }
                if ( value == "eta" )
                {
                    productionModelType = CexmcEtaProduction;
                    break;
                }
            } while ( false );
            runManager->SetProductionModelType( productionModelType );
            break;
        }
        if ( cmd == setGdmlFile )
        {
            runManager->SetGdmlFileName( value );
            break;
        }
        if ( cmd == setGuiMacro )
        {
            runManager->SetGuiMacroName( value );
            break;
        }
        if ( cmd == setEventCountPolicy )
        {
            CexmcEventCountPolicy  eventCountPolicy( CexmcCountAllEvents );
            do
            {
                if ( value == "interaction" )
                {
                    eventCountPolicy = CexmcCountEventsWithInteraction;
                    break;
                }
                if ( value == "trigger" )
                {
                    eventCountPolicy = CexmcCountEventsWithTrigger;
                    break;
                }
            } while ( false );
            runManager->SetEventCountPolicy( eventCountPolicy );
            break;
        }
        if ( cmd == setEventDataVerboseLevel )
        {
            CexmcEventDataVerboseLevel  eventDataVerboseLevel(
                                                CexmcWriteEventDataOnEveryEDT );
            do
            {
                if ( value == "nosave" )
                {
                    eventDataVerboseLevel = CexmcWriteNoEventData;
                    break;
                }
                if ( value == "trigger" )
                {
                    eventDataVerboseLevel = CexmcWriteEventDataOnEveryEDT;
                    break;
                }
                if ( value == "interaction" )
                {
                    eventDataVerboseLevel = CexmcWriteEventDataOnEveryTPT;
                    break;
                }
            } while ( false );
            runManager->SetEventDataVerboseLevel( eventDataVerboseLevel );
            break;
        }
#ifdef CEXMC_USE_PERSISTENCY
        if ( cmd == replayEvents )
        {
            runManager->ReplayEvents(
                                G4UIcmdWithAnInteger::GetNewIntValue( value ) );
            break;
        }
        if ( cmd == seekTo )
        {
            runManager->SeekTo( G4UIcmdWithAnInteger::GetNewIntValue( value ) );
            break;
        }
        if ( cmd == skipInteractionsWithoutEDT )
        {
            runManager->SkipInteractionsWithoutEDTonWrite(
                                G4UIcmdWithABool::GetNewBoolValue( value ) );
            break;
        }
#endif
        if ( cmd == registerScenePrimitives )
        {
            runManager->RegisterScenePrimitives();
            break;
        }
        if ( cmd == validateGdmlFile )
        {
            runManager->SetGdmlFileValidation(
                                G4UIcmdWithABool::GetNewBoolValue( value ) );
            break;
        }
    } while ( false );
}

---

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

• CexmcRunManagerMessenger.hh
• CexmcRunManagerMessenger.cc