Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4AttCheck.cc
Go to the documentation of this file.
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
28#include "G4AttCheck.hh"
29
30#include "globals.hh"
31
32#include "G4AttDef.hh"
33#include "G4AttDefStore.hh"
34#include "G4AttValue.hh"
35#include "G4UnitsTable.hh"
36#include "G4UIcommand.hh"
37
38G4ThreadLocal G4bool G4AttCheck::fFirst = true;
39
40G4ThreadLocal std::set<G4String> *G4AttCheck::fUnitCategories = 0;
41
42G4ThreadLocal std::map<G4String,G4String> *G4AttCheck::fStandardUnits = 0;
43
44G4ThreadLocal std::set<G4String> *G4AttCheck::fCategories = 0;
45
46G4ThreadLocal std::set<G4String> *G4AttCheck::fUnits = 0;
47
48G4ThreadLocal std::set<G4String> *G4AttCheck::fValueTypes = 0;
49
50G4AttCheck::G4AttCheck
51(const std::vector<G4AttValue>* values,
52 const std::map<G4String,G4AttDef>* definitions):
53 fpValues(values),
54 fpDefinitions(definitions)
55{
56 Init();
57
58 if (fFirst) { // Initialise static containers.
59 fFirst = false;
60
61 // Legal Unit Category Types...
62 fUnitCategories->insert("Length");
63 fUnitCategories->insert("Energy");
64 fUnitCategories->insert("Time");
65 fUnitCategories->insert("Electric charge");
66 fUnitCategories->insert("Volumic Mass"); // (Density)
67
68 // Corresponding Standard Units...
69 (*fStandardUnits)["Length"] = "m";
70 (*fStandardUnits)["Energy"] = "MeV";
71 (*fStandardUnits)["Time"] = "ns";
72 (*fStandardUnits)["Electric charge"] = "e+";
73 (*fStandardUnits)["Volumic Mass"] = "kg/m3";
74
75 // Legal Categories...
76 fCategories->insert("Bookkeeping");
77 fCategories->insert("Draw");
78 fCategories->insert("Physics");
79 fCategories->insert("PickAction");
80 fCategories->insert("Association");
81
82 // Legal units...
83 fUnits->insert("");
84 fUnits->insert("G4BestUnit");
85 // ...plus any legal unit symbol ("MeV", "km", etc.)...
86 G4UnitsTable& units = G4UnitDefinition::GetUnitsTable();
87 for (size_t i = 0; i < units.size(); ++i) {
88 if (fUnitCategories->find(units[i]->GetName()) !=
89 fUnitCategories->end()) {
90 //G4cout << units[i]->GetName() << G4endl;
91 G4UnitsContainer& container = units[i]->GetUnitsList();
92 for (size_t j = 0; j < container.size(); ++j) {
93 //G4cout << container[j]->GetName() << ' '
94 // << container[j]->GetSymbol() << G4endl;
95 fUnits->insert(container[j]->GetSymbol());
96 }
97 }
98 }
99
100 // Legal Value Types...
101 fValueTypes->insert("G4String");
102 fValueTypes->insert("G4int");
103 fValueTypes->insert("G4double");
104 fValueTypes->insert("G4ThreeVector");
105 fValueTypes->insert("G4bool");
106 }
107}
108
109G4AttCheck::~G4AttCheck()
110{
111}
112
113void G4AttCheck::Init()
114{
115 if (!fValueTypes) fValueTypes = new std::set<G4String>;
116 if (!fUnits) fUnits = new std::set<G4String>;
117 if (!fCategories) fCategories = new std::set<G4String>;
118 if (!fStandardUnits) fStandardUnits = new std::map<G4String,G4String>;
119 if (!fUnitCategories) fUnitCategories = new std::set<G4String>;
120}
121
122G4bool G4AttCheck::Check(const G4String& leader) const
123{
124 // Check only. Silent unless error - then G4cerr. Returns error.
125 G4bool error = false;
126 static G4ThreadLocal G4int iError = 0;
127 G4bool print = false;
128 if (iError < 10 || iError%100 == 0) {
129 print = true;
130 }
131 using namespace std;
132 if (!fpValues) return error; // A null values vector is a valid situation.
133 if (!fpDefinitions) {
134 ++iError;
135 error = true;
136 if (print) {
137 G4cerr <<
138 "\n*******************************************************";
139 if (leader != "") {
140 G4cerr << '\n' << leader;
141 }
142 G4cerr <<
143 "\nG4AttCheck: ERROR " << iError << ": Null definitions pointer"
144 "\n*******************************************************"
145 << G4endl;
146 }
147 return error;
148 }
149 vector<G4AttValue>::const_iterator iValue;
150 for (iValue = fpValues->begin(); iValue != fpValues->end(); ++iValue) {
151 const G4String& valueName = iValue->GetName();
152 const G4String& value = iValue->GetValue();
153 map<G4String,G4AttDef>::const_iterator iDef =
154 fpDefinitions->find(valueName);
155 if (iDef == fpDefinitions->end()) {
156 ++iError;
157 error = true;
158 if (print) {
159 G4cerr <<
160 "\n*******************************************************";
161 if (leader != "") {
162 G4cerr << '\n' << leader;
163 }
164 G4cerr <<
165 "\nG4AttCheck: ERROR " << iError << ": No G4AttDef for G4AttValue \""
166 << valueName << "\": " << value <<
167 "\n*******************************************************"
168 << G4endl;
169 }
170 } else {
171 const G4String& category = iDef->second.GetCategory();
172 const G4String& extra = iDef->second.GetExtra();
173 const G4String& valueType = iDef->second.GetValueType();
174 if (fCategories->find(category) == fCategories->end()) {
175 ++iError;
176 error = true;
177 if (print) {
178 G4cerr <<
179 "\n*******************************************************";
180 if (leader != "") {
181 G4cerr << '\n' << leader;
182 }
183 G4cerr <<
184 "\nG4AttCheck: ERROR " << iError << ": Illegal Category Field \""
185 << category << "\" for G4AttValue \""
186 << valueName << "\": " << value <<
187 "\n Possible Categories:";
188 set<G4String>::iterator i;
189 for (i = fCategories->begin(); i != fCategories->end(); ++i) {
190 G4cerr << ' ' << *i;
191 }
192 G4cerr <<
193 "\n*******************************************************"
194 << G4endl;
195 }
196 }
197 if(category == "Physics" && fUnits->find(extra) == fUnits->end()) {
198 ++iError;
199 error = true;
200 if (print) {
201 G4cerr <<
202 "\n*******************************************************";
203 if (leader != "") {
204 G4cerr << '\n' << leader;
205 }
206 G4cerr <<
207 "\nG4AttCheck: ERROR " << iError << ": Illegal Extra field \""
208 << extra << "\" for G4AttValue \""
209 << valueName << "\": " << value <<
210 "\n Possible Extra fields if Category==\"Physics\":\n ";
211 set<G4String>::iterator i;
212 for (i = fUnits->begin(); i != fUnits->end(); ++i) {
213 G4cerr << ' ' << *i;
214 }
215 G4cerr <<
216 "\n*******************************************************"
217 << G4endl;
218 }
219 }
220 if (fValueTypes->find(valueType) == fValueTypes->end()) {
221 ++iError;
222 error = true;
223 if (print) {
224 G4cerr <<
225 "\n*******************************************************";
226 if (leader != "") {
227 G4cerr << '\n' << leader;
228 }
229 G4cerr <<
230 "\nG4AttCheck: ERROR " << iError << ": Illegal Value Type field \""
231 << valueType << "\" for G4AttValue \""
232 << valueName << "\": " << value <<
233 "\n Possible Value Types:";
234 set<G4String>::iterator i;
235 for (i = fValueTypes->begin(); i != fValueTypes->end(); ++i) {
236 G4cerr << ' ' << *i;
237 }
238 G4cerr <<
239 "\n*******************************************************"
240 << G4endl;
241 }
242 }
243 }
244 }
245 return error;
246}
247
248std::ostream& operator<< (std::ostream& os, const G4AttCheck& ac)
249{
250 using namespace std;
251 if (!ac.fpDefinitions) {
252 os << "G4AttCheck: ERROR: zero definitions pointer." << endl;
253 return os;
254 }
255 G4String storeKey;
256 if (G4AttDefStore::GetStoreKey(ac.fpDefinitions, storeKey)) {
257 os << storeKey << ':' << endl;
258 }
259 if (!ac.fpValues) {
260 // A null values vector is a valid situation.
261 os << "G4AttCheck: zero values pointer." << endl;
262 return os;
263 }
264 vector<G4AttValue>::const_iterator iValue;
265 for (iValue = ac.fpValues->begin(); iValue != ac.fpValues->end(); ++iValue) {
266 const G4String& valueName = iValue->GetName();
267 const G4String& value = iValue->GetValue();
268 map<G4String,G4AttDef>::const_iterator iDef =
269 ac.fpDefinitions->find(valueName);
270 G4bool error = false;
271 if (iDef == ac.fpDefinitions->end()) {
272 error = true;
273 os << "G4AttCheck: ERROR: No G4AttDef for G4AttValue \""
274 << valueName << "\": " << value << endl;
275 } else {
276 const G4String& category = iDef->second.GetCategory();
277 const G4String& extra = iDef->second.GetExtra();
278 const G4String& valueType = iDef->second.GetValueType();
279 if (ac.fCategories->find(category) == ac.fCategories->end()) {
280 error = true;
281 os <<
282 "G4AttCheck: ERROR: Illegal Category Field \"" << category
283 << "\" for G4AttValue \"" << valueName << "\": " << value <<
284 "\n Possible Categories:";
285 set<G4String>::iterator i;
286 for (i = ac.fCategories->begin(); i != ac.fCategories->end(); ++i) {
287 os << ' ' << *i;
288 }
289 os << endl;
290 }
291 if(category == "Physics" && ac.fUnits->find(extra) == ac.fUnits->end()) {
292 error = true;
293 os <<
294 "G4AttCheck: ERROR: Illegal Extra field \""<< extra
295 << "\" for G4AttValue \"" << valueName << "\": " << value <<
296 "\n Possible Extra fields if Category==\"Physics\":\n ";
297 set<G4String>::iterator i;
298 for (i = ac.fUnits->begin(); i != ac.fUnits->end(); ++i) {
299 os << ' ' << *i;
300 }
301 os << endl;
302 }
303 if (ac.fValueTypes->find(valueType) == ac.fValueTypes->end()) {
304 error = true;
305 os <<
306 "G4AttCheck: ERROR: Illegal Value Type field \"" << valueType
307 << "\" for G4AttValue \"" << valueName << "\": " << value <<
308 "\n Possible Value Types:";
309 set<G4String>::iterator i;
310 for (i = ac.fValueTypes->begin(); i != ac.fValueTypes->end(); ++i) {
311 os << ' ' << *i;
312 }
313 os << endl;
314 }
315 }
316 if (!error) {
317 os << iDef->second.GetDesc()
318 << " (" << valueName
319 << "): " << value;
320 if (iDef->second.GetCategory() == "Physics" &&
321 !iDef->second.GetExtra().empty()) {
322 os << " (" << iDef->second.GetExtra() << ")";
323 }
324 os << endl;
325 }
326 }
327 return os;
328}
329
330void G4AttCheck::AddValuesAndDefs
331(std::vector<G4AttValue>* standardValues,
332 std::map<G4String,G4AttDef>* standardDefinitions,
333 const G4String& oldName,
334 const G4String& name,
335 const G4String& value,
336 const G4String& extra,
337 const G4String& description) const
338{
339 // Add new G4AttDeff...
340 standardValues->push_back(G4AttValue(name,value,""));
341 // Copy original G4AttDef...
342 (*standardDefinitions)[name] = fpDefinitions->find(oldName)->second;
343 // ...and make appropriate changes...
344 (*standardDefinitions)[name].SetName(name);
345 (*standardDefinitions)[name].SetExtra(extra);
346 if (description != "") (*standardDefinitions)[name].SetDesc(description);
347}
348
349G4bool G4AttCheck::Standard
350(std::vector<G4AttValue>* standardValues,
351 std::map<G4String,G4AttDef>* standardDefinitions) const
352{
353 // Places standard versions in provided vector and map and returns error.
354 // Assumes valid input. Use Check to check.
355 using namespace std;
356 G4bool error = false;
357 vector<G4AttValue>::const_iterator iValue;
358 for (iValue = fpValues->begin(); iValue != fpValues->end(); ++iValue) {
359 const G4String& valueName = iValue->GetName();
360 const G4String& value = iValue->GetValue();
361 map<G4String,G4AttDef>::const_iterator iDef =
362 fpDefinitions->find(valueName);
363 if (iDef == fpDefinitions->end()) {
364 error = true;
365 } else {
366 const G4String& category = iDef->second.GetCategory();
367 const G4String& extra = iDef->second.GetExtra();
368 const G4String& valueType = iDef->second.GetValueType();
369 if (fCategories->find(category) == fCategories->end() ||
370 (category == "Physics" && fUnits->find(extra) == fUnits->end()) ||
371 fValueTypes->find(valueType) == fValueTypes->end()) {
372 error = true;
373 } else {
374 if (category != "Physics") { // Simply copy...
375 standardValues->push_back(*iValue);
376 (*standardDefinitions)[valueName] =
377 fpDefinitions->find(valueName)->second;
378 } else { // "Physics"...
379 if (extra.empty()) { // Dimensionless...
380 if (valueType == "G4ThreeVector") { // Split vector into 3...
381 G4ThreeVector internalValue =
382 G4UIcommand::ConvertTo3Vector(value);
383 AddValuesAndDefs
384 (standardValues,standardDefinitions,
385 valueName,valueName+"-X",
386 G4UIcommand::ConvertToString(internalValue.x()),"",
387 fpDefinitions->find(valueName)->second.GetDesc()+"-X");
388 AddValuesAndDefs
389 (standardValues,standardDefinitions,
390 valueName,valueName+"-Y",
391 G4UIcommand::ConvertToString(internalValue.y()),"",
392 fpDefinitions->find(valueName)->second.GetDesc()+"-Y");
393 AddValuesAndDefs
394 (standardValues,standardDefinitions,
395 valueName,valueName+"-Z",
396 G4UIcommand::ConvertToString(internalValue.z()),"",
397 fpDefinitions->find(valueName)->second.GetDesc()+"-Z");
398 } else { // Simply copy...
399 standardValues->push_back(*iValue);
400 (*standardDefinitions)[valueName] =
401 fpDefinitions->find(valueName)->second;
402 }
403 } else { // Dimensioned...
404 G4String valueAndUnit;
405 G4String unit;
406 if (extra == "G4BestUnit") {
407 valueAndUnit = value;
408 valueAndUnit = valueAndUnit.strip();
409 unit = valueAndUnit.substr(valueAndUnit.rfind(' ')+1);
410 } else {
411 valueAndUnit = value + ' ' + extra;
412 valueAndUnit = valueAndUnit.strip();
413 unit = extra;
414 }
415 G4String unitCategory = G4UnitDefinition::GetCategory(unit);
416 if (fUnitCategories->find(unitCategory) != fUnitCategories->end()) {
417 G4String standardUnit = (*fStandardUnits)[unitCategory];
418 G4double valueOfStandardUnit =
419 G4UnitDefinition::GetValueOf(standardUnit);
420// G4String exstr = iDef->second.GetExtra();
421 if (valueType == "G4ThreeVector") { // Split vector into 3...
422 G4ThreeVector internalValue =
423 G4UIcommand::ConvertToDimensioned3Vector(valueAndUnit);
424 AddValuesAndDefs
425 (standardValues,standardDefinitions,
426 valueName,valueName+"-X",
427 G4UIcommand::ConvertToString
428 (internalValue.x()/valueOfStandardUnit),
429 standardUnit,
430 fpDefinitions->find(valueName)->second.GetDesc()+"-X");
431 AddValuesAndDefs
432 (standardValues,standardDefinitions,
433 valueName,valueName+"-Y",
434 G4UIcommand::ConvertToString
435 (internalValue.y()/valueOfStandardUnit),
436 standardUnit,
437 fpDefinitions->find(valueName)->second.GetDesc()+"-Y");
438 AddValuesAndDefs
439 (standardValues,standardDefinitions,
440 valueName,valueName+"-Z",
441 G4UIcommand::ConvertToString
442 (internalValue.z()/valueOfStandardUnit),
443 standardUnit,
444 fpDefinitions->find(valueName)->second.GetDesc()+"-Z");
445 } else {
446 G4double internalValue =
447 G4UIcommand::ConvertToDimensionedDouble(valueAndUnit);
448 AddValuesAndDefs
449 (standardValues,standardDefinitions,
450 valueName,valueName,
451 G4UIcommand::ConvertToString
452 (internalValue/valueOfStandardUnit),
453 standardUnit);
454 }
455 }
456 }
457 }
458 }
459 }
460 }
461 if (error) {
462 G4cerr << "G4AttCheck::Standard: Conversion error." << G4endl;
463 }
464 return error;
465}
operator<<
std::ostream & operator<<(std::ostream &os, const G4AttCheck &ac)
Definition: G4AttCheck.cc:248
G4double
double G4double
Definition: G4Types.hh:83
G4bool
bool G4bool
Definition: G4Types.hh:86
G4int
int G4int
Definition: G4Types.hh:85
G4UnitsContainer
std::vector< G4UnitDefinition * > G4UnitsContainer
Definition: G4UnitsTable.hh:127
G4UnitsTable
std::vector< G4UnitsCategory * > G4UnitsTable
Definition: G4UnitsTable.hh:68
print
void print(G4double elem)
Definition: G4ecpssrBaseKxsModel.cc:108
G4cerr
G4GLOB_DLL std::ostream G4cerr
G4endl
#define G4endl
Definition: G4ios.hh:57
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
G4AttCheck::G4AttCheck
G4AttCheck(const std::vector< G4AttValue > *values, const std::map< G4String, G4AttDef > *definitions)
Definition: G4AttCheck.cc:51
G4AttCheck::Check
G4bool Check(const G4String &leader="") const
Definition: G4AttCheck.cc:122
G4AttCheck::Standard
G4bool Standard(std::vector< G4AttValue > *standardValues, std::map< G4String, G4AttDef > *standardDefinitions) const
Definition: G4AttCheck.cc:350
G4String::strip
G4String strip(G4int strip_Type=trailing, char c=' ')
G4UIcommand::ConvertTo3Vector
static G4ThreeVector ConvertTo3Vector(const char *st)
Definition: G4UIcommand.cc:583
G4UIcommand::ConvertToString
static G4String ConvertToString(G4bool boolVal)
Definition: G4UIcommand.cc:430
G4UIcommand::ConvertToDimensionedDouble
static G4double ConvertToDimensionedDouble(const char *st)
Definition: G4UIcommand.cc:570
G4UIcommand::ConvertToDimensioned3Vector
static G4ThreeVector ConvertToDimensioned3Vector(const char *st)
Definition: G4UIcommand.cc:594
G4UnitDefinition::GetValueOf
static G4double GetValueOf(const G4String &)
Definition: G4UnitsTable.cc:193
G4UnitDefinition::GetCategory
static G4String GetCategory(const G4String &)
Definition: G4UnitsTable.cc:218
G4UnitDefinition::GetUnitsTable
static G4UnitsTable & GetUnitsTable()
Definition: G4UnitsTable.cc:151
G4AttDefStore::GetStoreKey
G4bool GetStoreKey(const std::map< G4String, G4AttDef > *definitions, G4String &key)
Definition: G4AttDefStore.cc:69
G4ThreadLocal
#define G4ThreadLocal
Definition: tls.hh:77