HcalAlignPolarfires.h

#ifndef HCALALIGNPOLARFIRES_H
#define HCALALIGNPOLARFIRES_H
#include <queue>
 
#include "Framework/EventProcessor.h"
#include "Recon/Event/HgcrocDigiCollection.h"
 
namespace hcal {
class HcalAlignPolarfires : public framework::Producer {
  std::vector<std::string> input_names_;
  std::string input_pass_;
  std::string output_name_;
  static int max_tick_diff_;
 
 public:
  struct PolarfireQueueEntry {
    int spill;
    int ticks;
    ldmx::HgcrocDigiCollection digis;
    PolarfireQueueEntry(const framework::Event& event,
                        const std::string& input_name,
                        const std::string& input_pass,
                        std::pair<int, int>& spill_counter);
    bool same_event(const PolarfireQueueEntry& rhs) {
      return (spill == rhs.spill and abs(ticks - rhs.ticks) < max_tick_diff_);
    }
    bool earlier_event(const PolarfireQueueEntry& rhs) {
      if (spill == rhs.spill) return ticks < rhs.ticks;
      return spill < rhs.spill;
    }
  };
  std::queue<PolarfireQueueEntry> pf0_queue, pf1_queue;
  std::pair<int, int> pf0_spill_counter{0, -1}, pf1_spill_counter{0, -1};
 
 public:
  HcalAlignPolarfires(const std::string& n, framework::Process& p)
      : framework::Producer(n, p) {}
  virtual ~HcalAlignPolarfires() = default;
  void configure(framework::config::Parameters& ps) override;
  void produce(framework::Event& event) override;
};
 
}  // namespace hcal
#endif /* HCALALIGNPOLARFIRES_H */