update CreateTrkTrackTool

Tracking/Acts/FaserActsKalmanFilter/src/CreateTrkTrackTool.cxx

@@ -3,6 +3,7 @@
 
 #include <Acts/EventData/MultiTrajectoryHelpers.hpp>
 #include "TrackerIdentifier/FaserSCT_ID.h"
+#include "FaserActsKalmanFilter/IndexSourceLink.h"
 
 CreateTrkTrackTool::CreateTrkTrackTool(const std::string& type, const std::string& name, const IInterface* parent) :
     AthAlgTool( type, name, parent ) {}
@@ -17,56 +18,56 @@ StatusCode CreateTrkTrackTool::finalize() {
 }
 
 std::unique_ptr<Trk::Track>
-CreateTrkTrackTool::createTrack(const Acts::GeometryContext &gctx, const FaserActsRecMultiTrajectory &traj, bool backwardPropagation) const {
+CreateTrkTrackTool::createTrack(const Acts::GeometryContext &gctx, const CreateTrkTrackTool::TrackContainer::TrackProxy &track, bool backwardPropagation) const {
   std::unique_ptr<Trk::Track> newtrack = nullptr;
   DataVector<const Trk::TrackStateOnSurface>* finalTrajectory = new DataVector<const Trk::TrackStateOnSurface>{};
-  using ConstTrackStateProxy = Acts::detail_lt::TrackStateProxy<IndexSourceLink, 6, true>;
-  auto trajState = Acts::MultiTrajectoryHelpers::trajectoryState(traj.multiTrajectory(), traj.tips().front());
-  traj.multiTrajectory().visitBackwards(traj.tips().front(), [&](const ConstTrackStateProxy& state) {
+  // Loop over all the output state to create track state
+  for (const auto& state : track.trackStatesReversed()) {
     auto flag = state.typeFlags();
     if (state.referenceSurface().associatedDetectorElement() != nullptr) {
       std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
-      const Trk::TrackParameters *parm;
+      std::unique_ptr<Trk::TrackParameters> parm;
 
-      if (flag[Acts::TrackStateFlag::HoleFlag]) {
+      if (flag.test(Acts::TrackStateFlag::HoleFlag)) {
+        //todo: make the particle hypothesis configurable
         const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
-                                                   state.predicted(), state.predictedCovariance());
-        parm = ConvertActsTrackParameterToATLAS(actsParam, gctx);
+                                                   state.predicted(), state.predictedCovariance(), Acts::ParticleHypothesis::pion());
+        parm = std::move(ConvertActsTrackParameterToATLAS(actsParam, gctx));
         typePattern.set(Trk::TrackStateOnSurface::Hole);
       }
-      else if (flag[Acts::TrackStateFlag::OutlierFlag]) {
+      else if (flag.test(Acts::TrackStateFlag::OutlierFlag)) {
         const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
-                                                   state.filtered(), state.filteredCovariance());
-        parm = ConvertActsTrackParameterToATLAS(actsParam, gctx);
+                                                   state.filtered(), state.filteredCovariance(), Acts::ParticleHypothesis::pion());
+        parm = std::move(ConvertActsTrackParameterToATLAS(actsParam, gctx));
         typePattern.set(Trk::TrackStateOnSurface::Outlier);
       }
       else {
         const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
-                                                   state.smoothed(), state.smoothedCovariance());
-        parm = ConvertActsTrackParameterToATLAS(actsParam, gctx);
+                                                   state.smoothed(), state.smoothedCovariance(), Acts::ParticleHypothesis::pion());
+        parm = std::move(ConvertActsTrackParameterToATLAS(actsParam, gctx));
         typePattern.set(Trk::TrackStateOnSurface::Measurement);
       }
-      Tracker::FaserSCT_ClusterOnTrack* clusterOnTrack = nullptr;
-      if (state.hasUncalibrated()) {
-        const Tracker::FaserSCT_Cluster* cluster = state.uncalibrated().hit();
+      std::unique_ptr<Tracker::FaserSCT_ClusterOnTrack> clusterOnTrack = nullptr;
+      if (state.hasUncalibratedSourceLink()) {
+        const Tracker::FaserSCT_Cluster* cluster = state.getUncalibratedSourceLink().template get<IndexSourceLink>().hit();
         if (cluster->detectorElement() != nullptr) {
-          clusterOnTrack = new Tracker::FaserSCT_ClusterOnTrack{
+          clusterOnTrack = std::make_unique<Tracker::FaserSCT_ClusterOnTrack>(
               cluster,
               Trk::LocalParameters{
                   Trk::DefinedParameter{cluster->localPosition()[0], Trk::loc1},
                   Trk::DefinedParameter{cluster->localPosition()[1], Trk::loc2}
               },
-              cluster->localCovariance(),
+              Amg::MatrixX(cluster->localCovariance()),
               m_idHelper->wafer_hash(cluster->detectorElement()->identify())
-          };
+          );
         }
       }
       double nDoF = state.calibratedSize();
       const Trk::FitQualityOnSurface* quality = new Trk::FitQualityOnSurface(state.chi2(), nDoF);
       const Trk::TrackStateOnSurface* perState = new Trk::TrackStateOnSurface(
-									      clusterOnTrack, 
-									      parm,
-									      quality,
+									      *quality,
+									      std::move(clusterOnTrack), 
+									      std::move(parm),
 									      nullptr,
 									      typePattern);
       if ((perState) && (!backwardPropagation)) {
@@ -75,20 +76,19 @@ CreateTrkTrackTool::createTrack(const Acts::GeometryContext &gctx, const FaserAc
 	        finalTrajectory->push_back(perState);
       }
     }
-    return;
-  });
+  }
 
-  Trk::FitQuality* q = new Trk::FitQuality {trajState.chi2Sum, static_cast<double>(trajState.nMeasurements - 5)};
+  std::unique_ptr<Trk::FitQuality> q = std::make_unique<Trk::FitQuality>(track.chi2(), static_cast<double>(track.nMeasurements() - 5));
   Trk::TrackInfo newInfo(Trk::TrackInfo::TrackFitter::KalmanFitter, Trk::ParticleHypothesis::muon);
   std::unique_ptr<DataVector<const Trk::TrackStateOnSurface>> sink(finalTrajectory);
   // newtrack = std::make_unique<Trk::Track>(newInfo, std::move(*finalTrajectory), quality);
-  Trk::Track* tmpTrack = new Trk::Track(newInfo, std::move(*sink), q);
+  Trk::Track* tmpTrack = new Trk::Track(newInfo, std::move(sink), std::move(q));
   newtrack = std::unique_ptr<Trk::Track>(tmpTrack);
   return newtrack;
 }
 
 
-const Trk::TrackParameters*
+std::unique_ptr<Trk::TrackParameters>
 CreateTrkTrackTool::ConvertActsTrackParameterToATLAS(const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext& gctx) const {
   using namespace Acts::UnitLiterals;
   std::optional<AmgSymMatrix(5)> cov = std::nullopt;
@@ -110,6 +110,5 @@ CreateTrkTrackTool::ConvertActsTrackParameterToATLAS(const Acts::BoundTrackParam
   double p = std::abs(1. / tqOverP);
   Amg::Vector3D tmom(p * std::cos(tphi) * std::sin(ttheta), p * std::sin(tphi) * std::sin(ttheta), p * std::cos(ttheta));
   double charge = tqOverP > 0. ? 1. : -1.;
-  const Trk::CurvilinearParameters * curv = new Trk::CurvilinearParameters(pos,tmom,charge, cov);
-  return curv;
+  return std::make_unique<Trk::CurvilinearParameters>(pos,tmom,charge, cov);
 }

Tracking/Acts/FaserActsKalmanFilter/src/CreateTrkTrackTool.h

@@ -7,21 +7,29 @@
 #include "TrkParameters/TrackParameters.h"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/EventData/TrackParameters.hpp"
-#include "FaserActsRecMultiTrajectory.h"
+#include "Acts/EventData/TrackContainer.hpp"
+#include "Acts/EventData/TrackProxy.hpp"
+#include "Acts/EventData/VectorTrackContainer.hpp"
+#include "Acts/EventData/VectorMultiTrajectory.hpp"
+//#include "FaserActsRecMultiTrajectory.h"
 
 
 class FaserSCT_ID;
 
 class CreateTrkTrackTool: public AthAlgTool {
 public:
+  using TrackContainer =
+      Acts::TrackContainer<Acts::VectorTrackContainer,
+                           Acts::VectorMultiTrajectory, std::shared_ptr>;
+ 
   CreateTrkTrackTool(const std::string &type, const std::string &name, const IInterface *parent);
   virtual ~CreateTrkTrackTool() = default;
   virtual StatusCode initialize() override;
   virtual StatusCode finalize() override;
-  std::unique_ptr<Trk::Track> createTrack(const Acts::GeometryContext &gctx, const FaserActsRecMultiTrajectory &traj, bool backwardPropagation=false) const;
-  const Trk::TrackParameters* ConvertActsTrackParameterToATLAS(const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext& gctx) const;
+  std::unique_ptr<Trk::Track> createTrack(const Acts::GeometryContext &gctx, const TrackContainer::TrackProxy &track, bool backwardPropagation=false) const;
+  std::unique_ptr<Trk::TrackParameters> ConvertActsTrackParameterToATLAS(const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext& gctx) const;
 private:
   const FaserSCT_ID* m_idHelper {nullptr};
 };
 
-#endif //FASERACTSKALMANFILTER_CREATETRKTRACKTOOL_H
\ No newline at end of file
+#endif //FASERACTSKALMANFILTER_CREATETRKTRACKTOOL_H