CexmcEnergyDepositDigitizerMessenger Class Reference

#include <CexmcEnergyDepositDigitizerMessenger.hh>

Inheritance diagram for CexmcEnergyDepositDigitizerMessenger:

Collaboration diagram for CexmcEnergyDepositDigitizerMessenger:

Public Member Functions
	CexmcEnergyDepositDigitizerMessenger (CexmcEnergyDepositDigitizer *energyDepositDigitiser)
	~CexmcEnergyDepositDigitizerMessenger ()
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
G4bool	CommandsShouldBeInMaster () const

Private Attributes
CexmcEnergyDepositDigitizer *	energyDepositDigitizer
G4UIcmdWithADoubleAndUnit *	setMonitorThreshold
G4UIcmdWithADoubleAndUnit *	setVetoCountersThreshold
G4UIcmdWithADoubleAndUnit *	setLeftVetoCounterThreshold
G4UIcmdWithADoubleAndUnit *	setRightVetoCounterThreshold
G4UIcmdWithADoubleAndUnit *	setCalorimetersThreshold
G4UIcmdWithADoubleAndUnit *	setLeftCalorimeterThreshold
G4UIcmdWithADoubleAndUnit *	setRightCalorimeterThreshold
G4UIcmdWithAString *	setCalorimeterTriggerAlgorithm
G4UIcmdWithAString *	setOuterCrystalsVetoAlgorithm
G4UIcmdWithADouble *	setOuterCrystalsVetoFraction
G4UIcmdWithABool *	applyFiniteCrystalResolution
G4UIcmdWith3Vector *	addCrystalResolutionRange
G4UIcmdWithoutParameter *	clearCrystalResolutionData

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 59 of file CexmcEnergyDepositDigitizerMessenger.hh.

Constructor & Destructor Documentation

CexmcEnergyDepositDigitizerMessenger()

CexmcEnergyDepositDigitizerMessenger::CexmcEnergyDepositDigitizerMessenger ( CexmcEnergyDepositDigitizer *  energyDepositDigitiser )

explicit

Definition at line 56 of file CexmcEnergyDepositDigitizerMessenger.cc.

                                                                :
    energyDepositDigitizer( energyDepositDigitizer ),
    setMonitorThreshold( NULL ), setVetoCountersThreshold( NULL ),
    setLeftVetoCounterThreshold( NULL ), setRightVetoCounterThreshold( NULL ),
    setCalorimetersThreshold( NULL ), setLeftCalorimeterThreshold( NULL ),
    setRightCalorimeterThreshold( NULL ),
    setCalorimeterTriggerAlgorithm( NULL ),
    setOuterCrystalsVetoAlgorithm( NULL ), setOuterCrystalsVetoFraction( NULL ),
    applyFiniteCrystalResolution( NULL ), addCrystalResolutionRange( NULL ),
    clearCrystalResolutionData( NULL )
{
    setMonitorThreshold = new G4UIcmdWithADoubleAndUnit(
            ( CexmcMessenger::monitorEDDirName + "threshold" ).c_str(), this );
    setMonitorThreshold->SetGuidance( "Monitor trigger threshold" );
    setMonitorThreshold->SetParameterName( "MonitorThreshold", false );
    setMonitorThreshold->SetDefaultValue( 0 );
    setMonitorThreshold->SetUnitCandidates( "ev keV MeV GeV" );
    setMonitorThreshold->SetDefaultUnit( "MeV" );
    setMonitorThreshold->AvailableForStates( G4State_PreInit, G4State_Idle );

    setVetoCountersThreshold = new G4UIcmdWithADoubleAndUnit(
            ( CexmcMessenger::vetoCounterEDDirName + "threshold" ).c_str(),
            this );
    setVetoCountersThreshold->SetGuidance( "Veto counters trigger threshold" );
    setVetoCountersThreshold->SetParameterName( "VetoCountersThreshold",
                                                false );
    setVetoCountersThreshold->SetDefaultValue( 0 );
    setVetoCountersThreshold->SetUnitCandidates( "ev keV MeV GeV" );
    setVetoCountersThreshold->SetDefaultUnit( "MeV" );
    setVetoCountersThreshold->AvailableForStates( G4State_PreInit,
                                                  G4State_Idle );

    setLeftVetoCounterThreshold = new G4UIcmdWithADoubleAndUnit(
            ( CexmcMessenger::vetoCounterLeftEDDirName + "threshold" ).c_str(),
            this );
    setLeftVetoCounterThreshold->SetGuidance(
                                    "Left veto counter trigger threshold" );
    setLeftVetoCounterThreshold->SetParameterName( "LeftVetoCounterThreshold",
                                                   false );
    setLeftVetoCounterThreshold->SetDefaultValue( 0 );
    setLeftVetoCounterThreshold->SetUnitCandidates( "ev keV MeV GeV" );
    setLeftVetoCounterThreshold->SetDefaultUnit( "MeV" );
    setLeftVetoCounterThreshold->AvailableForStates( G4State_PreInit,
                                                     G4State_Idle );

    setRightVetoCounterThreshold = new G4UIcmdWithADoubleAndUnit(
            ( CexmcMessenger::vetoCounterRightEDDirName + "threshold" ).c_str(),
            this );
    setRightVetoCounterThreshold->SetGuidance(
                                    "Right veto counter trigger threshold" );
    setRightVetoCounterThreshold->SetParameterName( "RightVetoCounterThreshold",
                                                    false );
    setRightVetoCounterThreshold->SetDefaultValue( 0 );
    setRightVetoCounterThreshold->SetUnitCandidates( "ev keV MeV GeV" );
    setRightVetoCounterThreshold->SetDefaultUnit( "MeV" );
    setRightVetoCounterThreshold->AvailableForStates( G4State_PreInit,
                                                      G4State_Idle );

    setCalorimetersThreshold = new G4UIcmdWithADoubleAndUnit(
            ( CexmcMessenger::calorimeterEDDirName + "threshold" ).c_str(),
            this );
    setCalorimetersThreshold->SetGuidance( "Calorimeters trigger threshold" );
    setCalorimetersThreshold->SetParameterName( "CalorimetersThreshold",
                                                false );
    setCalorimetersThreshold->SetDefaultValue( 0 );
    setCalorimetersThreshold->SetUnitCandidates( "ev keV MeV GeV" );
    setCalorimetersThreshold->SetDefaultUnit( "MeV" );
    setCalorimetersThreshold->AvailableForStates( G4State_PreInit,
                                                  G4State_Idle );

    setLeftCalorimeterThreshold = new G4UIcmdWithADoubleAndUnit(
            ( CexmcMessenger::calorimeterLeftEDDirName + "threshold" ).c_str(),
            this );
    setLeftCalorimeterThreshold->SetGuidance(
                                    "Left calorimeter trigger threshold" );
    setLeftCalorimeterThreshold->SetParameterName( "LeftCalorimeterThreshold",
                                                   false );
    setLeftCalorimeterThreshold->SetDefaultValue( 0 );
    setLeftCalorimeterThreshold->SetUnitCandidates( "ev keV MeV GeV" );
    setLeftCalorimeterThreshold->SetDefaultUnit( "MeV" );
    setLeftCalorimeterThreshold->AvailableForStates( G4State_PreInit,
                                                     G4State_Idle );

    setRightCalorimeterThreshold = new G4UIcmdWithADoubleAndUnit(
            ( CexmcMessenger::calorimeterRightEDDirName + "threshold" ).c_str(),
            this );
    setRightCalorimeterThreshold->SetGuidance(
                                    "Right calorimeter trigger threshold" );
    setRightCalorimeterThreshold->SetParameterName( "RightCalorimeterThreshold",
                                                    false );
    setRightCalorimeterThreshold->SetDefaultValue( 0 );
    setRightCalorimeterThreshold->SetUnitCandidates( "ev keV MeV GeV" );
    setRightCalorimeterThreshold->SetDefaultUnit( "MeV" );
    setRightCalorimeterThreshold->AvailableForStates( G4State_PreInit,
                                                      G4State_Idle );

    setCalorimeterTriggerAlgorithm = new G4UIcmdWithAString(
            ( CexmcMessenger::detectorDirName +
              "calorimeterTriggerAlgorithm" ).c_str(), this );
    setCalorimeterTriggerAlgorithm->SetGuidance( "\n"
                "    all - energy deposit in all crystals in a calorimeter\n"
                "          will be checked against calorimeter threshold "
                          "value,\n"
                "    inner - energy deposit in only inner crystals\n"
                "            will be checked against calorimeter threshold "
                            "value" );
    setCalorimeterTriggerAlgorithm->SetParameterName(
                                        "CalorimeterTriggerAlgorithm", false );
    setCalorimeterTriggerAlgorithm->SetCandidates( "all inner" );
    setCalorimeterTriggerAlgorithm->SetDefaultValue( "inner" );
    setCalorimeterTriggerAlgorithm->AvailableForStates( G4State_PreInit,
                                                        G4State_Idle );

    setOuterCrystalsVetoAlgorithm = new G4UIcmdWithAString(
            ( CexmcMessenger::detectorDirName +
              "outerCrystalsVetoAlgorithm" ).c_str(), this );
    setOuterCrystalsVetoAlgorithm->SetGuidance( "\n"
                "    none - events will not be rejected by any algorithm,\n"
                "    max - reject event trigger if crystal with maximum energy "
                    "\n          deposit is one of outer crystals,\n"
                "    fraction - reject event trigger if energy deposit "
                    "fraction in\n               outer crystals is more than "
                    "value of\n               'outerCrystalsVetoFraction'" );
    setOuterCrystalsVetoAlgorithm->SetParameterName(
                                        "OuterCrystalsVetoAlgorithm", false );
    setOuterCrystalsVetoAlgorithm->SetCandidates( "none max fraction" );
    setOuterCrystalsVetoAlgorithm->SetDefaultValue( "none" );
    setOuterCrystalsVetoAlgorithm->AvailableForStates( G4State_PreInit,
                                                       G4State_Idle );

    setOuterCrystalsVetoFraction = new G4UIcmdWithADouble(
            ( CexmcMessenger::detectorDirName +
              "outerCrystalsVetoFraction" ).c_str(), this );
    setOuterCrystalsVetoFraction->SetGuidance( "\n    Fraction of whole energy "
            "deposit in one calorimeter\n    that belongs to outer crystals.\n"
            "    If 'outerCrystalsVetoAlgorithm' is 'fraction' and\n"
            "    the outer crystals energy deposit fraction exceeds "
                "this\n    value then event won't trigger" );
    setOuterCrystalsVetoFraction->SetParameterName(
                                        "OuterCrystalsVetoFraction", false );
    setOuterCrystalsVetoFraction->SetDefaultValue( 0 );
    setOuterCrystalsVetoFraction->AvailableForStates( G4State_PreInit,
                                                      G4State_Idle );

    applyFiniteCrystalResolution = new G4UIcmdWithABool(
            ( CexmcMessenger::detectorDirName +
              "applyFiniteCrystalResolution" ).c_str(), this );
    applyFiniteCrystalResolution->SetGuidance( "\n     Specify if finite "
            "energy resolution of the crystals\n     will be accounted" );
    applyFiniteCrystalResolution->SetParameterName(
                                        "ApplyFiniteCrystalResolution", true );
    applyFiniteCrystalResolution->SetDefaultValue( true );
    applyFiniteCrystalResolution->AvailableForStates( G4State_PreInit,
                                                      G4State_Idle );

    addCrystalResolutionRange = new G4UIcmdWith3Vector(
            ( CexmcMessenger::detectorDirName +
              "addCrystalResolutionRange" ).c_str(), this );
    addCrystalResolutionRange->SetGuidance( "\n     Add new energy range "
            "(in GeV!) with fwhm percentage\n     value of crystal resolution "
            "in this range" );
    addCrystalResolutionRange->SetParameterName(
            "CrystalResolutionRangeBottom", "CrystalResolutionRangeTop",
            "CrystalResolutionRangeValue", false );
    addCrystalResolutionRange->SetRange( "CrystalResolutionRangeBottom >= 0. "
            "&& CrystalResolutionRangeTop >= 0. && "
            "CrystalResolutionRangeValue >= 0." );
    addCrystalResolutionRange->AvailableForStates( G4State_PreInit,
                                                   G4State_Idle );

    clearCrystalResolutionData = new G4UIcmdWithoutParameter(
            ( CexmcMessenger::detectorDirName +
              "clearCrystalResolutionData" ).c_str(), this );
    clearCrystalResolutionData->SetGuidance( "\n     Clear all crystal "
              "resolution ranges.\n     Can be used to redefine crystal "
              "resolution data" );
    clearCrystalResolutionData->AvailableForStates( G4State_PreInit,
                                                    G4State_Idle );
}

Here is the call graph for this function:

~CexmcEnergyDepositDigitizerMessenger()

CexmcEnergyDepositDigitizerMessenger::~CexmcEnergyDepositDigitizerMessenger

(

)

Definition at line 238 of file CexmcEnergyDepositDigitizerMessenger.cc.

{
    delete setMonitorThreshold;
    delete setVetoCountersThreshold;
    delete setLeftVetoCounterThreshold;
    delete setRightVetoCounterThreshold;
    delete setCalorimetersThreshold;
    delete setLeftCalorimeterThreshold;
    delete setRightCalorimeterThreshold;
    delete setCalorimeterTriggerAlgorithm;
    delete setOuterCrystalsVetoAlgorithm;
    delete setOuterCrystalsVetoFraction;
    delete applyFiniteCrystalResolution;
    delete addCrystalResolutionRange;
    delete clearCrystalResolutionData;
}

Member Function Documentation

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 256 of file CexmcEnergyDepositDigitizerMessenger.cc.

{
    do
    {
        if ( cmd == setMonitorThreshold )
        {
            energyDepositDigitizer->SetMonitorThreshold(
                        G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
            break;
        }
        if ( cmd == setVetoCountersThreshold )
        {
            energyDepositDigitizer->SetVetoCountersThreshold(
                        G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
            break;
        }
        if ( cmd == setLeftVetoCounterThreshold )
        {
            energyDepositDigitizer->SetVetoCounterLeftThreshold(
                        G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
            break;
        }
        if ( cmd == setRightVetoCounterThreshold )
        {
            energyDepositDigitizer->SetVetoCounterRightThreshold(
                        G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
            break;
        }
        if ( cmd == setCalorimetersThreshold )
        {
            energyDepositDigitizer->SetCalorimetersThreshold(
                        G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
            break;
        }
        if ( cmd == setLeftCalorimeterThreshold )
        {
            energyDepositDigitizer->SetCalorimeterLeftThreshold(
                        G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
            break;
        }
        if ( cmd == setRightCalorimeterThreshold )
        {
            energyDepositDigitizer->SetCalorimeterRightThreshold(
                        G4UIcmdWithADoubleAndUnit::GetNewDoubleValue( value ) );
            break;
        }
        if ( cmd == setCalorimeterTriggerAlgorithm )
        {
            CexmcCalorimeterTriggerAlgorithm  calorimeterTriggerAlgorithm(
                                    CexmcAllCrystalsMakeEDTriggerThreshold );
            do
            {
                if ( value == "inner" )
                {
                    calorimeterTriggerAlgorithm =
                                    CexmcInnerCrystalsMakeEDTriggerThreshold;
                    break;
                }
            } while ( false );
            energyDepositDigitizer->SetCalorimeterTriggerAlgorithm(
                                                calorimeterTriggerAlgorithm );
            break;
        }
        if ( cmd == setOuterCrystalsVetoAlgorithm )
        {
            CexmcOuterCrystalsVetoAlgorithm  outerCrystalsVetoAlgorithm(
                                                    CexmcNoOuterCrystalsVeto );
            do
            {
                if ( value == "max" )
                {
                    outerCrystalsVetoAlgorithm =
                                        CexmcMaximumEDInASingleOuterCrystalVeto;
                    break;
                }
                if ( value == "fraction" )
                {
                    outerCrystalsVetoAlgorithm =
                                        CexmcFractionOfEDInOuterCrystalsVeto;
                    break;
                }
            } while ( false );
            energyDepositDigitizer->SetOuterCrystalsVetoAlgorithm(
                                                outerCrystalsVetoAlgorithm );
            break;
        }
        if ( cmd == setOuterCrystalsVetoFraction )
        {
            energyDepositDigitizer->SetOuterCrystalsVetoFraction(
                        G4UIcmdWithADouble::GetNewDoubleValue( value ) );
            break;
        }
        if ( cmd == applyFiniteCrystalResolution )
        {
            energyDepositDigitizer->ApplyFiniteCrystalResolution(
                        G4UIcmdWithABool::GetNewBoolValue( value ) );
            break;
        }
        if ( cmd == addCrystalResolutionRange )
        {
            G4ThreeVector  vec( G4UIcmdWith3Vector::GetNew3VectorValue(
                                                                    value ) );
            G4double       bottom( std::min( vec.x(), vec.y() ) );
            G4double       top( std::max( vec.x(), vec.y() ) );
            energyDepositDigitizer->AddCrystalResolutionRange( bottom, top,
                                                               vec.z() );
            break;
        }
        if ( cmd == clearCrystalResolutionData )
        {
            energyDepositDigitizer->ClearCrystalResolutionData();
            break;
        }
    } while ( false );
}

Here is the call graph for this function:

Member Data Documentation

addCrystalResolutionRange

G4UIcmdWith3Vector* CexmcEnergyDepositDigitizerMessenger::addCrystalResolutionRange

private

Definition at line 95 of file CexmcEnergyDepositDigitizerMessenger.hh.

applyFiniteCrystalResolution

G4UIcmdWithABool* CexmcEnergyDepositDigitizerMessenger::applyFiniteCrystalResolution

private

Definition at line 93 of file CexmcEnergyDepositDigitizerMessenger.hh.

clearCrystalResolutionData

G4UIcmdWithoutParameter* CexmcEnergyDepositDigitizerMessenger::clearCrystalResolutionData

private

Definition at line 97 of file CexmcEnergyDepositDigitizerMessenger.hh.

energyDepositDigitizer

CexmcEnergyDepositDigitizer* CexmcEnergyDepositDigitizerMessenger::energyDepositDigitizer

private

Definition at line 71 of file CexmcEnergyDepositDigitizerMessenger.hh.

setCalorimetersThreshold

G4UIcmdWithADoubleAndUnit* CexmcEnergyDepositDigitizerMessenger::setCalorimetersThreshold

private

Definition at line 81 of file CexmcEnergyDepositDigitizerMessenger.hh.

setCalorimeterTriggerAlgorithm

G4UIcmdWithAString* CexmcEnergyDepositDigitizerMessenger::setCalorimeterTriggerAlgorithm

private

Definition at line 87 of file CexmcEnergyDepositDigitizerMessenger.hh.

setLeftCalorimeterThreshold

G4UIcmdWithADoubleAndUnit* CexmcEnergyDepositDigitizerMessenger::setLeftCalorimeterThreshold

private

Definition at line 83 of file CexmcEnergyDepositDigitizerMessenger.hh.

setLeftVetoCounterThreshold

G4UIcmdWithADoubleAndUnit* CexmcEnergyDepositDigitizerMessenger::setLeftVetoCounterThreshold

private

Definition at line 77 of file CexmcEnergyDepositDigitizerMessenger.hh.

setMonitorThreshold

G4UIcmdWithADoubleAndUnit* CexmcEnergyDepositDigitizerMessenger::setMonitorThreshold

private

Definition at line 73 of file CexmcEnergyDepositDigitizerMessenger.hh.

setOuterCrystalsVetoAlgorithm

G4UIcmdWithAString* CexmcEnergyDepositDigitizerMessenger::setOuterCrystalsVetoAlgorithm

private

Definition at line 89 of file CexmcEnergyDepositDigitizerMessenger.hh.

setOuterCrystalsVetoFraction

G4UIcmdWithADouble* CexmcEnergyDepositDigitizerMessenger::setOuterCrystalsVetoFraction

private

Definition at line 91 of file CexmcEnergyDepositDigitizerMessenger.hh.

setRightCalorimeterThreshold

G4UIcmdWithADoubleAndUnit* CexmcEnergyDepositDigitizerMessenger::setRightCalorimeterThreshold

private

Definition at line 85 of file CexmcEnergyDepositDigitizerMessenger.hh.

setRightVetoCounterThreshold

G4UIcmdWithADoubleAndUnit* CexmcEnergyDepositDigitizerMessenger::setRightVetoCounterThreshold

private

Definition at line 79 of file CexmcEnergyDepositDigitizerMessenger.hh.

setVetoCountersThreshold

G4UIcmdWithADoubleAndUnit* CexmcEnergyDepositDigitizerMessenger::setVetoCountersThreshold

private

Definition at line 75 of file CexmcEnergyDepositDigitizerMessenger.hh.

---

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

• CexmcEnergyDepositDigitizerMessenger.hh
• CexmcEnergyDepositDigitizerMessenger.cc