ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4AttCheck.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4AttCheck.cc
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 
38 G4ThreadLocal G4bool G4AttCheck::fFirst = true;
39 
40 G4ThreadLocal std::set<G4String> *G4AttCheck::fUnitCategories = 0;
41 
42 G4ThreadLocal std::map<G4String,G4String> *G4AttCheck::fStandardUnits = 0;
43 
44 G4ThreadLocal std::set<G4String> *G4AttCheck::fCategories = 0;
45 
46 G4ThreadLocal std::set<G4String> *G4AttCheck::fUnits = 0;
47 
48 G4ThreadLocal std::set<G4String> *G4AttCheck::fValueTypes = 0;
49 
50 G4AttCheck::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 
109 G4AttCheck::~G4AttCheck()
110 {
111 }
112 
113 void 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 
122 G4bool 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 
248 std::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 
330 void 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 
349 G4bool 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 }