RunManager Class Reference

#include <RunManager.h>

Public Member Functions
void	abortEvent ()
void	abortRun (bool softAbort=false)
void	Connect (RunAction *)
void	Connect (EventAction *)
void	Connect (TrackingAction *)
void	Connect (SteppingAction *)
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_
AttachSD *	m_attach
bool	m_check
sim::ChordFinderSetter *	m_chordFinderSetter
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
edm::ParameterSet	m_pGeometry
std::unique_ptr< PhysicsList >	m_physicsList
std::string	m_PhysicsTablesDir
edm::ParameterSet	m_pPhysics
PrimaryTransformer *	m_primaryTransformer
std::unique_ptr< DDG4ProductionCuts >	m_prodCuts
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
edm::ParameterSet	m_pVertexGenerator
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
std::unique_ptr< CustomUIsession >	m_UIsession
RunAction *	m_userRunAction
std::vector< std::shared_ptr< SimWatcher > >	m_watchers
std::string	m_WriteFile

Detailed Description

Definition at line 59 of file RunManager.h.

Constructor & Destructor Documentation

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

Definition at line 117 of file RunManager.cc.

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

  :   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.getParameter<std::string>("PhysicsTablesDirectory")),
      m_StorePhysicsTables(p.getParameter<bool>("StorePhysicsTables")),
      m_RestorePhysicsTables(p.getParameter<bool>("RestorePhysicsTables")),
      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.getParameter<edm::ParameterSet>("G4CheckOverlap")),
      m_G4Commands(p.getParameter<std::vector<std::string> >("G4Commands")),
      m_p(p), m_chordFinderSetter(nullptr)
{    
  m_UIsession.reset(new CustomUIsession());
  m_kernel = new G4RunManagerKernel();
  G4StateManager::GetStateManager()->SetExceptionHandler(new ExceptionHandler());

  m_check = p.getUntrackedParameter<bool>("CheckOverlap",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);
  }
}

RunManager::~RunManager

(

)

Definition at line 173 of file RunManager.cc.

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

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

Member Function Documentation

void RunManager::abortEvent

(

)

Definition at line 439 of file RunManager.cc.

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

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

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

void RunManager::abortRun

(

bool

softAbort = false

)

Definition at line 524 of file RunManager.cc.

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

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

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

void RunManager::Connect

(

RunAction *

runAction

)

Definition at line 547 of file RunManager.cc.

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().

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

void RunManager::Connect

(

EventAction *

eventAction

)

Definition at line 553 of file RunManager.cc.

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

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

void RunManager::Connect

(

TrackingAction *

trackingAction

)

Definition at line 559 of file RunManager.cc.

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

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

void RunManager::Connect

(

SteppingAction *

steppingAction

)

Definition at line 565 of file RunManager.cc.

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

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

const G4Event* RunManager::currentEvent ( ) const

inline

Definition at line 77 of file RunManager.h.

{ return m_currentEvent; }

const G4Run* RunManager::currentRun ( ) const

inline

Definition at line 73 of file RunManager.h.

{ return m_currentRun; }

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

protected

Definition at line 570 of file RunManager.cc.

References funct::cos(), runTauDisplay::dr, PVValHelper::dz, groupFilesInBlocks::fout, mps_fire::i, createfilelist::int, m_FieldFile, MillePedeFileConverter_cfg::out, phi, point, alignCSCRings::r, funct::sin(), and z.

Referenced by initG4().

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

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

protected

Definition at line 405 of file RunManager.cc.

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().

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

const Generator* RunManager::generator ( ) const

inline

Definition at line 76 of file RunManager.h.

{ return m_generator; }

SimTrackManager * RunManager::GetSimTrackManager

(

)

Definition at line 542 of file RunManager.cc.

References m_trackManager.

Referenced by SimRunInterface::SimRunInterface().

{
  return m_trackManager.get();
}

void RunManager::initG4

(

const edm::EventSetup &

es

)

Definition at line 183 of file RunManager.cc.

References SimActivityRegistry::beginOfJobSignal_, trackerTree::check(), edm::ESWatcher< T >::check(), heppy_check::cmd, edm::errors::Configuration, AttachSD::create(), beamerCreator::create(), SimActivityRegistry::dddWorldSignal_, dir, DumpMagneticField(), Exception, firstRun, g, ecalTB2006H4_GenSimDigiReco_cfg::G4cout, edm::EventSetup::get(), reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), DDDWorld::GetWorldVolume(), GeV, idealGeomRcdWatcher_, idealMagRcdWatcher_, recoMuon::in, initializeRun(), initializeUserActions(), edm::errors::LogicError, m_attach, m_check, m_chordFinderSetter, m_FieldFile, m_G4Commands, m_g4overlap, m_kernel, m_managerInitialized, m_p, m_pField, m_physicsList, m_PhysicsTablesDir, m_pPhysics, m_primaryTransformer, m_prodCuts, m_pUseMagneticField, m_RegionFile, m_registry, m_RestorePhysicsTables, m_sensCaloDets, m_sensTkDets, m_StorePhysicsTables, m_sVerbose, m_trackManager, m_WriteFile, map_, hpstanc_transforms::max, edm::ESHandle< T >::product(), G4RegionReporter::ReportRegions(), and AlCaHLTBitMon_QueryRunRegistry::string.

{
  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";
  }
  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;
  
  // DDDWorld: get the DDCV from the ES and use it to build the World
  edm::ESTransientHandle<DDCompactView> pDD;
  es.get<IdealGeometryRecord>().get(pDD);
   
  G4LogicalVolumeToDDLogicalPartMap map_;
  SensitiveDetectorCatalog catalog_;
  const DDDWorld * world = new DDDWorld(&(*pDD), map_, catalog_, false);
  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) { 
    DumpMagneticField(tM->GetFieldManager()->GetDetectorField()); 
      }
    }

  // we need the track manager now
  m_trackManager = std::unique_ptr<SimTrackManager>(new SimTrackManager);

  // attach sensitive detector
  m_attach = new AttachSD;
  
  std::pair< std::vector<SensitiveTkDetector*>,
    std::vector<SensitiveCaloDetector*> > sensDets = 
    m_attach->create(*world,(*pDD),catalog_,m_p,m_trackManager.get(),
             m_registry);
      
  m_sensTkDets.swap(sensDets.first);
  m_sensCaloDets.swap(sensDets.second);
     
  edm::LogInfo("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(map_,fPDGTable,m_chordFinderSetter,m_pPhysics,m_registry);

  PhysicsList* phys = m_physicsList.get(); 
  if (phys==nullptr) { 
    throw edm::Exception(edm::errors::Configuration)
      << "Physics list construction failed!"; 
  }

  // adding GFlash, Russian Roulette for eletrons and gamma, 
  // step limiters on top of any Physics Lists
  phys->RegisterPhysics(new ParametrisedEMPhysics("EMoptions",m_pPhysics));

  m_physicsList->ResetStoredInAscii();
  std::string tableDir = m_PhysicsTablesDir;
  if (m_RestorePhysicsTables) {
    m_physicsList->SetPhysicsTableRetrieved(tableDir);
  } 
  edm::LogInfo("SimG4CoreApplication") 
    << "RunManager: start initialisation of PhysicsList";

  int verb = std::max(m_pPhysics.getUntrackedParameter<int>("Verbosity",0),
              m_p.getParameter<int>("SteppingVerbosity"));
  m_kernel->SetVerboseLevel(verb);

  m_physicsList->SetDefaultCutValue(m_pPhysics.getParameter<double>("DefaultCutValue")*CLHEP::cm);
  m_physicsList->SetCutsWithDefault();
  if(m_pPhysics.getParameter<bool>("CutsPerRegion")) {
    m_prodCuts.reset(new DDG4ProductionCuts(map_, verb, m_pPhysics));   
    m_prodCuts->update();
  }

  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.getParameter<int>("SteppingVerbosity");
  G4double elim = m_p.getParameter<double>("StepVerboseThreshold")*CLHEP::GeV;
  std::vector<int> ve = m_p.getParameter<std::vector<int> >("VerboseEvents");
  std::vector<int> vn = m_p.getParameter<std::vector<int> >("VertexNumber");
  std::vector<int> vt = m_p.getParameter<std::vector<int> >("VerboseTracks");

  if(sv > 0) {
    m_sVerbose.reset(new CMSSteppingVerbose(sv, elim, ve, vn, vt));
  }
  initializeUserActions();
  
  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]);
    }
  }

  if("" != m_WriteFile) {
    G4GDMLParser gdml;
    gdml.SetRegionExport(true);
    gdml.SetEnergyCutsExport(true);
    gdml.Write(m_WriteFile, world->GetWorldVolume(), true);
  }

  if("" != m_RegionFile) {
    G4RegionReporter rrep;
    rrep.ReportRegions(m_RegionFile);
  }

  if(m_check) { G4CheckOverlap check(m_g4overlap); }

  // If the Geant4 particle table is needed, decomment the lines below
  //
  //  G4cout << "Output of G4ParticleTable DumpTable:" << G4endl;
  //  G4ParticleTable::GetParticleTable()->DumpTable("ALL");
  
  initializeRun();
  firstRun= false;
}

void RunManager::initializeRun

(

)

Definition at line 497 of file RunManager.cc.

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

Referenced by initG4().

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

void RunManager::initializeUserActions

(

)

Definition at line 460 of file RunManager.cc.

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().

{
  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!";
  }
}

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

Definition at line 370 of file RunManager.cc.

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(), nullptr, G4SimEvent::nVertices(), edm::second(), and G4SimEvent::weight().

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

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

inline

Definition at line 85 of file RunManager.h.

                                                           {
    return m_producers;
  }

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

protected

Definition at line 533 of file RunManager.cc.

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

Referenced by generateEvent().

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

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

inline

Definition at line 82 of file RunManager.h.

                                                         { 
    return m_sensCaloDets; 
  }

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

inline

Definition at line 79 of file RunManager.h.

                                                     { 
    return m_sensTkDets; 
  }

G4SimEvent* RunManager::simEvent ( )

inline

Definition at line 78 of file RunManager.h.

Referenced by SimRunInterface::simEvent().

{ return m_simEvent; }

void RunManager::stopG4

(

)

Definition at line 364 of file RunManager.cc.

References m_runTerminated, and terminateRun().

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

void RunManager::terminateRun

(

)

Definition at line 507 of file RunManager.cc.

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

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

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

Member Data Documentation

bool RunManager::firstRun

private

Definition at line 119 of file RunManager.h.

Referenced by initG4().

edm::ESWatcher<IdealGeometryRecord> RunManager::idealGeomRcdWatcher_

private

Definition at line 161 of file RunManager.h.

Referenced by initG4().

edm::ESWatcher<IdealMagneticFieldRecord> RunManager::idealMagRcdWatcher_

private

Definition at line 162 of file RunManager.h.

Referenced by initG4().

AttachSD* RunManager::m_attach

private

Definition at line 148 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_check

private

Definition at line 133 of file RunManager.h.

Referenced by initG4(), and RunManager().

sim::ChordFinderSetter* RunManager::m_chordFinderSetter

private

Definition at line 159 of file RunManager.h.

Referenced by initG4().

G4Event* RunManager::m_currentEvent

private

Definition at line 124 of file RunManager.h.

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

G4Run* RunManager::m_currentRun

private

Definition at line 123 of file RunManager.h.

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

int RunManager::m_EvtMgrVerbosity

private

Definition at line 132 of file RunManager.h.

Referenced by initializeUserActions().

std::string RunManager::m_FieldFile

private

Definition at line 164 of file RunManager.h.

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

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

private

Definition at line 145 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_g4overlap

private

Definition at line 144 of file RunManager.h.

Referenced by initG4().

Generator* RunManager::m_generator

private

Definition at line 105 of file RunManager.h.

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

bool RunManager::m_hasWatchers

private

Definition at line 121 of file RunManager.h.

Referenced by initializeUserActions(), and RunManager().

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

private

Definition at line 107 of file RunManager.h.

Referenced by generateEvent().

G4RunManagerKernel* RunManager::m_kernel

private

Definition at line 103 of file RunManager.h.

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

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

private

Definition at line 108 of file RunManager.h.

Referenced by resetGenParticleId().

bool RunManager::m_managerInitialized

private

Definition at line 115 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_nonBeam

private

Definition at line 110 of file RunManager.h.

Referenced by generateEvent().

edm::ParameterSet RunManager::m_p

private

Definition at line 146 of file RunManager.h.

Referenced by initG4(), and RunManager().

edm::ParameterSet RunManager::m_pEventAction

private

Definition at line 140 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pField

private

Definition at line 135 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pGenerator

private

Definition at line 136 of file RunManager.h.

edm::ParameterSet RunManager::m_pGeometry

private

Definition at line 134 of file RunManager.h.

std::unique_ptr<PhysicsList> RunManager::m_physicsList

private

Definition at line 112 of file RunManager.h.

Referenced by initG4().

std::string RunManager::m_PhysicsTablesDir

private

Definition at line 129 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pPhysics

private

Definition at line 138 of file RunManager.h.

Referenced by initG4().

PrimaryTransformer* RunManager::m_primaryTransformer

private

Definition at line 113 of file RunManager.h.

Referenced by initG4().

std::unique_ptr<DDG4ProductionCuts> RunManager::m_prodCuts

private

Definition at line 152 of file RunManager.h.

Referenced by initG4().

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

private

Definition at line 156 of file RunManager.h.

Referenced by RunManager().

edm::ParameterSet RunManager::m_pRunAction

private

Definition at line 139 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pStackingAction

private

Definition at line 141 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pSteppingAction

private

Definition at line 143 of file RunManager.h.

Referenced by initializeUserActions().

edm::ParameterSet RunManager::m_pTrackingAction

private

Definition at line 142 of file RunManager.h.

Referenced by initializeUserActions().

bool RunManager::m_pUseMagneticField

private

Definition at line 120 of file RunManager.h.

Referenced by initG4().

edm::ParameterSet RunManager::m_pVertexGenerator

private

Definition at line 137 of file RunManager.h.

std::string RunManager::m_RegionFile

private

Definition at line 166 of file RunManager.h.

Referenced by initG4(), and RunManager().

SimActivityRegistry RunManager::m_registry

private

Definition at line 154 of file RunManager.h.

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

bool RunManager::m_RestorePhysicsTables

private

Definition at line 131 of file RunManager.h.

Referenced by initG4().

bool RunManager::m_runAborted

private

Definition at line 118 of file RunManager.h.

Referenced by abortRun(), and initializeRun().

bool RunManager::m_runInitialized

private

Definition at line 116 of file RunManager.h.

Referenced by initializeRun(), and terminateRun().

SimRunInterface* RunManager::m_runInterface

private

Definition at line 127 of file RunManager.h.

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

bool RunManager::m_runTerminated

private

Definition at line 117 of file RunManager.h.

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

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

private

Definition at line 150 of file RunManager.h.

Referenced by initG4().

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

private

Definition at line 149 of file RunManager.h.

Referenced by initG4().

G4SimEvent* RunManager::m_simEvent

private

Definition at line 125 of file RunManager.h.

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

bool RunManager::m_StorePhysicsTables

private

Definition at line 130 of file RunManager.h.

Referenced by initG4().

std::unique_ptr<CMSSteppingVerbose> RunManager::m_sVerbose

private

Definition at line 153 of file RunManager.h.

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

std::unique_ptr<SimTrackManager> RunManager::m_trackManager

private

Definition at line 158 of file RunManager.h.

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

std::unique_ptr<CustomUIsession> RunManager::m_UIsession

private

Definition at line 111 of file RunManager.h.

Referenced by RunManager().

RunAction* RunManager::m_userRunAction

private

Definition at line 126 of file RunManager.h.

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

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

private

Definition at line 155 of file RunManager.h.

Referenced by RunManager().

std::string RunManager::m_WriteFile

private

Definition at line 165 of file RunManager.h.

Referenced by initG4(), and RunManager().