| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 26
27 // Author: Ivana Hrivnacova, 20/07/2017 (ivana 27 // Author: Ivana Hrivnacova, 20/07/2017 (ivana@ipno.in2p3.fr)
28 28
29 #include "G4Hdf5RFileManager.hh" 29 #include "G4Hdf5RFileManager.hh"
30 #include "G4Hdf5HnRFileManager.hh" <<
31 #include "G4AnalysisManagerState.hh" 30 #include "G4AnalysisManagerState.hh"
32 #include "G4AnalysisUtilities.hh" 31 #include "G4AnalysisUtilities.hh"
33 32
34 #include "toolx/hdf5/h2file" << 33 #include "tools/hdf5/h2file"
35 #include "toolx/hdf5/group_exists" << 34 #include <tools/zlib>
36 #include "toolx/zlib" << 35
>> 36 #include <iostream>
>> 37 #include <cstdio>
37 38
38 using namespace G4Analysis; 39 using namespace G4Analysis;
39 using namespace tools; << 40
>> 41 //_____________________________________________________________________________
>> 42 const G4String G4Hdf5RFileManager::fgkDefaultDirectoryName = "default";
40 43
41 //____________________________________________ 44 //_____________________________________________________________________________
42 G4Hdf5RFileManager::G4Hdf5RFileManager(const G 45 G4Hdf5RFileManager::G4Hdf5RFileManager(const G4AnalysisManagerState& state)
43 : G4VRFileManager(state) << 46 : G4BaseFileManager(state),
>> 47 fRFiles()
44 { 48 {
45 // Create helpers defined in the base class <<
46 fH1RFileManager = std::make_shared<G4Hdf5HnR <<
47 fH2RFileManager = std::make_shared<G4Hdf5HnR <<
48 fH3RFileManager = std::make_shared<G4Hdf5HnR <<
49 fP1RFileManager = std::make_shared<G4Hdf5HnR <<
50 fP2RFileManager = std::make_shared<G4Hdf5HnR <<
51 } 49 }
52 50
53 // << 51 //_____________________________________________________________________________
>> 52 G4Hdf5RFileManager::~G4Hdf5RFileManager()
>> 53 {
>> 54 }
>> 55
>> 56 //
54 // private methods 57 // private methods
55 // 58 //
56 59
57 //____________________________________________ 60 //_____________________________________________________________________________
58 hid_t G4Hdf5RFileManager::OpenRFile(const G4St 61 hid_t G4Hdf5RFileManager::OpenRFile(const G4String& fileName,
59 G4bool is 62 G4bool isPerThread)
60 { 63 {
61 // Get full file name 64 // Get full file name
62 G4String name = GetFullFileName(fileName, is 65 G4String name = GetFullFileName(fileName, isPerThread);
63 66
64 Message(kVL4, "open", "read analysis file", << 67 #ifdef G4VERBOSE
>> 68 if ( fState.GetVerboseL4() )
>> 69 fState.GetVerboseL4()->Message("open", "read analysis file", name);
>> 70 #endif
65 71
66 // create new file 72 // create new file
67 hid_t newFile = H5Fopen(name, H5F_ACC_RDONLY 73 hid_t newFile = H5Fopen(name, H5F_ACC_RDONLY, H5P_DEFAULT);
68 if ( newFile < 0 ) { 74 if ( newFile < 0 ) {
69 Warn("Cannot open file " + name, fkClass, << 75 G4ExceptionDescription description;
70 return kInvalidId; << 76 description << " " << "Cannot open file " << name;
>> 77 G4Exception("G4Hdf5RFileManager::OpenFile()",
>> 78 "Analysis_WR001", JustWarning, description);
>> 79 return false;
71 } 80 }
72 81
73 // newFile->add_unziper('Z',toolx::decompres << 82 // newFile->add_unziper('Z',tools::decompress_buffer);
74 << 83
75 // add file in a map 84 // add file in a map
76 fRFiles[name] = G4Hdf5File(newFile, kInvalid << 85 std::map<G4String, hid_t>::iterator it
77 << 86 = fRFiles.find(name);
78 Message(kVL1, "open", "read analysis file", << 87 if ( it != fRFiles.end() ) {
79 << 88 it->second = newFile;
80 return newFile; << 89 }
81 } << 90 else {
82 << 91 fRFiles[name] = newFile;
>> 92 }
>> 93
>> 94 #ifdef G4VERBOSE
>> 95 if ( fState.GetVerboseL1() )
>> 96 fState.GetVerboseL1()
>> 97 ->Message("open", "read analysis file", name);
>> 98 #endif
>> 99
>> 100 return true;
>> 101 }
>> 102
83 //____________________________________________ 103 //_____________________________________________________________________________
84 hid_t G4Hdf5RFileManager::OpenDirectory(hid_t 104 hid_t G4Hdf5RFileManager::OpenDirectory(hid_t file, const G4String& directoryName)
85 { 105 {
86 Message(kVL4, "open", "read directory", dire << 106 #ifdef G4VERBOSE
87 << 107 if ( fState.GetVerboseL4() ) {
88 auto directory = toolx_H5Gopen(file, directo << 108 fState.GetVerboseL4()->Message("open", "read directory", directoryName);
>> 109 }
>> 110 #endif
>> 111
>> 112 auto directory = tools_H5Gopen(file, directoryName);
89 if ( directory < 0 ) { 113 if ( directory < 0 ) {
90 Warn("Cannot open directory " + directoryN << 114 G4ExceptionDescription description;
91 return kInvalidId; << 115 description << " "
92 } << 116 << "cannot open directory " << directoryName;
93 Message(kVL2, "open", "read directory", dire << 117 G4Exception("G4Hdf5RFileManager::OpenDirectory()",
94 return directory; << 118 "Analysis_W001", JustWarning, description);
>> 119 return kInvalidId;
>> 120 }
>> 121 else {
>> 122 #ifdef G4VERBOSE
>> 123 if ( fState.GetVerboseL2() ) {
>> 124 fState.GetVerboseL2()->Message("open", "read directory", directoryName);
>> 125 }
>> 126 #endif
>> 127 return directory;
>> 128 }
95 } 129 }
96 130
97 //____________________________________________ 131 //_____________________________________________________________________________
98 hid_t G4Hdf5RFileManager::GetRDirectory(const 132 hid_t G4Hdf5RFileManager::GetRDirectory(const G4String& directoryType,
99 const << 133 const G4String& fileName,
100 const << 134 const G4String& dirName,
101 G4boo << 135 G4bool isPerThread)
102 { 136 {
103 // Get or open a file 137 // Get or open a file
104 auto rfile = GetRFile(fileName, isPerThread) 138 auto rfile = GetRFile(fileName, isPerThread);
105 if (rfile == nullptr) { << 139 if ( rfile < 0 ) {
106 // Try to open it if not found in the map << 140 // Try to open it if not found in the map
107 if ( OpenRFile(fileName, isPerThread) < 0 << 141 if ( ! OpenRFile(fileName, isPerThread) ) return kInvalidId;
108 rfile = GetRFile(fileName, isPerThread); 142 rfile = GetRFile(fileName, isPerThread);
109 } 143 }
110 144
111 auto isHistograms = (directoryType == "histo <<
112 <<
113 // Get directory if already open <<
114 hid_t directory = kInvalidId; <<
115 if ( isHistograms ) { <<
116 directory = std::get<1>(*rfile); <<
117 } else { <<
118 directory = std::get<2>(*rfile); <<
119 } <<
120 if ( directory != kInvalidId ) { <<
121 return directory; <<
122 } <<
123 <<
124 // Use default directory name if not specifi 145 // Use default directory name if not specified
125 auto newDirName = dirName; 146 auto newDirName = dirName;
126 if ( newDirName == "" ) { 147 if ( newDirName == "" ) {
>> 148 // if ( fDefaultDirectory > 0 ) {
>> 149 // // Return the default directory if the name is not set and the default directory
>> 150 // // already exists
>> 151 // directory = fDefaultDirectory;
>> 152 // return true;
>> 153 // } else {
127 // Create the default directory if the n 154 // Create the default directory if the name is not set and the default directory
128 // does not yet exist 155 // does not yet exist
129 newDirName = fgkDefaultDirectoryName; 156 newDirName = fgkDefaultDirectoryName;
130 newDirName += "_"; 157 newDirName += "_";
131 newDirName += directoryType; 158 newDirName += directoryType;
132 } 159 }
133 160
134 // Open directory 161 // Open directory
135 directory = OpenDirectory(std::get<0>(*rfile << 162 return OpenDirectory(rfile, newDirName);
136 <<
137 // Update <<
138 if ( isHistograms ) { <<
139 std::get<1>(*rfile) = directory; <<
140 } else { <<
141 std::get<2>(*rfile) = directory; <<
142 } <<
143 <<
144 return directory; <<
145 } 163 }
146 164
>> 165
147 // 166 //
148 // public methods 167 // public methods
149 // 168 //
150 169
151 //____________________________________________ 170 //_____________________________________________________________________________
152 G4Hdf5File* G4Hdf5RFileManager::GetRFile(const << 171 hid_t G4Hdf5RFileManager::GetRFile(const G4String& fileName,
153 G4boo << 172 G4bool isPerThread) const
154 { << 173 {
155 // Get full file name 174 // Get full file name
156 G4String name = GetFullFileName(fileName, is 175 G4String name = GetFullFileName(fileName, isPerThread);
157 176
158 auto it = fRFiles.find(name); << 177 std::map<G4String, hid_t>::const_iterator it
159 if (it != fRFiles.end()) { << 178 = fRFiles.find(name);
160 return &(it->second); << 179 if ( it != fRFiles.end() )
161 } << 180 return it->second;
162 return nullptr; << 181 else {
>> 182 return kInvalidId;
>> 183 }
163 } 184 }
164 185
165 //____________________________________________ 186 //_____________________________________________________________________________
166 hid_t G4Hdf5RFileManager::GetHistoRDirectory(c 187 hid_t G4Hdf5RFileManager::GetHistoRDirectory(const G4String& fileName, const G4String& dirName,
167 G 188 G4bool isPerThread)
168 { 189 {
169 return GetRDirectory("histograms", fileName, 190 return GetRDirectory("histograms", fileName, dirName, isPerThread);
170 } 191 }
171 192
172 //____________________________________________ 193 //_____________________________________________________________________________
173 hid_t G4Hdf5RFileManager::GetNtupleRDirectory( 194 hid_t G4Hdf5RFileManager::GetNtupleRDirectory(const G4String& fileName, const G4String& dirName,
174 195 G4bool isPerThread)
175 { 196 {
176 return GetRDirectory("ntuples", fileName, di 197 return GetRDirectory("ntuples", fileName, dirName, isPerThread);
177 } 198 }
178 199
179 //____________________________________________ << 200
180 void G4Hdf5RFileManager::CloseFiles() <<
181 { <<
182 // Close all open directories and file <<
183 for ( auto [key, rfile] : fRFiles ) { <<
184 if (std::get<1>(rfile) != kInvalidId) { <<
185 ::H5Gclose(std::get<1>(rfile)); <<
186 } <<
187 if (std::get<2>(rfile) != kInvalidId) { <<
188 ::H5Gclose(std::get<2>(rfile)); <<
189 } <<
190 if (std::get<0>(rfile) != kInvalidId) { <<
191 ::H5Fclose(std::get<0>(rfile)); <<
192 } <<
193 } <<
194 } <<
195 201