Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VisCommands.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/management/src/G4VisCommands.cc (Version 11.3.0) and /visualization/management/src/G4VisCommands.cc (Version 10.1.p1)


  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: G4VisCommands.cc 87360 2014-12-01 16:07:16Z gcosmo $
 27                                                    28 
 28 // /vis/ top level commands - John Allison  5t     29 // /vis/ top level commands - John Allison  5th February 2001
 29                                                    30 
 30 #include "G4VisCommands.hh"                        31 #include "G4VisCommands.hh"
 31                                                    32 
 32 #include "G4VisManager.hh"                         33 #include "G4VisManager.hh"
 33 #include "G4UImanager.hh"                          34 #include "G4UImanager.hh"
 34 #include "G4UIcmdWithABool.hh"                     35 #include "G4UIcmdWithABool.hh"
 35 #include "G4UIcmdWithAString.hh"                   36 #include "G4UIcmdWithAString.hh"
 36 #include "G4UIcmdWithoutParameter.hh"              37 #include "G4UIcmdWithoutParameter.hh"
 37 #include "G4RunManager.hh"                         38 #include "G4RunManager.hh"
 38 #include "G4RunManagerFactory.hh"              <<  39 #ifdef G4MULTITHREADED
                                                   >>  40 #include "G4MTRunManager.hh"
                                                   >>  41 #endif
 39 #include "G4Run.hh"                                42 #include "G4Run.hh"
 40 #include "G4UIsession.hh"                          43 #include "G4UIsession.hh"
 41 #include "G4Trajectory.hh"                         44 #include "G4Trajectory.hh"
 42 #include "G4TrajectoryPoint.hh"                    45 #include "G4TrajectoryPoint.hh"
 43 #include "G4RichTrajectory.hh"                     46 #include "G4RichTrajectory.hh"
 44 #include "G4RichTrajectoryPoint.hh"                47 #include "G4RichTrajectoryPoint.hh"
 45 #include "G4SmoothTrajectory.hh"                   48 #include "G4SmoothTrajectory.hh"
 46 #include "G4SmoothTrajectoryPoint.hh"              49 #include "G4SmoothTrajectoryPoint.hh"
 47 #include "G4PhysicalVolumeModel.hh"                50 #include "G4PhysicalVolumeModel.hh"
 48 #include "G4AttDef.hh"                             51 #include "G4AttDef.hh"
 49                                                    52 
 50 #define G4warn G4cout                          << 
 51                                                << 
 52 ////////////// /vis/abortReviewKeptEvents ////     53 ////////////// /vis/abortReviewKeptEvents /////////////////////////////
 53                                                    54 
 54 G4VisCommandAbortReviewKeptEvents::G4VisComman     55 G4VisCommandAbortReviewKeptEvents::G4VisCommandAbortReviewKeptEvents () {
 55   G4bool omitable;                                 56   G4bool omitable;
 56                                                    57 
 57   fpCommand = new G4UIcmdWithABool("/vis/abort     58   fpCommand = new G4UIcmdWithABool("/vis/abortReviewKeptEvents", this);
 58   fpCommand -> SetGuidance("Abort review of ke     59   fpCommand -> SetGuidance("Abort review of kept events.");
 59   fpCommand -> SetParameterName("abort", omita     60   fpCommand -> SetParameterName("abort", omitable=true);
 60   fpCommand -> SetDefaultValue(true);              61   fpCommand -> SetDefaultValue(true);
 61 }                                                  62 }
 62                                                    63 
 63 G4VisCommandAbortReviewKeptEvents::~G4VisComma     64 G4VisCommandAbortReviewKeptEvents::~G4VisCommandAbortReviewKeptEvents () {
 64   delete fpCommand;                                65   delete fpCommand;
 65 }                                                  66 }
 66                                                    67 
 67 G4String G4VisCommandAbortReviewKeptEvents::Ge     68 G4String G4VisCommandAbortReviewKeptEvents::GetCurrentValue (G4UIcommand*) {
 68   return G4String();                               69   return G4String();
 69 }                                                  70 }
 70                                                    71 
 71 void G4VisCommandAbortReviewKeptEvents::SetNew     72 void G4VisCommandAbortReviewKeptEvents::SetNewValue (G4UIcommand*,
 72                                                <<  73                  G4String newValue) {
 73   fpVisManager->SetAbortReviewKeptEvents(G4UIc     74   fpVisManager->SetAbortReviewKeptEvents(G4UIcommand::ConvertToBool(newValue));
 74   G4warn << "Type \"continue\" to complete the <<  75   G4cout << "Type \"continue\" to complete the abort." << G4endl;
 75 }                                              << 
 76                                                << 
 77 ////////////// /vis/abortReviewPlots ///////// << 
 78                                                << 
 79 G4VisCommandAbortReviewPlots::G4VisCommandAbor << 
 80   G4bool omitable;                             << 
 81                                                << 
 82   fpCommand = new G4UIcmdWithABool("/vis/abort << 
 83   fpCommand -> SetGuidance("Abort review of pl << 
 84   fpCommand -> SetParameterName("abort", omita << 
 85   fpCommand -> SetDefaultValue(true);          << 
 86 }                                              << 
 87                                                << 
 88 G4VisCommandAbortReviewPlots::~G4VisCommandAbo << 
 89   delete fpCommand;                            << 
 90 }                                              << 
 91                                                << 
 92 G4String G4VisCommandAbortReviewPlots::GetCurr << 
 93   return G4String();                           << 
 94 }                                              << 
 95                                                << 
 96 void G4VisCommandAbortReviewPlots::SetNewValue << 
 97                                                << 
 98   fpVisManager->SetAbortReviewPlots(G4UIcomman << 
 99   G4warn << "Type \"continue\" to complete the << 
100 }                                              << 
101                                                << 
102 ////////////// /vis/drawOnlyToBeKeptEvents /// << 
103                                                << 
104 G4VisCommandDrawOnlyToBeKeptEvents::G4VisComma << 
105 {                                              << 
106   G4bool omitable;                             << 
107                                                << 
108   fpCommand = new G4UIcmdWithABool("/vis/drawO << 
109   fpCommand -> SetGuidance                     << 
110   ("DURING A RUN draw only those events that h << 
111    "\nwith G4EventManager::GetEventManager()-> << 
112    "\nwith \"/event/keepCurrentEvent\".");     << 
113   fpCommand -> SetGuidance(                    << 
114   "To draw selected events the user should set << 
115   "\n  if ( some criterion ) {"                << 
116   "\n    G4EventManager::GetEventManager()->Ke << 
117   "\n  }");                                    << 
118   fpCommand -> SetParameterName("draw", omitab << 
119   fpCommand -> SetDefaultValue(true);          << 
120 }                                              << 
121                                                << 
122 G4VisCommandDrawOnlyToBeKeptEvents::~G4VisComm << 
123   delete fpCommand;                            << 
124 }                                              << 
125                                                << 
126 G4String G4VisCommandDrawOnlyToBeKeptEvents::G << 
127   return G4String();                           << 
128 }                                              << 
129                                                << 
130 void G4VisCommandDrawOnlyToBeKeptEvents::SetNe << 
131                                                << 
132   fpVisManager->SetDrawEventOnlyIfToBeKept(G4U << 
133   G4VisManager::Verbosity verbosity = fpVisMan << 
134   if (verbosity < G4VisManager::warnings) {    << 
135     if (fpVisManager->GetDrawEventOnlyIfToBeKe << 
136       G4warn << "Only events that have been ke << 
137     } else {                                   << 
138       G4warn << "All events will be drawn." << << 
139     }                                          << 
140   }                                            << 
141 }                                                  76 }
142                                                    77 
143 ////////////// /vis/enable ///////////////////     78 ////////////// /vis/enable ///////////////////////////////////////
144                                                    79 
145 G4VisCommandEnable::G4VisCommandEnable () {        80 G4VisCommandEnable::G4VisCommandEnable () {
146   G4bool omitable;                                 81   G4bool omitable;
147                                                    82 
148   fpCommand = new G4UIcmdWithABool("/vis/enabl     83   fpCommand = new G4UIcmdWithABool("/vis/enable", this);
149   fpCommand -> SetGuidance("Enables/disables v     84   fpCommand -> SetGuidance("Enables/disables visualization system.");
150   fpCommand -> SetParameterName("enabled", omi     85   fpCommand -> SetParameterName("enabled", omitable=true);
151   fpCommand -> SetDefaultValue(true);              86   fpCommand -> SetDefaultValue(true);
152                                                    87 
153   fpCommand1 = new G4UIcmdWithoutParameter("/v     88   fpCommand1 = new G4UIcmdWithoutParameter("/vis/disable", this);
154   fpCommand1 -> SetGuidance("Disables visualiz     89   fpCommand1 -> SetGuidance("Disables visualization system.");
155 }                                                  90 }
156                                                    91 
157 G4VisCommandEnable::~G4VisCommandEnable () {       92 G4VisCommandEnable::~G4VisCommandEnable () {
158   delete fpCommand;                                93   delete fpCommand;
159   delete fpCommand1;                               94   delete fpCommand1;
160 }                                                  95 }
161                                                    96 
162 G4String G4VisCommandEnable::GetCurrentValue (     97 G4String G4VisCommandEnable::GetCurrentValue (G4UIcommand*) {
163   return G4String();                               98   return G4String();
164 }                                                  99 }
165                                                   100 
166 void G4VisCommandEnable::SetNewValue (G4UIcomm    101 void G4VisCommandEnable::SetNewValue (G4UIcommand* command,
167               G4String newValue) {                102               G4String newValue) {
168   if (command == fpCommand) {                     103   if (command == fpCommand) {
169     G4bool enable = G4UIcommand::ConvertToBool    104     G4bool enable = G4UIcommand::ConvertToBool(newValue);
170     if (enable) fpVisManager->Enable();  // Pr    105     if (enable) fpVisManager->Enable();  // Printing is in vis manager.
171     else fpVisManager->Disable();        // Pr    106     else fpVisManager->Disable();        // Printing is in vis manager.
172   } else fpVisManager->Disable();        // Pr    107   } else fpVisManager->Disable();        // Printing is in vis manager.
173   // Note: Printing is in vis manager.            108   // Note: Printing is in vis manager.
174 }                                                 109 }
175                                                   110 
176 ////////////// /vis/initialize ///////////////    111 ////////////// /vis/initialize ///////////////////////////////////////
177                                                   112 
178 G4VisCommandInitialize::G4VisCommandInitialize    113 G4VisCommandInitialize::G4VisCommandInitialize ()
179 {                                                 114 {
180   fpCommand = new G4UIcmdWithoutParameter("/vi    115   fpCommand = new G4UIcmdWithoutParameter("/vis/initialize", this);
181   fpCommand -> SetGuidance("Initialise visuali    116   fpCommand -> SetGuidance("Initialise visualisation manager.");
182 }                                                 117 }
183                                                   118 
184 G4VisCommandInitialize::~G4VisCommandInitializ    119 G4VisCommandInitialize::~G4VisCommandInitialize () {
185   delete fpCommand;                               120   delete fpCommand;
186 }                                                 121 }
187                                                   122 
188 void G4VisCommandInitialize::SetNewValue (G4UI    123 void G4VisCommandInitialize::SetNewValue (G4UIcommand*,
189             G4String) {                           124             G4String) {
190   fpVisManager->Initialize();                     125   fpVisManager->Initialize();
191 }                                                 126 }
192                                                   127 
193 ////////////// /vis/list /////////////////////    128 ////////////// /vis/list ///////////////////////////////////////
194                                                   129 
195 G4VisCommandList::G4VisCommandList ()             130 G4VisCommandList::G4VisCommandList ()
196 {                                                 131 {
197   G4bool omitable;                                132   G4bool omitable;
198                                                   133 
199   fpCommand = new G4UIcmdWithAString("/vis/lis    134   fpCommand = new G4UIcmdWithAString("/vis/list", this);
200   fpCommand -> SetGuidance("Lists visualizatio    135   fpCommand -> SetGuidance("Lists visualization parameters.");
201   fpCommand -> SetParameterName("verbosity", o    136   fpCommand -> SetParameterName("verbosity", omitable=true);
202   fpCommand -> SetDefaultValue("warnings");       137   fpCommand -> SetDefaultValue("warnings");
203 }                                                 138 }
204                                                   139 
205 G4VisCommandList::~G4VisCommandList ()            140 G4VisCommandList::~G4VisCommandList ()
206 {                                                 141 {
207   delete fpCommand;                               142   delete fpCommand;
208 }                                                 143 }
209                                                   144 
210 G4String G4VisCommandList::GetCurrentValue (G4    145 G4String G4VisCommandList::GetCurrentValue (G4UIcommand*)
211 {                                                 146 {
212   return "";                                      147   return "";
213 }                                                 148 }
214                                                   149 
215 void G4VisCommandList::SetNewValue (G4UIcomman    150 void G4VisCommandList::SetNewValue (G4UIcommand*, G4String newValue)
216 {                                                 151 {
217   G4VisManager::Verbosity verbosity = fpVisMan << 152   G4String& verbosityString = newValue;
                                                   >> 153   G4VisManager::Verbosity verbosity =
                                                   >> 154     fpVisManager->GetVerbosityValue(verbosityString);
218                                                   155 
219   G4VisManager::PrintAvailableVerbosity(G4cout << 156   fpVisManager->PrintAvailableGraphicsSystems();
220   G4cout << G4endl;                            << 
221   fpVisManager->PrintAvailableGraphicsSystems( << 
222   G4cout << G4endl;                               157   G4cout << G4endl;
223   fpVisManager->PrintAvailableModels(verbosity    158   fpVisManager->PrintAvailableModels(verbosity);
224   G4cout << G4endl;                               159   G4cout << G4endl;
225   fpVisManager->PrintAvailableUserVisActions(v    160   fpVisManager->PrintAvailableUserVisActions(verbosity);
226   G4cout << G4endl;                               161   G4cout << G4endl;
227   fpVisManager->PrintAvailableColours(verbosit    162   fpVisManager->PrintAvailableColours(verbosity);
228   G4cout << G4endl;                               163   G4cout << G4endl;
229   G4UImanager* UImanager = G4UImanager::GetUIp    164   G4UImanager* UImanager = G4UImanager::GetUIpointer();
230   UImanager->ApplyCommand("/vis/scene/list ! " << 165   UImanager->ApplyCommand("/vis/scene/list ! c");
231   G4cout << G4endl;                            << 166   UImanager->ApplyCommand("/vis/viewer/list ! c");
232   UImanager->ApplyCommand("/vis/viewer/list !  << 
233                                                   167 
234   G4cout <<                                       168   G4cout <<
235   "\nAttributes available for modeling and fil    169   "\nAttributes available for modeling and filtering with"
236   "\n  \"/vis/modeling/trajectories/create/dra    170   "\n  \"/vis/modeling/trajectories/create/drawByAttribute\" and"
237   "\n  \"/vis/filtering/trajectories/create/at    171   "\n  \"/vis/filtering/trajectories/create/attributeFilter\" commands"
238   "\nand by picking:"                             172   "\nand by picking:"
239   << G4endl;                                      173   << G4endl;
240   G4cout                                          174   G4cout
241   << *G4TrajectoriesModel().GetAttDefs();         175   << *G4TrajectoriesModel().GetAttDefs();
242   G4cout                                          176   G4cout
243   << *G4RichTrajectory().GetAttDefs()             177   << *G4RichTrajectory().GetAttDefs()
244   << *G4RichTrajectoryPoint().GetAttDefs();       178   << *G4RichTrajectoryPoint().GetAttDefs();
245   G4cout                                          179   G4cout
246   << *G4SmoothTrajectory().GetAttDefs()           180   << *G4SmoothTrajectory().GetAttDefs()
247   << *G4SmoothTrajectoryPoint().GetAttDefs();     181   << *G4SmoothTrajectoryPoint().GetAttDefs();
248   G4cout                                          182   G4cout
249   << *G4Trajectory().GetAttDefs()                 183   << *G4Trajectory().GetAttDefs()
250   << *G4TrajectoryPoint().GetAttDefs();           184   << *G4TrajectoryPoint().GetAttDefs();
251                                                   185 
252   G4cout <<                                       186   G4cout <<
253   "\nGeometry attributes available for touchab    187   "\nGeometry attributes available for touchables by picking:\n";
254   G4cout                                          188   G4cout
255   << *G4PhysicalVolumeModel().GetAttDefs();       189   << *G4PhysicalVolumeModel().GetAttDefs();
256                                                   190 
257   if (verbosity < G4VisManager::parameters)       191   if (verbosity < G4VisManager::parameters)
258     G4cout <<                                     192     G4cout <<
259   "\nTo get more information, \"/vis/list all\ << 193   "\nTo get more information, \"/vis/list all all\" or use individual commands"
260   "\n  such as (use \"ls\" or \"help\"):"         194   "\n  such as (use \"ls\" or \"help\"):"
261   "\n    /vis/scene/list all all"                 195   "\n    /vis/scene/list all all"
262   "\n    /vis/viewer/list all all"                196   "\n    /vis/viewer/list all all"
263   "\n    /vis/modeling/trajectories/list"         197   "\n    /vis/modeling/trajectories/list"
264   "\n    /vis/filtering/trajectories/list"        198   "\n    /vis/filtering/trajectories/list"
265      << G4endl;                                   199      << G4endl;
266 }                                                 200 }
267                                                   201 
268 ////////////// /vis/reviewKeptEvents /////////    202 ////////////// /vis/reviewKeptEvents ///////////////////////////////////////
269                                                   203 
270 G4VisCommandReviewKeptEvents::G4VisCommandRevi    204 G4VisCommandReviewKeptEvents::G4VisCommandReviewKeptEvents ()
271 {                                                 205 {
272   G4bool omitable;                                206   G4bool omitable;
273                                                   207 
274   fpCommand = new G4UIcmdWithAString("/vis/rev    208   fpCommand = new G4UIcmdWithAString("/vis/reviewKeptEvents", this);
275   fpCommand -> SetGuidance("Review kept events    209   fpCommand -> SetGuidance("Review kept events.");
276   fpCommand -> SetGuidance                        210   fpCommand -> SetGuidance
277     ("If a macro file is specified, it is exec    211     ("If a macro file is specified, it is executed for each event.");
278   fpCommand -> SetGuidance(                       212   fpCommand -> SetGuidance(
279   "If a macro file is not specified, each even    213   "If a macro file is not specified, each event is drawn to the current"
280   "\nviewer.  After each event, the session is    214   "\nviewer.  After each event, the session is paused.  The user may issue"
281   "\nany allowed command.  Then enter \"cont[i    215   "\nany allowed command.  Then enter \"cont[inue]\" to continue to the next"
282   "\nevent."                                      216   "\nevent."
283   "\nUseful commands might be:"                   217   "\nUseful commands might be:"
284   "\n  \"/vis/viewer/...\" to change the view     218   "\n  \"/vis/viewer/...\" to change the view (zoom, set/viewpoint,...)."
285   "\n  \"/vis/ogl/export\" to get hard copy."  << 219   "\n  \"/vis/oglx/printEPS\" to get hard copy."
286   "\n  \"/vis/open\" to get alternative viewer    220   "\n  \"/vis/open\" to get alternative viewer."
287   "\n  \"/vis/abortReviewKeptEvents\", then \"    221   "\n  \"/vis/abortReviewKeptEvents\", then \"cont[inue]\", to abort.");
288   fpCommand -> SetParameterName("macro-file-na    222   fpCommand -> SetParameterName("macro-file-name", omitable=true);
289   fpCommand -> SetDefaultValue("");               223   fpCommand -> SetDefaultValue("");
290 }                                                 224 }
291                                                   225 
292 G4VisCommandReviewKeptEvents::~G4VisCommandRev    226 G4VisCommandReviewKeptEvents::~G4VisCommandReviewKeptEvents ()
293 {                                                 227 {
294   delete fpCommand;                               228   delete fpCommand;
295 }                                                 229 }
296                                                   230 
297 G4String G4VisCommandReviewKeptEvents::GetCurr    231 G4String G4VisCommandReviewKeptEvents::GetCurrentValue (G4UIcommand*)
298 {                                                 232 {
299   return "";                                      233   return "";
300 }                                                 234 }
301                                                   235 
302 void G4VisCommandReviewKeptEvents::SetNewValue    236 void G4VisCommandReviewKeptEvents::SetNewValue (G4UIcommand*, G4String newValue)
303 {                                                 237 {
304   if (fpVisManager->GetReviewingKeptEvents())  << 238   static bool reviewing = false;
305     G4warn <<                                  << 239   if (reviewing) {
                                                   >> 240     G4cout <<
306       "\"/vis/reviewKeptEvents\" not allowed w    241       "\"/vis/reviewKeptEvents\" not allowed within an already started review."
307       "\n  No action taken."                      242       "\n  No action taken."
308      << G4endl;                                   243      << G4endl;
309     return;                                       244     return;
310   }                                               245   }
311                                                   246 
312   G4String& macroFileName = newValue;             247   G4String& macroFileName = newValue;
313   G4VisManager::Verbosity verbosity = fpVisMan    248   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
314                                                   249 
315   G4RunManager* runManager = G4RunManagerFacto << 250   G4RunManager* runManager = G4RunManager::GetRunManager();
316   const G4Run* run         = runManager ? runM << 251 #ifdef G4MULTITHREADED
317   const std::vector<const G4Event*>* events =  << 252   if(G4Threading::IsMultithreadedApplication())
318     run ? run->GetEventVector() : nullptr;     << 253   { runManager = G4MTRunManager::GetMasterRunManager(); }
319   size_t nKeptEvents = events ? events->size() << 254 #endif
                                                   >> 255   const G4Run* run = runManager? runManager->GetCurrentRun(): 0;
                                                   >> 256   const std::vector<const G4Event*>* events = run? run->GetEventVector(): 0;
                                                   >> 257   size_t nKeptEvents = events? events->size(): 0;
320                                                   258 
321   if (!nKeptEvents) {                             259   if (!nKeptEvents) {
322     if (verbosity >= G4VisManager::errors) {      260     if (verbosity >= G4VisManager::errors) {
323       G4warn <<                                << 261       G4cerr <<
324   "ERROR: G4VisCommandReviewKeptEvents::SetNew    262   "ERROR: G4VisCommandReviewKeptEvents::SetNewValue: No kept events,"
325   "\n  or kept events not accessible."            263   "\n  or kept events not accessible."
326        << G4endl;                                 264        << G4endl;
327     }                                             265     }
328     return;                                       266     return;
329   }                                               267   }
330                                                   268 
331   G4VViewer* viewer = fpVisManager->GetCurrent    269   G4VViewer* viewer = fpVisManager->GetCurrentViewer();
332   if (!viewer) {                                  270   if (!viewer) {
333     if (verbosity >= G4VisManager::errors) {      271     if (verbosity >= G4VisManager::errors) {
334       G4warn <<                                << 272       G4cerr <<
335   "ERROR: No current viewer - \"/vis/viewer/li    273   "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
336              << G4endl;                           274              << G4endl;
337     }                                             275     }
338     return;                                       276     return;
339   }                                               277   }
340                                                   278 
341   G4Scene* pScene = fpVisManager->GetCurrentSc    279   G4Scene* pScene = fpVisManager->GetCurrentScene();
342   if (!pScene) {                                  280   if (!pScene) {
343     if (verbosity >= G4VisManager::errors) {      281     if (verbosity >= G4VisManager::errors) {
344       G4warn << "ERROR: No current scene.  Ple << 282       G4cerr << "ERROR: No current scene.  Please create one." << G4endl;
345     }                                             283     }
346     return;                                       284     return;
347   }                                               285   }
348                                                   286 
349   G4UImanager* UImanager = G4UImanager::GetUIp    287   G4UImanager* UImanager = G4UImanager::GetUIpointer();
350   G4int keepControlVerbose = UImanager->GetVer << 288   G4int keepVerbose = UImanager->GetVerboseLevel();
351   G4int newVerbose(0);                            289   G4int newVerbose(0);
352   if (keepControlVerbose >= 2 || verbosity >=  << 290   if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
353     newVerbose = 2;                               291     newVerbose = 2;
354   UImanager->SetVerboseLevel(newVerbose);         292   UImanager->SetVerboseLevel(newVerbose);
355                                                   293   
356   G4VVisManager* keepConcreteInstance = fpVisM    294   G4VVisManager* keepConcreteInstance = fpVisManager->GetConcreteInstance();
357   fpVisManager->Enable();                         295   fpVisManager->Enable();
358                                                << 296   
359   // Start on clean view                       << 
360   UImanager->ApplyCommand("/vis/viewer/rebuild << 
361                                                << 
362   // Event by event refreshing...                 297   // Event by event refreshing...
363   fpVisManager->SetReviewingKeptEvents(true);  << 298   reviewing  = true;
364   G4bool currentRefreshAtEndOfEvent = pScene->    299   G4bool currentRefreshAtEndOfEvent = pScene->GetRefreshAtEndOfEvent();
365   pScene->SetRefreshAtEndOfEvent(true);           300   pScene->SetRefreshAtEndOfEvent(true);
366   if (macroFileName.empty()) {                    301   if (macroFileName.empty()) {
367                                                   302 
368     // Draw to viewer and pause session...        303     // Draw to viewer and pause session...
369     G4UIsession* session = UImanager->GetSessi    304     G4UIsession* session = UImanager->GetSession();
370     for (size_t i = 0; i < nKeptEvents; ++i) {    305     for (size_t i = 0; i < nKeptEvents; ++i) {
371       const G4Event* event = (*events)[i];        306       const G4Event* event = (*events)[i];
372       if (verbosity >= G4VisManager::warnings)    307       if (verbosity >= G4VisManager::warnings) {
373   G4warn << "Drawing event : " << event->GetEv << 308   G4cout << "Drawing event : " << event->GetEventID() <<
374     ".  At EndOfEvent, enter any command, then    309     ".  At EndOfEvent, enter any command, then \"cont[inue]\"..."
375          << G4endl;                               310          << G4endl;
376   static G4bool first = true;                     311   static G4bool first = true;
377   if (first) {                                    312   if (first) {
378     first = false;                                313     first = false;
379     G4warn <<                                  << 314     G4cout <<
380   "  Useful commands might be:"                   315   "  Useful commands might be:"
381   "\n    \"/vis/scene/add/trajectories\" if no    316   "\n    \"/vis/scene/add/trajectories\" if not already added."
382   "\n    \"/vis/viewer/...\" to change the vie    317   "\n    \"/vis/viewer/...\" to change the view (zoom, set/viewpoint,...)."
383   "\n    \"/vis/ogl/export\" to get hard copy. << 318   "\n    \"/vis/oglx/printEPS\" to get hard copy."
384   "\n    \"/vis/open\" to get alternative view    319   "\n    \"/vis/open\" to get alternative viewer."
385   "\n    \"/vis/abortReviewKeptEvents\", then     320   "\n    \"/vis/abortReviewKeptEvents\", then \"cont[inue]\", to abort."
386      << G4endl;                                   321      << G4endl;
387   }                                               322   }
388       }                                           323       }
389       fpVisManager->SetRequestedEvent(event);     324       fpVisManager->SetRequestedEvent(event);
390       UImanager->ApplyCommand("/vis/viewer/reb    325       UImanager->ApplyCommand("/vis/viewer/rebuild");
391       /* The above command forces a rebuild of    326       /* The above command forces a rebuild of the scene, including
392    the detector.  This is fine for "immediate"    327    the detector.  This is fine for "immediate" viewers - a
393    refresh requires a rebuild anyway.  But for    328    refresh requires a rebuild anyway.  But for "stored mode"
394    viewers, you could, in principle, avoid a r    329    viewers, you could, in principle, avoid a rebuild of the
395    detector with something like the following:    330    detector with something like the following:
396       sceneHandler->ClearTransientStore();        331       sceneHandler->ClearTransientStore();
397       viewer->DrawView();                         332       viewer->DrawView();
398       sceneHandler->DrawEvent(event);             333       sceneHandler->DrawEvent(event);
399          but this causes mayhem for "immediate    334          but this causes mayhem for "immediate" viewers because
400          ClearTransientStore issues a DrawView    335          ClearTransientStore issues a DrawView and some curious sort
401          of recursion takes place.  For "store    336          of recursion takes place.  For "stored" viewers, the event
402          gets drawn but not the eventID, so so    337          gets drawn but not the eventID, so something odd is happening
403          there too.  This needs further invest    338          there too.  This needs further investigation - enhanced
404          features or a complete re-think.         339          features or a complete re-think.
405       */                                          340       */
406       UImanager->ApplyCommand("/vis/viewer/flu    341       UImanager->ApplyCommand("/vis/viewer/flush");
407       session->PauseSessionStart("EndOfEvent")    342       session->PauseSessionStart("EndOfEvent");
408       fpVisManager->SetRequestedEvent(0);         343       fpVisManager->SetRequestedEvent(0);
409       if (fpVisManager->GetAbortReviewKeptEven    344       if (fpVisManager->GetAbortReviewKeptEvents()) break;
410     }                                             345     }
411     fpVisManager->SetAbortReviewKeptEvents(fal    346     fpVisManager->SetAbortReviewKeptEvents(false);
412                                                   347 
413   } else {                                        348   } else {
414                                                   349 
415     // Execute macro file...                      350     // Execute macro file...
416     for (size_t i = 0; i < nKeptEvents; ++i) {    351     for (size_t i = 0; i < nKeptEvents; ++i) {
417       const G4Event* event = (*events)[i];        352       const G4Event* event = (*events)[i];
418       if (verbosity >= G4VisManager::warnings)    353       if (verbosity >= G4VisManager::warnings) {
419   G4warn << "Drawing event : " << event->GetEv << 354   G4cout << "Drawing event : " << event->GetEventID()
420          << " with macro file \"" << macroFile    355          << " with macro file \"" << macroFileName << G4endl;
421       }                                           356       }
422       fpVisManager->SetRequestedEvent(event);     357       fpVisManager->SetRequestedEvent(event);
423       UImanager->ApplyCommand("/control/execut    358       UImanager->ApplyCommand("/control/execute " + macroFileName);
424       fpVisManager->SetRequestedEvent(0);         359       fpVisManager->SetRequestedEvent(0);
425     }                                             360     }
426   }                                               361   }
427   pScene->SetRefreshAtEndOfEvent(currentRefres    362   pScene->SetRefreshAtEndOfEvent(currentRefreshAtEndOfEvent);
428   fpVisManager->SetReviewingKeptEvents(false); << 363   reviewing  = false;
429                                                   364 
430   if (keepConcreteInstance) fpVisManager->Enab    365   if (keepConcreteInstance) fpVisManager->Enable();
431   else fpVisManager->Disable();                   366   else fpVisManager->Disable();
432   UImanager->SetVerboseLevel(keepControlVerbos << 367   UImanager->SetVerboseLevel(keepVerbose);
433 }                                              << 
434                                                << 
435 ////////////// /vis/reviewPlots ////////////// << 
436                                                << 
437 G4VisCommandReviewPlots::G4VisCommandReviewPlo << 
438 {                                              << 
439   fpCommand = new G4UIcmdWithoutParameter("/vi << 
440   fpCommand -> SetGuidance("Review plots.");   << 
441   fpCommand -> SetGuidance                     << 
442   ("Each plot is drawn, one by one, to the cur << 
443    "\nplot the session is paused.  The user ma << 
444    "\nThen enter \"cont[inue]\" to continue to << 
445    "\nUseful commands might be:"               << 
446    "\n  \"/vis/tsg/export\" to get hard copy." << 
447    "\n  \"/vis/abortReviewPlots\", then \"cont << 
448 }                                              << 
449                                                << 
450 G4VisCommandReviewPlots::~G4VisCommandReviewPl << 
451 {                                              << 
452   delete fpCommand;                            << 
453 }                                              << 
454                                                << 
455 G4String G4VisCommandReviewPlots::GetCurrentVa << 
456 {                                              << 
457   return "";                                   << 
458 }                                              << 
459                                                << 
460 #include <tools/histo/h1d>                     << 
461 #include <tools/histo/h2d>                     << 
462                                                << 
463 namespace {                                    << 
464   template <typename HT>  // tools::histo::h1d << 
465   G4bool ReviewPlots(const G4String& plotType) << 
466     auto visManager = G4VisManager::GetInstanc << 
467     auto ui = G4UImanager::GetUIpointer();     << 
468     auto session = ui->GetSession();           << 
469     G4bool aborting = false;                   << 
470     auto keepControlVerbose = ui->GetVerboseLe << 
471     ui->SetVerboseLevel(0);                    << 
472     auto status = ui->ApplyCommand("/analysis/ << 
473     ui->SetVerboseLevel(keepControlVerbose);   << 
474     if(status==G4UIcommandStatus::fCommandSucc << 
475       G4String hexString = ui->GetCurrentValue << 
476       if(hexString.size()) {                   << 
477         void* ptr;                             << 
478         std::istringstream is(hexString);      << 
479         is >> ptr;                             << 
480         auto _v = (const std::vector<HT*>*)ptr << 
481         auto _n = _v->size();                  << 
482         for (size_t i = 0; i < _n; ++i) {      << 
483           //  Draw then pause session...       << 
484           std::ostringstream oss;              << 
485           oss << "/vis/plot " << plotType << ' << 
486           ui->ApplyCommand(oss.str());         << 
487           session->PauseSessionStart("EndOfEve << 
488           if (visManager->GetAbortReviewPlots( << 
489             aborting = true;                   << 
490             break;                             << 
491           }                                    << 
492         }                                      << 
493       }                                        << 
494     }                                          << 
495     return aborting;                           << 
496   }                                            << 
497 }                                              << 
498                                                << 
499 void G4VisCommandReviewPlots::SetNewValue (G4U << 
500 {                                              << 
501   if (fpVisManager->GetReviewingPlots()) {     << 
502     G4warn <<                                  << 
503     "\"/vis/reviewPlots\" not allowed within a << 
504     "\n  No action taken."                     << 
505     << G4endl;                                 << 
506     return;                                    << 
507   }                                            << 
508                                                << 
509   auto verbosity = fpVisManager->GetVerbosity( << 
510                                                << 
511   auto currentViewer = fpVisManager->GetCurren << 
512   if (!currentViewer) {                        << 
513     if (verbosity >= G4VisManager::errors) {   << 
514       G4warn <<                                << 
515       "ERROR: No current viewer - \"/vis/viewe << 
516       << G4endl;                               << 
517     }                                          << 
518     return;                                    << 
519   }                                            << 
520                                                << 
521   if (currentViewer->GetName().find("TOOLSSG") << 
522     G4warn <<                                  << 
523     "WARNING: Current viewer not able to draw  << 
524     "\n  Try \"/vis/open TSG\", then \"/vis/re << 
525     << G4endl;                                 << 
526     return;                                    << 
527   }                                            << 
528                                                << 
529   G4Scene* pScene = fpVisManager->GetCurrentSc << 
530   if (!pScene) {                               << 
531     if (verbosity >= G4VisManager::errors) {   << 
532       G4warn << "ERROR: No current scene.  Ple << 
533     }                                          << 
534     return;                                    << 
535   }                                            << 
536                                                << 
537   auto ui = G4UImanager::GetUIpointer();       << 
538                                                << 
539   auto keepControlVerbose = ui->GetVerboseLeve << 
540   ui->SetVerboseLevel(0);                      << 
541   auto keepVisVerbose = fpVisManager->GetVerbo << 
542   fpVisManager->SetVerboseLevel(G4VisManager:: << 
543   auto keepEnable = fpVisManager->IsEnabled(); << 
544   fpVisManager->Enable();                      << 
545   fpVisManager->SetReviewingPlots(true);       << 
546                                                << 
547   if (ReviewPlots<tools::histo::h1d>("h1")) go << 
548   if (ReviewPlots<tools::histo::h2d>("h2")) go << 
549                                                << 
550 finish:                                        << 
551   fpVisManager->SetReviewingPlots(false);      << 
552   if (!keepEnable) fpVisManager->Disable();    << 
553   fpVisManager->SetVerboseLevel(keepVisVerbose << 
554   ui->SetVerboseLevel(keepControlVerbose);     << 
555 }                                                 368 }
556                                                   369 
557 ////////////// /vis/verbose //////////////////    370 ////////////// /vis/verbose ///////////////////////////////////////
558                                                   371 
559 G4VisCommandVerbose::G4VisCommandVerbose () {     372 G4VisCommandVerbose::G4VisCommandVerbose () {
560   G4bool omitable;                                373   G4bool omitable;
561                                                   374 
562   fpCommand = new G4UIcmdWithAString("/vis/ver    375   fpCommand = new G4UIcmdWithAString("/vis/verbose", this);
563   for (size_t i = 0; i < G4VisManager::Verbosi    376   for (size_t i = 0; i < G4VisManager::VerbosityGuidanceStrings.size(); ++i) {
564     fpCommand -> SetGuidance(G4VisManager::Ver    377     fpCommand -> SetGuidance(G4VisManager::VerbosityGuidanceStrings[i]);
565   }                                               378   }
566   fpCommand -> SetParameterName("verbosity", o    379   fpCommand -> SetParameterName("verbosity", omitable=true);
567   fpCommand -> SetDefaultValue("");            << 380   fpCommand -> SetDefaultValue("warnings");
568 }                                                 381 }
569                                                   382 
570 G4VisCommandVerbose::~G4VisCommandVerbose () {    383 G4VisCommandVerbose::~G4VisCommandVerbose () {
571   delete fpCommand;                               384   delete fpCommand;
572 }                                                 385 }
573                                                   386 
574 G4String G4VisCommandVerbose::GetCurrentValue     387 G4String G4VisCommandVerbose::GetCurrentValue (G4UIcommand*) {
575   return G4String();                              388   return G4String();
576 }                                                 389 }
577                                                   390 
578 void G4VisCommandVerbose::SetNewValue (G4UIcom    391 void G4VisCommandVerbose::SetNewValue (G4UIcommand*,
579                G4String newValue) {               392                G4String newValue) {
580   G4VisManager::Verbosity verbosity =             393   G4VisManager::Verbosity verbosity =
581     fpVisManager->GetVerbosityValue(newValue);    394     fpVisManager->GetVerbosityValue(newValue);
582   fpVisManager->SetVerboseLevel(verbosity);       395   fpVisManager->SetVerboseLevel(verbosity);
583   // Always prints whatever the verbosity...      396   // Always prints whatever the verbosity...
584   G4cout << "Visualization verbosity is now "  << 397   G4cout << "Visualization verbosity changed to "
585    << G4VisManager::VerbosityString(verbosity)    398    << G4VisManager::VerbosityString(verbosity) << G4endl;
586 }                                                 399 }
587                                                   400