RunManager Class Reference

#include <RunManager.h>

Public Member Functions
void	abortEvent ()
void	abortRun (bool softAbort=false)
void	Connect (EventAction *)
void	Connect (RunAction *)
void	Connect (SteppingAction *)
void	Connect (TrackingAction *)
const G4Event *	currentEvent () const
const G4Run *	currentRun () const
const Generator *	generator () const
SimTrackManager *	GetSimTrackManager ()
void	initG4 (const edm::EventSetup &es)
void	initializeRun ()
void	initializeUserActions ()
void	produce (edm::Event &inpevt, const edm::EventSetup &es)
std::vector< std::shared_ptr< SimProducer > >	producers () const
	RunManager (edm::ParameterSet const &p, edm::ConsumesCollector &&i)
std::vector< SensitiveCaloDetector * > &	sensCaloDetectors ()
std::vector< SensitiveTkDetector * > &	sensTkDetectors ()
G4SimEvent *	simEvent ()
void	stopG4 ()
void	terminateRun ()
	~RunManager ()

Protected Member Functions
void	DumpMagneticField (const G4Field *) const
G4Event *	generateEvent (edm::Event &inpevt)
void	resetGenParticleId (edm::Event &inpevt)

Private Attributes
bool	firstRun
edm::ESWatcher< IdealGeometryRecord >	idealGeomRcdWatcher_
edm::ESWatcher< IdealMagneticFieldRecord >	idealMagRcdWatcher_
bool	m_check
G4Event *	m_currentEvent
G4Run *	m_currentRun
int	m_EvtMgrVerbosity
std::string	m_FieldFile
std::vector< std::string >	m_G4Commands
edm::ParameterSet	m_g4overlap
Generator *	m_generator
bool	m_hasWatchers
edm::EDGetTokenT< edm::HepMCProduct >	m_HepMC
G4RunManagerKernel *	m_kernel
edm::EDGetTokenT< edm::LHCTransportLinkContainer >	m_LHCtr
bool	m_managerInitialized
bool	m_nonBeam
edm::ParameterSet	m_p
edm::ParameterSet	m_pEventAction
edm::ParameterSet	m_pField
edm::ParameterSet	m_pGenerator
std::unique_ptr< PhysicsList >	m_physicsList
std::string	m_PhysicsTablesDir
edm::ParameterSet	m_pPhysics
PrimaryTransformer *	m_primaryTransformer
std::vector< std::shared_ptr< SimProducer > >	m_producers
edm::ParameterSet	m_pRunAction
edm::ParameterSet	m_pStackingAction
edm::ParameterSet	m_pSteppingAction
edm::ParameterSet	m_pTrackingAction
bool	m_pUseMagneticField
std::string	m_RegionFile
SimActivityRegistry	m_registry
bool	m_RestorePhysicsTables
bool	m_runAborted
bool	m_runInitialized
SimRunInterface *	m_runInterface
bool	m_runTerminated
std::vector< SensitiveCaloDetector * >	m_sensCaloDets
std::vector< SensitiveTkDetector * >	m_sensTkDets
G4SimEvent *	m_simEvent
bool	m_StorePhysicsTables
std::unique_ptr< CMSSteppingVerbose >	m_sVerbose
std::unique_ptr< SimTrackManager >	m_trackManager
CustomUIsession *	m_UIsession
bool	m_UseParametrisedEMPhysics
RunAction *	m_userRunAction
std::vector< std::shared_ptr< SimWatcher > >	m_watchers
std::string	m_WriteFile

Detailed Description

Definition at line 54 of file RunManager.h.

Constructor & Destructor Documentation

RunManager()

RunManager::RunManager	(	edm::ParameterSet const &	p,
		edm::ConsumesCollector &&	i
	)

Definition at line 115 of file RunManager.cc.

    : m_generator(new Generator(p.getParameter<edm::ParameterSet>("Generator"))),
      m_HepMC(iC.consumes<edm::HepMCProduct>(
          p.getParameter<edm::ParameterSet>("Generator").getParameter<edm::InputTag>("HepMCProductLabel"))),
      m_LHCtr(iC.consumes<edm::LHCTransportLinkContainer>(p.getParameter<edm::InputTag>("theLHCTlinkTag"))),
      m_nonBeam(p.getParameter<bool>("NonBeamEvent")),
      m_primaryTransformer(nullptr),
      m_managerInitialized(false),
      m_runInitialized(false),
      m_runTerminated(false),
      m_runAborted(false),
      firstRun(true),
      m_pUseMagneticField(p.getParameter<bool>("UseMagneticField")),
      m_currentRun(nullptr),
      m_currentEvent(nullptr),
      m_simEvent(nullptr),
      m_PhysicsTablesDir(p.getUntrackedParameter<std::string>("PhysicsTablesDirectory", "")),
      m_StorePhysicsTables(p.getUntrackedParameter<bool>("StorePhysicsTables", false)),
      m_RestorePhysicsTables(p.getUntrackedParameter<bool>("RestorePhysicsTables", false)),
      m_UseParametrisedEMPhysics(p.getUntrackedParameter<bool>("UseParametrisedEMPhysics")),
      m_EvtMgrVerbosity(p.getUntrackedParameter<int>("G4EventManagerVerbosity", 0)),
      m_pField(p.getParameter<edm::ParameterSet>("MagneticField")),
      m_pGenerator(p.getParameter<edm::ParameterSet>("Generator")),
      m_pPhysics(p.getParameter<edm::ParameterSet>("Physics")),
      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_g4overlap(p.getUntrackedParameter<edm::ParameterSet>("G4CheckOverlap")),
      m_G4Commands(p.getParameter<std::vector<std::string> >("G4Commands")),
      m_p(p) {
  m_UIsession = new CustomUIsession();
  m_kernel = new G4RunManagerKernel();
  G4StateManager::GetStateManager()->SetExceptionHandler(new ExceptionHandler());
 
  m_physicsList.reset(nullptr);
 
  m_check = p.getUntrackedParameter<bool>("CheckGeometry", false);
  m_WriteFile = p.getUntrackedParameter<std::string>("FileNameGDML", "");
  m_FieldFile = p.getUntrackedParameter<std::string>("FileNameField", "");
  m_RegionFile = p.getUntrackedParameter<std::string>("FileNameRegions", "");
 
  m_userRunAction = nullptr;
  m_runInterface = nullptr;
 
  //Look for an outside SimActivityRegistry
  // this is used by the visualization code
  edm::Service<SimActivityRegistry> otherRegistry;
  if (otherRegistry) {
    m_registry.connect(*otherRegistry);
  }
  m_sVerbose.reset(nullptr);
 
  std::vector<edm::ParameterSet> watchers = p.getParameter<std::vector<edm::ParameterSet> >("Watchers");
  m_hasWatchers = (watchers.empty()) ? false : true;
 
  if (m_hasWatchers) {
    createWatchers(m_p, m_registry, m_watchers, m_producers);
  }
}

References SimActivityRegistry::connect(), createWatchers(), g4SimHits_cfi::CustomUIsession, m_check, m_FieldFile, m_hasWatchers, m_kernel, m_p, m_physicsList, m_producers, m_RegionFile, m_registry, m_runInterface, m_sVerbose, m_UIsession, m_userRunAction, m_watchers, m_WriteFile, AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

~RunManager()

RunManager::~RunManager

(

)

Definition at line 177 of file RunManager.cc.

                        {
  if (!m_runTerminated) {
    terminateRun();
  }
  G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
  G4GeometryManager::GetInstance()->OpenGeometry();
  //   if (m_kernel!=0) delete m_kernel;
  delete m_runInterface;
  delete m_generator;
}

References m_generator, m_runInterface, m_runTerminated, and terminateRun().

Member Function Documentation

abortEvent()

void RunManager::abortEvent

(

)

Definition at line 455 of file RunManager.cc.

                            {
  if (m_runTerminated) {
    return;
  }
  G4Track* t = m_kernel->GetEventManager()->GetTrackingManager()->GetTrack();
  t->SetTrackStatus(fStopAndKill);
 
  // CMS-specific act
  //
  TrackingAction* uta = (TrackingAction*)m_kernel->GetEventManager()->GetUserTrackingAction();
  uta->PostUserTrackingAction(t);
 
  m_currentEvent->SetEventAborted();
  m_kernel->GetEventManager()->GetStackManager()->clear();
  m_kernel->GetEventManager()->GetTrackingManager()->EventAborted();
 
  G4StateManager* stateManager = G4StateManager::GetStateManager();
  stateManager->SetNewState(G4State_GeomClosed);
}

References m_currentEvent, m_kernel, m_runTerminated, TrackingAction::PostUserTrackingAction(), and OrderedSet::t.

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

abortRun()

void RunManager::abortRun

(

bool

softAbort = false

)

Definition at line 541 of file RunManager.cc.

                                        {
  if (m_runAborted) {
    return;
  }
  if (!softAbort) {
    abortEvent();
  }
  if (m_currentRun != nullptr) {
    delete m_currentRun;
    m_currentRun = nullptr;
  }
  terminateRun();
  m_runAborted = true;
}

References abortEvent(), m_currentRun, m_runAborted, and terminateRun().

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

Connect() [1/4]

void RunManager::Connect

(

EventAction *

eventAction

)

Definition at line 571 of file RunManager.cc.

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

References SimActivityRegistry::beginOfEventSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfEventSignal_, EventAction::m_beginOfEventSignal, EventAction::m_endOfEventSignal, and m_registry.

Connect() [2/4]

void RunManager::Connect

(

RunAction *

runAction

)

Definition at line 566 of file RunManager.cc.

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

References SimActivityRegistry::beginOfRunSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfRunSignal_, RunAction::m_beginOfRunSignal, RunAction::m_endOfRunSignal, and m_registry.

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

Connect() [3/4]

void RunManager::Connect

(

SteppingAction *

steppingAction

)

Definition at line 581 of file RunManager.cc.

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

References sim_act::Signaler< T >::connect(), SimActivityRegistry::g4StepSignal_, SteppingAction::m_g4StepSignal, and m_registry.

Connect() [4/4]

void RunManager::Connect

(

TrackingAction *

trackingAction

)

Definition at line 576 of file RunManager.cc.

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

References SimActivityRegistry::beginOfTrackSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfTrackSignal_, TrackingAction::m_beginOfTrackSignal, TrackingAction::m_endOfTrackSignal, and m_registry.

currentEvent()

const G4Event* RunManager::currentEvent ( ) const

inline

Definition at line 70 of file RunManager.h.

{ return m_currentEvent; }

References m_currentEvent.

currentRun()

const G4Run* RunManager::currentRun ( ) const

inline

Definition at line 66 of file RunManager.h.

{ return m_currentRun; }

References m_currentRun.

DumpMagneticField()

void RunManager::DumpMagneticField ( const G4Field *  field ) const

protected

Definition at line 585 of file RunManager.cc.

                                                             {
  std::ofstream fout(m_FieldFile.c_str(), std::ios::out);
  if (fout.fail()) {
    edm::LogWarning("SimG4CoreApplication") << " RunManager WARNING : "
                                            << "error opening file <" << m_FieldFile << "> for magnetic field";
  } else {
    double rmax = 9000 * mm;
    double zmax = 16000 * mm;
 
    double dr = 5 * cm;
    double dz = 20 * 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();
  }
}

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

Referenced by initG4().

generateEvent()

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

protected

Definition at line 421 of file RunManager.cc.

                                                   {
  if (m_currentEvent != nullptr) {
    delete m_currentEvent;
  }
  m_currentEvent = nullptr;
  if (m_simEvent != nullptr) {
    delete m_simEvent;
  }
  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_HepMC, 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;
}

References edm::EventID::event(), runTauDisplay::evtid, edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), Generator::HepMC2G4(), edm::EventBase::id(), m_currentEvent, m_generator, m_HepMC, m_nonBeam, m_simEvent, Generator::nonBeamEvent2G4(), resetGenParticleId(), and Generator::setGenEvent().

Referenced by produce().

generator()

const Generator* RunManager::generator ( ) const

inline

Definition at line 69 of file RunManager.h.

{ return m_generator; }

References m_generator.

GetSimTrackManager()

SimTrackManager * RunManager::GetSimTrackManager

(

)

Definition at line 564 of file RunManager.cc.

{ return m_trackManager.get(); }

References m_trackManager.

Referenced by SimRunInterface::SimRunInterface().

initG4()

void RunManager::initG4

(

const edm::EventSetup &

es

)

Definition at line 188 of file RunManager.cc.

                                               {
  bool geomChanged = idealGeomRcdWatcher_.check(es);
  if (geomChanged && (!firstRun)) {
    throw cms::Exception("BadConfig") << "[SimG4Core RunManager]\n"
                                      << "The Geometry configuration is changed during the job execution\n"
                                      << "this is not allowed, the geometry must stay unchanged\n";
  }
  bool geoFromDD4hep = m_p.getParameter<bool>("g4GeometryDD4hepSource");
  bool cuts = m_pPhysics.getParameter<bool>("CutsPerRegion");
  bool protonCut = m_pPhysics.getParameter<bool>("CutsOnProton");
  int verb = std::max(m_pPhysics.getUntrackedParameter<int>("Verbosity", 0),
                      m_p.getUntrackedParameter<int>("SteppingVerbosity", 0));
  edm::LogVerbatim("SimG4CoreApplication")
      << "RunManager: start initialising of geometry DD4Hep: " << geoFromDD4hep << "\n"
      << "              cutsPerRegion: " << cuts << " cutForProton: " << protonCut << "\n"
      << "              G4 verbosity: " << verb;
 
  if (m_pUseMagneticField) {
    bool magChanged = idealMagRcdWatcher_.check(es);
    if (magChanged && (!firstRun)) {
      throw edm::Exception(edm::errors::Configuration)
          << "[SimG4Core RunManager]\n"
          << "The MagneticField configuration is changed during the job execution\n"
          << "this is not allowed, the MagneticField must stay unchanged\n";
    }
  }
 
  if (m_managerInitialized)
    return;
 
  // initialise geometry
  const DDCompactView* pDD = nullptr;
  const cms::DDCompactView* pDD4hep = nullptr;
  if (geoFromDD4hep) {
    edm::ESTransientHandle<cms::DDCompactView> ph;
    es.get<IdealGeometryRecord>().get(ph);
    pDD4hep = ph.product();
  } else {
    edm::ESTransientHandle<DDCompactView> ph;
    es.get<IdealGeometryRecord>().get(ph);
    pDD = ph.product();
  }
  SensitiveDetectorCatalog catalog;
  const DDDWorld* world = new DDDWorld(pDD, pDD4hep, catalog, verb, cuts, protonCut);
  G4VPhysicalVolume* pworld = world->GetWorldVolume();
 
  const G4RegionStore* regStore = G4RegionStore::GetInstance();
  const G4PhysicalVolumeStore* pvs = G4PhysicalVolumeStore::GetInstance();
  const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
  unsigned int numPV = pvs->size();
  unsigned int numLV = lvs->size();
  unsigned int nn = regStore->size();
  edm::LogVerbatim("SimG4CoreApplication")
      << "###RunManager: " << numPV << " PhysVolumes; " << numLV << " LogVolumes; " << nn << " Regions.";
 
  m_kernel->DefineWorldVolume(pworld, true);
  m_registry.dddWorldSignal_(world);
 
  if (m_pUseMagneticField) {
    // setup the magnetic field
    edm::ESHandle<MagneticField> pMF;
    es.get<IdealMagneticFieldRecord>().get(pMF);
    const GlobalPoint g(0., 0., 0.);
 
    sim::FieldBuilder fieldBuilder(pMF.product(), m_pField);
    CMSFieldManager* fieldManager = new CMSFieldManager();
    G4TransportationManager* tM = G4TransportationManager::GetTransportationManager();
    tM->SetFieldManager(fieldManager);
    fieldBuilder.build(fieldManager, tM->GetPropagatorInField());
 
    if (!m_FieldFile.empty()) {
      DumpMagneticField(tM->GetFieldManager()->GetDetectorField());
    }
  }
 
  // we need the track manager now
  m_trackManager = std::unique_ptr<SimTrackManager>(new SimTrackManager);
 
  // attach sensitive detector
  AttachSD attach;
  auto sensDets = attach.create(es, catalog, m_p, m_trackManager.get(), m_registry);
 
  m_sensTkDets.swap(sensDets.first);
  m_sensCaloDets.swap(sensDets.second);
 
  edm::LogVerbatim("SimG4CoreApplication")
      << " RunManager: Sensitive Detector "
      << "building finished; found " << m_sensTkDets.size() << " Tk type Producers, and " << m_sensCaloDets.size()
      << " Calo type producers ";
 
  edm::ESHandle<HepPDT::ParticleDataTable> fTable;
  es.get<PDTRecord>().get(fTable);
  const HepPDT::ParticleDataTable* fPDGTable = &(*fTable);
 
  m_primaryTransformer = new PrimaryTransformer();
 
  std::unique_ptr<PhysicsListMakerBase> physicsMaker(
      PhysicsListFactory::get()->create(m_pPhysics.getParameter<std::string>("type")));
  if (physicsMaker.get() == nullptr) {
    throw edm::Exception(edm::errors::Configuration) << "Unable to find the Physics list requested";
  }
  m_physicsList = physicsMaker->make(m_pPhysics, m_registry);
 
  PhysicsList* phys = m_physicsList.get();
  if (phys == nullptr) {
    throw edm::Exception(edm::errors::Configuration) << "Physics list construction failed!";
  }
 
  // exotic particle physics
  double monopoleMass = m_pPhysics.getUntrackedParameter<double>("MonopoleMass", 0.);
  if (monopoleMass > 0.0) {
    phys->RegisterPhysics(new CMSMonopolePhysics(fPDGTable, m_pPhysics));
  }
  bool exotica = m_pPhysics.getUntrackedParameter<bool>("ExoticaTransport", false);
  if (exotica) {
    CMSExoticaPhysics exo(phys, m_pPhysics);
  }
 
  // adding GFlash, Russian Roulette for eletrons and gamma,
  // step limiters on top of any Physics Lists
  if (m_UseParametrisedEMPhysics)
    phys->RegisterPhysics(new ParametrisedEMPhysics("EMoptions", m_pPhysics));
 
  std::string tableDir = m_PhysicsTablesDir;
  if (m_RestorePhysicsTables) {
    m_physicsList->SetPhysicsTableRetrieved(tableDir);
  }
  edm::LogInfo("SimG4CoreApplication") << "RunManager: start initialisation of PhysicsList";
 
  m_physicsList->SetDefaultCutValue(m_pPhysics.getParameter<double>("DefaultCutValue") * CLHEP::cm);
  m_physicsList->SetCutsWithDefault();
  m_kernel->SetPhysics(phys);
  m_kernel->InitializePhysics();
 
  if (m_kernel->RunInitialization()) {
    m_managerInitialized = true;
  } else {
    throw edm::Exception(edm::errors::LogicError) << "G4RunManagerKernel initialization failed!";
  }
 
  if (m_StorePhysicsTables) {
    std::ostringstream dir;
    dir << tableDir << '\0';
    std::string cmd = std::string("/control/shell mkdir -p ") + tableDir;
    if (!std::ifstream(dir.str().c_str(), std::ios::in))
      G4UImanager::GetUIpointer()->ApplyCommand(cmd);
    m_physicsList->StorePhysicsTable(tableDir);
  }
 
  //tell all interesting parties that we are beginning the job
  BeginOfJob aBeginOfJob(&es);
  m_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.reset(new CMSSteppingVerbose(sv, elim, ve, vn, vt));
  }
  initializeUserActions();
 
  if (!m_G4Commands.empty()) {
    G4cout << "RunManager: Requested UI commands: " << G4endl;
    for (unsigned it = 0; it < m_G4Commands.size(); ++it) {
      G4cout << "    " << m_G4Commands[it] << G4endl;
      G4UImanager::GetUIpointer()->ApplyCommand(m_G4Commands[it]);
    }
  }
  G4StateManager::GetStateManager()->SetNewState(G4State_Init);
 
  if (!m_WriteFile.empty()) {
    G4GDMLParser gdml;
    gdml.SetRegionExport(true);
    gdml.SetEnergyCutsExport(true);
    gdml.Write(m_WriteFile, pworld, true);
  }
 
  // G4Region dump file name
  auto regionFile = m_p.getUntrackedParameter<std::string>("FileNameRegions", "");
 
  // Geometry checks
  if (m_check || !regionFile.empty()) {
    CMSG4CheckOverlap check(m_g4overlap, regionFile, m_UIsession, pworld);
  }
 
  // If the Geant4 particle table is needed, decomment the lines below
  //
  //  G4cout << "Output of G4ParticleTable DumpTable:" << G4endl;
  //  G4ParticleTable::GetParticleTable()->DumpTable("ALL");
 
  initializeRun();
  firstRun = false;
}

References SimActivityRegistry::beginOfJobSignal_, getEcalConditions_orcoffint2r_cff::catalog, edm::ESWatcher< T >::check(), RPCNoise_example::check, mps_setup::cmd, edm::errors::Configuration, AttachSD::create(), beamerCreator::create(), L1TMuonDQMOffline_cfi::cuts, SimActivityRegistry::dddWorldSignal_, DeadROC_duringRun::dir, DumpMagneticField(), Exception, firstRun, g, ecalTB2006H4_GenSimDigiReco_cfg::G4cout, edm::EventSetup::get(), get, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), DDDWorld::GetWorldVolume(), GeV, idealGeomRcdWatcher_, idealMagRcdWatcher_, recoMuon::in, initializeRun(), initializeUserActions(), edm::errors::LogicError, m_check, m_FieldFile, m_G4Commands, m_g4overlap, m_kernel, m_managerInitialized, m_p, m_pField, m_physicsList, m_PhysicsTablesDir, m_pPhysics, m_primaryTransformer, m_pUseMagneticField, m_registry, m_RestorePhysicsTables, m_sensCaloDets, m_sensTkDets, m_StorePhysicsTables, m_sVerbose, m_trackManager, m_UIsession, m_UseParametrisedEMPhysics, m_WriteFile, SiStripPI::max, groupFilesInBlocks::nn, edm::ESTransientHandle< T >::product(), edm::ESHandle< T >::product(), FSQDQM_cfi::pvs, AlCaHLTBitMon_QueryRunRegistry::string, and pfDeepBoostedJetPreprocessParams_cfi::sv.

initializeRun()

void RunManager::initializeRun

(

)

Definition at line 508 of file RunManager.cc.

                               {
  m_runInitialized = false;
  if (m_currentRun == nullptr) {
    m_currentRun = new G4Run();
  }
  G4StateManager::GetStateManager()->SetNewState(G4State_GeomClosed);
  if (m_userRunAction != nullptr) {
    m_userRunAction->BeginOfRunAction(m_currentRun);
  }
  m_runAborted = false;
  m_runInitialized = true;
}

References RunAction::BeginOfRunAction(), m_currentRun, m_runAborted, m_runInitialized, and m_userRunAction.

Referenced by initG4().

initializeUserActions()

void RunManager::initializeUserActions

(

)

Definition at line 475 of file RunManager.cc.

                                       {
  m_runInterface = new SimRunInterface(this, false);
 
  m_userRunAction = new RunAction(m_pRunAction, m_runInterface, true);
  Connect(m_userRunAction);
 
  G4EventManager* eventManager = m_kernel->GetEventManager();
  eventManager->SetVerboseLevel(m_EvtMgrVerbosity);
 
  if (m_generator != nullptr) {
    EventAction* userEventAction =
        new EventAction(m_pEventAction, m_runInterface, m_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()));
 
  } else {
    edm::LogWarning("SimG4CoreApplication") << " RunManager: WARNING : "
                                            << "No generator; initialized "
                                            << "only RunAction!";
  }
}

References Connect(), g4SimHits_cfi::EventAction, m_EvtMgrVerbosity, m_generator, m_hasWatchers, m_kernel, m_pEventAction, m_pRunAction, m_pStackingAction, m_pSteppingAction, m_pTrackingAction, m_runInterface, m_sVerbose, m_trackManager, m_userRunAction, g4SimHits_cfi::RunAction, CastorDigiValidation::StackingAction, CastorDigiValidation::SteppingAction, and g4SimHits_cfi::TrackingAction.

Referenced by initG4().

produce()

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

Definition at line 392 of file RunManager.cc.

                                                               {
  m_currentEvent = generateEvent(inpevt);
  m_simEvent = new G4SimEvent;
  m_simEvent->hepEvent(m_generator->genEvent());
  m_simEvent->weight(m_generator->eventWeight());
  if (m_generator->genVertex() != nullptr) {
    m_simEvent->collisionPoint(math::XYZTLorentzVectorD(m_generator->genVertex()->x() / centimeter,
                                                        m_generator->genVertex()->y() / centimeter,
                                                        m_generator->genVertex()->z() / centimeter,
                                                        m_generator->genVertex()->t() / second));
  }
  if (m_currentEvent->GetNumberOfPrimaryVertex() == 0) {
    std::stringstream ss;
    ss << " RunManager::produce(): event " << inpevt.id().event() << " with no G4PrimaryVertices\n";
    throw SimG4Exception(ss.str());
 
    abortRun(false);
  } else {
    edm::LogInfo("SimG4CoreApplication") << "RunManager::produce: start Event " << inpevt.id().event() << " of weight "
                                         << m_simEvent->weight() << " with " << m_simEvent->nTracks() << " tracks and "
                                         << m_simEvent->nVertices() << " vertices, generated by "
                                         << m_simEvent->nGenParts() << " particles ";
 
    m_kernel->GetEventManager()->ProcessOneEvent(m_currentEvent);
 
    edm::LogInfo("SimG4CoreApplication") << " RunManager::produce: ended Event " << inpevt.id().event();
  }
}

References abortRun(), G4SimEvent::collisionPoint(), edm::EventID::event(), Generator::eventWeight(), generateEvent(), Generator::genEvent(), Generator::genVertex(), G4SimEvent::hepEvent(), edm::EventBase::id(), m_currentEvent, m_generator, m_kernel, m_simEvent, G4SimEvent::nGenParts(), G4SimEvent::nTracks(), G4SimEvent::nVertices(), edm::second(), contentValuesCheck::ss, and G4SimEvent::weight().

producers()

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

inline

Definition at line 74 of file RunManager.h.

{ return m_producers; }

References m_producers.

resetGenParticleId()

void RunManager::resetGenParticleId ( edm::Event &  inpevt )

protected

Definition at line 556 of file RunManager.cc.

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

References edm::Event::getByToken(), edm::HandleBase::isValid(), m_LHCtr, m_trackManager, and edm::Handle< T >::product().

Referenced by generateEvent().

sensCaloDetectors()

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

inline

Definition at line 73 of file RunManager.h.

{ return m_sensCaloDets; }

References m_sensCaloDets.

sensTkDetectors()

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

inline

Definition at line 72 of file RunManager.h.

{ return m_sensTkDets; }

References m_sensTkDets.

simEvent()

G4SimEvent* RunManager::simEvent ( )

inline

Definition at line 71 of file RunManager.h.

{ return m_simEvent; }

References m_simEvent.

Referenced by SimRunInterface::simEvent().

stopG4()

void RunManager::stopG4

(

)

Definition at line 385 of file RunManager.cc.

                        {
  G4StateManager::GetStateManager()->SetNewState(G4State_Quit);
  if (!m_runTerminated) {
    terminateRun();
  }
}

References m_runTerminated, and terminateRun().

terminateRun()

void RunManager::terminateRun

(

)

Definition at line 521 of file RunManager.cc.

                              {
  if (m_runTerminated) {
    return;
  }
  if (m_userRunAction != nullptr) {
    m_userRunAction->EndOfRunAction(m_currentRun);
    delete m_userRunAction;
    m_userRunAction = nullptr;
  }
  delete m_currentEvent;
  m_currentEvent = nullptr;
  delete m_simEvent;
  m_simEvent = nullptr;
  if (m_kernel != nullptr) {
    m_kernel->RunTermination();
  }
  m_runInitialized = false;
  m_runTerminated = true;
}

References RunAction::EndOfRunAction(), m_currentEvent, m_currentRun, m_kernel, m_runInitialized, m_runTerminated, m_simEvent, and m_userRunAction.

Referenced by abortRun(), stopG4(), and ~RunManager().

Member Data Documentation

firstRun

bool RunManager::firstRun

private

Definition at line 104 of file RunManager.h.

Referenced by initG4().

idealGeomRcdWatcher_

edm::ESWatcher<IdealGeometryRecord> RunManager::idealGeomRcdWatcher_

private

Definition at line 142 of file RunManager.h.

Referenced by initG4().

idealMagRcdWatcher_

edm::ESWatcher<IdealMagneticFieldRecord> RunManager::idealMagRcdWatcher_

private

Definition at line 143 of file RunManager.h.

Referenced by initG4().

m_check

bool RunManager::m_check

private

Definition at line 119 of file RunManager.h.

Referenced by initG4(), and RunManager().

m_currentEvent

G4Event* RunManager::m_currentEvent

private

Definition at line 109 of file RunManager.h.

Referenced by abortEvent(), currentEvent(), generateEvent(), produce(), and terminateRun().

m_currentRun

G4Run* RunManager::m_currentRun

private

Definition at line 108 of file RunManager.h.

Referenced by abortRun(), currentRun(), initializeRun(), and terminateRun().

m_EvtMgrVerbosity

int RunManager::m_EvtMgrVerbosity

private

Definition at line 118 of file RunManager.h.

Referenced by initializeUserActions().

m_FieldFile

std::string RunManager::m_FieldFile

private

Definition at line 145 of file RunManager.h.

Referenced by DumpMagneticField(), initG4(), and RunManager().

m_G4Commands

std::vector<std::string> RunManager::m_G4Commands

private

Definition at line 129 of file RunManager.h.

Referenced by initG4().

m_g4overlap

edm::ParameterSet RunManager::m_g4overlap

private

Definition at line 128 of file RunManager.h.

Referenced by initG4().

m_generator

Generator* RunManager::m_generator

private

Definition at line 90 of file RunManager.h.

Referenced by generateEvent(), generator(), initializeUserActions(), produce(), and ~RunManager().

m_hasWatchers

bool RunManager::m_hasWatchers

private

Definition at line 106 of file RunManager.h.

Referenced by initializeUserActions(), and RunManager().

m_HepMC

edm::EDGetTokenT<edm::HepMCProduct> RunManager::m_HepMC

private

Definition at line 92 of file RunManager.h.

Referenced by generateEvent().

m_kernel

G4RunManagerKernel* RunManager::m_kernel

private

Definition at line 88 of file RunManager.h.

Referenced by abortEvent(), initG4(), initializeUserActions(), produce(), RunManager(), and terminateRun().

m_LHCtr

edm::EDGetTokenT<edm::LHCTransportLinkContainer> RunManager::m_LHCtr

private

Definition at line 93 of file RunManager.h.

Referenced by resetGenParticleId().

m_managerInitialized

bool RunManager::m_managerInitialized

private

Definition at line 100 of file RunManager.h.

Referenced by initG4().

m_nonBeam

bool RunManager::m_nonBeam

private

Definition at line 95 of file RunManager.h.

Referenced by generateEvent().

m_p

edm::ParameterSet RunManager::m_p

private

Definition at line 130 of file RunManager.h.

Referenced by initG4(), and RunManager().

m_pEventAction

edm::ParameterSet RunManager::m_pEventAction

private

Definition at line 124 of file RunManager.h.

Referenced by initializeUserActions().

m_pField

edm::ParameterSet RunManager::m_pField

private

Definition at line 120 of file RunManager.h.

Referenced by initG4().

m_pGenerator

edm::ParameterSet RunManager::m_pGenerator

private

Definition at line 121 of file RunManager.h.

m_physicsList

std::unique_ptr<PhysicsList> RunManager::m_physicsList

private

Definition at line 97 of file RunManager.h.

Referenced by initG4(), and RunManager().

m_PhysicsTablesDir

std::string RunManager::m_PhysicsTablesDir

private

Definition at line 114 of file RunManager.h.

Referenced by initG4().

m_pPhysics

edm::ParameterSet RunManager::m_pPhysics

private

Definition at line 122 of file RunManager.h.

Referenced by initG4().

m_primaryTransformer

PrimaryTransformer* RunManager::m_primaryTransformer

private

Definition at line 98 of file RunManager.h.

Referenced by initG4().

m_producers

std::vector<std::shared_ptr<SimProducer> > RunManager::m_producers

private

Definition at line 138 of file RunManager.h.

Referenced by producers(), and RunManager().

m_pRunAction

edm::ParameterSet RunManager::m_pRunAction

private

Definition at line 123 of file RunManager.h.

Referenced by initializeUserActions().

m_pStackingAction

edm::ParameterSet RunManager::m_pStackingAction

private

Definition at line 125 of file RunManager.h.

Referenced by initializeUserActions().

m_pSteppingAction

edm::ParameterSet RunManager::m_pSteppingAction

private

Definition at line 127 of file RunManager.h.

Referenced by initializeUserActions().

m_pTrackingAction

edm::ParameterSet RunManager::m_pTrackingAction

private

Definition at line 126 of file RunManager.h.

Referenced by initializeUserActions().

m_pUseMagneticField

bool RunManager::m_pUseMagneticField

private

Definition at line 105 of file RunManager.h.

Referenced by initG4().

m_RegionFile

std::string RunManager::m_RegionFile

private

Definition at line 147 of file RunManager.h.

Referenced by RunManager().

m_registry

SimActivityRegistry RunManager::m_registry

private

Definition at line 136 of file RunManager.h.

Referenced by Connect(), initG4(), and RunManager().

m_RestorePhysicsTables

bool RunManager::m_RestorePhysicsTables

private

Definition at line 116 of file RunManager.h.

Referenced by initG4().

m_runAborted

bool RunManager::m_runAborted

private

Definition at line 103 of file RunManager.h.

Referenced by abortRun(), and initializeRun().

m_runInitialized

bool RunManager::m_runInitialized

private

Definition at line 101 of file RunManager.h.

Referenced by initializeRun(), and terminateRun().

m_runInterface

SimRunInterface* RunManager::m_runInterface

private

Definition at line 112 of file RunManager.h.

Referenced by initializeUserActions(), RunManager(), and ~RunManager().

m_runTerminated

bool RunManager::m_runTerminated

private

Definition at line 102 of file RunManager.h.

Referenced by abortEvent(), stopG4(), terminateRun(), and ~RunManager().

m_sensCaloDets

std::vector<SensitiveCaloDetector*> RunManager::m_sensCaloDets

private

Definition at line 133 of file RunManager.h.

Referenced by initG4(), and sensCaloDetectors().

m_sensTkDets

std::vector<SensitiveTkDetector*> RunManager::m_sensTkDets

private

Definition at line 132 of file RunManager.h.

Referenced by initG4(), and sensTkDetectors().

m_simEvent

G4SimEvent* RunManager::m_simEvent

private

Definition at line 110 of file RunManager.h.

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

m_StorePhysicsTables

bool RunManager::m_StorePhysicsTables

private

Definition at line 115 of file RunManager.h.

Referenced by initG4().

m_sVerbose

std::unique_ptr<CMSSteppingVerbose> RunManager::m_sVerbose

private

Definition at line 135 of file RunManager.h.

Referenced by initG4(), initializeUserActions(), and RunManager().

m_trackManager

std::unique_ptr<SimTrackManager> RunManager::m_trackManager

private

Definition at line 140 of file RunManager.h.

Referenced by GetSimTrackManager(), initG4(), initializeUserActions(), and resetGenParticleId().

m_UIsession

CustomUIsession* RunManager::m_UIsession

private

Definition at line 96 of file RunManager.h.

Referenced by initG4(), and RunManager().

m_UseParametrisedEMPhysics

bool RunManager::m_UseParametrisedEMPhysics

private

Definition at line 117 of file RunManager.h.

Referenced by initG4().

m_userRunAction

RunAction* RunManager::m_userRunAction

private

Definition at line 111 of file RunManager.h.

Referenced by initializeRun(), initializeUserActions(), RunManager(), and terminateRun().

m_watchers

std::vector<std::shared_ptr<SimWatcher> > RunManager::m_watchers

private

Definition at line 137 of file RunManager.h.

Referenced by RunManager().

m_WriteFile

std::string RunManager::m_WriteFile

private

Definition at line 146 of file RunManager.h.

Referenced by initG4(), and RunManager().