| Geant4 Cross Reference |
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
29 #include "G4GenericFileManager.hh"
30 #include "G4AnalysisManagerState.hh"
31 #include "G4AnalysisUtilities.hh"
32 #include "G4CsvFileManager.hh"
33 #include "G4CsvNtupleFileManager.hh"
34 #ifdef TOOLS_USE_HDF5
35 #include "G4Hdf5FileManager.hh"
36 #include "G4Hdf5NtupleFileManager.hh"
37 #endif
38 #include "G4RootFileManager.hh"
39 #include "G4RootNtupleFileManager.hh"
40 #include "G4XmlFileManager.hh"
41 #include "G4XmlNtupleFileManager.hh"
42
43 using namespace G4Analysis;
44
45 namespace {
46
47 //_____________________________________________________________________________
48 void 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 //_____________________________________________________________________________
62 G4GenericFileManager::G4GenericFileManager(const G4AnalysisManagerState& state)
63 : G4VFileManager(state)
64 {}
65
66 //
67 // private methods
68 //
69
70 //_____________________________________________________________________________
71 void G4GenericFileManager::CreateFileManager(G4AnalysisOutput output)
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 ) {
85 case G4AnalysisOutput::kCsv:
86 fCsvFileManager = std::make_shared<G4CsvFileManager>(fState);
87 fFileManagers[outputId] = fCsvFileManager;
88 break;
89 case G4AnalysisOutput::kHdf5:
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;
100 case G4AnalysisOutput::kRoot:
101 fRootFileManager = std::make_shared<G4RootFileManager>(fState);
102 fFileManagers[outputId] = fRootFileManager;
103 break;
104 case G4AnalysisOutput::kXml:
105 fXmlFileManager = std::make_shared<G4XmlFileManager>(fState);
106 fFileManagers[outputId] = fXmlFileManager ;
107 break;
108 case G4AnalysisOutput::kNone:
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 //_____________________________________________________________________________
126 std::shared_ptr<G4VFileManager>
127 G4GenericFileManager::GetFileManager(G4AnalysisOutput output) const
128 {
129 return fFileManagers[static_cast<size_t>(output)];
130 }
131
132 //_____________________________________________________________________________
133 std::shared_ptr<G4VFileManager>
134 G4GenericFileManager::GetFileManager(const G4String& fileName)
135 {
136 // Get file extension
137 G4String extension = GetExtension(fileName);
138 if (extension.size() == 0u) {
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 //_____________________________________________________________________________
164 G4bool G4GenericFileManager::OpenFile(const G4String& fileName)
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
190 LockDirectoryNames();
191 fIsOpenFile = true;
192
193 Message(kVL1, "open", "analysis file", fileName, result);
194
195 return result;
196 }
197
198 //_____________________________________________________________________________
199 G4bool G4GenericFileManager::OpenFiles()
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 // filenames for csv need to be updated
216 auto newFileName = fileName;
217 if (fileManager == fCsvFileManager) {
218 newFileName = fileManager->GetHnFileName(fileName, GetCycle());
219 }
220
221 result &= fileManager->CreateFile(newFileName);
222 }
223
224 Message(kVL3, "open", "analysis files", "", result);
225
226 return result;
227 }
228
229 //_____________________________________________________________________________
230 G4bool G4GenericFileManager::WriteFiles()
231 {
232 // Finish write for all files registered with objects
233
234 Message(kVL4, "write", "analysis files");
235
236 auto result = true;
237
238 for ( const auto& fileManager : fFileManagers ) {
239 if ( ! fileManager ) continue;
240
241 Message(kVL4, "write", fileManager->GetFileType(), "files");
242
243 result &= fileManager->WriteFiles();
244 }
245
246 Message(kVL3, "write", "analysis files", "", result);
247
248 return result;
249 }
250
251 //_____________________________________________________________________________
252 G4bool G4GenericFileManager::CloseFiles()
253 {
254 // Close all files regeistered with objects
255
256 Message(kVL4, "close", "analysis files");
257
258 auto result = true;
259
260 for ( const auto& fileManager : fFileManagers ) {
261 if ( ! fileManager ) continue;
262
263 Message(kVL4, "close", fileManager->GetFileType(), "files");
264
265 result &= fileManager->CloseFiles();
266 }
267
268 fIsOpenFile = false;
269
270 Message(kVL3, "close", "analysis files", "", result);
271
272 return result;
273 }
274
275 //_____________________________________________________________________________
276 G4bool G4GenericFileManager::DeleteEmptyFiles()
277 {
278 // Close all files regeistered with objects
279
280 Message(kVL4, "delete", "empty files");
281
282 auto result = true;
283
284 for ( const auto& fileManager : fFileManagers ) {
285 if ( ! fileManager ) continue;
286
287 Message(kVL4, "delete", fileManager->GetFileType(), "empty files");
288
289 result &= fileManager->DeleteEmptyFiles();
290 }
291
292 // Clear all saved file names in base file manager
293 G4BaseFileManager::ClearData();
294
295 Message(kVL3, "delete", "empty files", "", result);
296
297 return result;
298 }
299
300 //_____________________________________________________________________________
301 void G4GenericFileManager::Clear()
302 {
303 // Clear files data
304
305 for ( const auto& fileManager : fFileManagers ) {
306 if ( ! fileManager ) continue;
307
308 fileManager->Clear();
309 }
310 UnlockDirectoryNames();
311 }
312
313 //_____________________________________________________________________________
314 G4bool G4GenericFileManager::CreateFile(const G4String& fileName)
315 {
316 // New prototype, fully implemented in templated base class
317
318 auto fileManager = GetFileManager(fileName);
319 if ( ! fileManager ) {
320 FileManagerWarning(fileName, fkClass, "CreateFile", fHdf5Warn);
321 return false;
322 }
323
324 return fileManager->CreateFile(fileName);
325 }
326
327 //_____________________________________________________________________________
328 G4bool G4GenericFileManager::WriteFile(const G4String& fileName)
329 {
330 // New prototype, fully implemented in templated base class
331
332 auto fileManager = GetFileManager(fileName);
333 if ( ! fileManager ) {
334 FileManagerWarning(fileName, fkClass, "WriteFile", fHdf5Warn);
335 return false;
336 }
337
338 return fileManager->WriteFile(fileName);
339 }
340
341 //_____________________________________________________________________________
342 G4bool G4GenericFileManager::CloseFile(const G4String& fileName)
343 {
344 // New prototype, fully implemented in templated base class
345
346 auto fileManager = GetFileManager(fileName);
347 if ( ! fileManager ) {
348 FileManagerWarning(fileName, fkClass, "CloseFile", fHdf5Warn);
349 return false;
350 }
351
352 return fileManager->CloseFile(fileName);
353 }
354
355 //_____________________________________________________________________________
356 G4bool G4GenericFileManager::SetIsEmpty(const G4String& fileName, G4bool isEmpty)
357 {
358 auto fileManager = GetFileManager(fileName);
359 if ( ! fileManager ) {
360 FileManagerWarning(fileName, fkClass, "SetIsEmpty", fHdf5Warn);
361 return false;
362 }
363
364 return fileManager->SetIsEmpty(fileName, isEmpty);
365 }
366
367 //_____________________________________________________________________________
368 G4bool G4GenericFileManager::SetHistoDirectoryName(const G4String& dirName)
369 {
370 auto result = G4VFileManager::SetHistoDirectoryName(dirName);
371
372 for (auto& fileManager : fFileManagers ) {
373 if ( fileManager != nullptr ) {
374 result &= fileManager->SetHistoDirectoryName(dirName);
375 }
376 }
377 return result;
378 }
379
380 //_____________________________________________________________________________
381 G4bool G4GenericFileManager::SetNtupleDirectoryName(const G4String& dirName)
382 {
383 auto result = G4VFileManager::SetNtupleDirectoryName(dirName);
384
385 for (auto& fileManager : fFileManagers ) {
386 if ( fileManager != nullptr ) {
387 result &= fileManager->SetNtupleDirectoryName(dirName);
388 }
389 }
390 return result;
391 }
392
393 //_____________________________________________________________________________
394 void G4GenericFileManager::SetCompressionLevel(G4int level)
395 {
396 G4BaseFileManager::SetCompressionLevel(level);
397
398 for (auto& fileManager : fFileManagers ) {
399 if ( fileManager != nullptr ) {
400 fileManager->SetCompressionLevel(level);
401 }
402 }
403 }
404
405 //_____________________________________________________________________________
406 void G4GenericFileManager::SetDefaultFileType(const G4String& value)
407 {
408 // Check if value correspond to a valid file type
409 auto output = G4Analysis::GetOutput(value);
410 if ( output == G4AnalysisOutput::kNone ) {
411 Warn("The file type " + value + "is not supported.\n" +
412 "The default type " + fDefaultFileType + " will be used.",
413 fkClass, "SetDeafultFileType");
414 return;
415 }
416
417 fDefaultFileType = value;
418 }
419
420 //_____________________________________________________________________________
421 std::shared_ptr<G4VNtupleFileManager>
422 G4GenericFileManager::CreateNtupleFileManager(G4AnalysisOutput output)
423 {
424 if ( ! GetFileManager(output) ) {
425 CreateFileManager(output);
426 }
427
428 std::shared_ptr<G4VNtupleFileManager> vNtupleFileManager = nullptr;
429 G4String failure;
430
431 switch ( output ) {
432 case G4AnalysisOutput::kCsv: {
433 auto ntupleFileManager = std::make_shared<G4CsvNtupleFileManager>(fState);
434 ntupleFileManager->SetFileManager(fCsvFileManager);
435 vNtupleFileManager = ntupleFileManager;
436 break;
437 }
438 case G4AnalysisOutput::kHdf5: {
439 #ifdef TOOLS_USE_HDF5
440 auto ntupleFileManager = std::make_shared<G4Hdf5NtupleFileManager>(fState);
441 ntupleFileManager->SetFileManager(fHdf5FileManager);
442 vNtupleFileManager = ntupleFileManager;
443 #else
444 failure = " Hdf5 is not available";
445 #endif
446 break;
447 }
448 case G4AnalysisOutput::kRoot: {
449 auto ntupleFileManager = std::make_shared<G4RootNtupleFileManager>(fState);
450 ntupleFileManager->SetFileManager(fRootFileManager);
451 vNtupleFileManager = ntupleFileManager;
452 break;
453 }
454 case G4AnalysisOutput::kXml: {
455 auto ntupleFileManager = std::make_shared<G4XmlNtupleFileManager>(fState);
456 ntupleFileManager->SetFileManager(fXmlFileManager);
457 vNtupleFileManager = ntupleFileManager;
458 break;
459 }
460 case G4AnalysisOutput::kNone:
461 break;
462 }
463
464 if ( ! vNtupleFileManager ) {
465 Warn("Failed to create ntuple file manager of " +
466 G4Analysis::GetOutputName(output) + " type.\n" + failure,
467 fkClass, "CreateNtupleFileManager");
468 }
469
470 return vNtupleFileManager;
471 }
472