RunManagerMTWorker Class Reference

#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	endRun ()
SimTrackManager *	GetSimTrackManager ()
void	initializeG4 (RunManagerMT *runManagerMaster, const edm::EventSetup &es)
std::unique_ptr< G4SimEvent >	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 ()
G4SimEvent *	simEvent ()
	~RunManagerMTWorker ()

Private Member Functions
void	DumpMagneticField (const G4Field *, const std::string &) const
G4Event *	generateEvent (const edm::Event &inpevt)
int	getThreadIndex () const
void	initializeRun ()
void	initializeTLS ()
void	initializeUserActions ()
void	resetGenParticleId (const edm::Event &inpevt)
void	terminateRun ()

Private Attributes
bool	m_dumpMF {false}
int	m_EvtMgrVerbosity {0}
Generator	m_generator
bool	m_hasWatchers {false}
edm::EDGetTokenT < edm::HepMCProduct >	m_InToken
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_pCustomUIsession
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
G4SimEvent *	m_simEvent {nullptr}
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}

Detailed Description

Definition at line 49 of file RunManagerMTWorker.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 144 of file RunManagerMTWorker.cc.

    : 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_LHCTransport(iConfig.getParameter<bool>("LHCTransport")),
      m_thread_index{get_new_thread_index()},
      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) {
  int thisID = getThreadIndex();
  edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker for the thread " << thisID;

  // sensitive detectors
  std::vector<std::string> onlySDs = iConfig.getParameter<std::vector<std::string>>("OnlySDs");
  m_sdMakers = sim::sensitiveDetectorMakers(m_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 " << thisID;
  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

(

)

Definition at line 193 of file RunManagerMTWorker.cc.

References m_tls, and m_UIsession.

                                        {
  m_tls = nullptr;
  delete m_UIsession;
}

Member Function Documentation

void RunManagerMTWorker::abortEvent

(

)

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

void RunManagerMTWorker::abortRun

(

bool

softAbort = false

)

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

void RunManagerMTWorker::beginRun

(

const edm::EventSetup &

es

)

Definition at line 198 of file RunManagerMTWorker.cc.

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

                                                         {
  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);
    }
  }
}

void RunManagerMTWorker::Connect

(

RunAction *

runAction

)

Definition at line 401 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_);
}

void RunManagerMTWorker::Connect

(

EventAction *

eventAction

)

Definition at line 406 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_);
}

void RunManagerMTWorker::Connect

(

TrackingAction *

trackingAction

)

Definition at line 411 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_);
}

void RunManagerMTWorker::Connect

(

SteppingAction *

steppingAction

)

Definition at line 416 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_);
}

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

private

Definition at line 600 of file RunManagerMTWorker.cc.

References funct::cos(), runTauDisplay::dr, PVValHelper::dz, groupFilesInBlocks::fout, mps_fire::i, dqmiolumiharvest::j, submitPVResolutionJobs::out, phi, point, alignCSCRings::r, funct::sin(), and z.

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();
  }
}

void RunManagerMTWorker::endRun

(

)

Definition at line 212 of file RunManagerMTWorker.cc.

References getThreadIndex(), and terminateRun().

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

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

private

Definition at line 560 of file RunManagerMTWorker.cc.

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

Referenced by produce().

                                                                 {
  m_tls->currentEvent.reset();
  m_simEvent = nullptr;

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

SimTrackManager * RunManagerMTWorker::GetSimTrackManager

(

)

Definition at line 420 of file RunManagerMTWorker.cc.

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

Referenced by SimRunInterface::SimRunInterface().

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

int RunManagerMTWorker::getThreadIndex ( ) const

inlineprivate

Definition at line 89 of file RunManagerMTWorker.h.

References m_thread_index.

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

{ return m_thread_index; }

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

Definition at line 242 of file RunManagerMTWorker.cc.

References applyOnce, sim::attachSD(), sim::FieldBuilder::build(), RunManagerMT::catalog(), mps_check::command, edm::errors::Configuration, DumpMagneticField(), Exception, validate-o2o-wbm::f, g, RunManagerMT::G4Commands(), edm::ParameterSet::getParameter(), getThreadIndex(), edm::ParameterSet::getUntrackedParameter(), DDDWorld::GetWorldVolume(), GeV, initializeTLS(), initializeUserActions(), RunManagerMTWorker::TLSData::kernel, m_dumpMF, m_p, m_pCustomUIsession, m_pField, m_pMagField, m_pUseMagneticField, m_sVerbose, m_tls, m_UIsession, RunManagerMT::physicsListForWorker(), RunManagerMTWorker::TLSData::registry, RunManagerMTWorker::TLSData::sensCaloDets, RunManagerMTWorker::TLSData::sensTkDets, AlCaHLTBitMon_QueryRunRegistry::string, RunManagerMTWorker::TLSData::threadInitialized, RunManagerMTWorker::TLSData::trackManager, 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 per-thread output
  G4Threading::G4SetThreadId(thisID);
  G4UImanager::GetUIpointer()->SetUpForAThread(thisID);
  const std::string& uitype = m_pCustomUIsession.getUntrackedParameter<std::string>("Type", "MessageLogger");
  if (uitype == "MessageLogger") {
    m_UIsession = new CustomUIsession();
  } else if (uitype == "MessageLoggerThreadPrefix") {
    m_UIsession = new CustomUIsessionThreadPrefix(
        m_pCustomUIsession.getUntrackedParameter<std::string>("ThreadPrefix", ""), thisID);
  } else if (uitype == "FilePerThread") {
    m_UIsession =
        new CustomUIsessionToFile(m_pCustomUIsession.getUntrackedParameter<std::string>("ThreadFile", ""), thisID);
  } else {
    throw edm::Exception(edm::errors::Configuration)
        << "RunManagerMTWorker::initializeG4: Invalid value of CustomUIsession.Type '" << uitype
        << "', valid are MessageLogger, MessageLoggerThreadPrefix, FilePerThread";
  }
  G4UImanager::GetUIpointer()->SetCoutDestination(m_UIsession);

  // 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;
  G4StateManager::GetStateManager()->SetExceptionHandler(new ExceptionHandler(th));

  // 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
  m_tls->trackManager = std::make_unique<SimTrackManager>();

  // 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.swap(sensDets.first);
  m_tls->sensCaloDets.swap(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";

  // Set the physics list for the worker, share from master
  PhysicsList* physicsList = runManagerMaster->physicsListForWorker();

  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 edm::Exception(edm::errors::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", 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");

  if (sv > 0) {
    m_sVerbose = std::make_unique<CMSSteppingVerbose>(sv, elim, ve, vn, vt);
  }
  initializeUserActions();

  G4StateManager::GetStateManager()->SetNewState(G4State_Idle);

  timer.Stop();
  edm::LogVerbatim("SimG4CoreApplication")
      << "RunManagerMTWorker::initializeG4 done for the thread " << thisID << "  " << timer;
  m_tls->threadInitialized = true;
}

void RunManagerMTWorker::initializeRun ( )

private

Definition at line 437 of file RunManagerMTWorker.cc.

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

Referenced by produce().

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

void RunManagerMTWorker::initializeTLS ( )

private

Definition at line 218 of file RunManagerMTWorker.cc.

References edm::errors::Configuration, 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 edm::Exception(edm::errors::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);
}

void RunManagerMTWorker::initializeUserActions ( )

private

Definition at line 375 of file RunManagerMTWorker.cc.

References Connect(), RunManagerMTWorker::TLSData::kernel, m_EvtMgrVerbosity, m_hasWatchers, m_pEventAction, m_pRunAction, m_pStackingAction, m_pSteppingAction, m_pTrackingAction, m_sVerbose, m_tls, RunManagerMTWorker::TLSData::runInterface, 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());

  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()));
}

std::unique_ptr< G4SimEvent > RunManagerMTWorker::produce	(	const edm::Event &	inpevt,
		const edm::EventSetup &	es,
		RunManagerMT &	runManagerMaster
	)

Definition at line 468 of file RunManagerMTWorker.cc.

References cms::cuda::assert(), RunManagerMTWorker::TLSData::currentEvent, RunManagerMTWorker::TLSData::currentRunNumber, edm::EventID::event(), Generator::eventWeight(), generateEvent(), Generator::genEvent(), Generator::genVertex(), getThreadIndex(), G4SimEvent::hepEvent(), edm::EventBase::id(), initializeRun(), RunManagerMTWorker::TLSData::kernel, m_generator, m_simEvent, m_tls, edm::EventID::run(), RunManagerMTWorker::TLSData::runInterface, RunManagerMTWorker::TLSData::runTerminated, sd, edm::second(), RunManagerMTWorker::TLSData::sensCaloDets, simEvent(), 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.

  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,
      // terminate it now
      terminateRun();
    }
    initializeRun();
    m_tls->currentRunNumber = inpevt.id().run();
  }
  m_tls->runInterface->setRunManagerMTWorker(this);  // For UserActions

  m_tls->currentEvent.reset(generateEvent(inpevt));

  auto simEvent = std::make_unique<G4SimEvent>();
  m_simEvent = simEvent.get();
  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() / CLHEP::cm,
                                                        genVertex->y() / CLHEP::cm,
                                                        genVertex->z() / CLHEP::cm,
                                                        genVertex->t() / CLHEP::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 {
    edm::LogVerbatim("SimG4CoreApplication")
        << "RunManagerMTWorker::produce: start EventID=" << inpevt.id().event() << " StreamID=" << inpevt.streamID()
        << " threadIndex=" << getThreadIndex() << " weight=" << m_simEvent->weight() << "; "
        << m_tls->currentEvent->GetNumberOfPrimaryVertex() << " vertices for Geant4; generator produced "
        << m_simEvent->nGenParts() << " particles.";

    m_tls->kernel->GetEventManager()->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();

  m_simEvent = nullptr;
  return simEvent;
}

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

(

)

Definition at line 432 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 592 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 428 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 424 of file RunManagerMTWorker.cc.

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

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

G4SimEvent* RunManagerMTWorker::simEvent ( )

inline

Definition at line 64 of file RunManagerMTWorker.h.

References m_simEvent.

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

{ return m_simEvent; }

void RunManagerMTWorker::terminateRun ( )

private

Definition at line 447 of file RunManagerMTWorker.cc.

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

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

                                      {
  edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::terminateRun ";
  if (nullptr == m_tls || m_tls->runTerminated) {
    return;
  }
  int thisID = getThreadIndex();
  edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMTWorker::terminateRun " << thisID << " is started";
  if (m_tls->userRunAction) {
    m_tls->userRunAction->EndOfRunAction(m_tls->currentRun);
    m_tls->userRunAction.reset();
  }
  m_tls->currentEvent.reset();
  m_simEvent = nullptr;

  if (m_tls->kernel) {
    m_tls->kernel->RunTermination();
  }

  m_tls->runTerminated = true;
}

Member Data Documentation

bool RunManagerMTWorker::m_dumpMF {false}

private

Definition at line 102 of file RunManagerMTWorker.h.

Referenced by initializeG4().

int RunManagerMTWorker::m_EvtMgrVerbosity {0}

private

Definition at line 105 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

Generator RunManagerMTWorker::m_generator

private

Definition at line 91 of file RunManagerMTWorker.h.

Referenced by generateEvent(), and produce().

bool RunManagerMTWorker::m_hasWatchers {false}

private

Definition at line 100 of file RunManagerMTWorker.h.

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

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

private

Definition at line 92 of file RunManagerMTWorker.h.

Referenced by generateEvent().

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

private

Definition at line 93 of file RunManagerMTWorker.h.

Referenced by generateEvent().

bool RunManagerMTWorker::m_LHCTransport {false}

private

Definition at line 101 of file RunManagerMTWorker.h.

Referenced by generateEvent().

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

private

Definition at line 95 of file RunManagerMTWorker.h.

Referenced by beginRun().

bool RunManagerMTWorker::m_nonBeam {false}

private

Definition at line 98 of file RunManagerMTWorker.h.

Referenced by generateEvent().

edm::ParameterSet RunManagerMTWorker::m_p

private

Definition at line 114 of file RunManagerMTWorker.h.

Referenced by initializeG4(), and initializeTLS().

edm::ParameterSet RunManagerMTWorker::m_pCustomUIsession

private

Definition at line 113 of file RunManagerMTWorker.h.

Referenced by initializeG4().

edm::ParameterSet RunManagerMTWorker::m_pEventAction

private

Definition at line 109 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManagerMTWorker::m_pField

private

Definition at line 107 of file RunManagerMTWorker.h.

Referenced by initializeG4().

const MagneticField* RunManagerMTWorker::m_pMagField {nullptr}

private

Definition at line 96 of file RunManagerMTWorker.h.

Referenced by beginRun(), and initializeG4().

edm::ParameterSet RunManagerMTWorker::m_pRunAction

private

Definition at line 108 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManagerMTWorker::m_pStackingAction

private

Definition at line 110 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManagerMTWorker::m_pSteppingAction

private

Definition at line 112 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManagerMTWorker::m_pTrackingAction

private

Definition at line 111 of file RunManagerMTWorker.h.

Referenced by initializeUserActions().

bool RunManagerMTWorker::m_pUseMagneticField {true}

private

Definition at line 99 of file RunManagerMTWorker.h.

Referenced by beginRun(), and initializeG4().

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

private

Definition at line 122 of file RunManagerMTWorker.h.

G4SimEvent* RunManagerMTWorker::m_simEvent {nullptr}

private

Definition at line 120 of file RunManagerMTWorker.h.

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

std::unique_ptr<CMSSteppingVerbose> RunManagerMTWorker::m_sVerbose

private

Definition at line 121 of file RunManagerMTWorker.h.

Referenced by initializeG4(), and initializeUserActions().

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

private

Definition at line 94 of file RunManagerMTWorker.h.

Referenced by resetGenParticleId().

const int RunManagerMTWorker::m_thread_index {-1}

private

Definition at line 104 of file RunManagerMTWorker.h.

Referenced by getThreadIndex().

TLSData* RunManagerMTWorker::m_tls {nullptr}

private

Definition at line 117 of file RunManagerMTWorker.h.

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

CustomUIsession* RunManagerMTWorker::m_UIsession {nullptr}

private

Definition at line 119 of file RunManagerMTWorker.h.

Referenced by initializeG4(), and ~RunManagerMTWorker().