Public Member Functions
	VisiblesVetoProcessor (const std::string &name, framework::Process &process)

void	configure (framework::config::Parameters &parameters) override
	Callback for the EventProcessor to configure itself from the given set of parameters.

void	produce (framework::Event &event) override
	Process the event and put new data products into it.

Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.

virtual void	process (Event &event) final
	Processing an event for a Producer is calling produce.

Public Member Functions inherited from framework::EventProcessor
	DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
	declare that we have a factory for this class

	EventProcessor (const std::string &name, Process &process)
	Class constructor.

virtual	~EventProcessor ()=default
	Class destructor.

virtual void	beforeNewRun (ldmx::RunHeader &run_header)
	Callback for Producers to add parameters to the run header before conditions are initialized.

virtual void	onNewRun (const ldmx::RunHeader &run_header)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.

virtual void	onFileOpen (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.

virtual void	onFileClose (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.

virtual void	onProcessStart ()
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

virtual void	onProcessEnd ()
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.

TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.

void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module_.

void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.

int	getLogFrequency () const
	Get the current logging frequency from the process.

int	getRunNumber () const
	Get the run number from the process.

std::string	getName () const
	Get the processor name.

void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Member Functions
void	clearProcessor ()

void	buildBDTFeatureVector (const ldmx::VisiblesVetoResult &result)

bool	inList (std::vector< int > parents, int track_id)

Private Attributes
int	n_layers_hit_ {0}

double	x_std_ {0}

double	y_std_ {0}

double	z_std_ {0}

double	x_mean_ {0}

double	y_mean_ {0}

double	r_mean_ {0}

int	iso_hits_ {0}

double	iso_energy_ {0}

int	n_readout_hits_ {0}

double	summed_det_ {0}

double	r_mean_from_photon_track_ {0}

double	bdt_cut_val_ {0}

double	beam_energy_mev_ {0}

std::vector< float >	bdt_features_

std::string	feature_list_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	sp_collection_

std::string	sp_pass_name_

std::string	sim_particles_pass_name_

std::string	collection_name_ {"VisiblesVeto"}

std::unique_ptr< ldmx::ort::ONNXRuntime >	rt_

Additional Inherited Members
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms

NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.

logging::logger	the_log_
	The logger for this EventProcessor.

Detailed Description

Definition at line 22 of file VisiblesVetoProcessor.h.

Constructor & Destructor Documentation

◆ VisiblesVetoProcessor()

hcal::VisiblesVetoProcessor::VisiblesVetoProcessor	(	const std::string &	name,
		framework::Process &	process )

inline

Definition at line 24 of file VisiblesVetoProcessor.h.

25 : Producer(name, process) {}

framework::Producer::Producer

Producer(const std::string &name, Process &process)

Class constructor.

Definition EventProcessor.cxx:54

framework::Producer::process

virtual void process(Event &event) final

Processing an event for a Producer is calling produce.

Definition EventProcessor.h:278

◆ ~VisiblesVetoProcessor()

virtual hcal::VisiblesVetoProcessor::~VisiblesVetoProcessor ( )

inlinevirtual

Definition at line 27 of file VisiblesVetoProcessor.h.

27{}

Member Function Documentation

◆ buildBDTFeatureVector()

void hcal::VisiblesVetoProcessor::buildBDTFeatureVector ( const ldmx::VisiblesVetoResult & result )

private

Definition at line 18 of file VisiblesVetoProcessor.cxx.

                                          {
  bdt_features_.push_back(result.getNLayersHit());
  bdt_features_.push_back(result.getXStd());
  bdt_features_.push_back(result.getYStd());
  bdt_features_.push_back(result.getZStd());
  bdt_features_.push_back(result.getXMean());
  bdt_features_.push_back(result.getYMean());
  bdt_features_.push_back(result.getRMean());
  bdt_features_.push_back(result.getIsoHits());
  bdt_features_.push_back(result.getIsoEnergy());
  bdt_features_.push_back(result.getNReadoutHits());
  bdt_features_.push_back(result.getSummedDet());
  bdt_features_.push_back(result.getDistFromPhotonTrack());
}

◆ clearProcessor()

void hcal::VisiblesVetoProcessor::clearProcessor ( )

private

Definition at line 64 of file VisiblesVetoProcessor.cxx.

                                           {
  bdt_features_.clear();
 
  n_layers_hit_ = 0;
  x_std_ = 0.;
  y_std_ = 0.;
  z_std_ = 0.;
  x_mean_ = 0.;
  y_mean_ = 0.;
  r_mean_ = 0.;
  iso_hits_ = 0;
  iso_energy_ = 0.;
  n_readout_hits_ = 0;
  summed_det_ = 0.;
  r_mean_from_photon_track_ = 0.;
}

◆ configure()

void hcal::VisiblesVetoProcessor::configure ( framework::config::Parameters & parameters )

overridevirtual

Callback for the EventProcessor to configure itself from the given set of parameters.

The parameters a processor has access to are the member variables of the python class in the sequence that has class_name equal to the EventProcessor class name.

For an example, look at MyProcessor.

Parameters

parameters Parameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 34 of file VisiblesVetoProcessor.cxx.

                                           {
  feature_list_name_ = parameters.get<std::string>("feature_list_name");
  // Load BDT ONNX file
  rt_ = std::make_unique<ldmx::ort::ONNXRuntime>(
      parameters.get<std::string>("bdt_file"));
 
  bdt_cut_val_ = parameters.get<double>("disc_cut");
 
  beam_energy_mev_ = parameters.get<double>("beam_energy");
 
  // collection and pass names
  collection_name_ = parameters.get<std::string>("collection_name");
  rec_pass_name_ = parameters.get<std::string>("rec_pass_name");
  rec_coll_name_ = parameters.get<std::string>("rec_coll_name");
 
  recoil_from_tracking_ = parameters.get<bool>("recoil_from_tracking");
  track_collection_ = parameters.get<std::string>("track_collection");
  track_pass_name_ = parameters.get<std::string>("track_pass_name");
 
  sp_collection_ = parameters.get<std::string>("sp_coll_name");
  sp_pass_name_ = parameters.get<std::string>("sp_pass_name");
  sim_particles_pass_name_ =
      parameters.get<std::string>("sim_particles_pass_name");
}

References framework::config::Parameters::get().

◆ inList()

bool hcal::VisiblesVetoProcessor::inList	(	std::vector< int >	parents,
		int	track_id )

private

Definition at line 60 of file VisiblesVetoProcessor.cxx.

                                                                       {
  return std::find(parents.begin(), parents.end(), track_id) != parents.end();
}

◆ produce()

void hcal::VisiblesVetoProcessor::produce ( framework::Event & event )

overridevirtual

Process the event and put new data products into it.

Parameters

event The Event to process.

Implements framework::Producer.

Definition at line 81 of file VisiblesVetoProcessor.cxx.

                                                         {
  ldmx::VisiblesVetoResult result;
 
  clearProcessor();
 
  const auto &particle_map{event.getMap<int, ldmx::SimParticle>(
      "SimParticles", sim_particles_pass_name_)};
 
  // Get target scoring plane hits for recoil electron
  // Use this to calculate the projected photon line vector
  // This currently uses truth-level information, but it should be replaced
  // by reconstructed tracker information, when available
  std::vector<double> gamma_p(3);
  std::vector<double> gamma_x0(3);
  if (recoil_from_tracking_) {
    const auto &recoil_tracks{
        event.getCollection<ldmx::Track>(track_collection_, track_pass_name_)};
    // Fill this in later when you know how to use it
    for (auto &track : recoil_tracks) {
      // need to figure out how to best isolate candidate electron track
      auto trk_pos = track.getPositionAtTarget();
      auto trk_mom = track.getMomentumAtTarget();
      if (track.getCharge() == 1 && track.getNhits() == 5 &&
          trk_pos.size() == 3 && trk_mom.size() == 3) {
        gamma_x0 = trk_pos;
        gamma_p[0] = -1. * trk_mom[0];
        gamma_p[1] = -1. * trk_mom[1];
        gamma_p[2] = beam_energy_mev_ - trk_mom[2];
      }
    }
  } else {
    if (event.exists(sp_collection_, sp_pass_name_)) {
      const auto &target_sp_hits = event.getCollection<ldmx::SimTrackerHit>(
          sp_collection_, sp_pass_name_);
      for (auto const &it : particle_map) {
        for (auto const &sphit : target_sp_hits) {
          if (sphit.getPosition()[2] > 0) {
            if (it.first == sphit.getTrackID()) {
              if (it.second.getPdgID() == 11 &&
                  inList(it.second.getParents(), 0)) {
                /* Since SP hit positions are stored as floats and gamma_x0 is
                 a double vector, the conversion here is a little convolcuted.
               */
                std::vector<float> x0_float = sphit.getPosition();
                std::vector<double> x0_double(x0_float.begin(), x0_float.end());
                gamma_x0 = x0_double;
                gamma_p[0] = -1. * sphit.getMomentum()[0];
                gamma_p[1] = -1. * sphit.getMomentum()[1];
                gamma_p[2] = beam_energy_mev_ - sphit.getMomentum()[2];
              }
            }
          }
        }
      }
    }
  }
 
  // Get Hcal reconstructed hits and loop through them to build features
  const auto &hcal_rec_hits =
      event.getCollection<ldmx::HcalHit>(rec_coll_name_, rec_pass_name_);
 
  double z_mean = 0.;  // need this when calculating z_std_
  std::vector<int> layers_hit;
  for (const ldmx::HcalHit &hit : hcal_rec_hits) {
    if (hit.getEnergy() > 0.) {
      ldmx::HcalID det_id(hit.getID());
      if (det_id.getSection() != 0) {  // skip hits that aren't in main Hcal
        continue;
      }
      n_readout_hits_ += 1;
      double hit_x = hit.getXPos();
      double hit_y = hit.getYPos();
      double hit_z = hit.getZPos();
      double hit_r = sqrt(hit_x * hit_x + hit_y * hit_y);
 
      summed_det_ += hit.getEnergy();
 
      x_mean_ += hit_x * hit.getEnergy();
      y_mean_ += hit_y * hit.getEnergy();
      z_mean += hit_z * hit.getEnergy();
      r_mean_ += hit_r * hit.getEnergy();
 
      // check if this is a new layer in the collection
      if (!(std::find(layers_hit.begin(), layers_hit.end(),
                      det_id.getLayerID()) != layers_hit.end())) {
        layers_hit.push_back(det_id.getLayerID());
      }
 
      double proj_x =
          gamma_x0[0] + (hit_z - gamma_x0[2]) * gamma_p[0] / gamma_p[2];
      double proj_y =
          gamma_x0[1] + (hit_z - gamma_x0[2]) * gamma_p[1] / gamma_p[2];
 
      r_mean_from_photon_track_ +=
          hit.getEnergy() * sqrt((hit_x - proj_x) * (hit_x - proj_x) +
                                 (hit_y - proj_y) * (hit_y - proj_y));
 
      // Calculate isolated hits
      double closest_point = 9999.;
      for (const ldmx::HcalHit &hit2 : hcal_rec_hits) {
        if (hit2.getEnergy() > 0.) {
          ldmx::HcalID det_i_d2(hit2.getID());
          if (det_i_d2.getLayerID() == det_id.getLayerID()) {
            // Determine if a bar is vertical (along y-axis) or horizontal
            // (along x-axis) Odd layers have horizontal strips Even layers have
            // vertical strips
            if (hit.isOrientationX()) {
              if (abs(hit2.getYPos() - hit_y) > 0) {
                if (abs(hit2.getYPos() - hit_y) < closest_point) {
                  closest_point = abs(hit2.getYPos() - hit_y);
                }
              }
            }
            if (hit.isOrientationY()) {
              if (abs(hit2.getXPos() - hit_x) > 0) {
                if (abs(hit2.getXPos() - hit_x) < closest_point) {
                  closest_point = abs(hit2.getXPos() - hit_x);
                }
              }
            }
          }
        }
      }
      if (closest_point > 50.) {
        iso_hits_ += 1;
        iso_energy_ += hit.getEnergy();
      }
    }
  }
 
  n_layers_hit_ = layers_hit.size();
 
  if (summed_det_ > 0.) {
    x_mean_ /= summed_det_;
    y_mean_ /= summed_det_;
    z_mean /= summed_det_;
    r_mean_ /= summed_det_;
 
    r_mean_from_photon_track_ /= summed_det_;
  }
 
  for (const ldmx::HcalHit &hit : hcal_rec_hits) {
    if (hit.getEnergy() > 0.) {
      ldmx::HcalID det_id(hit.getID());
      if (det_id.getSection() == 0) {
        x_std_ += hit.getEnergy() * (hit.getXPos() - x_mean_) *
                  (hit.getXPos() - x_mean_);
        y_std_ += hit.getEnergy() * (hit.getYPos() - y_mean_) *
                  (hit.getYPos() - y_mean_);
        z_std_ += hit.getEnergy() * (hit.getZPos() - z_mean) *
                  (hit.getZPos() - z_mean);
      }
    }
  }
 
  if (summed_det_ > 0.) {
    x_std_ = sqrt(x_std_ / summed_det_);
    y_std_ = sqrt(y_std_ / summed_det_);
    z_std_ = sqrt(z_std_ / summed_det_);
  }
 
  result.setVariables(n_layers_hit_, x_std_, y_std_, z_std_, x_mean_, y_mean_,
                      r_mean_, iso_hits_, iso_energy_, n_readout_hits_,
                      summed_det_, r_mean_from_photon_track_);
 
  buildBDTFeatureVector(result);
 
  ldmx::ort::FloatArrays inputs({bdt_features_});
  float pred =
      rt_->run({feature_list_name_}, inputs, {"probabilities"})[0].at(1);
  ldmx_log(info) << " Visibles BDT was ran, score is " << pred;
 
  event.add(collection_name_, result);
}

References framework::Event::exists(), and ldmx::HcalID::getLayerID().

Member Data Documentation

◆ bdt_cut_val_

double hcal::VisiblesVetoProcessor::bdt_cut_val_ {0}

private

Definition at line 54 of file VisiblesVetoProcessor.h.

54{0};

◆ bdt_features_

std::vector<float> hcal::VisiblesVetoProcessor::bdt_features_

private

Definition at line 58 of file VisiblesVetoProcessor.h.

◆ beam_energy_mev_

double hcal::VisiblesVetoProcessor::beam_energy_mev_ {0}

private

Definition at line 56 of file VisiblesVetoProcessor.h.

56{0};

◆ collection_name_

std::string hcal::VisiblesVetoProcessor::collection_name_ {"VisiblesVeto"}

private

Definition at line 71 of file VisiblesVetoProcessor.h.

71{"VisiblesVeto"};

◆ feature_list_name_

std::string hcal::VisiblesVetoProcessor::feature_list_name_

private

Definition at line 59 of file VisiblesVetoProcessor.h.

◆ iso_energy_

double hcal::VisiblesVetoProcessor::iso_energy_ {0}

private

Definition at line 49 of file VisiblesVetoProcessor.h.

49{0};

◆ iso_hits_

int hcal::VisiblesVetoProcessor::iso_hits_ {0}

private

Definition at line 48 of file VisiblesVetoProcessor.h.

48{0};

◆ n_layers_hit_

int hcal::VisiblesVetoProcessor::n_layers_hit_ {0}

private

Definition at line 41 of file VisiblesVetoProcessor.h.

41{0};

◆ n_readout_hits_

int hcal::VisiblesVetoProcessor::n_readout_hits_ {0}

private

Definition at line 50 of file VisiblesVetoProcessor.h.

50{0};

◆ r_mean_

double hcal::VisiblesVetoProcessor::r_mean_ {0}

private

Definition at line 47 of file VisiblesVetoProcessor.h.

47{0};

◆ r_mean_from_photon_track_

double hcal::VisiblesVetoProcessor::r_mean_from_photon_track_ {0}

private

Definition at line 52 of file VisiblesVetoProcessor.h.

52{0};

◆ rec_coll_name_

std::string hcal::VisiblesVetoProcessor::rec_coll_name_

private

Definition at line 63 of file VisiblesVetoProcessor.h.

◆ rec_pass_name_

std::string hcal::VisiblesVetoProcessor::rec_pass_name_

private

Definition at line 62 of file VisiblesVetoProcessor.h.

◆ recoil_from_tracking_

bool hcal::VisiblesVetoProcessor::recoil_from_tracking_

private

Definition at line 64 of file VisiblesVetoProcessor.h.

◆ rt_

std::unique_ptr<ldmx::ort::ONNXRuntime> hcal::VisiblesVetoProcessor::rt_

private

Definition at line 73 of file VisiblesVetoProcessor.h.

◆ sim_particles_pass_name_

std::string hcal::VisiblesVetoProcessor::sim_particles_pass_name_

private

Definition at line 69 of file VisiblesVetoProcessor.h.

◆ sp_collection_

std::string hcal::VisiblesVetoProcessor::sp_collection_

private

Definition at line 67 of file VisiblesVetoProcessor.h.

◆ sp_pass_name_

std::string hcal::VisiblesVetoProcessor::sp_pass_name_

private

Definition at line 68 of file VisiblesVetoProcessor.h.

◆ summed_det_

double hcal::VisiblesVetoProcessor::summed_det_ {0}

private

Definition at line 51 of file VisiblesVetoProcessor.h.

51{0};

◆ track_collection_

std::string hcal::VisiblesVetoProcessor::track_collection_

private

Definition at line 66 of file VisiblesVetoProcessor.h.

◆ track_pass_name_

std::string hcal::VisiblesVetoProcessor::track_pass_name_

private

Definition at line 65 of file VisiblesVetoProcessor.h.

◆ x_mean_

double hcal::VisiblesVetoProcessor::x_mean_ {0}

private

Definition at line 45 of file VisiblesVetoProcessor.h.

45{0};

◆ x_std_

double hcal::VisiblesVetoProcessor::x_std_ {0}

private

Definition at line 42 of file VisiblesVetoProcessor.h.

42{0};

◆ y_mean_

double hcal::VisiblesVetoProcessor::y_mean_ {0}

private

Definition at line 46 of file VisiblesVetoProcessor.h.

46{0};

◆ y_std_

double hcal::VisiblesVetoProcessor::y_std_ {0}

private

Definition at line 43 of file VisiblesVetoProcessor.h.

43{0};

◆ z_std_

double hcal::VisiblesVetoProcessor::z_std_ {0}

private

Definition at line 44 of file VisiblesVetoProcessor.h.

44{0};

The documentation for this class was generated from the following files:

Hcal/include/Hcal/VisiblesVetoProcessor.h
Hcal/src/Hcal/VisiblesVetoProcessor.cxx

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ VisiblesVetoProcessor()

◆ ~VisiblesVetoProcessor()

Member Function Documentation

◆ buildBDTFeatureVector()

◆ clearProcessor()

◆ configure()

◆ inList()

◆ produce()

Member Data Documentation

◆ bdt_cut_val_

◆ bdt_features_

◆ beam_energy_mev_

◆ collection_name_

◆ feature_list_name_

◆ iso_energy_

◆ iso_hits_

◆ n_layers_hit_

◆ n_readout_hits_

◆ r_mean_

◆ r_mean_from_photon_track_

◆ rec_coll_name_

◆ rec_pass_name_

◆ recoil_from_tracking_

◆ rt_

◆ sim_particles_pass_name_

◆ sp_collection_

◆ sp_pass_name_

◆ summed_det_

◆ track_collection_

◆ track_pass_name_

◆ x_mean_

◆ x_std_

◆ y_mean_

◆ y_std_

◆ z_std_