#include <G4GenericFileManager.hh>

Inheritance diagram for G4GenericFileManager:

Public Member Functions
void	AddFileName (const G4String &fileName)

virtual void	Clear () final

virtual G4bool	CloseFile (const G4String &fileName) final

virtual G4bool	CloseFiles () final

virtual G4bool	CreateFile (const G4String &fileName) final

std::shared_ptr< G4VNtupleFileManager >	CreateNtupleFileManager (G4AnalysisOutput output)

virtual G4bool	DeleteEmptyFiles () final

	G4GenericFileManager (const G4AnalysisManagerState &state)

G4String	GetDefaultFileType () const

std::shared_ptr< G4VFileManager >	GetFileManager (const G4String &fileName)

G4String	GetFileName () const

const std::vector< G4String > &	GetFileNames () const

virtual G4String	GetFileType () const final

G4String	GetFullFileName (const G4String &baseFileName="", G4bool isPerThread=true) const

G4String	GetHistoDirectoryName () const

template<typename HT >
std::shared_ptr< G4VTHnFileManager< HT > >	GetHnFileManager () const

G4String	GetHnFileName (const G4String &hnType, const G4String &hnName) const

G4String	GetNtupleDirectoryName () const

G4String	GetNtupleFileName (const G4String &ntupleName) const

G4String	GetNtupleFileName (G4int ntupleFileNumber) const

G4String	GetPlotFileName () const

G4bool	IsOpenFile () const

void	LockDirectoryNames ()

virtual G4bool	OpenFile (const G4String &fileName) final

virtual G4bool	OpenFiles () final

void	SetDefaultFileType (const G4String &value)

virtual G4bool	SetFileName (const G4String &fileName) final

virtual G4bool	SetHistoDirectoryName (const G4String &dirName)

virtual G4bool	SetIsEmpty (const G4String &fileName, G4bool isEmpty) final

virtual G4bool	SetNtupleDirectoryName (const G4String &dirName)

void	UnlockDirectoryNames ()

virtual G4bool	WriteFile (const G4String &fileName) final

virtual G4bool	WriteFiles () final

template<typename HT >
G4bool	WriteTExtra (const G4String &fileName, HT *ht, const G4String &htName)

virtual	~G4GenericFileManager ()=default

Protected Member Functions
void	Message (G4int level, const G4String &action, const G4String &objectType, const G4String &objectName="", G4bool success=true) const

Protected Attributes
G4String	fFileName

std::vector< G4String >	fFileNames

std::shared_ptr< G4VTHnFileManager< tools::histo::h1d > >	fH1FileManager { nullptr }

std::shared_ptr< G4VTHnFileManager< tools::histo::h2d > >	fH2FileManager { nullptr }

std::shared_ptr< G4VTHnFileManager< tools::histo::h3d > >	fH3FileManager { nullptr }

G4String	fHistoDirectoryName

G4bool	fIsOpenFile { false }

G4bool	fLockDirectoryNames { false }

G4String	fNtupleDirectoryName

std::shared_ptr< G4VTHnFileManager< tools::histo::p1d > >	fP1FileManager { nullptr }

std::shared_ptr< G4VTHnFileManager< tools::histo::p2d > >	fP2FileManager { nullptr }

const G4AnalysisManagerState &	fState

Private Member Functions
void	CreateFileManager (G4AnalysisOutput output)

std::shared_ptr< G4VFileManager >	GetFileManager (G4AnalysisOutput output) const

Private Attributes
std::shared_ptr< G4CsvFileManager >	fCsvFileManager { nullptr }

std::shared_ptr< G4VFileManager >	fDefaultFileManager { nullptr }

G4String	fDefaultFileType

std::vector< std::shared_ptr< G4VFileManager > >	fFileManagers

G4bool	fHdf5Warn { true }

std::shared_ptr< G4RootFileManager >	fRootFileManager { nullptr }

std::shared_ptr< G4XmlFileManager >	fXmlFileManager { nullptr }

Static Private Attributes
static constexpr std::string_view	fkClass { "G4GenericFileManager" }

Detailed Description

Definition at line 52 of file G4GenericFileManager.hh.

Constructor & Destructor Documentation

◆ G4GenericFileManager()

G4GenericFileManager::G4GenericFileManager ( const G4AnalysisManagerState & state )

explicit

Definition at line 62 of file G4GenericFileManager.cc.

63 : G4VFileManager(state)

64{}

G4VFileManager::G4VFileManager

G4VFileManager()=delete

◆ ~G4GenericFileManager()

virtual G4GenericFileManager::~G4GenericFileManager ( )

virtualdefault

Member Function Documentation

◆ AddFileName()

void G4BaseFileManager::AddFileName ( const G4String & fileName )

inherited

Definition at line 44 of file G4BaseFileManager.cc.

{
  // G4cout << "registering " << fileName << " in manager of " << GetFileType() << G4endl;
 
  // Do nothing in file name is already present
  for ( const auto& name : fFileNames ) {
    if ( name == fileName ) return;
  }
 
  fFileNames.push_back(fileName);
}

References G4BaseFileManager::fFileNames, and G4InuclParticleNames::name().

◆ Clear()

void G4GenericFileManager::Clear ( )

finalvirtual

Implements G4VFileManager.

Definition at line 292 of file G4GenericFileManager.cc.

{
// Clear files data
 
  for ( const auto& fileManager : fFileManagers ) {
    if ( ! fileManager ) continue;
 
    fileManager->Clear();
  }
  UnlockDirectoryNames();
}

References fFileManagers, and G4VFileManager::UnlockDirectoryNames().

◆ CloseFile()

G4bool G4GenericFileManager::CloseFile ( const G4String & fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 333 of file G4GenericFileManager.cc.

{
// New prototype, fully implemented in templated base class
 
  auto fileManager = GetFileManager(fileName);
  if ( ! fileManager ) {
    FileManagerWarning(fileName, fkClass, "CloseFile", fHdf5Warn);
    return false;
  }
 
  return fileManager->CloseFile(fileName);
}

References fHdf5Warn, anonymous_namespace{G4GenericFileManager.cc}::FileManagerWarning(), fkClass, and GetFileManager().

◆ CloseFiles()

G4bool G4GenericFileManager::CloseFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 246 of file G4GenericFileManager.cc.

{
// Close all files regeistered with objects
 
  Message(kVL4, "close", "analysis files");
 
  auto result = true;
 
  for ( const auto& fileManager : fFileManagers ) {
    if ( ! fileManager ) continue;
 
    Message(kVL4, "close", fileManager->GetFileType(), "files");
 
    result &= fileManager->CloseFiles();
  }
 
  fIsOpenFile = false;
 
  Message(kVL3, "close", "analysis files", "", result);
 
  return result;
}

References fFileManagers, G4VFileManager::fIsOpenFile, G4Analysis::kVL3, G4Analysis::kVL4, and G4BaseFileManager::Message().

◆ CreateFile()

G4bool G4GenericFileManager::CreateFile ( const G4String & fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 305 of file G4GenericFileManager.cc.

{
// New prototype, fully implemented in templated base class
 
  auto fileManager = GetFileManager(fileName);
  if ( ! fileManager ) {
    FileManagerWarning(fileName, fkClass, "CreateFile", fHdf5Warn);
    return false;
  }
 
  return fileManager->CreateFile(fileName);
}

References fHdf5Warn, anonymous_namespace{G4GenericFileManager.cc}::FileManagerWarning(), fkClass, and GetFileManager().

◆ CreateFileManager()

void G4GenericFileManager::CreateFileManager ( G4AnalysisOutput output )

private

Definition at line 71 of file G4GenericFileManager.cc.

{
  Message(kVL4, "create", "file manager", GetOutputName(output));
 
  auto outputId = static_cast<size_t>(output);
  if ( fFileManagers[outputId] ) {
    Warn("The file manager of " + G4Analysis::GetOutputName(output) +
         " type already exists.",
         fkClass, "CreateFileManager");
    return;
  }
 
  // Create the manager
  switch ( output ) {
    case G4AnalysisOutput::kCsv:
      fCsvFileManager = std::make_shared<G4CsvFileManager>(fState);
      fFileManagers[outputId] = fCsvFileManager;
      break;
    case G4AnalysisOutput::kHdf5:
#ifdef TOOLS_USE_HDF5
      fHdf5FileManager = std::make_shared<G4Hdf5FileManager>(fState);
      fFileManagers[outputId] = fHdf5FileManager;
#else
      if ( fHdf5Warn) {
        Warn("Hdf5 type is not available.", fkClass, "CreateFileManager");
        fHdf5Warn = false;
      }
#endif
      break;
    case G4AnalysisOutput::kRoot:
      fRootFileManager = std::make_shared<G4RootFileManager>(fState);
      fFileManagers[outputId] = fRootFileManager;
      break;
    case G4AnalysisOutput::kXml:
      fXmlFileManager = std::make_shared<G4XmlFileManager>(fState);
      fFileManagers[outputId] = fXmlFileManager ;
      break;
    case G4AnalysisOutput::kNone:
      Warn(G4Analysis::GetOutputName(output) + " type is not supported.",
        fkClass, "CreateFileManager");
      return;
  }
 
  // Pass directory names (only if set)
  if ( ! GetHistoDirectoryName().empty() ) {
    fFileManagers[outputId]->SetHistoDirectoryName(GetHistoDirectoryName());
  }
  if ( ! GetNtupleDirectoryName().empty() ) {
    fFileManagers[outputId]->SetNtupleDirectoryName(GetNtupleDirectoryName());
  }
 
  Message(kVL3, "create", "file manager", GetOutputName(output));
}

References anonymous_namespace{G4MTcoutDestination.cc}::empty, fCsvFileManager, fFileManagers, fHdf5Warn, fkClass, fRootFileManager, G4BaseFileManager::fState, fXmlFileManager, G4VFileManager::GetHistoDirectoryName(), G4VFileManager::GetNtupleDirectoryName(), G4Analysis::GetOutputName(), kCsv, kHdf5, kNone, kRoot, G4Analysis::kVL3, G4Analysis::kVL4, kXml, G4BaseFileManager::Message(), and G4Analysis::Warn().

Referenced by CreateNtupleFileManager(), and GetFileManager().

◆ CreateNtupleFileManager()

std::shared_ptr< G4VNtupleFileManager > G4GenericFileManager::CreateNtupleFileManager ( G4AnalysisOutput output )

Definition at line 401 of file G4GenericFileManager.cc.

{
  if ( ! GetFileManager(output) ) {
    CreateFileManager(output);
  }
 
  std::shared_ptr<G4VNtupleFileManager> vNtupleFileManager = nullptr;
  G4String failure;
 
  switch ( output ) {
    case G4AnalysisOutput::kCsv: {
      auto ntupleFileManager = std::make_shared<G4CsvNtupleFileManager>(fState);
      ntupleFileManager->SetFileManager(fCsvFileManager);
      vNtupleFileManager = ntupleFileManager;
      break;
    }
    case G4AnalysisOutput::kHdf5: {
#ifdef TOOLS_USE_HDF5
      auto ntupleFileManager = std::make_shared<G4Hdf5NtupleFileManager>(fState);
      ntupleFileManager->SetFileManager(fHdf5FileManager);
      vNtupleFileManager = ntupleFileManager;
#else
      failure = " Hdf5 is not available";
#endif
      break;
    }
    case G4AnalysisOutput::kRoot: {
      auto ntupleFileManager = std::make_shared<G4RootNtupleFileManager>(fState);
      ntupleFileManager->SetFileManager(fRootFileManager);
      vNtupleFileManager = ntupleFileManager;
      break;
    }
    case G4AnalysisOutput::kXml: {
      auto ntupleFileManager = std::make_shared<G4XmlNtupleFileManager>(fState);
      ntupleFileManager->SetFileManager(fXmlFileManager);
      vNtupleFileManager = ntupleFileManager;
      break;
    }
    case G4AnalysisOutput::kNone:
      break;
  }
 
  if ( ! vNtupleFileManager ) {
      Warn("Failed to create ntuple file manager of " +
           G4Analysis::GetOutputName(output) + " type.\n" + failure,
           fkClass, "CreateNtupleFileManager");
  }
 
  return vNtupleFileManager;
}

References CreateFileManager(), fCsvFileManager, fkClass, fRootFileManager, G4BaseFileManager::fState, fXmlFileManager, GetFileManager(), G4Analysis::GetOutputName(), kCsv, kHdf5, kNone, kRoot, kXml, and G4Analysis::Warn().

◆ DeleteEmptyFiles()

G4bool G4GenericFileManager::DeleteEmptyFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 270 of file G4GenericFileManager.cc.

{
// Close all files regeistered with objects
 
  Message(kVL4, "delete", "empty files");
 
  auto result = true;
 
  for ( const auto& fileManager : fFileManagers ) {
    if ( ! fileManager ) continue;
 
    Message(kVL4, "delete", fileManager->GetFileType(), "empty files");
 
    result &= fileManager->DeleteEmptyFiles();
  }
 
  Message(kVL3, "delete", "empty files", "", result);
 
  return result;
}

References fFileManagers, G4Analysis::kVL3, G4Analysis::kVL4, and G4BaseFileManager::Message().

◆ GetDefaultFileType()

G4String G4GenericFileManager::GetDefaultFileType ( ) const

◆ GetFileManager() [1/2]

std::shared_ptr< G4VFileManager > G4GenericFileManager::GetFileManager ( const G4String & fileName )

Definition at line 134 of file G4GenericFileManager.cc.

{
  // Get file extension
  G4String extension = GetExtension(fileName);
  if ( ! extension.size() ) {
    // use the default
    extension = fDefaultFileType;
  }
 
  auto output = G4Analysis::GetOutput(extension);
  if ( output == G4AnalysisOutput::kNone ) {
    Warn("The file extension " + extension + "is not supported.",
      fkClass, "GetFileManager");
    return nullptr;
  }
 
  std::shared_ptr<G4VFileManager> fileManager = GetFileManager(output);
  if ( ! GetFileManager(output) ) {
    CreateFileManager(output);
    fileManager = GetFileManager(output);
  }
 
  return GetFileManager(output);
}

References CreateFileManager(), fDefaultFileType, fkClass, G4Analysis::GetExtension(), GetFileManager(), G4Analysis::GetOutput(), kNone, and G4Analysis::Warn().

Referenced by CloseFile(), CreateFile(), CreateNtupleFileManager(), GetFileManager(), OpenFile(), OpenFiles(), SetIsEmpty(), and WriteFile().

◆ GetFileManager() [2/2]

std::shared_ptr< G4VFileManager > G4GenericFileManager::GetFileManager ( G4AnalysisOutput output ) const

private

Definition at line 127 of file G4GenericFileManager.cc.

{
  return fFileManagers[static_cast<size_t>(output)];
}

References fFileManagers.

◆ GetFileName()

G4String G4BaseFileManager::GetFileName ( ) const

inlineinherited

Definition at line 105 of file G4BaseFileManager.hh.

                                                     {
  return fFileName;
}

References G4BaseFileManager::fFileName.

◆ GetFileNames()

const std::vector< G4String > & G4BaseFileManager::GetFileNames ( ) const

inlineinherited

Definition at line 109 of file G4BaseFileManager.hh.

                                                                        {
  return fFileNames;
}

References G4BaseFileManager::fFileNames.

Referenced by OpenFiles().

◆ GetFileType()

virtual G4String G4GenericFileManager::GetFileType ( ) const

inlinefinalvirtual

Reimplemented from G4BaseFileManager.

Definition at line 79 of file G4GenericFileManager.hh.

79{ return ""; }

◆ GetFullFileName()

G4String G4BaseFileManager::GetFullFileName	(	const G4String &	baseFileName = `""`,
		G4bool	isPerThread = `true`
	)		const

inherited

Definition at line 63 of file G4BaseFileManager.cc.

{
  G4String fileName(baseFileName);
  if ( fileName == "" ) fileName = fFileName;
 
  // Take out file extension
  auto name = G4Analysis::GetBaseName(fileName);
 
  // Add thread Id to a file name if MT processing
  if ( isPerThread && ! fState.GetIsMaster() ) {
    std::ostringstream os;
    os << G4Threading::G4GetThreadId();
    name.append("_t");
    name.append(os.str());
  }
 
  // Add (back if it was present or is defined) file extension
  auto extension = G4Analysis::GetExtension(fileName, GetFileType());
  if ( extension.size() ) {
    name.append(".");
    name.append(extension);
  }
 
  return name;
}

References G4BaseFileManager::fFileName, G4Analysis::GetBaseName(), and G4InuclParticleNames::name().

Referenced by G4Hdf5FileManager::GetNtupleFileName(), G4RootFileManager::GetNtupleFileName(), G4XmlRFileManager::GetRFile(), G4Hdf5RFileManager::GetRFile(), G4RootRFileManager::GetRFile(), G4Hdf5FileManager::OpenFile(), G4RootFileManager::OpenFile(), G4XmlFileManager::OpenFile(), G4XmlRFileManager::OpenRFile(), G4Hdf5RFileManager::OpenRFile(), and G4RootRFileManager::OpenRFile().

◆ GetHistoDirectoryName()

G4String G4VFileManager::GetHistoDirectoryName ( ) const

inlineinherited

Definition at line 120 of file G4VFileManager.hh.

121{ return fHistoDirectoryName; }

G4VFileManager::fHistoDirectoryName

G4String fHistoDirectoryName

Definition: G4VFileManager.hh:96

References G4VFileManager::fHistoDirectoryName.

Referenced by CreateFileManager().

◆ GetHnFileManager()

template<typename HT >

std::shared_ptr< G4VTHnFileManager< HT > > G4VFileManager::GetHnFileManager ( ) const

inherited

◆ GetHnFileName()

G4String G4BaseFileManager::GetHnFileName	(	const G4String &	hnType,
		const G4String &	hnName
	)		const

inherited

Definition at line 91 of file G4BaseFileManager.cc.

{
  return G4Analysis::GetHnFileName(fFileName, GetFileType(), hnType, hnName);
}

References G4BaseFileManager::fFileName, G4BaseFileManager::GetFileType(), and G4Analysis::GetHnFileName().

◆ GetNtupleDirectoryName()

G4String G4VFileManager::GetNtupleDirectoryName ( ) const

inlineinherited

Definition at line 123 of file G4VFileManager.hh.

124{ return fNtupleDirectoryName; }

G4VFileManager::fNtupleDirectoryName

G4String fNtupleDirectoryName

Definition: G4VFileManager.hh:97

References G4VFileManager::fNtupleDirectoryName.

Referenced by CreateFileManager(), and G4CsvFileManager::GetNtupleFileName().

◆ GetNtupleFileName() [1/2]

G4String G4BaseFileManager::GetNtupleFileName ( const G4String & ntupleName ) const

inherited

Definition at line 98 of file G4BaseFileManager.cc.

{
  return G4Analysis::GetNtupleFileName(fFileName, GetFileType(), ntupleName);
}

References G4BaseFileManager::fFileName, G4BaseFileManager::GetFileType(), and G4Analysis::GetNtupleFileName().

◆ GetNtupleFileName() [2/2]

G4String G4BaseFileManager::GetNtupleFileName ( G4int ntupleFileNumber ) const

inherited

Definition at line 104 of file G4BaseFileManager.cc.

{
  return G4Analysis::GetNtupleFileName(fFileName, GetFileType(), ntupleFileNumber);
}

References G4BaseFileManager::fFileName, G4BaseFileManager::GetFileType(), and G4Analysis::GetNtupleFileName().

◆ GetPlotFileName()

G4String G4BaseFileManager::GetPlotFileName ( ) const

inherited

Definition at line 110 of file G4BaseFileManager.cc.

{
  return G4Analysis::GetPlotFileName(fFileName);
}

References G4BaseFileManager::fFileName, and G4Analysis::GetPlotFileName().

◆ IsOpenFile()

G4bool G4VFileManager::IsOpenFile ( ) const

inlineinherited

Definition at line 117 of file G4VFileManager.hh.

118{ return fIsOpenFile; }

References G4VFileManager::fIsOpenFile.

◆ LockDirectoryNames()

void G4VFileManager::LockDirectoryNames ( )

inlineinherited

Definition at line 111 of file G4VFileManager.hh.

112{ fLockDirectoryNames = true; }

G4VFileManager::fLockDirectoryNames

G4bool fLockDirectoryNames

Definition: G4VFileManager.hh:99

References G4VFileManager::fLockDirectoryNames.

Referenced by OpenFile(), G4Hdf5FileManager::OpenFile(), and G4RootFileManager::OpenFile().

◆ Message()

void G4BaseFileManager::Message	(	G4int	level,
		const G4String &	action,
		const G4String &	objectType,
		const G4String &	objectName = `""`,
		G4bool	success = `true`
	)		const

inlineprotectedinherited

Definition at line 113 of file G4BaseFileManager.hh.

{
  fState.Message(level, action, objectType, objectName, success);
}

References geant4_check_module_cycles::action, G4BaseFileManager::fState, and G4AnalysisManagerState::Message().

Referenced by CloseFiles(), G4CsvFileManager::CloseNtupleFile(), G4XmlFileManager::CloseNtupleFile(), G4Hdf5FileManager::CreateDirectory(), G4RootFileManager::CreateDirectory(), CreateFileManager(), G4CsvFileManager::CreateNtupleFile(), G4XmlFileManager::CreateNtupleFile(), DeleteEmptyFiles(), G4Hdf5RFileManager::OpenDirectory(), OpenFile(), OpenFiles(), G4CsvRFileManager::OpenRFile(), G4XmlRFileManager::OpenRFile(), G4Hdf5RFileManager::OpenRFile(), G4RootRFileManager::OpenRFile(), and WriteFiles().

◆ OpenFile()

G4bool G4GenericFileManager::OpenFile ( const G4String & fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 164 of file G4GenericFileManager.cc.

{
  auto fileManager = GetFileManager(fileName);
  if ( ! fileManager ) return false;
 
  if ( fDefaultFileManager && (fDefaultFileManager != fileManager) ) {
    // Print warning if default output changed
    // (maybe be not needed?)
    Warn("Default file manager changed "
         "(old: " +fDefaultFileManager->GetFileType() +
         ", new:" + fileManager->GetFileType() + ")",
         fkClass, "OpenFile");
  }
  fDefaultFileManager = fileManager;
  fDefaultFileType = fileManager->GetFileType();
 
  Message(kVL4, "open", "analysis file", fileName);
 
  auto result = true;
 
  // Save the default file name
  // both in the generic file manager and the output specific one
  result &= SetFileName(fileName);
  result &= fDefaultFileManager->SetFileName(fileName);
  result &= fDefaultFileManager->OpenFile(fileName);
 
  LockDirectoryNames();
  fIsOpenFile = true;
 
  Message(kVL1, "open", "analysis file", fileName, result);
 
  return result;
}

References fDefaultFileManager, fDefaultFileType, G4VFileManager::fIsOpenFile, fkClass, GetFileManager(), G4Analysis::kVL1, G4Analysis::kVL4, G4VFileManager::LockDirectoryNames(), G4BaseFileManager::Message(), G4VFileManager::SetFileName(), and G4Analysis::Warn().

◆ OpenFiles()

G4bool G4GenericFileManager::OpenFiles ( )

finalvirtual

Definition at line 199 of file G4GenericFileManager.cc.

{
// Open all files regeistered with objects
 
  Message(kVL4, "open", "analysis files");
 
  auto result = true;
 
  // process names registered in base file manager
  for ( const auto& fileName : GetFileNames() ) {
    auto fileManager = GetFileManager(fileName);
    if ( ! fileManager ) {
      FileManagerWarning(fileName, fkClass, "OpenFiles", fHdf5Warn);
      continue;
    }
 
    result &= fileManager->CreateFile(fileName);
  }
 
  Message(kVL3, "open", "analysis files", "", result);
 
  return result;
}

References fHdf5Warn, anonymous_namespace{G4GenericFileManager.cc}::FileManagerWarning(), fkClass, GetFileManager(), G4BaseFileManager::GetFileNames(), G4Analysis::kVL3, G4Analysis::kVL4, and G4BaseFileManager::Message().

◆ SetDefaultFileType()

void G4GenericFileManager::SetDefaultFileType ( const G4String & value )

Definition at line 385 of file G4GenericFileManager.cc.

{
  // Check if value correspond to a valid file type
  auto output = G4Analysis::GetOutput(value);
  if ( output == G4AnalysisOutput::kNone ) {
    Warn("The file type " + value + "is not supported.\n" +
         "The default type " + fDefaultFileType + " will be used.",
         fkClass, "SetDeafultFileType");
    return;
  }
 
  fDefaultFileType = value;
}

References fDefaultFileType, fkClass, G4Analysis::GetOutput(), kNone, and G4Analysis::Warn().

◆ SetFileName()

G4bool G4VFileManager::SetFileName ( const G4String & fileName )

finalvirtualinherited

Reimplemented from G4BaseFileManager.

Definition at line 45 of file G4VFileManager.cc.

{
  // Check extension
  auto name = fileName;
  auto extension = G4Analysis::GetExtension(fileName);
  if ( extension.size() && GetFileType().size() && extension != GetFileType() ) {
    // replace extension
    name = G4Analysis::GetBaseName(fileName) + "." + GetFileType();
    Warn(fileName + " file extension is not valid for " + GetFileType() + " output.\n" +
         name + " will be used.", fkClass, "SetFileName");
  }
 
  return G4BaseFileManager::SetFileName(name);
}

References G4VFileManager::fkClass, G4Analysis::GetBaseName(), G4Analysis::GetExtension(), G4BaseFileManager::GetFileType(), G4InuclParticleNames::name(), G4BaseFileManager::SetFileName(), and G4Analysis::Warn().

Referenced by OpenFile().

◆ SetHistoDirectoryName()

G4bool G4GenericFileManager::SetHistoDirectoryName ( const G4String & dirName )

virtual

Reimplemented from G4VFileManager.

Definition at line 359 of file G4GenericFileManager.cc.

{
  auto result = G4VFileManager::SetHistoDirectoryName(dirName);
 
  for (auto fileManager : fFileManagers ) {
    if ( fileManager != nullptr ) {
      result &= fileManager->SetHistoDirectoryName(dirName);
    }
  }
  return result;
}

References fFileManagers, and G4VFileManager::SetHistoDirectoryName().

◆ SetIsEmpty()

G4bool G4GenericFileManager::SetIsEmpty	(	const G4String &	fileName,
		G4bool	isEmpty
	)

finalvirtual

Implements G4VFileManager.

Definition at line 347 of file G4GenericFileManager.cc.

{
  auto fileManager = GetFileManager(fileName);
  if ( ! fileManager ) {
    FileManagerWarning(fileName, fkClass, "SetIsEmpty", fHdf5Warn);
    return false;
  }
 
  return fileManager->SetIsEmpty(fileName, isEmpty);
}

References fHdf5Warn, anonymous_namespace{G4GenericFileManager.cc}::FileManagerWarning(), fkClass, and GetFileManager().

◆ SetNtupleDirectoryName()

G4bool G4GenericFileManager::SetNtupleDirectoryName ( const G4String & dirName )

virtual

Reimplemented from G4VFileManager.

Definition at line 372 of file G4GenericFileManager.cc.

{
  auto result = G4VFileManager::SetNtupleDirectoryName(dirName);
 
  for (auto fileManager : fFileManagers ) {
    if ( fileManager != nullptr ) {
      result &= fileManager->SetNtupleDirectoryName(dirName);
    }
  }
  return result;
}

References fFileManagers, and G4VFileManager::SetNtupleDirectoryName().

◆ UnlockDirectoryNames()

void G4VFileManager::UnlockDirectoryNames ( )

inlineinherited

Definition at line 114 of file G4VFileManager.hh.

115{ fLockDirectoryNames = false; }

References G4VFileManager::fLockDirectoryNames.

Referenced by Clear().

◆ WriteFile()

G4bool G4GenericFileManager::WriteFile ( const G4String & fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 319 of file G4GenericFileManager.cc.

{
// New prototype, fully implemented in templated base class
 
  auto fileManager = GetFileManager(fileName);
  if ( ! fileManager ) {
    FileManagerWarning(fileName, fkClass, "WriteFile", fHdf5Warn);
    return false;
  }
 
  return fileManager->WriteFile(fileName);
}

References fHdf5Warn, anonymous_namespace{G4GenericFileManager.cc}::FileManagerWarning(), fkClass, and GetFileManager().

◆ WriteFiles()

G4bool G4GenericFileManager::WriteFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 224 of file G4GenericFileManager.cc.

{
// Finish write for all files registered with objects
 
  Message(kVL4, "write", "analysis files");
 
  auto result = true;
 
  for ( const auto& fileManager : fFileManagers ) {
    if ( ! fileManager ) continue;
 
    Message(kVL4, "write", fileManager->GetFileType(), "files");
 
    result &= fileManager->WriteFiles();
  }
 
  Message(kVL3, "write", "analysis files", "", result);
 
  return result;
}

References fFileManagers, G4Analysis::kVL3, G4Analysis::kVL4, and G4BaseFileManager::Message().

◆ WriteTExtra()

template<typename HT >

G4bool G4GenericFileManager::WriteTExtra	(	const G4String &	fileName,
		HT *	ht,
		const G4String &	htName
	)

Field Documentation

◆ fCsvFileManager

std::shared_ptr<G4CsvFileManager> G4GenericFileManager::fCsvFileManager { nullptr }

private

Definition at line 112 of file G4GenericFileManager.hh.

Referenced by CreateFileManager(), and CreateNtupleFileManager().

◆ fDefaultFileManager

std::shared_ptr<G4VFileManager> G4GenericFileManager::fDefaultFileManager { nullptr }

private

Definition at line 107 of file G4GenericFileManager.hh.

Referenced by OpenFile().

◆ fDefaultFileType

G4String G4GenericFileManager::fDefaultFileType

private

Definition at line 106 of file G4GenericFileManager.hh.

Referenced by GetFileManager(), OpenFile(), and SetDefaultFileType().

◆ fFileManagers

std::vector<std::shared_ptr<G4VFileManager> > G4GenericFileManager::fFileManagers

private

Initial value:

{
       
       nullptr, nullptr, nullptr, nullptr
     }

Definition at line 108 of file G4GenericFileManager.hh.

Referenced by Clear(), CloseFiles(), CreateFileManager(), DeleteEmptyFiles(), GetFileManager(), SetHistoDirectoryName(), SetNtupleDirectoryName(), and WriteFiles().

◆ fFileName

G4String G4BaseFileManager::fFileName

protectedinherited

Definition at line 95 of file G4BaseFileManager.hh.

Referenced by G4BaseFileManager::GetFileName(), G4BaseFileManager::GetFullFileName(), G4BaseFileManager::GetHnFileName(), G4BaseFileManager::GetNtupleFileName(), G4RootFileManager::GetNtupleFileName(), G4BaseFileManager::GetPlotFileName(), G4CsvFileManager::OpenFile(), G4Hdf5FileManager::OpenFile(), G4RootFileManager::OpenFile(), G4XmlFileManager::OpenFile(), and G4BaseFileManager::SetFileName().

◆ fFileNames

std::vector<G4String> G4BaseFileManager::fFileNames

protectedinherited

Definition at line 96 of file G4BaseFileManager.hh.

Referenced by G4BaseFileManager::AddFileName(), and G4BaseFileManager::GetFileNames().

◆ fH1FileManager

std::shared_ptr<G4VTHnFileManager<tools::histo::h1d> > G4VFileManager::fH1FileManager { nullptr }

protectedinherited

Definition at line 102 of file G4VFileManager.hh.

Referenced by G4CsvFileManager::G4CsvFileManager(), G4Hdf5FileManager::G4Hdf5FileManager(), G4RootFileManager::G4RootFileManager(), and G4XmlFileManager::G4XmlFileManager().

◆ fH2FileManager

std::shared_ptr<G4VTHnFileManager<tools::histo::h2d> > G4VFileManager::fH2FileManager { nullptr }

protectedinherited

Definition at line 103 of file G4VFileManager.hh.

Referenced by G4CsvFileManager::G4CsvFileManager(), G4Hdf5FileManager::G4Hdf5FileManager(), G4RootFileManager::G4RootFileManager(), and G4XmlFileManager::G4XmlFileManager().

◆ fH3FileManager

std::shared_ptr<G4VTHnFileManager<tools::histo::h3d> > G4VFileManager::fH3FileManager { nullptr }

protectedinherited

Definition at line 104 of file G4VFileManager.hh.

Referenced by G4CsvFileManager::G4CsvFileManager(), G4Hdf5FileManager::G4Hdf5FileManager(), G4RootFileManager::G4RootFileManager(), and G4XmlFileManager::G4XmlFileManager().

◆ fHdf5Warn

G4bool G4GenericFileManager::fHdf5Warn { true }

private

Definition at line 118 of file G4GenericFileManager.hh.

Referenced by CloseFile(), CreateFile(), CreateFileManager(), OpenFiles(), SetIsEmpty(), and WriteFile().

◆ fHistoDirectoryName

G4String G4VFileManager::fHistoDirectoryName

protectedinherited

Definition at line 96 of file G4VFileManager.hh.

Referenced by G4Hdf5FileManager::CreateFileImpl(), G4RootFileManager::CreateFileImpl(), G4VFileManager::GetHistoDirectoryName(), and G4VFileManager::SetHistoDirectoryName().

◆ fIsOpenFile

G4bool G4VFileManager::fIsOpenFile { false }

protectedinherited

Definition at line 98 of file G4VFileManager.hh.

Referenced by CloseFiles(), G4VFileManager::IsOpenFile(), G4CsvFileManager::OpenFile(), OpenFile(), G4Hdf5FileManager::OpenFile(), G4RootFileManager::OpenFile(), and G4XmlFileManager::OpenFile().

◆ fkClass

constexpr std::string_view G4GenericFileManager::fkClass { "G4GenericFileManager" }

staticconstexprprivate

Definition at line 101 of file G4GenericFileManager.hh.

Referenced by CloseFile(), CreateFile(), CreateFileManager(), CreateNtupleFileManager(), GetFileManager(), OpenFile(), OpenFiles(), SetDefaultFileType(), SetIsEmpty(), and WriteFile().

◆ fLockDirectoryNames

G4bool G4VFileManager::fLockDirectoryNames { false }

protectedinherited

Definition at line 99 of file G4VFileManager.hh.

Referenced by G4VFileManager::LockDirectoryNames(), G4VFileManager::SetHistoDirectoryName(), G4VFileManager::SetNtupleDirectoryName(), and G4VFileManager::UnlockDirectoryNames().

◆ fNtupleDirectoryName

G4String G4VFileManager::fNtupleDirectoryName

protectedinherited

Definition at line 97 of file G4VFileManager.hh.

Referenced by G4Hdf5FileManager::CreateFileImpl(), G4RootFileManager::CreateFileImpl(), G4VFileManager::GetNtupleDirectoryName(), and G4VFileManager::SetNtupleDirectoryName().

◆ fP1FileManager

std::shared_ptr<G4VTHnFileManager<tools::histo::p1d> > G4VFileManager::fP1FileManager { nullptr }

protectedinherited

Definition at line 105 of file G4VFileManager.hh.

Referenced by G4CsvFileManager::G4CsvFileManager(), G4Hdf5FileManager::G4Hdf5FileManager(), G4RootFileManager::G4RootFileManager(), and G4XmlFileManager::G4XmlFileManager().

◆ fP2FileManager

std::shared_ptr<G4VTHnFileManager<tools::histo::p2d> > G4VFileManager::fP2FileManager { nullptr }

protectedinherited

Definition at line 106 of file G4VFileManager.hh.

Referenced by G4CsvFileManager::G4CsvFileManager(), G4Hdf5FileManager::G4Hdf5FileManager(), G4RootFileManager::G4RootFileManager(), and G4XmlFileManager::G4XmlFileManager().

◆ fRootFileManager

std::shared_ptr<G4RootFileManager> G4GenericFileManager::fRootFileManager { nullptr }

private

Definition at line 116 of file G4GenericFileManager.hh.

Referenced by CreateFileManager(), and CreateNtupleFileManager().

◆ fState

const G4AnalysisManagerState& G4BaseFileManager::fState

protectedinherited

Definition at line 94 of file G4BaseFileManager.hh.

Referenced by G4RootFileManager::CreateFileImpl(), CreateFileManager(), CreateNtupleFileManager(), G4BaseFileManager::GetFileType(), G4BaseFileManager::Message(), and G4XmlFileManager::OpenFile().

◆ fXmlFileManager

std::shared_ptr<G4XmlFileManager> G4GenericFileManager::fXmlFileManager { nullptr }

private

Definition at line 117 of file G4GenericFileManager.hh.

Referenced by CreateFileManager(), and CreateNtupleFileManager().

The documentation for this class was generated from the following files:

source/analysis/factory/include/G4GenericFileManager.hh
source/analysis/factory/src/G4GenericFileManager.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4GenericFileManager()

◆ ~G4GenericFileManager()

Member Function Documentation

◆ AddFileName()

◆ Clear()

◆ CloseFile()

◆ CloseFiles()

◆ CreateFile()

◆ CreateFileManager()

◆ CreateNtupleFileManager()

◆ DeleteEmptyFiles()

◆ GetDefaultFileType()

◆ GetFileManager() [1/2]

◆ GetFileManager() [2/2]

◆ GetFileName()

◆ GetFileNames()

◆ GetFileType()

◆ GetFullFileName()

◆ GetHistoDirectoryName()

◆ GetHnFileManager()

◆ GetHnFileName()

◆ GetNtupleDirectoryName()

◆ GetNtupleFileName() [1/2]

◆ GetNtupleFileName() [2/2]

◆ GetPlotFileName()

◆ IsOpenFile()

◆ LockDirectoryNames()

◆ Message()

◆ OpenFile()

◆ OpenFiles()

◆ SetDefaultFileType()

◆ SetFileName()

◆ SetHistoDirectoryName()

◆ SetIsEmpty()

◆ SetNtupleDirectoryName()

◆ UnlockDirectoryNames()

◆ WriteFile()

◆ WriteFiles()

◆ WriteTExtra()

Field Documentation

◆ fCsvFileManager

◆ fDefaultFileManager

◆ fDefaultFileType

◆ fFileManagers

◆ fFileName

◆ fFileNames

◆ fH1FileManager

◆ fH2FileManager

◆ fH3FileManager

◆ fHdf5Warn

◆ fHistoDirectoryName

◆ fIsOpenFile

◆ fkClass

◆ fLockDirectoryNames

◆ fNtupleDirectoryName

◆ fP1FileManager

◆ fP2FileManager

◆ fRootFileManager

◆ fState

◆ fXmlFileManager