#include <RunManagerMT.h>

Public Member Functions
void	abortRun (bool softAbort=false)

const SensitiveDetectorCatalog &	catalog () const

void	Connect (RunAction *)

const std::vector< std::string > &	G4Commands () const

void	initG4 (const DDCompactView pDD, const MagneticField pMF, const HepPDT::ParticleDataTable *fPDGTable)

void	initializeUserActions ()

PhysicsList *	physicsListForWorker () const

	RunManagerMT (edm::ParameterSet const &p)

void	stopG4 ()

const DDDWorld &	world () const

	~RunManagerMT ()

Private Member Functions
void	DumpMagneticField (const G4Field *) const

void	terminateRun ()

Private Attributes
SensitiveDetectorCatalog	m_catalog

bool	m_check

G4Run *	m_currentRun

std::string	m_FieldFile

std::vector< std::string >	m_G4Commands

edm::ParameterSet	m_g4overlap

G4GeometryManager *	m_geometryManager

G4MTRunManagerKernel *	m_kernel

bool	m_managerInitialized

edm::ParameterSet	m_p

edm::ParameterSet	m_pField

std::unique_ptr< PhysicsList >	m_physicsList

const std::string	m_PhysicsTablesDir

edm::ParameterSet	m_pPhysics

std::unique_ptr< DDG4ProductionCuts >	m_prodCuts

edm::ParameterSet	m_pRunAction

bool	m_pUseMagneticField

std::string	m_RegionFile

SimActivityRegistry	m_registry

bool	m_RestorePhysicsTables

std::unique_ptr< SimRunInterface >	m_runInterface

bool	m_runTerminated

G4StateManager *	m_stateManager

bool	m_StorePhysicsTables

std::unique_ptr< CustomUIsession >	m_UIsession

RunAction *	m_userRunAction

std::unique_ptr< DDDWorld >	m_world

std::string	m_WriteFile

Friends
class	RunManagerMTWorker

Detailed Description

Definition at line 53 of file RunManagerMT.h.

Constructor & Destructor Documentation

RunManagerMT::RunManagerMT ( edm::ParameterSet const & p )

explicit

Definition at line 65 of file RunManagerMT.cc.

References g4SimHits_cfi::CustomUIsession, edm::ParameterSet::getUntrackedParameter(), m_check, m_currentRun, m_FieldFile, m_geometryManager, m_kernel, m_physicsList, m_prodCuts, m_RegionFile, m_runInterface, m_stateManager, m_UIsession, m_userRunAction, m_world, m_WriteFile, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                    :
       m_managerInitialized(false), 
       m_runTerminated(false),
       m_pUseMagneticField(p.getParameter<bool>("UseMagneticField")),
       m_PhysicsTablesDir(p.getParameter<std::string>("PhysicsTablesDirectory")),
       m_StorePhysicsTables(p.getParameter<bool>("StorePhysicsTables")),
       m_RestorePhysicsTables(p.getParameter<bool>("RestorePhysicsTables")),
       m_pField(p.getParameter<edm::ParameterSet>("MagneticField")),
       m_pPhysics(p.getParameter<edm::ParameterSet>("Physics")),
       m_pRunAction(p.getParameter<edm::ParameterSet>("RunAction")),
       m_g4overlap(p.getParameter<edm::ParameterSet>("G4CheckOverlap")),
       m_G4Commands(p.getParameter<std::vector<std::string> >("G4Commands")),
       m_p(p)
 {    
   m_currentRun = nullptr;
   m_UIsession.reset(new CustomUIsession());
   m_physicsList.reset(nullptr);
   m_world.reset(nullptr);
 
   m_runInterface.reset(nullptr);
   m_prodCuts.reset(nullptr);
   m_userRunAction = nullptr;
   m_currentRun = nullptr;
 
   m_kernel = new G4MTRunManagerKernel();
   m_stateManager = G4StateManager::GetStateManager();
   m_stateManager->SetExceptionHandler(new ExceptionHandler());
   m_geometryManager->G4GeometryManager::GetInstance();
 
   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","");
 }

RunManagerMT::~RunManagerMT ( )

Definition at line 100 of file RunManagerMT.cc.

References stopG4().

 {
   stopG4();
 }

Member Function Documentation

void RunManagerMT::abortRun ( bool softAbort = false )

inline

Definition at line 71 of file RunManagerMT.h.

71 {}

const SensitiveDetectorCatalog& RunManagerMT::catalog ( ) const

inline

Definition at line 77 of file RunManagerMT.h.

Referenced by RunManagerMTWorker::initializeThread().

                                                          {
     return m_catalog;
   }

void RunManagerMT::Connect ( RunAction * runAction )

Definition at line 257 of file RunManagerMT.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 RunManagerMT::DumpMagneticField ( const G4Field * field ) const

private

Definition at line 282 of file RunManagerMT.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 {
     // CMS magnetic field volume
     double rmax = 9000*mm;
     double zmax = 24000*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();
   }
 }

const std::vector<std::string>& RunManagerMT::G4Commands ( ) const

inline

Definition at line 81 of file RunManagerMT.h.

Referenced by RunManagerMTWorker::initializeThread().

                                                         {
     return m_G4Commands;
   }

void RunManagerMT::initG4	(	const DDCompactView *	pDD,
		const MagneticField *	pMF,
		const HepPDT::ParticleDataTable *	fPDGTable
	)

Definition at line 105 of file RunManagerMT.cc.

References RunAction::BeginOfRunAction(), sim::FieldBuilder::build(), trackerTree::check(), mps_setup::cmd, mps_check::command, edm::errors::Configuration, beamerCreator::create(), SimActivityRegistry::dddWorldSignal_, dir, DumpMagneticField(), Exception, g, ecalTB2006H4_GenSimDigiReco_cfg::G4cout, reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), recoMuon::in, initializeUserActions(), edm::errors::LogicError, m_catalog, m_check, m_currentRun, m_FieldFile, m_G4Commands, m_g4overlap, m_kernel, m_managerInitialized, m_p, m_pField, m_physicsList, m_PhysicsTablesDir, m_pPhysics, m_prodCuts, m_pUseMagneticField, m_RegionFile, m_registry, m_RestorePhysicsTables, m_stateManager, m_StorePhysicsTables, m_userRunAction, m_world, m_WriteFile, SiStripPI::max, G4RegionReporter::ReportRegions(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
   if (m_managerInitialized) return;
 
   edm::LogVerbatim("SimG4CoreApplication") 
     << "RunManagerMT: start initialisation of geometry";
   
   // DDDWorld: get the DDCV from the ES and use it to build the World
   G4LogicalVolumeToDDLogicalPartMap map_lv;
   m_world.reset(new DDDWorld(pDD, map_lv, m_catalog, false));
   m_registry.dddWorldSignal_(m_world.get());
 
   // setup the magnetic field
   edm::LogVerbatim("SimG4CoreApplication") 
     << "RunManagerMT: start initialisation of magnetic field";
 
   if (m_pUseMagneticField && !m_FieldFile.empty())
     {
       const GlobalPoint g(0.,0.,0.);
       sim::FieldBuilder fieldBuilder(pMF, m_pField);
       CMSFieldManager* fieldManager = new CMSFieldManager();
       G4TransportationManager * tM =
     G4TransportationManager::GetTransportationManager();
       tM->SetFieldManager(fieldManager);
       fieldBuilder.build( fieldManager, tM->GetPropagatorInField());
       DumpMagneticField(tM->GetFieldManager()->GetDetectorField());
     }
 
   // Create physics list
   edm::LogVerbatim("SimG4CoreApplication") 
     << "RunManagerMT: create PhysicsList";
 
   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
   phys->RegisterPhysics(new ParametrisedEMPhysics("EMoptions",m_pPhysics));
 
   if (m_RestorePhysicsTables) {
     m_physicsList->SetPhysicsTableRetrieved(m_PhysicsTablesDir);
   }
   edm::LogVerbatim("SimG4CoreApplication") 
     << "RunManagerMT: start initialisation of PhysicsList for master";
 
   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_lv, verb, m_pPhysics)); 
     m_prodCuts->update();
   }
   
   m_kernel->SetPhysics(phys);
 
   // Geant4 UI commands before initialisation of physics
   if(!m_G4Commands.empty()) {
     G4cout << "RunManagerMT: Requested UI commands: " << G4endl;
     for (const std::string& command : m_G4Commands) {
       G4cout << "    " << command << G4endl;
       G4UImanager::GetUIpointer()->ApplyCommand(command);
     }
   }
 
   m_stateManager->SetNewState(G4State_Init);
   m_kernel->InitializePhysics();
   m_kernel->SetUpDecayChannels();
 
   // The following line was with the following comment in
   // G4MTRunManager::InitializePhysics() in 10.00.p01; in practice
   // needed to initialize certain singletons during the master thread
   // initialization in order to avoid races later...
   //
   //BERTINI, this is needed to create pseudo-particles, to be removed
   G4CascadeInterface::Initialize();
 
   if (m_kernel->RunInitialization()) { m_managerInitialized = true; }
   else { 
     throw edm::Exception( edm::errors::LogicError, 
               "G4RunManagerKernel initialization failed!"); 
   }
 
   if (m_StorePhysicsTables) {
     std::ostringstream dir;
     dir << m_PhysicsTablesDir << '\0';
     std::string cmd = std::string("/control/shell mkdir -p ")+m_PhysicsTablesDir;
     if (!std::ifstream(dir.str().c_str(), std::ios::in))
       G4UImanager::GetUIpointer()->ApplyCommand(cmd);
     m_physicsList->StorePhysicsTable(m_PhysicsTablesDir);
   }
 
   initializeUserActions();
 
   if(verb > 1) { m_physicsList->DumpCutValuesTable(); }
 
   // geometry dump
   if(!m_WriteFile.empty()) {
     G4GDMLParser gdml;
     gdml.SetRegionExport(true);
     gdml.SetEnergyCutsExport(true);
     gdml.Write(m_WriteFile, m_world->GetWorldVolume(), true);
   }
 
   // G4Region dump
   if(!m_RegionFile.empty()) {
     G4RegionReporter rrep;
     rrep.ReportRegions(m_RegionFile);
   }
 
   // Intersection check
   if(m_check) { G4CheckOverlap check(m_g4overlap); }
 
   // If the Geant4 particle table is needed, decomment the lines below
   //
   //G4ParticleTable::GetParticleTable()->DumpTable("ALL");
   //
   m_stateManager->SetNewState(G4State_GeomClosed);
   m_currentRun = new G4Run(); 
   m_userRunAction->BeginOfRunAction(m_currentRun); 
 }

void RunManagerMT::initializeUserActions ( )

Definition at line 251 of file RunManagerMT.cc.

References Connect(), m_pRunAction, m_runInterface, m_userRunAction, and g4SimHits_cfi::RunAction.

Referenced by initG4().

                                          {
   m_runInterface.reset(new SimRunInterface(this, true));
   m_userRunAction = new RunAction(m_pRunAction, m_runInterface.get(), true);
   Connect(m_userRunAction);
 }

PhysicsList* RunManagerMT::physicsListForWorker ( ) const

inline

Definition at line 88 of file RunManagerMT.h.

References RunManagerMTWorker::terminateRun().

Referenced by RunManagerMTWorker::initializeThread().

                                                    {
     return m_physicsList.get();
   }

void RunManagerMT::stopG4 ( )

Definition at line 263 of file RunManagerMT.cc.

References m_geometryManager, m_runTerminated, m_stateManager, and terminateRun().

Referenced by ~RunManagerMT().

 {
   m_geometryManager->OpenGeometry();
   m_stateManager->SetNewState(G4State_Quit);
   if(!m_runTerminated) { terminateRun(); }
 }

void RunManagerMT::terminateRun ( )

private

Definition at line 270 of file RunManagerMT.cc.

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

Referenced by stopG4().

                                 {
   if(m_userRunAction) {
     m_userRunAction->EndOfRunAction(m_currentRun);
     delete m_userRunAction;
     m_userRunAction = nullptr;
   }
   if(m_kernel && !m_runTerminated) {
     m_kernel->RunTermination();
   }
   m_runTerminated = true;
 }

const DDDWorld& RunManagerMT::world ( ) const

inline

Definition at line 73 of file RunManagerMT.h.

Referenced by RunManagerMTWorker::initializeThread().

                                        {
     return *m_world;
   }

Friends And Related Function Documentation

friend class RunManagerMTWorker

friend

Definition at line 55 of file RunManagerMT.h.

Member Data Documentation

SensitiveDetectorCatalog RunManagerMT::m_catalog

private

Definition at line 124 of file RunManagerMT.h.

Referenced by initG4().

bool RunManagerMT::m_check

private

Definition at line 113 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

G4Run* RunManagerMT::m_currentRun

private

Definition at line 104 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and terminateRun().

std::string RunManagerMT::m_FieldFile

private

Definition at line 126 of file RunManagerMT.h.

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

std::vector<std::string> RunManagerMT::m_G4Commands

private

Definition at line 118 of file RunManagerMT.h.

Referenced by initG4().

edm::ParameterSet RunManagerMT::m_g4overlap

private

Definition at line 117 of file RunManagerMT.h.

Referenced by initG4().

G4GeometryManager* RunManagerMT::m_geometryManager

private

Definition at line 106 of file RunManagerMT.h.

Referenced by RunManagerMT(), and stopG4().

G4MTRunManagerKernel* RunManagerMT::m_kernel

private

Definition at line 96 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and terminateRun().

bool RunManagerMT::m_managerInitialized

private

Definition at line 100 of file RunManagerMT.h.

Referenced by initG4().

edm::ParameterSet RunManagerMT::m_p

private

Definition at line 119 of file RunManagerMT.h.

Referenced by initG4().

edm::ParameterSet RunManagerMT::m_pField

private

Definition at line 114 of file RunManagerMT.h.

Referenced by initG4().

std::unique_ptr<PhysicsList> RunManagerMT::m_physicsList

private

Definition at line 99 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

const std::string RunManagerMT::m_PhysicsTablesDir

private

Definition at line 110 of file RunManagerMT.h.

Referenced by initG4().

edm::ParameterSet RunManagerMT::m_pPhysics

private

Definition at line 115 of file RunManagerMT.h.

Referenced by initG4().

std::unique_ptr<DDG4ProductionCuts> RunManagerMT::m_prodCuts

private

Definition at line 122 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

edm::ParameterSet RunManagerMT::m_pRunAction

private

Definition at line 116 of file RunManagerMT.h.

Referenced by initializeUserActions().

bool RunManagerMT::m_pUseMagneticField

private

Definition at line 102 of file RunManagerMT.h.

Referenced by initG4().

std::string RunManagerMT::m_RegionFile

private

Definition at line 128 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

SimActivityRegistry RunManagerMT::m_registry

private

Definition at line 123 of file RunManagerMT.h.

Referenced by Connect(), and initG4().

bool RunManagerMT::m_RestorePhysicsTables

private

Definition at line 112 of file RunManagerMT.h.

Referenced by initG4().

std::unique_ptr<SimRunInterface> RunManagerMT::m_runInterface

private

Definition at line 108 of file RunManagerMT.h.

Referenced by initializeUserActions(), and RunManagerMT().

bool RunManagerMT::m_runTerminated

private

Definition at line 101 of file RunManagerMT.h.

Referenced by stopG4(), and terminateRun().

G4StateManager* RunManagerMT::m_stateManager

private

Definition at line 105 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and stopG4().

bool RunManagerMT::m_StorePhysicsTables

private

Definition at line 111 of file RunManagerMT.h.

Referenced by initG4().

std::unique_ptr<CustomUIsession> RunManagerMT::m_UIsession

private

Definition at line 98 of file RunManagerMT.h.

Referenced by RunManagerMT().

RunAction* RunManagerMT::m_userRunAction

private

Definition at line 103 of file RunManagerMT.h.

Referenced by initG4(), initializeUserActions(), RunManagerMT(), and terminateRun().

std::unique_ptr<DDDWorld> RunManagerMT::m_world

private

Definition at line 121 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

std::string RunManagerMT::m_WriteFile

private

Definition at line 127 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation