Trk::TrackSummaryTool Class Reference

#include <TrackSummaryTool.h>

Inheritance diagram for Trk::TrackSummaryTool:

Collaboration diagram for Trk::TrackSummaryTool:

Public Member Functions
	TrackSummaryTool (const std::string &, const std::string &, const IInterface *)
virtual	~TrackSummaryTool ()
virtual StatusCode	initialize () override
virtual void	computeAndReplaceTrackSummary (const EventContext &ctx, Track &track, bool suppress_hole_search=false) const override final
virtual void	updateTrack (const EventContext &ctx, Track &track) const override final
	Same behavious as IExtendedTrackSummaryTool:computeAndReplaceTrackSummary but without the need to pass Does hole search. More...
virtual std::unique_ptr< Trk::TrackSummary >	summary (const EventContext &ctx, const Track &track) const override final
virtual std::unique_ptr< Trk::TrackSummary >	summaryNoHoleSearch (const EventContext &ctx, const Track &track) const override final
virtual void	updateTrackSummary (const EventContext &ctx, Track &track) const override final
	method which can be used to update the summary of a track it, without doing hole search. More...
virtual void	updateTrackSummary (const EventContext &ctx, Track &track, bool suppress_hole_search=false) const override final
	method which can be used to update the summary of a track If a summary is present it is modified in place. More...
virtual void	updateAdditionalInfo (Track &track) const override
	method to update additional information (PID, dEdX), this is optimised for track collection merging. More...
virtual void	computeAndReplaceTrackSummary (const EventContext &ctx, Track &track, bool suppress_hole_search=false) const=0
	Compute track summary and replace the summary in given track. More...
void	computeAndReplaceTrackSummary (Track &track, bool suppress_hole_search=false) const
	Compute track summary and replace the summary in given track. More...
virtual std::unique_ptr< Trk::TrackSummary >	summary (const EventContext &ctx, const Track &track) const=0
std::unique_ptr< Trk::TrackSummary >	summary (const Track &track) const
virtual std::unique_ptr< Trk::TrackSummary >	summary (const EventContext &ctx, const Track &track) const =0
std::unique_ptr< Trk::TrackSummary >	summary (const Track &track) const
virtual std::unique_ptr< Trk::TrackSummary >	summaryNoHoleSearch (const EventContext &ctx, const Track &track) const=0
std::unique_ptr< Trk::TrackSummary >	summaryNoHoleSearch (const Track &track) const
virtual std::unique_ptr< Trk::TrackSummary >	summaryNoHoleSearch (const EventContext &ctx, const Track &track) const =0
std::unique_ptr< Trk::TrackSummary >	summaryNoHoleSearch (const Track &track) const

Private Member Functions
void	fillSummary (const EventContext &ctx, Trk::TrackSummary &ts, const Trk::Track &track, bool doHolesInDet, bool doHolesMuon) const
void	UpdateSummary (const EventContext &ctx, Track &track, bool suppress_hole_search) const
std::unique_ptr< Trk::TrackSummary >	createSummary (const EventContext &ctx, const Track &track, bool doHolesInDet, bool doHolesMuon) const
const Trk::IExtendedTrackSummaryHelperTool *	getTool (const Identifier &id) const
	Return the correct tool, matching the passed Identifier. More...
void	processTrackStates (const EventContext &ctx, const Track &track, const Trk::TrackStates *tsos, std::vector< int > &information, std::bitset< numberOfDetectorTypes > &hitPattern, bool doHolesInDet, bool doHolesMuon) const
	loops over TrackStatesOnSurface and uses this to produce the summary information Fills 'information', 'eProbability', and 'hitPattern' More...
void	processMeasurement (const EventContext &ctx, const Track &track, const Trk::MeasurementBase *meas, const Trk::TrackStateOnSurface *tsos, std::vector< int > &information, std::bitset< numberOfDetectorTypes > &hitPattern) const
void	searchHolesStepWise (const Trk::Track &track, std::vector< int > &information, bool doHolesInDet, bool doHolesMuon) const
	Extrapolation is performed from one hit to the next, it is checked if surfaces in between the extrapolation are left out. More...

Private Attributes
ToolHandle< IExtendedTrackSummaryHelperTool >	m_idTool { this, "InDetSummaryHelperTool", "", "" }
	tool to decipher ID RoTs More...
ToolHandle< IExtendedTrackSummaryHelperTool >	m_muonTool { this, "MuonSummaryHelperTool", "", "" }
	tool to decipher muon RoTs More...
Gaudi::Property< bool >	m_doHolesMuon { this, "doHolesMuon", false, "" }
	controls whether holes on track in MS are produced Turning this on will (slightly) increase processing time. More...
Gaudi::Property< bool >	m_doHolesInDet { this, "doHolesInDet", false, "" }
	controls whether holes on track in ID are produced More...
Gaudi::Property< bool >	m_addMuonDetailedSummary
	controls whether the detailed summary is added for the muons More...
Gaudi::Property< bool >	m_pixelExists { this, "PixelExists", true, "" }
	switch to deactivate Pixel info init More...
Gaudi::Property< bool >	m_alwaysRecomputeHoles
const AtlasDetectorID *	m_detID
	atlas id helper More...

Detailed Description

Definition at line 42 of file TrackSummaryTool.h.

Constructor & Destructor Documentation

TrackSummaryTool()

Trk::TrackSummaryTool::TrackSummaryTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 52 of file TrackSummaryTool.cxx.

  : base_class(t, n, p)
  , m_detID{}
{
  declareInterface<ITrackSummaryTool>(this);
}

~TrackSummaryTool()

Trk::TrackSummaryTool::~TrackSummaryTool ( )

virtualdefault

Member Function Documentation

computeAndReplaceTrackSummary() [1/3]

void Trk::TrackSummaryTool::computeAndReplaceTrackSummary ( const EventContext &  ctx, Trk::Track &  track, bool  suppress_hole_search = false  ) const

finaloverridevirtual

Definition at line 96 of file TrackSummaryTool.cxx.

{
  track.setTrackSummary(createSummary(ctx,
                                      track,
                                      m_doHolesInDet & !suppress_hole_search,
                                      m_doHolesMuon & !suppress_hole_search));
}

computeAndReplaceTrackSummary() [2/3]

virtual void Trk::IExtendedTrackSummaryTool::computeAndReplaceTrackSummary

Compute track summary and replace the summary in given track.

Parameters

track	the track whose track summary is replaced with a newly computed one
suppress_hole_search	do not perform the hole search independent of the settings of the ID and muon hole search properties. Will recompute the track summary for the given track, delete the old track summary of the track if there is already one and set the new one. The hole search is performed according to the settings of the ID and muon hole search properties unless the suppress_hole_search argument is true.

computeAndReplaceTrackSummary() [3/3]

void Trk::IExtendedTrackSummaryTool::computeAndReplaceTrackSummary

Compute track summary and replace the summary in given track.

Parameters

track	the track whose track summary is replaced with a newly computed one
suppress_hole_search	do not perform the hole search independent of the settings of the ID and muon hole search properties. Will recompute the track summary for the given track, delete the old track summary of the track if there is already one and set the new one. The hole search is performed according to the settings of the ID and muon hole search properties unless the suppress_hole_search argument is true.

createSummary()

std::unique_ptr< Trk::TrackSummary > Trk::TrackSummaryTool::createSummary ( const EventContext &  ctx, const Track &  track, bool  doHolesInDet, bool  doHolesMuon  ) const

private

Definition at line 136 of file TrackSummaryTool.cxx.

{
  std::unique_ptr<Trk::TrackSummary> ts;
  // first check if track has summary already and then clone it.
  if (track.trackSummary() != nullptr) {
    ts = std::make_unique<Trk::TrackSummary>(*(track.trackSummary()));
  } else {
    ts = std::make_unique<Trk::TrackSummary>();
  }
  // fill the summary
  fillSummary(ctx, *ts, track, doHolesInDet, doHolesMuon);
  return ts;
}

fillSummary()

void Trk::TrackSummaryTool::fillSummary ( const EventContext &  ctx, Trk::TrackSummary &  ts, const Trk::Track &  track, bool  doHolesInDet, bool  doHolesMuon  ) const

private

Definition at line 160 of file TrackSummaryTool.cxx.

{
  // Resize the vector where we will keep the information needed for the summary
  std::vector<int>& information = ts.m_information;
  information.resize(std::min(information.size(),
                              static_cast<size_t>(numberOfTrackSummaryTypes)));
 
  constexpr int toZero{ 0 };
  if (!m_idTool.empty()) {
    if (m_pixelExists) {
      // Pixel counters set to 0
      constexpr size_t numberOfPixelCounters{ 8 };
      constexpr std::array<size_t, numberOfPixelCounters> atPixelIndices{
        numberOfContribPixelLayers,
        numberOfInnermostPixelLayerHits,
        numberOfNextToInnermostPixelLayerHits,
        numberOfPixelHits,
        numberOfGangedPixels,
        numberOfGangedFlaggedFakes,
        numberOfPixelSpoiltHits,
        numberOfGangedFlaggedFakes
      };
      setTheseElements(information, atPixelIndices, toZero);
      information[Trk::numberOfDBMHits] = 0;
 
    }
    // SCT and TRT counters set to 0
    constexpr size_t numberOfSctOrTrtCounters{ 9 };
    constexpr std::array<size_t, numberOfSctOrTrtCounters> atSctOrTrtIndices{
      numberOfSCTHits,
      numberOfSCTSpoiltHits,
      numberOfTRTHits,
      numberOfTRTXenonHits,
      numberOfTRTHighThresholdHits,
      numberOfTRTHighThresholdHitsTotal,
      numberOfTRTOutliers,
      numberOfTRTHighThresholdOutliers,
      numberOfTRTTubeHits
    };
    setTheseElements(information, atSctOrTrtIndices, toZero);
  }
 
  if (!m_muonTool.empty()) {
    // Muon counters set to 0
    constexpr size_t numberOfMuonRelatedCounters{ 15 };
    constexpr std::array<size_t, numberOfMuonRelatedCounters> atMuonIndices{
      numberOfMdtHits,          numberOfTgcPhiHits,
      numberOfTgcEtaHits,       numberOfCscPhiHits,
      numberOfCscEtaHits,       numberOfCscUnspoiltEtaHits,
      numberOfRpcPhiHits,       numberOfRpcEtaHits,
      Trk::numberOfMdtHoles,    Trk::numberOfTgcEtaHoles,
      Trk::numberOfTgcPhiHoles, Trk::numberOfCscEtaHoles,
      Trk::numberOfCscPhiHoles, Trk::numberOfRpcEtaHoles,
      Trk::numberOfRpcPhiHoles,
    };
    // New Small Wheel counters set to 0
    constexpr size_t numberOfNswRelatedCounters{ 6 };
    constexpr std::array<size_t, numberOfNswRelatedCounters> atNswIndices{
      Trk::numberOfStgcEtaHits,  Trk::numberOfStgcPhiHits,  Trk::numberOfMmHits,
      Trk::numberOfStgcEtaHoles, Trk::numberOfStgcPhiHoles, Trk::numberOfMmHoles
    };
    setTheseElements(information, atMuonIndices, toZero);
    setTheseElements(information, atNswIndices, toZero);
  }
 
  // update the summart counters processing the track states
  std::bitset<numberOfDetectorTypes> hitPattern;
  if (track.trackStateOnSurfaces()) {
    information[Trk::numberOfOutliersOnTrack] = 0;
    processTrackStates(ctx,
                       track,
                       track.trackStateOnSurfaces(),
                       information,
                       hitPattern,
                       doHolesInDet,
                       doHolesMuon);
  } else {
    ATH_MSG_WARNING("Null pointer to TSoS found on Track (author = "
                    << track.info().dumpInfo()
                    << "). This should never happen! ");
  }
  ts.m_idHitPattern = hitPattern.to_ulong();
 
  //Now the possible additional summary steps
  // Is the hole search done , could be there in the input already
  bool holeSearchDone = (information[Trk::numberOfPixelHoles] != -1 &&
                         information[Trk::numberOfSCTHoles] != -1 &&
                         information[Trk::numberOfSCTDoubleHoles] != -1 &&
                         information[Trk::numberOfPixelDeadSensors] != -1 &&
                         information[Trk::numberOfSCTDeadSensors] != -1);
 
  // Do the holes search if we have to or insist to
  if ((doHolesInDet || doHolesMuon) &&
      (!holeSearchDone || m_alwaysRecomputeHoles.value())) {
    if (m_pixelExists) {
      information[numberOfPixelHoles] = 0;
    }
    information[numberOfSCTHoles] = 0;
    information[numberOfSCTDoubleHoles] = 0;
    searchHolesStepWise(track, information, doHolesInDet, doHolesMuon);
  }
 
  // add detailed summary for muons
  if (m_addMuonDetailedSummary && !m_muonTool.empty()) {
    m_muonTool->addDetailedTrackSummary(ctx, track, ts);
  }
}

getTool()

const Trk::IExtendedTrackSummaryHelperTool * Trk::TrackSummaryTool::getTool ( const Identifier &  id ) const

private

Return the correct tool, matching the passed Identifier.

Definition at line 406 of file TrackSummaryTool.cxx.

{
  if (m_detID->is_indet(id)) {
    if (!m_idTool.empty()) {
      return &*m_idTool;
    }
    ATH_MSG_WARNING("getTool: Identifier is from ID but have no ID tool");
  } else if (m_detID->is_muon(id)) {
    if (!m_muonTool.empty()) {
      return &*m_muonTool;
    }
    ATH_MSG_WARNING("getTool: Identifier is from Muon but have no Muon tool");
  } else {
    ATH_MSG_WARNING(
      "getTool: Identifier is of unknown type! id: " << id.getString());
  }
  return nullptr;
}

initialize()

StatusCode Trk::TrackSummaryTool::initialize ( )

overridevirtual

Definition at line 64 of file TrackSummaryTool.cxx.

{
  ATH_CHECK(detStore()->retrieve(m_detID, "AtlasID"));
  if (m_idTool.empty() && m_muonTool.empty()) {
    ATH_MSG_WARNING("Could get neither InDetHelperTool nor MuonHelperTool.");
  }
  if (not m_idTool.empty()) {
    ATH_CHECK(m_idTool.retrieve());
  }
  if (not m_muonTool.empty()) {
    ATH_CHECK(m_muonTool.retrieve());
  }
  if(m_doHolesInDet){
    ATH_MSG_INFO("Search for InDet holes ON");
  }
  if(m_doHolesMuon){
    ATH_MSG_INFO("Search for Muon holes ON");
  }
  return StatusCode::SUCCESS;
}

processMeasurement()

void Trk::TrackSummaryTool::processMeasurement ( const EventContext &  ctx, const Track &  track, const Trk::MeasurementBase *  meas, const Trk::TrackStateOnSurface *  tsos, std::vector< int > &  information, std::bitset< numberOfDetectorTypes > &  hitPattern  ) const

private

Definition at line 362 of file TrackSummaryTool.cxx.

{
  // Check if the measurement type is RIO on Track (ROT)
  const RIO_OnTrack* rot = nullptr;
  if (meas->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
    rot = static_cast<const RIO_OnTrack*>(meas);
  }
  if (rot) {
    // have RIO_OnTrack
    const Trk::IExtendedTrackSummaryHelperTool* tool = getTool(rot->identify());
    if (tool == nullptr) {
      ATH_MSG_WARNING("Cannot find tool to match ROT. Skipping.");
    } else {
      tool->analyse(
        ctx, track, rot, tsos, information, hitPattern);
    }
  } else {
    // check if the measurement type is CompetingRIOsOnTrack
    const Trk::CompetingRIOsOnTrack* compROT = nullptr;
    if (meas->type(Trk::MeasurementBaseType::CompetingRIOsOnTrack)) {
      compROT = static_cast<const CompetingRIOsOnTrack*>(meas);
    }
    if (compROT) {
      // if this works we have a CompetingRIOsOnTrack.
      rot = &compROT->rioOnTrack(0); // get 1st rot
      const Trk::IExtendedTrackSummaryHelperTool* tool =
        getTool(rot->identify()); // Use 'main' ROT to get detector type
      if (tool == nullptr) {
        ATH_MSG_WARNING("Cannot find tool to match cROT. Skipping.");
      } else {
        tool->analyse(
          ctx, track, compROT, tsos, information, hitPattern);
      }
    }
  }
}

processTrackStates()

void Trk::TrackSummaryTool::processTrackStates ( const EventContext &  ctx, const Track &  track, const Trk::TrackStates *  tsos, std::vector< int > &  information, std::bitset< numberOfDetectorTypes > &  hitPattern, bool  doHolesInDet, bool  doHolesMuon  ) const

private

loops over TrackStatesOnSurface and uses this to produce the summary information Fills 'information', 'eProbability', and 'hitPattern'

Definition at line 276 of file TrackSummaryTool.cxx.

{
  int cntAddChi2 = 0;
  float chi2Sum = 0;
  float chi2Sum2 = 0;
  Trk::TrackStates::const_iterator it = tsos->begin();
  Trk::TrackStates::const_iterator itEnd = tsos->end();
  for (; it != itEnd; ++it) {
    const auto& trackState = **it;
    const auto isMeasurement =
      trackState.type(Trk::TrackStateOnSurface::Measurement);
    const auto isOutlier = trackState.type(Trk::TrackStateOnSurface::Outlier);
    if (isMeasurement or isOutlier) {
      const Trk::MeasurementBase* measurement = trackState.measurementOnTrack();
      if (!measurement) {
        ATH_MSG_WARNING("measurementOnTrack == null for a TrackStateOnSurface "
                        "of type Measurement or Outlier");
      } else {
        if (isOutlier)
          ++information[Trk::numberOfOutliersOnTrack]; // increment outlier
                                                       // counter
        processMeasurement(
          ctx, track, measurement, *it, information, hitPattern);
      } // if have measurement pointer
    }   // if type measurement, scatterer or outlier
 
    if (isMeasurement) {
      if (const auto& pFitQuality{ trackState.fitQualityOnSurface() };
          pFitQuality and pFitQuality.numberDoF() > 0) {
        ++cntAddChi2;
        if (const auto& chiSq{ pFitQuality.chiSquared() };
            chiSq > 1.e5) { // limit unphysical values and protect against FPE
          chi2Sum += 1.e5;
          chi2Sum2 += 1.e10;
        } else {
          const float chi2add = chiSq / pFitQuality.numberDoF();
          chi2Sum += chi2add;
          chi2Sum2 += chi2add * chi2add;
        }
      }
    }
 
    if (trackState.type(Trk::TrackStateOnSurface::Hole) &&
        trackState.trackParameters()) {
      if (!doHolesInDet ||
          !doHolesMuon) { // no dedicated hole search via extrapolation, but
                          // take what might be on the track already.
        if (trackState.trackParameters()
              ->associatedSurface()
              .associatedDetectorElement() != nullptr) {
          const Identifier& id = trackState.trackParameters()
                                   ->associatedSurface()
                                   .associatedDetectorElementIdentifier();
          if (!doHolesInDet && m_detID->is_pixel(id))
            ++information[Trk::numberOfPixelHoles];
          if (!doHolesInDet && m_detID->is_sct(id))
            ++information[Trk::numberOfSCTHoles];
          if (!doHolesMuon && m_detID->is_mdt(id))
            ++information[Trk::numberOfMdtHoles];
        }
      }
    }
  }
 
  float varChi2 = 0;
  if (cntAddChi2 > 0) {
    const auto inverseCount{ 1. / cntAddChi2 };
    varChi2 = (chi2Sum2 - (chi2Sum * chi2Sum * inverseCount)) * inverseCount;
  }
  if (varChi2 > 0 && varChi2 < 1.e13)
    information[Trk::standardDeviationOfChi2OS] = int(std::sqrt(varChi2) * 100);
}

searchHolesStepWise()

void Trk::TrackSummaryTool::searchHolesStepWise ( const Trk::Track &  track, std::vector< int > &  information, bool  doHolesInDet, bool  doHolesMuon  ) const

private

Extrapolation is performed from one hit to the next, it is checked if surfaces in between the extrapolation are left out.

The trackParameters of the destination hit (instead of the trackParameters of the extrapolation step) are then used as starting point for the next extrapolation step.

Definition at line 426 of file TrackSummaryTool.cxx.

{
  ATH_MSG_VERBOSE("Entering Trk::TrackSummaryTool::searchHolesStepWise");
  // -------- obtain hits in Pixel and SCT only
  if (track.trackStateOnSurfaces() == nullptr) {
    constexpr int toMinusOne{ -1 };
    constexpr std::array<size_t, 16> atIndices{ numberOfPixelHoles,
                                                numberOfPixelDeadSensors,
                                                numberOfSCTHoles,
                                                numberOfSCTDoubleHoles,
                                                numberOfSCTDeadSensors,
                                                numberOfTRTHoles,
                                                numberOfTRTDeadStraws,
                                                numberOfCscEtaHoles,
                                                numberOfCscPhiHoles,
                                                numberOfRpcEtaHoles,
                                                numberOfRpcPhiHoles,
                                                numberOfTgcEtaHoles,
                                                numberOfTgcPhiHoles,
                                                // new small wheels
                                                numberOfStgcEtaHoles,
                                                numberOfStgcPhiHoles,
                                                numberOfMmHoles };
    setTheseElements(information, atIndices, toMinusOne);
    return;
  }
 
  constexpr int toZero{ 0 };
  if (doHolesInDet) {
    // -------- perform the InDet hole search
    if (m_pixelExists) {
      setTheseElements(
        information, { numberOfPixelHoles, numberOfPixelDeadSensors }, toZero);
    }
    setTheseElements(
      information,
      { numberOfSCTHoles, numberOfSCTDoubleHoles, numberOfSCTDeadSensors },
      toZero);
    m_idTool->searchForHoles(track, information, Trk::pion);
  }
  if (!m_muonTool.empty() && doHolesMuon) {
    // now do Muon hole search. It works completely differently to the above,
    // so we need to make this all a bit more general
    // and probably more efficient. But this hopefully works for now! EJWM
    constexpr size_t numberOfRelatedMuonCounters{ 10 };
    constexpr std::array<size_t, numberOfRelatedMuonCounters> atMuonIndices{
      numberOfMdtHoles,
      numberOfCscEtaHoles,
      numberOfCscPhiHoles,
      numberOfRpcEtaHoles,
      numberOfRpcPhiHoles,
      numberOfTgcEtaHoles,
      numberOfTgcPhiHoles,
      // new small wheels
      numberOfStgcEtaHoles,
      numberOfStgcPhiHoles,
      numberOfMmHoles
    };
    setTheseElements(information, atMuonIndices, toZero);
    m_muonTool->searchForHoles(track, information, Trk::muon);
  }
}

summary() [1/5]

virtual std::unique_ptr<Trk::TrackSummary> Trk::ITrackSummaryTool::summary

summary() [2/5]

std::unique_ptr< Trk::TrackSummary > Trk::TrackSummaryTool::summary ( const EventContext &  ctx, const Track &  track  ) const

finaloverridevirtual

Definition at line 112 of file TrackSummaryTool.cxx.

{
  return createSummary(
    ctx, track, m_doHolesInDet, m_doHolesMuon);
}

summary() [3/5]

virtual std::unique_ptr<Trk::TrackSummary> Trk::IExtendedTrackSummaryTool::summary

summary() [4/5]

std::unique_ptr<Trk::TrackSummary> Trk::ITrackSummaryTool::summary

summary() [5/5]

std::unique_ptr<Trk::TrackSummary> Trk::IExtendedTrackSummaryTool::summary

summaryNoHoleSearch() [1/5]

virtual std::unique_ptr<Trk::TrackSummary> Trk::ITrackSummaryTool::summaryNoHoleSearch

summaryNoHoleSearch() [2/5]

std::unique_ptr< Trk::TrackSummary > Trk::TrackSummaryTool::summaryNoHoleSearch ( const EventContext &  ctx, const Track &  track  ) const

finaloverridevirtual

Definition at line 125 of file TrackSummaryTool.cxx.

{
  return createSummary(ctx, track, false, false);
}

summaryNoHoleSearch() [3/5]

virtual std::unique_ptr<Trk::TrackSummary> Trk::IExtendedTrackSummaryTool::summaryNoHoleSearch

summaryNoHoleSearch() [4/5]

std::unique_ptr<Trk::TrackSummary> Trk::IExtendedTrackSummaryTool::summaryNoHoleSearch

summaryNoHoleSearch() [5/5]

std::unique_ptr<Trk::TrackSummary> Trk::ITrackSummaryTool::summaryNoHoleSearch

updateAdditionalInfo()

virtual void Trk::TrackSummaryTool::updateAdditionalInfo ( Track &  track ) const

overridevirtual

method to update additional information (PID, dEdX), this is optimised for track collection merging.

UpdateSummary()

void Trk::TrackSummaryTool::UpdateSummary ( const EventContext &  ctx, Track &  track, bool  suppress_hole_search  ) const

private

updateTrack()

virtual void Trk::TrackSummaryTool::updateTrack ( const EventContext &  ctx, Track &  track  ) const

finaloverridevirtual

Same behavious as IExtendedTrackSummaryTool:computeAndReplaceTrackSummary but without the need to pass Does hole search.

updateTrackSummary() [1/2]

virtual void Trk::TrackSummaryTool::updateTrackSummary ( const EventContext &  ctx, Track &  track  ) const

finaloverridevirtual

method which can be used to update the summary of a track it, without doing hole search.

If a summary is present it is modified in place. Otherwise a new one is created and filled.

updateTrackSummary() [2/2]

virtual void Trk::TrackSummaryTool::updateTrackSummary ( const EventContext &  ctx, Track &  track, bool  suppress_hole_search = false  ) const

finaloverridevirtual

method which can be used to update the summary of a track If a summary is present it is modified in place.

Otherwise a new one is created and filled.

Member Data Documentation

m_addMuonDetailedSummary

Gaudi::Property<bool> Trk::TrackSummaryTool::m_addMuonDetailedSummary

private

Initial value:

{ this,
                                                  "AddDetailedMuonSummary",
                                                  true,
                                                  "" }

controls whether the detailed summary is added for the muons

Definition at line 159 of file TrackSummaryTool.h.

m_alwaysRecomputeHoles

Gaudi::Property<bool> Trk::TrackSummaryTool::m_alwaysRecomputeHoles

private

Initial value:

{ this,
                                                "AlwaysRecomputeHoles",
                                                false,
                                                "" }

Definition at line 166 of file TrackSummaryTool.h.

m_detID

const AtlasDetectorID* Trk::TrackSummaryTool::m_detID

private

atlas id helper

Definition at line 172 of file TrackSummaryTool.h.

m_doHolesInDet

Gaudi::Property<bool> Trk::TrackSummaryTool::m_doHolesInDet { this, "doHolesInDet", false, "" }

private

controls whether holes on track in ID are produced

Definition at line 156 of file TrackSummaryTool.h.

m_doHolesMuon

Gaudi::Property<bool> Trk::TrackSummaryTool::m_doHolesMuon { this, "doHolesMuon", false, "" }

private

controls whether holes on track in MS are produced Turning this on will (slightly) increase processing time.

Definition at line 154 of file TrackSummaryTool.h.

m_idTool

ToolHandle<IExtendedTrackSummaryHelperTool> Trk::TrackSummaryTool::m_idTool { this, "InDetSummaryHelperTool", "", "" }

private

tool to decipher ID RoTs

Definition at line 147 of file TrackSummaryTool.h.

m_muonTool

ToolHandle<IExtendedTrackSummaryHelperTool> Trk::TrackSummaryTool::m_muonTool { this, "MuonSummaryHelperTool", "", "" }

private

tool to decipher muon RoTs

Definition at line 150 of file TrackSummaryTool.h.

m_pixelExists

Gaudi::Property<bool> Trk::TrackSummaryTool::m_pixelExists { this, "PixelExists", true, "" }

private

switch to deactivate Pixel info init

Definition at line 164 of file TrackSummaryTool.h.

---

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

• TrackSummaryTool.h
• TrackSummaryTool.cxx