#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	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)

Private Attributes
double	averageNumber_

std::unique_ptr< EventPrincipal >	eventPrincipal_

size_t	fileNameHash_

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	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 64 of file PileUp.cc.

References dqmPostProcessing_online::DB, edm::ParameterSet::emptyParameterSetID(), eventPrincipal_, 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_, none_, poisson_, poisson_OOT_, probFunctionDistribution_, processConfiguration_, HLT_25ns14e33_v1_cff::producers, productRegistry_, provider_, PU_Study_, 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"),
     fileNameHash_(0U),
     productRegistry_(new SignallingProductRegistry),
     input_(VectorInputSourceFactory::get()->makeVectorInputSource(pset, VectorInputSourceDescription(
                                                                    productRegistry_, edm::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)) {
 
     // 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(),
                                        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_ = "";
 
     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 332 of file PileUp.cc.

332 {

333 }

Member Function Documentation

double edm::PileUp::averageNumber ( ) const

inline

Definition at line 44 of file PileUp.h.

References averageNumber_.

Referenced by reload().

44 {return averageNumber_;}

edm::PileUp::averageNumber_

double averageNumber_

Definition: PileUp.h:88

void edm::PileUp::beginJob ( void )

Definition at line 187 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 208 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 201 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 381 of file PileUp.cc.

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

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

inline

Definition at line 46 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 54 of file PileUp.h.

References input_.

                                                                           {
       input_->dropUnwantedBranches(wantedBranches);
     }

void edm::PileUp::endJob ( void )

Definition at line 194 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 222 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 217 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 76 of file PileUp.h.

References inputType_.

76 {return inputType_;}

edm::PileUp::inputType_

unsigned int inputType_

Definition: PileUp.h:85

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

inline

Definition at line 77 of file PileUp.h.

References inputType_, and alignCSCRings::s.

77 {inputType_=s;}

edm::PileUp::inputType_

unsigned int inputType_

Definition: PileUp.h:85

alignCSCRings.s

list s

Definition: alignCSCRings.py:91

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 188 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);
   }

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 180 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);
   }

bool edm::PileUp::poisson ( ) const

inline

Definition at line 45 of file PileUp.h.

References poisson_.

45 {return poisson_;}

edm::PileUp::poisson_

bool poisson_

Definition: PileUp.h:93

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

private

Definition at line 350 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 335 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 365 of file PileUp.cc.

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

Referenced by CalculatePileup(), 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::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 164 of file PileUp.h.

References eventPrincipal_, fileNameHash_, input_, randomEngine(), SiPixelLorentzAngle_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.";
   }

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

Definition at line 237 of file PileUp.cc.

References funct::abs(), MixingInputConfig::averageNumber(), averageNumber(), averageNumber_, HDQMDatabaseProducer::config, alignCSCRings::e, 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 (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;
       }
 
     
   }

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

Definition at line 228 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);
     }
   }