Geant4 Cross Reference |
1 // ******************************************* 1 // ******************************************************************** 2 // * License and Disclaimer 2 // * License and Disclaimer * 3 // * 3 // * * 4 // * The Geant4 software is copyright of th 4 // * The Geant4 software is copyright of the Copyright Holders of * 5 // * the Geant4 Collaboration. It is provided 5 // * the Geant4 Collaboration. It is provided under the terms and * 6 // * conditions of the Geant4 Software License 6 // * conditions of the Geant4 Software License, included in the file * 7 // * LICENSE and available at http://cern.ch/ 7 // * LICENSE and available at http://cern.ch/geant4/license . These * 8 // * include a list of copyright holders. 8 // * include a list of copyright holders. * 9 // * 9 // * * 10 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing * 11 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this * 12 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, * 13 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its * 14 // * use. Please see the license in the file 14 // * use. Please see the license in the file LICENSE and URL above * 15 // * for the full disclaimer and the limitatio 15 // * for the full disclaimer and the limitation of liability. * 16 // * 16 // * * 17 // * This code implementation is the result 17 // * This code implementation is the result of the scientific and * 18 // * technical work of the GEANT4 collaboratio 18 // * technical work of the GEANT4 collaboration. * 19 // * By using, copying, modifying or distri 19 // * By using, copying, modifying or distributing the software (or * 20 // * any work based on the software) you ag 20 // * any work based on the software) you agree to acknowledge its * 21 // * use in resulting scientific publicati 21 // * use in resulting scientific publications, and indicate your * 22 // * acceptance of all terms of the Geant4 Sof 22 // * acceptance of all terms of the Geant4 Software license. * 23 // ******************************************* 23 // ******************************************************************** 24 // 24 // 25 // G4GenericMessenger << 26 // 25 // 27 // Author: << 26 // $Id: G4UIaliasList.cc,v 1.6 2006-06-29 19:08:33 gunter Exp $ 28 // P.Mato, CERN - 27 September 2012 << 27 // 29 // Updates: << 30 // M.Asai, SLAC - 26 November 2013 << 31 // Adding methods with unit declaration a << 32 // version 10. << 33 // M.Asai, SLAC - 04 May 2014 << 34 // Fix core dump when GetCurrentValue() m << 35 // a command defined by DeclareMethod(). << 36 // M.Asai, SLAC - 30 September 2020 << 37 // Adding new parameter type 'L' for long << 38 // M.Asai, SLAC - 11 July 2021 << 39 // Adding G4ThreeVector type without unit << 40 // M.Asai, JLab - 24 April 2024 << 41 // Fix DeclareMethod() wrongly converts v << 42 // ------------------------------------------- << 43 28 44 #include "G4GenericMessenger.hh" 29 #include "G4GenericMessenger.hh" 45 << 46 #include "G4Threading.hh" << 47 #include "G4Types.hh" 30 #include "G4Types.hh" 48 #include "G4UIcmdWithABool.hh" << 31 #include "G4UImessenger.hh" 49 #include "G4UIcmdWith3Vector.hh" << 50 #include "G4UIcmdWith3VectorAndUnit.hh" << 51 #include "G4UIcmdWithADoubleAndUnit.hh" << 52 #include "G4UIcommand.hh" 32 #include "G4UIcommand.hh" >> 33 #include "G4UIcmdWithADoubleAndUnit.hh" >> 34 #include "G4UIcmdWith3VectorAndUnit.hh" 53 #include "G4UIdirectory.hh" 35 #include "G4UIdirectory.hh" 54 #include "G4UImessenger.hh" << 55 #include "G4Tokenizer.hh" << 56 36 57 #include <iostream> 37 #include <iostream> 58 38 59 class G4InvalidUICommand : public std::bad_cas << 39 class G4InvalidUICommand: public std::bad_cast { 60 { << 40 public: 61 public: << 41 G4InvalidUICommand() {} 62 G4InvalidUICommand() = default; << 42 virtual const char* what() const throw() { 63 const char* what() const throw() override << 43 return "G4InvalidUICommand: command does not exists or is of invalid type"; 64 { << 44 } 65 return "G4InvalidUICommand: command does << 66 } << 67 }; 45 }; 68 46 69 G4GenericMessenger::G4GenericMessenger(void* o << 47 70 : directory(dir), object(obj) << 48 G4GenericMessenger::G4GenericMessenger(void* obj, const G4String& dir, const G4String& doc): directory(dir), object(obj) { 71 { << 49 // Check if parent commnand is already existing. >> 50 // In fact there is no way to check this. UImanager->GetTree()->FindPath() will always rerurn NULL is a dicrectory is given >> 51 size_t pos = dir.find_last_of('/', dir.size()-2); >> 52 while(pos != 0 && pos != std::string::npos) { >> 53 G4UIdirectory* d = new G4UIdirectory(dir.substr(0,pos+1).c_str()); >> 54 G4String guidance = "Commands for "; >> 55 guidance += dir.substr(1,pos-1); >> 56 d->SetGuidance(guidance); >> 57 pos = dir.find_last_of('/', pos-1); >> 58 } 72 dircmd = new G4UIdirectory(dir); 59 dircmd = new G4UIdirectory(dir); 73 dircmd->SetGuidance(doc); 60 dircmd->SetGuidance(doc); 74 } 61 } 75 62 76 G4GenericMessenger::~G4GenericMessenger() << 63 G4GenericMessenger::~G4GenericMessenger() { 77 { << 78 delete dircmd; 64 delete dircmd; 79 for (const auto& propertie : properties) { << 65 for (std::map<G4String, Property>::iterator i = properties.begin(); i != properties.end(); i++) delete i->second.command; 80 delete propertie.second.command; << 66 for (std::map<G4String, Method>::iterator i = methods.begin(); i != methods.end(); i++) delete i->second.command; 81 } << 82 for (const auto& method : methods) { << 83 delete method.second.command; << 84 } << 85 } 67 } 86 68 87 G4GenericMessenger::Command& << 88 G4GenericMessenger::DeclareProperty(const G4St << 89 { << 90 G4String fullpath = directory + name; << 91 G4UIcommand* cmd = nullptr; << 92 if (var.TypeInfo() == typeid(G4ThreeVector)) << 93 cmd = new G4UIcmdWith3Vector(fullpath.c_st << 94 (static_cast<G4UIcmdWith3Vector*>(cmd)) << 95 ->SetParameterName("valueX", "valueY", " << 96 } << 97 else { << 98 cmd = new G4UIcommand(fullpath.c_str(), th << 99 char ptype; << 100 if (var.TypeInfo() == typeid(int) || var.T << 101 || var.TypeInfo() == typeid(unsigned i << 102 { << 103 ptype = 'i'; << 104 } << 105 else if (var.TypeInfo() == typeid(float) | << 106 ptype = 'd'; << 107 } << 108 else if (var.TypeInfo() == typeid(bool)) { << 109 ptype = 'b'; << 110 } << 111 else if (var.TypeInfo() == typeid(G4String << 112 ptype = 's'; << 113 } << 114 else { << 115 ptype = 's'; << 116 } << 117 cmd->SetParameter(new G4UIparameter("value << 118 } << 119 if (!doc.empty()) { << 120 cmd->SetGuidance(doc); << 121 } << 122 return properties[name] = Property(var, cmd) << 123 } << 124 69 125 G4GenericMessenger::Command& 70 G4GenericMessenger::Command& 126 G4GenericMessenger::DeclarePropertyWithUnit(co << 71 G4GenericMessenger::DeclareProperty(const G4String& name, const G4AnyType& var, const G4String& doc) { 127 co << 72 G4String fullpath = directory+name; 128 { << 73 G4UIcommand* cmd = new G4UIcommand(fullpath.c_str(), this); 129 if (var.TypeInfo() != typeid(float) && var.T << 74 if(doc != "") cmd->SetGuidance(doc); 130 && var.TypeInfo() != typeid(G4ThreeVecto << 75 char ptype; 131 { << 76 if(var.TypeInfo() == typeid(int) || var.TypeInfo() == typeid(long) || 132 return DeclareProperty(name, var, doc); << 77 var.TypeInfo() == typeid(unsigned int) || var.TypeInfo() == typeid(unsigned long)) ptype = 'i'; 133 } << 78 else if(var.TypeInfo() == typeid(float) || var.TypeInfo() == typeid(double)) ptype = 'd'; 134 G4String fullpath = directory + name; << 79 else if(var.TypeInfo() == typeid(bool)) ptype = 'b'; 135 G4UIcommand* cmd; << 80 else if(var.TypeInfo() == typeid(G4String)) ptype = 's'; 136 if (var.TypeInfo() == typeid(float) || var.T << 81 else ptype = 's'; 137 cmd = new G4UIcmdWithADoubleAndUnit(fullpa << 82 cmd->SetParameter(new G4UIparameter("value", ptype, false)); 138 (static_cast<G4UIcmdWithADoubleAndUnit*>(c << 139 (static_cast<G4UIcmdWithADoubleAndUnit*>(c << 140 } << 141 else { << 142 cmd = new G4UIcmdWith3VectorAndUnit(fullpa << 143 (static_cast<G4UIcmdWith3VectorAndUnit*>(c << 144 ->SetParameterName("valueX", "valueY", " << 145 (static_cast<G4UIcmdWith3VectorAndUnit*>(c << 146 } << 147 << 148 if (!doc.empty()) { << 149 cmd->SetGuidance(doc); << 150 } << 151 return properties[name] = Property(var, cmd) 83 return properties[name] = Property(var, cmd); 152 } 84 } 153 85 154 G4GenericMessenger::Command& << 155 G4GenericMessenger::DeclareMethod(const G4Stri << 156 { << 157 G4String fullpath = directory + name; << 158 auto* cmd = new G4UIcommand(fullpath.c_str() << 159 if (!doc.empty()) { << 160 cmd->SetGuidance(doc); << 161 } << 162 for (std::size_t i = 0; i < fun.NArg(); ++i) << 163 G4String argNam = "arg" + ItoS((G4int)i); << 164 char ptype = 's'; << 165 auto& tInfo = fun.ArgType(i); << 166 if (tInfo == typeid(int) || tInfo == typei << 167 || tInfo == typeid(unsigned long)) << 168 { << 169 ptype = 'i'; << 170 } << 171 else if (tInfo == typeid(float) || tInfo = << 172 ptype = 'd'; << 173 } << 174 else if (tInfo == typeid(bool)) { << 175 ptype = 'b'; << 176 } << 177 else if (tInfo == typeid(G4String)) { << 178 ptype = 's'; << 179 } << 180 else { << 181 ptype = 's'; << 182 } << 183 cmd->SetParameter(new G4UIparameter(argNam << 184 } << 185 return methods[name] = Method(fun, object, c << 186 } << 187 86 188 G4GenericMessenger::Command& G4GenericMessenge << 87 G4GenericMessenger::Command& 189 << 88 G4GenericMessenger::DeclareMethod(const G4String& name, const G4AnyMethod& fun, const G4String& doc) { 190 << 89 G4String fullpath = directory+name; 191 << 90 G4UIcommand* cmd = new G4UIcommand(fullpath.c_str(), this); 192 { << 91 if(doc != "") cmd->SetGuidance(doc); 193 G4String fullpath = directory + name; << 92 for (size_t i = 0; i < fun.NArg(); i++) { 194 if (fun.NArg() != 1) { << 93 cmd->SetParameter(new G4UIparameter("arg", 's', false)); 195 G4ExceptionDescription ed; << 196 ed << "G4GenericMessenger::DeclareMethodWi << 197 "method that has more than\n" << 198 << "one arguments (or no argument). Ple << 199 "G4GenericMessenger::DeclareMethod m << 200 << "your command <" << fullpath << ">." << 201 G4Exception("G4GenericMessenger::DeclareMe << 202 } << 203 G4UIcommand* cmd = new G4UIcmdWithADoubleAnd << 204 (static_cast<G4UIcmdWithADoubleAndUnit*>(cmd << 205 (static_cast<G4UIcmdWithADoubleAndUnit*>(cmd << 206 if (!doc.empty()) { << 207 cmd->SetGuidance(doc); << 208 } 94 } 209 return methods[name] = Method(fun, object, c 95 return methods[name] = Method(fun, object, cmd); 210 } 96 } 211 97 212 G4String G4GenericMessenger::GetCurrentValue(G << 98 G4String G4GenericMessenger::GetCurrentValue(G4UIcommand* command) { 213 { << 99 if ( properties.find(command->GetCommandName()) != properties.end()) { 214 if (properties.find(command->GetCommandName( << 215 Property& p = properties[command->GetComma 100 Property& p = properties[command->GetCommandName()]; 216 return p.variable.ToString(); 101 return p.variable.ToString(); 217 } 102 } 218 if (methods.find(command->GetCommandName()) << 103 else { 219 G4cout << " GetCurrentValue() is not avail << 104 throw G4InvalidUICommand(); 220 "G4GenericMessenger::DeclareMeth << 221 << G4endl; << 222 return G4String(); << 223 } 105 } 224 << 225 throw G4InvalidUICommand(); << 226 } 106 } 227 107 228 void G4GenericMessenger::SetNewValue(G4UIcomma << 108 void G4GenericMessenger::SetNewValue(G4UIcommand* command, G4String newValue) { 229 { << 230 // Check if there are units on this commands 109 // Check if there are units on this commands 231 if (typeid(*command) == typeid(G4UIcmdWithAD 110 if (typeid(*command) == typeid(G4UIcmdWithADoubleAndUnit)) { 232 newValue = G4UIcommand::ConvertToString(G4 111 newValue = G4UIcommand::ConvertToString(G4UIcommand::ConvertToDimensionedDouble(newValue)); 233 } 112 } 234 else if (typeid(*command) == typeid(G4UIcmdW 113 else if (typeid(*command) == typeid(G4UIcmdWith3VectorAndUnit)) { 235 newValue = G4UIcommand::ConvertToString(G4 114 newValue = G4UIcommand::ConvertToString(G4UIcommand::ConvertToDimensioned3Vector(newValue)); 236 } 115 } 237 else if (typeid(*command) == typeid(G4UIcmdW << 116 238 if(StoB(newValue)) { << 117 if ( properties.find(command->GetCommandName()) != properties.end()) { 239 newValue = "1"; << 240 } else { << 241 newValue = "0"; << 242 } << 243 } << 244 << 245 if (properties.find(command->GetCommandName( << 246 Property& p = properties[command->GetComma 118 Property& p = properties[command->GetCommandName()]; 247 p.variable.FromString(newValue); 119 p.variable.FromString(newValue); 248 } 120 } 249 else if (methods.find(command->GetCommandNam << 121 else if (methods.find(command->GetCommandName()) != methods.end()) { 250 Method& m = methods[command->GetCommandNam 122 Method& m = methods[command->GetCommandName()]; 251 if (m.method.NArg() == 0) { << 123 if(m.method.NArg() == 0) 252 m.method.operator()(m.object); 124 m.method.operator()(m.object); 253 } << 254 else if (m.method.NArg() > 0) { 125 else if (m.method.NArg() > 0) { 255 G4Tokenizer tokens(newValue); << 126 m.method.operator()(m.object,newValue); 256 G4String paraValue; << 257 for (std::size_t i = 0; i < m.method.NAr << 258 G4String aToken = tokens(); << 259 if(m.method.ArgType(i)==typeid(bool)) << 260 if(StoB(aToken)) { << 261 aToken = "1"; << 262 } else { << 263 aToken = "0"; << 264 } << 265 } << 266 paraValue += aToken + " "; << 267 } << 268 m.method.operator()(m.object, paraValue) << 269 } 127 } 270 else { 128 else { 271 throw G4InvalidUICommand(); 129 throw G4InvalidUICommand(); 272 } 130 } 273 } 131 } 274 } 132 } 275 133 276 void G4GenericMessenger::SetGuidance(const G4S << 134 277 { << 135 void G4GenericMessenger::SetGuidance(const G4String& s) { 278 dircmd->SetGuidance(s); 136 dircmd->SetGuidance(s); 279 } 137 } 280 138 281 G4GenericMessenger::Command& G4GenericMessenge << 282 << 283 { << 284 // Change the type of command (unfortunatell << 285 // We need to delete the old command before << 286 // we need to recover the information before << 287 if (G4Threading::IsMultithreadedApplication( << 288 G4String cmdpath = command->GetCommandPath << 289 G4ExceptionDescription ed; << 290 ed << "G4GenericMessenger::Command::SetUni << 291 "not be used\n" << 292 << "in multi-threaded mode. For your co << 293 << " DeclarePropertyWithUnit(const G4St << 294 "defaultUnit,\n" << 295 << " const G4An << 296 "doc)\n" << 297 << "or\n" << 298 << " DeclareMethodWithUnit(const G4Stri << 299 "defaultUnit,\n" << 300 << " const G4AnyT << 301 "doc)\n" << 302 << "to define a command with a unit <" << 303 if (spec != UnitDefault) { << 304 ed << "\nPlease use a default unit inste << 305 } << 306 G4Exception("G4GenericMessenger::Command:: << 307 return *this; << 308 } << 309 139 >> 140 G4GenericMessenger::Command& G4GenericMessenger::Command::SetUnit(const G4String& unit, UnitSpec spec) { >> 141 // Change the type of command (unfortunatelly this is done a posteriory) >> 142 // We need to delete the old command before creating the new one and therefore we need to recover the information >> 143 // before the deletetion 310 G4String cmdpath = command->GetCommandPath() 144 G4String cmdpath = command->GetCommandPath(); 311 G4UImessenger* messenger = command->GetMesse 145 G4UImessenger* messenger = command->GetMessenger(); 312 G4String range = command->GetRange(); 146 G4String range = command->GetRange(); 313 std::vector<G4String> guidance; 147 std::vector<G4String> guidance; 314 G4String par_name = command->GetParameter(0) << 148 for (G4int i = 0; i < command->GetGuidanceEntries(); i++) guidance.push_back(command->GetGuidanceLine(i)); 315 G4bool par_omitable = command->GetParameter( << 149 // Before deleting the command we need to add a fake one to avoid deleting the directory entry and with its guidance 316 for (G4int i = 0; i < (G4int)command->GetGui << 150 G4UIcommand tmp((cmdpath+"_tmp").c_str(), messenger); 317 guidance.push_back(command->GetGuidanceLin << 318 } << 319 // Before deleting the command we need to ad << 320 // the directory entry and with its guidance << 321 G4UIcommand tmp((cmdpath + "_tmp").c_str(), << 322 delete command; 151 delete command; 323 152 324 if (*type == typeid(float) || *type == typei << 153 if (*type == typeid(float) || *type == typeid(double) ) { 325 auto* cmd_t = new G4UIcmdWithADoubleAndUni << 154 G4UIcmdWithADoubleAndUnit* cmd_t = new G4UIcmdWithADoubleAndUnit(cmdpath, messenger); 326 if (spec == UnitDefault) { << 155 if(spec == UnitDefault) cmd_t->SetDefaultUnit(unit); 327 cmd_t->SetDefaultUnit(unit); << 156 else if(spec == UnitCategory) cmd_t->SetUnitCategory(unit); 328 } << 329 else if (spec == UnitCategory) { << 330 cmd_t->SetUnitCategory(unit); << 331 } << 332 cmd_t->SetParameterName(par_name, par_omit << 333 command = cmd_t; 157 command = cmd_t; 334 } 158 } 335 else if (*type == typeid(G4ThreeVector)) { 159 else if (*type == typeid(G4ThreeVector)) { 336 auto* cmd_t = new G4UIcmdWith3VectorAndUni << 160 G4UIcmdWith3VectorAndUnit* cmd_t = new G4UIcmdWith3VectorAndUnit(cmdpath, messenger); 337 if (spec == UnitDefault) { << 161 if(spec == UnitDefault) cmd_t->SetDefaultUnit(unit); 338 cmd_t->SetDefaultUnit(unit); << 162 else if(spec == UnitCategory) cmd_t->SetUnitCategory(unit); 339 } << 340 else if (spec == UnitCategory) { << 341 cmd_t->SetUnitCategory(unit); << 342 } << 343 command = cmd_t; 163 command = cmd_t; 344 } 164 } 345 else { 165 else { 346 G4cerr << "Only parameters of type <double << 166 G4cerr << "Only parameters of type <double> or <float> can be associated with units" << G4endl; 347 "with units" << 348 << G4endl; << 349 return *this; 167 return *this; 350 } 168 } 351 for (auto& i : guidance) { << 169 for (size_t i = 0; i < guidance.size(); i++) command->SetGuidance(guidance[i]); 352 command->SetGuidance(i); << 353 } << 354 command->SetRange(range); 170 command->SetRange(range); 355 return *this; 171 return *this; 356 } 172 } 357 173 358 G4GenericMessenger::Command& G4GenericMessenge << 174 G4GenericMessenger::Command& G4GenericMessenger::Command::SetParameterName(const G4String& name,G4bool omittable, G4bool currentAsDefault) { 359 << 360 << 361 { << 362 return SetParameterName(0, name, omittable, << 363 } << 364 << 365 G4GenericMessenger::Command& G4GenericMessenge << 366 << 367 << 368 << 369 { << 370 if (pIdx < 0 || pIdx >= (G4int)(command->Get << 371 G4cerr << "Invalid parameter index : " << << 372 return *this; << 373 } << 374 G4UIparameter* theParam = command->GetParame << 375 theParam->SetParameterName(name); << 376 theParam->SetOmittable(omittable); << 377 theParam->SetCurrentAsDefault(currentAsDefau << 378 return *this; << 379 } << 380 << 381 G4GenericMessenger::Command& G4GenericMessenge << 382 << 383 << 384 << 385 << 386 { << 387 if (*type != typeid(G4ThreeVector)) { << 388 G4cerr << "This SetParameterName method is << 389 << "Method ignored." << G4endl; << 390 return *this; << 391 } << 392 G4UIparameter* theParam = command->GetParame 175 G4UIparameter* theParam = command->GetParameter(0); 393 theParam->SetParameterName(namex); << 176 theParam->SetParameterName(name); 394 theParam->SetOmittable(omittable); << 395 theParam->SetCurrentAsDefault(currentAsDefau << 396 theParam = command->GetParameter(1); << 397 theParam->SetParameterName(namey); << 398 theParam->SetOmittable(omittable); << 399 theParam->SetCurrentAsDefault(currentAsDefau << 400 theParam = command->GetParameter(2); << 401 theParam->SetParameterName(namez); << 402 theParam->SetOmittable(omittable); 177 theParam->SetOmittable(omittable); 403 theParam->SetCurrentAsDefault(currentAsDefau 178 theParam->SetCurrentAsDefault(currentAsDefault); 404 return *this; 179 return *this; 405 } 180 } 406 181 407 G4GenericMessenger::Command& G4GenericMessenge << 182 G4GenericMessenger::Command& G4GenericMessenger::Command::SetCandidates(const G4String& candList) { 408 { << 183 G4UIparameter * theParam = command->GetParameter(0); 409 return SetCandidates(0, candList); << 410 } << 411 << 412 G4GenericMessenger::Command& G4GenericMessenge << 413 << 414 { << 415 if (pIdx < 0 || pIdx >= (G4int)(command->Get << 416 G4cerr << "Invalid parameter index : " << << 417 return *this; << 418 } << 419 G4UIparameter* theParam = command->GetParame << 420 theParam->SetParameterCandidates(candList); 184 theParam->SetParameterCandidates(candList); 421 return *this; 185 return *this; 422 } 186 } 423 187 424 G4GenericMessenger::Command& G4GenericMessenge << 188 G4GenericMessenger::Command& G4GenericMessenger::Command::SetDefaultValue(const G4String& defVal) { 425 { << 189 G4UIparameter * theParam = command->GetParameter(0); 426 return SetDefaultValue(0, defVal); << 427 } << 428 << 429 G4GenericMessenger::Command& G4GenericMessenge << 430 << 431 { << 432 if (pIdx < 0 || pIdx >= (G4int)(command->Get << 433 G4cerr << "Invalid parameter index : " << << 434 return *this; << 435 } << 436 G4UIparameter* theParam = command->GetParame << 437 theParam->SetDefaultValue(defVal); 190 theParam->SetDefaultValue(defVal); 438 return *this; 191 return *this; 439 } 192 } >> 193 >> 194 >> 195 440 196