#include <PixelClusteringTool.h>

Inheritance diagram for ActsTrk::PixelClusteringTool:

Collaboration diagram for ActsTrk::PixelClusteringTool:

Public Member Functions
	PixelClusteringTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	clusterize (const EventContext &ctx, const RawDataCollection &RDOs, const InDet::SiDetectorElementStatus &pixelDetElStatus, const InDetDD::SiDetectorElement &element, Acts::Ccl::ClusteringData &data, std::vector< ClusterCollection > &collection) const override
virtual std::any	makeVars (SG::AuxVectorData &cont) const override
virtual StatusCode	makeClusters (const EventContext &ctx, typename IPixelClusteringTool::ClusterCollection &clusters, const InDetDD::SiDetectorElement &element, size_t icluster, std::any &vars, typename ClusterContainer::iterator itrContainer) const override
virtual StatusCode	initialize () override

Private Member Functions
StatusCode	makeCluster (PixelClusteringTool::Cluster &cluster, const InDetDD::SiDetectorElement element, const InDetDD::PixelModuleDesign &design, const PixelChargeCalibCondData calibData, const PixelChargeCalibCondData::CalibrationStrategy calibStrategy, double lorentz_shift, size_t icluster, xAOD::PixelCluster::ClusterVars &clusterVars) const
IPixelClusteringTool::CellCollection	unpackRDOs (const RawDataCollection &RDOs, const InDet::SiDetectorElementStatus &stripDetElStatus, const InDetDD::SiDetectorElement &element) const

Static Private Member Functions
static std::optional< Identifier >	isGanged (const Identifier &rdoID, const InDetDD::SiDetectorElement &element)

Private Attributes
ToolHandle< ISiLorentzAngleTool >	m_pixelLorentzAngleTool {this, "PixelLorentzAngleTool", "", "Tool to retreive Lorentz angle of Pixel"}
SG::ReadCondHandleKey< PixelChargeCalibCondData >	m_chargeDataKey
Gaudi::Property< bool >	m_addCorners {this, "AddCorners", true}
Gaudi::Property< bool >	m_useWeightedPos {this, "UseWeightedPosition", false}
Gaudi::Property< bool >	m_broadErrors {this, "UseBroadErrors", false}
Gaudi::Property< bool >	m_checkGanged {this, "CheckGanged", false}
Gaudi::Property< bool >	m_isITk {this, "isITk", true, "True if running in ITk"}
const PixelID *	m_pixelID {nullptr}

Detailed Description

Definition at line 21 of file PixelClusteringTool.h.

Constructor & Destructor Documentation

◆ PixelClusteringTool()

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

Definition at line 62 of file PixelClusteringTool.cxx.

64 : base_class(type,name,parent)

65{}

Member Function Documentation

◆ clusterize()

StatusCode ActsTrk::PixelClusteringTool::clusterize	(	const EventContext &	ctx,
		const RawDataCollection &	RDOs,
		const InDet::SiDetectorElementStatus &	pixelDetElStatus,
		const InDetDD::SiDetectorElement &	element,
		Acts::Ccl::ClusteringData &	data,
		std::vector< ClusterCollection > &	collection ) const

overridevirtual

Definition at line 240 of file PixelClusteringTool.cxx.

{
  IdentifierHash idHash = RDOs.identifyHash();
  collection.emplace_back();
  if ( not pixelDetElStatus.isGood(idHash) ) {
    // the module being flagged as bad is not a failure
    // An empty cluster collection needs to be added because the assumption
    // is that there is one element per element RawDataCollection.
    return StatusCode::SUCCESS;
  }
 
  // Retrieve the cells from the detector element
  CellCollection cells = unpackRDOs(RDOs, pixelDetElStatus, element);
 
  Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>
    (data, cells, collection.back(), Acts::Ccl::DefaultConnect<Cell, 2>(m_addCorners));
  
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode ActsTrk::PixelClusteringTool::initialize ( )

overridevirtual

Definition at line 41 of file PixelClusteringTool.cxx.

{
  ATH_MSG_DEBUG("Initializing " << name() << " ...");
 
  ATH_MSG_DEBUG("   " << m_addCorners );
  ATH_MSG_DEBUG("   " << m_useWeightedPos );
  ATH_MSG_DEBUG("   " << m_broadErrors );
  ATH_MSG_DEBUG("   " << m_checkGanged );
    
  ATH_CHECK(m_pixelLorentzAngleTool.retrieve());
 
  ATH_CHECK(m_chargeDataKey.initialize(not m_chargeDataKey.empty()));
 
  ATH_MSG_INFO("   Charge Data Key:" << m_chargeDataKey);
 
  ATH_CHECK( detStore()->retrieve(m_pixelID, "PixelID") );
  
  ATH_MSG_DEBUG(name() << " successfully initialized");
  return StatusCode::SUCCESS;
}

◆ isGanged()

std::optional< Identifier > ActsTrk::PixelClusteringTool::isGanged	(	const Identifier &	rdoID,
		const InDetDD::SiDetectorElement &	element )

inlinestaticprivate

Definition at line 371 of file PixelClusteringTool.cxx.

{
  // If the pixel is ganged, returns a new identifier for it
  InDetDD::SiCellId cellID = element.cellIdFromIdentifier( rdoID );
  if ( element.numberOfConnectedCells( cellID ) > 1 ) {
    InDetDD::SiCellId gangedCellID = element.connectedCell( cellID, 1 );
    return element.identifierFromCellId( gangedCellID );
  } 
  return std::nullopt;
}

◆ makeCluster()

StatusCode ActsTrk::PixelClusteringTool::makeCluster	(	PixelClusteringTool::Cluster &	cluster,
		const InDetDD::SiDetectorElement *	element,
		const InDetDD::PixelModuleDesign &	design,
		const PixelChargeCalibCondData *	calibData,
		const PixelChargeCalibCondData::CalibrationStrategy	calibStrategy,
		double	lorentz_shift,
		size_t	icluster,
		xAOD::PixelCluster::ClusterVars &	clusterVars ) const

private

Definition at line 68 of file PixelClusteringTool.cxx.

{ 
 
  Amg::Vector2D pos_acc(0,0);
  int tot_acc = 0;
 
  std::vector<float> chargeList;
  if (calibData) chargeList.reserve(cluster.ids.size());
  
  InDetDD::PixelDiodeTree::CellIndexType rowmax = std::numeric_limits<InDetDD::PixelDiodeTree::CellIndexType>::min();
  InDetDD::PixelDiodeTree::CellIndexType colmax = std::numeric_limits<InDetDD::PixelDiodeTree::CellIndexType>::min();
  InDetDD::PixelDiodeTree::CellIndexType rowmin = std::numeric_limits<InDetDD::PixelDiodeTree::CellIndexType>::max();
  InDetDD::PixelDiodeTree::CellIndexType colmin = std::numeric_limits<InDetDD::PixelDiodeTree::CellIndexType>::max();
  InDetDD::PixelDiodeTree::DiodeProxyWithPosition colmin_diode{};
  InDetDD::PixelDiodeTree::DiodeProxyWithPosition colmax_diode{};
  InDetDD::PixelDiodeTree::DiodeProxyWithPosition rowmin_diode{};
  InDetDD::PixelDiodeTree::DiodeProxyWithPosition rowmax_diode{};
 
  // We temporary comment this since it is not used
  // bool hasGanged = false;
 
  IdentifierHash moduleHash = element->identifyHash();
 
  for (size_t i = 0; i < cluster.ids.size(); i++) {
 
    //Construct the identifier class
    Identifier id = Identifier(cluster.ids[i]);
 
    // We temporary comment this since it is not used
    // TODO: Check how the ganged info is used in legacy
    // if (multiChip)  {
    //   hasGanged = hasGanged ||
    //  m_pixelRDOTool->isGanged(id, element).has_value();
    // }
 
    int tot = cluster.tots.at(i);
    float charge = tot;
 
    std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx
       = InDetDD::PixelDiodeTree::makeCellIndex(m_pixelID->phi_index(id),
                                                m_pixelID->eta_index(id));
    InDetDD::PixelDiodeTree::DiodeProxyWithPosition si_param ( design.diodeProxyFromIdxCachePosition(diode_idx));
 
    if (calibData) {
      // Retrieving the calibration only depends on FE and not per cell (can be further optimized)
      // Single FE modules could have an optimized getCharge function where the calib constants are cached
      std::uint32_t feValue = design.getFE(si_param);
      auto diode_type = design.getDiodeType(si_param);
      if (m_isITk){
        if (design.getReadoutTechnology() != InDetDD::PixelReadoutTechnology::RD53) {
    ATH_MSG_ERROR("Chip type is not recognized!");
    return StatusCode::FAILURE;
        }
 
        charge = calibData->getCharge(diode_type,
              calibStrategy,
              moduleHash,
              feValue,
              tot);
        chargeList.push_back(charge);
      } else {
        charge = calibData->getCharge(diode_type,
                                      moduleHash,
                                      feValue,
                                      tot);
 
        // These numbers are taken from the Cluster Maker Tool
        if (design.getReadoutTechnology() != InDetDD::PixelReadoutTechnology::RD53 && (moduleHash < 12 or moduleHash > 2035)) {
          charge = tot/8.0*(8000.0-1200.0)+1200.0;
        }
        chargeList.push_back(charge);
      }
    }
    
    const InDetDD::PixelDiodeTree::CellIndexType &row = diode_idx[0];
    const InDetDD::PixelDiodeTree::CellIndexType &col = diode_idx[1];
    if (row>rowmax) {
       rowmax=row;
       rowmax_diode = si_param;
    }
    if (row<rowmin) {
       rowmin=row;
       rowmin_diode = si_param;
    }
    if (col>colmax) {
       colmax=col;
       colmax_diode = si_param;
    }
    if (col<colmin) {
       colmin=col;
       colmin_diode = si_param;
    }
 
    // We compute the digital position as a sum of all RDO positions
    // all with the same weight of 1
    // We do not compute a charge-weighted center of gravity here (by default) since
    // we observe it to be worse than the digital position
    // ToT-weighted center of gravity must not be used
    if (m_useWeightedPos) {
      pos_acc += charge * si_param.position();
      tot_acc += charge;
    } else {
      pos_acc += si_param.position();
      tot_acc += 1;
    }
    
  }
  
  if (tot_acc > 0)
    pos_acc /= tot_acc;
 
  
  const int colWidth = colmax - colmin + 1;
  const int rowWidth = rowmax - rowmin + 1;
 
  double etaWidth = colmax_diode.xEtaMax() - colmin_diode.xEtaMin(); // design.widthFromColumnRange(colmin, colmax);
  double phiWidth = rowmax_diode.xPhiMax() - rowmin_diode.xPhiMin(); // design.widthFromColumnRange(colmin, colmax);
 
  // ask for Lorentz correction, get global position
  const Amg::Vector2D localPos = pos_acc;
  Amg::Vector2D locpos(localPos[Trk::locX]+lorentz_shift, localPos[Trk::locY]);
  // find global position of element
  const Amg::Transform3D& T = element->surface().transform();
  double Ax[3] = {T(0,0),T(1,0),T(2,0)};
  double Ay[3] = {T(0,1),T(1,1),T(2,1)};
  double R [3] = {T(0,3),T(1,3),T(2,3)};
  
  const Amg::Vector2D&    M = locpos;
  Amg::Vector3D globalPos(M[0]*Ax[0]+M[1]*Ay[0]+R[0],M[0]*Ax[1]+M[1]*Ay[1]+R[1],M[0]*Ax[2]+M[1]*Ay[2]+R[2]);
 
  // Compute error matrix
  float width0, width1;
  if (m_broadErrors) {
      // Use cluster width
      width0 = phiWidth;
      width1 = etaWidth;
  } else {
      // Use average pixel width
      width0 = phiWidth / rowWidth;
      width1 = etaWidth / colWidth;
  }
 
  // Actually create the cluster (i.e. fill the values)
  
  Eigen::Matrix<float,2,1> localPosition(locpos.x(), locpos.y());
  Eigen::Matrix<float,2,2> localCovariance = Eigen::Matrix<float,2,2>::Zero();
  localCovariance(0, 0) = width0 * width0 / 12.0f; 
  localCovariance(1, 1) = width1 * width1 / 12.0f;
  
  clusterVars.identifierHash[icluster] = moduleHash;
  xAOD::VectorMap<2>(clusterVars.localPositionDim2[icluster].data()) = localPosition;
  xAOD::MatrixMap<2>(clusterVars.localCovarianceDim2[icluster].data()) = localCovariance;
  clusterVars.identifier[icluster] = cluster.ids.front();
  clusterVars.rdoList[icluster] = std::move(cluster.ids);
  xAOD::VectorMap<3>(clusterVars.globalPosition[icluster].data()) = globalPos.cast<float>();
  clusterVars.totList[icluster] = std::move(cluster.tots);
  clusterVars.lvl1a[icluster] = cluster.lvl1min;
  clusterVars.channelsInPhi[icluster] = rowWidth;
  clusterVars.channelsInEta[icluster] = colWidth;
  clusterVars.widthInEta[icluster] = etaWidth;
    
  return StatusCode::SUCCESS;
}

◆ makeClusters()

StatusCode ActsTrk::PixelClusteringTool::makeClusters	(	const EventContext &	ctx,
		typename IPixelClusteringTool::ClusterCollection &	clusters,
		const InDetDD::SiDetectorElement &	element,
		size_t	icluster,
		std::any &	vars,
		typename ClusterContainer::iterator	itrContainer ) const

overridevirtual

Definition at line 273 of file PixelClusteringTool.cxx.

{
  // Retrieve the calibration data
  const PixelChargeCalibCondData *calibData = nullptr;
  if (not m_chargeDataKey.empty()) {
    SG::ReadCondHandle<PixelChargeCalibCondData> calibDataHandle = SG::makeHandle( m_chargeDataKey, ctx );
    calibData = calibDataHandle.cptr();
    
    if (!calibData) {
      ATH_MSG_ERROR("PixelChargeCalibCondData requested but couldn't be retrieved from " << m_chargeDataKey.key());
      return StatusCode::FAILURE;
    }
  }
  
  // Get the element design
  const InDetDD::PixelModuleDesign& design = 
    static_cast<const InDetDD::PixelModuleDesign&>(element.design());
  
  // Get the calibration strategy for this module. 
  // Default to RD53 if the calibData is not available. That is fine because it won't be used anyway
  auto calibrationStrategy = calibData ? calibData->getCalibrationStrategy(element.identifyHash()) : PixelChargeCalibCondData::CalibrationStrategy::RD53;
 
  double lorentz_shift = m_pixelLorentzAngleTool->getLorentzShift(element.identifyHash(), ctx);
 
  auto* clusterVars = std::any_cast<xAOD::PixelCluster::ClusterVars> (&vars);
  if (!clusterVars) throw std::bad_any_cast();
 
  for (typename IPixelClusteringTool::Cluster& cl : clusters) {
    ATH_CHECK(makeCluster(cl,
                          &element,
                          design,
                          calibData,
                          calibrationStrategy,
                          lorentz_shift,
                          icluster++,
                          *clusterVars));
  }
  
  return StatusCode::SUCCESS;
}

◆ makeVars()

std::any ActsTrk::PixelClusteringTool::makeVars ( SG::AuxVectorData & cont ) const

overridevirtual

Definition at line 266 of file PixelClusteringTool.cxx.

{
  return std::any (xAOD::PixelCluster::ClusterVars (cont));
}

◆ unpackRDOs()

IPixelClusteringTool::CellCollection ActsTrk::PixelClusteringTool::unpackRDOs	(	const RawDataCollection &	RDOs,
		const InDet::SiDetectorElementStatus &	stripDetElStatus,
		const InDetDD::SiDetectorElement &	element ) const

private

Definition at line 320 of file PixelClusteringTool.cxx.

{
  // Get the element design
  const InDetDD::PixelModuleDesign& design =
    static_cast<const InDetDD::PixelModuleDesign&>(element.design());
  CellCollection cells;
  cells.reserve(300);
  
  const IdentifierHash& idHash = RDOs.identifyHash();
  for (const auto *const rdo : RDOs) {
    const Identifier& rdoID = rdo->identify();
    std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx
      = InDetDD::PixelDiodeTree::makeCellIndex(m_pixelID->phi_index(rdoID),
                                               m_pixelID->eta_index(rdoID));
    InDetDD::PixelDiodeTree::DiodeProxy si_param ( design.diodeProxyFromIdx(diode_idx));
    std::uint32_t fe = design.getFE(si_param);
    
    // check if good RDO
    // the pixel RDO tool here says always good if m_useModuleMap is false
    if (not pixelDetElStatus.isChipGood(idHash, fe)) {
      continue;
    }
    
    const int lvl1 = rdo->getLVL1A();
    const int tot = rdo->getToT();
    
    cells.emplace_back(m_pixelID->phi_index(rdoID),
                       m_pixelID->eta_index(rdoID),
                       tot,
                       lvl1,
                       rdoID.get_compact());
    
    if ( m_checkGanged ) {
      std::optional<Identifier> gangedID = isGanged(rdoID, element);
      if (gangedID.has_value()) {
        cells.emplace_back(m_pixelID->phi_index(*gangedID),
                           m_pixelID->eta_index(*gangedID),
                           tot,
                           lvl1,
                           gangedID->get_compact());
      }
    }
    
  }
 
  return cells;
}

Member Data Documentation

◆ m_addCorners

Gaudi::Property<bool> ActsTrk::PixelClusteringTool::m_addCorners {this, "AddCorners", true}

private

Definition at line 76 of file PixelClusteringTool.h.

76{this, "AddCorners", true};

◆ m_broadErrors

Gaudi::Property<bool> ActsTrk::PixelClusteringTool::m_broadErrors {this, "UseBroadErrors", false}

private

Definition at line 78 of file PixelClusteringTool.h.

78{this, "UseBroadErrors", false};

◆ m_chargeDataKey

SG::ReadCondHandleKey<PixelChargeCalibCondData> ActsTrk::PixelClusteringTool::m_chargeDataKey

private

Initial value:

{this, "PixelChargeCalibCondData", "",

"Pixel charge calibration data"}

Definition at line 73 of file PixelClusteringTool.h.

73 {this, "PixelChargeCalibCondData", "",

74 "Pixel charge calibration data"};

◆ m_checkGanged

Gaudi::Property<bool> ActsTrk::PixelClusteringTool::m_checkGanged {this, "CheckGanged", false}

private

Definition at line 79 of file PixelClusteringTool.h.

79{this, "CheckGanged", false};

◆ m_isITk

Gaudi::Property<bool> ActsTrk::PixelClusteringTool::m_isITk {this, "isITk", true, "True if running in ITk"}

private

Definition at line 80 of file PixelClusteringTool.h.

80{this, "isITk", true, "True if running in ITk"};

◆ m_pixelID

const PixelID* ActsTrk::PixelClusteringTool::m_pixelID {nullptr}

private

Definition at line 81 of file PixelClusteringTool.h.

81{nullptr};

◆ m_pixelLorentzAngleTool

ToolHandle< ISiLorentzAngleTool > ActsTrk::PixelClusteringTool::m_pixelLorentzAngleTool {this, "PixelLorentzAngleTool", "", "Tool to retreive Lorentz angle of Pixel"}

private

Definition at line 71 of file PixelClusteringTool.h.

71{this, "PixelLorentzAngleTool", "", "Tool to retreive Lorentz angle of Pixel"};

◆ m_useWeightedPos

Gaudi::Property<bool> ActsTrk::PixelClusteringTool::m_useWeightedPos {this, "UseWeightedPosition", false}

private

Definition at line 77 of file PixelClusteringTool.h.

77{this, "UseWeightedPosition", false};

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

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PixelClusteringTool()

Member Function Documentation

◆ clusterize()

◆ initialize()

◆ isGanged()

◆ makeCluster()

◆ makeClusters()

◆ makeVars()

◆ unpackRDOs()

Member Data Documentation

◆ m_addCorners

◆ m_broadErrors

◆ m_chargeDataKey

◆ m_checkGanged

◆ m_isITk

◆ m_pixelID

◆ m_pixelLorentzAngleTool

◆ m_useWeightedPos