ActsTrk::TrackToTrackParticleCnvTool Class Reference

#include <TrackToTrackParticleCnvTool.h>

Inheritance diagram for ActsTrk::TrackToTrackParticleCnvTool:

Collaboration diagram for ActsTrk::TrackToTrackParticleCnvTool:

Public Member Functions
	TrackToTrackParticleCnvTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	convert (xAOD::TrackParticle &trackParticle, const EventContext &ctx, const ActsTrk::TrackContainer::ConstTrackProxy &track, const Acts::PerigeeSurface *perigeeSurface=nullptr, const InDet::BeamSpotData *beamspotData=nullptr) const override

Private Types
using	Stepper = Acts::EigenStepper<>
using	Navigator = Acts::Navigator
using	Propagator = Acts::Propagator<Stepper, Navigator>

Private Member Functions
Acts::BoundTrackParameters	parametersAtPerigee (const EventContext &ctx, const ActsTrk::TrackContainer::ConstTrackProxy &track, const Acts::PerigeeSurface &perigee_surface) const

Static Private Member Functions
static xAOD::ParticleHypothesis	convertParticleHypothesis (Acts::PdgParticle abs_pdg_id)

Private Attributes
ToolHandle< ActsTrk::IExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool", ""}
PublicToolHandle< ActsTrk::ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollection >	m_siDetEleCollKey
Gaudi::Property< std::vector< unsigned int > >	m_siDetEleCollToMeasurementType
Gaudi::Property< double >	m_paramExtrapolationParLimit
Gaudi::Property< bool >	m_firstAndLastParamOnly
Gaudi::Property< bool >	m_computeExpectedLayerPattern
Gaudi::Property< bool >	m_expectIfPixelContributes
Gaudi::Property< double >	m_pixelExpectLayerPathLimitInMM
Gaudi::Property< unsigned long >	m_patternRecognitionInfo
Gaudi::Property< int >	m_trackFitter
std::unique_ptr< Propagator >	m_propagator

Detailed Description

Definition at line 30 of file TrackToTrackParticleCnvTool.h.

Member Typedef Documentation

Navigator

using ActsTrk::TrackToTrackParticleCnvTool::Navigator = Acts::Navigator

private

Definition at line 48 of file TrackToTrackParticleCnvTool.h.

Propagator

using ActsTrk::TrackToTrackParticleCnvTool::Propagator = Acts::Propagator<Stepper, Navigator>

private

Definition at line 49 of file TrackToTrackParticleCnvTool.h.

Stepper

using ActsTrk::TrackToTrackParticleCnvTool::Stepper = Acts::EigenStepper<>

private

Definition at line 47 of file TrackToTrackParticleCnvTool.h.

Constructor & Destructor Documentation

TrackToTrackParticleCnvTool()

ActsTrk::TrackToTrackParticleCnvTool::TrackToTrackParticleCnvTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 100 of file TrackToTrackParticleCnvTool.cxx.

      : base_class(type, name, parent)
   {
   }

Member Function Documentation

convert()

StatusCode ActsTrk::TrackToTrackParticleCnvTool::convert ( xAOD::TrackParticle & trackParticle, const EventContext & ctx, const ActsTrk::TrackContainer::ConstTrackProxy & track, const Acts::PerigeeSurface * perigeeSurface = nullptr, const InDet::BeamSpotData * beamspotData = nullptr ) const

overridevirtual

Definition at line 147 of file TrackToTrackParticleCnvTool.cxx.

   {
      using namespace Acts::UnitLiterals;
 
      SG::ReadCondHandle<AtlasFieldCacheCondObj> fieldHandle = SG::makeHandle(m_fieldCacheCondObjInputKey, ctx);
      ATH_CHECK(fieldHandle.isValid());
      const AtlasFieldCacheCondObj* field_cond_data = fieldHandle.cptr();
      MagField::AtlasFieldCache fieldCache;
      field_cond_data->getInitializedCache(fieldCache);
 
      const GeometryContext& gctx = m_trackingGeometryTool->getNominalGeometryContext();
 
      std::array<const InDetDD::SiDetectorElementCollection*, ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::nTypes)> siDetEleColl{};
      for (unsigned int idx = 0; idx < m_siDetEleCollToMeasurementType.size(); ++idx) {
         SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> detHandle = SG::makeHandle(m_siDetEleCollKey[idx], ctx);
         ATH_CHECK(detHandle.isValid());
         siDetEleColl[m_siDetEleCollToMeasurementType[idx]] = detHandle.cptr();
      }
 
      static const std::array<unsigned short, ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::nTypes)>
         measurementToSummaryType ATLAS_THREAD_SAFE (makeMeasurementToSummaryTypeMap());
 
      // re-used temporaries
      std::vector<float> tmp_cov_vector;
      std::vector<ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType> tmp_param_state_idx;
      tmp_param_state_idx.reserve(30);
      Amg::Vector3D magnFieldVect;
      std::vector<std::vector<float>> parametersVec;
      ActsTrk::detail::HitSummaryData hitInfo;
 
      // convert defining parameters
      Acts::BoundTrackParameters perigeeParam = [&] {
         if (perigeeSurface == nullptr) {
            return track.createParametersAtReference();
         } else {
            return parametersAtPerigee(ctx, track, *perigeeSurface);
         }
      }();
 
      Acts::BoundVector boundParams = perigeeParam.parameters();
      track_particle.setDefiningParameters(boundParams[Acts::eBoundLoc0],
                                           boundParams[Acts::eBoundLoc1],
                                           boundParams[Acts::eBoundPhi],
                                           boundParams[Acts::eBoundTheta],
                                           boundParams[Acts::eBoundQOverP] * 1_MeV);
 
      if (perigeeParam.covariance().has_value()) {
         lowerTriangleToVectorScaleLastRow(perigeeParam.covariance().value(), tmp_cov_vector, 5, 1_MeV);
         track_particle.setDefiningParametersCovMatrixVec(tmp_cov_vector);
      }
 
      // optional beam tilt
      if (beamspot_data) {
         track_particle.setBeamlineTiltX(beamspot_data->beamTilt(0));
         track_particle.setBeamlineTiltY(beamspot_data->beamTilt(1));
      }
 
      // fit info, quality
      track_particle.setFitQuality(track.chi2(), track.nDoF());
      track_particle.setPatternRecognitionInfo(m_patternRecognitionInfo.value());
      track_particle.setTrackFitter(static_cast<xAOD::TrackFitter>(m_trackFitter.value()));
 
      const Acts::ParticleHypothesis& hypothesis = track.particleHypothesis();
      track_particle.setParticleHypothesis(convertParticleHypothesis(hypothesis.absolutePdg()));
      constexpr float inv_1_MeV = 1 / 1_MeV;
 
      std::array<std::array<uint8_t, ActsTrk::detail::to_underlying(ActsTrk::detail::HitCategory::N)>,
                 ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::nTypes)> specialHitCounts{};
 
      ActsTrk::detail::SumOfValues chi2_stat;
      gatherTrackSummaryData(track,
                             siDetEleColl,
                             measurementToSummaryType,
                             chi2_stat,
                             hitInfo,
                             tmp_param_state_idx,
                             specialHitCounts);
 
      // pixel summaries
      std::array<std::tuple<uint8_t, uint8_t, uint8_t, bool>, 4> copy_summary {
         std::make_tuple(static_cast<uint8_t>(ActsTrk::detail::HitSummaryData::pixelTotal),
                         static_cast<uint8_t>(xAOD::numberOfContribPixelLayers),
                         static_cast<uint8_t>(xAOD::numberOfPixelHits),
                         false),
 
         std::make_tuple(static_cast<uint8_t>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat),
                         static_cast<uint8_t>(xAOD::numberOfContribPixelBarrelFlatLayers),
                         static_cast<uint8_t>(xAOD::numberOfPixelBarrelFlatHits),
                         true),
 
         std::make_tuple(static_cast<uint8_t>(ActsTrk::detail::HitSummaryData::pixelBarrelInclined),
                         static_cast<uint8_t>(xAOD::numberOfContribPixelBarrelInclinedLayers),
                         static_cast<uint8_t>(xAOD::numberOfPixelBarrelInclinedHits),
                         true),
 
         std::make_tuple(static_cast<uint8_t>(ActsTrk::detail::HitSummaryData::pixelEndcap),
                         static_cast<uint8_t>(xAOD::numberOfContribPixelEndcap),
                         static_cast<uint8_t>(xAOD::numberOfPixelEndcapHits),
                         true) };
 
      for (auto [src_region, dest_xaod_summary_layer, dest_xaod_summary_hits, add_outlier] : copy_summary) {
         setSummaryValue(track_particle,
                         hitInfo.contributingLayers(static_cast<ActsTrk::detail::HitSummaryData::DetectorRegion>(src_region)),
                         static_cast<xAOD::SummaryType>(dest_xaod_summary_layer));
         setSummaryValue(track_particle,
                         hitInfo.contributingHits(static_cast<ActsTrk::detail::HitSummaryData::DetectorRegion>(src_region))
                         + (add_outlier
                            ? hitInfo.contributingOutlierHits(static_cast<ActsTrk::detail::HitSummaryData::DetectorRegion>(src_region))
                            : 0),
                         static_cast<xAOD::SummaryType>(dest_xaod_summary_hits));
      }
      setSummaryValue(track_particle,
                      hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 0)
                      + hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap, 0),
                      xAOD::numberOfInnermostPixelLayerEndcapHits);
      setSummaryValue(track_particle,
                      hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap, 0),
                      xAOD::numberOfInnermostPixelLayerEndcapOutliers);
      setSummaryValue(track_particle,
                      hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 1)
                      + hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 2)
                      + hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap, 1)
                      + hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap, 2),
                      xAOD::numberOfNextToInnermostPixelLayerEndcapHits);
      setSummaryValue(track_particle,
                      hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap, 1)
                      + hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap, 2),
                      xAOD::numberOfNextToInnermostPixelLayerEndcapOutliers);
      setSummaryValue(track_particle,
                      hitInfo.contributingOutlierHits(ActsTrk::detail::HitSummaryData::pixelTotal),
                      xAOD::numberOfPixelOutliers);
      setSummaryValue(track_particle,
                      specialHitCounts[ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::PixelClusterType)][ActsTrk::detail::HitCategory::Hole],
                      xAOD::numberOfPixelHoles);
      setSummaryValue(track_particle,
                      hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 0),
                      xAOD::numberOfInnermostPixelLayerSharedEndcapHits);
      setSummaryValue(track_particle,
                      hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 1)
                      + hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 2),
                      xAOD::numberOfNextToInnermostPixelLayerSharedEndcapHits);
      setSummaryValue(track_particle,
                      hitInfo.contributingSharedHits(ActsTrk::detail::HitSummaryData::pixelTotal),
                      xAOD::numberOfPixelSharedHits);
 
      // expected layer pattern
      std::array<unsigned int, 4> expect_layer_pattern{};
      if (detail::ExpectedLayerPatternHelper::exists(track.container())) {
         expect_layer_pattern = detail::ExpectedLayerPatternHelper::get(track);
      } else {
         expect_layer_pattern = (m_computeExpectedLayerPattern.value()
                                 && (!m_expectIfPixelContributes.value()
                                     || hitInfo.contributingLayers(ActsTrk::detail::HitSummaryData::pixelTotal))
                                 ? detail::expectedLayerPattern(ctx,
                                                                *m_extrapolationTool,
                                                                perigeeParam,
                                                                m_pixelExpectLayerPathLimitInMM.value() * Acts::UnitConstants::mm)
                                 : std::array<unsigned int, 4>{0u, 0u, 0u, 0u});
      }
 
      // @TODO consider end-caps for inner most pixel hits ?
      setSummaryValue(track_particle,
                      static_cast<uint8_t>((expect_layer_pattern[0] & (1<<0)) != 0),
                      xAOD::expectInnermostPixelLayerHit);
      setSummaryValue(track_particle,
                      static_cast<uint8_t>((expect_layer_pattern[0] & (1<<1)) != 0),
                      xAOD::expectNextToInnermostPixelLayerHit);
      setSummaryValue(track_particle,
                      static_cast<unsigned int>(hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat, 0)),
                      xAOD::numberOfInnermostPixelLayerHits);
      setSummaryValue(track_particle,
                      static_cast<unsigned int>(hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat, 0)),
                      xAOD::numberOfInnermostPixelLayerOutliers);
      setSummaryValue(track_particle,
                      static_cast<unsigned int>(hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat, 1)),
                      xAOD::numberOfNextToInnermostPixelLayerHits);
      setSummaryValue(track_particle,
                      static_cast<unsigned int>(hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat, 1)),
                      xAOD::numberOfNextToInnermostPixelLayerOutliers);
      setSummaryValue(track_particle,
                      static_cast<unsigned int>(hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat, 0)),
                      xAOD::numberOfInnermostPixelLayerSharedHits);
      setSummaryValue(track_particle,
                      static_cast<unsigned int>(hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat, 1)),
                      xAOD::numberOfNextToInnermostPixelLayerSharedHits);
 
      // Strip summaries
      setSummaryValue(track_particle,
                      hitInfo.contributingHits(ActsTrk::detail::HitSummaryData::stripTotal),
                      xAOD::numberOfSCTHits);
      setSummaryValue(track_particle,
                      hitInfo.contributingOutlierHits(ActsTrk::detail::HitSummaryData::stripTotal),
                      xAOD::numberOfSCTOutliers);
      setSummaryValue(track_particle,
                      hitInfo.contributingSharedHits(ActsTrk::detail::HitSummaryData::stripTotal),
                      xAOD::numberOfSCTSharedHits);
      setSummaryValue(track_particle,
                      specialHitCounts[ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::StripClusterType)][ActsTrk::detail::HitCategory::Hole],
                      xAOD::numberOfSCTHoles);
 
      double biased_chi2_variance = chi2_stat.biasedVariance();
      setSummaryValue(track_particle,
                      static_cast<uint8_t>(biased_chi2_variance > 0.
                                           ? std::min(static_cast<unsigned int>(std::sqrt(biased_chi2_variance) * 100), 255u)
                                           : 0u),
                      xAOD::standardDeviationOfChi2OS);
 
      setSummaryValue(track_particle,
                      hitInfo.contributingOutlierHits(ActsTrk::detail::HitSummaryData::pixelTotal)
                      + hitInfo.contributingOutlierHits(ActsTrk::detail::HitSummaryData::stripTotal),
                      xAOD::numberOfOutliersOnTrack);
 
      // @TODO select states for which parameters are stored
      if (m_firstAndLastParamOnly && tmp_param_state_idx.size() > 2) {
         tmp_param_state_idx[1] = tmp_param_state_idx.back();
         tmp_param_state_idx.erase(tmp_param_state_idx.begin() + 2, tmp_param_state_idx.end());
      }
 
      // store track parameters and covariances for selected states
      parametersVec.clear();
      parametersVec.reserve(tmp_param_state_idx.size());
 
      for (std::vector<ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType>::const_reverse_iterator
              idx_iter = tmp_param_state_idx.rbegin();
           idx_iter != tmp_param_state_idx.rend();
           ++idx_iter) {
         ActsTrk::TrackStateBackend::ConstTrackStateProxy
            state = track.container().trackStateContainer().getTrackState(*idx_iter);
         const Acts::BoundTrackParameters actsParam = track.createParametersFromState(state);
 
         Acts::Vector3 position = actsParam.position(gctx.context());
         Acts::Vector3 momentum = actsParam.momentum();
 
         // scaling from Acts momentum units (GeV) to Athena Units (MeV)
         for (unsigned int i = 0; i < momentum.rows(); ++i) {
            momentum(i) *= inv_1_MeV;
         }
 
         if (actsParam.covariance()) {
            Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
            Acts::GeometryContext tgContext = gctx.context();
 
            magnFieldVect.setZero();
            fieldCache.getField(position.data(), magnFieldVect.data());
            // scaling from Athena magnetic field units kT to Acts units T
            {
               using namespace Acts::UnitLiterals;
               magnFieldVect *= 1000_T;
            }
 
            auto curvilinear_cov_result = ActsTrk::detail::convertActsBoundCovToCurvilinearParam(tgContext, actsParam, magnFieldVect, hypothesis);
            if (curvilinear_cov_result.has_value()) {
               Acts::BoundMatrix& curvilinear_cov = curvilinear_cov_result.value();
 
               // convert q/p components from GeV (Acts) to MeV (Athena)
               for (unsigned int col_i = 0; col_i < 4; ++col_i) {
                  curvilinear_cov(col_i, 4) *= 1_MeV;
                  curvilinear_cov(4, col_i) *= 1_MeV;
               }
               curvilinear_cov(4, 4) *= (1_MeV * 1_MeV);
 
               std::size_t param_idx = parametersVec.size();
               // only use the 5x5 sub-matrix of the full covariance matrix
               lowerTriangleToVector(curvilinear_cov, tmp_cov_vector, 5);
               if (tmp_cov_vector.size() != 15) {
                  ATH_MSG_ERROR("Invalid size of lower triangle cov " << tmp_cov_vector.size() << " != 15"
                                << " input matrix : " << curvilinear_cov.rows() << " x " << curvilinear_cov.cols());
               }
               track_particle.setTrackParameterCovarianceMatrix(param_idx, tmp_cov_vector);
            }
         }
         parametersVec.emplace_back(std::vector<float>{
            static_cast<float>(position[0]), static_cast<float>(position[1]), static_cast<float>(position[2]),
            static_cast<float>(momentum[0]), static_cast<float>(momentum[1]), static_cast<float>(momentum[2]) });
      }
      for (const std::vector<float>& param : parametersVec) {
         if (param.size() != 6) {
            ATH_MSG_ERROR("Invalid size of param element " << param.size() << " != 6");
         }
      }
 
      track_particle.setTrackParameters(parametersVec);
 
      return StatusCode::SUCCESS;
   }

convertParticleHypothesis()

xAOD::ParticleHypothesis ActsTrk::TrackToTrackParticleCnvTool::convertParticleHypothesis ( Acts::PdgParticle abs_pdg_id )

staticprivate

Definition at line 82 of file TrackToTrackParticleCnvTool.cxx.

                                                                                                                  {
     static const std::array map {
       std::pair{Acts::eElectron, xAOD::electron},
       std::pair{Acts::eMuon,     xAOD::muon},
       std::pair{Acts::ePionPlus, xAOD::pion},
       std::pair{Acts::eProton,   xAOD::proton},
       std::pair{Acts::ePionZero, xAOD::pi0},
       std::pair{Acts::eNeutron,  xAOD::neutron},
       std::pair{Acts::eGamma,    xAOD::photon},
     };
     auto iter = std::find_if(
       map.begin(), map.end(),
       [abs_pdg_id](const auto& elm) {
         return abs_pdg_id == elm.first;
       });
     return (iter != map.end() ? iter->second : xAOD::noHypothesis);
   }

initialize()

StatusCode ActsTrk::TrackToTrackParticleCnvTool::initialize ( )

overridevirtual

Definition at line 107 of file TrackToTrackParticleCnvTool.cxx.

   {
      ATH_CHECK( m_trackingGeometryTool.retrieve() );
      ATH_CHECK( m_extrapolationTool.retrieve() );
      ATH_CHECK( m_fieldCacheCondObjInputKey.initialize() );
      ATH_CHECK( m_siDetEleCollKey.initialize() );
 
      if (m_siDetEleCollToMeasurementType.size() == m_siDetEleCollKey.size()) {
         unsigned int collection_idx = 0;
         for (int type : m_siDetEleCollToMeasurementType) {
            if (type < 1 || type > 2) {
               ATH_MSG_ERROR("Invalid measurement type (" << type << ") given for collection " << collection_idx << " : "
                             << m_siDetEleCollKey[collection_idx].key()
                             << ". Expected 1 for pixel, 2 for strips.");
               return StatusCode::FAILURE;
            }
            ++collection_idx;
         }
      } else {
         ATH_MSG_ERROR("Expected exactly one value in SiDetEleCollToMeasurementType per SiDetectorElementCollection. But got "
                       << m_siDetEleCollToMeasurementType.size() << " instead of " << m_siDetEleCollKey.size() << ".");
         return StatusCode::FAILURE;
      }
 
      // propagator for conversion to curvilinear parameters
      {
         auto logger = makeActsAthenaLogger(this, "Prop");
         Navigator::Config cfg{m_trackingGeometryTool->trackingGeometry()};
         cfg.resolvePassive = false;
         cfg.resolveMaterial = true;
         cfg.resolveSensitive = true;
         auto navigtor_logger = logger->cloneWithSuffix("Navigator");
         m_propagator = std::make_unique<Propagator>(Stepper(std::make_shared<ATLASMagneticFieldWrapper>()),
                                                     Navigator(cfg, std::move(navigtor_logger)),
                                                     std::move(logger));
      }
 
      return StatusCode::SUCCESS;
   }

parametersAtPerigee()

Acts::BoundTrackParameters ActsTrk::TrackToTrackParticleCnvTool::parametersAtPerigee ( const EventContext & ctx, const ActsTrk::TrackContainer::ConstTrackProxy & track, const Acts::PerigeeSurface & perigee_surface ) const

private

Definition at line 438 of file TrackToTrackParticleCnvTool.cxx.

   {
      const Acts::BoundTrackParameters trackParam = track.createParametersAtReference();
 
      Acts::Result<Acts::BoundTrackParameters>
         perigeeParam = m_extrapolationTool->propagate(ctx,
                                                       trackParam,
                                                       perigee_surface,
                                                       Acts::Direction::Backward(),
                                                       m_paramExtrapolationParLimit.value());
      if (!perigeeParam.ok()) {
         ATH_MSG_WARNING("Failed to extrapolate to perigee, started from \n" << trackParam << " " << trackParam.referenceSurface().name());
         return trackParam;
      }
 
      return perigeeParam.value();
   }

Member Data Documentation

m_computeExpectedLayerPattern

Gaudi::Property<bool> ActsTrk::TrackToTrackParticleCnvTool::m_computeExpectedLayerPattern

private

Initial value:

{this, "ComputeExpectedLayerPattern", true,
        "Compute the expected layer pattern. CPU expensive"}

Definition at line 83 of file TrackToTrackParticleCnvTool.h.

       {this, "ComputeExpectedLayerPattern", true,
        "Compute the expected layer pattern. CPU expensive"};

m_expectIfPixelContributes

Gaudi::Property<bool> ActsTrk::TrackToTrackParticleCnvTool::m_expectIfPixelContributes

private

Initial value:

{this, "expectIfPixelContribution", true,
        "Only expect pixel hits if there are pixel hits on track."}

Definition at line 87 of file TrackToTrackParticleCnvTool.h.

       {this, "expectIfPixelContribution", true,
        "Only expect pixel hits if there are pixel hits on track."};

m_extrapolationTool

ToolHandle<ActsTrk::IExtrapolationTool> ActsTrk::TrackToTrackParticleCnvTool::m_extrapolationTool {this, "ExtrapolationTool", ""}

private

Definition at line 57 of file TrackToTrackParticleCnvTool.h.

{this, "ExtrapolationTool", ""};

m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> ActsTrk::TrackToTrackParticleCnvTool::m_fieldCacheCondObjInputKey

private

Initial value:

{this, "AtlasFieldCacheCondObj", "fieldCondObj",
        "Name of the Magnetic Field conditions object key"}

Definition at line 63 of file TrackToTrackParticleCnvTool.h.

       {this, "AtlasFieldCacheCondObj", "fieldCondObj",
        "Name of the Magnetic Field conditions object key"};

m_firstAndLastParamOnly

Gaudi::Property<bool> ActsTrk::TrackToTrackParticleCnvTool::m_firstAndLastParamOnly

private

Initial value:

{this, "FirstAndLastParameterOnly", true,
        "Only convert the first and the last parameter."}

Definition at line 79 of file TrackToTrackParticleCnvTool.h.

       {this, "FirstAndLastParameterOnly", true,
        "Only convert the first and the last parameter."};

m_paramExtrapolationParLimit

Gaudi::Property<double> ActsTrk::TrackToTrackParticleCnvTool::m_paramExtrapolationParLimit

private

Initial value:

{this, "ExtrapolationPathLimit", std::numeric_limits<double>::max(),
        "PathLimit for extrapolating track parameters."}

Definition at line 75 of file TrackToTrackParticleCnvTool.h.

       {this, "ExtrapolationPathLimit", std::numeric_limits<double>::max(),
        "PathLimit for extrapolating track parameters."};

m_patternRecognitionInfo

Gaudi::Property<unsigned long> ActsTrk::TrackToTrackParticleCnvTool::m_patternRecognitionInfo

private

Initial value:

{this, "PatternRecognitionInfo", (1ul << xAOD::SiSPSeededFinder),
        "Pattern recognition info bitmask to store on converted track particles."}

Definition at line 95 of file TrackToTrackParticleCnvTool.h.

       {this, "PatternRecognitionInfo", (1ul << xAOD::SiSPSeededFinder),
        "Pattern recognition info bitmask to store on converted track particles."};

m_pixelExpectLayerPathLimitInMM

Gaudi::Property<double> ActsTrk::TrackToTrackParticleCnvTool::m_pixelExpectLayerPathLimitInMM

private

Initial value:

{this, "PixelExpectLayerPathLimitInMM", 1000,
        "PathLimit for extrapolating to get the expected pixel layer pattern in mm."}

Definition at line 91 of file TrackToTrackParticleCnvTool.h.

       {this, "PixelExpectLayerPathLimitInMM", 1000,
        "PathLimit for extrapolating to get the expected pixel layer pattern in mm."};

m_propagator

std::unique_ptr<Propagator> ActsTrk::TrackToTrackParticleCnvTool::m_propagator

private

Definition at line 103 of file TrackToTrackParticleCnvTool.h.

m_siDetEleCollKey

SG::ReadCondHandleKeyArray<InDetDD::SiDetectorElementCollection> ActsTrk::TrackToTrackParticleCnvTool::m_siDetEleCollKey

private

Initial value:

{this, "SiDetectorElementCollections", {},
        "Pixel and strip element collections to get geometry information about measurements."}

Definition at line 67 of file TrackToTrackParticleCnvTool.h.

       {this, "SiDetectorElementCollections", {},
        "Pixel and strip element collections to get geometry information about measurements."};

m_siDetEleCollToMeasurementType

Gaudi::Property<std::vector<unsigned int> > ActsTrk::TrackToTrackParticleCnvTool::m_siDetEleCollToMeasurementType

private

Initial value:

{this, "SiDetEleCollToMeasurementType", {},
        "One value per si detector collection: Pixel = 1, Strip = 2"}

Definition at line 71 of file TrackToTrackParticleCnvTool.h.

       {this, "SiDetEleCollToMeasurementType", {},
        "One value per si detector collection: Pixel = 1, Strip = 2"};

m_trackFitter

Gaudi::Property<int> ActsTrk::TrackToTrackParticleCnvTool::m_trackFitter

private

Initial value:

{this, "TrackFitter", static_cast<int>(xAOD::KalmanFitter),
        "Track fitter identifier to store on converted track particles."}

Definition at line 99 of file TrackToTrackParticleCnvTool.h.

       {this, "TrackFitter", static_cast<int>(xAOD::KalmanFitter),
        "Track fitter identifier to store on converted track particles."};

m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ActsTrk::TrackToTrackParticleCnvTool::m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}

private

Definition at line 60 of file TrackToTrackParticleCnvTool.h.

{this, "TrackingGeometryTool", "ActsTrackingGeometryTool"};

---

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

• TrackToTrackParticleCnvTool.h
• TrackToTrackParticleCnvTool.cxx