#include <PileUp.h>

Public Member Functions
double	averageNumber () const

void	beginJob ()

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

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

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	endJob ()

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

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

const unsigned int &	input () const

void	input (unsigned int s)

	PileUp (ParameterSet const &pset, std::string sourcename, double averageNumber, TH1F *const histo, const bool playback)

template<typename T >
void	playPileUp (const std::vector< edm::EventID > &ids, T eventOperator)

bool	poisson () const

template<typename T >
void	readPileUp (edm::EventID const &signal, std::vector< edm::EventID > &ids, T eventOperator, const int 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)

Private Attributes
double	averageNumber_

std::unique_ptr< EventPrincipal >	eventPrincipal_

bool	fixed_

bool	fixed_OOT_

TH1F *	h1f

TH1F *	histo_

bool	histoDistribution_

TH1F *	hprobFunction

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_

TFile *	probFileHisto

bool	probFunctionDistribution_

std::shared_ptr < ProcessConfiguration >	processConfiguration_

std::shared_ptr< ProductRegistry >	productRegistry_

std::unique_ptr < SecondaryEventProvider >	provider_

bool	PU_Study_

std::vector < CLHEP::HepRandomEngine * >	randomEngines_

std::shared_ptr< RunPrincipal >	runPrincipal_

bool	samelumi_

int	seed_

bool	sequential_

std::string	Source_type_

std::string	Study_type_

std::string	type_

std::vector< std::unique_ptr < CLHEP::RandPoisson > >	vPoissonDistr_OOT_

std::vector< std::unique_ptr < CLHEP::RandPoissonQ > >	vPoissonDistribution_

Detailed Description

Definition at line 30 of file PileUp.h.

Constructor & Destructor Documentation

edm::PileUp::PileUp	(	ParameterSet const &	pset,
		std::string	sourcename,
		double	averageNumber,
		TH1F *const	histo,
		const bool	playback
	)

explicit

Definition at line 33 of file PileUp.cc.

References dqmPostProcessing_online::DB, edm::ParameterSet::emptyParameterSetID(), eventPrincipal_, edm::hlt::Exception, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), fixed_, fixed_OOT_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), histoDistribution_, input_, intFixed_ITPU_, intFixed_OOT_, edm::Service< T >::isAvailable(), manage_OOT_, maxBunch_cosmics_, minBunch_cosmics_, edm::RandomNumberGenerator::mySeed(), none_, poisson_, poisson_OOT_, probFunctionDistribution_, processConfiguration_, productRegistry_, provider_, PU_Study_, seed_, Source_type_, AlCaHLTBitMon_QueryRunRegistry::string, Study_type_, and type_.

                                                                                                                               :
     type_(pset.getParameter<std::string>("type")),
     Source_type_(sourcename),
     averageNumber_(averageNumber),
     intAverage_(static_cast<int>(averageNumber)),
     histo_(histo),
     histoDistribution_(type_ == "histo"),
     probFunctionDistribution_(type_ == "probFunction"),
     poisson_(type_ == "poisson"),
     fixed_(type_ == "fixed"),
     none_(type_ == "none"),
     productRegistry_(new SignallingProductRegistry),
     input_(VectorInputSourceFactory::get()->makeVectorInputSource(pset, InputSourceDescription(
                                                                    ModuleDescription(),
                                                                    *productRegistry_,
                                                                    std::make_shared<BranchIDListHelper>(),
                                                                    std::make_shared<ThinnedAssociationsHelper>(),
                                                                    std::make_shared<ActivityRegistry>(),
                                                                    -1, -1, -1,
                                                                    PreallocationConfiguration()
                                                                    )).release()),
     processConfiguration_(new ProcessConfiguration(std::string("@MIXING"), getReleaseVersion(), getPassID())),
     eventPrincipal_(),
     lumiPrincipal_(),
     runPrincipal_(),
     provider_(),
     vPoissonDistribution_(),
     vPoissonDistr_OOT_(),
     randomEngines_(),
     playback_(playback),
     sequential_(pset.getUntrackedParameter<bool>("sequential", false)),
     samelumi_(pset.getUntrackedParameter<bool>("sameLumiBlock", false)),
     seed_(0) {
 
     // Use the empty parameter set for the parameter set ID of our "@MIXING" process.
     processConfiguration_->setParameterSetID(ParameterSet::emptyParameterSetID());
 
     if(pset.existsAs<std::vector<ParameterSet> >("producers", true)) {
       std::vector<ParameterSet> producers = pset.getParameter<std::vector<ParameterSet> >("producers");
       provider_.reset(new SecondaryEventProvider(producers, *productRegistry_, processConfiguration_));
     }
 
     productRegistry_->setFrozen();
 
     // A modified HistoryAppender must be used for unscheduled processing.
     eventPrincipal_.reset(new EventPrincipal(input_->productRegistry(),
                                        input_->branchIDListHelper(),
                                        input_->thinnedAssociationsHelper(),
                                        *processConfiguration_,
                                        nullptr));
 
     if (pset.exists("nbPileupEvents")) {
        seed_=pset.getParameter<edm::ParameterSet>("nbPileupEvents").getUntrackedParameter<int>("seed",0);
     }
 
     bool DB=type_=="readDB";
 
     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.";
     }
     
     // Get seed for the case when using user histogram or probability function
     // 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.
     if (histoDistribution_ || probFunctionDistribution_ || DB){ 
       if(seed_ !=0) {
     gRandom->SetSeed(seed_);
     LogInfo("MixingModule") << " Change seed for " << type_ << " mode. The seed is set to " << seed_;
       }
       else {
     gRandom->SetSeed(rng->mySeed());
       }
     }
         
     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_ = "";
 
     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

edm::PileUp::~PileUp ( )

Definition at line 325 of file PileUp.cc.

325 {

326 }

Member Function Documentation

double edm::PileUp::averageNumber ( ) const

inline

Definition at line 41 of file PileUp.h.

References averageNumber_.

Referenced by reload().

41 {return averageNumber_;}

edm::PileUp::averageNumber_

double averageNumber_

Definition: PileUp.h:85

void edm::PileUp::beginJob ( void )

Definition at line 180 of file PileUp.cc.

References input_, productRegistry_, and provider_.

                          {
     input_->doBeginJob();
     if (provider_.get() != nullptr) {
       provider_->beginJob(*productRegistry_);
     }
   }

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

Definition at line 201 of file PileUp.cc.

References printConversionInfo::aux, edm::LuminosityBlock::luminosityBlockAuxiliary(), lumiPrincipal_, edm::LuminosityBlock::moduleCallingContext(), processConfiguration_, productRegistry_, provider_, and runPrincipal_.

                                                                                               {
     if (provider_.get() != nullptr) {
       auto aux = std::make_shared<LuminosityBlockAuxiliary>(lumi.luminosityBlockAuxiliary());
       lumiPrincipal_.reset(new LuminosityBlockPrincipal(aux, productRegistry_, *processConfiguration_, nullptr, 0));
       lumiPrincipal_->setRunPrincipal(runPrincipal_);
       provider_->beginLuminosityBlock(*lumiPrincipal_, setup, lumi.moduleCallingContext());
     }
   }

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

Definition at line 194 of file PileUp.cc.

References printConversionInfo::aux, edm::Run::moduleCallingContext(), processConfiguration_, productRegistry_, provider_, edm::Run::runAuxiliary(), and runPrincipal_.

                                                                      {
     if (provider_.get() != nullptr) {
       auto aux = std::make_shared<RunAuxiliary>(run.runAuxiliary());
       runPrincipal_.reset(new RunPrincipal(aux, productRegistry_, *processConfiguration_, nullptr, 0));
       provider_->beginRun(*runPrincipal_, setup, run.moduleCallingContext());
     }
   }

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

Definition at line 374 of file PileUp.cc.

References averageNumber_, fixed_, histo_, histoDistribution_, intAverage_, intFixed_ITPU_, intFixed_OOT_, manage_OOT_, none_, poisson_, poisson_OOT_, poissonDistr_OOT(), poissonDistribution(), probFunctionDistribution_, PU_Study_, 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(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 = histo_->GetRandom();
     //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 = histo_->GetRandom();
       PileupSelection.push_back(int(d));
       TrueNumInteractions.push_back( d );
     }
       }
     
     }
   }

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

inline

Definition at line 43 of file PileUp.h.

References averageNumber_, 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_);
       }
     }

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

inline

Definition at line 51 of file PileUp.h.

References input_.

                                                                           {
       input_->dropUnwantedBranches(wantedBranches);
     }

void edm::PileUp::endJob ( void )

Definition at line 187 of file PileUp.cc.

References input_, and provider_.

                        {
     if (provider_.get() != nullptr) {
       provider_->endJob();
     }
     input_->doEndJob();
   }

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

Definition at line 215 of file PileUp.cc.

References lumiPrincipal_, edm::LuminosityBlock::moduleCallingContext(), and provider_.

                                                                                             {
     if (provider_.get() != nullptr) {
       provider_->endLuminosityBlock(*lumiPrincipal_, setup, lumi.moduleCallingContext());
     }
   }

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

Definition at line 210 of file PileUp.cc.

References edm::Run::moduleCallingContext(), provider_, and runPrincipal_.

                                                                    {
     if (provider_.get() != nullptr) {
       provider_->endRun(*runPrincipal_, setup, run.moduleCallingContext());
     }
   }

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

inline

Definition at line 73 of file PileUp.h.

References inputType_.

73 {return inputType_;}

edm::PileUp::inputType_

unsigned int inputType_

Definition: PileUp.h:82

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

inline

Definition at line 74 of file PileUp.h.

References inputType_, and alignCSCRings::s.

74 {inputType_=s;}

edm::PileUp::inputType_

unsigned int inputType_

Definition: PileUp.h:82

alignCSCRings.s

list s

Definition: alignCSCRings.py:91

template<typename T >

void edm::PileUp::playPileUp	(	const std::vector< edm::EventID > &	ids,
		T	eventOperator
	)

Definition at line 210 of file PileUp.h.

References eventPrincipal_, and input_.

                                                                         {
     //TrueNumInteractions.push_back( ids.size() ) ;
     PassEventID<T> recorder(eventOperator);
     input_->loopSpecified(*eventPrincipal_,ids,recorder);
   }

bool edm::PileUp::poisson ( ) const

inline

Definition at line 42 of file PileUp.h.

References poisson_.

42 {return poisson_;}

edm::PileUp::poisson_

bool poisson_

Definition: PileUp.h:90

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

private

Definition at line 343 of file PileUp.cc.

References cmsHarvester::index, randomEngine(), edm::StreamID::value(), and vPoissonDistr_OOT_.

Referenced by CalculatePileup().

                                                                                           {
     unsigned int index = streamID.value();
     if(index >= vPoissonDistr_OOT_.size()) {
       // This resizing is not thread safe and only works because
       // this is used by a "one" type module
       vPoissonDistr_OOT_.resize(index + 1);
     }
     std::unique_ptr<CLHEP::RandPoisson>& ptr = vPoissonDistr_OOT_[index];
     if(!ptr) {
       CLHEP::HepRandomEngine& engine = *randomEngine(streamID);
       ptr.reset(new CLHEP::RandPoisson(engine));
     }
     return ptr;
   }

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

private

Definition at line 328 of file PileUp.cc.

References averageNumber_, cmsHarvester::index, randomEngine(), edm::StreamID::value(), and vPoissonDistribution_.

Referenced by CalculatePileup().

                                                                                               {
     unsigned int index = streamID.value();
     if(index >= vPoissonDistribution_.size()) {
       // This resizing is not thread safe and only works because
       // this is used by a "one" type module
       vPoissonDistribution_.resize(index + 1);
     }
     std::unique_ptr<CLHEP::RandPoissonQ>& ptr = vPoissonDistribution_[index];
     if(!ptr) {
       CLHEP::HepRandomEngine& engine = *randomEngine(streamID);
       ptr.reset(new CLHEP::RandPoissonQ(engine, averageNumber_));
     }
     return ptr;
   }

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

private

Definition at line 358 of file PileUp.cc.

References cmsHarvester::index, randomEngines_, and edm::StreamID::value().

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

                                                                      {
     unsigned int index = streamID.value();
     if(index >= randomEngines_.size()) {
       // This resizing is not thread safe and only works because
       // this is used by a "one" type module
       randomEngines_.resize(index + 1, nullptr);
     }
     CLHEP::HepRandomEngine* ptr = randomEngines_[index];
     if(!ptr) {
       Service<RandomNumberGenerator> rng;
       ptr = &rng->getEngine(streamID);
       randomEngines_[index] = ptr;
     }
     return ptr;
   }

template<typename T >

void edm::PileUp::readPileUp	(	edm::EventID const &	signal,
		std::vector< edm::EventID > &	ids,
		T	eventOperator,
		const int	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 181 of file PileUp.h.

References eventPrincipal_, input_, fjr2json::lumi, edm::EventID::luminosityBlock(), randomEngine(), SiPixelLorentzAngle_cfi::read, edm::EventID::run(), samelumi_, 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;
     if (samelumi_) {
       const edm::LuminosityBlockID lumi(signal.run(), signal.luminosityBlock());
       if (sequential_)
         read = input_->loopSequentialWithID(*eventPrincipal_, lumi, pileEventCnt, recorder);
       else
         read = input_->loopRandomWithID(*eventPrincipal_, lumi, pileEventCnt, recorder, randomEngine(streamID));
     } else {
       if (sequential_) {
         read = input_->loopSequential(*eventPrincipal_, pileEventCnt, recorder);
       } else  {
         read = input_->loopRandom(*eventPrincipal_, pileEventCnt, recorder, randomEngine(streamID));
       }
     }
     if (read != pileEventCnt)
       edm::LogWarning("PileUp") << "Could not read enough pileup events: only " << read << " out of " << pileEventCnt << " requested.";
   }

void edm::PileUp::reload ( const edm::EventSetup & setup )

Definition at line 230 of file PileUp.cc.

References MixingInputConfig::averageNumber(), averageNumber(), averageNumber_, HDQMDatabaseProducer::config, alignCSCRings::e, edm::hlt::Exception, fixed_, fixed_OOT_, MixingInputConfig::fixedOutOfTime(), edm::EventSetup::get(), histo_, histoDistribution_, i, inputType_, intFixed_OOT_, j, LogDebug, manage_OOT_, none_, MixingInputConfig::outOfTime(), poisson_, poisson_OOT_, probFunctionDistribution_, MixingInputConfig::probFunctionVariable(), MixingInputConfig::probValue(), MixingInputConfig::type(), type_, vPoissonDistribution_, SiStripMonitorClusterAlca_cfi::xmax, and SiStripMonitorClusterAlca_cfi::xmin.

                                                 {
     //get the required parameters from DB.
     edm::ESHandle<MixingModuleConfig> configM;
     setup.get<MixingRcd>().get(configM);
 
     const MixingInputConfig & config=configM->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();
         for(auto & distribution : vPoissonDistribution_) {
           if(distribution) {
             distribution.reset(new CLHEP::RandPoissonQ(distribution->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;
 
     if (histo_) delete histo_;
     histo_ = 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 ( ((histo_->Integral() - 1) > 1.0e-02) && ((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;
       }
 
     
   }

void edm::PileUp::setupPileUpEvent ( const edm::EventSetup & setup )

Definition at line 221 of file PileUp.cc.

References eventPrincipal_, lumiPrincipal_, and provider_.

                                                           {
     if (provider_.get() != nullptr) {
       // note:  run and lumi numbers must be modified to match lumiPrincipal_
       eventPrincipal_->setLuminosityBlockPrincipal(lumiPrincipal_);
       eventPrincipal_->setRunAndLumiNumber(lumiPrincipal_->run(), lumiPrincipal_->luminosityBlock());
       provider_->setupPileUpEvent(*eventPrincipal_, setup);
     }
   }