Muon::CscCondDbAlg Class Reference

#include <CscCondDbAlg.h>

Inheritance diagram for Muon::CscCondDbAlg:

Collaboration diagram for Muon::CscCondDbAlg:

Public Member Functions
virtual	~CscCondDbAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &) const override
virtual bool	isReEntrant () const override
	Avoid scheduling algorithm multiple times.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef SG::WriteCondHandle< CscCondDbData >	writeHandle_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	loadDataHv (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	loadData (CscCondDbData *, const CondAttrListCollection *, const std::string &, bool=false) const
StatusCode	loadDataF001 (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	loadDataNoise (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	loadDataPed (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	loadDataPSlope (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	loadDataRMS (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	loadDataStatus (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	loadDataT0Base (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	loadDataT0Phase (writeHandle_t &, CscCondDbData *, const EventContext &) const
StatusCode	cache (const std::string &, CscCondDbData *, const std::string &) const
StatusCode	cacheASM (const std::string &, CscCondDbData *, const std::string &) const
StatusCode	getAsmScope (int, int &, int &, int &, int &, int &) const
StatusCode	recordParameter (unsigned int, const std::string &, CscCondDbData *, const std::string &) const
StatusCode	recordParameter (IdentifierHash, const std::string &, CscCondDbData *, const std::string &) const
StatusCode	recordParameterF001 (IdentifierHash, std::string, CscCondDbData *) const
StatusCode	recordParameterNoise (IdentifierHash, std::string, CscCondDbData *) const
StatusCode	recordParameterPed (IdentifierHash, std::string, CscCondDbData *) const
StatusCode	recordParameterPSlope (IdentifierHash, std::string, CscCondDbData *) const
StatusCode	recordParameterRMS (IdentifierHash, std::string, CscCondDbData *) const
StatusCode	recordParameterStatus (IdentifierHash, std::string, CscCondDbData *) const
StatusCode	recordParameterT0Base (IdentifierHash, std::string, CscCondDbData *) const
StatusCode	recordParameterT0Phase (IdentifierHash, std::string, CscCondDbData *) const
template<typename T>
StatusCode	getParameter (IdentifierHash chanHash, std::string data, T &token) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< bool >	m_isOnline {this, "isOnline", false, ""}
Gaudi::Property< bool >	m_isData {this, "isData", false, ""}
Gaudi::Property< bool >	m_isRun1 {this, "isRun1", false, ""}
Gaudi::Property< bool >	m_onlineOfflinePhiFlip {this, "onlineOfflinePhiFlip", true, ""}
Gaudi::Property< std::string >	m_defaultDatabaseReadVersion {this, "defaultDatabaseReadVersion", "02-00", ""}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::WriteCondHandleKey< CscCondDbData >	m_writeKey {this, "WriteKey", "CscCondDbData", "Key of output CSC condition data"}
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_hv
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_f001
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_noise
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_ped
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_pslope
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_rms
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_status
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_t0base
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_folder_da_t0phase
Gaudi::Property< bool >	m_pslopeFromDB
	The pslope is the gain of each CSC channel.
const float	m_DEFAULT_PSLOPE = 0.175
	The CSC gain was originally 5.304 ADC counts per fC, but later increased to 5.7 ADC counts per fC, so the pslope equals 1/5.7 = 0.175438.
Gaudi::Property< float >	m_pslope
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 28 of file CscCondDbAlg.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

writeHandle_t

typedef SG::WriteCondHandle<CscCondDbData> Muon::CscCondDbAlg::writeHandle_t

private

Definition at line 36 of file CscCondDbAlg.h.

Constructor & Destructor Documentation

~CscCondDbAlg()

virtual Muon::CscCondDbAlg::~CscCondDbAlg ( )

virtualdefault

Member Function Documentation

cache()

StatusCode Muon::CscCondDbAlg::cache ( const std::string & data, CscCondDbData * writeCdo, const std::string & parName ) const

private

Definition at line 285 of file CscCondDbAlg.cxx.

                                                                                                             {
    std::istringstream ss(data);
    std::string valueStr;
    unsigned int chanAddress = 0;
 
    bool started = false;
    while (ss.good()) {
        ss >> valueStr;
 
        if (valueStr == "<END_DATA>") break;
 
        if (valueStr == "<BEGIN_DATA>") {
            started = true;
            continue;
        }
        if (!started) continue;
        ATH_MSG_VERBOSE("cache() - current element " << valueStr);
        std::istringstream iss(valueStr);
 
        // use new iss to translate the hex
        if (chanAddress == 0) {
            iss >> std::hex >> chanAddress;
            continue;
        }
 
        // record parameter
        if (recordParameter(chanAddress, valueStr, writeCdo, parName).isFailure()) return StatusCode::FAILURE;
 
        // reset the address
        chanAddress = 0;
    }
 
    return StatusCode::SUCCESS;
}

cacheASM()

StatusCode Muon::CscCondDbAlg::cacheASM ( const std::string & data, CscCondDbData * writeCdo, const std::string & parName ) const

private

Definition at line 320 of file CscCondDbAlg.cxx.

                                                                                                                {
    std::istringstream ss(data);
    std::string valueStr;
    std::string chanAddress;
    bool setAddress = false;
 
    bool started = false;
    while (ss.good()) {
        ss >> valueStr;
 
        if (valueStr == "<END_DATA>") break;
 
        if (valueStr == "<BEGIN_DATA>") {
            started = true;
            continue;
        }
        if (!started) continue;
        ATH_MSG_VERBOSE("cacheASM() - current element " << valueStr);
        std::istringstream iss(valueStr);
 
        // use new iss to translate the hex
        if (!setAddress) {
            iss >> chanAddress;
            setAddress = true;
            continue;
        }
 
        // chanAddress is the ASM tag, need to do something with it
        // format: ASM[#:1-5]_[StationEtaString:AorC][stationPhi:1-8]_[stationName:50-51]
        //         xxx   3   x                  5                6   x             x9
        int asmNum = atoi(chanAddress.substr(3, 1).c_str());
 
        int stationEta = 0;
        if (chanAddress[5] == 'A')
            stationEta = 1;
        else if (chanAddress[5] == 'C')
            stationEta = -1;
        else {
            ATH_MSG_FATAL("Bad ASMID String in CSC COOL database \"" << chanAddress << "\" (wheel " << chanAddress[5] << " doesn't exist!");
            return StatusCode::FAILURE;
        }
 
        int stationPhi = atoi(chanAddress.substr(6, 1).c_str());
        int stationName = atoi(chanAddress.substr(8, 2).c_str());
 
        if (stationPhi < 1 || stationPhi > 8 || stationName < 50 || stationName > 51) {
            ATH_MSG_FATAL("Bad ASMID String in CSC COOL database: \"" << chanAddress << "\"");
            ATH_MSG_FATAL("Read station phi: " << stationPhi << ", stationName " << stationName);
            return StatusCode::FAILURE;
        }
 
        int chamberLayer = 2;  // chamberLayer1 was never built.
 
        int measuresPhi = 0;
        int layerSince = 0;
        int layerUntil = 0;
        int stripSince = 0;
        int stripUntil = 0;
        if (!getAsmScope(asmNum, measuresPhi, layerSince, layerUntil, stripSince, stripUntil).isSuccess()) {
            ATH_MSG_FATAL("Failure of getAsmScope in cacheASM.");
            return StatusCode::FAILURE;
        }
 
        //  Now for given asmID, loop over strip and layer
        unsigned int index = 0;
        Identifier chanId;
        IdentifierHash hashIdentifier;
        for (int iStrip = stripSince; iStrip < stripUntil; iStrip++) {
            for (int iLayer = layerSince; iLayer < layerUntil; iLayer++) {
                // The following call of channelID with check=true ensures that the identifier is checked to be physically valid.
                // This is currently required to be checked when running with layouts which do not contain all CSCs anymore, since the
                // CSCCool database contains still all CSCs. A clean fix would be to have a dedicated database for every layout.
                bool isValid = true;
                chanId = m_idHelperSvc->cscIdHelper().channelID(stationName, stationEta, stationPhi, chamberLayer, iLayer, measuresPhi,
                                                                iStrip, isValid);
               
                static std::atomic<bool> conversionFailPrinted = false;
                if (!isValid) {
                  if (!conversionFailPrinted.load()) {
                    ATH_MSG_WARNING(
                      "Failed to retrieve offline identifier from ASM cool "
                      "string "
                      << chanAddress
                      << ". This is likely due to the fact that the CSCCool "
                         "database contains "
                      << "more entries than the detector layout.");
                    conversionFailPrinted.store(true);
                  }
                  continue;
                }
                if (m_idHelperSvc->cscIdHelper().get_channel_hash(chanId, hashIdentifier)) {
                    ATH_MSG_WARNING("Failed to retrieve channel hash for Identifier " << chanId.get_compact());
                }
                index = (int)hashIdentifier;
                if (index == UINT_MAX) continue;
 
                ATH_MSG_VERBOSE("[cache version 2 (ASM)] Recording " << valueStr << " at index " << index << "\nstationName " << stationName
                                                                     << "\nstationEta " << stationEta << "\nstationPhi " << stationPhi
                                                                     << "\nchamberLayer " << chamberLayer << "\niLayer " << iLayer
                                                                     << "\nmeasuresPhi " << measuresPhi << "\niStrip " << iStrip);
 
                // record parameter
                if (recordParameter(hashIdentifier, valueStr, writeCdo, parName).isFailure()) return StatusCode::FAILURE;
            }
        }
 
        // reset the address
        setAddress = false;
        chanAddress = "";
    }
 
    return StatusCode::SUCCESS;
}

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode Muon::CscCondDbAlg::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 47 of file CscCondDbAlg.cxx.

                                                              {
    ATH_MSG_DEBUG("execute " << name());
 
    // launching Write Cond Handle
    SG::WriteCondHandle<CscCondDbData> writeHandle{m_writeKey, ctx};
    if (writeHandle.isValid()) {
        ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid."
                                    << " In theory this should not be called, but may happen"
                                    << " if multiple concurrent events are being processed out of order.");
        return StatusCode::SUCCESS;
    }
    std::unique_ptr<CscCondDbData> writeCdo{std::make_unique<CscCondDbData>()};
 
    writeCdo->loadParameters(&m_idHelperSvc->cscIdHelper());
    writeCdo->setParameters(m_onlineOfflinePhiFlip);
 
    // data only
    if (m_isData) {
        // ATH_CHECK(loadDataHv(writeHandle, writeCdo.get(), ctx)); // keep for future development
    }
 
    // both data and MC
    ATH_CHECK(loadDataF001(writeHandle, writeCdo.get(), ctx));
    ATH_CHECK(loadDataNoise(writeHandle, writeCdo.get(), ctx));
    ATH_CHECK(loadDataPed(writeHandle, writeCdo.get(), ctx));
    if (m_pslopeFromDB) ATH_CHECK(loadDataPSlope(writeHandle, writeCdo.get(), ctx));
    ATH_CHECK(loadDataRMS(writeHandle, writeCdo.get(), ctx));
    ATH_CHECK(loadDataStatus(writeHandle, writeCdo.get(), ctx));
 
    if (!m_isOnline) {
        ATH_CHECK(loadDataT0Base(writeHandle, writeCdo.get(), ctx));
        ATH_CHECK(loadDataT0Phase(writeHandle, writeCdo.get(), ctx));
    }
 
    if (writeHandle.record(std::move(writeCdo)).isFailure()) {
        ATH_MSG_FATAL("Could not record CscCondDbData " << writeHandle.key() << " with EventRange " << writeHandle.getRange()
                                                        << " into Conditions Store");
        return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Recorded new " << writeHandle.key() << " with range " << writeHandle.getRange() << " into Conditions Store");
 
    return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

getAsmScope()

StatusCode Muon::CscCondDbAlg::getAsmScope ( int asmNum, int & measuresPhi, int & layerSince, int & layerUntil, int & stripSince, int & stripUntil ) const

private

Definition at line 435 of file CscCondDbAlg.cxx.

                                                            {
    // copy-paste from CscCoolStrSvc
 
    if (asmNum == 1) {
        stripSince = 1;   // inclusive
        stripUntil = 97;  // exclusive
        layerSince = 1;   // inclusive
        layerUntil = 3;   // exclusive
        measuresPhi = 0;
    } else if (asmNum == 2) {
        stripSince = 1;   // inclusive
        stripUntil = 97;  // exclusive
        layerSince = 3;   // inclusive
        layerUntil = 5;   // exclusive
        measuresPhi = 0;
    } else if (asmNum == 3) {
        stripSince = 97;
        stripUntil = 193;
        layerSince = 1;
        layerUntil = 3;
        measuresPhi = 0;
    } else if (asmNum == 4) {
        stripSince = 97;
        stripUntil = 193;
        layerSince = 3;
        layerUntil = 5;
        measuresPhi = 0;
    } else if (asmNum == 5) {
        stripSince = 1;
        stripUntil = 49;
        layerSince = 1;
        layerUntil = 5;
        measuresPhi = 1;
    } else {
        ATH_MSG_FATAL("ASM  number  \"" << asmNum << "\" is invalid. It needs to end in a number from 1-5.");
        return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
}

getParameter()

template<typename T>

StatusCode Muon::CscCondDbAlg::getParameter ( IdentifierHash chanHash, std::string data, T & token ) const

inlineprivate

Definition at line 115 of file CscCondDbAlg.h.

                                                                                                           {
        // next element is the status bit
        std::istringstream iss(data);
        iss >> token;
 
        ATH_MSG_VERBOSE("Recorded token " << token << " for channelHash " << chanHash);
        return StatusCode::SUCCESS;
    }

initialize()

StatusCode Muon::CscCondDbAlg::initialize ( )

overridevirtual

Definition at line 12 of file CscCondDbAlg.cxx.

                                    {
    ATH_MSG_DEBUG("initializing " << name());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_writeKey.initialize());
 
    if (m_pslopeFromDB) {
        ATH_MSG_WARNING("You have activated the retrieval of the pslope per CSC channel from the COOL database. "
                        << "Please make sure that a correct PSLOPE database is in place which uses geometrical CSC hashes in hex format "
                        << "as keys and different values of the pslopes for the different CSC channels as values, otherwise please run "
                        << "with the ReadPSlopeFromDatabase property set to false");
    } else {
        float pslope = m_pslope; // Work around cppcheck false positive
        if (!(pslope > 0 && pslope < 1)) {
            ATH_MSG_FATAL("The Pslope cannot be set to a value <=0 or >=1");
            return StatusCode::FAILURE;
        } else if (m_pslope != m_DEFAULT_PSLOPE) {
            ATH_MSG_WARNING("You have manually set the Pslope property (to " << m_pslope
                                                                             << "). Please check whether this is really intended.");
        }
    }
 
    ATH_CHECK(m_readKey_folder_da_hv.initialize(!m_readKey_folder_da_hv.empty() && m_isData));
    ATH_CHECK(m_readKey_folder_da_f001.initialize());
    ATH_CHECK(m_readKey_folder_da_noise.initialize());
    ATH_CHECK(m_readKey_folder_da_ped.initialize());
    ATH_CHECK(m_readKey_folder_da_pslope.initialize(m_pslopeFromDB));
    ATH_CHECK(m_readKey_folder_da_rms.initialize());
    ATH_CHECK(m_readKey_folder_da_status.initialize());
    ATH_CHECK(m_readKey_folder_da_t0base.initialize(!m_readKey_folder_da_t0base.empty()));
    ATH_CHECK(m_readKey_folder_da_t0phase.initialize(!m_readKey_folder_da_t0phase.empty()));
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

isReEntrant()

virtual bool AthCondAlgorithm::isReEntrant ( ) const

inlineoverridevirtualinherited

Avoid scheduling algorithm multiple times.

With multiple concurrent events, conditions objects often expire simultaneously for all slots. To avoid that the scheduler runs the CondAlg in each slot, we declare it as "non-reentrant". This ensures that the conditions objects are only created once.

In case a particular CondAlg should behave differently, it can override this method again and return true.

See also

ATEAM-836

Definition at line 39 of file AthCondAlgorithm.h.

{ return false; }

loadData()

StatusCode Muon::CscCondDbAlg::loadData ( CscCondDbData * writeCdo, const CondAttrListCollection * readCdo, const std::string & parName, bool parAsm = false ) const

private

Definition at line 228 of file CscCondDbAlg.cxx.

                                                     {
    CondAttrListCollection::const_iterator itr;
 
    for (itr = readCdo->begin(); itr != readCdo->end(); ++itr) {
        const coral::AttributeList& atr = itr->second;
        std::string data = atr["Data"].data<std::string>();
        ATH_MSG_DEBUG("Data is: " << data);
 
        std::istringstream ss(data);
 
        if (!ss.good()) {
            ATH_MSG_WARNING("Failed forming stringstream during caching");
            continue;
        }
 
        std::string version;
        ss >> version;
 
        if (version == "02-00" && parAsm) {
            if (!cacheASM(data, writeCdo, parName).isSuccess()) {
                ATH_MSG_ERROR("Failed caching from COOL string version 02-00 in ASM format");
                return StatusCode::FAILURE;
            }
        } else if (version == "02-00") {
            if (!cache(data, writeCdo, parName).isSuccess()) {
                ATH_MSG_ERROR("Failed caching from COOL string version 02-00");
                return StatusCode::FAILURE;
            }
        } else {
            // Old version was treated as an actual number rather than string. It was always
            // set to 1 or sometimes 1.00000, so we convert to integer here and check
            ATH_MSG_WARNING("Don't recognize CSC COOL string version " << version << ". Will treat as default version "
                                                                       << m_defaultDatabaseReadVersion);
            if (m_defaultDatabaseReadVersion == "02-00" && parAsm) {
                if (!cacheASM(data, writeCdo, parName).isSuccess()) {
                    ATH_MSG_ERROR("Failed caching from COOL string version 02-00 in ASM format");
                    return StatusCode::FAILURE;
                }
            } else if (m_defaultDatabaseReadVersion == "02-00") {
                if (!cache(data, writeCdo, parName).isSuccess()) {
                    ATH_MSG_ERROR("Failed caching from COOL string version 02-00");
                    return StatusCode::FAILURE;
                }
            } else {
                ATH_MSG_FATAL("Did not recognize CSC COOL string version "
                              << version
                              << ". Currently, only version 02-00 is supported. The keys of the database have to be geometrical CSC hashes "
                                 "in hex format.");
                return StatusCode::FAILURE;
            }
        }
    }
 
    return StatusCode::SUCCESS;
}

loadDataF001()

StatusCode Muon::CscCondDbAlg::loadDataF001 ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 172 of file CscCondDbAlg.cxx.

                                                                                                                        {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_f001, ctx};
    writeHandle.addDependency(readHandle);
    return loadData(writeCdo, *readHandle, "f001");
}

loadDataHv()

StatusCode Muon::CscCondDbAlg::loadDataHv ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 92 of file CscCondDbAlg.cxx.

                                                                                                                      {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_hv, ctx};
    const CondAttrListCollection* readCdo{*readHandle};
    if (readCdo == nullptr) {
        ATH_MSG_ERROR("Null pointer to the read conditions object");
        return StatusCode::FAILURE;
    }
    writeHandle.addDependency(readHandle);
 
    ATH_MSG_DEBUG("Size of CondAttrListCollection " << readHandle.fullKey() << " readCdo->size()= " << readCdo->size());
    ATH_MSG_DEBUG("Range of input is " << readHandle.getRange() << ", range of output is " << writeHandle.getRange());
 
    CondAttrListCollection::const_iterator itr;
    std::map<Identifier, int> layerMap;
    int hv_state, lv_state, hv_setpoint0, hv_setpoint1;
    unsigned int chan_index = 0;
    for (itr = readCdo->begin(); itr != readCdo->end(); ++itr) {
        unsigned int chanNum = readCdo->chanNum(chan_index);
        const std::string& csc_chan_name = readCdo->chanName(chanNum);
 
        const coral::AttributeList& atr = itr->second;
 
        if (atr.size()) {
            hv_state = *(static_cast<const int*>((atr["HVState"]).addressOfData()));
            lv_state = *(static_cast<const int*>((atr["LVState"]).addressOfData()));
            hv_setpoint0 = *(static_cast<const int*>((atr["HVSetpoint0"]).addressOfData()));
            hv_setpoint1 = *(static_cast<const int*>((atr["HVSetpoint1"]).addressOfData()));
 
            std::string_view delimiter{"_"};
            auto tokens = CxxUtils::tokenize(csc_chan_name, delimiter);
 
            if ((hv_state != 1 or lv_state != 1 or hv_setpoint0 < 1000 or hv_setpoint1 < 1000) && !tokens.empty()) {
                std::string_view layer = tokens[1];
                std::string number_layer = tokens[1].substr(1, 2);
                int wirelayer = CxxUtils::atoi(number_layer);
 
                int eta = 0;
                char eta_side = tokens[0][0];
                if (eta_side == 'A') eta = +1;
                if (eta_side == 'C') eta = -1;
 
                std::string chamber_name;
                char size_side = tokens[0][1];
                if (size_side == 'L') chamber_name = "CSL";
                else if (size_side == 'S') chamber_name = "CSS";
 
                int phi = 0;
                std::string sector_side = tokens[0].substr(2, 4);
                if (sector_side == "01" || sector_side == "02") phi = 1;
                else if (sector_side == "03" || sector_side == "04") phi = 2;
                else if (sector_side == "05" || sector_side == "06") phi = 3;
                else if (sector_side == "07" || sector_side == "08") phi = 4;
                else if (sector_side == "09" || sector_side == "10") phi = 5;
                else if (sector_side == "11" || sector_side == "12") phi = 6;
                else if (sector_side == "13" || sector_side == "14") phi = 7;
                else if (sector_side == "15" || sector_side == "16") phi = 8;
 
                Identifier ChamberId = m_idHelperSvc->cscIdHelper().elementID(chamber_name, eta, phi);
                Identifier WireLayerId = m_idHelperSvc->cscIdHelper().channelID(ChamberId, 1, wirelayer, 1, 1);
                std::string WireLayerstring = std::string(chamber_name);
                WireLayerstring += '_';
                WireLayerstring += eta_side;
                WireLayerstring += '_';
                WireLayerstring += sector_side;
                WireLayerstring += '_';
                WireLayerstring += layer;
 
                writeCdo->setDeadLayer(WireLayerstring, WireLayerId);
                int& mapval = layerMap[ChamberId];
                ++mapval;
                if (mapval == 3) writeCdo->setDeadStation(chamber_name, ChamberId);
            }
        }
        chan_index++;
    }
 
    return StatusCode::SUCCESS;
}

loadDataNoise()

StatusCode Muon::CscCondDbAlg::loadDataNoise ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 179 of file CscCondDbAlg.cxx.

                                                                                                                         {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_noise, ctx};
    writeHandle.addDependency(readHandle);
    return loadData(writeCdo, *readHandle, "noise");
}

loadDataPed()

StatusCode Muon::CscCondDbAlg::loadDataPed ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 186 of file CscCondDbAlg.cxx.

                                                                                                                       {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_ped, ctx};
    writeHandle.addDependency(readHandle);
    return loadData(writeCdo, *readHandle, "ped");
}

loadDataPSlope()

StatusCode Muon::CscCondDbAlg::loadDataPSlope ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 193 of file CscCondDbAlg.cxx.

                                                                                                                          {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_pslope, ctx};
    writeHandle.addDependency(readHandle);
    return loadData(writeCdo, *readHandle, "pslope");
}

loadDataRMS()

StatusCode Muon::CscCondDbAlg::loadDataRMS ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 200 of file CscCondDbAlg.cxx.

                                                                                                                       {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_rms, ctx};
    writeHandle.addDependency(readHandle);
    return loadData(writeCdo, *readHandle, "rms");
}

loadDataStatus()

StatusCode Muon::CscCondDbAlg::loadDataStatus ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 207 of file CscCondDbAlg.cxx.

                                                                                                                          {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_status, ctx};
    writeHandle.addDependency(readHandle);
    return loadData(writeCdo, *readHandle, "status");
}

loadDataT0Base()

StatusCode Muon::CscCondDbAlg::loadDataT0Base ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 214 of file CscCondDbAlg.cxx.

                                                                                                                          {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_t0base, ctx};
    writeHandle.addDependency(readHandle);
    return loadData(writeCdo, *readHandle, "t0base");
}

loadDataT0Phase()

StatusCode Muon::CscCondDbAlg::loadDataT0Phase ( writeHandle_t & writeHandle, CscCondDbData * writeCdo, const EventContext & ctx ) const

private

Definition at line 221 of file CscCondDbAlg.cxx.

                                                                                                                           {
    SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey_folder_da_t0phase, ctx};
    writeHandle.addDependency(readHandle);
    return loadData(writeCdo, *readHandle, "t0phase", true);
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

recordParameter() [1/2]

StatusCode Muon::CscCondDbAlg::recordParameter ( IdentifierHash chanHash, const std::string & data, CscCondDbData * writeCdo, const std::string & parName ) const

private

Definition at line 500 of file CscCondDbAlg.cxx.

                                                                         {
    // record parameter
    StatusCode sc = StatusCode::FAILURE;
    if (parName == "f001")
        sc = recordParameterF001(chanHash, data, writeCdo);
    else if (parName == "noise")
        sc = recordParameterNoise(chanHash, data, writeCdo);
    else if (parName == "ped")
        sc = recordParameterPed(chanHash, data, writeCdo);
    else if (parName == "pslope")
        sc = recordParameterPSlope(chanHash, data, writeCdo);
    else if (parName == "rms")
        sc = recordParameterRMS(chanHash, data, writeCdo);
    else if (parName == "status")
        sc = recordParameterStatus(chanHash, data, writeCdo);
    else if (parName == "t0base")
        sc = recordParameterT0Base(chanHash, data, writeCdo);
    else if (parName == "t0phase")
        sc = recordParameterT0Phase(chanHash, data, writeCdo);
 
    if (!sc.isSuccess())
        ATH_MSG_ERROR("Cannot extract parameter " << parName << " for channel hash " << chanHash << " from data string '" << data << "'");
    return sc;
}

recordParameter() [2/2]

StatusCode Muon::CscCondDbAlg::recordParameter ( unsigned int chanAddress, const std::string & data, CscCondDbData * writeCdo, const std::string & parName ) const

private

Definition at line 477 of file CscCondDbAlg.cxx.

                                                                         {
    // retrieve channel hash
    Identifier chamberId;
    Identifier channelId;
    if (!writeCdo->onlineToOfflineIds(&m_idHelperSvc->cscIdHelper(), chanAddress, chamberId, channelId).isSuccess()) {
        // if onlineToOfflineIds does not return SUCCESS, the underlying reason was alrady printed there, so no need to also print a WARNING
        // here
        return StatusCode::SUCCESS;
    }
 
    IdentifierHash chanHash;
    if (m_idHelperSvc->cscIdHelper().get_channel_hash(channelId, chanHash)) {
        ATH_MSG_WARNING("recordParameter(): Failed to retrieve channel Identifier hash for Identifier " << channelId.get_compact()
                                                                                                        << ". Not recording parameter...");
        return StatusCode::SUCCESS;
    }
 
    // record parameter
    return recordParameter(chanHash, data, writeCdo, parName);
}

recordParameterF001()

StatusCode Muon::CscCondDbAlg::recordParameterF001 ( IdentifierHash chanHash, std::string data, CscCondDbData * writeCdo ) const

private

Definition at line 527 of file CscCondDbAlg.cxx.

                                                                                                                   {
    float token;
    if (getParameter(chanHash, std::move(data), token).isFailure()) return StatusCode::FAILURE;
    writeCdo->setChannelF001(chanHash, token);
    return StatusCode::SUCCESS;
}

recordParameterNoise()

StatusCode Muon::CscCondDbAlg::recordParameterNoise ( IdentifierHash chanHash, std::string data, CscCondDbData * writeCdo ) const

private

Definition at line 535 of file CscCondDbAlg.cxx.

                                                                                                                    {
    float token;
    if (getParameter(chanHash, std::move(data), token).isFailure()) return StatusCode::FAILURE;
    writeCdo->setChannelNoise(chanHash, token);
    return StatusCode::SUCCESS;
}

recordParameterPed()

StatusCode Muon::CscCondDbAlg::recordParameterPed ( IdentifierHash chanHash, std::string data, CscCondDbData * writeCdo ) const

private

Definition at line 543 of file CscCondDbAlg.cxx.

                                                                                                                  {
    float token;
    if (getParameter(chanHash, std::move(data), token).isFailure()) return StatusCode::FAILURE;
    writeCdo->setChannelPed(chanHash, token);
    return StatusCode::SUCCESS;
}

recordParameterPSlope()

StatusCode Muon::CscCondDbAlg::recordParameterPSlope ( IdentifierHash chanHash, std::string data, CscCondDbData * writeCdo ) const

private

Definition at line 551 of file CscCondDbAlg.cxx.

                                                                                                                     {
    if (m_pslopeFromDB) {
        float token;
        if (getParameter(chanHash, std::move(data), token).isFailure()) return StatusCode::FAILURE;
        writeCdo->setChannelPSlope(chanHash, token);
    } else {
        // just set plsope to m_pslope for every channel
        writeCdo->setChannelPSlope(chanHash, m_pslope);
    }
    return StatusCode::SUCCESS;
}

recordParameterRMS()

StatusCode Muon::CscCondDbAlg::recordParameterRMS ( IdentifierHash chanHash, std::string data, CscCondDbData * writeCdo ) const

private

Definition at line 564 of file CscCondDbAlg.cxx.

                                                                                                                  {
    float token;
    if (getParameter(chanHash, std::move(data), token).isFailure()) return StatusCode::FAILURE;
    writeCdo->setChannelRMS(chanHash, token);
    return StatusCode::SUCCESS;
}

recordParameterStatus()

StatusCode Muon::CscCondDbAlg::recordParameterStatus ( IdentifierHash chanHash, std::string data, CscCondDbData * writeCdo ) const

private

Definition at line 572 of file CscCondDbAlg.cxx.

                                                                                                                     {
    int token{};
    if (getParameter(chanHash, std::move(data), token).isFailure()) return StatusCode::FAILURE;
    //setChannelStatus takes signed int token argument
    writeCdo->setChannelStatus(chanHash, token);
    return StatusCode::SUCCESS;
}

recordParameterT0Base()

StatusCode Muon::CscCondDbAlg::recordParameterT0Base ( IdentifierHash chanHash, std::string data, CscCondDbData * writeCdo ) const

private

Definition at line 581 of file CscCondDbAlg.cxx.

                                                                                                                     {
    float token;
    if (getParameter(chanHash, std::move(data), token).isFailure()) return StatusCode::FAILURE;
    writeCdo->setChannelT0Base(chanHash, token);
    return StatusCode::SUCCESS;
}

recordParameterT0Phase()

StatusCode Muon::CscCondDbAlg::recordParameterT0Phase ( IdentifierHash chanHash, std::string data, CscCondDbData * writeCdo ) const

private

Definition at line 589 of file CscCondDbAlg.cxx.

                                                                                                                      {
    bool token;
    if (getParameter(chanHash, std::move(data), token).isFailure()) return StatusCode::FAILURE;
    writeCdo->setChannelT0Phase(chanHash, token);
    return StatusCode::SUCCESS;
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_DEFAULT_PSLOPE

const float Muon::CscCondDbAlg::m_DEFAULT_PSLOPE = 0.175

private

The CSC gain was originally 5.304 ADC counts per fC, but later increased to 5.7 ADC counts per fC, so the pslope equals 1/5.7 = 0.175438.

Definition at line 110 of file CscCondDbAlg.h.

m_defaultDatabaseReadVersion

Gaudi::Property<std::string> Muon::CscCondDbAlg::m_defaultDatabaseReadVersion {this, "defaultDatabaseReadVersion", "02-00", ""}

private

Definition at line 71 of file CscCondDbAlg.h.

{this, "defaultDatabaseReadVersion", "02-00", ""};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::CscCondDbAlg::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 73 of file CscCondDbAlg.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_isData

Gaudi::Property<bool> Muon::CscCondDbAlg::m_isData {this, "isData", false, ""}

private

Definition at line 68 of file CscCondDbAlg.h.

{this, "isData", false, ""};

m_isOnline

Gaudi::Property<bool> Muon::CscCondDbAlg::m_isOnline {this, "isOnline", false, ""}

private

Definition at line 67 of file CscCondDbAlg.h.

{this, "isOnline", false, ""};

m_isRun1

Gaudi::Property<bool> Muon::CscCondDbAlg::m_isRun1 {this, "isRun1", false, ""}

private

Definition at line 69 of file CscCondDbAlg.h.

{this, "isRun1", false, ""};

m_onlineOfflinePhiFlip

Gaudi::Property<bool> Muon::CscCondDbAlg::m_onlineOfflinePhiFlip {this, "onlineOfflinePhiFlip", true, ""}

private

Definition at line 70 of file CscCondDbAlg.h.

{this, "onlineOfflinePhiFlip", true, ""};

m_pslope

Gaudi::Property<float> Muon::CscCondDbAlg::m_pslope

private

Initial value:

{this, "PSlope", m_DEFAULT_PSLOPE,
                                    "in case someone comes up with a new default value for pslope in the future"}

Definition at line 111 of file CscCondDbAlg.h.

                                 {this, "PSlope", m_DEFAULT_PSLOPE,
                                    "in case someone comes up with a new default value for pslope in the future"};

m_pslopeFromDB

Gaudi::Property<bool> Muon::CscCondDbAlg::m_pslopeFromDB

private

Initial value:

{
        this, "ReadPSlopeFromDatabase", false,
        "read the pslope parameter from the conditions database (if it is not the same value for all channels)"}

The pslope is the gain of each CSC channel.

It was intended to be retrieved by calibration with the pulser runs, but the pulses caused overload in the amplifiers because every channel fires at once. This leads to errors that are larger than the variation between channels. Consequently, the pslope is the same for all channels. In the future, one could try to calibrate from data. The support for the pslope in the database is maintained by having a boolean property ReadPSlopeFromDatabase. If it is set to false, the value of the property PSlope is used for all channels.

Definition at line 103 of file CscCondDbAlg.h.

                                      {
        this, "ReadPSlopeFromDatabase", false,
        "read the pslope parameter from the conditions database (if it is not the same value for all channels)"};

m_readKey_folder_da_f001

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_f001

private

Initial value:

{this, "ReadKey_FT", "/CSC/FTHOLD",
                                                                           "Key of input CSC condition data F001"}

Definition at line 79 of file CscCondDbAlg.h.

                                                                        {this, "ReadKey_FT", "/CSC/FTHOLD",
                                                                           "Key of input CSC condition data F001"};

m_readKey_folder_da_hv

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_hv

private

Initial value:

{this, "ReadKey_HV", "/CSC/DCS/LAYERSTATE",
                                                                         "Key of input CSC condition data HV"}

Definition at line 77 of file CscCondDbAlg.h.

                                                                      {this, "ReadKey_HV", "/CSC/DCS/LAYERSTATE",
                                                                         "Key of input CSC condition data HV"};

m_readKey_folder_da_noise

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_noise

private

Initial value:

{this, "ReadKey_NO", "/CSC/NOISE",
                                                                            "Key of input CSC condition data NOISE"}

Definition at line 81 of file CscCondDbAlg.h.

                                                                         {this, "ReadKey_NO", "/CSC/NOISE",
                                                                            "Key of input CSC condition data NOISE"};

m_readKey_folder_da_ped

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_ped

private

Initial value:

{this, "ReadKey_PD", "/CSC/PED",
                                                                          "Key of input CSC condition data PEDESTALS"}

Definition at line 83 of file CscCondDbAlg.h.

                                                                       {this, "ReadKey_PD", "/CSC/PED",
                                                                          "Key of input CSC condition data PEDESTALS"};

m_readKey_folder_da_pslope

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_pslope

private

Initial value:

{this, "ReadKey_PS", "/CSC/PSLOPE",
                                                                             "Key of input CSC condition data PSLOPE"}

Definition at line 85 of file CscCondDbAlg.h.

                                                                          {this, "ReadKey_PS", "/CSC/PSLOPE",
                                                                             "Key of input CSC condition data PSLOPE"};

m_readKey_folder_da_rms

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_rms

private

Initial value:

{this, "ReadKey_RM", "/CSC/RMS",
                                                                          "Key of input CSC condition data RMS"}

Definition at line 87 of file CscCondDbAlg.h.

                                                                       {this, "ReadKey_RM", "/CSC/RMS",
                                                                          "Key of input CSC condition data RMS"};

m_readKey_folder_da_status

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_status

private

Initial value:

{this, "ReadKey_ST", "/CSC/STAT",
                                                                             "Key of input CSC condition data STATUS"}

Definition at line 89 of file CscCondDbAlg.h.

                                                                          {this, "ReadKey_ST", "/CSC/STAT",
                                                                             "Key of input CSC condition data STATUS"};

m_readKey_folder_da_t0base

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_t0base

private

Initial value:

{this, "ReadKey_TB", "/CSC/T0BASE",
                                                                             "Key of input CSC condition data T0BASE"}

Definition at line 91 of file CscCondDbAlg.h.

                                                                          {this, "ReadKey_TB", "/CSC/T0BASE",
                                                                             "Key of input CSC condition data T0BASE"};

m_readKey_folder_da_t0phase

SG::ReadCondHandleKey<CondAttrListCollection> Muon::CscCondDbAlg::m_readKey_folder_da_t0phase

private

Initial value:

{this, "ReadKey_TP", "/CSC/T0PHASE",
                                                                              "Key of input CSC condition data T0PHASE"}

Definition at line 93 of file CscCondDbAlg.h.

                                                                           {this, "ReadKey_TP", "/CSC/T0PHASE",
                                                                              "Key of input CSC condition data T0PHASE"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeKey

SG::WriteCondHandleKey<CscCondDbData> Muon::CscCondDbAlg::m_writeKey {this, "WriteKey", "CscCondDbData", "Key of output CSC condition data"}

private

Definition at line 75 of file CscCondDbAlg.h.

{this, "WriteKey", "CscCondDbData", "Key of output CSC condition data"};

---

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

• CscCondDbAlg.h
• CscCondDbAlg.cxx