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

Import Geant4 10.3.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-12-09 12:35:28 +01:00
parent 4ec577e5c4
commit a3452e42ac
3514 changed files with 210500 additions and 89628 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/analysis/root/src/G4RootAnalysisManager.cc
+321 -66
View File
@@ -23,15 +23,18 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4RootAnalysisManager.cc 93815 2015-11-02 11:32:20Z gcosmo $
// $Id: G4RootAnalysisManager.cc 100648 2016-10-31 10:06:45Z gcosmo $
// Author: Ivana Hrivnacova, 18/06/2013 (ivana@ipno.in2p3.fr)
#include "G4RootAnalysisManager.hh"
#include "G4RootFileManager.hh"
#include "G4RootNtupleManager.hh"
#include "G4RootMainNtupleManager.hh"
#include "G4RootPNtupleManager.hh"
#include "G4AnalysisVerbose.hh"
#include "G4AnalysisManagerState.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
@@ -76,7 +79,10 @@ G4bool G4RootAnalysisManager::IsInstance()
//_____________________________________________________________________________
G4RootAnalysisManager::G4RootAnalysisManager(G4bool isMaster)
: G4ToolsAnalysisManager("Root", isMaster),
fNofNtupleFiles(0),
fNtupleMergeMode(G4NtupleMergeMode::kNone),
fNtupleManager(nullptr),
fSlaveNtupleManager(nullptr),
fFileManager(nullptr)
{
if ( ( isMaster && fgMasterInstance ) || ( fgInstance ) ) {
@@ -91,16 +97,21 @@ G4RootAnalysisManager::G4RootAnalysisManager(G4bool isMaster)
if ( isMaster ) fgMasterInstance = this;
fgInstance = this;
// Create managers
fNtupleManager = new G4RootNtupleManager(fState);
// File manager
fFileManager = std::make_shared<G4RootFileManager>(fState);
// The managers will be deleted by the base class
// Set managers to base class which takes then their ownership
SetNtupleManager(fNtupleManager);
SetFileManager(fFileManager);
}
fFileManager->SetBasketSize(fgkDefaultBasketSize);
// 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();
}
//_____________________________________________________________________________
G4RootAnalysisManager::~G4RootAnalysisManager()
{
@@ -112,6 +123,189 @@ 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
// G4int nofThreads = G4Threading::GetNumberOfThreads();
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);
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);
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);
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()
{
@@ -237,6 +431,40 @@ 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::Reset()
{
@@ -247,12 +475,17 @@ G4bool G4RootAnalysisManager::Reset()
auto result = G4ToolsAnalysisManager::Reset();
finalResult = finalResult && result;
result = fNtupleManager->Reset(false);
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ||
fNtupleMergeMode == G4NtupleMergeMode::kMain ) {
result = fNtupleManager->Reset(false);
finalResult = result && finalResult;
}
finalResult = finalResult && result;
return finalResult;
}
}
//
// protected methods
//
@@ -264,23 +497,52 @@ G4bool G4RootAnalysisManager::OpenFileImpl(const G4String& fileName)
auto result = fFileManager->SetFileName(fileName);
finalResult = finalResult && result;
#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();
if ( fNtupleMergeMode == G4NtupleMergeMode::kNone ) {
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()->Message("open", "analysis file", name);
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);
#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);
#endif
}
if ( fNtupleMergeMode == G4NtupleMergeMode::kSlave ) {
// No file is open by Slave manager
fSlaveNtupleManager->CreateNtuplesFromMain();
}
return finalResult;
}
@@ -323,10 +585,16 @@ G4bool G4RootAnalysisManager::WriteImpl()
result = WriteP2();
finalResult = finalResult && result;
// File
result = fFileManager->WriteFile();
// Ntuples
result = WriteNtuple();
finalResult = finalResult && result;
// File
if ( fNtupleMergeMode != G4NtupleMergeMode::kSlave ) {
result = fFileManager->WriteFile();
finalResult = finalResult && result;
}
// Write ASCII if activated
if ( IsAscii() ) {
result = WriteAscii(fFileManager->GetFileName());
@@ -341,12 +609,6 @@ G4bool G4RootAnalysisManager::CloseFileImpl()
{
auto finalResult = true;
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()
->Message("close", "file", fFileManager->GetFullFileName());
#endif
// reset data
auto result = Reset();
if ( ! result ) {
@@ -357,40 +619,33 @@ G4bool G4RootAnalysisManager::CloseFileImpl()
}
finalResult = finalResult && result;
// close file
fFileManager->CloseFile();
// No files clean-up in sequential mode
if ( ! G4Threading::IsMultithreadedApplication() ) return finalResult;
// Delete files if empty in MT mode
if ( ( fState.GetIsMaster() &&
fH1Manager->IsEmpty() && fH2Manager->IsEmpty() && fH3Manager->IsEmpty() &&
fP1Manager->IsEmpty() && fP2Manager->IsEmpty() && fNtupleManager->IsEmpty() ) ||
( ( ! fState.GetIsMaster() ) && fNtupleManager->IsEmpty() ) ) {
result = ! std::remove(fFileManager->GetFullFileName());
// std::remove returns 0 when success
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Removing file "
<< fFileManager->GetFullFileName() << " failed";
G4Exception("G4XmlAnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
}
finalResult = finalResult && result;
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
->Message("delete", "empty file", fFileManager->GetFullFileName());
#endif
}
else {
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
->Message("close", "file", fFileManager->GetFullFileName());
#endif
if ( fNtupleMergeMode != G4NtupleMergeMode::kSlave ) {
// close file
fFileManager->CloseFile();
}
return finalResult;
}
}
//
// public methods
//
//_____________________________________________________________________________
void G4RootAnalysisManager::SetNtupleMerging(G4bool mergeNtuples,
G4int nofNtupleFiles,
unsigned int basketSize)
{
// Keep basketSize in file manager
fFileManager->SetBasketSize(basketSize);
// Set ntuple merging mode
SetNtupleMergingMode(mergeNtuples, nofNtupleFiles);
// Clear existing managers
ClearNtupleManagers();
// Re-create managers
CreateNtupleManagers();
}