G4GenericFileManager Class Reference

#include <G4GenericFileManager.hh>

Inheritance diagram for G4GenericFileManager:

Public Member Functions
	G4GenericFileManager (const G4AnalysisManagerState &state)
	~G4GenericFileManager () override=default
G4bool	OpenFile (const G4String &fileName) final
virtual G4bool	OpenFiles () final
G4bool	WriteFiles () final
G4bool	CloseFiles () final
G4bool	DeleteEmptyFiles () final
void	Clear () final
G4bool	CreateFile (const G4String &fileName) final
G4bool	WriteFile (const G4String &fileName) final
G4bool	CloseFile (const G4String &fileName) final
G4bool	SetIsEmpty (const G4String &fileName, G4bool isEmpty) final
G4bool	SetHistoDirectoryName (const G4String &dirName) override
G4bool	SetNtupleDirectoryName (const G4String &dirName) override
G4String	GetFileType () const final
void	SetDefaultFileType (const G4String &value)
G4String	GetDefaultFileType () const
std::shared_ptr< G4VFileManager >	GetFileManager (const G4String &fileName)
template<typename HT >
G4bool	WriteTExtra (const G4String &fileName, HT *ht, const G4String &htName)
std::shared_ptr< G4VNtupleFileManager >	CreateNtupleFileManager (G4AnalysisOutput output)
Public Member Functions inherited from G4VFileManager
	G4VFileManager (const G4AnalysisManagerState &state)
	G4VFileManager ()=delete
	~G4VFileManager () override=default
G4bool	SetFileName (const G4String &fileName) final
void	LockDirectoryNames ()
void	UnlockDirectoryNames ()
G4bool	IsOpenFile () const
G4String	GetHistoDirectoryName () const
G4String	GetNtupleDirectoryName () const
G4int	GetCycle () const
template<typename HT >
std::shared_ptr< G4VTHnFileManager< HT > >	GetHnFileManager () const
Public Member Functions inherited from G4BaseFileManager
	G4BaseFileManager (const G4AnalysisManagerState &state)
	G4BaseFileManager ()=delete
virtual	~G4BaseFileManager ()=default
void	SetCompressionLevel (G4int level)
virtual G4bool	HasCycles () const
void	AddFileName (const G4String &fileName)
G4int	GetCompressionLevel () const
G4String	GetFileName () const
G4String	GetFullFileName (const G4String &baseFileName="", G4bool isPerThread=true) const
const std::vector< G4String > &	GetFileNames () const
G4String	GetHnFileName (const G4String &hnType, const G4String &hnName) const
G4String	GetHnFileName (const G4String &fileName, G4int cycle=0) const
G4String	GetNtupleFileName (const G4String &ntupleName, G4int cycle=0) const
G4String	GetNtupleFileName (G4int ntupleFileNumber, G4int cycle=0) const
G4String	GetPlotFileName () const

Additional Inherited Members
Protected Member Functions inherited from G4BaseFileManager
void	Message (G4int level, const G4String &action, const G4String &objectType, const G4String &objectName="", G4bool success=true) const
void	ClearData ()
Protected Attributes inherited from G4VFileManager
G4String	fHistoDirectoryName
G4String	fNtupleDirectoryName
G4bool	fIsOpenFile { false }
G4bool	fLockDirectoryNames { false }
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 }
std::shared_ptr< G4VTHnFileManager< tools::histo::p1d > >	fP1FileManager { nullptr }
std::shared_ptr< G4VTHnFileManager< tools::histo::p2d > >	fP2FileManager { nullptr }
Protected Attributes inherited from G4BaseFileManager
const G4AnalysisManagerState &	fState
G4int	fCompressionLevel { 1 }
G4String	fFileName
std::vector< G4String >	fFileNames
Static Protected Attributes inherited from G4VFileManager
static constexpr std::string_view	fkClass { "G4VFileManager" }

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.

 : G4VFileManager(state)
{}

~G4GenericFileManager()

G4GenericFileManager::~G4GenericFileManager ( )

overridedefault

Member Function Documentation

Clear()

void G4GenericFileManager::Clear ( )

finalvirtual

Implements G4VFileManager.

Definition at line 301 of file G4GenericFileManager.cc.

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

CloseFile()

G4bool G4GenericFileManager::CloseFile ( const G4String & fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 342 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);
}

CloseFiles()

G4bool G4GenericFileManager::CloseFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 252 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;
}

CreateFile()

G4bool G4GenericFileManager::CreateFile ( const G4String & fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 314 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);
}

CreateNtupleFileManager()

std::shared_ptr< G4VNtupleFileManager > G4GenericFileManager::CreateNtupleFileManager

(

G4AnalysisOutput

output

)

Definition at line 410 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;
}

DeleteEmptyFiles()

G4bool G4GenericFileManager::DeleteEmptyFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 276 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();
  }
 
  // Clear all saved file names in base file manager
  G4BaseFileManager::ClearData();
 
  Message(kVL3, "delete", "empty files", "", result);
 
  return result;
}

GetDefaultFileType()

G4String G4GenericFileManager::GetDefaultFileType

(

)

const

GetFileManager()

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() == 0u) {
    // 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);
}

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

GetFileType()

G4String G4GenericFileManager::GetFileType ( ) const

inlinefinalvirtual

Reimplemented from G4BaseFileManager.

Definition at line 79 of file G4GenericFileManager.hh.

{ return ""; }

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;
}

OpenFiles()

G4bool G4GenericFileManager::OpenFiles ( )

finalvirtual

Implements G4VFileManager.

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;
    }
 
    // filenames for csv need to be updated
    auto newFileName = fileName;
    if (fileManager == fCsvFileManager) {
      newFileName = fileManager->GetHnFileName(fileName, GetCycle());
    }
 
    result &= fileManager->CreateFile(newFileName);
  }
 
  Message(kVL3, "open", "analysis files", "", result);
 
  return result;
}

SetDefaultFileType()

void G4GenericFileManager::SetDefaultFileType

(

const G4String &

value

)

Definition at line 394 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;
}

SetHistoDirectoryName()

G4bool G4GenericFileManager::SetHistoDirectoryName ( const G4String & dirName )

overridevirtual

Reimplemented from G4VFileManager.

Definition at line 368 of file G4GenericFileManager.cc.

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

SetIsEmpty()

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

finalvirtual

Implements G4VFileManager.

Definition at line 356 of file G4GenericFileManager.cc.

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

SetNtupleDirectoryName()

G4bool G4GenericFileManager::SetNtupleDirectoryName ( const G4String & dirName )

overridevirtual

Reimplemented from G4VFileManager.

Definition at line 381 of file G4GenericFileManager.cc.

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

WriteFile()

G4bool G4GenericFileManager::WriteFile ( const G4String & fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 328 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);
}

WriteFiles()

G4bool G4GenericFileManager::WriteFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 230 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;
}

WriteTExtra()

template<typename HT >

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

---

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

• G4GenericFileManager.hh
• G4GenericFileManager.cc