EcalVetoProcessor.h

Go to the documentation of this file.

 
#ifndef EVENTPROC_ECALVETOPROCESSOR_H_
#define EVENTPROC_ECALVETOPROCESSOR_H_
 
// LDMX
#include "DetDescr/EcalGeometry.h"
#include "DetDescr/EcalID.h"
#include "DetDescr/SimSpecialID.h"
#include "Ecal/EcalHelper.h"
#include "Ecal/Event/EcalHit.h"
#include "Ecal/Event/EcalTrajectoryInfo.h"
#include "Ecal/Event/EcalVetoResult.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/EventProcessor.h"
#include "SimCore/Event/SimParticle.h"
#include "SimCore/Event/SimTrackerHit.h"
#include "Tools/AnalysisUtils.h"
#include "Tools/ONNXRuntime.h"
 
// C++
#include <stdlib.h>
 
#include <algorithm>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <map>
#include <memory>
 
// ROOT (for angle calculations)
#include "Math/Vector3D.h"
 
namespace ecal {
 
class EcalVetoProcessor : public framework::Producer {
 public:
  typedef std::pair<ldmx::EcalID, float> CellEnergyPair;
 
  typedef std::pair<float, float> XYCoords;
 
  EcalVetoProcessor(const std::string& name, framework::Process& process)
      : Producer(name, process) {}
 
  virtual ~EcalVetoProcessor() {}
 
  void onNewRun(const ldmx::RunHeader& rh) override;
 
  void onProcessEnd() override;
 
  void configure(framework::config::Parameters& parameters) override;
 
  void produce(framework::Event& event) override;
 
 private:
  void clearProcessor();
 
  /* Function to calculate the energy weighted shower centroid */
  ldmx::EcalID getShowerCentroidIdAndRms(
      const std::vector<ldmx::EcalHit>& ecal_rec_hits, float& shower_rms);
 
  /* Function to load up empty vector of hit maps */
  void fillHitMap(const std::vector<ldmx::EcalHit>& ecal_rec_hits,
                  std::map<ldmx::EcalID, float>& cell_map_);
 
  /* Function to take loaded hit maps and find isolated hits in them */
  void fillIsolatedHitMap(const std::vector<ldmx::EcalHit>& ecal_rec_hits,
                          ldmx::EcalID global_centroid,
                          std::map<ldmx::EcalID, float>& cell_map,
                          std::map<ldmx::EcalID, float>& cell_map_iso,
                          bool doTight = false);
 
  std::vector<XYCoords> getTrajectory(std::array<float, 3> momentum,
                                      std::array<float, 3> position);
 
  void buildBDTFeatureVector(const ldmx::EcalVetoResult& result);
 
 private:
  int nevents_{0};
  float processing_time_{0.};
 
  std::map<std::string, float> profiling_map_;
  std::map<ldmx::EcalID, float> cell_map_;
  std::map<ldmx::EcalID, float> cell_map_tight_iso_;
 
  std::vector<float> ecal_layer_edep_raw_;
  std::vector<float> ecal_layer_edep_readout_;
  std::vector<float> ecal_layer_time_;
 
  std::vector<std::vector<float>> roc_range_values_;
 
  int n_ecal_layers_{0};
  int n_readout_hits_{0};
  int deepest_layer_hit_{0};
 
  float summed_det_{0};
  float summed_tight_iso_{0};
  float max_cell_dep_{0};
  float shower_rms_{0};
  float x_std_{0};
  float y_std_{0};
  float avg_layer_hit_{0};
  float std_layer_hit_{0};
  float ecal_back_energy_{0};
 
  int n_tracking_hits_{0};
  float ep_ang_{0};
  float ep_ang_at_target_{0};
  float ep_sep_{0};
  float ep_dot_{0};
  float ep_dot_at_target_{0};
 
  float bdt_cut_val_{0};
 
  float beam_energy_mev_{0};
 
  std::string bdt_file_name_;
  std::string roc_file_name_;
  std::vector<float> bdt_features_;
  std::string feature_list_name_;
 
  // Pass and collection names
  std::string sp_pass_name_;
  std::string rec_pass_name_;
  std::string rec_coll_name_;
  bool recoil_from_tracking_;
  std::string track_pass_name_;
  std::string track_collection_;
 
  std::string sim_particles_passname_;
  bool inverse_skim_{false};
 
  std::string collection_name_{"EcalVeto"};
 
  std::unique_ptr<ldmx::ort::ONNXRuntime> rt_;
 
  const ldmx::EcalGeometry* geometry_;
};
 
}  // namespace ecal
 
#endif