edm::PileUp Class Reference

#include <PileUp.h>

Public Member Functions
double	averageNumber () 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 ()
const unsigned int &	input () const
void	input (unsigned int s)
	PileUp (ParameterSet const &pset, const std::shared_ptr< PileUpConfig > &config)
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_
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_
std::shared_ptr< RunPrincipal >	runPrincipal_
bool	sequential_
std::string	Source_type_
std::shared_ptr< StreamContext >	streamContext_
std::string	Study_type_
std::string	type_

Detailed Description

Definition at line 40 of file PileUp.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 66 of file PileUp.cc.

References 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_, mix_2012_lumiLevel_15_20_50ns_PoissonOOTPU_cfi::OOT_type, poisson_, poisson_OOT_, probFunctionDistribution_, processConfiguration_, processContext_, particleFlowRecHitECAL_cfi::producers, productRegistry_, provider_, PU_Study_, Source_type_, AlCaHLTBitMon_QueryRunRegistry::string, Study_type_, 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)) {

    // 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");
      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_ = 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 324 of file PileUp.cc.

                  {
  }

Member Function Documentation

double edm::PileUp::averageNumber ( ) const

inline

Definition at line 54 of file PileUp.h.

Referenced by reload().

{return averageNumber_;}

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

Definition at line 203 of file PileUp.cc.

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

                                                                                              {
    if (provider_.get() != nullptr) {
      lumiPrincipal_.reset(new LuminosityBlockPrincipal(productRegistry_, *processConfiguration_, nullptr, 0));
      lumiPrincipal_->setAux(lumi.luminosityBlockAuxiliary());
      lumiPrincipal_->setRunPrincipal(runPrincipal_);
      provider_->beginLuminosityBlock(*lumiPrincipal_, setup, lumi.moduleCallingContext(), *streamContext_);
    }
  }

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

Definition at line 196 of file PileUp.cc.

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

                                                                     {
    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(), *streamContext_);
    }
  }

void edm::PileUp::beginStream

(

edm::StreamID

)

Definition at line 178 of file PileUp.cc.

References eventPrincipal_, input_, processContext_, productRegistry_, provider_, and streamContext_.

                                       {
    auto iID = eventPrincipal_->streamID(); // each producer has its own workermanager, so use default streamid
    streamContext_.reset(new StreamContext(iID, processContext_.get()));
    input_->doBeginJob();
    if (provider_.get() != nullptr) {
      provider_->beginJob(*productRegistry_);
      provider_->beginStream(iID, *streamContext_);
    }
  }

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

Definition at line 351 of file PileUp.cc.

References averageNumber_, edmIntegrityCheck::d, fixed_, GetRandom(), histo_, histoDistribution_, createfilelist::int, 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_.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 );
    }
      }

    }
  }

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

inline

Definition at line 56 of file PileUp.h.

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

References Ecal2004TBTDCRanges_v1_cff::endRun, findQualityFiles::run, and GeneralSetup::setup().

                                                                          {
      input_->dropUnwantedBranches(wantedBranches);
    }

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

Definition at line 217 of file PileUp.cc.

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

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

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

Definition at line 212 of file PileUp.cc.

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

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

void edm::PileUp::endStream

(

)

Definition at line 188 of file PileUp.cc.

References input_, provider_, and streamContext_.

                          {
    if (provider_.get() != nullptr) {
      provider_->endStream(streamContext_->streamID(), *streamContext_);
      provider_->endJob();
    }
    input_->doEndJob();
  }

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

inline

Definition at line 86 of file PileUp.h.

{return inputType_;}

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

inline

Definition at line 87 of file PileUp.h.

References randomEngine, and alignCSCRings::s.

{inputType_=s;}

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 200 of file PileUp.h.

                                                                                                                                                                                 {
    //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 192 of file PileUp.h.

                                                                                                                                                                                                                {
    //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 55 of file PileUp.h.

{return poisson_;}

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

private

Definition at line 335 of file PileUp.cc.

References PoissonDistr_OOT_, and randomEngine().

Referenced by CalculatePileup().

                                                                                          {
    if(!PoissonDistr_OOT_) {
      CLHEP::HepRandomEngine& engine = *randomEngine(streamID);
      PoissonDistr_OOT_.reset(new CLHEP::RandPoisson(engine));
    }
    return PoissonDistr_OOT_;
  }

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

private

Definition at line 327 of file PileUp.cc.

References averageNumber_, PoissonDistribution_, and randomEngine().

Referenced by CalculatePileup().

                                                                                              {
    if(!PoissonDistribution_) {
      CLHEP::HepRandomEngine& engine = *randomEngine(streamID);
      PoissonDistribution_.reset(new CLHEP::RandPoissonQ(engine, averageNumber_));
    }
    return PoissonDistribution_;
  }

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

private

Definition at line 343 of file PileUp.cc.

References randomEngine_.

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

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

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 176 of file PileUp.h.

References randomEngine.

                                                                         {

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

References funct::abs(), MixingInputConfig::averageNumber(), averageNumber(), averageNumber_, MixingModuleConfig::config(), MillePedeFileConverter_cfg::e, Exception, fixed_, fixed_OOT_, MixingInputConfig::fixedOutOfTime(), edm::EventSetup::get(), histo_, histoDistribution_, mps_fire::i, inputType_, createfilelist::int, intFixed_OOT_, LogDebug, manage_OOT_, none_, MixingInputConfig::outOfTime(), poisson_, poisson_OOT_, PoissonDistribution_, probFunctionDistribution_, MixingInputConfig::probFunctionVariable(), MixingInputConfig::probValue(), MixingInputConfig::type(), type_, TrackerOfflineValidation_Dqm_cff::xmax, and TrackerOfflineValidation_Dqm_cff::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();
        if(PoissonDistribution_) {
          PoissonDistribution_.reset(new 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;
      }


  }

void edm::PileUp::setupPileUpEvent

(

const edm::EventSetup &

setup

)

Definition at line 223 of file PileUp.cc.

References eventPrincipal_, lumiPrincipal_, provider_, 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());
      provider_->setupPileUpEvent(*eventPrincipal_, setup, *streamContext_);
    }
  }

Member Data Documentation

double edm::PileUp::averageNumber_

private

Definition at line 98 of file PileUp.h.

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

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

private

Definition at line 126 of file PileUp.h.

Referenced by beginStream(), PileUp(), and setupPileUpEvent().

size_t edm::PileUp::fileNameHash_

private

Definition at line 120 of file PileUp.h.

bool edm::PileUp::fixed_

private

Definition at line 104 of file PileUp.h.

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

bool edm::PileUp::fixed_OOT_

private

Definition at line 108 of file PileUp.h.

Referenced by PileUp(), and reload().

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

private

Definition at line 100 of file PileUp.h.

Referenced by CalculatePileup(), and reload().

bool edm::PileUp::histoDistribution_

private

Definition at line 101 of file PileUp.h.

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

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

private

Definition at line 122 of file PileUp.h.

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

unsigned int edm::PileUp::inputType_

private

Definition at line 95 of file PileUp.h.

Referenced by reload().

int const edm::PileUp::intAverage_

private

Definition at line 99 of file PileUp.h.

Referenced by CalculatePileup().

int edm::PileUp::intFixed_ITPU_

private

Definition at line 115 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

int edm::PileUp::intFixed_OOT_

private

Definition at line 114 of file PileUp.h.

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

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

private

Definition at line 127 of file PileUp.h.

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

bool edm::PileUp::manage_OOT_

private

Definition at line 106 of file PileUp.h.

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

int edm::PileUp::maxBunch_cosmics_

private

Definition at line 118 of file PileUp.h.

Referenced by PileUp().

int edm::PileUp::minBunch_cosmics_

private

Definition at line 117 of file PileUp.h.

Referenced by PileUp().

bool edm::PileUp::none_

private

Definition at line 105 of file PileUp.h.

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

bool edm::PileUp::playback_

private

Definition at line 139 of file PileUp.h.

bool edm::PileUp::poisson_

private

Definition at line 103 of file PileUp.h.

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

bool edm::PileUp::poisson_OOT_

private

Definition at line 107 of file PileUp.h.

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

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

private

Definition at line 131 of file PileUp.h.

Referenced by poissonDistr_OOT().

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

private

Definition at line 130 of file PileUp.h.

Referenced by poissonDistribution(), and reload().

bool edm::PileUp::probFunctionDistribution_

private

Definition at line 102 of file PileUp.h.

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

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

private

Definition at line 123 of file PileUp.h.

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

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

private

Definition at line 124 of file PileUp.h.

Referenced by beginStream(), and PileUp().

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

private

Definition at line 121 of file PileUp.h.

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

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

private

Definition at line 129 of file PileUp.h.

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

bool edm::PileUp::PU_Study_

private

Definition at line 110 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

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

private

Definition at line 132 of file PileUp.h.

Referenced by randomEngine().

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

private

Definition at line 128 of file PileUp.h.

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

bool edm::PileUp::sequential_

private

Definition at line 142 of file PileUp.h.

std::string edm::PileUp::Source_type_

private

Definition at line 97 of file PileUp.h.

Referenced by PileUp().

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

private

Definition at line 125 of file PileUp.h.

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

std::string edm::PileUp::Study_type_

private

Definition at line 111 of file PileUp.h.

Referenced by CalculatePileup(), and PileUp().

std::string edm::PileUp::type_

private

Definition at line 96 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(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::moduleLabel_(), Modules.ESProducer::moduleLabel_(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), Modules.ESPrefer::nameInProcessDesc_(), PileUp(), and reload().