edm::ConcurrentGeneratorFilter< HAD, DEC > Class Template Reference

#include <ConcurrentGeneratorFilter.h>

Inheritance diagram for edm::ConcurrentGeneratorFilter< HAD, DEC >:

Public Types
typedef DEC	Decayer
typedef HAD	Hadronizer
Public Types inherited from edm::global::EDFilterBase
typedef EDFilterBase	ModuleType
Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex >>
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
std::unique_ptr< gen::GenStreamCache< HAD, DEC > >	beginStream (StreamID) const override
	ConcurrentGeneratorFilter (ParameterSet const &ps)
bool	filter (StreamID id, Event &e, EventSetup const &es) const override
void	globalBeginLuminosityBlockProduce (LuminosityBlock &, EventSetup const &) const override
std::shared_ptr< gen::GenLumiSummary >	globalBeginLuminosityBlockSummary (LuminosityBlock const &, EventSetup const &) const override
std::shared_ptr< gen::GenRunCache >	globalBeginRun (Run const &, EventSetup const &) const override
void	globalEndLuminosityBlockProduce (LuminosityBlock &, EventSetup const &, gen::GenLumiSummary const *) const override
void	globalEndLuminosityBlockSummary (LuminosityBlock const &, EventSetup const &, gen::GenLumiSummary *) const override
void	globalEndRun (Run const &, EventSetup const &) const override
void	globalEndRunProduce (Run &, EventSetup const &) const override
void	streamBeginLuminosityBlock (StreamID, LuminosityBlock const &, EventSetup const &) const override
void	streamEndLuminosityBlock (StreamID, LuminosityBlock const &, EventSetup const &) const override
void	streamEndLuminosityBlockSummary (StreamID, LuminosityBlock const &, EventSetup const &, gen::GenLumiSummary *) const override
void	streamEndRun (StreamID, Run const &, EventSetup const &) const override
Public Member Functions inherited from edm::global::EDFilter< EndRunProducer, BeginLuminosityBlockProducer, EndLuminosityBlockProducer, RunCache< gen::GenRunCache >, LuminosityBlockSummaryCache< gen::GenLumiSummary >, StreamCache< gen::GenStreamCache< HAD, DEC > > >
	EDFilter ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsStreamLuminosityBlocks () const final
bool	wantsStreamRuns () const final
Public Member Functions inherited from edm::global::EDFilterBase
	EDFilterBase ()
ModuleDescription const &	moduleDescription () const
	~EDFilterBase () override
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
	~ProducerBase () noexcept(false) override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	initLumi (gen::GenStreamCache< HAD, DEC > *cache, LuminosityBlock const &index, EventSetup const &es) const

Private Attributes
ParameterSet	config_
std::atomic< gen::GenStreamCache< HAD, DEC > * >	useInLumi_ { 0 }

Additional Inherited Members
Static Public Member Functions inherited from edm::global::EDFilterBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

template<class HAD, class DEC>
class edm::ConcurrentGeneratorFilter< HAD, DEC >

Definition at line 76 of file ConcurrentGeneratorFilter.h.

Member Typedef Documentation

template<class HAD , class DEC >

typedef DEC edm::ConcurrentGeneratorFilter< HAD, DEC >::Decayer

Definition at line 84 of file ConcurrentGeneratorFilter.h.

template<class HAD , class DEC >

typedef HAD edm::ConcurrentGeneratorFilter< HAD, DEC >::Hadronizer

Definition at line 83 of file ConcurrentGeneratorFilter.h.

Constructor & Destructor Documentation

template<class HAD , class DEC >

edm::ConcurrentGeneratorFilter< HAD, DEC >::ConcurrentGeneratorFilter ( ParameterSet const &  ps )

explicit

Definition at line 122 of file ConcurrentGeneratorFilter.h.

                                                                                       : config_(ps) {
    // TODO:
    // Put the list of types produced by the filters here.
    // The current design calls for:
    //   * LHEGeneratorInfo
    //   * LHEEvent
    //   * HepMCProduct
    // But I can not find the LHEGeneratorInfo class; it might need to
    // be invented.

    this->template produces<HepMCProduct>("unsmeared");
    this->template produces<GenEventInfoProduct>();
    this->template produces<GenLumiInfoHeader, edm::Transition::BeginLuminosityBlock>();
    this->template produces<GenLumiInfoProduct, edm::Transition::EndLuminosityBlock>();
    this->template produces<GenRunInfoProduct, edm::Transition::EndRun>();
  }

Member Function Documentation

template<class HAD , class DEC >

std::unique_ptr< gen::GenStreamCache< HAD, DEC > > edm::ConcurrentGeneratorFilter< HAD, DEC >::beginStream ( StreamID  ) const

override

Definition at line 140 of file ConcurrentGeneratorFilter.h.

References utilities::cache(), edm::ConcurrentGeneratorFilter< HAD, DEC >::config_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), and edm::ConcurrentGeneratorFilter< HAD, DEC >::useInLumi_.

                                                                                                            {
    auto cache = std::make_unique<gen::GenStreamCache<HAD, DEC>>(config_);

    if (config_.exists("ExternalDecays")) {
      ParameterSet ps1 = config_.getParameter<ParameterSet>("ExternalDecays");
      cache->decayer_.reset(new Decayer(ps1));
    }

    // We need a hadronizer during globalBeginLumiProduce, doesn't matter which one
    gen::GenStreamCache<HAD, DEC>* expected = nullptr;
    useInLumi_.compare_exchange_strong(expected, cache.get());

    return cache;
  }

template<class HAD , class DEC >

bool edm::ConcurrentGeneratorFilter< HAD, DEC >::filter ( StreamID  id, Event &  e, EventSetup const &  es  ) const

overridevirtual

Implements edm::global::EDFilterBase.

Definition at line 211 of file ConcurrentGeneratorFilter.h.

References utilities::cache(), edm::EventID::event(), event(), particlelevel_cff::genEventInfo, edm::EventBase::id(), eostools::move(), edm::Event::put(), edm::Event::streamID(), and protons_cff::t.

                                                                                                    {
    auto cache = this->streamCache(id);
    RandomEngineSentry<HAD> randomEngineSentry(&cache->hadronizer_, ev.streamID());
    RandomEngineSentry<DEC> randomEngineSentryDecay(cache->decayer_.get(), ev.streamID());

    cache->hadronizer_.setEDMEvent(ev);

    bool passEvtGenSelector = false;
    std::unique_ptr<HepMC::GenEvent> event(nullptr);

    while (!passEvtGenSelector) {
      event.reset();
      cache->hadronizer_.setEDMEvent(ev);

      if (!cache->hadronizer_.generatePartonsAndHadronize())
        return false;

      // this is "fake" stuff
      // in principle, decays are done as part of full event generation,
      // except for particles that are marked as to be kept stable
      // but we currently keep in it the design, because we might want
      // to use such feature for other applications
      //
      if (!cache->hadronizer_.decay())
        return false;

      event = cache->hadronizer_.getGenEvent();
      if (!event.get())
        return false;

      //
      // The external decay driver is being added to the system, it should be called here
      //
      if (cache->decayer_) {
        auto t = cache->decayer_->decay(event.get());
        if (t != event.get()) {
          event.reset(t);
        }
      }
      if (!event.get())
        return false;

      passEvtGenSelector = cache->hadronizer_.select(event.get());
    }

    // check and perform if there're any unstable particles after
    // running external decay packages
    //
    // fisrt of all, put back modified event tree (after external decay)
    //
    cache->hadronizer_.resetEvent(std::move(event));

    //
    // now run residual decays
    //
    if (!cache->hadronizer_.residualDecay())
      return false;

    cache->hadronizer_.finalizeEvent();

    event = cache->hadronizer_.getGenEvent();
    if (!event.get())
      return false;

    event->set_event_number(ev.id().event());

    //
    // finally, form up EDM products !
    //
    std::unique_ptr<GenEventInfoProduct> genEventInfo(cache->hadronizer_.getGenEventInfo());
    if (!genEventInfo.get()) {
      // create GenEventInfoProduct from HepMC event in case hadronizer didn't provide one
      genEventInfo = std::make_unique<GenEventInfoProduct>(event.get());
    }

    ev.put(std::move(genEventInfo));

    std::unique_ptr<HepMCProduct> bare_product(new HepMCProduct());
    bare_product->addHepMCData(event.release());
    ev.put(std::move(bare_product), "unsmeared");
    cache->nEventsInLumiBlock_++;
    return true;
  }

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::globalBeginLuminosityBlockProduce ( LuminosityBlock &  lumi, EventSetup const &  es  ) const

override

Definition at line 296 of file ConcurrentGeneratorFilter.h.

References genWeightsTable_cfi::genLumiInfoHeader, edm::ConcurrentGeneratorFilter< HAD, DEC >::initLumi(), eostools::move(), edm::LuminosityBlock::put(), and edm::ConcurrentGeneratorFilter< HAD, DEC >::useInLumi_.

                                                                                                          {
    // need one of the streams to finish
    while (useInLumi_.load() == nullptr) {
    }
    initLumi(useInLumi_, lumi, es);
    std::unique_ptr<GenLumiInfoHeader> genLumiInfoHeader(useInLumi_.load()->hadronizer_.getGenLumiInfoHeader());
    lumi.put(std::move(genLumiInfoHeader));
  }

template<class HAD , class DEC >

std::shared_ptr< gen::GenLumiSummary > edm::ConcurrentGeneratorFilter< HAD, DEC >::globalBeginLuminosityBlockSummary ( LuminosityBlock const &  , EventSetup const &    ) const

override

Definition at line 162 of file ConcurrentGeneratorFilter.h.

                                                       {
    return std::make_shared<gen::GenLumiSummary>();
  }

template<class HAD , class DEC >

std::shared_ptr< gen::GenRunCache > edm::ConcurrentGeneratorFilter< HAD, DEC >::globalBeginRun ( Run const &  , EventSetup const &    ) const

override

Definition at line 156 of file ConcurrentGeneratorFilter.h.

                                                                                                                 {
    return std::make_shared<gen::GenRunCache>();
  }

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::globalEndLuminosityBlockProduce ( LuminosityBlock &  lumi, EventSetup const &  , gen::GenLumiSummary const *  iSummary  ) const

override

Definition at line 375 of file ConcurrentGeneratorFilter.h.

References edm::gen::GenLumiSummary::lumiInfo_, eostools::move(), and edm::LuminosityBlock::put().

                                                                                                                     {
    lumi.put(std::move(iSummary->lumiInfo_));
  }

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::globalEndLuminosityBlockSummary ( LuminosityBlock const &  , EventSetup const &  , gen::GenLumiSummary *    ) const

override

Definition at line 370 of file ConcurrentGeneratorFilter.h.

                                                                                                      {}

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::globalEndRun ( Run const &  , EventSetup const &    ) const

override

Definition at line 407 of file ConcurrentGeneratorFilter.h.

{}

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::globalEndRunProduce ( Run &  run, EventSetup const &    ) const

override

Definition at line 410 of file ConcurrentGeneratorFilter.h.

References edm::Run::index(), edm::Run::put(), and fetchall_from_DQM_v2::release.

                                                                                                 {
    run.put(this->runCache(run.index())->release());
  }

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::initLumi ( gen::GenStreamCache< HAD, DEC > *  cache, LuminosityBlock const &  index, EventSetup const &  es  ) const

private

Definition at line 168 of file ConcurrentGeneratorFilter.h.

References edm::errors::Configuration, edmIntegrityCheck::d, edm::gen::GenStreamCache< HAD, DEC >::decayer_, Exception, edm::LuminosityBlock::get(), h, edm::gen::GenStreamCache< HAD, DEC >::hadronizer_, edm::LuminosityBlock::index(), edm::gen::GenStreamCache< HAD, DEC >::initialized_, and edm::gen::GenStreamCache< HAD, DEC >::nEventsInLumiBlock_.

Referenced by edm::ConcurrentGeneratorFilter< HAD, DEC >::globalBeginLuminosityBlockProduce(), and edm::ConcurrentGeneratorFilter< HAD, DEC >::streamBeginLuminosityBlock().

                                                                                 {
    cache->nEventsInLumiBlock_ = 0;

    // We need all copies to see same random # for begin lumi
    Service<RandomNumberGenerator> rng;
    auto enginePtr = rng->cloneEngine(lumi.index());
    cache->hadronizer_.setRandomEngine(enginePtr.get());
    cache->decayer_->setRandomEngine(enginePtr.get());

    auto unsetH = [](HAD* h) { h->setRandomEngine(nullptr); };
    auto unsetD = [](DEC* d) { d->setRandomEngine(nullptr); };

    std::unique_ptr<HAD, decltype(unsetH)> randomEngineSentry(&cache->hadronizer_, unsetH);
    std::unique_ptr<DEC, decltype(unsetD)> randomEngineSentryDecay(cache->decayer_.get(), unsetD);

    cache->hadronizer_.randomizeIndex(lumi, enginePtr.get());

    if (!cache->hadronizer_.readSettings(0))
      throw edm::Exception(errors::Configuration)
          << "Failed to read settings for the hadronizer " << cache->hadronizer_.classname() << " \n";

    if (cache->decayer_) {
      cache->decayer_->init(es);
      if (!cache->hadronizer_.declareStableParticles(cache->decayer_->operatesOnParticles()))
        throw edm::Exception(errors::Configuration)
            << "Failed to declare stable particles in hadronizer " << cache->hadronizer_.classname()
            << " for internal parton generation\n";
      if (!cache->hadronizer_.declareSpecialSettings(cache->decayer_->specialSettings()))
        throw edm::Exception(errors::Configuration)
            << "Failed to declare special settings in hadronizer " << cache->hadronizer_.classname() << "\n";
    }

    if (!cache->hadronizer_.initializeForInternalPartons())
      throw edm::Exception(errors::Configuration)
          << "Failed to initialize hadronizer " << cache->hadronizer_.classname()
          << " for internal parton generation\n";

    cache->initialized_ = true;
  }

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::streamBeginLuminosityBlock ( StreamID  id, LuminosityBlock const &  lumi, EventSetup const &  es  ) const

override

Definition at line 307 of file ConcurrentGeneratorFilter.h.

References edm::ConcurrentGeneratorFilter< HAD, DEC >::initLumi(), and edm::ConcurrentGeneratorFilter< HAD, DEC >::useInLumi_.

                                                                                                   {
    if (useInLumi_ != this->streamCache(id)) {
      initLumi(this->streamCache(id), lumi, es);
    } else {
      useInLumi_.store(nullptr);
    }
  }

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::streamEndLuminosityBlock ( StreamID  id, LuminosityBlock const &  , EventSetup const &    ) const

override

Definition at line 318 of file ConcurrentGeneratorFilter.h.

                                                                                              {
    this->streamCache(id)->hadronizer_.cleanLHE();
  }

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::streamEndLuminosityBlockSummary ( StreamID  id, LuminosityBlock const &  , EventSetup const &  , gen::GenLumiSummary *  iSummary  ) const

override

Definition at line 325 of file ConcurrentGeneratorFilter.h.

References utilities::cache(), GenRunInfoProduct::XSec::error(), GenRunInfoProduct::internalXSec(), edm::gen::GenLumiSummary::lumiInfo_, eostools::move(), GenLumiInfoProduct::ProcessInfo::setAccepted(), GenLumiInfoProduct::ProcessInfo::setAcceptedBr(), GenLumiInfoProduct::setHEPIDWTUP(), GenLumiInfoProduct::ProcessInfo::setKilled(), GenLumiInfoProduct::ProcessInfo::setLheXSec(), GenLumiInfoProduct::ProcessInfo::setNPassNeg(), GenLumiInfoProduct::ProcessInfo::setNPassPos(), GenLumiInfoProduct::ProcessInfo::setNTotalNeg(), GenLumiInfoProduct::ProcessInfo::setNTotalPos(), GenLumiInfoProduct::ProcessInfo::setProcess(), GenLumiInfoProduct::setProcessInfo(), GenLumiInfoProduct::ProcessInfo::setSelected(), GenLumiInfoProduct::ProcessInfo::setTried(), groupFilesInBlocks::temp, edm::ConcurrentGeneratorFilter< HAD, DEC >::useInLumi_, and GenRunInfoProduct::XSec::value().

                                                                                                               {
    auto cache = this->streamCache(id);
    cache->hadronizer_.statistics();
    if (cache->decayer_)
      cache->decayer_->statistics();

    GenRunInfoProduct genRunInfo = GenRunInfoProduct(cache->hadronizer_.getGenRunInfo());
    std::vector<GenLumiInfoProduct::ProcessInfo> GenLumiProcess;
    const GenRunInfoProduct::XSec& xsec = genRunInfo.internalXSec();
    GenLumiInfoProduct::ProcessInfo temp;
    unsigned int nEvtInLumiBlock_ = cache->nEventsInLumiBlock_;
    temp.setProcess(0);
    temp.setLheXSec(xsec.value(), xsec.error());  // Pythia gives error of -1
    temp.setNPassPos(nEvtInLumiBlock_);
    temp.setNPassNeg(0);
    temp.setNTotalPos(nEvtInLumiBlock_);
    temp.setNTotalNeg(0);
    temp.setTried(nEvtInLumiBlock_, nEvtInLumiBlock_, nEvtInLumiBlock_);
    temp.setSelected(nEvtInLumiBlock_, nEvtInLumiBlock_, nEvtInLumiBlock_);
    temp.setKilled(nEvtInLumiBlock_, nEvtInLumiBlock_, nEvtInLumiBlock_);
    temp.setAccepted(0, -1, -1);
    temp.setAcceptedBr(0, -1, -1);
    GenLumiProcess.push_back(temp);

    GenLumiInfoProduct genLumiInfo;
    genLumiInfo.setHEPIDWTUP(-1);
    genLumiInfo.setProcessInfo(GenLumiProcess);

    if (iSummary->lumiInfo_) {
      iSummary->lumiInfo_->mergeProduct(genLumiInfo);
    } else {
      iSummary->lumiInfo_ = std::make_unique<GenLumiInfoProduct>(std::move(genLumiInfo));
    }

    cache->nEventsInLumiBlock_ = 0;

    gen::GenStreamCache<HAD, DEC>* expected = nullptr;
    //make it available for beginLuminosityBlockProduce
    useInLumi_.compare_exchange_strong(expected, this->streamCache(id));
  }

template<class HAD , class DEC >

void edm::ConcurrentGeneratorFilter< HAD, DEC >::streamEndRun ( StreamID  id, Run const &  run, EventSetup const &    ) const

override

Definition at line 382 of file ConcurrentGeneratorFilter.h.

References utilities::cache(), and edm::Run::index().

                                                                                                             {
    auto rCache = this->runCache(run.index());
    auto cache = this->streamCache(id);

    // If relevant, record the integrated luminosity for this run
    // here.  To do so, we would need a standard function to invoke on
    // the contained hadronizer that would report the integrated
    // luminosity.

    if (cache->initialized_) {
      cache->hadronizer_.statistics();
      if (cache->decayer_)
        cache->decayer_->statistics();
    }
    GenRunInfoProduct& genRunInfo = cache->hadronizer_.getGenRunInfo();
    GenRunInfoProduct* expect = nullptr;

    std::unique_ptr<GenRunInfoProduct> griproduct(new GenRunInfoProduct(genRunInfo));
    // All the GenRunInfoProducts for all streams shoule be identical, therefore we only need one
    if (rCache->product_.compare_exchange_strong(expect, griproduct.get())) {
      griproduct.release();
    }
  }

Member Data Documentation

template<class HAD , class DEC >

ParameterSet edm::ConcurrentGeneratorFilter< HAD, DEC >::config_

private

Definition at line 113 of file ConcurrentGeneratorFilter.h.

Referenced by edm::ConcurrentGeneratorFilter< HAD, DEC >::beginStream().

template<class HAD , class DEC >

std::atomic<gen::GenStreamCache<HAD, DEC>*> edm::ConcurrentGeneratorFilter< HAD, DEC >::useInLumi_ { 0 }

mutableprivate

Definition at line 114 of file ConcurrentGeneratorFilter.h.

Referenced by edm::ConcurrentGeneratorFilter< HAD, DEC >::beginStream(), edm::ConcurrentGeneratorFilter< HAD, DEC >::globalBeginLuminosityBlockProduce(), edm::ConcurrentGeneratorFilter< HAD, DEC >::streamBeginLuminosityBlock(), and edm::ConcurrentGeneratorFilter< HAD, DEC >::streamEndLuminosityBlockSummary().