ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
PixelConditionsSummaryTool Class Reference

#include <PixelConditionsSummaryTool.h>

Inheritance diagram for PixelConditionsSummaryTool:
Collaboration 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 More...
 
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. 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 sysInitialize () override
 Perform system initialization for an algorithm. 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, V, H > &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
 
 DeclareInterfaceID (IInDetConditionsTool, 1, 0)
 Creates the InterfaceID and interfaceID() method. More...
 

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 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 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. More...
 
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. More...
 
std::unique_ptr< InDet::SiDetectorElementStatus > createDetectorElementStatus (const EventContext &ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const
 Create a new detector element status element container. More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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

10  :AthAlgTool(type, name, parent),
11  m_pixelID(nullptr)
12 {
13  m_isActiveStatus.emplace_back("OK");
14  m_isActiveStates.emplace_back("READY");
15 
16  declareProperty("IsActiveStatus", m_isActiveStatus);
17  declareProperty("IsActiveStates", m_isActiveStates);
18 }

◆ ~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.

266  {
267  return 1.0;
268 }

◆ checkChipStatus()

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

Definition at line 181 of file PixelConditionsSummaryTool.h.

181  {
182  std::bitset<16> chipStatus(SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getChipStatus(moduleHash));
183  if (chipStatus.any()) {
184 
185  const InDetDD::SiDetectorElement *element = getDetectorEelement(moduleHash,ctx);
186  const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
187 
188  std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx
189  = InDetDD::PixelDiodeTree::makeCellIndex(m_pixelID->phi_index(pixid),
190  m_pixelID->eta_index(pixid));
191  InDetDD::PixelDiodeTree::DiodeProxy si_param ( p_design->diodeProxyFromIdx(diode_idx));
192  std::uint32_t chFE = p_design->getFE(si_param);
193 
194  std::bitset<16> circ;
195  circ.set(chFE);
196  if ((chipStatus&circ).any()) { return false; }
197  }
198  return true;
199 }

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

331  {
332  if (!m_pixelDetElStatusCondKey.empty()) {
333  SG::ReadCondHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusCondKey, ctx};
334  if (whandle) {
335  whandle->addDependency (input_element_status);
336  }
337  return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
338  }
339  else if (!m_pixelDetElStatusEventKey.empty()) {
340  SG::ReadHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusEventKey, ctx};
341  return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
342  }
343  else {
344  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
345  if (not pixelDetEleHandle.isValid() ) {
346  std::stringstream msg;
347  msg << m_pixelDetEleCollKey.fullKey() << " is not available.";
348  throw std::runtime_error(msg.str());
349  }
350  if (whandle) {
351  whandle->addDependency (pixelDetEleHandle);
352  }
353  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
354  return std::make_unique<InDet::PixelDetectorElementStatus>(*elements);
355  }
356 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ DeclareInterfaceID()

IInDetConditionsTool::DeclareInterfaceID ( IInDetConditionsTool  ,
1  ,
0   
)
inherited

Creates the InterfaceID and interfaceID() method.

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

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

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

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

115  {
116  return getBSErrorWord(moduleHash, moduleHash, ctx, cacheEntry);
117 }

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

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

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

146  {
147 
148  if (!m_useByteStreamFEI4 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::FEI4) { return 0; }
149  if (!m_useByteStreamFEI3 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::FEI3) { return 0; }
150  if (!m_useByteStreamRD53 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::RD53) { return 0; }
151 
152  if (cacheEntry == nullptr){
153  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
154  cacheEntry=getCacheEntry(ctx);
155  }
156  const auto *idcCachePtr = cacheEntry->IDCCache;
157  if (idcCachePtr==nullptr) {
158  ATH_MSG_ERROR("PixelConditionsSummaryTool No cache! " );
159  return 0;
160  }
161  uint64_t word = (uint64_t)idcCachePtr->retrieve(index);
162  return word<m_missingErrorInfo ? word : 0;
163 }

◆ getCacheEntry()

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

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.

94  {
95  IDCCacheEntry* cacheEntry = m_eventCache.get(ctx);
96  if (cacheEntry->needsUpdate(ctx)) {
97  const auto *idcErrContPtr = getContainer(ctx);
98  if (idcErrContPtr==nullptr) { // missing or not, the cache needs to be reset
99  cacheEntry->reset(ctx.evt(), nullptr);
100  }
101  else {
102  cacheEntry->reset(ctx.evt(), idcErrContPtr->cache());
103  }
104  ATH_MSG_VERBOSE("PixelConditionsSummaryTool Cache for the event reset " << cacheEntry->eventId << " with IDC container" << idcErrContPtr);
105  }
106  return cacheEntry;
107 }

◆ getCacheEntryOut()

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

Implements IInDetConditionsTool.

Definition at line 109 of file PixelConditionsSummaryTool.cxx.

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

◆ getContainer()

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

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.

83  {
84  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
85  if (!useByteStream || m_BSErrContReadKey.empty() ) {
86  return nullptr;
87  }
88  SG::ReadHandle<IDCInDetBSErrContainer> idcErrCont(m_BSErrContReadKey, ctx);
89  if (not idcErrCont.isValid()) { return nullptr; }
90  ATH_MSG_VERBOSE("PixelConditionsSummaryTool IDC Container fetched " << m_BSErrContReadKey.key());
91  return idcErrCont.cptr();
92 }

◆ getDetectorEelement()

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

Definition at line 119 of file PixelConditionsSummaryTool.cxx.

119  {
120  if (moduleHash>=m_pixelID->wafer_hash_max()) {
121  ATH_MSG_ERROR("invalid moduleHash : " << moduleHash << " exceed maximum hash id: " << m_pixelID->wafer_hash_max());
122  return nullptr;
123  }
124 
125  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
126  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
127  if (not pixelDetEleHandle.isValid() or elements==nullptr) {
128  ATH_MSG_ERROR(m_pixelDetEleCollKey.fullKey() << " is not available.");
129  return nullptr;
130  }
131  return elements->getDetectorElement(moduleHash);
132 }

◆ 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
ctxthe current event contex
whandlePointer 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.

360  {
361  std::unique_ptr<InDet::SiDetectorElementStatus> element_status( createDetectorElementStatus(ctx, whandle));
362  std::vector<bool> &status=element_status->getElementStatus();
363  status.resize(m_pixelID->wafer_hash_max(),
364  ((1<<0) & m_activeStateMask) // default value of PixelDCSStateData is 0
365  );
366  std::vector<InDet::ChipFlags_t> &chip_status=element_status->getElementChipStatus();
367  chip_status.resize(status.size(),0);
368 
369  // module state
370  {
371  SG::ReadCondHandle<PixelDCSStateData> dcs_state_handle(m_condDCSStateKey, ctx);
372  andStatus(dcs_state_handle->moduleStatusMap(), m_activeStateMask, status);
373  if (whandle) {
374  whandle->addDependency (dcs_state_handle);
375  }
376  }
377  const bool active_only = m_activeOnly;
378  if (!active_only) {
379  SG::ReadCondHandle<PixelDCSStatusData> dcs_status_handle(m_condDCSStatusKey, ctx);
380  andStatus(dcs_status_handle->moduleStatusMap(), m_activeStatusMask, status);
381  if (whandle) {
382  whandle->addDependency (dcs_status_handle);
383  }
384  }
385  if (!m_condTDAQKey.empty()) {
386  SG::ReadCondHandle<PixelTDAQData> tdaq_handle(m_condTDAQKey,ctx);
387  andNotStatus(tdaq_handle->moduleStatusMap(), status);
388  if (whandle) {
389  whandle->addDependency (tdaq_handle);
390  }
391  }
392  {
393  SG::ReadCondHandle<PixelDeadMapCondData> dead_map_handle(m_condDeadMapKey, ctx);
394  andNotStatus(dead_map_handle->moduleStatusMap(), status);
395  if (whandle) {
396  whandle->addDependency (dead_map_handle);
397  }
398 
399  const PixelDeadMapCondData *dead_map = dead_map_handle.cptr();
400  unsigned int element_i=0;
401  for (const InDetDD::SiDetectorElement *element : element_status->getDetectorElements()) {
402  if (status[element_i]) {
403  const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
404  InDetDD::PixelReadoutTechnology readout_technology = p_design->getReadoutTechnology();
405  unsigned int number_of_chips = readout_technology == InDetDD::PixelReadoutTechnology::FEI3 ? 2*p_design->numberOfCircuits() : p_design->numberOfCircuits();
406  InDet::ChipFlags_t chip_mask = (1ul<<number_of_chips)-1ul;
407  assert( chip_mask != 0 );
408  std::bitset<16> dead_chip_mask(dead_map->getChipStatus(element_i));
409  chip_status[element_i] = chip_mask & (~static_cast<InDet::ChipFlags_t>(dead_chip_mask.to_ulong()));
410  }
411  ++element_i;
412  }
413  }
414 
415 
416  static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::FEI4) < 32u) ;
417  static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::FEI3) < 32u) ;
418  static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::RD53) < 32u) ;
419  unsigned int readout_technology_mask= Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI4, 1 && m_useByteStreamFEI4 )
420  | Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI3, 1 && m_useByteStreamFEI3 )
421  | Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::RD53, 1 && m_useByteStreamRD53 );
422  if (readout_technology_mask) {
423  if (whandle) {
424  ATH_MSG_ERROR("PixelConditionsSummaryTool not configured for use with conditions objects");
425  whandle->addDependency (IDetectorElementStatusTool::getInvalidRange());
426  }
427  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
428  const IDCInDetBSErrContainer_Cache *idcCachePtr = nullptr;
429  idcCachePtr = getCacheEntry(ctx)->IDCCache;
430  if (idcCachePtr==nullptr) {
431  ATH_MSG_ERROR("PixelConditionsSummaryTool No cache! " );
432  }
433  else {
434 
435  constexpr uint64_t error_mask = PixelByteStreamErrors::makeError(PixelByteStreamErrors::TruncatedROB)
436  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MaskedROB)
437  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Preamble)
438  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::TimeOut)
439  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::LVL1ID)
440  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::BCID)
441  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Trailer)
442  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDEoECheck)
443  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCBCIDEoECheck)
444  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDCheck)
445  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCEoEOverflow)
446  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCHitOverflow);
447 
448  constexpr uint64_t chip_error_mask = PixelByteStreamErrors::makeError(PixelByteStreamErrors::Preamble)
449  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::TimeOut)
450  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::LVL1ID)
451  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::BCID)
452  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Trailer)
453  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDEoECheck)
454  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCBCIDEoECheck)
455  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDCheck)
456  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCEoEOverflow)
457  | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCHitOverflow);
458 
459  // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
460  // Here, 52736 is a separator beween error flags and isActive flags.
461  unsigned int element_offset_i = (active_only ? 52736 : 0);
462 
463  unsigned int element_i=0;
464  unsigned int maxHash = m_pixelID->wafer_hash_max();
465  for (const InDetDD::SiDetectorElement *element : element_status->getDetectorElements()) {
466  const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
467  InDetDD::PixelReadoutTechnology readout_technology = p_design->getReadoutTechnology();
468  unsigned int readout_technology_flags = readout_technology_mask & Pixel::makeReadoutTechnologyBit(readout_technology);
469 
470  // set to false if has one of the considered errors and the readout technology is considered.
471  status.at(element_i) = status.at(element_i) && not ( readout_technology_flags
472  && ( !active_only
473  ? isBSError(static_cast<uint64_t>(idcCachePtr->retrieve(element_i)), m_missingErrorInfo, error_mask)
474  : idcCachePtr->retrieve(element_i+element_offset_i)!=1 ));
475 
476  // compute the status for the individual front-ends
477  if (status[element_i]) {
478  unsigned int number_of_chips = readout_technology == InDetDD::PixelReadoutTechnology::FEI3 ? 2*p_design->numberOfCircuits() : p_design->numberOfCircuits();
479  InDet::ChipFlags_t chip_mask = status[element_i] ? (1ul<<number_of_chips)-1ul : 0;
480  assert( chip_mask != 0 );
481  InDet::ChipFlags_t bs_status_flags = active_only ? chip_mask : 0;
482  if (!active_only) {
483  for (unsigned int chip_i =0; chip_i < number_of_chips; ++chip_i) {
484  // get bytestream error for chip
485  unsigned int indexFE = (1+chip_i)*maxHash + element_i; // (FE_channel+1)*2048 + moduleHash
486  InDet::ChipFlags_t chip_flag =not ( readout_technology_flags
487  && (isBSError(static_cast<uint64_t>(idcCachePtr->retrieve(indexFE)), m_missingErrorInfo, chip_error_mask)));
488  bs_status_flags |= (chip_flag << chip_i);
489  }
490  }
491  chip_status[element_i] &= (bs_status_flags & chip_mask);
492  }
493  else {
494  chip_status[element_i] = 0;
495  }
496  ++element_i;
497  }
498  }
499  }
500  return element_status;
501 }

◆ getInvalidRange()

static EventIDRange IDetectorElementStatusTool::getInvalidRange ( )
inlinestaticinherited

Definition at line 33 of file IDetectorElementStatusTool.h.

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

◆ getUndefinedEventId()

static EventIDBase IDetectorElementStatusTool::getUndefinedEventId ( )
inlinestaticinherited

Definition at line 32 of file IDetectorElementStatusTool.h.

32 { 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.

557  {
558 
559  if (!isGood(moduleHash, ctx)) { return 0.0; }
560 
561  Identifier moduleID = m_pixelID->wafer_id(moduleHash);
562 
563  int phiStart = m_pixelID->phi_index(idStart);
564  int etaStart = m_pixelID->eta_index(idStart);
565 
566  int phiEnd = m_pixelID->phi_index(idEnd);
567  int etaEnd = m_pixelID->eta_index(idEnd);
568 
569  double nTotal = (std::abs(phiStart-phiEnd)+1.0)*(std::abs(etaStart-etaEnd)+1.0);
570 
571  double nGood = 0.0;
572  IInDetConditionsTool::IDCCacheEntry* cacheEntry = getCacheEntry(ctx);
573  for (int i=std::min(phiStart,phiEnd); i<=std::max(phiStart,phiEnd); i++) {
574  for (int j=std::min(etaStart,etaEnd); j<=std::max(etaStart,etaEnd); j++) {
575  if (checkChipStatus(moduleHash, m_pixelID->pixel_id(moduleID,i,j), ctx)) {
576  if (!hasBSError(moduleHash, m_pixelID->pixel_id(moduleID,i,j), ctx, cacheEntry)) { nGood++; }
577  }
578  }
579  }
580  return nGood/nTotal;
581 }

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

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

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

191  {
192  const InDetDD::SiDetectorElement *element = getDetectorEelement(moduleHash,ctx);
193  const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
194 
195  if (hasBSError(p_design, moduleHash, ctx, cacheEntry)) { return true; }
196 
197  int maxHash = m_pixelID->wafer_hash_max();
198 
199  std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx
200  = InDetDD::PixelDiodeTree::makeCellIndex(m_pixelID->phi_index(pixid),
201  m_pixelID->eta_index(pixid));
202  InDetDD::PixelDiodeTree::DiodeProxy si_param ( p_design->diodeProxyFromIdx(diode_idx));
203  std::uint32_t chFE = p_design->getFE(si_param);
204 
205  int indexFE = (1+chFE)*maxHash+static_cast<int>(moduleHash); // (FE_channel+1)*2048 + moduleHash
206  uint64_t word = getBSErrorWord(p_design,indexFE,ctx,cacheEntry);
207  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Preamble)) { return true; }
208  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TimeOut)) { return true; }
209  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::LVL1ID)) { return true; }
210  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::BCID)) { return true; }
211  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Trailer)) { return true; }
212  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDEoECheck)) { return true; }
213  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCBCIDEoECheck)) { return true; }
214  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDCheck)) { return true; }
215  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCEoEOverflow)) { return true; }
216  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCHitOverflow)) { return true; }
217  return false;
218 }

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

174  {
175  uint64_t word = getBSErrorWord(p_design,moduleHash, ctx,cacheEntry);
176  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TruncatedROB)) { return true; }
177  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MaskedROB)) { return true; }
178  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Preamble)) { return true; }
179  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TimeOut)) { return true; }
180  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::LVL1ID)) { return true; }
181  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::BCID)) { return true; }
182  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Trailer)) { return true; }
183  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDEoECheck)) { return true; }
184  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCBCIDEoECheck)) { return true; }
185  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDCheck)) { return true; }
186  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCEoEOverflow)) { return true; }
187  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCHitOverflow)) { return true; }
188  return false;
189 }

◆ initialize()

StatusCode PixelConditionsSummaryTool::initialize ( )
overridevirtual

Definition at line 22 of file PixelConditionsSummaryTool.cxx.

22  {
23  ATH_MSG_DEBUG("PixelConditionsSummaryTool::initialize()");
24 
25  ATH_CHECK(m_condDCSStateKey.initialize());
26  ATH_CHECK(m_condDCSStatusKey.initialize());
27 
28  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
29  ATH_CHECK(m_BSErrContReadKey.initialize(useByteStream && !m_BSErrContReadKey.empty()));
30  ATH_CHECK(detStore()->retrieve(m_pixelID,"PixelID"));
31  ATH_CHECK(m_condTDAQKey.initialize( !m_condTDAQKey.empty() ));
32  ATH_CHECK(m_condDeadMapKey.initialize());
33  ATH_CHECK(m_pixelDetEleCollKey.initialize());
34  if (!m_pixelDetElStatusEventKey.empty() && !m_pixelDetElStatusCondKey.empty()) {
35  ATH_MSG_FATAL("The event data (PixelDetElStatusEventDataBaseKey) and cond data (PixelDetElStatusCondDataBaseKey) keys cannot be set at the same time.");
36  }
37  ATH_CHECK(m_pixelDetElStatusEventKey.initialize( !m_pixelDetElStatusEventKey.empty()));
38  ATH_CHECK(m_pixelDetElStatusCondKey.initialize( !m_pixelDetElStatusCondKey.empty()));
39 
40  m_activeStateMask=0;
41  for (unsigned int istate=0; istate<m_isActiveStates.size(); istate++) {
42  if (m_isActiveStates[istate]=="READY") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::READY); }
43  else if (m_isActiveStates[istate]=="ON") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::ON); }
44  else if (m_isActiveStates[istate]=="UNKNOWN") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::UNKNOWN); }
45  else if (m_isActiveStates[istate]=="TRANSITION") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::TRANSITION); }
46  else if (m_isActiveStates[istate]=="UNDEFINED") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::UNDEFINED); }
47  else if (m_isActiveStates[istate]=="DISABLED") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::DISABLED); }
48  else if (m_isActiveStates[istate]=="LOCKED_OUT") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::LOCKED_OUT); }
49  else if (m_isActiveStates[istate]=="OFF") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::OFF); }
50  else if (m_isActiveStates[istate]=="NOSTATE") { m_activeState.push_back(PixelDCSStateData::DCSModuleState::NOSTATE); }
51  else {
52  ATH_MSG_ERROR("No matching DCS state " << m_isActiveStates[istate] << " in DCSModuleState");
53  return StatusCode::FAILURE;
54  }
55  if (m_activeState.back()<0 || m_activeState.back()>31) {
56  ATH_MSG_FATAL("Logic error: status id too large. Cannot be represented by a bit");
57  return StatusCode::FAILURE;
58  }
59  m_activeStateMask |= (1u<<m_activeState.back());
60  }
61 
62  m_activeStatusMask=0;
63  for (auto & isActiveStatus : m_isActiveStatus) {
64  if (isActiveStatus=="OK") { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::OK); }
65  else if (isActiveStatus=="WARNING") { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::WARNING); }
66  else if (isActiveStatus=="ERROR") { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::ERROR); }
67  else if (isActiveStatus=="FATAL") { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::FATAL); }
68  else if (isActiveStatus=="NOSTATUS") { m_activeStatus.push_back(PixelDCSStatusData::DCSModuleStatus::NOSTATUS); }
69  else {
70  ATH_MSG_ERROR("No matching DCS status " << isActiveStatus << " in DCSModuleStatus");
71  return StatusCode::FAILURE;
72  }
73  if (m_activeStatus.back()<0 || m_activeStatus.back()>31) {
74  ATH_MSG_FATAL("Logic error: status id too large. Cannot be represented by a bit");
75  return StatusCode::FAILURE;
76  }
77  m_activeStatusMask |= (1u<<m_activeStatus.back());
78  }
79 
80  return StatusCode::SUCCESS;
81 }

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

176  {
177  static InterfaceID IID_PixelConditionsSummaryTool("PixelConditionsSummaryTool", 1, 0);
178  return IID_PixelConditionsSummaryTool;
179 }

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

220  {
221  return true;
222 }

◆ isActive() [2/3]

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

Implements IInDetConditionsTool.

Definition at line 224 of file PixelConditionsSummaryTool.cxx.

224  {
225 
226  // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
227  // Here, 52736 is a separator beween error flags and isActive flags.
228  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
229  if (useByteStream && getBSErrorWord(moduleHash,moduleHash+52736,ctx)!=1) { return false; }
230 
231  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey,ctx);
232  bool isDCSActive = false;
233  for (int istate : m_activeState) {
234  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
235  }
236  if (!isDCSActive) { return false; }
237 
238  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
239 
240  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey,ctx)->getModuleStatus(moduleHash)) { return false; }
241 
242  return true;
243 }

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

245  {
246 
247  // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
248  // Here, 52736 is a separator beween error flags and isActive flags.
249  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
250  if (useByteStream && getBSErrorWord(moduleHash,moduleHash+52736,ctx)!=1) { return false; }
251 
252  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey,ctx);
253  bool isDCSActive = false;
254  for (int istate : m_activeState) {
255  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
256  }
257  if (!isDCSActive) { return false; }
258 
259  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
260 
261  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey,ctx)->getModuleStatus(moduleHash)) { return false; }
262 
263  return checkChipStatus(moduleHash, elementId, ctx);
264 }

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

270  {
271  Identifier moduleID = m_pixelID->wafer_id(elementId);
272  IdentifierHash moduleHash = m_pixelID->wafer_hash(moduleID);
273 
274  if (hasBSError(moduleHash, ctx)) { return false; }
275 
276  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
277  bool isDCSActive = false;
278  for (int istate : m_activeState) {
279  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
280  }
281  if (!isDCSActive) { return false; }
282 
283  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
284  bool isDCSGood = false;
285  for (int activeStatus : m_activeStatus) {
286  if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
287  }
288  if (!isDCSGood) { return false; }
289 
290  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
291 
292  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
293 
294  if (h==InDetConditions::PIXEL_CHIP) {
295  if (!checkChipStatus(moduleHash, elementId,ctx)) { return false; }
296  if (hasBSError(moduleHash, elementId, ctx)) { return false; }
297  }
298 
299  return true;
300 }

◆ isGood() [2/3]

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

Implements IInDetConditionsTool.

Definition at line 503 of file PixelConditionsSummaryTool.cxx.

503  {
504 
505  if (hasBSError(moduleHash, ctx)) { return false; }
506 
507  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
508  bool isDCSActive = false;
509  for (int istate : m_activeState) {
510  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
511  }
512  if (!isDCSActive) { return false; }
513 
514  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
515  bool isDCSGood = false;
516  for (int activeStatus : m_activeStatus) {
517  if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
518  }
519  if (!isDCSGood) { return false; }
520 
521  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
522 
523  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
524 
525  return true;
526 }

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

528  {
529 
530  if (hasBSError(moduleHash, ctx, cacheEntry)) { return false; }
531 
532  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
533  bool isDCSActive = false;
534  for (int istate : m_activeState) {
535  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
536  }
537  if (!isDCSActive) { return false; }
538 
539  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
540  bool isDCSGood = false;
541  for (int activeStatus : m_activeStatus) {
542  if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
543  }
544  if (!isDCSGood) { return false; }
545 
546  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
547 
548  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
549 
550  if (!checkChipStatus(moduleHash, elementId, ctx)) { return false; }
551 
552  if (hasBSError(moduleHash, elementId, ctx, cacheEntry)) { return false; }
553 
554  return true;
555 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

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.

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

◆ m_condDCSStateKey

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

Definition at line 109 of file PixelConditionsSummaryTool.h.

◆ m_condDCSStatusKey

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

Definition at line 112 of file PixelConditionsSummaryTool.h.

◆ m_condDeadMapKey

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

Definition at line 118 of file PixelConditionsSummaryTool.h.

◆ m_condTDAQKey

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

Definition at line 115 of file PixelConditionsSummaryTool.h.

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

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

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

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

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

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

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

◆ 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:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
python.StoreID.UNKNOWN
int UNKNOWN
Definition: StoreID.py:16
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
PixelID::phi_index
int phi_index(const Identifier &id) const
Definition: PixelID.h:639
InDetDD::PixelReadoutTechnology
PixelReadoutTechnology
Definition: PixelReadoutDefinitions.h:37
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:27
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:18
SG::ReadCondHandle
Definition: ReadCondHandle.h:40
InDetDD::PixelModuleDesign
Definition: PixelModuleDesign.h:45
PixelConditionsSummaryTool::checkChipStatus
bool checkChipStatus(IdentifierHash moduleHash, Identifier pixid, const EventContext &ctx) const
Definition: PixelConditionsSummaryTool.h:181
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
PixelConditionsSummaryTool::m_activeStatusMask
unsigned int m_activeStatusMask
mask in which each status is represented by a bit and for status values which are cnsidered active th...
Definition: PixelConditionsSummaryTool.h:98
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
PixelConditionsSummaryTool::hasBSError
virtual bool hasBSError(const IdentifierHash &moduleHash, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
Definition: PixelConditionsSummaryTool.cxx:165
PixelConditionsSummaryTool::getCacheEntry
IDCCacheEntry * getCacheEntry(const EventContext &ctx) const
Return cache for the current event If, for current slot, the cache is outdated it is retrieved from t...
Definition: PixelConditionsSummaryTool.cxx:94
python.Constants.ERROR
int ERROR
Definition: Control/AthenaCommon/python/Constants.py:17
Pixel::makeReadoutTechnologyBit
unsigned int makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology technology, unsigned int bit_val=1)
Create a word with a bit representing the given readout technology to the given value.
Definition: PixelFEUtils.h:63
PixelConditionsSummaryTool::m_isActiveStates
std::vector< std::string > m_isActiveStates
Definition: PixelConditionsSummaryTool.h:94
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
InDetConditions::PIXEL_CHIP
@ PIXEL_CHIP
Definition: InDetHierarchy.h:15
PixelByteStreamErrors::MCCBCIDEoECheck
@ MCCBCIDEoECheck
Definition: PixelByteStreamErrors.h:15
InDetDD::PixelReadoutTechnology::FEI3
@ FEI3
PixelConditionsSummaryTool::isGood
virtual bool isGood(const Identifier &elementId, const InDetConditions::Hierarchy h, const EventContext &ctx) const override final
Definition: PixelConditionsSummaryTool.cxx:270
PixelByteStreamErrors::makeError
constexpr IDCInDetBSErrContainer::ErrorCode makeError(PixelErrorsEnum errType)
helper to be used in clients to fetch error information
Definition: PixelByteStreamErrors.h:21
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
PixelConditionsSummaryTool::getBSErrorWord
virtual uint64_t getBSErrorWord(const IdentifierHash &moduleHash, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
Definition: PixelConditionsSummaryTool.cxx:115
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
InDetDD::PixelModuleDesign::getFE
static unsigned int getFE(const PixelDiodeTree::DiodeProxy &diode_proxy)
Definition: PixelModuleDesign.h:258
PixelConditionsSummaryTool::m_condDCSStateKey
SG::ReadCondHandleKey< PixelDCSStateData > m_condDCSStateKey
Definition: PixelConditionsSummaryTool.h:110
InDetDD::PixelModuleDesign::diodeProxyFromIdx
PixelDiodeTree::DiodeProxy diodeProxyFromIdx(const std::array< PixelDiodeTree::IndexType, 2 > &idx) const
Definition: PixelModuleDesign.h:248
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:360
PixelByteStreamErrors::TimeOut
@ TimeOut
Definition: PixelByteStreamErrors.h:13
IdentifiableValueCache::retrieve
T retrieve(size_t i)
Retrieve the Value stored in that hash.
Definition: IdentifiableValueCache.h:49
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
PixelConditionsSummaryTool::m_condDCSStatusKey
SG::ReadCondHandleKey< PixelDCSStatusData > m_condDCSStatusKey
Definition: PixelConditionsSummaryTool.h:113
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
InDetDD::PixelReadoutTechnology::RD53
@ RD53
PixelByteStreamErrors::BCID
@ BCID
Definition: PixelByteStreamErrors.h:13
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
PixelConditionsSummaryTool::m_pixelDetElStatusEventKey
SG::ReadHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusEventKey
Definition: PixelConditionsSummaryTool.h:128
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition: PixelID.h:383
PixelConditionsSummaryTool::m_BSErrContReadKey
SG::ReadHandleKey< IDCInDetBSErrContainer > m_BSErrContReadKey
Definition: PixelConditionsSummaryTool.h:122
PixelConditionsSummaryTool::m_activeStateMask
unsigned int m_activeStateMask
mask in which each state is represented by a bit and for states which are cnsidered active the corres...
Definition: PixelConditionsSummaryTool.h:97
AthCommonDataStore
Definition: AthCommonDataStore.h:52
PixelConditionsSummaryTool::m_useByteStreamFEI4
Gaudi::Property< bool > m_useByteStreamFEI4
Definition: PixelConditionsSummaryTool.h:101
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
PixelByteStreamErrors::Preamble
@ Preamble
Definition: PixelByteStreamErrors.h:13
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
IDetectorElementStatusTool::getInvalidRange
static EventIDRange getInvalidRange()
Definition: IDetectorElementStatusTool.h:33
InDetDD::PixelModuleDesign::numberOfCircuits
int numberOfCircuits() const
Total number of circuits:
Definition: PixelModuleDesign.h:306
PixelByteStreamErrors::MCCLVL1IDEoECheck
@ MCCLVL1IDEoECheck
Definition: PixelByteStreamErrors.h:15
test_pyathena.parent
parent
Definition: test_pyathena.py:15
PixelID::eta_index
int eta_index(const Identifier &id) const
Definition: PixelID.h:645
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
PixelDeadMapCondData::getChipStatus
int getChipStatus(const int chanNum) const
Definition: PixelDeadMapCondData.cxx:31
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
detail::ul
unsigned long ul
Definition: PrimitiveHelpers.h:47
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
PixelConditionsSummaryTool::m_pixelID
const PixelID * m_pixelID
Definition: PixelConditionsSummaryTool.h:91
python.Constants.WARNING
int WARNING
Definition: Control/AthenaCommon/python/Constants.py:16
python.compareNtuple.nGood
nGood
Definition: compareNtuple.py:55
PixelByteStreamErrors::MaskedROB
@ MaskedROB
Definition: PixelByteStreamErrors.h:14
HTXS::UNDEFINED
@ UNDEFINED
Definition: HiggsTemplateCrossSectionsDefs.h:13
PixelConditionsSummaryTool::m_activeState
std::vector< int > m_activeState
Definition: PixelConditionsSummaryTool.h:95
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
PixelByteStreamErrors::MCCHitOverflow
@ MCCHitOverflow
Definition: PixelByteStreamErrors.h:15
PixelID::wafer_hash_max
size_type wafer_hash_max() const
Definition: PixelID.cxx:801
PixelByteStreamErrors::MCCLVL1IDCheck
@ MCCLVL1IDCheck
Definition: PixelByteStreamErrors.h:15
PixelConditionsSummaryTool::m_condTDAQKey
SG::ReadCondHandleKey< PixelTDAQData > m_condTDAQKey
Definition: PixelConditionsSummaryTool.h:116
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
PixelByteStreamErrors::MCCEoEOverflow
@ MCCEoEOverflow
Definition: PixelByteStreamErrors.h:15
PixelConditionsSummaryTool::m_pixelDetElStatusCondKey
SG::ReadCondHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusCondKey
Definition: PixelConditionsSummaryTool.h:130
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
InDetDD::PixelReadoutTechnology::FEI4
@ FEI4
InDetDD::PixelModuleDesign::getReadoutTechnology
PixelReadoutTechnology getReadoutTechnology() const
Definition: PixelModuleDesign.h:391
a
TList * a
Definition: liststreamerinfos.cxx:10
h
InDetDD::PixelDiodeTree::DiodeProxy
Helper class to access parameters of a diode.
Definition: PixelDiodeTree.h:183
PixelConditionsSummaryTool::getContainer
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 ret...
Definition: PixelConditionsSummaryTool.cxx:83
PixelID::pixel_id
Identifier pixel_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int phi_index, int eta_index) const
For an individual pixel.
Definition: PixelID.h:428
PixelConditionsSummaryTool::m_condDeadMapKey
SG::ReadCondHandleKey< PixelDeadMapCondData > m_condDeadMapKey
Definition: PixelConditionsSummaryTool.h:119
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
PixelConditionsSummaryTool::createDetectorElementStatus
std::unique_ptr< InDet::SiDetectorElementStatus > createDetectorElementStatus(const EventContext &ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const
Create a new detector element status element container.
Definition: PixelConditionsSummaryTool.cxx:330
PixelConditionsSummaryTool::getDetectorEelement
const InDetDD::SiDetectorElement * getDetectorEelement(const IdentifierHash &moduleHash, const EventContext &ctx) const
Definition: PixelConditionsSummaryTool.cxx:119
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
PixelConditionsSummaryTool::m_useByteStreamFEI3
Gaudi::Property< bool > m_useByteStreamFEI3
Definition: PixelConditionsSummaryTool.h:104
InDet::ChipFlags_t
unsigned short ChipFlags_t
Definition: SiDetectorElementStatus.h:60
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
PixelDeadMapCondData
Definition: PixelDeadMapCondData.h:11
merge.status
status
Definition: merge.py:16
PixelConditionsSummaryTool::m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
Definition: PixelConditionsSummaryTool.h:125
InDetDD::PixelDiodeTree::makeCellIndex
static constexpr std::array< PixelDiodeTree::CellIndexType, 2 > makeCellIndex(T local_x_idx, T local_y_idx)
Create a 2D cell index from the indices in local-x (phi, row) and local-y (eta, column) direction.
Definition: PixelDiodeTree.h:320
PixelConditionsSummaryTool::m_useByteStreamRD53
Gaudi::Property< bool > m_useByteStreamRD53
Definition: PixelConditionsSummaryTool.h:107
PixelConditionsSummaryTool::m_missingErrorInfo
const uint64_t m_missingErrorInfo
Definition: PixelConditionsSummaryTool.h:135
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
InDetDD::SiDetectorElement::design
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
PixelConditionsSummaryTool::m_activeOnly
Gaudi::Property< bool > m_activeOnly
Definition: PixelConditionsSummaryTool.h:133
IdentifiableValueCache
This class is to provide an event wide MT container for concurrent storing of basic types,...
Definition: IdentifiableValueCache.h:19
PixelByteStreamErrors::TruncatedROB
@ TruncatedROB
Definition: PixelByteStreamErrors.h:14
PixelByteStreamErrors::Trailer
@ Trailer
Definition: PixelByteStreamErrors.h:13
IInDetConditionsTool::IDCCacheEntry::IDCCache
const IDCInDetBSErrContainer_Cache * IDCCache
Definition: IInDetConditionsTool.h:34
fitman.k
k
Definition: fitman.py:528
PixelConditionsSummaryTool::m_activeStatus
std::vector< int > m_activeStatus
Definition: PixelConditionsSummaryTool.h:96
IDetectorElementStatusTool::getUndefinedEventId
static EventIDBase getUndefinedEventId()
Definition: IDetectorElementStatusTool.h:32
IInDetConditionsTool::IDCCacheEntry
Definition: IInDetConditionsTool.h:32
PixelConditionsSummaryTool::m_isActiveStatus
std::vector< std::string > m_isActiveStatus
Definition: PixelConditionsSummaryTool.h:93
SG::WriteCondHandle::addDependency
void addDependency(const EventIDRange &range)
Definition: WriteCondHandle.h:279
PixelByteStreamErrors::LVL1ID
@ LVL1ID
Definition: PixelByteStreamErrors.h:13
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Fri Nov 21 2025 21:40:45 for ATLAS Offline Software by   doxygen 1.8.18