Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // 26 // 26 // >> 27 // $Id: G4AttCheck.cc 78955 2014-02-05 09:45:46Z gcosmo $ 27 28 28 #include "G4AttCheck.hh" 29 #include "G4AttCheck.hh" 29 30 30 #include "globals.hh" 31 #include "globals.hh" 31 32 32 #include "G4AttDef.hh" 33 #include "G4AttDef.hh" 33 #include "G4AttDefStore.hh" 34 #include "G4AttDefStore.hh" 34 #include "G4AttValue.hh" 35 #include "G4AttValue.hh" 35 #include "G4UnitsTable.hh" 36 #include "G4UnitsTable.hh" 36 #include "G4UIcommand.hh" 37 #include "G4UIcommand.hh" 37 38 38 G4ThreadLocal G4bool G4AttCheck::fFirst = true 39 G4ThreadLocal G4bool G4AttCheck::fFirst = true; 39 40 40 G4ThreadLocal std::set<G4String> *G4AttCheck:: << 41 G4ThreadLocal std::set<G4String> *G4AttCheck::fUnitCategories = 0; 41 42 42 G4ThreadLocal std::map<G4String,G4String> *G4A << 43 G4ThreadLocal std::map<G4String,G4String> *G4AttCheck::fStandardUnits = 0; 43 44 44 G4ThreadLocal std::set<G4String> *G4AttCheck:: << 45 G4ThreadLocal std::set<G4String> *G4AttCheck::fCategories = 0; 45 46 46 G4ThreadLocal std::set<G4String> *G4AttCheck:: << 47 G4ThreadLocal std::set<G4String> *G4AttCheck::fUnits = 0; 47 48 48 G4ThreadLocal std::set<G4String> *G4AttCheck:: << 49 G4ThreadLocal std::set<G4String> *G4AttCheck::fValueTypes = 0; 49 50 50 G4AttCheck::G4AttCheck 51 G4AttCheck::G4AttCheck 51 (const std::vector<G4AttValue>* values, 52 (const std::vector<G4AttValue>* values, 52 const std::map<G4String,G4AttDef>* definition 53 const std::map<G4String,G4AttDef>* definitions): 53 fpValues(values), 54 fpValues(values), 54 fpDefinitions(definitions) 55 fpDefinitions(definitions) 55 { 56 { 56 Init(); 57 Init(); 57 58 58 if (fFirst) { // Initialise static containe 59 if (fFirst) { // Initialise static containers. 59 fFirst = false; 60 fFirst = false; 60 61 61 // Legal Unit Category Types... 62 // Legal Unit Category Types... 62 fUnitCategories->insert("Length"); 63 fUnitCategories->insert("Length"); 63 fUnitCategories->insert("Energy"); 64 fUnitCategories->insert("Energy"); 64 fUnitCategories->insert("Time"); 65 fUnitCategories->insert("Time"); 65 fUnitCategories->insert("Electric charge") 66 fUnitCategories->insert("Electric charge"); 66 fUnitCategories->insert("Volumic Mass"); 67 fUnitCategories->insert("Volumic Mass"); // (Density) 67 68 68 // Corresponding Standard Units... 69 // Corresponding Standard Units... 69 (*fStandardUnits)["Length"] = "m"; 70 (*fStandardUnits)["Length"] = "m"; 70 (*fStandardUnits)["Energy"] = "MeV"; 71 (*fStandardUnits)["Energy"] = "MeV"; 71 (*fStandardUnits)["Time"] = "ns"; 72 (*fStandardUnits)["Time"] = "ns"; 72 (*fStandardUnits)["Electric charge"] = "e+ 73 (*fStandardUnits)["Electric charge"] = "e+"; 73 (*fStandardUnits)["Volumic Mass"] = "kg/m3 74 (*fStandardUnits)["Volumic Mass"] = "kg/m3"; 74 75 75 // Legal Categories... 76 // Legal Categories... 76 fCategories->insert("Bookkeeping"); 77 fCategories->insert("Bookkeeping"); 77 fCategories->insert("Draw"); 78 fCategories->insert("Draw"); 78 fCategories->insert("Physics"); 79 fCategories->insert("Physics"); 79 fCategories->insert("PickAction"); 80 fCategories->insert("PickAction"); 80 fCategories->insert("Association"); 81 fCategories->insert("Association"); 81 82 82 // Legal units... 83 // Legal units... 83 fUnits->insert(""); 84 fUnits->insert(""); 84 fUnits->insert("G4BestUnit"); 85 fUnits->insert("G4BestUnit"); 85 // ...plus any legal unit symbol ("MeV", " 86 // ...plus any legal unit symbol ("MeV", "km", etc.)... 86 G4UnitsTable& units = G4UnitDefinition::Ge 87 G4UnitsTable& units = G4UnitDefinition::GetUnitsTable(); 87 for (size_t i = 0; i < units.size(); ++i) 88 for (size_t i = 0; i < units.size(); ++i) { 88 if (fUnitCategories->find(units[i]->GetN 89 if (fUnitCategories->find(units[i]->GetName()) != 89 fUnitCategories->end()) { 90 fUnitCategories->end()) { 90 //G4cout << units[i]->GetName() << G4e 91 //G4cout << units[i]->GetName() << G4endl; 91 G4UnitsContainer& container = units[i] 92 G4UnitsContainer& container = units[i]->GetUnitsList(); 92 for (auto & j : container) { << 93 for (size_t j = 0; j < container.size(); ++j) { 93 //G4cout << container[j]->GetName() 94 //G4cout << container[j]->GetName() << ' ' 94 // << container[j]->GetSymbol( 95 // << container[j]->GetSymbol() << G4endl; 95 fUnits->insert(j->GetSymbol()); << 96 fUnits->insert(container[j]->GetSymbol()); 96 } 97 } 97 } 98 } 98 } 99 } 99 100 100 // Legal Value Types... 101 // Legal Value Types... 101 fValueTypes->insert("G4String"); 102 fValueTypes->insert("G4String"); 102 fValueTypes->insert("G4int"); 103 fValueTypes->insert("G4int"); 103 fValueTypes->insert("G4double"); 104 fValueTypes->insert("G4double"); 104 fValueTypes->insert("G4ThreeVector"); 105 fValueTypes->insert("G4ThreeVector"); 105 fValueTypes->insert("G4bool"); 106 fValueTypes->insert("G4bool"); 106 } 107 } 107 } 108 } 108 109 >> 110 G4AttCheck::~G4AttCheck() >> 111 { >> 112 } >> 113 109 void G4AttCheck::Init() 114 void G4AttCheck::Init() 110 { 115 { 111 if (fValueTypes == nullptr) fValueTypes = ne << 116 if (!fValueTypes) fValueTypes = new std::set<G4String>; 112 if (fUnits == nullptr) fUnits = new std::set << 117 if (!fUnits) fUnits = new std::set<G4String>; 113 if (fCategories == nullptr) fCategories = ne << 118 if (!fCategories) fCategories = new std::set<G4String>; 114 if (fStandardUnits == nullptr) fStandardUnit << 119 if (!fStandardUnits) fStandardUnits = new std::map<G4String,G4String>; 115 if (fUnitCategories == nullptr) fUnitCategor << 120 if (!fUnitCategories) fUnitCategories = new std::set<G4String>; 116 } 121 } 117 122 118 G4bool G4AttCheck::Check(const G4String& leade 123 G4bool G4AttCheck::Check(const G4String& leader) const 119 { 124 { 120 // Check only. Silent unless error - then G 125 // Check only. Silent unless error - then G4cerr. Returns error. 121 G4bool error = false; 126 G4bool error = false; 122 static G4ThreadLocal G4int iError = 0; 127 static G4ThreadLocal G4int iError = 0; 123 G4bool print = false; 128 G4bool print = false; 124 if (iError < 10 || iError%100 == 0) { 129 if (iError < 10 || iError%100 == 0) { 125 print = true; 130 print = true; 126 } 131 } 127 using namespace std; 132 using namespace std; 128 if (fpValues == nullptr) return error; // A << 133 if (!fpValues) return error; // A null values vector is a valid situation. 129 if (fpDefinitions == nullptr) { << 134 if (!fpDefinitions) { 130 ++iError; 135 ++iError; 131 error = true; 136 error = true; 132 if (print) { 137 if (print) { 133 G4cerr << 138 G4cerr << 134 "\n*********************************** 139 "\n*******************************************************"; 135 if (!leader.empty()) { << 140 if (leader != "") { 136 G4cerr << '\n' << leader; 141 G4cerr << '\n' << leader; 137 } 142 } 138 G4cerr << 143 G4cerr << 139 "\nG4AttCheck: ERROR " << iError << ": 144 "\nG4AttCheck: ERROR " << iError << ": Null definitions pointer" 140 "\n*********************************** 145 "\n*******************************************************" 141 << G4endl; 146 << G4endl; 142 } 147 } 143 return error; 148 return error; 144 } 149 } 145 vector<G4AttValue>::const_iterator iValue; 150 vector<G4AttValue>::const_iterator iValue; 146 for (iValue = fpValues->begin(); iValue != f 151 for (iValue = fpValues->begin(); iValue != fpValues->end(); ++iValue) { 147 const G4String& valueName = iValue->GetNam 152 const G4String& valueName = iValue->GetName(); 148 const G4String& value = iValue->GetValue() 153 const G4String& value = iValue->GetValue(); 149 // NOLINTNEXTLINE(modernize-use-auto): Exp << 150 map<G4String,G4AttDef>::const_iterator iDe 154 map<G4String,G4AttDef>::const_iterator iDef = 151 fpDefinitions->find(valueName); 155 fpDefinitions->find(valueName); 152 if (iDef == fpDefinitions->end()) { 156 if (iDef == fpDefinitions->end()) { 153 ++iError; 157 ++iError; 154 error = true; 158 error = true; 155 if (print) { 159 if (print) { 156 G4cerr << 160 G4cerr << 157 "\n********************************* 161 "\n*******************************************************"; 158 if (!leader.empty()) { << 162 if (leader != "") { 159 G4cerr << '\n' << leader; 163 G4cerr << '\n' << leader; 160 } 164 } 161 G4cerr << 165 G4cerr << 162 "\nG4AttCheck: ERROR " << iError << 166 "\nG4AttCheck: ERROR " << iError << ": No G4AttDef for G4AttValue \"" 163 << valueName << "\": " << valu 167 << valueName << "\": " << value << 164 "\n********************************* 168 "\n*******************************************************" 165 << G4endl; 169 << G4endl; 166 } 170 } 167 } else { 171 } else { 168 const G4String& category = iDef->second. 172 const G4String& category = iDef->second.GetCategory(); 169 const G4String& extra = iDef->second.Get 173 const G4String& extra = iDef->second.GetExtra(); 170 const G4String& valueType = iDef->second 174 const G4String& valueType = iDef->second.GetValueType(); 171 if (fCategories->find(category) == fCate 175 if (fCategories->find(category) == fCategories->end()) { 172 ++iError; 176 ++iError; 173 error = true; 177 error = true; 174 if (print) { 178 if (print) { 175 G4cerr << 179 G4cerr << 176 "\n******************************* 180 "\n*******************************************************"; 177 if (!leader.empty()) { << 181 if (leader != "") { 178 G4cerr << '\n' << leader; 182 G4cerr << '\n' << leader; 179 } 183 } 180 G4cerr << 184 G4cerr << 181 "\nG4AttCheck: ERROR " << iError < 185 "\nG4AttCheck: ERROR " << iError << ": Illegal Category Field \"" 182 << category << "\" for G4AttV 186 << category << "\" for G4AttValue \"" 183 << valueName << "\": " << val 187 << valueName << "\": " << value << 184 "\n Possible Categories:"; 188 "\n Possible Categories:"; 185 set<G4String>::iterator i; 189 set<G4String>::iterator i; 186 for (i = fCategories->begin(); i != 190 for (i = fCategories->begin(); i != fCategories->end(); ++i) { 187 G4cerr << ' ' << *i; 191 G4cerr << ' ' << *i; 188 } 192 } 189 G4cerr << 193 G4cerr << 190 "\n******************************* 194 "\n*******************************************************" 191 << G4endl; 195 << G4endl; 192 } 196 } 193 } 197 } 194 if(category == "Physics" && fUnits->find 198 if(category == "Physics" && fUnits->find(extra) == fUnits->end()) { 195 ++iError; 199 ++iError; 196 error = true; 200 error = true; 197 if (print) { 201 if (print) { 198 G4cerr << 202 G4cerr << 199 "\n******************************* 203 "\n*******************************************************"; 200 if (!leader.empty()) { << 204 if (leader != "") { 201 G4cerr << '\n' << leader; 205 G4cerr << '\n' << leader; 202 } 206 } 203 G4cerr << 207 G4cerr << 204 "\nG4AttCheck: ERROR " << iError < 208 "\nG4AttCheck: ERROR " << iError << ": Illegal Extra field \"" 205 << extra << "\" for G4AttValu 209 << extra << "\" for G4AttValue \"" 206 << valueName << "\": " << val 210 << valueName << "\": " << value << 207 "\n Possible Extra fields if Cate 211 "\n Possible Extra fields if Category==\"Physics\":\n "; 208 set<G4String>::iterator i; 212 set<G4String>::iterator i; 209 for (i = fUnits->begin(); i != fUnit 213 for (i = fUnits->begin(); i != fUnits->end(); ++i) { 210 G4cerr << ' ' << *i; 214 G4cerr << ' ' << *i; 211 } 215 } 212 G4cerr << 216 G4cerr << 213 "\n******************************* 217 "\n*******************************************************" 214 << G4endl; 218 << G4endl; 215 } 219 } 216 } 220 } 217 if (fValueTypes->find(valueType) == fVal 221 if (fValueTypes->find(valueType) == fValueTypes->end()) { 218 ++iError; 222 ++iError; 219 error = true; 223 error = true; 220 if (print) { 224 if (print) { 221 G4cerr << 225 G4cerr << 222 "\n******************************* 226 "\n*******************************************************"; 223 if (!leader.empty()) { << 227 if (leader != "") { 224 G4cerr << '\n' << leader; 228 G4cerr << '\n' << leader; 225 } 229 } 226 G4cerr << 230 G4cerr << 227 "\nG4AttCheck: ERROR " << iError < 231 "\nG4AttCheck: ERROR " << iError << ": Illegal Value Type field \"" 228 << valueType << "\" for G4Att 232 << valueType << "\" for G4AttValue \"" 229 << valueName << "\": " << val 233 << valueName << "\": " << value << 230 "\n Possible Value Types:"; 234 "\n Possible Value Types:"; 231 set<G4String>::iterator i; 235 set<G4String>::iterator i; 232 for (i = fValueTypes->begin(); i != 236 for (i = fValueTypes->begin(); i != fValueTypes->end(); ++i) { 233 G4cerr << ' ' << *i; 237 G4cerr << ' ' << *i; 234 } 238 } 235 G4cerr << 239 G4cerr << 236 "\n******************************* 240 "\n*******************************************************" 237 << G4endl; 241 << G4endl; 238 } 242 } 239 } 243 } 240 } 244 } 241 } 245 } 242 return error; 246 return error; 243 } 247 } 244 248 245 std::ostream& operator<< (std::ostream& os, co 249 std::ostream& operator<< (std::ostream& os, const G4AttCheck& ac) 246 { 250 { 247 using namespace std; 251 using namespace std; 248 if (ac.fpDefinitions == nullptr) { << 252 if (!ac.fpDefinitions) { 249 os << "G4AttCheck: ERROR: zero definitions 253 os << "G4AttCheck: ERROR: zero definitions pointer." << endl; 250 return os; 254 return os; 251 } 255 } 252 G4String storeKey; 256 G4String storeKey; 253 if (G4AttDefStore::GetStoreKey(ac.fpDefiniti 257 if (G4AttDefStore::GetStoreKey(ac.fpDefinitions, storeKey)) { 254 os << storeKey << ':' << endl; 258 os << storeKey << ':' << endl; 255 } 259 } 256 if (ac.fpValues == nullptr) { << 260 if (!ac.fpValues) { 257 // A null values vector is a valid situati 261 // A null values vector is a valid situation. 258 os << "G4AttCheck: zero values pointer." < 262 os << "G4AttCheck: zero values pointer." << endl; 259 return os; 263 return os; 260 } 264 } 261 vector<G4AttValue>::const_iterator iValue; 265 vector<G4AttValue>::const_iterator iValue; 262 for (iValue = ac.fpValues->begin(); iValue ! 266 for (iValue = ac.fpValues->begin(); iValue != ac.fpValues->end(); ++iValue) { 263 const G4String& valueName = iValue->GetNam 267 const G4String& valueName = iValue->GetName(); 264 const G4String& value = iValue->GetValue() 268 const G4String& value = iValue->GetValue(); 265 // NOLINTNEXTLINE(modernize-use-auto): Exp << 269 map<G4String,G4AttDef>::const_iterator iDef = 266 map<G4String,G4AttDef>::const_iterator iDe << 267 ac.fpDefinitions->find(valueName); 270 ac.fpDefinitions->find(valueName); 268 G4bool error = false; 271 G4bool error = false; 269 if (iDef == ac.fpDefinitions->end()) { 272 if (iDef == ac.fpDefinitions->end()) { 270 error = true; 273 error = true; 271 os << "G4AttCheck: ERROR: No G4AttDef fo 274 os << "G4AttCheck: ERROR: No G4AttDef for G4AttValue \"" 272 << valueName << "\": " << value << en 275 << valueName << "\": " << value << endl; 273 } else { 276 } else { 274 const G4String& category = iDef->second. 277 const G4String& category = iDef->second.GetCategory(); 275 const G4String& extra = iDef->second.Get 278 const G4String& extra = iDef->second.GetExtra(); 276 const G4String& valueType = iDef->second 279 const G4String& valueType = iDef->second.GetValueType(); 277 if (ac.fCategories->find(category) == ac 280 if (ac.fCategories->find(category) == ac.fCategories->end()) { 278 error = true; 281 error = true; 279 os << 282 os << 280 "G4AttCheck: ERROR: Illegal Category 283 "G4AttCheck: ERROR: Illegal Category Field \"" << category 281 << "\" for G4AttValue \"" << valueN 284 << "\" for G4AttValue \"" << valueName << "\": " << value << 282 "\n Possible Categories:"; 285 "\n Possible Categories:"; 283 set<G4String>::iterator i; 286 set<G4String>::iterator i; 284 for (i = ac.fCategories->begin(); i != 287 for (i = ac.fCategories->begin(); i != ac.fCategories->end(); ++i) { 285 os << ' ' << *i; 288 os << ' ' << *i; 286 } 289 } 287 os << endl; 290 os << endl; 288 } 291 } 289 if(category == "Physics" && ac.fUnits->f 292 if(category == "Physics" && ac.fUnits->find(extra) == ac.fUnits->end()) { 290 error = true; 293 error = true; 291 os << 294 os << 292 "G4AttCheck: ERROR: Illegal Extra fi 295 "G4AttCheck: ERROR: Illegal Extra field \""<< extra 293 << "\" for G4AttValue \"" << valueN 296 << "\" for G4AttValue \"" << valueName << "\": " << value << 294 "\n Possible Extra fields if Catego 297 "\n Possible Extra fields if Category==\"Physics\":\n "; 295 set<G4String>::iterator i; 298 set<G4String>::iterator i; 296 for (i = ac.fUnits->begin(); i != ac.f 299 for (i = ac.fUnits->begin(); i != ac.fUnits->end(); ++i) { 297 os << ' ' << *i; 300 os << ' ' << *i; 298 } 301 } 299 os << endl; 302 os << endl; 300 } 303 } 301 if (ac.fValueTypes->find(valueType) == a 304 if (ac.fValueTypes->find(valueType) == ac.fValueTypes->end()) { 302 error = true; 305 error = true; 303 os << 306 os << 304 "G4AttCheck: ERROR: Illegal Value Ty 307 "G4AttCheck: ERROR: Illegal Value Type field \"" << valueType 305 << "\" for G4AttValue \"" << valueN 308 << "\" for G4AttValue \"" << valueName << "\": " << value << 306 "\n Possible Value Types:"; 309 "\n Possible Value Types:"; 307 set<G4String>::iterator i; 310 set<G4String>::iterator i; 308 for (i = ac.fValueTypes->begin(); i != 311 for (i = ac.fValueTypes->begin(); i != ac.fValueTypes->end(); ++i) { 309 os << ' ' << *i; 312 os << ' ' << *i; 310 } 313 } 311 os << endl; 314 os << endl; 312 } 315 } 313 } 316 } 314 if (!error) { 317 if (!error) { 315 os << iDef->second.GetDesc() 318 os << iDef->second.GetDesc() 316 << " (" << valueName 319 << " (" << valueName 317 << "): " << value; 320 << "): " << value; 318 if (iDef->second.GetCategory() == "Physi 321 if (iDef->second.GetCategory() == "Physics" && 319 !iDef->second.GetExtra().empty()) { 322 !iDef->second.GetExtra().empty()) { 320 os << " (" << iDef->second.GetExtra() 323 os << " (" << iDef->second.GetExtra() << ")"; 321 } 324 } 322 os << endl; 325 os << endl; 323 } 326 } 324 } 327 } 325 return os; 328 return os; 326 } 329 } 327 330 328 void G4AttCheck::AddValuesAndDefs 331 void G4AttCheck::AddValuesAndDefs 329 (std::vector<G4AttValue>* standardValues, 332 (std::vector<G4AttValue>* standardValues, 330 std::map<G4String,G4AttDef>* standardDefiniti 333 std::map<G4String,G4AttDef>* standardDefinitions, 331 const G4String& oldName, 334 const G4String& oldName, 332 const G4String& name, 335 const G4String& name, 333 const G4String& value, 336 const G4String& value, 334 const G4String& extra, 337 const G4String& extra, 335 const G4String& description) const 338 const G4String& description) const 336 { 339 { 337 // Add new G4AttDeff... 340 // Add new G4AttDeff... 338 standardValues->push_back(G4AttValue(name,va 341 standardValues->push_back(G4AttValue(name,value,"")); 339 // Copy original G4AttDef... 342 // Copy original G4AttDef... 340 (*standardDefinitions)[name] = fpDefinitions 343 (*standardDefinitions)[name] = fpDefinitions->find(oldName)->second; 341 // ...and make appropriate changes... 344 // ...and make appropriate changes... 342 (*standardDefinitions)[name].SetName(name); 345 (*standardDefinitions)[name].SetName(name); 343 (*standardDefinitions)[name].SetExtra(extra) 346 (*standardDefinitions)[name].SetExtra(extra); 344 if (!description.empty()) (*standardDefiniti << 347 if (description != "") (*standardDefinitions)[name].SetDesc(description); 345 } 348 } 346 349 347 G4bool G4AttCheck::Standard 350 G4bool G4AttCheck::Standard 348 (std::vector<G4AttValue>* standardValues, 351 (std::vector<G4AttValue>* standardValues, 349 std::map<G4String,G4AttDef>* standardDefiniti 352 std::map<G4String,G4AttDef>* standardDefinitions) const 350 { 353 { 351 // Places standard versions in provided vect 354 // Places standard versions in provided vector and map and returns error. 352 // Assumes valid input. Use Check to check. 355 // Assumes valid input. Use Check to check. 353 using namespace std; 356 using namespace std; 354 G4bool error = false; 357 G4bool error = false; 355 vector<G4AttValue>::const_iterator iValue; 358 vector<G4AttValue>::const_iterator iValue; 356 for (iValue = fpValues->begin(); iValue != f 359 for (iValue = fpValues->begin(); iValue != fpValues->end(); ++iValue) { 357 const G4String& valueName = iValue->GetNam 360 const G4String& valueName = iValue->GetName(); 358 const G4String& value = iValue->GetValue() 361 const G4String& value = iValue->GetValue(); 359 // NOLINTNEXTLINE(modernize-use-auto): Exp << 360 map<G4String,G4AttDef>::const_iterator iDe 362 map<G4String,G4AttDef>::const_iterator iDef = 361 fpDefinitions->find(valueName); 363 fpDefinitions->find(valueName); 362 if (iDef == fpDefinitions->end()) { 364 if (iDef == fpDefinitions->end()) { 363 error = true; 365 error = true; 364 } else { 366 } else { 365 const G4String& category = iDef->second. 367 const G4String& category = iDef->second.GetCategory(); 366 const G4String& extra = iDef->second.Get 368 const G4String& extra = iDef->second.GetExtra(); 367 const G4String& valueType = iDef->second 369 const G4String& valueType = iDef->second.GetValueType(); 368 if (fCategories->find(category) == fCate 370 if (fCategories->find(category) == fCategories->end() || 369 (category == "Physics" && fUnits->fi 371 (category == "Physics" && fUnits->find(extra) == fUnits->end()) || 370 fValueTypes->find(valueType) == fVal 372 fValueTypes->find(valueType) == fValueTypes->end()) { 371 error = true; 373 error = true; 372 } else { 374 } else { 373 if (category != "Physics") { // Simpl 375 if (category != "Physics") { // Simply copy... 374 standardValues->push_back(*iValue); 376 standardValues->push_back(*iValue); 375 (*standardDefinitions)[valueName] = 377 (*standardDefinitions)[valueName] = 376 fpDefinitions->find(valueName)->se 378 fpDefinitions->find(valueName)->second; 377 } else { // "Physics"... 379 } else { // "Physics"... 378 if (extra.empty()) { // Dimensionle 380 if (extra.empty()) { // Dimensionless... 379 if (valueType == "G4ThreeVector") 381 if (valueType == "G4ThreeVector") { // Split vector into 3... 380 G4ThreeVector internalValue = 382 G4ThreeVector internalValue = 381 G4UIcommand::ConvertTo3Vector( 383 G4UIcommand::ConvertTo3Vector(value); 382 AddValuesAndDefs 384 AddValuesAndDefs 383 (standardValues,standardDefini 385 (standardValues,standardDefinitions, 384 valueName,valueName+"-X", 386 valueName,valueName+"-X", 385 G4UIcommand::ConvertToString( 387 G4UIcommand::ConvertToString(internalValue.x()),"", 386 fpDefinitions->find(valueName 388 fpDefinitions->find(valueName)->second.GetDesc()+"-X"); 387 AddValuesAndDefs 389 AddValuesAndDefs 388 (standardValues,standardDefini 390 (standardValues,standardDefinitions, 389 valueName,valueName+"-Y", 391 valueName,valueName+"-Y", 390 G4UIcommand::ConvertToString( 392 G4UIcommand::ConvertToString(internalValue.y()),"", 391 fpDefinitions->find(valueName 393 fpDefinitions->find(valueName)->second.GetDesc()+"-Y"); 392 AddValuesAndDefs 394 AddValuesAndDefs 393 (standardValues,standardDefini 395 (standardValues,standardDefinitions, 394 valueName,valueName+"-Z", 396 valueName,valueName+"-Z", 395 G4UIcommand::ConvertToString( 397 G4UIcommand::ConvertToString(internalValue.z()),"", 396 fpDefinitions->find(valueName 398 fpDefinitions->find(valueName)->second.GetDesc()+"-Z"); 397 } else { // Simply copy... 399 } else { // Simply copy... 398 standardValues->push_back(*iValu 400 standardValues->push_back(*iValue); 399 (*standardDefinitions)[valueName 401 (*standardDefinitions)[valueName] = 400 fpDefinitions->find(valueName) 402 fpDefinitions->find(valueName)->second; 401 } 403 } 402 } else { // Dimensioned... 404 } else { // Dimensioned... 403 G4String valueAndUnit; 405 G4String valueAndUnit; 404 G4String unit; 406 G4String unit; 405 if (extra == "G4BestUnit") { 407 if (extra == "G4BestUnit") { 406 valueAndUnit = G4StrUtil::strip_ << 408 valueAndUnit = value; >> 409 valueAndUnit = valueAndUnit.strip(); 407 unit = valueAndUnit.substr(value 410 unit = valueAndUnit.substr(valueAndUnit.rfind(' ')+1); 408 } else { 411 } else { 409 valueAndUnit = G4StrUtil::strip_ << 412 valueAndUnit = value + ' ' + extra; >> 413 valueAndUnit = valueAndUnit.strip(); 410 unit = extra; 414 unit = extra; 411 } 415 } 412 G4String unitCategory = G4UnitDefi 416 G4String unitCategory = G4UnitDefinition::GetCategory(unit); 413 if (fUnitCategories->find(unitCate 417 if (fUnitCategories->find(unitCategory) != fUnitCategories->end()) { 414 G4String standardUnit = (*fStand 418 G4String standardUnit = (*fStandardUnits)[unitCategory]; 415 G4double valueOfStandardUnit = 419 G4double valueOfStandardUnit = 416 G4UnitDefinition::GetValueOf(s 420 G4UnitDefinition::GetValueOf(standardUnit); 417 // G4String exstr = iDef->second. 421 // G4String exstr = iDef->second.GetExtra(); 418 if (valueType == "G4ThreeVector" 422 if (valueType == "G4ThreeVector") { // Split vector into 3... 419 G4ThreeVector internalValue = 423 G4ThreeVector internalValue = 420 G4UIcommand::ConvertToDimens 424 G4UIcommand::ConvertToDimensioned3Vector(valueAndUnit); 421 AddValuesAndDefs 425 AddValuesAndDefs 422 (standardValues,standardDefi 426 (standardValues,standardDefinitions, 423 valueName,valueName+"-X", 427 valueName,valueName+"-X", 424 G4UIcommand::ConvertToStrin 428 G4UIcommand::ConvertToString 425 (internalValue.x()/valueOfS 429 (internalValue.x()/valueOfStandardUnit), 426 standardUnit, 430 standardUnit, 427 fpDefinitions->find(valueNa 431 fpDefinitions->find(valueName)->second.GetDesc()+"-X"); 428 AddValuesAndDefs 432 AddValuesAndDefs 429 (standardValues,standardDefi 433 (standardValues,standardDefinitions, 430 valueName,valueName+"-Y", 434 valueName,valueName+"-Y", 431 G4UIcommand::ConvertToStrin 435 G4UIcommand::ConvertToString 432 (internalValue.y()/valueOfS 436 (internalValue.y()/valueOfStandardUnit), 433 standardUnit, 437 standardUnit, 434 fpDefinitions->find(valueNa 438 fpDefinitions->find(valueName)->second.GetDesc()+"-Y"); 435 AddValuesAndDefs 439 AddValuesAndDefs 436 (standardValues,standardDefi 440 (standardValues,standardDefinitions, 437 valueName,valueName+"-Z", 441 valueName,valueName+"-Z", 438 G4UIcommand::ConvertToStrin 442 G4UIcommand::ConvertToString 439 (internalValue.z()/valueOfS 443 (internalValue.z()/valueOfStandardUnit), 440 standardUnit, 444 standardUnit, 441 fpDefinitions->find(valueNa 445 fpDefinitions->find(valueName)->second.GetDesc()+"-Z"); 442 } else { 446 } else { 443 G4double internalValue = 447 G4double internalValue = 444 G4UIcommand::ConvertToDimens 448 G4UIcommand::ConvertToDimensionedDouble(valueAndUnit); 445 AddValuesAndDefs 449 AddValuesAndDefs 446 (standardValues,standardDefi 450 (standardValues,standardDefinitions, 447 valueName,valueName, 451 valueName,valueName, 448 G4UIcommand::ConvertToStrin 452 G4UIcommand::ConvertToString 449 (internalValue/valueOfStand 453 (internalValue/valueOfStandardUnit), 450 standardUnit); 454 standardUnit); 451 } 455 } 452 } 456 } 453 } 457 } 454 } 458 } 455 } 459 } 456 } 460 } 457 } 461 } 458 if (error) { 462 if (error) { 459 G4cerr << "G4AttCheck::Standard: Conversio 463 G4cerr << "G4AttCheck::Standard: Conversion error." << G4endl; 460 } 464 } 461 return error; 465 return error; 462 } 466 } 463 467