InDetDD::ITk::PixelReadoutManager Class Reference

#include <ITkPixelReadoutManager.h>

Inheritance diagram for InDetDD::ITk::PixelReadoutManager:

Collaboration diagram for InDetDD::ITk::PixelReadoutManager:

Public Member Functions
	PixelReadoutManager (const std::string &name, ISvcLocator *svc)
virtual StatusCode	initialize () override final
virtual PixelModuleType	getModuleType (Identifier id) const override final
virtual PixelDiodeType	getDiodeType (Identifier id) const override final
virtual Identifier	getPixelIdfromHash (IdentifierHash offlineIdHash, uint32_t FE, uint32_t row, uint32_t column) const override final
virtual Identifier	getPixelId (Identifier offlineId, uint32_t FE, uint32_t row, uint32_t column) const override final
virtual uint32_t	getFE (Identifier diodeId, Identifier offlineId) const override final
virtual uint32_t	getColumn (Identifier diodeId, Identifier offlineId) const override final
virtual uint32_t	getRow (Identifier diodeId, Identifier offlineId) const override final

Private Attributes
ServiceHandle< StoreGateSvc >	m_detStore {this, "DetectorStore", "DetectorStore"}
const PixelDetectorManager *	m_detManager {}
const PixelID *	m_idHelper {}
Gaudi::Property< std::string >	m_detectorName {this, "DetectorName", "ITkPixel", "Pixel detector name"}
Gaudi::Property< std::string >	m_pixelIDName {this, "PixelIDName", "PixelID", "Pixel ID name"}

Detailed Description

Definition at line 23 of file ITkPixelReadoutManager.h.

Constructor & Destructor Documentation

PixelReadoutManager()

InDetDD::ITk::PixelReadoutManager::PixelReadoutManager	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 16 of file ITkPixelReadoutManager.cxx.

      : base_class(name, svc){
    }

Member Function Documentation

getColumn()

uint32_t InDetDD::ITk::PixelReadoutManager::getColumn ( Identifier  diodeId, Identifier  offlineId  ) const

finaloverridevirtual

Definition at line 191 of file ITkPixelReadoutManager.cxx.

                                                                               {
      const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
      const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
      if (p_design->getReadoutTechnology() != PixelReadoutTechnology::RD53) {
        ATH_MSG_ERROR("Non-RD53 readout technologies not supported!");
        return invalidColumn;
      }
      unsigned int columnsPerFE = p_design->columnsPerCircuit();
      unsigned int eta_index = m_idHelper->eta_index(diodeId);
      // ---------------------
      // Convert eta index to column number
      // ---------------------
      unsigned int column{};
      if (eta_index >= columnsPerFE) {
        column = 2 * columnsPerFE - eta_index - 1;
      } else {
        column = eta_index;
      }
      // ---------------------
      // Check output sanity
      // ---------------------
      if (column >= columnsPerFE) {
        ATH_MSG_WARNING("Computed column number exceeds maximum value: col = " << column << " (max = " << columnsPerFE << ")");
        ATH_MSG_INFO("diodeId = "<<diodeId<<", offlineId= "<<offlineId);
        ATH_MSG_INFO("ModuleType: "<<PixelModuleTypeName(getModuleType(offlineId)));
        ATH_MSG_INFO("DiodeType: "<<PixelDiodeTypeName(getDiodeType(offlineId)));
        return invalidColumn;
      }
      return column;
    }

getDiodeType()

PixelDiodeType InDetDD::ITk::PixelReadoutManager::getDiodeType ( Identifier  id ) const

finaloverridevirtual

Definition at line 53 of file ITkPixelReadoutManager.cxx.

                                                        {
      const Identifier wafer_id = m_idHelper->wafer_id(id);
      const SiDetectorElement *element = m_detManager->getDetectorElement(wafer_id);
      const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
      if (p_design->getReadoutTechnology() != PixelReadoutTechnology::RD53) {
        ATH_MSG_ERROR("Non-RD53 readout technologies not supported!");
        return PixelDiodeType::NONE;
      }
    
      Identifier diodeId = id;
      uint32_t col = getColumn(diodeId, wafer_id);
      uint32_t row = getRow(diodeId, wafer_id);
      if (col == invalidColumn or row == invalidRow){
        return PixelDiodeType::NONE;
      }
      // ---------------------
      // Get the pixel type
      // ---------------------
      unsigned int FEs = p_design->numberOfCircuits();
      unsigned int rowsPerFE =  p_design->rowsPerCircuit();
      unsigned int columnsPerFE = p_design->columnsPerCircuit();
    
      if (FEs == 4) {
        // long pixel row and columns
        // 2 per row/column side
        // TODO: avoid hardcoding this
        if (row > rowsPerFE - 3 && col < columnsPerFE - 2) {
          return PixelDiodeType::LONG;
        }
        if (col > columnsPerFE - 3 && row < rowsPerFE - 2) {
          return PixelDiodeType::LONG;
        }
        // corner big pixels
        if (row > rowsPerFE - 3 && col > columnsPerFE - 3) {
          return PixelDiodeType::LARGE;
        }
      } else if (FEs != 1) {
        ATH_MSG_WARNING("Module with a number of circuits which is not 1 or 4.");
        ATH_MSG_WARNING("Long/pixel identification not implemented");
      }
      return PixelDiodeType::NORMAL;
    }

getFE()

uint32_t InDetDD::ITk::PixelReadoutManager::getFE ( Identifier  diodeId, Identifier  offlineId  ) const

finaloverridevirtual

Definition at line 153 of file ITkPixelReadoutManager.cxx.

                                                                           {
      const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
      const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
      if (p_design->getReadoutTechnology() != PixelReadoutTechnology::RD53) {
        ATH_MSG_WARNING("Non-RD53 readout technologies not supported!");
        return invalidFrontEnd;
      }
      unsigned int FEsPerRow = p_design->numberOfCircuitsPerRow();
      unsigned int rowsPerFE =  p_design->rowsPerCircuit();
      unsigned int columnsPerFE = p_design->columnsPerCircuit();
      // ---------------------
      // Set module properties
      // ---------------------
      unsigned int phi_index = m_idHelper->phi_index(diodeId);
      unsigned int eta_index = m_idHelper->eta_index(diodeId);
      PixelModuleType moduleType = getModuleType(offlineId);
      if (moduleType == PixelModuleType::PIX_ENDCAP) {
        // Swap phi_index for even endcap modules
        int module_phi = m_idHelper->phi_module(offlineId);
        if (module_phi % 2 == 0) {
          phi_index = FEsPerRow * rowsPerFE - phi_index - 1;
        }
      }
      // ---------------------
      // Compute FE number
      // ---------------------
      // ITk has up to 4 FEs
      unsigned int FErow = static_cast<unsigned int>(std::floor(phi_index / rowsPerFE));
      unsigned int FEcol = static_cast<unsigned int>(std::floor(eta_index / columnsPerFE));
      if (FErow > 0) {
        return 2 + FEcol;
      } else {
        return FEcol;
      }
    }

getModuleType()

PixelModuleType InDetDD::ITk::PixelReadoutManager::getModuleType ( Identifier  id ) const

finaloverridevirtual

Definition at line 31 of file ITkPixelReadoutManager.cxx.

                                                                         {
      const Identifier wafer_id = m_idHelper->wafer_id(id);
      const SiDetectorElement *element = m_detManager->getDetectorElement(wafer_id);
      const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
      if (p_design->getReadoutTechnology() != PixelReadoutTechnology::RD53) {
        ATH_MSG_ERROR("Non-RD53 readout technologies not supported!");
        return PixelModuleType::NONE;
      }
    
      if (m_idHelper->barrel_ec(id) == 0) {
        return PixelModuleType::PIX_BARREL;
      }
    
      if (std::abs(m_idHelper->barrel_ec(id)) == 2) {
        return PixelModuleType::PIX_ENDCAP;
      }
    
      return PixelModuleType::NONE;
    }

getPixelId()

Identifier InDetDD::ITk::PixelReadoutManager::getPixelId ( Identifier  offlineId, uint32_t  FE, uint32_t  row, uint32_t  column  ) const

finaloverridevirtual

Definition at line 104 of file ITkPixelReadoutManager.cxx.

                                                                                                        {
      const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
      const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
      if (p_design->getReadoutTechnology() != PixelReadoutTechnology::RD53) {
        ATH_MSG_ERROR("Non-RD53 readout technologies not supported!");
        return {};// illegal Identifier, standardized for PixelRodDecoder
      }
      unsigned int FEs = p_design->numberOfCircuits();
      unsigned int FEsPerRow = p_design->numberOfCircuitsPerRow();
      unsigned int rowsPerFE =  p_design->rowsPerCircuit();
      unsigned int columnsPerFE = p_design->columnsPerCircuit();
      // ---------------------
      // Check input sanity
      // ---------------------
      if (row >= rowsPerFE || column >= columnsPerFE || FE >= FEs) {
        ATH_MSG_DEBUG("Illegal pixel requested OfflineID: " << std::hex << offlineId << std::dec << " FE: " << FE << " row: " << row << " column: " << column);
        ATH_MSG_DEBUG("Limits are: FE < " << FEs << ", row < " << rowsPerFE << ", column < " << columnsPerFE);
        return {}; // illegal Identifier, standardized for PixelRodDecoder
      }
      // ---------------------
      // Convert row/column to eta/phi indices
      // ---------------------
      unsigned int phi_index{}, eta_index{};
      if (FE >= 2) {
        phi_index = 2 * rowsPerFE - 1 - row;
      } else {
        phi_index = row;
      }
      if (FE % 2 == 1) {
        eta_index = 2 * columnsPerFE - 1 - column;
      } else {
        eta_index = column;
      }
    
      // Identify the module type
      PixelModuleType moduleType = getModuleType(offlineId);
      if (moduleType == PixelModuleType::PIX_ENDCAP) {
        // Swap phi_index for even endcap modules
        int module_phi = m_idHelper->phi_module(offlineId);
        if (module_phi % 2 == 0) {
          phi_index = FEsPerRow * rowsPerFE - phi_index - 1;
          ATH_MSG_DEBUG("Even disk module found, phi module: " << module_phi << " swapped phi index to : " << phi_index);
        }
      }
      return m_idHelper->pixel_id(offlineId, phi_index, eta_index);
    }

getPixelIdfromHash()

Identifier InDetDD::ITk::PixelReadoutManager::getPixelIdfromHash ( IdentifierHash  offlineIdHash, uint32_t  FE, uint32_t  row, uint32_t  column  ) const

finaloverridevirtual

Definition at line 97 of file ITkPixelReadoutManager.cxx.

                                                     {
      return getPixelId(m_idHelper->wafer_id(offlineIdHash), FE, row, column);
    }

getRow()

uint32_t InDetDD::ITk::PixelReadoutManager::getRow ( Identifier  diodeId, Identifier  offlineId  ) const

finaloverridevirtual

Definition at line 224 of file ITkPixelReadoutManager.cxx.

                                                                            {
      const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
      const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
      if (p_design->getReadoutTechnology() != PixelReadoutTechnology::RD53) {
        ATH_MSG_WARNING("Non-RD53 readout technologies not supported!");
        return invalidRow;
      }
      unsigned int FEsPerRow = p_design->numberOfCircuitsPerRow();
      unsigned int rowsPerFE =  p_design->rowsPerCircuit();
      unsigned int phi_index = m_idHelper->phi_index(diodeId);
      // Identify the module type
      PixelModuleType moduleType = getModuleType(offlineId);
      if (moduleType == PixelModuleType::PIX_ENDCAP) {
        // Swap phi_index for even endcap modules
        int module_phi = m_idHelper->phi_module(offlineId);
        if (module_phi % 2 == 0) {
          phi_index = FEsPerRow * rowsPerFE - phi_index - 1;
        }
      }
      // ---------------------
      // Convert phi index to row number
      // ---------------------
      unsigned int row{};
      if (phi_index >= rowsPerFE) {
        row = 2 * rowsPerFE - phi_index - 1;
      } else {
        row = phi_index;
      }
      // ---------------------
      // Check output sanity
      // ---------------------
      if (row >= rowsPerFE) {
        ATH_MSG_WARNING("Computed row number exceeds maximum value: row = " << row << "(max = " << rowsPerFE << ")");
        return invalidRow;
      }
      return row;
    }

initialize()

StatusCode InDetDD::ITk::PixelReadoutManager::initialize ( )

finaloverridevirtual

Definition at line 22 of file ITkPixelReadoutManager.cxx.

                                              {
      ATH_MSG_DEBUG("ITkPixelReadoutManager::initialize()");
      ATH_CHECK(m_detStore.retrieve());
      ATH_CHECK(m_detStore->retrieve(m_detManager, m_detectorName.value()));
      ATH_CHECK(m_detStore->retrieve(m_idHelper, m_pixelIDName.value()));
      return StatusCode::SUCCESS;
    }

Member Data Documentation

m_detectorName

Gaudi::Property<std::string> InDetDD::ITk::PixelReadoutManager::m_detectorName {this, "DetectorName", "ITkPixel", "Pixel detector name"}

private

Definition at line 56 of file ITkPixelReadoutManager.h.

m_detManager

const PixelDetectorManager* InDetDD::ITk::PixelReadoutManager::m_detManager {}

private

Definition at line 53 of file ITkPixelReadoutManager.h.

m_detStore

ServiceHandle<StoreGateSvc> InDetDD::ITk::PixelReadoutManager::m_detStore {this, "DetectorStore", "DetectorStore"}

private

Definition at line 51 of file ITkPixelReadoutManager.h.

m_idHelper

const PixelID* InDetDD::ITk::PixelReadoutManager::m_idHelper {}

private

Definition at line 54 of file ITkPixelReadoutManager.h.

m_pixelIDName

Gaudi::Property<std::string> InDetDD::ITk::PixelReadoutManager::m_pixelIDName {this, "PixelIDName", "PixelID", "Pixel ID name"}

private

Definition at line 58 of file ITkPixelReadoutManager.h.

---

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

• ITkPixelReadoutManager.h
• ITkPixelReadoutManager.cxx