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/G4Hdf5AnalysisManager.cc
+37 -59
View File
@@ -28,11 +28,14 @@
#include "G4Hdf5AnalysisManager.hh"
#include "G4Hdf5FileManager.hh"
#include "G4Hdf5NtupleManager.hh"
#include "G4Hdf5NtupleFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
using namespace G4Analysis;
// mutex in a file scope
namespace {
@@ -75,7 +78,7 @@ G4bool G4Hdf5AnalysisManager::IsInstance()
//_____________________________________________________________________________
G4Hdf5AnalysisManager::G4Hdf5AnalysisManager(G4bool isMaster)
: G4ToolsAnalysisManager("Hdf5", isMaster),
fNtupleManager(nullptr),
fNtupleFileManager(nullptr),
fFileManager(nullptr)
{
#ifdef G4MULTITHREADED
@@ -84,7 +87,7 @@ G4Hdf5AnalysisManager::G4Hdf5AnalysisManager(G4bool isMaster)
message
<< "Your HDF5 lib is not built with H5_HAVE_THREADSAFE.";
G4Exception("G4Hdf5AnalysisManager::G4Hdf5AnalysisManager",
"Analysis_F001", FatalException, message);
"Analysis_F002", FatalException, message);
#endif
#endif
@@ -105,11 +108,10 @@ G4Hdf5AnalysisManager::G4Hdf5AnalysisManager(G4bool isMaster)
SetFileManager(fFileManager);
fFileManager->SetBasketSize(fgkDefaultBasketSize);
// Ntuple manager
fNtupleManager = new G4Hdf5NtupleManager(fState);
fNtupleManager->SetFileManager(fFileManager);
SetNtupleManager(fNtupleManager);
// The managers will be deleted by the base class
// Ntuple file manager
fNtupleFileManager = std::make_shared<G4Hdf5NtupleFileManager>(fState);
fNtupleFileManager->SetFileManager(fFileManager);
fNtupleFileManager->SetBookingManager(fNtupleBookingManager);
}
//_____________________________________________________________________________
@@ -134,8 +136,7 @@ G4bool G4Hdf5AnalysisManager::WriteH1()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WriteHn(h1Vector, hnVector, directoryName, "h1");
result = WriteHn(h1Vector, hnVector, "h1");
}
else {
// The worker manager just adds its histograms to the master
@@ -159,8 +160,7 @@ G4bool G4Hdf5AnalysisManager::WriteH2()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WriteHn(h2Vector, hnVector, directoryName, "h2");
result = WriteHn(h2Vector, hnVector, "h2");
}
else {
// The worker manager just adds its histograms to the master
@@ -184,8 +184,7 @@ G4bool G4Hdf5AnalysisManager::WriteH3()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WriteHn(h3Vector, hnVector, directoryName, "h3");
result = WriteHn(h3Vector, hnVector, "h3");
}
else {
// The worker manager just adds its histograms to the master
@@ -209,8 +208,7 @@ G4bool G4Hdf5AnalysisManager::WriteP1()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WritePn(p1Vector, hnVector, directoryName, "p1");
result = WritePn(p1Vector, hnVector, "p1");
}
else {
// The worker manager just adds its profiles to the master
@@ -234,8 +232,7 @@ G4bool G4Hdf5AnalysisManager::WriteP2()
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WritePn(p2Vector, hnVector, directoryName, "p2");
result = WritePn(p2Vector, hnVector, "p2");
}
else {
// The worker manager just adds its profiles to the master
@@ -258,7 +255,7 @@ G4bool G4Hdf5AnalysisManager::Reset()
auto result = G4ToolsAnalysisManager::Reset();
finalResult = finalResult && result;
result = fNtupleManager->Reset(true);
result = fNtupleFileManager->Reset();
finalResult = finalResult && result;
return finalResult;
@@ -271,47 +268,34 @@ G4bool G4Hdf5AnalysisManager::Reset()
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::OpenFileImpl(const G4String& fileName)
{
auto finalResult = true;
auto result = fFileManager->SetFileName(fileName);
finalResult = finalResult && result;
// Create ntuple manager(s)
// and set it to base class which takes then their ownership
SetNtupleManager(fNtupleFileManager->CreateNtupleManager());
#ifdef G4VERBOSE
G4String name = fFileManager->GetFullFileName();
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("open", "analysis file", name);
#endif
auto finalResult = true;
G4AutoLock lock(&openFileMutex);
result = fFileManager->OpenFile(fileName);
auto result = fFileManager->OpenFile(fileName);
finalResult = finalResult && result;
// fNtupleManager->SetNtupleDirectory(fFileManager->GetNtupleDirectory());
fNtupleManager->CreateNtuplesFromBooking();
result = fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
finalResult = finalResult && result;
lock.unlock();
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()->Message("open", "analysis file", name, finalResult);
#endif
return finalResult;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteImpl()
{
auto finalResult = true;
#ifdef G4VERBOSE
auto name = fFileManager->GetFullFileName();
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("write", "files", name);
if ( fState.GetVerboseL4() ) {
fState.GetVerboseL4()->Message("write", "files", "");
}
#endif
// Histo directory
// auto result = fFileManager->WriteHistoDirectory();
// if ( ! result ) return false;
auto result = WriteH1();
finalResult = finalResult && result;
@@ -331,10 +315,6 @@ G4bool G4Hdf5AnalysisManager::WriteImpl()
result = WriteP2();
finalResult = finalResult && result;
// // Ntuple directory
// result = fFileManager->WriteNtupleDirectory();
// if ( ! result ) return false;
// Write ASCII if activated
if ( IsAscii() ) {
result = WriteAscii(fFileManager->GetFileName());
@@ -342,9 +322,9 @@ G4bool G4Hdf5AnalysisManager::WriteImpl()
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
->Message("write", "file", fFileManager->GetFullFileName(), finalResult);
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()->Message("write", "files", "", finalResult);
}
#endif
return finalResult;
@@ -356,27 +336,25 @@ G4bool G4Hdf5AnalysisManager::CloseFileImpl(G4bool reset)
auto finalResult = true;
G4AutoLock lock(&closeFileMutex);
auto result = fFileManager->CloseFile();
auto result = fFileManager->CloseFiles();
finalResult = finalResult && result;
if ( reset ) {
// reset data
result = Reset();
} else {
// ntuple must be reset
result = fNtupleManager->Reset(true);
}
if ( ! result ) {
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4Hdf5AnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
}
}
lock.unlock();
finalResult = finalResult && result;
// No files clean-up as ntuples are not supported in MT mode
result = fNtupleFileManager->ActionAtCloseFile(reset);
finalResult = finalResult && result;
lock.unlock();
return finalResult;
}
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);
}
source/analysis/hdf5/src/G4Hdf5NtupleFileManager.cc
+150
View File
@@ -0,0 +1,150 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// Author: Ivana Hrivnacova, 15/09/2020 (ivana@ipno.in2p3.fr)
#include "G4Hdf5NtupleFileManager.hh"
#include "G4Hdf5NtupleManager.hh"
#include "G4Hdf5FileManager.hh"
#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)
{}
//_____________________________________________________________________________
G4Hdf5NtupleFileManager::~G4Hdf5NtupleFileManager()
{}
//
// private methods
//
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::CloseNtupleFiles()
{
// Close ntuple files
auto finalResult = true;
auto ntupleVector = fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntupleDescription : ntupleVector) {
auto result = fFileManager->CloseNtupleFile(ntupleDescription);
finalResult = finalResult && result;
}
return finalResult;
}
//
// public methods
//
//_____________________________________________________________________________
std::shared_ptr<G4VNtupleManager> G4Hdf5NtupleFileManager::CreateNtupleManager()
{
// The managers will be deleted by the base class
fNtupleManager = std::make_shared<G4Hdf5NtupleManager>(fState);
fNtupleManager->SetFileManager(fFileManager);
return fNtupleManager;
}
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::ActionAtOpenFile(const G4String& /*fileName*/)
{
// Create ntuples if they are booked
// (The files will be created with creating ntuples)
fNtupleManager->CreateNtuplesFromBooking(
fBookingManager->GetNtupleBookingVector());
return true;
}
//_____________________________________________________________________________
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;
}
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::ActionAtCloseFile(G4bool reset)
{
auto finalResult = true;
// Close ntuple files
auto result = CloseNtupleFiles();
finalResult = finalResult && result;
if ( ! reset ) {
// 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);
}
finalResult = finalResult && result;
}
return finalResult;
}
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::Reset()
{
return fNtupleManager->Reset(true);
}
source/analysis/hdf5/src/G4Hdf5NtupleManager.cc
+22 -21
View File
@@ -41,7 +41,7 @@ using namespace G4Analysis;
//_____________________________________________________________________________
G4Hdf5NtupleManager::G4Hdf5NtupleManager(const G4AnalysisManagerState& state)
: G4TNtupleManager<tools::hdf5::ntuple>(state),
: G4TNtupleManager<tools::hdf5::ntuple, G4Hdf5File>(state),
fFileManager(nullptr)
{}
@@ -54,26 +54,30 @@ G4Hdf5NtupleManager::~G4Hdf5NtupleManager()
//
//_____________________________________________________________________________
void G4Hdf5NtupleManager::CreateTNtuple(
NtupleDescriptionType* ntupleDescription, G4bool warn)
Hdf5NtupleDescription* ntupleDescription, G4bool warn)
{
// Ntuple will be created from ntupleDescription if file is open,
// return with or without warning otherwise
// create a file for this ntuple
// if ( ! fFileManager->CreateNtupleFile(ntupleDescription) ) return;
// Get ntuple file from ntuple description
auto ntupleFile = ntupleDescription->fFile;
if (! ntupleFile) {
ntupleFile = fFileManager->GetFile();
}
// Check ntuple directory
if ( fFileManager->GetNtupleDirectory() < 0 ) {
if ( warn ) {
G4String inFunction = "G4Hdf5NtupleManager::::CreateTNtupleFromBooking";
// Check file
if ( ! ntupleFile ) {
if (warn) {
G4String inFunction = "G4Hdf5NtupleManager::::CreateTNtuple";
G4ExceptionDescription description;
description << " "
<< "Cannot create ntuple. Ntuple directory does not exist." << G4endl;
<< "Cannot create ntuple. Ntuple file does not exist." << G4endl;
G4Exception(inFunction, "Analysis_W002", JustWarning, description);
}
return;
}
auto directory = std::get<2>(*ntupleFile);
auto basketSize = fFileManager->GetBasketSize();
// auto compressionLevel = fState.GetCompressionLevel();
auto compressionLevel = 0;
@@ -81,31 +85,28 @@ void G4Hdf5NtupleManager::CreateTNtuple(
// create ntuple
ntupleDescription->fNtuple
= new tools::hdf5::ntuple(
G4cout, fFileManager->GetNtupleDirectory(), ntupleDescription->fNtupleBooking,
G4cout, directory, ntupleDescription->fNtupleBooking,
compressionLevel, basketSize);
fNtupleVector.push_back(ntupleDescription->fNtuple);
}
//_____________________________________________________________________________
void G4Hdf5NtupleManager::CreateTNtuple(
G4TNtupleDescription<tools::hdf5::ntuple>* /*ntupleDescription*/,
const G4String& /*name*/, const G4String& /*title*/)
{
// Ntuple will be created at finish ntuple from ntuple_booking
}
//_____________________________________________________________________________
void G4Hdf5NtupleManager::CreateTNtupleFromBooking(
G4TNtupleDescription<tools::hdf5::ntuple>* ntupleDescription)
Hdf5NtupleDescription* ntupleDescription)
{
// Create file if file name per object is set
if ( ntupleDescription->fFileName.size() ) {
fFileManager->CreateNtupleFile(ntupleDescription);
}
// Create ntuple from booking and print a warning if file is not open
CreateTNtuple(ntupleDescription, true);
}
//_____________________________________________________________________________
void G4Hdf5NtupleManager::FinishTNtuple(
G4TNtupleDescription<tools::hdf5::ntuple>* ntupleDescription,
Hdf5NtupleDescription* ntupleDescription,
G4bool /*fromBooking*/)
{
if ( ! ntupleDescription->fNtuple ) {
@@ -113,6 +114,6 @@ void G4Hdf5NtupleManager::FinishTNtuple(
CreateTNtuple(ntupleDescription, false);
}
fFileManager->LockNtupleDirectoryName();
fFileManager->LockDirectoryNames();
}