ActsTrk::PixelClusteringTool Class Reference

#include <PixelClusteringTool.h>

Inheritance diagram for ActsTrk::PixelClusteringTool:

Collaboration diagram for ActsTrk::PixelClusteringTool:

Classes
struct	Cluster

Public Types
using	Cell = InDet::UnpackedPixelRDO
using	CellCollection = std::vector< Cell >
using	ClusterCollection = std::vector< Cluster >

Public Member Functions
	PixelClusteringTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	clusterize (const InDetRawDataCollection< PixelRDORawData > &RDOs, const PixelID &pixelID, const EventContext &ctx, xAOD::PixelClusterContainer &container) const override
virtual StatusCode	initialize () override

Private Member Functions
StatusCode	makeCluster (const EventContext &ctx, PixelClusteringTool::Cluster &cluster, const PixelID &pixelID, const InDetDD::SiDetectorElement *element, const InDetDD::PixelModuleDesign &design, const PixelChargeCalibCondData *calibData, const PixelChargeCalibCondData::CalibrationStrategy calibStrategy, xAOD::PixelCluster &container) const

Private Attributes
ServiceHandle< InDetDD::IPixelReadoutManager >	m_pixelReadout
ToolHandle< InDet::PixelRDOTool >	m_pixelRDOTool {this, "PixelRDOTool", "", "The Pixel RDO tool"}
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}

Detailed Description

Definition at line 23 of file PixelClusteringTool.h.

Member Typedef Documentation

Cell

using ActsTrk::PixelClusteringTool::Cell = InDet::UnpackedPixelRDO

Definition at line 26 of file PixelClusteringTool.h.

CellCollection

using ActsTrk::PixelClusteringTool::CellCollection = std::vector<Cell>

Definition at line 27 of file PixelClusteringTool.h.

ClusterCollection

using ActsTrk::PixelClusteringTool::ClusterCollection = std::vector<Cluster>

Definition at line 35 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 53 of file PixelClusteringTool.cxx.

    : base_class(type,name,parent)
{}

Member Function Documentation

clusterize()

StatusCode ActsTrk::PixelClusteringTool::clusterize ( const InDetRawDataCollection< PixelRDORawData > &  RDOs, const PixelID &  pixelID, const EventContext &  ctx, xAOD::PixelClusterContainer &  container  ) const

overridevirtual

Definition at line 246 of file PixelClusteringTool.cxx.

{
 
    // Retrieve the detector element
    const InDetDD::SiDetectorElement* element = m_pixelRDOTool->checkCollection(RDOs, ctx);
    if (element == nullptr) {
       // the RDO tool will return nullptr if the module is flagged bad, which is not a failure.
       return StatusCode::SUCCESS;
    }
 
    // Retrieve the calibration data
    const PixelChargeCalibCondData *calibData = nullptr;
    if (not m_chargeDataKey.empty()) {
      SG::ReadCondHandle<PixelChargeCalibCondData> calibDataHandle(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;
      }
    }
 
    // Retrieve the cells from the detector element
    std::vector<InDet::UnpackedPixelRDO> cells =
      m_pixelRDOTool->getUnpackedPixelRDOs(RDOs, pixelID, element, ctx);
 
    // 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;
 
    // Get the element design
    const InDetDD::PixelModuleDesign& design = 
     static_cast<const InDetDD::PixelModuleDesign&>(element->design());
        
    ClusterCollection clusters =
      Acts::Ccl::createClusters<CellCollection, ClusterCollection, 2>
      (cells, Acts::Ccl::DefaultConnect<Cell, 2>(m_addCorners));
 
 
    std::size_t previousSizeContainer = container.size();
    // Fast insertion trick
    std::vector<xAOD::PixelCluster*> toAddCollection;
    toAddCollection.reserve(clusters.size());
    for (std::size_t i(0); i<clusters.size(); ++i)
      toAddCollection.push_back(new xAOD::PixelCluster());
    container.insert(container.end(), toAddCollection.begin(), toAddCollection.end());
    
    for (std::size_t i(0); i<clusters.size(); ++i) {
      Cluster& cluster = clusters[i];
      
      ATH_CHECK(makeCluster(ctx,
                cluster,
                pixelID,
                element,
                design,
                calibData,
                calibrationStrategy,
                *container[previousSizeContainer+i]));
    }
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode ActsTrk::PixelClusteringTool::initialize ( )

overridevirtual

Definition at line 40 of file PixelClusteringTool.cxx.

{
  ATH_MSG_DEBUG("Initializing " << name() << " ...");
  ATH_CHECK(m_pixelRDOTool.retrieve());
  ATH_CHECK(m_pixelLorentzAngleTool.retrieve());
  if (not m_chargeDataKey.empty()) ATH_CHECK(m_pixelReadout.retrieve());
  
  ATH_CHECK(m_chargeDataKey.initialize(not m_chargeDataKey.empty()));
 
  ATH_MSG_DEBUG(name() << " successfully initialized");
  return StatusCode::SUCCESS;
}

makeCluster()

StatusCode ActsTrk::PixelClusteringTool::makeCluster ( const EventContext &  ctx, PixelClusteringTool::Cluster &  cluster, const PixelID &  pixelID, const InDetDD::SiDetectorElement *  element, const InDetDD::PixelModuleDesign &  design, const PixelChargeCalibCondData *  calibData, const PixelChargeCalibCondData::CalibrationStrategy  calibStrategy, xAOD::PixelCluster &  container  ) const

private

Definition at line 59 of file PixelClusteringTool.cxx.

{ 
 
  InDetDD::SiLocalPosition pos_acc(0,0);
  int tot_acc = 0;
 
  std::vector<float> chargeList;
  if (calibData) chargeList.reserve(cluster.ids.size());
  
  int colmax = std::numeric_limits<int>::min();
  int rowmax = std::numeric_limits<int>::min();
  int colmin = std::numeric_limits<int>::max();
  int rowmin = std::numeric_limits<int>::max();
 
  float qRowMin = 0.f;
  float qRowMax = 0.f;
  float qColMin = 0.f;
  float qColMax = 0.f;
 
  // We temporary comment this since it is not used
  // bool hasGanged = false;
  
  Identifier moduleID = element->identify();
  IdentifierHash moduleHash = element->identifyHash();
 
  // This could be moved outside the cluster loop
  bool multiChip = design.numberOfCircuits() > 1;
    
  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;
        
    if (calibData) {
 
      if (design.getReadoutTechnology() != InDetDD::PixelReadoutTechnology::RD53) {
    ATH_MSG_ERROR("Chip type is not recognized!");
    return StatusCode::FAILURE;
      }
      
      // The calibration strategy is updated for each element 
      // 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
      int feValue = multiChip ? m_pixelReadout->getFE(id, moduleID, element) : 0;
      charge = calibData->getCharge(m_pixelReadout->getDiodeType(id,element),
                    calibStrategy,
                    moduleHash,
                    feValue,
                    tot);
      chargeList.push_back(charge);
    }
    
    const int row = pixelID.phi_index(id);
    if (row > rowmax) {
      rowmax = row;
      qRowMax = charge;
    } else if (row == rowmax) {
      qRowMax += charge; 
    }
    
    if (row < rowmin) {  
      rowmin = row;
      qRowMin = charge;
    } else if (row == rowmin) {
      qRowMin += charge;
    } 
       
    const int col = pixelID.eta_index(id);
    if (col > colmax) {
      colmax = col;
      qColMax = charge;
    } else if (col == colmax) {
      qColMax += charge;
    }     
 
    if (col < colmin) {
      colmin = col;
      qColMin = charge;
    } else if (col == colmin) {
      qColMin += charge;
    } 
    
    InDetDD::SiCellId si_cell = element->cellIdFromIdentifier(id);
    InDetDD::SiLocalPosition pos = design.localPositionOfCell(si_cell);
 
    // 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 * pos;
      tot_acc += charge;
    } else {
      pos_acc += pos;
      tot_acc += 1;
    }
    
  }
  
  if (tot_acc > 0)
    pos_acc /= tot_acc;
 
  // Compute omega for charge interpolation correction (if required)
  // Two pixels may have charge=0 (very rarely, hopefully)
  float omegax = -1.f;
  float omegay = -1.f;
  if(qRowMin + qRowMax > 0) omegax = qRowMax/(qRowMin + qRowMax);
  if(qColMin + qColMax > 0) omegay = qColMax/(qColMin + qColMax);
 
  
  const int colWidth = colmax - colmin + 1;
  const int rowWidth = rowmax - rowmin + 1;
  double etaWidth = design.widthFromColumnRange(colmin, colmax);
  double phiWidth = design.widthFromRowRange(rowmin, rowmax);
  InDet::SiWidth siWidth(Amg::Vector2D(rowWidth,colWidth), Amg::Vector2D(phiWidth,etaWidth));
 
  // ask for Lorentz correction, get global position
  double shift = m_pixelLorentzAngleTool->getLorentzShift(moduleHash, ctx);
  const Amg::Vector2D localPos = pos_acc;
  Amg::Vector2D locpos(localPos[Trk::locX]+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 = siWidth.phiR();
      width1 = siWidth.z();
  } else {
      // Use average pixel width
      width0 = siWidth.phiR() / siWidth.colRow().x();
      width1 = siWidth.z() / siWidth.colRow().y();
  }
 
  // 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.0; 
  localCovariance(1, 1) = width1 * width1 / 12.0;
  
  xaodcluster.setMeasurement<2>(moduleHash, localPosition, localCovariance);
  xaodcluster.setIdentifier( element->identifierOfPosition(locpos).get_compact() );
  xaodcluster.setRDOlist(std::move(cluster.ids));
  xaodcluster.globalPosition() = globalPos.cast<float>();
  xaodcluster.setTotalToT( xAOD::xAODInDetMeasurement::Utilities::computeTotalToT(cluster.tots) );
  xaodcluster.setToTlist(std::move(cluster.tots));
  xaodcluster.setTotalCharge( xAOD::xAODInDetMeasurement::Utilities::computeTotalCharge(chargeList) );
  xaodcluster.setChargelist(std::move(chargeList));
  xaodcluster.setLVL1A(cluster.lvl1min);
  xaodcluster.setChannelsInPhiEta(siWidth.colRow()[0],
                  siWidth.colRow()[1]);
  xaodcluster.setWidthInEta(static_cast<float>(siWidth.widthPhiRZ()[1]));
  xaodcluster.setOmegas(omegax, omegay);
  xaodcluster.setIsSplit(false);
  xaodcluster.setSplitProbabilities(0.0, 0.0);
    
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_addCorners

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

private

Definition at line 72 of file PixelClusteringTool.h.

m_broadErrors

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

private

Definition at line 74 of file PixelClusteringTool.h.

m_chargeDataKey

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

private

Initial value:

{this, "PixelChargeCalibCondData", "ITkPixelChargeCalibCondData",
    "Pixel charge calibration data"}

Definition at line 69 of file PixelClusteringTool.h.

m_pixelLorentzAngleTool

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

private

Definition at line 67 of file PixelClusteringTool.h.

m_pixelRDOTool

ToolHandle< InDet::PixelRDOTool > ActsTrk::PixelClusteringTool::m_pixelRDOTool {this, "PixelRDOTool", "", "The Pixel RDO tool"}

private

Definition at line 66 of file PixelClusteringTool.h.

m_pixelReadout

ServiceHandle< InDetDD::IPixelReadoutManager > ActsTrk::PixelClusteringTool::m_pixelReadout

private

Initial value:

{this, "PixelReadoutManager", "ITkPixelReadoutManager",
      "Pixel readout manager" }

Definition at line 63 of file PixelClusteringTool.h.

m_useWeightedPos

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

private

Definition at line 73 of file PixelClusteringTool.h.

---

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

• PixelClusteringTool.h
• PixelClusteringTool.cxx