Geant4 Cross Reference |
1 // ******************************************* 1 2 // * License and Disclaimer 3 // * 4 // * The Geant4 software is copyright of th 5 // * the Geant4 Collaboration. It is provided 6 // * conditions of the Geant4 Software License 7 // * LICENSE and available at http://cern.ch/ 8 // * include a list of copyright holders. 9 // * 10 // * Neither the authors of this software syst 11 // * institutes,nor the agencies providing fin 12 // * work make any representation or warran 13 // * regarding this software system or assum 14 // * use. Please see the license in the file 15 // * for the full disclaimer and the limitatio 16 // * 17 // * This code implementation is the result 18 // * technical work of the GEANT4 collaboratio 19 // * By using, copying, modifying or distri 20 // * any work based on the software) you ag 21 // * use in resulting scientific publicati 22 // * acceptance of all terms of the Geant4 Sof 23 // ******************************************* 24 // 25 // G4GenericMessenger 26 // 27 // Author: 28 // P.Mato, CERN - 27 September 2012 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 44 #include "G4GenericMessenger.hh" 45 46 #include "G4Threading.hh" 47 #include "G4Types.hh" 48 #include "G4UIcmdWithABool.hh" 49 #include "G4UIcmdWith3Vector.hh" 50 #include "G4UIcmdWith3VectorAndUnit.hh" 51 #include "G4UIcmdWithADoubleAndUnit.hh" 52 #include "G4UIcommand.hh" 53 #include "G4UIdirectory.hh" 54 #include "G4UImessenger.hh" 55 #include "G4Tokenizer.hh" 56 57 #include <iostream> 58 59 class G4InvalidUICommand : public std::bad_cas 60 { 61 public: 62 G4InvalidUICommand() = default; 63 const char* what() const throw() override 64 { 65 return "G4InvalidUICommand: command does 66 } 67 }; 68 69 G4GenericMessenger::G4GenericMessenger(void* o 70 : directory(dir), object(obj) 71 { 72 dircmd = new G4UIdirectory(dir); 73 dircmd->SetGuidance(doc); 74 } 75 76 G4GenericMessenger::~G4GenericMessenger() 77 { 78 delete dircmd; 79 for (const auto& propertie : properties) { 80 delete propertie.second.command; 81 } 82 for (const auto& method : methods) { 83 delete method.second.command; 84 } 85 } 86 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 125 G4GenericMessenger::Command& 126 G4GenericMessenger::DeclarePropertyWithUnit(co 127 co 128 { 129 if (var.TypeInfo() != typeid(float) && var.T 130 && var.TypeInfo() != typeid(G4ThreeVecto 131 { 132 return DeclareProperty(name, var, doc); 133 } 134 G4String fullpath = directory + name; 135 G4UIcommand* cmd; 136 if (var.TypeInfo() == typeid(float) || var.T 137 cmd = new G4UIcmdWithADoubleAndUnit(fullpa 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) 152 } 153 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 188 G4GenericMessenger::Command& G4GenericMessenge 189 190 191 192 { 193 G4String fullpath = directory + name; 194 if (fun.NArg() != 1) { 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 } 209 return methods[name] = Method(fun, object, c 210 } 211 212 G4String G4GenericMessenger::GetCurrentValue(G 213 { 214 if (properties.find(command->GetCommandName( 215 Property& p = properties[command->GetComma 216 return p.variable.ToString(); 217 } 218 if (methods.find(command->GetCommandName()) 219 G4cout << " GetCurrentValue() is not avail 220 "G4GenericMessenger::DeclareMeth 221 << G4endl; 222 return G4String(); 223 } 224 225 throw G4InvalidUICommand(); 226 } 227 228 void G4GenericMessenger::SetNewValue(G4UIcomma 229 { 230 // Check if there are units on this commands 231 if (typeid(*command) == typeid(G4UIcmdWithAD 232 newValue = G4UIcommand::ConvertToString(G4 233 } 234 else if (typeid(*command) == typeid(G4UIcmdW 235 newValue = G4UIcommand::ConvertToString(G4 236 } 237 else if (typeid(*command) == typeid(G4UIcmdW 238 if(StoB(newValue)) { 239 newValue = "1"; 240 } else { 241 newValue = "0"; 242 } 243 } 244 245 if (properties.find(command->GetCommandName( 246 Property& p = properties[command->GetComma 247 p.variable.FromString(newValue); 248 } 249 else if (methods.find(command->GetCommandNam 250 Method& m = methods[command->GetCommandNam 251 if (m.method.NArg() == 0) { 252 m.method.operator()(m.object); 253 } 254 else if (m.method.NArg() > 0) { 255 G4Tokenizer tokens(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 } 270 else { 271 throw G4InvalidUICommand(); 272 } 273 } 274 } 275 276 void G4GenericMessenger::SetGuidance(const G4S 277 { 278 dircmd->SetGuidance(s); 279 } 280 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 310 G4String cmdpath = command->GetCommandPath() 311 G4UImessenger* messenger = command->GetMesse 312 G4String range = command->GetRange(); 313 std::vector<G4String> guidance; 314 G4String par_name = command->GetParameter(0) 315 G4bool par_omitable = command->GetParameter( 316 for (G4int i = 0; i < (G4int)command->GetGui 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; 323 324 if (*type == typeid(float) || *type == typei 325 auto* cmd_t = new G4UIcmdWithADoubleAndUni 326 if (spec == UnitDefault) { 327 cmd_t->SetDefaultUnit(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; 334 } 335 else if (*type == typeid(G4ThreeVector)) { 336 auto* cmd_t = new G4UIcmdWith3VectorAndUni 337 if (spec == UnitDefault) { 338 cmd_t->SetDefaultUnit(unit); 339 } 340 else if (spec == UnitCategory) { 341 cmd_t->SetUnitCategory(unit); 342 } 343 command = cmd_t; 344 } 345 else { 346 G4cerr << "Only parameters of type <double 347 "with units" 348 << G4endl; 349 return *this; 350 } 351 for (auto& i : guidance) { 352 command->SetGuidance(i); 353 } 354 command->SetRange(range); 355 return *this; 356 } 357 358 G4GenericMessenger::Command& G4GenericMessenge 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 393 theParam->SetParameterName(namex); 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); 403 theParam->SetCurrentAsDefault(currentAsDefau 404 return *this; 405 } 406 407 G4GenericMessenger::Command& G4GenericMessenge 408 { 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); 421 return *this; 422 } 423 424 G4GenericMessenger::Command& G4GenericMessenge 425 { 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); 438 return *this; 439 } 440