| 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;
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, const G4String& binSchemeName)
>> 79 {
>> 80 G4bool 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 ( ( GetBinScheme(binSchemeName) == kLogBinScheme ) && ( xmin == 0 ) ) {
>> 93 G4ExceptionDescription description;
>> 94 description
>> 95 << " Illegal value of (xmin = 0) with logarithmic binning" << G4endl;
>> 96 G4Exception("G4VAnalysisManager::CheckMinMax",
>> 97 "Analysis_W013", JustWarning, description);
>> 98
>> 99 result = false;
>> 100 }
>> 101
>> 102 return result;
>> 103 }
>> 104
>> 105 //_____________________________________________________________________________
>> 106 G4bool CheckEdges(const std::vector<G4double>& edges)
>> 107 {
>> 108 if ( edges.size() <= 1 ) {
>> 109 G4ExceptionDescription description;
>> 110 description
>> 111 << " Illegal edges vector (size <= 1)" << G4endl;
>> 112 G4Exception("G4VAnalysisManager::CheckEdges",
>> 113 "Analysis_W013", JustWarning, description);
>> 114 return false;
>> 115 }
>> 116 else
>> 117 return true;
>> 118
>> 119 }
>> 120
>> 121 //_____________________________________________________________________________
>> 122 G4bool CheckName(const G4String& name, const G4String& objectType)
>> 123 {
>> 124 if ( ! name.size() ) {
>> 125 G4ExceptionDescription description;
>> 126 description
>> 127 << " Empty " << objectType << " name is not allowed." << G4endl
>> 128 << " " << objectType << " was not created." << G4endl;
>> 129 G4Exception("G4VAnalysisManager::CheckName",
>> 130 "Analysis_W013", JustWarning, description);
>> 131 return false;
>> 132 }
>> 133 else
>> 134 return true;
72 } 135 }
73 136
74 //____________________________________________ 137 //_____________________________________________________________________________
75 G4double GetUnitValue(const G4String& unit) 138 G4double GetUnitValue(const G4String& unit)
76 { 139 {
77 G4double value = 1.; 140 G4double value = 1.;
78 if ( unit != "none" ) { 141 if ( unit != "none" ) {
79 value = G4UnitDefinition::GetValueOf(unit 142 value = G4UnitDefinition::GetValueOf(unit);
80 if ( value == 0. ) value = 1.; << 143 if ( value == 0. ) value = 1.;
81 } << 144 }
82 return value; 145 return value;
83 } << 146 }
>> 147
>> 148 //_____________________________________________________________________________
>> 149 void UpdateTitle(G4String& title,
>> 150 const G4String& unitName,
>> 151 const G4String& fcnName)
>> 152 {
>> 153 if ( fcnName != "none" ) { title += " "; title += fcnName; title += "("; }
>> 154 if ( unitName != "none" ) { title += " ["; title += unitName; title += "]";}
>> 155 if ( fcnName != "none" ) { title += ")"; }
>> 156 }
84 157
85 //____________________________________________ 158 //_____________________________________________________________________________
86 void Tokenize(const G4String& line, std::vect 159 void Tokenize(const G4String& line, std::vector<G4String>& tokens)
87 { 160 {
88 // Define start values 161 // Define start values
89 std::string::size_type begIdx = 0; 162 std::string::size_type begIdx = 0;
90 std::string::size_type endIdx = 0; << 163 std::string::size_type endIdx = 0;
91 G4String token; 164 G4String token;
92 << 165
93 do { 166 do {
94 if ( GetToken(line, token, begIdx, endIdx) 167 if ( GetToken(line, token, begIdx, endIdx) ) {
95 //G4cout << "got token: '" << token << " 168 //G4cout << "got token: '" << token << "'" << G4endl;
96 //G4cout << "beg, end: " << begIdx << ", 169 //G4cout << "beg, end: " << begIdx << ", " << endIdx << G4endl;
97 tokens.push_back(token); 170 tokens.push_back(token);
98 } << 171 }
99 begIdx = endIdx + 1; 172 begIdx = endIdx + 1;
100 } 173 }
101 while ( endIdx < line.length() ); // Loop ch << 174 while ( endIdx != line.length() );
102 } <<
103 <<
104 //____________________________________________ <<
105 G4AnalysisOutput GetOutput(const G4String& out <<
106 { <<
107 if (outputName == "csv") return G4AnalysisO <<
108 if (outputName == "hdf5") return G4AnalysisO <<
109 if (outputName == "root") return G4AnalysisO <<
110 if (outputName == "xml") return G4AnalysisO <<
111 if (outputName == "none") return G4AnalysisO <<
112 <<
113 if (warn) { <<
114 Warn("\"" + outputName + "\" output type i <<
115 } <<
116 return G4AnalysisOutput::kNone; <<
117 } <<
118 <<
119 //____________________________________________ <<
120 G4String GetOutputName(G4AnalysisOutput output <<
121 { <<
122 switch ( output ) { <<
123 case G4AnalysisOutput::kCsv: <<
124 return "csv"; <<
125 break; <<
126 case G4AnalysisOutput::kHdf5: <<
127 return "hdf5"; <<
128 break; <<
129 case G4AnalysisOutput::kRoot: <<
130 return "root"; <<
131 break; <<
132 case G4AnalysisOutput::kXml: <<
133 return "xml"; <<
134 break; <<
135 case G4AnalysisOutput::kNone: <<
136 return "none"; <<
137 break; <<
138 } <<
139 // should never reach this line <<
140 Warn("\"" + to_string(static_cast<int>(outpu <<
141 "\" output type is not supported.", <<
142 kNamespaceName, "CheckOutputName"); <<
143 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 } 175 }
360 176
361 } 177 }
362 178