#include <RunManagerMTWorker.h>

Classes
struct	TLSData

Public Member Functions
void	abortEvent ()

void	abortRun (bool softAbort=false)

void	Connect (RunAction *)

void	Connect (EventAction *)

void	Connect (TrackingAction *)

void	Connect (SteppingAction *)

void	endRun ()

SimTrackManager *	GetSimTrackManager ()

void	produce (const edm::Event &inpevt, const edm::EventSetup &es, RunManagerMT &runManagerMaster)

std::vector< std::shared_ptr< SimProducer > >	producers ()

	RunManagerMTWorker (const edm::ParameterSet &iConfig, edm::ConsumesCollector &&i)

std::vector< SensitiveCaloDetector * > &	sensCaloDetectors ()

std::vector< SensitiveTkDetector * > &	sensTkDetectors ()

G4SimEvent *	simEvent ()

	~RunManagerMTWorker ()

Private Member Functions
G4Event *	generateEvent (const edm::Event &inpevt)

void	initializeRun ()

void	initializeThread (RunManagerMT &runManagerMaster, const edm::EventSetup &es)

void	initializeTLS ()

void	initializeUserActions ()

void	resetGenParticleId (const edm::Event &inpevt)

void	terminateRun ()

Private Attributes
int	m_EvtMgrVerbosity

Generator	m_generator

bool	m_hasWatchers

edm::EDGetTokenT< edm::HepMCProduct >	m_InToken

bool	m_nonBeam

edm::ParameterSet	m_p

edm::ParameterSet	m_pCustomUIsession

edm::ParameterSet	m_pEventAction

edm::ParameterSet	m_pField

edm::ParameterSet	m_pRunAction

edm::ParameterSet	m_pStackingAction

edm::ParameterSet	m_pSteppingAction

edm::ParameterSet	m_pTrackingAction

bool	m_pUseMagneticField

std::unique_ptr< G4SimEvent >	m_simEvent

std::unique_ptr< CMSSteppingVerbose >	m_sVerbose

edm::EDGetTokenT< edm::LHCTransportLinkContainer >	m_theLHCTlinkToken

Static Private Attributes
static thread_local TLSData *	m_tls = 0

Detailed Description

Definition at line 39 of file RunManagerMTWorker.h.

Constructor & Destructor Documentation

RunManagerMTWorker::RunManagerMTWorker	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &&	i
	)

explicit

Definition at line 134 of file RunManagerMTWorker.cc.

References edm::ParameterSet::getParameter(), initializeTLS(), m_hasWatchers, m_simEvent, and m_sVerbose.

                                                                                                :
   m_generator(iConfig.getParameter<edm::ParameterSet>("Generator")),
   m_InToken(iC.consumes<edm::HepMCProduct>(iConfig.getParameter<edm::ParameterSet>("Generator").getParameter<edm::InputTag>("HepMCProductLabel"))),
   m_theLHCTlinkToken(iC.consumes<edm::LHCTransportLinkContainer>(iConfig.getParameter<edm::InputTag>("theLHCTlinkTag"))),
   m_nonBeam(iConfig.getParameter<bool>("NonBeamEvent")),
   m_pUseMagneticField(iConfig.getParameter<bool>("UseMagneticField")),
   m_EvtMgrVerbosity(iConfig.getUntrackedParameter<int>("G4EventManagerVerbosity",0)),
   m_pField(iConfig.getParameter<edm::ParameterSet>("MagneticField")),
   m_pRunAction(iConfig.getParameter<edm::ParameterSet>("RunAction")),
   m_pEventAction(iConfig.getParameter<edm::ParameterSet>("EventAction")),
   m_pStackingAction(iConfig.getParameter<edm::ParameterSet>("StackingAction")),
   m_pTrackingAction(iConfig.getParameter<edm::ParameterSet>("TrackingAction")),
   m_pSteppingAction(iConfig.getParameter<edm::ParameterSet>("SteppingAction")),
   m_pCustomUIsession(iConfig.getUntrackedParameter<edm::ParameterSet>("CustomUIsession")),
   m_p(iConfig)
 {
   initializeTLS();
   m_simEvent.reset(nullptr);
   m_sVerbose.reset(nullptr);
   std::vector<edm::ParameterSet> watchers = 
     iConfig.getParameter<std::vector<edm::ParameterSet> >("Watchers");
   m_hasWatchers = (watchers.empty()) ? false : true;
 }

RunManagerMTWorker::~RunManagerMTWorker ( )

Definition at line 158 of file RunManagerMTWorker.cc.

References m_tls, RunManagerMTWorker::TLSData::runTerminated, and terminateRun().

                                         {
   if(m_tls && !m_tls->runTerminated) { terminateRun(); }
 }

Member Function Documentation

void RunManagerMTWorker::abortEvent ( )

Definition at line 478 of file RunManagerMTWorker.cc.

References RunManagerMTWorker::TLSData::currentEvent, RunManagerMTWorker::TLSData::kernel, m_tls, TrackingAction::PostUserTrackingAction(), RunManagerMTWorker::TLSData::runTerminated, and lumiQTWidget::t.

Referenced by SimRunInterface::abortEvent(), and abortRun().

                                     {
   if(m_tls->runTerminated) { return; }
   G4Track* t = m_tls->kernel->GetEventManager()->GetTrackingManager()->GetTrack();
   t->SetTrackStatus(fStopAndKill) ;
 
   // CMS-specific act
   //
   TrackingAction* uta =
     static_cast<TrackingAction *>(m_tls->kernel->GetEventManager()->GetUserTrackingAction());
   uta->PostUserTrackingAction(t) ;
 
   m_tls->currentEvent->SetEventAborted();
   m_tls->kernel->GetEventManager()->GetStackManager()->clear();
   m_tls->kernel->GetEventManager()->GetTrackingManager()->EventAborted();
 }

void RunManagerMTWorker::abortRun ( bool softAbort = false )

Definition at line 494 of file RunManagerMTWorker.cc.

References abortEvent(), RunManagerMTWorker::TLSData::currentRun, m_tls, and terminateRun().

Referenced by SimRunInterface::abortRun().

                                                 {
   if (!softAbort) { abortEvent(); }
   m_tls->currentRun.reset();
   terminateRun();
 }

void RunManagerMTWorker::Connect ( RunAction * runAction )

Definition at line 342 of file RunManagerMTWorker.cc.

References SimActivityRegistry::beginOfRunSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfRunSignal_, RunAction::m_beginOfRunSignal, RunAction::m_endOfRunSignal, m_tls, and RunManagerMTWorker::TLSData::registry.

Referenced by SimRunInterface::Connect(), and initializeUserActions().

 {
   runAction->m_beginOfRunSignal.connect(m_tls->registry.beginOfRunSignal_);
   runAction->m_endOfRunSignal.connect(m_tls->registry.endOfRunSignal_);
 }

void RunManagerMTWorker::Connect ( EventAction * eventAction )

Definition at line 348 of file RunManagerMTWorker.cc.

References SimActivityRegistry::beginOfEventSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfEventSignal_, EventAction::m_beginOfEventSignal, EventAction::m_endOfEventSignal, m_tls, and RunManagerMTWorker::TLSData::registry.

 {
   eventAction->m_beginOfEventSignal.connect(m_tls->registry.beginOfEventSignal_);
   eventAction->m_endOfEventSignal.connect(m_tls->registry.endOfEventSignal_);
 }

void RunManagerMTWorker::Connect ( TrackingAction * trackingAction )

Definition at line 354 of file RunManagerMTWorker.cc.

References SimActivityRegistry::beginOfTrackSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfTrackSignal_, TrackingAction::m_beginOfTrackSignal, TrackingAction::m_endOfTrackSignal, m_tls, and RunManagerMTWorker::TLSData::registry.

 {
   trackingAction->m_beginOfTrackSignal.connect(m_tls->registry.beginOfTrackSignal_);
   trackingAction->m_endOfTrackSignal.connect(m_tls->registry.endOfTrackSignal_);
 }

void RunManagerMTWorker::Connect ( SteppingAction * steppingAction )

Definition at line 360 of file RunManagerMTWorker.cc.

References sim_act::Signaler< T >::connect(), SimActivityRegistry::g4StepSignal_, SteppingAction::m_g4StepSignal, m_tls, and RunManagerMTWorker::TLSData::registry.

 {
   steppingAction->m_g4StepSignal.connect(m_tls->registry.g4StepSignal_);
 }

void RunManagerMTWorker::endRun ( )

Definition at line 162 of file RunManagerMTWorker.cc.

References terminateRun().

                                 {
   terminateRun();
 }

G4Event * RunManagerMTWorker::generateEvent ( const edm::Event & inpevt )

private

Definition at line 500 of file RunManagerMTWorker.cc.

References RunManagerMTWorker::TLSData::currentEvent, edm::EventID::event(), runTauDisplay::evtid, edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), Generator::HepMC2G4(), edm::EventBase::id(), m_generator, m_InToken, m_nonBeam, m_simEvent, m_tls, Generator::nonBeamEvent2G4(), resetGenParticleId(), and Generator::setGenEvent().

Referenced by produce().

                                                                   {
   m_tls->currentEvent.reset();
   m_simEvent.reset();
 
   // 64 bits event ID in CMSSW converted into Geant4 event ID
   G4int evtid = (G4int)inpevt.id().event();
   G4Event * evt = new G4Event(evtid);
 
   edm::Handle<edm::HepMCProduct> HepMCEvt;
 
   inpevt.getByToken(m_InToken, HepMCEvt);
 
   m_generator.setGenEvent(HepMCEvt->GetEvent());
 
   // required to reset the GenParticle Id for particles transported
   // along the beam pipe
   // to their original value for SimTrack creation
   resetGenParticleId( inpevt );
 
   if (!m_nonBeam) 
     {
       m_generator.HepMC2G4(HepMCEvt->GetEvent(),evt);
     }
   else 
     {
       m_generator.nonBeamEvent2G4(HepMCEvt->GetEvent(),evt);
     }
 
   return evt;
 }

SimTrackManager * RunManagerMTWorker::GetSimTrackManager ( )

Definition at line 365 of file RunManagerMTWorker.cc.

References initializeTLS(), m_tls, and RunManagerMTWorker::TLSData::trackManager.

Referenced by SimRunInterface::SimRunInterface().

                                                         {
   initializeTLS();
   return m_tls->trackManager.get();
 }

void RunManagerMTWorker::initializeRun ( )

private

Definition at line 382 of file RunManagerMTWorker.cc.

References RunManagerMTWorker::TLSData::currentRun, m_tls, and RunManagerMTWorker::TLSData::userRunAction.

Referenced by produce().

                                        {
   m_tls->currentRun.reset(new G4Run());
   G4StateManager::GetStateManager()->SetNewState(G4State_GeomClosed);
   if (m_tls->userRunAction) { m_tls->userRunAction->BeginOfRunAction(m_tls->currentRun.get()); }
 }

void RunManagerMTWorker::initializeThread	(	RunManagerMT &	runManagerMaster,
		const edm::EventSetup &	es
	)

private

Definition at line 185 of file RunManagerMTWorker.cc.

References SimActivityRegistry::beginOfJobSignal_, RunManagerMT::catalog(), mps_check::command, edm::errors::Configuration, AttachSD::create(), g4SimHits_cfi::CustomUIsession, Exception, g, RunManagerMT::G4Commands(), edm::EventSetup::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), DDDWorld::GetWorldVolumeForWorker(), GeV, initializeTLS(), initializeUserActions(), RunManagerMTWorker::TLSData::kernel, m_p, m_pCustomUIsession, m_pField, m_pUseMagneticField, m_sVerbose, m_tls, RunManagerMT::physicsListForWorker(), edm::ESHandle< T >::product(), RunManagerMTWorker::TLSData::registry, RunManagerMTWorker::TLSData::sensCaloDets, RunManagerMTWorker::TLSData::sensTkDets, AlCaHLTBitMon_QueryRunRegistry::string, RunManagerMTWorker::TLSData::trackManager, RunManagerMTWorker::TLSData::UIsession, DDDWorld::WorkerSetAsWorld(), and RunManagerMT::world().

Referenced by produce().

                                                                                                  {
   // I guess everything initialized here should be in thread_local storage
   initializeTLS();
 
   int thisID = getThreadIndex();
 
   edm::LogInfo("SimG4CoreApplication")
     << "RunManagerMTWorker::initializeThread " << thisID;
 
   // Initialize per-thread output
   G4Threading::G4SetThreadId( thisID );
   G4UImanager::GetUIpointer()->SetUpForAThread( thisID );
   const std::string& uitype = m_pCustomUIsession.getUntrackedParameter<std::string>("Type");
   if(uitype == "MessageLogger") {
     m_tls->UIsession.reset(new CustomUIsession());
   }
   else if(uitype == "MessageLoggerThreadPrefix") {
     m_tls->UIsession.reset(new CustomUIsessionThreadPrefix(m_pCustomUIsession.getUntrackedParameter<std::string>("ThreadPrefix"), thisID));
   }
   else if(uitype == "FilePerThread") {
     m_tls->UIsession.reset(new CustomUIsessionToFile(m_pCustomUIsession.getUntrackedParameter<std::string>("ThreadFile"), thisID));
   }
   else {
     throw edm::Exception(edm::errors::Configuration) 
       << "Invalid value of CustomUIsession.Type '" << uitype 
       << "', valid are MessageLogger, MessageLoggerThreadPrefix, FilePerThread";
   }
 
   // Initialize worker part of shared resources (geometry, physics)
   G4WorkerThread::BuildGeometryAndPhysicsVector();
 
   // Create worker run manager
   m_tls->kernel = G4WorkerRunManagerKernel::GetRunManagerKernel();
   if(!m_tls->kernel) { m_tls->kernel = new G4WorkerRunManagerKernel(); }
 
   // Define G4 exception handler
   G4StateManager::GetStateManager()->SetExceptionHandler(new ExceptionHandler());
 
   // Set the geometry for the worker, share from master
   DDDWorld::WorkerSetAsWorld(runManagerMaster.world().GetWorldVolumeForWorker());
 
   // we need the track manager now
   m_tls->trackManager.reset(new SimTrackManager());
 
   // Get DDCompactView, or would it be better to get the object from
   // runManagerMaster instead of EventSetup in here?
   edm::ESTransientHandle<DDCompactView> pDD;
   es.get<IdealGeometryRecord>().get(pDD);
 
   // setup the magnetic field
   if (m_pUseMagneticField)
     {
       const GlobalPoint g(0.,0.,0.);
 
       edm::ESHandle<MagneticField> pMF;
       es.get<IdealMagneticFieldRecord>().get(pMF);
 
       sim::FieldBuilder fieldBuilder(pMF.product(), m_pField);
       CMSFieldManager* fieldManager = new CMSFieldManager();
       G4TransportationManager * tM =
     G4TransportationManager::GetTransportationManager();
       tM->SetFieldManager(fieldManager);
       fieldBuilder.build( fieldManager, tM->GetPropagatorInField());
     }
 
   // attach sensitive detector
   AttachSD attach;
   std::pair< std::vector<SensitiveTkDetector*>,
     std::vector<SensitiveCaloDetector*> > sensDets =
     attach.create(runManagerMaster.world(),
                   (*pDD),
                   runManagerMaster.catalog(),
                   m_p,
                   m_tls->trackManager.get(),
                   m_tls->registry);
 
   m_tls->sensTkDets.swap(sensDets.first);
   m_tls->sensCaloDets.swap(sensDets.second);
 
   edm::LogInfo("SimG4CoreApplication")
     << " RunManagerMTWorker: Sensitive Detector "
     << "building finished; found "
     << m_tls->sensTkDets.size()
     << " Tk type Producers, and "
     << m_tls->sensCaloDets.size()
     << " Calo type producers ";
 
   // Set the physics list for the worker, share from master
   PhysicsList *physicsList = runManagerMaster.physicsListForWorker();
 
   edm::LogInfo("SimG4CoreApplication") 
     << "RunManagerMTWorker: start initialisation of PhysicsList for a thread";
 
   physicsList->InitializeWorker();
   m_tls->kernel->SetPhysics(physicsList);
   m_tls->kernel->InitializePhysics();
 
   const bool kernelInit = m_tls->kernel->RunInitialization();
   if(!kernelInit) {
     throw SimG4Exception("G4WorkerRunManagerKernel initialization failed");
   }
   //tell all interesting parties that we are beginning the job
   BeginOfJob aBeginOfJob(&es);
   m_tls->registry.beginOfJobSignal_(&aBeginOfJob);
 
   G4int sv = m_p.getParameter<int>("SteppingVerbosity");
   G4double elim = m_p.getParameter<double>("StepVerboseThreshold")*CLHEP::GeV;
   std::vector<int> ve = m_p.getParameter<std::vector<int> >("VerboseEvents");
   std::vector<int> vn = m_p.getParameter<std::vector<int> >("VertexNumber");
   std::vector<int> vt = m_p.getParameter<std::vector<int> >("VerboseTracks");
 
   if(sv > 0) {
     m_sVerbose.reset(new CMSSteppingVerbose(sv, elim, ve, vn, vt));
   }
   initializeUserActions();
 
   edm::LogInfo("SimG4CoreApplication")
     << "RunManagerMTWorker::initializeThread done for the thread " << thisID;
 
   for(const std::string& command: runManagerMaster.G4Commands()) {
     edm::LogInfo("SimG4CoreApplication") << "RunManagerMTWorker:: Requests UI: "
                                          << command;
     G4UImanager::GetUIpointer()->ApplyCommand(command);
   }
 }

void RunManagerMTWorker::initializeTLS ( )

private

Definition at line 166 of file RunManagerMTWorker.cc.

References edm::errors::Configuration, SimActivityRegistry::connect(), createWatchers(), Exception, m_hasWatchers, m_p, m_tls, RunManagerMTWorker::TLSData::producers, RunManagerMTWorker::TLSData::registry, and RunManagerMTWorker::TLSData::watchers.

Referenced by GetSimTrackManager(), initializeThread(), producers(), RunManagerMTWorker(), sensCaloDetectors(), and sensTkDetectors().

                                        {
   if(m_tls) { return; }
   m_tls = new TLSData;
 
   edm::Service<SimActivityRegistry> otherRegistry;
   //Look for an outside SimActivityRegistry
   // this is used by the visualization code
   int thisID = getThreadIndex();
   if(otherRegistry){
     m_tls->registry.connect(*otherRegistry);
     if(thisID > 0) {
       throw edm::Exception(edm::errors::Configuration) << "SimActivityRegistry service (i.e. visualization) is not supported for more than 1 thread. If this use case is needed, RunManagerMTWorker has to be updated.";
     }
   }
   if(m_hasWatchers) {
     createWatchers(m_p, m_tls->registry, m_tls->watchers, m_tls->producers, thisID);
   }
 }

void RunManagerMTWorker::initializeUserActions ( )

private

Definition at line 311 of file RunManagerMTWorker.cc.

References Connect(), g4SimHits_cfi::EventAction, RunManagerMTWorker::TLSData::kernel, m_EvtMgrVerbosity, m_hasWatchers, m_pEventAction, m_pRunAction, m_pStackingAction, m_pSteppingAction, m_pTrackingAction, m_sVerbose, m_tls, g4SimHits_cfi::RunAction, RunManagerMTWorker::TLSData::runInterface, CastorDigiValidation::StackingAction, CastorDigiValidation::SteppingAction, g4SimHits_cfi::TrackingAction, RunManagerMTWorker::TLSData::trackManager, and RunManagerMTWorker::TLSData::userRunAction.

Referenced by initializeThread().

                                                {
   m_tls->runInterface.reset(new SimRunInterface(this, false));
   m_tls->userRunAction.reset(new RunAction(m_pRunAction, 
                        m_tls->runInterface.get(),false));
   m_tls->userRunAction->SetMaster(false);
   Connect(m_tls->userRunAction.get());
 
   G4EventManager * eventManager = m_tls->kernel->GetEventManager();
   eventManager->SetVerboseLevel(m_EvtMgrVerbosity);
 
   EventAction * userEventAction =
     new EventAction(m_pEventAction, m_tls->runInterface.get(), 
             m_tls->trackManager.get(), m_sVerbose.get());
   Connect(userEventAction);
   eventManager->SetUserAction(userEventAction);
 
   TrackingAction* userTrackingAction =
     new TrackingAction(userEventAction, m_pTrackingAction, m_sVerbose.get());
   Connect(userTrackingAction);
   eventManager->SetUserAction(userTrackingAction);
 
   SteppingAction* userSteppingAction =
     new SteppingAction(userEventAction,m_pSteppingAction,m_sVerbose.get(),m_hasWatchers); 
   Connect(userSteppingAction);
   eventManager->SetUserAction(userSteppingAction);
 
   eventManager->SetUserAction(new StackingAction(userTrackingAction,
                          m_pStackingAction,m_sVerbose.get()));
 
 }

void RunManagerMTWorker::produce	(	const edm::Event &	inpevt,
		const edm::EventSetup &	es,
		RunManagerMT &	runManagerMaster
	)

Definition at line 404 of file RunManagerMTWorker.cc.

References RunManagerMTWorker::TLSData::currentEvent, RunManagerMTWorker::TLSData::currentRunNumber, edm::EventID::event(), Generator::eventWeight(), generateEvent(), Generator::genEvent(), Generator::genVertex(), edm::EventBase::id(), initializeRun(), initializeThread(), RunManagerMTWorker::TLSData::kernel, LogDebug, m_generator, m_simEvent, m_tls, nullptr, edm::EventID::run(), RunManagerMTWorker::TLSData::runInterface, RunManagerMTWorker::TLSData::runTerminated, edm::second(), edm::Event::streamID(), terminateRun(), and RunManagerMTWorker::TLSData::threadInitialized.

                                                                  {
   // The initialization and begin/end run is a bit convoluted due to
   // - Geant4 deals per-thread
   // - OscarMTProducer deals per-stream
   // and framework/TBB is free to schedule work in streams to the
   // threads as it likes.
   //
   // We have to do the per-thread initialization, and per-thread
   // per-run initialization here by ourselves. 
 
   if(!(m_tls && m_tls->threadInitialized)) {
     LogDebug("SimG4CoreApplication") 
       << "RunManagerMTWorker::produce(): stream " 
       << inpevt.streamID() << " thread " << getThreadIndex() << " initializing";
     initializeThread(runManagerMaster, es);
     m_tls->threadInitialized = true;
   }
   // Initialize run
   if(inpevt.id().run() != m_tls->currentRunNumber) {
     if(m_tls->currentRunNumber != 0 && !m_tls->runTerminated) {
       // If previous run in this thread was not terminated via endRun() call, terminate it now
       terminateRun();
     }
     initializeRun();
     m_tls->currentRunNumber = inpevt.id().run();
   }
   m_tls->runInterface->setRunManagerMTWorker(this); // For UserActions
 
   m_tls->currentEvent.reset(generateEvent(inpevt));
 
   m_simEvent.reset(new G4SimEvent());
   m_simEvent->hepEvent(m_generator.genEvent());
   m_simEvent->weight(m_generator.eventWeight());
   if (m_generator.genVertex() != nullptr ) {
     auto genVertex = m_generator.genVertex();
     m_simEvent->collisionPoint(
       math::XYZTLorentzVectorD(genVertex->x()/centimeter,
                    genVertex->y()/centimeter,
                    genVertex->z()/centimeter,
                    genVertex->t()/second));
   }
   if (m_tls->currentEvent->GetNumberOfPrimaryVertex()==0) {
     std::stringstream ss;
     ss << "RunManagerMTWorker::produce(): event " << inpevt.id().event()
        << " with no G4PrimaryVertices \n" ;
     throw SimG4Exception(ss.str());
 
   } else {
     if(!m_tls->kernel) {
       std::stringstream ss;
       ss << " RunManagerMT::produce(): "
      << " no G4WorkerRunManagerKernel yet for thread index" 
      << getThreadIndex() << ", id " << std::hex 
      << std::this_thread::get_id() << " \n";
       throw SimG4Exception(ss.str());
     }
 
     edm::LogInfo("SimG4CoreApplication")
       << " RunManagerMTWorker::produce: start Event " << inpevt.id().event() 
       << " stream id " << inpevt.streamID()
       << " thread index " << getThreadIndex()
       << " of weight " << m_simEvent->weight()
       << " with " << m_simEvent->nTracks() << " tracks and " 
       << m_simEvent->nVertices()
       << " vertices, generated by " << m_simEvent->nGenParts() << " particles ";
 
     m_tls->kernel->GetEventManager()->ProcessOneEvent(m_tls->currentEvent.get());
 
     edm::LogInfo("SimG4CoreApplication")
       << " RunManagerMTWorker::produce: ended Event " << inpevt.id().event(); 
   } 
 }

std::vector< std::shared_ptr< SimProducer > > RunManagerMTWorker::producers ( )

Definition at line 377 of file RunManagerMTWorker.cc.

References initializeTLS(), m_tls, and RunManagerMTWorker::TLSData::producers.

                                                                      {
   initializeTLS();
   return m_tls->producers;
 }

void RunManagerMTWorker::resetGenParticleId ( const edm::Event & inpevt )

private

Definition at line 531 of file RunManagerMTWorker.cc.

References edm::Event::getByToken(), edm::HandleBase::isValid(), m_theLHCTlinkToken, m_tls, edm::Handle< T >::product(), and RunManagerMTWorker::TLSData::trackManager.

Referenced by generateEvent().

 {
   edm::Handle<edm::LHCTransportLinkContainer> theLHCTlink;
   inpevt.getByToken( m_theLHCTlinkToken, theLHCTlink );
   if ( theLHCTlink.isValid() ) {
     m_tls->trackManager->setLHCTransportLink( theLHCTlink.product() );
   }
 }

std::vector< SensitiveCaloDetector * > & RunManagerMTWorker::sensCaloDetectors ( )

Definition at line 373 of file RunManagerMTWorker.cc.

References initializeTLS(), m_tls, and RunManagerMTWorker::TLSData::sensCaloDets.

                                                                          {
   initializeTLS();
   return m_tls->sensCaloDets; 
 }

std::vector< SensitiveTkDetector * > & RunManagerMTWorker::sensTkDetectors ( )

Definition at line 369 of file RunManagerMTWorker.cc.

References initializeTLS(), m_tls, and RunManagerMTWorker::TLSData::sensTkDets.

                                                                      {
   initializeTLS();
   return m_tls->sensTkDets; 
 }

G4SimEvent* RunManagerMTWorker::simEvent ( )

inline

Definition at line 51 of file RunManagerMTWorker.h.

References particleFlowRecHitECAL_cfi::producers.

Referenced by SimRunInterface::simEvent().

51 { return m_simEvent.get(); }

RunManagerMTWorker::m_simEvent

std::unique_ptr< G4SimEvent > m_simEvent

Definition: RunManagerMTWorker.h:96

void RunManagerMTWorker::terminateRun ( )

private

Definition at line 388 of file RunManagerMTWorker.cc.

References RunManagerMTWorker::TLSData::currentEvent, RunManagerMTWorker::TLSData::currentRun, RunManagerMTWorker::TLSData::kernel, m_simEvent, m_tls, RunManagerMTWorker::TLSData::runTerminated, and RunManagerMTWorker::TLSData::userRunAction.

Referenced by abortRun(), endRun(), RunManagerMT::physicsListForWorker(), produce(), and ~RunManagerMTWorker().

                                       {
   if(!m_tls || m_tls->runTerminated) { return; }
   if(m_tls->userRunAction) {
     m_tls->userRunAction->EndOfRunAction(m_tls->currentRun.get());
     m_tls->userRunAction.reset();
   }
   m_tls->currentEvent.reset();
   m_simEvent.reset();
 
   if(m_tls->kernel) {
     m_tls->kernel->RunTermination();
   }
 
   m_tls->runTerminated = true;
 }