TrackingUtilities Namespace Reference

Functions
StatusCode	convertInDetToXaodCluster (const InDet::PixelCluster &indetCluster, const InDetDD::SiDetectorElement &element, xAOD::PixelCluster &xaodCluster)
StatusCode	convertInDetToXaodCluster (const InDet::SCT_Cluster &indetCluster, const InDetDD::SiDetectorElement &element, xAOD::StripCluster &xaodCluster, bool isITk=true)
const InDetDD::PixelModuleDesign *	pixelModuleDesign (const InDetDD::SiDetectorElement &element)
	Resolve the readout design of a pixel/strip detector element.
const InDetDD::SCT_ModuleSideDesign *	stripModuleSideDesign (const InDetDD::SiDetectorElement &element)
std::unique_ptr< InDet::PixelCluster >	convertXaodToInDetCluster (const xAOD::PixelCluster &xaodCluster, const InDetDD::SiDetectorElement &element, const InDetDD::PixelModuleDesign &design, const PixelID &pixelID)
std::unique_ptr< InDet::SCT_Cluster >	convertXaodToInDetCluster (const xAOD::StripCluster &xaodCluster, const InDetDD::SiDetectorElement &element, const InDetDD::SCT_ModuleSideDesign &design, const SCT_ID &stripID, double shift=0.)
StatusCode	convertInDetToXaodCluster (const ::HGTD_Cluster &indetCluster, const InDetDD::HGTD_DetectorElement &element, xAOD::HGTDCluster &xaodCluster)
std::unique_ptr<::HGTD_Cluster >	convertXaodToInDetCluster (const xAOD::HGTDCluster &xaodCluster, const InDetDD::HGTD_DetectorElement &element)
std::pair< xAOD::MeasVector< 1 >, xAOD::MeasMatrix< 1 > >	convertSCT_LocalPosCov (const InDet::SCT_Cluster &cluster, bool isITk=true)
std::pair< xAOD::MeasVector< 2 >, xAOD::MeasMatrix< 2 > >	convertPix_LocalPosCov (const InDet::PixelCluster &cluster)
std::pair< xAOD::MeasVector< 3 >, xAOD::MeasMatrix< 3 > >	convertHGTD_LocalPosCov (const HGTD_Cluster &cluster)
std::pair< float, float >	computeOmegas (const xAOD::PixelCluster &cluster, const PixelID &pixelID)
StatusCode	convertTrkToXaodPixelSpacePoint (const InDet::PixelSpacePoint &trkSpacePoint, xAOD::SpacePoint &xaodSpacePoint)
StatusCode	convertTrkToXaodStripSpacePoint (const InDet::SCT_SpacePoint &trkSpacePoint, xAOD::SpacePoint &xaodSpacePoint)

Function Documentation

computeOmegas()

std::pair< float, float > TrackingUtilities::computeOmegas	(	const xAOD::PixelCluster &	cluster,
		const PixelID &	pixelID )

Definition at line 9 of file InnerDetector/InDetMeasurementUtilities/src/Helpers.cxx.

  {    
    SG::ConstAccessor<SG::JaggedVecElt<Identifier::value_type> >::element_type
       rdo_list_cluster = cluster.rdoList();
    SG::ConstAccessor<SG::JaggedVecElt<float> >::element_type
       charge_list_cluster = cluster.chargeList();
    SG::ConstAccessor<SG::JaggedVecElt<int> >::element_type
       tot_list_cluster = cluster.totList();
 
    // Prefer the calibrated charge for the omega weights. When charge calibration
    // is unavailable (e.g. digital clustering) the charge list is left empty, so
    // fall back to the ToT list, mirroring InDet::ClusterMakerTool. This keeps the
    // analogue charge-interpolation correction defined instead of silently
    // disabling it (returning -1) whenever the charge list is missing.
    const bool useCharge = rdo_list_cluster.size() == charge_list_cluster.size();
    if (not useCharge and rdo_list_cluster.size() != tot_list_cluster.size()) {
      return {-1.f, -1.f};
    }
 
    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;
    
    for (std::size_t i(0); i<rdo_list_cluster.size(); ++i) {
      Identifier this_rdo(rdo_list_cluster.at(i));
      const float this_charge = useCharge ? charge_list_cluster.at(i)
                                          : static_cast<float>(tot_list_cluster.at(i));
      
      const int row = pixelID.phi_index(this_rdo);
      if (row > rowmax) {
        rowmax = row;
        qRowMax = this_charge;
      } else if (row == rowmax) {
        qRowMax += this_charge;
      }
      
      if (row < rowmin) {
        rowmin = row;
        qRowMin = this_charge;
      } else if (row == rowmin) {
        qRowMin += this_charge;
      }
 
      const int col = pixelID.eta_index(this_rdo);
      if (col > colmax) {
        colmax = col;
    qColMax = this_charge;
      } else if (col == colmax) {
        qColMax += this_charge;
      }
 
      if (col < colmin) {
    colmin = col;
        qColMin = this_charge;
      } else if (col == colmin) {
        qColMin += this_charge;
      }
    } // loop on rdos and charges
 
    float omegax = -1.f;
    float omegay = -1.f;
    if(qRowMin + qRowMax > 0) omegax = qRowMax/(qRowMin + qRowMax);
    if(qColMin + qColMax > 0) omegay = qColMax/(qColMin + qColMax);
 
    return std::make_pair(omegax, omegay);
  }

convertHGTD_LocalPosCov()

std::pair< xAOD::MeasVector< 3 >, xAOD::MeasMatrix< 3 > > TrackingUtilities::convertHGTD_LocalPosCov

(

const HGTD_Cluster &

cluster

)

Definition at line 26 of file ClusterConversionUtilities.cxx.

                                                                                                     {
    auto localPos = cluster.localPosition();
    auto localCov = cluster.localCovariance();
 
    const float time = cluster.time();
    const float timeResolution = cluster.timeResolution();
 
    Eigen::Matrix<float,3,1> localPosition = Eigen::Matrix<float,3,1>::Zero();
    localPosition(0, 0) = localPos.x();
    localPosition(1, 0) = localPos.y();
    localPosition(2, 0)  = time;
 
    Eigen::Matrix<float,3,3> localCovariance = Eigen::Matrix<float,3,3>::Zero();
    localCovariance(0, 0) = localCov(0, 0);
    localCovariance(1, 1) = localCov(1, 1);
    localCovariance(2, 2) = timeResolution * timeResolution;
 
    return {localPosition, localCovariance}; 
  }

convertInDetToXaodCluster() [1/3]

StatusCode TrackingUtilities::convertInDetToXaodCluster	(	const ::HGTD_Cluster &	indetCluster,
		const InDetDD::HGTD_DetectorElement &	element,
		xAOD::HGTDCluster &	xaodCluster )

Definition at line 46 of file ClusterConversionUtilities.cxx.

  {
    IdentifierHash idHash = element.identifyHash();
 
    const auto [localPosition, localCovariance] = convertHGTD_LocalPosCov(indetCluster);
        
    const auto& RDOs = indetCluster.rdoList();
    const auto& ToTs = indetCluster.totList();
 
    xaodCluster.setMeasurement<3>(idHash, localPosition, localCovariance);
    xaodCluster.setIdentifier( indetCluster.identify().get_compact() );
    xaodCluster.setRDOlist(RDOs);
    xaodCluster.setToTlist(ToTs);
    
    return StatusCode::SUCCESS;
  }

convertInDetToXaodCluster() [2/3]

StatusCode TrackingUtilities::convertInDetToXaodCluster	(	const InDet::PixelCluster &	indetCluster,
		const InDetDD::SiDetectorElement &	element,
		xAOD::PixelCluster &	xaodCluster )

Definition at line 79 of file ClusterConversionUtilities.cxx.

  {
    IdentifierHash idHash = element.identifyHash();
    
    const auto [localPosition, localCovariance] = convertPix_LocalPosCov(indetCluster);
 
    xAOD::MeasVector<3> globalPosition = xAOD::toStorage(indetCluster.globalPosition());
    
    const auto& RDOs = indetCluster.rdoList();
    const auto& ToTs = indetCluster.totList();
    const auto& charges = indetCluster.chargeList();
    const auto& width = indetCluster.width();
 
    xaodCluster.setMeasurement<2>(idHash, localPosition, localCovariance);
    xaodCluster.setIdentifier( indetCluster.identify().get_compact() );
    xaodCluster.setRDOlist(RDOs);
    xaodCluster.globalPosition() = globalPosition;
    xaodCluster.setToTlist(ToTs);
    xaodCluster.setChargelist(charges);
    xaodCluster.setTotalCharge( xAOD::xAODInDetMeasurement::Utilities::computeTotalCharge(xaodCluster) );
    xaodCluster.setLVL1A(indetCluster.LVL1A());
    xaodCluster.setChannelsInPhiEta(width.colRow()[0], width.colRow()[1]);
    xaodCluster.setWidthInEta(static_cast<float>(width.widthPhiRZ()[1]));
 
    return StatusCode::SUCCESS;
  }

convertInDetToXaodCluster() [3/3]

StatusCode TrackingUtilities::convertInDetToXaodCluster	(	const InDet::SCT_Cluster &	indetCluster,
		const InDetDD::SiDetectorElement &	element,
		xAOD::StripCluster &	xaodCluster,
		bool	isITk = true )

Definition at line 132 of file ClusterConversionUtilities.cxx.

  {
    IdentifierHash idHash = element.identifyHash();
 
    const auto [localPosition, localCovariance] = convertSCT_LocalPosCov(indetCluster, isITk);
   
    auto globalPos = indetCluster.globalPosition();
    Eigen::Matrix<float, 3, 1> globalPosition(globalPos.x(), globalPos.y(), globalPos.z());
 
    const auto& RDOs = indetCluster.rdoList();
    const auto& width = indetCluster.width();
 
    xaodCluster.setMeasurement<1>(idHash, localPosition, localCovariance);
    xaodCluster.setIdentifier( indetCluster.identify().get_compact() );
    xaodCluster.setRDOlist(RDOs);
    xaodCluster.globalPosition() = globalPosition;
    xaodCluster.setChannelsInPhi(width.colRow()[0]);
 
    return StatusCode::SUCCESS;
  }

convertPix_LocalPosCov()

std::pair< xAOD::MeasVector< 2 >, xAOD::MeasMatrix< 2 > > TrackingUtilities::convertPix_LocalPosCov

(

const InDet::PixelCluster &

cluster

)

Definition at line 65 of file ClusterConversionUtilities.cxx.

                                                                                                         {
    auto localCov = cluster.localCovariance();
 
    xAOD::MeasVector<2> localPosition = xAOD::toStorage(cluster.localPosition());
 
    Eigen::Matrix<float,2,2> localCovariance;
    localCovariance.setZero();
    localCovariance(0, 0) = localCov(0, 0);
    localCovariance(1, 1) = localCov(1, 1);
    //cid 23274
    //coverity[UNINIT:FALSE]
    return {localPosition, localCovariance}; 
  }

convertSCT_LocalPosCov()

std::pair< xAOD::MeasVector< 1 >, xAOD::MeasMatrix< 1 > > TrackingUtilities::convertSCT_LocalPosCov	(	const InDet::SCT_Cluster &	cluster,
		bool	isITk = true )

Definition at line 108 of file ClusterConversionUtilities.cxx.

                                                                                                                   {
    const InDetDD::SiDetectorElement& element{*cluster.detectorElement()};
    auto localPos = cluster.localPosition();
 
    float localPosition = 0.f, localCovariance = 0.f;
    if (element.isBarrel() or (not isITk)) {
      localPosition = localPos.x();
      localCovariance = element.phiPitch() * element.phiPitch() * one_over_twelve;
    } else {
      const auto* design = dynamic_cast<const InDetDD::StripStereoAnnulusDesign *>(&element.design());
      if ( design == nullptr ) {
        THROW_EXCEPTION("Invalid bounds from "<<cluster);
      }
      // convert the cluster centre directly, rather than going via the cell id,
      // which would snap the position to the centre of a single strip
      InDetDD::SiLocalPosition localInPolar = design->localPositionPC(localPos);
      localPosition = localInPolar.xPhi();
      localCovariance = design->phiPitchPhi() * design->phiPitchPhi() * one_over_twelve;
    }
 
    return std::make_pair(xAOD::MeasVector<1>{localPosition}, 
                          xAOD::MeasMatrix<1>{localCovariance});
  }

convertTrkToXaodPixelSpacePoint()

StatusCode TrackingUtilities::convertTrkToXaodPixelSpacePoint	(	const InDet::PixelSpacePoint &	trkSpacePoint,
		xAOD::SpacePoint &	xaodSpacePoint )

Definition at line 12 of file SpacePointConversionUtilities.cxx.

  {
    unsigned int idHash = trkSpacePoint.elementIdList().first;
    const auto& globPos = trkSpacePoint.globalPosition();
    
    const InDet::SiCluster* c  = static_cast<const InDet::SiCluster*>(trkSpacePoint.clusterList().first);
    const InDetDD::SiDetectorElement *de = c->detectorElement();
    const Amg::Transform3D &Tp = de->surface().transform();
    
    float r_3 = static_cast<float>( Tp(0,2) );
    float r_4 = static_cast<float>( Tp(1,2) );
    float r_5 = static_cast<float>( Tp(2,2) );
    
    const Amg::MatrixX& v = c->localCovariance();
    float f22 = static_cast<float>( v(1,1) );
    float wid = static_cast<float>( c->width().z() );
    float cov = wid*wid*.08333;
    if(cov < f22) cov = f22;
    float covr = 6 * cov * (r_5*r_5);
    float covz = 6 * cov * (r_3*r_3 + r_4*r_4);
    
    xaodSpacePoint.setSpacePoint(idHash,
                 globPos.cast<float>(),
                 covr,
                 covz,
                 {});
 
    return StatusCode::SUCCESS;
  }

convertTrkToXaodStripSpacePoint()

StatusCode TrackingUtilities::convertTrkToXaodStripSpacePoint	(	const InDet::SCT_SpacePoint &	trkSpacePoint,
		xAOD::SpacePoint &	xaodSpacePoint )

Definition at line 43 of file SpacePointConversionUtilities.cxx.

  {
    std::pair<unsigned int, unsigned int> idHashes = trkSpacePoint.elementIdList();
    const auto& globPos = trkSpacePoint.globalPosition();
    
    const InDet::SiCluster *c0 = static_cast<const InDet::SiCluster *>(trkSpacePoint.clusterList().first);
    const InDet::SiCluster *c1 = static_cast<const InDet::SiCluster *>(trkSpacePoint.clusterList().second);
    const InDetDD::SiDetectorElement *d0 = c0->detectorElement();
    const InDetDD::SiDetectorElement *d1 = c1->detectorElement();
    
    Amg::Vector2D lc0 = c0->localPosition();
    Amg::Vector2D lc1 = c1->localPosition();
    
    std::pair<Amg::Vector3D, Amg::Vector3D> e0 =
      (d0->endsOfStrip(InDetDD::SiLocalPosition(lc0.y(), lc0.x(), 0.)));
    std::pair<Amg::Vector3D, Amg::Vector3D> e1 =
      (d1->endsOfStrip(InDetDD::SiLocalPosition(lc1.y(), lc1.x(), 0.)));
    
    auto stripCenter_1 = 0.5 * (e0.first + e0.second);
    auto stripDir_1 = e0.first - e0.second;
    
    auto stripCenter_2 = 0.5 * (e1.first + e1.second);
    auto stripDir_2 = e1.first - e1.second;
    
    float topHalfStripLength = 0.5 * stripDir_1.norm();
    Eigen::Matrix<double, 3, 1> topStripDirection = - stripDir_1 / (2. * topHalfStripLength);
    Eigen::Matrix<double, 3, 1> topStripCenter = stripCenter_1;
    float bottomHalfStripLength = 0.5 * stripDir_2.norm();
    Eigen::Matrix<double, 3, 1> bottomStripDirection = - stripDir_2 / (2. * bottomHalfStripLength);
    Eigen::Matrix<double, 3, 1> stripCenterDistance = stripCenter_1 - stripCenter_2;
    
    const Amg::MatrixX& v = trkSpacePoint.localCovariance();
    float f22 = static_cast<float>( v(1,1) );
    
    float covr = d0->isBarrel() ? .1 : 8.*f22;
    float covz = d0->isBarrel() ? 8.*f22 : .1;
    
    xaodSpacePoint.setSpacePoint({idHashes.first, idHashes.second},
                 globPos.cast<float>(),
                 covr,
                 covz,
                 {},
                 topHalfStripLength,
                 bottomHalfStripLength,
                 topStripDirection.cast<float>(),
                 bottomStripDirection.cast<float>(),
                 stripCenterDistance.cast<float>(),
                 topStripCenter.cast<float>());
    
    return StatusCode::SUCCESS;
  }

convertXaodToInDetCluster() [1/3]

std::unique_ptr<::HGTD_Cluster > TrackingUtilities::convertXaodToInDetCluster	(	const xAOD::HGTDCluster &	xaodCluster,
		const InDetDD::HGTD_DetectorElement &	element )

Definition at line 371 of file ClusterConversionUtilities.cxx.

                                                                                                            {
    const auto& locPos = xaodCluster.localPosition<3>(); 
    Amg::Vector2D localPosition(locPos(0,0), locPos(1,0));
    float time = xAOD::HGTDCluster::time(locPos);
 
    InDetDD::SiLocalPosition centroid(localPosition);
    const Identifier id = element.identifierOfPosition(centroid);
 
    xAOD::ConstMatrixMap<3> local_covariance(xaodCluster.localCovariance<3>());
    auto errorMatrix = Amg::MatrixX(2,2);
    errorMatrix.setIdentity();
    errorMatrix.fillSymmetric(0, 0, local_covariance(0, 0));
    errorMatrix.fillSymmetric(1, 1, local_covariance(1, 1));
    float time_resolution = std::sqrt(xAOD::HGTDCluster::timeCovariance(local_covariance));
 
    double etaWidth = 1.3;
    double phiWidth = 1.3;
    int channelsPhi = 1;
    int channelsEta = 1;
    InDet::SiWidth width( Amg::Vector2D(channelsPhi, channelsEta), Amg::Vector2D(phiWidth, etaWidth) );
    std::vector<Identifier> rdo_list;
    rdo_list.reserve(xaodCluster.rdoList().size());
    for (const Identifier::value_type rdo_id_value : xaodCluster.rdoList()) {
       rdo_list.emplace_back(rdo_id_value);
    }
 
    return std::make_unique<::HGTD_Cluster>(id,
              localPosition,
              std::move(rdo_list),
              width,
              &element,
              std::move(errorMatrix),
              time,
              time_resolution,
              std::vector<int>(xaodCluster.totList()));              
 
  }

convertXaodToInDetCluster() [2/3]

std::unique_ptr< InDet::PixelCluster > TrackingUtilities::convertXaodToInDetCluster	(	const xAOD::PixelCluster &	xaodCluster,
		const InDetDD::SiDetectorElement &	element,
		const InDetDD::PixelModuleDesign &	design,
		const PixelID &	pixelID )

Definition at line 170 of file ClusterConversionUtilities.cxx.

  {
    const InDetDD::PixelModuleDesign* design = &moduleDesign;
 
    Amg::Vector2D localPosition = xAOD::toEigen(xaodCluster.localPosition<2>());
    
    InDetDD::SiLocalPosition centroid(localPosition);
    const Identifier id = element.identifierOfPosition(centroid);
 
    Amg::Vector3D globalPosition = xAOD::toEigen(xaodCluster.globalPosition());
    auto errorMatrix = Amg::MatrixX(2,2);
    errorMatrix.setIdentity();
    errorMatrix.fillSymmetric(0, 0, xaodCluster.localCovariance<2>()(0, 0));
    errorMatrix.fillSymmetric(1, 1, xaodCluster.localCovariance<2>()(1, 1));
 
    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;
    
    SG::ConstAccessor<SG::JaggedVecElt<Identifier::value_type> >::element_type
       rdo_list_cluster = xaodCluster.rdoList();
    SG::ConstAccessor<SG::JaggedVecElt<float> >::element_type
       charge_list_cluster = xaodCluster.chargeList();
    std::vector<Identifier> rdo_list_new;
    
    auto tot_list = xaodCluster.totList();
 
    rdo_list_new.reserve(rdo_list_cluster.size());
 
    if (rdo_list_cluster.size() == charge_list_cluster.size()) {
      for (std::size_t i(0); i<rdo_list_cluster.size(); ++i) {
        Identifier this_rdo(rdo_list_cluster[i]);
        rdo_list_new.push_back(this_rdo);
        const float this_charge=charge_list_cluster[i];
        const int row = pixelID.phi_index(this_rdo);
        if (row > rowmax) {
          rowmax = row;
          qRowMax = this_charge;
        } else if (row == rowmax) {
          qRowMax += this_charge; 
        }
        if (row < rowmin) {  
          rowmin = row;
          qRowMin = this_charge;
        } else if (row == rowmin) {
          qRowMin += this_charge;
        } 
        
        const int col = pixelID.eta_index(this_rdo);
        if (col > colmax) {
          colmax = col;
          qColMax = this_charge;
        } else if (col == colmax) {
          qColMax += this_charge;
        }     
        
        if (col < colmin) {
          colmin = col;
          qColMin = this_charge;
        } else if (col == colmin) {
          qColMin += this_charge;
        }
        
      }//loop on rdo list
    } // check that rdo list has the same size of charge list
     else {
        std::ranges::transform(rdo_list_cluster, std::back_inserter(rdo_list_new),
                               [](const Identifier::value_type& rdo) { return Identifier{rdo}; });  
     }
    // 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);
        
    double etaWidth = design->widthFromColumnRange(colmin, colmax);
    double phiWidth = design->widthFromRowRange(rowmin, rowmax);
    InDet::SiWidth width( Amg::Vector2D(xaodCluster.channelsInPhi(), xaodCluster.channelsInEta()),
                          Amg::Vector2D(phiWidth,etaWidth) );
    return std::make_unique<InDet::PixelCluster>(id,
                                           localPosition,
                                           globalPosition,
                                           std::move(rdo_list_new),
                                           xaodCluster.lvl1a(),
                                           std::vector<int>(tot_list.begin(), tot_list.end()),
                                           std::vector<float>(charge_list_cluster.begin(),charge_list_cluster.end()),
                                           width,
                                           &element,
                                           std::move(errorMatrix),
                                           omegax, omegay,
                                           false, 0, 0);
 
  }

convertXaodToInDetCluster() [3/3]

std::unique_ptr< InDet::SCT_Cluster > TrackingUtilities::convertXaodToInDetCluster	(	const xAOD::StripCluster &	xaodCluster,
		const InDetDD::SiDetectorElement &	element,
		const InDetDD::SCT_ModuleSideDesign &	design,
		const SCT_ID &	stripID,
		double	shift = 0. )

Definition at line 275 of file ClusterConversionUtilities.cxx.

  {
    bool isBarrel = element.isBarrel();
    const InDetDD::SCT_ModuleSideDesign* design = &moduleDesign;
 
    const auto designShape = design->shape();
 
 
    SG::ConstAccessor<SG::JaggedVecElt<Identifier::value_type> >::element_type
       rdo_list_cluster = xaodCluster.rdoList();
    Identifier id(rdo_list_cluster.front());
 
    const auto& localPos = xaodCluster.localPosition<1>();
 
    double pos_x = localPos(0, 0);
    double pos_y = 0;
    if (not isBarrel) {
      const Identifier firstStripId(id);
      int firstStrip = stripID.strip(firstStripId);
      int stripRow = stripID.row(firstStripId);
      int clusterSizeInStrips = xaodCluster.channelsInPhi();
      auto clusterPosition = design->localPositionOfCluster(design->strip1Dim(firstStrip, stripRow), clusterSizeInStrips);
      pos_x = clusterPosition.xPhi() + shift;
      pos_y = clusterPosition.xEta();
    }
 
    Amg::Vector2D locpos = Amg::Vector2D( pos_x, pos_y );
 
    // Most of the following is taken from what is done in ClusterMakerTool
    // Need to make this computation instead of using the local pos
    // with local pos instead some differences w.r.t. reference are observed
    const auto& firstStrip = stripID.strip(Identifier(rdo_list_cluster.front()));
    const auto& lastStrip = stripID.strip(Identifier(rdo_list_cluster.back()));
    const auto& row = stripID.row(Identifier(rdo_list_cluster.front()));
    const int firstStrip1D = design->strip1Dim (firstStrip, row );
    const int lastStrip1D = design->strip1Dim( lastStrip, row );
    const InDetDD::SiCellId cell1(firstStrip1D);
    const InDetDD::SiCellId cell2(lastStrip1D);
    const InDetDD::SiLocalPosition firstStripPos( element.rawLocalPositionOfCell(cell1 ));
    const InDetDD::SiLocalPosition lastStripPos( element.rawLocalPositionOfCell(cell2) );
    const InDetDD::SiLocalPosition centre( (firstStripPos+lastStripPos) * 0.5 );
    const double clusterWidth = design->stripPitch() * ( lastStrip - firstStrip + 1 );
 
    const std::pair<InDetDD::SiLocalPosition, InDetDD::SiLocalPosition> ends( design->endsOfStrip(centre) );
    const double stripLength( std::abs(ends.first.xEta() - ends.second.xEta()) );
 
    InDet::SiWidth width( Amg::Vector2D(xaodCluster.channelsInPhi(), 1),
                          Amg::Vector2D(clusterWidth, stripLength) );
 
    const double col_x = width.colRow().x();
    const double col_y = width.colRow().y();
 
    double scale_factor = 1.;
    if ( col_x  == 1 )
      scale_factor = 1.05;
    else if ( col_x == 2 )
      scale_factor = 0.27;
 
    auto errorMatrix = Amg::MatrixX(2,2);
    errorMatrix.setIdentity();
    errorMatrix.fillSymmetric(0, 0, scale_factor * scale_factor * width.phiR() * width.phiR() * one_over_twelve);
    errorMatrix.fillSymmetric(1, 1, width.z() * width.z() / col_y / col_y * one_over_twelve);
 
    if( designShape == InDetDD::Trapezoid or designShape == InDetDD::Annulus) {
      // rotation for endcap SCT
 
      // The following is being computed with the local position,
      // without considering the lorentz shift
      // So we remove it from the local position
      Amg::Vector2D local(pos_x - shift, pos_y);
      double sn = element.sinStereoLocal(local);
      double sn2 = sn * sn;
      double cs2 = 1. - sn2;
      double w = element.phiPitch(local) / element.phiPitch();
      double v0 = errorMatrix(0,0) * w * w;
      double v1 = errorMatrix(1,1);
      errorMatrix.fillSymmetric( 0, 0, cs2 * v0 + sn2 * v1 );
      errorMatrix.fillSymmetric( 0, 1, sn * std::sqrt(cs2) * (v0 - v1) );
      errorMatrix.fillSymmetric( 1, 1, sn2 * v0 + cs2 * v1 );
    }
    std::vector<Identifier> rdo_list_new;
    for(Identifier::value_type rdo_id_value : rdo_list_cluster) {
       rdo_list_new.emplace_back(rdo_id_value);
    }
 
    return  std::make_unique<InDet::SCT_Cluster>(id,
                                          locpos,
                                          std::move(rdo_list_new),
                                          width,
                                          &element,
                                          std::move(errorMatrix));
  }

pixelModuleDesign()

const InDetDD::PixelModuleDesign * TrackingUtilities::pixelModuleDesign

(

const InDetDD::SiDetectorElement &

element

)

Resolve the readout design of a pixel/strip detector element.

The result only depends on the element, so callers converting many clusters of the same element should hoist this out of their loop: the cast is not free and the conversion is run once per cluster in the event.

Definition at line 156 of file ClusterConversionUtilities.cxx.

  {
    return dynamic_cast<const InDetDD::PixelModuleDesign*>(&element.design());
  }

stripModuleSideDesign()

const InDetDD::SCT_ModuleSideDesign * TrackingUtilities::stripModuleSideDesign

(

const InDetDD::SiDetectorElement &

element

)

Definition at line 161 of file ClusterConversionUtilities.cxx.

  {
    if (not element.isBarrel()) {
      return dynamic_cast<const InDetDD::StripStereoAnnulusDesign*>(&element.design());
    }
    return dynamic_cast<const InDetDD::SCT_ModuleSideDesign*>(&element.design());
  }