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.

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	beforeNewRun (ldmx::RunHeader &header)
	Handle allowing producers to modify run headers before the run begins.

Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.

virtual	~EventProcessor ()
	Class destructor.

virtual void	onFileOpen (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.

virtual void	onFileClose (EventFile &eventFile)
	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	overlayFileName_
	Pileup overlay events input file name.

std::unique_ptr< framework::EventFile >	overlayFile_
	Pileup overlay events input file.

framework::Event	overlayEvent_
	The overlay ldmx event bus.

std::vector< std::string >	caloCollections_
	List of SimCalorimeterHit collection(s) to loop over and add hits from, combining sim and pileup.

std::vector< std::string >	trackerCollections_
	List of SimTrackerHit collection(s) to loop over and add hits from, combining sim and pileup.

std::string	overlayPassName_
	Pileup overlay events input pass name.

std::string	simPassName_
	To use for finding the sim event bus passengers, mostly a disambiguation.

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

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

double	poissonMu_ {0.}
	(average) total number of events

std::unique_ptr< TRandom2 >	rndm_
	Random number generator for number of overlaid events.

std::unique_ptr< TRandom2 >	rndmTime_
	Random number generator for pileup event time offset.

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

double	timeMean_ {0.}
	Average position in time (in [ns]) of pileup bunches, relative to the sim event.

double	bunchSpacing_ {0.}
	Spacing in time (in [ns]) between electron bunches.

int	nEarlier_ {0}
	Number of bunches before the sim event to pull pileup events from.

int	nLater_ {0}
	Number of bunches after the sim event to pull pileup events from.

int	verbosity_
	Local control of processor verbosity.

int	overlayIncidentID_ {-1000}
	For Ecal, overlay hits should be added as contribs.

int	overlayTrackID_ {-1000}

int	overlayPdgCode_ {0}

Additional Inherited Members
Static Public Member Functions inherited from framework::EventProcessor
static void	declare (const std::string &classname, int classtype, EventProcessorMaker *)
	Internal function which is part of the PluginFactory machinery.

Static Public Attributes inherited from framework::Producer
static const int	CLASSTYPE {1}
	Constant used to track EventProcessor types by the PluginFactory.

Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Protected Attributes inherited from framework::EventProcessor
HistogramHelper	histograms_
	Interface class for making and filling histograms.

NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.

logging::logger	theLog_
	The logger for this EventProcessor.

Detailed Description

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

Definition at line 23 of file OverlayProducer.h.

Constructor & Destructor Documentation

◆ OverlayProducer()

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

inline

Definition at line 25 of file OverlayProducer.h.

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

framework::Producer

Base class for a module which produces a data product.

Definition EventProcessor.h:252

recon::OverlayProducer::overlayEvent_

framework::Event overlayEvent_

The overlay ldmx event bus.

Definition OverlayProducer.h:83

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 9 of file OverlayProducer.cxx.

                                                                     {
  params_ = parameters;
 
  ldmx_log(debug) << "Running configure() ";
 
  // name of file containing events to be overlaid, and a list of collections to
  // overlay
  overlayFileName_ = parameters.getParameter<std::string>("overlayFileName");
  caloCollections_ = parameters.getParameter<std::vector<std::string>>(
      "overlayCaloHitCollections");
  trackerCollections_ = parameters.getParameter<std::vector<std::string>>(
      "overlayTrackerHitCollections");
  simPassName_ = parameters.getParameter<std::string>("passName");
  overlayPassName_ = parameters.getParameter<std::string>("overlayPassName");
  // overlay specifics:
  poissonMu_ = parameters.getParameter<double>("totalNumberOfInteractions");
  doPoissonIT_ = parameters.getParameter<bool>("doPoissonIntime");
  doPoissonOOT_ = parameters.getParameter<bool>("doPoissonOutoftime");
  timeSigma_ = parameters.getParameter<double>("timeSpread");
  timeMean_ = parameters.getParameter<double>("timeMean");
  nEarlier_ = parameters.getParameter<int>("nEarlierBunchesToSample");
  nLater_ = parameters.getParameter<int>("nLaterBunchesToSample");
  bunchSpacing_ = parameters.getParameter<double>("bunchSpacing");
  verbosity_ = parameters.getParameter<int>("verbosity");
 
  if (verbosity_) {
    ldmx_log(info) << "Got parameters \n \t overlayFileName = "
                   << overlayFileName_
                   << "\n\t sim pass name = " << simPassName_
                   << "\n\t overlay pass name = " << overlayPassName_
                   << "\n\t overlayCaloHitCollections = ";
    for (const auto &coll : caloCollections_) ldmx_log(info) << coll << "; ";
 
    ldmx_log(info) << "\n\t overlayTrackerHitCollections = ";
    for (const std::string &coll : trackerCollections_)
      ldmx_log(info) << coll << "; ";
 
    ldmx_log(info) << "\n\t numberOverlaidInteractions = " << poissonMu_
                   << "\n\t nEarlierBunchesToSample = " << nEarlier_
                   << "\n\t nLaterBunchesToSample = " << nLater_
                   << "\n\t bunchSpacing = " << bunchSpacing_
                   << "\n\t doPoissonIntime = " << doPoissonIT_
                   << "\n\t doPoissonOutoftime = " << doPoissonOOT_
                   << "\n\t timeSpread = " << timeSigma_
                   << "\n\t timeMean = " << timeMean_
                   << "\n\t verbosity = " << verbosity_;
  }
  return;
}

References bunchSpacing_, caloCollections_, doPoissonIT_, doPoissonOOT_, framework::config::Parameters::getParameter(), nEarlier_, nLater_, overlayFileName_, overlayPassName_, params_, poissonMu_, simPassName_, timeMean_, timeSigma_, trackerCollections_, and verbosity_.

◆ 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 60 of file OverlayProducer.cxx.

                                                    {
  if (rndm_.get() == nullptr) {
    // not been seeded yet, get it from RNSS
    const auto &rnss = getCondition<framework::RandomNumberSeedService>(
        framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
    rndm_ = std::make_unique<TRandom2>(rnss.getSeed("OverlayProducer::rndm"));
  }
 
  int start_event = rndm_->Uniform(20., 1e4);
  // EventFile::skipToEvent handles actual number of events in file
  int evNb = overlayFile_->skipToEvent(start_event);
  if (evNb < 0) {
    EXCEPTION_RAISE("BadRead", "Couldn't read to starting offset.");
  }
  overlayEvent_.getEventHeader().setEventNumber(evNb);
  ldmx_log(info) << "Starting overlay process with pileup event number " << evNb
                 << " (random event number picked was " << start_event << ").";
}

References framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME, framework::Event::getEventHeader(), overlayEvent_, overlayFile_, rndm_, and ldmx::EventHeader::setEventNumber().

◆ 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 391 of file OverlayProducer.cxx.

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

References overlayEvent_, overlayFile_, overlayFileName_, params_, and verbosity_.

◆ 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 80 of file OverlayProducer.cxx.

                                                   {
  // event is the incoming, simulated event/"hard" process
  // overlayEvent_ is the overlay producer's own event.
  if (verbosity_ > 1) {
    ldmx_log(info) << "produce() starts on simulation event "
                   << event.getEventHeader().getEventNumber();
  }
 
  if (rndmTime_.get() == nullptr) {
    // not been seeded yet, get it from RNSS
    const auto &rnss = getCondition<framework::RandomNumberSeedService>(
        framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
    rndmTime_ =
        std::make_unique<TRandom2>(rnss.getSeed("OverlayProducer::rndmTime"));
  }
 
  // 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>> caloCollectionMap;
  std::map<std::string, std::vector<ldmx::SimTrackerHit>> trackerCollectionMap;
  std::map<int, ldmx::SimCalorimeterHit> hitMap;
 
  // 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 : caloCollections_
  for (const auto &collName : caloCollections_) {
    // for now, Ecal and only Ecal uses contribs instead of multiple
    // SimHitsCalo per channel, meaning, it requires special treatment
    auto needsContribsAdded{collName.find("Ecal") != std::string::npos ? true
                                                                       : false};
 
    // start out by just copying the sim hits, unaltered.
    auto simHitsCalo =
        event.getCollection<ldmx::SimCalorimeterHit>(collName, simPassName_);
    // but don't copy ecal hits immediately: for them, wait until overlay
    // contribs have been added. then add everything through the hitmap
    if (!needsContribsAdded) {
      caloCollectionMap[collName + "Overlay"] = simHitsCalo;
    }
 
    if (verbosity_ > 2) {
      ldmx_log(debug) << "in loop: start of collection " << collName
                      << "in loop: printing current sim event: ";
    }
    ldmx_log(debug) << "in loop: size of sim hits vector " << collName << " is "
                    << simHitsCalo.size();
 
    // we don't need to touch the hard process sim hits, really... but we
    // might need the simhits in the hit map.
    if (needsContribsAdded || verbosity_ > 2) {
      for (const ldmx::SimCalorimeterHit &simHit : simHitsCalo) {
        if (verbosity_ > 2) simHit.Print();
 
        if (needsContribsAdded) {
          // this copies the hit, its ID and its coordinates directly
          hitMap[simHit.getID()] = simHit;
        }
 
      }  // over calo simhit collection
    }    // if needContribs or very verbose
 
  }  // over calo collections for sim event
 
  /* ----------- now 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 : trackerCollections_
  for (const auto &collName : trackerCollections_) {
    auto simHitsTracker =
        event.getCollection<ldmx::SimTrackerHit>(collName, simPassName_);
    trackerCollectionMap[collName + "Overlay"] = simHitsTracker;
 
    // the rest is printouts for debugging
    ldmx_log(debug) << "in loop: size of sim hits vector " << collName << " is "
                    << simHitsTracker.size();
 
    if (verbosity_ > 2) {
      ldmx_log(debug) << "in loop: start of collection " << collName
                      << "in loop: printing current sim event: ";
 
      for (const ldmx::SimTrackerHit &simHit : simHitsTracker) simHit.Print();
    }  // if high verbosity
  }    // over tracker collections for sim event
 
  /* ----------- now do the pileup 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= (int)rndmTime_->Uniform(
  //                   -(nEarlier_+1) , nLater_+1);  // +1 to get
  // inclusive interval
  int startBunch = -nEarlier_;
  int endBunch = nLater_;
 
  // 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 bunchOffset{startBunch}; bunchOffset <= endBunch; bunchOffset++) {
    // sample a poisson distribution, or use mu as fixed number of overlay
    // events
    int nEvsOverlay =
        doPoissonOOT_ ? rndm_->Poisson(poissonMu_) : (int)poissonMu_;
 
    // special case: in-time pileup at bunch 0
    if (bunchOffset == 0) {
      if (!doPoissonIT_)
        nEvsOverlay = (int)poissonMu_;          // fix it to the average
      else if (doPoissonIT_ && !doPoissonOOT_)  // then we haven't set this yet
        nEvsOverlay = rndm_->Poisson(poissonMu_);
 
      // paticularly useful in the poisson fluctuated case
      event.getEventHeader().setIntParameter("inTimePU", nEvsOverlay);
 
      // the total number of events is nPU + 1 (it includes the sim event)
      nEvsOverlay -= 1;  // in any case, subtract the sim event from nOverlay
      if (verbosity_ > 2) {
        ldmx_log(debug) << "will overlay " << nEvsOverlay
                        << " events on the simulated one";
      }
    }
 
    // get event wherever nextEvent()  left us
    if (!&overlayEvent_) {
      ldmx_log(error) << "No overlay event!";
      return;
    }
 
    float bunchTimeOffset = bunchSpacing_ * bunchOffset;
 
    for (int iEv = 0; iEv < nEvsOverlay; iEv++) {
      if (!overlayFile_->nextEvent()) {
        ldmx_log(error) << "At sim event "
                        << event.getEventHeader().getEventNumber()
                        << ": couldn't read next overlay event!";
        return;
      }
 
      // a pileup event wide time offset to be applied to all its hits.
      float timeOffset = rndmTime_->Gaus(timeMean_, timeSigma_);
      timeOffset += bunchTimeOffset;
 
      if (verbosity_ > 2) {
        ldmx_log(debug) << "in overlay loop: overlaying event "
                        << overlayEvent_.getEventHeader().getEventNumber()
                        << "which is " << iEv + 1 << " out of " << nEvsOverlay
                        << "\n\thit time offset is " << timeOffset << " ns"
                        << "\n\tbunch position offset is " << bunchOffset
                        << ", leading to a total time offset of "
                        << bunchTimeOffset << " ns";
      }
 
      /* ----------- first do the SimCalorimeterHits overlay ----------- */
 
      // again get the calo hits collections that we want to overlay
      for (uint iColl = 0; iColl < caloCollections_.size(); iColl++) {
        // for now, Ecal and only Ecal uses contribs
        bool needsContribsAdded = false;
        if (strstr(caloCollections_[iColl].c_str(), "Ecal"))
          needsContribsAdded = true;
 
        std::vector<ldmx::SimCalorimeterHit> overlayHits =
            overlayEvent_.getCollection<ldmx::SimCalorimeterHit>(
                caloCollections_[iColl], overlayPassName_);
 
        ldmx_log(debug) << "in loop: size of overlay hits vector is "
                        << overlayHits.size();
 
        std::string outCollName = caloCollections_[iColl] + "Overlay";
 
        if (verbosity_ > 2) {
          ldmx_log(debug) << "in loop: printing overlay event: ";
        }
 
        for (ldmx::SimCalorimeterHit &overlayHit : overlayHits) {
          if (verbosity_ > 2) overlayHit.Print();
 
          const float overlayTime = overlayHit.getTime() + timeOffset;
          overlayHit.setTime(overlayTime);
 
          if (needsContribsAdded) {  // special treatment for (for now only)
                                     // ecal
            int overlayHitID = overlayHit.getID();
            if (hitMap.find(overlayHitID) ==
                hitMap.end()) {  // there wasn't already a simhit in this id
              hitMap[overlayHitID] = ldmx::SimCalorimeterHit();
              hitMap[overlayHitID].setID(overlayHitID);
              std::vector<float> hitPos = overlayHit.getPosition();
              hitMap[overlayHitID].setPosition(hitPos[0], hitPos[1], hitPos[2]);
            }
            // add the overlay hit (as a) contrib
            // incidentID = -1000, trackID = -1000, pdgCode = 0  <-- these are
            // set in the header for now but could be parameters
            hitMap[overlayHitID].addContrib(overlayIncidentID_, overlayTrackID_,
                                            overlayPdgCode_,
                                            overlayHit.getEdep(), overlayTime);
          }  // if add overlay as contribs
          else {
            caloCollectionMap[outCollName].push_back(overlayHit);
            if (verbosity_ > 2)
              ldmx_log(debug) << "Adding non-Ecal overlay hit to outhit vector "
                              << outCollName;
          }
        }  // over overlay calo simhit collection
 
        if (!needsContribsAdded)
          ldmx_log(debug) << "Nhits in overlay collection " << outCollName
                          << ": " << caloCollectionMap[outCollName].size();
 
      }  // over caloCollections
 
      /* ----------- now do simtracker hits overlay ----------- */
 
      // get the SimTrackerHit collections that we want to overlay
      for (const auto &coll : trackerCollections_) {
        auto overlayTrackerHits{
            overlayEvent_.getCollection<ldmx::SimTrackerHit>(coll,
                                                             overlayPassName_)};
 
        ldmx_log(debug) << "in loop: size of overlay hits vector is "
                        << overlayTrackerHits.size();
 
        auto outCollName{coll + "Overlay"};
 
        if (verbosity_ > 2) {
          ldmx_log(debug) << "in loop: printing overlay event: ";
        }
 
        for (auto &overlayHit : overlayTrackerHits) {
          auto overlayTime{overlayHit.getTime() + timeOffset};
          overlayHit.setTime(overlayTime);
          trackerCollectionMap[outCollName].push_back(overlayHit);
 
          if (verbosity_ > 2) {
            overlayHit.Print();
            ldmx_log(debug) << "Adding tracker overlay hit to outhit vector "
                            << outCollName;
          }  // verbose
        }    // over overlay tracker simhit collection
 
        ldmx_log(debug) << "Nhits in overlay collection " << outCollName << ": "
                        << trackerCollectionMap[outCollName].size();
 
      }  // over trackerCollections
 
    }  // over overlay events
  }    // over bunches
 
  // after all events are done, the ecal hitmap is final and can be written to
  // the event output
  for (uint iColl = 0; iColl < caloCollections_.size(); iColl++) {
    // loop through collection names to find the right collection name
    // add overlaid ecal hits as contribs/from hitmap rather than as copied
    // simhits
    if (strstr(caloCollections_[iColl].c_str(), "Ecal")) {
      if (verbosity_ > 2)
        ldmx_log(debug) << "Hits in hitmap after overlay of "
                        << caloCollections_[iColl] << "Overlay :";
 
      for (auto &mapHit : hitMap) {
        if (verbosity_ > 2) mapHit.second.Print();
 
        if (caloCollectionMap.find(caloCollections_[iColl] + "Overlay") ==
            caloCollectionMap.end()) {
          ldmx_log(debug) << "Adding first hit from hit map as first outhit "
                             "vector to caloCollectionMap";
          caloCollectionMap[caloCollections_[iColl] + "Overlay"] = {
              mapHit.second};
        } else
          caloCollectionMap[caloCollections_[iColl] + "Overlay"].push_back(
              mapHit.second);
      }
      break;  // for now we only have one hitMap: for Ecal. so no need looking
              // further after we got a match
    }         // isEcal
  }           // second loop over collections, to collect hits from hitmap
 
  // done collecting hits.
 
  // this should be added to the sim file, so to "event"
  // once for each hit type
  for (auto &[name, coll] : caloCollectionMap) {
    ldmx_log(debug) << "Writing " << name << " to event bus.";
    if (verbosity_ > 2) {
      ldmx_log(debug) << "List of hits added: ";
      for (auto &hit : coll) hit.Print();
    }
    event.add(name, coll);
  }
  for (auto &[name, coll] : trackerCollectionMap) {
    ldmx_log(debug) << "Writing " << name << " to event bus.";
    if (verbosity_ > 2) {
      ldmx_log(debug) << "List of hits added: ";
      for (auto &hit : coll) hit.Print();
    }
    event.add(name, coll);
  }
  return;
}

References bunchSpacing_, caloCollections_, framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME, doPoissonIT_, doPoissonOOT_, framework::Event::getCollection(), framework::Event::getEventHeader(), ldmx::EventHeader::getEventNumber(), nEarlier_, nLater_, overlayEvent_, overlayFile_, overlayIncidentID_, overlayPassName_, poissonMu_, ldmx::SimCalorimeterHit::Print(), ldmx::SimTrackerHit::Print(), rndm_, rndmTime_, simPassName_, timeMean_, timeSigma_, trackerCollections_, and verbosity_.

Member Data Documentation

◆ bunchSpacing_

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

private

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

Definition at line 154 of file OverlayProducer.h.

154{0.};

Referenced by configure(), and produce().

◆ caloCollections_

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

private

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

Definition at line 89 of file OverlayProducer.h.

Referenced by configure(), and produce().

◆ doPoissonIT_

bool recon::OverlayProducer::doPoissonIT_ {false}

private

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

Definition at line 111 of file OverlayProducer.h.

111{false};

Referenced by configure(), and produce().

◆ doPoissonOOT_

bool recon::OverlayProducer::doPoissonOOT_ {false}

private

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

Definition at line 117 of file OverlayProducer.h.

117{false};

Referenced by configure(), and produce().

◆ nEarlier_

int recon::OverlayProducer::nEarlier_ {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 161 of file OverlayProducer.h.

161{0};

Referenced by configure(), and produce().

◆ nLater_

int recon::OverlayProducer::nLater_ {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 168 of file OverlayProducer.h.

168{0};

Referenced by configure(), and produce().

◆ overlayEvent_

framework::Event recon::OverlayProducer::overlayEvent_

private

The overlay ldmx event bus.

Definition at line 83 of file OverlayProducer.h.

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

◆ overlayFile_

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

private

Pileup overlay events input file.

Definition at line 78 of file OverlayProducer.h.

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

◆ overlayFileName_

std::string recon::OverlayProducer::overlayFileName_

private

Pileup overlay events input file name.

Definition at line 73 of file OverlayProducer.h.

Referenced by configure(), and onProcessStart().

◆ overlayIncidentID_

int recon::OverlayProducer::overlayIncidentID_ {-1000}

private

For Ecal, overlay hits should be added as contribs.

But these are required to be unique, by the Ecal rconstruction code. So assign a nonsensical trackID, incidentID, and PDG ID to the contribs from overlay. These are hardwired right here.

Definition at line 181 of file OverlayProducer.h.

181{-1000};

Referenced by produce().

◆ overlayPassName_

std::string recon::OverlayProducer::overlayPassName_

private

Pileup overlay events input pass name.

Definition at line 100 of file OverlayProducer.h.

Referenced by configure(), and produce().

◆ overlayPdgCode_

int recon::OverlayProducer::overlayPdgCode_ {0}

private

Definition at line 183 of file OverlayProducer.h.

183{0};

◆ overlayTrackID_

int recon::OverlayProducer::overlayTrackID_ {-1000}

private

Definition at line 182 of file OverlayProducer.h.

182{-1000};

◆ params_

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

private

The parameters used to configure this producer.

Definition at line 68 of file OverlayProducer.h.

Referenced by configure(), and onProcessStart().

◆ poissonMu_

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

private

(average) total number of events

Definition at line 122 of file OverlayProducer.h.

122{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 129 of file OverlayProducer.h.

Referenced by onNewRun(), and produce().

◆ rndmTime_

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

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 136 of file OverlayProducer.h.

Referenced by produce().

◆ simPassName_

std::string recon::OverlayProducer::simPassName_

private

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

Definition at line 105 of file OverlayProducer.h.

Referenced by configure(), and produce().

◆ timeMean_

double recon::OverlayProducer::timeMean_ {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 149 of file OverlayProducer.h.

149{0.};

Referenced by configure(), and produce().

◆ timeSigma_

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

private

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

Definition at line 142 of file OverlayProducer.h.

142{0.};

Referenced by configure(), and produce().

◆ trackerCollections_

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

private

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

Definition at line 95 of file OverlayProducer.h.

Referenced by configure(), and produce().

◆ verbosity_

int recon::OverlayProducer::verbosity_

private

Local control of processor verbosity.

Definition at line 173 of file OverlayProducer.h.

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

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ OverlayProducer()

Member Function Documentation

◆ configure()

◆ onNewRun()

◆ onProcessStart()

◆ produce()

Member Data Documentation

◆ bunchSpacing_

◆ caloCollections_

◆ doPoissonIT_

◆ doPoissonOOT_

◆ nEarlier_

◆ nLater_

◆ overlayEvent_

◆ overlayFile_

◆ overlayFileName_

◆ overlayIncidentID_

◆ overlayPassName_

◆ overlayPdgCode_

◆ overlayTrackID_

◆ params_

◆ poissonMu_

◆ rndm_

◆ rndmTime_

◆ simPassName_

◆ timeMean_

◆ timeSigma_

◆ trackerCollections_

◆ verbosity_