PixelConditionsSummaryTool Class Reference

#include <PixelConditionsSummaryTool.h>

Inheritance diagram for PixelConditionsSummaryTool:

Public Member Functions
	PixelConditionsSummaryTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~PixelConditionsSummaryTool ()
virtual StatusCode	initialize () override
virtual bool	isActive (const Identifier &elementId, const InDetConditions::Hierarchy h, const EventContext &ctx) const override final
virtual bool	isActive (const IdentifierHash &moduleHash, const EventContext &ctx) const override final
virtual bool	isActive (const IdentifierHash &moduleHash, const Identifier &elementId, const EventContext &ctx) const override final
virtual double	activeFraction (const IdentifierHash &moduleHash, const Identifier &idStart, const Identifier &idEnd, const EventContext &ctx) const override final
virtual bool	isGood (const Identifier &elementId, const InDetConditions::Hierarchy h, const EventContext &ctx) const override final
virtual bool	isGood (const IdentifierHash &moduleHash, const EventContext &ctx) const override final
virtual bool	isGood (const IdentifierHash &moduleHash, const Identifier &elementId, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
virtual double	goodFraction (const IdentifierHash &moduleHash, const Identifier &idStart, const Identifier &idEnd, const EventContext &ctx) const override final
virtual std::unique_ptr< InDet::SiDetectorElementStatus >	getDetectorElementStatus (const EventContext &ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const override
	get the module and chip status of Si detector elements
virtual bool	hasBSError (const IdentifierHash &moduleHash, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
virtual bool	hasBSError (const IdentifierHash &moduleHash, Identifier pixid, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
virtual uint64_t	getBSErrorWord (const IdentifierHash &moduleHash, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
virtual uint64_t	getBSErrorWord (const IdentifierHash &moduleHash, const int index, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
virtual IDCCacheEntry *	getCacheEntryOut (const EventContext &ctx) const override final
bool	checkChipStatus (IdentifierHash moduleHash, Identifier pixid, 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	sysInitialize () override
	Perform system initialization for an algorithm.
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
	DeclareInterfaceID (IInDetConditionsTool, 1, 0)
	Creates the InterfaceID and interfaceID() method.

Static Public Member Functions
static InterfaceID &	interfaceID ()
static EventIDBase	getUndefinedEventId ()
static EventIDRange	getInvalidRange ()

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 ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
uint64_t	getBSErrorWord (const InDetDD::PixelModuleDesign *p_design, const int index, const EventContext &ctx, const IInDetConditionsTool::IDCCacheEntry *cacheEntry) const
bool	hasBSError (const InDetDD::PixelModuleDesign *p_design, const IdentifierHash &moduleHash, const EventContext &ctx, const IInDetConditionsTool::IDCCacheEntry *cacheEntry) const
const InDetDD::SiDetectorElement *	getDetectorEelement (const IdentifierHash &moduleHash, const EventContext &ctx) const
const IDCInDetBSErrContainer *	getContainer (const EventContext &ctx) const
	Obtains container form the SG, if it is missing it will complain (hard-coded 3 times per job) and return nullptr.
IDCCacheEntry *	getCacheEntry (const EventContext &ctx) const
	Return cache for the current event If, for current slot, the cache is outdated it is retrieved from the IDC collection.
std::unique_ptr< InDet::SiDetectorElementStatus >	createDetectorElementStatus (const EventContext &ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const
	Create a new detector element status element container.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const PixelID *	m_pixelID {}
std::vector< std::string >	m_isActiveStatus
std::vector< std::string >	m_isActiveStates
std::vector< int >	m_activeState
std::vector< int >	m_activeStatus
unsigned int	m_activeStateMask {}
	mask in which each state is represented by a bit and for states which are cnsidered active the corresponding bit is set;
unsigned int	m_activeStatusMask {}
	mask in which each status is represented by a bit and for status values which are cnsidered active the corresponding bit is set;
Gaudi::Property< bool >	m_useByteStreamFEI4 {this, "UseByteStreamFEI4", false, "Switch of the ByteStream error for FEI4"}
Gaudi::Property< bool >	m_useByteStreamFEI3 {this, "UseByteStreamFEI3", false, "Switch of the ByteStream error for FEI3"}
Gaudi::Property< bool >	m_useByteStreamRD53 {this, "UseByteStreamRD53", false, "Switch of the ByteStream error for RD53"}
SG::ReadCondHandleKey< PixelDCSStateData >	m_condDCSStateKey {this, "PixelDCSStateCondData", "PixelDCSStateCondData", "Pixel FSM state key"}
SG::ReadCondHandleKey< PixelDCSStatusData >	m_condDCSStatusKey {this, "PixelDCSStatusCondData", "PixelDCSStatusCondData", "Pixel FSM status key"}
SG::ReadCondHandleKey< PixelTDAQData >	m_condTDAQKey {this, "PixelTDAQCondData", "", "Pixel TDAQ conditions key"}
SG::ReadCondHandleKey< PixelDeadMapCondData >	m_condDeadMapKey {this, "PixelDeadMapCondData", "PixelDeadMapCondData", "Pixel deadmap conditions key"}
SG::ReadHandleKey< IDCInDetBSErrContainer >	m_BSErrContReadKey {this, "PixelByteStreamErrs", "PixelByteStreamErrs", "PixelByteStreamErrs container key"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}
SG::ReadHandleKey< InDet::SiDetectorElementStatus >	m_pixelDetElStatusEventKey {this, "PixelDetElStatusEventDataBaseKey", "", "Optional event data key of an input SiDetectorElementStatus on which the newly created object will be based."}
SG::ReadCondHandleKey< InDet::SiDetectorElementStatus >	m_pixelDetElStatusCondKey {this, "PixelDetElStatusCondDataBaseKey", "" , "Optional conditions data key of an input SiDetectorElementStatus on which the newly created object will be based."}
Gaudi::Property< bool >	m_activeOnly {this, "ActiveOnly", false, "Module and chip status will only reflect whether the modules or chips are active not necessarily whether the signals are good."}
const uint64_t	m_missingErrorInfo {std::numeric_limits<uint64_t>::max()-3000000000}
SG::SlotSpecificObj< std::mutex > m_cacheMutex	ATLAS_THREAD_SAFE
SG::SlotSpecificObj< IDCCacheEntry > m_eventCache	ATLAS_THREAD_SAFE
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 49 of file PixelConditionsSummaryTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

PixelConditionsSummaryTool()

PixelConditionsSummaryTool::PixelConditionsSummaryTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 9 of file PixelConditionsSummaryTool.cxx.

  :AthAlgTool(type, name, parent),
  m_pixelID(nullptr)
{
  m_isActiveStatus.emplace_back("OK");
  m_isActiveStates.emplace_back("READY");
 
  declareProperty("IsActiveStatus", m_isActiveStatus);
  declareProperty("IsActiveStates", m_isActiveStates);
}

~PixelConditionsSummaryTool()

PixelConditionsSummaryTool::~PixelConditionsSummaryTool ( )

virtualdefault

Member Function Documentation

activeFraction()

double PixelConditionsSummaryTool::activeFraction ( const IdentifierHash & moduleHash, const Identifier & idStart, const Identifier & idEnd, const EventContext & ctx ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 266 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                                   {
  return 1.0;
}

checkChipStatus()

bool PixelConditionsSummaryTool::checkChipStatus ( IdentifierHash moduleHash, Identifier pixid, const EventContext & ctx ) const

inline

Definition at line 181 of file PixelConditionsSummaryTool.h.

                                                                                                                                  {
  std::bitset<16> chipStatus(SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getChipStatus(moduleHash));
  if (chipStatus.any()) {
 
     const InDetDD::SiDetectorElement *element = getDetectorEelement(moduleHash,ctx);
     const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
 
     std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx
        = InDetDD::PixelDiodeTree::makeCellIndex(m_pixelID->phi_index(pixid),
                                                 m_pixelID->eta_index(pixid));
     InDetDD::PixelDiodeTree::DiodeProxy si_param ( p_design->diodeProxyFromIdx(diode_idx));
     std::uint32_t chFE = p_design->getFE(si_param);
 
    std::bitset<16> circ;
    circ.set(chFE);
    if ((chipStatus&circ).any()) { return false; }
  }
  return true;
}

createDetectorElementStatus()

std::unique_ptr< InDet::SiDetectorElementStatus > PixelConditionsSummaryTool::createDetectorElementStatus ( const EventContext & ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > * whandle ) const

private

Create a new detector element status element container.

Depending on the properties the container may be a copy of an event data or conditions data element status container.

Definition at line 330 of file PixelConditionsSummaryTool.cxx.

                                                                                                                         {
   if (!m_pixelDetElStatusCondKey.empty()) {
      SG::ReadCondHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusCondKey, ctx};
      if (whandle) {
        whandle->addDependency (input_element_status);
      }
      return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
   }
   else if (!m_pixelDetElStatusEventKey.empty()) {
      SG::ReadHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusEventKey, ctx};
      return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
   }
   else {
      SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
      if (not pixelDetEleHandle.isValid() ) {
         std::stringstream msg;
         msg << m_pixelDetEleCollKey.fullKey() << " is not available.";
         throw std::runtime_error(msg.str());
      }
      if (whandle) {
        whandle->addDependency (pixelDetEleHandle);
      }
      const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
      return std::make_unique<InDet::PixelDetectorElementStatus>(*elements);
   }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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());
 
  }

DeclareInterfaceID()

IInDetConditionsTool::DeclareInterfaceID ( IInDetConditionsTool , 1 , 0  )

inherited

Creates the InterfaceID and interfaceID() method.

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

getBSErrorWord() [1/3]

uint64_t PixelConditionsSummaryTool::getBSErrorWord ( const IdentifierHash & moduleHash, const EventContext & ctx, const IDCCacheEntry * cacheEntry = nullptr ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 115 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                                                        {
  return getBSErrorWord(moduleHash, moduleHash, ctx, cacheEntry);
}

getBSErrorWord() [2/3]

uint64_t PixelConditionsSummaryTool::getBSErrorWord ( const IdentifierHash & moduleHash, const int index, const EventContext & ctx, const IDCCacheEntry * cacheEntry = nullptr ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 134 of file PixelConditionsSummaryTool.cxx.

                                                                                                               {
   const InDetDD::SiDetectorElement *element = getDetectorEelement(moduleHash,ctx);
   const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
   return getBSErrorWord(p_design,index,ctx,cacheEntry);
}

getBSErrorWord() [3/3]

uint64_t PixelConditionsSummaryTool::getBSErrorWord ( const InDetDD::PixelModuleDesign * p_design, const int index, const EventContext & ctx, const IInDetConditionsTool::IDCCacheEntry * cacheEntry ) const

private

Definition at line 143 of file PixelConditionsSummaryTool.cxx.

                                                                                                               {
 
  if (!m_useByteStreamFEI4 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::FEI4) { return 0; }
  if (!m_useByteStreamFEI3 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::FEI3) { return 0; }
  if (!m_useByteStreamRD53 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::RD53) { return 0; }
 
  if (cacheEntry == nullptr){
    std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
    cacheEntry=getCacheEntry(ctx);
  }
  const auto *idcCachePtr = cacheEntry->IDCCache;
  if (idcCachePtr==nullptr) {
    ATH_MSG_ERROR("PixelConditionsSummaryTool No cache! " );
    return 0;
  }
  uint64_t word = (uint64_t)idcCachePtr->retrieve(index);
  return word<m_missingErrorInfo ? word : 0;
}

getCacheEntry()

IInDetConditionsTool::IDCCacheEntry * PixelConditionsSummaryTool::getCacheEntry ( const EventContext & ctx ) const

nodiscardprivate

Return cache for the current event If, for current slot, the cache is outdated it is retrieved from the IDC collection.

If the IDC is missing nullptr is returned.

Definition at line 94 of file PixelConditionsSummaryTool.cxx.

                                                                                                          {
  IDCCacheEntry* cacheEntry = m_eventCache.get(ctx);
  if (cacheEntry->needsUpdate(ctx)) {
    const auto *idcErrContPtr = getContainer(ctx);
    if (idcErrContPtr==nullptr) {     // missing or not, the cache needs to be reset
      cacheEntry->reset(ctx.evt(), nullptr);
    }
    else {
      cacheEntry->reset(ctx.evt(), idcErrContPtr->cache());
    }
    ATH_MSG_VERBOSE("PixelConditionsSummaryTool Cache for the event reset " << cacheEntry->eventId << " with IDC container" << idcErrContPtr);
  }
  return cacheEntry;
}

getCacheEntryOut()

IInDetConditionsTool::IDCCacheEntry * PixelConditionsSummaryTool::getCacheEntryOut ( const EventContext & ctx ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 109 of file PixelConditionsSummaryTool.cxx.

                                                                                                            {
  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
  IDCCacheEntry* cacheEntry = getCacheEntry(ctx);
  return cacheEntry;
}

getContainer()

const IDCInDetBSErrContainer * PixelConditionsSummaryTool::getContainer ( const EventContext & ctx ) const

nodiscardprivate

Obtains container form the SG, if it is missing it will complain (hard-coded 3 times per job) and return nullptr.

Definition at line 83 of file PixelConditionsSummaryTool.cxx.

                                                                                                    {
  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
  if (!useByteStream || m_BSErrContReadKey.empty() ) {
    return nullptr;
  }
  SG::ReadHandle<IDCInDetBSErrContainer> idcErrCont(m_BSErrContReadKey, ctx);
  if (not idcErrCont.isValid()) { return nullptr; }
  ATH_MSG_VERBOSE("PixelConditionsSummaryTool IDC Container fetched " << m_BSErrContReadKey.key());
  return idcErrCont.cptr();
}

getDetectorEelement()

const InDetDD::SiDetectorElement * PixelConditionsSummaryTool::getDetectorEelement ( const IdentifierHash & moduleHash, const EventContext & ctx ) const

private

Definition at line 119 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                               {
  if (moduleHash>=m_pixelID->wafer_hash_max()) {
    ATH_MSG_ERROR("invalid moduleHash : " << moduleHash << " exceed maximum hash id: " << m_pixelID->wafer_hash_max());
    return nullptr;
  }
 
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
  if (not pixelDetEleHandle.isValid() or elements==nullptr) {
    ATH_MSG_ERROR(m_pixelDetEleCollKey.fullKey() << " is not available.");
    return nullptr;
  }
  return elements->getDetectorElement(moduleHash);
}

getDetectorElementStatus()

std::unique_ptr< InDet::SiDetectorElementStatus > PixelConditionsSummaryTool::getDetectorElementStatus ( const EventContext & ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > * whandle ) const

overridevirtual

get the module and chip status of Si detector elements

Parameters

ctx	the current event contex
whandle	Pointer to the write handle for the conditions object being built, for propagation of IOV range and dependency information. Pass nullptr if we're building an object for event data, rather than conditions data.

Implements IDetectorElementStatusTool.

Definition at line 359 of file PixelConditionsSummaryTool.cxx.

                                                                                                                      {
   std::unique_ptr<InDet::SiDetectorElementStatus> element_status( createDetectorElementStatus(ctx, whandle));
   std::vector<bool> &status=element_status->getElementStatus();
   status.resize(m_pixelID->wafer_hash_max(),
                    ((1<<0) & m_activeStateMask)     // default value of PixelDCSStateData  is 0
                 );
   std::vector<InDet::ChipFlags_t> &chip_status=element_status->getElementChipStatus();
   chip_status.resize(status.size(),0);
 
   // module state
   {
      SG::ReadCondHandle<PixelDCSStateData> dcs_state_handle(m_condDCSStateKey, ctx);
      andStatus(dcs_state_handle->moduleStatusMap(),   m_activeStateMask,  status);
      if (whandle) {
        whandle->addDependency (dcs_state_handle);
      }
   }
   const bool active_only = m_activeOnly;
   if (!active_only) {
      SG::ReadCondHandle<PixelDCSStatusData> dcs_status_handle(m_condDCSStatusKey, ctx);
      andStatus(dcs_status_handle->moduleStatusMap(), m_activeStatusMask, status);
      if (whandle) {
        whandle->addDependency (dcs_status_handle);
      }
   }
   if (!m_condTDAQKey.empty()) {
      SG::ReadCondHandle<PixelTDAQData> tdaq_handle(m_condTDAQKey,ctx);
      andNotStatus(tdaq_handle->moduleStatusMap(), status);
      if (whandle) {
        whandle->addDependency (tdaq_handle);
      }
   }
   {
      SG::ReadCondHandle<PixelDeadMapCondData> dead_map_handle(m_condDeadMapKey, ctx);
      andNotStatus(dead_map_handle->moduleStatusMap(), status);
      if (whandle) {
        whandle->addDependency (dead_map_handle);
      }
 
      const PixelDeadMapCondData *dead_map = dead_map_handle.cptr();
      unsigned int element_i=0;
      for (const InDetDD::SiDetectorElement *element : element_status->getDetectorElements()) {
         if (status[element_i]) {
            const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
            InDetDD::PixelReadoutTechnology readout_technology = p_design->getReadoutTechnology();
            unsigned int number_of_chips = readout_technology == InDetDD::PixelReadoutTechnology::FEI3  ? 2*p_design->numberOfCircuits() : p_design->numberOfCircuits();
            InDet::ChipFlags_t  chip_mask = (1ul<<number_of_chips)-1ul;
            assert( chip_mask != 0 );
            std::bitset<16> dead_chip_mask(dead_map->getChipStatus(element_i));
            chip_status[element_i]  =   chip_mask & (~static_cast<InDet::ChipFlags_t>(dead_chip_mask.to_ulong()));
         }
         ++element_i;
      }
   }
 
 
   static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::FEI4) < 32u) ;
   static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::FEI3) < 32u) ;
   static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::RD53) < 32u) ;
   unsigned int readout_technology_mask=  Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI4, 1 && m_useByteStreamFEI4 )
      | Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI3, 1 && m_useByteStreamFEI3 )
      | Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::RD53, 1 && m_useByteStreamRD53 );
   if (readout_technology_mask) {
      if (whandle) {
        ATH_MSG_ERROR("PixelConditionsSummaryTool not configured for use with conditions objects");
        whandle->addDependency (IDetectorElementStatusTool::getInvalidRange());
      }
      std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
      const IDCInDetBSErrContainer_Cache *idcCachePtr = nullptr;
      idcCachePtr = getCacheEntry(ctx)->IDCCache;
      if (idcCachePtr==nullptr) {
         ATH_MSG_ERROR("PixelConditionsSummaryTool No cache! " );
      }
      else {
 
         constexpr uint64_t error_mask = PixelByteStreamErrors::makeError(PixelByteStreamErrors::TruncatedROB)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MaskedROB)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Preamble)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::TimeOut)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::LVL1ID)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::BCID)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Trailer)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDEoECheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCBCIDEoECheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDCheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCEoEOverflow)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCHitOverflow);
 
         constexpr uint64_t chip_error_mask = PixelByteStreamErrors::makeError(PixelByteStreamErrors::Preamble)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::TimeOut)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::LVL1ID)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::BCID)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Trailer)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDEoECheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCBCIDEoECheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDCheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCEoEOverflow)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCHitOverflow);
 
         // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
         // Here, 52736 is a separator beween error flags and isActive flags.
         unsigned int element_offset_i = (active_only ? 52736 : 0);
 
         unsigned int element_i=0;
         unsigned int maxHash = m_pixelID->wafer_hash_max();
         for (const InDetDD::SiDetectorElement *element : element_status->getDetectorElements()) {
            const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
            InDetDD::PixelReadoutTechnology readout_technology = p_design->getReadoutTechnology();
            unsigned int readout_technology_flags = readout_technology_mask & Pixel::makeReadoutTechnologyBit(readout_technology);
 
            // set to false if has one of the considered errors and the readout technology is considered.
            status.at(element_i) = status.at(element_i) &&  not (   readout_technology_flags
                                                                &&  ( !active_only
                                                                     ?  isBSError(static_cast<uint64_t>(idcCachePtr->retrieve(element_i)), m_missingErrorInfo, error_mask)
                                                                      : idcCachePtr->retrieve(element_i+element_offset_i)!=1 ));
 
            // compute the status for the individual front-ends
            if (status[element_i]) {
               unsigned int number_of_chips = readout_technology == InDetDD::PixelReadoutTechnology::FEI3  ? 2*p_design->numberOfCircuits() : p_design->numberOfCircuits();
               InDet::ChipFlags_t  chip_mask = status[element_i] ? (1ul<<number_of_chips)-1ul : 0;
               assert( chip_mask != 0 );
               InDet::ChipFlags_t bs_status_flags = active_only ? chip_mask : 0;
               if (!active_only) {
                  for (unsigned int chip_i =0; chip_i < number_of_chips; ++chip_i) {
                     // get bytestream error for chip
                     unsigned int indexFE = (1+chip_i)*maxHash + element_i;    // (FE_channel+1)*2048 + moduleHash
                     InDet::ChipFlags_t chip_flag =not (    readout_technology_flags
                                                        && (isBSError(static_cast<uint64_t>(idcCachePtr->retrieve(indexFE)), m_missingErrorInfo, chip_error_mask)));
                     bs_status_flags |= (chip_flag << chip_i);
                  }
               }
               chip_status[element_i] &=  (bs_status_flags & chip_mask);
            }
            else {
               chip_status[element_i] = 0;
            }
            ++element_i;
         }
      }
   }
   return element_status;
}

getInvalidRange()

EventIDRange IDetectorElementStatusTool::getInvalidRange ( )

inlinestaticinherited

Definition at line 33 of file IDetectorElementStatusTool.h.

{ return EventIDRange (getUndefinedEventId(),getUndefinedEventId()); }

getUndefinedEventId()

EventIDBase IDetectorElementStatusTool::getUndefinedEventId ( )

inlinestaticinherited

Definition at line 32 of file IDetectorElementStatusTool.h.

{ return EventIDBase (0, EventIDBase::UNDEFEVT, EventIDBase::UNDEFNUM, 0, 0); }

goodFraction()

double PixelConditionsSummaryTool::goodFraction ( const IdentifierHash & moduleHash, const Identifier & idStart, const Identifier & idEnd, const EventContext & ctx ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 557 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                                                      {
 
  if (!isGood(moduleHash, ctx)) { return 0.0; }
 
  Identifier moduleID = m_pixelID->wafer_id(moduleHash);
 
  int phiStart = m_pixelID->phi_index(idStart);
  int etaStart = m_pixelID->eta_index(idStart);
 
  int phiEnd = m_pixelID->phi_index(idEnd);
  int etaEnd = m_pixelID->eta_index(idEnd);
 
  double nTotal = (std::abs(phiStart-phiEnd)+1.0)*(std::abs(etaStart-etaEnd)+1.0);
 
  double nGood = 0.0;
  IInDetConditionsTool::IDCCacheEntry* cacheEntry = getCacheEntry(ctx);
  for (int i=std::min(phiStart,phiEnd); i<=std::max(phiStart,phiEnd); i++) {
    for (int j=std::min(etaStart,etaEnd); j<=std::max(etaStart,etaEnd); j++) {
      if (checkChipStatus(moduleHash, m_pixelID->pixel_id(moduleID,i,j), ctx)) { 
        if (!hasBSError(moduleHash, m_pixelID->pixel_id(moduleID,i,j), ctx, cacheEntry)) { nGood++; }
      }
    }
  }
  return nGood/nTotal;
}

hasBSError() [1/3]

bool PixelConditionsSummaryTool::hasBSError ( const IdentifierHash & moduleHash, const EventContext & ctx, const IDCCacheEntry * cacheEntry = nullptr ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 165 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                                                {
  const InDetDD::SiDetectorElement *element = getDetectorEelement(moduleHash,ctx);
  const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
  return hasBSError(p_design,moduleHash, ctx,cacheEntry);
}

hasBSError() [2/3]

bool PixelConditionsSummaryTool::hasBSError ( const IdentifierHash & moduleHash, Identifier pixid, const EventContext & ctx, const IDCCacheEntry * cacheEntry = nullptr ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 191 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                                                                  {
  const InDetDD::SiDetectorElement *element = getDetectorEelement(moduleHash,ctx);
  const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
 
  if (hasBSError(p_design, moduleHash, ctx, cacheEntry)) { return true; }
 
  int maxHash = m_pixelID->wafer_hash_max();
 
  std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx
     = InDetDD::PixelDiodeTree::makeCellIndex(m_pixelID->phi_index(pixid),
                                              m_pixelID->eta_index(pixid));
  InDetDD::PixelDiodeTree::DiodeProxy si_param ( p_design->diodeProxyFromIdx(diode_idx));
  std::uint32_t chFE = p_design->getFE(si_param);
 
  int indexFE = (1+chFE)*maxHash+static_cast<int>(moduleHash);    // (FE_channel+1)*2048 + moduleHash
  uint64_t word = getBSErrorWord(p_design,indexFE,ctx,cacheEntry);
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Preamble))          { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TimeOut))           { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::LVL1ID))            { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::BCID))              { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Trailer))           { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDEoECheck)) { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCBCIDEoECheck))   { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDCheck))    { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCEoEOverflow))    { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCHitOverflow))    { return true; }
  return false;
}

hasBSError() [3/3]

bool PixelConditionsSummaryTool::hasBSError ( const InDetDD::PixelModuleDesign * p_design, const IdentifierHash & moduleHash, const EventContext & ctx, const IInDetConditionsTool::IDCCacheEntry * cacheEntry ) const

private

Definition at line 171 of file PixelConditionsSummaryTool.cxx.

                                                                                                       {
  uint64_t word = getBSErrorWord(p_design,moduleHash, ctx,cacheEntry);
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TruncatedROB))      { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MaskedROB))         { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Preamble))          { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TimeOut))           { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::LVL1ID))            { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::BCID))              { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Trailer))           { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDEoECheck)) { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCBCIDEoECheck))   { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDCheck))    { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCEoEOverflow))    { return true; }
  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCHitOverflow))    { return true; }
  return false;
}

initialize()

StatusCode PixelConditionsSummaryTool::initialize ( )

overridevirtual

Definition at line 22 of file PixelConditionsSummaryTool.cxx.

                                                 {
  ATH_MSG_DEBUG("PixelConditionsSummaryTool::initialize()");
 
  ATH_CHECK(m_condDCSStateKey.initialize());
  ATH_CHECK(m_condDCSStatusKey.initialize());
 
  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
  ATH_CHECK(m_BSErrContReadKey.initialize(useByteStream && !m_BSErrContReadKey.empty()));
  ATH_CHECK(detStore()->retrieve(m_pixelID,"PixelID"));
  ATH_CHECK(m_condTDAQKey.initialize( !m_condTDAQKey.empty() ));
  ATH_CHECK(m_condDeadMapKey.initialize());
  ATH_CHECK(m_pixelDetEleCollKey.initialize());
  if (!m_pixelDetElStatusEventKey.empty() && !m_pixelDetElStatusCondKey.empty()) {
     ATH_MSG_FATAL("The event data (PixelDetElStatusEventDataBaseKey) and cond data (PixelDetElStatusCondDataBaseKey) keys cannot be set at the same time.");
  }
  ATH_CHECK(m_pixelDetElStatusEventKey.initialize( !m_pixelDetElStatusEventKey.empty()));
  ATH_CHECK(m_pixelDetElStatusCondKey.initialize( !m_pixelDetElStatusCondKey.empty()));
 
  m_activeStateMask=0;
  for (unsigned int istate=0; istate<m_isActiveStates.size(); istate++) {
    if      (m_isActiveStates[istate]=="READY")      { m_activeState.push_back(PixelDCSStateData::DCSModuleState::READY); }
    else if (m_isActiveStates[istate]=="ON")         { m_activeState.push_back(PixelDCSStateData::DCSModuleState::ON); }
    else if (m_isActiveStates[istate]=="UNKNOWN")    { m_activeState.push_back(PixelDCSStateData::DCSModuleState::UNKNOWN); }
    else if (m_isActiveStates[istate]=="TRANSITION") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::TRANSITION); }
    else if (m_isActiveStates[istate]=="UNDEFINED")  { m_activeState.push_back(PixelDCSStateData::DCSModuleState::UNDEFINED); }
    else if (m_isActiveStates[istate]=="DISABLED")   { m_activeState.push_back(PixelDCSStateData::DCSModuleState::DISABLED); }
    else if (m_isActiveStates[istate]=="LOCKED_OUT") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::LOCKED_OUT); }
    else if (m_isActiveStates[istate]=="OFF")        { m_activeState.push_back(PixelDCSStateData::DCSModuleState::OFF); }
    else if (m_isActiveStates[istate]=="NOSTATE")    { m_activeState.push_back(PixelDCSStateData::DCSModuleState::NOSTATE); }
    else {
      ATH_MSG_ERROR("No matching DCS state " << m_isActiveStates[istate] << " in DCSModuleState");
      return StatusCode::FAILURE;
    }
    if (m_activeState.back()<0 || m_activeState.back()>31) {
      ATH_MSG_FATAL("Logic error: status id too large. Cannot be represented by a bit");
      return StatusCode::FAILURE;
    }
    m_activeStateMask |= (1u<<m_activeState.back());
  }
 
  m_activeStatusMask=0;
  for (auto & isActiveStatus : m_isActiveStatus) {
    if      (isActiveStatus=="OK")       { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::OK); }
    else if (isActiveStatus=="WARNING")  { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::WARNING); }
    else if (isActiveStatus=="ERROR")    { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::ERROR); }
    else if (isActiveStatus=="FATAL")    { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::FATAL); }
    else if (isActiveStatus=="NOSTATUS") { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::NOSTATUS); }
    else {
      ATH_MSG_ERROR("No matching DCS status " << isActiveStatus << " in DCSModuleStatus");
      return StatusCode::FAILURE;
    }
    if (m_activeStatus.back()<0 || m_activeStatus.back()>31) {
      ATH_MSG_FATAL("Logic error: status id too large. Cannot be represented by a bit");
      return StatusCode::FAILURE;
    }
    m_activeStatusMask |= (1u<<m_activeStatus.back());
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

InterfaceID & PixelConditionsSummaryTool::interfaceID ( )

inlinestatic

Definition at line 176 of file PixelConditionsSummaryTool.h.

                                                           {
  static InterfaceID IID_PixelConditionsSummaryTool("PixelConditionsSummaryTool", 1, 0);
  return IID_PixelConditionsSummaryTool;
}

isActive() [1/3]

bool PixelConditionsSummaryTool::isActive ( const Identifier & elementId, const InDetConditions::Hierarchy h, const EventContext & ctx ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 220 of file PixelConditionsSummaryTool.cxx.

                                                                                                                            {
  return true;
}

isActive() [2/3]

bool PixelConditionsSummaryTool::isActive ( const IdentifierHash & moduleHash, const EventContext & ctx ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 224 of file PixelConditionsSummaryTool.cxx.

                                                                                                         {
 
  // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
  // Here, 52736 is a separator beween error flags and isActive flags.
  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
  if (useByteStream && getBSErrorWord(moduleHash,moduleHash+52736,ctx)!=1) { return false; }
 
  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey,ctx);
  bool isDCSActive = false;
  for (int istate : m_activeState) {
    if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
  }
  if (!isDCSActive) { return false; }
 
  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
 
  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey,ctx)->getModuleStatus(moduleHash)) { return false; }
 
  return true;
}

isActive() [3/3]

bool PixelConditionsSummaryTool::isActive ( const IdentifierHash & moduleHash, const Identifier & elementId, const EventContext & ctx ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 245 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                      {
 
  // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
  // Here, 52736 is a separator beween error flags and isActive flags.
  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
  if (useByteStream && getBSErrorWord(moduleHash,moduleHash+52736,ctx)!=1) { return false; }
 
  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey,ctx);
  bool isDCSActive = false;
  for (int istate : m_activeState) {
    if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
  }
  if (!isDCSActive) { return false; }
 
  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
 
  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey,ctx)->getModuleStatus(moduleHash)) { return false; }
 
  return checkChipStatus(moduleHash, elementId, ctx);
}

isGood() [1/3]

bool PixelConditionsSummaryTool::isGood ( const Identifier & elementId, const InDetConditions::Hierarchy h, const EventContext & ctx ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 270 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                    {
  Identifier moduleID       = m_pixelID->wafer_id(elementId);
  IdentifierHash moduleHash = m_pixelID->wafer_hash(moduleID);
 
  if (hasBSError(moduleHash, ctx)) { return false; }
 
  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
  bool isDCSActive = false;
  for (int istate : m_activeState) {
    if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
  }
  if (!isDCSActive) { return false; }
 
  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
  bool isDCSGood = false;
  for (int activeStatus : m_activeStatus) {
    if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
  }
  if (!isDCSGood) { return false; }
 
  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
 
  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
 
  if (h==InDetConditions::PIXEL_CHIP) {
    if (!checkChipStatus(moduleHash, elementId,ctx)) { return false; }
    if (hasBSError(moduleHash, elementId, ctx)) { return false; }
  }
 
  return true;
}

isGood() [2/3]

bool PixelConditionsSummaryTool::isGood ( const IdentifierHash & moduleHash, const EventContext & ctx ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 503 of file PixelConditionsSummaryTool.cxx.

                                                                                                       {
 
  if (hasBSError(moduleHash, ctx)) { return false; }
 
  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
  bool isDCSActive = false;
  for (int istate : m_activeState) {
    if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
  }
  if (!isDCSActive) { return false; }
 
  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
  bool isDCSGood = false;
  for (int activeStatus : m_activeStatus) {
    if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
  }
  if (!isDCSGood) { return false; }
 
  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
 
  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
 
  return true;
}

isGood() [3/3]

bool PixelConditionsSummaryTool::isGood ( const IdentifierHash & moduleHash, const Identifier & elementId, const EventContext & ctx, const IDCCacheEntry * cacheEntry = nullptr ) const

finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 528 of file PixelConditionsSummaryTool.cxx.

                                                                                                                                                                                          {
 
  if (hasBSError(moduleHash, ctx, cacheEntry)) { return false; }
 
  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
  bool isDCSActive = false;
  for (int istate : m_activeState) {
    if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
  }
  if (!isDCSActive) { return false; }
 
  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
  bool isDCSGood = false;
  for (int activeStatus : m_activeStatus) {
    if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
  }
  if (!isDCSGood) { return false; }
 
  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
 
  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
 
  if (!checkChipStatus(moduleHash, elementId, ctx)) { return false; }
 
  if (hasBSError(moduleHash, elementId, ctx, cacheEntry)) { return false; }
 
  return true;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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

ATLAS_THREAD_SAFE [1/2]

SG::SlotSpecificObj<std::mutex> m_cacheMutex PixelConditionsSummaryTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 137 of file PixelConditionsSummaryTool.h.

ATLAS_THREAD_SAFE [2/2]

SG::SlotSpecificObj<IDCCacheEntry> m_eventCache PixelConditionsSummaryTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 153 of file PixelConditionsSummaryTool.h.

m_activeOnly

Gaudi::Property< bool> PixelConditionsSummaryTool::m_activeOnly {this, "ActiveOnly", false, "Module and chip status will only reflect whether the modules or chips are active not necessarily whether the signals are good."}

private

Definition at line 132 of file PixelConditionsSummaryTool.h.

{this, "ActiveOnly", false, "Module and chip status will only reflect whether the modules or chips are active not necessarily whether the signals are good."};

m_activeState

std::vector<int> PixelConditionsSummaryTool::m_activeState

private

Definition at line 95 of file PixelConditionsSummaryTool.h.

m_activeStateMask

unsigned int PixelConditionsSummaryTool::m_activeStateMask {}

private

mask in which each state is represented by a bit and for states which are cnsidered active the corresponding bit is set;

Definition at line 97 of file PixelConditionsSummaryTool.h.

{};  

m_activeStatus

std::vector<int> PixelConditionsSummaryTool::m_activeStatus

private

Definition at line 96 of file PixelConditionsSummaryTool.h.

m_activeStatusMask

unsigned int PixelConditionsSummaryTool::m_activeStatusMask {}

private

mask in which each status is represented by a bit and for status values which are cnsidered active the corresponding bit is set;

Definition at line 98 of file PixelConditionsSummaryTool.h.

{}; 

m_BSErrContReadKey

SG::ReadHandleKey<IDCInDetBSErrContainer> PixelConditionsSummaryTool::m_BSErrContReadKey {this, "PixelByteStreamErrs", "PixelByteStreamErrs", "PixelByteStreamErrs container key"}

private

Definition at line 121 of file PixelConditionsSummaryTool.h.

{this, "PixelByteStreamErrs", "PixelByteStreamErrs", "PixelByteStreamErrs container key"};

m_condDCSStateKey

SG::ReadCondHandleKey<PixelDCSStateData> PixelConditionsSummaryTool::m_condDCSStateKey {this, "PixelDCSStateCondData", "PixelDCSStateCondData", "Pixel FSM state key"}

private

Definition at line 109 of file PixelConditionsSummaryTool.h.

{this, "PixelDCSStateCondData", "PixelDCSStateCondData", "Pixel FSM state key"};

m_condDCSStatusKey

SG::ReadCondHandleKey<PixelDCSStatusData> PixelConditionsSummaryTool::m_condDCSStatusKey {this, "PixelDCSStatusCondData", "PixelDCSStatusCondData", "Pixel FSM status key"}

private

Definition at line 112 of file PixelConditionsSummaryTool.h.

{this, "PixelDCSStatusCondData", "PixelDCSStatusCondData", "Pixel FSM status key"};

m_condDeadMapKey

SG::ReadCondHandleKey<PixelDeadMapCondData> PixelConditionsSummaryTool::m_condDeadMapKey {this, "PixelDeadMapCondData", "PixelDeadMapCondData", "Pixel deadmap conditions key"}

private

Definition at line 118 of file PixelConditionsSummaryTool.h.

{this, "PixelDeadMapCondData", "PixelDeadMapCondData", "Pixel deadmap conditions key"};

m_condTDAQKey

SG::ReadCondHandleKey<PixelTDAQData> PixelConditionsSummaryTool::m_condTDAQKey {this, "PixelTDAQCondData", "", "Pixel TDAQ conditions key"}

private

Definition at line 115 of file PixelConditionsSummaryTool.h.

{this, "PixelTDAQCondData", "", "Pixel TDAQ conditions key"}; //Default empty - legacy option

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_isActiveStates

std::vector<std::string> PixelConditionsSummaryTool::m_isActiveStates

private

Definition at line 94 of file PixelConditionsSummaryTool.h.

m_isActiveStatus

std::vector<std::string> PixelConditionsSummaryTool::m_isActiveStatus

private

Definition at line 93 of file PixelConditionsSummaryTool.h.

m_missingErrorInfo

const uint64_t PixelConditionsSummaryTool::m_missingErrorInfo {std::numeric_limits<uint64_t>::max()-3000000000}

private

Definition at line 135 of file PixelConditionsSummaryTool.h.

{std::numeric_limits<uint64_t>::max()-3000000000};

m_pixelDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> PixelConditionsSummaryTool::m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}

private

Definition at line 124 of file PixelConditionsSummaryTool.h.

{this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"};

m_pixelDetElStatusCondKey

SG::ReadCondHandleKey<InDet::SiDetectorElementStatus> PixelConditionsSummaryTool::m_pixelDetElStatusCondKey {this, "PixelDetElStatusCondDataBaseKey", "" , "Optional conditions data key of an input SiDetectorElementStatus on which the newly created object will be based."}

private

Definition at line 129 of file PixelConditionsSummaryTool.h.

{this, "PixelDetElStatusCondDataBaseKey", "" , "Optional conditions data key of an input SiDetectorElementStatus on which the newly created object will be based."};

m_pixelDetElStatusEventKey

SG::ReadHandleKey<InDet::SiDetectorElementStatus> PixelConditionsSummaryTool::m_pixelDetElStatusEventKey {this, "PixelDetElStatusEventDataBaseKey", "", "Optional event data key of an input SiDetectorElementStatus on which the newly created object will be based."}

private

Definition at line 127 of file PixelConditionsSummaryTool.h.

{this, "PixelDetElStatusEventDataBaseKey", "", "Optional event data key of an input SiDetectorElementStatus on which the newly created object will be based."};

m_pixelID

const PixelID* PixelConditionsSummaryTool::m_pixelID {}

private

Definition at line 91 of file PixelConditionsSummaryTool.h.

{};

m_useByteStreamFEI3

Gaudi::Property<bool> PixelConditionsSummaryTool::m_useByteStreamFEI3 {this, "UseByteStreamFEI3", false, "Switch of the ByteStream error for FEI3"}

private

Definition at line 103 of file PixelConditionsSummaryTool.h.

{this, "UseByteStreamFEI3", false, "Switch of the ByteStream error for FEI3"};

m_useByteStreamFEI4

Gaudi::Property<bool> PixelConditionsSummaryTool::m_useByteStreamFEI4 {this, "UseByteStreamFEI4", false, "Switch of the ByteStream error for FEI4"}

private

Definition at line 100 of file PixelConditionsSummaryTool.h.

{this, "UseByteStreamFEI4", false, "Switch of the ByteStream error for FEI4"};

m_useByteStreamRD53

Gaudi::Property<bool> PixelConditionsSummaryTool::m_useByteStreamRD53 {this, "UseByteStreamRD53", false, "Switch of the ByteStream error for RD53"}

private

Definition at line 106 of file PixelConditionsSummaryTool.h.

{this, "UseByteStreamRD53", false, "Switch of the ByteStream error for RD53"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• PixelConditionsSummaryTool.h
• PixelConditionsSummaryTool.cxx