ActsTrk::ActsToTrkConverterTool Class Reference

#include <ActsToTrkConverterTool.h>

Inheritance diagram for ActsTrk::ActsToTrkConverterTool:

Collaboration diagram for ActsTrk::ActsToTrkConverterTool:

Public Member Functions
virtual StatusCode	initialize () override
virtual std::vector< Acts::SourceLink >	trkTrackToSourceLinks (const Trk::Track &track) const override
	Converts the Trk measurement track states into a vector of Acts::Source links.
virtual std::unique_ptr< Trk::Track >	convertActsToTrk (const EventContext &ctx, const ActsTrack_t &actsTrack, const Trk::TrackInfo::TrackFitter fitAuthor) const override final
virtual std::unique_ptr< Trk::Track >	convertTrack (const EventContext &ctx, const ConstTrack_t &trackProxy) const override final
	Converts a const Acts::Track into.
virtual void	convertTrkToActsContainer (const EventContext &ctx, const TrackCollection &trackColl, ActsTrk::MutableTrackContainer &outTrackcoll) const override
	Convert the Trk::Track in the passed TrackCollection into Acts tracks and appends the result to the passed mutable track container.
virtual std::unique_ptr< TrackCollection >	convertActsToTrkContainer (const EventContext &ctx, const ActsTrk::TrackContainer &trackCont) const override final
	Converts the Acts track container to a Trk::Track collection.

Private Types
using	TrkTSOSMask = std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes>
	Abrivate the state mask for the TSOS.

Private Member Functions
template<typename Proxy_t>
std::unique_ptr< Trk::Track >	convertActsTrack (const EventContext &ctx, const Proxy_t &track, const Trk::TrackInfo::TrackFitter fitAuthor) const
	Helper function to convert a Acts TrackPoxy (which may be const or not) into a Trk::Track.
void	appendMeasTSOS (const EventContext &ctx, const xAOD::UncalibratedMeasurement *meas, const TrkTSOSMask typePattern, Trk::FitQualityOnSurface &&quality, std::unique_ptr< Trk::TrackParameters > trkPars, Trk::TrackStates &states) const
	Append the translated TSOS at the beginning of the states container corresponding to the parsed measurement.
template<typename PrdType_t>
const Trk::PrepRawData *	fetchPrd (const EventContext &ctx, const SG::ReadHandleKey< PrdType_t > &key, const Identifier &prdId, const IdentifierHash &hash) const
	Searches a Prd object from a collection according to the measurement's Identifier and the container's hash.
bool	actsTrackParameterPositionCheck (const Acts::BoundTrackParameters &actsParameter, const Trk::TrackParameters &tsos, const Acts::GeometryContext &gctx) const

Private Attributes
PublicToolHandle< IGeometryRealmConvTool >	m_geometryConvTool {this, "GeometryRealmConvTool", ""}
ContextUtility	m_ctxProvider {this}
	Utility to fetch the geometry, magnetic field and calibration context in the event.
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trkSummaryTool {this, "SummaryTool", "", "ToolHandle for track summary tool"}
	Tools needed to create Trk::Tracks from the ACts fit result.
ToolHandle< Trk::IRIO_OnTrackCreator >	m_ROTcreator {this, "RotCreatorTool", ""}
Gaudi::Property< bool >	m_convertHoles {this, "convertHoles", true }
	Flag to convert the hole states.
Gaudi::Property< bool >	m_convertOutliers {this, "convertOutliers", true}
	Flag to convert the outlier states.
Gaudi::Property< bool >	m_convertMaterial {this, "convertMaterial", false}
	Flag to convert the material states (non sensitive) Acts -> Trk conversion.
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadHandleKey< Muon::MdtPrepDataContainer >	m_keyMdt {this, "MdtKey", "MDT_DriftCircles"}
SG::ReadHandleKey< Muon::RpcPrepDataContainer >	m_keyRpc {this, "RpcKey", "RPC_Measurements"}
SG::ReadHandleKey< Muon::TgcPrepDataContainer >	m_keyTgc {this, "TgcKey", "TGC_MeasurementsAllBCs"}
SG::ReadHandleKey< Muon::MMPrepDataContainer >	m_keyMm {this, "MmKey", "MM_Measurements"}
SG::ReadHandleKey< Muon::sTgcPrepDataContainer >	m_keyStgc {this, "sTgcKey", "STGC_Measurements"}
SG::ReadHandleKey< InDet::PixelClusterContainer >	m_pixelKey {this, "PixelKey", "ITkPixelClusters" }
SG::ReadHandleKey< InDet::SCT_ClusterContainer >	m_sctKey {this, "SctKey", "ITkStripClusters" }
ToolHandle< Muon::IMuonCompetingClustersOnTrackCreator >	m_compRotCreator {this, "CompetingRotCreator", ""}
detail::TrkMeasurementCalibrator	m_measCalib {}
detail::TrkPrepRawDataCalibrator	m_prdCalib {}
Trk::TrackInfo::TrackFitter	m_fitAuthor {Trk::TrackInfo::TrackFitter::GlobalChi2Fitter}

Detailed Description

Definition at line 44 of file ActsToTrkConverterTool.h.

Member Typedef Documentation

TrkTSOSMask

using ActsTrk::ActsToTrkConverterTool::TrkTSOSMask = std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes>

private

Abrivate the state mask for the TSOS.

Definition at line 80 of file ActsToTrkConverterTool.h.

Member Function Documentation

actsTrackParameterPositionCheck()

bool ActsTrk::ActsToTrkConverterTool::actsTrackParameterPositionCheck ( const Acts::BoundTrackParameters & actsParameter, const Trk::TrackParameters & tsos, const Acts::GeometryContext & gctx ) const

private

Definition at line 230 of file ActsToTrkConverterTool.cxx.

                                           {
  auto actsPos = parameters.position(gctx);
 
  if ( (actsPos - trkparameters.position()).mag() > 0.1) {
    ATH_MSG_WARNING("Parameter position mismatch. Acts \n"
                    << actsPos << " vs Trk \n"
                    << trkparameters.position());
    ATH_MSG_WARNING("Acts surface:");
    ATH_MSG_WARNING(parameters.referenceSurface().toString(gctx));
    ATH_MSG_WARNING("Trk surface:");
    ATH_MSG_WARNING(trkparameters.associatedSurface());
    return false;
  }
  return true;
}

appendMeasTSOS()

void ActsTrk::ActsToTrkConverterTool::appendMeasTSOS ( const EventContext & ctx, const xAOD::UncalibratedMeasurement * meas, const TrkTSOSMask typePattern, Trk::FitQualityOnSurface && quality, std::unique_ptr< Trk::TrackParameters > trkPars, Trk::TrackStates & states ) const

private

Append the translated TSOS at the beginning of the states container corresponding to the parsed measurement.

Parameters

ctx	EventContext to access the calibration conditions data needed for the Trk::RIO_OnTrack conversion and to access the PrepRawData
meas	Pointer to the uncalibrated measurement for conversion
typePattern	Bit mask stating whether the measurement is on track or an outlier
quality	Chi2 and nDOF contribution from the measurement
trkPars	The track parameters on the surface
states	Output container into which the new TSOS is pushed

Dimension 0 measurements are combined measurements!

Todo

Check whether the phi surface is in front of the eta surface

Correct the ROT according to the surface

Definition at line 380 of file ActsToTrkConverterTool.cxx.

                                                                            {
    std::unique_ptr<Trk::MeasurementBase> rot{};
    switch (meas->type()) {
        using enum xAOD::UncalibMeasType;
        case PixelClusterType: {
          static const SG::AuxElement::ConstAccessor<ElementLink<InDet::PixelClusterCollection>> acc_prdLink("pixelClusterLink");
          if (acc_prdLink.isAvailable(*meas) && acc_prdLink(*meas).isValid()) {
              rot.reset(m_ROTcreator->correct(**acc_prdLink(*meas), *trkPars, ctx));
          } else {
              ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - The pixel xAOD -> prd accessor is invalid");
          }
          break;
        } case StripClusterType: {
          static const SG::AuxElement::ConstAccessor<ElementLink<InDet::SCT_ClusterCollection>> acc_prdLink("sctClusterLink");
          if (acc_prdLink.isAvailable(*meas) && acc_prdLink(*meas).isValid()) {
              rot.reset(m_ROTcreator->correct(**acc_prdLink(*meas), *trkPars, ctx));
          } else {
              ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - The strip xAOD -> prd accessor is invalid");
          }
          break;
        } case MdtDriftCircleType:
          case MMClusterType: {
            const Identifier& id = static_cast<const xAOD::MuonMeasurement*>(meas)->identify();
            const IdentifierHash modHash = m_idHelperSvc->moduleHash(id);
            const auto* prd =  meas->type() == MdtDriftCircleType ?  fetchPrd(ctx, m_keyMdt, id, modHash) 
                                                                  :  fetchPrd(ctx, m_keyMm, id, modHash);
            assert(prd != nullptr);
            rot.reset(m_ROTcreator->correct(*prd, *trkPars, ctx));
            break;
        } case TgcStripType:
          case RpcStripType:
          case sTgcStripType: {
            const Identifier& id = static_cast<const xAOD::MuonMeasurement*>(meas)->identify();
            const IdentifierHash modHash = m_idHelperSvc->moduleHash(id);
            const Trk::PrepRawData* prd{nullptr}, *prd1{nullptr};
 
            if (meas->numDimensions() == 0) {
              const auto* muonMeas = static_cast<const xAOD::CombinedMuonStrip*>(meas);
              if (meas->type() == RpcStripType) {
                prd  = fetchPrd(ctx, m_keyRpc, id, modHash);
                prd1 = fetchPrd(ctx, m_keyRpc, muonMeas->secondaryStrip()->identify(), modHash);
              } else if (meas->type() == TgcStripType) {
                prd = fetchPrd(ctx, m_keyTgc, id, modHash);
                prd1 = fetchPrd(ctx, m_keyTgc, muonMeas->secondaryStrip()->identify(), modHash);
              } else {
                prd  = fetchPrd(ctx, m_keyStgc, id, modHash);
                prd1 = fetchPrd(ctx, m_keyStgc, muonMeas->secondaryStrip()->identify(), modHash);
              }
              assert(prd != nullptr);
              assert(prd1 != nullptr);

              const Trk::Surface& phiSurface = prd1->detectorElement()->surface(prd1->identify());
              auto phiPars = rotateParams(*trkPars, phiSurface);
              assert(phiPars != nullptr);
              std::unique_ptr<Trk::MeasurementBase> phiRot{};
              if (meas->type() != sTgcStripType) {
                phiRot = m_compRotCreator->createBroadCluster(std::list{prd1}, 1.);
                rot = m_compRotCreator->createBroadCluster(std::list{prd}, 1.);
              } else {
                phiRot.reset(m_ROTcreator->correct(*prd1, *phiPars, ctx));
                rot.reset(m_ROTcreator->correct(*prd, *trkPars, ctx));
              }
              assert(phiRot != nullptr);
              states.insert(states.begin(),
                            std::make_unique<Trk::TrackStateOnSurface>(quality, 
                                                                       std::move(phiRot), 
                                                                       std::move(phiPars), nullptr, typePattern));
            } else {
              const auto* prd  = meas->type() == RpcStripType ? fetchPrd(ctx, m_keyRpc, id, modHash)
                                                              :
                                meas->type() == TgcStripType ? fetchPrd(ctx, m_keyTgc, id, modHash)
                                                             : fetchPrd(ctx, m_keyStgc, id, modHash);
              assert(prd != nullptr);
              // Track parameter representation needs to change towards a phi surface
              if (m_idHelperSvc->measuresPhi(id)) {
                  ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Convert the track parameters "<<m_idHelperSvc->toString(id)
                                <<", "<<m_idHelperSvc->toStringDetEl(prd->detectorElement()->identify()));
                  const Trk::Surface& target = prd->detectorElement()->surface(id);
                  trkPars = rotateParams(*trkPars, target);
              }
              rot.reset(m_ROTcreator->correct(*prd, *trkPars, ctx));
            }
            break;
        } default:
          ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Measurement type "<<meas->type()<<" is not implemented");
          return;
    }
    if (!rot) {
      ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - ROT creation failed.");
      return;
    }
    assert(rot != nullptr);
    assert(trkPars != nullptr);
    states.insert(states.begin(),
                  std::make_unique<Trk::TrackStateOnSurface>(std::move(quality), std::move(rot), 
                                                             std::move(trkPars), nullptr, typePattern));
 
  }

convertActsToTrk()

std::unique_ptr< Trk::Track > ActsTrk::ActsToTrkConverterTool::convertActsToTrk ( const EventContext & ctx, const ActsTrack_t & actsTrack, const Trk::TrackInfo::TrackFitter fitAuthor ) const

finaloverridevirtual

Definition at line 249 of file ActsToTrkConverterTool.cxx.

                                                                                                                    {
    return convertActsTrack<ActsTrack_t>(ctx, actsTrack, fitAuthor);
}

convertActsToTrkContainer()

std::unique_ptr< TrackCollection > ActsTrk::ActsToTrkConverterTool::convertActsToTrkContainer ( const EventContext & ctx, const ActsTrk::TrackContainer & trackCont ) const

finaloverridevirtual

Converts the Acts track container to a Trk::Track collection.

Parameters

ctx	EventContext to access the current conditions (alignment, calibration, etc.)
trackCont	Reference to the track container for legacy converstion

Definition at line 372 of file ActsToTrkConverterTool.cxx.

                                                                                                    {
      auto outColl = std::make_unique<TrackCollection>();
      for (const ActsTrk::TrackContainer::ConstTrackProxy trk : trackCont) {
          outColl->push_back(convertActsTrack(ctx, trk, m_fitAuthor));
      }
      return outColl;
  }

convertActsTrack()

template<typename Proxy_t>

std::unique_ptr< Trk::Track > ActsTrk::ActsToTrkConverterTool::convertActsTrack ( const EventContext & ctx, const Proxy_t & track, const Trk::TrackInfo::TrackFitter fitAuthor ) const

private

Helper function to convert a Acts TrackPoxy (which may be const or not) into a Trk::Track.

Parameters

ctx	The EventContext to access the current calibration constants
track	Reference to the track state proxy for translation
fitAuthor	Author that is written in the track summary info

Definition at line 260 of file ActsToTrkConverterTool.cxx.

                                                                                           {
 
    ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Check track "<<acts_track.tipIndex());
    const Acts::CalibrationContext cctx{getCalibrationContext(ctx)};
    const Acts::GeometryContext tgContext{m_ctxProvider.getGeometryContext(ctx)};
   
    auto finalTrajectory = std::make_unique<Trk::TrackStates>();
 
 
    // Loop over all the output state to create track state
    acts_track.container().trackStateContainer().visitBackwards(acts_track.tipIndex(), 
      [&] (const auto &state) -> void {
        if (!state.hasReferenceSurface()) {
          return;
        }
        // First only consider state with an associated detector element
        if (!m_convertMaterial && !state.referenceSurface().isSensitive()) {
          return;
        }
        int nDoF{0};
        double chi2{0};
 
        if (!state.hasSmoothed() && !state.hasFiltered() && !state.hasPredicted()) {
          ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - State has no valid parameters (smoothed/filtered/predicted)");
          return;
        }
 
        if (const auto* associatedDetEl = dynamic_cast<const ISurfacePlacement*>(
                                        state.referenceSurface().surfacePlacement());
            associatedDetEl != nullptr) {
            ATH_MSG_VERBOSE("Associated det: "<<associatedDetEl->detectorType());
        }
 
        auto flag = state.typeFlags();
 
        auto boundPars = acts_track.createParametersFromState(state);
 
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - "<<" hole: "<<flag.isHole()
            <<", outlier: "<<flag.isOutlier()<<", measurement: "<<flag.isMeasurement()<<"/"
            <<flag.hasMeasurement()<<", "<<m_convertOutliers<<", "<<m_convertHoles
            <<", has SL: "<<state.hasUncalibratedSourceLink()
            <<", parameters: "<<boundPars);
 
        // We need to determine the type of state 
        TrkTSOSMask typePattern;
 
        std::unique_ptr<Trk::TrackParameters> trkPars = m_geometryConvTool->convertTrackParametersToTrk(ctx, boundPars);
        std::unique_ptr<Trk::MeasurementBase> trkMeasurement{};
 
 
        // State is a hole (no associated measurement), use predicted parameters   
        if (flag.isHole()) {
          if (!m_convertHoles) { return; }
          typePattern.set(Trk::TrackStateOnSurface::Hole);
        } if (flag.isOutlier()) {
          if (!m_convertOutliers) { return; }
          typePattern.set(Trk::TrackStateOnSurface::Outlier);
        } 
        if (flag.hasMeasurement()) {
          typePattern.set(Trk::TrackStateOnSurface::Measurement);
          nDoF = state.calibratedSize();
          chi2 = state.chi2();
          const auto slType = detail::MeasurementCalibratorBase::getType(state.getUncalibratedSourceLink());
          switch (slType) {
              using enum detail::SourceLinkType;
              case TrkMeasurement: 
                trkMeasurement = m_measCalib.unpack(state.getUncalibratedSourceLink())->uniqueClone();
                break;
              case TrkPrepRawData:
                trkMeasurement = m_prdCalib.createROT(tgContext, cctx, state.getUncalibratedSourceLink(), state);
                break;
              case xAODUnCalibMeas:
                  appendMeasTSOS(ctx, detail::xAODUncalibMeasCalibrator::unpack(state.getUncalibratedSourceLink()),
                                 typePattern, Trk::FitQualityOnSurface{chi2, nDoF}, 
                                 std::move(trkPars), *finalTrajectory);
                  return;
              default:
                THROW_EXCEPTION("Invalid "<<slType<<" type parsed.");
          }
        }
        auto perState = std::make_unique<Trk::TrackStateOnSurface>(Trk::FitQualityOnSurface{chi2, nDoF},
                                                                   std::move(trkMeasurement), 
                                                                   std::move(trkPars), nullptr, typePattern);
        // If a state was succesfully created add it to the trajectory 
        ATH_MSG_VERBOSE("State succesfully created, adding it to the trajectory");
        finalTrajectory->insert(finalTrajectory->begin(), std::move(perState));
      });
 
      if (finalTrajectory->empty()) {
          ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" No measurements added to the track");
          return nullptr;
      }
      // Convert the perigee state and add it to the trajectory
      std::unique_ptr<Trk::TrackParameters> per = m_geometryConvTool->convertTrackParametersToTrk(ctx, acts_track.createParametersAtReference());
      TrkTSOSMask typePattern;
      typePattern.set(Trk::TrackStateOnSurface::Perigee);
      finalTrajectory->insert(finalTrajectory->begin(), 
                              std::make_unique<Trk::TrackStateOnSurface>(nullptr, std::move(per), nullptr, typePattern));
      // Create the track using the states
      Trk::TrackInfo newInfo{fitAuthor, ParticleHypothesis::convertTrk(acts_track.particleHypothesis())};
      auto newtrack = std::make_unique<Trk::Track>(newInfo, std::move(finalTrajectory), 
                                                   std::make_unique<Trk::FitQuality>(static_cast<double>(acts_track.chi2()), 
                                                                                     static_cast<int>(acts_track.nDoF())));
      constexpr bool suppressHoleSearch = false;
      m_trkSummaryTool->updateTrackSummary(ctx, *newtrack, suppressHoleSearch);
      ATH_MSG_VERBOSE("Created new track "<<(*newtrack->trackSummary()));
      return newtrack;
  }

convertTrack()

std::unique_ptr< Trk::Track > ActsTrk::ActsToTrkConverterTool::convertTrack ( const EventContext & ctx, const ConstTrack_t & trackProxy ) const

finaloverridevirtual

Converts a const Acts::Track into.

Parameters

ctx	EventContext to access the current conditions (alignment, calibrations, etc.)
trackProxy	The acts track for conversion

Definition at line 254 of file ActsToTrkConverterTool.cxx.

                                                                                                       {
    return convertActsTrack(ctx, trackProxy, m_fitAuthor);
}

convertTrkToActsContainer()

void ActsTrk::ActsToTrkConverterTool::convertTrkToActsContainer ( const EventContext & ctx, const TrackCollection & trackColl, ActsTrk::MutableTrackContainer & outTrackcoll ) const

overridevirtual

Convert the Trk::Track in the passed TrackCollection into Acts tracks and appends the result to the passed mutable track container.

Parameters

ctx	EventContext to access the current conditions (alignment, calibrations, etc.)
trackColl	The Trk::Track container to be converted
outTrackColl	Reference to the mutable track container to which the converted tracks are appended.

Definition at line 101 of file ActsToTrkConverterTool.cxx.

                                                                                                         {
  const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
  ATH_MSG_VERBOSE("Calling trkTrackCollectionToActsTrackContainer with "
                  << trackColl.size() << " tracks.");
  unsigned int trkCount = 0;
  std::vector<Identifier> failedIds; // Keep track of Identifiers of failed conversions
  for (const Trk::Track* trk : trackColl) {
    // Do conversions!
    const Trk::TrackStates *trackStates = trk->trackStateOnSurfaces();
   
    auto actsTrack = outTrackcoll.getTrack(outTrackcoll.addTrack());
    auto& trackStateContainer = outTrackcoll.trackStateContainer();
 
    ATH_MSG_VERBOSE("Track "<<trkCount++<<" has " << trackStates->size()
                                 << " track states on surfaces.");
    // basic quantities copy
    actsTrack.chi2() = trk->fitQuality()->chiSquared();
    actsTrack.nDoF() = trk->fitQuality()->numberDoF();
 
    // loop over track states on surfaces, convert and add them to the ACTS
    // container
    bool first_tsos = true;  // We need to handle the first one differently
    int measurementsCount = 0;
    for (const Trk::TrackStateOnSurface* tsos : *trackStates) {
 
      // Setup the mask
      Acts::TrackStatePropMask mask = Acts::TrackStatePropMask::None;
      if (tsos->measurementOnTrack()) {
        mask |= Acts::TrackStatePropMask::Calibrated;
      }
      if (tsos->trackParameters()) {
        mask |= Acts::TrackStatePropMask::Smoothed;
      }
 
      // Setup the index of the trackstate
      auto index = Acts::kTrackIndexInvalid;
      if (!first_tsos) {
        index = actsTrack.tipIndex();
      }
      auto actsTSOS = trackStateContainer.getTrackState(trackStateContainer.addTrackState(mask, index));
      ATH_MSG_VERBOSE("TipIndex: " << actsTrack.tipIndex() << " TSOS index within trajectory: "<< actsTSOS.index());
      actsTrack.tipIndex() = actsTSOS.index();
 
      if (tsos->trackParameters()) {
        // TODO This try/catch is temporary and should be removed once the sTGC problem is fixed.
        try {
          ATH_MSG_VERBOSE("Converting track parameters.");
          // TODO - work out whether we should set predicted, filtered, smoothed
          const Acts::BoundTrackParameters parameters = m_geometryConvTool->convertTrackParametersToActs(ctx, *tsos->trackParameters());
          ATH_MSG_VERBOSE("Track parameters: " << parameters.parameters());
          // Sanity check on positions
          if (!actsTrackParameterPositionCheck(parameters, *(tsos->trackParameters()), tgContext)) {
            failedIds.push_back(tsos->trackParameters()->associatedSurface().associatedDetectorElementIdentifier());
          }
 
          if (first_tsos) {
            // This is the first track state, so we need to set the track
            // parameters
            actsTrack.parameters() = parameters.parameters();
            actsTrack.covariance() = *parameters.covariance();
            actsTrack.setReferenceSurface(parameters.referenceSurface().getSharedPtr());
            first_tsos = false;
          } else {
            actsTSOS.setReferenceSurface(parameters.referenceSurface().getSharedPtr());
            // Since we're converting final Trk::Tracks, let's assume they're smoothed
            actsTSOS.smoothed() = parameters.parameters();
            if (parameters.covariance().has_value()) {
              actsTSOS.smoothedCovariance() = *parameters.covariance();
            }
            else {
              actsTSOS.smoothedCovariance() = Acts::BoundMatrix::Zero();
            }
            // Not yet implemented in MultiTrajectory.icc
            // actsTSOS.typeFlags().setHasParameters();
            if (!(actsTSOS.hasSmoothed() && actsTSOS.hasReferenceSurface())) {
              ATH_MSG_WARNING("TrackState does not have smoothed state ["
                              << actsTSOS.hasSmoothed()
                              << "] or reference surface ["
                              << actsTSOS.hasReferenceSurface() << "].");
            } else {
              ATH_MSG_VERBOSE("TrackState has smoothed state and reference surface.");
            }
          }
        } catch (const std::exception& e){
          ATH_MSG_ERROR("Unable to convert TrackParameter with exception ["<<e.what()<<"]. Will be missing from ACTS track."
                        <<(*tsos->trackParameters()));
        }
      }
      if (tsos->measurementOnTrack()) {
        auto &measurement = *(tsos->measurementOnTrack());
        actsTSOS.typeFlags().setIsMeasurement();
 
        measurementsCount++;
        // const Acts::Surface &surface =
        //     convertSurfaceToActs(measurement.associatedSurface());
        //  Commented for the moment because Surfaces not yet implemented in
        //  MultiTrajectory.icc
 
        int dim = measurement.localParameters().dimension();
        actsTSOS.allocateCalibrated(dim); 
        if (dim == 1) {
          actsTSOS.calibrated<1>() = measurement.localParameters();
          actsTSOS.calibratedCovariance<1>() = measurement.localCovariance();
        } else if (dim == 2) {
          actsTSOS.calibrated<2>() = measurement.localParameters();
          actsTSOS.calibratedCovariance<2>() = measurement.localCovariance();
        } else {
          throw std::domain_error("Cannot handle measurement dim>2");
        }
        actsTSOS.setUncalibratedSourceLink(detail::TrkMeasurementCalibrator::pack(tsos->measurementOnTrack()));
 
      }  // end if measurement
    }    // end loop over track states
    actsTrack.nMeasurements() = measurementsCount;
    ATH_MSG_VERBOSE("TrackProxy has " << actsTrack.nTrackStates()
                                 << " track states on surfaces.");
  }
  ATH_MSG_VERBOSE("Finished converting " << trackColl.size() << " tracks.");
 
  if (!failedIds.empty()){
    ATH_MSG_WARNING("Failed to convert "<<failedIds.size()<<" track parameters.");
    for (auto id : failedIds){
      ATH_MSG_WARNING("-> Failed for Identifier "<<m_idHelperSvc->toString(id));
    }
  }
  ATH_MSG_VERBOSE("ACTS Track container has " << outTrackcoll.size() << " tracks.");
}

fetchPrd()

template<typename PrdType_t>

const Trk::PrepRawData * ActsTrk::ActsToTrkConverterTool::fetchPrd ( const EventContext & ctx, const SG::ReadHandleKey< PrdType_t > & key, const Identifier & prdId, const IdentifierHash & hash ) const

private

Searches a Prd object from a collection according to the measurement's Identifier and the container's hash.

Parameters

ctx	EventContext to retrieve the container from StoreGate
key	ReadHandleKey specifying which container is to be fetched
prdId	Identifier of the measurement to retrieve
hash	The associated IdentifierHash to look-up the collection

Definition at line 487 of file ActsToTrkConverterTool.cxx.

                                                                                            {
      const PrdType_t* container{nullptr};
      if (key.empty() || !SG::get(container, key, ctx).isSuccess()) {
          THROW_EXCEPTION("Failed to retrieve container "<<key.fullKey());
      }
      const auto* coll = container->indexFindPtr(hash);
      if (coll == nullptr){
          ATH_MSG_WARNING("fetchPrd() - Failed to find a valid collection for "<<prdId.getString()<<", key: "<<key.fullKey());
          return nullptr;
      }
      for (const Trk::PrepRawData* prd : *coll) {
          if (prd->identify() == prdId) {
              return prd;
          }
      }
      ATH_MSG_WARNING("fetchPrd() - Prep data object "<<prdId.getString()<<" is not in "<<key.fullKey());
      return nullptr;
  }

initialize()

StatusCode ActsTrk::ActsToTrkConverterTool::initialize ( )

overridevirtual

Definition at line 68 of file ActsToTrkConverterTool.cxx.

                                              {
  ATH_MSG_DEBUG("Initializing ACTS to ATLAS converter tool");
  
  ATH_CHECK(m_trkSummaryTool.retrieve());
  ATH_CHECK(m_ROTcreator.retrieve());
  ATH_CHECK(m_geometryConvTool.retrieve());
  ATH_CHECK(m_ctxProvider.initialize());
  m_prdCalib = detail::TrkPrepRawDataCalibrator{m_geometryConvTool.get(), m_ROTcreator.get()};
  ATH_CHECK(m_keyMdt.initialize(SG::AllowEmpty));
  ATH_CHECK(m_keyRpc.initialize(SG::AllowEmpty));
  ATH_CHECK(m_keyTgc.initialize(SG::AllowEmpty));
  ATH_CHECK(m_keyMm.initialize(SG::AllowEmpty));
  ATH_CHECK(m_keyStgc.initialize(SG::AllowEmpty));
  ATH_CHECK(m_pixelKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_sctKey.initialize(SG::AllowEmpty));
  
  if (!m_keyMdt.empty() || !m_keyRpc.empty() || !m_keyTgc.empty() ||
      !m_keyMm.empty() || !m_keyStgc.empty()) {
    ATH_CHECK(m_idHelperSvc.retrieve());
  }
  ATH_CHECK(m_compRotCreator.retrieve(EnableTool{!m_keyRpc.empty() || !m_keyTgc.empty()}));
  return StatusCode::SUCCESS;
}

trkTrackToSourceLinks()

std::vector< Acts::SourceLink > ActsTrk::ActsToTrkConverterTool::trkTrackToSourceLinks ( const Trk::Track & track ) const

overridevirtual

Converts the Trk measurement track states into a vector of Acts::Source links.

The source links don't take ownership over the measurement states.

Parameters

track

Reference to the track to convert

Definition at line 93 of file ActsToTrkConverterTool.cxx.

                                                                         {
  std::vector<Acts::SourceLink> sourceLinks{};
  sourceLinks.reserve(track.measurementsOnTrack()->size() +
                      track.outliersOnTrack()->size());
  detail::MeasurementCalibratorBase::pack(track.measurementsOnTrack()->stdcont(), sourceLinks);
  detail::MeasurementCalibratorBase::pack(track.outliersOnTrack()->stdcont(), sourceLinks);
  return sourceLinks;
}

Member Data Documentation

m_compRotCreator

ToolHandle<Muon::IMuonCompetingClustersOnTrackCreator> ActsTrk::ActsToTrkConverterTool::m_compRotCreator {this, "CompetingRotCreator", ""}

private

Definition at line 139 of file ActsToTrkConverterTool.h.

{this, "CompetingRotCreator", ""};  //<! competing clusters rio ontrack creator

m_convertHoles

Gaudi::Property<bool> ActsTrk::ActsToTrkConverterTool::m_convertHoles {this, "convertHoles", true }

private

Flag to convert the hole states.

Definition at line 123 of file ActsToTrkConverterTool.h.

{this, "convertHoles", true };

m_convertMaterial

Gaudi::Property<bool> ActsTrk::ActsToTrkConverterTool::m_convertMaterial {this, "convertMaterial", false}

private

Flag to convert the material states (non sensitive) Acts -> Trk conversion.

Definition at line 127 of file ActsToTrkConverterTool.h.

{this, "convertMaterial", false};

m_convertOutliers

Gaudi::Property<bool> ActsTrk::ActsToTrkConverterTool::m_convertOutliers {this, "convertOutliers", true}

private

Flag to convert the outlier states.

Definition at line 125 of file ActsToTrkConverterTool.h.

{this, "convertOutliers", true};

m_ctxProvider

ContextUtility ActsTrk::ActsToTrkConverterTool::m_ctxProvider {this}

private

Utility to fetch the geometry, magnetic field and calibration context in the event.

Definition at line 117 of file ActsToTrkConverterTool.h.

{this};

m_fitAuthor

Trk::TrackInfo::TrackFitter ActsTrk::ActsToTrkConverterTool::m_fitAuthor {Trk::TrackInfo::TrackFitter::GlobalChi2Fitter}

private

Definition at line 144 of file ActsToTrkConverterTool.h.

{Trk::TrackInfo::TrackFitter::GlobalChi2Fitter};

m_geometryConvTool

PublicToolHandle<IGeometryRealmConvTool> ActsTrk::ActsToTrkConverterTool::m_geometryConvTool {this, "GeometryRealmConvTool", ""}

private

Definition at line 114 of file ActsToTrkConverterTool.h.

{this, "GeometryRealmConvTool", ""};

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> ActsTrk::ActsToTrkConverterTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 129 of file ActsToTrkConverterTool.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_keyMdt

SG::ReadHandleKey<Muon::MdtPrepDataContainer> ActsTrk::ActsToTrkConverterTool::m_keyMdt {this, "MdtKey", "MDT_DriftCircles"}

private

Definition at line 131 of file ActsToTrkConverterTool.h.

{this, "MdtKey", "MDT_DriftCircles"};

m_keyMm

SG::ReadHandleKey<Muon::MMPrepDataContainer> ActsTrk::ActsToTrkConverterTool::m_keyMm {this, "MmKey", "MM_Measurements"}

private

Definition at line 134 of file ActsToTrkConverterTool.h.

{this, "MmKey", "MM_Measurements"};

m_keyRpc

SG::ReadHandleKey<Muon::RpcPrepDataContainer> ActsTrk::ActsToTrkConverterTool::m_keyRpc {this, "RpcKey", "RPC_Measurements"}

private

Definition at line 132 of file ActsToTrkConverterTool.h.

{this, "RpcKey", "RPC_Measurements"};

m_keyStgc

SG::ReadHandleKey<Muon::sTgcPrepDataContainer> ActsTrk::ActsToTrkConverterTool::m_keyStgc {this, "sTgcKey", "STGC_Measurements"}

private

Definition at line 135 of file ActsToTrkConverterTool.h.

{this, "sTgcKey", "STGC_Measurements"};

m_keyTgc

SG::ReadHandleKey<Muon::TgcPrepDataContainer> ActsTrk::ActsToTrkConverterTool::m_keyTgc {this, "TgcKey", "TGC_MeasurementsAllBCs"}

private

Definition at line 133 of file ActsToTrkConverterTool.h.

{this, "TgcKey", "TGC_MeasurementsAllBCs"};

m_measCalib

detail::TrkMeasurementCalibrator ActsTrk::ActsToTrkConverterTool::m_measCalib {}

private

Definition at line 141 of file ActsToTrkConverterTool.h.

{};

m_pixelKey

SG::ReadHandleKey<InDet::PixelClusterContainer> ActsTrk::ActsToTrkConverterTool::m_pixelKey {this, "PixelKey", "ITkPixelClusters" }

private

Definition at line 136 of file ActsToTrkConverterTool.h.

{this, "PixelKey", "ITkPixelClusters" };

m_prdCalib

detail::TrkPrepRawDataCalibrator ActsTrk::ActsToTrkConverterTool::m_prdCalib {}

private

Definition at line 142 of file ActsToTrkConverterTool.h.

{};

m_ROTcreator

ToolHandle<Trk::IRIO_OnTrackCreator> ActsTrk::ActsToTrkConverterTool::m_ROTcreator {this, "RotCreatorTool", ""}

private

Definition at line 120 of file ActsToTrkConverterTool.h.

{this, "RotCreatorTool", ""};

m_sctKey

SG::ReadHandleKey<InDet::SCT_ClusterContainer> ActsTrk::ActsToTrkConverterTool::m_sctKey {this, "SctKey", "ITkStripClusters" }

private

Definition at line 137 of file ActsToTrkConverterTool.h.

{this, "SctKey", "ITkStripClusters" };

m_trkSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> ActsTrk::ActsToTrkConverterTool::m_trkSummaryTool {this, "SummaryTool", "", "ToolHandle for track summary tool"}

private

Tools needed to create Trk::Tracks from the ACts fit result.

Definition at line 119 of file ActsToTrkConverterTool.h.

{this, "SummaryTool", "", "ToolHandle for track summary tool"};

---

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

• ActsToTrkConverterTool.h
• ActsToTrkConverterTool.cxx