#include <G4AttCheck.hh>

Public Member Functions
G4bool	Check (const G4String &leader="") const

	G4AttCheck (const std::vector< G4AttValue > values, const std::map< G4String, G4AttDef > definitions)

const std::map< G4String, G4AttDef > *	GetAttDefs () const

const std::vector< G4AttValue > *	GetAttValues () const

G4bool	Standard (std::vector< G4AttValue > standardValues, std::map< G4String, G4AttDef > standardDefinitions) const

	~G4AttCheck ()

Private Member Functions
void	AddValuesAndDefs (std::vector< G4AttValue > newValues, std::map< G4String, G4AttDef > newDefinitions, const G4String &oldName, const G4String &name, const G4String &value, const G4String &extra, const G4String &description="") const

void	Init ()

Private Attributes
const std::map< G4String, G4AttDef > *	fpDefinitions

const std::vector< G4AttValue > *	fpValues

Static Private Attributes
static G4ThreadLocal std::set< G4String > *	fCategories = 0

static G4ThreadLocal G4bool	fFirst = true

static G4ThreadLocal std::map< G4String, G4String > *	fStandardUnits = 0

static G4ThreadLocal std::set< G4String > *	fUnitCategories = 0

static G4ThreadLocal std::set< G4String > *	fUnits = 0

static G4ThreadLocal std::set< G4String > *	fValueTypes = 0

Friends
std::ostream &	operator<< (std::ostream &, const G4AttCheck &)

Detailed Description

Definition at line 56 of file G4AttCheck.hh.

Constructor & Destructor Documentation

◆ G4AttCheck()

G4AttCheck::G4AttCheck	(	const std::vector< G4AttValue > *	values,
		const std::map< G4String, G4AttDef > *	definitions
	)

Definition at line 50 of file G4AttCheck.cc.

                                              :
  fpValues(values),
  fpDefinitions(definitions)
{
  Init();
 
  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");
  }
}

References fCategories, fFirst, fUnitCategories, fUnits, fValueTypes, G4UnitDefinition::GetUnitsTable(), and Init().

◆ ~G4AttCheck()

G4AttCheck::~G4AttCheck ( )

Definition at line 109 of file G4AttCheck.cc.

110{

111}

Member Function Documentation

◆ AddValuesAndDefs()

void G4AttCheck::AddValuesAndDefs	(	std::vector< G4AttValue > *	newValues,
		std::map< G4String, G4AttDef > *	newDefinitions,
		const G4String &	oldName,
		const G4String &	name,
		const G4String &	value,
		const G4String &	extra,
		const G4String &	description = `""`
	)		const

private

Definition at line 330 of file G4AttCheck.cc.

{
  // 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);
}

References fpDefinitions, and G4InuclParticleNames::name().

Referenced by Standard().

◆ Check()

G4bool G4AttCheck::Check ( const G4String & leader = "" ) const

Definition at line 122 of file G4AttCheck.cc.

{
  // Check only.  Silent unless error - then G4cerr.  Returns error.
  G4bool error = false;
  static G4ThreadLocal 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;
}

References error, fCategories, fpDefinitions, fpValues, fUnits, fValueTypes, G4cerr, G4endl, G4ThreadLocal, and print().

Referenced by G4TrajectoriesModelDebugG4AttValues().

◆ GetAttDefs()

const std::map< G4String, G4AttDef > * G4AttCheck::GetAttDefs ( ) const

inline

Definition at line 70 of file G4AttCheck.hh.

                                                      {
    return fpDefinitions;
  }

References fpDefinitions.

◆ GetAttValues()

const std::vector< G4AttValue > * G4AttCheck::GetAttValues ( ) const

inline

Definition at line 66 of file G4AttCheck.hh.

                                                    {
    return fpValues;
  }

References fpValues.

◆ Init()

void G4AttCheck::Init ( )

private

Definition at line 113 of file G4AttCheck.cc.

{
  if (!fValueTypes) fValueTypes = new std::set<G4String>;
  if (!fUnits) fUnits = new std::set<G4String>;
  if (!fCategories) fCategories = new std::set<G4String>;
  if (!fStandardUnits) fStandardUnits = new std::map<G4String,G4String>;
  if (!fUnitCategories) fUnitCategories = new std::set<G4String>;
}

References fCategories, fStandardUnits, fUnitCategories, fUnits, and fValueTypes.

Referenced by G4AttCheck().

◆ Standard()

G4bool G4AttCheck::Standard	(	std::vector< G4AttValue > *	standardValues,
		std::map< G4String, G4AttDef > *	standardDefinitions
	)		const

Definition at line 349 of file G4AttCheck.cc.

{
  // 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 = G4StrUtil::strip_copy(value);
              unit = valueAndUnit.substr(valueAndUnit.rfind(' ')+1);
            } else {
              valueAndUnit = G4StrUtil::strip_copy(value + ' ' + extra);
              unit = extra;
            }
            G4String unitCategory = G4UnitDefinition::GetCategory(unit);
            if (fUnitCategories->find(unitCategory) != fUnitCategories->end()) {
              G4String standardUnit = (*fStandardUnits)[unitCategory];
              G4double valueOfStandardUnit =
                G4UnitDefinition::GetValueOf(standardUnit);
//              G4String exstr = 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;
}

References AddValuesAndDefs(), G4UIcommand::ConvertTo3Vector(), G4UIcommand::ConvertToDimensioned3Vector(), G4UIcommand::ConvertToDimensionedDouble(), G4UIcommand::ConvertToString(), error, fCategories, fpDefinitions, fpValues, fUnitCategories, fUnits, fValueTypes, G4cerr, G4endl, G4UnitDefinition::GetCategory(), G4UnitDefinition::GetValueOf(), G4StrUtil::strip_copy(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4HepRepFileSceneHandler::AddCompound(), and G4TrajectoriesModelDebugG4AttValues().

Friends And Related Function Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		const G4AttCheck &	ac
	)

friend

Definition at line 248 of file G4AttCheck.cc.

{
  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;
}

Field Documentation

◆ fCategories

G4ThreadLocal std::set< G4String > * G4AttCheck::fCategories = 0

staticprivate

Definition at line 105 of file G4AttCheck.hh.

Referenced by Check(), G4AttCheck(), Init(), and Standard().

◆ fFirst

G4ThreadLocal G4bool G4AttCheck::fFirst = true

staticprivate

Definition at line 102 of file G4AttCheck.hh.

Referenced by G4AttCheck().

◆ fpDefinitions

const std::map<G4String,G4AttDef>* G4AttCheck::fpDefinitions

private

Definition at line 100 of file G4AttCheck.hh.

Referenced by AddValuesAndDefs(), Check(), GetAttDefs(), and Standard().

◆ fpValues

const std::vector<G4AttValue>* G4AttCheck::fpValues

private

Definition at line 99 of file G4AttCheck.hh.

Referenced by Check(), GetAttValues(), and Standard().

◆ fStandardUnits

G4ThreadLocal std::map< G4String, G4String > * G4AttCheck::fStandardUnits = 0

staticprivate

Definition at line 104 of file G4AttCheck.hh.

Referenced by Init().

◆ fUnitCategories

G4ThreadLocal std::set< G4String > * G4AttCheck::fUnitCategories = 0

staticprivate

Definition at line 103 of file G4AttCheck.hh.

Referenced by G4AttCheck(), Init(), and Standard().

◆ fUnits

G4ThreadLocal std::set< G4String > * G4AttCheck::fUnits = 0

staticprivate

Definition at line 106 of file G4AttCheck.hh.

Referenced by Check(), G4AttCheck(), Init(), and Standard().

◆ fValueTypes

G4ThreadLocal std::set< G4String > * G4AttCheck::fValueTypes = 0

staticprivate

Definition at line 107 of file G4AttCheck.hh.

Referenced by Check(), G4AttCheck(), Init(), and Standard().

The documentation for this class was generated from the following files:

source/graphics_reps/include/G4AttCheck.hh
source/graphics_reps/src/G4AttCheck.cc

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ G4AttCheck()

◆ ~G4AttCheck()

Member Function Documentation

◆ AddValuesAndDefs()

◆ Check()

◆ GetAttDefs()

◆ GetAttValues()

◆ Init()

◆ Standard()

Friends And Related Function Documentation

◆ operator<<

Field Documentation

◆ fCategories

◆ fFirst

◆ fpDefinitions

◆ fpValues

◆ fStandardUnits

◆ fUnitCategories

◆ fUnits

◆ fValueTypes