recon::OverlayProducer Class Reference

Class to overlay in-time pile-up events from an overlay file. More...

#include <OverlayProducer.h>

Public Member Functions
	OverlayProducer (const std::string &name, framework::Process &process)
void	configure (framework::config::Parameters &parameters) override
	Configure the processor with input parameters from the python cofig.
void	onNewRun (const ldmx::RunHeader &) override
	At the start of the run, the pileup overlay file is set up, and the starting event number is chosen, using the RNSS.
void	produce (framework::Event &event) override
	Based on the list of collections to overlay, and the desired number of events, loop through all relevant collections and copy the sim event (once), and then add the corresponding collection from the pileup overlay file.
int	encodeTrack (int track_id, const unsigned int encoding_version, const unsigned int event_index=0)
	Encode track ID with overlay event information.
void	onProcessStart () override
	At the start of processing, the pileup overlay file is set up.
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	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	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 Attributes
framework::config::Parameters	params_
	The parameters used to configure this producer.
std::string	overlay_filename_
	Pileup overlay events input file name.
std::unique_ptr< framework::EventFile >	overlay_file_
	Pileup overlay events input file.
framework::Event	overlay_event_
	The overlay ldmx event bus.
std::vector< std::string >	calo_collections_
	List of SimCalorimeterHit collection(s) to loop over and add hits from, combining sim and pileup.
std::vector< std::string >	tracker_collections_
	List of SimTrackerHit collection(s) to loop over and add hits from, combining sim and pileup.
std::vector< std::string >	particle_collections_
	List of SimParticle collection(s) to loop over and add hits from, combining sim and pileup.
std::vector< std::string >	contrib_collections_
	List of SimCalorimeterHit collections which keep track of hit contribs.
std::string	overlay_passname_
	Pileup overlay events input pass name.
std::string	sim_passname_
	To use for finding the sim event bus passengers, mostly a disambiguation.
std::string	out_coll_postfix_
	Postfix to add to the collection name of the overlayed collections.
bool	do_poisson_in_time_ {false}
	Let the total number of in-time events be poisson distributed, or fix at the chosen value, poissonMu_.
bool	do_poisson_out_of_time_ {false}
	Let the total number of out-of-time events be poisson distributed, or fix at the chosen value, poissonMu_.
double	poisson_mu_ {0.}
	(average) total number of events
std::unique_ptr< TRandom2 >	rndm_
	Random number generator for number of overlaid events.
std::unique_ptr< TRandom2 >	rndm_time_
	Random number generator for pileup event time offset.
double	time_sigma_ {0.}
	Width of pileup bunch spread in time (in [ns]), specified as a sigma of a Gaussian distribution.
double	time_mean_ {0.}
	Average position in time (in [ns]) of pileup bunches, relative to the sim event.
double	bunch_spacing_ {0.}
	Spacing in time (in [ns]) between electron bunches.
int	n_earlier_ {0}
	Number of bunches before the sim event to pull pileup events from.
int	n_later_ {0}
	Number of bunches after the sim event to pull pileup events from.
int	start_event_min_ {1}
	Minimum event number to start overlaying from.
int	start_event_max_ {10000}
	Maximum event number to start overlaying from.
unsigned	track_id_encoding_ {0}
	Track ID encoding scheme version.

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

Class to overlay in-time pile-up events from an overlay file.

Definition at line 30 of file OverlayProducer.h.

Constructor & Destructor Documentation

OverlayProducer()

recon::OverlayProducer::OverlayProducer ( const std::string & name, framework::Process & process )

inline

Definition at line 32 of file OverlayProducer.h.

      : framework::Producer(name, process), overlay_event_{"overlay"} {}

Member Function Documentation

configure()

void recon::OverlayProducer::configure ( framework::config::Parameters & parameters )

overridevirtual

Configure the processor with input parameters from the python cofig.

Print the parameters actually set. Helpful in case of typos.

Reimplemented from framework::EventProcessor.

Definition at line 5 of file OverlayProducer.cxx.

                                                                     {
  params_ = parameters;
 
  // name of file containing events to be overlaid, and a list of collections to
  // overlay
  overlay_filename_ = parameters.get<std::string>("overlay_filename");
  calo_collections_ =
      parameters.get<std::vector<std::string>>("calo_collections");
  tracker_collections_ =
      parameters.get<std::vector<std::string>>("tracker_collections");
  particle_collections_ =
      parameters.get<std::vector<std::string>>("particle_collections");
  contrib_collections_ =
      parameters.get<std::vector<std::string>>("contrib_collections");
  sim_passname_ = parameters.get<std::string>("sim_passname");
  overlay_passname_ = parameters.get<std::string>("overlay_passname");
  out_coll_postfix_ = parameters.get<std::string>("out_coll_postfix");
  // overlay specifics:
  poisson_mu_ = parameters.get<double>("poisson_mu");
  do_poisson_in_time_ = parameters.get<bool>("do_poisson_in_time");
  do_poisson_out_of_time_ = parameters.get<bool>("do_poisson_out_of_time");
  time_sigma_ = parameters.get<double>("time_sigma");
  time_mean_ = parameters.get<double>("time_mean");
  n_earlier_ = parameters.get<int>("n_earlier");
  n_later_ = parameters.get<int>("n_later");
  bunch_spacing_ = parameters.get<double>("bunch_spacing");
  start_event_min_ = parameters.get<int>("start_event_min");
  start_event_max_ = parameters.get<int>("start_event_max");
  track_id_encoding_ = unsigned(parameters.get<int>("track_id_encoding", 0));
 
  ldmx_log(debug) << "Got parameters \n \t overlayFileName = "
                  << overlay_filename_
                  << "\n\t sim pass name = " << sim_passname_
                  << "\n\t overlay pass name = " << overlay_passname_;
  ldmx_log(debug) << "\n\t overlayCaloHitCollections = ";
  for (const auto &coll : calo_collections_) {
    ldmx_log(debug) << coll << "; ";
  }
 
  ldmx_log(debug) << "\n\t overlayTrackerHitCollections = ";
  for (const std::string &coll : tracker_collections_) {
    ldmx_log(debug) << coll << "; ";
  }
 
  ldmx_log(debug) << "\n\t overlayParticleCollections = ";
  for (const std::string &coll : particle_collections_) {
    ldmx_log(debug) << coll << "; ";
  }
 
  ldmx_log(trace) << "\n\t numberOverlaidInteractions = " << poisson_mu_
                  << "\n\t nEarlierBunchesToSample = " << n_earlier_
                  << "\n\t nLaterBunchesToSample = " << n_later_
                  << "\n\t bunchSpacing = " << bunch_spacing_
                  << "\n\t doPoissonIntime = " << do_poisson_in_time_
                  << "\n\t doPoissonOutoftime = " << do_poisson_out_of_time_
                  << "\n\t timeSpread = " << time_sigma_
                  << "\n\t timeMean = " << time_mean_
                  << "\n\t startEventMin = " << start_event_min_
                  << "\n\t startEventMax = " << start_event_max_;
 
  // given how the contrib collection specification is setup, it's possible for
  // spelling errors to cause doom here, so we want to flag those
  for (auto coll_name : contrib_collections_) {
    if (std::find(calo_collections_.begin(), calo_collections_.end(),
                  coll_name) == calo_collections_.end()) {
      EXCEPTION_RAISE("CollNameMismatch",
                      "The contrib-using collection " + coll_name +
                          " does not match any SimCalorimeterHit collection in "
                          "'calo_collections_'! Please check your spelling");
    }
  }
 
  return;
}  // end configure()

References bunch_spacing_, calo_collections_, contrib_collections_, do_poisson_in_time_, do_poisson_out_of_time_, framework::config::Parameters::get(), n_earlier_, n_later_, out_coll_postfix_, overlay_filename_, overlay_passname_, params_, particle_collections_, poisson_mu_, sim_passname_, start_event_max_, start_event_min_, time_mean_, time_sigma_, track_id_encoding_, and tracker_collections_.

encodeTrack()

int recon::OverlayProducer::encodeTrack	(	int	track_id,
		const unsigned int	encoding_version,
		const unsigned int	event_index = 0 )

Encode track ID with overlay event information.

Performs bitwise encoding on track ID integer with version and event index.

VERSION DESCRIPTION

• 0 : no encoding, leaves track_id alone
• 1 : four bit version (27-31) plus three bit event index (24-26)

Definition at line 534 of file OverlayProducer.cxx.

                                                                 {
  ldmx_log(trace) << "Encoding track ID " << track_id
                  << " according to version " << encoding_version;
  int encoded_id;
 
  // check if the encoding_version will overflow into the int sign bit
  if (encoding_version > 15) {
    EXCEPTION_RAISE("TrackEncodingError",
                    "Track ID encoding version " +
                        std::to_string(encoding_version) +
                        " has exceeded version maximum value of 15");
  }
  if (track_id < 0) {
    // if track_id < 0 it's probably a default nonsense value -1;
    // encoding at present DOES NOT WORK for negative values because C++ uses
    // twos complement encoding for negative numbers;
    // thus when decoding you should first check the first bit, and
    // set it to a nonsense -1 if the number is negative.
    // Right now (2026-03-07) the only place where track IDs are -1 are the
    // origin ids in the SimCalorimeterHit contribs, which aren't used anyways
    // and present no risk for overwriting data for duplicate track IDs, so we
    // can leave this alone
    ldmx_log(warn) << "Track ID has value " << track_id
                   << " < 0; no encoding will be applied";
    return track_id;
  }
 
  // encode Track ID according to provided version
  switch (encoding_version) {
    case (unsigned)0: {  // need braces for variable init scope control
      ldmx_log(trace) << "No encoding applied";
      encoded_id = track_id;
      break;
    }
    case (unsigned)1: {
      // create bitwise masks for encoding from version number and event index
      unsigned version_mask = (encoding_version << 27);
      unsigned index_mask = (event_index << 24);
 
      // encode track ID using bitwise OR
      encoded_id = track_id | version_mask | index_mask;
      ldmx_log(trace) << "Encoding successful! encoded_id = " << encoded_id
                      << ", with bit representation "
                      << std::bitset<32>(encoded_id);
      break;
    }
    default: {  // version number has no associated encoding scheme
      ldmx_log(warn) << "Track ID encoding version " << encoding_version
                     << " has no definition! No encoding will be applied";
      encoded_id = track_id;
    }
  }
 
  return encoded_id;
}

Referenced by produce().

onNewRun()

void recon::OverlayProducer::onNewRun ( const ldmx::RunHeader & )

overridevirtual

At the start of the run, the pileup overlay file is set up, and the starting event number is chosen, using the RNSS.

set up random seeds

Reimplemented from framework::EventProcessor.

Definition at line 81 of file OverlayProducer.cxx.

                                                    {
  const auto &rnss = getCondition<framework::RandomNumberSeedService>(
      framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
  rndm_ = std::make_unique<TRandom2>(rnss.getSeed("OverlayProducer::rndm"));
  rndm_time_ =
      std::make_unique<TRandom2>(rnss.getSeed("OverlayProducer::rndmTime"));
 
  // Pick a random event from the Pileup file
  int start_event = rndm_->Uniform(start_event_min_, start_event_max_);
  // EventFile::skipToEvent handles actual number of events in file
  int ev_number = overlay_file_->skipToEvent(start_event);
  if (ev_number < 0) {
    EXCEPTION_RAISE("BadRead", "Couldn't read to starting offset.");
  }
  overlay_event_.getEventHeader().setEventNumber(ev_number);
  ldmx_log(info) << "Starting overlay process with pileup event number "
                 << ev_number << " (random event number picked was "
                 << start_event << ").";
}  // end onNewRun()

References framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME, framework::EventProcessor::getCondition(), framework::Event::getEventHeader(), overlay_event_, overlay_file_, rndm_, rndm_time_, ldmx::EventHeader::setEventNumber(), start_event_max_, and start_event_min_.

onProcessStart()

void recon::OverlayProducer::onProcessStart ( )

overridevirtual

At the start of processing, the pileup overlay file is set up.

Reimplemented from framework::EventProcessor.

Definition at line 592 of file OverlayProducer.cxx.

                                     {
  // replace by this line once the corresponding tweak to EventFile is ready:
  overlay_file_ =
      std::make_unique<framework::EventFile>(params_, overlay_filename_, true);
  overlay_file_->setupEvent(&overlay_event_);
  // we update the iterator at the end of each event. so do this once here to
  // grab the first event in the processor
  // ldmx_log(trace) << "Used input file: "
  // << overlay_file_->getFileName() << " Got event info: " <<
  // overlay_file_->getEvent()->Print();
 
  return;
}  // end onProcessStart

References overlay_event_, overlay_file_, overlay_filename_, and params_.

produce()

void recon::OverlayProducer::produce ( framework::Event & event )

overridevirtual

Based on the list of collections to overlay, and the desired number of events, loop through all relevant collections and copy the sim event (once), and then add the corresponding collection from the pileup overlay file.

The event loop is the outer loop, and the inner loop is over the list of collections.

The collections have to be specified separately as a list of SimCalorimeterHit collections and a list of SimTrackerHit collections.

The collection name is parsed for "Ecal" to be flagged as a collection which needs overlay hits to be added as contribs. This is currently hardwired.

The resulting collections inherit the input collection name, with an appended string "Overlay". This name is also currently hardwired.

Go to next overlay event This overlay file has been configured to loop back to the beginning of the TTree when it reaches the end. This means nextEvent() will only return false if an error is occurred or if the overlay file is mis-configured.

Implements framework::Producer.

Definition at line 102 of file OverlayProducer.cxx.

                                                   {
  // using nextEvent to loop, we need to loop over overlay events and in an
  // inner loop, loop over collections, and store them. after all pileup events
  // have been added, the vector of collections is iterated over and added to
  // the event bus.
  std::map<std::string, std::vector<ldmx::SimCalorimeterHit>>
      calo_collection_map;
  std::map<std::string, std::vector<ldmx::SimTrackerHit>>
      tracker_collection_map;
  std::map<std::string, std::map<int, ldmx::SimParticle>>
      particle_collection_map;
  std::map<std::string, std::map<int, ldmx::SimCalorimeterHit>> hit_map;
 
  // start by copying over all the collections from the sim event
 
  /* ----------- first do the SimCalorimeterHits ----------- */
 
  // get the calo hits_ collections that we want to overlay, by looping over
  // the list of collections passed to the producer : calo_collections_
  for (const auto &coll_name : calo_collections_) {
    // search for the collection name in the list of collections that
    // need contribs to be added, contrib_collections_
    bool needs_contribs_added{std::find(contrib_collections_.begin(),
                                        contrib_collections_.end(),
                                        coll_name) != contrib_collections_.end()
                                  ? true
                                  : false};
 
    // start out by just copying the sim hits, unaltered.
    auto simhits_calo =
        event.getCollection<ldmx::SimCalorimeterHit>(coll_name, sim_passname_);
    // but don't copy contrib using hits immediately: for them, wait until
    // overlay contribs have been added. then add everything through the hit_map
    if (!needs_contribs_added) {
      calo_collection_map[coll_name + out_coll_postfix_] = simhits_calo;
      // after copying, perform track ID encodings;
      // the main sample gets the event index 0 by default
      for (auto &simhit : calo_collection_map[coll_name + out_coll_postfix_]) {
        simhit.encodeTracks(
            [this](int id, unsigned enc, unsigned idx) {
              return encodeTrack(id, enc, idx);
            },
            track_id_encoding_, (unsigned)0);
      }
    }
 
    ldmx_log(debug) << "in loop: start of collection " << coll_name
                    << "in loop: printing current sim event: ";
    ldmx_log(debug) << "in loop: size of sim hits_ vector " << coll_name
                    << " is " << simhits_calo.size();
 
    // we don't need to touch the hard process sim hits_, really... but we
    // might need the simhits in the hit map.
    if (needs_contribs_added) {
      ldmx_log(trace) << "Collection " << coll_name << " needs contribs added";
      for (const ldmx::SimCalorimeterHit &simhit : simhits_calo) {
        ldmx_log(trace) << simhit;
        // this copies the hit, its ID and its coordinates directly
        hit_map[coll_name + out_coll_postfix_][simhit.getID()] = simhit;
        // now encode track IDs on copied object
        hit_map[coll_name + out_coll_postfix_][simhit.getID()].encodeTracks(
            [this](int id, unsigned enc, unsigned idx) {
              return encodeTrack(id, enc, idx);
            },
            track_id_encoding_, (unsigned)0);
      }  // over calo simhit collection
    }  // if needContribs
 
  }  // over calo collections for sim event
 
  /* ----------- then do the same with SimTrackerHits! ----------- */
 
  // get the SimTrackerHit collections that we want to overlay, by looping
  // over the list of collections passed to the producer : tracker_collections_
  for (const auto &coll_name : tracker_collections_) {
    auto simhits_tracker =
        event.getCollection<ldmx::SimTrackerHit>(coll_name, sim_passname_);
    tracker_collection_map[coll_name + out_coll_postfix_] = simhits_tracker;
    // after copying, perform track ID encoding
    for (auto &simhit : tracker_collection_map[coll_name + out_coll_postfix_]) {
      int encoded_track_id =
          encodeTrack(simhit.getTrackID(), track_id_encoding_, (unsigned)0);
      simhit.setTrackID(encoded_track_id);
    }
 
    // the rest is printouts for debugging
    ldmx_log(debug) << "in loop: size of sim hits_ vector " << coll_name
                    << " is " << simhits_tracker.size();
 
    ldmx_log(debug) << "in loop: start of collection " << coll_name
                    << "in loop: printing current sim event: ";
 
    for (const ldmx::SimTrackerHit &simhit : simhits_tracker) {
      ldmx_log(trace) << simhit;
    }
  }  // over tracker collections for sim event
 
  /* ----------- and finish up with SimParticles ----------- */
 
  // get the SimParticle collections that we want to overlay, by looping
  // over the list of collections passed to the producer : particle_collections_
  for (const auto &coll_name : particle_collections_) {
    auto sim_particles =
        event.getMap<int, ldmx::SimParticle>(coll_name, sim_passname_);
    auto &output_map = particle_collection_map[coll_name + out_coll_postfix_];
 
    ldmx_log(debug) << "in loop: size of sim particles map " << coll_name
                    << " is " << sim_particles.size();
 
    ldmx_log(debug) << "in loop: start of collection " << coll_name
                    << "in loop: printing current sim event: ";
 
    // need to copy SimParticles individually because of std::map key
    // immutability
    for (auto &[track_id, particle] : sim_particles) {
      int encoded_track_id =
          encodeTrack(track_id, track_id_encoding_, (unsigned)0);
      output_map[encoded_track_id] = particle;
      output_map[encoded_track_id].encodeTracks(
          [this](int id, unsigned enc, unsigned idx) {
            return encodeTrack(id, enc, idx);
          },
          track_id_encoding_, (unsigned)0);
      ldmx_log(trace) << particle;
    }
  }  // over particle collections for sim event
 
  /* ----------- now do the overlay ----------- */
 
  // we could shift these by a random number, effectively placing the
  // sim event at random positions in the interval, preserving the
  // overall interval length
  // int simBunch=  static_cast<int>(rndm_time_->Uniform(
  //                   -(n_earlier_+1) , n_later_+1));  // +1 to get
  // inclusive interval
  int start_bunch = -n_earlier_;
  int end_bunch = n_later_;
 
  // this is the event index number assigned to overlay sample hits and
  // particles for track ID encoding
  unsigned overlay_event_index = 1;
 
  // TODO -- figure out if we should also randomly shift the time of the sim
  // event (likely only needed if time bias gets picked up by BDT or ML by way
  // of pulse behaviour)
  for (int bunch_offset{start_bunch}; bunch_offset <= end_bunch;
       bunch_offset++) {
    // sample a poisson distribution, or use mu as fixed number of overlay
    // events
    int n_events_overlay = do_poisson_out_of_time_
                               ? rndm_->Poisson(poisson_mu_)
                               : static_cast<int>(poisson_mu_);
 
    // special case: in-time pileup at bunch 0
    if (bunch_offset == 0) {
      if (!do_poisson_in_time_) {
        // fix it to the average
        n_events_overlay = static_cast<int>(poisson_mu_);
      } else if (do_poisson_in_time_ && !do_poisson_out_of_time_) {
        // then we haven't set this yet
        n_events_overlay = rndm_->Poisson(poisson_mu_);
      }
 
      // paticularly useful in the poisson fluctuated case
      event.getEventHeader().setIntParameter("in_time_pu", n_events_overlay);
 
      // the total number of events is nPU + 1 (it includes the sim event)
      // in any case, subtract the sim event from nOverlay
      n_events_overlay -= 1;
 
    }  // end if bunch_offset == 0
 
    float bunchtime_offset = bunch_spacing_ * bunch_offset;
    ldmx_log(debug) << "Will overlay " << n_events_overlay
                    << " events on the simulated one";
 
    for (int i_ev = 0; i_ev < n_events_overlay; i_ev++) {
      if (!overlay_file_->nextEvent()) {
        ldmx_log(error) << "Couldn't read next overlay event!";
        return;
      }
 
      // a pileup event wide time offset to be applied to all its hits_.
      float time_offset = rndm_time_->Gaus(time_mean_, time_sigma_);
      time_offset += bunchtime_offset;
 
      ldmx_log(trace) << "in overlay loop: overlaying event " << "which is "
                      << i_ev + 1 << " out of " << n_events_overlay
                      << "\n\thit time offset is " << time_offset << " ns"
                      << "\n\tbunch position offset is " << bunch_offset
                      << ", leading to a total time offset of "
                      << bunchtime_offset << " ns";
 
      /* ----------- first do the SimCalorimeterHits overlay ----------- */
 
      // again get the calo hits_ collections that we want to overlay
      for (uint i_coll = 0; i_coll < calo_collections_.size(); i_coll++) {
        // search for the collection name in the list of collections that
        // need contribs to be added, contrib_collections_
        bool needs_contribs_added{
            std::find(contrib_collections_.begin(), contrib_collections_.end(),
                      calo_collections_[i_coll]) != contrib_collections_.end()
                ? true
                : false};
 
        std::vector<ldmx::SimCalorimeterHit> overlay_hits =
            overlay_event_.getCollection<ldmx::SimCalorimeterHit>(
                calo_collections_[i_coll], overlay_passname_);
 
        ldmx_log(debug) << "in loop: size of overlay hits_ vector is "
                        << overlay_hits.size();
 
        std::string out_coll_name =
            calo_collections_[i_coll] + out_coll_postfix_;
 
        ldmx_log(trace) << "in loop: printing overlay event: ";
 
        for (ldmx::SimCalorimeterHit &overlay_hit : overlay_hits) {
          ldmx_log(trace) << overlay_hit;
 
          // update relevant parameters with overlay modifications
          overlay_hit.setTime(overlay_hit.getTime() + time_offset);
          overlay_hit.setPreStepTime(overlay_hit.getPreStepTime() +
                                     time_offset);
          overlay_hit.setPostStepTime(overlay_hit.getPostStepTime() +
                                      time_offset);
          overlay_hit.encodeTracks(
              [this](int id, unsigned enc, unsigned idx) {
                return encodeTrack(id, enc, idx);
              },
              track_id_encoding_, overlay_event_index);
 
          if (needs_contribs_added) {  // special treatment for (for now only)
                                       // ecal
            auto &this_coll_hit_map{
                hit_map[calo_collections_[i_coll] + out_coll_postfix_]};
            int overlay_hit_id = overlay_hit.getID();
            if (this_coll_hit_map.find(overlay_hit_id) ==
                this_coll_hit_map
                    .end()) {  // there wasn't already a simhit in this id
              ldmx_log(trace)
                  << "No existing simhit found for ID " << overlay_hit_id
                  << "; copying overlay hit to output collection";
              auto &output_hit = this_coll_hit_map[overlay_hit_id];
              output_hit = overlay_hit;  // copy hit
 
              // we need to do some backflips to get the contribs correct later
              auto id = output_hit.getID();
              auto pos = output_hit.getPosition();
              auto time = output_hit.getTime();
              output_hit.clear();  // with the below adjustments, this will only
                                   // clear contribs from the output_hit
              output_hit.setID(id);
              output_hit.setPosition(pos[0], pos[1], pos[2]);
              output_hit.setTime(time);
            }  // if overlay_hit_id not present
 
            // add the overlay hit contribs to existing hit,
            // incrementing track IDs and timestamp as needed
            int n_contribs = overlay_hit.getNumberOfContribs();
            ldmx_log(trace)
                << "Copying and reindexing " << n_contribs
                << " contributors to the sim hit for ID " << overlay_hit_id;
            for (int i = 0; i < n_contribs; i++) {
              ldmx::SimCalorimeterHit::Contrib contrib{
                  overlay_hit.getContrib(i)};
              // tracks were encoded in-place above, so we only need to worry
              // about times
              this_coll_hit_map[overlay_hit_id].addContrib(
                  contrib.incident_id_, contrib.track_id_, contrib.pdg_code_,
                  contrib.edep_, contrib.time_ + time_offset);
            }  // loop over contribs in overlay_hit
            ldmx_log(trace)
                << "There are now "
                << this_coll_hit_map[overlay_hit_id].getNumberOfContribs()
                << " total contributors in the output collection";
          }  // if add overlay as contribs
          else {
            // no need to change contrib timestamps here
            calo_collection_map[out_coll_name].push_back(overlay_hit);
 
            ldmx_log(trace) << "Adding non-Ecal overlay hit to outhit vector "
                            << out_coll_name;
          }  // end else !needs_contribs_added
        }  // over overlay calo simhit collection
 
        if (!needs_contribs_added)
          ldmx_log(debug) << "Nhits in overlay collection " << out_coll_name
                          << ": " << calo_collection_map[out_coll_name].size();
 
      }  // over calo_collections_
 
      /* ----------- now do simtracker hits_ overlay ----------- */
 
      // loop over the SimTrackerHit collections that we want to overlay
      for (const auto &coll : tracker_collections_) {
        auto overlay_tracker_hits{
            overlay_event_.getCollection<ldmx::SimTrackerHit>(
                coll, overlay_passname_)};
 
        ldmx_log(debug) << "in loop: size of overlay hits_ vector is "
                        << overlay_tracker_hits.size();
 
        std::string out_coll_name_tracker{coll + out_coll_postfix_};
 
        ldmx_log(trace) << "in loop: printing overlay event: ";
 
        for (auto &overlay_hit : overlay_tracker_hits) {
          auto overlay_time{overlay_hit.getTime() + time_offset};
          overlay_hit.setTime(overlay_time);
          auto overlay_track_id{encodeTrack(overlay_hit.getTrackID(),
                                            track_id_encoding_,
                                            overlay_event_index)};
          overlay_hit.setTrackID(overlay_track_id);
 
          ldmx_log(trace) << overlay_hit;
          ldmx_log(trace) << "Adding tracker overlay hit to outhit vector "
                          << out_coll_name_tracker;
 
          tracker_collection_map[out_coll_name_tracker].push_back(overlay_hit);
        }  // over overlay tracker simhit collection
 
        ldmx_log(debug) << "Nhits in overlay collection "
                        << out_coll_name_tracker << ": "
                        << tracker_collection_map[out_coll_name_tracker].size();
 
      }  // over tracker_collections_
 
      /* ----------- finally do SimParticles overlay ----------- */
      for (const auto &coll : particle_collections_) {
        auto overlay_particles{overlay_event_.getMap<int, ldmx::SimParticle>(
            coll, overlay_passname_)};
 
        ldmx_log(debug) << "in loop: size of overlay particles map is "
                        << overlay_particles.size();
 
        std::string out_coll_name_particles{coll + out_coll_postfix_};
        auto &output_map = particle_collection_map[out_coll_name_particles];
 
        ldmx_log(trace) << "in loop: printing overlay event: ";
 
        for (auto &[track_id, particle] : overlay_particles) {
          int new_track_id =
              encodeTrack(track_id, track_id_encoding_, overlay_event_index);
 
          output_map[new_track_id] = particle;
          output_map[new_track_id].encodeTracks(
              [this](int id, unsigned enc, unsigned idx) {
                return encodeTrack(id, enc, idx);
              },
              track_id_encoding_, overlay_event_index);
          output_map[new_track_id].setTime(particle.getTime() + time_offset);
 
          ldmx_log(trace) << "Track ID: " << new_track_id << " --- "
                          << output_map[new_track_id];
          ldmx_log(trace) << "Adding sim particle to output map "
                          << out_coll_name_particles;
        }  // over overlay sim particles collection
      }  // over particle_collections_
 
    }  // over overlay events
  }  // over bunches
 
  // after all events are done, the contrib-using collections' hit_maps are
  // final and can be written to the event output
  for (uint i_coll = 0; i_coll < contrib_collections_.size(); i_coll++) {
    // for each SimCalorimeterHit collection that uses contribs, add overlaid
    // hits_ as contribs/from hit_map rather than as copied simhits
    ldmx_log(trace) << "Hits in hit_map after overlay of "
                    << contrib_collections_[i_coll] << "Overlay :";
 
    for (auto &map_hit :
         hit_map[contrib_collections_[i_coll] + out_coll_postfix_]) {
      ldmx_log(trace) << map_hit.second;
 
      if (calo_collection_map.find(contrib_collections_[i_coll] +
                                   out_coll_postfix_) ==
          calo_collection_map.end()) {
        ldmx_log(debug) << "Adding first hit from hit map as first outhit "
                           "vector to calo_collection_map";
        calo_collection_map[contrib_collections_[i_coll] + out_coll_postfix_] =
            {map_hit.second};
      } else {
        calo_collection_map[contrib_collections_[i_coll] + out_coll_postfix_]
            .push_back(map_hit.second);
      }
    }  // over hit_map
  }  // second loop over contrib using collections, to collect hits_ from
     // hit_map
 
  // done collecting hits_.
 
  // now we can write the calo collections to the event bus
  for (auto &[name, coll] : calo_collection_map) {
    ldmx_log(debug) << "Writing " << name << " to event bus.";
 
    ldmx_log(trace) << "List of hits_ added: ";
    for (auto &hit : coll) {
      ldmx_log(trace) << hit;
    }
    event.add(name, coll);
  }
 
  // and now for the tracker hits_
  for (auto &[name, coll] : tracker_collection_map) {
    ldmx_log(debug) << "Writing " << name << " to event bus.";
    ldmx_log(trace) << "List of hits_ added: ";
    for (auto &hit : coll) {
      ldmx_log(trace) << hit;
    }
    event.add(name, coll);
  }
 
  // and finally for sim particles
  for (auto &[name, coll] : particle_collection_map) {
    ldmx_log(debug) << "Writing " << name << " to event bus.";
    ldmx_log(trace) << "List of particles added: ";
    for (auto &[track_id, particle] : coll) {
      ldmx_log(trace) << "Track ID: " << track_id << " --- " << particle;
    }
    event.add(name, coll);
  }
 
  return;
}  // end produce()

References bunch_spacing_, calo_collections_, contrib_collections_, do_poisson_in_time_, do_poisson_out_of_time_, encodeTrack(), framework::Event::getCollection(), framework::Event::getMap(), n_earlier_, n_later_, out_coll_postfix_, overlay_event_, overlay_file_, overlay_passname_, particle_collections_, poisson_mu_, rndm_, rndm_time_, sim_passname_, time_mean_, time_sigma_, track_id_encoding_, and tracker_collections_.

Member Data Documentation

bunch_spacing_

double recon::OverlayProducer::bunch_spacing_ {0.}

private

Spacing in time (in [ns]) between electron bunches.

Definition at line 191 of file OverlayProducer.h.

{0.};

Referenced by configure(), and produce().

calo_collections_

std::vector<std::string> recon::OverlayProducer::calo_collections_

private

List of SimCalorimeterHit collection(s) to loop over and add hits from, combining sim and pileup.

Definition at line 109 of file OverlayProducer.h.

Referenced by configure(), and produce().

contrib_collections_

std::vector<std::string> recon::OverlayProducer::contrib_collections_

private

List of SimCalorimeterHit collections which keep track of hit contribs.

Definition at line 126 of file OverlayProducer.h.

Referenced by configure(), and produce().

do_poisson_in_time_

bool recon::OverlayProducer::do_poisson_in_time_ {false}

private

Let the total number of in-time events be poisson distributed, or fix at the chosen value, poissonMu_.

Definition at line 148 of file OverlayProducer.h.

{false};

Referenced by configure(), and produce().

do_poisson_out_of_time_

bool recon::OverlayProducer::do_poisson_out_of_time_ {false}

private

Let the total number of out-of-time events be poisson distributed, or fix at the chosen value, poissonMu_.

Definition at line 154 of file OverlayProducer.h.

{false};

Referenced by configure(), and produce().

n_earlier_

int recon::OverlayProducer::n_earlier_ {0}

private

Number of bunches before the sim event to pull pileup events from.

Defaults to 0 --> all events occur in the same bunch as the sim event.

Definition at line 198 of file OverlayProducer.h.

{0};

Referenced by configure(), and produce().

n_later_

int recon::OverlayProducer::n_later_ {0}

private

Number of bunches after the sim event to pull pileup events from.

Defaults to 0 --> all events occur in the same bunch as the sim event.

Definition at line 205 of file OverlayProducer.h.

{0};

Referenced by configure(), and produce().

out_coll_postfix_

std::string recon::OverlayProducer::out_coll_postfix_

private

Postfix to add to the collection name of the overlayed collections.

This is currently set to "Overlay".

Definition at line 142 of file OverlayProducer.h.

Referenced by configure(), and produce().

overlay_event_

framework::Event recon::OverlayProducer::overlay_event_

private

The overlay ldmx event bus.

Definition at line 103 of file OverlayProducer.h.

Referenced by onNewRun(), onProcessStart(), and produce().

overlay_file_

std::unique_ptr<framework::EventFile> recon::OverlayProducer::overlay_file_

private

Pileup overlay events input file.

Definition at line 98 of file OverlayProducer.h.

Referenced by onNewRun(), onProcessStart(), and produce().

overlay_filename_

std::string recon::OverlayProducer::overlay_filename_

private

Pileup overlay events input file name.

Definition at line 93 of file OverlayProducer.h.

Referenced by configure(), and onProcessStart().

overlay_passname_

std::string recon::OverlayProducer::overlay_passname_

private

Pileup overlay events input pass name.

Definition at line 131 of file OverlayProducer.h.

Referenced by configure(), and produce().

params_

framework::config::Parameters recon::OverlayProducer::params_

private

The parameters used to configure this producer.

Definition at line 88 of file OverlayProducer.h.

Referenced by configure(), and onProcessStart().

particle_collections_

std::vector<std::string> recon::OverlayProducer::particle_collections_

private

List of SimParticle collection(s) to loop over and add hits from, combining sim and pileup.

Definition at line 121 of file OverlayProducer.h.

Referenced by configure(), and produce().

poisson_mu_

double recon::OverlayProducer::poisson_mu_ {0.}

private

(average) total number of events

Definition at line 159 of file OverlayProducer.h.

{0.};

Referenced by configure(), and produce().

rndm_

std::unique_ptr<TRandom2> recon::OverlayProducer::rndm_

private

Random number generator for number of overlaid events.

TRandom2 slightly (~10%) faster than TRandom3; shorter period but our input files will have way shorter period anyway.

Definition at line 166 of file OverlayProducer.h.

Referenced by onNewRun(), and produce().

rndm_time_

std::unique_ptr<TRandom2> recon::OverlayProducer::rndm_time_

private

Random number generator for pileup event time offset.

TRandom2 slightly (~10%) faster than TRandom3; shorter period but our input files will have way shorter period anyway.

Definition at line 173 of file OverlayProducer.h.

Referenced by onNewRun(), and produce().

sim_passname_

std::string recon::OverlayProducer::sim_passname_

private

To use for finding the sim event bus passengers, mostly a disambiguation.

Definition at line 136 of file OverlayProducer.h.

Referenced by configure(), and produce().

start_event_max_

int recon::OverlayProducer::start_event_max_ {10000}

private

Maximum event number to start overlaying from.

Inclusive.

Definition at line 217 of file OverlayProducer.h.

{10000};

Referenced by configure(), and onNewRun().

start_event_min_

int recon::OverlayProducer::start_event_min_ {1}

private

Minimum event number to start overlaying from.

Inclusive.

Definition at line 211 of file OverlayProducer.h.

{1};

Referenced by configure(), and onNewRun().

time_mean_

double recon::OverlayProducer::time_mean_ {0.}

private

Average position in time (in [ns]) of pileup bunches, relative to the sim event.

Should realistically be 0. Using a non-zero mean and sigma = 0 is however useful for validation.

Definition at line 186 of file OverlayProducer.h.

{0.};

Referenced by configure(), and produce().

time_sigma_

double recon::OverlayProducer::time_sigma_ {0.}

private

Width of pileup bunch spread in time (in [ns]), specified as a sigma of a Gaussian distribution.

Definition at line 179 of file OverlayProducer.h.

{0.};

Referenced by configure(), and produce().

track_id_encoding_

unsigned recon::OverlayProducer::track_id_encoding_ {0}

private

Track ID encoding scheme version.

Version is stored in first 4 bits after the sign bit in the track ID int variables (i.e. bits 28-31)

If this variable is left as the hardcoded default 0, then the OverlayProducer will default to not managing track IDs, instead setting all equal to nonsense values as was the case before the introduction of this track ID management.

Definition at line 229 of file OverlayProducer.h.

{0};

Referenced by configure(), and produce().

tracker_collections_

std::vector<std::string> recon::OverlayProducer::tracker_collections_

private

List of SimTrackerHit collection(s) to loop over and add hits from, combining sim and pileup.

Definition at line 115 of file OverlayProducer.h.

Referenced by configure(), and produce().

---

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

• Recon/include/Recon/OverlayProducer.h
• Recon/src/Recon/OverlayProducer.cxx