RpcCablingCondAlg Class Reference

#include <RpcCablingCondAlg.h>

Inheritance diagram for RpcCablingCondAlg:

Collaboration diagram for RpcCablingCondAlg:

Public Member Functions
	RpcCablingCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~RpcCablingCondAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) 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 std::array< int, 64 >	sectorMap_t
typedef std::map< int, RPC_CondCabling::SectorLogicSetup *, std::less< int > >	SLmap_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	setup (const CondAttrListCollection *readCdoMap, const CondAttrListCollection *readCdoCorr, const CondAttrListCollection *readCdoEta, const CondAttrListCollection *readCdoPhi, RpcCablingCondData *writeCdo) const
std::list< Identifier >	give_strip_id (const unsigned short int SubsystemId, const unsigned short int SectorId, const unsigned short int PADId, const unsigned short int CMAId, const unsigned short ijk, const unsigned short int Channel, const sectorMap_t &smap, const RpcCablingCondData::STvec &sType) const
bool	BoardParamCheck (const unsigned short int SubId, const unsigned short int SecId, const unsigned short int PADId, const unsigned short int CMAId, const unsigned short int inputType, const unsigned int layer, const unsigned int type, const unsigned short int Channel1, const unsigned short int Channel2, const short int Number) const
bool	CableParamCheck (const unsigned short int SubId, const unsigned short int SecId, const unsigned short int PADId, const unsigned short int CMAId, const unsigned short int ijk, const unsigned int type, const unsigned short int Channel1, const unsigned short int Channel2, const short int Number) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static bool	correct (const unsigned short int SubsystemId, const unsigned short int SectorId, const unsigned short int PADId, const unsigned short int CMAId, const CMAinput it, const unsigned int layer, const unsigned short int Channel1, const unsigned short int Channel2, const short int number, const L1RPCcabCorrection type, const sectorMap_t &smap, const RpcCablingCondData::STvec &sType)

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_map_schema
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_map_schema_corr
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_cm_thr_eta
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey_cm_thr_phi
SG::WriteCondHandleKey< RpcCablingCondData >	m_writeKey
Gaudi::Property< std::string >	m_database_repository {this, "DatabaseRepository", "MuonRPC_Cabling/ATLAS.data"}
Gaudi::Property< bool >	m_cosmic_configuration {this, "CosmicConfiguration", false}
Gaudi::Property< bool >	m_ApplyFeetPadThresholds
Gaudi::Property< bool >	m_ForceFeetPadThresholdsFromJO {this, "ForceFeetPadThresholdsFromJO", false, "JO override db setting"}
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 21 of file RpcCablingCondAlg.h.

Member Typedef Documentation

sectorMap_t

typedef std::array<int, 64> RpcCablingCondAlg::sectorMap_t

private

Definition at line 30 of file RpcCablingCondAlg.h.

SLmap_t

typedef std::map<int, RPC_CondCabling::SectorLogicSetup*, std::less<int> > RpcCablingCondAlg::SLmap_t

private

Definition at line 31 of file RpcCablingCondAlg.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

RpcCablingCondAlg()

RpcCablingCondAlg::RpcCablingCondAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 12 of file RpcCablingCondAlg.cxx.

: AthCondAlgorithm(name, pSvcLocator) {}

~RpcCablingCondAlg()

virtual RpcCablingCondAlg::~RpcCablingCondAlg ( )

virtualdefault

Member Function Documentation

BoardParamCheck()

bool RpcCablingCondAlg::BoardParamCheck ( const unsigned short int SubId, const unsigned short int SecId, const unsigned short int PADId, const unsigned short int CMAId, const unsigned short int inputType, const unsigned int layer, const unsigned int type, const unsigned short int Channel1, const unsigned short int Channel2, const short int Number ) const

private

Definition at line 784 of file RpcCablingCondAlg.cxx.

                                                                      {
    if (SubId != 0x65 && SubId != 0x66) {
        ATH_MSG_ERROR("Subsystem Id out of range: " << SubId << " not in [0x65,0x66].");
        return false;
    }
    if (SecId > 31) {
        ATH_MSG_ERROR("Sector Id out of range [0/31].");
        return false;
    }
    if (PADId > 8) {
        ATH_MSG_ERROR("Pad Id out of range [0/8].");
        return false;
    }
    if (CMAId > 7) {
        ATH_MSG_ERROR("CMA Id out of range [0/7].");
        return false;
    }
    if (inputType > 2) {
        ATH_MSG_ERROR("Board input out of range [0/2].");
        return false;
    }
    if (layer > 1) {
        ATH_MSG_ERROR("Board layer out of range [0/1].");
        return false;
    }
    if (type > 3) {
        ATH_MSG_ERROR("correction type out of range [0/3].");
        return false;
    }
    if (Channel1 > 63) {
        ATH_MSG_ERROR("ijk Channel 1 out of range [0/31].");
        return false;
    }
    if (Channel2 > 63) {
        ATH_MSG_ERROR("ijk Channel 2 out of range [0/31].");
        return false;
    }
    if (Number > 64) {
        ATH_MSG_ERROR("Number out of range [0/64].");
        return false;
    }
    return true;
}

CableParamCheck()

bool RpcCablingCondAlg::CableParamCheck ( const unsigned short int SubId, const unsigned short int SecId, const unsigned short int PADId, const unsigned short int CMAId, const unsigned short int ijk, const unsigned int type, const unsigned short int Channel1, const unsigned short int Channel2, const short int Number ) const

private

Definition at line 831 of file RpcCablingCondAlg.cxx.

                                                                      {
    if (SubId != 0x65 && SubId != 0x66) {
        ATH_MSG_ERROR("Subsystem Id out of range [0x65,0x66].");
        return false;
    }
    if (SecId > 31) {
        ATH_MSG_ERROR("Sector Id out of range [0/31].");
        return false;
    }
    if (PADId > 8) {
        ATH_MSG_ERROR("Pad Id out of range [0/8].");
        return false;
    }
    if (CMAId > 7) {
        ATH_MSG_ERROR("CMA Id out of range [0/7].");
        return false;
    }
    if (ijk > 5) {
        ATH_MSG_ERROR("ijk out of range [0/5].");
        return false;
    }
    if (type > 3) {
        ATH_MSG_ERROR("correction type out of range [0/3].");
        return false;
    }
    if (Channel1 > 31) {
        ATH_MSG_ERROR("ijk Channel 1 out of range [0/31].");
        return false;
    }
    if (Channel2 > 31) {
        ATH_MSG_ERROR("ijk Channel 2 out of range [0/31].");
        return false;
    }
    if (Number > 32) {
        ATH_MSG_ERROR("Number out of range [0/32].");
        return false;
    }
    return true;
}

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

correct()

bool RpcCablingCondAlg::correct ( const unsigned short int SubsystemId, const unsigned short int SectorId, const unsigned short int PADId, const unsigned short int CMAId, const CMAinput it, const unsigned int layer, const unsigned short int Channel1, const unsigned short int Channel2, const short int number, const L1RPCcabCorrection type, const sectorMap_t & smap, const RpcCablingCondData::STvec & sType )

staticprivate

Definition at line 759 of file RpcCablingCondAlg.cxx.

                                                                                                                              {
    int logic_sector = (SubsystemId == 0x65) ? SectorId + 32 : SectorId;
    unsigned short int Ixx = CMAId & 1;
    unsigned short int ep = (CMAId >> 1) & 1;
 
    ep = (ep == 1) ? 0 : 1;
 
    // retrieve the Sector Logic setup
    const RPC_CondCabling::SectorLogicSetup& s = sType[smap[logic_sector] - 1];
 
    // retrieve the CMAparameters associated to the identifiers
    if (ep) {
        CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
        CMAidentity PHI(Phi, PhiCov, PADId, Ixx);
        return s.correct(PHI, type, it, layer, Channel1, Channel2, number);
    } else {
        CMAidentity ETA(Eta, AllSectors, PADId, Ixx);
        return s.correct(ETA, type, it, layer, Channel1, Channel2, number);
    }
    return false;
}

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 RpcCablingCondAlg::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 25 of file RpcCablingCondAlg.cxx.

                                                                   {
    
    ATH_MSG_DEBUG("executing" << name());
 
    SG::WriteCondHandle<RpcCablingCondData> 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;
    }
 
    // read in the 4 different cond objects:
    // map
    SG::ReadCondHandle<CondAttrListCollection> readHandle_map_schema{m_readKey_map_schema, ctx};
    const CondAttrListCollection* readCdoMap{*readHandle_map_schema};
    if (!readCdoMap) {
        ATH_MSG_FATAL("Null pointer to the read conditions object");
        return StatusCode::FAILURE;
    }
    writeHandle.addDependency(readHandle_map_schema);
    ATH_MSG_DEBUG("Size of CondAttrListCollection readCdoMap->size()= " << readCdoMap->size());
 
    // corr
    SG::ReadCondHandle<CondAttrListCollection> readHandle_map_schema_corr{m_readKey_map_schema_corr, ctx};
    const CondAttrListCollection* readCdoCorr{*readHandle_map_schema_corr};
    if (!readCdoCorr) {
        ATH_MSG_FATAL("Null pointer to the read conditions object");
        return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Size of CondAttrListCollection readCdoMap_corr->size()= " << readCdoCorr->size());
    writeHandle.addDependency(readHandle_map_schema_corr);
 
    // EtaTable
    SG::ReadCondHandle<CondAttrListCollection> readHandle_cm_thr_eta{m_readKey_cm_thr_eta, ctx};
    const CondAttrListCollection* readCdoEta{*readHandle_cm_thr_eta};
    if (!readCdoEta) {
        ATH_MSG_FATAL("Null pointer to the read conditions object");
        return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Size of CondAttrListCollection readCdo_cm_thr_eta->size()= " << readCdoEta->size());
    writeHandle.addDependency(readHandle_cm_thr_eta);
 
    // phiTable
    SG::ReadCondHandle<CondAttrListCollection> readHandle_cm_thr_phi{m_readKey_cm_thr_phi, ctx};
    const CondAttrListCollection* readCdoPhi{*readHandle_cm_thr_phi};
    if (!readCdoPhi) {
        ATH_MSG_FATAL("Null pointer to the read conditions object");
        return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Size of CondAttrListCollection readCdo_cm_thr_phi->size()= " << readCdoPhi->size());
    writeHandle.addDependency(readHandle_cm_thr_phi);
 
    std::unique_ptr<RpcCablingCondData> writeCdo{std::make_unique<RpcCablingCondData>()};
    ATH_CHECK(setup(readCdoMap, readCdoCorr, readCdoEta, readCdoPhi, writeCdo.get()));
 
    if (writeHandle.record(std::move(writeCdo)).isFailure()) {
        ATH_MSG_FATAL("Could not record RpcCondCablingData " << writeHandle.key() << " with EventRange " << writeHandle.getRange()
                                                             << " into Conditions Store");
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_INFO("recorded new " << writeHandle.key() << " with range " << writeHandle.getRange());
    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();
  }

give_strip_id()

std::list< Identifier > RpcCablingCondAlg::give_strip_id ( const unsigned short int SubsystemId, const unsigned short int SectorId, const unsigned short int PADId, const unsigned short int CMAId, const unsigned short ijk, const unsigned short int Channel, const sectorMap_t & smap, const RpcCablingCondData::STvec & sType ) const

private

Definition at line 688 of file RpcCablingCondAlg.cxx.

                                                                                                   {
    std::list<unsigned int> CodeList;
 
    int logic_sector = SectorId + SubsystemId * 32;
    unsigned short int Ixx = CMAId & 1;
    unsigned short int ep = (CMAId >> 1) & 1;
    unsigned short int lh = (CMAId >> 2) & 1;
 
    ep = (ep == 1) ? 0 : 1;
 
    // retrieve the Sector Logic setup
    const RPC_CondCabling::SectorLogicSetup& s = sType[smap[logic_sector] - 1];
 
    // retrieve the CMAparameters associated to the identifiers
    if (ep) {
        CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
        CMAidentity PHI(ViewType::Phi, PhiCov, PADId, Ixx);
        CodeList = s.give_strip_code(PHI, logic_sector, lh, ijk, Channel);
    } else {
        CMAidentity ETA(ViewType::Eta, CMAcoverage::AllSectors, PADId, Ixx);
        CodeList = s.give_strip_code(ETA, logic_sector, lh, ijk, Channel);
    }
 
    std::list<RPCofflineId> offlineIdList;
    std::list<unsigned int>::const_iterator it = CodeList.begin();
    while (it != CodeList.end()) {
        RPCdecoder decode(*it);
        if (!decode)
            throw std::runtime_error("RpcCablingCondAlg::give_strip_id() - cannot decode LVL1 Id at " +
                                     std::string(__FILE__) + ":" + std::to_string(__LINE__));
        RPCofflineId rpcId;
 
        int RPC_strip = decode.strip_number();
        int RPC_chamber = decode.rpc_z_index();
        int RPC_layer = decode.rpc_layer();
        int RPC_station = decode.lvl1_station();
        int sector = (decode.logic_sector()) % 32;
 
        const RPC_CondCabling::RPCchamber* rpc = s.find_chamber(RPC_station, RPC_chamber);
 
        rpcId.stationName = rpc->stationName();
        rpcId.stationEta = (decode.half_barrel() == Positive) ? rpc->stationEta() : -rpc->stationEta();
        rpcId.stationPhi = (sector == 31) ? 1 : (sector + 1) / 4 + 1;
        rpcId.doubletR = rpc->doubletR();
        rpcId.doubletZ = rpc->doubletZ();
        rpcId.doubletPhi = (rpc->phiReadoutPannels() == 2) ? (sector + 1) % 2 + 1 : 1;
        rpcId.gasGap = RPC_layer + 1;
        rpcId.measuresPhi = static_cast<int>(decode.view());
        rpcId.strip = RPC_strip + 1;
 
        offlineIdList.push_back(std::move(rpcId));
 
        ++it;
    }
 
    std::list<Identifier> id;
    std::list<RPCofflineId>::const_iterator iterator = offlineIdList.begin();
    while (iterator != offlineIdList.end()) {
        Identifier rpcId = m_idHelperSvc->rpcIdHelper().channelID((*iterator).stationName, (*iterator).stationEta, (*iterator).stationPhi,
                                                                  (*iterator).doubletR, (*iterator).doubletZ, (*iterator).doubletPhi,
                                                                  (*iterator).gasGap, (*iterator).measuresPhi, (*iterator).strip);
        id.push_back(rpcId);
        ++iterator;
    }
 
    return id;
}

initialize()

StatusCode RpcCablingCondAlg::initialize ( )

overridevirtual

Definition at line 14 of file RpcCablingCondAlg.cxx.

                                         {
    ATH_MSG_DEBUG("initializing" << name());
    ATH_CHECK(m_readKey_map_schema.initialize());
    ATH_CHECK(m_readKey_map_schema_corr.initialize());
    ATH_CHECK(m_readKey_cm_thr_eta.initialize());
    ATH_CHECK(m_readKey_cm_thr_phi.initialize());
    ATH_CHECK(m_writeKey.initialize());
    ATH_CHECK(m_idHelperSvc.retrieve());
    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; }

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.

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

setup()

StatusCode RpcCablingCondAlg::setup ( const CondAttrListCollection * readCdoMap, const CondAttrListCollection * readCdoCorr, const CondAttrListCollection * readCdoEta, const CondAttrListCollection * readCdoPhi, RpcCablingCondData * writeCdo ) const

private

Definition at line 91 of file RpcCablingCondAlg.cxx.

                                                                        {
    ATH_MSG_DEBUG("starting setup()");
 
    int maxType = 0;
    sectorMap_t sectorMap;
    RpcCablingCondData::STvec sectorType;
    std::vector<unsigned short int> feedPadThresholds;
    std::map<std::string, std::string> trigroads;
    SLmap_t sectorLogic;
 
    // ------------------------------
    // readCdoMap
    // ------------------------------
    ATH_MSG_INFO("setup() - Reading " << m_readKey_map_schema.key());
    const coral::AttributeList& atr_map = readCdoMap->attributeList(1);  // All data sits in cool channel 1
    std::stringstream MAP(atr_map["Map"].data<std::string>());
 
    // ------------------------------
    // readCdoCorr
    // ------------------------------
    ATH_MSG_INFO("setup() - Reading " << m_readKey_map_schema_corr.key());
    const coral::AttributeList& atr_map_corr = readCdoCorr->attributeList(1);  // All data sits in cool channel 1
    std::stringstream MAP_corr(atr_map_corr["Map"].data<std::string>());
 
    // ------------------------------
    // readCdoEta
    // ------------------------------
    ATH_MSG_INFO("setup() - Reading " << m_readKey_cm_thr_eta.key());
    std::string etaCM_File;
    std::string etaTh0;
    CondAttrListCollection::const_iterator itr_eta;
    for (itr_eta = readCdoEta->begin(); itr_eta != readCdoEta->end(); ++itr_eta) {
        const coral::AttributeList& atr = itr_eta->second;
        etaCM_File = *(static_cast<const std::string*>((atr["CM_File"]).addressOfData()));
        etaTh0 = *(static_cast<const std::string*>((atr["Th0"]).addressOfData()));
        trigroads[etaCM_File] = etaTh0;
    }
 
    // ------------------------------
    // readCdoPhi
    // ------------------------------
    ATH_MSG_INFO("setup() - Reading " << m_readKey_cm_thr_phi.key());
    std::string phiCM_File;
    std::string phiTh0;
    CondAttrListCollection::const_iterator itr;
    for (itr = readCdoPhi->begin(); itr != readCdoPhi->end(); ++itr) {
        const coral::AttributeList& atr = itr->second;
        phiCM_File = *(static_cast<const std::string*>((atr["CM_File"]).addressOfData()));
        phiTh0 = *(static_cast<const std::string*>((atr["Th0"]).addressOfData()));
        trigroads[phiCM_File] = phiTh0;
    }
    // ------------------------------
 
    DBline data(MAP);
    // store the setup environment
    std::string version, setup, layout;
 
    // Start reading routine
    unsigned int nlines = 0;
 
    std::string dataName = PathResolver::find_directory(m_database_repository, "DATAPATH");
 
    // Start reading routine
    while (++data) {
        ATH_MSG_DEBUG("setup() - Reading routine. nlines = " << nlines);
        ++nlines;
        data("Version") >> version >> setup >> layout;
 
        // Read the Sector Type enumeration
        int start = 0;
        int stop = 0;
        if (data("SECTOR TYPES (") >> start >> "-" >> stop >> "):") {
            for (int i = start; i <= stop; ++i) { data >> sectorMap[i]; }
        }
 
        // Set the maxType variable and the type of SectorMap objects
        if (stop == 63 || stop == 8) {
            for (int i = 0; i < 64; ++i) { maxType = std::max(sectorMap[i], maxType); }
            sectorType.clear();
            //sectorType.reserve(maxType); // this would require a copy-constructor
            ATH_MSG_DEBUG("setup() - Loop over " << maxType << " sector-types");
 
            for (int i = 1; i <= maxType; ++i) {
                sectorType.emplace_back(i, dataName, layout, m_cosmic_configuration);
                RPC_CondCabling::SectorLogicSetup& sec = sectorType[i - 1];
                sec.SetPtoTrigRoads(&trigroads);
                for (int j = 0; j < 64; ++j) {
                    if (sectorMap[j] == i) {
                        sec << j;
                        sectorLogic.insert(SLmap_t::value_type(j, &sec));
                        ATH_MSG_DEBUG("setup() - filling sectorLogicSetup Map for type " << i << " sector  " << j);
                    }
                }
            }
        }
 
        // Loop on GEOMETRY TYPES
        for (int i = 1; i <= maxType; ++i) {
            // Read the RPC geometry
            if (data("RPC GEOM  # :", i)) {
                RPC_CondCabling::RPCchamberdata RPCdata(data, i);
                if (!(sectorType[i - 1] += RPCdata)) return StatusCode::FAILURE;
            }
            // Read the Wired OR geometry
            if (data("WIRED OR  # :", i)) {
                RPC_CondCabling::WiredORdata WORdata(data, i);
                if (!(sectorType[i - 1] += WORdata)) return StatusCode::FAILURE;
            }
            // Read the CMAs segmentation
            if (data("CMAs  # : pivot segmentation", i)) {
                RPC_CondCabling::CMApivotdata CMAdata(data, i, layout);
                if (!(sectorType[i - 1] += CMAdata)) return StatusCode::FAILURE;
            }
            // Read the CMAs cabling
            if (data("CMAs  # : eta cabling", i)) {
                RPC_CondCabling::CMAcablingdata CMAdata(data, i);
                if (!(sectorType[i - 1] += CMAdata)) return StatusCode::FAILURE;
            }
        }
    }
    ATH_MSG_DEBUG("setup() - map n. of lines read is " << nlines);
    ATH_MSG_INFO("setup() - version is " << version << " " << setup << " " << layout << " (cosmic=" << (int)m_cosmic_configuration << ")");
 
    for (int i = 1; i <= maxType; ++i) {
        if (!sectorType[i - 1].setup(msg())) return StatusCode::FAILURE;
        if (!sectorType[i - 1].check()) return StatusCode::FAILURE;
        if (msgLvl(MSG::DEBUG)) {
            ATH_MSG_DEBUG("calling get_cabling for i=" << i);
            const RPC_CondCabling::SectorLogicSetup::EtaCMAmap& CMAs = sectorType[i - 1].giveEtaCMA();
            for (const auto& cma : CMAs) {
                unsigned int cabling = UINT_MAX;
                if (cma.second.get_cabling(CMAinput::Pivot, 0, 0, 0, cabling)) {
                    ATH_MSG_DEBUG("got pivot cabling=" << cabling);
                } else {
                    ATH_MSG_DEBUG("failed to get cabling");
                }
            }
        }
    }
 
    ATH_MSG_DEBUG("setup() - " << m_readKey_map_schema.key() << " maps have been parsed");
 
    for (int sector = 0; sector < 64; ++sector) {
        unsigned int nRDOentries = 0;
        int side = (sector < 32) ? 0 : 1;
        int logic_sector = sector % 32;
 
        if (sectorMap[sector]) {
            // get the Sector Logic Setup
            const RPC_CondCabling::SectorLogicSetup& Sector = sectorType[sectorMap[sector] - 1];
 
            // get the Eta CMA map from the Sector Logic Setup
            const RPC_CondCabling::SectorLogicSetup::EtaCMAmap& CMAs = Sector.giveEtaCMA();
            RPC_CondCabling::SectorLogicSetup::EtaCMAmap::const_iterator it = CMAs.begin();
 
            bool isFirst = false;
 
            // loop over the whole set of Eta CMAs
            while (it != CMAs.end()) {
                // get the set of parameters for idenfying the first RPC strip
                unsigned int ID = (*it).second.id().Ixx_index();
                bool inversion = (*it).second.inversion();
                isFirst = (ID == 1 && inversion) || (ID == 0 && !inversion);
                unsigned int PADid = (*it).first.PAD_index();
                unsigned int cabling = UINT_MAX;
                if ((*it).second.get_cabling(CMAinput::Pivot, 0, 0, 0, cabling)) {
                    unsigned int RPC_strip = cabling % 100;
                    unsigned int RPC_chamber = (cabling / 100) % 100;
                    unsigned int RPC_layer = 0;
                    unsigned int RPC_station = (*it).second.whichCMAstation(CMAinput::Pivot);
                    unsigned int lvl1_sector = sector;
 
                    const RPC_CondCabling::RPCchamber* rpc = Sector.find_chamber(RPC_station, RPC_chamber);
                    std::string name = rpc->stationName();
                    int sEta = (side) ? rpc->stationEta() : -rpc->stationEta();
                    int sPhi = (logic_sector == 31) ? 1 : (logic_sector + 1) / 4 + 1;
                    int dR = rpc->doubletR();
                    int dZ = rpc->doubletZ();
                    int dP = (rpc->phiReadoutPannels() == 2) ? (logic_sector + 1) % 2 + 1 : 1;
 
                    // build the Level-1 code index
                    RPCdecoder decode(Eta, lvl1_sector, RPC_station, RPC_layer, RPC_chamber, RPC_strip);
 
                    // instanciate the corresponding RDO index
                    RDOindex rdo(PADid, decode.code(), name, sEta, sPhi, dR, dZ, dP, m_idHelperSvc->rpcIdHelper());
 
                    // compute the key for retrieving RDO into the map
                    int key = side * 10000 + logic_sector * 100 + PADid;
                    // insert the RDO into the map
                    std::pair<RpcCablingCondData::RDOmap::iterator, bool> ins =
                        writeCdo->m_RDOs.insert(RpcCablingCondData::RDOmap::value_type(key, rdo));
 
                    if (!ins.second) {
                        ATH_MSG_ERROR("RpcCablingCondData::RDOmap is false for stationName="
                                      << name << ", stationEta=" << sEta << ", stationPhi=" << sPhi << ", doubletR=" << dR
                                      << ", doubletZ=" << dZ << ", doubletPhi=" << dP);
                        return StatusCode::FAILURE;
                    }
 
                    ++nRDOentries;
                }
 
                else if (!(*it).second.get_cabling(CMAinput::Pivot, 0, 0, 0, cabling) && isFirst) {
                    // try to catch configrm cabling
                    bool existLow = false;
                    bool existHigh = false;
 
                    if (!(existLow = (*it).second.get_cabling(CMAinput::LowPt, 0, 0, 0, cabling)))
                        existHigh = (*it).second.get_cabling(CMAinput::HighPt, 0, 0, 0, cabling);
 
                    if (!existLow && !existHigh) {
                        ATH_MSG_ERROR("Error while configuring the RDO map");
                        return StatusCode::FAILURE;
                    }
 
                    unsigned int RPC_strip = cabling % 100;
                    unsigned int RPC_chamber = (cabling / 100) % 100;
                    unsigned int RPC_layer = 0;
                    unsigned int RPC_station = 0;
                    if (existLow)
                        RPC_station = (*it).second.whichCMAstation(CMAinput::LowPt);
                    else
                        RPC_station = (*it).second.whichCMAstation(CMAinput::HighPt);
                    unsigned int lvl1_sector = sector;
 
                    const RPC_CondCabling::RPCchamber* rpc = Sector.find_chamber(RPC_station, RPC_chamber);
                    std::string name = rpc->stationName();
                    int sEta = (side) ? rpc->stationEta() : -rpc->stationEta();
                    int sPhi = (logic_sector == 31) ? 1 : (logic_sector + 1) / 4 + 1;
                    int dR = rpc->doubletR();
                    int dZ = rpc->doubletZ();
                    int dP = (rpc->phiReadoutPannels() == 2) ? (logic_sector + 1) % 2 + 1 : 1;
 
                    // build the Level-1 code index
                    RPCdecoder decode(Eta, lvl1_sector, RPC_station, RPC_layer, RPC_chamber, RPC_strip);
 
                    // instanciate the corresponding RDO index
                    RDOindex rdo(PADid, decode.code(), name, sEta, sPhi, dR, dZ, dP, m_idHelperSvc->rpcIdHelper());
 
                    // compute the key for retrieving RDO into the map
                    int key = side * 10000 + logic_sector * 100 + PADid;
 
                    // insert the RDO into the map
                    std::pair<RpcCablingCondData::RDOmap::iterator, bool> ins =
                        writeCdo->m_RDOs.insert(RpcCablingCondData::RDOmap::value_type(key, rdo));
 
                    if (!ins.second) {
                        ATH_MSG_ERROR("RpcCablingCondData::RDOmap is false for stationName="
                                      << name << ", stationEta=" << sEta << ", stationPhi=" << sPhi << ", doubletR=" << dR
                                      << ", doubletZ=" << dZ << ", doubletPhi=" << dP);
                        return StatusCode::FAILURE;
                    }
 
                    ++nRDOentries;
                }
 
                // increase the iterator
                while (it != CMAs.end() && (unsigned int)(*it).first.PAD_index() == PADid) { ++it; }
            }
        }
        ATH_MSG_DEBUG("setup() - sector " << sector << ", number of associated RDO (i.e. Pads) = " << nRDOentries);
    }
 
    DBline data_corr(MAP_corr);
    nlines = 0;
    while (++data_corr) {
        ++nlines;
        unsigned short int SubId;
        unsigned short int SecId;
        unsigned short int PADId;
        unsigned short int CMAId;
        unsigned short int ijk;
        unsigned short int inputType;
        unsigned int layer;
        unsigned int type;
        unsigned short int Channel1;
        unsigned short int Channel2;
        int Number;
 
        if (data_corr("CABLE") >> data_corr.dbhex() >> SubId >> SecId >> PADId >> CMAId >> ijk >> data_corr.dbdec() >> type >> Channel1 >>
            Channel2 >> Number) {
            bool ok = CableParamCheck(SubId, SecId, PADId, CMAId, ijk, type, Channel1, Channel2, Number);
 
            layer = (ijk == 0 || ijk == 2 || ijk == 3) ? 0 : 1;
 
            if (ijk > 1) {
                Channel1 += 32 * (ijk % 2);
                Channel2 += 32 * (ijk % 2);
            }
 
            unsigned short int lh = (CMAId >> 2) & 1;
 
            if (ijk == 0 || ijk == 1)
                inputType = 1;
            else
                inputType = (lh) ? 2 : 0;
 
            if (ijk > 5) inputType = 3;
            if (type > 3) type = 4;
 
            if (ok && !correct(SubId, SecId, PADId, CMAId, static_cast<CMAinput>(inputType), layer, Channel1, Channel2, Number,
                               static_cast<L1RPCcabCorrection>(type), sectorMap, sectorType)) {
                ATH_MSG_WARNING("Cannot apply correction: "
                                << std::hex << std::setw(4) << std::showbase << SubId << " " << std::setw(4) << std::showbase << SecId
                                << " " << std::setw(3) << std::showbase << PADId << " " << std::setw(3) << std::showbase << CMAId << " "
                                << std::setw(3) << std::showbase << ijk << "  " << std::dec << std::setw(1) << std::showbase << type << " "
                                << std::setw(2) << std::showbase << Channel1 << " " << std::setw(2) << std::showbase << Channel2 << " "
                                << std::setw(2) << std::showbase << Number);
            }
        }
        if (data_corr("BOARD") >> data_corr.dbhex() >> SubId >> SecId >> PADId >> CMAId >> data_corr.dbdec() >> inputType >> layer >>
            type >> Channel1 >> Channel2 >> Number) {
            bool ok = BoardParamCheck(SubId, SecId, PADId, CMAId, inputType, layer, type, Channel1, Channel2, Number);
 
            if (inputType > 2) inputType = 3;
            if (type > 3) type = 4;
 
            if (ok && !correct(SubId, SecId, PADId, CMAId, static_cast<CMAinput>(inputType), layer, Channel1, Channel2, Number,
                               static_cast<L1RPCcabCorrection>(type), sectorMap, sectorType)) {
                ATH_MSG_WARNING("Cannot apply correction: "
                                << std::hex << std::setw(4) << std::showbase << SubId << " " << std::setw(4) << std::showbase << SecId
                                << " " << std::setw(3) << std::showbase << PADId << " " << std::setw(3) << std::showbase << CMAId << "  "
                                << std::dec << std::setw(1) << inputType << " " << std::setw(1) << layer << " " << std::dec << std::setw(1)
                                << std::showbase << type << " " << std::setw(2) << std::showbase << Channel1 << " " << std::setw(2)
                                << std::showbase << Channel2 << " " << std::setw(2) << std::showbase << Number);
            }
        }
    }
    ATH_MSG_DEBUG("setup() - corrected map n. of lines read is " << nlines);
    ATH_MSG_DEBUG("setup() - " << m_readKey_map_schema_corr.key() << " maps have been parsed");
 
    for (int side = 0; side < 2; ++side) {
        for (int rod = 0; rod < 16; ++rod) { (writeCdo->m_rod2hash[side][rod]).clear(); }
    }
 
    int hashID = 0;
    std::set<uint32_t> ROBid;
    IdContext rpcModuleContext = m_idHelperSvc->rpcIdHelper().module_context();
 
    // reserve enough space in the hash-vector
    writeCdo->m_HashVec.reserve(writeCdo->m_RDOs.size());
 
    ATH_MSG_INFO("setup() - start building OfflineOnlineMap for " << writeCdo->m_RDOs.size() << " RDOs");
 
    RpcCablingCondData::RDOmap::iterator pad_beg = writeCdo->m_RDOs.begin();
    RpcCablingCondData::RDOmap::iterator pad_end = writeCdo->m_RDOs.end();
    for (; pad_beg != pad_end; ++pad_beg) {
        const RDOindex* pRDOindex = &((*pad_beg).second);
        (*pad_beg).second.set_hash(hashID);
 
        // get pointer to RDOindex class
        writeCdo->m_HashVec.push_back(pRDOindex);
 
        if (writeCdo->m_HashVec.size() != pRDOindex->hash() + 1) {
            ATH_MSG_ERROR("Size of hash vector and RDO hash does not match");
            return StatusCode::FAILURE;
        }
 
        // calculate  m_fullListOfRobIds
        const unsigned short int rob_id = pRDOindex->ROBid();
        const unsigned short int rod_id = pRDOindex->RODid();
        const unsigned short int sub_id = pRDOindex->side();
        const unsigned short int sec_id = pRDOindex->SLid();
        const unsigned short int pad_id = pRDOindex->PADid();
 
        uint32_t ROD_ID = (sub_id << 16) | rod_id;
        uint32_t ROB_ID = (sub_id << 16) | rob_id;
 
        ROBid.insert(ROB_ID);
        unsigned short int sub_id_index = ((sub_id == 0x65) ? 1 : 0);  // convert 0x65 -> 1 (side A) and 0x66 -> 0 (side C)
 
        Identifier id;
        pRDOindex->pad_identifier(id);
 
        ATH_MSG_DEBUG(hashID << "-th entry has sub_id_index=" << sub_id_index << ", ROBid=" << rob_id << ", RODid=" << rod_id << ", side="
                             << sub_id << ", SLid=" << sec_id << ", PADid=" << pad_id << ", pad_identifier=" << id.get_compact());
 
        // build the offline_id vector
        writeCdo->m_offline_id[sub_id_index][sec_id][pad_id] = id;
 
        // build the map
        std::pair<RpcCablingCondData::OfflineOnlineMap::iterator, bool> ins =
            writeCdo->m_RDOmap.insert(RpcCablingCondData::OfflineOnlineMap::value_type(id, pRDOindex));
        ATH_MSG_DEBUG("OfflineOnlineMap new entry: Identifier with technology="
                      << m_idHelperSvc->rpcIdHelper().technology(id) << ", stationName=" << m_idHelperSvc->rpcIdHelper().stationName(id)
                      << ", stationEta=" << m_idHelperSvc->rpcIdHelper().stationEta(id) << ", stationPhi="
                      << m_idHelperSvc->rpcIdHelper().stationPhi(id) << ", doubletR=" << m_idHelperSvc->rpcIdHelper().doubletR(id)
                      << ", doubletZ=" << m_idHelperSvc->rpcIdHelper().doubletZ(id) << ", doubletPhi="
                      << m_idHelperSvc->rpcIdHelper().doubletPhi(id) << " and hash of the RDOindex(key)= " << pRDOindex->hash());
        if (!ins.second) {
            ATH_MSG_ERROR("RpcCablingCondData::OfflineOnlineMap is false for technology="
                          << m_idHelperSvc->rpcIdHelper().technology(id) << ", stationName=" << m_idHelperSvc->rpcIdHelper().stationName(id)
                          << ", stationEta=" << m_idHelperSvc->rpcIdHelper().stationEta(id) << ", stationPhi="
                          << m_idHelperSvc->rpcIdHelper().stationPhi(id) << ", doubletR=" << m_idHelperSvc->rpcIdHelper().doubletR(id)
                          << ", doubletZ=" << m_idHelperSvc->rpcIdHelper().doubletZ(id) << ", doubletPhi="
                          << m_idHelperSvc->rpcIdHelper().doubletPhi(id) << " and hash of the RDOindex(key)= " << pRDOindex->hash());
            return StatusCode::FAILURE;
        }
 
        // build the ROB->RDO map
        std::pair<std::set<IdentifierHash>::iterator, bool> insert_ROB_RDO_returnVal =
            writeCdo->m_ROB_RDO_map[ROB_ID].insert(IdentifierHash(pRDOindex->hash()));
        if (insert_ROB_RDO_returnVal.second)
            ATH_MSG_DEBUG("A new RDO HashId = " << pRDOindex->hash() << " registered for ROB Id = " << ROB_ID);
        else
            ATH_MSG_VERBOSE("The RDO HashId = " << pRDOindex->hash() << " was already registered for ROB Id = " << ROB_ID);
 
        // build the PRD->RDO and PRD->ROB maps
        ATH_MSG_VERBOSE("Looking for PRDs corresponding to this RDO");
        std::list<Identifier> strip_id_list;
        IdentifierHash rdoHashId((IdentifierHash::value_type)pRDOindex->hash());
        ATH_MSG_DEBUG("RDO HashId = " << (int)rdoHashId << " RDO Id = " << id.get_compact() << " ROB Id = " << MSG::hex << ROB_ID
                                      << MSG::dec << " ROD Id = " << MSG::hex << ROD_ID << MSG::dec);
 
        for (unsigned short int CMAId : {2, 3, 6, 7}) {  // loop over phi CMA IDs
            for (unsigned short int ijk : {1, 2, 3}) {   // loop over IJK identifiers
                strip_id_list.clear();
                for (unsigned short int channel : {0, 31}) {  // check for the first and the last channel
                    strip_id_list.splice(strip_id_list.end(),
                                         give_strip_id(sub_id_index, sec_id, pad_id, CMAId, ijk, channel, sectorMap, sectorType));
                }
                for (Identifier strip_id : strip_id_list) {
                    Identifier idp = m_idHelperSvc->rpcIdHelper().parentID(strip_id);
                    IdentifierHash prdHashId;
                    int gethash_code = m_idHelperSvc->rpcIdHelper().get_hash(idp, prdHashId, &rpcModuleContext);
                    if (gethash_code != 0) {
                        ATH_MSG_DEBUG("Unable to get the PRD HashId! parentID(strip_id)=" << idp.getString());
                        continue;
                    }
 
                    // fill the PRD->RDO map
                    std::pair<std::set<IdentifierHash>::iterator, bool> insertRDO_returnVal =
                        writeCdo->m_PRD_RDO_map[prdHashId].insert(rdoHashId);
                    if (insertRDO_returnVal.second) {
                        ATH_MSG_DEBUG("A new RDO HashId = " << (int)rdoHashId << " registered for PRD HashId = " << (int)prdHashId);
                    } else {
                        ATH_MSG_VERBOSE("The RDO HashId = " << (int)rdoHashId
                                                            << " was already registered for PRD HashId = " << (int)prdHashId);
                    }
 
                    // fill the PRD->ROB map
                    std::pair<std::set<uint32_t>::iterator, bool> insertROB_returnVal = writeCdo->m_PRD_ROB_map[prdHashId].insert(ROB_ID);
                    if (insertROB_returnVal.second) {
                        ATH_MSG_DEBUG("A new ROB Id = " << MSG::hex << ROB_ID << MSG::dec
                                                        << " registered for PRD HashId = " << (int)prdHashId);
                    } else {
                        ATH_MSG_VERBOSE("The ROB Id = " << MSG::hex << ROB_ID << MSG::dec
                                                        << " was already registered for PRD HashId = " << (int)prdHashId);
                    }
                }
            }
        }
 
        // Trigger Roads Header
        std::map<std::string, std::string>::const_iterator it;
        it = trigroads.find("infos.txt");
        if (it == trigroads.end()) {
            ATH_MSG_WARNING("Missing HEADER FILE infos.txt");
        } else {
            ATH_MSG_VERBOSE("======== RPC Trigger Roads from COOL - Header infos ========");
            ATH_MSG_VERBOSE("\n" + it->second + "\n");
            // Read FeetPadThresholds from infos.txt
            if (!m_ForceFeetPadThresholdsFromJO) {
                std::stringstream ss;
                ss << it->second;
                std::string word;
                while (ss >> word) {
                    if (word == "FeetPadThresholds") {
                        feedPadThresholds.assign(3, 0);
                        ss >> feedPadThresholds.at(0);
                        ss >> feedPadThresholds.at(1);
                        ss >> feedPadThresholds.at(2);
                        ATH_MSG_VERBOSE("FeetPadThresholds set from COOL to: " << feedPadThresholds.at(0) << "," << feedPadThresholds.at(1)
                                                                               << "," << feedPadThresholds.at(2));
                    }
                }
            }
        }
 
        // ------ begin like  PCcablingInterface::RpcPadIdHash::RpcPadIdHash()
        RDOindex index = (*pad_beg).second;
        index.pad_identifier(id);
 
        writeCdo->m_int2id.push_back(id);
 
        if (writeCdo->m_int2id.size() != index.hash() + 1) {
            ATH_MSG_ERROR("Inconsistence between PAD hash and RpcPadIdHash");
            ATH_MSG_ERROR(index);
            ATH_MSG_ERROR("Position into RpcPadIdHash map is " << writeCdo->m_int2id.size() - 1);
            return StatusCode::FAILURE;
        }
 
        unsigned short int side = index.side();
        unsigned short int rod = index.RODid();
 
        if (rod > 15) {
            ATH_MSG_ERROR("RPC ROD greater than 15");
            return StatusCode::FAILURE;
        }
 
        IdentifierHash HashID = index.hash();
 
        (writeCdo->m_rod2hash[(side == 0x66) ? 0 : 1][rod]).push_back(HashID);
 
        writeCdo->m_lookup[id] = index.hash();
 
        ATH_MSG_DEBUG("RDO loop entry " << hashID << " done");
        ++hashID;
    }
    ATH_MSG_DEBUG("setup() - start recording RpcCablingCondData");
 
    // this must be done both in case of source = COOL or ASCII
    // -----  Initialization of Pad configuration ------ //
    if (m_ApplyFeetPadThresholds) {
        if (feedPadThresholds.size() != 3) {
            // if thresholds vector empty, set it to default
            feedPadThresholds.assign(3, 0);
            feedPadThresholds.at(0) = 0;
            feedPadThresholds.at(1) = 2;
            feedPadThresholds.at(2) = 5;
        }
        ATH_MSG_INFO("Applying FeetPadThresholds : " << feedPadThresholds.at(0) << "," << feedPadThresholds.at(1) << ","
                                                     << feedPadThresholds.at(2));
 
        const unsigned int NumFeetSectors = 8;
        unsigned int FeetSectors[NumFeetSectors] = {21, 22, 25, 26, 53, 54, 57, 58};
        const unsigned int NumSpecialFeetPads = 4;
        unsigned int SpecialFeetPads[NumSpecialFeetPads] = {2, 4, 5, 7};
 
        for (unsigned int is = 0; is < NumFeetSectors; is++) {
            for (unsigned int it = 0; it < NumSpecialFeetPads; it++) {
                writeCdo->m_RPCPadParameters_array[FeetSectors[is]][SpecialFeetPads[it]].set_feet_on(true);
                for (unsigned int th = 0; th < 3; th++) {
                    writeCdo->m_RPCPadParameters_array[FeetSectors[is]][SpecialFeetPads[it]].set_feet_threshold(th,
                                                                                                                feedPadThresholds.at(th));
                }
            }
        }
    }
 
    // reserve enough space
    writeCdo->m_fullListOfRobIds.reserve(ROBid.size());
    for (uint32_t robid : ROBid) writeCdo->m_fullListOfRobIds.push_back(robid);
 
    ATH_MSG_DEBUG("Number of valid RPC Pad IDs " << writeCdo->m_int2id.size());
 
    for (int i = 0; i < 64; i++) writeCdo->m_SectorMap[i] = sectorMap[i];
    writeCdo->m_SectorType = std::move(sectorType);
    writeCdo->m_MaxType = maxType;
 
    if (msgLvl(MSG::DEBUG)) {
        std::stringstream ss1;
        ss1 << "Level-1 configuration database " << std::endl;
        ss1 << "Contains " << maxType << " Trigger Sector Types:" << std::endl;
        ss1 << "negative sectors  0 - 15 ==> ";
        for (int i = 0; i < 16; i++) ss1 << std::setw(2) << sectorMap[i] << " ";
        ss1 << std::endl << "negative sectors 16 - 31 ==> ";
        for (int i = 16; i < 32; i++) ss1 << std::setw(2) << sectorMap[i] << " ";
        ss1 << std::endl << "positive sectors 32 - 47 ==> ";
        for (int i = 32; i < 48; i++) ss1 << std::setw(2) << sectorMap[i] << " ";
        ss1 << std::endl << "positive sectors 48 - 63 ==> ";
        for (int i = 48; i < 64; i++) ss1 << std::setw(2) << sectorMap[i] << " ";
        ss1 << std::endl;
        ATH_MSG_DEBUG(ss1.str());
    }
 
    // record
    if (writeCdo->m_RDOs.empty()) {
        ATH_MSG_ERROR("Could not read any map configuration");
        return StatusCode::FAILURE;
    }
    if (writeCdo->m_HashVec.empty()) {
        ATH_MSG_ERROR("Could not read any HashID");
        return StatusCode::FAILURE;
    }
    if (writeCdo->m_SectorType.empty()) {
        ATH_MSG_ERROR("Could not read any sectorMap");
        return StatusCode::FAILURE;
    }
    if (writeCdo->m_int2id.empty()) {
        ATH_MSG_ERROR("Could not read any HashID");
        return StatusCode::FAILURE;
    }
    if (writeCdo->m_lookup.empty()) {
        ATH_MSG_ERROR("Could not read any HashID");
        return StatusCode::FAILURE;
    }
    if (writeCdo->m_fullListOfRobIds.empty()) {
        ATH_MSG_ERROR("Could not read any HashID");
        return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("setup() - RpcCablingCondData recorded");
    return StatusCode::SUCCESS;
}

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_ApplyFeetPadThresholds

Gaudi::Property<bool> RpcCablingCondAlg::m_ApplyFeetPadThresholds

private

Initial value:

{this, "ApplyFeetPadThresholds", true,
                                                   "map 3 low pt thresholds from special feet pads on standard 6 (3low+3high)"}

Definition at line 49 of file RpcCablingCondAlg.h.

                                                {this, "ApplyFeetPadThresholds", true,
                                                   "map 3 low pt thresholds from special feet pads on standard 6 (3low+3high)"};

m_cosmic_configuration

Gaudi::Property<bool> RpcCablingCondAlg::m_cosmic_configuration {this, "CosmicConfiguration", false}

private

Definition at line 48 of file RpcCablingCondAlg.h.

{this, "CosmicConfiguration", false};

m_database_repository

Gaudi::Property<std::string> RpcCablingCondAlg::m_database_repository {this, "DatabaseRepository", "MuonRPC_Cabling/ATLAS.data"}

private

Definition at line 47 of file RpcCablingCondAlg.h.

{this, "DatabaseRepository", "MuonRPC_Cabling/ATLAS.data"};

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_ForceFeetPadThresholdsFromJO

Gaudi::Property<bool> RpcCablingCondAlg::m_ForceFeetPadThresholdsFromJO {this, "ForceFeetPadThresholdsFromJO", false, "JO override db setting"}

private

Definition at line 51 of file RpcCablingCondAlg.h.

{this, "ForceFeetPadThresholdsFromJO", false, "JO override db setting"};

m_idHelperSvc

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

private

Definition at line 33 of file RpcCablingCondAlg.h.

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

m_readKey_cm_thr_eta

SG::ReadCondHandleKey<CondAttrListCollection> RpcCablingCondAlg::m_readKey_cm_thr_eta

private

Initial value:

{this, "ReadKeyThrEta", "/RPC/TRIGGER/CM_THR_ETA",
                                                                       "Key of input muon rpc trigger eta condition data"}

Definition at line 39 of file RpcCablingCondAlg.h.

                                                                    {this, "ReadKeyThrEta", "/RPC/TRIGGER/CM_THR_ETA",
                                                                       "Key of input muon rpc trigger eta condition data"};

m_readKey_cm_thr_phi

SG::ReadCondHandleKey<CondAttrListCollection> RpcCablingCondAlg::m_readKey_cm_thr_phi

private

Initial value:

{this, "ReadKeyThrPhi", "/RPC/TRIGGER/CM_THR_PHI",
                                                                       "Key of input muon rpc trigger phi condition data"}

Definition at line 41 of file RpcCablingCondAlg.h.

                                                                    {this, "ReadKeyThrPhi", "/RPC/TRIGGER/CM_THR_PHI",
                                                                       "Key of input muon rpc trigger phi condition data"};

m_readKey_map_schema

SG::ReadCondHandleKey<CondAttrListCollection> RpcCablingCondAlg::m_readKey_map_schema

private

Initial value:

{this, "ReadKeySchema", "/RPC/CABLING/MAP_SCHEMA",
                                                                       "Key of input muon rpc map schema condition data"}

Definition at line 35 of file RpcCablingCondAlg.h.

                                                                    {this, "ReadKeySchema", "/RPC/CABLING/MAP_SCHEMA",
                                                                       "Key of input muon rpc map schema condition data"};

m_readKey_map_schema_corr

SG::ReadCondHandleKey<CondAttrListCollection> RpcCablingCondAlg::m_readKey_map_schema_corr

private

Initial value:

{this, "ReadKeySchemaCorr", "/RPC/CABLING/MAP_SCHEMA_CORR",
                                                                            "Key of input muon rpc map correction schema condition data"}

Definition at line 37 of file RpcCablingCondAlg.h.

                                                                         {this, "ReadKeySchemaCorr", "/RPC/CABLING/MAP_SCHEMA_CORR",
                                                                            "Key of input muon rpc map correction schema condition data"};

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<RpcCablingCondData> RpcCablingCondAlg::m_writeKey

private

Initial value:

{this, "WriteKey", "RpcCablingCondData",
                                                          "Key of output RPC cabling condition data"}

Definition at line 44 of file RpcCablingCondAlg.h.

                                                       {this, "WriteKey", "RpcCablingCondData",
                                                          "Key of output RPC cabling condition data"};

---

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

• RpcCablingCondAlg.h
• RpcCablingCondAlg.cxx