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/hdf5/src/G4Hdf5AnalysisManager.cc
+57 -238
View File
@@ -31,6 +31,7 @@
#include "G4Hdf5NtupleFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4ThreadLocalSingleton.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
@@ -41,72 +42,44 @@ using namespace G4Analysis;
namespace {
//Mutex to lock master manager when opening a file
G4Mutex openFileMutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging H1 histograms
G4Mutex mergeH1Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging H1 histograms
G4Mutex mergeH2Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging H1 histograms
G4Mutex mergeH3Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging P1 profiles
G4Mutex mergeP1Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging P2 profiles
G4Mutex mergeP2Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when closing a file
G4Mutex closeFileMutex = G4MUTEX_INITIALIZER;
}
}
G4Hdf5AnalysisManager* G4Hdf5AnalysisManager::fgMasterInstance = nullptr;
G4ThreadLocal G4Hdf5AnalysisManager* G4Hdf5AnalysisManager::fgInstance = nullptr;
// G4Hdf5AnalysisManager* G4Hdf5AnalysisManager::fgMasterInstance = nullptr;
// G4ThreadLocal G4bool G4Hdf5AnalysisManager::fgIsInstance = false;
//_____________________________________________________________________________
G4Hdf5AnalysisManager* G4Hdf5AnalysisManager::Instance()
{
if ( fgInstance == nullptr ) {
G4bool isMaster = ! G4Threading::IsWorkerThread();
fgInstance = new G4Hdf5AnalysisManager(isMaster);
}
return fgInstance;
static G4ThreadLocalSingleton<G4Hdf5AnalysisManager> instance;
fgIsInstance = true;
return instance.Instance();
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::IsInstance()
{
return ( fgInstance != 0 );
}
return fgIsInstance;
}
//_____________________________________________________________________________
G4Hdf5AnalysisManager::G4Hdf5AnalysisManager(G4bool isMaster)
: G4ToolsAnalysisManager("Hdf5", isMaster),
fNtupleFileManager(nullptr),
fFileManager(nullptr)
G4Hdf5AnalysisManager::G4Hdf5AnalysisManager()
: G4ToolsAnalysisManager("Hdf5")
{
#ifdef G4MULTITHREADED
#ifndef H5_HAVE_THREADSAFE
G4ExceptionDescription message;
message
<< "Your HDF5 lib is not built with H5_HAVE_THREADSAFE.";
G4Exception("G4Hdf5AnalysisManager::G4Hdf5AnalysisManager",
"Analysis_F002", FatalException, message);
"Analysis_F001", FatalException,
"Your HDF5 lib is not built with H5_HAVE_THREADSAFE.");
#endif
#endif
if ( ( isMaster && fgMasterInstance ) || ( fgInstance ) ) {
G4ExceptionDescription description;
description
<< " "
<< "G4Hdf5AnalysisManager already exists."
<< "Cannot create another instance.";
G4Exception("G4Hdf5AnalysisManager::G4Hdf5AnalysisManager",
"Analysis_F001", FatalException, description);
}
if ( isMaster ) fgMasterInstance = this;
fgInstance = this;
if ( ! G4Threading::IsWorkerThread() ) fgMasterInstance = this;
// File manager
fFileManager = std::make_shared<G4Hdf5FileManager>(fState);
SetFileManager(fFileManager);
fFileManager->SetBasketSize(fgkDefaultBasketSize);
// Ntuple file manager
fNtupleFileManager = std::make_shared<G4Hdf5NtupleFileManager>(fState);
@@ -116,152 +89,12 @@ G4Hdf5AnalysisManager::G4Hdf5AnalysisManager(G4bool isMaster)
//_____________________________________________________________________________
G4Hdf5AnalysisManager::~G4Hdf5AnalysisManager()
{
{
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
fgInstance = nullptr;
fgIsInstance = false;
}
//
// private methods
//
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteH1()
{
auto h1Vector = fH1Manager->GetH1Vector();
auto hnVector = fH1Manager->GetHnVector();
if ( ! h1Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
result = WriteHn(h1Vector, hnVector, "h1");
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lH1(&mergeH1Mutex);
fgMasterInstance->fH1Manager->AddH1Vector(h1Vector);
lH1.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteH2()
{
auto h2Vector = fH2Manager->GetH2Vector();
auto hnVector = fH2Manager->GetHnVector();
if ( ! h2Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
result = WriteHn(h2Vector, hnVector, "h2");
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lH2(&mergeH2Mutex);
fgMasterInstance->fH2Manager->AddH2Vector(h2Vector);
lH2.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteH3()
{
auto h3Vector = fH3Manager->GetH3Vector();
auto hnVector = fH3Manager->GetHnVector();
if ( ! h3Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
result = WriteHn(h3Vector, hnVector, "h3");
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lH3(&mergeH3Mutex);
fgMasterInstance->fH3Manager->AddH3Vector(h3Vector);
lH3.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteP1()
{
auto p1Vector = fP1Manager->GetP1Vector();
auto hnVector = fP1Manager->GetHnVector();
if ( ! p1Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
result = WritePn(p1Vector, hnVector, "p1");
}
else {
// The worker manager just adds its profiles to the master
// This operation needs a lock
G4AutoLock lP1(&mergeP1Mutex);
fgMasterInstance->fP1Manager->AddP1Vector(p1Vector);
lP1.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteP2()
{
auto p2Vector = fP2Manager->GetP2Vector();
auto hnVector = fP2Manager->GetHnVector();
if ( ! p2Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
result = WritePn(p2Vector, hnVector, "p2");
}
else {
// The worker manager just adds its profiles to the master
// This operation needs a lock
G4AutoLock lP2(&mergeP2Mutex);
fgMasterInstance->fP2Manager->AddP2Vector(p2Vector);
lP2.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::Reset()
{
// Reset histograms and ntuple
auto finalResult = true;
auto result = G4ToolsAnalysisManager::Reset();
finalResult = finalResult && result;
result = fNtupleFileManager->Reset();
finalResult = finalResult && result;
return finalResult;
}
//
// protected methods
//
@@ -272,89 +105,75 @@ G4bool G4Hdf5AnalysisManager::OpenFileImpl(const G4String& fileName)
// and set it to base class which takes then their ownership
SetNtupleManager(fNtupleFileManager->CreateNtupleManager());
auto finalResult = true;
auto result = true;
G4AutoLock lock(&openFileMutex);
auto result = fFileManager->OpenFile(fileName);
finalResult = finalResult && result;
result = fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
finalResult = finalResult && result;
result &= fFileManager->OpenFile(fileName);
result &= fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
lock.unlock();
return finalResult;
}
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteImpl()
G4bool G4Hdf5AnalysisManager::WriteImpl()
{
auto finalResult = true;
auto result = true;
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
fState.GetVerboseL4()->Message("write", "files", "");
Message(kVL4, "write", "files");
if ( G4Threading::IsWorkerThread() ) {
result &= G4ToolsAnalysisManager::Merge();
}
#endif
else {
// Open all files registered with objects
fFileManager->OpenFiles();
auto result = WriteH1();
finalResult = finalResult && result;
// Write all histograms/profile on master
result &= G4ToolsAnalysisManager::WriteImpl();
}
// H2
result = WriteH2();
finalResult = finalResult && result;
// H3
result = WriteH3();
finalResult = finalResult && result;
// P1
result = WriteP1();
finalResult = finalResult && result;
// P2
result = WriteP2();
finalResult = finalResult && result;
// Write ASCII if activated
if ( IsAscii() ) {
result = WriteAscii(fFileManager->GetFileName());
finalResult = finalResult && result;
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()->Message("write", "files", "", finalResult);
result &= WriteAscii(fFileManager->GetFileName());
}
#endif
return finalResult;
Message(kVL3, "write", "files", "", result);
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::CloseFileImpl(G4bool reset)
{
auto finalResult = true;
auto result = true;
G4AutoLock lock(&closeFileMutex);
auto result = fFileManager->CloseFiles();
finalResult = finalResult && result;
result &= fFileManager->CloseFiles();
if ( reset ) {
// reset data
result = Reset();
result = ResetImpl();
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4Hdf5AnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
Warn("Resetting data failed", fkClass, "OpenDirectory");
}
}
finalResult = finalResult && result;
result = fNtupleFileManager->ActionAtCloseFile(reset);
finalResult = finalResult && result;
result &= fNtupleFileManager->ActionAtCloseFile(reset);
lock.unlock();
return finalResult;
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::ResetImpl()
{
auto result = true;
result &= G4ToolsAnalysisManager::ResetImpl();
if ( fNtupleFileManager != nullptr ) {
result &= fNtupleFileManager->Reset();
}
return result;
}
source/analysis/hdf5/src/G4Hdf5AnalysisReader.cc
+31 -200
View File
@@ -27,52 +27,31 @@
// Author: Ivana Hrivnacova, 20/07/2017 (ivana@ipno.in2p3.fr)
#include "G4Hdf5AnalysisReader.hh"
#include "G4Hdf5RFileManager.hh"
#include "G4Hdf5RNtupleManager.hh"
#include "G4AnalysisVerbose.hh"
#include "G4AnalysisUtilities.hh"
#include "G4ThreadLocalSingleton.hh"
#include "G4Threading.hh"
#include <iostream>
#include <cstdio>
using namespace G4Analysis;
G4Hdf5AnalysisReader* G4Hdf5AnalysisReader::fgMasterInstance = nullptr;
G4ThreadLocal G4Hdf5AnalysisReader* G4Hdf5AnalysisReader::fgInstance = nullptr;
//_____________________________________________________________________________
G4Hdf5AnalysisReader* G4Hdf5AnalysisReader::Instance()
{
if ( fgInstance == nullptr ) {
G4bool isMaster = ! G4Threading::IsWorkerThread();
fgInstance = new G4Hdf5AnalysisReader(isMaster);
}
return fgInstance;
}
static G4ThreadLocalSingleton<G4Hdf5AnalysisReader> instance;
return instance.Instance();
}
//_____________________________________________________________________________
G4Hdf5AnalysisReader::G4Hdf5AnalysisReader(G4bool isMaster)
: G4ToolsAnalysisReader("Hdf5", isMaster),
fNtupleManager(nullptr),
fFileManager(nullptr)
G4Hdf5AnalysisReader::G4Hdf5AnalysisReader()
: G4ToolsAnalysisReader("Hdf5")
{
if ( ( isMaster && fgMasterInstance ) || ( fgInstance ) ) {
G4ExceptionDescription description;
description
<< " "
<< "G4Hdf5AnalysisReader already exists."
<< "Cannot create another instance.";
G4Exception("G4Hdf5AnalysisReader::G4Hdf5AnalysisReader()",
"Analysis_F001", FatalException, description);
}
if ( isMaster ) fgMasterInstance = this;
fgInstance = this;
if ( ! G4Threading::IsWorkerThread() ) fgMasterInstance = this;
// Create managers
fNtupleManager = new G4Hdf5RNtupleManager(fState);
fFileManager = new G4Hdf5RFileManager(fState);
fNtupleManager = std::make_shared<G4Hdf5RNtupleManager>(fState);
fFileManager = std::make_shared<G4Hdf5RFileManager>(fState);
fNtupleManager->SetFileManager(fFileManager);
// Set managers to base class
SetNtupleManager(fNtupleManager);
SetFileManager(fFileManager);
@@ -82,10 +61,9 @@ G4Hdf5AnalysisReader::G4Hdf5AnalysisReader(G4bool isMaster)
G4Hdf5AnalysisReader::~G4Hdf5AnalysisReader()
{
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
fgInstance = nullptr;
}
//
//
// private methods
//
@@ -94,179 +72,32 @@ G4bool G4Hdf5AnalysisReader::Reset()
{
// Reset histograms and ntuple
auto finalResult = true;
auto result = G4ToolsAnalysisReader::Reset();
finalResult = finalResult && result;
auto result = true;
result = fNtupleManager->Reset();
finalResult = finalResult && result;
return finalResult;
}
//
result &= G4ToolsAnalysisReader::Reset();
result &= fNtupleManager->Reset();
return result;
}
//
// protected methods
//
//_____________________________________________________________________________
G4int G4Hdf5AnalysisReader::ReadH1Impl(const G4String& h1Name,
const G4String& fileName,
const G4String& dirName,
G4bool /*isUserFileName*/)
G4bool G4Hdf5AnalysisReader::CloseFilesImpl(G4bool reset)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "h1", h1Name);
#endif
Message(kVL4, "close", "files");
auto h1 = ReadHnImpl<tools::histo::h1d>(h1Name, fileName, dirName);
if ( ! h1 ) return kInvalidId;
auto id = fH1Manager->AddH1(h1Name, h1);
auto result = true;
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "h1", h1Name, id > kInvalidId);
#endif
return id;
}
if (reset) {
result &= Reset();
}
//_____________________________________________________________________________
G4int G4Hdf5AnalysisReader::ReadH2Impl(const G4String& h2Name,
const G4String& fileName,
const G4String& dirName,
G4bool /*isUserFileName*/)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "h2", h2Name);
#endif
fFileManager->CloseFiles();
auto h2 = ReadHnImpl<tools::histo::h2d>(h2Name, fileName, dirName);
if ( ! h2 ) return kInvalidId;
auto id = fH2Manager->AddH2(h2Name, h2);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "h2", h2Name, id > kInvalidId);
#endif
return id;
}
Message(kVL2, "close", "files", "", result);
//_____________________________________________________________________________
G4int G4Hdf5AnalysisReader::ReadH3Impl(const G4String& h3Name,
const G4String& fileName,
const G4String& dirName,
G4bool /*isUserFileName*/)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "h3", h3Name);
#endif
auto h3 = ReadHnImpl<tools::histo::h3d>(h3Name, fileName, dirName);
if ( ! h3 ) return kInvalidId;
auto id = fH3Manager->AddH3(h3Name, h3);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "h3", h3Name, id > kInvalidId);
#endif
return id;
}
//_____________________________________________________________________________
G4int G4Hdf5AnalysisReader::ReadP1Impl(const G4String& p1Name,
const G4String& fileName,
const G4String& dirName,
G4bool /*isUserFileName*/)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "p1", p1Name);
#endif
auto p1 = ReadPnImpl<tools::histo::p1d>(p1Name, fileName, dirName);
if ( ! p1 ) return kInvalidId;
auto id = fP1Manager->AddP1(p1Name, p1);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "p1", p1Name, id > kInvalidId);
#endif
return id;
}
//_____________________________________________________________________________
G4int G4Hdf5AnalysisReader::ReadP2Impl(const G4String& p2Name,
const G4String& fileName,
const G4String& dirName,
G4bool /*isUserFileName*/)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "p2", p2Name);
#endif
auto p2 = ReadPnImpl<tools::histo::p2d>(p2Name, fileName, dirName);
if ( ! p2 ) return kInvalidId;
auto id = fP2Manager->AddP2(p2Name, p2);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "p2", p2Name, id > kInvalidId);
#endif
return id;
}
//_____________________________________________________________________________
G4int G4Hdf5AnalysisReader::ReadNtupleImpl(const G4String& ntupleName,
const G4String& fileName,
const G4String& dirName,
G4bool isUserFileName)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "ntuple", ntupleName);
#endif
// Ntuples are saved in files per thread
// but apply thethe thread suffix only if fileName is not provided explicitly
G4String fullFileName = fileName;
if ( ! isUserFileName ) {
fullFileName = fFileManager->GetFullFileName();
}
// Get directory
auto directory = fFileManager->GetNtupleRDirectory(fullFileName, dirName, false);
if ( directory < 0 ) return kInvalidId;
// Create ntuple
auto rntuple = new tools::hdf5::ntuple(G4cout, directory, ntupleName);
auto rntupleDescription = new G4TRNtupleDescription<tools::hdf5::ntuple>(rntuple);
auto id = fNtupleManager->SetNtuple(rntupleDescription);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "ntuple", ntupleName, id > kInvalidId);
#endif
return id;
}
return result;
}
source/analysis/hdf5/src/G4Hdf5FileManager.cc
+23 -58
View File
@@ -42,29 +42,21 @@ using namespace tools;
namespace {
//Mutex to lock master manager when closing a file
G4Mutex closeFileMutex = G4MUTEX_INITIALIZER;
}
//_____________________________________________________________________________
const G4String G4Hdf5FileManager::fgkDefaultDirectoryName = "default";
}
//_____________________________________________________________________________
G4Hdf5FileManager::G4Hdf5FileManager(const G4AnalysisManagerState& state)
: G4VTFileManager<G4Hdf5File>(state),
fBasketSize(0) // TO DO: check default value !! (433 in test)
: G4VTFileManager<G4Hdf5File>(state)
{
// Create helpers defined in the base class
fH1FileManager = std::make_shared<G4Hdf5HnFileManager<histo::h1d>>(this);
fH2FileManager = std::make_shared<G4Hdf5HnFileManager<histo::h2d>>(this);
fH3FileManager = std::make_shared<G4Hdf5HnFileManager<histo::h3d>>(this);
fP1FileManager = std::make_shared<G4Hdf5HnFileManager<histo::p1d>>(this);
fP2FileManager = std::make_shared<G4Hdf5HnFileManager<histo::p2d>>(this);
fP2FileManager = std::make_shared<G4Hdf5HnFileManager<histo::p2d>>(this);
}
//_____________________________________________________________________________
G4Hdf5FileManager::~G4Hdf5FileManager()
{}
//
//
// private methods
//
@@ -85,12 +77,7 @@ hid_t G4Hdf5FileManager::CreateDirectory(hid_t& file,
newDirectoryName += objectType;
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
fState.GetVerboseL4()
->Message("create", "directory for " + objectType, newDirectoryName);
}
#endif
Message(kVL4, "create", "directory for " + objectType, newDirectoryName);
auto success = true;
@@ -100,39 +87,29 @@ hid_t G4Hdf5FileManager::CreateDirectory(hid_t& file,
// be the default value but 0 is what is found in examples, and in the code, if we pass 0, clearly some
// default value is taken.
if ( directory < 0 ) {
G4ExceptionDescription description;
description << " "
<< "cannot create directory " << directoryName;
G4Exception("G4Hdf5FileManager::CreateDirectory()",
"Analysis_W001", JustWarning, description);
Warn("Cannot create directory " + directoryName,
fkClass, "CreateDirectory");
success = false;
}
else {
// write atb (header?)
auto result = hdf5::write_atb(directory, "type", "directory");
if ( !result) {
G4ExceptionDescription description;
description << " "
<< "write_atb class failed for " << directoryName;
G4Exception("G4Hdf5FileManager::CreateDirectory()",
"Analysis_W001", JustWarning, description);
Warn("Write_atb class failed for " + directoryName,
fkClass, "CreateDirectory");
success = false;
}
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()
->Message("create", "directory for " + objectType, newDirectoryName, success);
}
#endif
Message(kVL2, "create", "directory for " + objectType, newDirectoryName, success);
return directory;
}
//_____________________________________________________________________________
G4String G4Hdf5FileManager::GetNtupleFileName(Hdf5NtupleDescription* ntupleDescription)
{
// get ntuple file name
// get ntuple file name
auto ntupleFileName = ntupleDescription->fFileName;
if ( ntupleFileName.size() ) {
// update filename per object per thread
@@ -142,9 +119,9 @@ G4String G4Hdf5FileManager::GetNtupleFileName(Hdf5NtupleDescription* ntupleDescr
ntupleFileName = GetFullFileName();
}
return ntupleFileName;
}
}
//
//
// protected methods
//
@@ -157,19 +134,14 @@ std::shared_ptr<G4Hdf5File> G4Hdf5FileManager::CreateFileImpl(const G4String& fi
// Do nothing if there is no file
// (the error should be handled by caller)
if ( file < 0 ) {
G4ExceptionDescription description;
description << " " << "::H5Fcreate failed " << fileName;
G4Exception("G4Hdf5AnalysisManager::CreateFileImpl()",
"Analysis_W001", JustWarning, description);
Warn("::H5Fcreate failed " + fileName, fkClass, "CreateFileImpl");
return std::make_shared<G4Hdf5File>(-1, -1, -1);
}
// create a header with general infos
if(!tools::hdf5::write_header(file)) {
G4ExceptionDescription description;
description << " " << "tools::hdf5::write_header() failed for " << fileName;
G4Exception("G4Hdf5AnalysisManager::CreateFileImpl()",
"Analysis_W001", JustWarning, description);
Warn("tools::hdf5::write_header() failed for " + fileName,
fkClass, "CreateFileImpl");
return std::make_shared<G4Hdf5File>(-1, -1, -1);
}
@@ -177,7 +149,7 @@ std::shared_ptr<G4Hdf5File> G4Hdf5FileManager::CreateFileImpl(const G4String& fi
auto hdirectory
= CreateDirectory(file, fHistoDirectoryName, "histograms");
if ( hdirectory < 0 ) {
// Warnin is issued in CreateDirectory
// Warning is issued in CreateDirectory
return std::make_shared<G4Hdf5File>(-1, -1, -1);
}
@@ -227,30 +199,23 @@ G4bool G4Hdf5FileManager::OpenFile(const G4String& fileName)
auto name = GetFullFileName();
if ( fFile ) {
G4ExceptionDescription description;
description
<< "File " << fileName << " already exists.";
G4Exception("G4Hdf5FileManager::OpenFile()",
"Analysis_W001", JustWarning, description);
Warn("File " + fileName + " already exists.", fkClass, "OpenFile");
fFile.reset();
}
// create new file
fFile = CreateTFile(name);
if ( ! fFile ) {
G4ExceptionDescription description;
description << "Failed to create file " << fileName;
G4Exception("G4Hdf5FileManager::OpenFile()",
"Analysis_W001", JustWarning, description);
Warn("Failed to create file " + fileName, fkClass, "OpenFile");
return false;
}
fLockDirectoryNames = true;
LockDirectoryNames();
fIsOpenFile = true;
return true;
}
//_____________________________________________________________________________
G4bool G4Hdf5FileManager::CreateNtupleFile(
Hdf5NtupleDescription* ntupleDescription)
@@ -272,7 +237,7 @@ G4bool G4Hdf5FileManager::CloseNtupleFile(
Hdf5NtupleDescription* ntupleDescription)
{
// Do nothing if there is no file
if ( ! ntupleDescription->fFile ) return true;
if ( ntupleDescription->fFile == nullptr ) return true;
// Ntuple files will be closed with CloseFiles() calls
ntupleDescription->fFile.reset();
source/analysis/hdf5/src/G4Hdf5NtupleFileManager.cc
+15 -45
View File
@@ -32,28 +32,18 @@
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4Threading.hh"
#include <iostream>
using namespace G4Analysis;
//
//
// utility methods
//
//_____________________________________________________________________________
G4Hdf5NtupleFileManager::G4Hdf5NtupleFileManager(const G4AnalysisManagerState& state)
: G4VNtupleFileManager(state, "hdf5"),
fFileManager(nullptr),
fNtupleManager(nullptr)
: G4VNtupleFileManager(state, "hdf5")
{}
//_____________________________________________________________________________
G4Hdf5NtupleFileManager::~G4Hdf5NtupleFileManager()
{}
//
//
// private methods
//
@@ -62,14 +52,13 @@ G4bool G4Hdf5NtupleFileManager::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;
}
//
@@ -90,7 +79,7 @@ std::shared_ptr<G4VNtupleManager> G4Hdf5NtupleFileManager::CreateNtupleManager()
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::ActionAtOpenFile(const G4String& /*fileName*/)
{
// Create ntuples if they are booked
// Create ntuples if they are booked
// (The files will be created with creating ntuples)
fNtupleManager->CreateNtuplesFromBooking(
fBookingManager->GetNtupleBookingVector());
@@ -101,50 +90,31 @@ G4bool G4Hdf5NtupleFileManager::ActionAtOpenFile(const G4String& /*fileName*/)
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::ActionAtWrite()
{
// notify that ntuple file is not empty
auto finalResult = true;
// Notify that ntuple files are not empty
auto ntupleVector
= fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntupleDescription : ntupleVector) {
if (ntupleDescription->fFile) {
auto result = fFileManager->SetIsEmpty(ntupleDescription->fFileName, false);
finalResult = finalResult && result;
}
}
return finalResult;
// Nothing to be done
return true;
}
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::ActionAtCloseFile(G4bool reset)
{
auto finalResult = true;
auto result = true;
// Close ntuple files
auto result = CloseNtupleFiles();
finalResult = finalResult && result;
result &= CloseNtupleFiles();
if ( ! reset ) {
// The ntuples must be always reset when closing file)
// The ntuples must be always reset when closing file)
result = Reset();
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4Hdf5NtupleFileManager::CloseFile()",
"Analysis_W021", JustWarning, description);
Warn("Resetting data failed", fkClass, "ActionAtCloseFile");
}
finalResult = finalResult && result;
}
return finalResult;
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::Reset()
{
return fNtupleManager->Reset(true);
return fNtupleManager->Reset();
}
source/analysis/hdf5/src/G4Hdf5NtupleManager.cc
+5 -16
View File
@@ -34,22 +34,14 @@
#include "tools/ntuple_booking"
#include <iostream>
//#include <cstdio>
using namespace G4Analysis;
//_____________________________________________________________________________
G4Hdf5NtupleManager::G4Hdf5NtupleManager(const G4AnalysisManagerState& state)
: G4TNtupleManager<tools::hdf5::ntuple, G4Hdf5File>(state),
fFileManager(nullptr)
: G4TNtupleManager<tools::hdf5::ntuple, G4Hdf5File>(state)
{}
//_____________________________________________________________________________
G4Hdf5NtupleManager::~G4Hdf5NtupleManager()
{}
//
//
// private methods
//
//_____________________________________________________________________________
@@ -68,11 +60,8 @@ void G4Hdf5NtupleManager::CreateTNtuple(
// Check file
if ( ! ntupleFile ) {
if (warn) {
G4String inFunction = "G4Hdf5NtupleManager::::CreateTNtuple";
G4ExceptionDescription description;
description << " "
<< "Cannot create ntuple. Ntuple file does not exist." << G4endl;
G4Exception(inFunction, "Analysis_W002", JustWarning, description);
Warn( "Cannot create ntuple. Ntuple file does not exist.",
fkClass, "CreateTNtuple");
}
return;
}
@@ -88,7 +77,7 @@ void G4Hdf5NtupleManager::CreateTNtuple(
G4cout, directory, ntupleDescription->fNtupleBooking,
compressionLevel, basketSize);
fNtupleVector.push_back(ntupleDescription->fNtuple);
fNtupleVector.push_back(ntupleDescription->fNtuple);
}
//_____________________________________________________________________________
source/analysis/hdf5/src/G4Hdf5RFileManager.cc
+80 -83
View File
@@ -27,33 +27,30 @@
// Author: Ivana Hrivnacova, 20/07/2017 (ivana@ipno.in2p3.fr)
#include "G4Hdf5RFileManager.hh"
#include "G4Hdf5HnRFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "tools/hdf5/h2file"
#include <tools/zlib>
#include <iostream>
#include <cstdio>
#include "tools/hdf5/group_exists"
#include "tools/zlib"
using namespace G4Analysis;
//_____________________________________________________________________________
const G4String G4Hdf5RFileManager::fgkDefaultDirectoryName = "default";
using namespace tools;
//_____________________________________________________________________________
G4Hdf5RFileManager::G4Hdf5RFileManager(const G4AnalysisManagerState& state)
: G4BaseFileManager(state),
fRFiles()
: G4VRFileManager(state)
{
// Create helpers defined in the base class
fH1RFileManager = std::make_shared<G4Hdf5HnRFileManager<histo::h1d>>(this);
fH2RFileManager = std::make_shared<G4Hdf5HnRFileManager<histo::h2d>>(this);
fH3RFileManager = std::make_shared<G4Hdf5HnRFileManager<histo::h3d>>(this);
fP1RFileManager = std::make_shared<G4Hdf5HnRFileManager<histo::p1d>>(this);
fP2RFileManager = std::make_shared<G4Hdf5HnRFileManager<histo::p2d>>(this);
}
//_____________________________________________________________________________
G4Hdf5RFileManager::~G4Hdf5RFileManager()
{
}
//
//
// private methods
//
@@ -64,93 +61,71 @@ hid_t G4Hdf5RFileManager::OpenRFile(const G4String& fileName,
// Get full file name
G4String name = GetFullFileName(fileName, isPerThread);
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("open", "read analysis file", name);
#endif
Message(kVL4, "open", "read analysis file", name);
// create new file
hid_t newFile = H5Fopen(name, H5F_ACC_RDONLY, H5P_DEFAULT);
if ( newFile < 0 ) {
G4ExceptionDescription description;
description << " " << "Cannot open file " << name;
G4Exception("G4Hdf5RFileManager::OpenFile()",
"Analysis_WR001", JustWarning, description);
return false;
Warn("Cannot open file " + name, fkClass, "OpenRFile");
return kInvalidId;
}
// newFile->add_unziper('Z',tools::decompress_buffer);
// add file in a map
std::map<G4String, hid_t>::iterator it
= fRFiles.find(name);
if ( it != fRFiles.end() ) {
it->second = newFile;
}
else {
fRFiles[name] = newFile;
}
fRFiles[name] = G4Hdf5File(newFile, kInvalidId, kInvalidId);
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
->Message("open", "read analysis file", name);
#endif
Message(kVL1, "open", "read analysis file", name);
return newFile;
}
return true;
}
//_____________________________________________________________________________
hid_t G4Hdf5RFileManager::OpenDirectory(hid_t file, const G4String& directoryName)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
fState.GetVerboseL4()->Message("open", "read directory", directoryName);
}
#endif
Message(kVL4, "open", "read directory", directoryName);
auto directory = tools_H5Gopen(file, directoryName);
if ( directory < 0 ) {
G4ExceptionDescription description;
description << " "
<< "cannot open directory " << directoryName;
G4Exception("G4Hdf5RFileManager::OpenDirectory()",
"Analysis_W001", JustWarning, description);
return kInvalidId;
}
Warn("Cannot open directory " + directoryName, fkClass, "OpenDirectory");
return kInvalidId;
}
else {
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()->Message("open", "read directory", directoryName);
}
#endif
Message(kVL2, "open", "read directory", directoryName);
return directory;
}
}
}
//_____________________________________________________________________________
hid_t G4Hdf5RFileManager::GetRDirectory(const G4String& directoryType,
const G4String& fileName,
const G4String& dirName,
G4bool isPerThread)
const G4String& fileName,
const G4String& dirName,
G4bool isPerThread)
{
// Get or open a file
auto rfile = GetRFile(fileName, isPerThread);
if ( rfile < 0 ) {
// Try to open it if not found in the map
if ( ! OpenRFile(fileName, isPerThread) ) return kInvalidId;
if ( ! rfile ) {
// Try to open it if not found in the map
if ( OpenRFile(fileName, isPerThread) < 0 ) return kInvalidId;
rfile = GetRFile(fileName, isPerThread);
}
auto isHistograms = (directoryType == "histograms");
// Get directory if already open
hid_t directory = kInvalidId;
if ( isHistograms ) {
directory = std::get<1>(*rfile);
} else {
directory = std::get<2>(*rfile);
}
if ( directory != kInvalidId ) {
return directory;
}
// Use default directory name if not specified
auto newDirName = dirName;
if ( newDirName == "" ) {
// if ( fDefaultDirectory > 0 ) {
// // Return the default directory if the name is not set and the default directory
// // already exists
// directory = fDefaultDirectory;
// return true;
// } else {
// Create the default directory if the name is not set and the default directory
// does not yet exist
newDirName = fgkDefaultDirectoryName;
@@ -159,28 +134,35 @@ hid_t G4Hdf5RFileManager::GetRDirectory(const G4String& directoryType,
}
// Open directory
return OpenDirectory(rfile, newDirName);
}
directory = OpenDirectory(std::get<0>(*rfile), newDirName);
// Update
if ( isHistograms ) {
std::get<1>(*rfile) = directory;
} else {
std::get<2>(*rfile) = directory;
}
return directory;
}
//
// public methods
//
//_____________________________________________________________________________
hid_t G4Hdf5RFileManager::GetRFile(const G4String& fileName,
G4bool isPerThread) const
{
G4Hdf5File* G4Hdf5RFileManager::GetRFile(const G4String& fileName,
G4bool isPerThread)
{
// Get full file name
G4String name = GetFullFileName(fileName, isPerThread);
std::map<G4String, hid_t>::const_iterator it
= fRFiles.find(name);
auto it = fRFiles.find(name);
if ( it != fRFiles.end() )
return it->second;
return &(it->second);
else {
return kInvalidId;
}
return nullptr;
}
}
//_____________________________________________________________________________
@@ -197,4 +179,19 @@ hid_t G4Hdf5RFileManager::GetNtupleRDirectory(const G4String& fileName, const G4
return GetRDirectory("ntuples", fileName, dirName, isPerThread);
}
//_____________________________________________________________________________
void G4Hdf5RFileManager::CloseFiles()
{
// Close all open directories and file
for ( auto [key, rfile] : fRFiles ) {
if (std::get<1>(rfile) != kInvalidId) {
::H5Gclose(std::get<1>(rfile));
}
if (std::get<2>(rfile) != kInvalidId) {
::H5Gclose(std::get<2>(rfile));
}
if (std::get<0>(rfile) != kInvalidId) {
::H5Fclose(std::get<0>(rfile));
}
}
}
source/analysis/hdf5/src/G4Hdf5RNtupleManager.cc
+36 -18
View File
@@ -27,20 +27,48 @@
// Author: Ivana Hrivnacova, 20/07/2017 (ivana@ipno.in2p3.fr)
#include "G4Hdf5RNtupleManager.hh"
#include "G4Hdf5RFileManager.hh"
using namespace G4Analysis;
//_____________________________________________________________________________
G4Hdf5RNtupleManager::G4Hdf5RNtupleManager(const G4AnalysisManagerState& state)
: G4TRNtupleManager<tools::hdf5::ntuple>(state)
{}
//_____________________________________________________________________________
G4Hdf5RNtupleManager::~G4Hdf5RNtupleManager()
{}
//
//
// private methods
//
//_____________________________________________________________________________
G4int G4Hdf5RNtupleManager::ReadNtupleImpl(const G4String& ntupleName,
const G4String& fileName,
const G4String& dirName,
G4bool isUserFileName)
{
Message(kVL4, "read", "ntuple", ntupleName);
// Ntuples are saved in files per thread
// but apply thethe thread suffix only if fileName is not provided explicitly
G4String fullFileName = fileName;
if ( ! isUserFileName ) {
fullFileName = fFileManager->GetFullFileName();
}
// Get directory
auto directory = fFileManager->GetNtupleRDirectory(fullFileName, dirName, false);
if ( directory < 0 ) return kInvalidId;
// Create ntuple
auto rntuple = new tools::hdf5::ntuple(G4cout, directory, ntupleName);
auto rntupleDescription = new G4TRNtupleDescription<tools::hdf5::ntuple>(rntuple);
auto id = SetNtuple(rntupleDescription);
Message(kVL2, "read", "ntuple", ntupleName, id > kInvalidId);
return id;
}
//_____________________________________________________________________________
G4bool G4Hdf5RNtupleManager::GetTNtupleRow(
G4TRNtupleDescription<tools::hdf5::ntuple>* ntupleDescription)
@@ -51,26 +79,16 @@ G4bool G4Hdf5RNtupleManager::GetTNtupleRow(
if ( ! isInitialized ) {
auto ntupleBinding = ntupleDescription->fNtupleBinding;
if ( ! ntuple->initialize(G4cout, *ntupleBinding) ) {
G4ExceptionDescription description;
description
<< " "
<< "Ntuple initialization failed !!";
G4Exception("G4Hdf5RNtuple::GetNtupleRow()",
"Analysis_WR021", JustWarning, description);
Warn("Ntuple initialization failed !!", fkClass, "GetTNtupleRow");
return false;
}
ntupleDescription->fIsInitialized = true;
}
if ( ! ntuple->get_row() ) {
G4ExceptionDescription description;
description
<< " "
<< "Ntuple get_row() failed !!";
G4Exception("G4Hdf5RNtuple::GetNtupleRow()",
"Analysis_WR021", JustWarning, description);
Warn( "Ntuple get_row() failed !!", fkClass, "GetTNtupleRow");
return false;
}
return true;
}
}