RunManagerMTWorker Class Reference

#include <RunManagerMTWorker.h>

Classes
struct	TLSData

Public Member Functions
void	abortEvent ()
void	abortRun (bool softAbort=false)
void	beginRun (const RunManagerMT &runManagerMaster, const edm::EventSetup &es)
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, const 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 (const RunManagerMT &runManagerMaster, const edm::EventSetup &es)
void	initializeTLS ()
void	initializeUserActions ()
void	resetGenParticleId (const edm::Event &inpevt)
void	terminateRun ()

Private Attributes
const int	m_EvtMgrVerbosity
Generator	m_generator
edm::EDGetTokenT < edm::HepMCProduct >	m_InToken
const 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
const bool	m_pUseMagneticField
std::unique_ptr< G4SimEvent >	m_simEvent
edm::EDGetTokenT < edm::LHCTransportLinkContainer >	m_theLHCTlinkToken

Static Private Attributes
static thread_local TLSData *	m_tls = 0

Detailed Description

Definition at line 38 of file RunManagerMTWorker.h.

Constructor & Destructor Documentation

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

Definition at line 130 of file RunManagerMTWorker.cc.

References initializeTLS().

                                                                                               :
  m_generator(iConfig.getParameter<edm::ParameterSet>("Generator")),
  m_InToken(iC.consumes<edm::HepMCProduct>(iConfig.getParameter<edm::ParameterSet>("Generator").getParameter<std::string>("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();
}

RunManagerMTWorker::~RunManagerMTWorker

(

)

Definition at line 149 of file RunManagerMTWorker.cc.

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

                                        {
  if(!(m_tls && m_tls->runTerminated)) { terminateRun(); }
  // RunManagerMT has 'delete m_runInterface' in the destructor, but
  // doesn't make much sense here because it is thread_local and we're
  // not guaranteed to run the destructor on each of the threads.
}

Member Function Documentation

void RunManagerMTWorker::abortEvent

(

)

Definition at line 444 of file RunManagerMTWorker.cc.

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

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

                                    {
  if(m_tls->runTerminated) { return; }
  G4RunManagerKernel *kernel = G4WorkerRunManagerKernel::GetRunManagerKernel();
  G4Track* t = kernel->GetEventManager()->GetTrackingManager()->GetTrack();
  t->SetTrackStatus(fStopAndKill) ;

  // CMS-specific act
  //
  TrackingAction* uta =
    static_cast<TrackingAction *>(kernel->GetEventManager()->GetUserTrackingAction());
  uta->PostUserTrackingAction(t) ;

  m_tls->currentEvent->SetEventAborted();

  // do NOT call this method for now
  // because it'll set abortRequested=true (withing G4EventManager)
  // this will make Geant4, in the event *next* after the aborted one
  // NOT to get the primary, thus there's NOTHING to trace, and it goes
  // to the end of G4Event::DoProcessing(G4Event*), where abortRequested
  // will be reset to true again
  //
  //kernel->GetEventManager()->AbortCurrentEvent();
  //
  // instead, mimic what it does, except (re)setting abortRequested
  //
  kernel->GetEventManager()->GetStackManager()->clear() ;
  kernel->GetEventManager()->GetTrackingManager()->EventAborted() ;

  G4StateManager* stateManager = G4StateManager::GetStateManager();
  stateManager->SetNewState(G4State_GeomClosed);
}

void RunManagerMTWorker::abortRun

(

bool

softAbort = false

)

Definition at line 476 of file RunManagerMTWorker.cc.

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

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

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

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

void RunManagerMTWorker::Connect

(

RunAction *

runAction

)

Definition at line 317 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 323 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 329 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 335 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

(

void

)

Definition at line 156 of file RunManagerMTWorker.cc.

References terminateRun().

                                {
  terminateRun();
}

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

private

Definition at line 482 of file RunManagerMTWorker.cc.

References RunManagerMTWorker::TLSData::currentEvent, edm::EventID::event(), edm::Event::getByToken(), 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 340 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 358 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 ( const RunManagerMT &  runManagerMaster, const edm::EventSetup &  es  )

private

Definition at line 179 of file RunManagerMTWorker.cc.

References SimActivityRegistry::beginOfJobSignal_, RunManagerMT::catalog(), RunManagerMT::chordFinderSetterForWorker(), AttachSD::create(), Exception, RunManagerMTWorker::TLSData::fieldBuilder, g, edm::EventSetup::get(), edm::ParameterSet::getUntrackedParameter(), DDDWorld::GetWorldVolumeForWorker(), initializeTLS(), initializeUserActions(), m_p, m_pCustomUIsession, m_pField, m_pUseMagneticField, m_tls, RunManagerMT::physicsListForWorker(), edm::ESHandle< class >::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();

  // 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 cms::Exception("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
  G4RunManagerKernel *kernel = G4WorkerRunManagerKernel::GetRunManagerKernel();
  if(!kernel) kernel = new G4WorkerRunManagerKernel();

  // 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);

      m_tls->fieldBuilder.reset(new sim::FieldBuilder(pMF.product(), m_pField));
      G4TransportationManager * tM =
    G4TransportationManager::GetTransportationManager();
      m_tls->fieldBuilder->build( tM->GetFieldManager(),
                                  tM->GetPropagatorInField(),
                                  runManagerMaster.chordFinderSetterForWorker());
    }


  // 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();
  kernel->SetPhysics(physicsList);
  kernel->InitializePhysics();

  const bool kernelInit = 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);

  initializeUserActions();
  /*
  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 160 of file RunManagerMTWorker.cc.

References SimActivityRegistry::connect(), createWatchers(), Exception, 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 cms::Exception("Unsupported") << "SimActivityRegistry service (i.e. visualization) is not supported for more than 1 thread. If this use case is needed, RunManagerMTWorker has to be updated.";
    }
  }

  createWatchers(m_p, m_tls->registry, m_tls->watchers, m_tls->producers, thisID);
}

void RunManagerMTWorker::initializeUserActions ( )

private

Definition at line 287 of file RunManagerMTWorker.cc.

References Connect(), m_EvtMgrVerbosity, m_pEventAction, m_pRunAction, m_pStackingAction, m_pSteppingAction, m_pTrackingAction, m_tls, RunManagerMTWorker::TLSData::runInterface, 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()));
  m_tls->userRunAction->SetMaster(false);
  Connect(m_tls->userRunAction.get());

  G4RunManagerKernel *kernel = G4WorkerRunManagerKernel::GetRunManagerKernel();
  G4EventManager * eventManager = kernel->GetEventManager();
  eventManager->SetVerboseLevel(m_EvtMgrVerbosity);

  EventAction * userEventAction =
    new EventAction(m_pEventAction, m_tls->runInterface.get(), m_tls->trackManager.get());
  Connect(userEventAction);
  eventManager->SetUserAction(userEventAction);

  TrackingAction* userTrackingAction =
    new TrackingAction(userEventAction,m_pTrackingAction);
  Connect(userTrackingAction);
  eventManager->SetUserAction(userTrackingAction);

  SteppingAction* userSteppingAction =
    new SteppingAction(userEventAction,m_pSteppingAction); 
  Connect(userSteppingAction);
  eventManager->SetUserAction(userSteppingAction);

  eventManager->SetUserAction(new StackingAction(userTrackingAction,
                         m_pStackingAction));

}

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

Definition at line 379 of file RunManagerMTWorker.cc.

References abortRun(), RunManagerMTWorker::TLSData::currentEvent, RunManagerMTWorker::TLSData::currentRunNumber, edm::EventID::event(), Generator::eventWeight(), generateEvent(), Generator::genEvent(), Generator::genVertex(), edm::EventBase::id(), initializeRun(), initializeThread(), LogDebug, m_generator, m_simEvent, m_tls, edm::EventID::run(), RunManagerMTWorker::TLSData::runInterface, RunManagerMTWorker::TLSData::runTerminated, edm::second(), contentValuesCheck::ss, 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() !=0 ) {
    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) {
    edm::LogError("SimG4CoreApplication") 
      << " RunManagerMT::produce event " << inpevt.id().event()
      << " with no G4PrimaryVertices \n  Aborting Run" ;
       
    abortRun(false);
  } else {
    G4RunManagerKernel *kernel = G4WorkerRunManagerKernel::GetRunManagerKernel();
    if(!kernel) {
      std::stringstream ss;
      ss << "No G4WorkerRunManagerKernel yet for thread index" << getThreadIndex() << ", id " << std::hex << std::this_thread::get_id();
      throw SimG4Exception(ss.str());
    }
    kernel->GetEventManager()->ProcessOneEvent(m_tls->currentEvent.get());
  }
    
  edm::LogInfo("SimG4CoreApplication")
    << " RunManagerMTWorker: saved : 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 ";
}

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

(

)

Definition at line 352 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 513 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 348 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 344 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 m_simEvent.

Referenced by SimRunInterface::simEvent().

{ return m_simEvent.get(); }

void RunManagerMTWorker::terminateRun ( )

private

Definition at line 364 of file RunManagerMTWorker.cc.

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

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

                                      {
  if(m_tls && m_tls->userRunAction) {
    m_tls->userRunAction->EndOfRunAction(m_tls->currentRun.get());
    m_tls->userRunAction.reset();
  }

  G4RunManagerKernel *kernel = G4WorkerRunManagerKernel::GetRunManagerKernel();
  if(kernel && m_tls && !m_tls->runTerminated) {
    m_tls->currentEvent.reset();
    m_simEvent.reset();
    kernel->RunTermination();
    m_tls->runTerminated = true;
  }
}

Member Data Documentation

const int RunManagerMTWorker::m_EvtMgrVerbosity

private

Definition at line 78 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

Generator RunManagerMTWorker::m_generator

private

Definition at line 73 of file RunManagerMTWorker.h.

Referenced by generateEvent(), and produce().

edm::EDGetTokenT<edm::HepMCProduct> RunManagerMTWorker::m_InToken

private

Definition at line 74 of file RunManagerMTWorker.h.

Referenced by generateEvent().

const bool RunManagerMTWorker::m_nonBeam

private

Definition at line 76 of file RunManagerMTWorker.h.

Referenced by generateEvent().

edm::ParameterSet RunManagerMTWorker::m_p

private

Definition at line 86 of file RunManagerMTWorker.h.

Referenced by initializeThread(), and initializeTLS().

edm::ParameterSet RunManagerMTWorker::m_pCustomUIsession

private

Definition at line 85 of file RunManagerMTWorker.h.

Referenced by initializeThread().

edm::ParameterSet RunManagerMTWorker::m_pEventAction

private

Definition at line 81 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManagerMTWorker::m_pField

private

Definition at line 79 of file RunManagerMTWorker.h.

Referenced by initializeThread().

edm::ParameterSet RunManagerMTWorker::m_pRunAction

private

Definition at line 80 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManagerMTWorker::m_pStackingAction

private

Definition at line 82 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManagerMTWorker::m_pSteppingAction

private

Definition at line 84 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManagerMTWorker::m_pTrackingAction

private

Definition at line 83 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

const bool RunManagerMTWorker::m_pUseMagneticField

private

Definition at line 77 of file RunManagerMTWorker.h.

Referenced by initializeThread().

std::unique_ptr<G4SimEvent> RunManagerMTWorker::m_simEvent

private

Definition at line 91 of file RunManagerMTWorker.h.

Referenced by generateEvent(), produce(), simEvent(), and terminateRun().

edm::EDGetTokenT<edm::LHCTransportLinkContainer> RunManagerMTWorker::m_theLHCTlinkToken

private

Definition at line 75 of file RunManagerMTWorker.h.

Referenced by resetGenParticleId().

thread_local RunManagerMTWorker::TLSData * RunManagerMTWorker::m_tls = 0

staticprivate

Definition at line 88 of file RunManagerMTWorker.h.

Referenced by abortEvent(), abortRun(), Connect(), generateEvent(), GetSimTrackManager(), initializeRun(), initializeThread(), initializeTLS(), initializeUserActions(), produce(), producers(), resetGenParticleId(), sensCaloDetectors(), sensTkDetectors(), terminateRun(), and ~RunManagerMTWorker().