#include <RunManagerMTWorker.h>

Classes
struct	TLSData

Public Member Functions
void	abortEvent ()

void	abortRun (bool softAbort=false)

void	beginRun (const edm::EventSetup &)

void	Connect (RunAction *)

void	Connect (EventAction *)

void	Connect (TrackingAction *)

void	Connect (SteppingAction *)

void	Connect (Phase2SteppingAction *)

void	endRun ()

SimTrackManager *	getSimTrackManager ()

int	getThreadIndex () const

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

TmpSimEvent *	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 &&iC)

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

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

TmpSimEvent *	simEvent ()

	~RunManagerMTWorker ()

Private Member Functions
void	DumpMagneticField (const G4Field *, const std::string &) const

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

void	initializeRun ()

void	initializeTLS ()

void	initializeUserActions ()

void	resetGenParticleId (const edm::Event &inpevt)

void	terminateRun ()

Private Attributes
bool	m_dumpGDML {false}

bool	m_dumpMF {false}

bool	m_endOfRun {false}

std::unique_ptr< CMSSimEventManager >	m_evtManager

std::vector< std::string >	m_G4Commands

std::vector< std::string >	m_G4CommandsEndRun

Generator	m_generator

bool	m_hasWatchers {false}

edm::EDGetTokenT< edm::HepMCProduct >	m_InToken

bool	m_isPhase2 {false}

edm::EDGetTokenT< edm::HepMCProduct >	m_LHCToken

bool	m_LHCTransport {false}

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	m_MagField

bool	m_nonBeam {false}

edm::ParameterSet	m_p

edm::ParameterSet	m_pEventAction

edm::ParameterSet	m_pField

const MagneticField *	m_pMagField {nullptr}

edm::ParameterSet	m_pRunAction

edm::ParameterSet	m_pStackingAction

edm::ParameterSet	m_pSteppingAction

edm::ParameterSet	m_pTrackingAction

bool	m_pUseMagneticField {true}

std::unordered_map< std::string, std::unique_ptr< SensitiveDetectorMakerBase > >	m_sdMakers

TmpSimEvent	m_simEvent

std::unique_ptr< CMSSteppingVerbose >	m_sVerbose

edm::EDGetTokenT< edm::LHCTransportLinkContainer >	m_theLHCTlinkToken

const int	m_thread_index {-1}

TLSData *	m_tls {nullptr}

CustomUIsession *	m_UIsession {nullptr}

bool	m_UseG4EventManager {true}

Detailed Description

Definition at line 51 of file RunManagerMTWorker.h.

Constructor & Destructor Documentation

◆ RunManagerMTWorker()

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

explicit

Definition at line 151 of file RunManagerMTWorker.cc.

     : m_generator(p.getParameter<edm::ParameterSet>("Generator")),
       m_InToken(iC.consumes<edm::HepMCProduct>(
           p.getParameter<edm::ParameterSet>("Generator").getParameter<edm::InputTag>("HepMCProductLabel"))),
       m_theLHCTlinkToken(iC.consumes<edm::LHCTransportLinkContainer>(p.getParameter<edm::InputTag>("theLHCTlinkTag"))),
       m_nonBeam(p.getParameter<bool>("NonBeamEvent")),
       m_UseG4EventManager(p.getParameter<bool>("UseG4EventManager")),
       m_pUseMagneticField(p.getParameter<bool>("UseMagneticField")),
       m_LHCTransport(p.getParameter<bool>("LHCTransport")),
       m_thread_index{(get_new_thread_index())},
       m_pField(p.getParameter<edm::ParameterSet>("MagneticField")),
       m_pRunAction(p.getParameter<edm::ParameterSet>("RunAction")),
       m_pEventAction(p.getParameter<edm::ParameterSet>("EventAction")),
       m_pStackingAction(p.getParameter<edm::ParameterSet>("StackingAction")),
       m_pTrackingAction(p.getParameter<edm::ParameterSet>("TrackingAction")),
       m_pSteppingAction(p.getParameter<edm::ParameterSet>("SteppingAction")),
       m_G4Commands(p.getParameter<std::vector<std::string>>("G4Commands")),
       m_G4CommandsEndRun(p.getParameter<std::vector<std::string>>("G4CommandsEndRun")),
       m_p(p) {
   int id = getThreadIndex();
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker for the thread " << id;
 
   // Initialize per-thread output
   G4Threading::G4SetThreadId(id);
   G4UImanager::GetUIpointer()->SetUpForAThread(id);
   auto iPset = p.getUntrackedParameter<edm::ParameterSet>("CustomUIsession");
   const std::string& uitype = iPset.getUntrackedParameter<std::string>("Type");
   if (uitype == "MessageLogger") {
     m_UIsession = new CustomUIsession();
   } else if (uitype == "MessageLoggerThreadPrefix") {
     m_UIsession = new CustomUIsessionThreadPrefix(iPset.getUntrackedParameter<std::string>("ThreadPrefix"), id);
   } else if (uitype == "FilePerThread") {
     m_UIsession = new CustomUIsessionToFile(iPset.getUntrackedParameter<std::string>("ThreadFile"), id);
   } else {
     throw cms::Exception("Configuration")
         << "RunManagerMTWorker::initializeG4: Invalid value of CustomUIsession.Type '" << uitype
         << "', valid are MessageLogger, MessageLoggerThreadPrefix, FilePerThread";
   }
   G4UImanager::GetUIpointer()->SetCoutDestination(m_UIsession);
 
   // sensitive detectors
   std::vector<std::string> onlySDs = p.getParameter<std::vector<std::string>>("OnlySDs");
   m_sdMakers = sim::sensitiveDetectorMakers(p, iC, onlySDs);
 
   // TLS and watchers
   initializeTLS();
   if (m_hasWatchers) {
     for (auto& watcher : m_tls->watchers) {
       watcher->registerConsumes(iC);
     }
   }
   if (m_LHCTransport) {
     m_LHCToken = iC.consumes<edm::HepMCProduct>(edm::InputTag("LHCTransport"));
   }
   if (m_pUseMagneticField) {
     m_MagField = iC.esConsumes<MagneticField, IdealMagneticFieldRecord, edm::Transition::BeginRun>();
   }
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker is constructed for the thread " << id;
   unsigned int k = 0;
   for (std::unordered_map<std::string, std::unique_ptr<SensitiveDetectorMakerBase>>::const_iterator itr =
            m_sdMakers.begin();
        itr != m_sdMakers.end();
        ++itr, ++k) {
     edm::LogVerbatim("SimG4CoreApplication") << "SD[" << k << "] " << itr->first;
   }
 }

◆ ~RunManagerMTWorker()

RunManagerMTWorker::~RunManagerMTWorker ( )

Definition at line 218 of file RunManagerMTWorker.cc.

References m_tls, and m_UIsession.

                                         {
   m_tls = nullptr;
   delete m_UIsession;
 }

Member Function Documentation

◆ abortEvent()

void RunManagerMTWorker::abortEvent ( )

Definition at line 612 of file RunManagerMTWorker.cc.

References RunManagerMTWorker::TLSData::currentEvent, RunManagerMTWorker::TLSData::kernel, m_tls, TrackingAction::PostUserTrackingAction(), RunManagerMTWorker::TLSData::runTerminated, and submitPVValidationJobs::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();
 }

◆ abortRun()

void RunManagerMTWorker::abortRun ( bool softAbort = false )

Definition at line 629 of file RunManagerMTWorker.cc.

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

Referenced by SimRunInterface::abortRun().

                                                 {
   if (!softAbort) {
     abortEvent();
   }
   m_tls->currentRun = nullptr;
   terminateRun();
 }

◆ beginRun()

void RunManagerMTWorker::beginRun ( const edm::EventSetup & es )

Definition at line 223 of file RunManagerMTWorker.cc.

References edm::EventSetup::getData(), getThreadIndex(), l1ctLayer2EG_cff::id, m_hasWatchers, m_MagField, m_pMagField, m_pUseMagneticField, m_sdMakers, m_tls, and RunManagerMTWorker::TLSData::watchers.

                                                          {
   int id = getThreadIndex();
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::beginRun for the thread " << id;
   for (auto& maker : m_sdMakers) {
     maker.second->beginRun(es);
   }
   if (m_pUseMagneticField) {
     m_pMagField = &es.getData(m_MagField);
   }
   if (m_hasWatchers) {
     for (auto& watcher : m_tls->watchers) {
       watcher->beginRun(es);
     }
   }
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::beginRun done for the thread " << id;
 }

◆ Connect() [1/5]

void RunManagerMTWorker::Connect ( RunAction * runAction )

Definition at line 468 of file RunManagerMTWorker.cc.

References sim_act::Signaler< T >::connect(), 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_);
 }

◆ Connect() [2/5]

void RunManagerMTWorker::Connect ( EventAction * eventAction )

Definition at line 473 of file RunManagerMTWorker.cc.

References sim_act::Signaler< T >::connect(), 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_);
 }

◆ Connect() [3/5]

void RunManagerMTWorker::Connect ( TrackingAction * trackingAction )

Definition at line 478 of file RunManagerMTWorker.cc.

References sim_act::Signaler< T >::connect(), 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_);
 }

◆ Connect() [4/5]

void RunManagerMTWorker::Connect ( SteppingAction * steppingAction )

Definition at line 483 of file RunManagerMTWorker.cc.

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

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

◆ Connect() [5/5]

void RunManagerMTWorker::Connect ( Phase2SteppingAction * steppingAction )

Definition at line 487 of file RunManagerMTWorker.cc.

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

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

◆ DumpMagneticField()

void RunManagerMTWorker::DumpMagneticField	(	const G4Field *	field,
		const std::string &	file
	)		const

private

Definition at line 675 of file RunManagerMTWorker.cc.

References funct::cos(), l1ctLayer1_cff::dr, PVValHelper::dz, geometryDiff::file, groupFilesInBlocks::fout, mps_fire::i, createfilelist::int, dqmiolumiharvest::j, EgHLTOffHistBins_cfi::nr, MillePedeFileConverter_cfg::out, phi, point, alignCSCRings::r, funct::sin(), z, HLTMuonOfflineAnalyzer_cfi::z0, and SiStripMonitorCluster_cfi::zmax.

Referenced by initializeG4().

                                                                                             {
   std::ofstream fout(file.c_str(), std::ios::out);
   if (fout.fail()) {
     edm::LogWarning("SimG4CoreApplication")
         << "MTWorker::DumpMagneticField: error opening file <" << file << "> for magnetic field";
   } else {
     // CMS magnetic field volume
     double rmax = 9000 * mm;
     double zmax = 24000 * mm;
 
     double dr = 1 * cm;
     double dz = 5 * cm;
 
     int nr = (int)(rmax / dr);
     int nz = 2 * (int)(zmax / dz);
 
     double r = 0.0;
     double z0 = -zmax;
     double z;
 
     double phi = 0.0;
     double cosf = cos(phi);
     double sinf = sin(phi);
 
     double point[4] = {0.0, 0.0, 0.0, 0.0};
     double bfield[3] = {0.0, 0.0, 0.0};
 
     fout << std::setprecision(6);
     for (int i = 0; i <= nr; ++i) {
       z = z0;
       for (int j = 0; j <= nz; ++j) {
         point[0] = r * cosf;
         point[1] = r * sinf;
         point[2] = z;
         field->GetFieldValue(point, bfield);
         fout << "R(mm)= " << r / mm << " phi(deg)= " << phi / degree << " Z(mm)= " << z / mm
              << "   Bz(tesla)= " << bfield[2] / tesla << " Br(tesla)= " << (bfield[0] * cosf + bfield[1] * sinf) / tesla
              << " Bphi(tesla)= " << (bfield[0] * sinf - bfield[1] * cosf) / tesla << G4endl;
         z += dz;
       }
       r += dr;
     }
 
     fout.close();
   }
 }

◆ endRun()

void RunManagerMTWorker::endRun ( )

Definition at line 240 of file RunManagerMTWorker.cc.

References getThreadIndex(), l1ctLayer2EG_cff::id, and terminateRun().

                                 {
   int id = getThreadIndex();
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::endRun for the thread " << id;
   terminateRun();
 }

◆ generateEvent()

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

private

Definition at line 637 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_LHCToken, m_LHCTransport, m_nonBeam, m_tls, Generator::nonCentralEvent2G4(), resetGenParticleId(), and Generator::setGenEvent().

Referenced by produce().

                                                                  {
   m_tls->currentEvent.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);
     if (m_LHCTransport) {
       edm::Handle<edm::HepMCProduct> LHCMCEvt;
       inpevt.getByToken(m_LHCToken, LHCMCEvt);
       m_generator.nonCentralEvent2G4(LHCMCEvt->GetEvent(), evt);
     }
   } else {
     m_generator.nonCentralEvent2G4(HepMCEvt->GetEvent(), evt);
   }
 
   return evt;
 }

◆ getSimTrackManager()

SimTrackManager * RunManagerMTWorker::getSimTrackManager ( )

Definition at line 491 of file RunManagerMTWorker.cc.

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

Referenced by SimRunInterface::SimRunInterface().

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

◆ getThreadIndex()

int RunManagerMTWorker::getThreadIndex ( ) const

inline

Definition at line 78 of file RunManagerMTWorker.h.

References m_thread_index.

Referenced by beginRun(), endRun(), initializeG4(), initializeRun(), initializeTLS(), produce(), and terminateRun().

78 { return m_thread_index; }

RunManagerMTWorker::m_thread_index

const int m_thread_index

Definition: RunManagerMTWorker.h:108

◆ initializeG4()

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

Definition at line 270 of file RunManagerMTWorker.cc.

References applyOnce, applyOnceGDML, sim::attachSD(), sim::FieldBuilder::build(), RunManagerMT::catalog(), mps_check::command, DumpMagneticField(), Exception, f, g, RunManagerMT::G4Commands(), ecalTB2006H4_GenSimDigiReco_cfg::G4cout, edm::ParameterSet::getParameter(), getThreadIndex(), edm::ParameterSet::getUntrackedParameter(), DDDWorld::GetWorldVolume(), initializeTLS(), initializeUserActions(), RunManagerMT::isPhase2(), RunManagerMTWorker::TLSData::kernel, m_dumpGDML, m_dumpMF, m_evtManager, m_isPhase2, m_p, m_pField, m_pMagField, m_pUseMagneticField, m_sdMakers, m_simEvent, m_sVerbose, m_tls, m_UseG4EventManager, RunManagerMT::physicsListForWorker(), RunManagerMTWorker::TLSData::registry, RunManagerMTWorker::TLSData::sensCaloDets, RunManagerMTWorker::TLSData::sensTkDets, AlCaHLTBitMon_QueryRunRegistry::string, pfDeepBoostedJetPreprocessParams_cfi::sv, RunManagerMTWorker::TLSData::threadInitialized, RunManagerMTWorker::TLSData::trackManager, verbose, and RunManagerMT::world().

                                                                                              {
   if (m_tls->threadInitialized)
     return;
 
   G4Timer timer;
   timer.Start();
 
   // I guess everything initialized here should be in thread_local storage
   initializeTLS();
 
   int thisID = getThreadIndex();
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::initializeG4 in thread " << thisID << " is started";
 
   // Initialize worker part of shared resources (geometry, physics)
   G4WorkerThread::BuildGeometryAndPhysicsVector();
 
   // Create worker run manager
   m_tls->kernel.reset(G4WorkerRunManagerKernel::GetRunManagerKernel());
   if (nullptr == m_tls->kernel) {
     m_tls->kernel = std::make_unique<G4WorkerRunManagerKernel>();
   }
 
   // Define G4 exception handler
   double th = m_p.getParameter<double>("ThresholdForGeometryExceptions") * CLHEP::GeV;
   bool tr = m_p.getParameter<bool>("TraceExceptions");
   G4StateManager::GetStateManager()->SetExceptionHandler(new ExceptionHandler(th, tr));
 
   // Set the geometry for the worker, share from master
   auto worldPV = runManagerMaster->world().GetWorldVolume();
   m_tls->kernel->WorkerDefineWorldVolume(worldPV);
   G4TransportationManager* tM = G4TransportationManager::GetTransportationManager();
   tM->SetWorldForTracking(worldPV);
 
   // we need the track manager now
   int verbose = m_p.getParameter<int>("EventVerbose");
   m_tls->trackManager = std::make_unique<SimTrackManager>(&m_simEvent, verbose);
 
   // setup the magnetic field
   if (m_pUseMagneticField) {
     const GlobalPoint g(0.f, 0.f, 0.f);
 
     sim::FieldBuilder fieldBuilder(m_pMagField, m_pField);
 
     CMSFieldManager* fieldManager = new CMSFieldManager();
     tM->SetFieldManager(fieldManager);
     fieldBuilder.build(fieldManager, tM->GetPropagatorInField());
 
     std::string fieldFile = m_p.getUntrackedParameter<std::string>("FileNameField", "");
     if (!fieldFile.empty()) {
       std::call_once(applyOnce, [this]() { m_dumpMF = true; });
       if (m_dumpMF) {
         edm::LogVerbatim("SimG4CoreApplication")
             << "RunManagerMTWorker::InitializeG4: Dump magnetic field to file " << fieldFile;
         DumpMagneticField(tM->GetFieldManager()->GetDetectorField(), fieldFile);
       }
     }
   }
 
   // attach sensitive detector
   auto sensDets = sim::attachSD(
       m_sdMakers, es, runManagerMaster->catalog(), m_p, m_tls->trackManager.get(), *(m_tls->registry.get()));
 
   m_tls->sensTkDets = sensDets.first;
   m_tls->sensCaloDets = sensDets.second;
 
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMTWorker::InitializeG4: Sensitive Detectors are built in thread " << thisID << " found "
       << m_tls->sensTkDets.size() << " Tk type SD, and " << m_tls->sensCaloDets.size() << " Calo type SD";
 
   // geometry dump
   G4String writeFile = (G4String)m_p.getUntrackedParameter<std::string>("FileNameGDML");
   if (!writeFile.empty()) {
     std::call_once(applyOnceGDML, [this]() { m_dumpGDML = true; });
     edm::LogVerbatim("SimG4CoreApplication") << "DumpGDML:" << m_dumpGDML;
     if (m_dumpGDML) {
       G4int thID = G4Threading::G4GetThreadId();
       edm::LogVerbatim("SimG4CoreApplication") << "ThreadID=" << thID;
       G4Threading::G4SetThreadId(-1);
       G4GDMLParser gdml;
       gdml.SetRegionExport(true);
       gdml.SetEnergyCutsExport(true);
       gdml.SetSDExport(true);
       gdml.Write(writeFile, worldPV, true);
       G4Threading::G4SetThreadId(thID);
     }
   }
 
   // Enable couple transportation
   bool scorer = m_p.getParameter<bool>("UseCommandBaseScorer");
   if (scorer) {
     G4ScoringManager* scManager = G4ScoringManager::GetScoringManager();
     scManager->SetVerboseLevel(1);
   }
 
   // Set the physics list for the worker, share from master
   PhysicsList* physicsList = runManagerMaster->physicsListForWorker();
   m_isPhase2 = runManagerMaster->isPhase2();
 
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMTWorker::InitializeG4: start initialisation of PhysicsList for the thread " << thisID;
 
   // Geant4 UI commands in PreInit state
   if (!runManagerMaster->G4Commands().empty()) {
     G4cout << "RunManagerMTWorker::InitializeG4: Requested UI commands: " << G4endl;
     for (const std::string& command : runManagerMaster->G4Commands()) {
       G4cout << "          " << command << G4endl;
       G4UImanager::GetUIpointer()->ApplyCommand(command);
     }
   }
   G4StateManager::GetStateManager()->SetNewState(G4State_Init);
 
   physicsList->InitializeWorker();
   m_tls->kernel->SetPhysics(physicsList);
   m_tls->kernel->InitializePhysics();
 
   if (!m_tls->kernel->RunInitialization()) {
     throw cms::Exception("Configuration")
         << "RunManagerMTWorker::InitializeG4: Geant4 kernel initialization failed in thread " << thisID;
   }
 
   //tell all interesting parties that we are beginning the job
   BeginOfJob aBeginOfJob(&es);
   m_tls->registry->beginOfJobSignal_(&aBeginOfJob);
 
   G4int sv = m_p.getUntrackedParameter<int>("SteppingVerbosity");
 
   if (sv > 0) {
     G4double elim = m_p.getUntrackedParameter<double>("StepVerboseThreshold", 0.1) * CLHEP::GeV;
     std::vector<int> ve = m_p.getUntrackedParameter<std::vector<int>>("VerboseEvents");
     std::vector<int> vn = m_p.getUntrackedParameter<std::vector<int>>("VertexNumber");
     std::vector<int> vt = m_p.getUntrackedParameter<std::vector<int>>("VerboseTracks");
     m_sVerbose = std::make_unique<CMSSteppingVerbose>(sv, elim, ve, vn, vt);
   }
   if (!m_UseG4EventManager)
     m_evtManager = std::make_unique<CMSSimEventManager>(m_p);
   initializeUserActions();
 
   G4StateManager::GetStateManager()->SetNewState(G4State_Idle);
 
   timer.Stop();
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMTWorker::initializeG4 done for the thread " << thisID << "  " << timer;
   m_tls->threadInitialized = true;
 }

◆ initializeRun()

void RunManagerMTWorker::initializeRun ( )

private

Definition at line 508 of file RunManagerMTWorker.cc.

References RunManagerMTWorker::TLSData::currentRun, getThreadIndex(), l1ctLayer2EG_cff::id, m_tls, and RunManagerMTWorker::TLSData::userRunAction.

Referenced by produce().

                                        {
   m_tls->currentRun = new G4Run();
   G4StateManager::GetStateManager()->SetNewState(G4State_GeomClosed);
   if (nullptr != m_tls->userRunAction) {
     m_tls->userRunAction->BeginOfRunAction(m_tls->currentRun);
   }
   int id = getThreadIndex();
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::initializeRun done for thread " << id;
 }

◆ initializeTLS()

void RunManagerMTWorker::initializeTLS ( )

private

Definition at line 246 of file RunManagerMTWorker.cc.

References createWatchers(), Exception, getThreadIndex(), m_hasWatchers, m_p, m_tls, RunManagerMTWorker::TLSData::producers, RunManagerMTWorker::TLSData::registry, and RunManagerMTWorker::TLSData::watchers.

Referenced by getSimTrackManager(), initializeG4(), producers(), sensCaloDetectors(), and sensTkDetectors().

                                        {
   if (nullptr != m_tls) {
     return;
   }
 
   m_tls = new TLSData();
   m_tls->registry = std::make_unique<SimActivityRegistry>();
 
   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("Configuration")
           << "RunManagerMTWorker::initializeTLS : "
           << "SimActivityRegistry service (i.e. visualization) is not supported for more than 1 thread. "
           << " \n If this use case is needed, RunManagerMTWorker has to be updated.";
     }
   }
   m_hasWatchers = createWatchers(m_p, m_tls->registry.get(), m_tls->watchers, m_tls->producers, thisID);
 }

◆ initializeUserActions()

void RunManagerMTWorker::initializeUserActions ( )

private

Definition at line 415 of file RunManagerMTWorker.cc.

References Connect(), g4SimHits_cfi::EventAction, edm::ParameterSet::getParameter(), RunManagerMTWorker::TLSData::kernel, m_evtManager, m_hasWatchers, m_isPhase2, m_p, m_pEventAction, m_pRunAction, m_pStackingAction, m_pSteppingAction, m_pTrackingAction, m_sVerbose, m_tls, m_UseG4EventManager, RunManagerMTWorker::TLSData::runInterface, CastorDigiValidation::StackingAction, CastorDigiValidation::SteppingAction, g4SimHits_cfi::TrackingAction, RunManagerMTWorker::TLSData::trackManager, and RunManagerMTWorker::TLSData::userRunAction.

Referenced by initializeG4().

                                                {
   m_tls->runInterface = std::make_unique<SimRunInterface>(this, false);
   m_tls->userRunAction = std::make_unique<RunAction>(m_pRunAction, m_tls->runInterface.get(), false);
   m_tls->userRunAction->SetMaster(false);
   Connect(m_tls->userRunAction.get());
 
   G4int ver = m_p.getParameter<int>("EventVerbose");
   G4EventManager* eventManager = m_tls->kernel->GetEventManager();
   eventManager->SetVerboseLevel(ver);
 
   auto userEventAction =
       new EventAction(m_pEventAction, m_tls->runInterface.get(), m_tls->trackManager.get(), m_sVerbose.get());
   Connect(userEventAction);
   if (m_UseG4EventManager) {
     eventManager->SetUserAction(userEventAction);
   } else {
     m_evtManager->SetUserAction(userEventAction);
   }
 
   auto userTrackingAction = new TrackingAction(m_tls->trackManager.get(), m_sVerbose.get(), m_pTrackingAction);
   Connect(userTrackingAction);
   if (m_UseG4EventManager) {
     eventManager->SetUserAction(userTrackingAction);
   } else {
     m_evtManager->SetUserAction(userTrackingAction);
   }
 
   // different stepping actions for Run2,3 and Phase2
   G4UserSteppingAction* userSteppingAction;
   bool dd4hep = m_p.getParameter<bool>("g4GeometryDD4hepSource");
   if (m_isPhase2) {
     auto ptr = new Phase2SteppingAction(m_sVerbose.get(), m_pSteppingAction, m_hasWatchers, dd4hep);
     Connect(ptr);
     userSteppingAction = (G4UserSteppingAction*)ptr;
   } else {
     auto ptr = new SteppingAction(m_sVerbose.get(), m_pSteppingAction, m_hasWatchers, dd4hep);
     Connect(ptr);
     userSteppingAction = (G4UserSteppingAction*)ptr;
   }
   if (m_UseG4EventManager) {
     eventManager->SetUserAction(userSteppingAction);
   } else {
     m_evtManager->SetUserAction(userSteppingAction);
   }
 
   auto userStackingAction = new StackingAction(userTrackingAction, m_pStackingAction, m_sVerbose.get());
   if (m_UseG4EventManager) {
     eventManager->SetUserAction(userStackingAction);
   } else {
     m_evtManager->SetUserAction(userStackingAction);
   }
 }

◆ produce()

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

Definition at line 548 of file RunManagerMTWorker.cc.

References cms::cuda::assert(), TmpSimEvent::clear(), TmpSimEvent::collisionPoint(), RunManagerMTWorker::TLSData::currentEvent, RunManagerMTWorker::TLSData::currentRunNumber, edm::EventID::event(), Generator::eventWeight(), Exception, generateEvent(), Generator::genEvent(), Generator::genVertex(), getThreadIndex(), edm::EventBase::id(), initializeRun(), RunManagerMTWorker::TLSData::kernel, m_evtManager, m_generator, m_simEvent, m_tls, m_UseG4EventManager, TmpSimEvent::nTracks(), edm::EventID::run(), RunManagerMTWorker::TLSData::runTerminated, edm::second(), RunManagerMTWorker::TLSData::sensCaloDets, TmpSimEvent::setHepEvent(), TmpSimEvent::setWeight(), edm::Event::streamID(), terminateRun(), RunManagerMTWorker::TLSData::threadInitialized, and TmpSimEvent::weight().

                                                                          {
   // We have to do the per-thread initialization, and per-thread
   // per-run initialization here by ourselves.
 
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::produce: start EventID=" << inpevt.id().event();
 
   assert(m_tls != nullptr and m_tls->threadInitialized);
   // Initialize run
   if (inpevt.id().run() != m_tls->currentRunNumber) {
     edm::LogVerbatim("SimG4CoreApplication")
         << "RunManagerMTWorker::produce: RunID= " << inpevt.id().run() << "  TLS RunID= " << m_tls->currentRunNumber;
     if (m_tls->currentRunNumber != 0 && !m_tls->runTerminated) {
       // If previous run in this thread was not terminated via endRun() call,
       // then terminate it now
       terminateRun();
     }
     initializeRun();
     m_tls->currentRunNumber = inpevt.id().run();
   }
 
   // event and primary
   m_tls->currentEvent.reset(generateEvent(inpevt));
   m_simEvent.clear();
   m_simEvent.setHepEvent(m_generator.genEvent());
   m_simEvent.setWeight(m_generator.eventWeight());
 
   if (m_generator.genVertex() != nullptr) {
     auto genVertex = m_generator.genVertex();
     m_simEvent.collisionPoint(math::XYZTLorentzVectorD(genVertex->x() / CLHEP::cm,
                                                        genVertex->y() / CLHEP::cm,
                                                        genVertex->z() / CLHEP::cm,
                                                        genVertex->t() / CLHEP::second));
   }
   if (m_tls->currentEvent->GetNumberOfPrimaryVertex() == 0) {
     throw cms::Exception("EventCorruption")
         << "RunManagerMTWorker::produce: event " << inpevt.id().event() << " with no G4PrimaryVertices"
         << " StreamID=" << inpevt.streamID() << " threadIndex=" << getThreadIndex();
 
   } else {
     edm::LogVerbatim("SimG4CoreApplication")
         << "RunManagerMTWorker::produce: start EventID=" << inpevt.id().event() << " StreamID=" << inpevt.streamID()
         << " threadIndex=" << getThreadIndex() << " weight=" << m_simEvent.weight()
         << " Nprimary: " << m_tls->currentEvent->GetNumberOfPrimaryVertex() << " vertices and " << m_simEvent.nTracks()
         << " particles";
     // process event
     if (m_UseG4EventManager) {
       m_tls->kernel->GetEventManager()->ProcessOneEvent(m_tls->currentEvent.get());
     } else {
       m_evtManager->ProcessOneEvent(m_tls->currentEvent.get());
     }
   }
 
   // remove memory only needed during event processing
   m_tls->currentEvent.reset();
   for (auto& sd : m_tls->sensCaloDets) {
     sd->reset();
   }
 
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::produce: ended Event " << inpevt.id().event();
   return &m_simEvent;
 }

◆ producers()

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

Definition at line 503 of file RunManagerMTWorker.cc.

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

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

◆ resetGenParticleId()

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

private

Definition at line 667 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());
   }
 }

◆ sensCaloDetectors()

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

Definition at line 499 of file RunManagerMTWorker.cc.

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

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

◆ sensTkDetectors()

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

Definition at line 495 of file RunManagerMTWorker.cc.

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

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

◆ simEvent()

TmpSimEvent* RunManagerMTWorker::simEvent ( )

inline

Definition at line 77 of file RunManagerMTWorker.h.

References m_simEvent.

Referenced by SimRunInterface::simEvent().

77 { return &m_simEvent; }

RunManagerMTWorker::m_simEvent

TmpSimEvent m_simEvent

Definition: RunManagerMTWorker.h:124

◆ terminateRun()

void RunManagerMTWorker::terminateRun ( )

private

Definition at line 518 of file RunManagerMTWorker.cc.

References applyOnceEnd, mps_check::command, RunManagerMTWorker::TLSData::currentEvent, RunManagerMTWorker::TLSData::currentRun, getThreadIndex(), l1ctLayer2EG_cff::id, RunManagerMTWorker::TLSData::kernel, m_endOfRun, m_G4CommandsEndRun, m_tls, RunManagerMTWorker::TLSData::runTerminated, AlCaHLTBitMon_QueryRunRegistry::string, and RunManagerMTWorker::TLSData::userRunAction.

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

                                       {
   int id = getThreadIndex();
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::terminateRun for thread " << id;
   if (nullptr == m_tls || m_tls->runTerminated) {
     return;
   }
 
   // Geant4 UI commands after the run
   if (!m_G4CommandsEndRun.empty()) {
     std::call_once(applyOnceEnd, [this]() { m_endOfRun = true; });
     if (m_endOfRun) {
       edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker: Requested end of run UI commands: ";
       for (const std::string& command : m_G4CommandsEndRun) {
         edm::LogVerbatim("SimG4CoreApplication") << "    " << command;
         G4UImanager::GetUIpointer()->ApplyCommand(command);
       }
     }
   }
   if (m_tls->userRunAction) {
     m_tls->userRunAction->EndOfRunAction(m_tls->currentRun);
     m_tls->userRunAction.reset();
   }
   m_tls->currentEvent.reset();
   if (m_tls->kernel) {
     m_tls->kernel->RunTermination();
   }
   m_tls->runTerminated = true;
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::terminateRun done for thread " << id;
 }

Member Data Documentation

◆ m_dumpGDML

bool RunManagerMTWorker::m_dumpGDML {false}

private

Definition at line 104 of file RunManagerMTWorker.h.

Referenced by initializeG4().

◆ m_dumpMF

bool RunManagerMTWorker::m_dumpMF {false}

private

Definition at line 103 of file RunManagerMTWorker.h.

Referenced by initializeG4().

◆ m_endOfRun

bool RunManagerMTWorker::m_endOfRun {false}

private

Definition at line 105 of file RunManagerMTWorker.h.

Referenced by terminateRun().

◆ m_evtManager

std::unique_ptr<CMSSimEventManager> RunManagerMTWorker::m_evtManager

private

Definition at line 125 of file RunManagerMTWorker.h.

Referenced by initializeG4(), initializeUserActions(), and produce().

◆ m_G4Commands

std::vector<std::string> RunManagerMTWorker::m_G4Commands

private

Definition at line 116 of file RunManagerMTWorker.h.

◆ m_G4CommandsEndRun

std::vector<std::string> RunManagerMTWorker::m_G4CommandsEndRun

private

Definition at line 117 of file RunManagerMTWorker.h.

Referenced by terminateRun().

◆ m_generator

Generator RunManagerMTWorker::m_generator

private

Definition at line 91 of file RunManagerMTWorker.h.

Referenced by generateEvent(), and produce().

◆ m_hasWatchers

bool RunManagerMTWorker::m_hasWatchers {false}

private

Definition at line 101 of file RunManagerMTWorker.h.

Referenced by beginRun(), initializeTLS(), and initializeUserActions().

◆ m_InToken

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

private

Definition at line 92 of file RunManagerMTWorker.h.

Referenced by generateEvent().

◆ m_isPhase2

bool RunManagerMTWorker::m_isPhase2 {false}

private

Definition at line 106 of file RunManagerMTWorker.h.

Referenced by initializeG4(), and initializeUserActions().

◆ m_LHCToken

edm::EDGetTokenT<edm::HepMCProduct> RunManagerMTWorker::m_LHCToken

private

Definition at line 93 of file RunManagerMTWorker.h.

Referenced by generateEvent().

◆ m_LHCTransport

bool RunManagerMTWorker::m_LHCTransport {false}

private

Definition at line 102 of file RunManagerMTWorker.h.

Referenced by generateEvent().

◆ m_MagField

edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> RunManagerMTWorker::m_MagField

private

Definition at line 95 of file RunManagerMTWorker.h.

Referenced by beginRun().

◆ m_nonBeam

bool RunManagerMTWorker::m_nonBeam {false}

private

Definition at line 98 of file RunManagerMTWorker.h.

Referenced by generateEvent().

◆ m_p

edm::ParameterSet RunManagerMTWorker::m_p

private

Definition at line 118 of file RunManagerMTWorker.h.

Referenced by initializeG4(), initializeTLS(), and initializeUserActions().

◆ m_pEventAction

edm::ParameterSet RunManagerMTWorker::m_pEventAction

private

Definition at line 112 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

◆ m_pField

edm::ParameterSet RunManagerMTWorker::m_pField

private

Definition at line 110 of file RunManagerMTWorker.h.

Referenced by initializeG4().

◆ m_pMagField

const MagneticField* RunManagerMTWorker::m_pMagField {nullptr}

private

Definition at line 96 of file RunManagerMTWorker.h.

Referenced by beginRun(), and initializeG4().

◆ m_pRunAction

edm::ParameterSet RunManagerMTWorker::m_pRunAction

private

Definition at line 111 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

◆ m_pStackingAction

edm::ParameterSet RunManagerMTWorker::m_pStackingAction

private

Definition at line 113 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

◆ m_pSteppingAction

edm::ParameterSet RunManagerMTWorker::m_pSteppingAction

private

Definition at line 115 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

◆ m_pTrackingAction

edm::ParameterSet RunManagerMTWorker::m_pTrackingAction

private

Definition at line 114 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

◆ m_pUseMagneticField

bool RunManagerMTWorker::m_pUseMagneticField {true}

private

Definition at line 100 of file RunManagerMTWorker.h.

Referenced by beginRun(), and initializeG4().

◆ m_sdMakers

std::unordered_map<std::string, std::unique_ptr<SensitiveDetectorMakerBase> > RunManagerMTWorker::m_sdMakers

private

Definition at line 127 of file RunManagerMTWorker.h.

Referenced by beginRun(), and initializeG4().

◆ m_simEvent

TmpSimEvent RunManagerMTWorker::m_simEvent

private

Definition at line 124 of file RunManagerMTWorker.h.

Referenced by initializeG4(), produce(), and simEvent().

◆ m_sVerbose

std::unique_ptr<CMSSteppingVerbose> RunManagerMTWorker::m_sVerbose

private

Definition at line 126 of file RunManagerMTWorker.h.

Referenced by initializeG4(), and initializeUserActions().

◆ m_theLHCTlinkToken

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

private

Definition at line 94 of file RunManagerMTWorker.h.

Referenced by resetGenParticleId().

◆ m_thread_index

const int RunManagerMTWorker::m_thread_index {-1}

private

Definition at line 108 of file RunManagerMTWorker.h.

Referenced by getThreadIndex().

◆ m_tls

TLSData* RunManagerMTWorker::m_tls {nullptr}

private

Definition at line 121 of file RunManagerMTWorker.h.

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

◆ m_UIsession

CustomUIsession* RunManagerMTWorker::m_UIsession {nullptr}

private

Definition at line 123 of file RunManagerMTWorker.h.

Referenced by ~RunManagerMTWorker().

◆ m_UseG4EventManager

bool RunManagerMTWorker::m_UseG4EventManager {true}

private

Definition at line 99 of file RunManagerMTWorker.h.

Referenced by initializeG4(), initializeUserActions(), and produce().

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RunManagerMTWorker()

◆ ~RunManagerMTWorker()

Member Function Documentation

◆ abortEvent()

◆ abortRun()

◆ beginRun()

◆ Connect() [1/5]

◆ Connect() [2/5]

◆ Connect() [3/5]

◆ Connect() [4/5]

◆ Connect() [5/5]

◆ DumpMagneticField()

◆ endRun()

◆ generateEvent()

◆ getSimTrackManager()

◆ getThreadIndex()

◆ initializeG4()

◆ initializeRun()

◆ initializeTLS()

◆ initializeUserActions()

◆ produce()

◆ producers()

◆ resetGenParticleId()

◆ sensCaloDetectors()

◆ sensTkDetectors()

◆ simEvent()

◆ terminateRun()

Member Data Documentation

◆ m_dumpGDML

◆ m_dumpMF

◆ m_endOfRun

◆ m_evtManager

◆ m_G4Commands

◆ m_G4CommandsEndRun

◆ m_generator

◆ m_hasWatchers

◆ m_InToken

◆ m_isPhase2

◆ m_LHCToken

◆ m_LHCTransport

◆ m_MagField

◆ m_nonBeam

◆ m_p

◆ m_pEventAction

◆ m_pField

◆ m_pMagField

◆ m_pRunAction

◆ m_pStackingAction

◆ m_pSteppingAction

◆ m_pTrackingAction

◆ m_pUseMagneticField

◆ m_sdMakers

◆ m_simEvent

◆ m_sVerbose

◆ m_theLHCTlinkToken

◆ m_thread_index

◆ m_tls

◆ m_UIsession

◆ m_UseG4EventManager