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/root/include/G4RootAnalysisManager.hh
+6 -17
View File
@@ -36,7 +36,6 @@
#include "globals.hh"
#include "tools/wroot/ntuple"
#include "tools/histo/hmpi"
#include <memory>
#include <string_view>
@@ -59,7 +58,7 @@ class G4RootAnalysisManager : public G4ToolsAnalysisManager
friend class G4ThreadLocalSingleton<G4RootAnalysisManager>;
public:
virtual ~G4RootAnalysisManager();
~G4RootAnalysisManager() override;
// Static methods
static G4RootAnalysisManager* Instance();
@@ -76,29 +75,19 @@ class G4RootAnalysisManager : public G4ToolsAnalysisManager
std::vector<tools::wroot::ntuple*>::const_iterator EndConstNtuple() const;
// MT/MPI
virtual void SetNtupleMerging(G4bool mergeNtuples,
G4int nofReducedNtupleFiles = 0) override;
virtual void SetNtupleRowWise(G4bool rowWise, G4bool rowMode = true) override;
virtual void SetBasketSize(unsigned int basketSize) override;
virtual void SetBasketEntries(unsigned int basketEntries) override;
protected:
// virtual methods from base class
virtual G4bool OpenFileImpl(const G4String& fileName) override;
virtual G4bool WriteImpl() override;
virtual G4bool CloseFileImpl(G4bool reset) override;
virtual G4bool ResetImpl() override;
virtual G4bool IsOpenFileImpl() const final;
void SetNtupleMerging(G4bool mergeNtuples, G4int nofReducedNtupleFiles = 0) override;
void SetNtupleRowWise(G4bool rowWise, G4bool rowMode = true) override;
void SetBasketSize(unsigned int basketSize) override;
void SetBasketEntries(unsigned int basketEntries) override;
private:
G4RootAnalysisManager();
// Static data members
inline static G4RootAnalysisManager* fgMasterInstance { nullptr };
inline static G4ThreadLocal G4bool fgIsInstance { false };
static constexpr std::string_view fkClass { "G4RootAnalysisManager" };
// data members
// Data members
std::shared_ptr<G4RootFileManager> fFileManager { nullptr };
std::shared_ptr<G4RootNtupleFileManager> fNtupleFileManager { nullptr };
};
source/analysis/root/include/G4RootAnalysisManager.icc
-7
View File
@@ -28,13 +28,6 @@
#include "G4RootNtupleFileManager.hh"
#include "G4RootFileManager.hh"
//_____________________________________________________________________________
inline
G4bool G4RootAnalysisManager::IsOpenFileImpl() const
{
return fFileManager->IsOpenFile();
}
//_____________________________________________________________________________
inline
tools::wroot::ntuple* G4RootAnalysisManager::GetNtuple() const
source/analysis/root/include/G4RootAnalysisReader.hh
+2 -2
View File
@@ -51,7 +51,7 @@ class G4RootAnalysisReader : public G4ToolsAnalysisReader
friend class G4ThreadLocalSingleton<G4RootAnalysisReader>;
public:
virtual ~G4RootAnalysisReader();
~G4RootAnalysisReader() override;
// Static methods
static G4RootAnalysisReader* Instance();
@@ -65,7 +65,7 @@ class G4RootAnalysisReader : public G4ToolsAnalysisReader
G4RootAnalysisReader();
// // Virtual methods from base class
virtual G4bool CloseFilesImpl(G4bool reset) final;
G4bool CloseFilesImpl(G4bool reset) final;
private:
// Static data members
source/analysis/root/include/G4RootFileDef.hh
+1 -2
View File
@@ -24,8 +24,7 @@
// ********************************************************************
//
// Manager class for Root ntuples.
// It implements functions specific to Root ntuples in sequential mode.
// The tuple for root file including its directories
//
// Author: Ivana Hrivnacova, 18/06/2013 (ivana@ipno.in2p3.fr)
source/analysis/root/include/G4RootFileManager.hh
+9 -8
View File
@@ -55,16 +55,17 @@ class G4RootFileManager : public G4VTFileManager<G4RootFile>
public:
explicit G4RootFileManager(const G4AnalysisManagerState& state);
G4RootFileManager() = delete;
virtual ~G4RootFileManager() = default;
~G4RootFileManager() override = default;
using G4BaseFileManager::GetNtupleFileName;
using G4VTFileManager<G4RootFile>::WriteFile;
using G4VTFileManager<G4RootFile>::CloseFile;
// Methods to manipulate file from base classes
virtual G4bool OpenFile(const G4String& fileName) final;
G4bool OpenFile(const G4String& fileName) final;
virtual G4String GetFileType() const final { return "root"; }
G4String GetFileType() const final { return "root"; }
G4bool HasCycles() const final { return true; }
// Specific methods for files per objects
std::shared_ptr<G4RootFile> CreateNtupleFile(RootNtupleDescription* ntupleDescription,
@@ -72,8 +73,8 @@ class G4RootFileManager : public G4VTFileManager<G4RootFile>
std::shared_ptr<G4RootFile> GetNtupleFile(RootNtupleDescription* ntupleDescription,
G4bool perThread = true,
G4int mainNumber = -1) const;
G4bool WriteNtupleFile(RootNtupleDescription* ntupleDescription);
G4bool CloseNtupleFile(RootNtupleDescription* ntupleDescription);
G4bool CloseNtupleFile(RootNtupleDescription* ntupleDescription,
G4int mainNumber = -1);
// Set methods
void SetBasketSize(unsigned int basketSize);
@@ -85,9 +86,9 @@ class G4RootFileManager : public G4VTFileManager<G4RootFile>
protected:
// Methods derived from templated base class
virtual std::shared_ptr<G4RootFile> CreateFileImpl(const G4String& fileName) final;
virtual G4bool WriteFileImpl(std::shared_ptr<G4RootFile> file) final;
virtual G4bool CloseFileImpl(std::shared_ptr<G4RootFile> file) final;
std::shared_ptr<G4RootFile> CreateFileImpl(const G4String& fileName) final;
G4bool WriteFileImpl(std::shared_ptr<G4RootFile> file) final;
G4bool CloseFileImpl(std::shared_ptr<G4RootFile> file) final;
private:
// Methods
source/analysis/root/include/G4RootHnFileManager.hh
+3 -3
View File
@@ -45,13 +45,13 @@ class G4RootHnFileManager : public G4VTHnFileManager<HT>
explicit G4RootHnFileManager(G4RootFileManager* fileManger)
: G4VTHnFileManager<HT>(), fFileManager(fileManger) {}
G4RootHnFileManager() = delete;
virtual ~G4RootHnFileManager() = default;
~G4RootHnFileManager() 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/root/include/G4RootHnFileManager.icc
+2 -2
View File
@@ -53,11 +53,11 @@ G4bool G4RootHnFileManager<HT>::WriteExtra(
// TO DO
// rfile->add_ziper('Z', toolx::compress_buffer);
// rfile->set_compression(fState.GetCompressionLevel());
if ( ! rfile ) return false;
if (rfile == nullptr) return false;
// no directory supported in this mode
auto hdirectory = &(rfile->dir());
if ( ! hdirectory ) return false;
if (hdirectory == nullptr) return false;
// write histo
result &= Write(hdirectory, ht, htName);
source/analysis/root/include/G4RootHnRFileManager.hh
+4 -4
View File
@@ -52,15 +52,15 @@ class G4RootHnRFileManager : public G4VTHnRFileManager<HT>
explicit G4RootHnRFileManager(G4RootRFileManager* rfileManger)
: G4VTHnRFileManager<HT>(), fRFileManager(rfileManger) {}
G4RootHnRFileManager() = delete;
virtual ~G4RootHnRFileManager() = default;
~G4RootHnRFileManager() override = default;
// Methods for reading 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
std::tuple<tools::rroot::buffer*, tools::rroot::TDirectory*> GetBuffer(
tools::rroot::buffer* GetBuffer(
const G4String& fileName,
const G4String& dirName,
const G4String& name);
source/analysis/root/include/G4RootHnRFileManager.icc
+35 -28
View File
@@ -27,6 +27,7 @@
// Author: Ivana Hrivnacova, 26/08/2021 (ivana@ipno.in2p3.fr)
#include "G4AnalysisUtilities.hh"
#include "G4RootRFileDef.hh"
#include "tools/rroot/file"
#include "tools/rroot/rall"
@@ -35,8 +36,7 @@
//_____________________________________________________________________________
template <typename HT>
inline
std::tuple<tools::rroot::buffer*, tools::rroot::TDirectory*>
G4RootHnRFileManager<HT>::GetBuffer(
tools::rroot::buffer* G4RootHnRFileManager<HT>::GetBuffer(
const G4String& fileName, const G4String& dirName, const G4String& objectName)
{
// Get buffer for reading histogram or profile specified by objectNmae
@@ -47,53 +47,62 @@ G4RootHnRFileManager<HT>::GetBuffer(
G4bool isPerThread = false;
// Get or open a file
auto rfile = fRFileManager->GetRFile(fileName, isPerThread);
if ( ! rfile ) {
auto rfileTuple = fRFileManager->GetRFile(fileName, isPerThread);
if (rfileTuple == nullptr) {
if ( ! fRFileManager->OpenRFile(fileName, isPerThread) ) {
return std::tuple(nullptr, nullptr);
return nullptr;
}
rfileTuple = fRFileManager->GetRFile(fileName, isPerThread);
}
auto rfile = std::get<0>(*rfileTuple);
// Get or open a directory if dirName is defined
tools::rroot::TDirectory* histoDirectory = nullptr;
if ( histoDirectory == nullptr ) {
// Retrieve directory only once as analysis manager supports only
// 1 histo directory par file)
if ( ! dirName.empty() ) {
histoDirectory = tools::rroot::find_dir(rfile->dir(), dirName);
if ( histoDirectory != nullptr ) {
std::get<1>(*rfileTuple) = histoDirectory;
}
else {
G4Analysis::Warn(
"Directory " + dirName + " not found in file " + fileName + ".",
fkClass, "ReadNtupleImpl");
return nullptr;
}
}
rfile = fRFileManager->GetRFile(fileName, isPerThread);
}
// Get key
tools::rroot::key* key = nullptr;
tools::rroot::TDirectory* newDir = nullptr;
if ( ! dirName.empty() ) {
newDir = tools::rroot::find_dir(rfile->dir(), dirName);
if ( newDir ) {
key = newDir->find_key(objectName);
}
else {
G4Analysis::Warn(
"Directory " + dirName + " not found in file " + fileName + ".",
fkClass, "GetBuffer");
return std::tuple(nullptr, nullptr);
}
if ( histoDirectory != nullptr ) {
key = histoDirectory->find_key(objectName);
}
else {
key = rfile->dir().find_key(objectName);
}
if ( ! key ) {
if (key == nullptr) {
G4Analysis::Warn(
"Key " + objectName + " for Histogram/Profile not found in file " +
fileName + ", directory " + dirName, fkClass, "GetBuffer");
return std::tuple(nullptr, newDir);
return nullptr;
}
unsigned int size;
char* charBuffer = key->get_object_buffer(*rfile, size);
if ( ! charBuffer ) {
if (charBuffer == nullptr) {
G4Analysis::Warn(
"Cannot get " + objectName + " in file " + fileName,
fkClass, "GetBuffer");
return std::tuple(nullptr, newDir);
return nullptr;
}
auto verbose = false;
return std::tuple(new tools::rroot::buffer(G4cout, rfile->byte_swap(), size, charBuffer,
key->key_length(), verbose), newDir);
return new tools::rroot::buffer(G4cout, rfile->byte_swap(), size, charBuffer,
key->key_length(), verbose);
}
//_____________________________________________________________________________
@@ -148,15 +157,13 @@ HT* G4RootHnRFileManager<HT>::Read(
const G4String& htName, const G4String& fileName, const G4String& dirName,
G4bool /*isUserFileName*/)
{
auto [buffer, newDir] = GetBuffer(fileName, dirName, htName);
auto buffer = GetBuffer(fileName, dirName, htName);
if ( ! buffer ) {
delete newDir;
return nullptr;
}
auto ht = ReadT(buffer);
delete buffer;
delete newDir;
if ( ! ht ) {
G4Analysis::Warn(
source/analysis/root/include/G4RootMainNtupleManager.hh
+23 -7
View File
@@ -33,13 +33,14 @@
#include "G4BaseAnalysisManager.hh"
#include "G4NtupleBookingManager.hh"
#include "G4TNtupleDescription.hh"
#include "G4RootNtupleManager.hh"
#include "G4RootFileDef.hh"
#include "G4RootNtupleManager.hh"
#include "G4TNtupleDescription.hh"
#include "globals.hh"
#include <vector>
#include <string_view>
#include <utility>
#include <vector>
class G4RootFileManager;
class G4RootNtupleManager;
@@ -53,6 +54,7 @@ class ntuple;
// Types alias
using RootNtupleDescription = G4TNtupleDescription<tools::wroot::ntuple, G4RootFile>;
using RootMainNtupleDescription = std::pair<RootNtupleDescription*, std::shared_ptr<G4RootFile>>;
class G4RootMainNtupleManager : public G4BaseAnalysisManager
{
@@ -66,7 +68,9 @@ class G4RootMainNtupleManager : public G4BaseAnalysisManager
G4bool rowWise, G4int fileNumber,
const G4AnalysisManagerState& state);
G4RootMainNtupleManager() = delete;
virtual ~G4RootMainNtupleManager() = default;
~G4RootMainNtupleManager() override = default;
void CreateNtuplesFromBooking();
protected:
// Methods to manipulate ntuples
@@ -80,6 +84,10 @@ class G4RootMainNtupleManager : public G4BaseAnalysisManager
void SetRowWise(G4bool rowWise);
std::shared_ptr<G4RootFile> GetNtupleFile(RootNtupleDescription* ntupleDescription) const;
// New cycle option
void SetNewCycle(G4bool value);
G4bool GetNewCycle() const;
// Access functions
const std::vector<tools::wroot::ntuple*>& GetNtupleVector()
{ return fNtupleVector; }
@@ -96,12 +104,15 @@ class G4RootMainNtupleManager : public G4BaseAnalysisManager
G4bool fRowWise;
G4int fFileNumber;
std::vector<tools::wroot::ntuple*> fNtupleVector;
std::vector<RootNtupleDescription*> fNtupleDescriptionVector;
std::vector<RootMainNtupleDescription> fNtupleDescriptionVector;
G4bool fNewCycle { false };
};
inline void G4RootMainNtupleManager::SetFileManager(
std::shared_ptr<G4RootFileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
inline void G4RootMainNtupleManager::SetRowWise(G4bool rowWise)
{ fRowWise = rowWise; }
@@ -109,5 +120,10 @@ inline void G4RootMainNtupleManager::SetRowWise(G4bool rowWise)
inline unsigned int G4RootMainNtupleManager::GetBasketEntries() const
{ return fNtupleBuilder->GetBasketEntries(); }
#endif
inline void G4RootMainNtupleManager::SetNewCycle(G4bool value)
{ fNewCycle = value; }
inline G4bool G4RootMainNtupleManager::GetNewCycle() const
{ return fNewCycle; }
#endif
source/analysis/root/include/G4RootNtupleFileManager.hh
+16 -20
View File
@@ -35,6 +35,7 @@
#include "G4VNtupleFileManager.hh"
#include <string_view>
#include <utility>
class G4RootFileManager;
class G4RootNtupleManager;
@@ -42,12 +43,6 @@ class G4RootPNtupleManager;
class G4VNtupleManager;
class G4NtupleBookingManager;
enum class G4NtupleMergeMode {
kNone,
kMain,
kSlave
};
class G4RootNtupleFileManager : public G4VNtupleFileManager
{
friend class G4RootMpiNtupleFileManager;
@@ -55,27 +50,26 @@ class G4RootNtupleFileManager : public G4VNtupleFileManager
public:
explicit G4RootNtupleFileManager(const G4AnalysisManagerState& state);
G4RootNtupleFileManager() = delete;
virtual ~G4RootNtupleFileManager();
~G4RootNtupleFileManager() override;
// MT/MPI
virtual void SetNtupleMerging(G4bool mergeNtuples,
G4int nofReducedNtupleFiles = 0) override;
virtual void SetNtupleRowWise(G4bool rowWise, G4bool rowMode = true) override;
virtual void SetBasketSize(unsigned int basketSize) override;
virtual void SetBasketEntries(unsigned int basketEntries) override;
void SetNtupleMerging(G4bool mergeNtuples, G4int nofReducedNtupleFiles = 0) override;
void SetNtupleRowWise(G4bool rowWise, G4bool rowMode = true) override;
void SetBasketSize(unsigned int basketSize) override;
void SetBasketEntries(unsigned int basketEntries) override;
// virtual methods from base class
virtual G4bool ActionAtOpenFile(const G4String& fileName) override;
virtual G4bool ActionAtWrite() override;
virtual G4bool ActionAtCloseFile(G4bool reset) override;
virtual G4bool Reset() override;
virtual G4bool IsNtupleMergingSupported() const override;
G4bool ActionAtOpenFile(const G4String& fileName) override;
G4bool ActionAtWrite() override;
G4bool ActionAtCloseFile() override;
G4bool Reset() override;
G4bool IsNtupleMergingSupported() const override;
virtual std::shared_ptr<G4VNtupleManager> CreateNtupleManager() override;
std::shared_ptr<G4VNtupleManager> CreateNtupleManager() override;
void SetFileManager(std::shared_ptr<G4RootFileManager> fileManager);
G4NtupleMergeMode GetMergeMode() const;
G4NtupleMergeMode GetMergeMode() const override;
std::shared_ptr<G4RootNtupleManager> GetNtupleManager() const;
private:
@@ -102,7 +96,9 @@ class G4RootNtupleFileManager : public G4VNtupleFileManager
inline void G4RootNtupleFileManager::SetFileManager(
std::shared_ptr<G4RootFileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
inline G4NtupleMergeMode G4RootNtupleFileManager::GetMergeMode() const
{ return fNtupleMergeMode; }
source/analysis/root/include/G4RootNtupleManager.hh
+9 -9
View File
@@ -70,17 +70,14 @@ class G4RootNtupleManager : public G4TNtupleManager<tools::wroot::ntuple,
G4int nofMainManagers, G4int nofReducedFiles,
G4bool rowWise, G4bool rowMode);
G4RootNtupleManager() = delete;
virtual ~G4RootNtupleManager() = default;
~G4RootNtupleManager() override = default;
private:
private:
// Methods from the templated base class
virtual void CreateTNtupleFromBooking(
RootNtupleDescription* ntupleDescription) final;
virtual void FinishTNtuple(
RootNtupleDescription* ntupleDescription,
G4bool fromBooking) final;
virtual G4bool Reset() final;
virtual void Clear() final;
void CreateTNtupleFromBooking(RootNtupleDescription* ntupleDescription) final;
void FinishTNtuple(RootNtupleDescription* ntupleDescription, G4bool fromBooking) final;
G4bool Reset() final;
void Clear() final;
virtual G4bool Merge();
// Set functions
@@ -88,6 +85,9 @@ class G4RootNtupleManager : public G4TNtupleManager<tools::wroot::ntuple,
void SetNtupleFile(std::shared_ptr<G4RootFile> file);
void SetNtupleRowWise(G4bool rowWise, G4bool rowMode);
// New cycle option
void SetNewCycle(G4bool value) final;
// Access functions
const std::vector<RootNtupleDescription*>& GetNtupleDescriptionVector() const;
std::shared_ptr<G4RootMainNtupleManager> GetMainNtupleManager(G4int index) const;
source/analysis/root/include/G4RootNtupleManager.icc
+2 -2
View File
@@ -56,7 +56,7 @@ inline G4bool G4TNtupleManager<tools::wroot::ntuple, G4RootFile>::FillNtupleTCol
}
auto ntuple = GetNtupleInFunction(ntupleId, "FillNtupleTColumn");
if ( ! ntuple ) return false;
if (ntuple == nullptr) return false;
auto index = columnId - fFirstNtupleColumnId;
if ( index < 0 || index >= G4int(ntuple->columns().size()) ) {
@@ -69,7 +69,7 @@ inline G4bool G4TNtupleManager<tools::wroot::ntuple, G4RootFile>::FillNtupleTCol
auto icolumn = ntuple->columns()[index];
auto column = dynamic_cast<tools::wroot::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/root/include/G4RootPNtupleDescription.hh
+54 -9
View File
@@ -50,20 +50,65 @@ class ntuple;
using RootNtupleDescription = G4TNtupleDescription<tools::wroot::ntuple, G4RootFile>;
struct G4RootPNtupleDescription
class G4RootPNtupleDescription
{
G4RootPNtupleDescription(G4NtupleBooking* g4NtupleBooking)
: fDescription(g4NtupleBooking) {}
public:
G4RootPNtupleDescription(G4NtupleBooking* g4NtupleBooking)
: fDescription(g4NtupleBooking) {}
~G4RootPNtupleDescription()
~G4RootPNtupleDescription()
{
if ( fDescription.fIsNtupleOwner ) delete fNtuple;
if ( fDescription.GetIsNtupleOwner() ) delete fNtuple;
}
RootNtupleDescription fDescription;
tools::wroot::imt_ntuple* fNtuple { nullptr };
tools::wroot::base_pntuple* fBasePNtuple { nullptr };
std::vector<tools::wroot::branch*> fMainBranches;
// Set methods
void SetNtuple(tools::wroot::imt_ntuple* intuple);
void SetBasePNtuple(tools::wroot::base_pntuple* basePNtuple);
void Reset();
// Get methods
RootNtupleDescription& GetDescription();
tools::wroot::imt_ntuple* GetNtuple() const;
tools::wroot::base_pntuple* GetBasePNtuple() const;
std::vector<tools::wroot::branch*>& GetMainBranches();
private:
RootNtupleDescription fDescription;
tools::wroot::imt_ntuple* fNtuple { nullptr };
tools::wroot::base_pntuple* fBasePNtuple { nullptr };
std::vector<tools::wroot::branch*> fMainBranches;
};
// inline function
inline void G4RootPNtupleDescription::SetNtuple(
tools::wroot::imt_ntuple* intuple)
{ fNtuple = intuple; }
inline void G4RootPNtupleDescription::SetBasePNtuple(
tools::wroot::base_pntuple* basePNtuple)
{ fBasePNtuple = basePNtuple; }
inline void G4RootPNtupleDescription::Reset()
{
if ( fDescription.GetIsNtupleOwner() ) delete fNtuple;
fNtuple = nullptr;
}
inline RootNtupleDescription&
G4RootPNtupleDescription::GetDescription()
{ return fDescription; }
inline tools::wroot::imt_ntuple*
G4RootPNtupleDescription::GetNtuple() const
{ return fNtuple; }
inline tools::wroot::base_pntuple*
G4RootPNtupleDescription::GetBasePNtuple() const
{ return fBasePNtuple; }
inline std::vector<tools::wroot::branch*>&
G4RootPNtupleDescription::GetMainBranches()
{ return fMainBranches; }
#endif
source/analysis/root/include/G4RootPNtupleManager.hh
+35 -22
View File
@@ -32,6 +32,7 @@
#define G4RootPNtupleManager_h 1
#include "G4BaseNtupleManager.hh"
#include "G4RootMainNtupleManager.hh"
#include "G4RootPNtupleDescription.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
@@ -57,20 +58,25 @@ class imt_ntuple;
class mutex : public virtual tools::wroot::imutex {
using parent = tools::wroot::imutex;
public:
virtual bool lock() {
bool lock() override
{
// G4cout << "!!! Mutex lock" << G4endl;
m_mutex.lock();
return true;}
virtual bool unlock() {
return true;
}
bool unlock() override
{
m_mutex.unlock();
// G4cout << "!!! Mutex unlock" << G4endl;
return true; }
return true;
}
//virtual bool trylock() {return m_mutex.trylock();}
public:
mutex(G4AutoLock& a_mutex):m_mutex(a_mutex){}
virtual ~mutex() = default;
~mutex() override = default;
protected:
mutex(const mutex& a_from):parent(a_from),m_mutex(a_from.m_mutex){}
mutex(const mutex& a_from) = default;
mutex& operator=(const mutex&){return *this;}
protected:
G4AutoLock& m_mutex;
@@ -87,19 +93,19 @@ class G4RootPNtupleManager : public G4BaseNtupleManager
std::shared_ptr<G4RootMainNtupleManager> main,
G4bool rowWise, G4bool rowMode);
G4RootPNtupleManager() = delete;
virtual ~G4RootPNtupleManager();
~G4RootPNtupleManager() override;
private:
// Methods to manipulate ntuples
void CreateNtupleFromMain(G4RootPNtupleDescription* ntupleDescription,
tools::wroot::ntuple* mainNtuple);
// void CreateNtupleFromMain(G4NtupleBooking* g4NtupleBooking,
// tools::wroot::ntuple* mainNtuple);
void CreateNtupleDescriptionsFromBooking();
void CreateNtuplesFromMain();
void CreateNtuplesIfNeeded();
// Methods to create ntuples
//
virtual G4int CreateNtuple(G4NtupleBooking* booking) final;
G4int CreateNtuple(G4NtupleBooking* booking) final;
// Methods to fill ntuples
// Methods for ntuple with id = FirstNtupleId (from base class)
@@ -109,29 +115,35 @@ class G4RootPNtupleManager : public G4BaseNtupleManager
using G4BaseNtupleManager::FillNtupleSColumn;
using G4BaseNtupleManager::AddNtupleRow;
// Methods for ntuple with id > FirstNtupleId (when more ntuples exist)
virtual G4bool FillNtupleIColumn(G4int ntupleId, G4int columnId, G4int value) final;
virtual G4bool FillNtupleFColumn(G4int ntupleId, G4int columnId, G4float value) final;
virtual G4bool FillNtupleDColumn(G4int ntupleId, G4int columnId, G4double value) final;
virtual G4bool FillNtupleSColumn(G4int ntupleId, G4int columnId,
const G4String& value) final;
virtual G4bool AddNtupleRow(G4int ntupleId) final;
G4bool FillNtupleIColumn(G4int ntupleId, G4int columnId, G4int value) final;
G4bool FillNtupleFColumn(G4int ntupleId, G4int columnId, G4float value) final;
G4bool FillNtupleDColumn(G4int ntupleId, G4int columnId, G4double value) final;
G4bool FillNtupleSColumn(G4int ntupleId, G4int columnId, const G4String& value) final;
G4bool AddNtupleRow(G4int ntupleId) final;
virtual G4bool Merge() final;
// Clear all data
virtual void Clear() final;
virtual G4bool Reset();
void Clear() final;
// Activation option
//
virtual void SetActivation(G4bool activation) final;
virtual void SetActivation(G4int ntupleId, G4bool activation) final;
virtual G4bool GetActivation(G4int ntupleId) const final;
void SetActivation(G4bool activation) final;
void SetActivation(G4int ntupleId, G4bool activation) final;
G4bool GetActivation(G4int ntupleId) const final;
// New cycle option
void SetNewCycle(G4bool value) final;
G4bool GetNewCycle() const final;
// Access methods
virtual G4int GetNofNtuples() const final;
G4int GetNofNtuples() const final;
// Set methods
void SetNtupleRowWise(G4bool rowWise, G4bool rowMode);
// List ntuples
G4bool List(std::ostream& output, G4bool onlyIfActive = true) final;
private:
G4RootPNtupleDescription*
GetNtupleDescriptionInFunction(G4int id, std::string_view function, G4bool warn = true) const;
@@ -157,6 +169,7 @@ class G4RootPNtupleManager : public G4BaseNtupleManager
G4bool fRowWise;
G4bool fRowMode;
G4bool fCreateNtuples { true };
G4bool fNewCycle { false };
};
#include "G4RootPNtupleManager.icc"
source/analysis/root/include/G4RootPNtupleManager.icc
+9 -9
View File
@@ -33,10 +33,6 @@ template <>
inline G4bool G4RootPNtupleManager::FillNtupleTColumn(
G4int ntupleId, G4int columnId, const std::string& value)
{
if (fCreateNtuples) {
CreateNtuplesFromMain();
}
if ( fState.GetIsActivation() && ( ! GetActivation(ntupleId) ) ) {
G4cout << "Skipping FillNtupleIColumn for " << ntupleId << G4endl;
return false;
@@ -48,8 +44,12 @@ inline G4bool G4RootPNtupleManager::FillNtupleTColumn(
" value " + G4Analysis::ToString(value));
}
// Creating ntuples on workers is triggered with the first FillColumn
// or AddRow (in only columns of vector type call)
CreateNtuplesIfNeeded();
auto ntuple = GetNtupleInFunction(ntupleId, "FillNtupleTColumn");
if ( ! ntuple ) return false;
if (ntuple == nullptr) return false;
auto index = columnId - fFirstNtupleColumnId;
if ( index < 0 || index >= G4int(ntuple->columns().size()) ) {
@@ -62,7 +62,7 @@ inline G4bool G4RootPNtupleManager::FillNtupleTColumn(
auto icolumn = ntuple->columns()[index];
auto column = dynamic_cast<tools::wroot::base_pntuple::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,
@@ -87,9 +87,9 @@ template <typename T>
G4bool G4RootPNtupleManager::FillNtupleTColumn(
G4int ntupleId, G4int columnId, const T& value)
{
if (fCreateNtuples) {
CreateNtuplesFromMain();
}
// Creating ntuples on workers is triggered with the first FillColumn
// or AddRow (in only columns of vector type call)
CreateNtuplesIfNeeded();
if ( fState.GetIsActivation() && ( ! GetActivation(ntupleId) ) ) {
G4cout << "Skipping FillNtupleIColumn for " << ntupleId << G4endl;
source/analysis/root/include/G4RootRFileDef.hh
+45
View File
@@ -0,0 +1,45 @@
//
// ********************************************************************
// * 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 tuple for root read file including its directories
//
// Author: Ivana Hrivnacova, 13/07/2022 (ivana@ipno.in2p3.fr)
#ifndef G4RootRFile_h
#define G4RootRFile_h 1
namespace tools {
namespace rroot {
class directory;
class file;
}
}
using G4RootRFile = std::tuple<tools::rroot::file*,
tools::rroot::directory*,
tools::rroot::directory*>;
#endif
source/analysis/root/include/G4RootRFileManager.hh
+6 -13
View File
@@ -32,44 +32,37 @@
#define G4RootRFileManager_h 1
#include "G4VRFileManager.hh"
#include "G4RootRFileDef.hh"
#include "globals.hh"
#include <map>
#include <string_view>
namespace tools {
namespace rroot {
class file;
//class directory;
}
}
class G4RootRFileManager : public G4VRFileManager
{
public:
explicit G4RootRFileManager(const G4AnalysisManagerState& state);
G4RootRFileManager() = delete;
virtual ~G4RootRFileManager();
~G4RootRFileManager() override;
virtual G4String GetFileType() const final { return "Root"; }
G4String GetFileType() const final { return "Root"; }
// Methods from base class
virtual void CloseFiles() final {}
void CloseFiles() final {}
// Methods to manipulate input files
virtual G4bool OpenRFile(const G4String& fileName,
G4bool isPerThread);
// Get methods
tools::rroot::file* GetRFile(const G4String& fileName,
G4bool isPerThread) const;
G4RootRFile* GetRFile(const G4String& fileName, G4bool isPerThread) const;
private:
// Static data members
static constexpr std::string_view fkClass { "G4RootRFileManager" };
// data members
std::map<G4String, tools::rroot::file*> fRFiles;
std::map<G4String, G4RootRFile*> fRFiles;
};
#endif
source/analysis/root/include/G4RootRNtupleManager.hh
+8 -5
View File
@@ -38,6 +38,7 @@
#include "tools/rroot/ntuple"
#include <string_view>
#include <utility>
class G4RootRFileManager;
struct G4RootRNtupleDescription;
@@ -49,16 +50,16 @@ class G4RootRNtupleManager : public G4TRNtupleManager<tools::rroot::ntuple>
public:
explicit G4RootRNtupleManager(const G4AnalysisManagerState& state);
G4RootRNtupleManager() = delete;
virtual ~G4RootRNtupleManager() = default;
~G4RootRNtupleManager() override = default;
private:
// Set methods
void SetFileManager(std::shared_ptr<G4RootRFileManager> 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<tools::rroot::ntuple>* ntupleDescription) final;
G4int ReadNtupleImpl(const G4String& ntupleName, const G4String& fileName,
const G4String& dirName, G4bool isUserFileName) final;
G4bool GetTNtupleRow(G4TRNtupleDescription<tools::rroot::ntuple>* ntupleDescription) final;
// Static data members
static constexpr std::string_view fkClass { "G4RootPNtupleManager" };
@@ -69,7 +70,9 @@ class G4RootRNtupleManager : public G4TRNtupleManager<tools::rroot::ntuple>
inline void
G4RootRNtupleManager::SetFileManager(std::shared_ptr<G4RootRFileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
#endif