source: trunk/source/graphics_reps/src/G4AttCheck.cc@ 1031

Last change on this file since 1031 was 850, checked in by garnier, 17 years ago

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