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

Import Geant4 11.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2021-12-10 14:46:44 +01:00
committed by Ben Morgan
parent 6399a014b6
commit 80e2389dd8
3932 changed files with 202519 additions and 246221 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/analysis/root/src/G4RootNtupleFileManager.cc
+87 -169
View File
@@ -32,53 +32,24 @@
#include "G4RootMainNtupleManager.hh"
#include "G4RootPNtupleManager.hh"
#include "G4VAnalysisManager.hh"
#include "G4AnalysisVerbose.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
#include <iostream>
#include <cstdio>
namespace {
void MergingException(const G4String& functionName,
G4ExceptionDescription& description)
{
G4String inFunction = "G4RootNtupleFileManager::" + functionName;
G4Exception(inFunction, "Analysis_W013", JustWarning, description);
}
}
using namespace G4Analysis;
using std::make_shared;
using std::to_string;
G4RootNtupleFileManager* G4RootNtupleFileManager::fgMasterInstance = nullptr;
//_____________________________________________________________________________
G4RootNtupleFileManager::G4RootNtupleFileManager(const G4AnalysisManagerState& state)
: G4VNtupleFileManager(state, "root"),
fIsInitialized(false),
fNofNtupleFiles(0),
fNtupleRowWise(false),
fNtupleRowMode(true),
fNtupleMergeMode(G4NtupleMergeMode::kNone),
fNtupleManager(nullptr),
fSlaveNtupleManager(nullptr),
fFileManager(nullptr)
: G4VNtupleFileManager(state, "root")
{
if ( G4Threading::IsMasterThread() && fgMasterInstance ) {
G4ExceptionDescription description;
description
<< " "
<< "G4RootNtupleFileManager already exists."
<< "Cannot create another instance.";
G4Exception("G4RootNtupleFileManager::G4RootNtupleFileManager()",
"Analysis_F001", FatalException, description);
}
if ( G4Threading::IsMasterThread() ) fgMasterInstance = this;
// Do not merge ntuples by default
@@ -91,45 +62,37 @@ G4RootNtupleFileManager::G4RootNtupleFileManager(const G4AnalysisManagerState& s
//_____________________________________________________________________________
G4RootNtupleFileManager::~G4RootNtupleFileManager()
{
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
}
//
//
// private methods
//
//_____________________________________________________________________________
void G4RootNtupleFileManager::SetNtupleMergingMode(G4bool mergeNtuples,
void G4RootNtupleFileManager::SetNtupleMergingMode(G4bool mergeNtuples,
G4int nofNtupleFiles)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
fState.GetVerboseL4()->Message("set", "ntuple merging mode", "");
}
#endif
Message(kVL4, "set", "ntuple merging mode");
auto canMerge = true;
// Illegal situations
if ( mergeNtuples && ( ! G4Threading::IsMultithreadedApplication() ) ) {
G4ExceptionDescription description;
description
<< "Merging ntuples is not applicable in sequential application." << G4endl
<< "Setting was ignored.";
MergingException("SetNtupleMergingMode", description);
canMerge = false;
Warn("Merging ntuples is not applicable in sequential application.\n"
"Setting was ignored.",
fkClass, "SetNtupleMergingMode");
canMerge = false;
}
// Illegal situations
if ( mergeNtuples && G4Threading::IsMultithreadedApplication() &&
( ! fgMasterInstance ) ) {
G4ExceptionDescription description;
description
<< "Merging ntuples requires G4AnalysisManager instance on master." << G4endl
<< "Setting was ignored.";
MergingException("SetNtupleMergingMode", description);
canMerge = false;
Warn("Merging ntuples requires G4AnalysisManager instance on master.\n"
"Setting was ignored.",
fkClass, "SetNtupleMergingMode");
canMerge = false;
}
G4String mergingMode;
@@ -140,34 +103,28 @@ void G4RootNtupleFileManager::SetNtupleMergingMode(G4bool mergeNtuples,
else {
// Set the number of reduced ntuple files
fNofNtupleFiles = nofNtupleFiles;
// Check the number of reduced ntuple files
if ( fNofNtupleFiles < 0 ) {
G4ExceptionDescription description;
description
<< "Number of reduced files must be [0, nofThreads]." << G4endl
<< "Cannot set " << nofNtupleFiles << " files" << G4endl
<< "Ntuples will be merged in a single file.";
MergingException("SetNtupleMergingMode", description);
Warn("Number of reduced files must be [0, nofThreads].\n"
"Cannot set " + to_string(nofNtupleFiles) +" files.\n" +
"Setting was ignored.",
fkClass, "SetNtupleMergingMode");
fNofNtupleFiles = 0;
}
// Forced merging mode
G4bool isMaster = ! G4Threading::IsWorkerThread();
if ( isMaster ) {
fNtupleMergeMode = G4NtupleMergeMode::kMain;
mergingMode = "G4NtupleMergeMode::kMain";
} else {
fNtupleMergeMode = G4NtupleMergeMode::kSlave;
fNtupleMergeMode = G4NtupleMergeMode::kSlave;
mergingMode = "G4NtupleMergeMode::kSlave";
}
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()->Message("set", "ntuple merging mode", mergingMode);
}
#endif
Message(kVL2, "set", "ntuple merging mode", mergingMode);
}
//_____________________________________________________________________________
@@ -187,59 +144,53 @@ G4bool G4RootNtupleFileManager::CloseNtupleFiles()
{
// Close ntuple files
auto finalResult = true;
auto result = true;
auto ntupleVector = fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntupleDescription : ntupleVector) {
auto result = fFileManager->CloseNtupleFile(ntupleDescription);
finalResult = finalResult && result;
result &= fFileManager->CloseNtupleFile(ntupleDescription);
}
return finalResult;
return result;
}
//
//
// public methods
//
//_____________________________________________________________________________
void G4RootNtupleFileManager::SetNtupleMerging(G4bool mergeNtuples,
void G4RootNtupleFileManager::SetNtupleMerging(G4bool mergeNtuples,
G4int nofNtupleFiles)
{
if ( fIsInitialized ) {
G4ExceptionDescription description;
description
<< "Cannot change merging mode." << G4endl
<< "The function must be called before OpenFile().";
MergingException("SetNtupleMerging", description);
return;
Warn("Cannot change merging mode.\n"
"The function must be called before OpenFile().",
fkClass, "SetNtupleMerging");
return;
}
// Set ntuple merging mode
// Set ntuple merging mode
SetNtupleMergingMode(mergeNtuples, nofNtupleFiles);
}
//_____________________________________________________________________________
void G4RootNtupleFileManager::SetNtupleRowWise(G4bool rowWise, G4bool rowMode)
void G4RootNtupleFileManager::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";
rowWiseMode = "column-wise";
}
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
->Message("set", "ntuple merging row mode", rowWiseMode);
#endif
Message(kVL1, "set", "ntuple merging row mode", rowWiseMode);
// Do nothing if the mode is not changed
if ( fNtupleRowWise == rowWise && fNtupleRowMode == rowMode ) return;
@@ -257,7 +208,7 @@ void G4RootNtupleFileManager::SetNtupleRowWise(G4bool rowWise, G4bool rowMode)
}
//_____________________________________________________________________________
void G4RootNtupleFileManager::SetBasketSize(unsigned int basketSize)
void G4RootNtupleFileManager::SetBasketSize(unsigned int basketSize)
{
fFileManager->SetBasketSize(basketSize);
}
@@ -275,10 +226,7 @@ std::shared_ptr<G4VNtupleManager> G4RootNtupleFileManager::CreateNtupleManager()
// If ntuple merging is activated, managers of different types are created
// on master/worker.
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("create", "ntuple manager", "");
#endif
Message(kVL4, "create", "ntuple manager");
// Check that file manager and anaysis manager are set !
@@ -286,7 +234,7 @@ std::shared_ptr<G4VNtupleManager> G4RootNtupleFileManager::CreateNtupleManager()
switch ( fNtupleMergeMode )
{
case G4NtupleMergeMode::kNone:
fNtupleManager
fNtupleManager
= make_shared<G4RootNtupleManager>(
fState, fBookingManager, 0, 0, fNtupleRowWise, fNtupleRowMode);
fNtupleManager->SetFileManager(fFileManager);
@@ -297,7 +245,7 @@ std::shared_ptr<G4VNtupleManager> G4RootNtupleFileManager::CreateNtupleManager()
G4int nofMainManagers = fNofNtupleFiles;
if ( ! nofMainManagers ) nofMainManagers = 1;
// create one manager if merging required into the histos & profiles files
fNtupleManager
fNtupleManager
= make_shared<G4RootNtupleManager>(
fState, fBookingManager, nofMainManagers, fNofNtupleFiles, fNtupleRowWise, fNtupleRowMode);
fNtupleManager->SetFileManager(fFileManager);
@@ -308,32 +256,28 @@ std::shared_ptr<G4VNtupleManager> G4RootNtupleFileManager::CreateNtupleManager()
case G4NtupleMergeMode::kSlave:
fNtupleManager = fgMasterInstance->fNtupleManager;
// The master class is used only in Get* functions
auto mainNtupleManager
= fNtupleManager->GetMainNtupleManager(GetNtupleFileNumber());
fSlaveNtupleManager
auto mainNtupleManager
= fNtupleManager->GetMainNtupleManager(GetNtupleFileNumber());
fSlaveNtupleManager
= make_shared<G4RootPNtupleManager>(
fState, fBookingManager, mainNtupleManager, fNtupleRowWise, fNtupleRowMode);
activeNtupleManager = fSlaveNtupleManager;
break;
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL3() ) {
G4String mergeMode;
switch ( fNtupleMergeMode ) {
case G4NtupleMergeMode::kNone:
mergeMode = "";
break;
case G4NtupleMergeMode::kMain:
mergeMode = "main ";
break;
case G4NtupleMergeMode::kSlave:
mergeMode = "slave ";
break;
}
fState.GetVerboseL3()->Message("create", mergeMode + "ntuple manager", "");
G4String mergeMode;
switch ( fNtupleMergeMode ) {
case G4NtupleMergeMode::kNone:
mergeMode = "";
break;
case G4NtupleMergeMode::kMain:
mergeMode = "main ";
break;
case G4NtupleMergeMode::kSlave:
mergeMode = "slave ";
break;
}
#endif
Message(kVL3, "create", mergeMode + "ntuple manager");
fIsInitialized = true;
@@ -341,37 +285,24 @@ std::shared_ptr<G4VNtupleManager> G4RootNtupleFileManager::CreateNtupleManager()
}
//_____________________________________________________________________________
#ifdef G4VERBOSE
G4bool G4RootNtupleFileManager::ActionAtOpenFile(const G4String& fileName)
#else
G4bool G4RootNtupleFileManager::ActionAtOpenFile(const G4String& /*fileName*/)
#endif
G4bool G4RootNtupleFileManager::ActionAtOpenFile([[maybe_unused]] const G4String& fileName)
{
// Check if fNtupleBookingManager is set
auto finalResult = true;
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ||
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ||
fNtupleMergeMode == G4NtupleMergeMode::kMain ) {
#ifdef G4VERBOSE
G4String objectType = "analysis file";
if ( fNtupleMergeMode == G4NtupleMergeMode::kMain ) {
objectType = "main analysis file";
}
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("open", objectType, fileName);
#endif
Message(kVL4, "open", objectType, fileName);
// Creating files is triggered from CreateNtuple
fNtupleManager->CreateNtuplesFromBooking(
fBookingManager->GetNtupleBookingVector());
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() ) {
fState.GetVerboseL1()->Message("open", objectType, fileName, finalResult);
}
#endif
Message(kVL1, "open", objectType, fileName);
}
// Creating ntuples from main is triggered from the first Fill call
@@ -380,69 +311,56 @@ G4bool G4RootNtupleFileManager::ActionAtOpenFile(const G4String& /*fileName*/)
// fSlaveNtupleManager->CreateNtuplesFromMain();
// }
return finalResult;
}
return true;
}
//_____________________________________________________________________________
G4bool G4RootNtupleFileManager::ActionAtWrite()
{
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ) {
return true;
}
auto finalResult = true;
auto result = 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
Message(kVL4, "merge", ntupleType);
if ( fNtupleMergeMode == G4NtupleMergeMode::kMain ) {
auto result = fNtupleManager->Merge();
finalResult = result && finalResult;
}
if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave ) {
auto result = fSlaveNtupleManager->Merge();
finalResult = result && finalResult;
result &= fNtupleManager->Merge();
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()->Message("merge", ntupleType, "");
#endif
return finalResult;
if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave ) {
result &= fSlaveNtupleManager->Merge();
}
Message(kVL1, "merge", ntupleType, "", result);
return result;
}
//_____________________________________________________________________________
G4bool G4RootNtupleFileManager::ActionAtCloseFile(G4bool reset)
{
auto finalResult = true;
auto result = true;
// close files
if ( fNtupleMergeMode != G4NtupleMergeMode::kSlave ) {
auto result = CloseNtupleFiles();
finalResult = finalResult && result;
result &= CloseNtupleFiles();
}
if ( ! reset ) {
// The ntuples must be always reset when closing file)
auto result = Reset();
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4RootNtupleFileManager::CloseFile()",
"Analysis_W021", JustWarning, description);
// The ntuples must be always reset when closing file)
if ( ! Reset() ) {
Warn("Resetting data failed", fkClass, "ActionAtCloseFile");
result = false;
}
finalResult = finalResult && result;
}
return finalResult;
return result;
}
//_____________________________________________________________________________
@@ -451,11 +369,11 @@ G4bool G4RootNtupleFileManager::Reset()
// Reset ntuples
auto result = true;
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ||
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ||
fNtupleMergeMode == G4NtupleMergeMode::kMain ) {
result = fNtupleManager->Reset(false);
}
result &= fNtupleManager->Reset();
}
return result;
}