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

Import Geant4 11.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2021-12-10 14:46:44 +01:00
committed by Ben Morgan
parent 6399a014b6
commit 80e2389dd8
3932 changed files with 202519 additions and 246221 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/analysis/xml/src/G4XmlAnalysisManager.cc
+72 -291
View File
@@ -31,64 +31,32 @@
#include "G4XmlNtupleFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4ThreadLocalSingleton.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
using namespace G4Analysis;
using std::make_shared;
// mutex in a file scope
namespace {
//Mutex to lock master manager when merging H1 histograms
G4Mutex mergeH1Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging H1 histograms
G4Mutex mergeH2Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging H1 histograms
G4Mutex mergeH3Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging P1 profiles
G4Mutex mergeP1Mutex = G4MUTEX_INITIALIZER;
//Mutex to lock master manager when merging P2 profiles
G4Mutex mergeP2Mutex = G4MUTEX_INITIALIZER;
}
G4XmlAnalysisManager* G4XmlAnalysisManager::fgMasterInstance = nullptr;
G4ThreadLocal G4XmlAnalysisManager* G4XmlAnalysisManager::fgInstance = nullptr;
//_____________________________________________________________________________
G4XmlAnalysisManager* G4XmlAnalysisManager::Instance()
{
if ( fgInstance == nullptr ) {
G4bool isMaster = ! G4Threading::IsWorkerThread();
fgInstance = new G4XmlAnalysisManager(isMaster);
}
return fgInstance;
static G4ThreadLocalSingleton<G4XmlAnalysisManager> instance;
fgIsInstance = true;
return instance.Instance();
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::IsInstance()
{
return ( fgInstance != 0 );
}
return fgIsInstance;
}
//_____________________________________________________________________________
G4XmlAnalysisManager::G4XmlAnalysisManager(G4bool isMaster)
: G4ToolsAnalysisManager("Xml", isMaster),
fFileManager(nullptr),
fNtupleFileManager(nullptr)
G4XmlAnalysisManager::G4XmlAnalysisManager()
: G4ToolsAnalysisManager("Xml")
{
if ( ( isMaster && fgMasterInstance ) || ( fgInstance ) ) {
G4ExceptionDescription description;
description
<< " "
<< "G4XmlAnalysisManager already exists."
<< "Cannot create another instance.";
G4Exception("G4XmlAnalysisManager::G4XmlAnalysisManager",
"Analysis_F001", FatalException, description);
}
if ( isMaster ) fgMasterInstance = this;
fgInstance = this;
if ( ! G4Threading::IsWorkerThread() ) fgMasterInstance = this;
// File Manager
fFileManager = std::make_shared<G4XmlFileManager>(fState);
SetFileManager(fFileManager);
@@ -101,157 +69,12 @@ G4XmlAnalysisManager::G4XmlAnalysisManager(G4bool isMaster)
//_____________________________________________________________________________
G4XmlAnalysisManager::~G4XmlAnalysisManager()
{
{
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
fgInstance = nullptr;
fgIsInstance = false;
}
//
// private methods
//
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::WriteH1()
{
auto h1Vector = fH1Manager->GetH1Vector();
auto hnVector = fH1Manager->GetHnVector();
if ( ! h1Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WriteT(h1Vector, hnVector, directoryName, "h1");
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lH1(&mergeH1Mutex);
fgMasterInstance->fH1Manager->AddH1Vector(h1Vector);
lH1.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::WriteH2()
{
auto h2Vector = fH2Manager->GetH2Vector();
auto hnVector = fH2Manager->GetHnVector();
if ( ! h2Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WriteT(h2Vector, hnVector, directoryName, "h2");
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lH2(&mergeH2Mutex);
fgMasterInstance->fH2Manager->AddH2Vector(h2Vector);
lH2.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::WriteH3()
{
auto h3Vector = fH3Manager->GetH3Vector();
auto hnVector = fH3Manager->GetHnVector();
if ( ! h3Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WriteT(h3Vector, hnVector, directoryName, "h3");
}
else {
// The worker manager just adds its histograms to the master
// This operation needs a lock
G4AutoLock lH3(&mergeH3Mutex);
fgMasterInstance->fH3Manager->AddH3Vector(h3Vector);
lH3.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::WriteP1()
{
auto p1Vector = fP1Manager->GetP1Vector();
auto hnVector = fP1Manager->GetHnVector();
if ( ! p1Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WriteT(p1Vector, hnVector, directoryName, "p1");
}
else {
// The worker manager just adds its profiles to the master
// This operation needs a lock
G4AutoLock lP1(&mergeP1Mutex);
fgMasterInstance->fP1Manager->AddP1Vector(p1Vector);
lP1.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::WriteP2()
{
auto p2Vector = fP2Manager->GetP2Vector();
auto hnVector = fP2Manager->GetHnVector();
if ( ! p2Vector.size() ) return true;
auto result = true;
if ( ! G4Threading::IsWorkerThread() ) {
auto directoryName = fFileManager->GetHistoDirectoryName();
result = WriteT(p2Vector, hnVector, directoryName, "p2");
}
else {
// The worker manager just adds its profiles to the master
// This operation needs a lock
G4AutoLock lP2(&mergeP2Mutex);
fgMasterInstance->fP2Manager->AddP2Vector(p2Vector);
lP2.unlock();
}
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::Reset()
{
// Reset histograms and ntuple
auto finalResult = true;
auto result = G4ToolsAnalysisManager::Reset();
finalResult = finalResult && result;
result = fNtupleFileManager->Reset();
finalResult = finalResult && result;
return finalResult;
}
//
// protected methods
//
@@ -262,144 +85,102 @@ G4bool G4XmlAnalysisManager::OpenFileImpl(const G4String& fileName)
// and set it to base class which takes then their ownership
SetNtupleManager(fNtupleFileManager->CreateNtupleManager());
auto finalResult = true;
auto result = true;
// Save file name in file manager
auto result = fFileManager->OpenFile(fileName);
finalResult = finalResult && result;
result &= fFileManager->OpenFile(fileName);
// Open ntuple files and create ntuples from bookings
result = fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
finalResult = finalResult && result;
result &= fNtupleFileManager->ActionAtOpenFile(fFileManager->GetFullFileName());
return result;
}
return finalResult;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::WriteImpl()
G4bool G4XmlAnalysisManager::WriteImpl()
{
auto finalResult = true;
auto result = true;
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
fState.GetVerboseL4()->Message("write", "files", "");
}
#endif
Message(kVL4, "write", "files");
// ntuples
// ntuples
fNtupleFileManager->ActionAtWrite();
if ( ! fgMasterInstance &&
( ( ! fH1Manager->IsEmpty() ) || ( ! fH2Manager->IsEmpty() ) ||
( ! fH3Manager->IsEmpty() ) || ( ! fP1Manager->IsEmpty() ) ||
( ! fP2Manager->IsEmpty() ) ) ) {
G4ExceptionDescription description;
description
<< " " << "No master G4XmlAnalysisManager instance exists."
<< G4endl
<< " " << "Histogram data will not be merged.";
G4Exception("G4XmlAnalysisManager::Write()",
"Analysis_W031", JustWarning, description);
if ( G4Threading::IsWorkerThread() ) {
result &= G4ToolsAnalysisManager::Merge();
}
else {
// Open all files registered with objects
fFileManager->OpenFiles();
// H1
auto result = WriteH1();
finalResult = finalResult && result;
// H2
result = WriteH2();
finalResult = finalResult && result;
// H3
result = WriteH3();
finalResult = finalResult && result;
// P1
result = WriteP1();
finalResult = finalResult && result;
// P2
result = WriteP2();
finalResult = finalResult && result;
// Write all histograms/profile on master
result &= G4ToolsAnalysisManager::WriteImpl();
}
// Write ASCII if activated
if ( IsAscii() ) {
result = WriteAscii(fFileManager->GetFileName());
finalResult = finalResult && result;
result &= WriteAscii(fFileManager->GetFileName());
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()->Message("write", "files", "", finalResult);
}
#endif
// File
result &= fFileManager->WriteFiles();
return finalResult;
Message(kVL3, "write", "files", "", result);
return result;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisManager::CloseFileImpl(G4bool reset)
{
auto finalResult = true;
auto result = true;
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("close", "files", "");
#endif
Message(kVL4, "close", "files");
// Close open files
result &= fFileManager->CloseFiles();
// close open files
auto result = fFileManager->CloseFiles();
finalResult = finalResult && result;
// Close Hn file
// result = fFileManager->CloseHnFile();
// finalResult = finalResult && result;
// Close ntuple files
result = fNtupleFileManager->ActionAtCloseFile(reset);
finalResult = finalResult && result;
result &= fNtupleFileManager->ActionAtCloseFile(reset);
// Reset data
if ( reset ) {
result = Reset();
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4XmlAnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
if ( ! Reset() ) {
Warn("Resetting data failed", fkClass, "CloseFileImpl");
result = false;
}
finalResult = finalResult && result;
}
// delete files if empty
// (ntuple files are created only if an ntuple is created)
if ( fFileManager->GetFile() &&
fH1Manager->IsEmpty() && fH2Manager->IsEmpty() && fH3Manager->IsEmpty() &&
fP1Manager->IsEmpty() && fP2Manager->IsEmpty() ) {
result = ! std::remove(fFileManager->GetFullFileName());
// std::remove returns 0 when success
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Removing file "
<< fFileManager->GetFullFileName() << " failed";
G4Exception("G4XmlAnalysisManager::CloseFile()",
"Analysis_W021", JustWarning, description);
}
finalResult = finalResult && result;
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
->Message("delete", "empty file", fFileManager->GetFullFileName());
#endif
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 {
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()
->Message("close", "files", "");
#endif
Message(kVL3, "close", "files");
}
return finalResult;
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/G4XmlAnalysisReader.cc
+31 -255
View File
@@ -28,58 +28,31 @@
#include "G4XmlAnalysisReader.hh"
#include "G4XmlRFileManager.hh"
#include "G4H1ToolsManager.hh"
#include "G4H2ToolsManager.hh"
#include "G4H3ToolsManager.hh"
#include "G4P1ToolsManager.hh"
#include "G4P2ToolsManager.hh"
#include "G4XmlRNtupleManager.hh"
#include "G4AnalysisVerbose.hh"
#include "G4AnalysisUtilities.hh"
#include "G4ThreadLocalSingleton.hh"
#include "G4Threading.hh"
#include <iostream>
#include <cstdio>
using namespace G4Analysis;
G4XmlAnalysisReader* G4XmlAnalysisReader::fgMasterInstance = nullptr;
G4ThreadLocal G4XmlAnalysisReader* G4XmlAnalysisReader::fgInstance = 0;
//_____________________________________________________________________________
G4XmlAnalysisReader* G4XmlAnalysisReader::Instance()
{
if ( fgInstance == nullptr ) {
G4bool isMaster = ! G4Threading::IsWorkerThread();
fgInstance = new G4XmlAnalysisReader(isMaster);
}
return fgInstance;
}
static G4ThreadLocalSingleton<G4XmlAnalysisReader> instance;
return instance.Instance();
}
//_____________________________________________________________________________
G4XmlAnalysisReader::G4XmlAnalysisReader(G4bool isMaster)
: G4ToolsAnalysisReader("Xml", isMaster),
fNtupleManager(nullptr),
fFileManager(nullptr)
G4XmlAnalysisReader::G4XmlAnalysisReader()
: G4ToolsAnalysisReader("Xml")
{
if ( ( isMaster && fgMasterInstance ) || ( fgInstance ) ) {
G4ExceptionDescription description;
description
<< " "
<< "G4XmlAnalysisReader already exists."
<< "Cannot create another instance.";
G4Exception("G4XmlAnalysisReader::G4XmlAnalysisReader()",
"Analysis_F001", FatalException, description);
}
if ( isMaster ) fgMasterInstance = this;
fgInstance = this;
if ( ! G4Threading::IsWorkerThread() ) fgMasterInstance = this;
// Create managers
fNtupleManager = new G4XmlRNtupleManager(fState);
fFileManager = new G4XmlRFileManager(fState);
// The managers will be deleted by the base class
fNtupleManager = std::make_shared<G4XmlRNtupleManager>(fState);
fFileManager = std::make_shared<G4XmlRFileManager>(fState);
fNtupleManager->SetFileManager(fFileManager);
// Set managers to base class
SetNtupleManager(fNtupleManager);
SetFileManager(fFileManager);
@@ -89,240 +62,43 @@ G4XmlAnalysisReader::G4XmlAnalysisReader(G4bool isMaster)
G4XmlAnalysisReader::~G4XmlAnalysisReader()
{
if ( fState.GetIsMaster() ) fgMasterInstance = nullptr;
fgInstance = nullptr;
}
//
//
// private methods
//
//_____________________________________________________________________________
tools::raxml_out* G4XmlAnalysisReader::GetHandler(
const G4String& fileName,
const G4String& objectName,
const G4String& objectType,
const G4String& inFunction)
{
// Get buffer for reading object specified by objectName and objectType
// for a file specified by fileName;
// open the file if it was not yet open
// Histograms and profiles are not saved per thread
// and ntuple file name is already updated
auto rfile = fFileManager->GetRFile(fileName);
if ( ! rfile ) {
if ( ! fFileManager->OpenRFile(fileName) ) return nullptr;
rfile = fFileManager->GetRFile(fileName);
}
tools::raxml_out* handler = nullptr;
if ( rfile ) {
std::vector<tools::raxml_out>& objects = rfile->objects();
std::vector<tools::raxml_out>::iterator it;
for (it = objects.begin(); it!=objects.end(); ++it) {
tools::raxml_out& object = *it;
if ( object.cls() == objectType && object.name() == objectName ) {
handler = &object;
break;
}
}
}
if ( ! handler ) {
G4ExceptionDescription description;
description
<< " "
<< "Cannot get "<< objectName << " in file " << fileName;
G4String inFunctionFull = "G4XmlAnalysisReader::";
inFunctionFull.append(inFunction);
G4Exception(inFunctionFull, "Analysis_WR011", JustWarning, description);
return nullptr;
}
return handler;
}
//_____________________________________________________________________________
G4bool G4XmlAnalysisReader::Reset()
{
// Reset histograms and ntuple
auto finalResult = true;
auto result = G4ToolsAnalysisReader::Reset();
finalResult = finalResult && result;
result = fNtupleManager->Reset();
finalResult = finalResult && result;
return finalResult;
}
//
auto result = true;
result &= G4ToolsAnalysisReader::Reset();
result &= fNtupleManager->Reset();
return result;
}
//
// protected methods
//
//_____________________________________________________________________________
G4int G4XmlAnalysisReader::ReadH1Impl(const G4String& h1Name,
const G4String& fileName,
const G4String& /*dirName*/,
G4bool /*isUserFileName*/)
G4bool G4XmlAnalysisReader::CloseFilesImpl(G4bool reset)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "h1", h1Name);
#endif
Message(kVL4, "close", "files");
tools::raxml_out* handler
= GetHandler(fileName, h1Name, tools::histo::h1d::s_class(), "ReadH1Impl");
if ( ! handler ) return kInvalidId;
auto result = true;
auto h1 = static_cast<tools::histo::h1d*>(handler->object());
auto id = fH1Manager->AddH1(h1Name, h1);
if (reset) {
result &= Reset();
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "h1", h1Name, id > kInvalidId);
#endif
return id;
}
fFileManager->CloseFiles();
//_____________________________________________________________________________
G4int G4XmlAnalysisReader::ReadH2Impl(const G4String& h2Name,
const G4String& fileName,
const G4String& /*dirName*/,
G4bool /*isUserFileName*/)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "h2", h2Name);
#endif
Message(kVL2, "close", "files", "", result);
auto handler
= GetHandler(fileName, h2Name, tools::histo::h2d::s_class(), "ReadH2Impl");
if ( ! handler ) return kInvalidId;
auto h2 = static_cast<tools::histo::h2d*>(handler->object());
auto id = fH2Manager->AddH2(h2Name, h2);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "h2", h2Name, id > kInvalidId);
#endif
return id;
}
//_____________________________________________________________________________
G4int G4XmlAnalysisReader::ReadH3Impl(const G4String& h3Name,
const G4String& fileName,
const G4String& /*dirName*/,
G4bool /*isUserFileName*/)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "h3", h3Name);
#endif
auto handler
= GetHandler(fileName, h3Name, tools::histo::h3d::s_class(), "ReadH3Impl");
if ( ! handler ) return kInvalidId;
auto h3 = static_cast<tools::histo::h3d*>(handler->object());
auto id = fH3Manager->AddH3(h3Name, h3);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "h3", h3Name, id > kInvalidId);
#endif
return id;
}
//_____________________________________________________________________________
G4int G4XmlAnalysisReader::ReadP1Impl(const G4String& p1Name,
const G4String& fileName,
const G4String& /*dirName*/,
G4bool /*isUserFileName*/)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "p1", p1Name);
#endif
auto handler
= GetHandler(fileName, p1Name, tools::histo::p1d::s_class(), "ReadP1Impl");
if ( ! handler ) return kInvalidId;
auto p1 = static_cast<tools::histo::p1d*>(handler->object());
auto id = fP1Manager->AddP1(p1Name, p1);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "p1", p1Name, id > kInvalidId);
#endif
return id;
}
//_____________________________________________________________________________
G4int G4XmlAnalysisReader::ReadP2Impl(const G4String& p2Name,
const G4String& fileName,
const G4String& /*dirName*/,
G4bool /*isUserFileName*/)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "p2", p2Name);
#endif
auto handler
= GetHandler(fileName, p2Name, tools::histo::p2d::s_class(), "ReadP2Impl");
if ( ! handler ) return kInvalidId;
auto p2 = static_cast<tools::histo::p2d*>(handler->object());
auto id = fP2Manager->AddP2(p2Name, p2);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "p2", p2Name, id > kInvalidId);
#endif
return id;
}
//_____________________________________________________________________________
G4int G4XmlAnalysisReader::ReadNtupleImpl(const G4String& ntupleName,
const G4String& fileName,
const G4String& /*dirName*/,
G4bool isUserFileName)
{
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("read", "ntuple", ntupleName);
#endif
// Ntuples are saved per object and per thread
// but apply the ntuple name and the thread suffixes
// only if fileName is not provided explicitly
auto fullFileName = fileName;
if ( ! isUserFileName ) {
fullFileName = fFileManager->GetNtupleFileName(ntupleName);
}
auto handler
= GetHandler(fullFileName, ntupleName, tools::aida::ntuple::s_class(),
"ReadNtupleImpl");
if ( ! handler ) return kInvalidId;
auto rntuple = static_cast<tools::aida::ntuple*>(handler->object());
auto id = fNtupleManager->SetNtuple(new G4TRNtupleDescription<tools::aida::ntuple>(rntuple));
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() )
fState.GetVerboseL2()->Message("read", "ntuple", ntupleName, id > kInvalidId);
#endif
return id;
}
return result;
}
source/analysis/xml/src/G4XmlFileManager.cc
+25 -61
View File
@@ -48,11 +48,7 @@ G4XmlFileManager::G4XmlFileManager(const G4AnalysisManagerState& state)
fP2FileManager = std::make_shared<G4XmlHnFileManager<histo::p2d>>(this);
}
//_____________________________________________________________________________
G4XmlFileManager::~G4XmlFileManager()
{}
//
//
// private methods
//
@@ -69,9 +65,9 @@ G4String G4XmlFileManager::GetNtupleFileName(XmlNtupleDescription* ntupleDescrip
ntupleFileName = GetNtupleFileName(ntupleDescription->fNtupleBooking.name());
}
return ntupleFileName;
}
}
//
//
// protected methods
//
@@ -80,11 +76,7 @@ std::shared_ptr<std::ofstream> G4XmlFileManager::CreateFileImpl(const G4String&
{
std::shared_ptr<std::ofstream> file = std::make_shared<std::ofstream>(fileName);
if ( file->fail() ) {
file = nullptr;
G4ExceptionDescription description;
description << " " << "Cannot create file " << fileName;
G4Exception("G4XmlFileManager::CreateFileImpl()",
"Analysis_W001", JustWarning, description);
Warn(G4String("Cannot create file ") + fileName, fkClass, "CreateFileImpl");
return nullptr;
}
@@ -96,22 +88,22 @@ std::shared_ptr<std::ofstream> G4XmlFileManager::CreateFileImpl(const G4String&
G4bool G4XmlFileManager::WriteFileImpl(std::shared_ptr<std::ofstream> /*file*/)
{
// Nothing to be done here
return true;
return true;
}
//_____________________________________________________________________________
G4bool G4XmlFileManager::CloseFileImpl(std::shared_ptr<std::ofstream> file)
G4bool G4XmlFileManager::CloseFileImpl(std::shared_ptr<std::ofstream> file)
{
if ( ! file ) return false;
// close file
waxml::end(*file);
file->close();
file->close();
return true;
}
//
//
// public methods
//
@@ -123,10 +115,7 @@ G4bool G4XmlFileManager::OpenFile(const G4String& fileName)
auto name = GetFullFileName(fFileName);
if ( fFile ) {
G4ExceptionDescription description;
description << "File " << fileName << " already exists.";
G4Exception("G4XmlFileManager::OpenFile()",
"Analysis_W001", JustWarning, description);
Warn(G4String("File ") + fileName + " already exists.", fkClass, "OpenFile");
fFile.reset();
}
@@ -135,10 +124,7 @@ G4bool G4XmlFileManager::OpenFile(const G4String& fileName)
// Create file (and save in in the file map (on master only)
fFile = CreateTFile(name);
if ( ! fFile) {
G4ExceptionDescription description;
description << "Failed to create file " << fileName;
G4Exception("G4XmlFileManager::OpenFile()",
"Analysis_W001", JustWarning, description);
Warn(G4String("Failed to create file") + fileName, fkClass, "OpenFile");
return false;
}
}
@@ -146,8 +132,8 @@ G4bool G4XmlFileManager::OpenFile(const G4String& fileName)
fIsOpenFile = true;
return true;
}
}
//_____________________________________________________________________________
G4bool G4XmlFileManager::CreateNtupleFile(
XmlNtupleDescription* ntupleDescription)
@@ -155,11 +141,7 @@ G4bool G4XmlFileManager::CreateNtupleFile(
// get ntuple file name per object (if defined)
auto ntupleFileName = GetNtupleFileName(ntupleDescription);
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
fState.GetVerboseL4()->Message("create", "ntuple file", ntupleFileName);
}
#endif
Message(kVL4, "create", "ntuple file", ntupleFileName);
// update file name if it is already in use
while ( GetTFile(ntupleFileName, false) ) {
@@ -168,26 +150,19 @@ G4bool G4XmlFileManager::CreateNtupleFile(
auto newName = GetBaseName(oldName) + "_bis." + GetExtension(oldName);
ntupleDescription->fFileName = newName;
G4ExceptionDescription description;
description
<< "Ntuple filename " << oldName << " is already in use." << G4endl
<< "It will be replaced with : " << newName;
G4Exception("G4XmlFileManager::CreateFileImpl()",
"Analysis_W001", JustWarning, description);
Warn(G4String( "Ntuple filename ") + oldName + " is already in use.\n" +
"It will be replaced with : " + newName,
fkClass, "CreateNtupleFile");
ntupleFileName = GetNtupleFileName(ntupleDescription);
}
ntupleDescription->fFile = CreateTFile(ntupleFileName);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()->Message("create", "ntuple file", ntupleFileName);
}
#endif
Message(kVL2, "create", "ntuple file", ntupleFileName);
return (ntupleDescription->fFile != nullptr);
}
}
//_____________________________________________________________________________
G4bool G4XmlFileManager::CloseNtupleFile(
@@ -196,32 +171,21 @@ G4bool G4XmlFileManager::CloseNtupleFile(
// Do nothing if there is no file
if ( ! ntupleDescription->fFile ) return true;
auto finalResult = true;
auto result = true;
auto ntupleFileName = GetNtupleFileName(ntupleDescription);
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
fState.GetVerboseL4()->Message("close", "ntuple file", ntupleFileName);
}
#endif
// close file
auto result = CloseTFile(ntupleFileName);
finalResult = result && finalResult;
Message(kVL4, "close", "ntuple file", ntupleFileName);
// Close file
result &= CloseTFile(ntupleFileName);
// Notify not empty file
result = SetIsEmpty(ntupleFileName, ! ntupleDescription->fHasFill);
finalResult = result && finalResult;
result &=SetIsEmpty(ntupleFileName, ! ntupleDescription->fHasFill);
// Reset file info in ntuple description
ntupleDescription->fFile.reset();
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
fState.GetVerboseL2()->Message("close", "ntuple file", ntupleFileName);
}
#endif
Message(kVL2, "close", "ntuple file", ntupleFileName);
return result;
return result;
}
source/analysis/xml/src/G4XmlNtupleFileManager.cc
+22 -34
View File
@@ -31,23 +31,17 @@
#include "G4XmlNtupleManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4Threading.hh"
#include "G4AutoLock.hh"
using namespace G4Analysis;
using std::make_shared;
//_____________________________________________________________________________
G4XmlNtupleFileManager::G4XmlNtupleFileManager(const G4AnalysisManagerState& state)
: G4VNtupleFileManager(state, "csv"),
fFileManager(nullptr),
fNtupleManager(nullptr)
: G4VNtupleFileManager(state, "csv")
{}
//_____________________________________________________________________________
G4XmlNtupleFileManager::~G4XmlNtupleFileManager()
{}
//
//
// private methods
//
@@ -56,17 +50,16 @@ G4bool G4XmlNtupleFileManager::CloseNtupleFiles()
{
// Close ntuple files
auto finalResult = true;
auto result = true;
auto ntupleVector = fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntupleDescription : ntupleVector) {
auto result = fFileManager->CloseNtupleFile(ntupleDescription);
finalResult = finalResult && result;
result &= fFileManager->CloseNtupleFile(ntupleDescription);
}
return finalResult;
}
return result;
}
//
//
// public methods
//
@@ -75,7 +68,7 @@ std::shared_ptr<G4VNtupleManager> G4XmlNtupleFileManager::CreateNtupleManager()
{
fNtupleManager = std::make_shared<G4XmlNtupleManager>(fState);
fNtupleManager->SetFileManager(fFileManager);
return fNtupleManager;
}
@@ -86,44 +79,39 @@ G4bool G4XmlNtupleFileManager::ActionAtOpenFile(const G4String& /*fileName*/)
// (The files will be created with creating ntuples)
fNtupleManager->CreateNtuplesFromBooking(
fBookingManager->GetNtupleBookingVector());
return true;
}
}
//_____________________________________________________________________________
G4bool G4XmlNtupleFileManager::ActionAtWrite()
G4bool G4XmlNtupleFileManager::ActionAtWrite()
{
auto ntupleVector = fNtupleManager->GetNtupleDescriptionVector();
for ( auto ntuple : ntupleVector ) {
if ( ntuple->fNtuple ) ntuple->fNtuple->write_trailer();
}
return true;
}
//_____________________________________________________________________________
G4bool G4XmlNtupleFileManager::ActionAtCloseFile(G4bool reset)
{
auto finalResult = true;
auto result = true;
// Close ntuple files
auto result = CloseNtupleFiles();
finalResult = finalResult && result;
result &= CloseNtupleFiles();
// Reset data
if ( ! reset ) {
result = Reset();
if ( ! result ) {
G4ExceptionDescription description;
description << " " << "Resetting data failed";
G4Exception("G4XmlNtupleFileManager::CloseFile()",
"Analysis_W021", JustWarning, description);
Warn("Resetting data failed", fkClass, "ActionAtCloseFile");
}
finalResult = finalResult && result;
}
return finalResult;
return result;
}
//_____________________________________________________________________________
@@ -131,6 +119,6 @@ G4bool G4XmlNtupleFileManager::Reset()
{
// Reset histograms and ntuple
return fNtupleManager->Reset(true);
}
return fNtupleManager->Reset();
}
source/analysis/xml/src/G4XmlNtupleManager.cc
+6 -18
View File
@@ -30,27 +30,18 @@
#include "G4XmlFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "G4Threading.hh"
#include "G4UnitsTable.hh"
#include "tools/ntuple_booking"
#include <iostream>
//#include <cstdio>
using namespace G4Analysis;
//_____________________________________________________________________________
G4XmlNtupleManager::G4XmlNtupleManager(const G4AnalysisManagerState& state)
: G4TNtupleManager<tools::waxml::ntuple, std::ofstream>(state),
fFileManager(nullptr)
: G4TNtupleManager<tools::waxml::ntuple, std::ofstream>(state)
{}
//_____________________________________________________________________________
G4XmlNtupleManager::~G4XmlNtupleManager()
{}
//
//
// private methods
//
@@ -65,7 +56,7 @@ void G4XmlNtupleManager::CreateTNtupleFromBooking(
ntupleDescription->fNtuple
= new tools::waxml::ntuple(
*(ntupleDescription->fFile), G4cerr, ntupleDescription->fNtupleBooking);
fNtupleVector.push_back(ntupleDescription->fNtuple);
fNtupleVector.push_back(ntupleDescription->fNtuple);
}
//_____________________________________________________________________________
@@ -84,10 +75,7 @@ void G4XmlNtupleManager::FinishTNtuple(
// Return if creating ntuple failed
if ( ! ntupleDescription->fNtuple ) {
G4ExceptionDescription description;
description << "Creating ntuple has failed. ";
G4Exception("G4XmlNtupleManager::FinishTNtuple()",
"Analysis_W022", JustWarning, description);
Warn("Creating ntuple has failed. ", fkClass, "FinishTNtuple");
return;
}
@@ -95,7 +83,7 @@ void G4XmlNtupleManager::FinishTNtuple(
G4String path = "/";
path.append(fFileManager->GetNtupleDirectoryName());
ntupleDescription->fNtuple
->write_header(path, ntupleDescription->fNtupleBooking.name(),
ntupleDescription->fNtupleBooking.title());
->write_header(path, ntupleDescription->fNtupleBooking.name(),
ntupleDescription->fNtupleBooking.title());
fFileManager->LockDirectoryNames();
}
source/analysis/xml/src/G4XmlRFileManager.cc
+33 -37
View File
@@ -27,29 +27,38 @@
// Author: Ivana Hrivnacova, 10/09/2014 (ivana@ipno.in2p3.fr)
#include "G4XmlRFileManager.hh"
#include "G4XmlHnRFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
#include "tools/waxml/begend"
#include "tools/raxml"
using namespace G4Analysis;
using namespace tools;
//_____________________________________________________________________________
G4XmlRFileManager::G4XmlRFileManager(const G4AnalysisManagerState& state)
: G4BaseFileManager(state),
fReadFactory(0),
fRFiles()
: G4VRFileManager(state)
{
// Create helpers defined in the base class
fH1RFileManager = std::make_shared<G4XmlHnRFileManager<histo::h1d>>(this);
fH2RFileManager = std::make_shared<G4XmlHnRFileManager<histo::h2d>>(this);
fH3RFileManager = std::make_shared<G4XmlHnRFileManager<histo::h3d>>(this);
fP1RFileManager = std::make_shared<G4XmlHnRFileManager<histo::p1d>>(this);
fP2RFileManager = std::make_shared<G4XmlHnRFileManager<histo::p2d>>(this);
}
//_____________________________________________________________________________
G4XmlRFileManager::~G4XmlRFileManager()
{
for (G4int i=0; i<G4int(fRFiles.size()); ++i) {
delete fRFiles[i];
}
delete fReadFactory;
{
for ( auto& rfile : fRFiles ) {
delete rfile.second;
}
delete fReadFactory;
}
//
//
// public methods
//
@@ -60,69 +69,56 @@ G4bool G4XmlRFileManager::OpenRFile(const G4String& fileName)
G4bool isPerThread = false;
G4String name = GetFullFileName(fileName, isPerThread);
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() )
fState.GetVerboseL4()->Message("open", "read analysis file", name);
#endif
Message(kVL4, "open", "read analysis file", name);
G4bool verbose = false;
// create factory (if it does not yet exist)
if ( ! fReadFactory ) {
fReadFactory = new tools::xml::default_factory();
}
}
// create new file
tools::raxml* newFile
= new tools::raxml(*fReadFactory, G4cout, verbose);
auto newFile = new tools::raxml(*fReadFactory, G4cout, verbose);
// clear objects
// clear objects
// (this should not be needed when starting a new raxml)
std::vector<tools::raxml_out>& objs = newFile->objects();
objs.clear();
G4bool compressed = false;
if ( ! newFile->load_file(name, compressed) ) {
G4ExceptionDescription description;
description << " " << "Cannot open file " << name;
G4Exception("G4XmlRFileManager::OpenRFile()",
"Analysis_WR001", JustWarning, description);
Warn(G4String( "Cannot open file ") + name, fkClass, "OpenRFile");
delete newFile;
return false;
}
// add file in a map and delete the previous file if it exists
std::map<G4String, tools::raxml*>::iterator it
= fRFiles.find(name);
if ( it != fRFiles.end() ) {
auto it = fRFiles.find(name);
if ( it != fRFiles.end() ) {
delete it->second;
it->second = newFile;
}
else {
fRFiles[name] = newFile;
}
}
#ifdef G4VERBOSE
if ( fState.GetVerboseL1() )
fState.GetVerboseL1()
->Message("open", "read analysis file", name);
#endif
Message(kVL1, "open", "read analysis file", name);
return true;
}
}
//_____________________________________________________________________________
tools::raxml* G4XmlRFileManager::GetRFile(const G4String& fileName) const
{
{
// Get full file name (add only extension)
G4bool isPerThread = false;
G4String name = GetFullFileName(fileName, isPerThread);
std::map<G4String, tools::raxml*>::const_iterator it
= fRFiles.find(name);
auto it = fRFiles.find(name);
if ( it != fRFiles.end() )
return it->second;
else {
return nullptr;
}
}
}
source/analysis/xml/src/G4XmlRNtupleManager.cc
+104 -90
View File
@@ -27,9 +27,14 @@
// Author: Ivana Hrivnacova, 25/07/2014 (ivana@ipno.in2p3.fr)
#include "G4XmlRNtupleManager.hh"
#include "G4XmlRFileManager.hh"
#include "G4AnalysisManagerState.hh"
#include "G4AnalysisUtilities.hh"
//
using namespace G4Analysis;
using std::to_string;
//
// utility function (to be provided in tools)
//
@@ -61,32 +66,51 @@ G4XmlRNtupleManager::G4XmlRNtupleManager(const G4AnalysisManagerState& state)
: G4TRNtupleManager<tools::aida::ntuple>(state)
{}
//_____________________________________________________________________________
G4XmlRNtupleManager::~G4XmlRNtupleManager()
{}
//
//
// private methods
//
//_____________________________________________________________________________
G4bool G4XmlRNtupleManager::SetNtupleIColumn(G4int ntupleId,
const G4String& columnName,
G4int G4XmlRNtupleManager::ReadNtupleImpl(const G4String& ntupleName,
const G4String& fileName,
const G4String& /*dirName*/,
G4bool isUserFileName)
{
Message(kVL4, "read", "ntuple", ntupleName);
// Ntuples are saved per object and per thread
// but apply the ntuple name and the thread suffixes
// only if fileName is not provided explicitly
auto fullFileName = fileName;
if ( ! isUserFileName ) {
fullFileName = fFileManager->GetNtupleFileName(ntupleName);
}
auto handler = fFileManager->GetHandler<tools::aida::ntuple>(
fullFileName, ntupleName, "ReadNtupleImpl");
if ( ! handler ) return kInvalidId;
auto rntuple = static_cast<tools::aida::ntuple*>(handler->object());
auto id = SetNtuple(new G4TRNtupleDescription<tools::aida::ntuple>(rntuple));
Message(kVL2, "read", "ntuple", ntupleName, id > kInvalidId);
return id;
}
//_____________________________________________________________________________
G4bool G4XmlRNtupleManager::SetNtupleIColumn(G4int ntupleId,
const G4String& columnName,
std::vector<G4int>& vector)
{
// Override base class default implementation
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
G4ExceptionDescription description;
description << " ntupleId " << ntupleId << " " << columnName;
fState.GetVerboseL4()->Message("set", "ntuple I column", description);
}
#endif
Message(kVL4, "set", "ntuple I column",
" ntupleId " + to_string(ntupleId) + " " + columnName);
auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetNtupleIColumn");
if ( ! ntupleDescription ) return false;
if ( ! ntupleDescription ) return false;
// not supported
//tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
//ntupleBinding->add_column(columnName, vector);
@@ -96,35 +120,26 @@ G4bool G4XmlRNtupleManager::SetNtupleIColumn(G4int ntupleId,
tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
ntupleBinding->add_column_cid(columnName, *subNtuple);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
G4ExceptionDescription description;
description << " ntupleId " << ntupleId << " " << columnName;
fState.GetVerboseL2()->Message("set", "ntuple I column", description, true);
}
#endif
Message(kVL2, "set", "ntuple I column",
" ntupleId " + to_string(ntupleId) + " " + columnName);
return true;
}
//_____________________________________________________________________________
G4bool G4XmlRNtupleManager::SetNtupleFColumn(G4int ntupleId,
const G4String& columnName,
G4bool G4XmlRNtupleManager::SetNtupleFColumn(G4int ntupleId,
const G4String& columnName,
std::vector<G4float>& vector)
{
// Override base class default implementation
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
G4ExceptionDescription description;
description << " ntupleId " << ntupleId << " " << columnName;
fState.GetVerboseL4()->Message("set", "ntuple F column of vector", description);
}
#endif
Message(kVL4, "set", "ntuple F column",
" ntupleId " + to_string(ntupleId) + " " + columnName);
auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetNtupleFColumn");
if ( ! ntupleDescription ) return false;
if ( ! ntupleDescription ) return false;
// not supported
//tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
//ntupleBinding->add_column(columnName, vector);
@@ -134,35 +149,25 @@ G4bool G4XmlRNtupleManager::SetNtupleFColumn(G4int ntupleId,
tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
ntupleBinding->add_column_cid(columnName, *subNtuple);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
G4ExceptionDescription description;
description << " ntupleId " << ntupleId << " " << columnName;
fState.GetVerboseL2()->Message("set", "ntuple F column", description, true);
}
#endif
Message(kVL4, "set", "ntuple F column",
" ntupleId " + to_string(ntupleId) + " " + columnName);
return true;
}
//_____________________________________________________________________________
G4bool G4XmlRNtupleManager::SetNtupleDColumn(G4int ntupleId,
const G4String& columnName,
G4bool G4XmlRNtupleManager::SetNtupleDColumn(G4int ntupleId,
const G4String& columnName,
std::vector<G4double>& vector)
{
// Override base class default implementation
#ifdef G4VERBOSE
if ( fState.GetVerboseL4() ) {
G4ExceptionDescription description;
description << " ntupleId " << ntupleId << " " << columnName;
fState.GetVerboseL4()->Message("set", "ntuple D column of vector", description);
}
#endif
Message(kVL4, "set", "ntuple D column",
" ntupleId " + to_string(ntupleId) + " " + columnName);
auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetNtupleDColumn");
if ( ! ntupleDescription ) return false;
if ( ! ntupleDescription ) return false;
// not supported
//tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
//ntupleBinding->add_column(columnName, vector);
@@ -172,13 +177,36 @@ G4bool G4XmlRNtupleManager::SetNtupleDColumn(G4int ntupleId,
tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
ntupleBinding->add_column_cid(columnName, *subNtuple);
#ifdef G4VERBOSE
if ( fState.GetVerboseL2() ) {
G4ExceptionDescription description;
description << " ntupleId " << ntupleId << " " << columnName;
fState.GetVerboseL2()->Message("set", "ntuple D column", description, true);
}
#endif
Message(kVL2, "set", "ntuple D column",
" ntupleId " + to_string(ntupleId) + " " + columnName);
return true;
}
//_____________________________________________________________________________
G4bool G4XmlRNtupleManager::SetNtupleSColumn(G4int ntupleId,
const G4String& columnName,
std::vector<std::string>& vector)
{
// Override base class default implementation
Message(kVL4, "set", "ntuple S column",
" ntupleId " + to_string(ntupleId) + " " + columnName);
auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetNtupleSColumn");
if ( ! ntupleDescription ) return false;
// not supported
//tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
//ntupleBinding->add_column(columnName, vector);
auto subNtuple = new tools::aida::ntuple(G4cout, columnName);
ntupleDescription->fSVectorBindingMap[subNtuple] = &vector;
tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
ntupleBinding->add_column_cid(columnName, *subNtuple);
Message(kVL2, "set", "ntuple S column",
" ntupleId " + to_string(ntupleId) + " " + columnName);
return true;
}
@@ -193,12 +221,7 @@ G4bool G4XmlRNtupleManager::GetTNtupleRow(
if ( ! isInitialized ) {
tools::ntuple_binding* ntupleBinding = ntupleDescription->fNtupleBinding;
if ( ! ntuple->set_binding(std::cout, *ntupleBinding) ) {
G4ExceptionDescription description;
description
<< " "
<< "Ntuple initialization failed !!";
G4Exception("G4XmlRNtuple::GetNtupleRow()",
"Analysis_WR021", JustWarning, description);
Warn("Ntuple initialization failed !!", fkClass, "GetTNtupleRow");
return false;
}
ntupleDescription->fIsInitialized = true;
@@ -208,33 +231,24 @@ G4bool G4XmlRNtupleManager::GetTNtupleRow(
G4bool next = ntuple->next();
if ( next ) {
if ( ! ntuple->get_row() ) {
G4ExceptionDescription description;
description
<< " "
<< "Ntuple get_row() failed !!";
G4Exception("G4XmlRNtuple::GetNtupleRow()",
"Analysis_WR021", JustWarning, description);
Warn("Ntuple get_row() failed !!", fkClass, "GetTNtupleRow");
return false;
}
// fill vector from sub ntuples
{std::map<tools::aida::ntuple*, std::vector<int>* >::iterator it;
for ( it = ntupleDescription->fIVectorBindingMap.begin();
it != ntupleDescription->fIVectorBindingMap.end(); it++) {
tools::aida::to_vector<int>(*(it->first), *(it->second));
}}
{std::map<tools::aida::ntuple*, std::vector<float>* >::iterator it;
for ( it = ntupleDescription->fFVectorBindingMap.begin();
it != ntupleDescription->fFVectorBindingMap.end(); it++) {
tools::aida::to_vector<float>(*(it->first), *(it->second));
}}
{std::map<tools::aida::ntuple*, std::vector<double>* >::iterator it;
for ( it = ntupleDescription->fDVectorBindingMap.begin();
it != ntupleDescription->fDVectorBindingMap.end(); it++) {
tools::aida::to_vector<double>(*(it->first), *(it->second));
}}
}
for ( auto [key, value] : ntupleDescription->fIVectorBindingMap) {
tools::aida::to_vector<int>(*key, *value);
}
for ( auto [key, value] : ntupleDescription->fFVectorBindingMap) {
tools::aida::to_vector<float>(*key, *value);
}
for ( auto [key, value] : ntupleDescription->fDVectorBindingMap) {
tools::aida::to_vector<double>(*key, *value);
}
for ( auto [key, value] : ntupleDescription->fSVectorBindingMap) {
tools::aida::to_vector<std::string>(*key, *value);
}
}
return next;
}
}