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 > &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 242 of file PixelConditionsSummaryTool.cxx.

242  {
243  return 1.0;
244 }

◆ checkChipStatus()

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

Definition at line 175 of file PixelConditionsSummaryTool.h.

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

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

307  {
308  if (!m_pixelDetElStatusCondKey.empty()) {
309  SG::ReadCondHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusCondKey, ctx};
310  if (whandle) {
311  whandle->addDependency (input_element_status);
312  }
313  return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
314  }
315  else if (!m_pixelDetElStatusEventKey.empty()) {
316  SG::ReadHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusEventKey, ctx};
317  return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
318  }
319  else {
320  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
321  if (not pixelDetEleHandle.isValid() ) {
322  std::stringstream msg;
323  msg << m_pixelDetEleCollKey.fullKey() << " is not available.";
324  throw std::runtime_error(msg.str());
325  }
326  if (whandle) {
327  whandle->addDependency (pixelDetEleHandle);
328  }
329  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
330  return std::make_unique<InDet::PixelDetectorElementStatus>(*elements);
331  }
332 }

◆ 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 IDCCacheEntry *  cacheEntry = nullptr 
) const
finaloverridevirtual

Implements IInDetConditionsTool.

Definition at line 119 of file PixelConditionsSummaryTool.cxx.

119  {
120  return getBSErrorWord(moduleHash, moduleHash, ctx, cacheEntry);
121 }

◆ getBSErrorWord() [2/2]

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

Implements IInDetConditionsTool.

Definition at line 123 of file PixelConditionsSummaryTool.cxx.

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

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

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

◆ getCacheEntryOut()

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

Implements IInDetConditionsTool.

Definition at line 113 of file PixelConditionsSummaryTool.cxx.

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

◆ 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  bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
89  if (!useByteStream || m_BSErrContReadKey.empty() ) {
90  return nullptr;
91  }
92  SG::ReadHandle<IDCInDetBSErrContainer> idcErrCont(m_BSErrContReadKey, ctx);
93  if (not idcErrCont.isValid()) { return nullptr; }
94  ATH_MSG_VERBOSE("PixelConditionsSummaryTool IDC Container fetched " << m_BSErrContReadKey.key());
95  return idcErrCont.cptr();
96 }

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

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

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

533  {
534 
535  if (!isGood(moduleHash, ctx)) { return 0.0; }
536 
537  Identifier moduleID = m_pixelID->wafer_id(moduleHash);
538 
539  int phiStart = m_pixelID->phi_index(idStart);
540  int etaStart = m_pixelID->eta_index(idStart);
541 
542  int phiEnd = m_pixelID->phi_index(idEnd);
543  int etaEnd = m_pixelID->eta_index(idEnd);
544 
545  double nTotal = (std::abs(phiStart-phiEnd)+1.0)*(std::abs(etaStart-etaEnd)+1.0);
546 
547  double nGood = 0.0;
548  IInDetConditionsTool::IDCCacheEntry* cacheEntry = getCacheEntry(ctx);
549  for (int i=std::min(phiStart,phiEnd); i<=std::max(phiStart,phiEnd); i++) {
550  for (int j=std::min(etaStart,etaEnd); j<=std::max(etaStart,etaEnd); j++) {
551  if (checkChipStatus(moduleHash, m_pixelID->pixel_id(moduleID,i,j), ctx)) {
552  if (!hasBSError(moduleHash, m_pixelID->pixel_id(moduleID,i,j), ctx, cacheEntry)) { nGood++; }
553  }
554  }
555  }
556  return nGood/nTotal;
557 }

◆ hasBSError() [1/2]

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

Implements IInDetConditionsTool.

Definition at line 156 of file PixelConditionsSummaryTool.cxx.

156  {
157  uint64_t word = getBSErrorWord(moduleHash,ctx,cacheEntry);
158  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TruncatedROB)) { return true; }
159  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MaskedROB)) { return true; }
160  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Preamble)) { return true; }
161  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TimeOut)) { return true; }
162  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::LVL1ID)) { return true; }
163  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::BCID)) { return true; }
164  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Trailer)) { return true; }
165  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDEoECheck)) { return true; }
166  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCBCIDEoECheck)) { return true; }
167  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDCheck)) { return true; }
168  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCEoEOverflow)) { return true; }
169  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCHitOverflow)) { return true; }
170  return false;
171 }

◆ hasBSError() [2/2]

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

Implements IInDetConditionsTool.

Definition at line 173 of file PixelConditionsSummaryTool.cxx.

173  {
174  if (hasBSError(moduleHash, ctx, cacheEntry)) { return true; }
175 
176  int maxHash = m_pixelID->wafer_hash_max();
177  Identifier moduleID = m_pixelID->wafer_id(pixid);
178  int chFE = m_pixelReadout->getFE(pixid, moduleID);
179  if (m_pixelReadout->getModuleType(moduleID)==InDetDD::PixelModuleType::IBL_3D) { chFE=0; }
180 
181  int indexFE = (1+chFE)*maxHash+static_cast<int>(moduleHash); // (FE_channel+1)*2048 + moduleHash
182  uint64_t word = getBSErrorWord(moduleHash,indexFE,ctx,cacheEntry);
183  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Preamble)) { return true; }
184  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::TimeOut)) { return true; }
185  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::LVL1ID)) { return true; }
186  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::BCID)) { return true; }
187  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::Trailer)) { return true; }
188  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDEoECheck)) { return true; }
189  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCBCIDEoECheck)) { return true; }
190  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCLVL1IDCheck)) { return true; }
191  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCEoEOverflow)) { return true; }
192  if (PixelByteStreamErrors::hasError(word,PixelByteStreamErrors::MCCHitOverflow)) { return true; }
193  return false;
194 }

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

170  {
171  static InterfaceID IID_PixelConditionsSummaryTool("PixelConditionsSummaryTool", 1, 0);
172  return IID_PixelConditionsSummaryTool;
173 }

◆ isActive() [1/3]

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

Implements IInDetConditionsTool.

Definition at line 196 of file PixelConditionsSummaryTool.cxx.

196  {
197  return true;
198 }

◆ isActive() [2/3]

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

Implements IInDetConditionsTool.

Definition at line 200 of file PixelConditionsSummaryTool.cxx.

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

◆ isActive() [3/3]

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

Implements IInDetConditionsTool.

Definition at line 221 of file PixelConditionsSummaryTool.cxx.

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

◆ isGood() [1/3]

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

Implements IInDetConditionsTool.

Definition at line 246 of file PixelConditionsSummaryTool.cxx.

246  {
247  Identifier moduleID = m_pixelID->wafer_id(elementId);
248  IdentifierHash moduleHash = m_pixelID->wafer_hash(moduleID);
249 
250  if (hasBSError(moduleHash, ctx)) { 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  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
260  bool isDCSGood = false;
261  for (int activeStatus : m_activeStatus) {
262  if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
263  }
264  if (!isDCSGood) { return false; }
265 
266  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
267 
268  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
269 
270  if (h==InDetConditions::PIXEL_CHIP) {
271  if (!checkChipStatus(moduleHash, elementId,ctx)) { return false; }
272  if (hasBSError(moduleHash, elementId, ctx)) { return false; }
273  }
274 
275  return true;
276 }

◆ isGood() [2/3]

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

Implements IInDetConditionsTool.

Definition at line 479 of file PixelConditionsSummaryTool.cxx.

479  {
480 
481  if (hasBSError(moduleHash, ctx)) { return false; }
482 
483  SG::ReadCondHandle<PixelDCSStateData> dcsstate_data(m_condDCSStateKey, ctx);
484  bool isDCSActive = false;
485  for (int istate : m_activeState) {
486  if (istate==dcsstate_data->getModuleStatus(moduleHash)) { isDCSActive=true; }
487  }
488  if (!isDCSActive) { return false; }
489 
490  SG::ReadCondHandle<PixelDCSStatusData> dcsstatus_data(m_condDCSStatusKey, ctx);
491  bool isDCSGood = false;
492  for (int activeStatus : m_activeStatus) {
493  if (activeStatus==dcsstatus_data->getModuleStatus(moduleHash)) { isDCSGood=true; }
494  }
495  if (!isDCSGood) { return false; }
496 
497  if (!m_condTDAQKey.empty() && SG::ReadCondHandle<PixelTDAQData>(m_condTDAQKey,ctx)->getModuleStatus(moduleHash)) { return false; }
498 
499  if (SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getModuleStatus(moduleHash)) { return false; }
500 
501  return true;
502 }

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

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

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

◆ ATLAS_THREAD_SAFE [2/2]

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

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

◆ m_activeState

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

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

◆ m_activeStatus

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

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

◆ m_BSErrContReadKey

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

Definition at line 115 of file PixelConditionsSummaryTool.h.

◆ m_condDCSStateKey

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

Definition at line 100 of file PixelConditionsSummaryTool.h.

◆ m_condDCSStatusKey

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

Definition at line 103 of file PixelConditionsSummaryTool.h.

◆ m_condDeadMapKey

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

Definition at line 109 of file PixelConditionsSummaryTool.h.

◆ m_condTDAQKey

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

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

◆ m_isActiveStatus

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

Definition at line 84 of file PixelConditionsSummaryTool.h.

◆ m_missingErrorInfo

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

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

◆ m_pixelID

const PixelID* PixelConditionsSummaryTool::m_pixelID {}
private

Definition at line 82 of file PixelConditionsSummaryTool.h.

◆ m_pixelReadout

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

Definition at line 112 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 94 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 91 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 97 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:658
InDetDD::PixelReadoutTechnology
PixelReadoutTechnology
Definition: PixelReadoutDefinitions.h:34
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:175
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:89
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
PixelConditionsSummaryTool::hasBSError
virtual bool hasBSError(const IdentifierHash &moduleHash, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
Definition: PixelConditionsSummaryTool.cxx:156
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:98
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:85
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:246
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
PixelConditionsSummaryTool::getBSErrorWord
virtual uint64_t getBSErrorWord(const IdentifierHash &moduleHash, const EventContext &ctx, const IDCCacheEntry *cacheEntry=nullptr) const override final
Definition: PixelConditionsSummaryTool.cxx:119
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:101
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
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:104
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
InDetDD::PixelReadoutTechnology::RD53
@ RD53
PixelByteStreamErrors::BCID
@ BCID
Definition: PixelByteStreamErrors.h:13
PixelConditionsSummaryTool::m_pixelDetElStatusEventKey
SG::ReadHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusEventKey
Definition: PixelConditionsSummaryTool.h:122
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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:116
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:88
AthCommonDataStore
Definition: AthCommonDataStore.h:52
PixelConditionsSummaryTool::m_useByteStreamFEI4
Gaudi::Property< bool > m_useByteStreamFEI4
Definition: PixelConditionsSummaryTool.h:92
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:85
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
detail::ul
unsigned long ul
Definition: PrimitiveHelpers.h:45
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:82
python.Constants.WARNING
int WARNING
Definition: Control/AthenaCommon/python/Constants.py:17
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:86
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:113
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:107
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
PixelByteStreamErrors::MCCEoEOverflow
@ MCCEoEOverflow
Definition: PixelByteStreamErrors.h:15
PixelConditionsSummaryTool::m_pixelDetElStatusCondKey
SG::ReadCondHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusCondKey
Definition: PixelConditionsSummaryTool.h:124
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:907
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:110
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:306
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
PixelConditionsSummaryTool::m_useByteStreamFEI3
Gaudi::Property< bool > m_useByteStreamFEI3
Definition: PixelConditionsSummaryTool.h:95
InDet::ChipFlags_t
unsigned short ChipFlags_t
Definition: SiDetectorElementStatus.h:60
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
PixelDeadMapCondData
Definition: PixelDeadMapCondData.h:11
merge.status
status
Definition: merge.py:17
PixelConditionsSummaryTool::m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
Definition: PixelConditionsSummaryTool.h:119
PixelConditionsSummaryTool::m_useByteStreamRD53
Gaudi::Property< bool > m_useByteStreamRD53
Definition: PixelConditionsSummaryTool.h:98
PixelConditionsSummaryTool::m_missingErrorInfo
const uint64_t m_missingErrorInfo
Definition: PixelConditionsSummaryTool.h:129
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:127
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
IInDetConditionsTool::IDCCacheEntry::IDCCache
const IDCInDetBSErrContainer_Cache * IDCCache
Definition: IInDetConditionsTool.h:35
fitman.k
k
Definition: fitman.py:528
PixelConditionsSummaryTool::m_activeStatus
std::vector< int > m_activeStatus
Definition: PixelConditionsSummaryTool.h:87
IDetectorElementStatusTool::getUndefinedEventId
static EventIDBase getUndefinedEventId()
Definition: IDetectorElementStatusTool.h:32
IInDetConditionsTool::IDCCacheEntry
Definition: IInDetConditionsTool.h:33
PixelConditionsSummaryTool::m_isActiveStatus
std::vector< std::string > m_isActiveStatus
Definition: PixelConditionsSummaryTool.h:84
SG::WriteCondHandle::addDependency
void addDependency(const EventIDRange &range)
Definition: WriteCondHandle.h:275
PixelByteStreamErrors::LVL1ID
@ LVL1ID
Definition: PixelByteStreamErrors.h:13
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 21:54:20 for ATLAS Offline Software by   doxygen 1.8.18