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/include/G4Hdf5AnalysisManager.hh
+2 -4
View File
@@ -40,7 +40,7 @@
#include <memory>
class G4Hdf5FileManager;
class G4Hdf5NtupleManager;
class G4Hdf5NtupleFileManager;
class G4Hdf5AnalysisManager : public G4ToolsAnalysisManager
{
@@ -81,12 +81,10 @@ class G4Hdf5AnalysisManager : public G4ToolsAnalysisManager
template <typename T>
G4bool WriteHn(const std::vector<T*>& htVector,
const std::vector<G4HnInformation*>& hnVector,
const G4String& directoryName,
const G4String& hnType);
template <typename T>
G4bool WritePn(const std::vector<T*>& htVector,
const std::vector<G4HnInformation*>& hnVector,
const G4String& directoryName,
const G4String& hnType);
G4bool WriteDirectory();
G4bool WriteH1();
@@ -97,7 +95,7 @@ class G4Hdf5AnalysisManager : public G4ToolsAnalysisManager
G4bool Reset();
// data members
G4Hdf5NtupleManager* fNtupleManager;
std::shared_ptr<G4Hdf5NtupleFileManager> fNtupleFileManager;
std::shared_ptr<G4Hdf5FileManager> fFileManager;
};
source/analysis/hdf5/include/G4Hdf5AnalysisManager.icc
+17 -16
View File
@@ -26,6 +26,7 @@
//
// Author: Ivana Hrivnacova, 20/07/2017 (ivana@ipno.in2p3.fr)
#include "G4Hdf5NtupleFileManager.hh"
#include "G4Hdf5NtupleManager.hh"
#include "G4Hdf5FileManager.hh"
@@ -36,9 +37,12 @@ template <typename T>
inline
G4bool G4Hdf5AnalysisManager::WriteHn(const std::vector<T*>& htVector,
const std::vector<G4HnInformation*>& hnVector,
const G4String& /*directoryName*/,
const G4String& hnType)
{
auto directory = fFileManager->GetHistoDirectory();
// Do nothing if there is no directory
if ( directory < 0 ) return false;
for ( G4int i=0; i<G4int(htVector.size()); ++i ) {
auto info = hnVector[i];
auto activation = info->GetActivation();
@@ -50,9 +54,6 @@ G4bool G4Hdf5AnalysisManager::WriteHn(const std::vector<T*>& htVector,
if ( fState.GetVerboseL3() )
fState.GetVerboseL3()->Message("write", hnType, name);
#endif
auto directory = fFileManager->GetHistoDirectory();
// Do nothing if there is no directory
if ( directory < 0 ) return false;
G4bool result
= tools::hdf5::write_histo(G4cout, directory, name, *ht);
@@ -63,7 +64,7 @@ G4bool G4Hdf5AnalysisManager::WriteHn(const std::vector<T*>& htVector,
"Analysis_W022", JustWarning, description);
return false;
}
fFileManager->LockHistoDirectoryName();
fFileManager->LockDirectoryNames();
}
return true;
@@ -74,9 +75,12 @@ template <typename T>
inline
G4bool G4Hdf5AnalysisManager::WritePn(const std::vector<T*>& htVector,
const std::vector<G4HnInformation*>& hnVector,
const G4String& /*directoryName*/,
const G4String& hnType)
{
auto directory = fFileManager->GetHistoDirectory();
// Do nothing if there is no directory
if ( directory < 0 ) return false;
for ( G4int i=0; i<G4int(htVector.size()); ++i ) {
auto info = hnVector[i];
auto activation = info->GetActivation();
@@ -88,9 +92,6 @@ G4bool G4Hdf5AnalysisManager::WritePn(const std::vector<T*>& htVector,
if ( fState.GetVerboseL3() )
fState.GetVerboseL3()->Message("write", hnType, name);
#endif
auto directory = fFileManager->GetHistoDirectory();
// Do nothing if there is no directory
if ( directory < 0 ) return false;
G4bool result
= tools::hdf5::write_profile(G4cout, directory, name, *ht);
@@ -101,7 +102,7 @@ G4bool G4Hdf5AnalysisManager::WritePn(const std::vector<T*>& htVector,
"Analysis_W022", JustWarning, description);
return false;
}
fFileManager->LockHistoDirectoryName();
fFileManager->LockDirectoryNames();
}
return true;
@@ -118,28 +119,28 @@ G4bool G4Hdf5AnalysisManager::IsOpenFileImpl() const
inline
tools::hdf5::ntuple* G4Hdf5AnalysisManager::GetNtuple() const
{
return fNtupleManager->GetNtuple();
return fNtupleFileManager->GetNtupleManager()->GetNtuple();
}
//_____________________________________________________________________________
inline
tools::hdf5::ntuple* G4Hdf5AnalysisManager::GetNtuple(G4int ntupleId) const
{
return fNtupleManager->GetNtuple(ntupleId);
return fNtupleFileManager->GetNtupleManager()->GetNtuple(ntupleId);
}
//_____________________________________________________________________________
inline
std::vector<tools::hdf5::ntuple*>::iterator G4Hdf5AnalysisManager::BeginNtuple()
{
return fNtupleManager->BeginNtuple();
return fNtupleFileManager->GetNtupleManager()->BeginNtuple();
}
//_____________________________________________________________________________
inline
std::vector<tools::hdf5::ntuple*>::iterator G4Hdf5AnalysisManager::EndNtuple()
{
return fNtupleManager->EndNtuple();
return fNtupleFileManager->GetNtupleManager()->EndNtuple();
}
//_____________________________________________________________________________
@@ -147,7 +148,7 @@ inline
std::vector<tools::hdf5::ntuple*>::const_iterator
G4Hdf5AnalysisManager::BeginConstNtuple() const
{
return fNtupleManager->BeginConstNtuple();
return fNtupleFileManager->GetNtupleManager()->BeginConstNtuple();
}
//_____________________________________________________________________________
@@ -155,5 +156,5 @@ inline
std::vector<tools::hdf5::ntuple*>::const_iterator
G4Hdf5AnalysisManager::EndConstNtuple() const
{
return fNtupleManager->EndConstNtuple();
return fNtupleFileManager->GetNtupleManager()->EndConstNtuple();
}
source/analysis/hdf5/include/G4Hdf5FileManager.hh
+27 -33
View File
@@ -31,75 +31,69 @@
#ifndef G4Hdf5FileManager_h
#define G4Hdf5FileManager_h 1
#include "G4VFileManager.hh"
#include "G4TNtupleDescription.hh"
#include "G4VTFileManager.hh"
#include "globals.hh"
#include "tools/hdf5/ntuple"
#include "tools/hdf5/ntuple" // for hid_t
#include <fstream>
#include <memory>
#include <tuple>
class G4AnalysisManagerState;
using G4Hdf5File = std::tuple<hid_t, hid_t, hid_t>;
using Hdf5NtupleDescription = G4TNtupleDescription<tools::hdf5::ntuple, G4Hdf5File>;
class G4Hdf5FileManager : public G4VFileManager
class G4Hdf5FileManager : public G4VTFileManager<G4Hdf5File>
{
public:
explicit G4Hdf5FileManager(const G4AnalysisManagerState& state);
~G4Hdf5FileManager();
// Type aliases
using NtupleType = tools::hdf5::ntuple;
using NtupleDescriptionType = G4TNtupleDescription<NtupleType>;
using G4BaseFileManager::GetNtupleFileName;
using G4VTFileManager<G4Hdf5File>::WriteFile;
using G4VTFileManager<G4Hdf5File>::CloseFile;
// Methods to manipulate output files
virtual G4bool OpenFile(const G4String& fileName) final;
virtual G4bool WriteFile() final;
virtual G4bool CloseFile() final;
G4bool WriteHistoDirectory();
G4bool WriteNtupleDirectory();
void CloseAfterHnWrite();
virtual G4String GetFileType() const final { return "hdf5"; }
// Specific methods for files per objects
G4bool CreateNtupleFile(Hdf5NtupleDescription* ntupleDescription);
G4bool CloseNtupleFile(Hdf5NtupleDescription* ntupleDescription);
// Set methods
void SetBasketSize(unsigned int basketSize);
// Get methods
hid_t GetFile() const;
hid_t GetHistoDirectory() const;
hid_t GetNtupleDirectory() const;
unsigned int GetBasketSize() const;
private:
G4bool CreateDirectory(const G4String& directoryType,
const G4String& directoryName, hid_t& directory);
G4bool WriteDirectory(const G4String& directoryType,
const G4String& directoryName, hid_t& directory);
protected:
// // Methods derived from templated base class
virtual std::shared_ptr<G4Hdf5File> CreateFileImpl(const G4String& fileName) final;
virtual G4bool WriteFileImpl(std::shared_ptr<G4Hdf5File> file) final;
virtual G4bool CloseFileImpl(std::shared_ptr<G4Hdf5File> file) final;
private:
hid_t CreateDirectory(hid_t& file, const G4String& directoryName,
const G4String& objectType);
G4String GetNtupleFileName(Hdf5NtupleDescription* ntupleDescription);
// constants
static const G4String fgkDefaultDirectoryName;
// data members
hid_t fFile;
hid_t fHistoDirectory;
hid_t fNtupleDirectory;
unsigned int fBasketSize;
};
// inline functions
inline void G4Hdf5FileManager::SetBasketSize(unsigned int basketSize)
//_____________________________________________________________________________
inline void G4Hdf5FileManager::SetBasketSize(unsigned int basketSize)
{ fBasketSize = basketSize; }
inline hid_t G4Hdf5FileManager::GetFile() const
{ return fFile; }
inline hid_t G4Hdf5FileManager::GetHistoDirectory() const
{ return fHistoDirectory; }
inline hid_t G4Hdf5FileManager::GetNtupleDirectory() const
{ return fNtupleDirectory; }
//_____________________________________________________________________________
inline unsigned int G4Hdf5FileManager::GetBasketSize() const
{ return fBasketSize; }
source/analysis/hdf5/include/G4Hdf5HnFileManager.hh
+65
View File
@@ -0,0 +1,65 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// The manager for histogram/profile Hfd5 file output.
// Author: Ivana Hrivnacova, 15/09/2020 (ivana@ipno.in2p3.fr)
#ifndef G4Hdf5HnFileManager_h
#define G4Hdf5HnFileManager_h 1
#include "G4VTHnFileManager.hh"
#include "tools/hdf5/ntuple" // for hid_t
class G4Hdf5FileManager;
template <typename HT>
class G4Hdf5HnFileManager : public G4VTHnFileManager<HT>
{
public:
G4Hdf5HnFileManager(G4Hdf5FileManager* fileManger)
: G4VTHnFileManager<HT>(), fFileManager(fileManger) {}
virtual ~G4Hdf5HnFileManager() {}
// Methods for writing objects
// Write to a new file (the file is closed after write)
virtual G4bool WriteExtra(HT* ht, const G4String& htName, const G4String& fileName) final;
// Write to the default file (handled with OpenFile()/CloseFile methods)
virtual G4bool Write(HT* ht, const G4String& htName, G4String& fileName) final;
private:
// Methods
G4bool WriteImpl(hid_t hdirectory, HT* ht, const G4String& htName);
// Data members
G4Hdf5FileManager* fFileManager;
};
// inline functions
#include "G4Hdf5HnFileManager.icc"
#endif
source/analysis/hdf5/include/G4Hdf5HnFileManager.icc
+140
View File
@@ -0,0 +1,140 @@
//
// ********************************************************************
// * 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 "tools/hdf5/header"
#include "tools/hdf5/h2file"
#include "tools/histo/h1d"
#include "tools/histo/h2d"
#include "tools/histo/h3d"
#include "tools/histo/p1d"
#include "tools/histo/p2d"
#include "tools/hdf5/h2file"
//_____________________________________________________________________________
template <>
inline
G4bool G4Hdf5HnFileManager<tools::histo::p1d>::WriteImpl(
hid_t hdirectory, tools::histo::p1d* ht, const G4String& htName)
{
return tools::hdf5::write_profile(G4cout, hdirectory, htName, *ht);
}
//_____________________________________________________________________________
template <>
inline
G4bool G4Hdf5HnFileManager<tools::histo::p2d>::WriteImpl(
hid_t hdirectory, tools::histo::p2d* ht, const G4String& htName)
{
return tools::hdf5::write_profile(G4cout, hdirectory, htName, *ht);
}
//_____________________________________________________________________________
template <typename HT>
inline
G4bool G4Hdf5HnFileManager<HT>::WriteImpl(
hid_t hdirectory, HT* ht, const G4String& htName)
{
return tools::hdf5::write_histo(G4cout, hdirectory, htName, *ht);
}
//_____________________________________________________________________________
template <typename HT>
inline
G4bool G4Hdf5HnFileManager<HT>::WriteExtra(
HT* ht, const G4String& htName, const G4String& fileName)
{
// create a new file
// create new file
hid_t hfile = ::H5Fcreate(fileName, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
// Do nothing if there is no file
// (te error should be handled by caller)
if ( hfile < 0 ) {
G4cerr << "::H5Fcreate failed " << G4endl;
return false;
}
// create a header with general infos :
if(!tools::hdf5::write_header(hfile)) {
G4cerr << "tools::hdf5::write_header() failed." << std::endl;
return false;
}
// Create directories
hid_t hdirectory = tools_H5Gcreate(hfile, "histograms", 0);
if ( hdirectory < 0 ) {
G4cerr << "tools_H5Gcreate failed " << G4endl;
return false;
}
auto result = tools::hdf5::write_atb(hdirectory, "type", "directory");
if ( ! result) {
G4cerr << "tools::hdf5::write_atb failed " << G4endl;
return false;
}
result = WriteImpl(hdirectory, ht, htName);
if ( ! result) {
G4cerr << "Writing HT failed" << G4endl;
return false;
}
// close file
::H5Gclose(hdirectory);
::H5Gclose(hfile);
return true;
}
//_____________________________________________________________________________
template <typename HT>
inline
G4bool G4Hdf5HnFileManager<HT>::Write(
HT* ht, const G4String& htName, G4String& fileName)
{
if (fileName.empty()) {
// should not happen
G4cerr << "!!! Hdf5 file name not defined." << G4endl;
G4cerr << "!!! Write " << htName << " failed." << G4endl;
return false;
}
auto hdirectory = std::get<1>(*fFileManager->GetTFile(fileName));
if ( hdirectory < 0 ) {
G4ExceptionDescription description;
description
<< "Failed to get Hdf5 file " << fileName << " histo directory.";
G4Exception("G4Hdf5HnFileManager<HT>::Write()",
"Analysis_W022", JustWarning, description);
return false;
}
auto result = WriteImpl(hdirectory, ht, htName);
fFileManager->LockDirectoryNames();
return result;
}
source/analysis/hdf5/include/G4Hdf5NtupleFileManager.hh
+79
View File
@@ -0,0 +1,79 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// Manager class for ntuple Hdf5 file output.
//
// Author: Ivana Hrivnacova, 15/09/2020 (ivana@ipno.in2p3.fr)
#ifndef G4Hdf5NtupleFileManager_h
#define G4Hdf5NtupleFileManager_h 1
#include "G4VNtupleFileManager.hh"
#include "globals.hh"
class G4Hdf5FileManager;
class G4Hdf5NtupleManager;
class G4VNtupleManager;
class G4NtupleBookingManager;
class G4Hdf5NtupleFileManager : public G4VNtupleFileManager
{
friend class G4Hdf5AnalysisManager;
public:
explicit G4Hdf5NtupleFileManager(const G4AnalysisManagerState& state);
~G4Hdf5NtupleFileManager();
virtual std::shared_ptr<G4VNtupleManager> CreateNtupleManager() override;
// Methods to be performed at file management
virtual G4bool ActionAtOpenFile(const G4String& fileName) override;
virtual G4bool ActionAtWrite() override;
virtual G4bool ActionAtCloseFile(G4bool reset) override;
virtual G4bool Reset() override;
void SetFileManager(std::shared_ptr<G4Hdf5FileManager> fileManager);
std::shared_ptr<G4Hdf5NtupleManager> GetNtupleManager() const;
private:
// methods
G4bool CloseNtupleFiles();
// data members
std::shared_ptr<G4Hdf5FileManager> fFileManager;
std::shared_ptr<G4Hdf5NtupleManager> fNtupleManager;
};
inline void G4Hdf5NtupleFileManager::SetFileManager(
std::shared_ptr<G4Hdf5FileManager> fileManager)
{ fFileManager = fileManager; }
inline std::shared_ptr<G4Hdf5NtupleManager> G4Hdf5NtupleFileManager::GetNtupleManager() const
{ return fNtupleManager; }
#endif
source/analysis/hdf5/include/G4Hdf5NtupleManager.hh
+14 -16
View File
@@ -41,46 +41,45 @@
class G4Hdf5FileManager;
// Types alias
using G4Hdf5File = std::tuple<hid_t, hid_t, hid_t>;
using Hdf5NtupleDescription = G4TNtupleDescription<tools::hdf5::ntuple, G4Hdf5File>;
// template specialization used by this class defined below
template <>
template <>
G4bool G4TNtupleManager<tools::hdf5::ntuple>::FillNtupleTColumn(
G4bool G4TNtupleManager<tools::hdf5::ntuple, G4Hdf5File>::FillNtupleTColumn(
G4int ntupleId, G4int columnId, const std::string& value);
class G4Hdf5NtupleManager : public G4TNtupleManager<tools::hdf5::ntuple>
class G4Hdf5NtupleManager : public G4TNtupleManager<tools::hdf5::ntuple,
G4Hdf5File>
{
friend class G4Hdf5AnalysisManager;
friend class G4Hdf5NtupleFileManager;
public:
explicit G4Hdf5NtupleManager(const G4AnalysisManagerState& state);
~G4Hdf5NtupleManager();
private:
// Types alias
using NtupleType = tools::hdf5::ntuple;
using NtupleDescriptionType = G4TNtupleDescription<NtupleType>;
// Set methods
void SetFileManager(std::shared_ptr<G4Hdf5FileManager> fileManager);
// Access to ntuple vector (needed for Write())
const std::vector<NtupleDescriptionType*>& GetNtupleDescriptionVector() const;
const std::vector<Hdf5NtupleDescription*>& GetNtupleDescriptionVector() const;
// Utility function
void CreateTNtuple(NtupleDescriptionType* ntupleDescription, G4bool warn);
void CreateTNtuple(Hdf5NtupleDescription* ntupleDescription, G4bool warn);
// Methods from the templated base class
//
virtual void CreateTNtuple(
NtupleDescriptionType* ntupleDescription,
const G4String& name, const G4String& title) final;
virtual void CreateTNtupleFromBooking(
NtupleDescriptionType* ntupleDescription) final;
Hdf5NtupleDescription* ntupleDescription) final;
virtual void FinishTNtuple(
NtupleDescriptionType* ntupleDescription,
Hdf5NtupleDescription* ntupleDescription,
G4bool fromBooking) final;
// data members
@@ -94,13 +93,13 @@ inline void
G4Hdf5NtupleManager::SetFileManager(std::shared_ptr<G4Hdf5FileManager> fileManager)
{ fFileManager = fileManager; }
inline const std::vector<G4TNtupleDescription<tools::hdf5::ntuple>*>&
inline const std::vector<Hdf5NtupleDescription*>&
G4Hdf5NtupleManager::GetNtupleDescriptionVector() const
{ return fNtupleDescriptionVector; }
template <>
template <>
inline G4bool G4TNtupleManager<tools::hdf5::ntuple>::FillNtupleTColumn(
inline G4bool G4TNtupleManager<tools::hdf5::ntuple, G4Hdf5File>::FillNtupleTColumn(
G4int ntupleId, G4int columnId, const std::string& value)
{
if ( fState.GetIsActivation() && ( ! GetActivation(ntupleId) ) ) {
@@ -150,4 +149,3 @@ inline G4bool G4TNtupleManager<tools::hdf5::ntuple>::FillNtupleTColumn(
}
#endif
source/analysis/hdf5/include/G4Hdf5RFileManager.hh
+2
View File
@@ -44,6 +44,8 @@ class G4Hdf5RFileManager : public G4BaseFileManager
explicit G4Hdf5RFileManager(const G4AnalysisManagerState& state);
virtual ~G4Hdf5RFileManager();
virtual G4String GetFileType() const final { return "hdf5"; }
// Get methods
hid_t GetRFile(const G4String& fileName, G4bool isPerThread) const;
hid_t GetHistoRDirectory(const G4String& fileName, const G4String& dirName,
source/analysis/hdf5/sources.cmake
+4
View File
@@ -13,7 +13,10 @@ geant4_define_module(NAME G4hdf5
G4Hdf5AnalysisReader.hh
G4Hdf5AnalysisReader.icc
G4Hdf5FileManager.hh
G4Hdf5HnFileManager.hh
G4Hdf5HnFileManager.icc
G4Hdf5NtupleManager.hh
G4Hdf5NtupleFileManager.hh
G4Hdf5RNtupleManager.hh
G4Hdf5RFileManager.hh
g4hdf5_defs.hh
@@ -23,6 +26,7 @@ geant4_define_module(NAME G4hdf5
G4Hdf5AnalysisReader.cc
G4Hdf5FileManager.cc
G4Hdf5NtupleManager.cc
G4Hdf5NtupleFileManager.cc
G4Hdf5RFileManager.cc
G4Hdf5RNtupleManager.cc
GRANULAR_DEPENDENCIES
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();
}