Geant4-11
G4GenericFileManager.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26
27// Author: Ivana Hrivnacova, 15/06/2011 (ivana@ipno.in2p3.fr)
28
32#include "G4CsvFileManager.hh"
34#ifdef TOOLS_USE_HDF5
35#include "G4Hdf5FileManager.hh"
37#endif
38#include "G4RootFileManager.hh"
40#include "G4XmlFileManager.hh"
42
43using namespace G4Analysis;
44
45namespace {
46
47//_____________________________________________________________________________
48void FileManagerWarning(const G4String& fileName,
49 std::string_view className,
50 std::string_view functionName,
51 G4bool hdf5Warn = true)
52{
53 if ( GetExtension(fileName) == "hdf5" && ( ! hdf5Warn ) ) return;
54
55 Warn("Cannot get file manager for " + fileName,
56 className, functionName);
57}
58
59}
60
61//_____________________________________________________________________________
63 : G4VFileManager(state)
64{}
65
66//
67// private methods
68//
69
70//_____________________________________________________________________________
72{
73 Message(kVL4, "create", "file manager", GetOutputName(output));
74
75 auto outputId = static_cast<size_t>(output);
76 if ( fFileManagers[outputId] ) {
77 Warn("The file manager of " + G4Analysis::GetOutputName(output) +
78 " type already exists.",
79 fkClass, "CreateFileManager");
80 return;
81 }
82
83 // Create the manager
84 switch ( output ) {
86 fCsvFileManager = std::make_shared<G4CsvFileManager>(fState);
88 break;
90#ifdef TOOLS_USE_HDF5
91 fHdf5FileManager = std::make_shared<G4Hdf5FileManager>(fState);
92 fFileManagers[outputId] = fHdf5FileManager;
93#else
94 if ( fHdf5Warn) {
95 Warn("Hdf5 type is not available.", fkClass, "CreateFileManager");
96 fHdf5Warn = false;
97 }
98#endif
99 break;
101 fRootFileManager = std::make_shared<G4RootFileManager>(fState);
103 break;
105 fXmlFileManager = std::make_shared<G4XmlFileManager>(fState);
106 fFileManagers[outputId] = fXmlFileManager ;
107 break;
109 Warn(G4Analysis::GetOutputName(output) + " type is not supported.",
110 fkClass, "CreateFileManager");
111 return;
112 }
113
114 // Pass directory names (only if set)
115 if ( ! GetHistoDirectoryName().empty() ) {
116 fFileManagers[outputId]->SetHistoDirectoryName(GetHistoDirectoryName());
117 }
118 if ( ! GetNtupleDirectoryName().empty() ) {
119 fFileManagers[outputId]->SetNtupleDirectoryName(GetNtupleDirectoryName());
120 }
121
122 Message(kVL3, "create", "file manager", GetOutputName(output));
123}
124
125//_____________________________________________________________________________
126std::shared_ptr<G4VFileManager>
128{
129 return fFileManagers[static_cast<size_t>(output)];
130}
131
132//_____________________________________________________________________________
133std::shared_ptr<G4VFileManager>
135{
136 // Get file extension
137 G4String extension = GetExtension(fileName);
138 if ( ! extension.size() ) {
139 // use the default
140 extension = fDefaultFileType;
141 }
142
143 auto output = G4Analysis::GetOutput(extension);
144 if ( output == G4AnalysisOutput::kNone ) {
145 Warn("The file extension " + extension + "is not supported.",
146 fkClass, "GetFileManager");
147 return nullptr;
148 }
149
150 std::shared_ptr<G4VFileManager> fileManager = GetFileManager(output);
151 if ( ! GetFileManager(output) ) {
152 CreateFileManager(output);
153 fileManager = GetFileManager(output);
154 }
155
156 return GetFileManager(output);
157}
158
159//
160// public methods
161//
162
163//_____________________________________________________________________________
165{
166 auto fileManager = GetFileManager(fileName);
167 if ( ! fileManager ) return false;
168
169 if ( fDefaultFileManager && (fDefaultFileManager != fileManager) ) {
170 // Print warning if default output changed
171 // (maybe be not needed?)
172 Warn("Default file manager changed "
173 "(old: " +fDefaultFileManager->GetFileType() +
174 ", new:" + fileManager->GetFileType() + ")",
175 fkClass, "OpenFile");
176 }
177 fDefaultFileManager = fileManager;
178 fDefaultFileType = fileManager->GetFileType();
179
180 Message(kVL4, "open", "analysis file", fileName);
181
182 auto result = true;
183
184 // Save the default file name
185 // both in the generic file manager and the output specific one
186 result &= SetFileName(fileName);
187 result &= fDefaultFileManager->SetFileName(fileName);
188 result &= fDefaultFileManager->OpenFile(fileName);
189
191 fIsOpenFile = true;
192
193 Message(kVL1, "open", "analysis file", fileName, result);
194
195 return result;
196}
197
198//_____________________________________________________________________________
200{
201// Open all files regeistered with objects
202
203 Message(kVL4, "open", "analysis files");
204
205 auto result = true;
206
207 // process names registered in base file manager
208 for ( const auto& fileName : GetFileNames() ) {
209 auto fileManager = GetFileManager(fileName);
210 if ( ! fileManager ) {
211 FileManagerWarning(fileName, fkClass, "OpenFiles", fHdf5Warn);
212 continue;
213 }
214
215 result &= fileManager->CreateFile(fileName);
216 }
217
218 Message(kVL3, "open", "analysis files", "", result);
219
220 return result;
221}
222
223//_____________________________________________________________________________
225{
226// Finish write for all files registered with objects
227
228 Message(kVL4, "write", "analysis files");
229
230 auto result = true;
231
232 for ( const auto& fileManager : fFileManagers ) {
233 if ( ! fileManager ) continue;
234
235 Message(kVL4, "write", fileManager->GetFileType(), "files");
236
237 result &= fileManager->WriteFiles();
238 }
239
240 Message(kVL3, "write", "analysis files", "", result);
241
242 return result;
243}
244
245//_____________________________________________________________________________
247{
248// Close all files regeistered with objects
249
250 Message(kVL4, "close", "analysis files");
251
252 auto result = true;
253
254 for ( const auto& fileManager : fFileManagers ) {
255 if ( ! fileManager ) continue;
256
257 Message(kVL4, "close", fileManager->GetFileType(), "files");
258
259 result &= fileManager->CloseFiles();
260 }
261
262 fIsOpenFile = false;
263
264 Message(kVL3, "close", "analysis files", "", result);
265
266 return result;
267}
268
269//_____________________________________________________________________________
271{
272// Close all files regeistered with objects
273
274 Message(kVL4, "delete", "empty files");
275
276 auto result = true;
277
278 for ( const auto& fileManager : fFileManagers ) {
279 if ( ! fileManager ) continue;
280
281 Message(kVL4, "delete", fileManager->GetFileType(), "empty files");
282
283 result &= fileManager->DeleteEmptyFiles();
284 }
285
286 Message(kVL3, "delete", "empty files", "", result);
287
288 return result;
289}
290
291//_____________________________________________________________________________
293{
294// Clear files data
295
296 for ( const auto& fileManager : fFileManagers ) {
297 if ( ! fileManager ) continue;
298
299 fileManager->Clear();
300 }
302}
303
304//_____________________________________________________________________________
306{
307// New prototype, fully implemented in templated base class
308
309 auto fileManager = GetFileManager(fileName);
310 if ( ! fileManager ) {
311 FileManagerWarning(fileName, fkClass, "CreateFile", fHdf5Warn);
312 return false;
313 }
314
315 return fileManager->CreateFile(fileName);
316}
317
318//_____________________________________________________________________________
320{
321// New prototype, fully implemented in templated base class
322
323 auto fileManager = GetFileManager(fileName);
324 if ( ! fileManager ) {
325 FileManagerWarning(fileName, fkClass, "WriteFile", fHdf5Warn);
326 return false;
327 }
328
329 return fileManager->WriteFile(fileName);
330}
331
332//_____________________________________________________________________________
334{
335// New prototype, fully implemented in templated base class
336
337 auto fileManager = GetFileManager(fileName);
338 if ( ! fileManager ) {
339 FileManagerWarning(fileName, fkClass, "CloseFile", fHdf5Warn);
340 return false;
341 }
342
343 return fileManager->CloseFile(fileName);
344}
345
346//_____________________________________________________________________________
348{
349 auto fileManager = GetFileManager(fileName);
350 if ( ! fileManager ) {
351 FileManagerWarning(fileName, fkClass, "SetIsEmpty", fHdf5Warn);
352 return false;
353 }
354
355 return fileManager->SetIsEmpty(fileName, isEmpty);
356}
357
358//_____________________________________________________________________________
360{
361 auto result = G4VFileManager::SetHistoDirectoryName(dirName);
362
363 for (auto fileManager : fFileManagers ) {
364 if ( fileManager != nullptr ) {
365 result &= fileManager->SetHistoDirectoryName(dirName);
366 }
367 }
368 return result;
369}
370
371//_____________________________________________________________________________
373{
374 auto result = G4VFileManager::SetNtupleDirectoryName(dirName);
375
376 for (auto fileManager : fFileManagers ) {
377 if ( fileManager != nullptr ) {
378 result &= fileManager->SetNtupleDirectoryName(dirName);
379 }
380 }
381 return result;
382}
383
384//_____________________________________________________________________________
386{
387 // Check if value correspond to a valid file type
388 auto output = G4Analysis::GetOutput(value);
389 if ( output == G4AnalysisOutput::kNone ) {
390 Warn("The file type " + value + "is not supported.\n" +
391 "The default type " + fDefaultFileType + " will be used.",
392 fkClass, "SetDeafultFileType");
393 return;
394 }
395
396 fDefaultFileType = value;
397}
398
399//_____________________________________________________________________________
400std::shared_ptr<G4VNtupleFileManager>
402{
403 if ( ! GetFileManager(output) ) {
404 CreateFileManager(output);
405 }
406
407 std::shared_ptr<G4VNtupleFileManager> vNtupleFileManager = nullptr;
408 G4String failure;
409
410 switch ( output ) {
412 auto ntupleFileManager = std::make_shared<G4CsvNtupleFileManager>(fState);
413 ntupleFileManager->SetFileManager(fCsvFileManager);
414 vNtupleFileManager = ntupleFileManager;
415 break;
416 }
418#ifdef TOOLS_USE_HDF5
419 auto ntupleFileManager = std::make_shared<G4Hdf5NtupleFileManager>(fState);
420 ntupleFileManager->SetFileManager(fHdf5FileManager);
421 vNtupleFileManager = ntupleFileManager;
422#else
423 failure = " Hdf5 is not available";
424#endif
425 break;
426 }
428 auto ntupleFileManager = std::make_shared<G4RootNtupleFileManager>(fState);
429 ntupleFileManager->SetFileManager(fRootFileManager);
430 vNtupleFileManager = ntupleFileManager;
431 break;
432 }
434 auto ntupleFileManager = std::make_shared<G4XmlNtupleFileManager>(fState);
435 ntupleFileManager->SetFileManager(fXmlFileManager);
436 vNtupleFileManager = ntupleFileManager;
437 break;
438 }
440 break;
441 }
442
443 if ( ! vNtupleFileManager ) {
444 Warn("Failed to create ntuple file manager of " +
445 G4Analysis::GetOutputName(output) + " type.\n" + failure,
446 fkClass, "CreateNtupleFileManager");
447 }
448
449 return vNtupleFileManager;
450}
G4AnalysisOutput
bool G4bool
Definition: G4Types.hh:86
static char className[]
Definition: G4Win32.cc:36
const std::vector< G4String > & GetFileNames() const
void Message(G4int level, const G4String &action, const G4String &objectType, const G4String &objectName="", G4bool success=true) const
const G4AnalysisManagerState & fState
virtual G4bool SetIsEmpty(const G4String &fileName, G4bool isEmpty) final
virtual G4bool WriteFiles() final
virtual G4bool CreateFile(const G4String &fileName) final
std::shared_ptr< G4VNtupleFileManager > CreateNtupleFileManager(G4AnalysisOutput output)
std::shared_ptr< G4VFileManager > fDefaultFileManager
virtual G4bool OpenFiles() final
std::vector< std::shared_ptr< G4VFileManager > > fFileManagers
virtual G4bool SetHistoDirectoryName(const G4String &dirName)
virtual G4bool CloseFile(const G4String &fileName) final
std::shared_ptr< G4VFileManager > GetFileManager(const G4String &fileName)
virtual G4bool OpenFile(const G4String &fileName) final
virtual void Clear() final
std::shared_ptr< G4CsvFileManager > fCsvFileManager
std::shared_ptr< G4XmlFileManager > fXmlFileManager
virtual G4bool SetNtupleDirectoryName(const G4String &dirName)
void CreateFileManager(G4AnalysisOutput output)
static constexpr std::string_view fkClass
void SetDefaultFileType(const G4String &value)
virtual G4bool WriteFile(const G4String &fileName) final
G4GenericFileManager(const G4AnalysisManagerState &state)
std::shared_ptr< G4RootFileManager > fRootFileManager
virtual G4bool CloseFiles() final
virtual G4bool DeleteEmptyFiles() final
G4String GetNtupleDirectoryName() const
G4String GetHistoDirectoryName() const
virtual G4bool SetHistoDirectoryName(const G4String &dirName)
virtual G4bool SetFileName(const G4String &fileName) final
virtual G4bool SetNtupleDirectoryName(const G4String &dirName)
void LockDirectoryNames()
void UnlockDirectoryNames()
G4String GetExtension(const G4String &fileName, const G4String &defaultExtension="")
constexpr G4int kVL1
G4String GetOutputName(G4AnalysisOutput outputType)
constexpr G4int kVL3
G4AnalysisOutput GetOutput(const G4String &outputName, G4bool warn=true)
constexpr G4int kVL4
void Warn(const G4String &message, const std::string_view inClass, const std::string_view inFunction)
void FileManagerWarning(const G4String &fileName, std::string_view className, std::string_view functionName, G4bool hdf5Warn=true)