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 "Ecal/Event/EcalHit.h"
#include "Ecal/Event/EcalVetoResult.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/EventProcessor.h"
#include "Tools/ONNXRuntime.h"
 
// ROOT (MIP tracking)
#include "TVector3.h"
 
// For recoil tracking
#include "Tracking/Event/Track.h"
 
// C++
#include <map>
#include <memory>
 
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;
 
  // MIP tracking:  Class for storing hit information for tracking in a
  // convenient way
  struct HitData {
    int layer;
    TVector3 pos;
  };
  struct HitData {…};
 
 private:
  void clearProcessor();
 
  /* Function to calculate the energy weighted shower centroid */
  ldmx::EcalID GetShowerCentroidIDAndRMS(
      const std::vector<ldmx::EcalHit>& ecalRecHits, float& showerRMS);
 
  /* Function to load up empty vector of hit maps */
  void fillHitMap(const std::vector<ldmx::EcalHit>& ecalRecHits,
                  std::map<ldmx::EcalID, float>& cellMap_);
 
  /* Function to take loaded hit maps and find isolated hits in them */
  void fillIsolatedHitMap(const std::vector<ldmx::EcalHit>& ecalRecHits,
                          ldmx::EcalID globalCentroid,
                          std::map<ldmx::EcalID, float>& cellMap,
                          std::map<ldmx::EcalID, float>& cellMapIso,
                          bool doTight = false);
 
  std::vector<XYCoords> getTrajectory(std::array<float, 3> momentum,
                                      std::array<float, 3> position);
 
  void buildBDTFeatureVector(const ldmx::EcalVetoResult& result);
 
  // MIP tracking
  float distTwoLines(TVector3 v1, TVector3 v2, TVector3 w1, TVector3 w2);
  float distPtToLine(TVector3 h1, TVector3 p1, TVector3 p2);
 
  std::vector<float> trackProp(const ldmx::Tracks& tracks,
                               ldmx::TrackStateType ts_type,
                               const std::string& ts_title);
 
 private:
  int nevents_{0};
  float processing_time_{0.};
 
  std::map<std::string, float> profiling_map_;
  std::map<ldmx::EcalID, float> cellMap_;
  std::map<ldmx::EcalID, float> cellMapTightIso_;
 
  std::vector<float> ecalLayerEdepRaw_;
  std::vector<float> ecalLayerEdepReadout_;
  std::vector<float> ecalLayerTime_;
 
  std::vector<std::vector<float>> roc_range_values_;
 
  int nEcalLayers_{0};
  int nReadoutHits_{0};
  int deepestLayerHit_{0};
 
  float summedDet_{0};
  float summedTightIso_{0};
  float maxCellDep_{0};
  float showerRMS_{0};
  float xStd_{0};
  float yStd_{0};
  float avgLayerHit_{0};
  float stdLayerHit_{0};
  float ecalBackEnergy_{0};
  // MIP tracking
  int nStraightTracks_{0};
  int nLinregTracks_{0};
  int firstNearPhLayer_{0};
  int nNearPhHits_{0};
  float epAng_{0};
  float epAngAtTarget_{0};
  float epSep_{0};
  float epDot_{0};
  float epDotAtTarget_{0};
  int photonTerritoryHits_{0};
 
  float bdtCutVal_{0};
 
  float beamEnergyMeV_{0};
  bool run_lin_reg_{true};
  float linreg_radius_{0};
 
  std::string bdtFileName_;
  std::string rocFileName_;
  std::vector<float> bdtFeatures_;
  std::string featureListName_;
 
  // 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_;
  bool inverse_skim_{false};
 
  std::string collectionName_{"EcalVeto"};
 
  std::unique_ptr<ldmx::Ort::ONNXRuntime> rt_;
 
  const ldmx::EcalGeometry* geometry_;
};
class EcalVetoProcessor : public framework::Producer {…};
 
}  // namespace ecal
 
#endif