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 const Trk::Surface &	actsSurfaceToTrkSurface (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 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, ActsTrk::MutableTrackContainer &tracks, 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 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.

Private Member Functions
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::IBoundaryCheckTool >	m_boundaryCheckTool {this, "BoundaryCheckTool", "", "Boundary checking tool for detector sensitivities"}
ToolHandle< Trk::IRIO_OnTrackCreator >	m_ROTcreator {this, "RotCreatorTool", ""}
std::shared_ptr< const Acts::TrackingGeometry >	m_trackingGeometry {}
std::unordered_map< Identifier, const Acts::Surface * >	m_actsSurfaceMap {}
Gaudi::Property< bool >	m_visualDebugOutput
Gaudi::Property< bool >	m_extractMuonSurfaces
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muonMgrKey {this, "MuonManagerKey", "MuonDetectorManager"}
	Detector manager to fetch the legacy Trk surfaces.

Detailed Description

Definition at line 34 of file ActsToTrkConverterTool.h.

Member Function Documentation

actsSurfaceToTrkSurface()

const Trk::Surface & ActsTrk::ActsToTrkConverterTool::actsSurfaceToTrkSurface ( 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)

Definition at line 131 of file ActsToTrkConverterTool.cxx.

                                          {
 
  const auto *detEleBase= dynamic_cast<const IDetectorElementBase*>(actsSurface.associatedDetectorElement());
  if (!detEleBase) {
    ATH_MSG_ERROR(actsSurface.toString(m_trackingGeometryTool->getNominalGeometryContext().context()));
    throw std::domain_error("ActsToTrkConverterTool() - Surface does not have an associated detector element. ");
  }
  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 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, Gaudi::Hive::currentContext()).isSuccess() || !detMgr) {
            THROW_EXCEPTION("Failed to retrieve the muon detector manager");
        }
        return detMgr->getReadoutElement(detEleBase->identify())->surface(detEleBase->identify());
      
      } default:
        break;
  }
  throw std::domain_error("ActsToTrkConverterTool() - No ATLAS surface corresponding to the Acts one");
}

actsTrackParameterPositionCheck()

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

private

Definition at line 549 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 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 299 of file ActsToTrkConverterTool.cxx.

                                           {
 
  using namespace Acts::UnitLiterals;
  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 = std::optional<AmgSymMatrix(5)>(newcov);
  }
 
  const Acts::Surface &actsSurface = actsParameter.referenceSurface();
  switch (actsSurface.type()) {
    case Acts::Surface::SurfaceType::Cone: {
      const auto &coneSurface = static_cast<const Trk::ConeSurface&>(actsSurfaceToTrkSurface(actsSurface));
      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&>(actsSurfaceToTrkSurface(actsSurface))};
      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: {
      const Trk::Surface& trkSurface{actsSurfaceToTrkSurface(actsSurface)};
      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 Trk::PerigeeSurface perSurface(actsSurface.center(gctx));
      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&>(actsSurfaceToTrkSurface(actsSurface))};
      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&>(actsSurfaceToTrkSurface(actsSurface))};
      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);
      break;
    } case Acts::Surface::SurfaceType::Other: {
      break;
    }
  }
  throw std::domain_error("Surface type not found");
}

convertFitResult()

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

finaloverridevirtual

Definition at line 741 of file ActsToTrkConverterTool.cxx.

                                                                                                              {
    detail::TrkMeasurementCalibrator measCalib{};
    detail::TrkPrepRawDataCalibrator prdCalib{this, m_ROTcreator.get()};
 
    if (not fitResult.ok()) {
      ATH_MSG_VERBOSE("Fit did not converge");  
      return nullptr;    
    }
    const Acts::CalibrationContext cctx{getCalibrationContext(ctx)};
    const Acts::GeometryContext gctx{m_trackingGeometryTool->getGeometryContext(ctx).context()};
    Acts::ParticleHypothesis hypothesis{Acts::ParticleHypothesis::pion()};
    
    // Get the fit output object
    const auto& acts_track = fitResult.value();
      
    auto finalTrajectory = std::make_unique<Trk::TrackStates>();
    // initialise the number of dead Pixel and Acts strip
    unsigned int numberOfDeadPixel{0}, numberOfDeadSCT{0};
    int nDoF{0};
 
    double chi2{0};
 
    // Loop over all the output state to create track state
    tracks.trackStateContainer().visitBackwards(acts_track.tipIndex(), 
      [&] (const auto &state) -> void {
        // First only consider state with an associated detector element
        const auto* associatedDetEl = dynamic_cast<const IDetectorElementBase*>(
                                        state.referenceSurface().associatedDetectorElement());
       
        if (not associatedDetEl) {
            ATH_MSG_VERBOSE("State is not associated with a measurement sruface");
            return;
        }
        ATH_MSG_VERBOSE("Associated det: "<<to_string(associatedDetEl->detectorType()));
        auto flag = state.typeFlags();
    
        // We need to determine the type of state 
        std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
        std::unique_ptr<Trk::TrackParameters> measPars{};
        std::unique_ptr<Trk::MeasurementBase> measState{};
    
        // State is a hole (no associated measurement), use predicted parameters   
        if (flag.test(Acts::TrackStateFlag::HoleFlag)){
          const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
                                                     state.parameters(),
                                                     state.covariance(),
                                                     hypothesis);
          measPars = actsTrackParametersToTrkParameters(actsParam, gctx);
          if (associatedDetEl->detectorType() == DetectorType::Pixel ||
              associatedDetEl->detectorType() == DetectorType::Sct) {
              ATH_MSG_VERBOSE("Check if this is a hole, a dead sensors or a state outside the sensor boundary");
              switch (m_boundaryCheckTool->boundaryCheck(*measPars)) {
                  case Trk::BoundaryCheckResult::DeadElement:
                      numberOfDeadPixel += (associatedDetEl->detectorType() == DetectorType::Pixel);
                      numberOfDeadSCT+= (associatedDetEl->detectorType() == DetectorType::Sct);
                      break;
                  case Trk::BoundaryCheckResult::Candidate:
                      break;
                  default:
                      return;
              }
          }
          typePattern.set(Trk::TrackStateOnSurface::Hole);
        }
        // The state is a measurement state, use smoothed parameters 
        else if (flag.test(Acts::TrackStateFlag::MeasurementFlag)) {
          Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
                                               state.parameters(),
                                               state.covariance(),
                                               hypothesis);
          typePattern.set(Trk::TrackStateOnSurface::Measurement);
          switch (slType) {
              using enum detail::SourceLinkType;
              case TrkMeasurement: 
                measState = measCalib.unpack(state.getUncalibratedSourceLink())->uniqueClone();
                break;
              case TrkPrepRawData:
                measState = prdCalib.createROT(gctx, cctx, state.getUncalibratedSourceLink(), state);
                break;
              case xAODUnCalibMeas:
                  ATH_MSG_WARNING("Uncalibrated measurement is not implemented");
                  return;
              case nTypes:
                ATH_MSG_WARNING("Invalid type enumaration parsed");
                return;
          }
          nDoF = state.calibratedSize();
          chi2 = state.chi2();
          
        }
        auto perState = std::make_unique<Trk::TrackStateOnSurface>(Trk::FitQualityOnSurface{chi2, nDoF},
                                                                   std::move(measState), 
                                                                   std::move(measPars), nullptr, typePattern);
        // If a state was succesfully created add it to the trajectory 
        ATH_MSG_VERBOSE("State succesfully creates, adding it to the trajectory");
        finalTrajectory->insert(finalTrajectory->begin(), std::move(perState));
      });
      // Convert the perigee state and add it to the trajectory
      const Acts::BoundTrackParameters actsPer(acts_track.referenceSurface().getSharedPtr(), 
                                              acts_track.parameters(), 
                                              acts_track.covariance(),
                                              acts_track.particleHypothesis());
      std::unique_ptr<Trk::TrackParameters> per = actsTrackParametersToTrkParameters(actsPer, gctx);
      std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
      typePattern.set(Trk::TrackStateOnSurface::Perigee);
      auto perState = std::make_unique<Trk::TrackStateOnSurface>(nullptr, std::move(per), nullptr, typePattern);
      finalTrajectory->insert(finalTrajectory->begin(), std::move(perState));
    
      // Create the track using the states
      Trk::TrackInfo newInfo{fitAuthor, Trk::noHypothesis};
      auto newtrack = std::make_unique<Trk::Track>(newInfo, std::move(finalTrajectory), nullptr);
      if (newtrack) {
        // Create the track summary and update the holes information
        if (!newtrack->trackSummary()) {
          newtrack->setTrackSummary(std::make_unique<Trk::TrackSummary>());
          newtrack->trackSummary()->update(Trk::numberOfPixelDeadSensors, numberOfDeadPixel);
          newtrack->trackSummary()->update(Trk::numberOfSCTDeadSensors, numberOfDeadSCT);
        }
        m_trkSummaryTool->updateTrackSummary(ctx, *newtrack, true);
      }
      return newtrack;
  }

initialize()

StatusCode ActsTrk::ActsToTrkConverterTool::initialize ( )

overridevirtual

Definition at line 78 of file ActsToTrkConverterTool.cxx.

                                              {
  ATH_MSG_VERBOSE("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->associatedDetectorElement());
      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({actsElement->identify(), surface});
      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_boundaryCheckTool.retrieve(EnableTool{!m_boundaryCheckTool.empty()}));
  ATH_CHECK(m_ROTcreator.retrieve());
 
  ATH_CHECK(m_muonMgrKey.initialize(m_extractMuonSurfaces));
  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->associatedDetectorElement())->identify();
        m_actsSurfaceMap.insert(std::make_pair(id, surf.get()));
      }
    }
    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 193 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 202 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);
                          });
}

trkSurfaceToActsSurface()

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

                                          {
 
  Identifier atlasID = atlasSurface.associatedDetectorElementIdentifier();
  auto it = m_actsSurfaceMap.find(atlasID);
  if (it != m_actsSurfaceMap.end()) {
    return *it->second;
  }
  ATH_MSG_ERROR("No Acts surface corresponding to this ATLAS surface: "<<atlasID);
  ATH_MSG_ERROR(atlasSurface);
  throw std::domain_error("No Acts surface corresponding to the ATLAS one");
}

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 425 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::MultiTrajectoryTraits::kInvalid;
      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() |= Acts::TrackStateFlag::ParameterFlag;
            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 213 of file ActsToTrkConverterTool.cxx.

                                                                                                            {
 
  using namespace Acts::UnitLiterals;
  std::shared_ptr<const Acts::Surface> actsSurface;
  Acts::BoundVector params;
 
  // get the associated surface
  if (atlasParameter.hasSurface() &&
      atlasParameter.associatedSurface().owner() == Trk::SurfaceOwner::DetElOwn) {
    try {
      actsSurface = trkSurfaceToActsSurface(atlasParameter.associatedSurface()).getSharedPtr();
    } 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...
    }
  }
  // no associated surface create a perigee one
  else {
    ATH_MSG_VERBOSE(
        "trkTrackParametersToActsParameters:: No associated surface found (owner: "<<atlasParameter.associatedSurface().owner()<<
        "). Creating a free surface. Trk parameters:");
    ATH_MSG_VERBOSE(atlasParameter);
    const Amg::Transform3D& trf{atlasParameter.associatedSurface().transform()};
    switch (atlasParameter.associatedSurface().type()){
      case Trk::SurfaceType::Plane:
        actsSurface = Acts::Surface::makeShared<const Acts::PlaneSurface>(trf);
        break;
      case Trk::SurfaceType::Perigee:
        actsSurface = Acts::Surface::makeShared<const Acts::PerigeeSurface>(trf);
        break;
      case Trk::SurfaceType::Line:
        actsSurface = Acts::Surface::makeShared<const Acts::StrawSurface>(trf);
        break;
      // TODO - implement the missing types?
      default: {
        std::stringstream surfStr{};
        atlasParameter.dump(surfStr);  
        throw std::domain_error(std::format("Failed to translate parameters {:}", surfStr.str()));
      }
    }
  }
 
  // 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::BoundSquareMatrix cov = Acts::BoundSquareMatrix::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 183 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, const Acts::Surface*> ActsTrk::ActsToTrkConverterTool::m_actsSurfaceMap {}

private

Definition at line 105 of file ActsToTrkConverterTool.h.

{};

m_boundaryCheckTool

ToolHandle<Trk::IBoundaryCheckTool> ActsTrk::ActsToTrkConverterTool::m_boundaryCheckTool {this, "BoundaryCheckTool", "", "Boundary checking tool for detector sensitivities"}

private

Definition at line 101 of file ActsToTrkConverterTool.h.

{this, "BoundaryCheckTool",  "", "Boundary checking tool for detector sensitivities"};

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

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

m_idHelperSvc

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

private

Definition at line 116 of file ActsToTrkConverterTool.h.

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

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

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

m_ROTcreator

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

private

Definition at line 102 of file ActsToTrkConverterTool.h.

{this, "RotCreatorTool", ""};

m_trackingGeometry

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

private

Definition at line 104 of file ActsToTrkConverterTool.h.

{};

m_trackingGeometryTool

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

private

Definition at line 97 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 100 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 107 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