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.
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.
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.

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::ITrackSummaryHelperTool *	getTool (const Identifier &id) const
	Return the correct tool, matching the passed Identifier.
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'
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.

Private Attributes
ToolHandle< ITrackSummaryHelperTool >	m_idTool { this, "InDetSummaryHelperTool", "", "" }
	tool to decipher ID RoTs
ToolHandle< ITrackSummaryHelperTool >	m_muonTool { this, "MuonSummaryHelperTool", "", "" }
	tool to decipher muon RoTs
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.
Gaudi::Property< bool >	m_doHolesInDet { this, "doHolesInDet", false, "" }
	controls whether holes on track in ID are produced
Gaudi::Property< bool >	m_addMuonDetailedSummary
	controls whether the detailed summary is added for the muons
Gaudi::Property< bool >	m_pixelExists { this, "PixelExists", true, "" }
	switch to deactivate Pixel info init
Gaudi::Property< bool >	m_alwaysRecomputeHoles
const AtlasDetectorID *	m_detID
	atlas id helper

Detailed Description

Definition at line 42 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/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 Tracking/TrkTools/TrkTrackSummaryTool/src/TrackSummaryTool.cxx.

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

~TrackSummaryTool()

Trk::TrackSummaryTool::~TrackSummaryTool ( )

virtualdefault

Member Function Documentation

computeAndReplaceTrackSummary()

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

finaloverridevirtual

Definition at line 96 of file Tracking/TrkTools/TrkTrackSummaryTool/src/TrackSummaryTool.cxx.

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

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 Tracking/TrkTools/TrkTrackSummaryTool/src/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 Tracking/TrkTools/TrkTrackSummaryTool/src/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::ITrackSummaryHelperTool * Trk::TrackSummaryTool::getTool ( const Identifier & id ) const

private

Return the correct tool, matching the passed Identifier.

Definition at line 406 of file Tracking/TrkTools/TrkTrackSummaryTool/src/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 Tracking/TrkTools/TrkTrackSummaryTool/src/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 Tracking/TrkTools/TrkTrackSummaryTool/src/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::ITrackSummaryHelperTool* 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::ITrackSummaryHelperTool* 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 Tracking/TrkTools/TrkTrackSummaryTool/src/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 Tracking/TrkTools/TrkTrackSummaryTool/src/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()

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

finaloverridevirtual

Definition at line 112 of file Tracking/TrkTools/TrkTrackSummaryTool/src/TrackSummaryTool.cxx.

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

summaryNoHoleSearch()

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

finaloverridevirtual

Definition at line 125 of file Tracking/TrkTools/TrkTrackSummaryTool/src/TrackSummaryTool.cxx.

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

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 154 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h.

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

m_alwaysRecomputeHoles

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

private

Initial value:

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

Definition at line 161 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h.

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

m_detID

const AtlasDetectorID* Trk::TrackSummaryTool::m_detID

private

atlas id helper

Definition at line 167 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/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 151 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h.

{ this, "doHolesInDet", false, "" };

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 149 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h.

{ this, "doHolesMuon", false, "" };

m_idTool

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

private

tool to decipher ID RoTs

Definition at line 142 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h.

{ this, "InDetSummaryHelperTool", "", "" };

m_muonTool

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

private

tool to decipher muon RoTs

Definition at line 145 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h.

{ this, "MuonSummaryHelperTool", "", "" };

m_pixelExists

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

private

switch to deactivate Pixel info init

Definition at line 159 of file Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h.

{ this, "PixelExists", true, "" };

---

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

• Tracking/TrkTools/TrkTrackSummaryTool/TrkTrackSummaryTool/TrackSummaryTool.h
• Tracking/TrkTools/TrkTrackSummaryTool/src/TrackSummaryTool.cxx