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/hdf5/src/G4Hdf5FileManager.cc
+178 -143
View File
@@ -27,24 +27,38 @@
// Author: Ivana Hrivnacova, 20/07/2017 (ivana@ipno.in2p3.fr)
#include "G4Hdf5FileManager.hh"
#include "G4Hdf5HnFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4AutoLock.hh"
#include "tools/hdf5/h2file"
using namespace G4Analysis;
using namespace tools;
//using namespace G4Analysis;
namespace {
//Mutex to lock master manager when closing a file
G4Mutex closeFileMutex = G4MUTEX_INITIALIZER;
}
//_____________________________________________________________________________
const G4String G4Hdf5FileManager::fgkDefaultDirectoryName = "default";
//_____________________________________________________________________________
G4Hdf5FileManager::G4Hdf5FileManager(const G4AnalysisManagerState& state)
: G4VFileManager(state),
fFile(kInvalidId),
fHistoDirectory(kInvalidId),
fNtupleDirectory(kInvalidId),
: G4VTFileManager<G4Hdf5File>(state),
fBasketSize(0) // TO DO: check default value !! (433 in test)
{}
{
// 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);
}
//_____________________________________________________________________________
G4Hdf5FileManager::~G4Hdf5FileManager()
@@ -55,109 +69,153 @@ G4Hdf5FileManager::~G4Hdf5FileManager()
//
//_____________________________________________________________________________
G4bool G4Hdf5FileManager::CreateDirectory(const G4String& directoryType,
const G4String& directoryName, hid_t& directory)
hid_t G4Hdf5FileManager::CreateDirectory(hid_t& file,
const G4String& directoryName, const G4String& objectType)
{
// Method for both histograms and ntuples directories.
// For histos: CreateDirectory("histograms", fHistoDirectoryName, fHistoDirectory)
// For ntples: CreateDirectory("ntuples", fNtupleDirectoryName, fNtupleDirectory)
// return if no file provided
if ( file < 0 ) return false;
// use default directory name if not provided
auto newDirectoryName = directoryName;
if ( newDirectoryName == "" ) {
// 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
newDirectoryName = fgkDefaultDirectoryName;
newDirectoryName += "_";
newDirectoryName += directoryType;
newDirectoryName += objectType;
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
G4String message = "directory for ";
message += directoryType;
fState.GetVerboseL4()->Message("create", message, newDirectoryName);
fState.GetVerboseL4()
->Message("create", "directory for " + objectType, newDirectoryName);
}
#endif
directory = tools_H5Gcreate(fFile, newDirectoryName, 0);
auto success = true;
// create directory
auto directory = tools_H5Gcreate(file, newDirectoryName, 0);
// 0 seems to be an optional parameter. The web doc does not say what should
// 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 << " "
description << " "
<< "cannot create directory " << directoryName;
G4Exception("G4Hdf5FileManager::CreateDirectory()",
"Analysis_W001", JustWarning, description);
return false;
}
#ifdef G4VERBOSE
success = false;
}
else {
if ( fState.GetVerboseL2() ) {
G4String message = "directory for ";
message += directoryType;
fState.GetVerboseL2()->Message("create", message, newDirectoryName);
// 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);
success = false;
}
}
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()
->Message("create", "directory for " + objectType, newDirectoryName, success);
}
#endif
return directory;
}
//_____________________________________________________________________________
G4String G4Hdf5FileManager::GetNtupleFileName(Hdf5NtupleDescription* ntupleDescription)
{
// get ntuple file name
auto ntupleFileName = ntupleDescription->fFileName;
if ( ntupleFileName.size() ) {
// update filename per object per thread
ntupleFileName = GetTnFileName(ntupleFileName, GetFileType());
} else {
// get default file name
ntupleFileName = GetFullFileName();
}
return ntupleFileName;
}
//
// protected methods
//
//_____________________________________________________________________________
std::shared_ptr<G4Hdf5File> G4Hdf5FileManager::CreateFileImpl(const G4String& fileName)
{
// create a new file
hid_t file = ::H5Fcreate(fileName, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
// 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);
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);
return std::make_shared<G4Hdf5File>(-1, -1, -1);
}
// create histo directory
auto hdirectory
= CreateDirectory(file, fHistoDirectoryName, "histograms");
if ( hdirectory < 0 ) {
// Warnin is issued in CreateDirectory
return std::make_shared<G4Hdf5File>(-1, -1, -1);
}
// create ntuple directory
auto ndirectory
= CreateDirectory(file, fNtupleDirectoryName, "ntuples");
if ( ndirectory < 0 ) {
// Warnin is issued in CreateDirectory
return std::make_shared<G4Hdf5File>(-1, -1, -1);
}
return std::make_shared<G4Hdf5File>(file, hdirectory, ndirectory);
}
//_____________________________________________________________________________
G4bool G4Hdf5FileManager::WriteFileImpl(std::shared_ptr<G4Hdf5File> /*file*/)
{
// Nothing to be done here
return true;
}
//_____________________________________________________________________________
#ifdef G4VERBOSE
G4bool G4Hdf5FileManager::WriteDirectory(const G4String& directoryType,
const G4String& directoryName, hid_t& directory)
#else
G4bool G4Hdf5FileManager::WriteDirectory(const G4String& /*directoryType*/,
const G4String& directoryName, hid_t& directory)
#endif
G4bool G4Hdf5FileManager::CloseFileImpl(std::shared_ptr<G4Hdf5File> file)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
G4String message = "directory for ";
message += directoryType;
fState.GetVerboseL4()
->Message("write", message, directoryName);
}
#endif
auto result
= tools::hdf5::write_atb(directory, "type", "directory");
if ( ! file ) return false;
if ( ! result ) {
G4ExceptionDescription description;
description << " "
<< "cannot write directory " << directoryName;
G4Exception("G4Hdf5FileManager::WriteDirectory()",
"Analysis_W001", JustWarning, description);
// close
// ::H5Gclose(histos);
// ::H5Fclose(file);
G4AutoLock lock(&closeFileMutex);
return false;
}
#ifdef G4VERBOSE
else {
if ( fState.GetVerboseL2() ) {
G4String message = "directory for ";
message += directoryType;
fState.GetVerboseL2()->Message("write", message, fHistoDirectoryName);
}
}
#endif
::H5Gclose(std::get<1>(*file));
::H5Gclose(std::get<2>(*file));
::H5Fclose(std::get<0>(*file));
return result;
lock.unlock();
return true;
}
//
//
// public methods
//
@@ -165,102 +223,79 @@ G4bool G4Hdf5FileManager::WriteDirectory(const G4String& /*directoryType*/,
G4bool G4Hdf5FileManager::OpenFile(const G4String& fileName)
{
// Keep file name
fFileName = fileName;
fFileName = fileName;
auto name = GetFullFileName();
// delete previous file if exists
//if ( fFile ) delete fFile;
if ( fFile ) {
G4ExceptionDescription description;
description
<< "File " << fileName << " already exists.";
G4Exception("G4Hdf5FileManager::OpenFile()",
"Analysis_W001", JustWarning, description);
fFile.reset();
}
// create new file
fFile = ::H5Fcreate(name, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
if ( fFile < 0 ) {
fFile = CreateTFile(name);
if ( ! fFile ) {
G4ExceptionDescription description;
description << " " << "Cannot open file " << fileName;
G4Exception("G4Hdf5AnalysisManager::OpenFile()",
description << "Failed to create file " << fileName;
G4Exception("G4Hdf5FileManager::OpenFile()",
"Analysis_W001", JustWarning, description);
return false;
}
// Create directories
if ( ! CreateDirectory("histograms", fHistoDirectoryName, fHistoDirectory) ) return false;
if ( ! CreateDirectory("ntuples", fNtupleDirectoryName, fNtupleDirectory) ) return false;
// // Open ntuple files
// OpenNtupleFiles();
// Write directories
if ( ! WriteHistoDirectory() ) return false;
if ( ! WriteNtupleDirectory() ) return false;
fLockFileName = true;
fLockHistoDirectoryName = true;
fLockNtupleDirectoryName = true;
fLockDirectoryNames = true;
fIsOpenFile = true;
return true;
}
//_____________________________________________________________________________
G4bool G4Hdf5FileManager::WriteFile()
G4bool G4Hdf5FileManager::CreateNtupleFile(
Hdf5NtupleDescription* ntupleDescription)
{
// Nothing to be done here
return true;
// get ntuple file name per object
auto ntupleFileName = GetNtupleFileName(ntupleDescription);
auto file = GetTFile(ntupleFileName, false);
if (! file) {
file = CreateTFile(ntupleFileName);
}
ntupleDescription->fFile = file;
return (ntupleDescription->fFile != nullptr);
}
//_____________________________________________________________________________
G4bool G4Hdf5FileManager::CloseFile()
G4bool G4Hdf5FileManager::CloseNtupleFile(
Hdf5NtupleDescription* ntupleDescription)
{
// Do nothing if there is no file
if ( fFile < 0 ) return true;
if ( ! ntupleDescription->fFile ) return true;
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("close", "file", GetFullFileName());
#endif
// Ntuple files will be closed with CloseFiles() calls
ntupleDescription->fFile.reset();
if ( fHistoDirectory >= 0 ) {
::H5Gclose(fHistoDirectory);
}
if ( fNtupleDirectory >= 0 ) {
::H5Gclose(fNtupleDirectory);
}
::H5Fclose(fFile);
// Notify not empty file
auto ntupleFileName = GetNtupleFileName(ntupleDescription);
auto result = SetIsEmpty(ntupleFileName, ! ntupleDescription->fHasFill);
fLockFileName = false;
fIsOpenFile = false;
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()->Message("close", "file", GetFullFileName(), true);
#endif
// CHECK
// the result not returned from hdf5
return true;
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5FileManager::WriteHistoDirectory()
hid_t G4Hdf5FileManager::GetHistoDirectory() const
{
return WriteDirectory("histograms", fHistoDirectoryName, fHistoDirectory);
if ( ! fFile ) return kInvalidId;
return std::get<1>(*fFile);
}
//_____________________________________________________________________________
G4bool G4Hdf5FileManager::WriteNtupleDirectory()
hid_t G4Hdf5FileManager::GetNtupleDirectory() const
{
return WriteDirectory("ntuples", fNtupleDirectoryName, fNtupleDirectory);
if ( ! fFile ) return kInvalidId;
return std::get<2>(*fFile);
}
//_____________________________________________________________________________
void G4Hdf5FileManager::CloseAfterHnWrite()
{
if ( fHistoDirectory >= 0 ) {
::H5Gclose(fHistoDirectory);
}
::H5Fclose(fFile);
}