| 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, 22/08/2013 (ivan 27 // Author: Ivana Hrivnacova, 22/08/2013 (ivana@ipno.in2p3.fr)
28 28
29 #include "G4AnalysisUtilities.hh" 29 #include "G4AnalysisUtilities.hh"
30 #include "G4BinScheme.hh" 30 #include "G4BinScheme.hh"
31 #include "G4Exception.hh" <<
32 #include "G4UnitsTable.hh" 31 #include "G4UnitsTable.hh"
33 #include "G4String.hh" 32 #include "G4String.hh"
34 #include "G4Threading.hh" <<
35 #include "G4Filesystem.hh" <<
36 <<
37 using std::to_string; <<
38 33
39 namespace { 34 namespace {
40 35
41 //____________________________________________ 36 //_____________________________________________________________________________
42 G4bool GetToken(const G4String& line, G4String << 37 G4bool GetToken(const G4String& line, G4String& token,
43 std::string::size_type begIdx, 38 std::string::size_type begIdx, std::string::size_type& endIdx)
44 { 39 {
45 while ( line[(G4int)begIdx] == ' ') ++begIdx << 40 while ( line[begIdx] == ' ') ++begIdx; // Loop checking, 23.06.2015, I. Hrivnacova
46 if ( line[(G4int)begIdx] == '"' ) { << 41 if ( line[begIdx] == '"' ) {
47 endIdx = line.find('"', begIdx+1); 42 endIdx = line.find('"', begIdx+1);
48 if ( endIdx == std::string::npos ) endIdx 43 if ( endIdx == std::string::npos ) endIdx = line.length();
49 token = line.substr(begIdx+1, (endIdx-1)-b 44 token = line.substr(begIdx+1, (endIdx-1)-begIdx);
50 ++endIdx; 45 ++endIdx;
51 } 46 }
52 else { 47 else {
53 endIdx = line.find(' ', begIdx); 48 endIdx = line.find(' ', begIdx);
54 if ( endIdx == std::string::npos ) endIdx 49 if ( endIdx == std::string::npos ) endIdx = line.length();
55 token = line.substr(begIdx, endIdx-begIdx) 50 token = line.substr(begIdx, endIdx-begIdx);
56 } 51 }
57 return ( token.length() > 0 ); 52 return ( token.length() > 0 );
58 } << 53 }
59 54
60 } 55 }
61 56
62 namespace G4Analysis 57 namespace G4Analysis
63 { 58 {
64 59
65 //____________________________________________ 60 //_____________________________________________________________________________
66 void Warn(const G4String& message, << 61 G4bool CheckNbins(G4int nbins)
67 const std::string_view inClass, <<
68 const std::string_view inFunction) <<
69 { 62 {
70 auto source = std::string(inClass) + "::" + << 63 if ( nbins <= 0 ) {
71 G4Exception(source.data(), "Analysis_W001", << 64 G4ExceptionDescription description;
>> 65 description
>> 66 << " Illegal value of number of bins: nbins <= 0" << G4endl;
>> 67 G4Exception("G4VAnalysisManager::CheckNbins",
>> 68 "Analysis_W013", JustWarning, description);
>> 69 return false;
>> 70 }
>> 71 else
>> 72 return true;
>> 73 }
>> 74
>> 75
>> 76 //_____________________________________________________________________________
>> 77 G4bool CheckMinMax(G4double xmin, G4double xmax,
>> 78 const G4String& fcnName, const G4String& binSchemeName)
>> 79 {
>> 80 auto result = true;
>> 81
>> 82 if ( xmax <= xmin ) {
>> 83 G4ExceptionDescription description;
>> 84 description
>> 85 << " Illegal values of (xmin >= xmax)" << G4endl;
>> 86 G4Exception("G4VAnalysisManager::CheckMinMax",
>> 87 "Analysis_W013", JustWarning, description);
>> 88
>> 89 result = false;
>> 90 }
>> 91
>> 92 if ( ( fcnName != "none" ) && ( binSchemeName != "linear" ) ) {
>> 93 G4ExceptionDescription description;
>> 94 description
>> 95 << " Combining Function and Binning scheme is not supported."
>> 96 << G4endl;
>> 97 G4Exception("G4VAnalysisManager::CheckMinMax",
>> 98 "Analysis_W013", JustWarning, description);
>> 99
>> 100 result = false;
>> 101 }
>> 102
>> 103 if ( ( GetBinScheme(binSchemeName) == G4BinScheme::kLog ||
>> 104 fcnName == "log" || fcnName == "log10" ) && ( xmin == 0 ) ) {
>> 105 G4ExceptionDescription description;
>> 106 description
>> 107 << " Illegal value of (xmin = 0) with logarithmic function or binning"
>> 108 << G4endl;
>> 109 G4Exception("G4VAnalysisManager::CheckMinMax",
>> 110 "Analysis_W013", JustWarning, description);
>> 111
>> 112 result = false;
>> 113 }
>> 114
>> 115 return result;
>> 116 }
>> 117
>> 118 //_____________________________________________________________________________
>> 119 G4bool CheckEdges(const std::vector<G4double>& edges)
>> 120 {
>> 121 if ( edges.size() <= 1 ) {
>> 122 G4ExceptionDescription description;
>> 123 description
>> 124 << " Illegal edges vector (size <= 1)" << G4endl;
>> 125 G4Exception("G4VAnalysisManager::CheckEdges",
>> 126 "Analysis_W013", JustWarning, description);
>> 127 return false;
>> 128 }
>> 129 else
>> 130 return true;
>> 131
>> 132 }
>> 133
>> 134 //_____________________________________________________________________________
>> 135 G4bool CheckName(const G4String& name, const G4String& objectType)
>> 136 {
>> 137 if ( ! name.size() ) {
>> 138 G4ExceptionDescription description;
>> 139 description
>> 140 << " Empty " << objectType << " name is not allowed." << G4endl
>> 141 << " " << objectType << " was not created." << G4endl;
>> 142 G4Exception("G4VAnalysisManager::CheckName",
>> 143 "Analysis_W013", JustWarning, description);
>> 144 return false;
>> 145 }
>> 146 else
>> 147 return true;
72 } 148 }
73 149
74 //____________________________________________ 150 //_____________________________________________________________________________
75 G4double GetUnitValue(const G4String& unit) 151 G4double GetUnitValue(const G4String& unit)
76 { 152 {
77 G4double value = 1.; 153 G4double value = 1.;
78 if ( unit != "none" ) { 154 if ( unit != "none" ) {
79 value = G4UnitDefinition::GetValueOf(unit 155 value = G4UnitDefinition::GetValueOf(unit);
80 if ( value == 0. ) value = 1.; << 156 if ( value == 0. ) value = 1.;
81 } << 157 }
82 return value; 158 return value;
83 } << 159 }
>> 160
>> 161 //_____________________________________________________________________________
>> 162 void UpdateTitle(G4String& title,
>> 163 const G4String& unitName,
>> 164 const G4String& fcnName)
>> 165 {
>> 166 if ( fcnName != "none" ) { title += " "; title += fcnName; title += "("; }
>> 167 if ( unitName != "none" ) { title += " ["; title += unitName; title += "]";}
>> 168 if ( fcnName != "none" ) { title += ")"; }
>> 169 }
84 170
85 //____________________________________________ 171 //_____________________________________________________________________________
86 void Tokenize(const G4String& line, std::vect 172 void Tokenize(const G4String& line, std::vector<G4String>& tokens)
87 { 173 {
88 // Define start values 174 // Define start values
89 std::string::size_type begIdx = 0; 175 std::string::size_type begIdx = 0;
90 std::string::size_type endIdx = 0; << 176 std::string::size_type endIdx = 0;
91 G4String token; 177 G4String token;
92 << 178
93 do { 179 do {
94 if ( GetToken(line, token, begIdx, endIdx) 180 if ( GetToken(line, token, begIdx, endIdx) ) {
95 //G4cout << "got token: '" << token << " 181 //G4cout << "got token: '" << token << "'" << G4endl;
96 //G4cout << "beg, end: " << begIdx << ", 182 //G4cout << "beg, end: " << begIdx << ", " << endIdx << G4endl;
97 tokens.push_back(token); 183 tokens.push_back(token);
98 } << 184 }
99 begIdx = endIdx + 1; 185 begIdx = endIdx + 1;
100 } 186 }
101 while ( endIdx < line.length() ); // Loop ch 187 while ( endIdx < line.length() ); // Loop checking, 23.06.2015, I. Hrivnacova
102 } 188 }
103 189
104 //____________________________________________ 190 //_____________________________________________________________________________
105 G4AnalysisOutput GetOutput(const G4String& out << 191 G4AnalysisOutput GetOutput(const G4String& outputName, G4bool warn) {
106 { << 192 if ( outputName == "csv" ) { return G4AnalysisOutput::kCsv; }
107 if (outputName == "csv") return G4AnalysisO << 193 #ifdef TOOLS_USE_HDF5
108 if (outputName == "hdf5") return G4AnalysisO << 194 else if ( outputName == "hdf5" ) { return G4AnalysisOutput::kHdf5; }
109 if (outputName == "root") return G4AnalysisO << 195 #endif
110 if (outputName == "xml") return G4AnalysisO << 196 else if ( outputName == "root" ) { return G4AnalysisOutput::kRoot; }
111 if (outputName == "none") return G4AnalysisO << 197 else if ( outputName == "xml" ) { return G4AnalysisOutput::kXml; }
112 << 198 else if ( outputName == "none" ) { return G4AnalysisOutput::kNone; }
113 if (warn) { << 199 else {
114 Warn("\"" + outputName + "\" output type i << 200 if (warn) {
>> 201 G4ExceptionDescription description;
>> 202 description
>> 203 << " \"" << outputName << "\" output type is not supported." << G4endl;
>> 204 G4Exception("G4Analysis::GetOutputType",
>> 205 "Analysis_W013", JustWarning, description);
>> 206 }
>> 207 return G4AnalysisOutput::kNone;
115 } 208 }
116 return G4AnalysisOutput::kNone; <<
117 } 209 }
118 210
119 //____________________________________________ 211 //_____________________________________________________________________________
120 G4String GetOutputName(G4AnalysisOutput output << 212 G4String GetOutputName(G4AnalysisOutput output) {
121 { <<
122 switch ( output ) { 213 switch ( output ) {
123 case G4AnalysisOutput::kCsv: 214 case G4AnalysisOutput::kCsv:
124 return "csv"; 215 return "csv";
125 break; 216 break;
126 case G4AnalysisOutput::kHdf5: << 217 #ifdef TOOLS_USE_HDF5
>> 218 case G4AnalysisOutput::kHdf5:
127 return "hdf5"; 219 return "hdf5";
128 break; 220 break;
129 case G4AnalysisOutput::kRoot: << 221 #endif
>> 222 case G4AnalysisOutput::kRoot:
130 return "root"; 223 return "root";
131 break; 224 break;
132 case G4AnalysisOutput::kXml: 225 case G4AnalysisOutput::kXml:
133 return "xml"; 226 return "xml";
134 break; 227 break;
135 case G4AnalysisOutput::kNone: 228 case G4AnalysisOutput::kNone:
136 return "none"; 229 return "none";
137 break; 230 break;
138 } 231 }
139 // should never reach this line 232 // should never reach this line
140 Warn("\"" + to_string(static_cast<int>(outpu << 233 G4ExceptionDescription description;
141 "\" output type is not supported.", << 234 description
142 kNamespaceName, "CheckOutputName"); << 235 << " \"" << static_cast<int>(output) << "\" is not handled." << G4endl
>> 236 << " " << "none type will be used.";
>> 237 G4Exception("G4Analysis::GetOutputName",
>> 238 "Analysis_W013", JustWarning, description);
143 return "none"; 239 return "none";
144 } <<
145 <<
146 //____________________________________________ <<
147 G4String GetBaseName(const G4String& fileName) <<
148 { <<
149 // Get file base name (without dot) <<
150 <<
151 G4fs::path filePath(fileName.data()); <<
152 if ( filePath.has_parent_path()) { <<
153 return filePath.parent_path().string() + <<
154 } <<
155 <<
156 return filePath.stem().string(); <<
157 } <<
158 <<
159 //____________________________________________ <<
160 G4String GetExtension(const G4String& fileName <<
161 const G4String& defaultE <<
162 { <<
163 // Get file base extension (without dot) <<
164 // If fileName is provided without extension, <<
165 <<
166 G4fs::path filePath(fileName.data()); <<
167 if ( filePath.has_extension() ) { <<
168 auto extension = filePath.extension().stri <<
169 // remove "." <<
170 return extension.substr(1, extension.lengt <<
171 } <<
172 <<
173 return defaultExtension; <<
174 } <<
175 <<
176 //____________________________________________ <<
177 G4String GetHnFileName( <<
178 const G4String& fileName, <<
179 const G4String& fileType, <<
180 const G4String& hnType, <<
181 const G4String& hnName) <<
182 { <<
183 // Compose and return the histogram or profile <<
184 // - add _hn_hnName suffix to the file base na <<
185 // - add _vN suffix if cycle > 0 <<
186 // - add file extension if not present <<
187 <<
188 auto name = GetBaseName(fileName); <<
189 <<
190 // Add _hnType_hnName <<
191 name.append("_"); <<
192 name.append(hnType); <<
193 name.append("_"); <<
194 name.append(hnName); <<
195 <<
196 // Add file extension <<
197 auto extension = GetExtension(fileName, file <<
198 if (extension.size() != 0u) { <<
199 name.append("."); <<
200 name.append(extension); <<
201 } <<
202 <<
203 return name; <<
204 } <<
205 <<
206 //____________________________________________ <<
207 G4String GetHnFileName( <<
208 const G4String& fileName, <<
209 const G4String& fileType, <<
210 G4int cycle) <<
211 { <<
212 // Update Hn file name: <<
213 // - add _vN suffix to the base namer if cycl <<
214 <<
215 auto name = GetBaseName(fileName); <<
216 <<
217 // Add cycle number <<
218 if (cycle > 0) { <<
219 name.append("_v"); <<
220 name.append(std::to_string(cycle)); <<
221 } <<
222 <<
223 // Add file extension <<
224 auto extension = GetExtension(fileName, file <<
225 if (extension.size() != 0u) { <<
226 name.append("."); <<
227 name.append(extension); <<
228 } <<
229 <<
230 return name; <<
231 } <<
232 <<
233 //____________________________________________ <<
234 G4String GetNtupleFileName( <<
235 const G4String& fileName, <<
236 const G4String& fileType, <<
237 const G4String& ntupleName, <<
238 G4int cycle) <<
239 { <<
240 // Compose and return the ntuple specific file <<
241 // - add _nt_ntupleName suffix to the file bas <<
242 // - add _vN suffix if cycle > 0 <<
243 // - add _tN suffix if called on thread worker <<
244 // - add file extension if not present <<
245 <<
246 auto name = GetBaseName(fileName); <<
247 <<
248 // Add ntupleName <<
249 name.append("_nt_"); <<
250 name.append(ntupleName); <<
251 <<
252 // Add cycle number <<
253 if (cycle > 0) { <<
254 name.append("_v"); <<
255 name.append(std::to_string(cycle)); <<
256 } <<
257 <<
258 // Add thread Id to a file name if MT proces <<
259 if ( ! G4Threading::IsMasterThread() ) { <<
260 std::ostringstream os; <<
261 os << G4Threading::G4GetThreadId(); <<
262 name.append("_t"); <<
263 name.append(os.str()); <<
264 } <<
265 <<
266 // Add file extension <<
267 auto extension = GetExtension(fileName, file <<
268 if (extension.size() != 0u) { <<
269 name.append("."); <<
270 name.append(extension); <<
271 } <<
272 <<
273 return name; <<
274 } <<
275 <<
276 //____________________________________________ <<
277 G4String GetNtupleFileName( <<
278 const G4String& fileName, <<
279 const G4String& fileType, <<
280 G4int ntupleFileNumber, <<
281 G4int cycle) <<
282 { <<
283 // Compose and return the ntuple specific file <<
284 // - add _mFN suffix to the file base name whe <<
285 // - add _vN suffix if cycle > 0 <<
286 // - add file extension if not present <<
287 <<
288 auto name = GetBaseName(fileName); <<
289 <<
290 // Add _M followed by ntupleFileNumber <<
291 std::ostringstream os; <<
292 os << ntupleFileNumber; <<
293 name.append("_m"); <<
294 name.append(os.str()); <<
295 <<
296 // Add cycle number <<
297 if (cycle > 0) { <<
298 name.append("_v"); <<
299 name.append(std::to_string(cycle)); <<
300 } <<
301 <<
302 // Add file extension <<
303 auto extension = GetExtension(fileName, file <<
304 if (extension.size() != 0u) { <<
305 name.append("."); <<
306 name.append(extension); <<
307 } <<
308 <<
309 return name; <<
310 } <<
311 <<
312 //____________________________________________ <<
313 G4String GetTnFileName( <<
314 const G4String& fileName, <<
315 const G4String& fileType, <<
316 G4int cycle) <<
317 { <<
318 // Update file base name with the thread suffi <<
319 // - add _tN suffix if called on thread worker <<
320 // - add file extension if not present <<
321 <<
322 auto name = GetBaseName(fileName); <<
323 <<
324 // Add cycle number <<
325 if (cycle > 0) { <<
326 name.append("_v"); <<
327 name.append(std::to_string(cycle)); <<
328 } <<
329 <<
330 // Add thread Id to a file name if MT proces <<
331 if ( ! G4Threading::IsMasterThread() ) { <<
332 std::ostringstream os; <<
333 os << G4Threading::G4GetThreadId(); <<
334 name.append("_t"); <<
335 name.append(os.str()); <<
336 } <<
337 <<
338 // Add file extension <<
339 auto extension = GetExtension(fileName, file <<
340 if (extension.size() != 0u) { <<
341 name.append("."); <<
342 name.append(extension); <<
343 } <<
344 <<
345 return name; <<
346 } <<
347 <<
348 //____________________________________________ <<
349 G4String GetPlotFileName(const G4String& fileN <<
350 { <<
351 // Generate plot file name for an output file <<
352 <<
353 auto name = GetBaseName(fileName); <<
354 <<
355 // Add .ps extension <<
356 name.append(".ps"); <<
357 <<
358 return name; <<
359 } 240 }
360 241
361 } 242 }
362 243