ATLAS Offline Software
Classes | 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:

Classes

struct  IDCCacheEntry
 

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 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 override final
 
virtual bool hasBSError (const IdentifierHash &moduleHash, Identifier pixid, const EventContext &ctx) const override final
 
virtual uint64_t getBSErrorWord (const IdentifierHash &moduleHash, const EventContext &ctx) const override final
 
virtual uint64_t getBSErrorWord (const IdentifierHash &moduleHash, const int index, 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 > &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

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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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"}
 
ServiceHandle< InDetDD::IPixelReadoutManager > m_pixelReadout {this, "PixelReadoutManager", "PixelReadoutManager", "Pixel readout manager" }
 
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 12 of file PixelConditionsSummaryTool.cxx.

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

◆ ~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 229 of file PixelConditionsSummaryTool.cxx.

229  {
230  return 1.0;
231 }

◆ checkChipStatus()

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

Definition at line 172 of file PixelConditionsSummaryTool.h.

172  {
173  std::bitset<16> chipStatus(SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getChipStatus(moduleHash));
174  if (chipStatus.any()) {
175  Identifier moduleID = m_pixelID->wafer_id(pixid);
176  std::bitset<16> circ;
177  circ.set(m_pixelReadout->getFE(pixid,moduleID));
178  if ((chipStatus&circ).any()) { return false; }
179  }
180  return true;
181 }

◆ 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 293 of file PixelConditionsSummaryTool.cxx.

294  {
295  if (!m_pixelDetElStatusCondKey.empty()) {
296  SG::ReadCondHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusCondKey, ctx};
297  if (whandle) {
298  whandle->addDependency (input_element_status);
299  }
300  return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
301  }
302  else if (!m_pixelDetElStatusEventKey.empty()) {
303  SG::ReadHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusEventKey, ctx};
304  return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
305  }
306  else {
307  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
308  if (not pixelDetEleHandle.isValid() ) {
309  std::stringstream msg;
310  msg << m_pixelDetEleCollKey.fullKey() << " is not available.";
311  throw std::runtime_error(msg.str());
312  }
313  if (whandle) {
314  whandle->addDependency (pixelDetEleHandle);
315  }
316  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
317  return std::make_unique<InDet::PixelDetectorElementStatus>(*elements);
318  }
319 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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 > &  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 > &  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 > &  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 > &  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/2]

uint64_t PixelConditionsSummaryTool::getBSErrorWord ( const IdentifierHash &  moduleHash,
const EventContext &  ctx 
) const
finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 109 of file PixelConditionsSummaryTool.cxx.

109  {
110  return getBSErrorWord(moduleHash, moduleHash, ctx);
111 }

◆ getBSErrorWord() [2/2]

uint64_t PixelConditionsSummaryTool::getBSErrorWord ( const IdentifierHash &  moduleHash,
const int  index,
const EventContext &  ctx 
) const
finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 113 of file PixelConditionsSummaryTool.cxx.

113  {
114 
115  if (moduleHash>=m_pixelID->wafer_hash_max()) {
116  ATH_MSG_WARNING("invalid moduleHash : " << moduleHash << " exceed maximum hash id: " << m_pixelID->wafer_hash_max());
117  return 0;
118  }
119 
120  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
121  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
122  if (not pixelDetEleHandle.isValid() or elements==nullptr) {
123  ATH_MSG_WARNING(m_pixelDetEleCollKey.fullKey() << " is not available.");
124  return 0;
125  }
126  const InDetDD::SiDetectorElement *element = elements->getDetectorElement(moduleHash);
127  const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
128 
129  if (!m_useByteStreamFEI4 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::FEI4) { return 0; }
130  if (!m_useByteStreamFEI3 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::FEI3) { return 0; }
131  if (!m_useByteStreamRD53 && p_design->getReadoutTechnology() == InDetDD::PixelReadoutTechnology::RD53) { return 0; }
132 
133  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
134  const auto *idcCachePtr = getCacheEntry(ctx)->IDCCache;
135  if (idcCachePtr==nullptr) {
136  ATH_MSG_ERROR("PixelConditionsSummaryTool No cache! " );
137  return 0;
138  }
139  uint64_t word = (uint64_t)idcCachePtr->retrieve(index);
140  return word<m_missingErrorInfo ? word : 0;
141 }

◆ getCacheEntry()

PixelConditionsSummaryTool::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 }

◆ 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 87 of file PixelConditionsSummaryTool.cxx.

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 }

◆ 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 322 of file PixelConditionsSummaryTool.cxx.

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

◆ 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 520 of file PixelConditionsSummaryTool.cxx.

520  {
521 
522  if (!isGood(moduleHash, ctx)) { return 0.0; }
523 
524  Identifier moduleID = m_pixelID->wafer_id(moduleHash);
525 
526  int phiStart = m_pixelID->phi_index(idStart);
527  int etaStart = m_pixelID->eta_index(idStart);
528 
529  int phiEnd = m_pixelID->phi_index(idEnd);
530  int etaEnd = m_pixelID->eta_index(idEnd);
531 
532  double nTotal = (std::abs(phiStart-phiEnd)+1.0)*(std::abs(etaStart-etaEnd)+1.0);
533 
534  double nGood = 0.0;
535  for (int i=std::min(phiStart,phiEnd); i<=std::max(phiStart,phiEnd); i++) {
536  for (int j=std::min(etaStart,etaEnd); j<=std::max(etaStart,etaEnd); j++) {
537  if (checkChipStatus(moduleHash, m_pixelID->pixel_id(moduleID,i,j), ctx)) {
538  if (!hasBSError(moduleHash, m_pixelID->pixel_id(moduleID,i,j), ctx)) { nGood++; }
539  }
540  }
541  }
542  return nGood/nTotal;
543 }

◆ hasBSError() [1/2]

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

Implements IInDetConditionsTool.

Definition at line 143 of file PixelConditionsSummaryTool.cxx.

143  {
144  uint64_t word = getBSErrorWord(moduleHash,ctx);
145  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TruncatedROB)) { return true; }
146  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MaskedROB)) { return true; }
147  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Preamble)) { return true; }
148  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TimeOut)) { return true; }
149  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::LVL1ID)) { return true; }
150  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::BCID)) { return true; }
151  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Trailer)) { return true; }
152  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDEoECheck)) { return true; }
153  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCBCIDEoECheck)) { return true; }
154  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDCheck)) { return true; }
155  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCEoEOverflow)) { return true; }
156  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCHitOverflow)) { return true; }
157  return false;
158 }

◆ hasBSError() [2/2]

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

Implements IInDetConditionsTool.

Definition at line 160 of file PixelConditionsSummaryTool.cxx.

160  {
161  if (hasBSError(moduleHash, ctx)) { return true; }
162 
163  int maxHash = m_pixelID->wafer_hash_max();
164  Identifier moduleID = m_pixelID->wafer_id(pixid);
165  int chFE = m_pixelReadout->getFE(pixid, moduleID);
166  if (m_pixelReadout->getModuleType(moduleID)==InDetDD::PixelModuleType::IBL_3D) { chFE=0; }
167 
168  int indexFE = (1+chFE)*maxHash+static_cast<int>(moduleHash); // (FE_channel+1)*2048 + moduleHash
169  uint64_t word = getBSErrorWord(moduleHash,indexFE,ctx);
170  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Preamble)) { return true; }
171  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TimeOut)) { return true; }
172  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::LVL1ID)) { return true; }
173  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::BCID)) { return true; }
174  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Trailer)) { return true; }
175  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDEoECheck)) { return true; }
176  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCBCIDEoECheck)) { return true; }
177  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDCheck)) { return true; }
178  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCEoEOverflow)) { return true; }
179  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCHitOverflow)) { return true; }
180  return false;
181 }

◆ initialize()

StatusCode PixelConditionsSummaryTool::initialize ( )
overridevirtual

Definition at line 25 of file PixelConditionsSummaryTool.cxx.

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

◆ 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 167 of file PixelConditionsSummaryTool.h.

167  {
168  static InterfaceID IID_PixelConditionsSummaryTool("PixelConditionsSummaryTool", 1, 0);
169  return IID_PixelConditionsSummaryTool;
170 }

◆ isActive() [1/3]

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

Implements IInDetConditionsTool.

Definition at line 183 of file PixelConditionsSummaryTool.cxx.

183  {
184  return true;
185 }

◆ isActive() [2/3]

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

Implements IInDetConditionsTool.

Definition at line 187 of file PixelConditionsSummaryTool.cxx.

187  {
188 
189  // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
190  // Here, 52736 is a separator beween error flags and isActive flags.
191  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
192  if (useByteStream && getBSErrorWord(moduleHash,moduleHash+52736,ctx)!=1) { return false; }
193 
194  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey,ctx);
195  bool isDCSActive = false;
196  for (int istate : m_activeState) {
197  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
198  }
199  if (!isDCSActive) { return false; }
200 
201  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
202 
203  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey,ctx)->getModuleStatus(moduleHash)) { return false; }
204 
205  return true;
206 }

◆ isActive() [3/3]

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

Implements IInDetConditionsTool.

Definition at line 208 of file PixelConditionsSummaryTool.cxx.

208  {
209 
210  // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
211  // Here, 52736 is a separator beween error flags and isActive flags.
212  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
213  if (useByteStream && getBSErrorWord(moduleHash,moduleHash+52736,ctx)!=1) { return false; }
214 
215  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey,ctx);
216  bool isDCSActive = false;
217  for (int istate : m_activeState) {
218  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
219  }
220  if (!isDCSActive) { return false; }
221 
222  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
223 
224  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey,ctx)->getModuleStatus(moduleHash)) { return false; }
225 
226  return checkChipStatus(moduleHash, elementId, ctx);
227 }

◆ isGood() [1/3]

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

Implements IInDetConditionsTool.

Definition at line 233 of file PixelConditionsSummaryTool.cxx.

233  {
234  Identifier moduleID = m_pixelID->wafer_id(elementId);
235  IdentifierHash moduleHash = m_pixelID->wafer_hash(moduleID);
236 
237  if (hasBSError(moduleHash, ctx)) { return false; }
238 
239  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
240  bool isDCSActive = false;
241  for (int istate : m_activeState) {
242  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
243  }
244  if (!isDCSActive) { return false; }
245 
246  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
247  bool isDCSGood = false;
248  for (int activeStatus : m_activeStatus) {
249  if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
250  }
251  if (!isDCSGood) { return false; }
252 
253  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
254 
255  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
256 
257  if (h==InDetConditions::PIXEL_CHIP) {
258  if (!checkChipStatus(moduleHash, elementId,ctx)) { return false; }
259  if (hasBSError(moduleHash, elementId, ctx)) { return false; }
260  }
261 
262  return true;
263 }

◆ isGood() [2/3]

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

Implements IInDetConditionsTool.

Definition at line 466 of file PixelConditionsSummaryTool.cxx.

466  {
467 
468  if (hasBSError(moduleHash, ctx)) { return false; }
469 
470  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
471  bool isDCSActive = false;
472  for (int istate : m_activeState) {
473  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
474  }
475  if (!isDCSActive) { return false; }
476 
477  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
478  bool isDCSGood = false;
479  for (int activeStatus : m_activeStatus) {
480  if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
481  }
482  if (!isDCSGood) { return false; }
483 
484  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
485 
486  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
487 
488  return true;
489 }

◆ isGood() [3/3]

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

Implements IInDetConditionsTool.

Definition at line 491 of file PixelConditionsSummaryTool.cxx.

491  {
492 
493  if (hasBSError(moduleHash, ctx)) { return false; }
494 
495  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
496  bool isDCSActive = false;
497  for (int istate : m_activeState) {
498  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
499  }
500  if (!isDCSActive) { return false; }
501 
502  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
503  bool isDCSGood = false;
504  for (int activeStatus : m_activeStatus) {
505  if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
506  }
507  if (!isDCSGood) { return false; }
508 
509  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
510 
511  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
512 
513  if (!checkChipStatus(moduleHash, elementId, ctx)) { return false; }
514 
515  if (hasBSError(moduleHash, elementId, ctx)) { return false; }
516 
517  return true;
518 }

◆ 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 128 of file PixelConditionsSummaryTool.h.

◆ ATLAS_THREAD_SAFE [2/2]

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

Definition at line 144 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 123 of file PixelConditionsSummaryTool.h.

◆ m_activeState

std::vector<int> PixelConditionsSummaryTool::m_activeState
private

Definition at line 83 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 85 of file PixelConditionsSummaryTool.h.

◆ m_activeStatus

std::vector<int> PixelConditionsSummaryTool::m_activeStatus
private

Definition at line 84 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 86 of file PixelConditionsSummaryTool.h.

◆ m_BSErrContReadKey

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

Definition at line 112 of file PixelConditionsSummaryTool.h.

◆ m_condDCSStateKey

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

Definition at line 97 of file PixelConditionsSummaryTool.h.

◆ m_condDCSStatusKey

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

Definition at line 100 of file PixelConditionsSummaryTool.h.

◆ m_condDeadMapKey

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

Definition at line 106 of file PixelConditionsSummaryTool.h.

◆ m_condTDAQKey

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

Definition at line 103 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 82 of file PixelConditionsSummaryTool.h.

◆ m_isActiveStatus

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

Definition at line 81 of file PixelConditionsSummaryTool.h.

◆ m_missingErrorInfo

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

Definition at line 126 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 115 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 120 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 118 of file PixelConditionsSummaryTool.h.

◆ m_pixelID

const PixelID* PixelConditionsSummaryTool::m_pixelID {}
private

Definition at line 79 of file PixelConditionsSummaryTool.h.

◆ m_pixelReadout

ServiceHandle<InDetDD::IPixelReadoutManager> PixelConditionsSummaryTool::m_pixelReadout {this, "PixelReadoutManager", "PixelReadoutManager", "Pixel readout manager" }
private

Definition at line 109 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 91 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 88 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 94 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
PixelConditionsSummaryTool::hasBSError
virtual bool hasBSError(const IdentifierHash &moduleHash, const EventContext &ctx) const override final
Definition: PixelConditionsSummaryTool.cxx:143
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:658
InDetDD::PixelReadoutTechnology
PixelReadoutTechnology
Definition: PixelReadoutDefinitions.h:28
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:30
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:19
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
InDetDD::PixelModuleDesign
Definition: PixelModuleDesign.h:48
PixelConditionsSummaryTool::checkChipStatus
bool checkChipStatus(IdentifierHash moduleHash, Identifier pixid, const EventContext &ctx) const
Definition: PixelConditionsSummaryTool.h:172
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:86
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
python.Constants.ERROR
int ERROR
Definition: Control/AthenaCommon/python/Constants.py:18
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:60
PixelConditionsSummaryTool::m_isActiveStates
std::vector< std::string > m_isActiveStates
Definition: PixelConditionsSummaryTool.h:82
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:233
PixelByteStreamErrors::makeError
constexpr IDCInDetBSErrContainer::ErrorCode makeError(PixelErrorsEnum errType)
helper to be used in clients to fetch error information
Definition: PixelByteStreamErrors.h:21
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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
PixelConditionsSummaryTool::m_condDCSStateKey
SG::ReadCondHandleKey< PixelDCSStateData > m_condDCSStateKey
Definition: PixelConditionsSummaryTool.h:98
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:83
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:364
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:101
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
InDetDD::PixelReadoutTechnology::RD53
@ RD53
PixelByteStreamErrors::BCID
@ BCID
Definition: PixelByteStreamErrors.h:13
PixelConditionsSummaryTool::m_pixelDetElStatusEventKey
SG::ReadHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusEventKey
Definition: PixelConditionsSummaryTool.h:119
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition: PixelID.h:387
PixelConditionsSummaryTool::m_BSErrContReadKey
SG::ReadHandleKey< IDCInDetBSErrContainer > m_BSErrContReadKey
Definition: PixelConditionsSummaryTool.h:113
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:85
AthCommonDataStore
Definition: AthCommonDataStore.h:52
PixelConditionsSummaryTool::m_useByteStreamFEI4
Gaudi::Property< bool > m_useByteStreamFEI4
Definition: PixelConditionsSummaryTool.h:89
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
UNDEFINED
@ UNDEFINED
Definition: sTGCenumeration.h:18
lumiFormat.i
int i
Definition: lumiFormat.py:92
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
PixelByteStreamErrors::Preamble
@ Preamble
Definition: PixelByteStreamErrors.h:13
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
IDetectorElementStatusTool::getInvalidRange
static EventIDRange getInvalidRange()
Definition: IDetectorElementStatusTool.h:33
InDetDD::PixelModuleDesign::numberOfCircuits
int numberOfCircuits() const
Total number of circuits:
Definition: PixelModuleDesign.h:297
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:664
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
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:79
python.Constants.WARNING
int WARNING
Definition: Control/AthenaCommon/python/Constants.py:17
PixelConditionsSummaryTool::getBSErrorWord
virtual uint64_t getBSErrorWord(const IdentifierHash &moduleHash, const EventContext &ctx) const override final
Definition: PixelConditionsSummaryTool.cxx:109
python.compareNtuple.nGood
nGood
Definition: compareNtuple.py:55
PixelByteStreamErrors::MaskedROB
@ MaskedROB
Definition: PixelByteStreamErrors.h:14
PixelConditionsSummaryTool::m_activeState
std::vector< int > m_activeState
Definition: PixelConditionsSummaryTool.h:83
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
min
#define min(a, b)
Definition: cfImp.cxx:40
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
PixelConditionsSummaryTool::m_pixelReadout
ServiceHandle< InDetDD::IPixelReadoutManager > m_pixelReadout
Definition: PixelConditionsSummaryTool.h:110
PixelByteStreamErrors::MCCHitOverflow
@ MCCHitOverflow
Definition: PixelByteStreamErrors.h:15
PixelByteStreamErrors::MCCLVL1IDCheck
@ MCCLVL1IDCheck
Definition: PixelByteStreamErrors.h:15
PixelConditionsSummaryTool::m_condTDAQKey
SG::ReadCondHandleKey< PixelTDAQData > m_condTDAQKey
Definition: PixelConditionsSummaryTool.h:104
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
PixelByteStreamErrors::MCCEoEOverflow
@ MCCEoEOverflow
Definition: PixelByteStreamErrors.h:15
PixelConditionsSummaryTool::m_pixelDetElStatusCondKey
SG::ReadCondHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusCondKey
Definition: PixelConditionsSummaryTool.h:121
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
PixelID::wafer_hash_max
size_type wafer_hash_max(void) const
Definition: PixelID.cxx:912
InDetDD::PixelReadoutTechnology::FEI4
@ FEI4
InDetDD::PixelModuleDesign::getReadoutTechnology
PixelReadoutTechnology getReadoutTechnology() const
Definition: PixelModuleDesign.h:368
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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:87
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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:432
PixelConditionsSummaryTool::m_condDeadMapKey
SG::ReadCondHandleKey< PixelDeadMapCondData > m_condDeadMapKey
Definition: PixelConditionsSummaryTool.h:107
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:293
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
PixelConditionsSummaryTool::m_useByteStreamFEI3
Gaudi::Property< bool > m_useByteStreamFEI3
Definition: PixelConditionsSummaryTool.h:92
InDet::ChipFlags_t
unsigned short ChipFlags_t
Definition: SiDetectorElementStatus.h:60
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
PixelDeadMapCondData
Definition: PixelDeadMapCondData.h:11
merge.status
status
Definition: merge.py:17
PixelConditionsSummaryTool::m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
Definition: PixelConditionsSummaryTool.h:116
PixelConditionsSummaryTool::m_useByteStreamRD53
Gaudi::Property< bool > m_useByteStreamRD53
Definition: PixelConditionsSummaryTool.h:95
PixelConditionsSummaryTool::m_missingErrorInfo
const uint64_t m_missingErrorInfo
Definition: PixelConditionsSummaryTool.h:126
IdentifierHash
Definition: IdentifierHash.h:38
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:124
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
InDetDD::PixelModuleType::IBL_3D
@ IBL_3D
IdentifiableValueCache
This class is to provide an event wide MT container for concurrent storing of basic types,...
Definition: IdentifiableValueCache.h:19
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
PixelByteStreamErrors::TruncatedROB
@ TruncatedROB
Definition: PixelByteStreamErrors.h:14
PixelByteStreamErrors::Trailer
@ Trailer
Definition: PixelByteStreamErrors.h:13
PixelConditionsSummaryTool::IDCCacheEntry::IDCCache
const IDCInDetBSErrContainer_Cache * IDCCache
Definition: PixelConditionsSummaryTool.h:132
fitman.k
k
Definition: fitman.py:528
PixelConditionsSummaryTool::m_activeStatus
std::vector< int > m_activeStatus
Definition: PixelConditionsSummaryTool.h:84
IDetectorElementStatusTool::getUndefinedEventId
static EventIDBase getUndefinedEventId()
Definition: IDetectorElementStatusTool.h:32
PixelConditionsSummaryTool::m_isActiveStatus
std::vector< std::string > m_isActiveStatus
Definition: PixelConditionsSummaryTool.h:81
SG::WriteCondHandle::addDependency
void addDependency(const EventIDRange &range)
Definition: WriteCondHandle.h:275
PixelByteStreamErrors::LVL1ID
@ LVL1ID
Definition: PixelByteStreamErrors.h:13
Generated on Fri Jun 28 2024 21:56:48 for ATLAS Offline Software by   doxygen 1.8.18