edm::PileUp Class Reference

#include <PileUp.h>

Public Member Functions
double	averageNumber () const
void	beginJob (eventsetup::ESRecordsToProductResolverIndices const &)
void	beginLuminosityBlock (const edm::LuminosityBlock &lumi, const edm::EventSetup &setup)
void	beginRun (const edm::Run &run, const edm::EventSetup &setup)
void	beginStream (edm::StreamID)
void	CalculatePileup (int MinBunch, int MaxBunch, std::vector< int > &PileupSelection, std::vector< float > &TrueNumInteractions, StreamID const &)
bool	doPileUp (int BX)
void	dropUnwantedBranches (std::vector< std::string > const &wantedBranches)
void	endLuminosityBlock (const edm::LuminosityBlock &lumi, const edm::EventSetup &setup)
void	endRun (const edm::Run &run, const edm::EventSetup &setup)
void	endStream ()
void	endStream (ExceptionCollector &)
const unsigned int &	input () const
void	input (unsigned int s)
	PileUp (ParameterSet const &pset, const std::shared_ptr< PileUpConfig > &config, edm::ConsumesCollector iC, const bool mixingConfigFromDB)
template<typename T >
void	playOldFormatPileUp (std::vector< edm::EventID >::const_iterator begin, std::vector< edm::EventID >::const_iterator end, std::vector< edm::SecondaryEventIDAndFileInfo > &ids, T eventOperator)
template<typename T >
void	playPileUp (std::vector< edm::SecondaryEventIDAndFileInfo >::const_iterator begin, std::vector< edm::SecondaryEventIDAndFileInfo >::const_iterator end, std::vector< edm::SecondaryEventIDAndFileInfo > &ids, T eventOperator)
bool	poisson () const
template<typename T >
void	readPileUp (edm::EventID const &signal, std::vector< edm::SecondaryEventIDAndFileInfo > &ids, T eventOperator, int const NumPU, StreamID const &)
void	reload (const edm::EventSetup &setup)
void	setupPileUpEvent (const edm::EventSetup &setup)
	~PileUp ()

Private Member Functions
std::unique_ptr< CLHEP::RandPoisson > const &	poissonDistr_OOT (StreamID const &streamID)
std::unique_ptr< CLHEP::RandPoissonQ > const &	poissonDistribution (StreamID const &streamID)
CLHEP::HepRandomEngine *	randomEngine (StreamID const &streamID)
void	setRandomEngine (StreamID)
void	setRandomEngine (LuminosityBlock const &)

Private Attributes
double	averageNumber_
edm::ESGetToken< MixingModuleConfig, MixingRcd >	configToken_
std::unique_ptr< EventPrincipal >	eventPrincipal_
size_t	fileNameHash_
bool	fixed_
bool	fixed_OOT_
std::shared_ptr< TH1F >	histo_
bool	histoDistribution_
std::unique_ptr< VectorInputSource > const	input_
unsigned int	inputType_
int const	intAverage_
int	intFixed_ITPU_
int	intFixed_OOT_
std::shared_ptr< LuminosityBlockPrincipal >	lumiPrincipal_
bool	manage_OOT_
int	maxBunch_cosmics_
int	minBunch_cosmics_
bool	none_
bool	playback_
bool	poisson_
bool	poisson_OOT_
std::unique_ptr< CLHEP::RandPoisson >	PoissonDistr_OOT_
std::unique_ptr< CLHEP::RandPoissonQ >	PoissonDistribution_
bool	probFunctionDistribution_
std::shared_ptr< ProcessConfiguration >	processConfiguration_
std::shared_ptr< ProcessContext >	processContext_
std::shared_ptr< ProductRegistry >	productRegistry_
std::unique_ptr< SecondaryEventProvider >	provider_
bool	PU_Study_
CLHEP::HepRandomEngine *	randomEngine_
PileupRandomNumberGenerator *	randomGenerator_ = nullptr
std::shared_ptr< RunPrincipal >	runPrincipal_
bool	sequential_
std::optional< ServiceToken >	serviceToken_
std::string	Source_type_
std::shared_ptr< StreamContext >	streamContext_
std::string	Study_type_
std::string	type_

Detailed Description

Definition at line 44 of file PileUp.h.

Constructor & Destructor Documentation

PileUp()

edm::PileUp::PileUp ( ParameterSet const &  pset, const std::shared_ptr< PileUpConfig > &  config, edm::ConsumesCollector  iC, const bool  mixingConfigFromDB  )

explicit

Definition at line 70 of file PileUp.cc.

References edm::BeginLuminosityBlock, configToken_, edm::ServiceRegistry::createContaining(), dqmPostProcessing_online::DB, edm::ParameterSet::emptyParameterSetID(), edm::ConsumesCollector::esConsumes(), eventPrincipal_, Exception, fixed_, fixed_OOT_, edm::ParameterSet::getUntrackedParameter(), histoDistribution_, input_, edm::ServiceRegistry::instance(), intFixed_ITPU_, intFixed_OOT_, edm::Service< T >::isAvailable(), manage_OOT_, maxBunch_cosmics_, minBunch_cosmics_, eostools::move(), names, none_, mix_2012_lumiLevel_15_20_50ns_PoissonOOTPU_cfi::OOT_type, poisson_, poisson_OOT_, probFunctionDistribution_, processConfiguration_, processContext_, HLT_2024v14_cff::producers, productRegistry_, provider_, muonDTDigis_cfi::pset, PU_Study_, randomGenerator_, serviceToken_, Source_type_, AlCaHLTBitMon_QueryRunRegistry::string, Study_type_, HcalDetIdTransform::transform(), and type_.

      : type_(pset.getParameter<std::string>("type")),
        Source_type_(config->sourcename_),
        averageNumber_(config->averageNumber_),
        intAverage_(static_cast<int>(averageNumber_)),
        histo_(std::make_shared<TH1F>(*config->histo_)),
        histoDistribution_(type_ == "histo"),
        probFunctionDistribution_(type_ == "probFunction"),
        poisson_(type_ == "poisson"),
        fixed_(type_ == "fixed"),
        none_(type_ == "none"),
        fileNameHash_(0U),
        productRegistry_(new SignallingProductRegistry),
        input_(VectorInputSourceFactory::get()
                   ->makeVectorInputSource(
                       pset, VectorInputSourceDescription(productRegistry_, edm::PreallocationConfiguration()))
                   .release()),
        processConfiguration_(new ProcessConfiguration(std::string("@MIXING"), getReleaseVersion(), getPassID())),
        processContext_(new ProcessContext()),
        eventPrincipal_(),
        lumiPrincipal_(),
        runPrincipal_(),
        provider_(),
        PoissonDistribution_(),
        PoissonDistr_OOT_(),
        randomEngine_(),
        playback_(config->playback_),
        sequential_(pset.getUntrackedParameter<bool>("sequential", false)) {
    if (mixingConfigFromDB) {
      configToken_ = iC.esConsumes<edm::Transition::BeginLuminosityBlock>();
    }

    // Use the empty parameter set for the parameter set ID of our "@MIXING" process.
    processConfiguration_->setParameterSetID(ParameterSet::emptyParameterSetID());
    processContext_->setProcessConfiguration(processConfiguration_.get());

    if (pset.existsAs<std::vector<ParameterSet> >("producers", true)) {
      std::vector<ParameterSet> producers = pset.getParameter<std::vector<ParameterSet> >("producers");

      std::vector<std::string> names;
      names.reserve(producers.size());
      std::transform(producers.begin(), producers.end(), std::back_inserter(names), [](edm::ParameterSet const& iPSet) {
        return iPSet.getParameter<std::string>("@module_label");
      });
      auto randomGenerator = std::make_unique<PileupRandomNumberGenerator>(names);
      randomGenerator_ = randomGenerator.get();
      std::unique_ptr<edm::RandomNumberGenerator> baseGen = std::move(randomGenerator);
      serviceToken_ = edm::ServiceRegistry::createContaining(
          std::move(baseGen), edm::ServiceRegistry::instance().presentToken(), true);

      provider_ = std::make_unique<SecondaryEventProvider>(producers, *productRegistry_, processConfiguration_);
    }

    productRegistry_->setFrozen();

    // A modified HistoryAppender must be used for unscheduled processing.
    eventPrincipal_ = std::make_unique<EventPrincipal>(input_->productRegistry(),
                                                       std::make_shared<BranchIDListHelper>(),
                                                       std::make_shared<ThinnedAssociationsHelper>(),
                                                       *processConfiguration_,
                                                       nullptr);

    bool DB = type_ == "readDB";

    if (pset.exists("nbPileupEvents")) {
      if (0 != pset.getParameter<edm::ParameterSet>("nbPileupEvents").getUntrackedParameter<int>("seed", 0)) {
        edm::LogWarning("MixingModule") << "Parameter nbPileupEvents.seed is not supported";
      }
    }

    edm::Service<edm::RandomNumberGenerator> rng;
    if (!rng.isAvailable()) {
      throw cms::Exception("Configuration")
          << "PileUp requires the RandomNumberGeneratorService\n"
             "which is not present in the configuration file.  You must add the service\n"
             "in the configuration file or remove the modules that require it.";
    }

    if (!(histoDistribution_ || probFunctionDistribution_ || poisson_ || fixed_ || none_) && !DB) {
      throw cms::Exception("Illegal parameter value", "PileUp::PileUp(ParameterSet const& pset)")
          << "'type' parameter (a string) has a value of '" << type_ << "'.\n"
          << "Legal values are 'poisson', 'fixed', or 'none'\n";
    }

    if (!DB) {
      manage_OOT_ = pset.getUntrackedParameter<bool>("manage_OOT", false);

      // Check for string describing special processing.  Add these here for individual cases
      PU_Study_ = false;
      Study_type_ = pset.getUntrackedParameter<std::string>("Special_Pileup_Studies", "");

      if (Study_type_ == "Fixed_ITPU_Vary_OOTPU") {
        PU_Study_ = true;
        intFixed_ITPU_ = pset.getUntrackedParameter<int>("intFixed_ITPU", 0);
      }

      if (manage_OOT_) {  // figure out what the parameters are

        //      if (playback_) throw cms::Exception("Illegal parameter clash","PileUp::PileUp(ParameterSet const& pset)")
        // << " manage_OOT option not allowed with playback ";

        std::string OOT_type = pset.getUntrackedParameter<std::string>("OOT_type");

        if (OOT_type == "Poisson" || OOT_type == "poisson") {
          poisson_OOT_ = true;
        } else if (OOT_type == "Fixed" || OOT_type == "fixed") {
          fixed_OOT_ = true;
          // read back the fixed number requested out-of-time
          intFixed_OOT_ = pset.getUntrackedParameter<int>("intFixed_OOT", -1);
          if (intFixed_OOT_ < 0) {
            throw cms::Exception("Illegal parameter value", "PileUp::PileUp(ParameterSet const& pset)")
                << " Fixed out-of-time pileup requested, but no fixed value given ";
          }
        } else {
          throw cms::Exception("Illegal parameter value", "PileUp::PileUp(ParameterSet const& pset)")
              << "'OOT_type' parameter (a string) has a value of '" << OOT_type << "'.\n"
              << "Legal values are 'poisson' or 'fixed'\n";
        }
        edm::LogInfo("MixingModule") << " Out-of-time pileup will be generated with a " << OOT_type
                                     << " distribution. ";
      }
    }

    if (Source_type_ == "cosmics") {  // allow for some extra flexibility for mixing
      minBunch_cosmics_ = pset.getUntrackedParameter<int>("minBunch_cosmics", -1000);
      maxBunch_cosmics_ = pset.getUntrackedParameter<int>("maxBunch_cosmics", 1000);
    }
  }  // end of constructor

~PileUp()

edm::PileUp::~PileUp

(

)

Definition at line 381 of file PileUp.cc.

{}

Member Function Documentation

averageNumber()

double edm::PileUp::averageNumber ( ) const

inline

Definition at line 71 of file PileUp.h.

References averageNumber_.

Referenced by reload().

{ return averageNumber_; }

beginJob()

void edm::PileUp::beginJob

(

eventsetup::ESRecordsToProductResolverIndices const &

iES

)

Definition at line 202 of file PileUp.cc.

References input_, edm::GlobalContext::kBeginJob, processContext_, productRegistry_, provider_, and serviceToken_.

                                                                              {
    input_->doBeginJob();
    if (provider_.get() != nullptr) {
      edm::ServiceRegistry::Operate guard(*serviceToken_);
      GlobalContext globalContext(GlobalContext::Transition::kBeginJob, processContext_.get());
      provider_->beginJob(*productRegistry_, iES, globalContext);
    }
  }

beginLuminosityBlock()

void edm::PileUp::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumi,
		const edm::EventSetup &	setup
	)

Definition at line 255 of file PileUp.cc.

References edm::StreamContext::kBeginLuminosityBlock, lumiPrincipal_, processConfiguration_, productRegistry_, provider_, runPrincipal_, serviceToken_, setRandomEngine(), singleTopDQM_cfi::setup, and streamContext_.

                                                                                              {
    if (provider_.get() != nullptr) {
      lumiPrincipal_.reset(new LuminosityBlockPrincipal(productRegistry_, *processConfiguration_, nullptr, 0));
      lumiPrincipal_->setAux(lumi.luminosityBlockAuxiliary());
      lumiPrincipal_->setRunPrincipal(runPrincipal_);
      setRandomEngine(lumi);
      edm::ServiceRegistry::Operate guard(*serviceToken_);
      streamContext_->setTransition(StreamContext::Transition::kBeginLuminosityBlock);
      provider_->beginLuminosityBlock(*lumiPrincipal_, setup.impl(), lumi.moduleCallingContext(), *streamContext_);
    }
  }

beginRun()

void edm::PileUp::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	setup
	)

Definition at line 246 of file PileUp.cc.

References edm::StreamContext::kBeginRun, processConfiguration_, productRegistry_, provider_, writedatasetfile::run, runPrincipal_, serviceToken_, singleTopDQM_cfi::setup, and streamContext_.

                                                                     {
    if (provider_.get() != nullptr) {
      runPrincipal_.reset(new RunPrincipal(productRegistry_, *processConfiguration_, nullptr, 0));
      runPrincipal_->setAux(run.runAuxiliary());
      edm::ServiceRegistry::Operate guard(*serviceToken_);
      streamContext_->setTransition(StreamContext::Transition::kBeginRun);
      provider_->beginRun(*runPrincipal_, setup.impl(), run.moduleCallingContext(), *streamContext_);
    }
  }

beginStream()

void edm::PileUp::beginStream

(

edm::StreamID

)

Definition at line 211 of file PileUp.cc.

References eventPrincipal_, edm::StreamContext::kBeginStream, processContext_, provider_, serviceToken_, and streamContext_.

                                      {
    auto iID = eventPrincipal_->streamID();  // each producer has its own workermanager, so use default streamid
    streamContext_.reset(new StreamContext(iID, processContext_.get()));
    streamContext_->setTransition(StreamContext::Transition::kBeginStream);
    if (provider_.get() != nullptr) {
      edm::ServiceRegistry::Operate guard(*serviceToken_);
      provider_->beginStream(iID, *streamContext_);
    }
  }

CalculatePileup()

void edm::PileUp::CalculatePileup	(	int	MinBunch,
		int	MaxBunch,
		std::vector< int > &	PileupSelection,
		std::vector< float > &	TrueNumInteractions,
		StreamID const &	streamID
	)

Definition at line 414 of file PileUp.cc.

References averageNumber_, nano_mu_digi_cff::bx, ztail::d, fixed_, GetRandom(), histo_, histoDistribution_, createfilelist::int, intAverage_, intFixed_ITPU_, intFixed_OOT_, manage_OOT_, none_, poisson_, poisson_OOT_, poissonDistr_OOT(), poissonDistribution(), probFunctionDistribution_, provider_, PU_Study_, randomEngine(), setRandomEngine(), and Study_type_.

                                                         {
    // if we are managing the distribution of out-of-time pileup separately, select the distribution for bunch
    // crossing zero first, save it for later.

    int nzero_crossing = -1;
    double Fnzero_crossing = -1;

    if (provider_) {
      setRandomEngine(streamID);
    }

    if (manage_OOT_) {
      if (none_) {
        nzero_crossing = 0;
      } else if (poisson_) {
        nzero_crossing = poissonDistribution(streamID)->fire();
      } else if (fixed_) {
        nzero_crossing = intAverage_;
      } else if (histoDistribution_ || probFunctionDistribution_) {
        // RANDOM_NUMBER_ERROR
        // Random number should be generated by the engines from the
        // RandomNumberGeneratorService. This appears to use the global
        // engine in ROOT. This is not thread safe unless the module using
        // it is a one module and declares a shared resource and all
        // other modules using it also declare the same shared resource.
        // This also breaks replay.
        double d = GetRandom(histo_.get(), randomEngine(streamID));
        //n = (int) floor(d + 0.5);  // incorrect for bins with integer edges
        Fnzero_crossing = d;
        nzero_crossing = int(d);
      }
    }

    for (int bx = MinBunch; bx < MaxBunch + 1; ++bx) {
      if (manage_OOT_) {
        if (bx == 0 && !poisson_OOT_) {
          PileupSelection.push_back(nzero_crossing);
          TrueNumInteractions.push_back(nzero_crossing);
        } else {
          if (poisson_OOT_) {
            if (PU_Study_ && (Study_type_ == "Fixed_ITPU_Vary_OOTPU") && bx == 0) {
              PileupSelection.push_back(intFixed_ITPU_);
            } else {
              PileupSelection.push_back(poissonDistr_OOT(streamID)->fire(Fnzero_crossing));
            }
            TrueNumInteractions.push_back(Fnzero_crossing);
          } else {
            PileupSelection.push_back(intFixed_OOT_);
            TrueNumInteractions.push_back(intFixed_OOT_);
          }
        }
      } else {
        if (none_) {
          PileupSelection.push_back(0);
          TrueNumInteractions.push_back(0.);
        } else if (poisson_) {
          PileupSelection.push_back(poissonDistribution(streamID)->fire());
          TrueNumInteractions.push_back(averageNumber_);
        } else if (fixed_) {
          PileupSelection.push_back(intAverage_);
          TrueNumInteractions.push_back(intAverage_);
        } else if (histoDistribution_ || probFunctionDistribution_) {
          // RANDOM_NUMBER_ERROR
          // Random number should be generated by the engines from the
          // RandomNumberGeneratorService. This appears to use the global
          // engine in ROOT. This is not thread safe unless the module using
          // it is a one module and declares a shared resource and all
          // other modules using it also declare the same shared resource.
          // This also breaks replay.
          double d = GetRandom(histo_.get(), randomEngine(streamID));
          PileupSelection.push_back(int(d));
          TrueNumInteractions.push_back(d);
        }
      }
    }
  }

doPileUp()

bool edm::PileUp::doPileUp ( int  BX )

inline

Definition at line 73 of file PileUp.h.

References averageNumber_, L1TStage2uGTEmulatorClient_cff::BX, funct::false, maxBunch_cosmics_, minBunch_cosmics_, none_, and Source_type_.

                          {
      if (Source_type_ != "cosmics") {
        return none_ ? false : averageNumber_ > 0.;
      } else {
        return (BX >= minBunch_cosmics_ && BX <= maxBunch_cosmics_);
      }
    }

dropUnwantedBranches()

void edm::PileUp::dropUnwantedBranches ( std::vector< std::string > const &  wantedBranches )

inline

Definition at line 80 of file PileUp.h.

References input_.

                                                                          {
      input_->dropUnwantedBranches(wantedBranches);
    }

endLuminosityBlock()

void edm::PileUp::endLuminosityBlock	(	const edm::LuminosityBlock &	lumi,
		const edm::EventSetup &	setup
	)

Definition at line 274 of file PileUp.cc.

References edm::StreamContext::kEndLuminosityBlock, lumiPrincipal_, provider_, serviceToken_, singleTopDQM_cfi::setup, and streamContext_.

                                                                                            {
    if (provider_.get() != nullptr) {
      edm::ServiceRegistry::Operate guard(*serviceToken_);
      streamContext_->setTransition(StreamContext::Transition::kEndLuminosityBlock);
      provider_->endLuminosityBlock(*lumiPrincipal_, setup.impl(), lumi.moduleCallingContext(), *streamContext_);
    }
  }

endRun()

void edm::PileUp::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	setup
	)

Definition at line 267 of file PileUp.cc.

References edm::StreamContext::kEndRun, provider_, writedatasetfile::run, runPrincipal_, serviceToken_, singleTopDQM_cfi::setup, and streamContext_.

                                                                   {
    if (provider_.get() != nullptr) {
      edm::ServiceRegistry::Operate guard(*serviceToken_);
      streamContext_->setTransition(StreamContext::Transition::kEndRun);
      provider_->endRun(*runPrincipal_, setup.impl(), run.moduleCallingContext(), *streamContext_);
    }
  }

endStream() [1/2]

void edm::PileUp::endStream

(

)

Definition at line 221 of file PileUp.cc.

References edm::ExceptionCollector::hasThrown(), and edm::ExceptionCollector::rethrow().

                         {
    ExceptionCollector exceptionCollector(
        "Multiple exceptions were thrown while executing PileUp::endStream. An exception message follows for "
        "each.\n");
    endStream(exceptionCollector);

    if (exceptionCollector.hasThrown()) {
      exceptionCollector.rethrow();
    }
  }

endStream() [2/2]

void edm::PileUp::endStream

(

ExceptionCollector &

exceptionCollector

)

Definition at line 232 of file PileUp.cc.

References input_, edm::GlobalContext::kEndJob, edm::StreamContext::kEndStream, processContext_, provider_, serviceToken_, and streamContext_.

                                                               {
    if (provider_.get() != nullptr) {
      edm::ServiceRegistry::Operate guard(*serviceToken_);
      streamContext_->setTransition(StreamContext::Transition::kEndStream);
      provider_->endStream(streamContext_->streamID(), *streamContext_, exceptionCollector);
      // This is kind of strange, end of job running as part of endStream multiple times...
      // For the moment, I'm leaving this as is but maybe we should think about this...
      // I think nothing uses this code anymore anyway...
      GlobalContext globalContext(GlobalContext::Transition::kEndJob, processContext_.get());
      provider_->endJob(exceptionCollector, globalContext);
    }
    input_->doEndJob();
  }

input() [1/2]

const unsigned int& edm::PileUp::input ( ) const

inline

Definition at line 108 of file PileUp.h.

References inputType_.

{ return inputType_; }

input() [2/2]

void edm::PileUp::input ( unsigned int  s )

inline

Definition at line 109 of file PileUp.h.

References inputType_, and alignCSCRings::s.

{ inputType_ = s; }

playOldFormatPileUp()

template<typename T >

void edm::PileUp::playOldFormatPileUp	(	std::vector< edm::EventID >::const_iterator	begin,
		std::vector< edm::EventID >::const_iterator	end,
		std::vector< edm::SecondaryEventIDAndFileInfo > &	ids,
		T	eventOperator
	)

Definition at line 229 of file PileUp.h.

References eventPrincipal_, fileNameHash_, and input_.

                                                    {
    //TrueNumInteractions.push_back( end - begin ) ;
    RecordEventID<T> recorder(ids, eventOperator);
    input_->loopSpecified(*eventPrincipal_, fileNameHash_, begin, end, recorder);
  }

playPileUp()

template<typename T >

void edm::PileUp::playPileUp	(	std::vector< edm::SecondaryEventIDAndFileInfo >::const_iterator	begin,
		std::vector< edm::SecondaryEventIDAndFileInfo >::const_iterator	end,
		std::vector< edm::SecondaryEventIDAndFileInfo > &	ids,
		T	eventOperator
	)

Definition at line 219 of file PileUp.h.

References eventPrincipal_, fileNameHash_, and input_.

                                           {
    //TrueNumInteractions.push_back( end - begin ) ;
    RecordEventID<T> recorder(ids, eventOperator);
    input_->loopSpecified(*eventPrincipal_, fileNameHash_, begin, end, recorder);
  }

poisson()

bool edm::PileUp::poisson ( ) const

inline

Definition at line 72 of file PileUp.h.

References poisson_.

{ return poisson_; }

poissonDistr_OOT()

std::unique_ptr< CLHEP::RandPoisson > const & edm::PileUp::poissonDistr_OOT ( StreamID const &  streamID )

private

Definition at line 391 of file PileUp.cc.

References PoissonDistr_OOT_, and randomEngine().

Referenced by CalculatePileup().

                                                                                          {
    if (!PoissonDistr_OOT_) {
      CLHEP::HepRandomEngine& engine = *randomEngine(streamID);
      PoissonDistr_OOT_ = std::make_unique<CLHEP::RandPoisson>(engine);
    }
    return PoissonDistr_OOT_;
  }

poissonDistribution()

std::unique_ptr< CLHEP::RandPoissonQ > const & edm::PileUp::poissonDistribution ( StreamID const &  streamID )

private

Definition at line 383 of file PileUp.cc.

References averageNumber_, PoissonDistribution_, and randomEngine().

Referenced by CalculatePileup().

                                                                                              {
    if (!PoissonDistribution_) {
      CLHEP::HepRandomEngine& engine = *randomEngine(streamID);
      PoissonDistribution_ = std::make_unique<CLHEP::RandPoissonQ>(engine, averageNumber_);
    }
    return PoissonDistribution_;
  }

randomEngine()

CLHEP::HepRandomEngine * edm::PileUp::randomEngine ( StreamID const &  streamID )

private

Definition at line 399 of file PileUp.cc.

References randomEngine_.

Referenced by CalculatePileup(), poissonDistr_OOT(), poissonDistribution(), readPileUp(), and setRandomEngine().

                                                                     {
    if (!randomEngine_) {
      Service<RandomNumberGenerator> rng;
      randomEngine_ = &rng->getEngine(streamID);
    }
    return randomEngine_;
  }

readPileUp()

template<typename T >

void edm::PileUp::readPileUp	(	edm::EventID const &	signal,
		std::vector< edm::SecondaryEventIDAndFileInfo > &	ids,
		T	eventOperator,
		int const	pileEventCnt,
		StreamID const &	streamID
	)

Generates events from a VectorInputSource. This function decides which method of VectorInputSource to call: sequential, random, or pre-specified. The ids are either ids to read or ids to store while reading. eventOperator has a type that matches the eventOperator in VectorInputSource::loopRandom.

The "signal" event is optionally used to restrict the secondary events used for pileup and mixing.

Definition at line 201 of file PileUp.h.

References eventPrincipal_, fileNameHash_, input_, randomEngine(), fileinputsource_cfi::read, and sequential_.

                                                    {
    // One reason PileUp is responsible for recording event IDs is
    // that it is the one that knows how many events will be read.
    ids.reserve(pileEventCnt);
    RecordEventID<T> recorder(ids, eventOperator);
    int read = 0;
    CLHEP::HepRandomEngine* engine = (sequential_ ? nullptr : randomEngine(streamID));
    read = input_->loopOverEvents(*eventPrincipal_, fileNameHash_, pileEventCnt, recorder, engine, &signal);
    if (read != pileEventCnt)
      edm::LogWarning("PileUp") << "Could not read enough pileup events: only " << read << " out of " << pileEventCnt
                                << " requested.";
  }

reload()

void edm::PileUp::reload

(

const edm::EventSetup &

setup

)

Definition at line 293 of file PileUp.cc.

References funct::abs(), averageNumber(), averageNumber_, configToken_, MillePedeFileConverter_cfg::e, Exception, fixed_, fixed_OOT_, histo_, histoDistribution_, mps_fire::i, inputType_, createfilelist::int, intFixed_OOT_, dqmiolumiharvest::j, LogDebug, manage_OOT_, none_, poisson_, poisson_OOT_, PoissonDistribution_, probFunctionDistribution_, singleTopDQM_cfi::setup, type_, TrackerOfflineValidation_Dqm_cff::xmax, and TrackerOfflineValidation_Dqm_cff::xmin.

                                                {
    //get the required parameters from DB.
    const MixingInputConfig& config = setup.getData(configToken_).config(inputType_);

    //get the type
    type_ = config.type();
    //set booleans
    histoDistribution_ = type_ == "histo";
    probFunctionDistribution_ = type_ == "probFunction";
    poisson_ = type_ == "poisson";
    fixed_ = type_ == "fixed";
    none_ = type_ == "none";

    if (histoDistribution_)
      edm::LogError("MisConfiguration") << "type histo cannot be reloaded from DB, yet";

    if (fixed_) {
      averageNumber_ = averageNumber();
    } else if (poisson_) {
      averageNumber_ = config.averageNumber();
      if (PoissonDistribution_) {
        PoissonDistribution_ = std::make_unique<CLHEP::RandPoissonQ>(PoissonDistribution_->engine(), averageNumber_);
      }
    } else if (probFunctionDistribution_) {
      //need to reload the histogram from DB
      const std::vector<int>& dataProbFunctionVar = config.probFunctionVariable();
      std::vector<double> dataProb = config.probValue();

      int varSize = (int)dataProbFunctionVar.size();
      int probSize = (int)dataProb.size();

      if ((dataProbFunctionVar[0] != 0) || (dataProbFunctionVar[varSize - 1] != (varSize - 1)))
        throw cms::Exception("BadProbFunction")
            << "Please, check the variables of the probability function! The first variable should be 0 and the "
               "difference between two variables should be 1."
            << std::endl;

      // Complete the vector containing the probability  function data
      // with the values "0"
      if (probSize < varSize) {
        edm::LogWarning("MixingModule") << " The probability function data will be completed with "
                                        << (varSize - probSize) << " values 0.";

        for (int i = 0; i < (varSize - probSize); i++)
          dataProb.push_back(0);

        probSize = dataProb.size();
        edm::LogInfo("MixingModule") << " The number of the P(x) data set after adding the values 0 is " << probSize;
      }

      // Create an histogram with the data from the probability function provided by the user
      int xmin = (int)dataProbFunctionVar[0];
      int xmax = (int)dataProbFunctionVar[varSize - 1] + 1;  // need upper edge to be one beyond last value
      int numBins = varSize;

      edm::LogInfo("MixingModule") << "An histogram will be created with " << numBins << " bins in the range (" << xmin
                                   << "," << xmax << ")." << std::endl;

      histo_.reset(new TH1F("h", "Histo from the user's probability function", numBins, xmin, xmax));

      LogDebug("MixingModule") << "Filling histogram with the following data:" << std::endl;

      for (int j = 0; j < numBins; j++) {
        LogDebug("MixingModule") << " x = " << dataProbFunctionVar[j] << " P(x) = " << dataProb[j];
        histo_->Fill(dataProbFunctionVar[j] + 0.5,
                     dataProb[j]);  // assuming integer values for the bins, fill bin centers, not edges
      }

      // Check if the histogram is normalized
      if (std::abs(histo_->Integral() - 1) > 1.0e-02) {
        throw cms::Exception("BadProbFunction") << "The probability function should be normalized!!! " << std::endl;
      }
      averageNumber_ = histo_->GetMean();
    }

    int oot = config.outOfTime();
    manage_OOT_ = false;
    if (oot == 1) {
      manage_OOT_ = true;
      poisson_OOT_ = false;
      fixed_OOT_ = true;
      intFixed_OOT_ = config.fixedOutOfTime();
    } else if (oot == 2) {
      manage_OOT_ = true;
      poisson_OOT_ = true;
      fixed_OOT_ = false;
    }
  }

setRandomEngine() [1/2]

void edm::PileUp::setRandomEngine ( StreamID  streamID )

private

Definition at line 407 of file PileUp.cc.

References randomEngine(), randomGenerator_, and PileupRandomNumberGenerator::setEngine().

Referenced by beginLuminosityBlock(), and CalculatePileup().

{ randomGenerator_->setEngine(*randomEngine(streamID)); }

setRandomEngine() [2/2]

void edm::PileUp::setRandomEngine ( LuminosityBlock const &  iLumi )

private

Definition at line 408 of file PileUp.cc.

References edm::LuminosityBlock::index(), randomGenerator_, PileupRandomNumberGenerator::setEngine(), and PileupRandomNumberGenerator::setSeed().

                                                           {
    Service<RandomNumberGenerator> rng;
    randomGenerator_->setSeed(rng->mySeed());
    randomGenerator_->setEngine(rng->getEngine(iLumi.index()));
  }

setupPileUpEvent()

void edm::PileUp::setupPileUpEvent

(

const edm::EventSetup &

setup

)

Definition at line 282 of file PileUp.cc.

References eventPrincipal_, edm::StreamContext::kEvent, lumiPrincipal_, provider_, serviceToken_, singleTopDQM_cfi::setup, and streamContext_.

                                                          {
    if (provider_.get() != nullptr) {
      // note:  run and lumi numbers must be modified to match lumiPrincipal_
      eventPrincipal_->setLuminosityBlockPrincipal(lumiPrincipal_.get());
      eventPrincipal_->setRunAndLumiNumber(lumiPrincipal_->run(), lumiPrincipal_->luminosityBlock());
      edm::ServiceRegistry::Operate guard(*serviceToken_);
      streamContext_->setTransition(StreamContext::Transition::kEvent);
      provider_->setupPileUpEvent(*eventPrincipal_, setup.impl(), *streamContext_);
    }
  }

Member Data Documentation

averageNumber_

double edm::PileUp::averageNumber_

private

Definition at line 121 of file PileUp.h.

Referenced by averageNumber(), CalculatePileup(), doPileUp(), poissonDistribution(), and reload().

configToken_

edm::ESGetToken<MixingModuleConfig, MixingRcd> edm::PileUp::configToken_

private

Definition at line 142 of file PileUp.h.

Referenced by PileUp(), and reload().

eventPrincipal_

std::unique_ptr<EventPrincipal> edm::PileUp::eventPrincipal_

private

Definition at line 149 of file PileUp.h.

Referenced by beginStream(), PileUp(), playOldFormatPileUp(), playPileUp(), readPileUp(), and setupPileUpEvent().

fileNameHash_

size_t edm::PileUp::fileNameHash_

private

Definition at line 143 of file PileUp.h.

Referenced by playOldFormatPileUp(), playPileUp(), and readPileUp().

fixed_

bool edm::PileUp::fixed_

private

Definition at line 127 of file PileUp.h.

Referenced by CalculatePileup(), PileUp(), and reload().

fixed_OOT_

bool edm::PileUp::fixed_OOT_

private

Definition at line 131 of file PileUp.h.

Referenced by PileUp(), and reload().

histo_

std::shared_ptr<TH1F> edm::PileUp::histo_

private

Definition at line 123 of file PileUp.h.

Referenced by CalculatePileup(), and reload().

histoDistribution_

bool edm::PileUp::histoDistribution_

private

Definition at line 124 of file PileUp.h.

Referenced by CalculatePileup(), PileUp(), and reload().

input_

std::unique_ptr<VectorInputSource> const edm::PileUp::input_

private

Definition at line 145 of file PileUp.h.

Referenced by beginJob(), dropUnwantedBranches(), endStream(), PileUp(), playOldFormatPileUp(), playPileUp(), and readPileUp().

inputType_

unsigned int edm::PileUp::inputType_

private

Definition at line 118 of file PileUp.h.

Referenced by input(), and reload().

intAverage_

int const edm::PileUp::intAverage_

private

Definition at line 122 of file PileUp.h.

Referenced by CalculatePileup().

intFixed_ITPU_

int edm::PileUp::intFixed_ITPU_

private

Definition at line 137 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

intFixed_OOT_

int edm::PileUp::intFixed_OOT_

private

Definition at line 136 of file PileUp.h.

Referenced by CalculatePileup(), PileUp(), and reload().

lumiPrincipal_

std::shared_ptr<LuminosityBlockPrincipal> edm::PileUp::lumiPrincipal_

private

Definition at line 150 of file PileUp.h.

Referenced by beginLuminosityBlock(), endLuminosityBlock(), and setupPileUpEvent().

manage_OOT_

bool edm::PileUp::manage_OOT_

private

Definition at line 129 of file PileUp.h.

Referenced by CalculatePileup(), PileUp(), and reload().

maxBunch_cosmics_

int edm::PileUp::maxBunch_cosmics_

private

Definition at line 140 of file PileUp.h.

Referenced by doPileUp(), and PileUp().

minBunch_cosmics_

int edm::PileUp::minBunch_cosmics_

private

Definition at line 139 of file PileUp.h.

Referenced by doPileUp(), and PileUp().

none_

bool edm::PileUp::none_

private

Definition at line 128 of file PileUp.h.

Referenced by CalculatePileup(), doPileUp(), PileUp(), and reload().

playback_

bool edm::PileUp::playback_

private

Definition at line 164 of file PileUp.h.

poisson_

bool edm::PileUp::poisson_

private

Definition at line 126 of file PileUp.h.

Referenced by CalculatePileup(), PileUp(), poisson(), and reload().

poisson_OOT_

bool edm::PileUp::poisson_OOT_

private

Definition at line 130 of file PileUp.h.

Referenced by CalculatePileup(), PileUp(), and reload().

PoissonDistr_OOT_

std::unique_ptr<CLHEP::RandPoisson> edm::PileUp::PoissonDistr_OOT_

private

Definition at line 156 of file PileUp.h.

Referenced by poissonDistr_OOT().

PoissonDistribution_

std::unique_ptr<CLHEP::RandPoissonQ> edm::PileUp::PoissonDistribution_

private

Definition at line 155 of file PileUp.h.

Referenced by poissonDistribution(), and reload().

probFunctionDistribution_

bool edm::PileUp::probFunctionDistribution_

private

Definition at line 125 of file PileUp.h.

Referenced by CalculatePileup(), PileUp(), and reload().

processConfiguration_

std::shared_ptr<ProcessConfiguration> edm::PileUp::processConfiguration_

private

Definition at line 146 of file PileUp.h.

Referenced by beginLuminosityBlock(), beginRun(), and PileUp().

processContext_

std::shared_ptr<ProcessContext> edm::PileUp::processContext_

private

Definition at line 147 of file PileUp.h.

Referenced by beginJob(), beginStream(), endStream(), and PileUp().

productRegistry_

std::shared_ptr<ProductRegistry> edm::PileUp::productRegistry_

private

Definition at line 144 of file PileUp.h.

Referenced by beginJob(), beginLuminosityBlock(), beginRun(), and PileUp().

provider_

std::unique_ptr<SecondaryEventProvider> edm::PileUp::provider_

private

Definition at line 154 of file PileUp.h.

Referenced by beginJob(), beginLuminosityBlock(), beginRun(), beginStream(), CalculatePileup(), endLuminosityBlock(), endRun(), endStream(), PileUp(), and setupPileUpEvent().

PU_Study_

bool edm::PileUp::PU_Study_

private

Definition at line 133 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

randomEngine_

CLHEP::HepRandomEngine* edm::PileUp::randomEngine_

private

Definition at line 157 of file PileUp.h.

Referenced by randomEngine().

randomGenerator_

PileupRandomNumberGenerator* edm::PileUp::randomGenerator_ = nullptr

private

Definition at line 152 of file PileUp.h.

Referenced by PileUp(), and setRandomEngine().

runPrincipal_

std::shared_ptr<RunPrincipal> edm::PileUp::runPrincipal_

private

Definition at line 151 of file PileUp.h.

Referenced by beginLuminosityBlock(), beginRun(), and endRun().

sequential_

bool edm::PileUp::sequential_

private

Definition at line 167 of file PileUp.h.

Referenced by readPileUp().

serviceToken_

std::optional<ServiceToken> edm::PileUp::serviceToken_

private

Definition at line 153 of file PileUp.h.

Referenced by beginJob(), beginLuminosityBlock(), beginRun(), beginStream(), endLuminosityBlock(), endRun(), endStream(), PileUp(), and setupPileUpEvent().

Source_type_

std::string edm::PileUp::Source_type_

private

Definition at line 120 of file PileUp.h.

Referenced by doPileUp(), and PileUp().

streamContext_

std::shared_ptr<StreamContext> edm::PileUp::streamContext_

private

Definition at line 148 of file PileUp.h.

Referenced by beginLuminosityBlock(), beginRun(), beginStream(), endLuminosityBlock(), endRun(), endStream(), and setupPileUpEvent().

Study_type_

std::string edm::PileUp::Study_type_

private

Definition at line 134 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

type_

std::string edm::PileUp::type_

private

Definition at line 119 of file PileUp.h.

Referenced by Modules.Service::__str__(), Modules.Service::_placeImpl(), Modules.ESSource::_placeImpl(), Modules.ESProducer::_placeImpl(), Modules.ESPrefer::copy(), Mixins._TypedParameterizable::dumpPython(), Modules.ESPrefer::dumpPythonAs(), Modules.Service::dumpSequencePython(), RandomRunSource.RandomRunSource::insertInto(), Modules.Service::insertInto(), ExternalGeneratorFilter.ExternalGeneratorFilter::insertInto(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::moduleLabel_(), Modules.ESProducer::moduleLabel_(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), Modules.ESPrefer::nameInProcessDesc_(), PileUp(), and reload().