edm::PileUp Class Reference

#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 ()
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, 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_
boost::shared_ptr < LuminosityBlockPrincipal >	lumiPrincipal_
bool	manage_OOT_
bool	none_
bool	playback_
bool	poisson_
bool	poisson_OOT_
TFile *	probFileHisto
bool	probFunctionDistribution_
boost::shared_ptr < ProcessConfiguration >	processConfiguration_
boost::shared_ptr < ProductRegistry >	productRegistry_
std::unique_ptr < SecondaryEventProvider >	provider_
bool	PU_Study_
std::vector < CLHEP::HepRandomEngine * >	randomEngines_
boost::shared_ptr< RunPrincipal >	runPrincipal_
bool	samelumi_
int	seed_
bool	sequential_
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 33 of file PileUp.h.

Constructor & Destructor Documentation

edm::PileUp::PileUp ( ParameterSet const &  pset, 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_, edm::RandomNumberGenerator::mySeed(), none_, poisson_, poisson_OOT_, probFunctionDistribution_, processConfiguration_, productRegistry_, provider_, PU_Study_, seed_, AlCaHLTBitMon_QueryRunRegistry::string, Study_type_, and type_.

                                                                                                        :
    type_(pset.getParameter<std::string>("type")),
    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_,
                                                                   boost::shared_ptr<BranchIDListHelper>(new BranchIDListHelper),
                                                                   boost::shared_ptr<ActivityRegistry>(new ActivityRegistry),
                                                                   -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(),
                                       *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. " ;
    }
    }
    
  }

edm::PileUp::~PileUp

(

)

Definition at line 310 of file PileUp.cc.

                  {
  }

Member Function Documentation

double edm::PileUp::averageNumber ( ) const

inline

Definition at line 44 of file PileUp.h.

References averageNumber_.

Referenced by reload().

{return averageNumber_;}

void edm::PileUp::beginJob

(

void

)

Definition at line 165 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 186 of file PileUp.cc.

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

                                                                                              {
    if (provider_.get() != nullptr) {
      boost::shared_ptr<LuminosityBlockAuxiliary> aux(new 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 179 of file PileUp.cc.

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

                                                                     {
    if (provider_.get() != nullptr) {
      boost::shared_ptr<RunAuxiliary> aux(new 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 359 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 ( )

inline

Definition at line 46 of file PileUp.h.

References averageNumber_, and none_.

{return none_ ? false :  averageNumber_>0.;}

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

inline

Definition at line 47 of file PileUp.h.

References input_.

                                                                          {
      input_->dropUnwantedBranches(wantedBranches);
    }

void edm::PileUp::endJob

(

void

)

Definition at line 172 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 200 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 195 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 69 of file PileUp.h.

References inputType_.

{return inputType_;}

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

inline

Definition at line 70 of file PileUp.h.

References inputType_, and alignCSCRings::s.

{inputType_=s;}

template<typename T >

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

Definition at line 199 of file PileUp.h.

References eventPrincipal_, and input_.

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

bool edm::PileUp::poisson ( ) const

inline

Definition at line 45 of file PileUp.h.

References poisson_.

{return poisson_;}

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

private

Definition at line 328 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 313 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 343 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 157 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_) {
        // boost::bind creates a functor from recordEventForPlayback
        // so that recordEventForPlayback can insert itself before
        // the original eventOperator.

        read = input_->loopSequential(*eventPrincipal_, pileEventCnt, recorder);
        //boost::bind(&PileUp::recordEventForPlayback<T>,
        //                    boost::ref(*this), _1, boost::ref(ids),
        //                             boost::ref(eventOperator))
        //  );
          
      } else  {
        read = input_->loopRandom(*eventPrincipal_, pileEventCnt, recorder, randomEngine(streamID));
        //               boost::bind(&PileUp::recordEventForPlayback<T>,
        //                             boost::ref(*this), _1, boost::ref(ids),
        //                             boost::ref(eventOperator))
        //                 );
      }
    }
    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 215 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 206 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);
    }
  }

Member Data Documentation

double edm::PileUp::averageNumber_

private

Definition at line 80 of file PileUp.h.

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

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

private

Definition at line 101 of file PileUp.h.

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

bool edm::PileUp::fixed_

private

Definition at line 86 of file PileUp.h.

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

bool edm::PileUp::fixed_OOT_

private

Definition at line 90 of file PileUp.h.

Referenced by PileUp(), and reload().

TH1F* edm::PileUp::h1f

private

Definition at line 109 of file PileUp.h.

TH1F* edm::PileUp::histo_

private

Definition at line 82 of file PileUp.h.

Referenced by CalculatePileup(), and reload().

bool edm::PileUp::histoDistribution_

private

Definition at line 83 of file PileUp.h.

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

TH1F* edm::PileUp::hprobFunction

private

Definition at line 110 of file PileUp.h.

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

private

Definition at line 99 of file PileUp.h.

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

unsigned int edm::PileUp::inputType_

private

Definition at line 78 of file PileUp.h.

Referenced by input(), and reload().

int const edm::PileUp::intAverage_

private

Definition at line 81 of file PileUp.h.

Referenced by CalculatePileup().

int edm::PileUp::intFixed_ITPU_

private

Definition at line 96 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

int edm::PileUp::intFixed_OOT_

private

Definition at line 95 of file PileUp.h.

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

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

private

Definition at line 102 of file PileUp.h.

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

bool edm::PileUp::manage_OOT_

private

Definition at line 88 of file PileUp.h.

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

bool edm::PileUp::none_

private

Definition at line 87 of file PileUp.h.

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

bool edm::PileUp::playback_

private

Definition at line 114 of file PileUp.h.

bool edm::PileUp::poisson_

private

Definition at line 85 of file PileUp.h.

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

bool edm::PileUp::poisson_OOT_

private

Definition at line 89 of file PileUp.h.

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

TFile* edm::PileUp::probFileHisto

private

Definition at line 111 of file PileUp.h.

bool edm::PileUp::probFunctionDistribution_

private

Definition at line 84 of file PileUp.h.

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

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

private

Definition at line 100 of file PileUp.h.

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

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

private

Definition at line 98 of file PileUp.h.

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

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

private

Definition at line 104 of file PileUp.h.

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

bool edm::PileUp::PU_Study_

private

Definition at line 92 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

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

private

Definition at line 107 of file PileUp.h.

Referenced by randomEngine().

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

private

Definition at line 103 of file PileUp.h.

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

bool edm::PileUp::samelumi_

private

Definition at line 120 of file PileUp.h.

Referenced by readPileUp().

int edm::PileUp::seed_

private

Definition at line 123 of file PileUp.h.

Referenced by PileUp().

bool edm::PileUp::sequential_

private

Definition at line 117 of file PileUp.h.

Referenced by readPileUp().

std::string edm::PileUp::Study_type_

private

Definition at line 93 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

std::string edm::PileUp::type_

private

Definition at line 79 of file PileUp.h.

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

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

private

Definition at line 106 of file PileUp.h.

Referenced by poissonDistr_OOT().

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

private

Definition at line 105 of file PileUp.h.

Referenced by poissonDistribution(), and reload().