lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.2.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2023-06-30 09:09:57 +02:00
parent aef78ca386
commit dd1f179cda
3780 changed files with 212808 additions and 142780 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/run/src/G4WorkerTaskRunManager.cc
+106 -182
View File
@@ -26,12 +26,16 @@
//
#include "G4WorkerTaskRunManager.hh"
#include "G4AutoLock.hh"
#include "G4MTRunManager.hh"
#include "G4ParallelWorldProcess.hh"
#include "G4ParallelWorldProcessStore.hh"
#include "G4RNGHelper.hh"
#include "G4Run.hh"
#include "G4SDManager.hh"
#include "G4ScoringManager.hh"
#include "G4TaskRunManager.hh"
#include "G4TiMemory.hh"
#include "G4Timer.hh"
#include "G4TransportationManager.hh"
@@ -48,18 +52,10 @@
#include "G4VVisManager.hh"
#include "G4WorkerTaskRunManagerKernel.hh"
#include "G4WorkerThread.hh"
#include "G4AutoLock.hh"
#include "G4ParallelWorldProcessStore.hh"
#include "G4TaskRunManager.hh"
#include <fstream>
#include <sstream>
// namespace
// {
// G4Mutex ConstructScoringWorldsMutex;
// }
//============================================================================//
G4WorkerTaskRunManager* G4WorkerTaskRunManager::GetWorkerRunManager()
@@ -69,29 +65,19 @@ G4WorkerTaskRunManager* G4WorkerTaskRunManager::GetWorkerRunManager()
//============================================================================//
G4WorkerTaskRunManagerKernel*
G4WorkerTaskRunManager::GetWorkerRunManagerKernel()
G4WorkerTaskRunManagerKernel* G4WorkerTaskRunManager::GetWorkerRunManagerKernel()
{
return static_cast<G4WorkerTaskRunManagerKernel*>(
GetWorkerRunManager()->kernel);
return static_cast<G4WorkerTaskRunManagerKernel*>(GetWorkerRunManager()->kernel);
}
//============================================================================//
G4WorkerTaskRunManager::G4WorkerTaskRunManager()
: G4WorkerRunManager()
{}
//============================================================================//
void G4WorkerTaskRunManager::RunInitialization()
{
#ifdef G4MULTITHREADED
if(!visIsSetUp)
{
if (!visIsSetUp) {
G4VVisManager* pVVis = G4VVisManager::GetConcreteInstance();
if(pVVis)
{
if (pVVis != nullptr) {
pVVis->SetUpForAThread();
visIsSetUp = true;
}
@@ -99,51 +85,43 @@ void G4WorkerTaskRunManager::RunInitialization()
#endif
runIsSeeded = false;
if(!(kernel->RunInitialization(fakeRun)))
return;
if (!(kernel->RunInitialization(fakeRun))) return;
// Signal this thread can start event loop.
// Note this will return only when all threads reach this point
G4MTRunManager::GetMasterRunManager()->ThisWorkerReady();
if(fakeRun)
return;
if (fakeRun) return;
const G4UserWorkerInitialization* uwi =
G4MTRunManager::GetMasterRunManager()->GetUserWorkerInitialization();
CleanUpPreviousEvents();
if(currentRun)
delete currentRun;
delete currentRun;
currentRun = nullptr;
if(IfGeometryHasBeenDestroyed())
G4ParallelWorldProcessStore::GetInstance()->UpdateWorlds();
if (IfGeometryHasBeenDestroyed()) G4ParallelWorldProcessStore::GetInstance()->UpdateWorlds();
// Call a user hook: this is guaranteed all threads are "synchronized"
if(uwi)
uwi->WorkerRunStart();
if (uwi != nullptr) uwi->WorkerRunStart();
if(userRunAction)
currentRun = userRunAction->GenerateRun();
if(!currentRun)
currentRun = new G4Run();
if (userRunAction != nullptr) currentRun = userRunAction->GenerateRun();
if (currentRun == nullptr) currentRun = new G4Run();
currentRun->SetRunID(runIDCounter);
G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
numberOfEventToBeProcessed = mrm->GetNumberOfEventsToBeProcessed();
currentRun->SetNumberOfEventToBeProcessed(numberOfEventToBeProcessed);
currentRun->SetDCtable(DCtable);
G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
if(fSDM != nullptr)
{
if (fSDM != nullptr) {
currentRun->SetHCtable(fSDM->GetHCtable());
}
if(G4VScoreNtupleWriter::Instance())
{
auto hce = (fSDM != nullptr) ? fSDM->PrepareNewEvent() : nullptr;
if (G4VScoreNtupleWriter::Instance() != nullptr) {
auto hce = (fSDM != nullptr) ? fSDM->PrepareNewEvent() : nullptr;
isScoreNtupleWriter = G4VScoreNtupleWriter::Instance()->Book(hce);
delete hce;
}
@@ -153,33 +131,27 @@ void G4WorkerTaskRunManager::RunInitialization()
randomNumberStatusForThisRun = oss.str();
currentRun->SetRandomNumberStatus(randomNumberStatusForThisRun);
for(G4int i_prev = 0; i_prev < n_perviousEventsToBeStored; ++i_prev)
for (G4int i_prev = 0; i_prev < n_perviousEventsToBeStored; ++i_prev)
previousEvents->push_back(nullptr);
if(printModulo > 0 || verboseLevel > 0)
{
G4cout << "### Run " << currentRun->GetRunID()
<< " starts on worker thread " << G4Threading::G4GetThreadId() << "."
<< G4endl;
if (printModulo > 0 || verboseLevel > 0) {
G4cout << "### Run " << currentRun->GetRunID() << " starts on worker thread "
<< G4Threading::G4GetThreadId() << "." << G4endl;
}
if(userRunAction)
userRunAction->BeginOfRunAction(currentRun);
if (userRunAction != nullptr) userRunAction->BeginOfRunAction(currentRun);
#if defined(GEANT4_USE_TIMEMORY)
workerRunProfiler.reset(new ProfilerConfig(currentRun));
#endif
if(isScoreNtupleWriter)
{
if (isScoreNtupleWriter) {
G4VScoreNtupleWriter::Instance()->OpenFile();
}
if(storeRandomNumberStatus)
{
if (storeRandomNumberStatus) {
G4String fileN = "currentRun";
if(rngStatusEventsFlag)
{
if (rngStatusEventsFlag) {
std::ostringstream os;
os << "run" << currentRun->GetRunID();
fileN = os.str();
@@ -187,17 +159,15 @@ void G4WorkerTaskRunManager::RunInitialization()
StoreRNGStatus(fileN);
}
runAborted = false;
runAborted = false;
numberOfEventProcessed = 0;
}
//============================================================================//
void G4WorkerTaskRunManager::DoEventLoop(G4int n_event, const char* macroFile,
G4int n_select)
void G4WorkerTaskRunManager::DoEventLoop(G4int n_event, const char* macroFile, G4int n_select)
{
if(!userPrimaryGeneratorAction)
{
if (userPrimaryGeneratorAction == nullptr) {
G4Exception("G4RunManager::GenerateEvent()", "Run0032", FatalException,
"G4VUserPrimaryGeneratorAction is not defined!");
}
@@ -207,7 +177,7 @@ void G4WorkerTaskRunManager::DoEventLoop(G4int n_event, const char* macroFile,
InitializeEventLoop(n_event, macroFile, n_select);
// Reset random number seeds queue
while(seedsQueue.size() > 0)
while (!seedsQueue.empty())
seedsQueue.pop();
// for each run, worker should receive at least one set of random number
// seeds.
@@ -215,24 +185,18 @@ void G4WorkerTaskRunManager::DoEventLoop(G4int n_event, const char* macroFile,
// Event loop
eventLoopOnGoing = true;
G4int i_event = -1;
nevModulo = -1;
currEvID = -1;
G4int i_event = -1;
nevModulo = -1;
currEvID = -1;
for(G4int evt = 0; evt < n_event; ++evt)
{
for (G4int evt = 0; evt < n_event; ++evt) {
ProcessOneEvent(i_event);
if(eventLoopOnGoing)
{
if (eventLoopOnGoing) {
TerminateOneEvent();
if(runAborted)
eventLoopOnGoing = false;
if (runAborted) eventLoopOnGoing = false;
}
if(!eventLoopOnGoing)
break;
if (!eventLoopOnGoing) break;
}
// TerminateEventLoop();
}
//============================================================================//
@@ -240,15 +204,13 @@ void G4WorkerTaskRunManager::DoEventLoop(G4int n_event, const char* macroFile,
void G4WorkerTaskRunManager::ProcessOneEvent(G4int i_event)
{
currentEvent = GenerateEvent(i_event);
if(eventLoopOnGoing)
{
if (eventLoopOnGoing) {
eventManager->ProcessOneEvent(currentEvent);
AnalyzeEvent(currentEvent);
UpdateScoring();
if(currentEvent->GetEventID() < n_select_msg)
{
G4cout << "Applying command \"" << msgText << "\" @ " << __FUNCTION__
<< ":" << __LINE__ << G4endl;
if (currentEvent->GetEventID() < n_select_msg) {
G4cout << "Applying command \"" << msgText << "\" @ " << __FUNCTION__ << ":" << __LINE__
<< G4endl;
G4UImanager::GetUIpointer()->ApplyCommand(msgText);
}
}
@@ -258,46 +220,37 @@ void G4WorkerTaskRunManager::ProcessOneEvent(G4int i_event)
G4Event* G4WorkerTaskRunManager::GenerateEvent(G4int i_event)
{
G4Event* anEvent = new G4Event(i_event);
long s1 = 0;
long s2 = 0;
long s3 = 0;
auto anEvent = new G4Event(i_event);
G4long s1 = 0;
G4long s2 = 0;
G4long s3 = 0;
G4bool eventHasToBeSeeded = true;
if(G4MTRunManager::SeedOncePerCommunication() == 1 && runIsSeeded)
eventHasToBeSeeded = false;
if (G4MTRunManager::SeedOncePerCommunication() == 1 && runIsSeeded) eventHasToBeSeeded = false;
if(i_event < 0)
{
if (i_event < 0) {
G4int nevM = G4MTRunManager::GetMasterRunManager()->GetEventModulo();
if(nevM == 1)
{
eventLoopOnGoing = G4MTRunManager::GetMasterRunManager()->SetUpAnEvent(
anEvent, s1, s2, s3, eventHasToBeSeeded);
if (nevM == 1) {
eventLoopOnGoing = G4MTRunManager::GetMasterRunManager()->SetUpAnEvent(anEvent, s1, s2, s3,
eventHasToBeSeeded);
runIsSeeded = true;
}
else
{
if(nevModulo <= 0)
{
G4int nevToDo = G4MTRunManager::GetMasterRunManager()->SetUpNEvents(
anEvent, &seedsQueue, eventHasToBeSeeded);
if(nevToDo == 0)
else {
if (nevModulo <= 0) {
G4int nevToDo = G4MTRunManager::GetMasterRunManager()->SetUpNEvents(anEvent, &seedsQueue,
eventHasToBeSeeded);
if (nevToDo == 0)
eventLoopOnGoing = false;
else
{
currEvID = anEvent->GetEventID();
else {
currEvID = anEvent->GetEventID();
nevModulo = nevToDo - 1;
}
}
else
{
if(G4MTRunManager::SeedOncePerCommunication() > 0)
eventHasToBeSeeded = false;
else {
if (G4MTRunManager::SeedOncePerCommunication() > 0) eventHasToBeSeeded = false;
anEvent->SetEventID(++currEvID);
nevModulo--;
}
if(eventLoopOnGoing && eventHasToBeSeeded)
{
if (eventLoopOnGoing && eventHasToBeSeeded) {
s1 = seedsQueue.front();
seedsQueue.pop();
s2 = seedsQueue.front();
@@ -305,27 +258,22 @@ G4Event* G4WorkerTaskRunManager::GenerateEvent(G4int i_event)
}
}
if(!eventLoopOnGoing)
{
if (!eventLoopOnGoing) {
delete anEvent;
return nullptr;
}
}
else if(eventHasToBeSeeded)
{
else if (eventHasToBeSeeded) {
// Need to reseed random number generator
G4RNGHelper* helper = G4RNGHelper::GetInstance();
s1 = helper->GetSeed(i_event * 2);
s2 = helper->GetSeed(i_event * 2 + 1);
s1 = helper->GetSeed(i_event * 2);
s2 = helper->GetSeed(i_event * 2 + 1);
}
if(eventHasToBeSeeded)
{
long seeds[3] = { s1, s2, 0 };
if (eventHasToBeSeeded) {
G4long seeds[3] = {s1, s2, 0};
G4Random::setTheSeeds(seeds, -1);
runIsSeeded = true;
////G4cout<<"Event "<<currEvID<<" is seeded with { "<<s1<<", "<<s2<<"
///}"<<G4endl;
}
// Read from file seed.
@@ -342,44 +290,36 @@ G4Event* G4WorkerTaskRunManager::GenerateEvent(G4int i_event)
};
G4bool RNGstatusReadFromFile = false;
if(readStatusFromFile)
{
if (readStatusFromFile) {
// Build full path of RNG status file for this event
std::ostringstream os;
os << filename() << ".rndm";
const G4String& randomStatusFile = os.str();
std::ifstream ifile(randomStatusFile.c_str());
if(ifile)
{
if (ifile) {
// File valid and readable
RNGstatusReadFromFile = true;
G4Random::restoreEngineStatus(randomStatusFile.c_str());
}
}
if(storeRandomNumberStatusToG4Event == 1 ||
storeRandomNumberStatusToG4Event == 3)
{
if (storeRandomNumberStatusToG4Event == 1 || storeRandomNumberStatusToG4Event == 3) {
std::ostringstream oss;
G4Random::saveFullState(oss);
randomNumberStatusForThisEvent = oss.str();
anEvent->SetRandomNumberStatus(randomNumberStatusForThisEvent);
}
if(storeRandomNumberStatus && !RNGstatusReadFromFile)
{
if (storeRandomNumberStatus && !RNGstatusReadFromFile) {
// If reading from file, avoid to rewrite the same
G4String fileN = "currentEvent";
if(rngStatusEventsFlag)
fileN = filename();
if (rngStatusEventsFlag) fileN = filename();
StoreRNGStatus(fileN);
}
if(printModulo > 0 && anEvent->GetEventID() % printModulo == 0)
{
if (printModulo > 0 && anEvent->GetEventID() % printModulo == 0) {
G4cout << "--> Event " << anEvent->GetEventID() << " starts";
if(eventHasToBeSeeded)
G4cout << " with initial seeds (" << s1 << "," << s2 << ")";
if (eventHasToBeSeeded) G4cout << " with initial seeds (" << s1 << "," << s2 << ")";
G4cout << "." << G4endl;
}
userPrimaryGeneratorAction->GeneratePrimaries(anEvent);
@@ -390,8 +330,7 @@ G4Event* G4WorkerTaskRunManager::GenerateEvent(G4int i_event)
void G4WorkerTaskRunManager::RunTermination()
{
if(!fakeRun && currentRun)
{
if (!fakeRun && (currentRun != nullptr)) {
#if defined(GEANT4_USE_TIMEMORY)
workerRunProfiler.reset();
#endif
@@ -402,12 +341,10 @@ void G4WorkerTaskRunManager::RunTermination()
//(TerminateRun allows for synch via G4RunAction::EndOfRun)
const G4UserWorkerInitialization* uwi =
G4MTRunManager::GetMasterRunManager()->GetUserWorkerInitialization();
if(uwi)
uwi->WorkerRunEnd();
if (uwi != nullptr) uwi->WorkerRunEnd();
}
if(currentRun)
{
if (currentRun != nullptr) {
G4RunManager::RunTermination();
}
// Signal this thread has finished envent-loop.
@@ -419,21 +356,17 @@ void G4WorkerTaskRunManager::RunTermination()
void G4WorkerTaskRunManager::TerminateEventLoop()
{
if(verboseLevel > 0 && !fakeRun)
{
if (verboseLevel > 0 && !fakeRun) {
timer->Stop();
// prefix with thread # info due to how TBB calls this function
G4String prefix =
"[thread " + std::to_string(workerContext->GetThreadId()) + "] ";
G4String prefix = "[thread " + std::to_string(workerContext->GetThreadId()) + "] ";
G4cout << prefix << "Thread-local run terminated." << G4endl;
G4cout << prefix << "Run Summary" << G4endl;
if(runAborted)
G4cout << prefix << " Run Aborted after " << numberOfEventProcessed
<< " events processed." << G4endl;
else
G4cout << prefix
<< " Number of events processed : " << numberOfEventProcessed
if (runAborted)
G4cout << prefix << " Run Aborted after " << numberOfEventProcessed << " events processed."
<< G4endl;
else
G4cout << prefix << " Number of events processed : " << numberOfEventProcessed << G4endl;
G4cout << prefix << " " << *timer << G4endl;
}
}
@@ -455,8 +388,7 @@ void G4WorkerTaskRunManager::SetupDefaultRNGEngine()
void G4WorkerTaskRunManager::StoreRNGStatus(const G4String& fn)
{
std::ostringstream os;
os << randomNumberStatusDir << "G4Worker" << workerContext->GetThreadId()
<< "_" << fn << ".rndm";
os << randomNumberStatusDir << "G4Worker" << workerContext->GetThreadId() << "_" << fn << ".rndm";
G4Random::saveEngineStatus(os.str().c_str());
}
@@ -465,18 +397,15 @@ void G4WorkerTaskRunManager::StoreRNGStatus(const G4String& fn)
void G4WorkerTaskRunManager::ProcessUI()
{
G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
if(!mrm)
return;
if (mrm == nullptr) return;
//------------------------------------------------------------------------//
// Check UI commands not already processed
auto command_stack = mrm->GetCommandStack();
bool matching = (command_stack.size() == processedCommandStack.size());
if(matching)
{
for(uintmax_t i = 0; i < command_stack.size(); ++i)
if(processedCommandStack.at(i) != command_stack.at(i))
{
bool matching = (command_stack.size() == processedCommandStack.size());
if (matching) {
for (uintmax_t i = 0; i < command_stack.size(); ++i)
if (processedCommandStack.at(i) != command_stack.at(i)) {
matching = false;
break;
}
@@ -484,9 +413,8 @@ void G4WorkerTaskRunManager::ProcessUI()
//------------------------------------------------------------------------//
// Execute UI commands stored in the master UI manager
if(!matching)
{
for(const auto& itr : command_stack)
if (!matching) {
for (const auto& itr : command_stack)
G4UImanager::GetUIpointer()->ApplyCommand(itr);
processedCommandStack = command_stack;
}
@@ -497,8 +425,8 @@ void G4WorkerTaskRunManager::ProcessUI()
void G4WorkerTaskRunManager::DoCleanup()
{
CleanUpPreviousEvents();
if(currentRun)
delete currentRun;
delete currentRun;
currentRun = nullptr;
}
@@ -506,16 +434,14 @@ void G4WorkerTaskRunManager::DoCleanup()
void G4WorkerTaskRunManager::DoWork()
{
G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
G4bool newRun = false;
const G4Run* run = mrm->GetCurrentRun();
G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
G4bool newRun = false;
const G4Run* run = mrm->GetCurrentRun();
G4ThreadLocalStatic G4int runId = -1;
if(run && run->GetRunID() != runId)
{
runId = run->GetRunID();
if ((run != nullptr) && run->GetRunID() != runId) {
runId = run->GetRunID();
newRun = true;
if(runId > 0)
{
if (runId > 0) {
ProcessUI();
assert(workerContext != nullptr);
}
@@ -523,19 +449,17 @@ void G4WorkerTaskRunManager::DoWork()
}
// Start this run
G4int nevts = mrm->GetNumberOfEventsToBeProcessed();
G4int numSelect = mrm->GetNumberOfSelectEvents();
G4int nevts = mrm->GetNumberOfEventsToBeProcessed();
G4int numSelect = mrm->GetNumberOfSelectEvents();
G4String macroFile = mrm->GetSelectMacro();
bool empty_macro = (macroFile == "" || macroFile == " ");
G4bool empty_macro = (macroFile.empty() || macroFile == " ");
const char* macro = (empty_macro) ? nullptr : macroFile.c_str();
numSelect = (empty_macro) ? -1 : numSelect;
numSelect = (empty_macro) ? -1 : numSelect;
if(newRun)
{
if (newRun) {
G4bool cond = ConfirmBeamOnCondition();
if(cond)
{
if (cond) {
ConstructScoringWorlds();
RunInitialization();
}