TruthSeedProcessor.h

#pragma once
 
//--- Framework ---//
#include "Framework/Configure/Parameters.h"
#include "Framework/EventProcessor.h"
#include "Framework/Logger.h"
#include "SimCore/Event/SimParticle.h"
#include "SimCore/Event/SimTrackerHit.h"
 
// --- Tracking --- //
#include "Tracking/Event/Track.h"
#include "Tracking/Event/TruthTrack.h"
#include "Tracking/Reco/TrackExtrapolatorTool.h"
#include "Tracking/Reco/TrackingGeometryUser.h"
#include "Tracking/Sim/TrackingUtils.h"
 
// --- ACTS --- //
#include <random>
 
#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Definitions/TrackParametrization.hpp"
#include "Acts/EventData/TrackParameters.hpp"
#include "Acts/Propagator/EigenStepper.hpp"
#include "Acts/Propagator/Navigator.hpp"
#include "Acts/Propagator/Propagator.hpp"
#include "Acts/Surfaces/PerigeeSurface.hpp"
#include "Tracking/Sim/BFieldXYZUtils.h"
 
using TruthPropagator = Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>;
 
namespace tracking::reco {
 
class TruthSeedProcessor : public TrackingGeometryUser {
 public:
  TruthSeedProcessor(const std::string& name, framework::Process& process);
 
  virtual ~TruthSeedProcessor() = default;
 
  void configure(framework::config::Parameters& parameters) override;
 
  void onProcessStart() override {};
 
  void onNewRun(const ldmx::RunHeader& rh) override;
 
  void produce(framework::Event& event) override;
 
 private:
  void makeHitCountMap(const std::vector<ldmx::SimTrackerHit>& sim_hits,
                       std::map<int, std::vector<int>>& hit_count_map);
 
  void createTruthTrack(const ldmx::SimParticle& particle, ldmx::Track& trk,
                        const std::shared_ptr<Acts::Surface>& target_surface);
 
  void createTruthTrack(const ldmx::SimParticle& particle,
                        const ldmx::SimTrackerHit& hit, ldmx::Track& trk,
                        const std::shared_ptr<Acts::Surface>& target_surface);
 
  void createTruthTrack(const std::vector<double>& pos_vec,
                        const std::vector<double>& p_vec, int charge,
                        ldmx::Track& trk,
                        const std::shared_ptr<Acts::Surface>& target_surface);
 
  bool scoringPlaneHitFilter(
      const ldmx::SimTrackerHit& hit,
      const std::vector<ldmx::SimTrackerHit>& ecal_sp_hits);
 
  ldmx::Track seedFromTruth(const ldmx::Track& tt, bool seed_smearing);
 
  ldmx::Track recoilFullSeed(
      const ldmx::SimParticle& particle, const int trackID,
      const ldmx::SimTrackerHit& hit, const ldmx::SimTrackerHit& ecal_hit,
      const std::map<int, std::vector<int>>& hit_count_map,
      const std::shared_ptr<Acts::Surface>& origin_surface,
      const std::shared_ptr<Acts::Surface>& target_surface,
      const std::shared_ptr<Acts::Surface>& ecal_surface);
 
  ldmx::Track taggerFullSeed(
      const ldmx::SimParticle& beam_electron, const int trackID,
      const ldmx::SimTrackerHit& hit,
      const std::map<int, std::vector<int>>& hit_count_map,
      const std::shared_ptr<Acts::Surface>& origin_surface,
      const std::shared_ptr<Acts::Surface>& target_surface);
 
  Acts::GeometryContext gctx_;
 
  std::vector<int> pdg_ids_{11};
 
  std::string scoring_hits_coll_name_{"TargetScoringPlaneHits"};
  std::string ecal_sp_coll_name_{"EcalScoringPlaneHits"};
  std::string sp_pass_name_{""};
 
  std::string tagger_sim_hits_coll_name_{"TaggerSimHits"};
 
  std::string recoil_sim_hits_coll_name_{"RecoilSimHits"};
 
  std::string input_pass_name_{""};
 
  std::string sim_particles_coll_name_;
  std::string sim_particles_passname_;
 
  int n_min_hits_tagger_{7};
 
  int n_min_hits_recoil_{7};
 
  float z_min_{-999};
 
  int track_id_{-999};
 
  double pz_cut_{-9999};
 
  double p_cut_{0.};
 
  double p_cut_max_{100000.};
 
  // Ask for a minimum p for the seeds at the ecal (from truth)
  double p_cut_ecal_{-1.};
 
  // Use scoring plane for recoil truth tracks
  bool recoil_sp_{true};
 
  // Use scoring plane for target truth tracks
  bool target_sp_{true};
 
  // skip the tagger tracker
  bool skip_tagger_{false};
 
  // skip the recoil tracker
  bool skip_recoil_{false};
 
  // Maximum track id for hit to be selected from target scoring plane
  int max_track_id_{5};
 
  std::unique_ptr<const TruthPropagator> propagator_;
 
  // Track Extrapolator Tool
  std::shared_ptr<tracking::reco::TrackExtrapolatorTool<TruthPropagator>>
      trk_extrap_;
 
  std::string field_map_{""};
 
  //--- Smearing ---//
 
  std::default_random_engine generator_;
  std::shared_ptr<std::normal_distribution<float>> normal_;
 
  bool seed_smearing_{false};
 
  std::vector<double> d0smear_;
  std::vector<double> z0smear_;
  double phismear_;
  double thetasmear_;
  double relpsmear_;
  std::vector<double> rel_smearfactors_;
  std::vector<double> inflate_factors_;
  std::vector<double> beam_origin_{-880.1, -44., 0.};
  int particle_hypothesis_;
 
  std::string beam_electrons_collection_;
  std::string tagger_truth_collection_;
  std::string recoil_truth_collection_;
  std::string tagger_seeds_collection_;
  std::string recoil_seeds_collection_;
};
}  // namespace tracking::reco