| 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