LinearSeedFinder.h

#pragma once
 
//---< Framework >---//
#include "Framework/Configure/Parameters.h"
#include "Framework/Event.h"
#include "Framework/EventProcessor.h"
 
//---< SimCore >---//
#include "SimCore/Event/SimTrackerHit.h"
 
//---< STD C++ >---//
#include <iostream>
 
//--- LDMX ---//
#include "Ecal/Event/EcalHit.h"
#include "TFile.h"
#include "TTree.h"
#include "Tracking/Event/Measurement.h"
#include "Tracking/Event/StraightTrack.h"
#include "Tracking/Reco/TrackingGeometryUser.h"
#include "Tracking/Reco/TruthMatchingTool.h"
 
namespace tracking {
namespace reco {
 
class LinearSeedFinder : public TrackingGeometryUser {
 public:
  LinearSeedFinder(const std::string &name, framework::Process &process);
 
  virtual ~LinearSeedFinder() = default;
  void onProcessStart() override;
  void onProcessEnd() override;
  void configure(framework::config::Parameters &parameters) override;
 
  void produce(framework::Event &event) override;
 
 protected:
  // Function to find seeds based on 2 Recoil points and 1 EcalRecHit
  ldmx::StraightTrack seedTracker(
      const std::tuple<std::array<double, 3>, ldmx::Measurement,
                       std::optional<ldmx::Measurement>>
          recoil_one,
      const std::tuple<std::array<double, 3>, ldmx::Measurement,
                       std::optional<ldmx::Measurement>>
          recoil_two,
      const std::array<double, 3> ecal_one);
 
  // Fitting function: fit a straight line in 3D using 3 points (1 degree of
  // freedom)
  std::tuple<double, double, double, double, std::vector<double>> fit3DLine(
      const std::array<double, 3> &first_recoil,
      const std::array<double, 3> &second_recoil,
      const std::array<double, 3> &ecal);
 
  // Helper function: calculate distance between 2 3D points
  double calculateDistance(const std::array<double, 3> &point1,
                           const std::array<double, 3> &point2);
 
  // Do 3D hit reconstruction using an axial measurement and a stereo
  // measurement according to geometric projections
  Acts::Vector3 simple3DHitV2(const ldmx::Measurement &axial,
                              const Acts::Surface &axial_surface,
                              const ldmx::Measurement &stereo,
                              const Acts::Surface &stereo_surface,
                              const ldmx::SimTrackerHit &hitOnTarget,
                              std::vector<ldmx::SimTrackerHit> pair_sim_hits);
 
  // Makes all combinations of sensor measurements to use in the seeding
  std::vector<std::tuple<
      std::array<double, 3>,
      std::tuple<ldmx::Measurement, ldmx::SimTrackerHit, ldmx::SimTrackerHit>,
      std::optional<std::tuple<ldmx::Measurement, ldmx::SimTrackerHit,
                               ldmx::SimTrackerHit>>>>
  processMeasurements(
      const std::vector<std::tuple<ldmx::Measurement, ldmx::SimTrackerHit,
                                   ldmx::SimTrackerHit>> &measurements,
      const geo::TrackersTrackingGeometry &tg);
 
  // Calculate chi2 of the fit
  double globalChiSquare(const std::array<double, 3> &first_sensor,
                         const std::array<double, 3> &second_sensor,
                         const std::array<double, 3> &ecal_hit, double a_x,
                         double a_y, double b_x, double b_y);
 
  // Function to find the number of unique layers hit (to determine if we have
  // enough points to fit)
  int uniqueLayersHit(const std::vector<ldmx::Measurement> &digi_points);
 
  // Helper functions:
  std::array<double, 3> convertToLdmxStdArray(const Acts::Vector3 &vec);
  std::tuple<Acts::Vector3, Acts::Vector3, Acts::Vector3> getSurfaceVectors(
      const Acts::Surface &surface);
  double dotProduct(const Acts::Vector3 &v1, const Acts::Vector3 &v2);
  std::array<double, 3> getPointAtZ(std::array<double, 3> target,
                                    std::array<double, 3> measurement,
                                    double z_target);
 
  double processing_time_{0.};
  long n_events_{0};
  unsigned int n_seeds_{0};
 
  std::string out_seed_collection_{"LinearRecoilSeedTracks"};
  std::string input_hits_collection_{"DigiRecoilSimHits"};
  std::string input_rec_hits_collection_{"EcalRecHits"};
  std::string input_pass_name_{""};
 
  double ecal_uncertainty_{3.87};
  // Max distance from RecHit for valid track
  double ecal_distance_threshold_{10.0};
 
  // Assuming rLDMX_v1 geometry
  double layer12_midpoint_{12.5};
  double layer23_midpoint_{20.0};
  double layer34_midpoint_{27.5};
  double ecal_first_layer_z_threshold_{250.0};
 
  std::vector<double> recoil_uncertainty_{0.006, 0.085};
 
  // Check failures
  long n_missing_{0};
 
  // Truth Matching tool
  std::shared_ptr<tracking::sim::TruthMatchingTool> truth_matching_tool_ =
      nullptr;
 
 private:
  std::string next_event_passname_;
  std::string sim_particles_passname_;
  std::string sim_particles_events_passname_;
 
};  // SeedFinderProcessor
 
}  // namespace reco
}  // namespace tracking