OverlayProducer.h

#ifndef RECON_OVERLAYPRODUCER_H
#define RECON_OVERLAYPRODUCER_H
 
//---< C++ StdLib >---//
#include <memory>
#include <string>
#include <vector>
 
//---< ROOT >---//
#include "TRandom2.h"
 
//---< Framework >---//
#include "Framework/Configure/Parameters.h"
#include "Framework/EventFile.h"
#include "Framework/EventProcessor.h"
 
namespace recon {
 
class OverlayProducer : public framework::Producer {
 public:
  OverlayProducer(const std::string& name, framework::Process& process)
      : framework::Producer(name, process), overlay_event_{"overlay"} {}
 
  // Destructor
  virtual ~OverlayProducer() = default;
 
  void configure(framework::config::Parameters& parameters) override;
 
  void onNewRun(const ldmx::RunHeader&) override;  // );    //
 
  void produce(framework::Event& event) override;
 
  int encodeTrack(int track_id, const unsigned int encoding_version,
                  const unsigned int event_index = 0);
 
  void onProcessStart() override;
 
 private:
  framework::config::Parameters params_;
 
  std::string overlay_filename_;
 
  std::unique_ptr<framework::EventFile> overlay_file_;
 
  framework::Event overlay_event_;
 
  std::vector<std::string> calo_collections_;
 
  std::vector<std::string> tracker_collections_;
 
  std::vector<std::string> particle_collections_;
 
  std::vector<std::string> contrib_collections_;
 
  std::string overlay_passname_;
 
  std::string sim_passname_;
 
  std::string out_coll_postfix_;
 
  bool do_poisson_in_time_{false};
 
  bool do_poisson_out_of_time_{false};
 
  double poisson_mu_{0.};
 
  std::unique_ptr<TRandom2> rndm_;
 
  std::unique_ptr<TRandom2> rndm_time_;
 
  double time_sigma_{0.};
 
  double time_mean_{0.};
 
  double bunch_spacing_{0.};
 
  int n_earlier_{0};
 
  int n_later_{0};
 
  int start_event_min_{1};
 
  int start_event_max_{10000};
 
  unsigned track_id_encoding_{0};
};
}  // namespace recon
 
#endif /* RECON_OVERLAY_OVERLAYPRODUCER_H */