| 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 // $Id:$
26 27
27 // Author: Ivana Hrivnacova, 22/08/2013 (ivan 28 // Author: Ivana Hrivnacova, 22/08/2013 (ivana@ipno.in2p3.fr)
28 29
29 #include "G4AnalysisUtilities.hh" 30 #include "G4AnalysisUtilities.hh"
30 #include "G4BinScheme.hh" 31 #include "G4BinScheme.hh"
31 #include "G4Exception.hh" <<
32 #include "G4UnitsTable.hh" 32 #include "G4UnitsTable.hh"
33 #include "G4String.hh" 33 #include "G4String.hh"
34 #include "G4Threading.hh" <<
35 #include "G4Filesystem.hh" <<
36 <<
37 using std::to_string; <<
38 34
39 namespace { 35 namespace {
40 36
41 //____________________________________________ 37 //_____________________________________________________________________________
42 G4bool GetToken(const G4String& line, G4String << 38 G4bool GetToken(const G4String& line, G4String& token,
43 std::string::size_type begIdx, 39 std::string::size_type begIdx, std::string::size_type& endIdx)
44 { 40 {
45 while ( line[(G4int)begIdx] == ' ') ++begIdx << 41 while ( line[begIdx] == ' ') ++begIdx; // Loop checking, 23.06.2015, I. Hrivnacova
46 if ( line[(G4int)begIdx] == '"' ) { << 42 if ( line[begIdx] == '"' ) {
47 endIdx = line.find('"', begIdx+1); 43 endIdx = line.find('"', begIdx+1);
48 if ( endIdx == std::string::npos ) endIdx 44 if ( endIdx == std::string::npos ) endIdx = line.length();
49 token = line.substr(begIdx+1, (endIdx-1)-b 45 token = line.substr(begIdx+1, (endIdx-1)-begIdx);
50 ++endIdx; 46 ++endIdx;
51 } 47 }
52 else { 48 else {
53 endIdx = line.find(' ', begIdx); 49 endIdx = line.find(' ', begIdx);
54 if ( endIdx == std::string::npos ) endIdx 50 if ( endIdx == std::string::npos ) endIdx = line.length();
55 token = line.substr(begIdx, endIdx-begIdx) 51 token = line.substr(begIdx, endIdx-begIdx);
56 } 52 }
57 return ( token.length() > 0 ); 53 return ( token.length() > 0 );
58 } << 54 }
59 55
60 } 56 }
61 57
62 namespace G4Analysis 58 namespace G4Analysis
63 { 59 {
64 60
65 //____________________________________________ 61 //_____________________________________________________________________________
66 void Warn(const G4String& message, << 62 G4bool CheckNbins(G4int nbins)
67 const std::string_view inClass, <<
68 const std::string_view inFunction) <<
69 { 63 {
70 auto source = std::string(inClass) + "::" + << 64 if ( nbins <= 0 ) {
71 G4Exception(source.data(), "Analysis_W001", << 65 G4ExceptionDescription description;
>> 66 description
>> 67 << " Illegal value of number of bins: nbins <= 0" << G4endl;
>> 68 G4Exception("G4VAnalysisManager::CheckNbins",
>> 69 "Analysis_W013", JustWarning, description);
>> 70 return false;
>> 71 }
>> 72 else
>> 73 return true;
>> 74 }
>> 75
>> 76
>> 77 //_____________________________________________________________________________
>> 78 G4bool CheckMinMax(G4double xmin, G4double xmax,
>> 79 const G4String& fcnName, const G4String& binSchemeName)
>> 80 {
>> 81 auto result = true;
>> 82
>> 83 if ( xmax <= xmin ) {
>> 84 G4ExceptionDescription description;
>> 85 description
>> 86 << " Illegal values of (xmin >= xmax)" << G4endl;
>> 87 G4Exception("G4VAnalysisManager::CheckMinMax",
>> 88 "Analysis_W013", JustWarning, description);
>> 89
>> 90 result = false;
>> 91 }
>> 92
>> 93 if ( ( fcnName != "none" ) && ( binSchemeName != "linear" ) ) {
>> 94 G4ExceptionDescription description;
>> 95 description
>> 96 << " Combining Function and Binning scheme is not supported."
>> 97 << G4endl;
>> 98 G4Exception("G4VAnalysisManager::CheckMinMax",
>> 99 "Analysis_W013", JustWarning, description);
>> 100
>> 101 result = false;
>> 102 }
>> 103
>> 104 if ( ( GetBinScheme(binSchemeName) == G4BinScheme::kLog ||
>> 105 fcnName == "log" || fcnName == "log10" ) && ( xmin == 0 ) ) {
>> 106 G4ExceptionDescription description;
>> 107 description
>> 108 << " Illegal value of (xmin = 0) with logarithmic function or binning"
>> 109 << G4endl;
>> 110 G4Exception("G4VAnalysisManager::CheckMinMax",
>> 111 "Analysis_W013", JustWarning, description);
>> 112
>> 113 result = false;
>> 114 }
>> 115
>> 116 return result;
>> 117 }
>> 118
>> 119 //_____________________________________________________________________________
>> 120 G4bool CheckEdges(const std::vector<G4double>& edges)
>> 121 {
>> 122 if ( edges.size() <= 1 ) {
>> 123 G4ExceptionDescription description;
>> 124 description
>> 125 << " Illegal edges vector (size <= 1)" << G4endl;
>> 126 G4Exception("G4VAnalysisManager::CheckEdges",
>> 127 "Analysis_W013", JustWarning, description);
>> 128 return false;
>> 129 }
>> 130 else
>> 131 return true;
>> 132
>> 133 }
>> 134
>> 135 //_____________________________________________________________________________
>> 136 G4bool CheckName(const G4String& name, const G4String& objectType)
>> 137 {
>> 138 if ( ! name.size() ) {
>> 139 G4ExceptionDescription description;
>> 140 description
>> 141 << " Empty " << objectType << " name is not allowed." << G4endl
>> 142 << " " << objectType << " was not created." << G4endl;
>> 143 G4Exception("G4VAnalysisManager::CheckName",
>> 144 "Analysis_W013", JustWarning, description);
>> 145 return false;
>> 146 }
>> 147 else
>> 148 return true;
72 } 149 }
73 150
74 //____________________________________________ 151 //_____________________________________________________________________________
75 G4double GetUnitValue(const G4String& unit) 152 G4double GetUnitValue(const G4String& unit)
76 { 153 {
77 G4double value = 1.; 154 G4double value = 1.;
78 if ( unit != "none" ) { 155 if ( unit != "none" ) {
79 value = G4UnitDefinition::GetValueOf(unit 156 value = G4UnitDefinition::GetValueOf(unit);
80 if ( value == 0. ) value = 1.; << 157 if ( value == 0. ) value = 1.;
81 } << 158 }
82 return value; 159 return value;
83 } << 160 }
>> 161
>> 162 //_____________________________________________________________________________
>> 163 void UpdateTitle(G4String& title,
>> 164 const G4String& unitName,
>> 165 const G4String& fcnName)
>> 166 {
>> 167 if ( fcnName != "none" ) { title += " "; title += fcnName; title += "("; }
>> 168 if ( unitName != "none" ) { title += " ["; title += unitName; title += "]";}
>> 169 if ( fcnName != "none" ) { title += ")"; }
>> 170 }
84 171
85 //____________________________________________ 172 //_____________________________________________________________________________
86 void Tokenize(const G4String& line, std::vect 173 void Tokenize(const G4String& line, std::vector<G4String>& tokens)
87 { 174 {
88 // Define start values 175 // Define start values
89 std::string::size_type begIdx = 0; 176 std::string::size_type begIdx = 0;
90 std::string::size_type endIdx = 0; << 177 std::string::size_type endIdx = 0;
91 G4String token; 178 G4String token;
92 << 179
93 do { 180 do {
94 if ( GetToken(line, token, begIdx, endIdx) 181 if ( GetToken(line, token, begIdx, endIdx) ) {
95 //G4cout << "got token: '" << token << " 182 //G4cout << "got token: '" << token << "'" << G4endl;
96 //G4cout << "beg, end: " << begIdx << ", 183 //G4cout << "beg, end: " << begIdx << ", " << endIdx << G4endl;
97 tokens.push_back(token); 184 tokens.push_back(token);
98 } << 185 }
99 begIdx = endIdx + 1; 186 begIdx = endIdx + 1;
100 } 187 }
101 while ( endIdx < line.length() ); // Loop ch 188 while ( endIdx < line.length() ); // Loop checking, 23.06.2015, I. Hrivnacova
102 } 189 }
103 190
104 //____________________________________________ 191 //_____________________________________________________________________________
105 G4AnalysisOutput GetOutput(const G4String& out << 192 G4AnalysisOutput GetOutput(const G4String& outputName) {
106 { << 193 if ( outputName == "csv" ) { return G4AnalysisOutput::kCsv; }
107 if (outputName == "csv") return G4AnalysisO << 194 else if ( outputName == "root" ) { return G4AnalysisOutput::kRoot; }
108 if (outputName == "hdf5") return G4AnalysisO << 195 else if ( outputName == "xml" ) { return G4AnalysisOutput::kXml; }
109 if (outputName == "root") return G4AnalysisO << 196 else if ( outputName == "none" ) { return G4AnalysisOutput::kNone; }
110 if (outputName == "xml") return G4AnalysisO << 197 else {
111 if (outputName == "none") return G4AnalysisO << 198 G4ExceptionDescription description;
112 << 199 description
113 if (warn) { << 200 << " \"" << outputName << "\" output type is not supported." << G4endl
114 Warn("\"" + outputName + "\" output type i << 201 << " " << "Root type will be used.";
>> 202 G4Exception("G4Analysis::GetOutputType",
>> 203 "Analysis_W013", JustWarning, description);
>> 204 return G4AnalysisOutput::kNone;
115 } 205 }
116 return G4AnalysisOutput::kNone; <<
117 } 206 }
118 207
119 //____________________________________________ 208 //_____________________________________________________________________________
120 G4String GetOutputName(G4AnalysisOutput output << 209 G4String GetOutputName(G4AnalysisOutput output) {
121 { <<
122 switch ( output ) { 210 switch ( output ) {
123 case G4AnalysisOutput::kCsv: 211 case G4AnalysisOutput::kCsv:
124 return "csv"; 212 return "csv";
125 break; 213 break;
126 case G4AnalysisOutput::kHdf5: << 214 case G4AnalysisOutput::kRoot:
127 return "hdf5"; <<
128 break; <<
129 case G4AnalysisOutput::kRoot: <<
130 return "root"; 215 return "root";
131 break; 216 break;
132 case G4AnalysisOutput::kXml: 217 case G4AnalysisOutput::kXml:
133 return "xml"; 218 return "xml";
134 break; 219 break;
135 case G4AnalysisOutput::kNone: 220 case G4AnalysisOutput::kNone:
136 return "none"; 221 return "none";
137 break; 222 break;
138 } 223 }
139 // should never reach this line 224 // should never reach this line
140 Warn("\"" + to_string(static_cast<int>(outpu << 225 G4ExceptionDescription description;
141 "\" output type is not supported.", << 226 description
142 kNamespaceName, "CheckOutputName"); << 227 << " \"" << static_cast<int>(output) << "\" is not handled." << G4endl
>> 228 << " " << "none type will be used.";
>> 229 G4Exception("G4Analysis::GetOutputName",
>> 230 "Analysis_W013", JustWarning, description);
143 return "none"; 231 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 } 232 }
360 233
361 } 234 }
362 235