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 SurfacePtr_t	actsSurfaceToTrkSurface (const EventContext &ctx, const Acts::Surface &actsSurface) const override
	Find the ATLAS surface corresponding to the Acts surface Only work if the Acts surface has an associated detector element (Pixel and SCT).
virtual std::shared_ptr< const Acts::Surface >	trkSurfaceToActsSurface (const Trk::Surface &atlasSurface) const override
	Find the Acts surface corresponding to the ATLAS surface Use a map associating ATLAS ID to Acts surfaces (Pixel and SCT).
virtual std::vector< Acts::SourceLink >	trkTrackToSourceLinks (const Trk::Track &track) const override
	Transform an ATLAS track into a vector of SourceLink to be use in the avts tracking Transform both measurement and outliers.
virtual void	toSourceLinks (const std::vector< const Trk::MeasurementBase * > &measSet, std::vector< Acts::SourceLink > &links) const override final
virtual void	toSourceLinks (const std::vector< const Trk::PrepRawData * > &prdSet, std::vector< Acts::SourceLink > &links) const override final
virtual std::unique_ptr< Trk::Track >	convertFitResult (const EventContext &ctx, TrackFitResult_t &fitResult, const Trk::TrackInfo::TrackFitter fitAuthor, const detail::SourceLinkType slType) const override final
virtual const Acts::BoundTrackParameters	trkTrackParametersToActsParameters (const Trk::TrackParameters &atlasParameter, const Acts::GeometryContext &gctx, Trk::ParticleHypothesis=Trk::pion) const override
	Create Acts TrackParameter from ATLAS one.
virtual std::unique_ptr< Trk::TrackParameters >	actsTrackParametersToTrkParameters (const EventContext &ctx, const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext &gctx) const override
	Create ATLAS TrackParameter from Acts one.
virtual void	trkTrackCollectionToActsTrackContainer (ActsTrk::MutableTrackContainer &tc, const TrackCollection &trackColl, const Acts::GeometryContext &gctx) const override
	Convert TrackCollection to Acts track container.
virtual std::unique_ptr< TrackCollection >	convertActsToTrkContainer (const EventContext &ctx, const ActsTrk::TrackContainer &trackCont) const override final

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 detail::SourceLinkType slType) const
	Helper function to convert a Acts TrackPoxy (which may be const or not) into a Trk::Track.
std::shared_ptr< Trk::SurfaceBounds >	translateBounds (const Acts::SurfaceBounds &bounds) const
SurfacePtr_t	translateFreeSurface (const Acts::Surface &surface) const
	Translate a surface that is not associated with any detector element.
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< ActsTrk::ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}
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", ""}
std::shared_ptr< const Acts::TrackingGeometry >	m_trackingGeometry {}
std::unordered_map< Identifier, std::shared_ptr< const Acts::Surface > >	m_actsSurfaceMap {}
Gaudi::Property< bool >	m_visualDebugOutput
Gaudi::Property< bool >	m_extractMuonSurfaces
Gaudi::Property< int >	m_sourceLinkType
	Source link sepcification used when the ActTrk container -> Trk container conversion is called.
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"}
ToolHandle< Muon::IMuonCompetingClustersOnTrackCreator >	m_compRotCreator {this, "CompetingRotCreator", ""}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muonMgrKey {this, "MuonManagerKey", "MuonDetectorManager"}
	Detector manager to fetch the legacy Trk surfaces.
detail::SourceLinkType	m_slType {detail::SourceLinkType::nTypes}
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 123 of file ActsToTrkConverterTool.h.

Member Function Documentation

actsSurfaceToTrkSurface()

SurfacePtr_t ActsTrk::ActsToTrkConverterTool::actsSurfaceToTrkSurface ( const EventContext & ctx, const Acts::Surface & actsSurface ) const

overridevirtual

Find the ATLAS surface corresponding to the Acts surface Only work if the Acts surface has an associated detector element (Pixel and SCT).

Produce a new free surface

Definition at line 210 of file ActsToTrkConverterTool.cxx.

                                                                                                   {
 
  const auto *detEleBase= dynamic_cast<const IDetectorElementBase*>(actsSurface.surfacePlacement());
  if (!detEleBase) {
     return translateFreeSurface(actsSurface);
  }
  switch (detEleBase->detectorType()) {
      using enum DetectorType;
      case Pixel:
      case Sct:
      case Hgtd:
      case Trt: {
        const auto actsElement = dynamic_cast<const ActsDetectorElement*>(detEleBase);
        if (actsElement) {
            return SurfacePtr_t{&actsElement->atlasSurface()};
        }
        break;
      }
      case Mdt:
      case Rpc:
      case Tgc:
      case Csc:
      case sTgc:
      case Mm: {
        const MuonGM::MuonDetectorManager* detMgr{nullptr};
        if (!SG::get(detMgr, m_muonMgrKey, ctx).isSuccess() || !detMgr) {
            THROW_EXCEPTION("Failed to retrieve the muon detector manager");
        }
        return SurfacePtr_t{&detMgr->getReadoutElement(detEleBase->identify())->surface(detEleBase->identify())};
      
      } default:
        break;
  }
  return translateFreeSurface(actsSurface);
}

actsTrackParameterPositionCheck()

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

private

Definition at line 657 of file ActsToTrkConverterTool.cxx.

                                           {
  auto actsPos = parameters.position(gctx);
  // ATH_MSG_VERBOSE("Acts position: \n"
  //                   << actsPos << " vs trk position: \n"
  //                   << trkparameters.position());
  // ATH_MSG_VERBOSE(parameters.referenceSurface().toString(gctx));
  // ATH_MSG_VERBOSE("GeometryId "<<parameters.referenceSurface().geometryId().value());  
 
  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;
}

actsTrackParametersToTrkParameters()

std::unique_ptr< Trk::TrackParameters > ActsTrk::ActsToTrkConverterTool::actsTrackParametersToTrkParameters ( const EventContext & ctx, const Acts::BoundTrackParameters & actsParameter, const Acts::GeometryContext & gctx ) const

overridevirtual

Create ATLAS TrackParameter from Acts one.

Take care of unit conversion between the two.

Convert to free parameters

Back conversion to bound parameters of the helper plane

Definition at line 363 of file ActsToTrkConverterTool.cxx.

                                           {
 
  std::optional<AmgSymMatrix(5)> cov = std::nullopt;
  if (actsParameter.covariance()) {
    AmgSymMatrix(5) newcov(actsParameter.covariance()->topLeftCorner<5, 5>());
    // Convert the covariance matrix to GeV
    for (int i = 0; i < newcov.rows(); i++) {
      newcov(i, 4) = newcov(i, 4) * 1_MeV;
    }
    for (int i = 0; i < newcov.cols(); i++) {
      newcov(4, i) = newcov(4, i) * 1_MeV;
    }
    cov = newcov;
  }
 
  const Acts::Surface &actsSurface = actsParameter.referenceSurface();
  SurfacePtr_t trkSurface = actsSurfaceToTrkSurface(ctx, actsSurface);
  switch (actsSurface.type()) {
    case Acts::Surface::SurfaceType::Cone: {
      const auto &coneSurface = static_cast<const Trk::ConeSurface&>(*trkSurface);
      return std::make_unique<Trk::AtaCone>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, coneSurface, cov);
    } case Acts::Surface::SurfaceType::Cylinder: {
      const auto &cylSurface{static_cast<const Trk::CylinderSurface&>(*trkSurface)};
      return std::make_unique<Trk::AtaCylinder>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, cylSurface, cov);
    } case Acts::Surface::SurfaceType::Disc: {
      if (trkSurface->type() == Trk::SurfaceType::Disc) {
         const auto& discSurface{static_cast<const Trk::DiscSurface&>(*trkSurface)};
         return std::make_unique<Trk::AtaDisc>(
              actsParameter.get<Acts::eBoundLoc0>(),
              actsParameter.get<Acts::eBoundLoc1>(),
              actsParameter.get<Acts::eBoundPhi>(),
              actsParameter.get<Acts::eBoundTheta>(),
              actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, discSurface, cov);
      } else if (trkSurface->type() == Trk::SurfaceType::Plane) {
        auto& planeSurface{static_cast<const Trk::PlaneSurface&>(*trkSurface)};
        // need to convert to plane position on plane surface (annulus bounds)
        auto helperSurface = Acts::Surface::makeShared<Acts::PlaneSurface>(planeSurface.transform());
 
        auto covpc = actsParameter.covariance().value();
        Acts::FreeVector freePars = Acts::transformBoundToFreeParameters(actsSurface, gctx, 
                                                                         actsParameter.parameters());

        Acts::BoundVector targetPars = Acts::transformFreeToBoundParameters(freePars,
                                                  *helperSurface, gctx).value();
        
        Acts::FreeMatrix freeTransportJacobian{Acts::FreeMatrix::Identity()};
 
        Acts::FreeVector freeToPathDerivatives{Acts::FreeVector::Zero()};
        freeToPathDerivatives.head<3>() = freePars.segment<3>(Acts::eFreeDir0);
 
        auto boundToFreeJacobian = actsSurface.boundToFreeJacobian(gctx, freePars.segment<3>(Acts::eFreePos0),
                                                                   freePars.segment<3>(Acts::eFreeDir0));
 
        Acts::BoundMatrix boundToBoundJac = Acts::detail::boundToBoundTransportJacobian(gctx, freePars, 
                  boundToFreeJacobian, freeTransportJacobian, freeToPathDerivatives, *helperSurface);
 
        Acts::BoundMatrix targetCov{boundToBoundJac * covpc * boundToBoundJac.transpose()};
 
        auto pars = std::make_unique<Trk::AtaPlane>(
            targetPars[Acts::eBoundLoc0], targetPars[Acts::eBoundLoc1],
            targetPars[Acts::eBoundPhi], targetPars[Acts::eBoundTheta],
            targetPars[Acts::eBoundQOverP] * 1_MeV, planeSurface,
            targetCov.topLeftCorner<5, 5>());
 
        if (m_visualDebugOutput) {
          ActsTrackParameterCheck(actsParameter, gctx, covpc, targetPars,
                                  targetCov, &planeSurface);
        }
        return pars;
 
      } else {
        throw std::domain_error("Acts::DiscSurface is not associated with ATLAS disc or plane surface");
      }
      break;
    } case Acts::Surface::SurfaceType::Perigee: {
      const auto& perSurface = static_cast<const Trk::PerigeeSurface&>(*trkSurface);
      return std::make_unique<Trk::Perigee>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, perSurface, cov);
    } case Acts::Surface::SurfaceType::Plane: {
      auto &plaSurface{static_cast<const Trk::PlaneSurface&>(*trkSurface)};
      return std::make_unique<Trk::AtaPlane>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, plaSurface, cov);
    } case Acts::Surface::SurfaceType::Straw: {
      auto& lineSurface{static_cast<const Trk::StraightLineSurface&>(*trkSurface)};
      return std::make_unique<Trk::AtaStraightLine>(
          actsParameter.get<Acts::eBoundLoc0>(),
          actsParameter.get<Acts::eBoundLoc1>(),
          actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, lineSurface, cov);
    } case Acts::Surface::SurfaceType::Curvilinear: {
      return std::make_unique<Trk::CurvilinearParameters>(
          actsParameter.position(gctx), actsParameter.get<Acts::eBoundPhi>(),
          actsParameter.get<Acts::eBoundTheta>(),
          actsParameter.get<Acts::eBoundQOverP>() * 1_MeV, cov);
    } case Acts::Surface::SurfaceType::Other: {
      break;
    }
  }
  throw std::domain_error("Surface type not found");
}

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 961 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_pixelLink("pixelClusterLink");
          if (acc_pixelLink.isAvailable(*meas) && acc_pixelLink(*meas).isValid()) {
              rot.reset(m_ROTcreator->correct(**acc_pixelLink(*meas), *trkPars, ctx));
          }
          break;
        } case StripClusterType: {
          static const SG::AuxElement::ConstAccessor<ElementLink<InDet::SCT_ClusterCollection>> acc_stripLink("sctClusterLink");
          if (acc_stripLink.isAvailable(*meas) && acc_stripLink(*meas).isValid()) {
              rot.reset(m_ROTcreator->correct(**acc_stripLink(*meas), *trkPars, ctx));
          }
          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("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("Measurement type "<<meas->type()<<" is not implemented");
          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));
 
  }

convertActsToTrkContainer()

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

finaloverridevirtual

Definition at line 953 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, m_slType));
      }
      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 detail::SourceLinkType slType ) 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
slType	Source link type to deduct which ATLAS EDM to be used

Definition at line 863 of file ActsToTrkConverterTool.cxx.

                                                                                     {
 
 
    const Acts::CalibrationContext cctx{getCalibrationContext(ctx)};
    const Acts::GeometryContext gctx{m_trackingGeometryTool->getGeometryContext(ctx).context()};
   
    auto finalTrajectory = std::make_unique<Trk::TrackStates>();
    int nDoF{0};
 
    double chi2{0};
 
    // 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;
        }
 
        if (const auto* associatedDetEl = dynamic_cast<const IDetectorElementBase*>(
                                        state.referenceSurface().surfacePlacement());
            associatedDetEl != nullptr) {
            ATH_MSG_VERBOSE("Associated det: "<<associatedDetEl->detectorType());
        }
 
        auto flag = state.typeFlags();
    
        // We need to determine the type of state 
        TrkTSOSMask typePattern;
        std::unique_ptr<Trk::TrackParameters> trkPars = actsTrackParametersToTrkParameters(ctx, 
                                                              acts_track.createParametersFromState(state), gctx);
        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();
          switch (slType) {
              using enum detail::SourceLinkType;
              case TrkMeasurement: 
                trkMeasurement = m_measCalib.unpack(state.getUncalibratedSourceLink())->uniqueClone();
                break;
              case TrkPrepRawData:
                trkMeasurement = m_prdCalib.createROT(gctx, 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));
      });
      // Convert the perigee state and add it to the trajectory
      std::unique_ptr<Trk::TrackParameters> per = actsTrackParametersToTrkParameters(ctx, acts_track.createParametersAtReference(), gctx);
      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), nullptr);
      constexpr bool suppressHoleSearch = false;
      m_trkSummaryTool->updateTrackSummary(ctx, *newtrack, suppressHoleSearch);
      return newtrack;
  }

convertFitResult()

std::unique_ptr< Trk::Track > ActsTrk::ActsToTrkConverterTool::convertFitResult ( const EventContext & ctx, TrackFitResult_t & fitResult, const Trk::TrackInfo::TrackFitter fitAuthor, const detail::SourceLinkType slType ) const

finaloverridevirtual

Definition at line 849 of file ActsToTrkConverterTool.cxx.

                                                                                                              {
 
    if (not fitResult.ok()) {
      ATH_MSG_VERBOSE("Fit did not converge");  
      return nullptr;    
    }
    return convertActsTrack(ctx, fitResult.value(), fitAuthor, slType);
}

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 1060 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 123 of file ActsToTrkConverterTool.cxx.

                                              {
  ATH_MSG_DEBUG("Initializing ACTS to ATLAS converter tool");
  if (!m_trackingGeometryTool.empty()) {
    ATH_CHECK(m_trackingGeometryTool.retrieve());
    m_trackingGeometry = m_trackingGeometryTool->trackingGeometry();
 
    m_trackingGeometry->visitSurfaces([&](const Acts::Surface *surface) {
      // find acts surface with the same detector element ID
      if (!surface)
        return;
      const auto *actsElement = dynamic_cast<const IDetectorElementBase*>(
          surface->surfacePlacement());
      if (!actsElement) {
        return;
      }
      // Conversion from Acts to ATLAS surface impossible for the TRT so the TRT
      // surfaces are not stored in this map
      if (actsElement->detectorType() == DetectorType::Trt) {
          return;
      }
 
      auto [it, ok] =  m_actsSurfaceMap.insert(std::make_pair(actsElement->identify(), surface->getSharedPtr()));
      if (!ok) {
        ATH_MSG_WARNING("ATLAS ID " << actsElement->identify()
                                    << " has two ACTS surfaces: "
                                    << it->second->geometryId() << " and "
                                    << surface->geometryId());
      }
    });
  }
 
  ATH_CHECK(m_trkSummaryTool.retrieve());
  ATH_CHECK(m_ROTcreator.retrieve());
  m_prdCalib = detail::TrkPrepRawDataCalibrator{this, m_ROTcreator.get()};
  m_slType = static_cast<detail::SourceLinkType>(m_sourceLinkType.value());
  ATH_CHECK(m_muonMgrKey.initialize(m_extractMuonSurfaces));
  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_compRotCreator.retrieve(EnableTool{!m_keyRpc.empty() || !m_keyTgc.empty()}));
  if (m_extractMuonSurfaces){
    ATH_CHECK(m_idHelperSvc.retrieve());
    const MuonGMR4::MuonDetectorManager* muonMgr{nullptr};    
    ATH_CHECK(detStore()->retrieve(muonMgr));
    unsigned int mapSize = m_actsSurfaceMap.size(); // For debugging message later
    for (auto readoutElement : muonMgr->getAllReadoutElements()) {
      std::vector<std::shared_ptr<Acts::Surface>> reSurfaces = readoutElement->getSurfaces();
      for ( const auto& surf : reSurfaces) {
        const Identifier id = static_cast<const SurfaceCache*>(surf->surfacePlacement())->identify();
        m_actsSurfaceMap.insert(std::make_pair(id, surf));
      }
    }
    ATH_MSG_VERBOSE("After adding muon surfaces, the map has grown from "<<mapSize<<" to "<<m_actsSurfaceMap.size());
  }
  return StatusCode::SUCCESS;
}

toSourceLinks() [1/2]

void ActsTrk::ActsToTrkConverterTool::toSourceLinks ( const std::vector< const Trk::MeasurementBase * > & measSet, std::vector< Acts::SourceLink > & links ) const

finaloverridevirtual

Definition at line 286 of file ActsToTrkConverterTool.cxx.

                                                                                        {
    if (sourceLinks.capacity() < sourceLinks.size() + measSet.size()) {
      sourceLinks.reserve(sourceLinks.size() + measSet.size());
    }
    std::ranges::transform(measSet, std::back_inserter(sourceLinks), [](const Trk::MeasurementBase* meas) {
                             return detail::TrkMeasurementCalibrator::pack(meas);
                          });
}

toSourceLinks() [2/2]

void ActsTrk::ActsToTrkConverterTool::toSourceLinks ( const std::vector< const Trk::PrepRawData * > & prdSet, std::vector< Acts::SourceLink > & links ) const

finaloverridevirtual

Definition at line 295 of file ActsToTrkConverterTool.cxx.

                                                                                   {
    if (links.capacity() < links.size() + prdSet.size()) {
      links.reserve(links.size() + prdSet.size());
    }
    std::ranges::transform(prdSet, std::back_inserter(links), [](const Trk::PrepRawData* prd) {
                            return detail::TrkPrepRawDataCalibrator::pack(prd);
                          });
}

translateBounds()

std::shared_ptr< Trk::SurfaceBounds > ActsTrk::ActsToTrkConverterTool::translateBounds ( const Acts::SurfaceBounds & bounds ) const

private

Definition at line 613 of file ActsToTrkConverterTool.cxx.

                                                                                 {
    switch (bounds.type()) {
      using enum Acts::SurfaceBounds::BoundsType;
      case eRectangle:{
        using ParEnum_t = Acts::RectangleBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::RectangleBounds&>(bounds);
        return std::make_shared<Trk::RectangleBounds>(cBounds.get(ParEnum_t::eMaxX), 
                                                      cBounds.get(ParEnum_t::eMaxY));
      } case eTrapezoid: {
        using ParEnum_t = Acts::TrapezoidBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::TrapezoidBounds&>(bounds);
        return std::make_shared<Trk::TrapezoidBounds>(cBounds.get(ParEnum_t::eHalfLengthXnegY),
                                                      cBounds.get(ParEnum_t::eHalfLengthXposY),
                                                      cBounds.get(ParEnum_t::eHalfLengthY));
   
      } case eDisc: {
        using ParEnum_t = Acts::RadialBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::RadialBounds&>(bounds);
        return std::make_shared<Trk::DiscBounds>(cBounds.get(ParEnum_t::eMinR),
                                                 cBounds.get(ParEnum_t::eMaxR),
                                                 cBounds.get(ParEnum_t::eAveragePhi),
                                                 cBounds.get(ParEnum_t::eHalfPhiSector));
 
      } case eCylinder: {
        using ParEnum_t = Acts::CylinderBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::CylinderBounds&>(bounds);
        return std::make_shared<Trk::CylinderBounds>(cBounds.get(ParEnum_t::eR),
                                                     cBounds.get(ParEnum_t::eHalfPhiSector),
                                                     cBounds.get(ParEnum_t::eAveragePhi),
                                                     cBounds.get(ParEnum_t::eHalfLengthZ));
      } case eLine: {
        using ParEnum_t = Acts::LineBounds::BoundValues;
        const auto& cBounds = static_cast<const Acts::LineBounds&>(bounds);
        return std::make_shared<Trk::CylinderBounds>(cBounds.get(ParEnum_t::eR),
                                                     cBounds.get(ParEnum_t::eHalfLengthZ));
      } default:
          break;
      
    }
    THROW_EXCEPTION("The bounds "<<bounds<<" cannot be translated");
    return nullptr;
}

translateFreeSurface()

SurfacePtr_t ActsTrk::ActsToTrkConverterTool::translateFreeSurface ( const Acts::Surface & surface ) const

private

Translate a surface that is not associated with any detector element.

Bounds of the surface are also translated

Parameters

surface

Reference to the Acts surface for translation

Definition at line 182 of file ActsToTrkConverterTool.cxx.

                                                                                          {
  const ActsTrk::GeometryContext gctx{};
  const Amg::Transform3D& trf{surface.localToGlobalTransform(gctx.context())};
  switch (surface.type()) {
      using enum Acts::Surface::SurfaceType;
      case Plane:
        return SurfacePtr_t{new Trk::PlaneSurface(trf, translateBounds(surface.bounds()))};
      case Cylinder:
          return SurfacePtr_t{new Trk::CylinderSurface(trf,
                 std::dynamic_pointer_cast<Trk::CylinderBounds>(translateBounds(surface.bounds())))};
      case Perigee:
          return SurfacePtr_t{new Trk::PerigeeSurface(trf)};
      case Disc:
          return SurfacePtr_t{new Trk::DiscSurface(trf,
                 std::dynamic_pointer_cast<Trk::DiscBounds>(translateBounds(surface.bounds())))};
      case Straw: {
          auto bounds = std::dynamic_pointer_cast<Trk::CylinderBounds>(translateBounds(surface.bounds()));
          return SurfacePtr_t{new Trk::StraightLineSurface(trf, bounds->r(), bounds->halflengthZ())};
      } default:
        break;
 
  }
  THROW_EXCEPTION("ActsToTrkConverterTool() - Surface cannot be translated " 
                  <<surface.toString(gctx.context()));
 
  return nullptr;
}

trkSurfaceToActsSurface()

std::shared_ptr< const Acts::Surface > ActsTrk::ActsToTrkConverterTool::trkSurfaceToActsSurface ( const Trk::Surface & atlasSurface ) const

overridevirtual

Find the Acts surface corresponding to the ATLAS surface Use a map associating ATLAS ID to Acts surfaces (Pixel and SCT).

Definition at line 249 of file ActsToTrkConverterTool.cxx.

                                                                                      {
 
  Identifier atlasID = atlasSurface.associatedDetectorElementIdentifier();
  auto it = m_actsSurfaceMap.find(atlasID);
  if (it != m_actsSurfaceMap.end()) {
    return it->second;
  }
  const Amg::Transform3D& trf{atlasSurface.transform()};
  switch (atlasSurface.type()){
      using enum Trk::SurfaceType;
      case Plane:
        return Acts::Surface::makeShared<Acts::PlaneSurface>(trf);
      case Perigee:
        return Acts::Surface::makeShared<Acts::PerigeeSurface>(trf);
      case Line:
        return Acts::Surface::makeShared<Acts::StrawSurface>(trf);
      // TODO - implement the missing types?
      default: {
        break;
      }
  }
  std::stringstream surfStr{};
  atlasSurface.dump(surfStr);  
  throw std::domain_error(std::format("Failed to translate surface {:}", surfStr.str()));
}

trkTrackCollectionToActsTrackContainer()

void ActsTrk::ActsToTrkConverterTool::trkTrackCollectionToActsTrackContainer ( ActsTrk::MutableTrackContainer & tc, const TrackCollection & trackColl, const Acts::GeometryContext & gctx ) const

overridevirtual

Convert TrackCollection to Acts track container.

Parameters

tc	The track container to fill

Definition at line 488 of file ActsToTrkConverterTool.cxx.

                                                                                                            {
  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 = tc.getTrack(tc.addTrack());
    auto& trackStateContainer = tc.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 =
              trkTrackParametersToActsParameters(*(tsos->trackParameters()), gctx);
          ATH_MSG_VERBOSE("Track parameters: " << parameters.parameters());
          // Sanity check on positions
          if (!actsTrackParameterPositionCheck(parameters, *(tsos->trackParameters()), gctx)){
            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();
            actsTSOS.smoothedCovariance() = *parameters.covariance();
            // 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());
 
        measurementsCount++;
        // const Acts::Surface &surface =
        //     trkSurfaceToActsSurface(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 " << tc.size() << " tracks.");
}

trkTrackParametersToActsParameters()

const Acts::BoundTrackParameters ActsTrk::ActsToTrkConverterTool::trkTrackParametersToActsParameters ( const Trk::TrackParameters & atlasParameter, const Acts::GeometryContext & gctx, Trk::ParticleHypothesis hypothesis = Trk::pion ) const

overridevirtual

Create Acts TrackParameter from ATLAS one.

Take care of unit conversion between the two.

Definition at line 306 of file ActsToTrkConverterTool.cxx.

                                                                                                   {
 
  std::shared_ptr<const Acts::Surface> actsSurface{};
  Acts::BoundVector params;
 
  // get the associated surface
  try {
      actsSurface = trkSurfaceToActsSurface(atlasParameter.associatedSurface());
  } catch (const std::exception &e) {
      ATH_MSG_ERROR("Could not find ACTS detector surface for this TrackParameter:");
      ATH_MSG_ERROR(atlasParameter);
      throw;  // Nothing we can do, so just pass exception on...
  }
 
  // Construct track parameters
  const auto& atlasParam{atlasParameter.parameters()};
  if (actsSurface->bounds().type() == Acts::SurfaceBounds::BoundsType::eAnnulus) {
    // Annulus surfaces are constructed differently in Acts/Trk so we need to
    // convert local coordinates
    const Amg::Vector3D& position{atlasParameter.position()};
    auto result = actsSurface->globalToLocal(gctx, position, atlasParameter.momentum());
    if (result.ok()) {
      params << (*result)[0], (*result)[1], atlasParam[Trk::phi0],
          atlasParam[Trk::theta],
          atlasParameter.charge() / (atlasParameter.momentum().mag() * 1_MeV),
          0.;
    } else {
      ATH_MSG_WARNING("Unable to convert annulus surface - globalToLocal failed");
    }
  } else {
    params << atlasParam[Trk::locX], atlasParam[Trk::locY],
             atlasParam[Trk::phi0], atlasParam[Trk::theta],
             atlasParameter.charge() / (atlasParameter.momentum().mag() * 1_MeV), 0.;
  }
 
  Acts::BoundMatrix cov = Acts::BoundMatrix::Identity();
  if (atlasParameter.covariance()) {
    cov.topLeftCorner(5, 5) = *atlasParameter.covariance();
 
    // Convert the covariance matrix from MeV
    // FIXME: This needs to handle the annulus case as well - currently the cov
    // is wrong for annulus surfaces
    for (int i = 0; i < cov.rows(); i++) {
      cov(i, 4) = cov(i, 4) / 1_MeV;
    }
    for (int i = 0; i < cov.cols(); i++) {
      cov(4, i) = cov(4, i) / 1_MeV;
    }
  }
 
  return Acts::BoundTrackParameters(actsSurface, params,cov, 
                                    ParticleHypothesis::convert(hypothesis));
}

trkTrackToSourceLinks()

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

overridevirtual

Transform an ATLAS track into a vector of SourceLink to be use in the avts tracking Transform both measurement and outliers.

Definition at line 276 of file ActsToTrkConverterTool.cxx.

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

Member Data Documentation

m_actsSurfaceMap

std::unordered_map<Identifier, std::shared_ptr<const Acts::Surface> > ActsTrk::ActsToTrkConverterTool::m_actsSurfaceMap {}

private

Definition at line 164 of file ActsToTrkConverterTool.h.

{};

m_compRotCreator

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

private

Definition at line 193 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 178 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 182 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 180 of file ActsToTrkConverterTool.h.

{this, "convertOutliers", true};

m_extractMuonSurfaces

Gaudi::Property<bool> ActsTrk::ActsToTrkConverterTool::m_extractMuonSurfaces

private

Initial value:

{this, "ExtractMuonSurfaces", false,
     "If True, use the MuonDetectorManager to extract the Muon surfaces"}

Definition at line 171 of file ActsToTrkConverterTool.h.

                                           {this, "ExtractMuonSurfaces", false,
     "If True, use the MuonDetectorManager to extract the Muon surfaces"};

m_fitAuthor

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

private

Definition at line 203 of file ActsToTrkConverterTool.h.

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

m_idHelperSvc

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

private

Definition at line 184 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 186 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 189 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 187 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 190 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 188 of file ActsToTrkConverterTool.h.

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

m_measCalib

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

private

Definition at line 200 of file ActsToTrkConverterTool.h.

{};

m_muonMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> ActsTrk::ActsToTrkConverterTool::m_muonMgrKey {this, "MuonManagerKey", "MuonDetectorManager"}

private

Detector manager to fetch the legacy Trk surfaces.

Definition at line 196 of file ActsToTrkConverterTool.h.

{this, "MuonManagerKey", "MuonDetectorManager"};

m_prdCalib

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

private

Definition at line 201 of file ActsToTrkConverterTool.h.

{};

m_ROTcreator

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

private

Definition at line 161 of file ActsToTrkConverterTool.h.

{this, "RotCreatorTool", ""};

m_slType

detail::SourceLinkType ActsTrk::ActsToTrkConverterTool::m_slType {detail::SourceLinkType::nTypes}

private

Definition at line 198 of file ActsToTrkConverterTool.h.

{detail::SourceLinkType::nTypes};

m_sourceLinkType

Gaudi::Property<int> ActsTrk::ActsToTrkConverterTool::m_sourceLinkType

private

Initial value:

{this, "SourceLinkType", 
                                        Acts::toUnderlying(detail::SourceLinkType::nTypes) }

Source link sepcification used when the ActTrk container -> Trk container conversion is called.

Definition at line 175 of file ActsToTrkConverterTool.h.

                                     {this, "SourceLinkType", 
                                        Acts::toUnderlying(detail::SourceLinkType::nTypes) };

m_trackingGeometry

std::shared_ptr<const Acts::TrackingGeometry> ActsTrk::ActsToTrkConverterTool::m_trackingGeometry {}

private

Definition at line 163 of file ActsToTrkConverterTool.h.

{};

m_trackingGeometryTool

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

private

Definition at line 157 of file ActsToTrkConverterTool.h.

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

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 160 of file ActsToTrkConverterTool.h.

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

m_visualDebugOutput

Gaudi::Property<bool> ActsTrk::ActsToTrkConverterTool::m_visualDebugOutput

private

Initial value:

{
     this, "VisualDebugOutput", false,
     "Print additional output for debug plots"}

Definition at line 166 of file ActsToTrkConverterTool.h.

                                         {
     this, "VisualDebugOutput", false,
     "Print additional output for debug plots"};

---

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

• ActsToTrkConverterTool.h
• ActsToTrkConverterTool.cxx