ATLAS Offline Software
Loading...
Searching...
No Matches
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::SiDetectorElementStatusgetDetectorElementStatus (const EventContext &ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const override

Static Public Member Functions

static InterfaceID & interfaceID ()

Protected Member Functions

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

Protected Attributes

const PixelIDm_pixelID {}

Private Attributes

SG::ReadHandleKey< IDCInDetBSErrContainerm_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;.
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollectionm_pixelDetEleCollKey {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"}
SG::ReadCondHandleKey< InDet::SiDetectorElementStatusm_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.

18 : PixelDetectorElementStatusToolBase(type,name, parent)
19 {}
PixelDetectorElementStatusToolBase(const std::string &type, const std::string &name, const IInterface *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.

35 {
36 if (!m_pixelDetElStatusCondKey.empty()) {
37 SG::ReadCondHandle<InDet::SiDetectorElementStatus> input_element_status{m_pixelDetElStatusCondKey, ctx};
38 if (whandle) {
39 whandle->addDependency (input_element_status);
40 }
41
42 return std::make_unique<InDet::PixelDetectorElementStatus>(*castToDerived(input_element_status.cptr()));
43 }
44 else {
45 SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
46 if (not pixelDetEleHandle.isValid() ) {
47 std::stringstream msg;
48 msg << m_pixelDetEleCollKey.fullKey() << " is not available.";
49 throw std::runtime_error(msg.str());
50 }
51 if (whandle) {
52 whandle->addDependency (pixelDetEleHandle);
53 }
54 const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
55 return std::make_unique<InDet::PixelDetectorElementStatus>(*elements);
56 }
57}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusCondKey
const_pointer_type cptr()
void addDependency(const EventIDRange &range)
MsgStream & msg
Definition testRead.cxx:32

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

32 {
33 std::unique_ptr<InDet::SiDetectorElementStatus> element_status( createDetectorElementStatus(ctx, whandle));
34 std::vector<bool> &status=element_status->getElementStatus();
35 if (status.empty()) {
36 status.resize(m_pixelID->wafer_hash_max(),true );
37 }
38 std::vector<InDet::ChipFlags_t> &chip_status=element_status->getElementChipStatus();
39 if (chip_status.empty()) {
40 chip_status.resize(status.size(),0xffff);
41 }
42
43 if (whandle) {
44 ATH_MSG_ERROR("PixelByteStreamErrorDetectorStatusTool is not for use with conditions objects");
46 }
47
49 SG::ReadHandle<IDCInDetBSErrContainer> idcErrCont(m_BSErrContReadKey, ctx);
50 if (!idcErrCont.isValid()) {
51 ATH_MSG_ERROR("Did not get bytestream error container with key " << m_BSErrContReadKey);
52 }
53 else {
54
55 const IDCInDetBSErrContainer_Cache *idcCachePtr = idcErrCont->cache();
56
69
80
81 // The index array is defined in PixelRawDataProviderTool::SizeOfIDCInDetBSErrContainer()
82 // Here, 52736 is a separator beween error flags and isActive flags.
83 const bool active_only = m_activeOnly;
84 unsigned int element_offset_i = (active_only ? 52736 : 0);
85
86 unsigned int element_i=0;
87 unsigned int maxHash = m_pixelID->wafer_hash_max();
88
89 constexpr uint64_t missingErrorInfo{std::numeric_limits<uint64_t>::max()-3000000000};
90
91 for (const InDetDD::SiDetectorElement *element : element_status->getDetectorElements()) {
92 const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
93 InDetDD::PixelReadoutTechnology readout_technology = p_design->getReadoutTechnology();
94 unsigned int readout_technology_flags = m_readoutTechnologyMask & Pixel::makeReadoutTechnologyBit(readout_technology);
95
96 // set to false if has one of the considered errors and the readout technology is considered.
97 status.at(element_i) = status.at(element_i) && not ( readout_technology_flags
98 && ( !active_only
99 ? isBSError(static_cast<uint64_t>(idcCachePtr->retrieve(element_i)), missingErrorInfo, error_mask)
100 : idcCachePtr->retrieve(element_i+element_offset_i)!=1 ));
101
102 // compute the status for the individual front-ends
103 if (status[element_i]) {
104 unsigned int number_of_chips = readout_technology == InDetDD::PixelReadoutTechnology::FEI3 ? 2*p_design->numberOfCircuits() : p_design->numberOfCircuits();
105 InDet::ChipFlags_t chip_mask = status[element_i] ? (1ul<<number_of_chips)-1ul : 0;
106 assert( chip_mask != 0 );
107 InDet::ChipFlags_t bs_status_flags = active_only ? chip_mask : 0;
108 if (!active_only) {
109 for (unsigned int chip_i =0; chip_i < number_of_chips; ++chip_i) {
110 // get bytestream error for chip
111 unsigned int indexFE = (1+chip_i)*maxHash + element_i; // (FE_channel+1)*2048 + moduleHash
112 InDet::ChipFlags_t chip_flag =not ( readout_technology_flags
113 && (isBSError(static_cast<uint64_t>(idcCachePtr->retrieve(indexFE)), missingErrorInfo, chip_error_mask)));
114 bs_status_flags |= (chip_flag << chip_i);
115 }
116 }
117 chip_status[element_i] &= (bs_status_flags & chip_mask);
118 }
119 else {
120 chip_status[element_i] = 0;
121 }
122 ++element_i;
123 }
124 }
125 }
126
127 return element_status;
128}
#define ATH_MSG_ERROR(x)
IdentifiableValueCache< IDCInDetBSErrContainer::ErrorCode > IDCInDetBSErrContainer_Cache
T retrieve(size_t i)
Retrieve the Value stored in that hash.
PixelReadoutTechnology getReadoutTechnology() const
int numberOfCircuits() const
Total number of circuits:
unsigned short ChipFlags_t
unsigned int m_readoutTechnologyMask
Mask where each bit represents a readout technology;.
std::unique_ptr< InDet::SiDetectorElementStatus > createDetectorElementStatus(const EventContext &ctx, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const
Create a new detector element status element container.
constexpr IDCInDetBSErrContainer::ErrorCode makeError(PixelErrorsEnum errType)
helper to be used in clients to fetch error information
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.
status
Definition merge.py:16

◆ initialize()

StatusCode PixelByteStreamErrorDetectorElementStatusTool::initialize ( )
overridevirtual

Reimplemented from PixelDetectorElementStatusToolBase.

Definition at line 6 of file PixelByteStreamErrorDetectorElementStatusTool.cxx.

7{
9
11 ATH_CHECK(m_BSErrContReadKey.initialize(useByteStream && !m_BSErrContReadKey.empty()));
12
13 static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::FEI4) < 32u) ;
14 static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::FEI3) < 32u) ;
15 static_assert( static_cast<unsigned int>(InDetDD::PixelReadoutTechnology::RD53) < 32u) ;
19
20 return StatusCode::SUCCESS;
21}
#define ATH_CHECK
Evaluate an expression and check for errors.

◆ interfaceID()

InterfaceID & PixelByteStreamErrorDetectorElementStatusTool::interfaceID ( )
inlinestatic

Definition at line 46 of file PixelByteStreamErrorDetectorElementStatusTool.h.

46 {
47 static InterfaceID IID_PixelByteStreamErrorDetectorElementStatusTool("PixelByteStreamErrorDetectorElementStatusTool", 1, 0);
48 return IID_PixelByteStreamErrorDetectorElementStatusTool;
49}

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.

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

◆ m_BSErrContReadKey

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

Definition at line 28 of file PixelByteStreamErrorDetectorElementStatusTool.h.

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

◆ m_pixelDetEleCollKey

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

Definition at line 41 of file PixelDetectorElementStatusToolBase.h.

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

◆ 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 44 of file PixelDetectorElementStatusToolBase.h.

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

◆ m_pixelID

const PixelID* PixelDetectorElementStatusToolBase::m_pixelID {}
protectedinherited

Definition at line 38 of file PixelDetectorElementStatusToolBase.h.

38{};

◆ m_readoutTechnologyMask

unsigned int PixelByteStreamErrorDetectorElementStatusTool::m_readoutTechnologyMask {}
private

Mask where each bit represents a readout technology;.

Definition at line 43 of file PixelByteStreamErrorDetectorElementStatusTool.h.

43{};

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

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

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

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

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

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

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