DeepTriggerProcessor.cxx

Go to the documentation of this file.

 
#include <limits>
 
#include "DetDescr/EcalID.h"
#include "Ecal/Event/EcalHit.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/EventProcessor.h"
#include "Recon/Event/TriggerResult.h"
 
namespace recon {
 
class DeepTriggerProcessor : public framework::Producer {
 public:
  DeepTriggerProcessor(const std::string& name, framework::Process& process)
      : framework::Producer(name, process) {}
 
  virtual ~DeepTriggerProcessor() {}
 
  void configure(framework::config::Parameters& parameters) override;
 
  void produce(framework::Event& event) override;
 
 private:
  std::vector<double> layer_e_sum_cuts_;
 
  double beam_energy_;
 
  int mode_{0};
 
  int start_layer_{0};
 
  int end_layer_{0};
 
  TString algo_name_;
 
  std::string input_coll_;
 
  std::string input_pass_;
 
  std::string output_coll_;
};
 
void DeepTriggerProcessor::configure(
    framework::config::Parameters& parameters) {
  layer_e_sum_cuts_ = parameters.get<std::vector<double>>("thresholds");
  beam_energy_ = parameters.get<double>("beam_energy");
  mode_ = parameters.get<int>("mode");
  start_layer_ = parameters.get<int>("start_layer");
  end_layer_ = parameters.get<int>("end_layer");
  input_coll_ = parameters.get<std::string>("input_collection");
  input_pass_ = parameters.get<std::string>("input_pass");
  output_coll_ = parameters.get<std::string>("trigger_collection");
 
  if (mode_ == 0) {
    algo_name_ = "DeepLayerSumTrig";
  } else if (mode_ == 1) {
    algo_name_ = "DeepCenterTower";
  }
}
 
void DeepTriggerProcessor::produce(framework::Event& event) {
  const std::vector<ldmx::EcalHit> ecal_rec_hits =
      event.getCollection<ldmx::EcalHit>(input_coll_, input_pass_);
 
  // number of electrons in this event
  const int n_electrons{event.getElectronCount()};
 
  double layer_e_sum_cut{0.};
  if (n_electrons <= 0)
    layer_e_sum_cut =
        std::numeric_limits<double>::max();  // always fail if no electrons
  else if (n_electrons <= layer_e_sum_cuts_.size())
    layer_e_sum_cut = layer_e_sum_cuts_.at(n_electrons - 1);
  else
    layer_e_sum_cut =
        layer_e_sum_cuts_.at(0) + (n_electrons - 1) * beam_energy_;
 
  ldmx_log(info) << "Got trigger energy cut " << layer_e_sum_cut << " for "
                 << n_electrons << " electrons counted in the event.";
 
  std::vector<double> layer_digi_e(100, 0.0);  // big empty vector..
 
  for (const ldmx::EcalHit& hit : ecal_rec_hits) {
    ldmx::EcalID id(hit.getID());
    if (id.layer() < layer_digi_e.size()) {  // just to be safe...
      if (mode_ == 0) {  // Sum over all cells in a given layer_
        layer_digi_e[id.layer()] += hit.getEnergy();
      } else if (mode_ == 1) {  // Sum over cells in central tower only
        // not implemented, see TriggerProcessor
      }
    }
  }
 
  float layer_sum = 0;
  bool pass = false;
 
  for (int i_l = start_layer_; i_l < end_layer_; ++i_l) {
    layer_sum += layer_digi_e[i_l];
  }
 
  pass = (layer_sum >= layer_e_sum_cut);
  ldmx_log(info) << "Got trigger energy sum " << layer_sum
                 << "; and decision is pass = " << pass;
 
  ldmx::TriggerResult result;
  result.set(algo_name_, pass, 4);
  result.setAlgoVar(0, layer_sum);
  result.setAlgoVar(1, layer_e_sum_cut);
  result.setAlgoVar(2, end_layer_ - start_layer_);
  result.setAlgoVar(3, n_electrons);
 
  event.add(output_coll_, result);
 
  // mark the event
  if (pass)
    setStorageHint(framework::HINT_SHOULD_KEEP);
  else
    setStorageHint(framework::HINT_SHOULD_DROP);
}
}  // namespace recon
 
DECLARE_PRODUCER(recon::DeepTriggerProcessor)