Geant4 Cross Reference |
1 // 1 2 // ******************************************* 3 // * License and Disclaimer 4 // * 5 // * The Geant4 software is copyright of th 6 // * the Geant4 Collaboration. It is provided 7 // * conditions of the Geant4 Software License 8 // * LICENSE and available at http://cern.ch/ 9 // * include a list of copyright holders. 10 // * 11 // * Neither the authors of this software syst 12 // * institutes,nor the agencies providing fin 13 // * work make any representation or warran 14 // * regarding this software system or assum 15 // * use. Please see the license in the file 16 // * for the full disclaimer and the limitatio 17 // * 18 // * This code implementation is the result 19 // * technical work of the GEANT4 collaboratio 20 // * By using, copying, modifying or distri 21 // * any work based on the software) you ag 22 // * use in resulting scientific publicati 23 // * acceptance of all terms of the Geant4 Sof 24 // ******************************************* 25 // 26 // 27 28 // /vis/scene commands - John Allison 9th Aug 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 -> GetC 54 G4String currentSceneName = "none"; 55 if (pScene) currentSceneName = pScene -> Get 56 return currentSceneName; 57 } 58 59 ////////////// /vis/scene/activateModel ////// 60 61 G4VisCommandSceneActivateModel::G4VisCommandSc 62 G4bool omitable; 63 fpCommand = new G4UIcommand ("/vis/scene/act 64 fpCommand -> SetGuidance 65 ("Activate or de-activate model."); 66 fpCommand -> SetGuidance 67 ("Attempts to match search string to name 68 fpCommand -> SetGuidance 69 ("Use \"/vis/scene/list\" to see model nam 70 fpCommand -> SetGuidance 71 ("If name == \"all\" (default), all models 72 G4UIparameter* parameter; 73 parameter = new G4UIparameter ("search-strin 74 parameter -> SetDefaultValue ("all"); 75 fpCommand -> SetParameter (parameter); 76 parameter = new G4UIparameter ("activate", ' 77 parameter -> SetDefaultValue (true); 78 fpCommand -> SetParameter (parameter); 79 } 80 81 G4VisCommandSceneActivateModel::~G4VisCommandS 82 delete fpCommand; 83 } 84 85 G4String G4VisCommandSceneActivateModel::GetCu 86 return ""; 87 } 88 89 void G4VisCommandSceneActivateModel::SetNewVal 90 G4String newValue) { 91 92 G4VisManager::Verbosity verbosity = fpVisMan 93 94 G4String searchString, activateString; 95 std::istringstream is (newValue); 96 // Need to handle the possibility that the s 97 // contains embedded blanks within quotation 98 // (This arises if the search string is auto 99 // global description, as in G4UIQt, clickin 100 auto lastQuotationMark = newValue.find_last_ 101 if (lastQuotationMark != std::string::npos) 102 auto firstQuotationMark = newValue.find_fi 103 if (lastQuotationMark != firstQuotationMar 104 // Note: there must not be more quotatio 105 searchString = newValue.substr 106 (firstQuotationMark + 1, lastQuotationMa 107 activateString = newValue.substr(lastQuo 108 // Perhaps we ought to check number of q 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 116 G4Exception("G4VisCommandSceneActivate 117 } 118 } 119 } 120 else { 121 // None or one quotation marks - just inpu 122 is >> searchString >> activateString; 123 } 124 G4bool activate = G4UIcommand::ConvertToBool 125 126 G4Scene* pScene = fpVisManager->GetCurrentSc 127 if (!pScene) { 128 if (verbosity >= G4VisManager::errors) { 129 G4warn << "ERROR: No current scene. Ple 130 } 131 return; 132 } 133 134 G4VSceneHandler* pSceneHandler = fpVisManage 135 if (!pSceneHandler) { 136 if (verbosity >= G4VisManager::errors) { 137 G4warn << "ERROR: No current sceneHandle 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 146 "\n Command ignored." 147 << G4endl; 148 } 149 return; 150 } 151 152 G4bool any = false; 153 154 std::vector<G4Scene::Model>& runDurationMode 155 pScene->SetRunDurationModelList(); 156 for (size_t i = 0; i < runDurationModelList. 157 const G4String& modelName = runDurationMod 158 if (searchString == "all" || modelName.fin 159 any = true; 160 runDurationModelList[i].fActive = activa 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>& endOfEventModel 171 pScene->SetEndOfEventModelList(); 172 for (size_t i = 0; i < endOfEventModelList.s 173 const G4String& modelName = endOfEventMode 174 if (searchString == "all" || modelName.fin 175 any = true; 176 endOfEventModelList[i].fActive = activat 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>& endOfRunModelLi 187 pScene->SetEndOfRunModelList(); 188 for (size_t i = 0; i < endOfRunModelList.siz 189 const G4String& modelName = endOfRunModelL 190 if (searchString == "all" || modelName.fin 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." << 205 } 206 return; 207 } 208 209 CheckSceneAndNotifyHandlers (pScene); 210 } 211 212 ////////////// /vis/scene/create ///////////// 213 214 G4VisCommandSceneCreate::G4VisCommandSceneCrea 215 G4bool omitable; 216 fpCommand = new G4UIcmdWithAString ("/vis/sc 217 fpCommand -> SetGuidance 218 ("Creates an empty scene."); 219 fpCommand -> SetGuidance 220 ("Invents a name if not supplied. This sc 221 fpCommand -> SetParameterName ("scene-name", 222 } 223 224 G4VisCommandSceneCreate::~G4VisCommandSceneCre 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::GetCurrentVa 235 return ""; 236 } 237 238 void G4VisCommandSceneCreate::SetNewValue (G4U 239 240 G4VisManager::Verbosity verbosity = fpVisMan 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 -> Set 251 std::size_t iScene, nScenes = sceneList.size 252 for (iScene = 0; iScene < nScenes; ++iScene) 253 if (sceneList [iScene] -> GetName () == ne 254 } 255 if (iScene < nScenes) { 256 if (verbosity >= G4VisManager::warnings) { 257 G4warn << "WARNING: Scene \"" << newName 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::confirmatio 269 G4cout << "New empty scene \"" << newNam 270 } 271 } 272 } 273 274 ////////////// /vis/scene/endOfEventAction /// 275 276 G4VisCommandSceneEndOfEventAction::G4VisComman 277 G4bool omitable; 278 fpCommand = new G4UIcommand ("/vis/scene/end 279 fpCommand -> SetGuidance 280 ("Accumulate or refresh the viewer for eac 281 fpCommand -> SetGuidance 282 ("\"accumulate\": viewer accumulates hits, 283 fpCommand -> SetGuidance 284 ("\"refresh\": viewer shows them at end of 285 "\n viewers, refreshes the screen just b 286 G4UIparameter* parameter; 287 parameter = new G4UIparameter ("action", 's' 288 parameter -> SetParameterCandidates ("accumu 289 parameter -> SetDefaultValue ("refresh"); 290 fpCommand -> SetParameter (parameter); 291 parameter = new G4UIparameter ("maxNumber", 292 parameter -> SetDefaultValue (100); 293 parameter -> SetGuidance 294 ("Maximum number of events kept. Unlimited 295 fpCommand -> SetParameter (parameter); 296 } 297 298 G4VisCommandSceneEndOfEventAction::~G4VisComma 299 delete fpCommand; 300 } 301 302 G4String G4VisCommandSceneEndOfEventAction::Ge 303 return ""; 304 } 305 306 void G4VisCommandSceneEndOfEventAction::SetNew 307 G4String newValue) { 308 309 G4VisManager::Verbosity verbosity = fpVisMan 310 311 G4String action; 312 G4int maxNumberOfKeptEvents; 313 std::istringstream is (newValue); 314 is >> action >> maxNumberOfKeptEvents; 315 316 G4Scene* pScene = fpVisManager->GetCurrentSc 317 if (!pScene) { 318 if (verbosity >= G4VisManager::errors) { 319 G4warn << "ERROR: No current scene. Ple 320 } 321 return; 322 } 323 324 G4VSceneHandler* pSceneHandler = fpVisManage 325 if (!pSceneHandler) { 326 if (verbosity >= G4VisManager::errors) { 327 G4warn << "ERROR: No current sceneHandle 328 } 329 return; 330 } 331 332 if (action == "accumulate") { 333 pScene->SetRefreshAtEndOfEvent(false); 334 pScene->SetMaxNumberOfKeptEvents(maxNumber 335 } 336 else if (action == "refresh") { 337 if (!pScene->GetRefreshAtEndOfRun()) { 338 if (verbosity >= G4VisManager::errors) { 339 G4warn << 340 "ERROR: Cannot refresh events unless runs 341 "\n Use \"/vis/scene/endOfRun refresh\"." 342 << G4endl; 343 } 344 } else { 345 pScene->SetRefreshAtEndOfEvent(true); 346 pScene->SetMaxNumberOfKeptEvents(maxNumb 347 pSceneHandler->SetMarkForClearingTransie 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 = G4RunManagerFacto 365 if(runManager) 366 { 367 const G4Run* currentRun = runManager->GetC 368 if(currentRun) 369 { 370 const std::vector<const G4Event*>* event 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()) G4co 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 10 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 398 } else { 399 G4warn << "The vis manager will keep "; 400 if (maxNumberOfKeptEvents < 0) G4warn << 401 else G4warn << "up to " << maxNumberOfKe 402 G4warn << " events."; 403 if (maxNumberOfKeptEvents > 1 || maxNumb 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 408 } 409 G4warn << G4endl; 410 } 411 } 412 413 ////////////// /vis/scene/endOfRunAction ///// 414 415 G4VisCommandSceneEndOfRunAction::G4VisCommandS 416 G4bool omitable; 417 fpCommand = new G4UIcmdWithAString ("/vis/sc 418 fpCommand -> SetGuidance 419 ("Accumulate or refresh the viewer for eac 420 fpCommand -> SetGuidance 421 ("\"accumulate\": viewer accumulates hits, 422 fpCommand -> SetGuidance 423 ("\"refresh\": viewer shows them at end of 424 "\n viewers, refreshes the screen just b 425 "\n event of the next run."); 426 fpCommand -> SetGuidance ("The detector rema 427 fpCommand -> SetParameterName ("action", omi 428 fpCommand -> SetCandidates ("accumulate refr 429 fpCommand -> SetDefaultValue ("refresh"); 430 } 431 432 G4VisCommandSceneEndOfRunAction::~G4VisCommand 433 delete fpCommand; 434 } 435 436 G4String G4VisCommandSceneEndOfRunAction::GetC 437 return ""; 438 } 439 440 void G4VisCommandSceneEndOfRunAction::SetNewVa 441 G4String newValue) { 442 443 G4VisManager::Verbosity verbosity = fpVisMan 444 445 G4String action; 446 std::istringstream is (newValue); 447 is >> action; 448 449 G4Scene* pScene = fpVisManager->GetCurrentSc 450 if (!pScene) { 451 if (verbosity >= G4VisManager::errors) { 452 G4warn << "ERROR: No current scene. Ple 453 } 454 return; 455 } 456 457 G4VSceneHandler* pSceneHandler = fpVisManage 458 if (!pSceneHandler) { 459 if (verbosity >= G4VisManager::errors) { 460 G4warn << "ERROR: No current sceneHandle 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 even 470 "\n Use \"/vis/scene/endOfEventAction acc 471 << G4endl; 472 } 473 } 474 else { 475 pScene->SetRefreshAtEndOfRun(false); 476 } 477 } 478 else if (action == "refresh") { 479 pScene->SetRefreshAtEndOfRun(true); 480 pSceneHandler->SetMarkForClearingTransient 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 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/lis 507 fpCommand -> SetGuidance ("Lists scene(s).") 508 fpCommand -> SetGuidance 509 ("\"help /vis/verbose\" for definition of 510 G4UIparameter* parameter; 511 parameter = new G4UIparameter ("scene-name", 512 parameter -> SetDefaultValue ("all"); 513 fpCommand -> SetParameter (parameter); 514 parameter = new G4UIparameter ("verbosity", 515 parameter -> SetDefaultValue ("warnings"); 516 fpCommand -> SetParameter (parameter); 517 } 518 519 G4VisCommandSceneList::~G4VisCommandSceneList 520 delete fpCommand; 521 } 522 523 G4String G4VisCommandSceneList::GetCurrentValu 524 return ""; 525 } 526 527 void G4VisCommandSceneList::SetNewValue (G4UIc 528 G4String name, verbosityString; 529 std::istringstream is (newValue); 530 is >> name >> verbosityString; 531 G4VisManager::Verbosity verbosity = 532 fpVisManager->GetVerbosityValue(verbosityS 533 const G4Scene* currentScene = fpVisManager - 534 G4String currentName; 535 if (currentScene) currentName = currentScene 536 537 G4SceneList& sceneList = fpVisManager -> Set 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 -> GetRu 558 if (nRunModels == 0) { 559 G4cout << " none."; 560 } 561 for (i = 0; i < nRunModels; ++i) { 562 if (pScene -> GetRunDurationModelList()[i].f 563 G4cout << "\n Active: "; 564 else G4cout << "\n Inactive: "; 565 G4VModel* pModel = pScene -> GetRunDurationM 566 G4cout << pModel -> GetGlobalDescription (); 567 } 568 G4cout << "\n End-of-event models:"; 569 std::size_t nEOEModels = pScene -> GetEn 570 if (nEOEModels == 0) { 571 G4cout << " none."; 572 } 573 for (i = 0; i < nEOEModels; ++i) { 574 if (pScene -> GetEndOfEventModelList()[i].fA 575 G4cout << "\n Active: "; 576 else G4cout << "\n Inactive: "; 577 G4VModel* pModel = pScene -> GetEndOfEventMo 578 G4cout << pModel -> GetGlobalDescription (); 579 } 580 G4cout << "\n End-of-run models:"; 581 std::size_t nEORModels = pScene -> GetEn 582 if (nEORModels == 0) { 583 G4cout << " none."; 584 } 585 for (i = 0; i < nEORModels; ++i) { 586 if (pScene -> GetEndOfRunModelList()[i].fAct 587 G4cout << "\n Active: "; 588 else G4cout << "\n Inactive: "; 589 G4VModel* pModel = pScene -> GetEndOfRunMode 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::G4VisCommandS 610 G4bool omitable; 611 fpCommand = new G4UIcommand ("/vis/scene/not 612 fpCommand -> SetGuidance 613 ("Notifies scene handlers and forces re-re 614 fpCommand -> SetGuidance 615 ("Notifies the handler(s) of the specified 616 "\nreconstruction of any graphical databa 617 "\nClears and refreshes all viewers of cu 618 "\n The default action \"refresh\" does 619 "\n /vis/viewer/update)." 620 "\nIf \"flush\" is specified, it issues a 621 "\n \"refresh\" - \"update\" and initiat 622 "\n for graphics systems which need it." 623 fpCommand -> SetGuidance 624 ("The default for <scene-name> is the curr 625 fpCommand -> SetGuidance 626 ("This command does not change current sce 627 G4UIparameter* parameter; 628 parameter = new G4UIparameter ("scene-name", 629 omitable = true); 630 parameter -> SetCurrentAsDefault(true); 631 fpCommand -> SetParameter (parameter); 632 parameter = new G4UIparameter ("refresh-flus 633 omitable = true); 634 parameter -> SetDefaultValue("refresh"); 635 parameter -> SetParameterCandidates("r refre 636 fpCommand -> SetParameter (parameter); 637 } 638 639 G4VisCommandSceneNotifyHandlers::~G4VisCommand 640 delete fpCommand; 641 } 642 643 G4String G4VisCommandSceneNotifyHandlers::GetC 644 return CurrentSceneName (); 645 } 646 647 void G4VisCommandSceneNotifyHandlers::SetNewVa 648 G4String newValue) { 649 650 G4VisManager::Verbosity verbosity = fpVisMan 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 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 ()) brea 668 } 669 if (iScene >= nScenes ) { 670 if (verbosity >= G4VisManager::warnings) { 671 G4warn << "WARNING: Scene \"" << sceneNa 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 han 684 << G4endl; 685 } 686 return; 687 } 688 G4VViewer* pCurrentViewer = fpVisManager -> 689 if (!pCurrentViewer) { 690 if (verbosity >= G4VisManager::warnings) { 691 G4warn << "WARNING: No current viewer." 692 << G4endl; 693 } 694 return; 695 } 696 G4Scene* pCurrentScene = fpVisManager -> Get 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 = f 706 707 // Suppress messages during this process (on 708 //fpVisManager -> SetVerboseLevel(G4VisManag 709 710 // For each scene handler, if it contains th 711 // rebuild the graphical database, then for 712 // current), clear, (re)draw, and show. 713 const std::size_t nSceneHandlers = sceneHand 714 for (std::size_t iSH = 0; iSH < nSceneHandle 715 G4VSceneHandler* aSceneHandler = sceneHand 716 G4Scene* aScene = aSceneHandler -> GetScen 717 if (aScene) { 718 const G4String& aSceneName = aScene -> G 719 if (sceneName == aSceneName) { 720 aScene->CalculateExtent(); // Check and rec 721 G4ViewerList& viewerList = aSceneHandler -> 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 726 aViewer -> NeedKernelVisit(); 727 if (aViewer->GetViewParameters().IsAutoRef 728 aSceneHandler -> SetCurrentViewer (aView 729 // Ensure consistency of vis manager... 730 fpVisManager -> SetCurrentViewer(aViewer 731 fpVisManager -> SetCurrentSceneHandler(a 732 fpVisManager -> SetCurrentScene(aScene); 733 aViewer -> SetView (); 734 aViewer -> ClearView (); 735 aViewer -> DrawView (); 736 if (flush) aViewer -> ShowView (); 737 if (verbosity >= G4VisManager::confirmat 738 G4cout << "Viewer \"" << aViewer -> Ge 739 << "\" of scene handler \"" << aScene 740 << "\"\n "; 741 if (flush) G4cout << "flushed"; 742 else G4cout << "refreshed"; 743 G4cout << " at request of scene \"" << 744 << "\"." << G4endl; 745 } 746 } else { 747 if (verbosity >= G4VisManager::confirmat 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: G4VisCommandSceneNotifyH 767 << aSceneHandler->GetName() 768 << "\" has a null scene." 769 << G4endl; 770 } 771 } 772 } 773 774 // Reclaim original context - but set viewer 775 // handler, because the latter might have be 776 // and, not yet having a viewer, the current 777 // temporarily, refer to another scene handl 778 // actually resets the scene handler, which 779 // so we set it again on the next line... 780 fpVisManager -> SetCurrentViewer(pCurrentVie 781 fpVisManager -> SetCurrentSceneHandler(pCurr 782 fpVisManager -> SetCurrentScene(pCurrentScen 783 fpVisManager -> SetVerboseLevel(currentVerbo 784 // Take care of special case of scene handle 785 if (pCurrentSceneHandler) { 786 G4ViewerList& viewerList = pCurrentSceneHa 787 const std::size_t nViewers = viewerList.si 788 if (nViewers) { 789 pCurrentSceneHandler -> SetCurrentViewer 790 // JA: I don't think we need this. SetVi 791 // if (pCurrentViewer && pCurrentSceneHa 792 // pCurrentViewer -> SetView (); 793 // } 794 } 795 } 796 } 797 798 ////////////// /vis/scene/removeModel //////// 799 800 G4VisCommandSceneRemoveModel::G4VisCommandScen 801 G4bool omitable; 802 fpCommand = new G4UIcommand ("/vis/scene/rem 803 fpCommand -> SetGuidance("Remove model."); 804 fpCommand -> SetGuidance 805 ("Attempts to match search string to name of 806 fpCommand -> SetGuidance 807 ("Use \"/vis/scene/list\" to see model names 808 G4UIparameter* parameter; 809 parameter = new G4UIparameter ("search-strin 810 fpCommand -> SetParameter (parameter); 811 } 812 813 G4VisCommandSceneRemoveModel::~G4VisCommandSce 814 delete fpCommand; 815 } 816 817 G4String G4VisCommandSceneRemoveModel::GetCurr 818 return ""; 819 } 820 821 void G4VisCommandSceneRemoveModel::SetNewValue 822 G4String newValue) { 823 824 G4VisManager::Verbosity verbosity = fpVisMan 825 826 G4String searchString; 827 std::istringstream is (newValue); 828 is >> searchString; 829 830 G4Scene* pScene = fpVisManager->GetCurrentSc 831 if (!pScene) { 832 if (verbosity >= G4VisManager::errors) { 833 G4warn << "ERROR: No current scene. Ple 834 } 835 return; 836 } 837 838 G4VSceneHandler* pSceneHandler = fpVisManage 839 if (!pSceneHandler) { 840 if (verbosity >= G4VisManager::errors) { 841 G4warn << "ERROR: No current sceneHandle 842 } 843 return; 844 } 845 846 G4bool any = false; 847 848 std::vector<G4Scene::Model>& runDurationMode 849 pScene->SetRunDurationModelList(); 850 for (size_t i = 0; i < runDurationModelList. 851 const G4String& modelName = 852 runDurationModelList[i].fpModel->GetGlobal 853 if (modelName.find(searchString) != std::s 854 runDurationModelList.erase(runDurationMo 855 any = true; 856 if (verbosity >= G4VisManager::warnings) 857 G4warn << "Model \"" << modelName << "\" rem 858 } 859 break; // Allow only one model at a tim 860 } 861 } 862 863 std::vector<G4Scene::Model>& endOfEventModel 864 pScene->SetEndOfEventModelList(); 865 for (size_t i = 0; i < endOfEventModelList.s 866 const G4String& modelName = 867 endOfEventModelList[i].fpModel->GetGlobalD 868 if (modelName.find(searchString) != std::s 869 endOfEventModelList.erase(endOfEventMode 870 any = true; 871 if (verbosity >= G4VisManager::warnings) 872 G4warn << "Model \"" << modelName << "\" rem 873 } 874 break; // Allow only one model at a tim 875 } 876 } 877 878 std::vector<G4Scene::Model>& endOfRunModelLi 879 pScene->SetEndOfRunModelList(); 880 for (size_t i = 0; i < endOfRunModelList.siz 881 const G4String& modelName = 882 endOfRunModelList[i].fpModel->GetGlobalDes 883 if (modelName.find(searchString) != std::s 884 endOfRunModelList.erase(endOfRunModelLis 885 any = true; 886 if (verbosity >= G4VisManager::warnings) 887 G4warn << "Model \"" << modelName << "\" rem 888 } 889 break; // Allow only one model at a tim 890 } 891 } 892 893 if (!any) { 894 if (verbosity >= G4VisManager::warnings) { 895 G4warn << "WARNING: No match found." << 896 } 897 return; 898 } 899 900 CheckSceneAndNotifyHandlers (pScene); 901 } 902 903 ////////////// /vis/scene/select ///////////// 904 905 G4VisCommandSceneSelect::G4VisCommandSceneSele 906 G4bool omitable; 907 fpCommand = new G4UIcmdWithAString ("/vis/sc 908 fpCommand -> SetGuidance ("Selects a scene") 909 fpCommand -> SetGuidance 910 ("Makes the scene current. \"/vis/scene/lis 911 "\n possible scene names."); 912 fpCommand -> SetParameterName ("scene-name", 913 } 914 915 G4VisCommandSceneSelect::~G4VisCommandSceneSel 916 delete fpCommand; 917 } 918 919 G4String G4VisCommandSceneSelect::GetCurrentVa 920 return ""; 921 } 922 923 void G4VisCommandSceneSelect::SetNewValue (G4U 924 925 G4VisManager::Verbosity verbosity = fpVisMan 926 927 G4String& selectName = newValue; 928 G4SceneList& sceneList = fpVisManager -> Set 929 std::size_t iScene, nScenes = sceneList.size 930 for (iScene = 0; iScene < nScenes; ++iScene) 931 if (sceneList [iScene] -> GetName () == se 932 } 933 if (iScene >= nScenes) { 934 if (verbosity >= G4VisManager::warnings) { 935 G4warn << "WARNING: Scene \"" << selectN 936 << "\" not found - \"/vis/scene/list\" t 937 << G4endl; 938 } 939 return; 940 } 941 942 if (verbosity >= G4VisManager::confirmations 943 G4cout << "Scene \"" << selectName 944 << "\" selected." << G4endl; 945 } 946 947 CheckSceneAndNotifyHandlers (sceneList [iSce 948 } 949 950 ////////////// /vis/scene/showExtents //////// 951 952 G4VisCommandSceneShowExtents::G4VisCommandScen 953 fpCommand = new G4UIcmdWithoutParameter ("/v 954 fpCommand -> SetGuidance ("Prints and draws 955 } 956 957 G4VisCommandSceneShowExtents::~G4VisCommandSce 958 delete fpCommand; 959 } 960 961 G4String G4VisCommandSceneShowExtents::GetCurr 962 return ""; 963 } 964 965 void G4VisCommandSceneShowExtents::SetNewValue 966 967 G4VisManager::Verbosity verbosity = fpVisMan 968 969 G4VSceneHandler* pCurrentSceneHandler = 970 fpVisManager -> GetCurrentSceneHandler(); 971 if (!pCurrentSceneHandler) { 972 if (verbosity >= G4VisManager::warnings) { 973 G4warn << "WARNING: No current scene han 974 << G4endl; 975 } 976 return; 977 } 978 G4VViewer* pCurrentViewer = fpVisManager -> 979 if (!pCurrentViewer) { 980 if (verbosity >= G4VisManager::warnings) { 981 G4warn << "WARNING: No current viewer." 982 << G4endl; 983 } 984 return; 985 } 986 G4Scene* pCurrentScene = fpVisManager -> Get 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 -> Ge 997 if (nRunModels == 0) { 998 G4cout << " none."; 999 } 1000 for (std::size_t i = 0; i < nRunModels; ++i 1001 if (pCurrentScene -> GetRunDurationModelL 1002 G4cout << "\n Active: "; 1003 else G4cout << "\n Inactive: "; 1004 G4VModel* pModel = pCurrentScene -> GetRu 1005 const G4VisExtent& transformedExtent = pM 1006 G4cout << pModel -> GetGlobalDescription 1007 << "\n" << transformedExtent; 1008 DrawExtent(transformedExtent); 1009 } 1010 G4cout << "\n End-of-event models:"; 1011 std::size_t nEOEModels = pCurrentScene -> G 1012 if (nEOEModels == 0) { 1013 G4cout << " none."; 1014 } 1015 for (std::size_t i = 0; i < nEOEModels; ++i 1016 if (pCurrentScene -> GetEndOfEventModelLi 1017 G4cout << "\n Active: "; 1018 else G4cout << "\n Inactive: "; 1019 G4VModel* pModel = pCurrentScene -> GetEn 1020 const G4VisExtent& transformedExtent = pM 1021 G4cout << pModel -> GetGlobalDescription 1022 << "\n" << transformedExtent; 1023 DrawExtent(transformedExtent); 1024 } 1025 G4cout << "\n End-of-run models:"; 1026 std::size_t nEORModels = pCurrentScene -> G 1027 if (nEORModels == 0) { 1028 G4cout << " none."; 1029 } 1030 for (std::size_t i = 0; i < nEORModels; ++i 1031 if (pCurrentScene -> GetEndOfRunModelList 1032 G4cout << "\n Active: "; 1033 else G4cout << "\n Inactive: "; 1034 G4VModel* pModel = pCurrentScene -> GetEn 1035 const G4VisExtent& transformedExtent = pM 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