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 sameEvent(const PolarfireQueueEntry& rhs) {
      return (spill_ == rhs.spill_ and
              abs(ticks_ - rhs.ticks_) < max_tick_diff);
    }
    bool earlierEvent(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 */