#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 () override

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

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 > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 20 of file RpcCablingCondAlg.h.

Member Typedef Documentation

◆ sectorMap_t

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

private

Definition at line 29 of file RpcCablingCondAlg.h.

◆ SLmap_t

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

private

Definition at line 30 of file RpcCablingCondAlg.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< 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 11 of file RpcCablingCondAlg.cxx.

11 : AthAlgorithm(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;
 }

◆ 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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & 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< Algorithm > >::detStore ( ) const

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode RpcCablingCondAlg::execute ( )

overridevirtual

Definition at line 24 of file RpcCablingCondAlg.cxx.

                                       {
     
     const EventContext& ctx = Gaudi::Hive::currentContext();
     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< 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 & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.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 Algorithm::extraOutputDeps();
 }

◆ 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(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 13 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< 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.

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< 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< 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< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

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

◆ sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                        {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::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< 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< 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 48 of file RpcCablingCondAlg.h.

◆ m_cosmic_configuration

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

private

Definition at line 47 of file RpcCablingCondAlg.h.

◆ m_database_repository

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

private

Definition at line 46 of file RpcCablingCondAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< 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< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_ForceFeetPadThresholdsFromJO

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

private

Definition at line 50 of file RpcCablingCondAlg.h.

◆ m_idHelperSvc

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

private

Definition at line 32 of file RpcCablingCondAlg.h.

◆ 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 38 of file RpcCablingCondAlg.h.

◆ 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 40 of file RpcCablingCondAlg.h.

◆ 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 34 of file RpcCablingCondAlg.h.

◆ 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 36 of file RpcCablingCondAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< 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 43 of file RpcCablingCondAlg.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ sectorMap_t

◆ SLmap_t

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ RpcCablingCondAlg()

◆ ~RpcCablingCondAlg()

Member Function Documentation

◆ BoardParamCheck()

◆ CableParamCheck()

◆ correct()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ give_strip_id()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setup()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_ApplyFeetPadThresholds

◆ m_cosmic_configuration

◆ m_database_repository

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_ForceFeetPadThresholdsFromJO

◆ m_idHelperSvc

◆ m_readKey_cm_thr_eta

◆ m_readKey_cm_thr_phi

◆ m_readKey_map_schema

◆ m_readKey_map_schema_corr

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_writeKey