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. More...
virtual	~PixelClusterOnTrackTool ()=default
virtual StatusCode	initialize () override
	AlgTool initialisation. More...
virtual InDet::PixelClusterOnTrack *	correct (const Trk::PrepRawData &, const Trk::TrackParameters &) const override
	produces a PixelClusterOnTrack (object factory!). More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

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

Protected Member Functions
InDet::PixelClusterOnTrack *	correctDefault (const Trk::PrepRawData &, const Trk::TrackParameters &) const
	The correct method produces a PixelClusterOnTrack using the measured PixelCluster and the track prediction. More...
InDet::PixelClusterOnTrack *	correctNN (const Trk::PrepRawData &, const Trk::TrackParameters &) const
bool	getErrorsDefaultAmbi (const InDet::PixelCluster *, const Trk::TrackParameters &, Amg::Vector2D &, Amg::MatrixX &) const
bool	getErrorsTIDE_Ambi (const InDet::PixelCluster *, const Trk::TrackParameters &, Amg::Vector2D &, Amg::MatrixX &) const
InDet::PixelClusterOnTrack *	correct (const Trk::PrepRawData &, const Trk::TrackParameters &, const ITk::PixelClusterStrategy) const
const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &	getClusterSplittingProbability (const InDet::PixelCluster *pix) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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."}
int	m_positionStrategy
	toolhandle for central error scaling flag storing if errors need scaling or should be kept nominal More...
std::atomic_int	m_errorStrategy {2}
IntegerProperty	m_errorStrategyProperty {this, "ErrorStrategy", 2, "Which calibration of cluster position errors"}
const PixelID *	m_pixelid
	Flag controlling how module distortions are taken into account: More...
bool	m_applyNNcorrection {false}
	Enable NN based calibration (do only if NN calibration is applied) More...
BooleanProperty	m_applyNNcorrectionProperty {this, "applyNNcorrection", false}
ToolHandle< InDet::NnClusterizationFactory >	m_NnClusterizationFactory
	NN clusterizationi factory for NN based positions and errors. More...
bool	m_doNotRecalibrateNN
bool	m_noNNandBroadErrors
bool	m_usingTIDE_Ambi
	Enable different treatment of cluster errors based on NN information (do only if TIDE ambi is run) More...
SG::ReadHandleKey< InDet::PixelGangedClusterAmbiguities >	m_splitClusterMapKey
SG::ReadHandleKey< Trk::ClusterSplitProbabilityContainer >	m_clusterSplitProbContainer {this, "ClusterSplitProbabilityName", "",""}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 59 of file ITkPixelClusterOnTrackTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 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),
  m_pixelid(nullptr),
  m_NnClusterizationFactory("InDet::NnClusterizationFactory/NnClusterizationFactory", this),
  m_doNotRecalibrateNN(false),
  m_noNNandBroadErrors(false),
  m_usingTIDE_Ambi(false),
  m_splitClusterMapKey("")
  {
  declareInterface<IRIO_OnTrackCreator>(this);
 
  declareProperty("PositionStrategy", m_positionStrategy = 1, "Which calibration of cluster positions");
  declareProperty("NnClusterizationFactory", m_NnClusterizationFactory);
  declareProperty("SplitClusterAmbiguityMap", m_splitClusterMapKey);//Remove Later
  declareProperty("doNotRecalibrateNN", m_doNotRecalibrateNN);
  declareProperty("m_noNNandBroadErrors", m_noNNandBroadErrors);
  declareProperty("RunningTIDE_Ambi", m_usingTIDE_Ambi);
}

~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

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 119 of file ITkPixelClusterOnTrackTool.cxx.

                                                                        {
 
  if (not m_applyNNcorrection){
    return correctDefault(rio, trackPar);
  }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);
      if (splitProb.isSplit()) {
        return correctNN(rio, trackPar);
      } else {
        return correctDefault(rio, trackPar);
      }
    } else {
      return correctNN(rio, trackPar);
    }
  }
}

correct() [2/2]

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

protected

Definition at line 361 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);
    m_errorStrategy = initial_errorStrategy;
    return newROT;
 
  default:
    return correct(rio, trackPar);
  }
}

correctDefault()

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

protected

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

Definition at line 156 of file ITkPixelClusterOnTrackTool.cxx.

                                                                        {
  using CLHEP::micrometer;
 
 
  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 iH = 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 =
      dynamic_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(iH);
    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(iH);
    int nrows = rowmax - rowmin + 1;
    int ncol = colmax - colmin + 1;
 
    // TOT interpolation for collision data
    SG::ReadCondHandle<ITk::PixelOfflineCalibData> offlineITkCalibDataHandle(m_clusterITkErrorKey);
 
    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(&element_id,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) {
      errphi = 250 * micrometer * std::tan(std::abs(angle)) * TOPHAT_SIGMA;
      erreta = width.z() > 250 * micrometer * std::tan(std::abs(boweta)) ?
               width.z() * TOPHAT_SIGMA : 250 * micrometer * 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(&element_id);
      errphi = nrows != 1 ? delta_err.first : (width.phiR()/nrows)*TOPHAT_SIGMA;
      erreta = ncol != 1 ? delta_err.second : (width.z()/ncol)*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 );
    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),
                                        iH, glob, pix->gangedPixel(), isbroad);
}

correctNN()

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

protected

Definition at line 383 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 iH = 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), iH, glob,
                                          pixelPrepCluster->gangedPixel(), false);
  }
 
 
 
  Amg::Vector2D finalposition;
  Amg::MatrixX finalerrormatrix;
 
  if (m_usingTIDE_Ambi) {
    if (!getErrorsTIDE_Ambi(pixelPrepCluster, trackPar, finalposition, finalerrormatrix)) {
      return correctDefault(rio, trackPar);
    }
  }else {
    if (!getErrorsDefaultAmbi(pixelPrepCluster, trackPar, finalposition, finalerrormatrix)) {
      return correctDefault(rio, trackPar);
    }
  }
 
  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 = finalerrormatrix;
  // create new copy of error matrix
  if (!m_pixelErrorScalingKey.key().empty()) {
    SG::ReadCondHandle<RIO_OnTrackErrorScaling> error_scaling( m_pixelErrorScalingKey );
    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), iH,
                                        glob,
                                        pixelPrepCluster->gangedPixel(),
                                        false);
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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() [1/2]

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; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 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

inlineprotected

Definition at line 108 of file ITkPixelClusterOnTrackTool.h.

                                                                    {
   if (!pix || m_clusterSplitProbContainer.key().empty())
     return Trk::ClusterSplitProbabilityContainer::getNoSplitProbability();
 
   SG::ReadHandle<Trk::ClusterSplitProbabilityContainer> splitProbContainer(
       m_clusterSplitProbContainer);
   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

protected

Definition at line 467 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);
    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

protected

Definition at line 615 of file ITkPixelClusterOnTrackTool.cxx.

                                                                                {
  const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &splitProb = getClusterSplittingProbability(pixelPrepCluster);
  std::vector<Amg::Vector2D> vectorOfPositions;
  int numberOfSubclusters = 1;
  if(m_applyNNcorrection){
    SG::ReadHandle<InDet::PixelGangedClusterAmbiguities> splitClusterMap(m_splitClusterMapKey);
    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 85 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()

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

inlinestaticinherited

The AlgTool InterfaceID.

Definition at line 41 of file IRIO_OnTrackCreator.h.

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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 380 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 364 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    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 157 of file ITkPixelClusterOnTrackTool.h.

m_applyNNcorrectionProperty

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

private

Definition at line 158 of file ITkPixelClusterOnTrackTool.h.

m_clusterITkErrorKey

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

private

Definition at line 129 of file ITkPixelClusterOnTrackTool.h.

m_clusterSplitProbContainer

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

private

Definition at line 169 of file ITkPixelClusterOnTrackTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doNotRecalibrateNN

bool ITk::PixelClusterOnTrackTool::m_doNotRecalibrateNN

private

Definition at line 163 of file ITkPixelClusterOnTrackTool.h.

m_errorStrategy

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

mutableprivate

Definition at line 137 of file ITkPixelClusterOnTrackTool.h.

m_errorStrategyProperty

IntegerProperty ITk::PixelClusterOnTrackTool::m_errorStrategyProperty {this, "ErrorStrategy", 2, "Which calibration of cluster position errors"}

private

Definition at line 138 of file ITkPixelClusterOnTrackTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_lorentzAngleTool

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

private

Definition at line 127 of file ITkPixelClusterOnTrackTool.h.

m_NnClusterizationFactory

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

private

NN clusterizationi factory for NN based positions and errors.

Definition at line 161 of file ITkPixelClusterOnTrackTool.h.

m_noNNandBroadErrors

bool ITk::PixelClusterOnTrackTool::m_noNNandBroadErrors

private

Definition at line 164 of file ITkPixelClusterOnTrackTool.h.

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 131 of file ITkPixelClusterOnTrackTool.h.

m_pixelid

const PixelID* ITk::PixelClusterOnTrackTool::m_pixelid

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 154 of file ITkPixelClusterOnTrackTool.h.

m_positionStrategy

int ITk::PixelClusterOnTrackTool::m_positionStrategy

private

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

Definition at line 136 of file ITkPixelClusterOnTrackTool.h.

m_splitClusterMapKey

SG::ReadHandleKey<InDet::PixelGangedClusterAmbiguities> ITk::PixelClusterOnTrackTool::m_splitClusterMapKey

private

Definition at line 167 of file ITkPixelClusterOnTrackTool.h.

m_usingTIDE_Ambi

bool ITk::PixelClusterOnTrackTool::m_usingTIDE_Ambi

private

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

Definition at line 166 of file ITkPixelClusterOnTrackTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• ITkPixelClusterOnTrackTool.h
• ITkPixelClusterOnTrackTool.cxx