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

Import Geant4 10.7.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2020-12-04 12:30:43 +01:00
parent 67ba86d073
commit dab42d2018
3770 changed files with 226369 additions and 286486 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/analysis/root/src/G4RootAnalysisManager.cc
+76 -374
View File
@@ -28,11 +28,10 @@
#include "G4RootAnalysisManager.hh"
#include "G4RootFileManager.hh"
#include "G4RootNtupleManager.hh"
#include "G4RootMainNtupleManager.hh"
#include "G4RootPNtupleManager.hh"
#include "G4RootNtupleFileManager.hh"
#include "G4AnalysisVerbose.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
@@ -40,6 +39,8 @@
#include <iostream>
#include <cstdio>
using namespace G4Analysis;
// mutex in a file scope
namespace {
@@ -78,13 +79,8 @@ G4bool G4RootAnalysisManager::IsInstance()
//_____________________________________________________________________________
G4RootAnalysisManager::G4RootAnalysisManager(G4bool isMaster)
: G4ToolsAnalysisManager("Root", isMaster),
fNofNtupleFiles(0),
fNtupleRowWise(false),
fNtupleRowMode(true),
fNtupleMergeMode(G4NtupleMergeMode::kNone),
fNtupleManager(nullptr),
fSlaveNtupleManager(nullptr),
fFileManager(nullptr)
fFileManager(nullptr),
fNtupleFileManager(nullptr)
{
if ( ( isMaster && fgMasterInstance ) || ( fgInstance ) ) {
G4ExceptionDescription description;
@@ -104,14 +100,10 @@ G4RootAnalysisManager::G4RootAnalysisManager(G4bool isMaster)
fFileManager->SetBasketSize(fgkDefaultBasketSize);
fFileManager->SetBasketEntries(fgkDefaultBasketEntries);
// Do not merge ntuples by default
// Merging may require user code migration as analysis manager
// must be created both on master and workers.
auto mergeNtuples = false;
SetNtupleMergingMode(mergeNtuples, fNofNtupleFiles);
// Create ntuple managers
CreateNtupleManagers();
// Ntuple file manager
fNtupleFileManager = std::make_shared<G4RootNtupleFileManager>(fState);
fNtupleFileManager->SetFileManager(fFileManager);
fNtupleFileManager->SetBookingManager(fNtupleBookingManager);
}
//_____________________________________________________________________________
@@ -125,190 +117,6 @@ G4RootAnalysisManager::~G4RootAnalysisManager()
// private methods
//
//_____________________________________________________________________________
void G4RootAnalysisManager::SetNtupleMergingMode(G4bool mergeNtuples,
G4int nofNtupleFiles)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()
->Message("set", "ntuple merging mode", "");
#endif
auto canMerge = true;
// Illegal situations
if ( mergeNtuples && ( ! G4Threading::IsMultithreadedApplication() ) ) {
if ( nofNtupleFiles > 0 ) {
G4ExceptionDescription description;
description
<< " " << "Merging ntuples is not applicable in sequential application."
<< G4endl
<< " " << "Setting was ignored.";
G4Exception("G4RootAnalysisManager::SetNtupleMergingMode()",
"Analysis_W013", JustWarning, description);
}
canMerge = false;
}
// Illegal situations
if ( mergeNtuples && G4Threading::IsMultithreadedApplication() &&
( ! fgMasterInstance ) ) {
G4ExceptionDescription description;
description
<< " " << "Merging ntuples requires G4AnalysisManager instance on master."
<< G4endl
<< " " << "Setting was ignored.";
G4Exception("G4RootAnalysisManager::SetNtupleMergingMode()",
"Analysis_W013", JustWarning, description);
canMerge = false;
}
G4String mergingMode;
if ( ( ! mergeNtuples ) || ( ! canMerge ) ) {
fNtupleMergeMode = G4NtupleMergeMode::kNone;
mergingMode = "G4NtupleMergeMode::kNone";
}
else {
// Set the number of reduced ntuple files
fNofNtupleFiles = nofNtupleFiles;
// Check the number of reduced ntuple files
// if ( fNofNtupleFiles < 0 || fNofNtupleFiles > nofThreads ) {
if ( fNofNtupleFiles < 0 ) {
G4ExceptionDescription description;
description
<< " " << "Number of reduced files must be [0, nofThreads]."
<< G4endl
<< " " << "Cannot set " << nofNtupleFiles
// << " files when nofThreads is " << nofThreads << G4endl
<< " files" << G4endl
<< " " << "Ntuples will be merged in a single file.";
G4Exception("G4RootAnalysisManager::SetNtupleMergingMode()",
"Analysis_W013", JustWarning, description);
fNofNtupleFiles = 0;
}
// if ( fNofNtupleFiles == nofThreads ) {
// // add warning that no merging will be applied
// fNtupleMergeMode = G4NtupleMergeMode::kNone;
// fNofNtupleFiles = 0;
// mergingMode = "G4NtupleMergeMode::kNone";
// }
// else {
// G4bool isMaster = ! G4Threading::IsWorkerThread();
// if ( isMaster ) {
// fNtupleMergeMode = G4NtupleMergeMode::kMain;
// mergingMode = "G4NtupleMergeMode::kMain";
// } else {
// fNtupleMergeMode = G4NtupleMergeMode::kSlave;
// mergingMode = "G4NtupleMergeMode::kSlave";
// }
// }
// Forced merging mode
G4bool isMaster = ! G4Threading::IsWorkerThread();
if ( isMaster ) {
fNtupleMergeMode = G4NtupleMergeMode::kMain;
mergingMode = "G4NtupleMergeMode::kMain";
} else {
fNtupleMergeMode = G4NtupleMergeMode::kSlave;
mergingMode = "G4NtupleMergeMode::kSlave";
}
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()
->Message("set", "ntuple merging mode", mergingMode);
#endif
}
//_____________________________________________________________________________
void G4RootAnalysisManager::ClearNtupleManagers()
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("clear", "ntuple managers", "");
#endif
if ( fNtupleMergeMode != G4NtupleMergeMode::kSlave ) {
// Do not reset master ntuple manager
delete fNtupleManager;
fNtupleManager = nullptr;
// SetNtupleManager(fNtupleManager);
}
delete fSlaveNtupleManager;
fSlaveNtupleManager = nullptr;
#ifdef G4VERBOSE
if ( fState.GetVerboseL3() )
fState.GetVerboseL3()->Message("clear", "ntuple managers", "");
#endif
}
//_____________________________________________________________________________
void G4RootAnalysisManager::CreateNtupleManagers()
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("create", "ntuple managers", "");
#endif
switch ( fNtupleMergeMode )
{
case G4NtupleMergeMode::kNone:
fNtupleManager = new G4RootNtupleManager(fState, 0, fNtupleRowWise, fNtupleRowMode);
fNtupleManager->SetFileManager(fFileManager);
SetNtupleManager(fNtupleManager);
break;
case G4NtupleMergeMode::kMain: {
G4int nofMainManagers = fNofNtupleFiles;
if ( ! nofMainManagers ) nofMainManagers = 1;
// create one manager if merging required into the histos & profiles files
fNtupleManager
= new G4RootNtupleManager(fState, nofMainManagers, fNtupleRowWise, fNtupleRowMode);
fNtupleManager->SetFileManager(fFileManager);
SetNtupleManager(fNtupleManager);
break;
}
case G4NtupleMergeMode::kSlave:
fNtupleManager = fgMasterInstance->fNtupleManager;
// The master class is used only in Get* functions
auto mainNtupleManager
= fNtupleManager->GetMainNtupleManager(GetNtupleFileNumber());
fSlaveNtupleManager
= new G4RootPNtupleManager(mainNtupleManager, fState, fNtupleRowWise, fNtupleRowMode);
SetNtupleManager(fSlaveNtupleManager);
break;
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL3() )
fState.GetVerboseL3()->Message("create", "ntuple managers", "");
#endif
}
//_____________________________________________________________________________
G4int G4RootAnalysisManager::GetNtupleFileNumber()
{
if ( ! fNofNtupleFiles ) return 0;
G4int nofMainManagers = fNofNtupleFiles;
if ( ! nofMainManagers ) nofMainManagers = 1;
// Debug - check G4Threading::GetNumberOfRunningWorkerThreads()
G4cout << "In GetNtupleFileNumber: "
<< G4Threading::GetNumberOfRunningWorkerThreads() << G4endl;
auto fileNumber = G4Threading::G4GetThreadId() % nofMainManagers;
return fileNumber;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::WriteH1()
{
@@ -320,8 +128,7 @@ G4bool G4RootAnalysisManager::WriteH1()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directory = fFileManager->GetHistoDirectory();
result = WriteT(h1Vector, hnVector, directory, "h1");
result = WriteT(h1Vector, hnVector, "h1");
}
else {
// The worker manager just adds its histograms to the master
@@ -345,8 +152,7 @@ G4bool G4RootAnalysisManager::WriteH2()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directory = fFileManager->GetHistoDirectory();
result = WriteT(h2Vector, hnVector, directory, "h2");
result = WriteT(h2Vector, hnVector, "h2");
}
else {
// The worker manager just adds its histograms to the master
@@ -370,8 +176,7 @@ G4bool G4RootAnalysisManager::WriteH3()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directory = fFileManager->GetHistoDirectory();
result = WriteT(h3Vector, hnVector, directory, "h3");
result = WriteT(h3Vector, hnVector, "h3");
}
else {
// The worker manager just adds its histograms to the master
@@ -395,8 +200,7 @@ G4bool G4RootAnalysisManager::WriteP1()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directory = fFileManager->GetHistoDirectory();
result = WriteT(p1Vector, hnVector, directory, "p1");
result = WriteT(p1Vector, hnVector, "p1");
}
else {
// The worker manager just adds its histograms to the master
@@ -420,8 +224,7 @@ G4bool G4RootAnalysisManager::WriteP2()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directory = fFileManager->GetHistoDirectory();
result = WriteT(p2Vector, hnVector, directory, "p2");
result = WriteT(p2Vector, hnVector, "p2");
}
else {
// The worker manager just adds its histograms to the master
@@ -434,56 +237,6 @@ G4bool G4RootAnalysisManager::WriteP2()
return result;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::WriteNtuple()
{
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ) return true;
auto finalResult = true;
G4String ntupleType;
if ( fNtupleMergeMode == G4NtupleMergeMode::kMain ) ntupleType = "main ntuples";
if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave ) ntupleType = "slave ntuples";
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("merge", ntupleType, "");
#endif
if ( fNtupleMergeMode == G4NtupleMergeMode::kMain ) {
auto result = fNtupleManager->Merge();
finalResult = result && finalResult;
}
if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave ) {
auto result = fSlaveNtupleManager->Merge();
finalResult = result && finalResult;
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()->Message("merge", ntupleType, "");
#endif
return finalResult;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::ResetNtuple()
{
// Reset histograms and ntuple
auto finalResult = true;
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ||
fNtupleMergeMode == G4NtupleMergeMode::kMain ) {
auto result = fNtupleManager->Reset(false);
finalResult = result && finalResult;
}
return finalResult;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::Reset()
{
@@ -494,7 +247,7 @@ G4bool G4RootAnalysisManager::Reset()
auto result = G4ToolsAnalysisManager::Reset();
finalResult = finalResult && result;
result = ResetNtuple();
result = fNtupleFileManager->Reset();
finalResult = result && finalResult;
return finalResult;
@@ -507,67 +260,36 @@ G4bool G4RootAnalysisManager::Reset()
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::OpenFileImpl(const G4String& fileName)
{
// Create ntuple manager(s)
// and set it to base class which takes then their ownership
SetNtupleManager(fNtupleFileManager->CreateNtupleManager());
auto finalResult = true;
auto result = fFileManager->SetFileName(fileName);
// Open file
if ( fNtupleFileManager->GetMergeMode() != G4NtupleMergeMode::kSlave ) {
auto result = fFileManager->OpenFile(fileName);
finalResult = finalResult && result;
}
// Open ntuple file(s) and create ntuples from bookings
auto result = fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
finalResult = finalResult && result;
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ) {
#ifdef G4VERBOSE
G4String name = fFileManager->GetFullFileName();
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("open", "analysis file", name);
#endif
result = fFileManager->OpenFile(fileName);
finalResult = finalResult && result;
fNtupleManager->SetNtupleDirectory(fFileManager->GetNtupleDirectory());
fNtupleManager->CreateNtuplesFromBooking();
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()->Message("open", "analysis file", name, finalResult);
#endif
}
if ( fNtupleMergeMode == G4NtupleMergeMode::kMain ) {
#ifdef G4VERBOSE
G4String name = fFileManager->GetFullFileName();
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("open", "main analysis file", name);
#endif
fFileManager->SetNofNtupleFiles(fNofNtupleFiles);
result = fFileManager->OpenFile(fileName);
finalResult = finalResult && result;
fNtupleManager->CreateNtuplesFromBooking();
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()->Message("open", "main analysis file", name, finalResult);
#endif
}
if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave ) {
G4cout << "Going to create slave ntuples from main" << G4endl;
// No file is open by Slave manager
fSlaveNtupleManager->CreateNtuplesFromMain();
}
return finalResult;
}
//_____________________________________________________________________________
G4bool G4RootAnalysisManager::WriteImpl()
{
auto finalResult = true;
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("write", "files", "");
#endif
if ( ! fgMasterInstance &&
( ( ! fH1Manager->IsEmpty() ) || ( ! fH2Manager->IsEmpty() ) ||
( ! fH3Manager->IsEmpty() ) || ( ! fP1Manager->IsEmpty() ) ||
@@ -602,12 +324,13 @@ G4bool G4RootAnalysisManager::WriteImpl()
finalResult = finalResult && result;
// Ntuples
result = WriteNtuple();
result = fNtupleFileManager->ActionAtWrite();
finalResult = finalResult && result;
// File
if ( fNtupleMergeMode != G4NtupleMergeMode::kSlave ) {
result = fFileManager->WriteFile();
if ( fNtupleFileManager->GetMergeMode() != G4NtupleMergeMode::kSlave ) {
// write all open files
result = fFileManager->WriteFiles();
finalResult = finalResult && result;
}
@@ -617,6 +340,12 @@ G4bool G4RootAnalysisManager::WriteImpl()
finalResult = finalResult && result;
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()->Message("write", "files", "", finalResult);
}
#endif
return finalResult;
}
@@ -625,46 +354,51 @@ G4bool G4RootAnalysisManager::CloseFileImpl(G4bool reset)
{
auto finalResult = true;
G4bool isNtupleManagerEmpty = fNtupleManager->IsEmpty();
// the ntuple decription vector is cleared on Reset()
// in kNoMergeAfterOpen ntuple manager mode
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("close", "files", "");
#endif
auto result = true;
if ( reset ) {
result = Reset();
} else {
// ntuple must be reset
result = ResetNtuple();
}
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4RootAnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4RootAnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
}
}
finalResult = finalResult && result;
if ( fNtupleMergeMode != G4NtupleMergeMode::kSlave ) {
// close file
fFileManager->CloseFile();
result = fNtupleFileManager->ActionAtCloseFile(reset);
finalResult = finalResult && result;
if ( fNtupleFileManager->GetMergeMode() != G4NtupleMergeMode::kSlave ) {
// close all open files
result = fFileManager->CloseFiles();
finalResult = finalResult && result;
}
// No files clean-up in sequential mode
if ( ! G4Threading::IsMultithreadedApplication() ) return finalResult;
G4bool isNtupleManagerEmpty = fNtupleBookingManager->IsEmpty();
// Delete files if empty in MT mode
if ( ( fState.GetIsMaster() &&
fH1Manager->IsEmpty() && fH2Manager->IsEmpty() && fH3Manager->IsEmpty() &&
fP1Manager->IsEmpty() && fP2Manager->IsEmpty() && isNtupleManagerEmpty ) ||
( ( ! fState.GetIsMaster() ) && isNtupleManagerEmpty &&
fNtupleMergeMode == G4NtupleMergeMode::kNone ) ) {
fNtupleFileManager->GetMergeMode() == G4NtupleMergeMode::kNone ) ) {
result = ! std::remove(fFileManager->GetFullFileName());
// std::remove returns 0 when success
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Removing file "
<< fFileManager->GetFullFileName() << " failed";
G4Exception("G4XmlAnalysisManager::CloseFile()",
G4Exception("G4RootAnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
}
finalResult = finalResult && result;
@@ -674,6 +408,13 @@ G4bool G4RootAnalysisManager::CloseFileImpl(G4bool reset)
->Message("delete", "empty file", fFileManager->GetFullFileName());
#endif
}
else {
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()
->Message("close", "files", "");
#endif
}
return finalResult;
}
@@ -685,53 +426,14 @@ G4bool G4RootAnalysisManager::CloseFileImpl(G4bool reset)
//_____________________________________________________________________________
void G4RootAnalysisManager::SetNtupleMerging(G4bool mergeNtuples,
G4int nofNtupleFiles)
{
// Set ntuple merging mode
SetNtupleMergingMode(mergeNtuples, nofNtupleFiles);
// Clear existing managers
ClearNtupleManagers();
// Re-create managers
CreateNtupleManagers();
fNtupleFileManager->SetNtupleMerging(mergeNtuples, nofNtupleFiles);
}
//_____________________________________________________________________________
void G4RootAnalysisManager::SetNtupleRowWise(G4bool rowWise, G4bool rowMode)
{
#ifdef G4VERBOSE
// Print info even when setting makes no effect
// (as we do not get printed the default setting in the output)
G4String rowWiseMode;
if ( rowWise ) {
rowWiseMode = "row-wise with extra branch";
}
else if ( rowMode ) {
rowWiseMode = "row-wise";
}
else {
rowWiseMode = "column-wise";
}
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
->Message("set", "ntuple merging row mode", rowWiseMode);
#endif
// Do nothing if the mode is not changed
if ( fNtupleRowWise == rowWise && fNtupleRowMode == rowMode ) return;
fNtupleRowWise = rowWise;
fNtupleRowMode = rowMode;
if ( fNtupleManager ) {
fNtupleManager->SetNtupleRowWise(rowWise, rowMode);
}
if ( fSlaveNtupleManager ) {
fSlaveNtupleManager->SetNtupleRowWise(rowWise, rowMode);
}
fNtupleFileManager->SetNtupleRowWise(rowWise, rowMode);
}
//_____________________________________________________________________________