Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VisCommandsScene.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 ]

  1 //
  2 // ********************************************************************
  3 // * License and Disclaimer                                           *
  4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.                             *
 10 // *                                                                  *
 11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                                                  *
 18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // ********************************************************************
 25 //
 26 //
 27 
 28 // /vis/scene commands - John Allison  9th August 1998
 29 
 30 #include "G4VisCommandsScene.hh"
 31 
 32 #include "G4VisManager.hh"
 33 #include "G4TransportationManager.hh"
 34 #include "G4RunManager.hh"
 35 #include "G4RunManagerFactory.hh"
 36 #include "G4Run.hh"
 37 #include "G4PhysicalVolumeModel.hh"
 38 #include "G4ApplicationState.hh"
 39 #include "G4UImanager.hh"
 40 #include "G4UIcommand.hh"
 41 #include "G4UIcmdWithAString.hh"
 42 #include "G4UIcmdWithoutParameter.hh"
 43 #include "G4ios.hh"
 44 #include <sstream>
 45 
 46 #define G4warn G4cout
 47 
 48 G4VVisCommandScene::G4VVisCommandScene () {}
 49 
 50 G4VVisCommandScene::~G4VVisCommandScene () {}
 51 
 52 G4String G4VVisCommandScene::CurrentSceneName () {
 53   const G4Scene* pScene = fpVisManager -> GetCurrentScene ();
 54   G4String currentSceneName = "none";
 55   if (pScene) currentSceneName = pScene -> GetName ();
 56   return currentSceneName;
 57 }
 58 
 59 ////////////// /vis/scene/activateModel ////////////////////////////
 60 
 61 G4VisCommandSceneActivateModel::G4VisCommandSceneActivateModel () {
 62   G4bool omitable;
 63   fpCommand = new G4UIcommand ("/vis/scene/activateModel", this);
 64   fpCommand -> SetGuidance
 65     ("Activate or de-activate model.");
 66   fpCommand -> SetGuidance
 67     ("Attempts to match search string to name of model - use unique sub-string.");
 68   fpCommand -> SetGuidance
 69     ("Use \"/vis/scene/list\" to see model names.");
 70   fpCommand -> SetGuidance
 71     ("If name == \"all\" (default), all models are activated.");
 72   G4UIparameter* parameter;
 73   parameter = new G4UIparameter ("search-string", 's', omitable = true);
 74   parameter -> SetDefaultValue ("all");
 75   fpCommand -> SetParameter (parameter);
 76   parameter = new G4UIparameter ("activate", 'b', omitable = true);
 77   parameter -> SetDefaultValue (true);
 78   fpCommand -> SetParameter (parameter);
 79 }
 80 
 81 G4VisCommandSceneActivateModel::~G4VisCommandSceneActivateModel () {
 82   delete fpCommand;
 83 }
 84 
 85 G4String G4VisCommandSceneActivateModel::GetCurrentValue(G4UIcommand*) {
 86   return "";
 87 }
 88 
 89 void G4VisCommandSceneActivateModel::SetNewValue (G4UIcommand*,
 90                  G4String newValue) {
 91 
 92   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
 93 
 94   G4String searchString, activateString;
 95   std::istringstream is (newValue);
 96   // Need to handle the possibility that the search string
 97   // contains embedded blanks within quotation marks.
 98   // (This arises if the search string is automatically generated from the
 99   // global description, as in G4UIQt, clicking on check box.)
100   auto lastQuotationMark = newValue.find_last_of('"');
101   if (lastQuotationMark != std::string::npos) {  // We have at least one quotation mark
102     auto firstQuotationMark = newValue.find_first_of('"');
103     if (lastQuotationMark != firstQuotationMark) {  // We have at least two quotations marks
104       // Note: there must not be more quotation marks - it upsets the command system.
105       searchString = newValue.substr
106       (firstQuotationMark + 1, lastQuotationMark - firstQuotationMark - 1);
107       activateString = newValue.substr(lastQuotationMark + 2);
108       // Perhaps we ought to check number of quotation marks
109       G4int nQuotes = 0;
110       for (auto c : newValue) {
111         if (c == '"') nQuotes++;
112       }
113       if (nQuotes > 2) {
114         G4ExceptionDescription ed;
115         ed << "More than 2 quotation marks in search string: " << searchString;
116         G4Exception("G4VisCommandSceneActivateModel::SetNewValue", "visman0301", JustWarning, ed);
117       }
118     }
119   }
120   else {
121     // None or one quotation marks - just input two strings
122     is >> searchString >> activateString;
123   }
124   G4bool activate = G4UIcommand::ConvertToBool(activateString);
125 
126   G4Scene* pScene = fpVisManager->GetCurrentScene();
127   if (!pScene) {
128     if (verbosity >= G4VisManager::errors) {
129       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
130     }
131     return;
132   }
133 
134   G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
135   if (!pSceneHandler) {
136     if (verbosity >= G4VisManager::errors) {
137       G4warn << "ERROR: No current sceneHandler.  Please create one." << G4endl;
138     }
139     return;
140   }
141 
142   if (searchString == "all" && !activate) {
143     if (verbosity >= G4VisManager::warnings) {
144       G4warn <<
145   "WARNING: You are not allowed to de-activate all models."
146   "\n  Command ignored."
147        << G4endl;
148     }
149     return;
150   }
151 
152   G4bool any = false;
153 
154   std::vector<G4Scene::Model>& runDurationModelList =
155     pScene->SetRunDurationModelList();
156   for (size_t i = 0; i < runDurationModelList.size(); i++) {
157     const G4String& modelName = runDurationModelList[i].fpModel->GetGlobalDescription();
158     if (searchString == "all" || modelName.find(searchString) != std::string::npos) {
159       any = true;
160       runDurationModelList[i].fActive = activate;
161       if (verbosity >= G4VisManager::warnings) {
162   G4warn << "Model \"" << modelName;
163   if (activate) G4warn << "\" activated.";
164   else  G4warn << "\" de-activated.";
165   G4warn << G4endl;
166       }
167     }
168   }
169 
170   std::vector<G4Scene::Model>& endOfEventModelList =
171     pScene->SetEndOfEventModelList();
172   for (size_t i = 0; i < endOfEventModelList.size(); i++) {
173     const G4String& modelName = endOfEventModelList[i].fpModel->GetGlobalDescription();
174     if (searchString == "all" || modelName.find(searchString) != std::string::npos) {
175       any = true;
176       endOfEventModelList[i].fActive = activate;
177       if (verbosity >= G4VisManager::warnings) {
178   G4warn << "Model \"" << modelName;
179   if (activate) G4warn << "\" activated.";
180   else  G4warn << "\" de-activated.";
181   G4warn << G4endl;
182       }
183     }
184   }
185 
186   std::vector<G4Scene::Model>& endOfRunModelList =
187     pScene->SetEndOfRunModelList();
188   for (size_t i = 0; i < endOfRunModelList.size(); i++) {
189     const G4String& modelName = endOfRunModelList[i].fpModel->GetGlobalDescription();
190     if (searchString == "all" || modelName.find(searchString) != std::string::npos) {
191       any = true;
192       endOfRunModelList[i].fActive = activate;
193       if (verbosity >= G4VisManager::warnings) {
194   G4warn << "Model \"" << modelName;
195   if (activate) G4warn << "\" activated.";
196   else  G4warn << "\" de-activated.";
197   G4warn << G4endl;
198       }
199     }
200   }
201 
202   if (!any) {
203     if (verbosity >= G4VisManager::warnings) {
204       G4warn << "WARNING: No match found." << G4endl;
205     }
206     return;
207   }
208 
209   CheckSceneAndNotifyHandlers (pScene);
210 }
211 
212 ////////////// /vis/scene/create ///////////////////////////////////////
213 
214 G4VisCommandSceneCreate::G4VisCommandSceneCreate (): fId (0) {
215   G4bool omitable;
216   fpCommand = new G4UIcmdWithAString ("/vis/scene/create", this);
217   fpCommand -> SetGuidance
218     ("Creates an empty scene.");
219   fpCommand -> SetGuidance
220     ("Invents a name if not supplied.  This scene becomes current.");
221   fpCommand -> SetParameterName ("scene-name", omitable = true);
222 }
223 
224 G4VisCommandSceneCreate::~G4VisCommandSceneCreate () {
225   delete fpCommand;
226 }
227 
228 G4String G4VisCommandSceneCreate::NextName () {
229   std::ostringstream oss;
230   oss << "scene-" << fId;
231   return oss.str();
232 }
233 
234 G4String G4VisCommandSceneCreate::GetCurrentValue (G4UIcommand*) {
235   return "";
236 }
237 
238 void G4VisCommandSceneCreate::SetNewValue (G4UIcommand*, G4String newValue) {
239 
240   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
241 
242   G4String& newName = newValue;
243   G4String nextName = NextName ();
244 
245   if (newName == "") {
246     newName = nextName;
247   }
248   if (newName == nextName) fId++;
249 
250   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
251   std::size_t iScene, nScenes = sceneList.size ();
252   for (iScene = 0; iScene < nScenes; ++iScene) {
253     if (sceneList [iScene] -> GetName () == newName) break;
254   }
255   if (iScene < nScenes) {
256     if (verbosity >= G4VisManager::warnings) {
257       G4warn << "WARNING: Scene \"" << newName << "\" already exists."
258        << "\n  New scene not created."
259        << G4endl;
260     }
261   } else {
262 
263     // Add empty scene data object to list...
264     G4Scene* pScene = new G4Scene (newName);
265     sceneList.push_back (pScene);
266     fpVisManager -> SetCurrentScene (pScene);
267 
268     if (verbosity >= G4VisManager::confirmations) {
269       G4cout << "New empty scene \"" << newName << "\" created." << G4endl;
270     }
271   }
272 }
273 
274 ////////////// /vis/scene/endOfEventAction ////////////////////////////
275 
276 G4VisCommandSceneEndOfEventAction::G4VisCommandSceneEndOfEventAction () {
277   G4bool omitable;
278   fpCommand = new G4UIcommand ("/vis/scene/endOfEventAction", this);
279   fpCommand -> SetGuidance
280     ("Accumulate or refresh the viewer for each new event.");
281   fpCommand -> SetGuidance
282     ("\"accumulate\": viewer accumulates hits, etc., event by event, or");
283   fpCommand -> SetGuidance
284     ("\"refresh\": viewer shows them at end of event or, for direct-screen"
285      "\n  viewers, refreshes the screen just before drawing the next event.");
286   G4UIparameter* parameter;
287   parameter = new G4UIparameter ("action", 's', omitable = true);
288   parameter -> SetParameterCandidates ("accumulate refresh");
289   parameter -> SetDefaultValue ("refresh");
290   fpCommand -> SetParameter (parameter);
291   parameter = new G4UIparameter ("maxNumber", 'i', omitable = true);
292   parameter -> SetDefaultValue (100);
293   parameter -> SetGuidance
294   ("Maximum number of events kept.  Unlimited if negative.");
295   fpCommand -> SetParameter (parameter);
296 }
297 
298 G4VisCommandSceneEndOfEventAction::~G4VisCommandSceneEndOfEventAction () {
299   delete fpCommand;
300 }
301 
302 G4String G4VisCommandSceneEndOfEventAction::GetCurrentValue(G4UIcommand*) {
303   return "";
304 }
305 
306 void G4VisCommandSceneEndOfEventAction::SetNewValue (G4UIcommand*,
307                  G4String newValue) {
308 
309   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
310 
311   G4String action;
312   G4int maxNumberOfKeptEvents;
313   std::istringstream is (newValue);
314   is >> action >> maxNumberOfKeptEvents;
315 
316   G4Scene* pScene = fpVisManager->GetCurrentScene();
317   if (!pScene) {
318     if (verbosity >= G4VisManager::errors) {
319       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
320     }
321     return;
322   }
323 
324   G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
325   if (!pSceneHandler) {
326     if (verbosity >= G4VisManager::errors) {
327       G4warn << "ERROR: No current sceneHandler.  Please create one." << G4endl;
328     }
329     return;
330   }
331 
332   if (action == "accumulate") {
333     pScene->SetRefreshAtEndOfEvent(false);
334     pScene->SetMaxNumberOfKeptEvents(maxNumberOfKeptEvents);
335   }
336   else if (action == "refresh") {
337     if (!pScene->GetRefreshAtEndOfRun()) {
338       if (verbosity >= G4VisManager::errors) {
339   G4warn <<
340     "ERROR: Cannot refresh events unless runs refresh too."
341     "\n  Use \"/vis/scene/endOfRun refresh\"."
342          << G4endl;
343       }
344     } else {
345       pScene->SetRefreshAtEndOfEvent(true);
346       pScene->SetMaxNumberOfKeptEvents(maxNumberOfKeptEvents);
347       pSceneHandler->SetMarkForClearingTransientStore(true);
348     }
349   }
350   else {
351     if (verbosity >= G4VisManager::errors) {
352       G4warn <<
353   "ERROR: unrecognised parameter \"" << action << "\"."
354              << G4endl;
355     }
356     return;
357   }
358 
359   // Change of transients behaviour, so...
360   fpVisManager->ResetTransientsDrawnFlags();
361 
362   // Are there any events currently kept...
363   size_t nCurrentlyKept    = 0;
364   G4RunManager* runManager = G4RunManagerFactory::GetMasterRunManager();
365   if(runManager)
366   {
367     const G4Run* currentRun = runManager->GetCurrentRun();
368     if(currentRun)
369     {
370       const std::vector<const G4Event*>* events = currentRun->GetEventVector();
371       if(events)
372         nCurrentlyKept = events->size();
373     }
374   }
375 
376   if (verbosity >= G4VisManager::confirmations) {
377     G4cout << "End of event action set to ";
378     if (pScene->GetRefreshAtEndOfEvent()) G4cout << "\"refresh\".";
379     else {
380       G4cout << "\"accumulate\"."
381   "\n  Maximum number of events to be kept: "
382        << maxNumberOfKeptEvents
383        << " (unlimited if negative)."
384   "\n  This may be changed with, e.g., "
385   "\"/vis/scene/endOfEventAction accumulate 1000\".";
386     }
387     G4cout << G4endl;
388   }
389 
390   if (!pScene->GetRefreshAtEndOfEvent() &&
391       maxNumberOfKeptEvents != 0 &&
392       verbosity >= G4VisManager::warnings) {
393     G4warn << "WARNING: ";
394     if (nCurrentlyKept) {
395       G4warn <<
396   "\n  There are currently " << nCurrentlyKept
397        << " events kept for refreshing and/or reviewing.";
398     } else {
399       G4warn << "The vis manager will keep ";
400       if (maxNumberOfKeptEvents < 0) G4warn << "an unlimited number of";
401       else G4warn << "up to " << maxNumberOfKeptEvents;
402       G4warn << " events.";
403       if (maxNumberOfKeptEvents > 1 || maxNumberOfKeptEvents < 0)
404   G4warn <<
405     "\n  This may use a lot of memory."
406     "\n  It may be changed with, e.g., "
407     "\"/vis/scene/endOfEventAction accumulate 10\".";
408     }
409     G4warn << G4endl;
410   }
411 }
412 
413 ////////////// /vis/scene/endOfRunAction ////////////////////////////
414 
415 G4VisCommandSceneEndOfRunAction::G4VisCommandSceneEndOfRunAction () {
416   G4bool omitable;
417   fpCommand = new G4UIcmdWithAString ("/vis/scene/endOfRunAction", this);
418   fpCommand -> SetGuidance
419     ("Accumulate or refresh the viewer for each new run.");
420   fpCommand -> SetGuidance
421     ("\"accumulate\": viewer accumulates hits, etc., run by run, or");
422   fpCommand -> SetGuidance
423     ("\"refresh\": viewer shows them at end of run or, for direct-screen"
424      "\n  viewers, refreshes the screen just before drawing the first"
425      "\n  event of the next run.");
426   fpCommand -> SetGuidance ("The detector remains or is redrawn.");
427   fpCommand -> SetParameterName ("action", omitable = true);
428   fpCommand -> SetCandidates ("accumulate refresh");
429   fpCommand -> SetDefaultValue ("refresh");
430 }
431 
432 G4VisCommandSceneEndOfRunAction::~G4VisCommandSceneEndOfRunAction () {
433   delete fpCommand;
434 }
435 
436 G4String G4VisCommandSceneEndOfRunAction::GetCurrentValue(G4UIcommand*) {
437   return "";
438 }
439 
440 void G4VisCommandSceneEndOfRunAction::SetNewValue (G4UIcommand*,
441                  G4String newValue) {
442 
443   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
444 
445   G4String action;
446   std::istringstream is (newValue);
447   is >> action;
448 
449   G4Scene* pScene = fpVisManager->GetCurrentScene();
450   if (!pScene) {
451     if (verbosity >= G4VisManager::errors) {
452       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
453     }
454     return;
455   }
456 
457   G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
458   if (!pSceneHandler) {
459     if (verbosity >= G4VisManager::errors) {
460       G4warn << "ERROR: No current sceneHandler.  Please create one." << G4endl;
461     }
462     return;
463   }
464 
465   if (action == "accumulate") {
466     if (pScene->GetRefreshAtEndOfEvent()) {
467       if (verbosity >= G4VisManager::errors) {
468   G4warn <<
469     "ERROR: Cannot accumulate runs unless events accumulate too."
470     "\n  Use \"/vis/scene/endOfEventAction accumulate\"."
471          << G4endl;
472       }
473     }
474     else {
475       pScene->SetRefreshAtEndOfRun(false);
476     }
477   }
478   else if (action == "refresh") {
479     pScene->SetRefreshAtEndOfRun(true);
480     pSceneHandler->SetMarkForClearingTransientStore(true);
481   }
482   else {
483     if (verbosity >= G4VisManager::errors) {
484       G4warn <<
485   "ERROR: unrecognised parameter \"" << action << "\"."
486              << G4endl;
487     }
488     return;
489   }
490 
491   // Change of transients behaviour, so...
492   fpVisManager->ResetTransientsDrawnFlags();
493 
494   if (verbosity >= G4VisManager::confirmations) {
495     G4cout << "End of run action set to \"";
496     if (pScene->GetRefreshAtEndOfRun()) G4cout << "refresh";
497     else G4cout << "accumulate";
498     G4cout << "\"" << G4endl;
499   }
500 }
501 
502 ////////////// /vis/scene/list ///////////////////////////////////////
503 
504 G4VisCommandSceneList::G4VisCommandSceneList () {
505   G4bool omitable;
506   fpCommand = new G4UIcommand ("/vis/scene/list", this);
507   fpCommand -> SetGuidance ("Lists scene(s).");
508   fpCommand -> SetGuidance
509     ("\"help /vis/verbose\" for definition of verbosity.");
510   G4UIparameter* parameter;
511   parameter = new G4UIparameter ("scene-name", 's', omitable = true);
512   parameter -> SetDefaultValue ("all");
513   fpCommand -> SetParameter (parameter);
514   parameter = new G4UIparameter ("verbosity", 's', omitable = true);
515   parameter -> SetDefaultValue ("warnings");
516   fpCommand -> SetParameter (parameter);
517 }
518 
519 G4VisCommandSceneList::~G4VisCommandSceneList () {
520   delete fpCommand;
521 }
522 
523 G4String G4VisCommandSceneList::GetCurrentValue (G4UIcommand*) {
524   return "";
525 }
526 
527 void G4VisCommandSceneList::SetNewValue (G4UIcommand*, G4String newValue) {
528   G4String name, verbosityString;
529   std::istringstream is (newValue);
530   is >> name >> verbosityString;
531   G4VisManager::Verbosity verbosity =
532     fpVisManager->GetVerbosityValue(verbosityString);
533   const G4Scene* currentScene = fpVisManager -> GetCurrentScene ();
534   G4String currentName;
535   if (currentScene) currentName = currentScene->GetName();
536 
537   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
538   std::size_t iScene, nScenes = sceneList.size ();
539   G4bool found = false;
540   for (iScene = 0; iScene < nScenes; ++iScene) {
541     G4Scene* pScene = sceneList [iScene];
542     const G4String& iName = pScene -> GetName ();
543     if (name != "all") {
544       if (name != iName) continue;
545     }
546     found = true;
547     if (iName == currentName) {
548       G4cout << "  (current)";
549     }
550     else {
551       G4cout << "           ";
552     }
553     G4cout << " scene \"" << iName << "\"";
554     if (verbosity >= G4VisManager::warnings) {
555       std::size_t i;
556       G4cout << "\n  Run-duration models:";
557       std::size_t nRunModels = pScene -> GetRunDurationModelList ().size ();
558       if (nRunModels == 0) {
559   G4cout << " none.";
560       }
561       for (i = 0; i < nRunModels; ++i) {
562   if (pScene -> GetRunDurationModelList()[i].fActive)
563     G4cout << "\n   Active:   ";
564   else G4cout << "\n   Inactive: ";
565   G4VModel* pModel = pScene -> GetRunDurationModelList()[i].fpModel;
566   G4cout << pModel -> GetGlobalDescription ();
567       }
568       G4cout << "\n  End-of-event models:";
569       std::size_t nEOEModels = pScene -> GetEndOfEventModelList ().size ();
570       if (nEOEModels == 0) {
571   G4cout << " none.";
572       }
573       for (i = 0; i < nEOEModels; ++i) {
574   if (pScene -> GetEndOfEventModelList()[i].fActive)
575     G4cout << "\n   Active:   ";
576   else G4cout << "\n   Inactive: ";
577   G4VModel* pModel = pScene -> GetEndOfEventModelList()[i].fpModel;
578   G4cout << pModel -> GetGlobalDescription ();
579       }
580       G4cout << "\n  End-of-run models:";
581       std::size_t nEORModels = pScene -> GetEndOfRunModelList ().size ();
582       if (nEORModels == 0) {
583   G4cout << " none.";
584       }
585       for (i = 0; i < nEORModels; ++i) {
586   if (pScene -> GetEndOfRunModelList()[i].fActive)
587     G4cout << "\n   Active:   ";
588   else G4cout << "\n   Inactive: ";
589   G4VModel* pModel = pScene -> GetEndOfRunModelList()[i].fpModel;
590   G4cout << pModel -> GetGlobalDescription ();
591       }
592     }
593     if (verbosity >= G4VisManager::parameters) {
594       G4cout << "\n  " << *sceneList [iScene];
595     }
596     G4cout << G4endl;
597   }
598   if (!found) {
599     G4warn << "No scenes found";
600     if (name != "all") {
601       G4warn << " of name \"" << name << "\"";
602     }
603     G4warn << "." << G4endl;
604   }
605 }
606 
607 ////////////// /vis/scene/notifyHandlers /////////////////////////
608 
609 G4VisCommandSceneNotifyHandlers::G4VisCommandSceneNotifyHandlers () {
610   G4bool omitable;
611   fpCommand = new G4UIcommand ("/vis/scene/notifyHandlers", this);
612   fpCommand -> SetGuidance
613     ("Notifies scene handlers and forces re-rendering.");
614   fpCommand -> SetGuidance
615     ("Notifies the handler(s) of the specified scene and forces a"
616      "\nreconstruction of any graphical databases."
617      "\nClears and refreshes all viewers of current scene."
618      "\n  The default action \"refresh\" does not issue \"update\" (see"
619      "\n    /vis/viewer/update)."
620      "\nIf \"flush\" is specified, it issues an \"update\" as well as"
621      "\n  \"refresh\" - \"update\" and initiates post-processing"
622      "\n  for graphics systems which need it.");
623   fpCommand -> SetGuidance 
624     ("The default for <scene-name> is the current scene name.");
625   fpCommand -> SetGuidance
626     ("This command does not change current scene, scene handler or viewer.");
627   G4UIparameter* parameter;
628   parameter = new G4UIparameter ("scene-name", 's',
629          omitable = true);
630   parameter -> SetCurrentAsDefault(true);
631   fpCommand -> SetParameter (parameter);
632   parameter = new G4UIparameter ("refresh-flush", 's',
633          omitable = true);
634   parameter -> SetDefaultValue("refresh");
635   parameter -> SetParameterCandidates("r refresh f flush");
636   fpCommand -> SetParameter (parameter);
637 }
638 
639 G4VisCommandSceneNotifyHandlers::~G4VisCommandSceneNotifyHandlers () {
640   delete fpCommand;
641 }
642 
643 G4String G4VisCommandSceneNotifyHandlers::GetCurrentValue(G4UIcommand*) {
644   return CurrentSceneName ();
645 }
646 
647 void G4VisCommandSceneNotifyHandlers::SetNewValue (G4UIcommand*,
648                G4String newValue) {
649 
650   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
651 
652   G4String sceneName, refresh_flush;
653   std::istringstream is (newValue);
654   is >> sceneName >> refresh_flush;
655   G4bool flush = false;
656   if (refresh_flush[0] == 'f') flush = true;
657 
658   const G4SceneList& sceneList = fpVisManager -> GetSceneList ();
659   G4SceneHandlerList& sceneHandlerList =
660     fpVisManager -> SetAvailableSceneHandlers ();
661 
662   // Check scene name.
663   const std::size_t nScenes = sceneList.size ();
664   std::size_t iScene;
665   for (iScene = 0; iScene < nScenes; ++iScene) {
666     G4Scene* scene = sceneList [iScene];
667     if (sceneName == scene -> GetName ()) break;
668   }
669   if (iScene >= nScenes ) {
670     if (verbosity >= G4VisManager::warnings) {
671       G4warn << "WARNING: Scene \"" << sceneName << "\" not found."
672   "\n  /vis/scene/list to see scenes."
673        << G4endl;
674     }
675     return;
676   }
677 
678   // Store current context...
679   G4VSceneHandler* pCurrentSceneHandler =
680     fpVisManager -> GetCurrentSceneHandler();
681   if (!pCurrentSceneHandler) {
682     if (verbosity >= G4VisManager::warnings) {
683       G4warn << "WARNING: No current scene handler."
684        << G4endl;
685     }
686     return;
687   }
688   G4VViewer* pCurrentViewer = fpVisManager -> GetCurrentViewer();
689   if (!pCurrentViewer) {
690     if (verbosity >= G4VisManager::warnings) {
691       G4warn << "WARNING: No current viewer."
692        << G4endl;
693     }
694     return;
695   }
696   G4Scene* pCurrentScene = fpVisManager -> GetCurrentScene();
697   if (!pCurrentScene) {
698     if (verbosity >= G4VisManager::warnings) {
699       G4warn << "WARNING: No current scene."
700        << G4endl;
701     }
702     return;
703   }
704 
705   G4VisManager::Verbosity currentVerbosity = fpVisManager -> GetVerbosity();
706 
707   // Suppress messages during this process (only print errors)...
708   //fpVisManager -> SetVerboseLevel(G4VisManager::errors);
709 
710   // For each scene handler, if it contains the scene, clear and
711   // rebuild the graphical database, then for each viewer set (make
712   // current), clear, (re)draw, and show.
713   const std::size_t nSceneHandlers = sceneHandlerList.size ();
714   for (std::size_t iSH = 0; iSH < nSceneHandlers; ++iSH) {
715     G4VSceneHandler* aSceneHandler = sceneHandlerList [iSH];
716     G4Scene* aScene = aSceneHandler -> GetScene ();
717     if (aScene) {
718       const G4String& aSceneName = aScene -> GetName ();
719       if (sceneName == aSceneName) {
720   aScene->CalculateExtent();  // Check and recalculate extent
721   G4ViewerList& viewerList = aSceneHandler -> SetViewerList ();
722   const std::size_t nViewers = viewerList.size ();
723   for (std::size_t iV = 0; iV < nViewers; ++iV) {
724     G4VViewer* aViewer = viewerList [iV];
725     // Force rebuild of graphical database, if any.
726     aViewer -> NeedKernelVisit();
727     if (aViewer->GetViewParameters().IsAutoRefresh()) {
728       aSceneHandler -> SetCurrentViewer (aViewer);
729       // Ensure consistency of vis manager...
730       fpVisManager -> SetCurrentViewer(aViewer);
731       fpVisManager -> SetCurrentSceneHandler(aSceneHandler);
732       fpVisManager -> SetCurrentScene(aScene);
733       aViewer -> SetView ();
734       aViewer -> ClearView ();
735       aViewer -> DrawView ();
736       if (flush) aViewer -> ShowView ();
737       if (verbosity >= G4VisManager::confirmations) {
738         G4cout << "Viewer \"" << aViewer -> GetName ()
739          << "\" of scene handler \"" << aSceneHandler -> GetName ()
740          << "\"\n  ";
741         if (flush) G4cout << "flushed";
742         else G4cout << "refreshed";
743         G4cout << " at request of scene \"" << sceneName
744          << "\"." << G4endl;
745       }
746     } else {
747       if (verbosity >= G4VisManager::confirmations) {
748         G4cout << "NOTE: The scene, \""
749          << sceneName
750          << "\", of viewer \""
751          << aViewer -> GetName ()
752          << "\"\n  of scene handler \""
753          << aSceneHandler -> GetName ()
754          << "\"  has changed.  To see effect,"
755          << "\n  \"/vis/viewer/select "
756          << aViewer -> GetShortName ()
757          << "\" and \"/vis/viewer/rebuild\"."
758          << G4endl;
759       }
760     }
761   }
762       }
763     }
764     else {
765       if (verbosity >= G4VisManager::warnings) {
766   G4warn << "WARNING: G4VisCommandSceneNotifyHandlers: scene handler \""
767          << aSceneHandler->GetName()
768          << "\" has a null scene."
769          << G4endl;
770       }
771     }
772   }
773 
774   // Reclaim original context - but set viewer first, then scene
775   // handler, because the latter might have been created very recently
776   // and, not yet having a viewer, the current viewer will,
777   // temporarily, refer to another scene handler.  SetCurrentViewer
778   // actually resets the scene handler, which is what we don't want,
779   // so we set it again on the next line...
780   fpVisManager -> SetCurrentViewer(pCurrentViewer);
781   fpVisManager -> SetCurrentSceneHandler(pCurrentSceneHandler);
782   fpVisManager -> SetCurrentScene(pCurrentScene);
783   fpVisManager -> SetVerboseLevel(currentVerbosity);
784   // Take care of special case of scene handler with no viewer yet.  
785   if (pCurrentSceneHandler) {
786     G4ViewerList& viewerList = pCurrentSceneHandler -> SetViewerList ();
787     const std::size_t nViewers = viewerList.size ();
788     if (nViewers) {
789       pCurrentSceneHandler -> SetCurrentViewer (pCurrentViewer);
790       // JA: I don't think we need this. SetView will be called when needed.
791       // if (pCurrentViewer && pCurrentSceneHandler->GetScene()) {
792       //   pCurrentViewer -> SetView ();
793       // }
794     }
795   }
796 }
797 
798 ////////////// /vis/scene/removeModel ////////////////////////////
799 
800 G4VisCommandSceneRemoveModel::G4VisCommandSceneRemoveModel () {
801   G4bool omitable;
802   fpCommand = new G4UIcommand ("/vis/scene/removeModel", this);
803   fpCommand -> SetGuidance("Remove model.");
804   fpCommand -> SetGuidance
805   ("Attempts to match search string to name of model - use unique sub-string.");
806   fpCommand -> SetGuidance
807   ("Use \"/vis/scene/list\" to see model names.");
808   G4UIparameter* parameter;
809   parameter = new G4UIparameter ("search-string", 's', omitable = false);
810   fpCommand -> SetParameter (parameter);
811 }
812 
813 G4VisCommandSceneRemoveModel::~G4VisCommandSceneRemoveModel () {
814   delete fpCommand;
815 }
816 
817 G4String G4VisCommandSceneRemoveModel::GetCurrentValue(G4UIcommand*) {
818   return "";
819 }
820 
821 void G4VisCommandSceneRemoveModel::SetNewValue (G4UIcommand*,
822               G4String newValue) {
823 
824   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
825 
826   G4String searchString;
827   std::istringstream is (newValue);
828   is >> searchString;
829 
830   G4Scene* pScene = fpVisManager->GetCurrentScene();
831   if (!pScene) {
832     if (verbosity >= G4VisManager::errors) {
833       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
834     }
835     return;
836   }
837 
838   G4VSceneHandler* pSceneHandler = fpVisManager->GetCurrentSceneHandler();
839   if (!pSceneHandler) {
840     if (verbosity >= G4VisManager::errors) {
841       G4warn << "ERROR: No current sceneHandler.  Please create one." << G4endl;
842     }
843     return;
844   }
845 
846   G4bool any = false;
847 
848   std::vector<G4Scene::Model>& runDurationModelList =
849   pScene->SetRunDurationModelList();
850   for (size_t i = 0; i < runDurationModelList.size(); i++) {
851     const G4String& modelName =
852     runDurationModelList[i].fpModel->GetGlobalDescription();
853     if (modelName.find(searchString) != std::string::npos) {
854       runDurationModelList.erase(runDurationModelList.begin()+i);
855       any = true;
856       if (verbosity >= G4VisManager::warnings) {
857   G4warn << "Model \"" << modelName << "\" removed." << G4endl;
858       }
859       break;  // Allow only one model at a time to be removed.
860     }
861   }
862 
863   std::vector<G4Scene::Model>& endOfEventModelList =
864   pScene->SetEndOfEventModelList();
865   for (size_t i = 0; i < endOfEventModelList.size(); i++) {
866     const G4String& modelName =
867     endOfEventModelList[i].fpModel->GetGlobalDescription();
868     if (modelName.find(searchString) != std::string::npos) {
869       endOfEventModelList.erase(endOfEventModelList.begin()+i);
870       any = true;
871       if (verbosity >= G4VisManager::warnings) {
872   G4warn << "Model \"" << modelName << "\" removed." << G4endl;
873       }
874       break;  // Allow only one model at a time to be removed.
875     }
876   }
877 
878   std::vector<G4Scene::Model>& endOfRunModelList =
879   pScene->SetEndOfRunModelList();
880   for (size_t i = 0; i < endOfRunModelList.size(); i++) {
881     const G4String& modelName =
882     endOfRunModelList[i].fpModel->GetGlobalDescription();
883     if (modelName.find(searchString) != std::string::npos) {
884       endOfRunModelList.erase(endOfRunModelList.begin()+i);
885       any = true;
886       if (verbosity >= G4VisManager::warnings) {
887   G4warn << "Model \"" << modelName << "\" removed." << G4endl;
888       }
889       break;  // Allow only one model at a time to be removed.
890     }
891   }
892 
893   if (!any) {
894     if (verbosity >= G4VisManager::warnings) {
895       G4warn << "WARNING: No match found." << G4endl;
896     }
897     return;
898   }
899 
900   CheckSceneAndNotifyHandlers (pScene);
901 }
902 
903 ////////////// /vis/scene/select ///////////////////////////////////////
904 
905 G4VisCommandSceneSelect::G4VisCommandSceneSelect () {
906   G4bool omitable;
907   fpCommand = new G4UIcmdWithAString ("/vis/scene/select", this);
908   fpCommand -> SetGuidance ("Selects a scene");
909   fpCommand -> SetGuidance
910   ("Makes the scene current.  \"/vis/scene/list\" to see"
911    "\n possible scene names.");
912   fpCommand -> SetParameterName ("scene-name", omitable = false);
913 }
914 
915 G4VisCommandSceneSelect::~G4VisCommandSceneSelect () {
916   delete fpCommand;
917 }
918 
919 G4String G4VisCommandSceneSelect::GetCurrentValue (G4UIcommand*) {
920   return "";
921 }
922 
923 void G4VisCommandSceneSelect::SetNewValue (G4UIcommand*, G4String newValue) {
924 
925   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
926 
927   G4String& selectName = newValue;
928   G4SceneList& sceneList = fpVisManager -> SetSceneList ();
929   std::size_t iScene, nScenes = sceneList.size ();
930   for (iScene = 0; iScene < nScenes; ++iScene) {
931     if (sceneList [iScene] -> GetName () == selectName) break;
932   }
933   if (iScene >= nScenes) {
934     if (verbosity >= G4VisManager::warnings) {
935       G4warn << "WARNING: Scene \"" << selectName
936       << "\" not found - \"/vis/scene/list\" to see possibilities."
937       << G4endl;
938     }
939     return;
940   }
941 
942   if (verbosity >= G4VisManager::confirmations) {
943     G4cout << "Scene \"" << selectName
944     << "\" selected." << G4endl;
945   }
946 
947   CheckSceneAndNotifyHandlers (sceneList [iScene]);
948 }
949 
950 ////////////// /vis/scene/showExtents ///////////////////////////////////////
951 
952 G4VisCommandSceneShowExtents::G4VisCommandSceneShowExtents () {
953   fpCommand = new G4UIcmdWithoutParameter ("/vis/scene/showExtents", this);
954   fpCommand -> SetGuidance ("Prints and draws extents of models in a scene");
955 }
956 
957 G4VisCommandSceneShowExtents::~G4VisCommandSceneShowExtents () {
958   delete fpCommand;
959 }
960 
961 G4String G4VisCommandSceneShowExtents::GetCurrentValue (G4UIcommand*) {
962   return "";
963 }
964 
965 void G4VisCommandSceneShowExtents::SetNewValue (G4UIcommand*, G4String) {
966 
967   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
968 
969   G4VSceneHandler* pCurrentSceneHandler =
970   fpVisManager -> GetCurrentSceneHandler();
971   if (!pCurrentSceneHandler) {
972     if (verbosity >= G4VisManager::warnings) {
973       G4warn << "WARNING: No current scene handler."
974       << G4endl;
975     }
976     return;
977   }
978   G4VViewer* pCurrentViewer = fpVisManager -> GetCurrentViewer();
979   if (!pCurrentViewer) {
980     if (verbosity >= G4VisManager::warnings) {
981       G4warn << "WARNING: No current viewer."
982       << G4endl;
983     }
984     return;
985   }
986   G4Scene* pCurrentScene = fpVisManager -> GetCurrentScene();
987   if (!pCurrentScene) {
988     if (verbosity >= G4VisManager::warnings) {
989       G4warn << "WARNING: No current scene."
990       << G4endl;
991     }
992     return;
993   }
994 
995   G4cout << "\n  Run-duration models:";
996   std::size_t nRunModels = pCurrentScene -> GetRunDurationModelList ().size ();
997   if (nRunModels == 0) {
998     G4cout << " none.";
999   }
1000   for (std::size_t i = 0; i < nRunModels; ++i) {
1001     if (pCurrentScene -> GetRunDurationModelList()[i].fActive)
1002       G4cout << "\n   Active:   ";
1003     else G4cout << "\n   Inactive: ";
1004     G4VModel* pModel = pCurrentScene -> GetRunDurationModelList()[i].fpModel;
1005     const G4VisExtent& transformedExtent = pModel -> GetExtent();
1006     G4cout << pModel -> GetGlobalDescription ()
1007     << "\n" << transformedExtent;
1008     DrawExtent(transformedExtent);
1009   }
1010   G4cout << "\n  End-of-event models:";
1011   std::size_t nEOEModels = pCurrentScene -> GetEndOfEventModelList ().size ();
1012   if (nEOEModels == 0) {
1013     G4cout << " none.";
1014   }
1015   for (std::size_t i = 0; i < nEOEModels; ++i) {
1016     if (pCurrentScene -> GetEndOfEventModelList()[i].fActive)
1017       G4cout << "\n   Active:   ";
1018     else G4cout << "\n   Inactive: ";
1019     G4VModel* pModel = pCurrentScene -> GetEndOfEventModelList()[i].fpModel;
1020     const G4VisExtent& transformedExtent = pModel -> GetExtent();
1021     G4cout << pModel -> GetGlobalDescription ()
1022     << "\n" << transformedExtent;
1023     DrawExtent(transformedExtent);
1024   }
1025   G4cout << "\n  End-of-run models:";
1026   std::size_t nEORModels = pCurrentScene -> GetEndOfRunModelList ().size ();
1027   if (nEORModels == 0) {
1028     G4cout << " none.";
1029   }
1030   for (std::size_t i = 0; i < nEORModels; ++i) {
1031     if (pCurrentScene -> GetEndOfRunModelList()[i].fActive)
1032       G4cout << "\n   Active:   ";
1033     else G4cout << "\n   Inactive: ";
1034     G4VModel* pModel = pCurrentScene -> GetEndOfRunModelList()[i].fpModel;
1035     const G4VisExtent& transformedExtent = pModel -> GetExtent();
1036     G4cout << pModel -> GetGlobalDescription ()
1037     << "\n" << transformedExtent;
1038     DrawExtent(transformedExtent);
1039   }
1040   G4cout << "\n  Overall extent:\n";
1041   DrawExtent(pCurrentScene->GetExtent());
1042   G4cout << G4endl;
1043 }
1044