CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Private Member Functions | Private Attributes
edm::MixingModule Class Reference

#include <MixingModule.h>

Inheritance diagram for edm::MixingModule:
edm::BMixingModule edm::stream::EDProducer< GlobalCache< MixingCache::Config > >

Public Types

typedef std::vector< DigiAccumulatorMixMod * > Accumulators
 
- Public Types inherited from edm::stream::EDProducer< GlobalCache< MixingCache::Config > >
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 

Public Member Functions

void accumulateEvent (Event const &event, EventSetup const &setup)
 
void accumulateEvent (PileUpEventPrincipal const &event, EventSetup const &setup, edm::StreamID const &)
 
virtual void beginJob ()
 
void beginLuminosityBlock (LuminosityBlock const &l1, EventSetup const &c) override
 
void beginRun (Run const &r1, EventSetup const &c) override
 
void endLuminosityBlock (LuminosityBlock const &l1, EventSetup const &c) override
 
void endRun (Run const &r1, EventSetup const &c) override
 
void finalizeEvent (Event &event, EventSetup const &setup) override
 
void initializeEvent (Event const &event, EventSetup const &setup) override
 
 MixingModule (const edm::ParameterSet &ps, MixingCache::Config const *globalConf)
 
void reload (const edm::EventSetup &) override
 
 ~MixingModule () override
 
- Public Member Functions inherited from edm::BMixingModule
virtual void addPileups (const int bcr, EventPrincipal *ep, unsigned int eventId, unsigned int worker, const edm::EventSetup &c)
 
double averageNumber () const
 
void beginLuminosityBlock (const edm::LuminosityBlock &l, const edm::EventSetup &setup) override
 
void beginRun (const edm::Run &r, const edm::EventSetup &setup) override
 
 BMixingModule (const edm::ParameterSet &ps, MixingCache::Config const *globalConf)
 
void endLuminosityBlock (const edm::LuminosityBlock &l, const edm::EventSetup &setup) override
 
void endRun (const edm::Run &r, const edm::EventSetup &setup) override
 
bool poisson () const
 
void produce (edm::Event &e1, const edm::EventSetup &c) override
 
virtual void setBcrOffset ()
 
virtual void setSourceOffset (const unsigned int s)
 
 ~BMixingModule () override
 
- Public Member Functions inherited from edm::stream::EDProducer< GlobalCache< MixingCache::Config > >
 EDProducer ()=default
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

Private Member Functions

void addSignals (const edm::Event &e, const edm::EventSetup &es) override
 
virtual void branchesActivate (const std::string &friendlyName, const std::string &subdet, InputTag &tag, std::string &label)
 
void checkSignal (const edm::Event &e) override
 
void createDigiAccumulators (const edm::ParameterSet &mixingPSet, edm::ConsumesCollector &iC)
 
void createnewEDProduct () override
 
void doPileUp (edm::Event &e, const edm::EventSetup &es) override
 
bool pileAllWorkers (EventPrincipal const &ep, ModuleCallingContext const *, int bcr, int id, int &offset, const edm::EventSetup &setup, edm::StreamID const &)
 
void put (edm::Event &e, const edm::EventSetup &es) override
 

Private Attributes

std::vector< AdjusterBase * > adjusters_
 
std::vector< AdjusterBase * > adjustersObjects_
 
Accumulators digiAccumulators_
 
InputTag inputTagPlayback_
 
bool mixProdStep1_
 
bool mixProdStep2_
 
CrossingFramePlaybackInfoNew * playbackInfo_
 
bool skipSignal_
 
bool useCurrentProcessOnly_
 
std::vector< std::string > wantedBranches_
 
std::vector< MixingWorkerBase * > workers_
 
std::vector< MixingWorkerBase * > workersObjects_
 
bool wrapLongTimes_
 

Additional Inherited Members

- Static Public Member Functions inherited from edm::BMixingModule
static void globalEndJob (MixingCache::Config *)
 
static std::unique_ptr< MixingCache::Config > initializeGlobalCache (edm::ParameterSet const &)
 
- Protected Member Functions inherited from edm::BMixingModule
void beginStream (edm::StreamID) override
 
void dropUnwantedBranches (std::vector< std::string > const &wantedBranches)
 
void endStream () override
 
void setupPileUpEvent (const edm::EventSetup &setup)
 
void update (edm::EventSetup const &)
 
- Protected Attributes inherited from edm::BMixingModule
int bunchSpace_
 
bool checktof_
 
bool doit_ [4]
 
unsigned int eventId_
 
std::vector< std::shared_ptr< PileUp > > inputSources_
 
int maxBunch_
 
int minBunch_
 
const bool mixProdStep1_
 
const bool mixProdStep2_
 
edm::ESWatcher< MixingRcd > parameterWatcher_
 
bool playback_
 
bool readDB_
 
std::vector< float > TrueNumInteractions_
 
int vertexOffset_
 
- Static Protected Attributes inherited from edm::BMixingModule
const static unsigned int maxNbSources_ = 4
 

Detailed Description

Definition at line 49 of file MixingModule.h.

Member Typedef Documentation

◆ Accumulators

typedef std::vector<DigiAccumulatorMixMod*> edm::MixingModule::Accumulators

Definition at line 51 of file MixingModule.h.

Constructor & Destructor Documentation

◆ MixingModule()

MixingModule::MixingModule ( const edm::ParameterSet &  ps,
MixingCache::Config const *  globalConf 
)
explicit

standard constructor

Definition at line 41 of file MixingModule.cc.

42  : BMixingModule(ps_mix, globalConf),
43  inputTagPlayback_(),
44  mixProdStep2_(ps_mix.getParameter<bool>("mixProdStep2")),
45  mixProdStep1_(ps_mix.getParameter<bool>("mixProdStep1")),
46  digiAccumulators_() {
47  if (!mixProdStep1_ && !mixProdStep2_)
48  LogInfo("MixingModule") << " The MixingModule was run in the Standard mode.";
49  if (mixProdStep1_)
50  LogInfo("MixingModule") << " The MixingModule was run in the Step1 mode. It produces a mixed secondary source.";
51  if (mixProdStep2_)
52  LogInfo("MixingModule") << " The MixingModule was run in the Step2 mode. It uses a mixed secondary source.";
53 
54  useCurrentProcessOnly_ = false;
55  if (ps_mix.exists("useCurrentProcessOnly")) {
56  useCurrentProcessOnly_ = ps_mix.getParameter<bool>("useCurrentProcessOnly");
57  LogInfo("MixingModule") << " using given Parameter 'useCurrentProcessOnly' =" << useCurrentProcessOnly_;
58  }
59  std::string labelPlayback;
60  if (ps_mix.exists("LabelPlayback")) {
61  labelPlayback = ps_mix.getParameter<std::string>("LabelPlayback");
62  }
63  if (labelPlayback.empty()) {
64  labelPlayback = ps_mix.getParameter<std::string>("@module_label");
65  }
66  if (playback_) {
67  inputTagPlayback_ = InputTag(labelPlayback, "", edm::InputTag::kSkipCurrentProcess);
68  consumes<CrossingFramePlaybackInfoNew>(inputTagPlayback_);
69  }
70  wrapLongTimes_ = false;
71  if (ps_mix.exists("WrapLongTimes")) {
72  wrapLongTimes_ = ps_mix.getParameter<bool>("WrapLongTimes");
73  }
74 
75  skipSignal_ = false;
76  if (ps_mix.exists("skipSignal")) {
77  skipSignal_ = ps_mix.getParameter<bool>("skipSignal");
78  }
79 
80  ParameterSet ps = ps_mix.getParameter<ParameterSet>("mixObjects");
81  std::vector<std::string> names = ps.getParameterNames();
82  for (std::vector<std::string>::iterator it = names.begin(); it != names.end(); ++it) {
83  ParameterSet pset = ps.getParameter<ParameterSet>((*it));
84  if (!pset.exists("type"))
85  continue; //to allow replacement by empty pset
86  std::string object = pset.getParameter<std::string>("type");
87  std::vector<InputTag> tags = pset.getParameter<std::vector<InputTag> >("input");
88 
89  //if (!mixProdStep2_) {
90 
91  InputTag tagCF = InputTag();
92  std::string labelCF = " ";
93 
94  if (object == "SimTrack") {
95  InputTag tag;
96  if (!tags.empty())
97  tag = tags[0];
98  std::string label;
99 
100  branchesActivate(TypeID(typeid(std::vector<SimTrack>)).friendlyClassName(), std::string(""), tag, label);
101  adjustersObjects_.push_back(new Adjuster<std::vector<SimTrack> >(tag, consumesCollector(), wrapLongTimes_));
102  bool makeCrossingFrame = pset.getUntrackedParameter<bool>("makeCrossingFrame", false);
103  if (makeCrossingFrame) {
104  workersObjects_.push_back(new MixingWorker<SimTrack>(
105  minBunch_, maxBunch_, bunchSpace_, std::string(""), label, labelCF, maxNbSources_, tag, tagCF));
106  produces<CrossingFrame<SimTrack> >(label);
107  }
108  consumes<std::vector<SimTrack> >(tag);
109 
110  LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
111  << label;
112  // std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
113 
114  } else if (object == "RecoTrack") {
115  InputTag tag;
116  if (!tags.empty())
117  tag = tags[0];
118  std::string label;
119 
120  branchesActivate(TypeID(typeid(std::vector<reco::Track>)).friendlyClassName(), std::string(""), tag, label);
121  branchesActivate(
122  TypeID(typeid(std::vector<reco::TrackExtra>)).friendlyClassName(), std::string(""), tag, label);
123  branchesActivate(
124  TypeID(typeid(edm::OwnVector<TrackingRecHit, edm::ClonePolicy<TrackingRecHit> >)).friendlyClassName(),
125  std::string(""),
126  tag,
127  label);
128  adjustersObjects_.push_back(
129  new Adjuster<edm::OwnVector<TrackingRecHit> >(tag, consumesCollector(), wrapLongTimes_));
130  // note: no crossing frame is foreseen to be used for this object type
131 
132  LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
133  << label;
134  //std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
135 
136  } else if (object == "SimVertex") {
137  InputTag tag;
138  if (!tags.empty())
139  tag = tags[0];
140  std::string label;
141 
142  branchesActivate(TypeID(typeid(std::vector<SimVertex>)).friendlyClassName(), std::string(""), tag, label);
143  adjustersObjects_.push_back(new Adjuster<std::vector<SimVertex> >(tag, consumesCollector(), wrapLongTimes_));
144  bool makeCrossingFrame = pset.getUntrackedParameter<bool>("makeCrossingFrame", false);
145  if (makeCrossingFrame) {
146  workersObjects_.push_back(new MixingWorker<SimVertex>(
147  minBunch_, maxBunch_, bunchSpace_, std::string(""), label, labelCF, maxNbSources_, tag, tagCF));
148  produces<CrossingFrame<SimVertex> >(label);
149  }
150  consumes<std::vector<SimVertex> >(tag);
151 
152  LogInfo("MixingModule") << "Will mix " << object << "s with InputTag " << tag.encode() << ", label will be "
153  << label;
154  // std::cout <<"Will mix "<<object<<"s with InputTag "<<tag.encode()<<", label will be "<<label<<std::endl;
155 
156  } else if (object == "HepMCProduct") {
157  InputTag tag;
158  if (!tags.empty())
159  tag = tags[0];
160  std::string label;
161 
162  branchesActivate(TypeID(typeid(HepMCProduct)).friendlyClassName(), std::string(""), tag, label);
163  bool makeCrossingFrame = pset.getUntrackedParameter<bool>("makeCrossingFrame", false);
164  if (makeCrossingFrame) {
165  workersObjects_.push_back(new MixingWorker<HepMCProduct>(
166  minBunch_, maxBunch_, bunchSpace_, std::string(""), label, labelCF, maxNbSources_, tag, tagCF, tags));
167  produces<CrossingFrame<HepMCProduct> >(label);
168  }
169  consumes<HepMCProduct>(tag);
170 
171  LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
172  << label;
173  // std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
174  for (size_t i = 1; i < tags.size(); ++i) {
175  InputTag fallbackTag = tags[i];
176  std::string fallbackLabel;
177  branchesActivate(
178  TypeID(typeid(HepMCProduct)).friendlyClassName(), std::string(""), fallbackTag, fallbackLabel);
179  mayConsume<HepMCProduct>(fallbackTag);
180  }
181 
182  } else if (object == "PCaloHit") {
183  std::vector<std::string> subdets = pset.getParameter<std::vector<std::string> >("subdets");
184  std::vector<std::string> crossingFrames =
185  pset.getUntrackedParameter<std::vector<std::string> >("crossingFrames", std::vector<std::string>());
186  sort_all(crossingFrames);
187  for (unsigned int ii = 0; ii < subdets.size(); ++ii) {
188  InputTag tag;
189  if (tags.size() == 1)
190  tag = tags[0];
191  else if (tags.size() > 1)
192  tag = tags[ii];
193  std::string label;
194 
195  branchesActivate(TypeID(typeid(std::vector<PCaloHit>)).friendlyClassName(), subdets[ii], tag, label);
196  adjustersObjects_.push_back(new Adjuster<std::vector<PCaloHit> >(tag, consumesCollector(), wrapLongTimes_));
197  if (binary_search_all(crossingFrames, tag.instance())) {
198  workersObjects_.push_back(new MixingWorker<PCaloHit>(
199  minBunch_, maxBunch_, bunchSpace_, subdets[ii], label, labelCF, maxNbSources_, tag, tagCF));
200  produces<CrossingFrame<PCaloHit> >(label);
201  consumes<std::vector<PCaloHit> >(tag);
202  }
203 
204  LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
205  << label;
206  // std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
207  }
208 
209  } else if (object == "PSimHit") {
210  std::vector<std::string> subdets = pset.getParameter<std::vector<std::string> >("subdets");
211  std::vector<std::string> crossingFrames =
212  pset.getUntrackedParameter<std::vector<std::string> >("crossingFrames", std::vector<std::string>());
213  sort_all(crossingFrames);
214  std::vector<std::string> pcrossingFrames =
215  pset.getUntrackedParameter<std::vector<std::string> >("pcrossingFrames", std::vector<std::string>());
216  sort_all(pcrossingFrames);
217  for (unsigned int ii = 0; ii < subdets.size(); ++ii) {
218  InputTag tag;
219  if (tags.size() == 1)
220  tag = tags[0];
221  else if (tags.size() > 1)
222  tag = tags[ii];
223  std::string label;
224 
225  branchesActivate(TypeID(typeid(std::vector<PSimHit>)).friendlyClassName(), subdets[ii], tag, label);
226  adjustersObjects_.push_back(new Adjuster<std::vector<PSimHit> >(tag, consumesCollector(), wrapLongTimes_));
227  if (binary_search_all(crossingFrames, tag.instance())) {
228  bool makePCrossingFrame = binary_search_all(pcrossingFrames, tag.instance());
229  workersObjects_.push_back(new MixingWorker<PSimHit>(minBunch_,
230  maxBunch_,
231  bunchSpace_,
232  subdets[ii],
233  label,
234  labelCF,
235  maxNbSources_,
236  tag,
237  tagCF,
238  makePCrossingFrame));
239  produces<CrossingFrame<PSimHit> >(label);
240  if (makePCrossingFrame) {
241  produces<PCrossingFrame<PSimHit> >(label);
242  }
243  consumes<std::vector<PSimHit> >(tag);
244  }
245 
246  LogInfo("MixingModule") << "Will mix " << object << "s with InputTag= " << tag.encode() << ", label will be "
247  << label;
248  // std::cout <<"Will mix "<<object<<"s with InputTag= "<<tag.encode()<<", label will be "<<label<<std::endl;
249  }
250  } else {
251  LogWarning("MixingModule")
252  << "You have asked to mix an unknown type of object(" << object
253  << ").\n If you want to include it in mixing, please contact the authors of the MixingModule!";
254  }
255  //} //if for mixProdStep2
256  } //while over the mixObjects parameters
257 
258  sort_all(wantedBranches_);
259  for (unsigned int branch = 0; branch < wantedBranches_.size(); ++branch)
260  LogDebug("MixingModule") << "Will keep branch " << wantedBranches_[branch] << " for mixing ";
261 
262  dropUnwantedBranches(wantedBranches_);
263 
264  produces<PileupMixingContent>();
265 
266  produces<CrossingFramePlaybackInfoNew>();
267 
268  edm::ConsumesCollector iC(consumesCollector());
269  // Create and configure digitizers
270  createDigiAccumulators(ps_mix, iC);
271  }

References adjustersObjects_, edm::binary_search_all(), MicroEventContent_cff::branch, branchesActivate(), edm::BMixingModule::bunchSpace_, createDigiAccumulators(), DigiHGCalTB160_cff::crossingFrames, edm::BMixingModule::dropUnwantedBranches(), edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), mps_fire::i, cuy::ii, HLT_FULL_cff::InputTag, inputTagPlayback_, edm::InputTag::kSkipCurrentProcess, label, LogDebug, DigiHGCalTB160_cff::makeCrossingFrame, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, mixProdStep1_, mixProdStep2_, names, mixObjects_cfi::pcrossingFrames, edm::BMixingModule::playback_, muonDTDigis_cfi::pset, skipSignal_, edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, fireworks::subdets, GlobalPosition_Frontier_DevDB_cff::tag, triggerMatcherToHLTDebug_cfi::tags, useCurrentProcessOnly_, wantedBranches_, workersObjects_, and wrapLongTimes_.

◆ ~MixingModule()

MixingModule::~MixingModule ( )
override

Default destructor

Definition at line 344 of file MixingModule.cc.

344  {
345  for (auto& worker : workersObjects_) {
346  delete worker;
347  }
348 
349  for (auto& adjuster : adjustersObjects_) {
350  delete adjuster;
351  }
352 
353  for (auto& digiAccumulator : digiAccumulators_) {
354  delete digiAccumulator;
355  }
356  }

References adjustersObjects_, digiAccumulators_, and workersObjects_.

Member Function Documentation

◆ accumulateEvent() [1/2]

void MixingModule::accumulateEvent ( edm::Event const &  event,
edm::EventSetup const &  setup 
)

Definition at line 678 of file MixingModule.cc.

678  {
679  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
680  accItr != accEnd;
681  ++accItr) {
682  (*accItr)->accumulate(event, setup);
683  }
684  }

References digiAccumulators_, and singleTopDQM_cfi::setup.

Referenced by addSignals(), and pileAllWorkers().

◆ accumulateEvent() [2/2]

void MixingModule::accumulateEvent ( PileUpEventPrincipal const &  event,
edm::EventSetup const &  setup,
edm::StreamID const &  streamID 
)

Definition at line 686 of file MixingModule.cc.

688  {
689  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
690  accItr != accEnd;
691  ++accItr) {
692  (*accItr)->accumulate(event, setup, streamID);
693  }
694  }

References digiAccumulators_, and singleTopDQM_cfi::setup.

◆ addSignals()

void MixingModule::addSignals ( const edm::Event &  e,
const edm::EventSetup &  es 
)
overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 358 of file MixingModule.cc.

358  {
359  if (skipSignal_) {
360  return;
361  }
362 
363  LogDebug("MixingModule") << "===============> adding signals for " << e.id();
364 
365  accumulateEvent(e, setup);
366  // fill in signal part of CrossingFrame
367  for (unsigned int ii = 0; ii < workers_.size(); ++ii) {
368  workers_[ii]->addSignals(e);
369  }
370  }

References accumulateEvent(), MillePedeFileConverter_cfg::e, cuy::ii, LogDebug, singleTopDQM_cfi::setup, skipSignal_, and workers_.

◆ beginJob()

virtual void edm::MixingModule::beginJob ( void  )
inlinevirtual

Definition at line 59 of file MixingModule.h.

59 {}

◆ beginLuminosityBlock()

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

Definition at line 652 of file MixingModule.cc.

652  {
653  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
654  accItr != accEnd;
655  ++accItr) {
656  (*accItr)->beginLuminosityBlock(lumi, setup);
657  }
658  BMixingModule::beginLuminosityBlock(lumi, setup);
659  }

References edm::BMixingModule::beginLuminosityBlock(), digiAccumulators_, and singleTopDQM_cfi::setup.

◆ beginRun()

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

Definition at line 634 of file MixingModule.cc.

634  {
635  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
636  accItr != accEnd;
637  ++accItr) {
638  (*accItr)->beginRun(run, setup);
639  }
640  BMixingModule::beginRun(run, setup);
641  }

References edm::BMixingModule::beginRun(), digiAccumulators_, writedatasetfile::run, and singleTopDQM_cfi::setup.

◆ branchesActivate()

void MixingModule::branchesActivate ( const std::string &  friendlyName,
const std::string &  subdet,
InputTag &  tag,
std::string &  label 
)
privatevirtual

Definition at line 303 of file MixingModule.cc.

306  {
307  label = tag.label() + tag.instance();
308  wantedBranches_.push_back(friendlyName + '_' + tag.label() + '_' + tag.instance());
309 
310  //if useCurrentProcessOnly, we have to change the input tag
311  if (useCurrentProcessOnly_) {
312  const std::string processName = edm::Service<edm::service::TriggerNamesService>()->getProcessName();
313  tag = InputTag(tag.label(), tag.instance(), processName);
314  }
315  }

References edm::friendlyname::friendlyName(), HLT_FULL_cff::InputTag, label, SimL1EmulatorRepack_CalouGT_cff::processName, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, useCurrentProcessOnly_, and wantedBranches_.

Referenced by MixingModule().

◆ checkSignal()

void MixingModule::checkSignal ( const edm::Event &  e)
overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 317 of file MixingModule.cc.

317  {
318  if (adjusters_.empty()) {
319  for (auto const& adjuster : adjustersObjects_) {
320  if (skipSignal_ or adjuster->checkSignal(e)) {
321  adjusters_.push_back(adjuster);
322  }
323  }
324  }
325  if (workers_.empty()) {
326  for (auto const& worker : workersObjects_) {
327  if (skipSignal_ or worker->checkSignal(e)) {
328  workers_.push_back(worker);
329  }
330  }
331  }
332  }

References adjusters_, adjustersObjects_, MillePedeFileConverter_cfg::e, or, skipSignal_, workers_, and workersObjects_.

◆ createDigiAccumulators()

void MixingModule::createDigiAccumulators ( const edm::ParameterSet &  mixingPSet,
edm::ConsumesCollector &  iC 
)
private

Definition at line 273 of file MixingModule.cc.

273  {
274  ParameterSet const& digiPSet = mixingPSet.getParameterSet("digitizers");
275  std::vector<std::string> digiNames = digiPSet.getParameterNames();
276  for (auto const& digiName : digiNames) {
277  ParameterSet const& pset = digiPSet.getParameterSet(digiName);
278  if (pset.existsAs<edm::InputTag>("HepMCProductLabel")) {
279  consumes<HepMCProduct>(pset.getParameter<edm::InputTag>("HepMCProductLabel"));
280  }
281  std::unique_ptr<DigiAccumulatorMixMod> accumulator = std::unique_ptr<DigiAccumulatorMixMod>(
282  DigiAccumulatorMixModFactory::get()->makeDigiAccumulator(pset, producesCollector(), iC));
283  // Create appropriate DigiAccumulator
284  if (accumulator.get() != nullptr) {
285  digiAccumulators_.push_back(accumulator.release());
286  }
287  }
288  }

References mixOne_premix_on_sim_cfi::accumulator, digiAccumulators_, edm::DigiAccumulatorMixModFactory::get(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getParameterSet(), and muonDTDigis_cfi::pset.

Referenced by MixingModule().

◆ createnewEDProduct()

void MixingModule::createnewEDProduct ( )
overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 334 of file MixingModule.cc.

334  {
335  //create playback info
336  playbackInfo_ = new CrossingFramePlaybackInfoNew(minBunch_, maxBunch_, maxNbSources_);
337  //and CrossingFrames
338  for (unsigned int ii = 0; ii < workers_.size(); ++ii) {
339  workers_[ii]->createnewEDProduct();
340  }
341  }

References cuy::ii, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, playbackInfo_, and workers_.

◆ doPileUp()

void MixingModule::doPileUp ( edm::Event &  e,
const edm::EventSetup &  es 
)
overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 401 of file MixingModule.cc.

401  {
402  using namespace std::placeholders;
403 
404  // Don't allocate because PileUp will do it for us.
405  std::vector<edm::SecondaryEventIDAndFileInfo> recordEventID;
406  std::vector<size_t> sizes;
407  sizes.reserve(maxNbSources_ * (maxBunch_ + 1 - minBunch_));
408  size_t playbackCounter = 0U;
409  edm::Handle<CrossingFramePlaybackInfoNew> playbackInfo_H;
410  edm::Handle<CrossingFramePlaybackInfoExtended> oldFormatPlaybackInfo_H;
411  bool oldFormatPlayback = false;
412  if (playback_) {
413  bool got = e.getByLabel(inputTagPlayback_, playbackInfo_H);
414  if (!got) {
415  bool gotOld = e.getByLabel(inputTagPlayback_, oldFormatPlaybackInfo_H);
416  if (!gotOld) {
417  throw cms::Exception("MixingProductNotFound")
418  << " No "
419  "CrossingFramePlaybackInfoNew on the input file, but playback "
420  "option set!!!!! Please change the input file if you really want "
421  "playback!!!!!!"
422  << std::endl;
423  }
424  oldFormatPlayback = true;
425  }
426  }
427 
428  // source[0] is "real" pileup. Check to see that this is what we are doing.
429 
430  std::vector<int> PileupList;
431  PileupList.clear();
432  TrueNumInteractions_.clear();
433 
434  std::shared_ptr<PileUp> source0 = inputSources_[0];
435 
436  if ((source0 && source0->doPileUp(0)) && !playback_) {
437  // if((!inputSources_[0] || !inputSources_[0]->doPileUp()) && !playback_ )
438 
439  // Pre-calculate all pileup distributions before we go fishing for events
440 
441  source0->CalculatePileup(minBunch_, maxBunch_, PileupList, TrueNumInteractions_, e.streamID());
442  }
443 
444  // pre-populate Pileup information
445  // necessary for luminosity-dependent effects during hit accumulation
446 
447  std::vector<int> numInteractionList;
448  std::vector<int> bunchCrossingList;
449  std::vector<float> TrueInteractionList;
450  std::vector<edm::EventID> eventInfoList; // will be empty if we pre-populate, but it's not used in digitizers
451 
452  if (!playback_) {
453  //Makin' a list: Basically, we don't care about the "other" sources at this point.
454  for (int bunchCrossing = minBunch_; bunchCrossing <= maxBunch_; ++bunchCrossing) {
455  bunchCrossingList.push_back(bunchCrossing);
456  if (!inputSources_[0] || !inputSources_[0]->doPileUp(0)) {
457  numInteractionList.push_back(0);
458  TrueInteractionList.push_back(0);
459  } else {
460  numInteractionList.push_back(PileupList[bunchCrossing - minBunch_]);
461  TrueInteractionList.push_back((TrueNumInteractions_)[bunchCrossing - minBunch_]);
462  }
463  }
464  } else { // have to read PU information from playback info
465  for (int bunchIdx = minBunch_; bunchIdx <= maxBunch_; ++bunchIdx) {
466  bunchCrossingList.push_back(bunchIdx);
467  for (size_t readSrcIdx = 0; readSrcIdx < maxNbSources_; ++readSrcIdx) {
468  if (oldFormatPlayback) {
469  std::vector<edm::EventID> const& playEventID =
470  oldFormatPlaybackInfo_H->getStartEventId(readSrcIdx, bunchIdx);
471  size_t numberOfEvents = playEventID.size();
472  if (readSrcIdx == 0) {
473  PileupList.push_back(numberOfEvents);
474  TrueNumInteractions_.push_back(numberOfEvents);
475  numInteractionList.push_back(numberOfEvents);
476  TrueInteractionList.push_back(numberOfEvents);
477  }
478  } else {
479  size_t numberOfEvents = playbackInfo_H->getNumberOfEvents(bunchIdx, readSrcIdx);
480  if (readSrcIdx == 0) {
481  PileupList.push_back(numberOfEvents);
482  TrueNumInteractions_.push_back(numberOfEvents);
483  numInteractionList.push_back(numberOfEvents);
484  TrueInteractionList.push_back(numberOfEvents);
485  }
486  }
487  }
488  }
489  }
490 
491  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
492  accItr != accEnd;
493  ++accItr) {
494  (*accItr)->StorePileupInformation(
495  bunchCrossingList, numInteractionList, TrueInteractionList, eventInfoList, bunchSpace_);
496  }
497 
498  // for (int bunchIdx = minBunch_; bunchIdx <= maxBunch_; ++bunchIdx) {
499  // std::cout << " bunch ID, Pileup, True " << bunchIdx << " " << PileupList[bunchIdx-minBunch_] << " " << TrueNumInteractions_[bunchIdx-minBunch_] << std::endl;
500  //}
501 
502  for (int bunchIdx = minBunch_; bunchIdx <= maxBunch_; ++bunchIdx) {
503  for (size_t setBcrIdx = 0; setBcrIdx < workers_.size(); ++setBcrIdx) {
504  workers_[setBcrIdx]->setBcrOffset();
505  }
506  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
507  accItr != accEnd;
508  ++accItr) {
509  (*accItr)->initializeBunchCrossing(e, setup, bunchIdx);
510  }
511 
512  for (size_t readSrcIdx = 0; readSrcIdx < maxNbSources_; ++readSrcIdx) {
513  std::shared_ptr<PileUp> source = inputSources_[readSrcIdx]; // this looks like we create
514  // new PileUp objects for each
515  // source for each event?
516  // Why?
517  for (size_t setSrcIdx = 0; setSrcIdx < workers_.size(); ++setSrcIdx) {
518  workers_[setSrcIdx]->setSourceOffset(readSrcIdx);
519  }
520 
521  if (!source || !source->doPileUp(bunchIdx)) {
522  sizes.push_back(0U);
523  if (playback_ && !oldFormatPlayback) {
524  playbackCounter += playbackInfo_H->getNumberOfEvents(bunchIdx, readSrcIdx);
525  }
526  continue;
527  }
528 
529  // int eventId = 0;
530  int vertexOffset = 0;
531 
532  ModuleCallingContext const* mcc = e.moduleCallingContext();
533  if (!playback_) {
534  // non-minbias pileup only gets one event for now. Fix later if desired.
535  int numberOfEvents = (readSrcIdx == 0 ? PileupList[bunchIdx - minBunch_] : 1);
536  sizes.push_back(numberOfEvents);
537  inputSources_[readSrcIdx]->readPileUp(e.id(),
538  recordEventID,
539  std::bind(&MixingModule::pileAllWorkers,
540  std::ref(*this),
541  _1,
542  mcc,
543  bunchIdx,
544  _2,
545  vertexOffset,
546  std::ref(setup),
547  e.streamID()),
548  numberOfEvents,
549  e.streamID());
550  } else if (oldFormatPlayback) {
551  std::vector<edm::EventID> const& playEventID = oldFormatPlaybackInfo_H->getStartEventId(readSrcIdx, bunchIdx);
552  size_t numberOfEvents = playEventID.size();
553  if (readSrcIdx == 0) {
554  PileupList.push_back(numberOfEvents);
555  TrueNumInteractions_.push_back(numberOfEvents);
556  }
557  sizes.push_back(numberOfEvents);
558  std::vector<EventID>::const_iterator begin = playEventID.begin();
559  std::vector<EventID>::const_iterator end = playEventID.end();
560  inputSources_[readSrcIdx]->playOldFormatPileUp(begin,
561  end,
562  recordEventID,
563  std::bind(&MixingModule::pileAllWorkers,
564  std::ref(*this),
565  _1,
566  mcc,
567  bunchIdx,
568  _2,
569  vertexOffset,
570  std::ref(setup),
571  e.streamID()));
572  } else {
573  size_t numberOfEvents = playbackInfo_H->getNumberOfEvents(bunchIdx, readSrcIdx);
574  if (readSrcIdx == 0) {
575  PileupList.push_back(numberOfEvents);
576  TrueNumInteractions_.push_back(numberOfEvents);
577  }
578  sizes.push_back(numberOfEvents);
579  std::vector<SecondaryEventIDAndFileInfo>::const_iterator begin = playbackInfo_H->getEventId(playbackCounter);
580  playbackCounter += numberOfEvents;
581  std::vector<SecondaryEventIDAndFileInfo>::const_iterator end = playbackInfo_H->getEventId(playbackCounter);
582  inputSources_[readSrcIdx]->playPileUp(begin,
583  end,
584  recordEventID,
585  std::bind(&MixingModule::pileAllWorkers,
586  std::ref(*this),
587  _1,
588  mcc,
589  bunchIdx,
590  _2,
591  vertexOffset,
592  std::ref(setup),
593  e.streamID()));
594  }
595  }
596  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
597  accItr != accEnd;
598  ++accItr) {
599  (*accItr)->finalizeBunchCrossing(e, setup, bunchIdx);
600  }
601  }
602 
603  // Save playback information
604  for (auto const item : recordEventID) {
605  eventInfoList.emplace_back(item.eventID());
606  }
607 
608  // setInfo swaps recordEventID, so recordEventID is useless (empty) after the call.
609  playbackInfo_->setInfo(recordEventID, sizes);
610 
611  // Keep track of pileup accounting...
612 
613  std::unique_ptr<PileupMixingContent> PileupMixing_;
614 
615  PileupMixing_ = std::unique_ptr<PileupMixingContent>(new PileupMixingContent(
616  bunchCrossingList, numInteractionList, TrueInteractionList, eventInfoList, bunchSpace_));
617 
618  e.put(std::move(PileupMixing_));
619 
620  // we have to do the ToF transformation for PSimHits once all pileup has been added
621  for (unsigned int ii = 0; ii < workers_.size(); ++ii) {
622  workers_[ii]->setTof();
623  workers_[ii]->put(e);
624  }
625  }

References genPUProtons_cfi::bunchCrossingList, edm::BMixingModule::bunchSpace_, digiAccumulators_, MillePedeFileConverter_cfg::e, mps_fire::end, Exception, CrossingFramePlaybackInfoNew::getEventId(), CrossingFramePlaybackInfoNew::getNumberOfEvents(), CrossingFramePlaybackInfoExtended::getStartEventId(), cuy::ii, edm::BMixingModule::inputSources_, inputTagPlayback_, B2GTnPMonitor_cfi::item, edm::BMixingModule::maxBunch_, edm::BMixingModule::maxNbSources_, edm::BMixingModule::minBunch_, eostools::move(), pileAllWorkers(), edm::BMixingModule::playback_, playbackInfo_, CrossingFramePlaybackInfoNew::setInfo(), singleTopDQM_cfi::setup, edm::source(), edm::BMixingModule::TrueNumInteractions_, mitigatedMETSequence_cff::U, and workers_.

◆ endLuminosityBlock()

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

Definition at line 661 of file MixingModule.cc.

661  {
662  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
663  accItr != accEnd;
664  ++accItr) {
665  (*accItr)->endLuminosityBlock(lumi, setup);
666  }
667  BMixingModule::endLuminosityBlock(lumi, setup);
668  }

References digiAccumulators_, edm::BMixingModule::endLuminosityBlock(), and singleTopDQM_cfi::setup.

◆ endRun()

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

Definition at line 643 of file MixingModule.cc.

643  {
644  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
645  accItr != accEnd;
646  ++accItr) {
647  (*accItr)->endRun(run, setup);
648  }
649  BMixingModule::endRun(run, setup);
650  }

References digiAccumulators_, edm::BMixingModule::endRun(), writedatasetfile::run, and singleTopDQM_cfi::setup.

◆ finalizeEvent()

void MixingModule::finalizeEvent ( edm::Event &  event,
edm::EventSetup const &  setup 
)
overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 696 of file MixingModule.cc.

696  {
697  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
698  accItr != accEnd;
699  ++accItr) {
700  (*accItr)->finalizeEvent(event, setup);
701  }
702  }

References digiAccumulators_, and singleTopDQM_cfi::setup.

◆ initializeEvent()

void MixingModule::initializeEvent ( edm::Event const &  event,
edm::EventSetup const &  setup 
)
overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 670 of file MixingModule.cc.

670  {
671  for (Accumulators::const_iterator accItr = digiAccumulators_.begin(), accEnd = digiAccumulators_.end();
672  accItr != accEnd;
673  ++accItr) {
674  (*accItr)->initializeEvent(event, setup);
675  }
676  }

References digiAccumulators_, and singleTopDQM_cfi::setup.

◆ pileAllWorkers()

bool MixingModule::pileAllWorkers ( EventPrincipal const &  ep,
ModuleCallingContext const *  mcc,
int  bcr,
int  id,
int &  offset,
const edm::EventSetup &  setup,
edm::StreamID const &  streamID 
)
private

Definition at line 372 of file MixingModule.cc.

378  {
379  InternalContext internalContext(eventPrincipal.id(), mcc);
380  ParentContext parentContext(&internalContext);
381  ModuleCallingContext moduleCallingContext(&moduleDescription());
382  ModuleContextSentry moduleContextSentry(&moduleCallingContext, parentContext);
383 
384  for (auto const& adjuster : adjusters_) {
385  adjuster->doOffset(bunchSpace_, bunchCrossing, eventPrincipal, &moduleCallingContext, eventId, vertexOffset);
386  }
387  PileUpEventPrincipal pep(eventPrincipal, &moduleCallingContext, bunchCrossing);
388 
389  accumulateEvent(pep, setup, streamID);
390 
391  for (auto const& worker : workers_) {
392  LogDebug("MixingModule") << " merging Event: id " << eventPrincipal.id();
393  // std::cout <<"PILEALLWORKERS merging Event: id " << eventPrincipal.id() << std::endl;
394 
395  worker->addPileups(eventPrincipal, &moduleCallingContext, eventId);
396  }
397 
398  return true;
399  }

References accumulateEvent(), adjusters_, edm::BMixingModule::bunchSpace_, edm::EventPrincipal::id(), LogDebug, singleTopDQM_cfi::setup, and workers_.

Referenced by doPileUp().

◆ put()

void MixingModule::put ( edm::Event &  e,
const edm::EventSetup &  es 
)
overrideprivatevirtual

Reimplemented from edm::BMixingModule.

Definition at line 627 of file MixingModule.cc.

627  {
628  if (playbackInfo_) {
629  std::unique_ptr<CrossingFramePlaybackInfoNew> pOut(playbackInfo_);
630  e.put(std::move(pOut));
631  }
632  }

References MillePedeFileConverter_cfg::e, eostools::move(), and playbackInfo_.

◆ reload()

void MixingModule::reload ( const edm::EventSetup &  setup)
overridevirtual

Reimplemented from edm::BMixingModule.

Definition at line 290 of file MixingModule.cc.

290  {
291  //change the basic parameters.
292  edm::ESHandle<MixingModuleConfig> config;
293  setup.get<MixingRcd>().get(config);
294  minBunch_ = config->minBunch();
295  maxBunch_ = config->maxBunch();
296  bunchSpace_ = config->bunchSpace();
297  //propagate to change the workers
298  for (unsigned int ii = 0; ii < workersObjects_.size(); ++ii) {
299  workersObjects_[ii]->reload(setup);
300  }
301  }

References edm::BMixingModule::bunchSpace_, submitPVResolutionJobs::config, edm::get(), cuy::ii, edm::BMixingModule::maxBunch_, edm::BMixingModule::minBunch_, singleTopDQM_cfi::setup, and workersObjects_.

Member Data Documentation

◆ adjusters_

std::vector<AdjusterBase*> edm::MixingModule::adjusters_
private

Definition at line 103 of file MixingModule.h.

Referenced by checkSignal(), and pileAllWorkers().

◆ adjustersObjects_

std::vector<AdjusterBase*> edm::MixingModule::adjustersObjects_
private

Definition at line 104 of file MixingModule.h.

Referenced by checkSignal(), MixingModule(), and ~MixingModule().

◆ digiAccumulators_

Accumulators edm::MixingModule::digiAccumulators_
private

Definition at line 113 of file MixingModule.h.

Referenced by accumulateEvent(), beginLuminosityBlock(), beginRun(), createDigiAccumulators(), doPileUp(), endLuminosityBlock(), endRun(), finalizeEvent(), initializeEvent(), and ~MixingModule().

◆ inputTagPlayback_

InputTag edm::MixingModule::inputTagPlayback_
private

Definition at line 98 of file MixingModule.h.

Referenced by doPileUp(), and MixingModule().

◆ mixProdStep1_

bool edm::MixingModule::mixProdStep1_
private

Definition at line 100 of file MixingModule.h.

Referenced by MixingModule().

◆ mixProdStep2_

bool edm::MixingModule::mixProdStep2_
private

Definition at line 99 of file MixingModule.h.

Referenced by MixingModule().

◆ playbackInfo_

CrossingFramePlaybackInfoNew* edm::MixingModule::playbackInfo_
private

Definition at line 101 of file MixingModule.h.

Referenced by createnewEDProduct(), doPileUp(), and put().

◆ skipSignal_

bool edm::MixingModule::skipSignal_
private

Definition at line 110 of file MixingModule.h.

Referenced by addSignals(), checkSignal(), and MixingModule().

◆ useCurrentProcessOnly_

bool edm::MixingModule::useCurrentProcessOnly_
private

Definition at line 108 of file MixingModule.h.

Referenced by branchesActivate(), and MixingModule().

◆ wantedBranches_

std::vector<std::string> edm::MixingModule::wantedBranches_
private

Definition at line 107 of file MixingModule.h.

Referenced by branchesActivate(), and MixingModule().

◆ workers_

std::vector<MixingWorkerBase*> edm::MixingModule::workers_
private

Definition at line 105 of file MixingModule.h.

Referenced by addSignals(), checkSignal(), createnewEDProduct(), doPileUp(), and pileAllWorkers().

◆ workersObjects_

std::vector<MixingWorkerBase*> edm::MixingModule::workersObjects_
private

Definition at line 106 of file MixingModule.h.

Referenced by checkSignal(), MixingModule(), reload(), and ~MixingModule().

◆ wrapLongTimes_

bool edm::MixingModule::wrapLongTimes_
private

Definition at line 109 of file MixingModule.h.

Referenced by MixingModule().

edm::BMixingModule::endRun
void endRun(const edm::Run &r, const edm::EventSetup &setup) override
Definition: BMixingModule.cc:258
edm::BMixingModule::inputSources_
std::vector< std::shared_ptr< PileUp > > inputSources_
Definition: BMixingModule.h:108
CrossingFramePlaybackInfoNew::getEventId
std::vector< edm::SecondaryEventIDAndFileInfo >::const_iterator getEventId(size_t offset) const
Definition: CrossingFramePlaybackInfoNew.h:41
edm::BMixingModule::endLuminosityBlock
void endLuminosityBlock(const edm::LuminosityBlock &l, const edm::EventSetup &setup) override
Definition: BMixingModule.cc:251
edm::source
static const std::string source("source")
edm::BMixingModule::bunchSpace_
int bunchSpace_
Definition: BMixingModule.h:91
MixingRcd
Definition: MixingRcd.h:24
mps_fire.i
i
Definition: mps_fire.py:428
edm::BMixingModule::minBunch_
int minBunch_
Definition: BMixingModule.h:94
edm::sort_all
void sort_all(RandomAccessSequence &s)
wrappers for std::sort
Definition: Algorithms.h:92
MicroEventContent_cff.branch
branch
Definition: MicroEventContent_cff.py:169
fireworks::subdets
static const std::string subdets[7]
Definition: TrackUtils.cc:60
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89285
edm::BMixingModule::maxBunch_
int maxBunch_
Definition: BMixingModule.h:95
MixingWorker
edm::ClonePolicy
Definition: ClonePolicy.h:6
CrossingFramePlaybackInfoExtended::getStartEventId
std::vector< edm::EventID > getStartEventId(const unsigned int s, const int bcr) const
Definition: CrossingFramePlaybackInfoExtended.h:31
PileUpEventPrincipal
Definition: PileUpEventPrincipal.h:19
edm::BMixingModule::TrueNumInteractions_
std::vector< float > TrueNumInteractions_
Definition: BMixingModule.h:103
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
edm::MixingModule::doPileUp
void doPileUp(edm::Event &e, const edm::EventSetup &es) override
Definition: MixingModule.cc:401
edm::Handle
Definition: AssociativeIterator.h:50
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
edm::MixingModule::playbackInfo_
CrossingFramePlaybackInfoNew * playbackInfo_
Definition: MixingModule.h:101
singleTopDQM_cfi.setup
setup
Definition: singleTopDQM_cfi.py:37
edm::MixingModule::wrapLongTimes_
bool wrapLongTimes_
Definition: MixingModule.h:109
edm::BMixingModule::beginLuminosityBlock
void beginLuminosityBlock(const edm::LuminosityBlock &l, const edm::EventSetup &setup) override
Definition: BMixingModule.cc:235
CrossingFramePlaybackInfoNew
Definition: CrossingFramePlaybackInfoNew.h:22
edm::MixingModule::mixProdStep2_
bool mixProdStep2_
Definition: MixingModule.h:99
config
Definition: config.py:1
names
const std::string names[nVars_]
Definition: PhotonIDValueMapProducer.cc:124
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
edm::BMixingModule::maxNbSources_
const static unsigned int maxNbSources_
Definition: BMixingModule.h:101
edm::MixingModule::wantedBranches_
std::vector< std::string > wantedBranches_
Definition: MixingModule.h:107
submitPVResolutionJobs.config
config
parse the configuration file
Definition: submitPVResolutionJobs.py:281
edm::BMixingModule::playback_
bool playback_
Definition: BMixingModule.h:100
mps_fire.end
end
Definition: mps_fire.py:242
edm::ESHandle
Definition: DTSurvey.h:22
edm::MixingModule::inputTagPlayback_
InputTag inputTagPlayback_
Definition: MixingModule.h:98
edm::binary_search_all
bool binary_search_all(ForwardSequence const &s, Datum const &d)
wrappers for std::binary_search
Definition: Algorithms.h:58
edm::MixingModule::createDigiAccumulators
void createDigiAccumulators(const edm::ParameterSet &mixingPSet, edm::ConsumesCollector &iC)
Definition: MixingModule.cc:273
edm::MixingModule::workersObjects_
std::vector< MixingWorkerBase * > workersObjects_
Definition: MixingModule.h:106
mitigatedMETSequence_cff.U
U
Definition: mitigatedMETSequence_cff.py:36
edm::MixingModule::branchesActivate
virtual void branchesActivate(const std::string &friendlyName, const std::string &subdet, InputTag &tag, std::string &label)
Definition: MixingModule.cc:303
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::MixingModule::useCurrentProcessOnly_
bool useCurrentProcessOnly_
Definition: MixingModule.h:108
edm::MixingModule::skipSignal_
bool skipSignal_
Definition: MixingModule.h:110
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
ParameterSet
Definition: Functions.h:16
edm::friendlyname::friendlyName
std::string friendlyName(std::string const &iFullName)
Definition: FriendlyName.cc:278
edm::get
T const & get(Event const &event, InputTag const &tag) noexcept(false)
Definition: Event.h:675
edm::MixingModule::adjusters_
std::vector< AdjusterBase * > adjusters_
Definition: MixingModule.h:103
edm::Service
Definition: Service.h:30
DigiHGCalTB160_cff.crossingFrames
crossingFrames
Definition: DigiHGCalTB160_cff.py:7
PileupMixingContent
Definition: PileupMixingContent.h:24
genPUProtons_cfi.bunchCrossingList
bunchCrossingList
Definition: genPUProtons_cfi.py:5
edm::BMixingModule::dropUnwantedBranches
void dropUnwantedBranches(std::vector< std::string > const &wantedBranches)
Definition: BMixingModule.cc:307
CrossingFramePlaybackInfoNew::setInfo
void setInfo(std::vector< edm::SecondaryEventIDAndFileInfo > &eventInfo, std::vector< size_t > &sizes)
Definition: CrossingFramePlaybackInfoNew.h:35
B2GTnPMonitor_cfi.item
item
Definition: B2GTnPMonitor_cfi.py:147
edm::MixingModule::accumulateEvent
void accumulateEvent(Event const &event, EventSetup const &setup)
Definition: MixingModule.cc:678
edm::MixingModule::workers_
std::vector< MixingWorkerBase * > workers_
Definition: MixingModule.h:105
DigiHGCalTB160_cff.makeCrossingFrame
makeCrossingFrame
Definition: DigiHGCalTB160_cff.py:24
SimL1EmulatorRepack_CalouGT_cff.processName
processName
Definition: SimL1EmulatorRepack_CalouGT_cff.py:17
TrackingRecHit
Definition: TrackingRecHit.h:21
edm::MixingModule::pileAllWorkers
bool pileAllWorkers(EventPrincipal const &ep, ModuleCallingContext const *, int bcr, int id, int &offset, const edm::EventSetup &setup, edm::StreamID const &)
Definition: MixingModule.cc:372
edm::MixingModule::mixProdStep1_
bool mixProdStep1_
Definition: MixingModule.h:100
mixOne_premix_on_sim_cfi.accumulator
accumulator
Definition: mixOne_premix_on_sim_cfi.py:167
eostools.move
def move(src, dest)
Definition: eostools.py:511
writedatasetfile.run
run
Definition: writedatasetfile.py:27
edm::BMixingModule::BMixingModule
BMixingModule(const edm::ParameterSet &ps, MixingCache::Config const *globalConf)
Definition: BMixingModule.cc:179
edm::MixingModule::adjustersObjects_
std::vector< AdjusterBase * > adjustersObjects_
Definition: MixingModule.h:104
edm::MixingModule::digiAccumulators_
Accumulators digiAccumulators_
Definition: MixingModule.h:113
Exception
Definition: hltDiff.cc:245
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
triggerMatcherToHLTDebug_cfi.tags
tags
Definition: triggerMatcherToHLTDebug_cfi.py:9
edm::InputTag::kSkipCurrentProcess
static const std::string kSkipCurrentProcess
Definition: InputTag.h:53
HepMCProduct
event
Definition: event.py:1
CrossingFramePlaybackInfoNew::getNumberOfEvents
size_t getNumberOfEvents(int bunchIdx, size_t sourceNumber) const
Definition: CrossingFramePlaybackInfoNew.h:47
lumi
Definition: LumiSectionData.h:20
mixObjects_cfi.pcrossingFrames
pcrossingFrames
Definition: mixObjects_cfi.py:50
cuy.ii
ii
Definition: cuy.py:590
edm::BMixingModule::beginRun
void beginRun(const edm::Run &r, const edm::EventSetup &setup) override
Definition: BMixingModule.cc:243
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
label
const char * label
Definition: PFTauDecayModeTools.cc:11
edm::ParameterSet::getParameterSet
ParameterSet const & getParameterSet(std::string const &) const
Definition: ParameterSet.cc:2128
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
edm::OwnVector
Definition: OwnVector.h:24
edm::DigiAccumulatorMixModFactory::get
static DigiAccumulatorMixModFactory const * get()
Definition: DigiAccumulatorMixModFactory.cc:18
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
Generated for CMSSW Reference Manual by doxygen 1.8.16