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

Import Geant4 11.1.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2022-12-09 14:43:28 +01:00
parent c07cea1fe0
commit 9f34590941
3810 changed files with 200490 additions and 182326 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/analysis/hdf5/include/G4Hdf5AnalysisManager.hh
+3 -9
View File
@@ -41,7 +41,6 @@
#include <string_view>
class G4Hdf5AnalysisManager;
class G4Hdf5FileManager;
class G4Hdf5NtupleFileManager;
template <class T>
class G4ThreadLocalSingleton;
@@ -51,7 +50,7 @@ class G4Hdf5AnalysisManager : public G4ToolsAnalysisManager
friend class G4ThreadLocalSingleton<G4Hdf5AnalysisManager>;
public:
virtual ~G4Hdf5AnalysisManager();
~G4Hdf5AnalysisManager() override;
// Static methods
static G4Hdf5AnalysisManager* Instance();
@@ -69,23 +68,18 @@ class G4Hdf5AnalysisManager : public G4ToolsAnalysisManager
protected:
// Virtual methods from base class
virtual G4bool OpenFileImpl(const G4String& fileName) final;
virtual G4bool WriteImpl() final;
virtual G4bool CloseFileImpl(G4bool reset) final;
virtual G4bool ResetImpl() final;
virtual G4bool IsOpenFileImpl() const final;
G4bool OpenFileImpl(const G4String& fileName) final;
G4bool CloseFileImpl(G4bool reset) final;
private:
G4Hdf5AnalysisManager();
// Static data members
inline static G4Hdf5AnalysisManager* fgMasterInstance { nullptr };
inline static G4ThreadLocal G4bool fgIsInstance { false };
static constexpr std::string_view fkClass { "G4Hdf5AnalysisManager" };
// Data members
std::shared_ptr<G4Hdf5NtupleFileManager> fNtupleFileManager { nullptr };
std::shared_ptr<G4Hdf5FileManager> fFileManager { nullptr };
};
#include "G4Hdf5AnalysisManager.icc"
source/analysis/hdf5/include/G4Hdf5AnalysisManager.icc
-7
View File
@@ -30,13 +30,6 @@
#include "G4Hdf5NtupleManager.hh"
#include "G4Hdf5FileManager.hh"
//_____________________________________________________________________________
inline
G4bool G4Hdf5AnalysisManager::IsOpenFileImpl() const
{
return fFileManager->IsOpenFile();
}
//_____________________________________________________________________________
inline
toolx::hdf5::ntuple* G4Hdf5AnalysisManager::GetNtuple() const
source/analysis/hdf5/include/G4Hdf5AnalysisReader.hh
+2 -2
View File
@@ -51,7 +51,7 @@ class G4Hdf5AnalysisReader : public G4ToolsAnalysisReader
friend class G4ThreadLocalSingleton<G4Hdf5AnalysisReader>;
public:
virtual ~G4Hdf5AnalysisReader();
~G4Hdf5AnalysisReader() override;
// Static methods
static G4Hdf5AnalysisReader* Instance();
@@ -63,7 +63,7 @@ class G4Hdf5AnalysisReader : public G4ToolsAnalysisReader
protected:
// Virtual methods from base class
virtual G4bool CloseFilesImpl(G4bool reset) final;
G4bool CloseFilesImpl(G4bool reset) final;
private:
G4Hdf5AnalysisReader();
source/analysis/hdf5/include/G4Hdf5FileManager.hh
+6 -6
View File
@@ -49,16 +49,16 @@ class G4Hdf5FileManager : public G4VTFileManager<G4Hdf5File>
public:
explicit G4Hdf5FileManager(const G4AnalysisManagerState& state);
G4Hdf5FileManager() = delete;
~G4Hdf5FileManager() = default;
~G4Hdf5FileManager() override = default;
using G4BaseFileManager::GetNtupleFileName;
using G4VTFileManager<G4Hdf5File>::WriteFile;
using G4VTFileManager<G4Hdf5File>::CloseFile;
// Methods to manipulate output files
virtual G4bool OpenFile(const G4String& fileName) final;
G4bool OpenFile(const G4String& fileName) final;
virtual G4String GetFileType() const final { return "hdf5"; }
G4String GetFileType() const final { return "hdf5"; }
// Specific methods for files per objects
G4bool CreateNtupleFile(Hdf5NtupleDescription* ntupleDescription);
@@ -74,9 +74,9 @@ class G4Hdf5FileManager : public G4VTFileManager<G4Hdf5File>
protected:
// // Methods derived from 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;
std::shared_ptr<G4Hdf5File> CreateFileImpl(const G4String& fileName) final;
G4bool WriteFileImpl(std::shared_ptr<G4Hdf5File> file) final;
G4bool CloseFileImpl(std::shared_ptr<G4Hdf5File> file) final;
private:
hid_t CreateDirectory(hid_t& file, const G4String& directoryName,
source/analysis/hdf5/include/G4Hdf5HnFileManager.hh
+4 -4
View File
@@ -45,14 +45,14 @@ class G4Hdf5HnFileManager : public G4VTHnFileManager<HT>
public:
explicit G4Hdf5HnFileManager(G4Hdf5FileManager* fileManger)
: G4VTHnFileManager<HT>(), fFileManager(fileManger) {}
G4Hdf5HnFileManager() = delete;
virtual ~G4Hdf5HnFileManager() = default;
G4Hdf5HnFileManager() = delete;
~G4Hdf5HnFileManager() override = default;
// 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;
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;
G4bool Write(HT* ht, const G4String& htName, G4String& fileName) final;
private:
// Methods
source/analysis/hdf5/include/G4Hdf5HnFileManager.icc
-2
View File
@@ -36,8 +36,6 @@
#include "tools/histo/p1d"
#include "tools/histo/p2d"
#include "toolx/hdf5/h2file"
//_____________________________________________________________________________
template <>
inline
source/analysis/hdf5/include/G4Hdf5HnRFileManager.hh
+3 -3
View File
@@ -46,11 +46,11 @@ class G4Hdf5HnRFileManager : public G4VTHnRFileManager<HT>
explicit G4Hdf5HnRFileManager(G4Hdf5RFileManager* rfileManger)
: G4VTHnRFileManager<HT>(), fRFileManager(rfileManger) {}
G4Hdf5HnRFileManager() = delete;
virtual ~G4Hdf5HnRFileManager() = default;
~G4Hdf5HnRFileManager() override = default;
// Methods for writing objects
virtual HT* Read(const G4String& htName, const G4String& fileName,
const G4String& dirName, G4bool isUserFileName) final;
HT* Read(const G4String& htName, const G4String& fileName, const G4String& dirName,
G4bool isUserFileName) final;
private:
// Methods
source/analysis/hdf5/include/G4Hdf5HnRFileManager.icc
-2
View File
@@ -36,8 +36,6 @@
#include "tools/histo/p1d"
#include "tools/histo/p2d"
#include "toolx/hdf5/h2file"
//_____________________________________________________________________________
template <typename HT>
inline
source/analysis/hdf5/include/G4Hdf5NtupleFileManager.hh
+10 -10
View File
@@ -35,6 +35,7 @@
#include "globals.hh"
#include <string_view>
#include <utility>
class G4Hdf5FileManager;
class G4Hdf5NtupleManager;
@@ -48,24 +49,21 @@ class G4Hdf5NtupleFileManager : public G4VNtupleFileManager
public:
explicit G4Hdf5NtupleFileManager(const G4AnalysisManagerState& state);
G4Hdf5NtupleFileManager() = delete;
virtual ~G4Hdf5NtupleFileManager() = default;
~G4Hdf5NtupleFileManager() override = default;
virtual std::shared_ptr<G4VNtupleManager> CreateNtupleManager() override;
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;
G4bool ActionAtOpenFile(const G4String& fileName) override;
G4bool ActionAtWrite() override;
G4bool ActionAtCloseFile() override;
G4bool Reset() override;
void SetFileManager(std::shared_ptr<G4Hdf5FileManager> fileManager);
std::shared_ptr<G4Hdf5NtupleManager> GetNtupleManager() const;
private:
// Methods
G4bool CloseNtupleFiles();
// Static data members
static constexpr std::string_view fkClass { "G4Hdf5NtupleFileManager" };
@@ -76,7 +74,9 @@ class G4Hdf5NtupleFileManager : public G4VNtupleFileManager
inline void G4Hdf5NtupleFileManager::SetFileManager(
std::shared_ptr<G4Hdf5FileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
inline std::shared_ptr<G4Hdf5NtupleManager> G4Hdf5NtupleFileManager::GetNtupleManager() const
{ return fNtupleManager; }
source/analysis/hdf5/include/G4Hdf5NtupleManager.hh
+10 -10
View File
@@ -37,8 +37,9 @@
#include "toolx/hdf5/ntuple"
#include <vector>
#include <memory>
#include <utility>
#include <vector>
class G4Hdf5FileManager;
@@ -63,7 +64,7 @@ class G4Hdf5NtupleManager : public G4TNtupleManager<toolx::hdf5::ntuple,
public:
explicit G4Hdf5NtupleManager(const G4AnalysisManagerState& state);
G4Hdf5NtupleManager() = delete;
virtual ~G4Hdf5NtupleManager() = default;
~G4Hdf5NtupleManager() override = default;
private:
// Set methods
@@ -77,12 +78,9 @@ class G4Hdf5NtupleManager : public G4TNtupleManager<toolx::hdf5::ntuple,
// Methods from the templated base class
//
virtual void CreateTNtupleFromBooking(
Hdf5NtupleDescription* ntupleDescription) final;
void CreateTNtupleFromBooking(Hdf5NtupleDescription* ntupleDescription) final;
virtual void FinishTNtuple(
Hdf5NtupleDescription* ntupleDescription,
G4bool fromBooking) final;
void FinishTNtuple(Hdf5NtupleDescription* ntupleDescription, G4bool fromBooking) final;
// Static data members
static constexpr std::string_view fkClass { "G4Hdf5NtupleManager" };
@@ -97,7 +95,9 @@ using std::to_string;
inline void
G4Hdf5NtupleManager::SetFileManager(std::shared_ptr<G4Hdf5FileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
inline const std::vector<Hdf5NtupleDescription*>&
G4Hdf5NtupleManager::GetNtupleDescriptionVector() const
@@ -115,7 +115,7 @@ inline G4bool G4TNtupleManager<toolx::hdf5::ntuple, G4Hdf5File>::FillNtupleTColu
// get ntuple
auto ntuple = GetNtupleInFunction(ntupleId, "FillNtupleTColumn");
if ( ! ntuple ) return false;
if (ntuple == nullptr) return false;
// get generic column
auto index = columnId - fFirstNtupleColumnId;
@@ -129,7 +129,7 @@ inline G4bool G4TNtupleManager<toolx::hdf5::ntuple, G4Hdf5File>::FillNtupleTColu
// get column and check its type
auto column = dynamic_cast<toolx::hdf5::ntuple::column_string* >(icolumn);
if ( ! column ) {
if (column == nullptr) {
G4Analysis::Warn(
"Column type does not match: ntupleId " + to_string(ntupleId) +
" columnId " + to_string(columnId) + " value " + value,
source/analysis/hdf5/include/G4Hdf5RFileManager.hh
+3 -3
View File
@@ -47,12 +47,12 @@ class G4Hdf5RFileManager : public G4VRFileManager
public:
explicit G4Hdf5RFileManager(const G4AnalysisManagerState& state);
G4Hdf5RFileManager() = delete;
virtual ~G4Hdf5RFileManager() = default;
~G4Hdf5RFileManager() override = default;
virtual G4String GetFileType() const final { return "hdf5"; }
G4String GetFileType() const final { return "hdf5"; }
// Methods from base class
virtual void CloseFiles() final;
void CloseFiles() final;
// Get methods
G4Hdf5File* GetRFile(const G4String& fileName, G4bool isPerThread);
source/analysis/hdf5/include/G4Hdf5RNtupleManager.hh
+8 -5
View File
@@ -38,6 +38,7 @@
#include "toolx/hdf5/ntuple"
#include <string_view>
#include <utility>
class G4Hdf5RFileManager;
@@ -48,16 +49,16 @@ class G4Hdf5RNtupleManager : public G4TRNtupleManager<toolx::hdf5::ntuple>
public:
explicit G4Hdf5RNtupleManager(const G4AnalysisManagerState& state);
G4Hdf5RNtupleManager() = delete;
virtual ~G4Hdf5RNtupleManager() = default;
~G4Hdf5RNtupleManager() override = default;
private:
// Set methods
void SetFileManager(std::shared_ptr<G4Hdf5RFileManager> fileManager);
// Methods from the base class
virtual G4int ReadNtupleImpl(const G4String& ntupleName, const G4String& fileName,
const G4String& dirName, G4bool isUserFileName) final;
virtual G4bool GetTNtupleRow(G4TRNtupleDescription<toolx::hdf5::ntuple>* ntupleDescription) final;
G4int ReadNtupleImpl(const G4String& ntupleName, const G4String& fileName,
const G4String& dirName, G4bool isUserFileName) final;
G4bool GetTNtupleRow(G4TRNtupleDescription<toolx::hdf5::ntuple>* ntupleDescription) final;
// Static data members
static constexpr std::string_view fkClass { "G4Hdf5RNtupleManager" };
@@ -70,7 +71,9 @@ class G4Hdf5RNtupleManager : public G4TRNtupleManager<toolx::hdf5::ntuple>
inline void
G4Hdf5RNtupleManager::SetFileManager(std::shared_ptr<G4Hdf5RFileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
#endif
source/analysis/hdf5/src/G4Hdf5AnalysisManager.cc
+6 -68
View File
@@ -75,22 +75,20 @@ G4Hdf5AnalysisManager::G4Hdf5AnalysisManager()
#endif
#endif
if ( ! G4Threading::IsWorkerThread() ) fgMasterInstance = this;
// File manager
fFileManager = std::make_shared<G4Hdf5FileManager>(fState);
SetFileManager(fFileManager);
auto fileManager = std::make_shared<G4Hdf5FileManager>(fState);
SetFileManager(fileManager);
// Ntuple file manager
fNtupleFileManager = std::make_shared<G4Hdf5NtupleFileManager>(fState);
fNtupleFileManager->SetFileManager(fFileManager);
SetNtupleFileManager(fNtupleFileManager);
fNtupleFileManager->SetFileManager(fileManager);
fNtupleFileManager->SetBookingManager(fNtupleBookingManager);
}
//_____________________________________________________________________________
G4Hdf5AnalysisManager::~G4Hdf5AnalysisManager()
{
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
fgIsInstance = false;
}
@@ -101,79 +99,19 @@ G4Hdf5AnalysisManager::~G4Hdf5AnalysisManager()
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::OpenFileImpl(const G4String& fileName)
{
// Create ntuple manager(s)
// and set it to base class which takes then their ownership
SetNtupleManager(fNtupleFileManager->CreateNtupleManager());
auto result = true;
G4AutoLock lock(&openFileMutex);
result &= fFileManager->OpenFile(fileName);
result &= fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
auto result = G4ToolsAnalysisManager::OpenFileImpl(fileName);
lock.unlock();
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteImpl()
{
auto result = true;
Message(kVL4, "write", "files");
if ( G4Threading::IsWorkerThread() ) {
result &= G4ToolsAnalysisManager::Merge();
}
else {
// Open all files registered with objects
fFileManager->OpenFiles();
// Write all histograms/profile on master
result &= G4ToolsAnalysisManager::WriteImpl();
}
// Write ASCII if activated
if ( IsAscii() ) {
result &= WriteAscii(fFileManager->GetFileName());
}
Message(kVL3, "write", "files", "", result);
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::CloseFileImpl(G4bool reset)
{
auto result = true;
G4AutoLock lock(&closeFileMutex);
result &= fFileManager->CloseFiles();
if ( reset ) {
// reset data
result = ResetImpl();
if ( ! result ) {
Warn("Resetting data failed", fkClass, "OpenDirectory");
}
}
result &= fNtupleFileManager->ActionAtCloseFile(reset);
auto result = G4ToolsAnalysisManager::CloseFileImpl(reset);
lock.unlock();
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::ResetImpl()
{
auto result = true;
result &= G4ToolsAnalysisManager::ResetImpl();
if ( fNtupleFileManager != nullptr ) {
result &= fNtupleFileManager->Reset();
}
return result;
}
source/analysis/hdf5/src/G4Hdf5AnalysisManager.cc.newLocking
+185
View File
@@ -0,0 +1,185 @@
//
// ********************************************************************
// * 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, 20/07/2017 (ivana@ipno.in2p3.fr)
#include "G4Hdf5AnalysisManager.hh"
#include "G4Hdf5FileManager.hh"
#include "G4Hdf5NtupleFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4ThreadLocalSingleton.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
using namespace G4Analysis;
// mutex in a file scope
namespace {
//Mutex to lock master manager when opening a file
G4Mutex openFileMutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when writing sata
G4Mutex writeMutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when closing a file
G4Mutex closeFileMutex = G4MUTEX_INITIALIZER;
}
// G4Hdf5AnalysisManager* G4Hdf5AnalysisManager::fgMasterInstance = nullptr;
// G4ThreadLocal G4bool G4Hdf5AnalysisManager::fgIsInstance = false;
//_____________________________________________________________________________
G4Hdf5AnalysisManager* G4Hdf5AnalysisManager::Instance()
{
static G4ThreadLocalSingleton<G4Hdf5AnalysisManager> instance;
fgIsInstance = true;
return instance.Instance();
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::IsInstance()
{
return fgIsInstance;
}
//_____________________________________________________________________________
G4Hdf5AnalysisManager::G4Hdf5AnalysisManager()
: G4ToolsAnalysisManager("Hdf5")
{
// #ifdef G4MULTITHREADED
// #ifndef H5_HAVE_THREADSAFE
// G4Exception("G4Hdf5AnalysisManager::G4Hdf5AnalysisManager",
// "Analysis_F001", FatalException,
// "Your HDF5 lib is not built with H5_HAVE_THREADSAFE.");
// #endif
// #endif
if ( ! G4Threading::IsWorkerThread() ) fgMasterInstance = this;
// File manager
fFileManager = std::make_shared<G4Hdf5FileManager>(fState);
SetFileManager(fFileManager);
// Ntuple file manager
fNtupleFileManager = std::make_shared<G4Hdf5NtupleFileManager>(fState);
fNtupleFileManager->SetFileManager(fFileManager);
fNtupleFileManager->SetBookingManager(fNtupleBookingManager);
}
//_____________________________________________________________________________
G4Hdf5AnalysisManager::~G4Hdf5AnalysisManager()
{
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
fgIsInstance = false;
}
//
// protected methods
//
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::OpenFileImpl(const G4String& fileName)
{
// Create ntuple manager(s)
// and set it to base class which takes then their ownership
SetNtupleManager(fNtupleFileManager->CreateNtupleManager());
auto result = true;
G4AutoLock lock(&openFileMutex);
result &= fFileManager->OpenFile(fileName);
result &= fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
lock.unlock();
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::WriteImpl()
{
auto result = true;
Message(kVL4, "write", "files");
G4AutoLock lock(&writeMutex);
if ( G4Threading::IsWorkerThread() ) {
result &= G4ToolsAnalysisManager::Merge();
}
else {
// Open all files registered with objects
fFileManager->OpenFiles();
// Write all histograms/profile on master
result &= G4ToolsAnalysisManager::WriteImpl();
}
// Write ASCII if activated
if ( IsAscii() ) {
result &= WriteAscii(fFileManager->GetFileName());
}
lock.unlock();
Message(kVL3, "write", "files", "", result);
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::CloseFileImpl(G4bool reset)
{
auto result = true;
G4AutoLock lock(&closeFileMutex);
result &= fFileManager->CloseFiles();
if ( reset ) {
// reset data
result = ResetImpl();
if ( ! result ) {
Warn("Resetting data failed", fkClass, "OpenDirectory");
}
}
result &= fNtupleFileManager->ActionAtCloseFile(reset);
lock.unlock();
return result;
}
//_____________________________________________________________________________
G4bool G4Hdf5AnalysisManager::ResetImpl()
{
auto result = true;
result &= G4ToolsAnalysisManager::ResetImpl();
if ( fNtupleFileManager != nullptr ) {
result &= fNtupleFileManager->Reset();
}
return result;
}
source/analysis/hdf5/src/G4Hdf5FileManager.cc
+12 -13
View File
@@ -67,7 +67,7 @@ hid_t G4Hdf5FileManager::CreateDirectory(hid_t& file,
// Method for both histograms and ntuples directories.
// return if no file provided
if ( file < 0 ) return false;
if (file < 0) return kInvalidId;
// use default directory name if not provided
auto newDirectoryName = directoryName;
@@ -110,11 +110,12 @@ hid_t G4Hdf5FileManager::CreateDirectory(hid_t& file,
G4String G4Hdf5FileManager::GetNtupleFileName(Hdf5NtupleDescription* ntupleDescription)
{
// get ntuple file name
auto ntupleFileName = ntupleDescription->fFileName;
if ( ntupleFileName.size() ) {
auto ntupleFileName = ntupleDescription->GetFileName();
if (ntupleFileName.size() != 0u) {
// update filename per object per thread
ntupleFileName = GetTnFileName(ntupleFileName, GetFileType());
} else {
}
else {
// get default file name
ntupleFileName = GetFullFileName();
}
@@ -227,24 +228,22 @@ G4bool G4Hdf5FileManager::CreateNtupleFile(
if (! file) {
file = CreateTFile(ntupleFileName);
}
ntupleDescription->fFile = file;
ntupleDescription->SetFile(file);
return (ntupleDescription->fFile != nullptr);
return (ntupleDescription->GetFile() != nullptr);
}
//_____________________________________________________________________________
G4bool G4Hdf5FileManager::CloseNtupleFile(
Hdf5NtupleDescription* ntupleDescription)
{
// Do nothing if there is no file
if ( ntupleDescription->fFile == nullptr ) return true;
// Ntuple files will be closed with CloseFiles() calls
ntupleDescription->fFile.reset();
// Notify not empty file
auto ntupleFileName = GetNtupleFileName(ntupleDescription);
auto result = SetIsEmpty(ntupleFileName, ! ntupleDescription->fHasFill);
auto result = SetIsEmpty(ntupleFileName, ! ntupleDescription->GetHasFill());
// Ntuple files are registered in file manager map.
// they will be closed with CloseFiles() calls
ntupleDescription->GetFile().reset();
return result;
}
source/analysis/hdf5/src/G4Hdf5NtupleFileManager.cc
+4 -27
View File
@@ -43,24 +43,6 @@ G4Hdf5NtupleFileManager::G4Hdf5NtupleFileManager(const G4AnalysisManagerState& s
: G4VNtupleFileManager(state, "hdf5")
{}
//
// private methods
//
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::CloseNtupleFiles()
{
// Close ntuple files
auto result = true;
auto ntupleVector = fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntupleDescription : ntupleVector) {
result &= fFileManager->CloseNtupleFile(ntupleDescription);
}
return result;
}
//
// public methods
//
@@ -95,19 +77,14 @@ G4bool G4Hdf5NtupleFileManager::ActionAtWrite()
}
//_____________________________________________________________________________
G4bool G4Hdf5NtupleFileManager::ActionAtCloseFile(G4bool reset)
G4bool G4Hdf5NtupleFileManager::ActionAtCloseFile()
{
auto result = true;
// Close ntuple files
result &= CloseNtupleFiles();
if ( ! reset ) {
// The ntuples must be always reset when closing file)
result = Reset();
if ( ! result ) {
Warn("Resetting data failed", fkClass, "ActionAtCloseFile");
}
auto ntupleVector = fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntupleDescription : ntupleVector) {
result &= fFileManager->CloseNtupleFile(ntupleDescription);
}
return result;
source/analysis/hdf5/src/G4Hdf5NtupleManager.cc
+18 -10
View File
@@ -52,7 +52,7 @@ void G4Hdf5NtupleManager::CreateTNtuple(
// return with or without warning otherwise
// Get ntuple file from ntuple description
auto ntupleFile = ntupleDescription->fFile;
auto ntupleFile = ntupleDescription->GetFile();
if (! ntupleFile) {
ntupleFile = fFileManager->GetFile();
}
@@ -71,13 +71,21 @@ void G4Hdf5NtupleManager::CreateTNtuple(
// auto compressionLevel = fState.GetCompressionLevel();
auto compressionLevel = 0;
// create ntuple
ntupleDescription->fNtuple
= new toolx::hdf5::ntuple(
G4cout, directory, ntupleDescription->fNtupleBooking,
compressionLevel, basketSize);
// Update ntuple name if cycle >0
auto ntupleBooking = ntupleDescription->GetNtupleBooking();
if (GetCycle() > 0) {
auto newNtupleName = ntupleDescription->GetNtupleBooking().name();
newNtupleName.append("_v");
newNtupleName.append(std::to_string(GetCycle()));
ntupleBooking.set_name(newNtupleName);
}
fNtupleVector.push_back(ntupleDescription->fNtuple);
// create ntuple
ntupleDescription->SetNtuple(
new toolx::hdf5::ntuple(
G4cout, directory, ntupleBooking, compressionLevel, basketSize));
fNtupleVector.push_back(ntupleDescription->GetNtuple());
}
//_____________________________________________________________________________
@@ -85,7 +93,7 @@ void G4Hdf5NtupleManager::CreateTNtupleFromBooking(
Hdf5NtupleDescription* ntupleDescription)
{
// Create file if file name per object is set
if ( ntupleDescription->fFileName.size() ) {
if (ntupleDescription->GetFileName().size() != 0u) {
fFileManager->CreateNtupleFile(ntupleDescription);
}
@@ -98,8 +106,8 @@ void G4Hdf5NtupleManager::FinishTNtuple(
Hdf5NtupleDescription* ntupleDescription,
G4bool /*fromBooking*/)
{
if ( ! ntupleDescription->fNtuple ) {
// Create ntuple from booking if file is open, do nothing otherwise
if (ntupleDescription->GetNtuple() == nullptr) {
// Create ntuple from booking if file is open, do nothing otherwise
CreateTNtuple(ntupleDescription, false);
}
source/analysis/hdf5/src/G4Hdf5RFileManager.cc
+5 -8
View File
@@ -90,10 +90,8 @@ hid_t G4Hdf5RFileManager::OpenDirectory(hid_t file, const G4String& directoryNam
Warn("Cannot open directory " + directoryName, fkClass, "OpenDirectory");
return kInvalidId;
}
else {
Message(kVL2, "open", "read directory", directoryName);
return directory;
}
Message(kVL2, "open", "read directory", directoryName);
return directory;
}
//_____________________________________________________________________________
@@ -104,7 +102,7 @@ hid_t G4Hdf5RFileManager::GetRDirectory(const G4String& directoryType,
{
// Get or open a file
auto rfile = GetRFile(fileName, isPerThread);
if ( ! rfile ) {
if (rfile == nullptr) {
// Try to open it if not found in the map
if ( OpenRFile(fileName, isPerThread) < 0 ) return kInvalidId;
rfile = GetRFile(fileName, isPerThread);
@@ -158,11 +156,10 @@ G4Hdf5File* G4Hdf5RFileManager::GetRFile(const G4String& fileName,
G4String name = GetFullFileName(fileName, isPerThread);
auto it = fRFiles.find(name);
if ( it != fRFiles.end() )
if (it != fRFiles.end()) {
return &(it->second);
else {
return nullptr;
}
return nullptr;
}
//_____________________________________________________________________________