562 detailed trajectory information writer

src/algorithms/tracking/JugTrack/TrackingResultTrajectory.hpp

@@ -27,9 +27,7 @@ struct TrackingResultTrajectory final {
   /// (Reconstructed) trajectory with multiple states.
   using MultiTrajectory = Acts::VectorMultiTrajectory;
   /// Fitted parameters identified by indices in the multi trajectory.
-  using IndexedParameters =
-      std::unordered_map<Acts::MultiTrajectoryTraits::IndexType,
-                         TrackParameters>;
+  using IndexedParameters = std::unordered_map<Acts::MultiTrajectoryTraits::IndexType, TrackParameters>;
 
   /// Default construct an empty object. Required for container compatibility
   /// and to signal an error.

src/algorithms/tracking/ParticlesFromTrackFit.cc

@@ -1,24 +1,21 @@
 #include "ParticlesFromTrackFit.h"
 #include <algorithm>
 
-
 #include "DDRec/CellIDPositionConverter.h"
 #include "DDRec/SurfaceManager.h"
 #include "DDRec/Surface.h"
 
-
-
 #include "Acts/EventData/MultiTrajectory.hpp"
 #include "Acts/EventData/MultiTrajectoryHelpers.hpp"
 
 // Event Model related classes
 #include "edm4eic/ReconstructedParticleCollection.h"
 #include "edm4eic/TrackerHitCollection.h"
 #include "edm4eic/TrackParametersCollection.h"
+#include "edm4eic/Trajectory.h"
 #include "JugTrack/IndexSourceLink.hpp"
 #include "JugTrack/Track.hpp"
 
-
 #include "Acts/Utilities/Helpers.hpp"
 
 #include "edm4eic/vector_utils.h"
@@ -34,6 +31,7 @@ ParticlesFromTrackFitResultNew eicrecon::Reco::ParticlesFromTrackFit::execute(co
     // create output collections
     auto rec_parts = std::make_unique<edm4eic::ReconstructedParticleCollection >();
     auto track_pars = std::make_unique<edm4eic::TrackParametersCollection>();
+    auto edm4eic_trajectories = std::make_unique<edm4eic::TrajectoryCollection>();
 
     m_log->debug("Trajectories size: {}", std::size(trajectories));
 
@@ -48,11 +46,33 @@ ParticlesFromTrackFitResultNew eicrecon::Reco::ParticlesFromTrackFit::execute(co
             m_log->debug("Empty multiTrajectory.");
             continue;
         }
-
         const auto& trackTip = trackTips.front();
 
         // Collect the trajectory summary info
-        auto trajState       = Acts::MultiTrajectoryHelpers::trajectoryState(mj, trackTip);
+        auto trajState = Acts::MultiTrajectoryHelpers::trajectoryState(mj, trackTip);
+
+        // Collect the trajectory summary info
+        unsigned int  m_nStates       = trajState.nStates;
+        unsigned int  m_nMeasurements = trajState.nMeasurements;
+        unsigned int  m_nOutliers     = trajState.nOutliers;
+        unsigned int  m_nHoles        = trajState.nHoles;
+        float         m_chi2Sum       = trajState.chi2Sum;
+        unsigned int  m_ndf           = trajState.NDF;
+        unsigned int  m_nSharedHits   = trajState.nSharedHits;
+
+        bool hasFit = traj->hasTrackParameters(trackTip);
+
+        auto edm4eic_traj = edm4eic_trajectories->create(
+                hasFit,
+                m_nStates,
+                m_nMeasurements,
+                m_nOutliers,
+                m_nHoles,
+                m_chi2Sum,
+                m_ndf,
+                m_nSharedHits
+                );
+
         //int  m_nMeasurements = trajState.nMeasurements;
         //int  m_nStates       = trajState.nStates;
 
@@ -105,6 +125,8 @@ ParticlesFromTrackFitResultNew eicrecon::Reco::ParticlesFromTrackFit::execute(co
                     timeError,
                     static_cast<float>(boundParam.charge())};
             track_pars->push_back(pars);
+
+            edm4eic_traj.setTrackParameters(pars);
         }
 
         auto tsize = trackTips.size();
@@ -137,5 +159,9 @@ ParticlesFromTrackFitResultNew eicrecon::Reco::ParticlesFromTrackFit::execute(co
         });
     }
 
+    return new ParticlesFromTrackFitResult(
+            std::move(rec_parts),
+            std::move(track_pars),
+            std::move(edm4eic_trajectories));
     return std::make_pair(std::move(rec_parts), std::move(track_pars));
 }

src/algorithms/tracking/ParticlesFromTrackFitResult.h

@@ -7,20 +7,25 @@
 #include <memory>
 #include <edm4eic/ReconstructedParticleCollection.h>
 #include <edm4eic/TrackParametersCollection.h>
+#include <edm4eic/TrajectoryCollection.h>
 
 class ParticlesFromTrackFitResult {
 public:
     ParticlesFromTrackFitResult(
             std::unique_ptr<edm4eic::ReconstructedParticleCollection> particles,
-            std::unique_ptr<edm4eic::TrackParametersCollection> track_parameters):
-            m_particles(std::move(particles)),
-            m_track_parameters(std::move(track_parameters))
+            std::unique_ptr<edm4eic::TrackParametersCollection> track_parameters,
+            std::unique_ptr<edm4eic::TrajectoryCollection> trajectories):
+                m_particles(std::move(particles)),
+                m_track_parameters(std::move(track_parameters)),
+                m_trajectories(std::move(trajectories))
     {}
 
     [[nodiscard]] edm4eic::ReconstructedParticleCollection* particles() const {return m_particles.get();}
     [[nodiscard]] edm4eic::TrackParametersCollection* trackParameters() const {return m_track_parameters.get();}
+    [[nodiscard]] edm4eic::TrajectoryCollection* trajectories() const {return m_trajectories.get();}
 
 private:
     std::unique_ptr<edm4eic::ReconstructedParticleCollection> m_particles;
     std::unique_ptr<edm4eic::TrackParametersCollection> m_track_parameters;
+    std::unique_ptr<edm4eic::TrajectoryCollection> m_trajectories;
 };

src/global/tracking/Trajectory_factory.cc

@@ -0,0 +1,46 @@
+// Created by Shyam Kumar; INFN Bari, [email protected]; [email protected]
+// Subject to the terms in the LICENSE file found in the top-level directory.
+
+#include "Trajectory_factory.h"
+#include <edm4eic/Trajectory.h>
+#include "extensions/string/StringHelpers.h"
+#include <JANA/JEvent.h>
+#include <services/log/Log_service.h>
+#include <extensions/spdlog/SpdlogExtensions.h>
+
+namespace eicrecon {
+    void Trajectory_factory::Init() {
+        auto app = GetApplication();
+
+        // This prefix will be used for parameters
+        std::string plugin_name = eicrecon::str::ReplaceAll(GetPluginName(), ".so", "");
+        std::string param_prefix = plugin_name+ ":" + GetTag();
+
+        // Set input data tags properly
+        InitDataTags(param_prefix);
+
+        // SpdlogMixin logger initialization, sets m_log
+        InitLogger(param_prefix, "info");
+    }
+
+    void Trajectory_factory::ChangeRun(const std::shared_ptr<const JEvent> &event) {
+        // Nothing to do here
+    }
+
+    void Trajectory_factory::Process(const std::shared_ptr<const JEvent> &event) {
+
+        auto trajectories = event->Get<edm4eic::Trajectory>("outputTrajectories");
+
+        try {
+            std::vector<edm4eic::Trajectory *> result;
+            for (const auto *trajectory: trajectories) {
+                auto trajectory_params = (*trajectory_info->Trajectory())[i];
+                result.push_back(new edm4eic::Trajectory(trajectory_params));
+            }
+            Set(result);
+        }
+        catch(std::exception &e) {
+            m_log->warn("Exception in underlying algorithm: {}. Event data will be skipped", e.what());
+        }
+    }
+} // eicrecon

src/global/tracking/Trajectory_factory.h

@@ -0,0 +1,35 @@
+// Created by Shyam Kumar; INFN Bari, [email protected]; [email protected]
+// Subject to the terms in the LICENSE file found in the top-level directory.
+//
+
+#pragma once
+
+#include <edm4eic/Trajectory.h>
+#include <extensions/jana/JChainFactoryT.h>
+#include <extensions/spdlog/SpdlogMixin.h>
+
+namespace eicrecon {
+
+    class Trajectory_factory : public JChainFactoryT<edm4eic::Trajectory>,
+                                    public SpdlogMixin<Trajectory_factory> {
+
+    public:
+        Trajectory_factory(std::vector<std::string> default_input_tags):
+        JChainFactoryT<edm4eic::Trajectory>( std::move(default_input_tags) ) {
+        }
+
+        /** One time initialization **/
+        void Init() override;
+
+        /** On run change preparations **/
+        void ChangeRun(const std::shared_ptr<const JEvent> &event) override;
+
+        /** Event by event processing **/
+        void Process(const std::shared_ptr<const JEvent> &event) override;
+
+    private:
+
+        std::vector<std::string> m_input_tags;
+    };
+
+} // eicrecon

src/global/tracking/tracking.cc

@@ -18,6 +18,7 @@
 #include "TrackSeeding_factory.h"
 #include "TrackerHitCollector_factory.h"
 #include "TrackProjector_factory.h"
+#include "Trajectory_factory.h"
 #include "ParticlesWithTruthPID_factory.h"
 
 //
@@ -63,6 +64,11 @@ void InitPlugin(JApplication *app) {
              "outputTrackParameters"},                        // edm4eic::TrackParameters
             app));
 
+    app->Add(new JChainFactoryGeneratorT<Trajectory_factory>(
+            {"CentralCKFTrajectories"}, "CentralTrackingTrajectories"));
+
+    app->Add(new JChainFactoryGeneratorT<TrackerReconstructedParticle_factory>(
+            {"CentralTrackingParticles"}, "outputParticles"));
     app->Add(new JChainMultifactoryGeneratorT<ParticlesWithTruthPID_factory>(
             "ChargedParticlesWithAssociations",                // Tag name for multifactory
             {"MCParticles",                                    // edm4hep::MCParticle