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/xml/include/G4XmlAnalysisManager.hh
+1 -12
View File
@@ -41,7 +41,6 @@
#include <string_view>
class G4XmlAnalysisManager;
class G4XmlFileManager;
class G4XmlNtupleFileManager;
template <class T>
class G4ThreadLocalSingleton;
@@ -51,7 +50,7 @@ class G4XmlAnalysisManager : public G4ToolsAnalysisManager
friend class G4ThreadLocalSingleton<G4XmlAnalysisManager>;
public:
virtual ~G4XmlAnalysisManager();
~G4XmlAnalysisManager() override;
// Static methods
static G4XmlAnalysisManager* Instance();
@@ -67,24 +66,14 @@ class G4XmlAnalysisManager : public G4ToolsAnalysisManager
std::vector<tools::waxml::ntuple*>::const_iterator BeginConstNtuple() const;
std::vector<tools::waxml::ntuple*>::const_iterator EndConstNtuple() const;
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;
private:
G4XmlAnalysisManager();
// Static data members
inline static G4XmlAnalysisManager* fgMasterInstance { nullptr };
inline static G4ThreadLocal G4bool fgIsInstance { false };
static constexpr std::string_view fkClass { "G4XmlAnalysisManager" };
// Data members
std::shared_ptr<G4XmlFileManager> fFileManager { nullptr };
std::shared_ptr<G4XmlNtupleFileManager> fNtupleFileManager { nullptr };
};
source/analysis/xml/include/G4XmlAnalysisManager.icc
-7
View File
@@ -28,13 +28,6 @@
#include "G4XmlNtupleManager.hh"
#include "G4XmlFileManager.hh"
//_____________________________________________________________________________
inline
G4bool G4XmlAnalysisManager::IsOpenFileImpl() const
{
return fFileManager->IsOpenFile();
}
//_____________________________________________________________________________
inline
tools::waxml::ntuple* G4XmlAnalysisManager::GetNtuple() const
source/analysis/xml/include/G4XmlAnalysisReader.hh
+2 -2
View File
@@ -51,7 +51,7 @@ class G4XmlAnalysisReader : public G4ToolsAnalysisReader
friend class G4ThreadLocalSingleton<G4XmlAnalysisReader>;
public:
virtual ~G4XmlAnalysisReader();
~G4XmlAnalysisReader() override;
// Static methods
static G4XmlAnalysisReader* Instance();
@@ -65,7 +65,7 @@ class G4XmlAnalysisReader : public G4ToolsAnalysisReader
G4XmlAnalysisReader();
// Virtual methods from base class
virtual G4bool CloseFilesImpl(G4bool reset) final;
G4bool CloseFilesImpl(G4bool reset) final;
private:
// Static data members
source/analysis/xml/include/G4XmlFileManager.hh
+7 -7
View File
@@ -52,16 +52,16 @@ class G4XmlFileManager : public G4VTFileManager<std::ofstream>
public:
explicit G4XmlFileManager(const G4AnalysisManagerState& state);
G4XmlFileManager() = delete;
virtual ~G4XmlFileManager() = default;
~G4XmlFileManager() override = default;
using G4BaseFileManager::GetNtupleFileName;
using G4VTFileManager<std::ofstream>::WriteFile;
using G4VTFileManager<std::ofstream>::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 "xml"; }
G4String GetFileType() const final { return "xml"; }
// Specific methods for files per objects
G4bool CreateNtupleFile(XmlNtupleDescription* ntupleDescription);
@@ -69,11 +69,11 @@ class G4XmlFileManager : public G4VTFileManager<std::ofstream>
protected:
// Methods derived from templated base class
virtual std::shared_ptr<std::ofstream> CreateFileImpl(const G4String& fileName) final;
virtual G4bool WriteFileImpl(std::shared_ptr<std::ofstream> file) final;
virtual G4bool CloseFileImpl(std::shared_ptr<std::ofstream> file) final;
std::shared_ptr<std::ofstream> CreateFileImpl(const G4String& fileName) final;
G4bool WriteFileImpl(std::shared_ptr<std::ofstream> file) final;
G4bool CloseFileImpl(std::shared_ptr<std::ofstream> file) final;
private:
private:
// Utility method
G4String GetNtupleFileName(XmlNtupleDescription* ntupleDescription);
source/analysis/xml/include/G4XmlHnFileManager.hh
+3 -3
View File
@@ -44,13 +44,13 @@ class G4XmlHnFileManager : public G4VTHnFileManager<HT>
G4XmlHnFileManager(G4XmlFileManager* fileManger)
: G4VTHnFileManager<HT>(), fFileManager(fileManger) {}
G4XmlHnFileManager() = delete;
virtual ~G4XmlHnFileManager() = default;
~G4XmlHnFileManager() 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:
// Static data members
source/analysis/xml/include/G4XmlHnRFileManager.hh
+3 -3
View File
@@ -44,11 +44,11 @@ class G4XmlHnRFileManager : public G4VTHnRFileManager<HT>
G4XmlHnRFileManager(G4XmlRFileManager* rfileManger)
: G4VTHnRFileManager<HT>(), fRFileManager(rfileManger) {}
G4XmlHnRFileManager() = delete;
virtual ~G4XmlHnRFileManager() = default;
~G4XmlHnRFileManager() 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:
// Static data members
source/analysis/xml/include/G4XmlNtupleFileManager.hh
+10 -10
View File
@@ -37,6 +37,7 @@
#include "tools/waxml/ntuple"
#include <memory>
#include <utility>
class G4XmlFileManager;
class G4XmlNtupleManager;
@@ -46,24 +47,21 @@ class G4XmlNtupleFileManager : public G4VNtupleFileManager
public:
explicit G4XmlNtupleFileManager(const G4AnalysisManagerState& state);
G4XmlNtupleFileManager() = delete;
virtual ~G4XmlNtupleFileManager() = default;
~G4XmlNtupleFileManager() 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<G4XmlFileManager> fileManager);
std::shared_ptr<G4XmlNtupleManager> GetNtupleManager() const;
private:
// Methods
G4bool CloseNtupleFiles();
// Static data members
static constexpr std::string_view fkClass { "G4XmlNtupleFileManager" };
@@ -76,7 +74,9 @@ class G4XmlNtupleFileManager : public G4VNtupleFileManager
inline void G4XmlNtupleFileManager::SetFileManager(
std::shared_ptr<G4XmlFileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
inline std::shared_ptr<G4XmlNtupleManager> G4XmlNtupleFileManager::GetNtupleManager() const
{ return fNtupleManager; }
source/analysis/xml/include/G4XmlNtupleManager.hh
+8 -8
View File
@@ -36,9 +36,10 @@
#include "tools/waxml/ntuple"
#include <vector>
#include <memory>
#include <string_view>
#include <utility>
#include <vector>
// Types alias
using XmlNtupleDescription = G4TNtupleDescription<tools::waxml::ntuple, std::ofstream>;
@@ -54,7 +55,7 @@ class G4XmlNtupleManager : public G4TNtupleManager<tools::waxml::ntuple,
public:
explicit G4XmlNtupleManager(const G4AnalysisManagerState& state);
G4XmlNtupleManager() = delete;
virtual ~G4XmlNtupleManager() = default;
~G4XmlNtupleManager() override = default;
private:
// Functions specific to the output type
@@ -68,12 +69,9 @@ class G4XmlNtupleManager : public G4TNtupleManager<tools::waxml::ntuple,
// Methods from the templated base class
//
virtual void CreateTNtupleFromBooking(
XmlNtupleDescription* ntupleDescription) final;
void CreateTNtupleFromBooking(XmlNtupleDescription* ntupleDescription) final;
virtual void FinishTNtuple(
XmlNtupleDescription* ntupleDescription,
G4bool fromBooking) final;
void FinishTNtuple(XmlNtupleDescription* ntupleDescription, G4bool fromBooking) final;
// Static data members
static constexpr std::string_view fkClass { "G4XmNtupleManager" };
@@ -86,7 +84,9 @@ class G4XmlNtupleManager : public G4TNtupleManager<tools::waxml::ntuple,
inline void
G4XmlNtupleManager::SetFileManager(std::shared_ptr<G4XmlFileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
inline const std::vector<G4TNtupleDescription<tools::waxml::ntuple, std::ofstream>*>&
G4XmlNtupleManager::GetNtupleDescriptionVector() const
source/analysis/xml/include/G4XmlRFileManager.hh
+3 -3
View File
@@ -45,12 +45,12 @@ class G4XmlRFileManager : public G4VRFileManager
public:
explicit G4XmlRFileManager(const G4AnalysisManagerState& state);
G4XmlRFileManager() = delete;
virtual ~G4XmlRFileManager();
~G4XmlRFileManager() override;
virtual G4String GetFileType() const final { return "xml"; }
G4String GetFileType() const final { return "xml"; }
// Methods from base class
virtual void CloseFiles() final {}
void CloseFiles() final {}
// Methods to manipulate input files
virtual G4bool OpenRFile(const G4String& fileName);
source/analysis/xml/include/G4XmlRFileManager.icc
+1 -2
View File
@@ -53,8 +53,7 @@ tools::raxml_out* G4XmlRFileManager::GetHandler(
std::vector<tools::raxml_out>::iterator it;
for (it = objects.begin(); it!=objects.end(); ++it) {
tools::raxml_out& object = *it;
if ( (object.cls().compare(HT::s_class()) == 0) &&
(object.name().compare(objectName) == 0) ) {
if ((object.cls() == HT::s_class()) && (object.name() == objectName)) {
handler = &object;
handler->disown();
break;
source/analysis/xml/include/G4XmlRNtupleManager.hh
+17 -14
View File
@@ -37,8 +37,9 @@
#include "toolx/raxml"
#include <vector>
#include <string_view>
#include <utility>
#include <vector>
class G4XmlRFileManager;
struct G4XmlRNtupleDescription;
@@ -50,7 +51,7 @@ class G4XmlRNtupleManager : public G4TRNtupleManager<tools::aida::ntuple>
public:
explicit G4XmlRNtupleManager(const G4AnalysisManagerState& state);
G4XmlRNtupleManager() = delete;
virtual ~G4XmlRNtupleManager() = default;
~G4XmlRNtupleManager() override = default;
protected:
// Set methods
@@ -68,20 +69,20 @@ class G4XmlRNtupleManager : public G4TRNtupleManager<tools::aida::ntuple>
// Override base class functions for vector columns
// in order to fill the maps
virtual G4bool SetNtupleIColumn(G4int ntupleId, const G4String& columnName,
std::vector<G4int>& vector) final;
virtual G4bool SetNtupleFColumn(G4int ntupleId, const G4String& columnName,
std::vector<G4float>& vector) final;
virtual G4bool SetNtupleDColumn(G4int ntupleId, const G4String& columnName,
std::vector<G4double>& vector) final;
virtual G4bool SetNtupleSColumn(G4int ntupleId, const G4String& columnName,
std::vector<std::string>& vector) final;
G4bool SetNtupleIColumn(
G4int ntupleId, const G4String& columnName, std::vector<G4int>& vector) final;
G4bool SetNtupleFColumn(
G4int ntupleId, const G4String& columnName, std::vector<G4float>& vector) final;
G4bool SetNtupleDColumn(
G4int ntupleId, const G4String& columnName, std::vector<G4double>& vector) final;
G4bool SetNtupleSColumn(
G4int ntupleId, const G4String& columnName, std::vector<std::string>& vector) final;
private:
// 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::aida::ntuple>* ntupleDescription) final;
G4int ReadNtupleImpl(const G4String& ntupleName, const G4String& fileName,
const G4String& dirName, G4bool isUserFileName) final;
G4bool GetTNtupleRow(G4TRNtupleDescription<tools::aida::ntuple>* ntupleDescription) final;
// Static data members
static constexpr std::string_view fkClass { "G4XmlRNtupleManager" };
@@ -92,6 +93,8 @@ class G4XmlRNtupleManager : public G4TRNtupleManager<tools::aida::ntuple>
inline void
G4XmlRNtupleManager::SetFileManager(std::shared_ptr<G4XmlRFileManager> fileManager)
{ fFileManager = fileManager; }
{
fFileManager = std::move(fileManager);
}
#endif
source/analysis/xml/src/G4XmlAnalysisManager.cc
+4 -117
View File
@@ -55,132 +55,19 @@ G4bool G4XmlAnalysisManager::IsInstance()
G4XmlAnalysisManager::G4XmlAnalysisManager()
: G4ToolsAnalysisManager("Xml")
{
if ( ! G4Threading::IsWorkerThread() ) fgMasterInstance = this;
// File Manager
fFileManager = std::make_shared<G4XmlFileManager>(fState);
SetFileManager(fFileManager);
auto fileManager = std::make_shared<G4XmlFileManager>(fState);
SetFileManager(fileManager);
// Ntuple file manager
fNtupleFileManager = std::make_shared<G4XmlNtupleFileManager>(fState);
fNtupleFileManager->SetFileManager(fFileManager);
SetNtupleFileManager(fNtupleFileManager);
fNtupleFileManager->SetFileManager(fileManager);
fNtupleFileManager->SetBookingManager(fNtupleBookingManager);
}
//_____________________________________________________________________________
G4XmlAnalysisManager::~G4XmlAnalysisManager()
{
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
fgIsInstance = false;
}
//
// protected methods
//
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::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;
// Save file name in file manager
result &= fFileManager->OpenFile(fileName);
// Open ntuple files and create ntuples from bookings
result &= fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::WriteImpl()
{
auto result = true;
Message(kVL4, "write", "files");
// ntuples
fNtupleFileManager->ActionAtWrite();
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());
}
// File
result &= fFileManager->WriteFiles();
Message(kVL3, "write", "files", "", result);
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::CloseFileImpl(G4bool reset)
{
auto result = true;
Message(kVL4, "close", "files");
// Close open files
result &= fFileManager->CloseFiles();
// Close ntuple files
result &= fNtupleFileManager->ActionAtCloseFile(reset);
// Reset data
if ( reset ) {
if ( ! Reset() ) {
Warn("Resetting data failed", fkClass, "CloseFileImpl");
result = false;
}
}
// delete files if empty
// (ntuple files are created only if an ntuple is created)
if ( fFileManager->GetFile() && G4ToolsAnalysisManager::IsEmpty() ) {
if ( std::remove(fFileManager->GetFullFileName()) ) {
// std::remove returns 0 when success
Warn(G4String(
"Removing file ") + fFileManager->GetFullFileName() + " failed",
fkClass, "CloseFileImpl");
result = false;
}
Message(kVL1, "delete", "empty file", fFileManager->GetFullFileName());
}
else {
Message(kVL3, "close", "files");
}
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::ResetImpl()
{
// Reset histograms and ntuple
auto result = true;
result &= G4ToolsAnalysisManager::ResetImpl();
if ( fNtupleFileManager != nullptr ) {
result &= fNtupleFileManager->Reset();
}
return result;
}
source/analysis/xml/src/G4XmlFileManager.cc
+22 -41
View File
@@ -56,14 +56,18 @@ G4XmlFileManager::G4XmlFileManager(const G4AnalysisManagerState& state)
G4String G4XmlFileManager::GetNtupleFileName(XmlNtupleDescription* 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 {
// compose ntuple file name from the default file name
ntupleFileName = GetNtupleFileName(ntupleDescription->fNtupleBooking.name());
ntupleFileName =
GetTnFileName(ntupleFileName, GetFileType()/*, ntupleDescription->GetCycle()*/);
}
else {
// compose ntuple file name from the default file name
ntupleFileName = GetNtupleFileName(
ntupleDescription->GetNtupleBooking().name()/*, ntupleDescription->GetCycle()*/);
}
return ntupleFileName;
}
@@ -138,54 +142,31 @@ G4bool G4XmlFileManager::OpenFile(const G4String& fileName)
G4bool G4XmlFileManager::CreateNtupleFile(
XmlNtupleDescription* ntupleDescription)
{
// get ntuple file name per object (if defined)
// Get ntuple file name per object (if defined)
auto ntupleFileName = GetNtupleFileName(ntupleDescription);
Message(kVL4, "create", "ntuple file", ntupleFileName);
// update file name if it is already in use
while ( GetTFile(ntupleFileName, false) ) {
// the file is already in use
auto oldName = ntupleDescription->fFileName;
auto newName = GetBaseName(oldName) + "_bis." + GetExtension(oldName);
ntupleDescription->fFileName = newName;
Warn(G4String( "Ntuple filename ") + oldName + " is already in use.\n" +
"It will be replaced with : " + newName,
fkClass, "CreateNtupleFile");
ntupleFileName = GetNtupleFileName(ntupleDescription);
// Create ntuple file name if it does not yet exist
auto ntupleFile = GetTFile(ntupleFileName, false);
if ( ntupleFile == nullptr) {
ntupleFile = CreateTFile(ntupleFileName);
}
ntupleDescription->fFile = CreateTFile(ntupleFileName);
ntupleDescription->SetFile(ntupleFile);
Message(kVL2, "create", "ntuple file", ntupleFileName);
return (ntupleDescription->fFile != nullptr);
return (ntupleDescription->GetFile() != nullptr);
}
//_____________________________________________________________________________
G4bool G4XmlFileManager::CloseNtupleFile(
XmlNtupleDescription* ntupleDescription)
{
// Do nothing if there is no file
if ( ! ntupleDescription->fFile ) return true;
auto result = true;
auto ntupleFileName = GetNtupleFileName(ntupleDescription);
Message(kVL4, "close", "ntuple file", ntupleFileName);
// Close file
result &= CloseTFile(ntupleFileName);
// Notify not empty file
result &=SetIsEmpty(ntupleFileName, ! ntupleDescription->fHasFill);
auto ntupleFileName = GetNtupleFileName(ntupleDescription);
auto result = SetIsEmpty(ntupleFileName, ! ntupleDescription->GetHasFill());
// Reset file info in ntuple description
ntupleDescription->fFile.reset();
Message(kVL2, "close", "ntuple file", ntupleFileName);
// Ntuple files are registered in file manager map.
// they will be closed with CloseFiles() calls
ntupleDescription->GetFile().reset();
return result;
}
source/analysis/xml/src/G4XmlNtupleFileManager.cc
+8 -29
View File
@@ -41,24 +41,6 @@ G4XmlNtupleFileManager::G4XmlNtupleFileManager(const G4AnalysisManagerState& sta
: G4VNtupleFileManager(state, "csv")
{}
//
// private methods
//
//_____________________________________________________________________________
G4bool G4XmlNtupleFileManager::CloseNtupleFiles()
{
// Close ntuple files
auto result = true;
auto ntupleVector = fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntupleDescription : ntupleVector) {
result &= fFileManager->CloseNtupleFile(ntupleDescription);
}
return result;
}
//
// public methods
//
@@ -88,27 +70,24 @@ G4bool G4XmlNtupleFileManager::ActionAtWrite()
{
auto ntupleVector = fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntuple : ntupleVector ) {
if ( ntuple->fNtuple ) ntuple->fNtuple->write_trailer();
for ( auto ntupleDescription : ntupleVector ) {
if (ntupleDescription->GetNtuple() != nullptr) {
ntupleDescription->GetNtuple()->write_trailer();
}
}
return true;
}
//_____________________________________________________________________________
G4bool G4XmlNtupleFileManager::ActionAtCloseFile(G4bool reset)
G4bool G4XmlNtupleFileManager::ActionAtCloseFile()
{
auto result = true;
// Close ntuple files
result &= CloseNtupleFiles();
// Reset data
if ( ! reset ) {
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/xml/src/G4XmlNtupleManager.cc
+19 -10
View File
@@ -53,10 +53,11 @@ void G4XmlNtupleManager::CreateTNtupleFromBooking(
if ( ! fFileManager->CreateNtupleFile(ntupleDescription) ) return;
// create ntuple
ntupleDescription->fNtuple
= new tools::waxml::ntuple(
*(ntupleDescription->fFile), G4cerr, ntupleDescription->fNtupleBooking);
fNtupleVector.push_back(ntupleDescription->fNtuple);
ntupleDescription->SetNtuple(
new tools::waxml::ntuple(
*(ntupleDescription->GetFile()), G4cerr,
ntupleDescription->GetNtupleBooking()));
fNtupleVector.push_back(ntupleDescription->GetNtuple());
}
//_____________________________________________________________________________
@@ -66,24 +67,32 @@ void G4XmlNtupleManager::FinishTNtuple(
{
// Do nothing if the base file name was not yet defined
if ( ! fFileManager->GetFileName().size() ) return;
if (fFileManager->GetFileName().size() == 0u) return;
// Create ntuple from booking
if ( ! ntupleDescription->fNtuple ) {
if (ntupleDescription->GetNtuple() == nullptr) {
CreateTNtupleFromBooking(ntupleDescription);
}
// Return if creating ntuple failed
if ( ! ntupleDescription->fNtuple ) {
if (ntupleDescription->GetNtuple() == nullptr) {
Warn("Creating ntuple has failed. ", fkClass, "FinishTNtuple");
return;
}
// Update ntuple name if cycle >0
auto ntupleName = ntupleDescription->GetNtupleBooking().name();
// if (ntupleDescription->GetCycle() > 0) {
if (GetCycle() > 0) {
ntupleName.append("_v");
ntupleName.append(std::to_string(GetCycle()));
}
// Write header
G4String path = "/";
path.append(fFileManager->GetNtupleDirectoryName());
ntupleDescription->fNtuple
->write_header(path, ntupleDescription->fNtupleBooking.name(),
ntupleDescription->fNtupleBooking.title());
ntupleDescription->GetNtuple()
->write_header(path, ntupleName,
ntupleDescription->GetNtupleBooking().title());
fFileManager->LockDirectoryNames();
}
source/analysis/xml/src/G4XmlRFileManager.cc
+3 -4
View File
@@ -74,7 +74,7 @@ G4bool G4XmlRFileManager::OpenRFile(const G4String& fileName)
G4bool verbose = false;
// create factory (if it does not yet exist)
if ( ! fReadFactory ) {
if (fReadFactory == nullptr) {
fReadFactory = new tools::xml::default_factory();
}
@@ -116,9 +116,8 @@ toolx::raxml* G4XmlRFileManager::GetRFile(const G4String& fileName) const
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;
}
source/analysis/xml/src/G4XmlRNtupleManager.cc
+5 -5
View File
@@ -88,7 +88,7 @@ G4int G4XmlRNtupleManager::ReadNtupleImpl(const G4String& ntupleName,
auto handler = fFileManager->GetHandler<tools::aida::ntuple>(
fullFileName, ntupleName, "ReadNtupleImpl");
if ( ! handler ) return kInvalidId;
if (handler == nullptr) return kInvalidId;
auto rntuple = static_cast<tools::aida::ntuple*>(handler->object());
auto id = SetNtuple(new G4TRNtupleDescription<tools::aida::ntuple>(rntuple));
@@ -109,7 +109,7 @@ G4bool G4XmlRNtupleManager::SetNtupleIColumn(G4int ntupleId,
" ntupleId " + to_string(ntupleId) + " " + columnName);
auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetNtupleIColumn");
if ( ! ntupleDescription ) return false;
if (ntupleDescription == nullptr) return false;
// not supported
//tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
@@ -138,7 +138,7 @@ G4bool G4XmlRNtupleManager::SetNtupleFColumn(G4int ntupleId,
auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetNtupleFColumn");
if ( ! ntupleDescription ) return false;
if (ntupleDescription == nullptr) return false;
// not supported
//tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
@@ -166,7 +166,7 @@ G4bool G4XmlRNtupleManager::SetNtupleDColumn(G4int ntupleId,
" ntupleId " + to_string(ntupleId) + " " + columnName);
auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetNtupleDColumn");
if ( ! ntupleDescription ) return false;
if (ntupleDescription == nullptr) return false;
// not supported
//tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
@@ -194,7 +194,7 @@ G4bool G4XmlRNtupleManager::SetNtupleSColumn(G4int ntupleId,
" ntupleId " + to_string(ntupleId) + " " + columnName);
auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetNtupleSColumn");
if ( ! ntupleDescription ) return false;
if (ntupleDescription == nullptr) return false;
// not supported
//tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;