Inheritance diagram for OscarMTProducer:

Public Types
typedef std::vector < std::shared_ptr< SimProducer > >	Producers

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< OscarMTMasterThread >, edm::RunCache< int > >
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
void	beginRun (const edm::Run &r, const edm::EventSetup &c) override

void	endRun (const edm::Run &r, const edm::EventSetup &c) override

	OscarMTProducer (edm::ParameterSet const &p, const OscarMTMasterThread *)

void	produce (edm::Event &e, const edm::EventSetup &c) override

	~OscarMTProducer () override

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< OscarMTMasterThread >, edm::RunCache< int > >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static std::shared_ptr< int >	globalBeginRun (const edm::Run &iRun, const edm::EventSetup &iSetup, const OscarMTMasterThread *masterThread)

static void	globalEndJob (OscarMTMasterThread *masterThread)

static void	globalEndRun (const edm::Run &iRun, const edm::EventSetup &iSetup, const RunContext *iContext)

static std::unique_ptr < OscarMTMasterThread >	initializeGlobalCache (const edm::ParameterSet &iConfig)

Private Attributes
omt::ThreadHandoff	m_handoff

const OscarMTMasterThread *	m_masterThread = nullptr

std::unique_ptr < RunManagerMTWorker >	m_runManagerWorker

Detailed Description

Definition at line 43 of file OscarMTProducer.cc.

Member Typedef Documentation

typedef std::vector<std::shared_ptr<SimProducer> > OscarMTProducer::Producers

Definition at line 45 of file OscarMTProducer.cc.

Constructor & Destructor Documentation

OscarMTProducer::OscarMTProducer	(	edm::ParameterSet const &	p,
		const OscarMTMasterThread *	ms
	)

explicit

Definition at line 102 of file OscarMTProducer.cc.

References OscarMTMasterThread::callConsumes(), edm::ParameterSet::getUntrackedParameter(), edm::ServiceRegistry::instance(), m_handoff, m_masterThread, m_runManagerWorker, AlCaHLTBitMon_ParallelJobs::p, edm::ServiceRegistry::presentToken(), HLT_FULL_cff::producers, omt::ThreadHandoff::runAndWait(), and unpackBuffers-CaloStage2::token.

     : m_handoff{p.getUntrackedParameter<int>("workerThreadStackSize", 10 * 1024 * 1024)} {
   // Random number generation not allowed here
   StaticRandomEngineSetUnset random(nullptr);
 
   auto token = edm::ServiceRegistry::instance().presentToken();
   m_handoff.runAndWait([this, &p, token]() {
     edm::ServiceRegistry::Operate guard{token};
     StaticRandomEngineSetUnset random(nullptr);
     m_runManagerWorker = std::make_unique<RunManagerMTWorker>(p, consumesCollector());
   });
   m_masterThread = ms;
   m_masterThread->callConsumes(consumesCollector());
 
   // List of produced containers
   produces<edm::SimTrackContainer>().setBranchAlias("SimTracks");
   produces<edm::SimVertexContainer>().setBranchAlias("SimVertices");
   produces<edm::PSimHitContainer>("TrackerHitsPixelBarrelLowTof");
   produces<edm::PSimHitContainer>("TrackerHitsPixelBarrelHighTof");
   produces<edm::PSimHitContainer>("TrackerHitsTIBLowTof");
   produces<edm::PSimHitContainer>("TrackerHitsTIBHighTof");
   produces<edm::PSimHitContainer>("TrackerHitsTIDLowTof");
   produces<edm::PSimHitContainer>("TrackerHitsTIDHighTof");
   produces<edm::PSimHitContainer>("TrackerHitsPixelEndcapLowTof");
   produces<edm::PSimHitContainer>("TrackerHitsPixelEndcapHighTof");
   produces<edm::PSimHitContainer>("TrackerHitsTOBLowTof");
   produces<edm::PSimHitContainer>("TrackerHitsTOBHighTof");
   produces<edm::PSimHitContainer>("TrackerHitsTECLowTof");
   produces<edm::PSimHitContainer>("TrackerHitsTECHighTof");
 
   produces<edm::PSimHitContainer>("TotemHitsT1");
   produces<edm::PSimHitContainer>("TotemHitsT2Gem");
   produces<edm::PSimHitContainer>("TotemHitsRP");
   produces<edm::PSimHitContainer>("CTPPSPixelHits");
   produces<edm::PSimHitContainer>("CTPPSTimingHits");
   produces<edm::PSimHitContainer>("FP420SI");
   produces<edm::PSimHitContainer>("BSCHits");
   produces<edm::PSimHitContainer>("PLTHits");
   produces<edm::PSimHitContainer>("BCM1FHits");
   produces<edm::PSimHitContainer>("BHMHits");
   produces<edm::PSimHitContainer>("FastTimerHitsBarrel");
   produces<edm::PSimHitContainer>("FastTimerHitsEndcap");
 
   produces<edm::PCaloHitContainer>("EcalHitsEB");
   produces<edm::PCaloHitContainer>("EcalHitsEE");
   produces<edm::PCaloHitContainer>("EcalHitsES");
   produces<edm::PCaloHitContainer>("HcalHits");
   produces<edm::PCaloHitContainer>("CaloHitsTk");
   produces<edm::PCaloHitContainer>("HGCHitsEE");
   produces<edm::PCaloHitContainer>("HGCHitsHEfront");
   produces<edm::PCaloHitContainer>("HGCHitsHEback");
 
   produces<edm::PSimHitContainer>("MuonDTHits");
   produces<edm::PSimHitContainer>("MuonCSCHits");
   produces<edm::PSimHitContainer>("MuonRPCHits");
   produces<edm::PSimHitContainer>("MuonGEMHits");
   produces<edm::PSimHitContainer>("MuonME0Hits");
   produces<edm::PCaloHitContainer>("CastorPL");
   produces<edm::PCaloHitContainer>("CastorFI");
   produces<edm::PCaloHitContainer>("CastorBU");
   produces<edm::PCaloHitContainer>("CastorTU");
   produces<edm::PCaloHitContainer>("EcalTBH4BeamHits");
   produces<edm::PCaloHitContainer>("HcalTB06BeamHits");
   produces<edm::PCaloHitContainer>("ZDCHITS");
   produces<edm::PCaloHitContainer>("ChamberHits");
   produces<edm::PCaloHitContainer>("FibreHits");
   produces<edm::PCaloHitContainer>("WedgeHits");
   produces<edm::PCaloHitContainer>("HFNoseHits");
   produces<edm::PCaloHitContainer>("TotemHitsT2Scint");
 
   //register any products
   auto& producers = m_runManagerWorker->producers();
   for (auto& ptr : producers) {
     ptr->registerProducts(producesCollector());
   }
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer is constructed";
 }

OscarMTProducer::~OscarMTProducer ( )

override

Definition at line 180 of file OscarMTProducer.cc.

References edm::ServiceRegistry::instance(), m_handoff, m_runManagerWorker, edm::ServiceRegistry::presentToken(), omt::ThreadHandoff::runAndWait(), and unpackBuffers-CaloStage2::token.

                                   {
   auto token = edm::ServiceRegistry::instance().presentToken();
   m_handoff.runAndWait([this, token]() {
     edm::ServiceRegistry::Operate guard{token};
     m_runManagerWorker.reset();
   });
 }

Member Function Documentation

void OscarMTProducer::beginRun	(	const edm::Run &	r,
		const edm::EventSetup &	c
	)

override

Definition at line 217 of file OscarMTProducer.cc.

References edm::ServiceRegistry::instance(), m_handoff, m_masterThread, m_runManagerWorker, edm::ServiceRegistry::presentToken(), omt::ThreadHandoff::runAndWait(), OscarMTMasterThread::runManagerMasterPtr(), and unpackBuffers-CaloStage2::token.

                                                                      {
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::beginRun";
   auto token = edm::ServiceRegistry::instance().presentToken();
   m_handoff.runAndWait([this, &es, token]() {
     edm::ServiceRegistry::Operate guard{token};
     m_runManagerWorker->beginRun(es);
     m_runManagerWorker->initializeG4(m_masterThread->runManagerMasterPtr(), es);
   });
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::beginRun done";
 }

void OscarMTProducer::endRun	(	const edm::Run &	r,
		const edm::EventSetup &	c
	)

override

Definition at line 228 of file OscarMTProducer.cc.

References edm::ServiceRegistry::instance(), m_handoff, m_runManagerWorker, edm::ServiceRegistry::presentToken(), omt::ThreadHandoff::runAndWait(), and unpackBuffers-CaloStage2::token.

                                                                 {
   // Random number generation not allowed here
   StaticRandomEngineSetUnset random(nullptr);
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::endRun";
   auto token = edm::ServiceRegistry::instance().presentToken();
   m_handoff.runAndWait([this, token]() {
     StaticRandomEngineSetUnset random(nullptr);
     edm::ServiceRegistry::Operate guard{token};
     m_runManagerWorker->endRun();
   });
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::endRun done";
 }

std::shared_ptr< int > OscarMTProducer::globalBeginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup,
		const OscarMTMasterThread *	masterThread
	)

static

Definition at line 196 of file OscarMTProducer.cc.

References OscarMTMasterThread::beginRun().

                                                                                               {
   // Random number generation not allowed here
   StaticRandomEngineSetUnset random(nullptr);
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::globalBeginRun";
   masterThread->beginRun(iSetup);
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::globalBeginRun done";
   return std::shared_ptr<int>();
 }

void OscarMTProducer::globalEndJob ( OscarMTMasterThread * masterThread )

static

Definition at line 212 of file OscarMTProducer.cc.

References OscarMTMasterThread::stopThread().

                                                                     {
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::globalEndJob";
   masterThread->stopThread();
 }

void OscarMTProducer::globalEndRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup,
		const RunContext *	iContext
	)

static

Definition at line 207 of file OscarMTProducer.cc.

References edm::stream::RunContextT< R, G >::global().

                                                                                                   {
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::globalEndRun";
   iContext->global()->endRun();
 }

std::unique_ptr< OscarMTMasterThread > OscarMTProducer::initializeGlobalCache ( const edm::ParameterSet & iConfig )

static

Definition at line 188 of file OscarMTProducer.cc.

References iConfig.

                                                                                                         {
   // Random number generation not allowed here
   StaticRandomEngineSetUnset random(nullptr);
   edm::LogVerbatim("SimG4CoreApplication") << "OscarMTProducer::initializeGlobalCache";
 
   return std::make_unique<OscarMTMasterThread>(iConfig);
 }

void OscarMTProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Definition at line 241 of file OscarMTProducer.cc.

References edm::errors::EventCorruption, Exception, edm::EventBase::id(), edm::ServiceRegistry::instance(), m_handoff, m_runManagerWorker, eostools::move(), mergeVDriftHistosByStation::name, fireworks::p1, fireworks::p2, edm::ServiceRegistry::presentToken(), HLT_FULL_cff::producers, edm::Event::put(), omt::ThreadHandoff::runAndWait(), edm::Event::streamID(), unpackBuffers-CaloStage2::token, findQualityFiles::v, and SimG4Exception::what().

                                                                   {
   StaticRandomEngineSetUnset random(e.streamID());
   auto engine = random.currentEngine();
   edm::LogVerbatim("SimG4CoreApplication") << "Produce event " << e.id() << " stream " << e.streamID();
   //edm::LogVerbatim("SimG4CoreApplication") << " rand= " << G4UniformRand();
 
   auto& sTk = m_runManagerWorker->sensTkDetectors();
   auto& sCalo = m_runManagerWorker->sensCaloDetectors();
 
   std::unique_ptr<G4SimEvent> evt;
   try {
     auto token = edm::ServiceRegistry::instance().presentToken();
     m_handoff.runAndWait([this, &e, &es, &evt, token, engine]() {
       edm::ServiceRegistry::Operate guard{token};
       StaticRandomEngineSetUnset random(engine);
       evt = m_runManagerWorker->produce(e, es, globalCache()->runManagerMaster());
     });
   } catch (const SimG4Exception& simg4ex) {
     edm::LogWarning("SimG4CoreApplication") << "SimG4Exception caght! " << simg4ex.what();
 
     throw edm::Exception(edm::errors::EventCorruption)
         << "SimG4CoreApplication exception in generation of event " << e.id() << " in stream " << e.streamID() << " \n"
         << simg4ex.what();
   }
 
   std::unique_ptr<edm::SimTrackContainer> p1(new edm::SimTrackContainer);
   std::unique_ptr<edm::SimVertexContainer> p2(new edm::SimVertexContainer);
   evt->load(*p1);
   evt->load(*p2);
 
   e.put(std::move(p1));
   e.put(std::move(p2));
 
   for (auto& tracker : sTk) {
     const std::vector<std::string>& v = tracker->getNames();
     for (auto& name : v) {
       std::unique_ptr<edm::PSimHitContainer> product(new edm::PSimHitContainer);
       tracker->fillHits(*product, name);
       if (product != nullptr && !product->empty())
         edm::LogVerbatim("SimG4CoreApplication") << "Produced " << product->size() << " tracker hits <" << name << ">";
       e.put(std::move(product), name);
     }
   }
   for (auto& calo : sCalo) {
     const std::vector<std::string>& v = calo->getNames();
 
     for (auto& name : v) {
       std::unique_ptr<edm::PCaloHitContainer> product(new edm::PCaloHitContainer);
       calo->fillHits(*product, name);
       if (product != nullptr && !product->empty())
         edm::LogVerbatim("SimG4CoreApplication") << "Produced " << product->size() << " calo hits <" << name << ">";
       e.put(std::move(product), name);
     }
   }
 
   auto& producers = m_runManagerWorker->producers();
   for (auto& prod : producers) {
     prod.get()->produce(e, es);
   }
   edm::LogVerbatim("SimG4CoreApplication") << "Event is produced " << e.id() << " stream " << e.streamID();
   //edm::LogVerbatim("SimG4CoreApplication") << " rand= " << G4UniformRand();
 }