Geant4_10
G4ModelCommandsT.hh
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // $Id: G4ModelCommandsT.hh 66373 2012-12-18 09:41:34Z gcosmo $
27 //
28 // Generic model messenges.
29 //
30 // Jane Tinslay March 2006
31 //
32 #ifndef G4MODELCOMMANDST_HH
33 #define G4MODELCOMMANDST_HH
34 
35 #include "G4ModelApplyCommandsT.hh"
36 #include "G4Polymarker.hh"
37 #include "G4UIdirectory.hh"
38 #include <sstream>
39 
41 // Set parameter colour
42 template <typename M>
44 
45 public: // With description
46 
47  G4ModelCmdSetStringColour(M* model, const G4String& placement,
48  const G4String& cmdName="set")
49  :G4ModelCmdApplyStringColour<M>(model, placement, cmdName) {}
50 
52 
53 protected:
54 
55  virtual void Apply(const G4String& param, const G4Colour& colour) {
56  G4VModelCommand<M>::Model()->Set(param, colour);
57  }
58 
59 };
60 
62 // Set default colour
63 template <typename M>
65 
66 public: // With description
67 
68  G4ModelCmdSetDefaultColour(M* model, const G4String& placement,
69  const G4String& cmdName="setDefault")
70  :G4ModelCmdApplyColour<M>(model, placement, cmdName) {}
71 
73 
74 protected:
75 
76  virtual void Apply(const G4Colour& colour) {
77  G4VModelCommand<M>::Model()->SetDefault(colour);
78  }
79 
80 };
81 
83 // Add string command
84 template <typename M>
86 
87 public: // With description
88 
89  G4ModelCmdAddString(M* model, const G4String& placement,
90  const G4String& cmdName="add")
91  :G4ModelCmdApplyString<M>(model, placement, cmdName)
92  {
94  }
95 
96  virtual ~G4ModelCmdAddString() {}
97 
98 protected:
99 
100  virtual void Apply(const G4String& newValue) {
101  G4VModelCommand<M>::Model()->Add(newValue);
102  }
103 
104 };
105 
107 //Add integer command
108 template <typename M>
110 
111 public: // With description
112 
113  G4ModelCmdAddInt(M* model, const G4String& placement,
114  const G4String& cmdName="add")
115  :G4ModelCmdApplyInteger<M>(model, placement, cmdName)
116  {
118  }
119 
120  virtual ~G4ModelCmdAddInt() {}
121 
122 protected:
123 
124  virtual void Apply(const G4int& newValue) {
125  G4VModelCommand<M>::Model()->Add(newValue);
126  }
127 
128 };
129 
131 // Invert command
132 template <typename M>
134 
135 public: // With description
136 
137  G4ModelCmdInvert(M* model, const G4String& placement,
138  const G4String& cmdName="invert")
139  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
140  {
141  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Invert command");
142  }
143 
144  virtual ~G4ModelCmdInvert() {}
145 
146 protected:
147 
148  virtual void Apply(const G4bool& newValue) {
149  G4VModelCommand<M>::Model()->SetInvert(newValue);
150  }
151 
152 };
153 
155 // Active command
156 template <typename M>
158 
159 public: // With description
160 
161  G4ModelCmdActive(M* model, const G4String& placement,
162  const G4String& cmdName="active")
163  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
164  {
165  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Active command");
166  }
167 
168  virtual ~G4ModelCmdActive() {}
169 
170 protected:
171 
172  virtual void Apply(const G4bool& newValue) {
173  G4VModelCommand<M>::Model()->SetActive(newValue);
174  }
175 
176 };
177 
179 // Verbose command
180 template <typename M>
182 
183 public: // With description
184 
185  G4ModelCmdVerbose(M* model, const G4String& placement,
186  const G4String& cmdName="verbose")
187  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
188  {
189  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Verbose command");
190  }
191 
192  virtual ~G4ModelCmdVerbose() {}
193 
194 protected:
195 
196  virtual void Apply(const G4bool& newValue) {
197  G4VModelCommand<M>::Model()->SetVerbose(newValue);
198  }
199 
200 };
201 
203 // Reset command
204 template <typename M>
206 
207 public: // With description
208 
209  G4ModelCmdReset(M* model, const G4String& placement,
210  const G4String& cmdName="reset")
211  :G4ModelCmdApplyNull<M>(model, placement, cmdName)
212  {
213  G4ModelCmdApplyNull<M>::Command()->SetGuidance("Reset command");
214  }
215 
216  virtual ~G4ModelCmdReset() {}
217 
218 protected:
219 
220  virtual void Apply() {
221  G4VModelCommand<M>::Model()->Reset();
222  }
223 
224 };
225 
227 // Set auxiliary points colour command
228 template <typename M>
230 
231 public:
232 
234  const G4String& cmdName="setAuxPtsColour")
235  :G4ModelCmdApplyColour<M>(model, placement, cmdName) {}
236 
237 protected:
238 
239  void Apply(const G4Colour& colour) {
240  G4VModelCommand<M>::Model()->SetAuxPtsColour(colour);
241  }
242 
243 };
244 
246 // Set set points colour command
247 template <typename M>
249 
250 public:
251 
253  const G4String& cmdName="setStepPtsColour")
254  :G4ModelCmdApplyColour<M>(model, placement, cmdName) {}
255 
256 protected:
257 
258  void Apply(const G4Colour& colour) {
259  G4VModelCommand<M>::Model()->SetStepPtsColour(colour);
260  }
261 
262 };
263 
265 // Set draw line command
266 template <typename M>
268 
269 public:
270 
271  G4ModelCmdSetDrawLine(M* model, const G4String& placement,
272  const G4String& cmdName="setDrawLine")
273  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
274  {
275  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set draw line command");
276  }
277 
278 protected:
279 
280  void Apply(const G4bool& myBool) {
281  G4VModelCommand<M>::Model()->SetDrawLine(myBool);
282  }
283 
284 };
285 
287 // Set line visibility command
288 template <typename M>
290 
291 public:
292 
294  const G4String& cmdName="setLineVisible")
295  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
296  {
297  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set line visibility command");
298  }
299 
300 protected:
301 
302  void Apply(const G4bool& myBool) {
303  G4VModelCommand<M>::Model()->SetLineVisible(myBool);
304  }
305 
306 };
307 
309 // Set draw auxiliary points command
310 template <typename M>
312 
313 public:
314 
315  G4ModelCmdSetDrawAuxPts(M* model, const G4String& placement,
316  const G4String& cmdName="setDrawAuxPts")
317  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
318  {
319  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set draw auxiliary points command");
320  }
321 
322 protected:
323 
324  void Apply(const G4bool& myBool) {
325  G4VModelCommand<M>::Model()->SetDrawAuxPts(myBool);
326  }
327 
328 };
329 
331 // Set auxiliary points visibility
332 template <typename M>
334 
335 public:
336 
338  const G4String& cmdName="setAuxPtsVisible")
339  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
340  {
341  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set auxiliary points visibility command");
342  }
343 
344 protected:
345 
346  void Apply(const G4bool& myBool) {
347  G4VModelCommand<M>::Model()->SetAuxPtsVisible(myBool);
348  }
349 
350 };
351 
353 // Set draw step points command
354 template <typename M>
356 
357 public:
358 
360  const G4String& cmdName="setDrawStepPts")
361  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
362  {
363  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set draw step points command");
364  }
365 
366 protected:
367 
368  void Apply(const G4bool& myBool) {
369  G4VModelCommand<M>::Model()->SetDrawStepPts(myBool);
370  }
371 
372 };
373 
375 // Set step points visible command
376 template <typename M>
378 
379 public:
380 
382  const G4String& cmdName="setStepPtsVisible")
383  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
384  {
385  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Set step points visible command");
386  }
387 
388 protected:
389 
390  void Apply(const G4bool& myBool) {
391  G4VModelCommand<M>::Model()->SetStepPtsVisible(myBool);
392  }
393 
394 };
395 
397 // Set auxiliary points size command
398 template <typename M>
400 
401 public:
402 
403  G4ModelCmdSetAuxPtsSize(M* model, const G4String& placement,
404  const G4String& cmdName="setAuxPtsSize")
405  :G4ModelCmdApplyString<M>(model, placement, cmdName)
406  {
407  G4ModelCmdApplyString<M>::Command()->SetGuidance("Set auxiliary points size command");
408  }
409 
410 protected:
411 
412  void Apply(const G4String& sizeString) {
413  std::istringstream iss(sizeString);
414  G4double size;
415  G4String unit;
416  iss >> size >> unit;
417  if (G4VModelCommand<M>::Model()->GetAuxPtsSizeType() == G4VMarker::world)
418  {
420  G4VModelCommand<M>::Model()->SetAuxPtsSize(myDouble);
421  }
422  else // none or screen
423  {
424  G4VModelCommand<M>::Model()->SetAuxPtsSize(size);
425  }
426  }
427 
428 };
429 
431 // Set step points size command
432 template <typename M>
434 
435 public:
436 
438  const G4String& cmdName="setStepPtsSize")
439  :G4ModelCmdApplyString<M>(model, placement, cmdName)
440  {
441  G4ModelCmdApplyString<M>::Command()->SetGuidance("Set step points size command");
442  }
443 
444 protected:
445 
446  void Apply(const G4String& sizeString) {
447  std::istringstream iss(sizeString);
448  G4double size;
449  G4String unit;
450  iss >> size >> unit;
451  if (G4VModelCommand<M>::Model()->GetStepPtsSizeType() == G4VMarker::world)
452  {
454  G4VModelCommand<M>::Model()->SetStepPtsSize(myDouble);
455  }
456  else // none or screen
457  {
458  G4VModelCommand<M>::Model()->SetStepPtsSize(size);
459  }
460  }
461 
462 };
463 
465 // Set step points type command
466 template <typename M>
468 
469 public:
470 
472  const G4String& cmdName="setStepPtsType")
473  :G4ModelCmdApplyString<M>(model, placement, cmdName)
474  {
476  cmd->SetGuidance("Set step points type.");
477  cmd->SetCandidates("dots circles squares");
478  }
479 
480 protected:
481 
482  void Apply(const G4String& type) {
484 
485  if (type == "dots") {myType = G4Polymarker::dots;}
486  else if (type == "circles") {myType = G4Polymarker::circles;}
487  else if (type == "squares") {myType = G4Polymarker::squares;}
488  else {
490  ed << "Invalid argument. See command guidance for options.";
492  ("G4ModelCmdSetStepPtsType::Apply",
493  "modeling0109", JustWarning, ed);
494  return;
495  }
496  G4VModelCommand<M>::Model()->SetStepPtsType(myType);
497  }
498 
499 };
500 
502 // Set auxiliary points type command
503 template <typename M>
505 
506 public:
507 
508  G4ModelCmdSetAuxPtsType(M* model, const G4String& placement,
509  const G4String& cmdName="setAuxPtsType")
510  :G4ModelCmdApplyString<M>(model, placement, cmdName)
511  {
513 
514  cmd->SetGuidance("Set auxiliary points type.");
515  cmd->SetCandidates("dots circles squares");
516  }
517 
518 protected:
519 
520  void Apply(const G4String& type) {
522 
523  if (type == "dots") {myType = G4Polymarker::dots;}
524  else if (type == "circles") {myType = G4Polymarker::circles;}
525  else if (type == "squares") {myType = G4Polymarker::squares;}
526  else {
528  ed << "Invalid argument. See command guidance for options.";
530  ("G4ModelCmdSetAuxPtsType::Apply",
531  "modeling0110", JustWarning, ed);
532  return;
533  }
534 
535  G4VModelCommand<M>::Model()->SetAuxPtsType(myType);
536  }
537 
538 };
539 
541 // Set step points size type command
542 template <typename M>
544 
545 public:
546 
548  const G4String& cmdName="setStepPtsSizeType")
549  :G4ModelCmdApplyString<M>(model, placement, cmdName)
550  {
552  cmd->SetGuidance("Set step size type.");
553  cmd->SetCandidates("none world screen");
554  }
555 
556 protected:
557 
558  void Apply(const G4String& type) {
559  G4VMarker::SizeType mySizeType;
560 
561  if (type == "none") {mySizeType = G4VMarker::none;}
562  else if (type == "world") {mySizeType = G4VMarker::world;}
563  else if (type == "screen") {mySizeType = G4VMarker::screen;}
564  else {
566  ed << "Invalid argument. See command guidance for options.";
568  ("G4ModelCmdSetStepPtsSizeType::Apply",
569  "modeling0111", JustWarning, ed);
570  return;
571  }
572  G4VModelCommand<M>::Model()->SetStepPtsSizeType(mySizeType);
573  }
574 
575 };
576 
578 // Set auxiliary points size type command
579 template <typename M>
581 
582 public:
583 
585  const G4String& cmdName="setAuxPtsSizeType")
586  :G4ModelCmdApplyString<M>(model, placement, cmdName)
587  {
589  cmd->SetGuidance("Set auxiliary size type.");
590  cmd->SetCandidates("none world screen");
591  }
592 
593 protected:
594 
595  void Apply(const G4String& type) {
596  G4VMarker::SizeType mySizeType;
597 
598  if (type == "none") {mySizeType = G4VMarker::none;}
599  else if (type == "world") {mySizeType = G4VMarker::world;}
600  else if (type == "screen") {mySizeType = G4VMarker::screen;}
601  else {
603  ed << "Invalid argument. See command guidance for options.";
605  ("G4ModelCmdSetAuxPtsSizeType::Apply",
606  "modeling0112", JustWarning, ed);
607  return;
608  }
609  G4VModelCommand<M>::Model()->SetAuxPtsSizeType(mySizeType);
610  }
611 
612 };
613 
615 // Set step points fill style command
616 template <typename M>
618 
619 public:
620 
622  const G4String& cmdName="setStepPtsFillStyle")
623  :G4ModelCmdApplyString<M>(model, placement, cmdName)
624  {
626  cmd->SetGuidance("Set step fill style type.");
627  cmd->SetCandidates("noFill hashed filled");
628  }
629 
630 protected:
631 
632  void Apply(const G4String& type) {
633  G4VMarker::FillStyle myFillStyle;
634 
635  if (type == "noFill") {myFillStyle = G4VMarker::noFill;}
636  else if (type == "hashed") {myFillStyle = G4VMarker::hashed;}
637  else if (type == "filled") {myFillStyle = G4VMarker::filled;}
638  else {
640  ed << "Invalid argument. See command guidance for options.";
642  ("G4ModelCmdSetStepPtsFillStyle::Apply",
643  "modeling0113", JustWarning, ed);
644  return;
645  }
646  G4VModelCommand<M>::Model()->SetStepPtsFillStyle(myFillStyle);
647  }
648 
649 };
650 
652 // Set auxiliary points fill style command
653 template <typename M>
655 
656 public:
657 
659  const G4String& cmdName="setAuxPtsFillStyle")
660  :G4ModelCmdApplyString<M>(model, placement, cmdName)
661  {
663  cmd->SetGuidance("Set auxiliary fill style.");
664  cmd->SetCandidates("noFill hashed filled");
665  }
666 
667 protected:
668 
669  void Apply(const G4String& type) {
670  G4VMarker::FillStyle myFillStyle;
671 
672  if (type == "noFill") {myFillStyle = G4VMarker::noFill;}
673  else if (type == "hashed") {myFillStyle = G4VMarker::hashed;}
674  else if (type == "filled") {myFillStyle = G4VMarker::filled;}
675  else {
677  ed << "Invalid argument. See command guidance for options.";
679  ("G4ModelCmdSetAuxPtsFillStyle::Apply",
680  "modeling0114", JustWarning, ed);
681  return;
682  }
683  G4VModelCommand<M>::Model()->SetAuxPtsFillStyle(myFillStyle);
684  }
685 
686 };
687 
689 // SetLineColour command
690 template <typename M>
692 
693 public:
694 
695  G4ModelCmdSetLineColour(M* model, const G4String& placement,
696  const G4String& cmdName="""setLineColour")
697  :G4ModelCmdApplyColour<M>(model, placement, cmdName){}
698 
699 protected:
700 
701  void Apply(const G4Colour& colour) {
702  G4VModelCommand<M>::Model()->SetLineColour(colour);
703  }
704 
705 };
706 
708 // Set time slice interval command
709 template <typename M>
711 
712 public:
713 
715  const G4String& cmdName = "setTimeSliceInterval")
716  :G4ModelCmdApplyDoubleAndUnit<M>(model, placement, cmdName)
717  {
719  cmd->SetGuidance
720  ("Set time slice interval. Give unit, e.g., \"0.1 ns\"");
721  cmd->SetUnitCategory("Time");
722  }
723 
724 protected:
725 
726  void Apply(const G4double& myDouble) {
727  G4VModelCommand<M>::Model()->SetTimeSliceInterval(myDouble);
728  }
729 
730 };
731 
733 // Create context directory command
734 template <typename M>
736 
737 public:
738 
740  {
741  G4String title = placement+"/"+model->Name()+"/";
742  cmd = new G4UIdirectory(title);
743 
744  cmd->SetGuidance("Commands for default configuration");
745  }
746 
748  delete cmd;
749  }
750 
751 protected:
752 
754 
755 };
756 
758 // Draw command
759 template <typename M>
761 
762 public: // With description
763 
764  G4ModelCmdDraw(M* model, const G4String& placement,
765  const G4String& cmdName="draw")
766  :G4ModelCmdApplyBool<M>(model, placement, cmdName)
767  {
768  G4ModelCmdApplyBool<M>::Command()->SetGuidance("Draw command");
769  }
770 
771  virtual ~G4ModelCmdDraw() {}
772 
773 protected:
774 
775  virtual void Apply(const G4bool& newValue) {
776  if (newValue) G4VModelCommand<M>::Model()->Draw();
777  }
778 
779 };
780 
782 // Set interval
783 template <typename M>
785 
786 public: // With description
787 
788  G4ModelCmdAddInterval(M* model, const G4String& placement,
789  const G4String& cmdName="addInterval")
790  :G4ModelCmdApplyString<M>(model, placement, cmdName)
791  {
793  cmd->SetGuidance("Set interval.");
794  }
795 
797 
798 protected:
799 
800  virtual void Apply(const G4String& param) {
801  G4VModelCommand<M>::Model()->AddInterval(param);
802 
803  }
804 };
805 
807 // Set value
808 template <typename M>
810 
811 public: // With description
812 
813  G4ModelCmdAddValue(M* model, const G4String& placement,
814  const G4String& cmdName="addValue")
815  :G4ModelCmdApplyString<M>(model, placement, cmdName)
816  {
818  cmd->SetGuidance("Set value.");
819  }
820 
821  virtual ~G4ModelCmdAddValue() {}
822 protected:
823 
824  virtual void Apply(const G4String& param) {
825  G4VModelCommand<M>::Model()->AddValue(param);
826 
827  }
828 };
829 
831 // Set string command
832 template <typename M>
834 
835 public: // With description
836 
837  G4ModelCmdSetString(M* model, const G4String& placement,
838  const G4String& cmdName="set")
839  :G4ModelCmdApplyString<M>(model, placement, cmdName)
840  {
842  }
843 
844  virtual ~G4ModelCmdSetString() {}
845 
846 protected:
847 
848  virtual void Apply(const G4String& newValue) {
849  G4VModelCommand<M>::Model()->Set(newValue);
850  }
851 
852 };
853 
854 #endif
G4UIcmdWithADoubleAndUnit * Command()
G4ModelCmdSetTimeSliceInterval(M *model, const G4String &placement, const G4String &cmdName="setTimeSliceInterval")
virtual void Apply(const G4bool &newValue)
char cmd[1024]
Definition: tracer.cxx:25
void Apply(const G4String &type)
virtual ~G4ModelCmdReset()
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
void Apply(const G4bool &myBool)
virtual void Apply(const G4Colour &colour)
G4ModelCmdSetStepPtsColour(M *model, const G4String &placement, const G4String &cmdName="setStepPtsColour")
virtual void Apply(const G4String &param)
G4ModelCmdSetDrawStepPts(M *model, const G4String &placement, const G4String &cmdName="setDrawStepPts")
void Apply(const G4bool &myBool)
G4ModelCmdVerbose(M *model, const G4String &placement, const G4String &cmdName="verbose")
void Apply(const G4String &type)
G4ModelCmdSetStepPtsType(M *model, const G4String &placement, const G4String &cmdName="setStepPtsType")
G4ModelCmdSetLineColour(M *model, const G4String &placement, const G4String &cmdName="""setLineColour")
G4ModelCmdSetDrawLine(M *model, const G4String &placement, const G4String &cmdName="setDrawLine")
void Apply(const G4Colour &colour)
G4ModelCmdSetAuxPtsColour(M *model, const G4String &placement, const G4String &cmdName="setAuxPtsColour")
void Apply(const G4double &myDouble)
void Apply(const G4String &type)
void SetUnitCategory(const char *unitCategory)
virtual ~G4ModelCmdAddString()
virtual ~G4ModelCmdActive()
G4ModelCmdSetStepPtsVisible(M *model, const G4String &placement, const G4String &cmdName="setStepPtsVisible")
static G4double GetNewDoubleValue(const char *paramString)
void Apply(const G4String &sizeString)
void Apply(const G4bool &myBool)
G4ModelCmdAddInt(M *model, const G4String &placement, const G4String &cmdName="add")
G4ModelCmdSetStepPtsSize(M *model, const G4String &placement, const G4String &cmdName="setStepPtsSize")
int G4int
Definition: G4Types.hh:78
G4ModelCmdAddValue(M *model, const G4String &placement, const G4String &cmdName="addValue")
G4ModelCmdReset(M *model, const G4String &placement, const G4String &cmdName="reset")
void Apply(const G4Colour &colour)
void Apply(const G4String &type)
G4ModelCmdSetDrawAuxPts(M *model, const G4String &placement, const G4String &cmdName="setDrawAuxPts")
G4ModelCmdSetStringColour(M *model, const G4String &placement, const G4String &cmdName="set")
void Apply(const G4bool &myBool)
virtual void Apply(const G4bool &newValue)
G4ModelCmdSetAuxPtsSize(M *model, const G4String &placement, const G4String &cmdName="setAuxPtsSize")
G4UIcmdWithAnInteger * Command()
G4ModelCmdInvert(M *model, const G4String &placement, const G4String &cmdName="invert")
G4UIcmdWithAString * Command()
bool G4bool
Definition: G4Types.hh:79
virtual void Apply()
virtual void Apply(const G4String &newValue)
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161
virtual void Apply(const G4String &param)
G4ModelCmdSetAuxPtsVisible(M *model, const G4String &placement, const G4String &cmdName="setAuxPtsVisible")
G4ModelCmdActive(M *model, const G4String &placement, const G4String &cmdName="active")
virtual void Apply(const G4bool &newValue)
const XML_Char XML_Content * model
Definition: expat.h:151
virtual void Apply(const G4int &newValue)
G4UIcmdWithABool * Command()
void Apply(const G4String &sizeString)
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4ModelCmdSetStepPtsSizeType(M *model, const G4String &placement, const G4String &cmdName="setStepPtsSizeType")
virtual ~G4ModelCmdAddInt()
virtual void Apply(const G4String &param, const G4Colour &colour)
G4ModelCmdDraw(M *model, const G4String &placement, const G4String &cmdName="draw")
subroutine title(NA, NB, NCA, NCB)
Definition: dpm25nuc7.f:1744
G4ModelCmdSetAuxPtsType(M *model, const G4String &placement, const G4String &cmdName="setAuxPtsType")
virtual ~G4ModelCmdDraw()
void Apply(const G4String &type)
G4ModelCmdSetAuxPtsFillStyle(M *model, const G4String &placement, const G4String &cmdName="setAuxPtsFillStyle")
G4ModelCmdAddInterval(M *model, const G4String &placement, const G4String &cmdName="addInterval")
void Apply(const G4bool &myBool)
void Apply(const G4bool &myBool)
G4ModelCmdCreateContextDir(M *model, const G4String &placement)
void SetCandidates(const char *candidateList)
virtual ~G4ModelCmdVerbose()
G4ModelCmdSetAuxPtsSizeType(M *model, const G4String &placement, const G4String &cmdName="setAuxPtsSizeType")
virtual void Apply(const G4String &newValue)
double G4double
Definition: G4Types.hh:76
virtual ~G4ModelCmdInvert()
G4ModelCmdSetString(M *model, const G4String &placement, const G4String &cmdName="set")
virtual void Apply(const G4bool &newValue)
void Apply(const G4Colour &colour)
G4ModelCmdSetDefaultColour(M *model, const G4String &placement, const G4String &cmdName="setDefault")
void Apply(const G4String &type)
G4ModelCmdAddString(M *model, const G4String &placement, const G4String &cmdName="add")
G4ModelCmdSetStepPtsFillStyle(M *model, const G4String &placement, const G4String &cmdName="setStepPtsFillStyle")
G4ModelCmdSetLineVisible(M *model, const G4String &placement, const G4String &cmdName="setLineVisible")