SeedFinderProcessor.h

#pragma once
 
//---< Framework >---//
#include "Framework/Configure/Parameters.h"
#include "Framework/Event.h"
#include "Framework/EventProcessor.h"
 
//---< Tracking >---//
#include "Tracking/Event/Track.h"
#include "Tracking/Sim/SeedToTrackParamMaker.h"
 
//---< SimCore >---//
 
//---< STD C++ >---//
 
//---< ACTS >---//
#include "Acts/Definitions/Algebra.hpp"
 
//--- LDMX ---//
#include "Tracking/Event/Measurement.h"
#include "Tracking/Reco/TrackingGeometryUser.h"
#include "Tracking/Reco/TruthMatchingTool.h"
 
namespace tracking {
namespace reco {
 
class SeedFinderProcessor : public TrackingGeometryUser {
 public:
  SeedFinderProcessor(const std::string& name, framework::Process& process);
 
  virtual ~SeedFinderProcessor() = default;
 
  void onProcessStart() override;
 
  void onProcessEnd() override;
 
  void configure(framework::config::Parameters& parameters) override;
 
  void produce(framework::Event& event) override;
 
  bool groupStrips(const std::vector<ldmx::Measurement>& measurements,
                   const std::vector<int> strategy);
 
  void findSeedsFromMap(std::vector<ldmx::Track>& seeds,
                        const ldmx::Measurements& pmeas,
                        const ldmx::Measurements& fit_constraints);
 
 private:
  ldmx::Track seedTracker(const ldmx::Measurements& vmeas, double xOrigin,
                          const Acts::Vector3& perigee_location,
                          const ldmx::Measurement* constraint);
 
  void lineParabolaToHelix(const Acts::Vector<5> parameters,
                           Acts::Vector<5>& helix_parameters,
                           Acts::Vector3 ref);
 
  Acts::Vector3 b_field_;
 
  /* This is a temporary (working) solution to estimate the track parameters out
   * of the seeds Eventually we should move to what is in ACTS (I'm not happy
   * with what they did regarding this part atm)
   */
 
  std::shared_ptr<tracking::sim::SeedToTrackParamMaker> seed_to_track_maker_;
 
  double processing_time_{0.};
  long nevents_{0};
  unsigned int ntracks_{0};
 
  std::vector<double> inflate_factors_{1., 1., 1., 1., 1.};
 
  std::string out_seed_collection_{"SeedTracks"};
  std::string input_hits_collection_{"TaggerSimHits"};
  std::string tagger_trks_collection_{"TaggerTracks"};
  std::string input_pass_name_{""};
 
  std::string sim_particles_coll_name_;
  std::string sim_particles_passname_;
  std::string tagger_trks_event_collection_passname_;
  std::string sim_particles_event_passname_;
  std::vector<double> perigee_location_{-700., 0., 0};
  double pmin_{0.05};
 
  double pmax_{8};
 
  double d0max_{20.};
 
  double d0min_{20.};
 
  double z0max_{60.};
 
  double piover2_{1.5708};
 
  double phicut_{0.1};
 
  double thetacut_{0.2};
 
  double loc0cut_{0.1};
  double loc1cut_{0.3};
 
  std::vector<std::string> strategies_{};
  std::vector<std::vector<int>> strategy_layers_{};
  bool prefilter_unconstrained_{false};
  long nfailprefilter_{0};
  std::vector<long> seeds_per_strategy_{};
  bool use_target_constraint_{false};
  std::shared_ptr<Acts::Surface> target_surface_;
  bool warned_ambiguous_tagger_{false};
  double bfield_{1.5};
 
  std::vector<float> xhit_;
  std::vector<float> yhit_;
  std::vector<float> zhit_;
 
  std::vector<float> b0_;
  std::vector<float> b1_;
  std::vector<float> b2_;
  std::vector<float> b3_;
  std::vector<float> b4_;
 
  // Check failures
  long ndoubles_{0};
  long nmissing_{0};
  long nfailpmin_{0};
  long nfailpmax_{0};
  long nfaild0min_{0};
  long nfaild0max_{0};
  long nfailz0max_{0};
  long nfailphi_{0};
  long nfailtheta_{0};
 
  // The measurements groups
  std::map<int, std::vector<const ldmx::Measurement*>> groups_map_;
 
  // Truth Matching tool
  std::shared_ptr<tracking::sim::TruthMatchingTool> truth_matching_tool_ =
      nullptr;
 
  double u_error_;
  double v_error_;
 
};  // SeedFinderProcessor
 
}  // namespace reco
}  // namespace tracking