PixelByteStreamErrorDetectorElementStatusTool Class Reference

Tool to extend pixel detector element status data by the status extracted from the bytestream error container. More...

#include <PixelByteStreamErrorDetectorElementStatusTool.h>

Inheritance diagram for PixelByteStreamErrorDetectorElementStatusTool:

Collaboration diagram for PixelByteStreamErrorDetectorElementStatusTool:

Public Member Functions
	PixelByteStreamErrorDetectorElementStatusTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual std::unique_ptr< InDet::SiDetectorElementStatus >	getDetectorElementStatus (const EventContext &ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const override

Static Public Member Functions
static InterfaceID &	interfaceID ()

Protected Member Functions
std::unique_ptr< InDet::SiDetectorElementStatus >	createDetectorElementStatus (const EventContext &ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const
	Create a new detector element status element container. More...

Protected Attributes
const PixelID *	m_pixelID {}

Private Attributes
SG::ReadHandleKey< IDCInDetBSErrContainer >	m_BSErrContReadKey {this, "PixelByteStreamErrs", "PixelByteStreamErrs", "PixelByteStreamErrs container key"}
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"}
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."}
unsigned int	m_readoutTechnologyMask {}
	Mask where each bit represents a readout technology;. More...
ServiceHandle< InDetDD::IPixelReadoutManager >	m_pixelReadout {this, "PixelReadoutManager", "PixelReadoutManager", "Pixel readout manager" }
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}
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."}

Detailed Description

Tool to extend pixel detector element status data by the status extracted from the bytestream error container.

The input to the tool can only be conditions data, the output will have an invalid IOV. Thus, can only be event data.

Definition at line 14 of file PixelByteStreamErrorDetectorElementStatusTool.h.

Constructor & Destructor Documentation

PixelByteStreamErrorDetectorElementStatusTool()

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

inline

Definition at line 17 of file PixelByteStreamErrorDetectorElementStatusTool.h.

      :  PixelDetectorElementStatusToolBase(type,name, parent)
   {}

Member Function Documentation

createDetectorElementStatus()

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

protectedinherited

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 34 of file PixelDetectorElementStatusToolBase.cxx.

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

getDetectorElementStatus()

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

overridevirtual

Definition at line 31 of file PixelByteStreamErrorDetectorElementStatusTool.cxx.

                                                                                                                                         {
   std::unique_ptr<InDet::SiDetectorElementStatus> element_status( createDetectorElementStatus(ctx, whandle));
   std::vector<bool> &status=element_status->getElementStatus();
   if (status.empty()) {
      status.resize(m_pixelID->wafer_hash_max(),true );
   }
   std::vector<InDet::ChipFlags_t> &chip_status=element_status->getElementChipStatus();
   if (chip_status.empty()) {
      chip_status.resize(status.size(),0xffff);
   }
 
   if (whandle) {
     ATH_MSG_ERROR("PixelByteStreamErrorDetectorStatusTool is not for use with conditions objects");
     whandle->addDependency (IDetectorElementStatusTool::getInvalidRange());
   }
 
   if (m_readoutTechnologyMask) {
      SG::ReadHandle<IDCInDetBSErrContainer> idcErrCont(m_BSErrContReadKey, ctx);
      if (!idcErrCont.isValid()) {
         ATH_MSG_ERROR("Did not get bytestream error container with key " << m_BSErrContReadKey);
      }
      else {
 
         const IDCInDetBSErrContainer_Cache *idcCachePtr = idcErrCont->cache();
 
         constexpr uint64_t error_mask = PixelByteStreamErrors::makeError(PixelByteStreamErrors::TruncatedROB)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MaskedROB)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Preamble)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::TimeOut)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::LVL1ID)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::BCID)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Trailer)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDEoECheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCBCIDEoECheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDCheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCEoEOverflow)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCHitOverflow);
 
         constexpr uint64_t chip_error_mask = PixelByteStreamErrors::makeError(PixelByteStreamErrors::Preamble)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::TimeOut)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::LVL1ID)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::BCID)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::Trailer)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDEoECheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCBCIDEoECheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCLVL1IDCheck)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCEoEOverflow)
            | PixelByteStreamErrors::makeError(PixelByteStreamErrors::MCCHitOverflow);
 
         // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
         // Here, 52736 is a separator beween error flags and isActive flags.
         const bool active_only = m_activeOnly;
         unsigned int element_offset_i = (active_only ? 52736 : 0);
 
         unsigned int element_i=0;
         unsigned int maxHash = m_pixelID->wafer_hash_max();
 
         constexpr uint64_t missingErrorInfo{std::numeric_limits<uint64_t>::max()-3000000000};
 
         for (const InDetDD::SiDetectorElement *element : element_status->getDetectorElements()) {
            const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
            InDetDD::PixelReadoutTechnology readout_technology = p_design->getReadoutTechnology();
            unsigned int readout_technology_flags = m_readoutTechnologyMask & Pixel::makeReadoutTechnologyBit(readout_technology);
 
            // set to false if has one of the considered errors and the readout technology is considered.
            status.at(element_i) = status.at(element_i) &&  not (   readout_technology_flags
                                                                &&  ( !active_only
                                                                     ?  isBSError(static_cast<uint64_t>(idcCachePtr->retrieve(element_i)), missingErrorInfo, error_mask)
                                                                      : idcCachePtr->retrieve(element_i+element_offset_i)!=1 ));
 
            // compute the status for the individual front-ends
            if (status[element_i]) {
               unsigned int number_of_chips = readout_technology == InDetDD::PixelReadoutTechnology::FEI3  ? 2*p_design->numberOfCircuits() : p_design->numberOfCircuits();
               InDet::ChipFlags_t  chip_mask = status[element_i] ? (1ul<<number_of_chips)-1ul : 0;
               assert( chip_mask != 0 );
               InDet::ChipFlags_t bs_status_flags = active_only ? chip_mask : 0;
               if (!active_only) {
                  for (unsigned int chip_i =0; chip_i < number_of_chips; ++chip_i) {
                     // get bytestream error for chip
                     unsigned int indexFE = (1+chip_i)*maxHash + element_i;    // (FE_channel+1)*2048 + moduleHash
                     InDet::ChipFlags_t chip_flag =not (    readout_technology_flags
                                                        && (isBSError(static_cast<uint64_t>(idcCachePtr->retrieve(indexFE)), missingErrorInfo, chip_error_mask)));
                     bs_status_flags |= (chip_flag << chip_i);
                  }
               }
               chip_status[element_i] &=  (bs_status_flags & chip_mask);
            }
            else {
               chip_status[element_i] = 0;
            }
            ++element_i;
         }
      }
   }
 
   return element_status;
}

initialize()

StatusCode PixelByteStreamErrorDetectorElementStatusTool::initialize ( )

overridevirtual

Reimplemented from PixelDetectorElementStatusToolBase.

Definition at line 6 of file PixelByteStreamErrorDetectorElementStatusTool.cxx.

{
   ATH_CHECK( PixelDetectorElementStatusToolBase::initialize() );
 
   bool useByteStream = (m_useByteStreamFEI4 || m_useByteStreamFEI3 || m_useByteStreamRD53);
   ATH_CHECK(m_BSErrContReadKey.initialize(useByteStream && !m_BSErrContReadKey.empty()));
 
   static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::FEI4) < 32u) ;
   static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::FEI3) < 32u) ;
   static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::RD53) < 32u) ;
   m_readoutTechnologyMask=  Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI4, 1 && m_useByteStreamFEI4 )
      | Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI3, 1 && m_useByteStreamFEI3 )
      | Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::RD53, 1 && m_useByteStreamRD53 );
 
   return StatusCode::SUCCESS;
}

interfaceID()

InterfaceID & PixelByteStreamErrorDetectorElementStatusTool::interfaceID ( )

inlinestatic

Definition at line 46 of file PixelByteStreamErrorDetectorElementStatusTool.h.

                                                                              {
  static InterfaceID IID_PixelByteStreamErrorDetectorElementStatusTool("PixelByteStreamErrorDetectorElementStatusTool", 1, 0);
  return IID_PixelByteStreamErrorDetectorElementStatusTool;
}

Member Data Documentation

m_activeOnly

Gaudi::Property< bool> PixelByteStreamErrorDetectorElementStatusTool::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 40 of file PixelByteStreamErrorDetectorElementStatusTool.h.

m_BSErrContReadKey

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

private

Definition at line 28 of file PixelByteStreamErrorDetectorElementStatusTool.h.

m_pixelDetEleCollKey

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

privateinherited

Definition at line 45 of file PixelDetectorElementStatusToolBase.h.

m_pixelDetElStatusCondKey

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

privateinherited

Definition at line 48 of file PixelDetectorElementStatusToolBase.h.

m_pixelID

const PixelID* PixelDetectorElementStatusToolBase::m_pixelID {}

protectedinherited

Definition at line 39 of file PixelDetectorElementStatusToolBase.h.

m_pixelReadout

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

privateinherited

Definition at line 42 of file PixelDetectorElementStatusToolBase.h.

m_readoutTechnologyMask

unsigned int PixelByteStreamErrorDetectorElementStatusTool::m_readoutTechnologyMask {}

private

Mask where each bit represents a readout technology;.

Definition at line 43 of file PixelByteStreamErrorDetectorElementStatusTool.h.

m_useByteStreamFEI3

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

private

Definition at line 34 of file PixelByteStreamErrorDetectorElementStatusTool.h.

m_useByteStreamFEI4

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

private

Definition at line 31 of file PixelByteStreamErrorDetectorElementStatusTool.h.

m_useByteStreamRD53

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

private

Definition at line 37 of file PixelByteStreamErrorDetectorElementStatusTool.h.

---

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

• PixelByteStreamErrorDetectorElementStatusTool.h
• PixelByteStreamErrorDetectorElementStatusTool.cxx