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 9.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,v 1.22 2007/03/27 15:47:32 allison Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-01-patch-01 $
 27                                                    29 
 28 // /vis/ top level commands - John Allison  5t     30 // /vis/ top level commands - John Allison  5th February 2001
 29                                                    31 
 30 #include "G4VisCommands.hh"                        32 #include "G4VisCommands.hh"
 31                                                    33 
 32 #include "G4VisManager.hh"                         34 #include "G4VisManager.hh"
 33 #include "G4UImanager.hh"                          35 #include "G4UImanager.hh"
 34 #include "G4UIcmdWithABool.hh"                     36 #include "G4UIcmdWithABool.hh"
 35 #include "G4UIcmdWithAString.hh"                   37 #include "G4UIcmdWithAString.hh"
 36 #include "G4UIcmdWithoutParameter.hh"              38 #include "G4UIcmdWithoutParameter.hh"
 37 #include "G4RunManager.hh"                         39 #include "G4RunManager.hh"
 38 #include "G4RunManagerFactory.hh"              << 
 39 #include "G4Run.hh"                                40 #include "G4Run.hh"
 40 #include "G4UIsession.hh"                          41 #include "G4UIsession.hh"
 41 #include "G4Trajectory.hh"                     << 
 42 #include "G4TrajectoryPoint.hh"                << 
 43 #include "G4RichTrajectory.hh"                 << 
 44 #include "G4RichTrajectoryPoint.hh"            << 
 45 #include "G4SmoothTrajectory.hh"               << 
 46 #include "G4SmoothTrajectoryPoint.hh"          << 
 47 #include "G4PhysicalVolumeModel.hh"            << 
 48 #include "G4AttDef.hh"                         << 
 49                                                << 
 50 #define G4warn G4cout                          << 
 51                                                    42 
 52 ////////////// /vis/abortReviewKeptEvents ////     43 ////////////// /vis/abortReviewKeptEvents /////////////////////////////
 53                                                    44 
 54 G4VisCommandAbortReviewKeptEvents::G4VisComman     45 G4VisCommandAbortReviewKeptEvents::G4VisCommandAbortReviewKeptEvents () {
 55   G4bool omitable;                                 46   G4bool omitable;
 56                                                    47 
 57   fpCommand = new G4UIcmdWithABool("/vis/abort     48   fpCommand = new G4UIcmdWithABool("/vis/abortReviewKeptEvents", this);
 58   fpCommand -> SetGuidance("Abort review of ke     49   fpCommand -> SetGuidance("Abort review of kept events.");
 59   fpCommand -> SetParameterName("abort", omita     50   fpCommand -> SetParameterName("abort", omitable=true);
 60   fpCommand -> SetDefaultValue(true);              51   fpCommand -> SetDefaultValue(true);
 61 }                                                  52 }
 62                                                    53 
 63 G4VisCommandAbortReviewKeptEvents::~G4VisComma     54 G4VisCommandAbortReviewKeptEvents::~G4VisCommandAbortReviewKeptEvents () {
 64   delete fpCommand;                                55   delete fpCommand;
 65 }                                                  56 }
 66                                                    57 
 67 G4String G4VisCommandAbortReviewKeptEvents::Ge     58 G4String G4VisCommandAbortReviewKeptEvents::GetCurrentValue (G4UIcommand*) {
 68   return G4String();                               59   return G4String();
 69 }                                                  60 }
 70                                                    61 
 71 void G4VisCommandAbortReviewKeptEvents::SetNew     62 void G4VisCommandAbortReviewKeptEvents::SetNewValue (G4UIcommand*,
 72                                                <<  63                  G4String newValue) {
 73   fpVisManager->SetAbortReviewKeptEvents(G4UIc     64   fpVisManager->SetAbortReviewKeptEvents(G4UIcommand::ConvertToBool(newValue));
 74   G4warn << "Type \"continue\" to complete the <<  65   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 }                                                  66 }
142                                                    67 
143 ////////////// /vis/enable ///////////////////     68 ////////////// /vis/enable ///////////////////////////////////////
144                                                    69 
145 G4VisCommandEnable::G4VisCommandEnable () {        70 G4VisCommandEnable::G4VisCommandEnable () {
146   G4bool omitable;                                 71   G4bool omitable;
147                                                    72 
148   fpCommand = new G4UIcmdWithABool("/vis/enabl     73   fpCommand = new G4UIcmdWithABool("/vis/enable", this);
149   fpCommand -> SetGuidance("Enables/disables v     74   fpCommand -> SetGuidance("Enables/disables visualization system.");
150   fpCommand -> SetParameterName("enabled", omi     75   fpCommand -> SetParameterName("enabled", omitable=true);
151   fpCommand -> SetDefaultValue(true);              76   fpCommand -> SetDefaultValue(true);
152                                                    77 
153   fpCommand1 = new G4UIcmdWithoutParameter("/v     78   fpCommand1 = new G4UIcmdWithoutParameter("/vis/disable", this);
154   fpCommand1 -> SetGuidance("Disables visualiz     79   fpCommand1 -> SetGuidance("Disables visualization system.");
155 }                                                  80 }
156                                                    81 
157 G4VisCommandEnable::~G4VisCommandEnable () {       82 G4VisCommandEnable::~G4VisCommandEnable () {
158   delete fpCommand;                                83   delete fpCommand;
159   delete fpCommand1;                               84   delete fpCommand1;
160 }                                                  85 }
161                                                    86 
162 G4String G4VisCommandEnable::GetCurrentValue (     87 G4String G4VisCommandEnable::GetCurrentValue (G4UIcommand*) {
163   return G4String();                               88   return G4String();
164 }                                                  89 }
165                                                    90 
166 void G4VisCommandEnable::SetNewValue (G4UIcomm     91 void G4VisCommandEnable::SetNewValue (G4UIcommand* command,
167               G4String newValue) {                 92               G4String newValue) {
168   if (command == fpCommand) {                      93   if (command == fpCommand) {
169     G4bool enable = G4UIcommand::ConvertToBool     94     G4bool enable = G4UIcommand::ConvertToBool(newValue);
170     if (enable) fpVisManager->Enable();  // Pr     95     if (enable) fpVisManager->Enable();  // Printing is in vis manager.
171     else fpVisManager->Disable();        // Pr     96     else fpVisManager->Disable();        // Printing is in vis manager.
172   } else fpVisManager->Disable();        // Pr     97   } else fpVisManager->Disable();        // Printing is in vis manager.
173   // Note: Printing is in vis manager.             98   // Note: Printing is in vis manager.
174 }                                                  99 }
175                                                   100 
176 ////////////// /vis/initialize /////////////// << 
177                                                << 
178 G4VisCommandInitialize::G4VisCommandInitialize << 
179 {                                              << 
180   fpCommand = new G4UIcmdWithoutParameter("/vi << 
181   fpCommand -> SetGuidance("Initialise visuali << 
182 }                                              << 
183                                                << 
184 G4VisCommandInitialize::~G4VisCommandInitializ << 
185   delete fpCommand;                            << 
186 }                                              << 
187                                                << 
188 void G4VisCommandInitialize::SetNewValue (G4UI << 
189             G4String) {                        << 
190   fpVisManager->Initialize();                  << 
191 }                                              << 
192                                                << 
193 ////////////// /vis/list /////////////////////    101 ////////////// /vis/list ///////////////////////////////////////
194                                                   102 
195 G4VisCommandList::G4VisCommandList ()             103 G4VisCommandList::G4VisCommandList ()
196 {                                                 104 {
197   G4bool omitable;                                105   G4bool omitable;
198                                                   106 
199   fpCommand = new G4UIcmdWithAString("/vis/lis    107   fpCommand = new G4UIcmdWithAString("/vis/list", this);
200   fpCommand -> SetGuidance("Lists visualizatio    108   fpCommand -> SetGuidance("Lists visualization parameters.");
201   fpCommand -> SetParameterName("verbosity", o    109   fpCommand -> SetParameterName("verbosity", omitable=true);
202   fpCommand -> SetDefaultValue("warnings");       110   fpCommand -> SetDefaultValue("warnings");
203 }                                                 111 }
204                                                   112 
205 G4VisCommandList::~G4VisCommandList ()            113 G4VisCommandList::~G4VisCommandList ()
206 {                                                 114 {
207   delete fpCommand;                               115   delete fpCommand;
208 }                                                 116 }
209                                                   117 
210 G4String G4VisCommandList::GetCurrentValue (G4    118 G4String G4VisCommandList::GetCurrentValue (G4UIcommand*)
211 {                                                 119 {
212   return "";                                      120   return "";
213 }                                                 121 }
214                                                   122 
215 void G4VisCommandList::SetNewValue (G4UIcomman    123 void G4VisCommandList::SetNewValue (G4UIcommand*, G4String newValue)
216 {                                                 124 {
217   G4VisManager::Verbosity verbosity = fpVisMan << 125   G4String& verbosityString = newValue;
                                                   >> 126   G4VisManager::Verbosity verbosity =
                                                   >> 127     fpVisManager->GetVerbosityValue(verbosityString);
218                                                   128 
219   G4VisManager::PrintAvailableVerbosity(G4cout << 129   fpVisManager->PrintAvailableGraphicsSystems();
220   G4cout << G4endl;                            << 
221   fpVisManager->PrintAvailableGraphicsSystems( << 
222   G4cout << G4endl;                               130   G4cout << G4endl;
223   fpVisManager->PrintAvailableModels(verbosity    131   fpVisManager->PrintAvailableModels(verbosity);
224   G4cout << G4endl;                               132   G4cout << G4endl;
225   fpVisManager->PrintAvailableUserVisActions(v << 
226   G4cout << G4endl;                            << 
227   fpVisManager->PrintAvailableColours(verbosit << 
228   G4cout << G4endl;                            << 
229   G4UImanager* UImanager = G4UImanager::GetUIp    133   G4UImanager* UImanager = G4UImanager::GetUIpointer();
230   UImanager->ApplyCommand("/vis/scene/list ! " << 134   UImanager->ApplyCommand(G4String("/vis/viewer/list ! ") + verbosityString);
231   G4cout << G4endl;                            << 
232   UImanager->ApplyCommand("/vis/viewer/list !  << 
233                                                << 
234   G4cout <<                                    << 
235   "\nAttributes available for modeling and fil << 
236   "\n  \"/vis/modeling/trajectories/create/dra << 
237   "\n  \"/vis/filtering/trajectories/create/at << 
238   "\nand by picking:"                          << 
239   << G4endl;                                   << 
240   G4cout                                       << 
241   << *G4TrajectoriesModel().GetAttDefs();      << 
242   G4cout                                       << 
243   << *G4RichTrajectory().GetAttDefs()          << 
244   << *G4RichTrajectoryPoint().GetAttDefs();    << 
245   G4cout                                       << 
246   << *G4SmoothTrajectory().GetAttDefs()        << 
247   << *G4SmoothTrajectoryPoint().GetAttDefs();  << 
248   G4cout                                       << 
249   << *G4Trajectory().GetAttDefs()              << 
250   << *G4TrajectoryPoint().GetAttDefs();        << 
251                                                << 
252   G4cout <<                                    << 
253   "\nGeometry attributes available for touchab << 
254   G4cout                                       << 
255   << *G4PhysicalVolumeModel().GetAttDefs();    << 
256                                                << 
257   if (verbosity < G4VisManager::parameters)       135   if (verbosity < G4VisManager::parameters)
258     G4cout <<                                     136     G4cout <<
259   "\nTo get more information, \"/vis/list all\ << 137   "\nTo get more information, \"/vis/list all all\" or use individual commands"
260   "\n  such as (use \"ls\" or \"help\"):"         138   "\n  such as (use \"ls\" or \"help\"):"
261   "\n    /vis/scene/list all all"              << 139   "\n    /vis/viewer/list"
262   "\n    /vis/viewer/list all all"             << 
263   "\n    /vis/modeling/trajectories/list"         140   "\n    /vis/modeling/trajectories/list"
264   "\n    /vis/filtering/trajectories/list"        141   "\n    /vis/filtering/trajectories/list"
265      << G4endl;                                   142      << G4endl;
266 }                                                 143 }
267                                                   144 
268 ////////////// /vis/reviewKeptEvents /////////    145 ////////////// /vis/reviewKeptEvents ///////////////////////////////////////
269                                                   146 
270 G4VisCommandReviewKeptEvents::G4VisCommandRevi    147 G4VisCommandReviewKeptEvents::G4VisCommandReviewKeptEvents ()
271 {                                                 148 {
272   G4bool omitable;                                149   G4bool omitable;
273                                                   150 
274   fpCommand = new G4UIcmdWithAString("/vis/rev    151   fpCommand = new G4UIcmdWithAString("/vis/reviewKeptEvents", this);
275   fpCommand -> SetGuidance("Review kept events    152   fpCommand -> SetGuidance("Review kept events.");
276   fpCommand -> SetGuidance                        153   fpCommand -> SetGuidance
277     ("If a macro file is specified, it is exec    154     ("If a macro file is specified, it is executed for each event.");
278   fpCommand -> SetGuidance(                       155   fpCommand -> SetGuidance(
279   "If a macro file is not specified, each even    156   "If a macro file is not specified, each event is drawn to the current"
280   "\nviewer.  After each event, the session is    157   "\nviewer.  After each event, the session is paused.  The user may issue"
281   "\nany allowed command.  Then enter \"cont[i    158   "\nany allowed command.  Then enter \"cont[inue]\" to continue to the next"
282   "\nevent."                                      159   "\nevent."
283   "\nUseful commands might be:"                   160   "\nUseful commands might be:"
284   "\n  \"/vis/viewer/...\" to change the view     161   "\n  \"/vis/viewer/...\" to change the view (zoom, set/viewpoint,...)."
285   "\n  \"/vis/ogl/export\" to get hard copy."  << 162   "\n  \"/vis/oglx/printEPS\" to get hard copy."
286   "\n  \"/vis/open\" to get alternative viewer    163   "\n  \"/vis/open\" to get alternative viewer."
287   "\n  \"/vis/abortReviewKeptEvents\", then \"    164   "\n  \"/vis/abortReviewKeptEvents\", then \"cont[inue]\", to abort.");
288   fpCommand -> SetParameterName("macro-file-na    165   fpCommand -> SetParameterName("macro-file-name", omitable=true);
289   fpCommand -> SetDefaultValue("");               166   fpCommand -> SetDefaultValue("");
290 }                                                 167 }
291                                                   168 
292 G4VisCommandReviewKeptEvents::~G4VisCommandRev    169 G4VisCommandReviewKeptEvents::~G4VisCommandReviewKeptEvents ()
293 {                                                 170 {
294   delete fpCommand;                               171   delete fpCommand;
295 }                                                 172 }
296                                                   173 
297 G4String G4VisCommandReviewKeptEvents::GetCurr    174 G4String G4VisCommandReviewKeptEvents::GetCurrentValue (G4UIcommand*)
298 {                                                 175 {
299   return "";                                      176   return "";
300 }                                                 177 }
301                                                   178 
302 void G4VisCommandReviewKeptEvents::SetNewValue    179 void G4VisCommandReviewKeptEvents::SetNewValue (G4UIcommand*, G4String newValue)
303 {                                                 180 {
304   if (fpVisManager->GetReviewingKeptEvents())  << 
305     G4warn <<                                  << 
306       "\"/vis/reviewKeptEvents\" not allowed w << 
307       "\n  No action taken."                   << 
308      << G4endl;                                << 
309     return;                                    << 
310   }                                            << 
311                                                << 
312   G4String& macroFileName = newValue;             181   G4String& macroFileName = newValue;
313   G4VisManager::Verbosity verbosity = fpVisMan    182   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
314                                                   183 
315   G4RunManager* runManager = G4RunManagerFacto << 184   G4RunManager* runManager = G4RunManager::GetRunManager();
316   const G4Run* run         = runManager ? runM << 185   const G4Run* run = runManager? runManager->GetCurrentRun(): 0;
317   const std::vector<const G4Event*>* events =  << 186   const std::vector<const G4Event*>* events = run? run->GetEventVector(): 0;
318     run ? run->GetEventVector() : nullptr;     << 187   size_t nKeptEvents = events? events->size(): 0;
319   size_t nKeptEvents = events ? events->size() << 
320                                                   188 
321   if (!nKeptEvents) {                             189   if (!nKeptEvents) {
322     if (verbosity >= G4VisManager::errors) {      190     if (verbosity >= G4VisManager::errors) {
323       G4warn <<                                << 191       G4cout <<
324   "ERROR: G4VisCommandReviewKeptEvents::SetNew    192   "ERROR: G4VisCommandReviewKeptEvents::SetNewValue: No kept events,"
325   "\n  or kept events not accessible."            193   "\n  or kept events not accessible."
326        << G4endl;                                 194        << G4endl;
327     }                                             195     }
328     return;                                       196     return;
329   }                                               197   }
330                                                   198 
331   G4VViewer* viewer = fpVisManager->GetCurrent    199   G4VViewer* viewer = fpVisManager->GetCurrentViewer();
332   if (!viewer) {                                  200   if (!viewer) {
333     if (verbosity >= G4VisManager::errors) {      201     if (verbosity >= G4VisManager::errors) {
334       G4warn <<                                << 202       G4cout <<
335   "ERROR: No current viewer - \"/vis/viewer/li    203   "ERROR: No current viewer - \"/vis/viewer/list\" to see possibilities."
336              << G4endl;                           204              << G4endl;
337     }                                             205     }
338     return;                                       206     return;
339   }                                               207   }
340                                                   208 
341   G4Scene* pScene = fpVisManager->GetCurrentSc    209   G4Scene* pScene = fpVisManager->GetCurrentScene();
342   if (!pScene) {                                  210   if (!pScene) {
343     if (verbosity >= G4VisManager::errors) {      211     if (verbosity >= G4VisManager::errors) {
344       G4warn << "ERROR: No current scene.  Ple << 212       G4cout << "ERROR: No current scene.  Please create one." << G4endl;
345     }                                             213     }
346     return;                                       214     return;
347   }                                               215   }
348                                                   216 
349   G4UImanager* UImanager = G4UImanager::GetUIp    217   G4UImanager* UImanager = G4UImanager::GetUIpointer();
350   G4int keepControlVerbose = UImanager->GetVer << 218   G4int keepVerbose = UImanager->GetVerboseLevel();
351   G4int newVerbose(0);                            219   G4int newVerbose(0);
352   if (keepControlVerbose >= 2 || verbosity >=  << 220   if (keepVerbose >= 2 || verbosity >= G4VisManager::confirmations)
353     newVerbose = 2;                               221     newVerbose = 2;
354   UImanager->SetVerboseLevel(newVerbose);         222   UImanager->SetVerboseLevel(newVerbose);
355                                                << 
356   G4VVisManager* keepConcreteInstance = fpVisM << 
357   fpVisManager->Enable();                      << 
358                                                << 
359   // Start on clean view                       << 
360   UImanager->ApplyCommand("/vis/viewer/rebuild << 
361                                                   223 
362   // Event by event refreshing...                 224   // Event by event refreshing...
363   fpVisManager->SetReviewingKeptEvents(true);  << 
364   G4bool currentRefreshAtEndOfEvent = pScene->    225   G4bool currentRefreshAtEndOfEvent = pScene->GetRefreshAtEndOfEvent();
365   pScene->SetRefreshAtEndOfEvent(true);           226   pScene->SetRefreshAtEndOfEvent(true);
366   if (macroFileName.empty()) {                    227   if (macroFileName.empty()) {
367                                                   228 
368     // Draw to viewer and pause session...        229     // Draw to viewer and pause session...
369     G4UIsession* session = UImanager->GetSessi    230     G4UIsession* session = UImanager->GetSession();
370     for (size_t i = 0; i < nKeptEvents; ++i) {    231     for (size_t i = 0; i < nKeptEvents; ++i) {
371       const G4Event* event = (*events)[i];        232       const G4Event* event = (*events)[i];
372       if (verbosity >= G4VisManager::warnings)    233       if (verbosity >= G4VisManager::warnings) {
373   G4warn << "Drawing event : " << event->GetEv << 234   G4cout << "Drawing event : " << event->GetEventID() <<
374     ".  At EndOfEvent, enter any command, then    235     ".  At EndOfEvent, enter any command, then \"cont[inue]\"..."
375          << G4endl;                               236          << G4endl;
376   static G4bool first = true;                     237   static G4bool first = true;
377   if (first) {                                    238   if (first) {
378     first = false;                                239     first = false;
379     G4warn <<                                  << 240     G4cout <<
380   "  Useful commands might be:"                   241   "  Useful commands might be:"
381   "\n    \"/vis/scene/add/trajectories\" if no << 
382   "\n    \"/vis/viewer/...\" to change the vie    242   "\n    \"/vis/viewer/...\" to change the view (zoom, set/viewpoint,...)."
383   "\n    \"/vis/ogl/export\" to get hard copy. << 243   "\n    \"/vis/oglx/printEPS\" to get hard copy."
384   "\n    \"/vis/open\" to get alternative view    244   "\n    \"/vis/open\" to get alternative viewer."
385   "\n    \"/vis/abortReviewKeptEvents\", then     245   "\n    \"/vis/abortReviewKeptEvents\", then \"cont[inue]\", to abort."
386      << G4endl;                                   246      << G4endl;
387   }                                               247   }
388       }                                           248       }
389       fpVisManager->SetRequestedEvent(event);     249       fpVisManager->SetRequestedEvent(event);
390       UImanager->ApplyCommand("/vis/viewer/reb    250       UImanager->ApplyCommand("/vis/viewer/rebuild");
391       /* The above command forces a rebuild of    251       /* The above command forces a rebuild of the scene, including
392    the detector.  This is fine for "immediate"    252    the detector.  This is fine for "immediate" viewers - a
393    refresh requires a rebuild anyway.  But for    253    refresh requires a rebuild anyway.  But for "stored mode"
394    viewers, you could, in principle, avoid a r    254    viewers, you could, in principle, avoid a rebuild of the
395    detector with something like the following:    255    detector with something like the following:
396       sceneHandler->ClearTransientStore();        256       sceneHandler->ClearTransientStore();
397       viewer->DrawView();                         257       viewer->DrawView();
398       sceneHandler->DrawEvent(event);             258       sceneHandler->DrawEvent(event);
399          but this causes mayhem for "immediate    259          but this causes mayhem for "immediate" viewers because
400          ClearTransientStore issues a DrawView    260          ClearTransientStore issues a DrawView and some curious sort
401          of recursion takes place.  For "store    261          of recursion takes place.  For "stored" viewers, the event
402          gets drawn but not the eventID, so so    262          gets drawn but not the eventID, so something odd is happening
403          there too.  This needs further invest    263          there too.  This needs further investigation - enhanced
404          features or a complete re-think.         264          features or a complete re-think.
405       */                                          265       */
406       UImanager->ApplyCommand("/vis/viewer/flu    266       UImanager->ApplyCommand("/vis/viewer/flush");
407       session->PauseSessionStart("EndOfEvent")    267       session->PauseSessionStart("EndOfEvent");
408       fpVisManager->SetRequestedEvent(0);         268       fpVisManager->SetRequestedEvent(0);
409       if (fpVisManager->GetAbortReviewKeptEven    269       if (fpVisManager->GetAbortReviewKeptEvents()) break;
410     }                                             270     }
411     fpVisManager->SetAbortReviewKeptEvents(fal    271     fpVisManager->SetAbortReviewKeptEvents(false);
412                                                   272 
413   } else {                                        273   } else {
414                                                   274 
415     // Execute macro file...                      275     // Execute macro file...
416     for (size_t i = 0; i < nKeptEvents; ++i) {    276     for (size_t i = 0; i < nKeptEvents; ++i) {
417       const G4Event* event = (*events)[i];        277       const G4Event* event = (*events)[i];
418       if (verbosity >= G4VisManager::warnings)    278       if (verbosity >= G4VisManager::warnings) {
419   G4warn << "Drawing event : " << event->GetEv << 279   G4cout << "Drawing event : " << event->GetEventID()
420          << " with macro file \"" << macroFile    280          << " with macro file \"" << macroFileName << G4endl;
421       }                                           281       }
422       fpVisManager->SetRequestedEvent(event);     282       fpVisManager->SetRequestedEvent(event);
423       UImanager->ApplyCommand("/control/execut    283       UImanager->ApplyCommand("/control/execute " + macroFileName);
424       fpVisManager->SetRequestedEvent(0);         284       fpVisManager->SetRequestedEvent(0);
425     }                                             285     }
426   }                                               286   }
427   pScene->SetRefreshAtEndOfEvent(currentRefres    287   pScene->SetRefreshAtEndOfEvent(currentRefreshAtEndOfEvent);
428   fpVisManager->SetReviewingKeptEvents(false); << 
429                                                << 
430   if (keepConcreteInstance) fpVisManager->Enab << 
431   else fpVisManager->Disable();                << 
432   UImanager->SetVerboseLevel(keepControlVerbos << 
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                                                   288 
511   auto currentViewer = fpVisManager->GetCurren << 289   UImanager->SetVerboseLevel(keepVerbose);
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 }                                                 290 }
556                                                   291 
557 ////////////// /vis/verbose //////////////////    292 ////////////// /vis/verbose ///////////////////////////////////////
558                                                   293 
559 G4VisCommandVerbose::G4VisCommandVerbose () {     294 G4VisCommandVerbose::G4VisCommandVerbose () {
560   G4bool omitable;                                295   G4bool omitable;
561                                                   296 
562   fpCommand = new G4UIcmdWithAString("/vis/ver    297   fpCommand = new G4UIcmdWithAString("/vis/verbose", this);
563   for (size_t i = 0; i < G4VisManager::Verbosi    298   for (size_t i = 0; i < G4VisManager::VerbosityGuidanceStrings.size(); ++i) {
564     fpCommand -> SetGuidance(G4VisManager::Ver    299     fpCommand -> SetGuidance(G4VisManager::VerbosityGuidanceStrings[i]);
565   }                                               300   }
566   fpCommand -> SetParameterName("verbosity", o    301   fpCommand -> SetParameterName("verbosity", omitable=true);
567   fpCommand -> SetDefaultValue("");            << 302   fpCommand -> SetDefaultValue("warnings");
568 }                                                 303 }
569                                                   304 
570 G4VisCommandVerbose::~G4VisCommandVerbose () {    305 G4VisCommandVerbose::~G4VisCommandVerbose () {
571   delete fpCommand;                               306   delete fpCommand;
572 }                                                 307 }
573                                                   308 
574 G4String G4VisCommandVerbose::GetCurrentValue     309 G4String G4VisCommandVerbose::GetCurrentValue (G4UIcommand*) {
575   return G4String();                              310   return G4String();
576 }                                                 311 }
577                                                   312 
578 void G4VisCommandVerbose::SetNewValue (G4UIcom    313 void G4VisCommandVerbose::SetNewValue (G4UIcommand*,
579                G4String newValue) {               314                G4String newValue) {
580   G4VisManager::Verbosity verbosity =             315   G4VisManager::Verbosity verbosity =
581     fpVisManager->GetVerbosityValue(newValue);    316     fpVisManager->GetVerbosityValue(newValue);
582   fpVisManager->SetVerboseLevel(verbosity);       317   fpVisManager->SetVerboseLevel(verbosity);
583   // Always prints whatever the verbosity...      318   // Always prints whatever the verbosity...
584   G4cout << "Visualization verbosity is now "  << 319   G4cout << "Visualization verbosity changed to "
585    << G4VisManager::VerbosityString(verbosity)    320    << G4VisManager::VerbosityString(verbosity) << G4endl;
586 }                                                 321 }
587                                                   322