| 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, 18/06/2013 (ivana@ipno.in2p3.fr)
28
29 #include "G4AnalysisUtilities.hh"
30
31 //_____________________________________________________________________________
32 template <typename FT>
33 inline
34 G4TFileManager<FT>::G4TFileManager(const G4AnalysisManagerState& state)
35 : fAMState(state)
36 {}
37
38 //_____________________________________________________________________________
39 template <typename FT>
40 inline
41 G4TFileManager<FT>::~G4TFileManager()
42 {
43 for ( const auto& mapElement : fFileMap ) {
44 delete mapElement.second;
45 }
46 }
47
48 //
49 // private functions
50 //
51
52 //_____________________________________________________________________________
53 template <typename FT>
54 inline
55 void
56 G4TFileManager<FT>::FileNotFoundWarning(const G4String& fileName,
57 std::string_view functionName) const
58 {
59 G4Analysis::Warn("Failed to get file " + fileName, fkClass, functionName);
60 }
61
62 //_____________________________________________________________________________
63 template <typename FT>
64 inline
65 G4TFileInformation<FT>*
66 G4TFileManager<FT>::GetFileInfoInFunction(const G4String& fileName,
67 std::string_view functionName, G4bool warn ) const
68 {
69 // Find the file information in the map
70 auto it = fFileMap.find(fileName);
71 if ( it == fFileMap.end() ) {
72 if (warn) {
73 FileNotFoundWarning(fileName, functionName);
74 }
75 return nullptr;
76 }
77
78 return it->second;
79 }
80
81 //_____________________________________________________________________________
82 template <typename FT>
83 inline
84 std::shared_ptr<FT>
85 G4TFileManager<FT>::GetFileInFunction(const G4String& fileName,
86 std::string_view functionName, G4bool warn) const
87 {
88 // Find the file information in the map
89 auto fileInfo = GetFileInfoInFunction(fileName, functionName, warn);
90 if (! fileInfo) return nullptr;
91
92 // Check if the file is open
93 if ( ! fileInfo->fFile ) {
94 if (warn) {
95 FileNotFoundWarning(fileName, functionName);
96 }
97 return nullptr;
98 }
99
100 return fileInfo->fFile;
101 }
102
103 //_____________________________________________________________________________
104 template <typename FT>
105 inline
106 G4bool G4TFileManager<FT>::WriteTFile(std::shared_ptr<FT> file,
107 [[maybe_unused]] const G4String& fileName)
108 {
109 fAMState.Message(G4Analysis::kVL4, "write", "file", fileName);
110
111 // Write the found file
112 auto result = WriteFileImpl(file);
113
114 fAMState.Message(G4Analysis::kVL1, "write", "file", fileName, result);
115
116 return result;
117 }
118
119 //_____________________________________________________________________________
120 template <typename FT>
121 inline
122 G4bool G4TFileManager<FT>::CloseTFile(std::shared_ptr<FT> file,
123 [[maybe_unused]] const G4String& fileName)
124 {
125 fAMState.Message(G4Analysis::kVL4, "close", "file", fileName);
126
127 // Close the found file
128 auto result = CloseFileImpl(file);
129
130 fAMState.Message(G4Analysis::kVL1, "close", "file", fileName, result);
131
132 return result;
133 }
134
135 //_____________________________________________________________________________
136 template <typename FT>
137 inline
138 G4bool G4TFileManager<FT>::DeleteEmptyFile(const G4String& fileName)
139 {
140 fAMState.Message(G4Analysis::kVL4, "delete", "empty file", fileName);
141
142 auto result = ! std::remove(fileName);
143
144 fAMState.Message(G4Analysis::kVL1, "delete", "empty file", fileName, result);
145
146 return result;
147 }
148
149 //_____________________________________________________________________________
150 template <typename FT>
151 inline
152 void G4TFileManager<FT>::ClearData()
153 {
154 for ( const auto& mapElement : fFileMap ) {
155 delete mapElement.second;
156 }
157 fFileMap.clear();
158
159 fAMState.Message(G4Analysis::kVL2, "clear", "files");
160 }
161
162 //
163 // public functions
164 //
165
166 //_____________________________________________________________________________
167 template <typename FT>
168 inline
169 std::shared_ptr<FT> G4TFileManager<FT>::CreateTFile(const G4String& fileName)
170 {
171 // Just return the file if it already exists
172 if ( auto file = GetFileInFunction(fileName, "CreateTFile", false);
173 file != nullptr ) {
174 return file;
175 // should we also update fileInformation ??
176 }
177
178 auto fileInformation = GetFileInfoInFunction(fileName, "CreateTFile", false);
179 if ( ! fileInformation ) {
180 fAMState.Message(G4Analysis::kVL4, "create", "fileInformation", fileName);
181
182 // Create file information and save it in the map
183 fileInformation = new G4TFileInformation<FT>(fileName);
184 fFileMap[fileName] = fileInformation;
185 }
186
187 // Create file and save it in fileInformation
188 fAMState.Message(G4Analysis::kVL4, "create", "file", fileName);
189
190 // Let concrete class create a file
191 auto file = CreateFileImpl(fileName);
192 if ( ! file ) {
193 G4Analysis::Warn("Failed to create file " + fileName, fkClass, "CreateTFile");
194 return nullptr;
195 }
196 // Save file in fileInformation
197 fileInformation->fFile = file;
198 fileInformation->fIsOpen = true;
199 fileInformation->fIsEmpty = true;
200 fileInformation->fIsDeleted = false;
201
202 fAMState.Message(G4Analysis::kVL1, "create", "file", fileName);
203
204 // Return created file
205 return file;
206 }
207
208 //_____________________________________________________________________________
209 template <typename FT>
210 inline
211 G4bool G4TFileManager<FT>::WriteTFile(const G4String& fileName)
212 {
213 // Find the file in the map
214 auto file = GetFileInFunction(fileName, "WriteTFile");
215 // Warning is issued in GetFileInfoFunction
216 if (! file) return false;
217
218 return WriteTFile(file, fileName);
219 }
220
221 //_____________________________________________________________________________
222 template <typename FT>
223 inline
224 G4bool G4TFileManager<FT>::CloseTFile(const G4String& fileName)
225 {
226 // Find the file information in the map
227 auto fileInfo = GetFileInfoInFunction(fileName, "CloseTFile");
228 // Warning is issued in GetFileInfoFunction
229 if ( ! fileInfo ) return false;
230
231 // Do nothing if file is not open
232 if ( ! fileInfo->fIsOpen ) return false;
233
234 // Get file from the file information
235 auto file = fileInfo->fFile;
236 if ( ! file ) {
237 FileNotFoundWarning(fileName, "CloseTFile");
238 return false;
239 }
240
241 auto result = CloseTFile(file, fileName);
242
243 // Update the file information
244 fileInfo->fFile.reset();
245 fileInfo->fIsOpen = false;
246
247 return result;
248 }
249
250 //_____________________________________________________________________________
251 template <typename FT>
252 inline
253 G4bool G4TFileManager<FT>::SetIsEmpty(const G4String& fileName, G4bool isEmpty)
254 {
255 // Find the file information in the map
256 auto fileInfo = GetFileInfoInFunction(fileName, "SetIsEmpty");
257
258 // Warning is issued in GetFileFunction
259 if ( ! fileInfo ) return false;
260
261 fAMState.Message(G4Analysis::kVL4, "notify not empty", "file", fileName);
262
263 // Set notification to file information
264 if ( fileInfo->fIsEmpty ) {
265 // do not revert information if file is not empty
266 fileInfo->fIsEmpty = isEmpty;
267
268 if ( ! isEmpty ) {
269 fAMState.Message(G4Analysis::kVL3, "notify not empty", "file", fileName);
270 }
271 }
272
273 return true;
274 }
275
276 //_____________________________________________________________________________
277 template <typename FT>
278 inline
279 std::shared_ptr<FT> G4TFileManager<FT>::GetTFile(
280 const G4String& fileName, G4bool warn) const
281 {
282 // Find the file information in the map
283 return GetFileInFunction(fileName, "GetTFile", warn);
284 }
285
286 //_____________________________________________________________________________
287 template <typename FT>
288 inline
289 G4bool G4TFileManager<FT>::OpenFiles()
290 {
291 auto result = true;
292 for ( const auto& mapElement : fFileMap ) {
293 auto fileInformation = mapElement.second;
294 // Do nothing if file was open by user explicitly
295 if ( fileInformation->fFile ) {
296 // G4cout << "... skipping open file for " << fileInformation->fFileName << G4endl;
297 continue;
298 }
299
300 result &= (CreateTFile(fileInformation->fFileName) != nullptr);
301 }
302 return result;
303 }
304
305 //_____________________________________________________________________________
306 template <typename FT>
307 inline
308 G4bool G4TFileManager<FT>::WriteFiles()
309 {
310 auto result = true;
311 for ( const auto& mapElement : fFileMap ) {
312 auto fileInformation = mapElement.second;
313 if ( ! fileInformation->fIsOpen ) {
314 // G4cout << "skipping write for file " << fileInformation->fFileName << G4endl;
315 continue;
316 }
317 result &= WriteTFile(fileInformation->fFile, fileInformation->fFileName);
318 }
319 return result;
320 }
321
322 //_____________________________________________________________________________
323 template <typename FT>
324 inline
325 G4bool G4TFileManager<FT>::CloseFiles()
326 {
327 auto result = true;
328 for ( const auto& mapElement : fFileMap ) {
329 auto fileInformation = mapElement.second;
330 if ( ! fileInformation->fIsOpen ) {
331 // G4cout << "skipping close for file " << fileInformation->fFileName << G4endl;
332 continue;
333 }
334 result &= CloseTFile(fileInformation->fFile, fileInformation->fFileName);
335
336 // Update file information
337 fileInformation->fFile.reset();
338 fileInformation->fIsOpen = false;
339 }
340
341 // As the files were set to nullptr, clear should not be needed
342 // fFileMap.clear();
343
344 return result;
345 }
346
347 //_____________________________________________________________________________
348 template <typename FT>
349 inline
350 G4bool G4TFileManager<FT>::DeleteEmptyFiles()
351 {
352 auto result = true;
353 for ( const auto& mapElement : fFileMap ) {
354 auto fileInformation = mapElement.second;
355 if ( (! fileInformation->fIsEmpty) || fileInformation->fIsDeleted ) {
356 // G4cout << "skipping delete for file " << fileInformation->fFileName << G4endl;
357 continue;
358 }
359
360 result &= DeleteEmptyFile(fileInformation->fFileName);
361
362 // Update file information
363 fileInformation->fIsDeleted = true;
364 }
365
366 return result;
367 }
368