G4GenericFileManager Class Reference

#include <G4GenericFileManager.hh>

Inheritance diagram for G4GenericFileManager:

Public Member Functions
	G4GenericFileManager (const G4AnalysisManagerState &state)
virtual	~G4GenericFileManager ()
virtual G4bool	OpenFile (const G4String &fileName) final
virtual G4bool	OpenFiles () final
virtual G4bool	WriteFiles () final
virtual G4bool	CloseFiles () final
virtual G4bool	DeleteEmptyFiles () final
virtual G4bool	CreateFile (const G4String &fileName) final
virtual G4bool	WriteFile (const G4String &fileName) final
virtual G4bool	CloseFile (const G4String &fileName) final
virtual G4bool	SetIsEmpty (const G4String &fileName, G4bool isEmpty) final
virtual G4String	GetFileType () const final
void	SetDefaultFileType (const G4String &value)
G4String	GetDefaultFileType () const
template<typename T >
G4bool	WriteT (const std::vector< T * > &htVector, const std::vector< G4HnInformation * > &hnVector)
template<typename T >
G4bool	WriteTExtra (const G4String &fileName, T *ht, const G4String &htName)
std::shared_ptr< G4VNtupleFileManager >	CreateNtupleFileManager (G4AnalysisOutput output)
Public Member Functions inherited from G4VFileManager
	G4VFileManager (const G4AnalysisManagerState &state)
virtual	~G4VFileManager ()
virtual G4bool	OpenFile (const G4String &fileName)=0
virtual G4bool	CreateFile (const G4String &fileName)=0
virtual G4bool	WriteFile (const G4String &fileName)=0
virtual G4bool	CloseFile (const G4String &fileName)=0
virtual G4bool	SetIsEmpty (const G4String &fileName, G4bool isEmpty)=0
virtual G4bool	WriteFiles ()=0
virtual G4bool	CloseFiles ()=0
virtual G4bool	DeleteEmptyFiles ()=0
virtual G4bool	SetFileName (const G4String &fileName) final
G4bool	SetHistoDirectoryName (const G4String &dirName)
G4bool	SetNtupleDirectoryName (const G4String &dirName)
void	LockDirectoryNames ()
G4bool	IsOpenFile () const
G4String	GetHistoDirectoryName () const
G4String	GetNtupleDirectoryName () const
template<typename HT >
std::shared_ptr< G4VTHnFileManager< HT > >	GetHnFileManager () const
Public Member Functions inherited from G4BaseFileManager
	G4BaseFileManager (const G4AnalysisManagerState &state)
virtual	~G4BaseFileManager ()
virtual G4bool	SetFileName (const G4String &fileName)
virtual G4String	GetFileType () const
void	AddFileName (const G4String &fileName)
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	GetNtupleFileName (const G4String &ntupleName) const
G4String	GetNtupleFileName (G4int ntupleFileNumber) const
G4String	GetPlotFileName () const

Additional Inherited Members
Protected Attributes inherited from G4VFileManager
G4String	fHistoDirectoryName
G4String	fNtupleDirectoryName
G4bool	fIsOpenFile
G4bool	fLockDirectoryNames
std::shared_ptr< G4VTHnFileManager< tools::histo::h1d > >	fH1FileManager
std::shared_ptr< G4VTHnFileManager< tools::histo::h2d > >	fH2FileManager
std::shared_ptr< G4VTHnFileManager< tools::histo::h3d > >	fH3FileManager
std::shared_ptr< G4VTHnFileManager< tools::histo::p1d > >	fP1FileManager
std::shared_ptr< G4VTHnFileManager< tools::histo::p2d > >	fP2FileManager
Protected Attributes inherited from G4BaseFileManager
const G4AnalysisManagerState &	fState
G4String	fFileName
std::vector< G4String >	fFileNames

Detailed Description

Definition at line 51 of file G4GenericFileManager.hh.

Constructor & Destructor Documentation

G4GenericFileManager()

G4GenericFileManager::G4GenericFileManager ( const G4AnalysisManagerState &  state )

explicit

Definition at line 68 of file G4GenericFileManager.cc.

 : G4VFileManager(state),
   fDefaultFileType(fgkDefaultFileType),
   fDefaultFileManager(nullptr),
   fFileManagers
     { nullptr, // Csv
       nullptr, // Hdf5
       nullptr, // Generic
       nullptr  // Xml
     },
   fCsvFileManager(nullptr),
#ifdef TOOLS_USE_HDF5
   fHdf5FileManager(nullptr),
#endif
   fRootFileManager(nullptr),
   fXmlFileManager(nullptr),
   fHdf5Warn(true)
{}

~G4GenericFileManager()

G4GenericFileManager::~G4GenericFileManager ( )

virtual

Definition at line 88 of file G4GenericFileManager.cc.

{}

Member Function Documentation

CloseFile()

G4bool G4GenericFileManager::CloseFile ( const G4String &  fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 423 of file G4GenericFileManager.cc.

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

CloseFiles()

G4bool G4GenericFileManager::CloseFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 323 of file G4GenericFileManager.cc.

{
// Close all files regeistered with objects
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL4() ) {
    fState.GetVerboseL4()->Message("close", "files", "");
  }
#endif
 
  auto finalResult = true;
  auto result = true;
 
  for ( auto fileManager : fFileManagers ) {
    if ( ! fileManager ) continue;
 
#ifdef G4VERBOSE
    if ( fState.GetVerboseL4() ) {
      fState.GetVerboseL4()->Message("close", fileManager->GetFileType(), "files");
    }
#endif
 
    result = fileManager->CloseFiles();
    finalResult = result && finalResult;
  }
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL3() ) {
    fState.GetVerboseL3()->Message("close", "files", "", finalResult);
  }
#endif
 
  return finalResult;
}

CreateFile()

G4bool G4GenericFileManager::CreateFile ( const G4String &  fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 395 of file G4GenericFileManager.cc.

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

CreateNtupleFileManager()

std::shared_ptr< G4VNtupleFileManager > G4GenericFileManager::CreateNtupleFileManager

(

G4AnalysisOutput

output

)

Definition at line 468 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 ) {
      G4ExceptionDescription description;
      description 
        << "      " 
        << "Failed to create ntuple file manager of " << G4Analysis::GetOutputName(output) << " type."
        << failure;
      G4Exception("G4GenericFileManager::CreateNtupleFileManager",
                  "Analysis_W002", JustWarning, description);
  }
 
  return vNtupleFileManager;
}

DeleteEmptyFiles()

G4bool G4GenericFileManager::DeleteEmptyFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 359 of file G4GenericFileManager.cc.

{
// Close all files regeistered with objects
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL4() ) {
    fState.GetVerboseL4()->Message("delete", "empty files", "");
  }
#endif
 
  auto finalResult = true;
  auto result = true;
 
  for ( auto fileManager : fFileManagers ) {
    if ( ! fileManager ) continue;
 
#ifdef G4VERBOSE
    if ( fState.GetVerboseL4() ) {
      fState.GetVerboseL4()->Message("delete", fileManager->GetFileType(), "files");
    }
#endif
 
    result = fileManager->DeleteEmptyFiles();
    finalResult = result && finalResult;
  }
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL3() ) {
    fState.GetVerboseL3()->Message("delete", "empty files", "", finalResult);
  }
#endif
 
  return finalResult;
}

GetDefaultFileType()

G4String G4GenericFileManager::GetDefaultFileType

(

)

const

GetFileType()

virtual G4String G4GenericFileManager::GetFileType ( ) const

inlinefinalvirtual

Reimplemented from G4BaseFileManager.

Definition at line 72 of file G4GenericFileManager.hh.

{ return ""; }

OpenFile()

G4bool G4GenericFileManager::OpenFile ( const G4String &  fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 202 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?)
    G4ExceptionDescription description;
    description
      << "Default file manager changed (old: " 
      << fDefaultFileManager->GetFileType()
      << ", new:" << fileManager->GetFileType() << ")";
    G4Exception("G4GenericFileManager::OpenFile",
                "Analysis_W001", JustWarning, description);
  } 
  fDefaultFileManager = fileManager;
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL4() ) {
    fState.GetVerboseL4()->Message("open", "analysis file", fileName);
  }
#endif
 
  auto finalResult = true;
  auto result = true;
 
  // Save the default file name 
  // both in the generic file manager and the output specific one
  result = SetFileName(fileName);
  finalResult = finalResult && result;
  result = fDefaultFileManager->SetFileName(fileName);
  finalResult = finalResult && result;
 
  result = fDefaultFileManager->OpenFile(fileName);
  finalResult = finalResult && result;
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL1() ) {
    fState.GetVerboseL1()->Message("open", "analysis file", fileName, finalResult);
  }
#endif
 
  fLockDirectoryNames = true;
  fIsOpenFile = true;
 
  return finalResult;  
}

OpenFiles()

G4bool G4GenericFileManager::OpenFiles ( )

finalvirtual

Definition at line 252 of file G4GenericFileManager.cc.

{
// Open all files regeistered with objects
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL4() ) {
    fState.GetVerboseL4()->Message("open", "analysis files", "");
  }
#endif
 
  auto finalResult = true;
  auto result = true;
 
  // process names registered in base file manager
  for ( auto fileName : GetFileNames() ) {
    auto fileManager = GetFileManager(fileName);
    if ( ! fileManager ) {
      FileManagerException(fileName, "OpenFiles", "W001", fHdf5Warn);
      continue;
    }
 
    result = fileManager->CreateFile(fileName);
    finalResult = result && finalResult;    
  }
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL3() ) {
    fState.GetVerboseL3()->Message("open", "analysis files", "", finalResult);
  }
#endif
 
  return finalResult;
}

SetDefaultFileType()

void G4GenericFileManager::SetDefaultFileType

(

const G4String &

value

)

Definition at line 449 of file G4GenericFileManager.cc.

{
  // Check if value correspond to a valid file type
  auto output = G4Analysis::GetOutput(value);
  if ( output == G4AnalysisOutput::kNone ) {
    G4ExceptionDescription description;
    description
      << "The file type " << value << "is not supported." << G4endl
      << "The default type " << fDefaultFileType << " will be used.";
    G4Exception("G4GenericFileManager::SetDeafultFileType",
                "Analysis_W051", JustWarning, description);
    return;
  }
 
  fDefaultFileType = value;
}

SetIsEmpty()

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

finalvirtual

Implements G4VFileManager.

Definition at line 437 of file G4GenericFileManager.cc.

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

WriteFile()

G4bool G4GenericFileManager::WriteFile ( const G4String &  fileName )

finalvirtual

Implements G4VFileManager.

Definition at line 409 of file G4GenericFileManager.cc.

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

WriteFiles()

G4bool G4GenericFileManager::WriteFiles ( )

finalvirtual

Implements G4VFileManager.

Definition at line 287 of file G4GenericFileManager.cc.

{
// Finish write for all files regeistered with objects
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL4() ) {
    fState.GetVerboseL4()->Message("write", "files", "");
  }
#endif
 
  auto finalResult = true;
  auto result = true;
 
  for ( auto fileManager : fFileManagers ) {
    if ( ! fileManager ) continue;
 
#ifdef G4VERBOSE
    if ( fState.GetVerboseL4() ) {
      fState.GetVerboseL4()->Message("write", fileManager->GetFileType(), "files");
    }
#endif
 
    result = fileManager->WriteFiles();
    finalResult = result && finalResult;
  }
 
#ifdef G4VERBOSE
  if ( fState.GetVerboseL3() ) {
    fState.GetVerboseL3()->Message("write", "files", "", finalResult);
  }
#endif
 
  return finalResult;
}

WriteT()

template<typename T >

G4bool G4GenericFileManager::WriteT	(	const std::vector< T * > &	htVector,
		const std::vector< G4HnInformation * > &	hnVector
	)

WriteTExtra()

template<typename T >

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

---

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

• G4GenericFileManager.hh
• G4GenericFileManager.cc