ITk::PixelClusterOnTrackTool Class Reference

#include <ITkPixelClusterOnTrackTool.h>

Inheritance diagram for ITk::PixelClusterOnTrackTool:

Collaboration diagram for ITk::PixelClusterOnTrackTool:

Public Member Functions
	PixelClusterOnTrackTool (const std::string &, const std::string &, const IInterface *)
	AlgTool constructor.
virtual	~PixelClusterOnTrackTool ()=default
virtual StatusCode	initialize () override
	AlgTool initialisation.
virtual InDet::PixelClusterOnTrack *	correct (const Trk::PrepRawData &, const Trk::TrackParameters &, const EventContext &ctx) const override
	produces a PixelClusterOnTrack (object factory!).
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	The AlgTool InterfaceID.

Protected Member Functions
InDet::PixelClusterOnTrack *	correctDefault (const Trk::PrepRawData &, const Trk::TrackParameters &, const EventContext &) const
	The correct method produces a PixelClusterOnTrack using the measured PixelCluster and the track prediction.
InDet::PixelClusterOnTrack *	correctNN (const Trk::PrepRawData &, const Trk::TrackParameters &, const EventContext &) const
bool	getErrorsDefaultAmbi (const InDet::PixelCluster *, const Trk::TrackParameters &, Amg::Vector2D &, Amg::MatrixX &, const EventContext &) const
bool	getErrorsTIDE_Ambi (const InDet::PixelCluster *, const Trk::TrackParameters &, Amg::Vector2D &, Amg::MatrixX &, const EventContext &) const
InDet::PixelClusterOnTrack *	correct (const Trk::PrepRawData &, const Trk::TrackParameters &, const ITk::PixelClusterStrategy, const EventContext &) const
const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &	getClusterSplittingProbability (const InDet::PixelCluster *pix, const EventContext &ctx) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool", "Tool to retreive Lorentz angle"}
SG::ReadCondHandleKey< ITk::PixelOfflineCalibData >	m_clusterITkErrorKey {this, "ITkPixelOfflineCalibData", "ITkPixelOfflineCalibData", "Output key of ITk pixel cluster"}
SG::ReadCondHandleKey< RIO_OnTrackErrorScaling >	m_pixelErrorScalingKey {this,"PixelErrorScalingKey", "/Indet/TrkErrorScalingPixel", "Key for pixel error scaling conditions data."}
IntegerProperty	m_positionStrategy
	toolhandle for central error scaling flag storing if errors need scaling or should be kept nominal
std::atomic_int	m_errorStrategy {2}
IntegerProperty	m_errorStrategyProperty
const PixelID *	m_pixelid = nullptr
	Flag controlling how module distortions are taken into account:
bool	m_applyNNcorrection {false}
	Enable NN based calibration (do only if NN calibration is applied).
BooleanProperty	m_applyNNcorrectionProperty {this, "applyNNcorrection", false}
ToolHandle< InDet::NnClusterizationFactory >	m_NnClusterizationFactory
	NN clusterizationi factory for NN based positions and errors.
BooleanProperty	m_doNotRecalibrateNN {this, "doNotRecalibrateNN", false}
BooleanProperty	m_noNNandBroadErrors {this, "noNNandBroadErrors", false}
BooleanProperty	m_usingTIDE_Ambi {this, "RunningTIDE_Ambi", false}
	Enable different treatment of cluster errors based on NN information (do only if TIDE ambi is run).
SG::ReadHandleKey< InDet::PixelGangedClusterAmbiguities >	m_splitClusterMapKey {this, "SplitClusterAmbiguityMap", ""}
SG::ReadHandleKey< Trk::ClusterSplitProbabilityContainer >	m_clusterSplitProbContainer {this, "ClusterSplitProbabilityName", "",""}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 58 of file ITkPixelClusterOnTrackTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

PixelClusterOnTrackTool()

ITk::PixelClusterOnTrackTool::PixelClusterOnTrackTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

AlgTool constructor.

Definition at line 59 of file ITkPixelClusterOnTrackTool.cxx.

                                                                :
  ::AthAlgTool(t, n, p)
{
  declareInterface<IRIO_OnTrackCreator>(this);
}

~PixelClusterOnTrackTool()

virtual ITk::PixelClusterOnTrackTool::~PixelClusterOnTrackTool ( )

virtualdefault

Member Function Documentation

correct() [1/2]

InDet::PixelClusterOnTrack * ITk::PixelClusterOnTrackTool::correct ( const Trk::PrepRawData & rio, const Trk::TrackParameters & trackPar, const EventContext & ctx ) const

overridevirtual

produces a PixelClusterOnTrack (object factory!).

Depending on job options it changes the pixel cluster position and error according to the parameters (in particular, the angle) of the intersecting track.

Implements Trk::IRIO_OnTrackCreator.

Definition at line 106 of file ITkPixelClusterOnTrackTool.cxx.

                                                                                                 {
 
  if (not m_applyNNcorrection){
    return correctDefault(rio, trackPar, ctx);
  }else {
    if (m_errorStrategy == 0 || m_errorStrategy == 1) {
      // version from Giacinto
      if (m_noNNandBroadErrors) {
        return nullptr;
      }
      // if we try broad errors, get Pixel Cluster to test if it is split
      const InDet::PixelCluster *pix = nullptr;
      if (rio.type(Trk::PrepRawDataType::PixelCluster)) {
        pix = static_cast<const InDet::PixelCluster *>(&rio);
      }
      if (!pix) {
        return nullptr;
      }
      const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &splitProb = getClusterSplittingProbability(pix, ctx);
      if (splitProb.isSplit()) {
        return correctNN(rio, trackPar, ctx);
      } else {
        return correctDefault(rio, trackPar, ctx);
      }
    } else {
      return correctNN(rio, trackPar, ctx);
    }
  }
}

correct() [2/2]

InDet::PixelClusterOnTrack * ITk::PixelClusterOnTrackTool::correct ( const Trk::PrepRawData & rio, const Trk::TrackParameters & trackPar, const ITk::PixelClusterStrategy strategy, const EventContext & ctx ) const

protected

Definition at line 347 of file ITkPixelClusterOnTrackTool.cxx.

                                                                          {
  int initial_errorStrategy;
  InDet::PixelClusterOnTrack *newROT;
 
  switch (strategy) {
  case PixelClusterStrategy::OUTLIER: // if cluster is outlier, increase errors
  case PixelClusterStrategy::SHARED:
    initial_errorStrategy = m_errorStrategy;
    m_errorStrategy = 0; // error as size of cluster /sqrt(12)
    newROT = correct(rio, trackPar, ctx);
    m_errorStrategy = initial_errorStrategy;
    return newROT;
 
  default:
    return correct(rio, trackPar, ctx);
  }
}

correctDefault()

InDet::PixelClusterOnTrack * ITk::PixelClusterOnTrackTool::correctDefault ( const Trk::PrepRawData & rio, const Trk::TrackParameters & trackPar, const EventContext & ctx ) const

protected

The correct method produces a PixelClusterOnTrack using the measured PixelCluster and the track prediction.

Definition at line 143 of file ITkPixelClusterOnTrackTool.cxx.

                                                                                                 {
 
  const double TOPHAT_SIGMA = 1. / std::sqrt(12.);
  const InDet::PixelCluster *pix = nullptr;
  if(rio.type(Trk::PrepRawDataType::PixelCluster)) {
     pix = static_cast<const InDet::PixelCluster *>(&rio);
  }
  else{
    return nullptr;
  }
 
  ATH_MSG_VERBOSE("Correct called with Error strategy " << m_errorStrategy);
 
  // PixelClusterOnTrack production
  //
  Trk::LocalParameters locpar;
  Amg::Vector3D glob(pix->globalPosition());
 
 
  // Get pointer to detector element
  const InDetDD::SiDetectorElement *element = pix->detectorElement();
  if (!element) {
    return nullptr;
  }
  IdentifierHash idHash = element->identifyHash();
 
  double errphi = -1;
  double erreta = -1;
 
  if (pix->rdoList().empty()) {
    ATH_MSG_WARNING("Pixel RDO-list size is 0, check integrity of pixel clusters! stop ROT creation.");
    return nullptr;
  } else {
    const InDetDD::PixelModuleDesign *design =
      static_cast<const InDetDD::PixelModuleDesign *>(&element->design());
 
    // get candidate track angle in module local frame
    const Amg::Vector3D& my_track = trackPar.momentum();
    const Amg::Vector3D& my_normal = element->normal();
    const Amg::Vector3D& my_phiax = element->phiAxis();
    const Amg::Vector3D& my_etaax = element->etaAxis();
    float trkphicomp = my_track.dot(my_phiax);
    float trketacomp = my_track.dot(my_etaax);
    float trknormcomp = my_track.dot(my_normal);
    double bowphi = std::atan2(trkphicomp, trknormcomp);
    double boweta = std::atan2(trketacomp, trknormcomp);
 
    float tanl = m_lorentzAngleTool->getTanLorentzAngle(idHash, ctx);
    int readoutside = element->design().readoutSide();
 
    // map the angles of inward-going tracks onto [-PI/2, PI/2]
    if (bowphi > M_PI *0.5) {
      bowphi -= M_PI;
    }
    if (bowphi < -M_PI *0.5) {
      bowphi += M_PI;
    }
    // finally, subtract the Lorentz angle effect
    // the readoutside term is needed because of a bug in old
    // geometry versions (CSC-01-* and CSC-02-*)
    double angle = std::atan(std::tan(bowphi) - readoutside * tanl);
 
    // settle the sign/pi periodicity issues
    double thetaloc = -999.;
    if (boweta > -0.5 * M_PI && boweta < M_PI / 2.) { //M_PI_2 in cmath
      thetaloc = M_PI_2 - boweta;
    }else if (boweta > M_PI_2 && boweta < M_PI) {
      thetaloc = 1.5 * M_PI - boweta;
    } else { // 3rd quadrant
      thetaloc = -M_PI_2 - boweta;
    }
    double etaloc = -1 * log(tan(thetaloc * 0.5));
 
    // try to understand...
    const Identifier element_id = element->identify();
    int PixEtaModule = m_pixelid->eta_module(element_id);
    int PixPhiModule = m_pixelid->phi_module(element_id);
    double PixTrkPt = trackPar.pT();
    double PixTrkEta = trackPar.eta();
    ATH_MSG_VERBOSE("tanl = " << tanl << " readout side is " << readoutside <<
                    " module " << PixEtaModule << " " << PixPhiModule <<
                    " track pt, eta = " << PixTrkPt << " " << PixTrkEta <<
                    " track momentum phi, norm = " << trkphicomp << " " <<
                    trknormcomp << " bowphi = " << bowphi << " angle = " << angle);
 
    float omegaphi = pix->omegax();
    float omegaeta = pix->omegay();
    double localphi = -9999.;
    double localeta = -9999.;
 
    const std::vector<Identifier> & rdos = pix->rdoList();
    InDetDD::SiLocalPosition meanpos(0, 0, 0);
    int rowmin = 9999;
    int rowmax = -9999;
    int colmin = 9999;
    int colmax = -9999;
    for (const auto & rId:rdos) {
      const int row = m_pixelid->phi_index(rId);
      const int col = m_pixelid->eta_index(rId);
      rowmin = std::min(rowmin, row);
      rowmax = std::max(rowmax,row);
      colmin = std::min(colmin, col);
      colmax = std::max(colmax, col);
      meanpos += design->positionFromColumnRow(col, row);
    }
    meanpos = meanpos / rdos.size();
    InDetDD::SiLocalPosition pos1 =
      design->positionFromColumnRow(colmin, rowmin);
    InDetDD::SiLocalPosition pos2 =
      design->positionFromColumnRow(colmax, rowmin);
    InDetDD::SiLocalPosition pos3 =
      design->positionFromColumnRow(colmin, rowmax);
    InDetDD::SiLocalPosition pos4 =
      design->positionFromColumnRow(colmax, rowmax);
 
    InDetDD::SiLocalPosition centroid = 0.25 * (pos1 + pos2 + pos3 + pos4);
    double shift = m_lorentzAngleTool->getLorentzShift(idHash, ctx);
    int nrows = rowmax - rowmin + 1;
    int ncol = colmax - colmin + 1;
 
    // TOT interpolation for collision data
    SG::ReadCondHandle<ITk::PixelOfflineCalibData> offlineITkCalibDataHandle(m_clusterITkErrorKey, ctx);
 
    if (m_positionStrategy > 0 && omegaphi > -0.5 && omegaeta > -0.5) {
      localphi = centroid.xPhi() + shift;
      localeta = centroid.xEta();
 
      std::pair<double,double> delta = offlineITkCalibDataHandle->getClusterErrorData()->getDelta(idHash,nrows,angle,ncol,etaloc);
      double delta_phi = nrows != 1 ? delta.first : 0.;
      double delta_eta = ncol != 1 ? delta.second : 0.;
      localphi += delta_phi*(omegaphi-0.5);
      localeta += delta_eta*(omegaeta-0.5);
    }
    // digital
    else {
      localphi = meanpos.xPhi() + shift;
      localeta = meanpos.xEta();
    }
 
    const InDet::SiWidth& width = pix->width();
 
    // Error strategies
 
    // For very shallow tracks the cluster can easily break as
    // the average charge per pixel is of the order of the threshold
    // In this case, an error equal to the geometrical projection
    // of the track path in silicon onto the module surface seems
    // appropriate
    if (std::abs(angle) > 1) {
      const double thickness = element->thickness();
      errphi = thickness * std::tan(std::abs(angle)) * TOPHAT_SIGMA;
      erreta = width.z() > thickness * std::tan(std::abs(boweta)) ?
               width.z() * TOPHAT_SIGMA : thickness * std::tan(std::abs(boweta)) * TOPHAT_SIGMA;
      ATH_MSG_VERBOSE("Shallow track with tanl = " << tanl << " bowphi = " <<
                      bowphi << " angle = " << angle << " width.z = " << width.z() <<
                      " errphi = " << errphi << " erreta = " << erreta);
    }else if (m_errorStrategy == 0) {
      errphi = width.phiR() * TOPHAT_SIGMA;
      erreta = width.z() * TOPHAT_SIGMA;
    }else if (m_errorStrategy == 1) {
      errphi = (width.phiR() / nrows) * TOPHAT_SIGMA;
      erreta = (width.z() / ncol) * TOPHAT_SIGMA;
    }else if (m_errorStrategy == 2) {
      std::pair<double,double> delta_err = offlineITkCalibDataHandle->getClusterErrorData()->getDeltaError(idHash);
      errphi = nrows != 1 ? delta_err.first : width.phiR()*TOPHAT_SIGMA;
      erreta = ncol != 1 ? delta_err.second : width.z()*TOPHAT_SIGMA;
    }
 
    Amg::Vector2D locpos = Amg::Vector2D(localphi, localeta);
    locpar = Trk::LocalParameters(locpos);
    centroid = InDetDD::SiLocalPosition(localeta, localphi, 0.);
    glob = element->globalPosition(centroid);
  }
 
  // Error matrix production
 
  Amg::MatrixX cov = pix->localCovariance();
 
  // corrected phi error
  if (errphi > 0) {
    cov(0, 0) = errphi * errphi;
  }
  if (erreta > 0) {
    cov(1, 1) = erreta * erreta;
  }
 
  ATH_MSG_VERBOSE(" errphi =  " << errphi << " erreta = " << erreta);
 
  // create new copy of error matrix
  if (!m_pixelErrorScalingKey.key().empty()) {
    SG::ReadCondHandle<RIO_OnTrackErrorScaling> error_scaling( m_pixelErrorScalingKey, ctx );
    cov = Trk::ErrorScalingCast<PixelRIO_OnTrackErrorScaling>(*error_scaling)
              ->getScaledCovariance(std::move(cov), *m_pixelid,
                                    element->identify());
  }
  bool isbroad = m_errorStrategy == 0;
  return new InDet::PixelClusterOnTrack(pix, std::move(locpar),
                                        std::move(cov),
                                        idHash, glob, pix->gangedPixel(), isbroad);
}

correctNN()

InDet::PixelClusterOnTrack * ITk::PixelClusterOnTrackTool::correctNN ( const Trk::PrepRawData & rio, const Trk::TrackParameters & trackPar, const EventContext & ctx ) const

protected

Definition at line 369 of file ITkPixelClusterOnTrackTool.cxx.

                                  {
 
  const InDet::PixelCluster *pixelPrepCluster = nullptr;
  if (rio.type(Trk::PrepRawDataType::PixelCluster)) {
    pixelPrepCluster = static_cast<const InDet::PixelCluster *>(&rio);
  }
 
  if (pixelPrepCluster == nullptr) {
    ATH_MSG_WARNING("This is not a pixel cluster, return 0.");
    return nullptr;
  }
 
  const InDetDD::SiDetectorElement *element = pixelPrepCluster->detectorElement();
  if (!element) {
    ATH_MSG_WARNING("Cannot access detector element. Aborting cluster correction...");
    return nullptr;
  }
 
  IdentifierHash idHash = element->identifyHash();
 
  if (m_doNotRecalibrateNN) {
    Amg::Vector3D glob(pixelPrepCluster->globalPosition());
 
    Amg::Vector2D locpos = pixelPrepCluster->localPosition();
    Trk::LocalParameters locpar = Trk::LocalParameters(locpos);
    Amg::MatrixX cov = pixelPrepCluster->localCovariance();
 
    return new InDet::PixelClusterOnTrack(pixelPrepCluster, std::move(locpar),
                                          std::move(cov), idHash, glob,
                                          pixelPrepCluster->gangedPixel(), false);
  }
 
 
 
  Amg::Vector2D finalposition;
  Amg::MatrixX finalerrormatrix;
 
  if (m_usingTIDE_Ambi) {
    if (!getErrorsTIDE_Ambi(pixelPrepCluster, trackPar, finalposition, finalerrormatrix, ctx)) {
      return correctDefault(rio, trackPar, ctx);
    }
  }else {
    if (!getErrorsDefaultAmbi(pixelPrepCluster, trackPar, finalposition, finalerrormatrix, ctx)) {
      return correctDefault(rio, trackPar, ctx);
    }
  }
 
  ATH_MSG_DEBUG( " Old position x: " << pixelPrepCluster->localPosition()[0]
      << " +/- " << std::sqrt(pixelPrepCluster->localCovariance()(0, 0))
      << " y: " << pixelPrepCluster->localPosition()[1]
      << " +/- " << std::sqrt(pixelPrepCluster->localCovariance()(1, 1)) <<"\n"
      << " Final position x: " << finalposition[0]
      << " +/- " << std::sqrt(finalerrormatrix(0, 0))
      << " y: " << finalposition[1] << " +/- "
      <<std::sqrt(finalerrormatrix(1, 1)) );
 
  Amg::MatrixX cov = std::move(finalerrormatrix);
  // create new copy of error matrix
  if (!m_pixelErrorScalingKey.key().empty()) {
    SG::ReadCondHandle<RIO_OnTrackErrorScaling> error_scaling( m_pixelErrorScalingKey, ctx );
    cov = Trk::ErrorScalingCast<PixelRIO_OnTrackErrorScaling>(*error_scaling)
              ->getScaledCovariance(std::move(cov), *m_pixelid,
                                    element->identify());
  }
 
  InDetDD::SiLocalPosition centroid = InDetDD::SiLocalPosition(finalposition[1],
                                                               finalposition[0],
                                                               0);
  Trk::LocalParameters locpar = Trk::LocalParameters(finalposition);
 
  const Amg::Vector3D &glob = element->globalPosition(centroid);
 
 
  return new InDet::PixelClusterOnTrack(pixelPrepCluster,
                                        std::move(locpar),
                                        std::move(cov), idHash,
                                        glob,
                                        pixelPrepCluster->gangedPixel(),
                                        false);
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getClusterSplittingProbability()

const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo & ITk::PixelClusterOnTrackTool::getClusterSplittingProbability ( const InDet::PixelCluster * pix, const EventContext & ctx ) const

inlineprotected

Definition at line 110 of file ITkPixelClusterOnTrackTool.h.

                                                                                             {
   if (!pix || m_clusterSplitProbContainer.key().empty())
     return Trk::ClusterSplitProbabilityContainer::getNoSplitProbability();
 
   SG::ReadHandle<Trk::ClusterSplitProbabilityContainer> splitProbContainer(
       m_clusterSplitProbContainer, ctx);
   if (!splitProbContainer.isValid()) {
     ATH_MSG_FATAL("Failed to get cluster splitting probability container "
                   << m_clusterSplitProbContainer);
   }
   return splitProbContainer->splitProbability(pix);
  }

getErrorsDefaultAmbi()

bool ITk::PixelClusterOnTrackTool::getErrorsDefaultAmbi ( const InDet::PixelCluster * pixelPrepCluster, const Trk::TrackParameters & trackPar, Amg::Vector2D & finalposition, Amg::MatrixX & finalerrormatrix, const EventContext & ctx ) const

protected

Definition at line 454 of file ITkPixelClusterOnTrackTool.cxx.

                                                                             {
  std::vector<Amg::Vector2D> vectorOfPositions;
  int numberOfSubclusters = 1;
  vectorOfPositions.push_back(pixelPrepCluster->localPosition());
 
  if (m_applyNNcorrection){
    SG::ReadHandle<InDet::PixelGangedClusterAmbiguities> splitClusterMap(m_splitClusterMapKey, ctx);
    InDet::PixelGangedClusterAmbiguities::const_iterator mapBegin = splitClusterMap->begin();
    InDet::PixelGangedClusterAmbiguities::const_iterator mapEnd = splitClusterMap->end();
    for (InDet::PixelGangedClusterAmbiguities::const_iterator mapIter = mapBegin; mapIter != mapEnd; ++mapIter) {
      const InDet::SiCluster *first = (*mapIter).first;
      const InDet::SiCluster *second = (*mapIter).second;
      if (first == pixelPrepCluster && second != pixelPrepCluster) {
        ATH_MSG_DEBUG("Found additional split cluster in ambiguity map (+=1).");
        numberOfSubclusters += 1;
        const InDet::SiCluster *otherOne = second;
        const InDet::PixelCluster *pixelAddCluster = nullptr;
        if (otherOne->type(Trk::PrepRawDataType::PixelCluster)) {
          pixelAddCluster = static_cast<const InDet::PixelCluster *>(otherOne);
        }
        if (pixelAddCluster == nullptr) {
          ATH_MSG_WARNING("Pixel ambiguity map has empty pixel cluster. Please DEBUG!");
          continue;
        }
        vectorOfPositions.push_back(pixelAddCluster->localPosition());
 
        ATH_MSG_DEBUG( "Found one more pixel cluster. Position x: "
                       << pixelAddCluster->localPosition()[0] << "y: " << pixelAddCluster->localPosition()[1]);
      }// find relevant element of map
    }// iterate over map
  }
 
  // now you have numberOfSubclusters and the vectorOfPositions (Amg::Vector2D)
 
  if (trackPar.surfaceType() != Trk::SurfaceType::Plane ||
      trackPar.type() != Trk::AtaSurface) {
    ATH_MSG_WARNING(
      "Parameters are not at a plane ! Aborting cluster correction... ");
    return false;
  }
 
  std::vector<Amg::Vector2D> allLocalPositions;
  std::vector<Amg::MatrixX> allErrorMatrix;
  allLocalPositions =
    m_NnClusterizationFactory->estimatePositions(*pixelPrepCluster,
                                                 trackPar.associatedSurface(),
                                                 trackPar,
                                                 allErrorMatrix,
                                                 numberOfSubclusters);
 
  if (allLocalPositions.empty()) {
    ATH_MSG_DEBUG( " Cluster cannot be treated by NN. Giving back to default clusterization " );
 
    return false;
  }
 
  if (allLocalPositions.size() != size_t(numberOfSubclusters)) {
    ATH_MSG_WARNING( "Returned position vector size " << allLocalPositions.size() <<
    " not according to expected number of subclusters: " << numberOfSubclusters << ". Abort cluster correction..." );
    return false;
  }
 
 
  // GP: now the not so nice part of matching the new result with the old one...
  // Takes the error into account to improve the matching
 
  if (numberOfSubclusters == 1) {
    finalposition = allLocalPositions[0];
    finalerrormatrix = allErrorMatrix[0];
  }
 
  else if (numberOfSubclusters == 2) {
    double distancesq1 =
      square(vectorOfPositions[0][0] - allLocalPositions[0][0]) / allErrorMatrix[0](0, 0) +
      square(vectorOfPositions[1][0] - allLocalPositions[1][0]) / allErrorMatrix[1](0, 0) +
      square(vectorOfPositions[0][1] - allLocalPositions[0][1]) / allErrorMatrix[0](1, 1) +
      square(vectorOfPositions[1][1] - allLocalPositions[1][1]) / allErrorMatrix[1](1, 1);
 
    double distancesq2 =
      square(vectorOfPositions[1][0] - allLocalPositions[0][0]) / allErrorMatrix[0](0, 0) +
      square(vectorOfPositions[0][0] - allLocalPositions[1][0]) / allErrorMatrix[1](0, 0) +
      square(vectorOfPositions[1][1] - allLocalPositions[0][1]) / allErrorMatrix[0](1, 1) +
      square(vectorOfPositions[0][1] - allLocalPositions[1][1]) / allErrorMatrix[1](1, 1);
 
    ATH_MSG_DEBUG(
     " Old pix (1) x: " << vectorOfPositions[0][0] << " y: " << vectorOfPositions[0][1] << "\n"
      << " Old pix (2) x: " << vectorOfPositions[1][0] << " y: " << vectorOfPositions[1][1] << "\n"
      << " Pix (1) x: " << allLocalPositions[0][0] << " +/- " << std::sqrt(allErrorMatrix[0](0, 0))
      << " y: " << allLocalPositions[0][1] << " +/- " << std::sqrt(allErrorMatrix[0](1, 1)) <<"\n"
      << " Pix (2) x: " << allLocalPositions[1][0] << " +/- " << std::sqrt(allErrorMatrix[1](0, 0))
      << " y: " << allLocalPositions[1][1] << " +/- " << std::sqrt(allErrorMatrix[1](1, 1)) << "\n"
      << " Old (1) new (1) dist: " << std::sqrt(distancesq1) << " Old (1) new (2) " << std::sqrt(distancesq2) );
 
 
    if (distancesq1 < distancesq2) {
      finalposition = allLocalPositions[0];
      finalerrormatrix = allErrorMatrix[0];
    }else {
      finalposition = allLocalPositions[1];
      finalerrormatrix = allErrorMatrix[1];
    }
  }
 
 
  else if (numberOfSubclusters == 3) {
    double distances[6];
 
    distances[0] = distance(vectorOfPositions, allLocalPositions, allErrorMatrix, 0, 1, 2);
    distances[1] = distance(vectorOfPositions, allLocalPositions, allErrorMatrix, 0, 2, 1);
    distances[2] = distance(vectorOfPositions, allLocalPositions, allErrorMatrix, 1, 0, 2);
    distances[3] = distance(vectorOfPositions, allLocalPositions, allErrorMatrix, 1, 2, 0);
    distances[4] = distance(vectorOfPositions, allLocalPositions, allErrorMatrix, 2, 0, 1);
    distances[5] = distance(vectorOfPositions, allLocalPositions, allErrorMatrix, 2, 1, 0);
 
    int smallestDistanceIndex = -10;
    double minDistance = 1e10;
 
    for (int i = 0; i < 6; i++) {
      ATH_MSG_VERBOSE(" distance n.: " << i << " distance is: " << distances[i]);
 
      if (distances[i] < minDistance) {
        minDistance = distances[i];
        smallestDistanceIndex = i;
      }
    }
 
    ATH_MSG_DEBUG(" The minimum distance is : " << minDistance << " for index: " << smallestDistanceIndex);
 
    if (smallestDistanceIndex == 0 || smallestDistanceIndex == 1) {
      finalposition = allLocalPositions[0];
      finalerrormatrix = allErrorMatrix[0];
    }
    if (smallestDistanceIndex == 2 || smallestDistanceIndex == 4) {
      finalposition = allLocalPositions[1];
      finalerrormatrix = allErrorMatrix[1];
    }
    if (smallestDistanceIndex == 3 || smallestDistanceIndex == 5) {
      finalposition = allLocalPositions[2];
      finalerrormatrix = allErrorMatrix[2];
    }
  }
  return true;
}

getErrorsTIDE_Ambi()

bool ITk::PixelClusterOnTrackTool::getErrorsTIDE_Ambi ( const InDet::PixelCluster * pixelPrepCluster, const Trk::TrackParameters & trackPar, Amg::Vector2D & finalposition, Amg::MatrixX & finalerrormatrix, const EventContext & ctx ) const

protected

Definition at line 603 of file ITkPixelClusterOnTrackTool.cxx.

                                                                           {
  const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &splitProb = getClusterSplittingProbability(pixelPrepCluster, ctx);
  std::vector<Amg::Vector2D> vectorOfPositions;
  int numberOfSubclusters = 1;
  if(m_applyNNcorrection){
    SG::ReadHandle<InDet::PixelGangedClusterAmbiguities> splitClusterMap(m_splitClusterMapKey, ctx);
    numberOfSubclusters = 1 + splitClusterMap->count(pixelPrepCluster);
 
    if (splitClusterMap->count(pixelPrepCluster) == 0 && splitProb.isSplit()) {
      numberOfSubclusters = 2;
    }
    if (splitClusterMap->count(pixelPrepCluster) != 0 && !splitProb.isSplit()) {
      numberOfSubclusters = 1;
    }
  }
 
  // now you have numberOfSubclusters and the vectorOfPositions (Amg::Vector2D)
  if (trackPar.surfaceType() != Trk::SurfaceType::Plane ||
      trackPar.type() != Trk::AtaSurface) {
    ATH_MSG_WARNING("Parameters are not at a plane surface ! Aborting cluster "
                    "correction... ");
    return false;
  }
 
  std::vector<Amg::Vector2D> allLocalPositions;
  std::vector<Amg::MatrixX> allErrorMatrix;
  allLocalPositions = m_NnClusterizationFactory->estimatePositions(
    *pixelPrepCluster,
    trackPar.associatedSurface(),
    trackPar,
    allErrorMatrix,
    numberOfSubclusters);
 
  if (allLocalPositions.empty()) {
    ATH_MSG_DEBUG(
      " Cluster cannot be treated by NN. Giving back to default clusterization, too big: " <<
      splitProb.isTooBigToBeSplit());
    return false;
  }
 
  if (allLocalPositions.size() != size_t(numberOfSubclusters)) {
    ATH_MSG_WARNING(
      "Returned position vector size " << allLocalPositions.size() << " not according to expected number of subclusters: " << numberOfSubclusters <<
    ". Abort cluster correction...");
    return false;
  }
 
  // AKM: now the not so nice part find the best match position option
  // Takes the error into account to scale the importance of the measurement
 
  if (numberOfSubclusters == 1) {
    finalposition = allLocalPositions[0];
    finalerrormatrix = allErrorMatrix[0];
    return true;
  }
 
  // Get the track parameters local position
  const Amg::Vector2D localpos = trackPar.localPosition();
  // Use the track parameters cov to weight distcances
  Amg::Vector2D localerr(0.01, 0.05);
  if (trackPar.covariance()) {
    localerr = Amg::Vector2D(std::sqrt((*trackPar.covariance())(0, 0)), std::sqrt((*trackPar.covariance())(1, 1)));
  }
 
  double minDistance(1e300);
  int index(0);
 
  for (unsigned int i(0); i < allLocalPositions.size(); ++i) {
    double distance =
      square(localpos[0] - allLocalPositions[i][0]) / localerr[0]
      + square(localpos[1] - allLocalPositions[i][1]) / localerr[1];
 
    if (distance < minDistance) {
      index = i;
      minDistance = distance;
    }
  }
 
  finalposition = allLocalPositions[index];
  finalerrormatrix = allErrorMatrix[index];
  return true;
}

initialize()

StatusCode ITk::PixelClusterOnTrackTool::initialize ( )

overridevirtual

AlgTool initialisation.

Definition at line 72 of file ITkPixelClusterOnTrackTool.cxx.

                                    {
 
  ATH_MSG_DEBUG(name() << " initialize()");
 
  m_errorStrategy = m_errorStrategyProperty;
  ATH_MSG_DEBUG("Error strategy is" << m_errorStrategy);
 
  m_applyNNcorrection = m_applyNNcorrectionProperty;
 
  ATH_CHECK(m_clusterITkErrorKey.initialize());
 
  ATH_CHECK(m_clusterSplitProbContainer.initialize( !m_clusterSplitProbContainer.key().empty()));
 
  // get the error scaling tool
  ATH_CHECK(m_pixelErrorScalingKey.initialize(!m_pixelErrorScalingKey.key().empty()));
  if (!m_pixelErrorScalingKey.key().empty()) ATH_MSG_DEBUG("Detected need for scaling Pixel errors.");
 
  ATH_CHECK (detStore()->retrieve(m_pixelid, "PixelID"));
 
  m_applyNNcorrection &= !m_splitClusterMapKey.key().empty();
  ATH_CHECK(m_splitClusterMapKey.initialize(m_applyNNcorrection));
  ATH_CHECK(m_NnClusterizationFactory.retrieve( DisableTool{!m_applyNNcorrection} ));
 
  ATH_CHECK(m_lorentzAngleTool.retrieve());
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & Trk::IRIO_OnTrackCreator::interfaceID ( )

inlinestaticinherited

The AlgTool InterfaceID.

Definition at line 43 of file IRIO_OnTrackCreator.h.

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_applyNNcorrection

bool ITk::PixelClusterOnTrackTool::m_applyNNcorrection {false}

private

Enable NN based calibration (do only if NN calibration is applied).

Definition at line 161 of file ITkPixelClusterOnTrackTool.h.

{false};

m_applyNNcorrectionProperty

BooleanProperty ITk::PixelClusterOnTrackTool::m_applyNNcorrectionProperty {this, "applyNNcorrection", false}

private

Definition at line 162 of file ITkPixelClusterOnTrackTool.h.

{this, "applyNNcorrection", false};

m_clusterITkErrorKey

SG::ReadCondHandleKey<ITk::PixelOfflineCalibData> ITk::PixelClusterOnTrackTool::m_clusterITkErrorKey {this, "ITkPixelOfflineCalibData", "ITkPixelOfflineCalibData", "Output key of ITk pixel cluster"}

private

Definition at line 131 of file ITkPixelClusterOnTrackTool.h.

{this, "ITkPixelOfflineCalibData", "ITkPixelOfflineCalibData", "Output key of ITk pixel cluster"};

m_clusterSplitProbContainer

SG::ReadHandleKey<Trk::ClusterSplitProbabilityContainer> ITk::PixelClusterOnTrackTool::m_clusterSplitProbContainer {this, "ClusterSplitProbabilityName", "",""}

private

Definition at line 176 of file ITkPixelClusterOnTrackTool.h.

{this, "ClusterSplitProbabilityName", "",""};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_doNotRecalibrateNN

BooleanProperty ITk::PixelClusterOnTrackTool::m_doNotRecalibrateNN {this, "doNotRecalibrateNN", false}

private

Definition at line 169 of file ITkPixelClusterOnTrackTool.h.

{this, "doNotRecalibrateNN", false};

m_errorStrategy

std::atomic_int ITk::PixelClusterOnTrackTool::m_errorStrategy {2}

mutableprivate

Definition at line 140 of file ITkPixelClusterOnTrackTool.h.

{2};

m_errorStrategyProperty

IntegerProperty ITk::PixelClusterOnTrackTool::m_errorStrategyProperty

private

Initial value:

{this, "ErrorStrategy", 2,
      "Which calibration of cluster position errors"}

Definition at line 141 of file ITkPixelClusterOnTrackTool.h.

                                         {this, "ErrorStrategy", 2,
      "Which calibration of cluster position errors"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_lorentzAngleTool

ToolHandle<ISiLorentzAngleTool> ITk::PixelClusterOnTrackTool::m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool", "Tool to retreive Lorentz angle"}

private

Definition at line 129 of file ITkPixelClusterOnTrackTool.h.

{this, "LorentzAngleTool", "SiLorentzAngleTool", "Tool to retreive Lorentz angle"};

m_NnClusterizationFactory

ToolHandle<InDet::NnClusterizationFactory> ITk::PixelClusterOnTrackTool::m_NnClusterizationFactory

private

Initial value:

{this, "NnClusterizationFactory",
    "InDet::NnClusterizationFactory/NnClusterizationFactory"}

NN clusterizationi factory for NN based positions and errors.

Definition at line 165 of file ITkPixelClusterOnTrackTool.h.

    {this, "NnClusterizationFactory",
    "InDet::NnClusterizationFactory/NnClusterizationFactory"};

m_noNNandBroadErrors

BooleanProperty ITk::PixelClusterOnTrackTool::m_noNNandBroadErrors {this, "noNNandBroadErrors", false}

private

Definition at line 170 of file ITkPixelClusterOnTrackTool.h.

{this, "noNNandBroadErrors", false};

m_pixelErrorScalingKey

SG::ReadCondHandleKey<RIO_OnTrackErrorScaling> ITk::PixelClusterOnTrackTool::m_pixelErrorScalingKey {this,"PixelErrorScalingKey", "/Indet/TrkErrorScalingPixel", "Key for pixel error scaling conditions data."}

private

Definition at line 133 of file ITkPixelClusterOnTrackTool.h.

{this,"PixelErrorScalingKey", "/Indet/TrkErrorScalingPixel", "Key for pixel error scaling conditions data."};

m_pixelid

const PixelID* ITk::PixelClusterOnTrackTool::m_pixelid = nullptr

private

Flag controlling how module distortions are taken into account:

case 0 -----> No distorsions implemented;

case 1 -----> Set curvature (in 1/meter) and twist (in radiant) equal for all modules;

case 2 -----> Read curvatures and twists from textfile containing Survey data;

case 3 -----> Set curvature and twist from Gaussian random generator with mean and RMS coming from Survey data;

case 4 -----> Read curvatures and twists from database (not ready yet); identifier-helper

Definition at line 158 of file ITkPixelClusterOnTrackTool.h.

m_positionStrategy

IntegerProperty ITk::PixelClusterOnTrackTool::m_positionStrategy

private

Initial value:

{this, "PositionStrategy", 1,
      "Which calibration of cluster positions"}

toolhandle for central error scaling flag storing if errors need scaling or should be kept nominal

Definition at line 138 of file ITkPixelClusterOnTrackTool.h.

                                    {this, "PositionStrategy", 1,
      "Which calibration of cluster positions"};

m_splitClusterMapKey

SG::ReadHandleKey<InDet::PixelGangedClusterAmbiguities> ITk::PixelClusterOnTrackTool::m_splitClusterMapKey {this, "SplitClusterAmbiguityMap", ""}

private

Definition at line 173 of file ITkPixelClusterOnTrackTool.h.

{this, "SplitClusterAmbiguityMap", ""};

m_usingTIDE_Ambi

BooleanProperty ITk::PixelClusterOnTrackTool::m_usingTIDE_Ambi {this, "RunningTIDE_Ambi", false}

private

Enable different treatment of cluster errors based on NN information (do only if TIDE ambi is run).

Definition at line 172 of file ITkPixelClusterOnTrackTool.h.

{this, "RunningTIDE_Ambi", false};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

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

• ITkPixelClusterOnTrackTool.h
• ITkPixelClusterOnTrackTool.cxx