Geant4 Cross Reference |
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 // 29 // John Allison 24th January 1998. 30 31 #ifndef G4VISEXECUTIVE_ICC 32 #define G4VISEXECUTIVE_ICC 33 34 // Filter/Model Factories 35 #include "G4HitFilterFactories.hh" 36 #include "G4DigiFilterFactories.hh" 37 #include "G4TrajectoryFilterFactories.hh" 38 #include "G4TrajectoryModelFactories.hh" 39 40 // Supported drivers... 41 // Not needing external packages or libraries... 42 #include "G4ASCIITree.hh" // no_geant4_module_check 43 #include "G4DAWNFILE.hh" // no_geant4_module_check 44 #include "G4HepRepFile.hh" // no_geant4_module_check 45 #include "G4RayTracer.hh" // no_geant4_module_check 46 #include "G4VRML2File.hh" // no_geant4_module_check 47 #include "G4GMocrenFile.hh" // no_geant4_module_check 48 #include "G4ToolsSGOffscreen.hh" // no_geant4_module_check 49 50 // Needing external packages or libraries... 51 #ifdef G4VIS_USE_OPENGLX 52 #include "G4OpenGLImmediateX.hh" // no_geant4_module_check 53 #include "G4OpenGLStoredX.hh" // no_geant4_module_check 54 #endif 55 56 #ifdef G4VIS_USE_OPENGLWIN32 57 #include "G4OpenGLImmediateWin32.hh" // no_geant4_module_check 58 #include "G4OpenGLStoredWin32.hh" // no_geant4_module_check 59 #endif 60 61 #ifdef G4VIS_USE_OPENGLXM 62 #include "G4OpenGLImmediateXm.hh" // no_geant4_module_check 63 #include "G4OpenGLStoredXm.hh" // no_geant4_module_check 64 #endif 65 66 #ifdef G4VIS_USE_OPENGLQT 67 #include "G4OpenGLImmediateQt.hh" // no_geant4_module_check 68 #include "G4OpenGLStoredQt.hh" // no_geant4_module_check 69 #endif 70 71 #ifdef G4VIS_USE_OIX 72 #include "G4OpenInventorX.hh" // no_geant4_module_check 73 #include "G4OpenInventorXtExtended.hh" // no_geant4_module_check 74 #endif 75 76 #ifdef G4VIS_USE_OIQT 77 #include "G4OpenInventorQt.hh" // no_geant4_module_check 78 #endif 79 80 #ifdef G4VIS_USE_OIWIN32 81 #include "G4OpenInventorWin32.hh" // no_geant4_module_check 82 #endif 83 84 #ifdef G4VIS_USE_RAYTRACERX 85 #include "G4RayTracerX.hh" // no_geant4_module_check 86 #endif 87 88 #ifdef G4VIS_USE_QT3D 89 #include "G4Qt3D.hh" // no_geant4_module_check 90 #endif 91 92 #ifdef G4VIS_USE_TOOLSSG_X11_GLES 93 #include "G4ToolsSGX11GLES.hh" // no_geant4_module_check 94 #endif 95 96 #ifdef G4VIS_USE_TOOLSSG_X11_ZB 97 #include "G4ToolsSGX11ZB.hh" // no_geant4_module_check 98 #endif 99 100 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_GLES 101 #include "G4ToolsSGWindowsGLES.hh" // no_geant4_module_check 102 #endif 103 104 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_ZB 105 #include "G4ToolsSGWindowsZB.hh" // no_geant4_module_check 106 #endif 107 108 #ifdef G4VIS_USE_TOOLSSG_XT_GLES 109 #include "G4ToolsSGXtGLES.hh" // no_geant4_module_check 110 #endif 111 112 #ifdef G4VIS_USE_TOOLSSG_XT_ZB 113 #include "G4ToolsSGXtZB.hh" // no_geant4_module_check 114 #endif 115 116 #ifdef G4VIS_USE_TOOLSSG_QT_GLES 117 #include "G4ToolsSGQtGLES.hh" // no_geant4_module_check 118 #endif 119 120 #ifdef G4VIS_USE_TOOLSSG_QT_ZB 121 #include "G4ToolsSGQtZB.hh" // no_geant4_module_check 122 #endif 123 124 #ifdef G4VIS_USE_VTK 125 #include "G4Vtk.hh" // no_geant4_module_check 126 #include "G4VtkOffscreen.hh" // no_geant4_module_check 127 #undef G4VIS_USE_TOOLSSG_X11_GLES 128 #undef G4VIS_USE_TOOLSSG_XT_GLES 129 #undef G4VIS_USE_TOOLSSG_QT_GLES 130 #undef G4VIS_USE_TOOLSSG_WINDOWS_GLES 131 #undef G4VIS_USE_OPENGLQT 132 #undef G4VIS_USE_OPENGLXM 133 #undef G4VIS_USE_OPENGLX 134 #undef G4VIS_USE_OPENGLWIN32 135 #endif 136 137 #ifdef G4VIS_USE_VTK_QT 138 #include "G4VtkQt.hh" // no_geant4_module_check 139 #endif 140 141 #include "G4UImanager.hh" 142 #include "G4UIsession.hh" 143 #include "G4UIbatch.hh" 144 145 #include <cstdlib> 146 #include <sstream> 147 148 #define G4warn G4cout 149 150 // The inline keyword prevents the compiler making an external 151 // reference even though they cannot actually be inlined since they 152 // are virtual functions. This prevents a "multiple definition" error 153 // if it is included in more than one file. However, as explained in 154 // the class description in G4VisExecutive.hh, it should never be 155 // necessary to #include "G4VisExecutive.hh" in more than one file 156 // since after instantiation the object can be treated as a 157 // G4VisManager. 158 159 inline 160 G4VisExecutive::G4VisExecutive(int argc, char** argv, const G4String& system, 161 const G4String& verbosityString): 162 G4VisManager(verbosityString), 163 fSelected(false) 164 { 165 fUserArgc = argc; 166 fUserArgv = argv; 167 fUserSpecifiedSystem = system; 168 } 169 170 inline 171 G4VisExecutive::G4VisExecutive (const G4String& verbosityString): 172 G4VisManager(verbosityString) 173 , fUserArgc(0) // >0 if argc is provided by the user... 174 , fUserArgv(nullptr) 175 , fSelected(false) 176 {} 177 178 inline 179 const G4String& G4VisExecutive::GetDefaultGraphicsSystemName () 180 { 181 if (fSelected) return fDefaultGraphicsSystemName; 182 if (fUserArgc > 0) SetDefaultsByArgument(fUserSpecifiedSystem); 183 if (!fSelected) SetDefaultsByEnvironment(); 184 if (!fSelected && fUserArgc > 0) SetDefaultsByFile(fUserArgc, fUserArgv); 185 if (!fSelected) { SetDefaultsByBatch(); 186 if (fSelected) { // No UI session 187 // Deal with this later - the user may have specified a system 188 // on the command line - see G4VisCommandSceneHandlerCreate. 189 return fDefaultGraphicsSystemName; 190 } 191 } 192 if (!fSelected) SetDefaultsByBuildFlags(); 193 if (GetVerbosity() >= warnings) { 194 G4warn << "Default graphics system is: " << fDefaultGraphicsSystemName 195 << " (based on " << fDefaultGraphicsSystemBasis << ")." 196 << "\nDefault window size hint is: " << fDefaultXGeometryString 197 << " (based on " << fDefaultXGeometryStringBasis << ")." 198 << "\nNote: Parameters specified on the command line will override these defaults." 199 << "\n Use \"vis/open\" without parameters to get these defaults." 200 << G4endl; 201 } 202 return fDefaultGraphicsSystemName; 203 } 204 205 inline 206 void G4VisExecutive::SetDefaultsByArgument(const G4String& system) 207 { 208 // 1st priority: selection by G4VisExecutive argument 209 if (!system.empty()) { 210 fDefaultGraphicsSystemName = system; 211 fDefaultGraphicsSystemBasis = "G4VisExecuitive argument"; 212 fSelected = true; 213 } 214 } 215 216 inline 217 void G4VisExecutive::SetDefaultsByEnvironment() 218 { 219 // 2nd priority: by environment variable 220 if (auto g4env = std::getenv("G4VIS_DEFAULT_DRIVER")) { 221 G4String graphicsSystem, windowSizeHint; 222 std::istringstream iss(g4env); 223 iss >> graphicsSystem >> windowSizeHint; 224 if (!graphicsSystem.empty()) { 225 fDefaultGraphicsSystemName = graphicsSystem; 226 fDefaultGraphicsSystemBasis = "environment G4VIS_DEFAULT_DRIVER"; 227 fSelected = true; 228 } 229 if (!windowSizeHint.empty()) { 230 fDefaultXGeometryString = windowSizeHint; 231 fDefaultXGeometryStringBasis = "environment G4VIS_DEFAULT_DRIVER"; 232 } 233 } 234 } 235 236 inline 237 void G4VisExecutive::SetDefaultsByFile(int argc, char** argv) 238 { 239 // 3rd priority: in $HOME/.g4session 240 241 // Find ~/.g4session - simply return if it does not exist 242 const char* home = std::getenv("HOME"); 243 if (home == nullptr) return; 244 G4String homedir = home; 245 #ifndef WIN32 246 G4String filename = homedir + "/.g4session"; 247 #else 248 G4String filename = homedir + "\\.g4session"; 249 #endif 250 std::ifstream g4session(filename); 251 if (g4session.fail()) return; 252 253 // Find app name 254 if (argc < 1) return; 255 G4String appInput = argv[0]; 256 G4String appName = ""; 257 size_t islash = appInput.find_last_of("/\\"); 258 if (islash == G4String::npos) appName = appInput; 259 else appName = appInput.substr(islash + 1, appInput.size() - islash - 1); 260 261 // Scan ~/.g4session 262 G4String line; 263 // First line is the user-chosen default: session, graphics system, windo wize hint 264 G4String applicableSession, applicableGraphicsSystem, applicableWindowSizeHint; 265 std::getline(g4session,line); 266 auto hash = line.find_first_of('#'); line = line.substr(0,hash); 267 std::istringstream iss(line); 268 iss >> applicableSession >> applicableGraphicsSystem >> applicableWindowSizeHint; 269 // Read subsequent lines 270 while (g4session.good()) { 271 G4String app, session, graphicsSystem, windowSizeHint; 272 std::getline(g4session,line); 273 hash = line.find_first_of('#'); line = line.substr(0,hash); 274 std::istringstream iss1(line); 275 iss1 >> app >> session >> graphicsSystem >> windowSizeHint; 276 if (app == appName) { 277 if (!session.empty()) applicableSession = session; // See G4UIExecutive 278 if (!graphicsSystem.empty()) applicableGraphicsSystem = graphicsSystem; 279 if (!windowSizeHint.empty()) applicableWindowSizeHint = windowSizeHint; 280 } 281 } 282 283 if (!applicableGraphicsSystem.empty()) { 284 fDefaultGraphicsSystemName = applicableGraphicsSystem; 285 fDefaultGraphicsSystemBasis = "~/.g4session"; 286 fSelected = true; 287 } 288 if (!applicableWindowSizeHint.empty()) { 289 fDefaultXGeometryString = applicableWindowSizeHint; 290 fDefaultXGeometryStringBasis = "~/.g4session"; 291 } 292 } 293 294 inline 295 void G4VisExecutive::SetDefaultsByBatch() 296 { 297 // 4th, special case for batch session 298 G4UIsession* session = G4UImanager::GetUIpointer()->GetBaseSession(); 299 if (session == nullptr // Usual case - pure batch 300 || dynamic_cast<G4UIbatch*>(session)) { // From a macro from batch 301 // Actually, in this case, we wish to force the user to specify a driver 302 fDefaultGraphicsSystemName = "NO_UI_SESSION"; 303 fDefaultGraphicsSystemBasis = "no UI session"; 304 fSelected = true; // To prevent any further selection 305 } 306 } 307 308 inline 309 void G4VisExecutive::SetDefaultsByBuildFlags() 310 { 311 // 5th, by cpp flags 312 #if defined G4VIS_USE_OPENGLQT || G4VIS_USE_OPENGLXM ||\ 313 G4VIS_USE_OPENGLX || G4VIS_USE_OPENGLWIN32 314 fDefaultGraphicsSystemName = "OGL"; 315 #elif defined G4VIS_USE_OI || G4VIS_USE_OIX 316 fDefaultGraphicsSystemName = "OI"; 317 #elif defined G4VIS_USE_TOOLSSG_QT_GLES || G4VIS_USE_TOOLSSG_X11_GLES ||\ 318 G4VIS_USE_TOOLSSG_XT_GLES || G4VIS_USE_TOOLSSG_WINDOWS_GLES 319 fDefaultGraphicsSystemName = "TSG"; 320 #elif defined G4VIS_USE_VTK || G4VIS_USE_VTK_QT 321 fDefaultGraphicsSystemName = "Vtk"; 322 #elif defined G4VIS_USE_TOOLSSG_QT_ZB || G4VIS_USE_TOOLSSG_X11_ZB ||\ 323 G4VIS_USE_TOOLSSG_XT_ZB || G4VIS_USE_TOOLSSG_WINDOWS_ZB 324 fDefaultGraphicsSystemName = "TSG"; 325 #elif defined G4VIS_USE_QT3D 326 fDefaultGraphicsSystemName = "Qt3D"; 327 #else 328 // Choose a graphics system not needing external packages or libraries 329 fDefaultGraphicsSystemName = "TSG_OFFSCREEN"; 330 #endif 331 fDefaultGraphicsSystemBasis = "build flags"; 332 fSelected = true; 333 } 334 335 inline 336 void G4VisExecutive::RegisterGraphicsSystems () { 337 338 // Graphics Systems not needing external packages or libraries... 339 RegisterGraphicsSystem (new G4ASCIITree); 340 RegisterGraphicsSystem (new G4DAWNFILE); 341 RegisterGraphicsSystem (new G4HepRepFile); 342 RegisterGraphicsSystem (new G4RayTracer); 343 RegisterGraphicsSystem (new G4VRML2File); 344 RegisterGraphicsSystem (new G4GMocrenFile); 345 G4VGraphicsSystem* tsg_offscreen = new G4ToolsSGOffscreen; 346 RegisterGraphicsSystem(tsg_offscreen); 347 tsg_offscreen->AddNickname("TSG_FILE"); 348 349 // Graphics systems needing external packages or libraries... 350 // Register OGL family of drivers with their normal names, 351 // super-abbreviated names and fallback names where approproiate. 352 353 #ifdef G4VIS_USE_OPENGLQT 354 G4VGraphicsSystem* ogliqt = new G4OpenGLImmediateQt; 355 G4VGraphicsSystem* oglsqt = new G4OpenGLStoredQt; 356 RegisterGraphicsSystem(ogliqt); 357 RegisterGraphicsSystem(oglsqt); 358 ogliqt->AddNickname("OGLI"); 359 oglsqt->AddNickname("OGL"); 360 oglsqt->AddNickname("OGLS"); 361 #endif 362 363 #ifdef G4VIS_USE_OPENGLXM 364 G4VGraphicsSystem* oglixm = new G4OpenGLImmediateXm; 365 G4VGraphicsSystem* oglsxm = new G4OpenGLStoredXm; 366 RegisterGraphicsSystem(oglixm); 367 RegisterGraphicsSystem(oglsxm); 368 # ifdef G4VIS_USE_OPENGLQT 369 oglixm->AddNickname("OGLIQt_FALLBACK"); 370 oglsxm->AddNickname("OGLSQt_FALLBACK"); 371 # else 372 oglixm->AddNickname("OGLI"); 373 oglsxm->AddNickname("OGL"); 374 oglsxm->AddNickname("OGLS"); 375 # endif 376 #endif 377 378 #ifdef G4VIS_USE_OPENGLX 379 G4VGraphicsSystem* oglix = new G4OpenGLImmediateX; 380 G4VGraphicsSystem* oglsx = new G4OpenGLStoredX; 381 RegisterGraphicsSystem(oglix); 382 RegisterGraphicsSystem(oglsx); 383 # ifdef G4VIS_USE_OPENGLQT 384 oglix->AddNickname("OGLIQt_FALLBACK"); 385 oglsx->AddNickname("OGLSQt_FALLBACK"); 386 # endif 387 # ifdef G4VIS_USE_OPENGLXM 388 oglix->AddNickname("OGLIXm_FALLBACK"); 389 oglsx->AddNickname("OGLSXm_FALLBACK"); 390 # endif 391 # if defined(G4VIS_USE_OPENGLQT) || (G4VIS_USE_OPENGLXM) 392 # else 393 oglix->AddNickname("OGLI"); 394 oglsx->AddNickname("OGL"); 395 oglsx->AddNickname("OGLS"); 396 # endif 397 #endif 398 399 #ifdef G4VIS_USE_OPENGLWIN32 400 G4VGraphicsSystem* ogliwin32 = new G4OpenGLImmediateWin32; 401 G4VGraphicsSystem* oglswin32 = new G4OpenGLStoredWin32; 402 RegisterGraphicsSystem(ogliwin32); 403 RegisterGraphicsSystem(oglswin32); 404 # ifdef G4VIS_USE_OPENGLQT 405 ogliwin32->AddNickname("OGLIQt_FALLBACK"); 406 oglswin32->AddNickname("OGLSQt_FALLBACK"); 407 # else 408 ogliwin32->AddNickname("OGLI"); 409 oglswin32->AddNickname("OGL"); 410 oglswin32->AddNickname("OGLS"); 411 # endif 412 #endif 413 414 // Register OI graphics system with super-abbreviated nickname 415 #ifdef G4VIS_USE_OI 416 G4VGraphicsSystem* oi = 0; 417 # ifdef G4VIS_USE_OIX 418 oi = new G4OpenInventorX; 419 # elif defined(G4VIS_USE_OIQT) 420 oi = new G4OpenInventorQt; 421 # elif defined(G4VIS_USE_OIWIN32) 422 oi = new G4OpenInventorWin32; 423 # endif 424 if(oi) 425 { 426 RegisterGraphicsSystem(oi); 427 oi->AddNickname("OI"); 428 } 429 #endif 430 431 // The new, extended OI is registered separately for now. 432 #ifdef G4VIS_USE_OIX 433 RegisterGraphicsSystem(new G4OpenInventorXtExtended); 434 #endif 435 436 #ifdef G4VIS_USE_RAYTRACERX 437 RegisterGraphicsSystem(new G4RayTracerX); 438 #endif 439 440 #ifdef G4VIS_USE_QT3D 441 RegisterGraphicsSystem(new G4Qt3D); 442 #endif 443 444 #ifdef G4VIS_USE_TOOLSSG_X11_GLES 445 G4VGraphicsSystem* tsg_x11_gles = new G4ToolsSGX11GLES; 446 RegisterGraphicsSystem(tsg_x11_gles); 447 tsg_x11_gles->AddNickname("TSGX11"); 448 #ifdef G4VIS_USE_TOOLSSG_XT_GLES 449 tsg_x11_gles->AddNickname("TSG_XT_GLES_FALLBACK"); 450 #endif 451 #ifdef G4VIS_USE_TOOLSSG_QT_GLES 452 #ifndef G4VIS_USE_TOOLSSG_XT_GLES 453 tsg_x11_gles->AddNickname("TSG_QT_GLES_FALLBACK"); 454 #endif 455 #endif 456 #endif 457 458 #ifdef G4VIS_USE_TOOLSSG_X11_ZB 459 G4VGraphicsSystem* tsg_x11_zb = new G4ToolsSGX11ZB; 460 RegisterGraphicsSystem(tsg_x11_zb); 461 tsg_x11_zb->AddNickname("TSGX11ZB"); 462 #endif 463 464 #ifdef G4VIS_USE_TOOLSSG_XT_GLES 465 G4VGraphicsSystem* tsg_xt_gles = new G4ToolsSGXtGLES; 466 RegisterGraphicsSystem(tsg_xt_gles); 467 tsg_xt_gles->AddNickname("TSGXt"); 468 #ifdef G4VIS_USE_TOOLSSG_QT_GLES 469 tsg_xt_gles->AddNickname("TSG_QT_GLES_FALLBACK"); 470 #endif 471 #endif 472 473 #ifdef G4VIS_USE_TOOLSSG_XT_ZB 474 G4VGraphicsSystem* tsg_xt_zb = new G4ToolsSGXtZB; 475 RegisterGraphicsSystem(tsg_xt_zb); 476 tsg_xt_zb->AddNickname("TSGXtZB"); 477 #endif 478 479 #ifdef G4VIS_USE_TOOLSSG_QT_GLES 480 G4VGraphicsSystem* tsg_qt_gles = new G4ToolsSGQtGLES; 481 RegisterGraphicsSystem(tsg_qt_gles); 482 tsg_qt_gles->AddNickname("TSGQt"); 483 #endif 484 485 #ifdef G4VIS_USE_TOOLSSG_QT_ZB 486 G4VGraphicsSystem* tsg_qt_zb = new G4ToolsSGQtZB; 487 RegisterGraphicsSystem(tsg_qt_zb); 488 tsg_qt_zb->AddNickname("TSGQtZB"); 489 #endif 490 491 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_GLES 492 G4VGraphicsSystem* tsg_windows_gles = new G4ToolsSGWindowsGLES; 493 RegisterGraphicsSystem(tsg_windows_gles); 494 #endif 495 496 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_ZB 497 G4VGraphicsSystem* tsg_windows_zb = new G4ToolsSGWindowsZB; 498 RegisterGraphicsSystem(tsg_windows_zb); 499 #endif 500 501 #ifdef G4VIS_USE_TOOLSSG_QT_GLES 502 tsg_qt_gles->AddNickname("TSG"); 503 #elif defined(G4VIS_USE_TOOLSSG_XT_GLES) 504 tsg_xt_gles->AddNickname("TSG"); 505 #elif defined(G4VIS_USE_TOOLSSG_X11_GLES) 506 tsg_x11_gles->AddNickname("TSG"); 507 #elif defined(G4VIS_USE_TOOLSSG_WINDOWS_GLES) 508 tsg_windows_gles->AddNickname("TSG"); 509 #else 510 #ifdef G4VIS_USE_TOOLSSG_QT_ZB 511 tsg_qt_zb->AddNickname("TSG"); 512 #elif G4VIS_USE_TOOLSSG_WINDOWS_ZB 513 tsg_windows_zb->AddNickname("TSG"); 514 #else 515 tsg_offscreen->AddNickname("TSG"); 516 #endif 517 #endif 518 519 #ifdef G4VIS_USE_VTK 520 if (GetVerbosity() >= startup) { 521 G4cout 522 << " VTK: OpenGL-based drivers suppressed because of compatibility issues." 523 << G4endl; 524 } 525 G4Vtk* vtkN = new G4Vtk(); 526 G4VtkOffscreen* vtkOS = new G4VtkOffscreen(); 527 RegisterGraphicsSystem(vtkN); 528 RegisterGraphicsSystem(vtkOS); 529 # ifdef G4VIS_USE_VTK_QT 530 vtkN->AddNickname("VTKQt_FALLBACK"); 531 # endif 532 #endif 533 534 #ifdef G4VIS_USE_VTK_QT 535 G4VtkQt* vtkQt = new G4VtkQt(); 536 RegisterGraphicsSystem(vtkQt); 537 vtkQt->AddNickname("VTKQt"); 538 #endif 539 540 #ifdef G4VIS_USE_VTK_QT 541 vtkQt->AddNickname("Vtk"); 542 vtkQt->AddNickname("VTK"); 543 #elif defined(G4VIS_USE_VTK) 544 vtkN->AddNickname("Vtk"); 545 vtkN->AddNickname("VTK"); 546 #endif 547 } 548 549 // See comments about inlining above. 550 inline void 551 G4VisExecutive::RegisterModelFactories() 552 { 553 // Trajectory draw models 554 RegisterModelFactory(new G4TrajectoryGenericDrawerFactory()); 555 RegisterModelFactory(new G4TrajectoryDrawByAttributeFactory()); 556 RegisterModelFactory(new G4TrajectoryDrawByChargeFactory()); 557 RegisterModelFactory(new G4TrajectoryDrawByOriginVolumeFactory()); 558 RegisterModelFactory(new G4TrajectoryDrawByParticleIDFactory()); 559 RegisterModelFactory(new G4TrajectoryDrawByEncounteredVolumeFactory()); 560 561 // Trajectory filter models 562 RegisterModelFactory(new G4TrajectoryAttributeFilterFactory()); 563 RegisterModelFactory(new G4TrajectoryChargeFilterFactory()); 564 RegisterModelFactory(new G4TrajectoryOriginVolumeFilterFactory()); 565 RegisterModelFactory(new G4TrajectoryParticleFilterFactory()); 566 RegisterModelFactory(new G4TrajectoryEncounteredVolumeFilterFactory()); 567 568 // Hit filter models 569 RegisterModelFactory(new G4HitAttributeFilterFactory()); 570 571 // Digi filter models 572 RegisterModelFactory(new G4DigiAttributeFilterFactory()); 573 } 574 575 #endif 576