lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b1eb5424d2e561eed732e8a9b976b16e7f281856
geant4/source/graphics_reps/src/G4AttCheck.cc
T
Gabriele Cosmo b1eb5424d2 Import Geant4 9.5.0 source tree
2016-06-09 16:46:55 +02:00

452 lines
15 KiB
C++
Raw Blame History

//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4AttCheck.cc,v 1.16 2010-12-07 09:36:59 allison Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
#include "G4AttCheck.hh"
#include "globals.hh"
#include "G4AttDef.hh"
#include "G4AttDefStore.hh"
#include "G4AttValue.hh"
#include "G4UnitsTable.hh"
#include "G4UIcommand.hh"
G4AttCheck::G4AttCheck
(const std::vector<G4AttValue>* values,
const std::map<G4String,G4AttDef>* definitions):
fpValues(values),
fpDefinitions(definitions)
{
if (fFirst) { // Initialise static containers.
fFirst = false;
// Legal Unit Category Types...
fUnitCategories.insert("Length");
fUnitCategories.insert("Energy");
fUnitCategories.insert("Time");
fUnitCategories.insert("Electric charge");
fUnitCategories.insert("Volumic Mass"); // (Density)
// Corresponding Standard Units...
fStandardUnits["Length"] = "m";
fStandardUnits["Energy"] = "MeV";
fStandardUnits["Time"] = "ns";
fStandardUnits["Electric charge"] = "e+";
fStandardUnits["Volumic Mass"] = "kg/m3";
// Legal Categories...
fCategories.insert("Bookkeeping");
fCategories.insert("Draw");
fCategories.insert("Physics");
fCategories.insert("PickAction");
fCategories.insert("Association");
// Legal units...
fUnits.insert("");
fUnits.insert("G4BestUnit");
// ...plus any legal unit symbol ("MeV", "km", etc.)...
G4UnitsTable& units = G4UnitDefinition::GetUnitsTable();
for (size_t i = 0; i < units.size(); ++i) {
if (fUnitCategories.find(units[i]->GetName()) !=
fUnitCategories.end()) {
//G4cout << units[i]->GetName() << G4endl;
G4UnitsContainer& container = units[i]->GetUnitsList();
for (size_t j = 0; j < container.size(); ++j) {
//G4cout << container[j]->GetName() << ' '
// << container[j]->GetSymbol() << G4endl;
fUnits.insert(container[j]->GetSymbol());
}
}
}
// Legal Value Types...
fValueTypes.insert("G4String");
fValueTypes.insert("G4int");
fValueTypes.insert("G4double");
fValueTypes.insert("G4ThreeVector");
fValueTypes.insert("G4bool");
}
}
G4AttCheck::~G4AttCheck() {}
G4bool G4AttCheck::fFirst = true;
std::set<G4String> G4AttCheck::fUnitCategories;
std::map<G4String,G4String> G4AttCheck::fStandardUnits;
std::set<G4String> G4AttCheck::fCategories;
std::set<G4String> G4AttCheck::fUnits;
std::set<G4String> G4AttCheck::fValueTypes;
G4bool G4AttCheck::Check(const G4String& leader) const {
// Check only. Silent unless error - then G4cerr. Returns error.
G4bool error = false;
static G4int iError = 0;
G4bool print = false;
if (iError < 10 || iError%100 == 0) {
print = true;
}
using namespace std;
if (!fpValues) return error; // A null values vector is a valid situation.
if (!fpDefinitions) {
++iError;
error = true;
if (print) {
G4cerr <<
"\n*******************************************************";
if (leader != "") {
G4cerr << '\n' << leader;
}
G4cerr <<
"\nG4AttCheck: ERROR " << iError << ": Null definitions pointer"
"\n*******************************************************"
<< G4endl;
}
return error;
}
vector<G4AttValue>::const_iterator iValue;
for (iValue = fpValues->begin(); iValue != fpValues->end(); ++iValue) {
const G4String& valueName = iValue->GetName();
const G4String& value = iValue->GetValue();
map<G4String,G4AttDef>::const_iterator iDef =
fpDefinitions->find(valueName);
if (iDef == fpDefinitions->end()) {
++iError;
error = true;
if (print) {
G4cerr <<
"\n*******************************************************";
if (leader != "") {
G4cerr << '\n' << leader;
}
G4cerr <<
"\nG4AttCheck: ERROR " << iError << ": No G4AttDef for G4AttValue \""
<< valueName << "\": " << value <<
"\n*******************************************************"
<< G4endl;
}
} else {
const G4String& category = iDef->second.GetCategory();
const G4String& extra = iDef->second.GetExtra();
const G4String& valueType = iDef->second.GetValueType();
if (fCategories.find(category) == fCategories.end()) {
++iError;
error = true;
if (print) {
G4cerr <<
"\n*******************************************************";
if (leader != "") {
G4cerr << '\n' << leader;
}
G4cerr <<
"\nG4AttCheck: ERROR " << iError << ": Illegal Category Field \""
<< category << "\" for G4AttValue \""
<< valueName << "\": " << value <<
"\n Possible Categories:";
set<G4String>::iterator i;
for (i = fCategories.begin(); i != fCategories.end(); ++i) {
G4cerr << ' ' << *i;
}
G4cerr <<
"\n*******************************************************"
<< G4endl;
}
}
if(category == "Physics" && fUnits.find(extra) == fUnits.end()) {
++iError;
error = true;
if (print) {
G4cerr <<
"\n*******************************************************";
if (leader != "") {
G4cerr << '\n' << leader;
}
G4cerr <<
"\nG4AttCheck: ERROR " << iError << ": Illegal Extra field \""
<< extra << "\" for G4AttValue \""
<< valueName << "\": " << value <<
"\n Possible Extra fields if Category==\"Physics\":\n ";
set<G4String>::iterator i;
for (i = fUnits.begin(); i != fUnits.end(); ++i) {
G4cerr << ' ' << *i;
}
G4cerr <<
"\n*******************************************************"
<< G4endl;
}
}
if (fValueTypes.find(valueType) == fValueTypes.end()) {
++iError;
error = true;
if (print) {
G4cerr <<
"\n*******************************************************";
if (leader != "") {
G4cerr << '\n' << leader;
}
G4cerr <<
"\nG4AttCheck: ERROR " << iError << ": Illegal Value Type field \""
<< valueType << "\" for G4AttValue \""
<< valueName << "\": " << value <<
"\n Possible Value Types:";
set<G4String>::iterator i;
for (i = fValueTypes.begin(); i != fValueTypes.end(); ++i) {
G4cerr << ' ' << *i;
}
G4cerr <<
"\n*******************************************************"
<< G4endl;
}
}
}
}
return error;
}
std::ostream& operator<< (std::ostream& os, const G4AttCheck& ac)
{
using namespace std;
if (!ac.fpDefinitions) {
os << "G4AttCheck: ERROR: zero definitions pointer." << endl;
return os;
}
G4String storeKey;
if (G4AttDefStore::GetStoreKey(ac.fpDefinitions, storeKey)) {
os << storeKey << ':' << endl;
}
if (!ac.fpValues) {
// A null values vector is a valid situation.
os << "G4AttCheck: zero values pointer." << endl;
return os;
}
vector<G4AttValue>::const_iterator iValue;
for (iValue = ac.fpValues->begin(); iValue != ac.fpValues->end(); ++iValue) {
const G4String& valueName = iValue->GetName();
const G4String& value = iValue->GetValue();
map<G4String,G4AttDef>::const_iterator iDef =
ac.fpDefinitions->find(valueName);
G4bool error = false;
if (iDef == ac.fpDefinitions->end()) {
error = true;
os << "G4AttCheck: ERROR: No G4AttDef for G4AttValue \""
<< valueName << "\": " << value << endl;
} else {
const G4String& category = iDef->second.GetCategory();
const G4String& extra = iDef->second.GetExtra();
const G4String& valueType = iDef->second.GetValueType();
if (ac.fCategories.find(category) == ac.fCategories.end()) {
error = true;
os <<
"G4AttCheck: ERROR: Illegal Category Field \"" << category
<< "\" for G4AttValue \"" << valueName << "\": " << value <<
"\n Possible Categories:";
set<G4String>::iterator i;
for (i = ac.fCategories.begin(); i != ac.fCategories.end(); ++i) {
os << ' ' << *i;
}
os << endl;
}
if(category == "Physics" && ac.fUnits.find(extra) == ac.fUnits.end()) {
error = true;
os <<
"G4AttCheck: ERROR: Illegal Extra field \""<< extra
<< "\" for G4AttValue \"" << valueName << "\": " << value <<
"\n Possible Extra fields if Category==\"Physics\":\n ";
set<G4String>::iterator i;
for (i = ac.fUnits.begin(); i != ac.fUnits.end(); ++i) {
os << ' ' << *i;
}
os << endl;
}
if (ac.fValueTypes.find(valueType) == ac.fValueTypes.end()) {
error = true;
os <<
"G4AttCheck: ERROR: Illegal Value Type field \"" << valueType
<< "\" for G4AttValue \"" << valueName << "\": " << value <<
"\n Possible Value Types:";
set<G4String>::iterator i;
for (i = ac.fValueTypes.begin(); i != ac.fValueTypes.end(); ++i) {
os << ' ' << *i;
}
os << endl;
}
}
if (!error) {
os << iDef->second.GetDesc()
<< " (" << valueName
<< "): " << value;
if (iDef->second.GetCategory() == "Physics" &&
!iDef->second.GetExtra().empty()) {
os << " (" << iDef->second.GetExtra() << ")";
}
os << endl;
}
}
return os;
}
void G4AttCheck::AddValuesAndDefs
(std::vector<G4AttValue>* standardValues,
std::map<G4String,G4AttDef>* standardDefinitions,
const G4String& oldName,
const G4String& name,
const G4String& value,
const G4String& extra,
const G4String& description) const {
// Add new G4AttDeff...
standardValues->push_back(G4AttValue(name,value,""));
// Copy original G4AttDef...
(*standardDefinitions)[name] = fpDefinitions->find(oldName)->second;
// ...and make appropriate changes...
(*standardDefinitions)[name].SetName(name);
(*standardDefinitions)[name].SetExtra(extra);
if (description != "") (*standardDefinitions)[name].SetDesc(description);
}
G4bool G4AttCheck::Standard
(std::vector<G4AttValue>* standardValues,
std::map<G4String,G4AttDef>* standardDefinitions) const {
// Places standard versions in provided vector and map and returns error.
// Assumes valid input. Use Check to check.
using namespace std;
G4bool error = false;
vector<G4AttValue>::const_iterator iValue;
for (iValue = fpValues->begin(); iValue != fpValues->end(); ++iValue) {
const G4String& valueName = iValue->GetName();
const G4String& value = iValue->GetValue();
map<G4String,G4AttDef>::const_iterator iDef =
fpDefinitions->find(valueName);
if (iDef == fpDefinitions->end()) {
error = true;
} else {
const G4String& category = iDef->second.GetCategory();
const G4String& extra = iDef->second.GetExtra();
const G4String& valueType = iDef->second.GetValueType();
if (fCategories.find(category) == fCategories.end() ||
(category == "Physics" && fUnits.find(extra) == fUnits.end()) ||
fValueTypes.find(valueType) == fValueTypes.end()) {
error = true;
} else {
if (category != "Physics") { // Simply copy...
standardValues->push_back(*iValue);
(*standardDefinitions)[valueName] =
fpDefinitions->find(valueName)->second;
} else { // "Physics"...
if (extra.empty()) { // Dimensionless...
if (valueType == "G4ThreeVector") { // Split vector into 3...
G4ThreeVector internalValue =
G4UIcommand::ConvertTo3Vector(value);
AddValuesAndDefs
(standardValues,standardDefinitions,
valueName,valueName+"-X",
G4UIcommand::ConvertToString(internalValue.x()),"",
fpDefinitions->find(valueName)->second.GetDesc()+"-X");
AddValuesAndDefs
(standardValues,standardDefinitions,
valueName,valueName+"-Y",
G4UIcommand::ConvertToString(internalValue.y()),"",
fpDefinitions->find(valueName)->second.GetDesc()+"-Y");
AddValuesAndDefs
(standardValues,standardDefinitions,
valueName,valueName+"-Z",
G4UIcommand::ConvertToString(internalValue.z()),"",
fpDefinitions->find(valueName)->second.GetDesc()+"-Z");
} else { // Simply copy...
standardValues->push_back(*iValue);
(*standardDefinitions)[valueName] =
fpDefinitions->find(valueName)->second;
}
} else { // Dimensioned...
G4String valueAndUnit;
G4String unit;
if (extra == "G4BestUnit") {
valueAndUnit = value;
valueAndUnit = valueAndUnit.strip();
unit = valueAndUnit.substr(valueAndUnit.rfind(' ')+1);
} else {
valueAndUnit = value + ' ' + extra;
valueAndUnit = valueAndUnit.strip();
unit = extra;
}
G4String unitCategory = G4UnitDefinition::GetCategory(unit);
if (fUnitCategories.find(unitCategory) != fUnitCategories.end()) {
G4String standardUnit = fStandardUnits[unitCategory];
G4double valueOfStandardUnit =
G4UnitDefinition::GetValueOf(standardUnit);
G4String extra = iDef->second.GetExtra();
if (valueType == "G4ThreeVector") { // Split vector into 3...
G4ThreeVector internalValue =
G4UIcommand::ConvertToDimensioned3Vector(valueAndUnit);
AddValuesAndDefs
(standardValues,standardDefinitions,
valueName,valueName+"-X",
G4UIcommand::ConvertToString
(internalValue.x()/valueOfStandardUnit),
standardUnit,
fpDefinitions->find(valueName)->second.GetDesc()+"-X");
AddValuesAndDefs
(standardValues,standardDefinitions,
valueName,valueName+"-Y",
G4UIcommand::ConvertToString
(internalValue.y()/valueOfStandardUnit),
standardUnit,
fpDefinitions->find(valueName)->second.GetDesc()+"-Y");
AddValuesAndDefs
(standardValues,standardDefinitions,
valueName,valueName+"-Z",
G4UIcommand::ConvertToString
(internalValue.z()/valueOfStandardUnit),
standardUnit,
fpDefinitions->find(valueName)->second.GetDesc()+"-Z");
} else {
G4double internalValue =
G4UIcommand::ConvertToDimensionedDouble(valueAndUnit);
AddValuesAndDefs
(standardValues,standardDefinitions,
valueName,valueName,
G4UIcommand::ConvertToString
(internalValue/valueOfStandardUnit),
standardUnit);
}
}
}
}
}
}
}
if (error) {
G4cerr << "G4AttCheck::Standard: Conversion error." << G4endl;
}
return error;
}
Reference in New Issue View Git Blame Copy Permalink