CexmcEnergyDepositDigitizerMessenger Class Reference

#include <CexmcEnergyDepositDigitizerMessenger.hh>

Inheritance 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

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

Constructor & Destructor Documentation

CexmcEnergyDepositDigitizerMessenger::CexmcEnergyDepositDigitizerMessenger ( CexmcEnergyDepositDigitizer *  energyDepositDigitiser )

explicit

Definition at line 56 of file CexmcEnergyDepositDigitizerMessenger.cc.

References G4UIcommand::AvailableForStates(), CexmcMessenger::calorimeterEDDirName, CexmcMessenger::calorimeterLeftEDDirName, CexmcMessenger::calorimeterRightEDDirName, CexmcMessenger::detectorDirName, G4State_Idle, G4State_PreInit, CexmcMessenger::monitorEDDirName, G4UIcmdWithAString::SetCandidates(), G4UIcmdWithADoubleAndUnit::SetDefaultUnit(), G4UIcmdWithADouble::SetDefaultValue(), G4UIcmdWithAString::SetDefaultValue(), G4UIcmdWithABool::SetDefaultValue(), G4UIcmdWithADoubleAndUnit::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcmdWithAString::SetParameterName(), G4UIcmdWithADouble::SetParameterName(), G4UIcmdWith3Vector::SetParameterName(), G4UIcmdWithABool::SetParameterName(), G4UIcmdWithADoubleAndUnit::SetParameterName(), G4UIcommand::SetRange(), G4UIcmdWithADoubleAndUnit::SetUnitCandidates(), CexmcMessenger::vetoCounterEDDirName, CexmcMessenger::vetoCounterLeftEDDirName, and CexmcMessenger::vetoCounterRightEDDirName.

                                                                :
    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 );
}

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

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

virtual

Reimplemented from G4UImessenger.

Definition at line 256 of file CexmcEnergyDepositDigitizerMessenger.cc.

References CexmcEnergyDepositDigitizer::AddCrystalResolutionRange(), CexmcEnergyDepositDigitizer::ApplyFiniteCrystalResolution(), CexmcAllCrystalsMakeEDTriggerThreshold, CexmcFractionOfEDInOuterCrystalsVeto, CexmcInnerCrystalsMakeEDTriggerThreshold, CexmcMaximumEDInASingleOuterCrystalVeto, CexmcNoOuterCrystalsVeto, CexmcEnergyDepositDigitizer::ClearCrystalResolutionData(), G4UIcmdWith3Vector::GetNew3VectorValue(), G4UIcmdWithABool::GetNewBoolValue(), G4UIcmdWithADouble::GetNewDoubleValue(), G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(), G4INCL::Math::max(), G4INCL::Math::min(), CexmcEnergyDepositDigitizer::SetCalorimeterLeftThreshold(), CexmcEnergyDepositDigitizer::SetCalorimeterRightThreshold(), CexmcEnergyDepositDigitizer::SetCalorimetersThreshold(), CexmcEnergyDepositDigitizer::SetCalorimeterTriggerAlgorithm(), CexmcEnergyDepositDigitizer::SetMonitorThreshold(), CexmcEnergyDepositDigitizer::SetOuterCrystalsVetoAlgorithm(), CexmcEnergyDepositDigitizer::SetOuterCrystalsVetoFraction(), CexmcEnergyDepositDigitizer::SetVetoCounterLeftThreshold(), CexmcEnergyDepositDigitizer::SetVetoCounterRightThreshold(), CexmcEnergyDepositDigitizer::SetVetoCountersThreshold(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

{
    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 );
}

---

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

• CexmcEnergyDepositDigitizerMessenger.hh
• CexmcEnergyDepositDigitizerMessenger.cc