Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VSceneHandler.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/G4VSceneHandler.cc (Version 11.3.0) and /visualization/management/src/G4VSceneHandler.cc (Version 8.1)


  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: G4VSceneHandler.cc,v 1.66 2006/06/29 21:29:24 gunter Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-08-01 $
 27 //                                                 29 //
 28 //                                                 30 // 
 29 // John Allison  19th July 1996                    31 // John Allison  19th July 1996
 30 // Abstract interface class for graphics scene     32 // Abstract interface class for graphics scenes.
 31                                                    33 
 32 #include "G4VSceneHandler.hh"                      34 #include "G4VSceneHandler.hh"
 33                                                    35 
 34 #include "G4ios.hh"                                36 #include "G4ios.hh"
 35 #include <sstream>                                 37 #include <sstream>
 36                                                    38 
 37 #include "G4VisManager.hh"                         39 #include "G4VisManager.hh"
 38 #include "G4VGraphicsSystem.hh"                    40 #include "G4VGraphicsSystem.hh"
 39 #include "G4VViewer.hh"                            41 #include "G4VViewer.hh"
 40 #include "G4VSolid.hh"                             42 #include "G4VSolid.hh"
 41 #include "G4RotationMatrix.hh"                     43 #include "G4RotationMatrix.hh"
 42 #include "G4ThreeVector.hh"                        44 #include "G4ThreeVector.hh"
 43 #include "G4VPhysicalVolume.hh"                    45 #include "G4VPhysicalVolume.hh"
 44 #include "G4Material.hh"                           46 #include "G4Material.hh"
 45 #include "G4Polyline.hh"                           47 #include "G4Polyline.hh"
                                                   >>  48 #include "G4Scale.hh"
 46 #include "G4Text.hh"                               49 #include "G4Text.hh"
 47 #include "G4Circle.hh"                             50 #include "G4Circle.hh"
 48 #include "G4Square.hh"                             51 #include "G4Square.hh"
 49 #include "G4Polymarker.hh"                         52 #include "G4Polymarker.hh"
 50 #include "G4Polyhedron.hh"                         53 #include "G4Polyhedron.hh"
                                                   >>  54 #include "G4NURBS.hh"
 51 #include "G4Visible.hh"                            55 #include "G4Visible.hh"
 52 #include "G4VisAttributes.hh"                      56 #include "G4VisAttributes.hh"
 53 #include "G4VModel.hh"                             57 #include "G4VModel.hh"
 54 #include "G4TrajectoriesModel.hh"                  58 #include "G4TrajectoriesModel.hh"
 55 #include "G4Box.hh"                                59 #include "G4Box.hh"
 56 #include "G4Cons.hh"                               60 #include "G4Cons.hh"
 57 #include "G4Orb.hh"                            <<  61 #include "G4Tubs.hh"
 58 #include "G4Para.hh"                           <<  62 #include "G4Trd.hh"
                                                   >>  63 #include "G4Trap.hh"
 59 #include "G4Sphere.hh"                             64 #include "G4Sphere.hh"
                                                   >>  65 #include "G4Para.hh"
 60 #include "G4Torus.hh"                              66 #include "G4Torus.hh"
 61 #include "G4Trap.hh"                           << 
 62 #include "G4Trd.hh"                            << 
 63 #include "G4Tubs.hh"                           << 
 64 #include "G4Ellipsoid.hh"                      << 
 65 #include "G4Polycone.hh"                           67 #include "G4Polycone.hh"
 66 #include "G4Polyhedra.hh"                          68 #include "G4Polyhedra.hh"
 67 #include "G4Tet.hh"                            << 
 68 #include "G4DisplacedSolid.hh"                 << 
 69 #include "G4UnionSolid.hh"                     << 
 70 #include "G4IntersectionSolid.hh"              << 
 71 #include "G4SubtractionSolid.hh"               << 
 72 #include "G4LogicalVolume.hh"                      69 #include "G4LogicalVolume.hh"
 73 #include "G4PhysicalVolumeModel.hh"                70 #include "G4PhysicalVolumeModel.hh"
 74 #include "G4ModelingParameters.hh"                 71 #include "G4ModelingParameters.hh"
 75 #include "G4VTrajectory.hh"                        72 #include "G4VTrajectory.hh"
 76 #include "G4VTrajectoryPoint.hh"               << 
 77 #include "G4HitsModel.hh"                      << 
 78 #include "G4VHit.hh"                               73 #include "G4VHit.hh"
 79 #include "G4VDigi.hh"                          <<  74 #include "Randomize.hh"
 80 #include "G4ScoringManager.hh"                 << 
 81 #include "G4VScoringMesh.hh"                   << 
 82 #include "G4Mesh.hh"                           << 
 83 #include "G4DefaultLinearColorMap.hh"          << 
 84 #include "G4QuickRand.hh"                      << 
 85 #include "G4StateManager.hh"                       75 #include "G4StateManager.hh"
 86 #include "G4RunManager.hh"                         76 #include "G4RunManager.hh"
 87 #include "G4RunManagerFactory.hh"              << 
 88 #include "G4Run.hh"                            << 
 89 #include "G4Transform3D.hh"                    << 
 90 #include "G4AttHolder.hh"                      << 
 91 #include "G4AttDef.hh"                         << 
 92 #include "G4SceneTreeItem.hh"                  << 
 93 #include "G4VVisCommand.hh"                    << 
 94 #include "G4PhysicalConstants.hh"              << 
 95 #include "G4SystemOfUnits.hh"                  << 
 96                                                << 
 97 #define G4warn G4cout                          << 
 98                                                    77 
 99 G4VSceneHandler::G4VSceneHandler (G4VGraphicsS     78 G4VSceneHandler::G4VSceneHandler (G4VGraphicsSystem& system, G4int id, const G4String& name):
100   fSystem                (system),                 79   fSystem                (system),
101   fSceneHandlerId        (id),                     80   fSceneHandlerId        (id),
102   fViewCount             (0),                      81   fViewCount             (0),
103   fpViewer               (0),                      82   fpViewer               (0),
104   fpScene                (0),                      83   fpScene                (0),
105   fMarkForClearingTransientStore (true),  // R     84   fMarkForClearingTransientStore (true),  // Ready for first
106             // ClearTransientStoreIfMarked(),      85             // ClearTransientStoreIfMarked(),
107             // e.g., at end of run (see            86             // e.g., at end of run (see
108             // G4VisManager.cc).                   87             // G4VisManager.cc).
109   fReadyForTransients    (true),  // Only fals     88   fReadyForTransients    (true),  // Only false while processing scene.
110   fProcessingSolid       (false),                  89   fProcessingSolid       (false),
111   fProcessing2D          (false),              <<  90   fSecondPassRequested   (false),
                                                   >>  91   fSecondPass            (false),
112   fpModel                (0),                      92   fpModel                (0),
                                                   >>  93   fpObjectTransformation (0),
113   fNestingDepth          (0),                      94   fNestingDepth          (0),
114   fpVisAttribs           (0)                   <<  95   fpVisAttribs           (0),
                                                   >>  96   fCurrentDepth          (0),
                                                   >>  97   fpCurrentPV            (0),
                                                   >>  98   fpCurrentLV            (0)
115 {                                                  99 {
116   G4VisManager* pVMan = G4VisManager::GetInsta    100   G4VisManager* pVMan = G4VisManager::GetInstance ();
117   fpScene = pVMan -> GetCurrentScene ();          101   fpScene = pVMan -> GetCurrentScene ();
118   if (name == "") {                               102   if (name == "") {
119     std::ostringstream ost;                       103     std::ostringstream ost;
120     ost << fSystem.GetName () << '-' << fScene    104     ost << fSystem.GetName () << '-' << fSceneHandlerId;
121     fName = ost.str();                            105     fName = ost.str();
122   }                                               106   }
123   else {                                          107   else {
124     fName = name;                                 108     fName = name;
125   }                                               109   }
126   fTransientsDrawnThisEvent = pVMan->GetTransi    110   fTransientsDrawnThisEvent = pVMan->GetTransientsDrawnThisEvent();
127   fTransientsDrawnThisRun = pVMan->GetTransien    111   fTransientsDrawnThisRun = pVMan->GetTransientsDrawnThisRun();
128 }                                                 112 }
129                                                   113 
130 G4VSceneHandler::~G4VSceneHandler () {            114 G4VSceneHandler::~G4VSceneHandler () {
131   G4VViewer* last;                             << 115   G4ViewerListIterator i;
132   while( ! fViewerList.empty() ) {             << 116   for (i = fViewerList.begin(); i != fViewerList.end(); ++i) {
133     last = fViewerList.back();                 << 117     delete *i;
134     fViewerList.pop_back();                    << 
135     delete last;                               << 
136   }                                            << 
137 }                                              << 
138                                                << 
139 const G4VisExtent& G4VSceneHandler::GetExtent( << 
140 {                                              << 
141   if (fpScene) {                               << 
142     return fpScene->GetExtent();               << 
143   } else {                                     << 
144     static const G4VisExtent defaultExtent = G << 
145     return defaultExtent;                      << 
146   }                                               118   }
147 }                                                 119 }
148                                                   120 
149 void G4VSceneHandler::PreAddSolid (const G4Tra    121 void G4VSceneHandler::PreAddSolid (const G4Transform3D& objectTransformation,
150            const G4VisAttributes& visAttribs)  << 122                                   const G4VisAttributes& visAttribs) {
151   fObjectTransformation = objectTransformation << 123   fpObjectTransformation = &objectTransformation;
152   fpVisAttribs = &visAttribs;                     124   fpVisAttribs = &visAttribs;
153   fProcessingSolid = true;                        125   fProcessingSolid = true;
154 }                                                 126 }
155                                                   127 
156 void G4VSceneHandler::PostAddSolid () {           128 void G4VSceneHandler::PostAddSolid () {
                                                   >> 129   fpObjectTransformation = 0;
157   fpVisAttribs = 0;                               130   fpVisAttribs = 0;
158   fProcessingSolid = false;                       131   fProcessingSolid = false;
159   if (fReadyForTransients) {                      132   if (fReadyForTransients) {
160     fTransientsDrawnThisEvent = true;             133     fTransientsDrawnThisEvent = true;
161     fTransientsDrawnThisRun = true;               134     fTransientsDrawnThisRun = true;
162   }                                               135   }
163 }                                                 136 }
164                                                   137 
165 void G4VSceneHandler::BeginPrimitives             138 void G4VSceneHandler::BeginPrimitives
166 (const G4Transform3D& objectTransformation) {     139 (const G4Transform3D& objectTransformation) {
167   //static G4int count = 0;                    << 
168   //G4cout << "G4VSceneHandler::BeginPrimitive << 
169   fNestingDepth++;                                140   fNestingDepth++;
170   if (fNestingDepth > 1)                          141   if (fNestingDepth > 1)
171     G4Exception                                << 142     G4Exception("G4VSceneHandler::BeginPrimitives: Nesting detected."
172       ("G4VSceneHandler::BeginPrimitives",     << 143     "\n  It is illegal to nest Begin/EndPrimitives.");
173        "visman0101", FatalException,           << 144   fpObjectTransformation = &objectTransformation;
174        "Nesting detected. It is illegal to nes << 
175   fObjectTransformation = objectTransformation << 
176 }                                                 145 }
177                                                   146 
178 void G4VSceneHandler::EndPrimitives () {          147 void G4VSceneHandler::EndPrimitives () {
179   if (fNestingDepth <= 0)                         148   if (fNestingDepth <= 0)
180     G4Exception("G4VSceneHandler::EndPrimitive << 149     G4Exception("G4VSceneHandler::EndPrimitives: Nesting error");
181     "visman0102", FatalException, "Nesting err << 
182   fNestingDepth--;                                150   fNestingDepth--;
                                                   >> 151   fpObjectTransformation = 0;
183   if (fReadyForTransients) {                      152   if (fReadyForTransients) {
184     fTransientsDrawnThisEvent = true;             153     fTransientsDrawnThisEvent = true;
185     fTransientsDrawnThisRun = true;               154     fTransientsDrawnThisRun = true;
186   }                                               155   }
187 }                                                 156 }
188                                                   157 
189 void G4VSceneHandler::BeginPrimitives2D        << 158 void G4VSceneHandler::BeginPrimitives2D () {
190 (const G4Transform3D& objectTransformation) {  << 
191   fNestingDepth++;                                159   fNestingDepth++;
192   if (fNestingDepth > 1)                          160   if (fNestingDepth > 1)
193     G4Exception                                << 161     G4Exception("G4VSceneHandler::BeginPrimitives2D: Nesting detected."
194       ("G4VSceneHandler::BeginPrimitives2D",   << 162     "\n  It is illegal to nest Begin/EndPrimitives.");
195        "visman0103", FatalException,           << 163   // Not actually required for 2D operations but some drivers do an
196        "Nesting detected. It is illegal to nes << 164   // initial transformation...
197   fObjectTransformation = objectTransformation << 165   fpObjectTransformation = &fIdentityTransformation;
198   fProcessing2D = true;                        << 
199 }                                                 166 }
200                                                   167 
201 void G4VSceneHandler::EndPrimitives2D () {        168 void G4VSceneHandler::EndPrimitives2D () {
202   if (fNestingDepth <= 0)                         169   if (fNestingDepth <= 0)
203     G4Exception("G4VSceneHandler::EndPrimitive << 170     G4Exception("G4VSceneHandler::EndPrimitives2D: Nesting error");
204     "visman0104", FatalException, "Nesting err << 
205   fNestingDepth--;                                171   fNestingDepth--;
                                                   >> 172   fpObjectTransformation = 0;
206   if (fReadyForTransients) {                      173   if (fReadyForTransients) {
207     fTransientsDrawnThisEvent = true;             174     fTransientsDrawnThisEvent = true;
208     fTransientsDrawnThisRun = true;               175     fTransientsDrawnThisRun = true;
209   }                                               176   }
210   fProcessing2D = false;                       << 
211 }                                                 177 }
212                                                   178 
213 void G4VSceneHandler::BeginModeling () {          179 void G4VSceneHandler::BeginModeling () {
214 }                                                 180 }
215                                                   181 
216 void G4VSceneHandler::EndModeling ()              182 void G4VSceneHandler::EndModeling ()
217 {                                                 183 {
218   fpModel = 0;                                    184   fpModel = 0;
219 }                                                 185 }
220                                                   186 
221 void G4VSceneHandler::ClearStore () {}         << 187 void G4VSceneHandler::ClearStore () {
222                                                << 188   // if (fpViewer) fpViewer -> NeedKernelVisit (true);
223 void G4VSceneHandler::ClearTransientStore () { << 189   // ?? Viewer is supposed to be smart enough to know when to visit
224                                                << 190   // kernel, but a problem in OpenGL Stored seems to require a forced
225 template <class T> void G4VSceneHandler::AddSo << 191   // kernel visit triggered by the above code.  John Allison Aug 2001
226 (const T& solid)                               << 192   // Feb 2005 - commented out.  Let's fix OpenGL if necessary.
227 {                                              << 
228   // Get and check applicable vis attributes.  << 
229   fpVisAttribs = fpViewer->GetApplicableVisAtt << 
230   RequestPrimitives (solid);                   << 
231 }                                                 193 }
232                                                   194 
233 template <class T> void G4VSceneHandler::AddSo << 195 void G4VSceneHandler::ClearTransientStore () {
234 (const T& solid)                               << 
235 {                                              << 
236   // Get and check applicable vis attributes.  << 
237   fpVisAttribs = fpViewer->GetApplicableVisAtt << 
238   // Draw with auxiliary edges unless otherwis << 
239   if (!fpVisAttribs->IsForceAuxEdgeVisible())  << 
240     // Create a vis atts object for the modifi << 
241     // It is static so that we may return a re << 
242     static G4VisAttributes visAttsWithAuxEdges << 
243     // Initialise it with the current vis atts << 
244     visAttsWithAuxEdges = *fpVisAttribs;       << 
245     // Force auxiliary edges visible.          << 
246     visAttsWithAuxEdges.SetForceAuxEdgeVisible << 
247     fpVisAttribs = &visAttsWithAuxEdges;       << 
248   }                                            << 
249   RequestPrimitives (solid);                   << 
250 }                                                 196 }
251                                                   197 
252 void G4VSceneHandler::AddSolid (const G4Box& b    198 void G4VSceneHandler::AddSolid (const G4Box& box) {
253   AddSolidT (box);                             << 199   RequestPrimitives (box);
254   // If your graphics system is sophisticated  << 200 // If your graphics system is sophisticated enough to handle a
255   //  particular solid shape as a primitive, i << 201 //  particular solid shape as a primitive, in your derived class write a
256   //  function to override this.               << 202 //  function to override this.  (Note: some compilers warn that your
257   // Your function might look like this...     << 203 //  function "hides" this one.  That's OK.)
258   // void G4MySceneHandler::AddSolid (const G4 << 204 // Your function might look like this...
259   // Get and check applicable vis attributes.  << 205 // void G4MyScene::AddSolid (const G4Box& box) {
260   //   fpVisAttribs = fpViewer->GetApplicableV << 206 // Get parameters of appropriate object, e.g.:
261   // Do not draw if not visible.               << 207 //   G4double dx = box.GetXHalfLength ();
262   //   if (fpVisAttribs->IsVisible()) {        << 208 //   G4double dy = box.GetYHalfLength ();
263   //   Get parameters of appropriate object, e << 209 //   G4double dz = box.GetZHalfLength ();
264   //     G4double dx = box.GetXHalfLength ();  << 210 // and Draw or Store in your display List.
265   //     G4double dy = box.GetYHalfLength ();  << 
266   //     G4double dz = box.GetZHalfLength ();  << 
267   //     ...                                   << 
268   //     and Draw or Store in your display Lis << 
269 }                                              << 
270                                                << 
271 void G4VSceneHandler::AddSolid (const G4Cons&  << 
272   AddSolidT (cons);                            << 
273 }                                                 211 }
274                                                   212 
275 void G4VSceneHandler::AddSolid (const G4Orb& o << 213 void G4VSceneHandler::AddSolid (const G4Tubs& tubs) {
276   AddSolidWithAuxiliaryEdges (orb);            << 214   RequestPrimitives (tubs);
277 }                                              << 
278                                                << 
279 void G4VSceneHandler::AddSolid (const G4Para&  << 
280   AddSolidT (para);                            << 
281 }                                                 215 }
282                                                   216 
283 void G4VSceneHandler::AddSolid (const G4Sphere << 217 void G4VSceneHandler::AddSolid (const G4Cons& cons) {
284   AddSolidWithAuxiliaryEdges (sphere);         << 218   RequestPrimitives (cons);
285 }                                                 219 }
286                                                   220 
287 void G4VSceneHandler::AddSolid (const G4Torus& << 221 void G4VSceneHandler::AddSolid (const G4Trd& trd) {
288   AddSolidWithAuxiliaryEdges (torus);          << 222   RequestPrimitives (trd);
289 }                                                 223 }
290                                                   224 
291 void G4VSceneHandler::AddSolid (const G4Trap&     225 void G4VSceneHandler::AddSolid (const G4Trap& trap) {
292   AddSolidT (trap);                            << 226   RequestPrimitives (trap);
293 }                                                 227 }
294                                                   228 
295 void G4VSceneHandler::AddSolid (const G4Trd& t << 229 void G4VSceneHandler::AddSolid (const G4Sphere& sphere) {
296   AddSolidT (trd);                             << 230   RequestPrimitives (sphere );
297 }                                                 231 }
298                                                   232 
299 void G4VSceneHandler::AddSolid (const G4Tubs&  << 233 void G4VSceneHandler::AddSolid (const G4Para& para) {
300   AddSolidT (tubs);                            << 234   RequestPrimitives (para);
301 }                                                 235 }
302                                                   236 
303 void G4VSceneHandler::AddSolid (const G4Ellips << 237 void G4VSceneHandler::AddSolid (const G4Torus& torus) {
304   AddSolidWithAuxiliaryEdges (ellipsoid);      << 238   RequestPrimitives (torus);
305 }                                                 239 }
306                                                   240 
307 void G4VSceneHandler::AddSolid (const G4Polyco    241 void G4VSceneHandler::AddSolid (const G4Polycone& polycone) {
308   AddSolidT (polycone);                        << 242   RequestPrimitives (polycone);
309 }                                                 243 }
310                                                   244 
311 void G4VSceneHandler::AddSolid (const G4Polyhe    245 void G4VSceneHandler::AddSolid (const G4Polyhedra& polyhedra) {
312   AddSolidT (polyhedra);                       << 246   RequestPrimitives (polyhedra);
313 }                                              << 
314                                                << 
315 void G4VSceneHandler::AddSolid (const G4Tessel << 
316   AddSolidT (tess);                            << 
317 }                                                 247 }
318                                                   248 
319 void G4VSceneHandler::AddSolid (const G4VSolid    249 void G4VSceneHandler::AddSolid (const G4VSolid& solid) {
320   AddSolidT (solid);                           << 250   RequestPrimitives (solid);
321 }                                                 251 }
322                                                   252 
323 void G4VSceneHandler::AddCompound (const G4VTr    253 void G4VSceneHandler::AddCompound (const G4VTrajectory& traj) {
324   G4TrajectoriesModel* trajectoriesModel =     << 254   G4TrajectoriesModel* pTrModel =
325     dynamic_cast<G4TrajectoriesModel*>(fpModel    255     dynamic_cast<G4TrajectoriesModel*>(fpModel);
326   if (trajectoriesModel)                       << 256   if (!pTrModel) G4Exception
327     traj.DrawTrajectory();                     << 257     ("G4VSceneHandler::AddCompound(const G4VTrajectory&): Not a G4TrajectoriesModel.");
328   else {                                       << 258   traj.DrawTrajectory(pTrModel->GetDrawingMode());
329     G4Exception                                << 
330     ("G4VSceneHandler::AddCompound(const G4VTr << 
331      "visman0105", FatalException, "Not a G4Tr << 
332   }                                            << 
333 }                                                 259 }
334                                                   260 
335 void G4VSceneHandler::AddCompound (const G4VHi    261 void G4VSceneHandler::AddCompound (const G4VHit& hit) {
336   // Cast away const because Draw is non-const << 262   ((G4VHit&)hit).Draw(); // Cast to non-const because Draw is non-const!!!!
337   const_cast<G4VHit&>(hit).Draw();             << 
338 }                                                 263 }
339                                                   264 
340 void G4VSceneHandler::AddCompound (const G4VDi << 265 void G4VSceneHandler::AddViewerToList (G4VViewer* pViewer) {
341   // Cast away const because Draw is non-const << 266   fViewerList.push_back (pViewer);
342   const_cast<G4VDigi&>(digi).Draw();           << 
343 }                                              << 
344                                                << 
345 void G4VSceneHandler::AddCompound (const G4THi << 
346   using MeshScoreMap = G4VScoringMesh::MeshSco << 
347   //G4cout << "AddCompound: hits: " << &hits < << 
348   G4bool scoreMapHits = false;                 << 
349   G4ScoringManager* scoringManager = G4Scoring << 
350   if (scoringManager) {                        << 
351     std::size_t nMeshes = scoringManager->GetN << 
352     for (std::size_t iMesh = 0; iMesh < nMeshe << 
353       G4VScoringMesh* mesh = scoringManager->G << 
354       if (mesh && mesh->IsActive()) {          << 
355   MeshScoreMap scoreMap = mesh->GetScoreMap(); << 
356         const G4String& mapNam = const_cast<G4 << 
357   for(MeshScoreMap::const_iterator i = scoreMa << 
358       i != scoreMap.cend(); ++i) {             << 
359     const G4String& scoreMapName = i->first;   << 
360     if (scoreMapName == mapNam) {              << 
361       G4DefaultLinearColorMap colorMap("G4VSce << 
362       scoreMapHits = true;                     << 
363       mesh->DrawMesh(scoreMapName, &colorMap); << 
364     }                                          << 
365   }                                            << 
366       }                                        << 
367     }                                          << 
368   }                                            << 
369   if (scoreMapHits) {                          << 
370     static G4bool first = true;                << 
371     if (first) {                               << 
372       first = false;                           << 
373       G4cout <<                                << 
374   "Scoring map drawn with default parameters." << 
375   "\n  To get gMocren file for gMocren browser << 
376   "\n    /vis/open gMocrenFile"                << 
377   "\n    /vis/viewer/flush"                    << 
378   "\n  Many other options available with /scor << 
379   "\n  You might want to \"/vis/viewer/set/aut << 
380        << G4endl;                              << 
381     }                                          << 
382   } else {  // Not score map hits.  Just call  << 
383     // Cast away const because DrawAllHits is  << 
384     const_cast<G4THitsMap<G4double>&>(hits).Dr << 
385   }                                            << 
386 }                                                 267 }
387                                                   268 
388 void G4VSceneHandler::AddCompound (const G4THi << 269 void G4VSceneHandler::EstablishSpecials (G4PhysicalVolumeModel& pvModel) {
389   using MeshScoreMap = G4VScoringMesh::MeshSco << 270   pvModel.DefinePointersToWorkingSpace (&fCurrentDepth,
390   //G4cout << "AddCompound: hits: " << &hits < << 271           &fpCurrentPV,
391   G4bool scoreMapHits = false;                 << 272           &fpCurrentLV,
392   G4ScoringManager* scoringManager = G4Scoring << 273           &fpCurrentMaterial);
393   if (scoringManager) {                        << 274 }
394     std::size_t nMeshes = scoringManager->GetN << 275 
395     for (std::size_t iMesh = 0; iMesh < nMeshe << 276 void G4VSceneHandler::AddPrimitive (const G4Scale& scale) {
396       G4VScoringMesh* mesh = scoringManager->G << 277 
397       if (mesh && mesh->IsActive()) {          << 278   const G4double margin(0.01);
398   MeshScoreMap scoreMap = mesh->GetScoreMap(); << 279   // Fractional margin - ensures scale is comfortably inside viewing
399   for(MeshScoreMap::const_iterator i = scoreMa << 280   // volume.
400       i != scoreMap.cend(); ++i) {             << 281   const G4double oneMinusMargin (1. - margin);
401     const G4String& scoreMapName = i->first;   << 282 
402     const G4THitsMap<G4StatDouble>* foundHits  << 283   const G4VisExtent& sceneExtent = fpScene->GetExtent();
403     if (foundHits == &hits) {                  << 284 
404       G4DefaultLinearColorMap colorMap("G4VSce << 285   // Useful constants...
405       scoreMapHits = true;                     << 286   const G4double length(scale.GetLength());
406       mesh->DrawMesh(scoreMapName, &colorMap); << 287   const G4double halfLength(length / 2.);
407     }                                          << 288   const G4double tickLength(length / 20.);
408   }                                            << 289   const G4double piBy2(halfpi);
409       }                                        << 290 
410     }                                          << 291   // Get size of scene...
411   }                                            << 292   const G4double xmin = sceneExtent.GetXmin();
412   if (scoreMapHits) {                          << 293   const G4double xmax = sceneExtent.GetXmax();
413     static G4bool first = true;                << 294   const G4double ymin = sceneExtent.GetYmin();
414     if (first) {                               << 295   const G4double ymax = sceneExtent.GetYmax();
415       first = false;                           << 296   const G4double zmin = sceneExtent.GetZmin();
416       G4cout <<                                << 297   const G4double zmax = sceneExtent.GetZmax();
417   "Scoring map drawn with default parameters." << 298 
418   "\n  To get gMocren file for gMocren browser << 299   // Create (empty) polylines having the same vis attributes...
419   "\n    /vis/open gMocrenFile"                << 300   G4Polyline scaleLine, tick11, tick12, tick21, tick22;
420   "\n    /vis/viewer/flush"                    << 301   G4VisAttributes visAtts(*scale.GetVisAttributes());  // Long enough life.
421   "\n  Many other options available with /scor << 302   scaleLine.SetVisAttributes(&visAtts);
422   "\n  You might want to \"/vis/viewer/set/aut << 303   tick11.SetVisAttributes(&visAtts);
423        << G4endl;                              << 304   tick12.SetVisAttributes(&visAtts);
                                                   >> 305   tick21.SetVisAttributes(&visAtts);
                                                   >> 306   tick22.SetVisAttributes(&visAtts);
                                                   >> 307 
                                                   >> 308   // Add points to the polylines to represent an scale parallel to the
                                                   >> 309   // x-axis centred on the origin...
                                                   >> 310   G4Point3D r1(G4Point3D(-halfLength, 0., 0.));
                                                   >> 311   G4Point3D r2(G4Point3D( halfLength, 0., 0.));
                                                   >> 312   scaleLine.push_back(r1);
                                                   >> 313   scaleLine.push_back(r2);
                                                   >> 314   G4Point3D ticky(0., tickLength, 0.);
                                                   >> 315   G4Point3D tickz(0., 0., tickLength);
                                                   >> 316   tick11.push_back(r1 + ticky);
                                                   >> 317   tick11.push_back(r1 - ticky);
                                                   >> 318   tick12.push_back(r1 + tickz);
                                                   >> 319   tick12.push_back(r1 - tickz);
                                                   >> 320   tick21.push_back(r2 + ticky);
                                                   >> 321   tick21.push_back(r2 - ticky);
                                                   >> 322   tick22.push_back(r2 + tickz);
                                                   >> 323   tick22.push_back(r2 - tickz);
                                                   >> 324   G4Point3D textPosition(0., tickLength, 0.);
                                                   >> 325 
                                                   >> 326   // Transform appropriately...
                                                   >> 327 
                                                   >> 328   G4Transform3D transformation;
                                                   >> 329   if (scale.GetAutoPlacing()) {
                                                   >> 330     G4Transform3D rotation;
                                                   >> 331     switch (scale.GetDirection()) {
                                                   >> 332     case G4Scale::x:
                                                   >> 333       break;
                                                   >> 334     case G4Scale::y:
                                                   >> 335       rotation = G4RotateZ3D(piBy2);
                                                   >> 336       break;
                                                   >> 337     case G4Scale::z:
                                                   >> 338       rotation = G4RotateY3D(piBy2);
                                                   >> 339       break;
                                                   >> 340     }
                                                   >> 341     G4double sxmid(scale.GetXmid());
                                                   >> 342     G4double symid(scale.GetYmid());
                                                   >> 343     G4double szmid(scale.GetZmid());
                                                   >> 344     sxmid = xmin + oneMinusMargin * (xmax - xmin);
                                                   >> 345     symid = ymin + margin * (ymax - ymin);
                                                   >> 346     szmid = zmin + oneMinusMargin * (zmax - zmin);
                                                   >> 347     switch (scale.GetDirection()) {
                                                   >> 348     case G4Scale::x:
                                                   >> 349       sxmid -= halfLength;
                                                   >> 350       break;
                                                   >> 351     case G4Scale::y:
                                                   >> 352       symid += halfLength;
                                                   >> 353       break;
                                                   >> 354     case G4Scale::z:
                                                   >> 355       szmid -= halfLength;
                                                   >> 356       break;
424     }                                             357     }
425   } else {  // Not score map hits.  Just call  << 358     G4Translate3D translation(sxmid, symid, szmid);
426     // Cast away const because DrawAllHits is  << 359     transformation = translation * rotation;
427     const_cast<G4THitsMap<G4StatDouble>&>(hits << 360   } else {
                                                   >> 361     if (fpModel) transformation = fpModel->GetTransformation();
428   }                                               362   }
429 }                                              << 
430                                                << 
431 void G4VSceneHandler::AddCompound(const G4Mesh << 
432 {                                              << 
433   G4warn <<                                    << 
434   "There has been an attempt to draw a mesh wi << 
435   << fpViewer->GetViewParameters().GetSpecialM << 
436   << "\":\n" << mesh                           << 
437   << "but it is not of a recognised type or is << 
438   "\nby the current graphics driver. Instead w << 
439   "\ncontainer \"" << mesh.GetContainerVolume( << 
440   << G4endl;                                   << 
441   const auto& pv = mesh.GetContainerVolume();  << 
442   const auto& lv = pv->GetLogicalVolume();     << 
443   const auto& solid = lv->GetSolid();          << 
444   const auto& transform = mesh.GetTransform(); << 
445   // Make sure container is visible            << 
446   G4VisAttributes tmpVisAtts;  // Visible, whi << 
447   const auto& saveVisAtts = lv->GetVisAttribut << 
448   if (saveVisAtts) {                           << 
449     tmpVisAtts = *saveVisAtts;                 << 
450     tmpVisAtts.SetVisibility(true);            << 
451     auto colour = saveVisAtts->GetColour();    << 
452     colour.SetAlpha(1.);                       << 
453     tmpVisAtts.SetColour(colour);              << 
454   }                                            << 
455   // Draw container                            << 
456   PreAddSolid(transform,tmpVisAtts);           << 
457   solid->DescribeYourselfTo(*this);            << 
458   PostAddSolid();                              << 
459   // Restore vis attributes                    << 
460   lv->SetVisAttributes(saveVisAtts);           << 
461 }                                              << 
462                                                   363 
463 void G4VSceneHandler::AddViewerToList (G4VView << 364   // Draw...
464   fViewerList.push_back (pViewer);             << 365   // We would like to call BeginPrimitives(transformation) here but
                                                   >> 366   // calling BeginPrimitives from within an AddPrimitive is not
                                                   >> 367   // allowed!  So we have to do our own transformation...
                                                   >> 368   AddPrimitive(scaleLine.transform(transformation));
                                                   >> 369   AddPrimitive(tick11.transform(transformation));
                                                   >> 370   AddPrimitive(tick12.transform(transformation));
                                                   >> 371   AddPrimitive(tick21.transform(transformation));
                                                   >> 372   AddPrimitive(tick22.transform(transformation));
                                                   >> 373   G4Text text(scale.GetAnnotation(),textPosition.transform(transformation));
                                                   >> 374   text.SetScreenSize(12.);
                                                   >> 375   AddPrimitive(text);
465 }                                                 376 }
466                                                   377 
467 void G4VSceneHandler::AddPrimitive (const G4Po    378 void G4VSceneHandler::AddPrimitive (const G4Polymarker& polymarker) {
468   switch (polymarker.GetMarkerType()) {           379   switch (polymarker.GetMarkerType()) {
469     default:                                   << 380   default:
470     case G4Polymarker::dots:                   << 381   case G4Polymarker::dots:
471     {                                             382     {
472       G4Circle dot (polymarker);               << 383       for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
473       dot.SetWorldSize  (0.);                  << 384   G4Circle dot (polymarker);
474       dot.SetScreenSize (0.1);  // Very small  << 
475       for (std::size_t iPoint = 0; iPoint < po << 
476         dot.SetPosition (polymarker[iPoint]);     385         dot.SetPosition (polymarker[iPoint]);
477         AddPrimitive (dot);                    << 386   dot.SetWorldSize  (0.);
                                                   >> 387   dot.SetScreenSize (0.1);  // Very small circle.
                                                   >> 388   AddPrimitive (dot);
478       }                                           389       }
479     }                                             390     }
480       break;                                   << 391     break;
481     case G4Polymarker::circles:                << 392   case G4Polymarker::circles:
482     {                                             393     {
483       G4Circle circle (polymarker);  // Defaul << 394       for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
484       for (std::size_t iPoint = 0; iPoint < po << 395   G4Circle circle (polymarker);
485         circle.SetPosition (polymarker[iPoint] << 396   circle.SetPosition (polymarker[iPoint]);
486         AddPrimitive (circle);                 << 397   AddPrimitive (circle);
487       }                                           398       }
488     }                                             399     }
489       break;                                   << 400     break;
490     case G4Polymarker::squares:                << 401   case G4Polymarker::squares:
491     {                                             402     {
492       G4Square square (polymarker);  // Defaul << 403       for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
493       for (std::size_t iPoint = 0; iPoint < po << 404   G4Square Square (polymarker);
494         square.SetPosition (polymarker[iPoint] << 405   Square.SetPosition (polymarker[iPoint]);
495         AddPrimitive (square);                 << 406   AddPrimitive (Square);
496       }                                           407       }
497     }                                             408     }
498       break;                                   << 409     break;
499   }                                               410   }
500 }                                                 411 }
501                                                   412 
502 void G4VSceneHandler::RemoveViewerFromList (G4    413 void G4VSceneHandler::RemoveViewerFromList (G4VViewer* pViewer) {
503   fViewerList.remove(pViewer);  // Does nothin << 414   fViewerList.remove(pViewer);
504   // And reset current viewer                  << 
505   auto visManager = G4VisManager::GetInstance( << 
506   visManager->SetCurrentViewer(nullptr);       << 
507 }                                              << 
508                                                << 
509                                                << 
510 void G4VSceneHandler::AddPrimitive (const G4Pl << 
511   G4warn << "WARNING: Plotter not implemented  << 
512   G4warn << "  Open a plotter-aware graphics s << 
513   G4warn << "  /vis/scene/removeModel Plotter" << 
514 }                                                 415 }
515                                                   416 
516 void G4VSceneHandler::SetScene (G4Scene* pScen    417 void G4VSceneHandler::SetScene (G4Scene* pScene) {
517   fpScene = pScene;                               418   fpScene = pScene;
518   // Notify all viewers that a kernel visit is    419   // Notify all viewers that a kernel visit is required.
519   G4ViewerListIterator i;                         420   G4ViewerListIterator i;
520   for (i = fViewerList.begin(); i != fViewerLi    421   for (i = fViewerList.begin(); i != fViewerList.end(); i++) {
521     (*i) -> SetNeedKernelVisit (true);            422     (*i) -> SetNeedKernelVisit (true);
522   }                                               423   }
523 }                                                 424 }
524                                                   425 
525 void G4VSceneHandler::RequestPrimitives (const << 426 void G4VSceneHandler::RequestPrimitives (const G4VSolid& solid) {
526 {                                              << 427   BeginPrimitives (*fpObjectTransformation);
527   // Sometimes solids that have no substance g << 428   G4NURBS* pNURBS = 0;
528   // be part of the geometry tree but have bee << 429   G4Polyhedron* pPolyhedron = 0;
529   // example by a Boolean subtraction in which << 430   switch (fpViewer -> GetViewParameters () . GetRepStyle ()) {
530   // is entirely inside the subtractor or an i << 431   case G4ViewParameters::nurbs:
531   // the original volume is entirely outside t << 432     pNURBS = solid.CreateNURBS ();
532   // The problem is that the Boolean Processor << 433     if (pNURBS) {
533   // polyhedron in these cases (IMHO it should << 434       pNURBS -> SetVisAttributes
534   // workaround is to return before the damage << 435   (fpViewer -> GetApplicableVisAttributes (fpVisAttribs));
535   // Algorithm by Evgueni Tcherniaev           << 436       AddPrimitive (*pNURBS);
536   auto pSolid = &solid;                        << 437       delete pNURBS;
537   auto pBooleanSolid = dynamic_cast<const G4Bo << 438       break;
538   if (pBooleanSolid) {                         << 439     }
539     G4ThreeVector bmin, bmax;                  << 440     else {
540     pBooleanSolid->BoundingLimits(bmin, bmax); << 441       G4VisManager::Verbosity verbosity =
541     G4bool isGood = false;                     << 442   G4VisManager::GetInstance()->GetVerbosity();
542     if (dynamic_cast<const G4SubtractionSolid* << 443       if (verbosity >= G4VisManager::errors) {
543       auto ptrB = pBooleanSolid->GetConstituen << 444   G4cout <<
544       for (G4int i=0; i<10; ++i) {             << 445     "ERROR: G4VSceneHandler::RequestPrimitives"
545         G4double x = bmin.x() + (bmax.x() - bm << 446     "\n  NURBS not available for "
546         G4double y = bmin.y() + (bmax.y() - bm << 447          << solid.GetName () << G4endl;
547         G4double z = bmin.z() + (bmax.z() - bm << 448   G4cout << "Trying polyhedron." << G4endl;
548         if (ptrB->Inside(G4ThreeVector(x,y,bmi << 449       }
549         if (ptrB->Inside(G4ThreeVector(x,y,bma << 450     }
550         if (ptrB->Inside(G4ThreeVector(x,bmin. << 451     // Dropping through to polyhedron...
551         if (ptrB->Inside(G4ThreeVector(x,bmax. << 452   case G4ViewParameters::polyhedron:
552         if (ptrB->Inside(G4ThreeVector(bmin.x( << 453   default:
553         if (ptrB->Inside(G4ThreeVector(bmax.x( << 454     G4Polyhedron::SetNumberOfRotationSteps
554       }                                        << 455       (fpViewer -> GetViewParameters () . GetNoOfSides ());
555     } else if (dynamic_cast<const G4Intersecti << 456     pPolyhedron = solid.GetPolyhedron ();
556       auto ptrB = pBooleanSolid->GetConstituen << 457     G4Polyhedron::ResetNumberOfRotationSteps ();
557       for (G4int i=0; i<10; ++i) {             << 458     if (pPolyhedron) {
558         G4double x = bmin.x() + (bmax.x() - bm << 459       pPolyhedron -> SetVisAttributes
559         G4double y = bmin.y() + (bmax.y() - bm << 460   (fpViewer -> GetApplicableVisAttributes (fpVisAttribs));
560         G4double z = bmin.z() + (bmax.z() - bm << 461       AddPrimitive (*pPolyhedron);
561         if (ptrB->Inside(G4ThreeVector(x,y,bmi << 462     }
562         if (ptrB->Inside(G4ThreeVector(x,y,bma << 463     else {
563         if (ptrB->Inside(G4ThreeVector(x,bmin. << 464       G4VisManager::Verbosity verbosity =
564         if (ptrB->Inside(G4ThreeVector(x,bmax. << 465   G4VisManager::GetInstance()->GetVerbosity();
565         if (ptrB->Inside(G4ThreeVector(bmin.x( << 466       if (verbosity >= G4VisManager::errors) {
566         if (ptrB->Inside(G4ThreeVector(bmax.x( << 467   G4cout <<
567       }                                        << 468     "ERROR: G4VSceneHandler::RequestPrimitives"
568     }                                          << 469     "\n  Polyhedron not available for " << solid.GetName () <<
569     if (!isGood)                               << 470     ".\n  This means it cannot be visualized on most systems."
570     {                                          << 471     "\n  Contact the Visualization Coordinator." << G4endl;
571       for (G4int i=0; i<10000; ++i) {          << 
572         G4double x = bmin.x() + (bmax.x() - bm << 
573         G4double y = bmin.y() + (bmax.y() - bm << 
574         G4double z = bmin.z() + (bmax.z() - bm << 
575         if (pBooleanSolid->Inside(G4ThreeVecto << 
576       }                                           472       }
577     }                                             473     }
578     if (!isGood) return;                       << 474     break;
579   }                                            << 
580                                                << 
581   const G4ViewParameters::DrawingStyle style = << 
582   const G4ViewParameters& vp = fpViewer->GetVi << 
583                                                << 
584   switch (style) {                             << 
585     default:                                   << 
586     case G4ViewParameters::wireframe:          << 
587     case G4ViewParameters::hlr:                << 
588     case G4ViewParameters::hsr:                << 
589     case G4ViewParameters::hlhsr:              << 
590     {                                          << 
591       // Use polyhedral representation         << 
592       G4Polyhedron::SetNumberOfRotationSteps ( << 
593       G4Polyhedron* pPolyhedron = solid.GetPol << 
594       G4Polyhedron::ResetNumberOfRotationSteps << 
595       if (pPolyhedron) {                       << 
596         pPolyhedron -> SetVisAttributes (fpVis << 
597         BeginPrimitives (fObjectTransformation << 
598         AddPrimitive (*pPolyhedron);           << 
599         EndPrimitives ();                      << 
600         break;                                 << 
601       } else {  // Print warnings and drop thr << 
602         G4VisManager::Verbosity verbosity = G4 << 
603         auto pPVModel = dynamic_cast<G4Physica << 
604         if (pPVModel) {                        << 
605           auto problematicVolume = pPVModel->G << 
606           if (fProblematicVolumes.find(problem << 
607             fProblematicVolumes[problematicVol << 
608             if (verbosity >= G4VisManager::err << 
609               G4warn <<                        << 
610               "ERROR: G4VSceneHandler::Request << 
611               "\n  Polyhedron not available fo << 
612               G4warn << "\n  Touchable path: " << 
613               static G4bool explanation = fals << 
614               if (!explanation) {              << 
615                 explanation = true;            << 
616                 G4warn <<                      << 
617                 "\n  This means it cannot be v << 
618                 "\n  1) The solid may not have << 
619                 "\n  2) For Boolean solids, th << 
620                 "\n     the resultant polyhedr << 
621                 "\n  Try RayTracer. It uses Ge << 
622               }                                << 
623             }                                  << 
624             G4warn << "\n  Drawing solid with  << 
625             G4warn << G4endl;                  << 
626           }                                    << 
627         }                                      << 
628       }                                        << 
629     }                                          << 
630       [[fallthrough]];                         << 
631                                                << 
632     case G4ViewParameters::cloud:              << 
633     {                                          << 
634       // Form solid out of cloud of dots on su << 
635       G4Polymarker dots;                       << 
636       // Note: OpenGL has a fast implementatio << 
637       // to build a polymarker rather than add << 
638       // And anyway, in Qt, in the latter case << 
639       // entry, something we would want to avo << 
640       dots.SetVisAttributes(fpVisAttribs);     << 
641       dots.SetMarkerType(G4Polymarker::dots);  << 
642       dots.SetSize(G4VMarker::screen,1.);      << 
643       G4int numberOfCloudPoints = GetNumberOfC << 
644       if (numberOfCloudPoints <= 0) numberOfCl << 
645       for (G4int i = 0; i < numberOfCloudPoint << 
646   G4ThreeVector p = solid.GetPointOnSurface(); << 
647   dots.push_back(p);                           << 
648       }                                        << 
649       BeginPrimitives (fObjectTransformation); << 
650       AddPrimitive(dots);                      << 
651       EndPrimitives ();                        << 
652       break;                                   << 
653     }                                          << 
654   }                                               475   }
                                                   >> 476   EndPrimitives ();
655 }                                                 477 }
656                                                   478 
657 //namespace {                                  << 479 void G4VSceneHandler::ProcessScene (G4VViewer&) {
658 //  void DrawExtent(const G4VModel* pModel)    << 
659 //  {                                          << 
660 //    // Show extent boxes - debug only, OGLSX << 
661 //    if (pModel->GetExtent() != G4VisExtent:: << 
662 //      const auto& extent = pModel->GetExtent << 
663 //      const auto& centre = extent.GetExtentC << 
664 //      const auto& position = G4Translate3D(c << 
665 //      const auto& dx = (extent.GetXmax()-ext << 
666 //      const auto& dy = (extent.GetYmax()-ext << 
667 //      const auto& dz = (extent.GetZmax()-ext << 
668 //      auto visAtts = G4VisAttributes();      << 
669 //      visAtts.SetForceWireframe();           << 
670 //      G4Box extentBox("Extent",dx,dy,dz);    << 
671 //      G4VisManager::GetInstance()->Draw(exte << 
672 //    }                                        << 
673 //  }                                          << 
674 //}                                            << 
675                                                << 
676 void G4VSceneHandler::ProcessScene()           << 
677 {                                              << 
678   // Assumes graphics database store has alrea << 
679   // relevant for the particular scene handler << 
680                                                << 
681   if(!fpScene)                                 << 
682     return;                                    << 
683                                                   480 
684   if(fpScene->GetExtent() == G4VisExtent::GetN << 481   if (!fpScene) return;
685   {                                            << 
686     G4Exception("G4VSceneHandler::ProcessScene << 
687                 "The scene has no extent.");   << 
688   }                                            << 
689                                                << 
690   G4VisManager* visManager = G4VisManager::Get << 
691                                                << 
692   if(!visManager->GetConcreteInstance())       << 
693     return;                                    << 
694                                                << 
695   G4VisManager::Verbosity verbosity = visManag << 
696                                                   482 
697   fReadyForTransients = false;                    483   fReadyForTransients = false;
698                                                   484 
699   // Reset fMarkForClearingTransientStore. (Le << 485   // Clear stored scene, if any, i.e., display lists, scene graphs.
                                                   >> 486   ClearStore ();
                                                   >> 487 
                                                   >> 488   // Reset fMarkForClearingTransientStore.  No need to clear transient
                                                   >> 489   // store since it has just been cleared above.  (Leaving
700   // fMarkForClearingTransientStore true cause    490   // fMarkForClearingTransientStore true causes problems with
701   // recomputing transients below.)  Restore i    491   // recomputing transients below.)  Restore it again at end...
702   G4bool tmpMarkForClearingTransientStore = fM    492   G4bool tmpMarkForClearingTransientStore = fMarkForClearingTransientStore;
703   fMarkForClearingTransientStore          = fa << 493   fMarkForClearingTransientStore = false;
                                                   >> 494 
                                                   >> 495   G4VisManager* visManager = G4VisManager::GetInstance();
                                                   >> 496   G4VisManager::Verbosity verbosity = visManager->GetVerbosity();
704                                                   497 
705   // Traverse geometry tree and send drawing p    498   // Traverse geometry tree and send drawing primitives to window(s).
706                                                   499 
707   const std::vector<G4Scene::Model>& runDurati << 500   const std::vector<G4VModel*>& runDurationModelList =
708     fpScene->GetRunDurationModelList();        << 501     fpScene -> GetRunDurationModelList ();
709                                                   502 
710   if(runDurationModelList.size()) {            << 503   if (runDurationModelList.size ()) {
711     if(verbosity >= G4VisManager::confirmation << 504     if (verbosity >= G4VisManager::confirmations) {
712       G4cout << "Traversing scene data..." <<     505       G4cout << "Traversing scene data..." << G4endl;
713       static G4int first = true;               << 
714       if (first) {                             << 
715         first = false;                         << 
716         G4cout <<                              << 
717         "(This could happen more than once - i << 
718         "\nper rebuild, for opaque, transparen << 
719         << G4endl;                             << 
720       }                                        << 
721     }                                             506     }
722                                                   507 
723     // Reset visibility of all objects to fals << 508     BeginModeling ();
724     fpViewer->AccessSceneTree().ResetVisibilit << 
725                                                << 
726     BeginModeling();                           << 
727                                                   509 
728     // Create modeling parameters from view pa    510     // Create modeling parameters from view parameters...
729     G4ModelingParameters* pMP = CreateModeling << 511     G4ModelingParameters* pMP = CreateModelingParameters ();
730                                                << 
731     for(std::size_t i = 0; i < runDurationMode << 
732       if(runDurationModelList[i].fActive) {    << 
733         fpModel = runDurationModelList[i].fpMo << 
734         fpModel->SetModelingParameters(pMP);   << 
735                                                << 
736         // Describe to the current scene handl << 
737         fpModel->DescribeYourselfTo(*this);    << 
738                                                << 
739         // To see the extents of each model re << 
740         // uncomment the next line and DrawExt << 
741         // DrawExtent(fpModel);                << 
742                                                << 
743         // Enter models in the scene tree. The << 
744         // the model to the scene tree, i.e.,  << 
745         fpViewer->InsertModelInSceneTree(fpMod << 
746         auto pPVModel = dynamic_cast<G4Physica << 
747         if (pPVModel) {                        << 
748           G4VViewer::SceneTreeScene sceneTreeS << 
749           fpModel->DescribeYourselfTo(sceneTre << 
750         }                                      << 
751                                                   512 
752         // Reset modeling parameters pointer   << 513     for (size_t i = 0; i < runDurationModelList.size (); i++) {
753         fpModel->SetModelingParameters(0);     << 514       G4VModel* pModel = runDurationModelList[i];
                                                   >> 515       // Note: this is not the place to take action on
                                                   >> 516       // pModel->GetTransformation().  The model must take care of
                                                   >> 517       // this in pModel->DescribeYourselfTo(*this).  See, for example,
                                                   >> 518       // G4PhysicalVolumeModel and /vis/scene/add/logo.
                                                   >> 519       pModel -> SetModelingParameters (pMP);
                                                   >> 520       SetModel (pModel);  // Store for use by derived class.
                                                   >> 521       pModel -> DescribeYourselfTo (*this);
                                                   >> 522       pModel -> SetModelingParameters (0);
                                                   >> 523     }
                                                   >> 524 
                                                   >> 525     // Repeat if required...
                                                   >> 526     if (fSecondPassRequested) {
                                                   >> 527       fSecondPass = true;
                                                   >> 528       for (size_t i = 0; i < runDurationModelList.size (); i++) {
                                                   >> 529   G4VModel* pModel = runDurationModelList[i];
                                                   >> 530   pModel -> SetModelingParameters (pMP);
                                                   >> 531   SetModel (pModel);  // Store for use by derived class.
                                                   >> 532   pModel -> DescribeYourselfTo (*this);
                                                   >> 533   pModel -> SetModelingParameters (0);
754       }                                           534       }
                                                   >> 535       fSecondPass = false;
                                                   >> 536       fSecondPassRequested = false;
755     }                                             537     }
756                                                   538 
757     fpModel = 0;                               << 
758     delete pMP;                                   539     delete pMP;
                                                   >> 540     EndModeling ();
759                                                   541 
760     EndModeling();                             << 542   } else {
761   }                                            << 543     G4VisManager::Verbosity verbosity =
762                                                << 544       G4VisManager::GetInstance()->GetVerbosity();
763   // Some printing                             << 545     if (verbosity >= G4VisManager::warnings) {
764   if(verbosity >= G4VisManager::confirmations) << 546       G4cout <<
765     for (const auto& model: runDurationModelLi << 547   "WARNING: G4VSceneHandler::ProcessScene: No run-duration models in"
766       if (model.fActive) {                     << 548   "\n  scene.  \"World\" will be added if you attempt to draw a view"
767         auto pvModel = dynamic_cast<G4Physical << 549        << G4endl;
768         if (pvModel) {                         << 
769           G4int nTouchables = 0;               << 
770           G4cout << "Numbers of touchables by  << 
771           << pvModel->GetGlobalDescription() < << 
772           for (const auto& dn : pvModel->GetNu << 
773             G4cout << "\n  Depth " << dn.first << 
774             nTouchables += dn.second;          << 
775           }                                    << 
776           G4cout << "\n  Total number of touch << 
777         }                                      << 
778       }                                        << 
779     }                                          << 
780                                                << 
781     if (fProblematicVolumes.size() > 0) {      << 
782       G4cout << "Problematic volumes:";        << 
783       for (const auto& prob: fProblematicVolum << 
784         G4cout << "\n  " << prob.first->GetNam << 
785       }                                        << 
786       G4cout << G4endl;                        << 
787     }                                             550     }
788   }                                               551   }
789                                                   552 
                                                   >> 553   fpViewer->FinishView();  // Flush streams and/or swap buffers.
                                                   >> 554 
790   fReadyForTransients = true;                     555   fReadyForTransients = true;
791                                                   556 
792   // Refresh event from end-of-event model lis << 557   // Now (re-)do transients (trajectories, hits, user drawing, etc.)...
793   // Allow only in Idle or GeomClosed state... << 558   if (fpScene->GetRecomputeTransients()) {  // ...if requested...
794   G4StateManager* stateManager = G4StateManage << 
795   G4ApplicationState state     = stateManager- << 
796   if(state == G4State_Idle || state == G4State << 
797   {                                            << 
798     visManager->SetEventRefreshing(true);      << 
799                                                   559 
800     if(visManager->GetRequestedEvent())        << 560     // Allowed only in idle state...
801     {                                          << 561     G4StateManager* stateManager = G4StateManager::GetStateManager();
802       DrawEvent(visManager->GetRequestedEvent( << 562     G4ApplicationState currentState = stateManager->GetCurrentState();
803     }                                          << 563     if(currentState != G4State_Idle) {
804     else                                       << 564       if (verbosity >= G4VisManager::warnings) {
805     {                                          << 565   G4cout << 
806       G4RunManager* runManager = G4RunManagerF << 566     "Cannot re-compute transients during existing run."
807       if(runManager)                           << 567     "\n  Trajectories, etc., will be lost."
808       {                                        << 568          << G4endl;
809         const G4Run* run = runManager->GetCurr << 569       }
810         // Draw a null event in order to pick  << 570     } else {
811         if (run == nullptr) DrawEvent(0);      << 571 
812         const std::vector<const G4Event*>* eve << 572   // Uses run manager via UImanager->ApplyCommand("/run/beamOn") so
813           run ? run->GetEventVector() : 0;     << 573   // only makes sense if a run manager exists.  More than that - the
814         std::size_t nKeptEvents = 0;           << 574   // random number status strings are created by G4RunManager, so they
815         if(events)                             << 575   // are null if a G4RunManager does not exist...
816           nKeptEvents = events->size();        << 576   G4RunManager* runManager = G4RunManager::GetRunManager();
817         if(nKeptEvents)                        << 577   if (runManager) {
818         {                                      << 578     if (visManager->GetEventCount()) {  // Must have had some prior event(s)...
819           if(fpScene->GetRefreshAtEndOfEvent() << 579       if (fpScene->GetRefreshAtEndOfEvent()) {
820           {                                    << 580   // Check if transients have been drawn.  Note: Use the flag in
821             if(verbosity >= G4VisManager::conf << 581   // the vis manager, which is set *after* a pass triggered by
822             {                                  << 582   // ClearTransientStoreIfMarked.  Avoids early processing.
823               G4cout << "Refreshing event..."  << 583   if (visManager->GetTransientsDrawnThisEvent()) {
824             }                                  << 584     // Change "warnings" to "confirmations" if this settles!!!!!!!!!!
825             const G4Event* event = 0;          << 585     if (verbosity >= G4VisManager::warnings) {
826             if(events && events->size())       << 586       G4cout << 
827               event = events->back();          << 587         "Recomputing transients generated by previous event..."
828             if(event)                          << 588         "\n  \"/vis/scene/transientsAction none\" to suppress."
829               DrawEvent(event);                << 589        << G4endl;
830           }                                    << 590     }
831           else                                 << 591     std::istringstream
832           {  // Accumulating events.           << 592       iss(visManager->GetBeginOfLastEventRandomStatus());
833                                                << 593     CLHEP::HepRandom::restoreFullState(iss);
834             if(verbosity >= G4VisManager::conf << 594     visManager->SetReprocessing(true);
835             {                                  << 595     visManager->SetReprocessingLastEvent(true);
836               G4cout << "Refreshing events in  << 596     G4int runID = visManager->GetLastRunID();
837             }                                  << 597     runManager->SetRunIDCounter(runID);
838             for(const auto& event : *events)   << 598     runManager->BeamOn(1);
839             {                                  << 599   }
840               if(event)                        << 600       } else {
841                 DrawEvent(event);              << 601   if (!fpScene->GetRefreshAtEndOfRun()) {
842             }                                  << 602     if (verbosity >= G4VisManager::warnings) {
843                                                << 603       G4cout <<
844             if(!fpScene->GetRefreshAtEndOfRun( << 604      "WARNING: Cannot refresh trajectories, etc., accumulated over more"
845             {                                  << 605      "\n  than one runs.  Refreshing just the last run..."
846               if(verbosity >= G4VisManager::wa << 606        << G4endl;
847               {                                << 607     }
848                 G4warn << "WARNING: Cannot ref << 608   }
849                           "\n  than one runs.  << 609   // Check if transients have been drawn.  Note: Use the flag in
850                        << G4endl;              << 610   // the vis manager, which is set *after* a pass triggered by
851               }                                << 611   // ClearTransientStoreIfMarked.  Avoids early processing.
852             }                                  << 612   if (visManager->GetTransientsDrawnThisRun()) {
853           }                                    << 613     // Change "warnings" to "confirmations" if this settles!!!!!!!!!!
854         }                                      << 614     if (verbosity >= G4VisManager::warnings) {
                                                   >> 615       G4cout << 
                                                   >> 616         "Recomputing transients generated by previous run..."
                                                   >> 617         "\n  \"/vis/scene/transientsAction none\" to suppress."
                                                   >> 618        << G4endl;
                                                   >> 619     }
                                                   >> 620     std::istringstream iss(visManager->GetBeginOfLastRunRandomStatus());
                                                   >> 621     CLHEP::HepRandom::restoreFullState(iss);
                                                   >> 622     G4int nEvents = visManager->GetEventCount();
                                                   >> 623     visManager->SetReprocessing(true);
                                                   >> 624     G4int runID = visManager->GetLastRunID();
                                                   >> 625     runManager->SetRunIDCounter(runID);
                                                   >> 626     runManager->BeamOn(nEvents);
                                                   >> 627   }
855       }                                           628       }
856     }                                             629     }
857     visManager->SetEventRefreshing(false);     << 
858   }                                               630   }
859                                                << 
860   // Refresh end-of-run model list.            << 
861   // Allow only in Idle or GeomClosed state... << 
862   if(state == G4State_Idle || state == G4State << 
863   {                                            << 
864     DrawEndOfRunModels();                      << 
865   }                                               631   }
866                                                << 
867   fMarkForClearingTransientStore = tmpMarkForC << 
868 }                                              << 
869                                                << 
870 void G4VSceneHandler::DrawEvent(const G4Event* << 
871 {                                              << 
872   if(!fpViewer->ReadyToDraw()) return;         << 
873   const std::vector<G4Scene::Model>& EOEModelL << 
874     fpScene -> GetEndOfEventModelList ();      << 
875   std::size_t nModels = EOEModelList.size();   << 
876   if (nModels) {                               << 
877     G4ModelingParameters* pMP = CreateModeling << 
878     pMP->SetEvent(event);                      << 
879     for (std::size_t i = 0; i < nModels; ++i)  << 
880       if (EOEModelList[i].fActive) {           << 
881         fpModel = EOEModelList[i].fpModel;     << 
882         fpModel -> SetModelingParameters(pMP); << 
883                                                << 
884         // Describe to the current scene handl << 
885         fpModel -> DescribeYourselfTo (*this); << 
886                                                << 
887         // Enter models in the scene tree      << 
888         fpViewer->InsertModelInSceneTree(fpMod << 
889                                                << 
890         // Reset modeling parameters pointer   << 
891         fpModel -> SetModelingParameters(0);   << 
892       }                                        << 
893     }                                          << 
894     fpModel = 0;                               << 
895     delete pMP;                                << 
896   }                                               632   }
897 }                                              << 
898                                                   633 
899 void G4VSceneHandler::DrawEndOfRunModels()     << 634   fMarkForClearingTransientStore = tmpMarkForClearingTransientStore;
900 {                                              << 
901   if(!fpViewer->ReadyToDraw()) return;         << 
902   const std::vector<G4Scene::Model>& EORModelL << 
903     fpScene -> GetEndOfRunModelList ();        << 
904   std::size_t nModels = EORModelList.size();   << 
905   if (nModels) {                               << 
906     G4ModelingParameters* pMP = CreateModeling << 
907     pMP->SetEvent(0);                          << 
908     for (std::size_t i = 0; i < nModels; ++i)  << 
909       if (EORModelList[i].fActive) {           << 
910         fpModel = EORModelList[i].fpModel;     << 
911         fpModel -> SetModelingParameters(pMP); << 
912                                                << 
913         // Describe to the current scene handl << 
914         fpModel -> DescribeYourselfTo (*this); << 
915                                                << 
916         // Enter models in the scene tree      << 
917         fpViewer->InsertModelInSceneTree(fpMod << 
918                                                << 
919         // Reset modeling parameters pointer   << 
920         fpModel -> SetModelingParameters(0);   << 
921       }                                        << 
922     }                                          << 
923     fpModel = 0;                               << 
924     delete pMP;                                << 
925   }                                            << 
926 }                                                 635 }
927                                                   636 
928 G4ModelingParameters* G4VSceneHandler::CreateM << 637 G4ModelingParameters* G4VSceneHandler::CreateModelingParameters () {
929 {                                              << 
930   // Create modeling parameters from View Para    638   // Create modeling parameters from View Parameters...
931   if (!fpViewer) return NULL;                  << 
932                                                << 
933   const G4ViewParameters& vp = fpViewer -> Get    639   const G4ViewParameters& vp = fpViewer -> GetViewParameters ();
934                                                   640 
935   // Convert drawing styles...                    641   // Convert drawing styles...
936   G4ModelingParameters::DrawingStyle modelDraw    642   G4ModelingParameters::DrawingStyle modelDrawingStyle =
937   G4ModelingParameters::wf;                    << 643     G4ModelingParameters::wf;
938   switch (vp.GetDrawingStyle ()) {                644   switch (vp.GetDrawingStyle ()) {
                                                   >> 645   default:
                                                   >> 646   case G4ViewParameters::wireframe:
                                                   >> 647     modelDrawingStyle = G4ModelingParameters::wf;
                                                   >> 648     break;
                                                   >> 649   case G4ViewParameters::hlr:
                                                   >> 650     modelDrawingStyle = G4ModelingParameters::hlr;
                                                   >> 651     break;
                                                   >> 652   case G4ViewParameters::hsr:
                                                   >> 653     modelDrawingStyle = G4ModelingParameters::hsr;
                                                   >> 654     break;
                                                   >> 655   case G4ViewParameters::hlhsr:
                                                   >> 656     modelDrawingStyle = G4ModelingParameters::hlhsr;
                                                   >> 657     break;
                                                   >> 658   }
                                                   >> 659 
                                                   >> 660   // Convert rep styles...
                                                   >> 661   G4ModelingParameters::RepStyle modelRepStyle =
                                                   >> 662     G4ModelingParameters::wireframe;
                                                   >> 663   if (vp.GetDrawingStyle () != G4ViewParameters::wireframe) {
                                                   >> 664     switch (vp.GetRepStyle ()) {
939     default:                                      665     default:
940     case G4ViewParameters::wireframe:          << 666     case G4ViewParameters::polyhedron:
941       modelDrawingStyle = G4ModelingParameters << 667       modelRepStyle = G4ModelingParameters::polyhedron;
942       break;                                   << 
943     case G4ViewParameters::hlr:                << 
944       modelDrawingStyle = G4ModelingParameters << 
945       break;                                   << 
946     case G4ViewParameters::hsr:                << 
947       modelDrawingStyle = G4ModelingParameters << 
948       break;                                      668       break;
949     case G4ViewParameters::hlhsr:              << 669     case G4ViewParameters::nurbs:
950       modelDrawingStyle = G4ModelingParameters << 670       modelRepStyle = G4ModelingParameters::nurbs;
951       break;                                   << 
952     case G4ViewParameters::cloud:              << 
953       modelDrawingStyle = G4ModelingParameters << 
954       break;                                      671       break;
                                                   >> 672     }
955   }                                               673   }
956                                                   674 
957   // Decide if covered daughters are really to    675   // Decide if covered daughters are really to be culled...
958   G4bool reallyCullCovered =                      676   G4bool reallyCullCovered =
959     vp.IsCullingCovered()   // Culling daughte    677     vp.IsCullingCovered()   // Culling daughters depends also on...
960     && !vp.IsSection ()     // Sections (DCUT)    678     && !vp.IsSection ()     // Sections (DCUT) not requested.
961     && !vp.IsCutaway ()     // Cutaways not re    679     && !vp.IsCutaway ()     // Cutaways not requested.
962     ;                                             680     ;
963                                                   681 
964   G4ModelingParameters* pModelingParams = new     682   G4ModelingParameters* pModelingParams = new G4ModelingParameters
965     (vp.GetDefaultVisAttributes (),               683     (vp.GetDefaultVisAttributes (),
966      modelDrawingStyle,                           684      modelDrawingStyle,
                                                   >> 685      modelRepStyle,
967      vp.IsCulling (),                             686      vp.IsCulling (),
968      vp.IsCullingInvisible (),                    687      vp.IsCullingInvisible (),
969      vp.IsDensityCulling (),                      688      vp.IsDensityCulling (),
970      vp.GetVisibleDensity (),                     689      vp.GetVisibleDensity (),
971      reallyCullCovered,                           690      reallyCullCovered,
972      vp.GetNoOfSides ()                        << 691      vp.GetNoOfSides (),
                                                   >> 692      vp.IsViewGeom (),
                                                   >> 693      vp.IsViewHits (),
                                                   >> 694      vp.IsViewDigis ()
973      );                                           695      );
974                                                   696 
975   pModelingParams->SetNumberOfCloudPoints(vp.G << 
976   pModelingParams->SetWarning                  << 
977     (G4VisManager::GetVerbosity() >= G4VisMana << 
978                                                << 
979   pModelingParams->SetCBDAlgorithmNumber(vp.Ge << 
980   pModelingParams->SetCBDParameters(vp.GetCBDP << 
981                                                << 
982   pModelingParams->SetExplodeFactor(vp.GetExpl << 
983   pModelingParams->SetExplodeCentre(vp.GetExpl << 
984                                                << 
985   pModelingParams->SetSectionSolid(CreateSecti << 
986                                                << 
987   if (vp.GetCutawayMode() == G4ViewParameters: << 
988     pModelingParams->SetCutawayMode(G4Modeling << 
989   } else if (vp.GetCutawayMode() == G4ViewPara << 
990     pModelingParams->SetCutawayMode(G4Modeling << 
991   }                                            << 
992                                                << 
993   pModelingParams->SetCutawaySolid(CreateCutaw << 
994   // The polyhedron objects are deleted in the << 
995                                                << 
996   pModelingParams->SetVisAttributesModifiers(v << 
997                                                << 
998   pModelingParams->SetSpecialMeshRendering(vp. << 
999   pModelingParams->SetSpecialMeshVolumes(vp.Ge << 
1000                                               << 
1001   return pModelingParams;                        697   return pModelingParams;
1002 }                                                698 }
1003                                                  699 
1004 G4DisplacedSolid* G4VSceneHandler::CreateSect << 
1005 {                                             << 
1006   G4DisplacedSolid* sectioner = 0;            << 
1007                                               << 
1008   const G4ViewParameters& vp = fpViewer->GetV << 
1009   if (vp.IsSection () ) {                     << 
1010                                               << 
1011     G4double radius = fpScene->GetExtent().Ge << 
1012     G4double safe = radius + fpScene->GetExte << 
1013     G4VSolid* sectionBox =                    << 
1014       new G4Box("_sectioner", safe, safe, 1.e << 
1015                                               << 
1016     const G4Plane3D& sp = vp.GetSectionPlane  << 
1017     G4ThreeVector normal = sp.normal();       << 
1018     G4Transform3D requiredTransform = G4Trans << 
1019     G4Rotate3D(G4ThreeVector(0,0,1), G4ThreeV << 
1020                                               << 
1021     sectioner = new G4DisplacedSolid          << 
1022     ("_displaced_sectioning_box", sectionBox, << 
1023   }                                           << 
1024                                               << 
1025   return sectioner;                           << 
1026 }                                             << 
1027                                               << 
1028 G4DisplacedSolid* G4VSceneHandler::CreateCuta << 
1029 {                                             << 
1030   const auto& vp = fpViewer->GetViewParameter << 
1031   const auto& nPlanes = vp.GetCutawayPlanes() << 
1032                                               << 
1033   if (nPlanes == 0) return nullptr;           << 
1034                                               << 
1035   std::vector<G4DisplacedSolid*> cutaway_soli << 
1036                                               << 
1037   G4double radius = fpScene->GetExtent().GetE << 
1038   G4double safe = radius + fpScene->GetExtent << 
1039   auto cutawayBox = new G4Box("_cutaway_box", << 
1040                                               << 
1041   // if (vp.GetCutawayMode() == G4ViewParamet << 
1042   // the intersection of displaced cutaway bo << 
1043   // positive values a*x+b*y+c*z+d>0, so we h << 
1044   // "back to front". The parameter "cutawayU << 
1045   // that remain *after* cutaway", because we << 
1046   // a "union" of what remains by superimposi << 
1047   // and G4OpenGLImmediate/StoredViewer::Proc << 
1048   // that is the intersection of inverted cut << 
1049                                               << 
1050   // Conversely, if (vp.GetCutawayMode() == G << 
1051   // create an intersector that is the inters << 
1052                                               << 
1053   for (size_t plane_no = 0; plane_no < nPlane << 
1054   {                                           << 
1055     const G4Plane3D& sp = vp.GetCutawayPlanes << 
1056     G4Transform3D requiredTransform;          << 
1057     G4ThreeVector normal;                     << 
1058     switch (vp.GetCutawayMode()) {            << 
1059       case G4ViewParameters::cutawayUnion:    << 
1060         normal = -sp.normal();  // Invert nor << 
1061         requiredTransform = G4Translate3D(nor << 
1062         G4Rotate3D(G4ThreeVector(0,0,1), G4Th << 
1063         break;                                << 
1064       case G4ViewParameters::cutawayIntersect << 
1065         normal = sp.normal();                 << 
1066         requiredTransform = G4Translate3D(nor << 
1067         G4Rotate3D(G4ThreeVector(0,0,1), G4Th << 
1068         break;                                << 
1069     }                                         << 
1070     cutaway_solids.push_back                  << 
1071     (new G4DisplacedSolid("_displaced_cutaway << 
1072   }                                           << 
1073                                               << 
1074   if (nPlanes == 1) return (G4DisplacedSolid* << 
1075                                               << 
1076   G4IntersectionSolid *union2 = nullptr, *uni << 
1077   G4IntersectionSolid *intersection2 = nullpt << 
1078   switch (vp.GetCutawayMode()) {              << 
1079                                               << 
1080     case G4ViewParameters::cutawayUnion:      << 
1081       // Here we make a subtractor of interse << 
1082       union2 = new G4IntersectionSolid("_unio << 
1083       if (nPlanes == 2) return (G4DisplacedSo << 
1084       else if (nPlanes == 3) {                << 
1085         union3 = new G4IntersectionSolid("_un << 
1086         return (G4DisplacedSolid*)union3;     << 
1087       }                                       << 
1088       break;                                  << 
1089                                               << 
1090     case G4ViewParameters::cutawayIntersectio << 
1091       // And here we make an intersector of i << 
1092       intersection2                           << 
1093       = new G4IntersectionSolid("_intersectio << 
1094       if (nPlanes == 2) return (G4DisplacedSo << 
1095       else if (nPlanes == 3) {                << 
1096         intersection3                         << 
1097         = new G4IntersectionSolid("_intersect << 
1098         return (G4DisplacedSolid*)intersectio << 
1099       }                                       << 
1100       break;                                  << 
1101   }                                           << 
1102                                               << 
1103   G4Exception("G4VSceneHandler::CreateCutaway << 
1104               "Not programmed for more than 3 << 
1105   return nullptr;                             << 
1106 }                                             << 
1107                                               << 
1108 void G4VSceneHandler::LoadAtts(const G4Visibl << 
1109 {                                             << 
1110   // Load G4Atts from G4VisAttributes, if any << 
1111   const G4VisAttributes* va = visible.GetVisA << 
1112   if (va) {                                   << 
1113     const std::map<G4String,G4AttDef>* vaDefs << 
1114       va->GetAttDefs();                       << 
1115     if (vaDefs) {                             << 
1116       holder->AddAtts(visible.GetVisAttribute << 
1117     }                                         << 
1118   }                                           << 
1119                                               << 
1120   G4PhysicalVolumeModel* pPVModel =           << 
1121     dynamic_cast<G4PhysicalVolumeModel*>(fpMo << 
1122   if (pPVModel) {                             << 
1123     // Load G4Atts from G4PhysicalVolumeModel << 
1124     const std::map<G4String,G4AttDef>* pvDefs << 
1125     if (pvDefs) {                             << 
1126       holder->AddAtts(pPVModel->CreateCurrent << 
1127     }                                         << 
1128   }                                           << 
1129                                               << 
1130   G4TrajectoriesModel* trajModel = dynamic_ca << 
1131   if (trajModel) {                            << 
1132     // Load G4Atts from trajectory model...   << 
1133     const std::map<G4String,G4AttDef>* trajMo << 
1134     if (trajModelDefs) {                      << 
1135       holder->AddAtts(trajModel->CreateCurren << 
1136     }                                         << 
1137     // Load G4Atts from trajectory...         << 
1138     const G4VTrajectory* traj = trajModel->Ge << 
1139     if (traj) {                               << 
1140       const std::map<G4String,G4AttDef>* traj << 
1141       if (trajDefs) {                         << 
1142         holder->AddAtts(traj->CreateAttValues << 
1143       }                                       << 
1144       G4int nPoints = traj->GetPointEntries() << 
1145       for (G4int i = 0; i < nPoints; ++i) {   << 
1146         G4VTrajectoryPoint* trajPoint = traj- << 
1147         if (trajPoint) {                      << 
1148           const std::map<G4String,G4AttDef>*  << 
1149           if (pointDefs) {                    << 
1150             holder->AddAtts(trajPoint->Create << 
1151           }                                   << 
1152         }                                     << 
1153       }                                       << 
1154     }                                         << 
1155   }                                           << 
1156                                               << 
1157   G4HitsModel* hitsModel = dynamic_cast<G4Hit << 
1158   if (hitsModel) {                            << 
1159     // Load G4Atts from hit...                << 
1160     const G4VHit* hit = hitsModel->GetCurrent << 
1161     const std::map<G4String,G4AttDef>* hitsDe << 
1162     if (hitsDefs) {                           << 
1163       holder->AddAtts(hit->CreateAttValues(), << 
1164     }                                         << 
1165   }                                           << 
1166 }                                             << 
1167                                               << 
1168 const G4Colour& G4VSceneHandler::GetColour () << 
1169   fpVisAttribs = fpViewer->GetApplicableVisAt << 
1170   const G4Colour& colour = fpVisAttribs -> Ge << 
1171   return colour;                              << 
1172 }                                             << 
1173                                               << 
1174 const G4Colour& G4VSceneHandler::GetColour (c    700 const G4Colour& G4VSceneHandler::GetColour (const G4Visible& visible) {
1175   auto pVA = visible.GetVisAttributes();      << 701   // Colour is determined by the applicable vis attributes.
1176   if (!pVA) pVA = fpViewer->GetViewParameters << 702   const G4Colour& colour = fpViewer ->
1177   return pVA->GetColour();                    << 703     GetApplicableVisAttributes (visible.GetVisAttributes ()) ->  GetColour ();
                                                   >> 704   return colour;
1178 }                                                705 }
1179                                                  706 
1180 const G4Colour& G4VSceneHandler::GetTextColou    707 const G4Colour& G4VSceneHandler::GetTextColour (const G4Text& text) {
1181   auto pVA = text.GetVisAttributes();         << 708   const G4VisAttributes* pVA = text.GetVisAttributes ();
1182   if (!pVA) pVA = fpViewer->GetViewParameters << 709   if (!pVA) {
1183   return pVA->GetColour();                    << 710     pVA = fpViewer -> GetViewParameters (). GetDefaultTextVisAttributes ();
1184 }                                             << 711   }
1185                                               << 712   const G4Colour& colour = pVA -> GetColour ();
1186 G4double G4VSceneHandler::GetLineWidth(const  << 713   return colour;
1187 {                                             << 
1188   G4double lineWidth = pVisAttribs->GetLineWi << 
1189   if (lineWidth < 1.) lineWidth = 1.;         << 
1190   lineWidth *= fpViewer -> GetViewParameters( << 
1191   if (lineWidth < 1.) lineWidth = 1.;         << 
1192   return lineWidth;                           << 
1193 }                                                714 }
1194                                                  715 
1195 G4ViewParameters::DrawingStyle G4VSceneHandle    716 G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle
1196 (const G4VisAttributes* pVisAttribs) {           717 (const G4VisAttributes* pVisAttribs) {
1197   // Drawing style is normally determined by     718   // Drawing style is normally determined by the view parameters, but
1198   // it can be overriddden by the ForceDrawin    719   // it can be overriddden by the ForceDrawingStyle flag in the vis
1199   // attributes.                                 720   // attributes.
1200   const G4ViewParameters& vp = fpViewer->GetV << 721   G4ViewParameters::DrawingStyle style =
1201   const G4ViewParameters::DrawingStyle viewer << 722     fpViewer->GetViewParameters().GetDrawingStyle();
1202   G4ViewParameters::DrawingStyle resultantSty << 
1203   if (pVisAttribs -> IsForceDrawingStyle ())     723   if (pVisAttribs -> IsForceDrawingStyle ()) {
1204     G4VisAttributes::ForcedDrawingStyle force    724     G4VisAttributes::ForcedDrawingStyle forcedStyle =
1205     pVisAttribs -> GetForcedDrawingStyle ();  << 725       pVisAttribs -> GetForcedDrawingStyle ();
1206     // This is complicated because if hidden     726     // This is complicated because if hidden line and surface removal
1207     // has been requested we wish to preserve    727     // has been requested we wish to preserve this sometimes.
1208     switch (forcedStyle) {                       728     switch (forcedStyle) {
1209       case (G4VisAttributes::solid):          << 729     case (G4VisAttributes::solid):
1210         switch (viewerStyle) {                << 730       switch (style) {
1211           case (G4ViewParameters::hlr):       << 731       case (G4ViewParameters::hlr):
1212             resultantStyle = G4ViewParameters << 732   style = G4ViewParameters::hlhsr;
1213             break;                            << 733   break;
1214           case (G4ViewParameters::wireframe): << 734       case (G4ViewParameters::wireframe):
1215             resultantStyle = G4ViewParameters << 735   style = G4ViewParameters::hsr;
1216             break;                            << 736   break;
1217           case (G4ViewParameters::cloud):     << 737       case (G4ViewParameters::hlhsr):
1218             resultantStyle = G4ViewParameters << 738       case (G4ViewParameters::hsr):
1219             break;                            << 
1220           case (G4ViewParameters::hlhsr):     << 
1221           case (G4ViewParameters::hsr):       << 
1222             break;                            << 
1223         }                                     << 
1224         break;                                << 
1225       case (G4VisAttributes::cloud):          << 
1226         resultantStyle = G4ViewParameters::cl << 
1227         break;                                << 
1228       case (G4VisAttributes::wireframe):      << 
1229       default:                                   739       default:
1230         // But if forced style is wireframe,  << 740   break;
1231         // main uses is in displaying the con << 741       } 
1232         // solid and their surfaces overlap w << 742       break;
1233         // solid, making a mess if hlr is spe << 743     case (G4VisAttributes::wireframe):
1234         resultantStyle = G4ViewParameters::wi << 744     default:
1235         break;                                << 745       // But if forced style is wireframe, do it, because one of its
                                                   >> 746       // main uses is in displaying the consituent solids of a Boolean
                                                   >> 747       // solid and their surfaces overlap with the resulting Booean
                                                   >> 748       // solid, making a mess if hlr is specified.
                                                   >> 749       style = G4ViewParameters::wireframe;
                                                   >> 750       break;
1236     }                                            751     }
1237   }                                              752   }
1238   return resultantStyle;                      << 753   return style;
1239 }                                             << 
1240                                               << 
1241 G4int G4VSceneHandler::GetNumberOfCloudPoints << 
1242 (const G4VisAttributes* pVisAttribs) const {  << 
1243   // Returns no of cloud points from current  << 
1244   // has forced through the vis attributes, t << 
1245   // current view parameter.                  << 
1246   G4int numberOfCloudPoints = fpViewer->GetVi << 
1247   if (pVisAttribs -> IsForceDrawingStyle() && << 
1248       pVisAttribs -> GetForcedDrawingStyle()  << 
1249       pVisAttribs -> GetForcedNumberOfCloudPo << 
1250     numberOfCloudPoints = pVisAttribs -> GetF << 
1251   }                                           << 
1252   return numberOfCloudPoints;                 << 
1253 }                                                754 }
1254                                                  755 
1255 G4bool G4VSceneHandler::GetAuxEdgeVisible (co    756 G4bool G4VSceneHandler::GetAuxEdgeVisible (const G4VisAttributes* pVisAttribs) {
1256   G4bool isAuxEdgeVisible = fpViewer->GetView    757   G4bool isAuxEdgeVisible = fpViewer->GetViewParameters().IsAuxEdgeVisible ();
1257   if (pVisAttribs -> IsForceAuxEdgeVisible()) << 758   if (pVisAttribs -> IsForceAuxEdgeVisible()) isAuxEdgeVisible = true;
1258     isAuxEdgeVisible = pVisAttribs->IsForcedA << 
1259   }                                           << 
1260   return isAuxEdgeVisible;                       759   return isAuxEdgeVisible;
1261 }                                                760 }
1262                                                  761 
1263 G4double G4VSceneHandler::GetMarkerSize       << 762 G4double G4VSceneHandler::GetMarkerSize (const G4VMarker& marker, 
1264 (const G4VMarker& marker,                     << 763           G4VSceneHandler::MarkerSizeType& markerSizeType) {
1265  G4VSceneHandler::MarkerSizeType& markerSizeT << 
1266 {                                             << 
1267   G4bool userSpecified = marker.GetWorldSize(    764   G4bool userSpecified = marker.GetWorldSize() || marker.GetScreenSize();
1268   const G4VMarker& defaultMarker =               765   const G4VMarker& defaultMarker =
1269     fpViewer -> GetViewParameters().GetDefaul    766     fpViewer -> GetViewParameters().GetDefaultMarker();
1270   G4double size = userSpecified ?                767   G4double size = userSpecified ?
1271     marker.GetWorldSize() : defaultMarker.Get    768     marker.GetWorldSize() : defaultMarker.GetWorldSize();
1272   if (size) {                                    769   if (size) {
1273     // Draw in world coordinates.                770     // Draw in world coordinates.
1274     markerSizeType = world;                      771     markerSizeType = world;
1275   }                                              772   }
1276   else {                                         773   else {
1277     size = userSpecified ?                       774     size = userSpecified ?
1278       marker.GetScreenSize() : defaultMarker.    775       marker.GetScreenSize() : defaultMarker.GetScreenSize();
1279     // Draw in screen coordinates.               776     // Draw in screen coordinates.
1280     markerSizeType = screen;                     777     markerSizeType = screen;
1281   }                                              778   }
                                                   >> 779   if (size <= 0.) size = 1.;
1282   size *= fpViewer -> GetViewParameters().Get    780   size *= fpViewer -> GetViewParameters().GetGlobalMarkerScale();
1283   if (markerSizeType == screen && size < 1.)  << 
1284   return size;                                   781   return size;
1285 }                                                782 }
1286                                                  783 
1287 G4int G4VSceneHandler::GetNoOfSides(const G4V << 784 std::ostream& operator << (std::ostream& os, const G4VSceneHandler& s) {
1288 {                                             << 
1289   // No. of sides (lines segments per circle) << 
1290   // by the view parameters, but it can be ov << 
1291   // ForceLineSegmentsPerCircle in the vis at << 
1292   G4int lineSegmentsPerCircle = fpViewer->Get << 
1293   if (pVisAttribs) {                          << 
1294     if (pVisAttribs->IsForceLineSegmentsPerCi << 
1295       lineSegmentsPerCircle = pVisAttribs->Ge << 
1296     if (lineSegmentsPerCircle < pVisAttribs-> << 
1297       lineSegmentsPerCircle = pVisAttribs->Ge << 
1298       G4warn <<                               << 
1299   "G4VSceneHandler::GetNoOfSides: attempt to  << 
1300   "\nnumber of line segments per circle < " < << 
1301        << "; forced to " << pVisAttribs->GetM << 
1302     }                                         << 
1303   }                                           << 
1304   return lineSegmentsPerCircle;               << 
1305 }                                             << 
1306                                                  785 
1307 std::ostream& operator << (std::ostream& os,  << 786   os << "Scene handler " << s.fName << " has "
1308                                               << 787      << s.fViewerList.size () << " viewer(s):";
1309   os << "Scene handler " << sh.fName << " has << 788   for (size_t i = 0; i < s.fViewerList.size (); i++) {
1310      << sh.fViewerList.size () << " viewer(s) << 789     os << "\n  " << *(s.fViewerList [i]);
1311   for (std::size_t i = 0; i < sh.fViewerList. << 
1312     os << "\n  " << *(sh.fViewerList [i]);    << 
1313   }                                              790   }
1314                                                  791 
1315   if (sh.fpScene) {                           << 792   if (s.fpScene) {
1316     os << "\n  " << *sh.fpScene;              << 793     os << "\n  " << *s.fpScene;
1317   }                                              794   }
1318   else {                                         795   else {
1319     os << "\n  This scene handler currently h    796     os << "\n  This scene handler currently has no scene.";
1320   }                                              797   }
1321                                                  798 
1322   return os;                                     799   return os;
1323 }                                             << 
1324                                               << 
1325 void G4VSceneHandler::PseudoSceneFor3DRectMes << 
1326   if (fpPVModel->GetCurrentDepth() == fpMesh- << 
1327     const auto& material = fpPVModel->GetCurr << 
1328     const auto& name = material? material->Ge << 
1329     const auto& pVisAtts = fpPVModel->GetCurr << 
1330     // Get position in world coordinates      << 
1331     // As a parameterisation the box is trans << 
1332     // and its centre, originally by definiti << 
1333     const G4ThreeVector& position = fpCurrent << 
1334     fPositionByMaterial.insert(std::make_pair << 
1335     if (fNameAndVisAttsByMaterial.find(materi << 
1336       // Store name and vis attributes of fir << 
1337       fNameAndVisAttsByMaterial[material] = N << 
1338   }                                           << 
1339 }                                             << 
1340                                               << 
1341 void G4VSceneHandler::PseudoSceneForTetVertic << 
1342   if (fpPVModel->GetCurrentDepth() == fpMesh- << 
1343     // Need to know it's a tet !!!! or implem << 
1344     try {                                     << 
1345       const auto& tet = dynamic_cast<const G4 << 
1346       const auto& material = fpPVModel->GetCu << 
1347       const auto& name = material? material-> << 
1348       const auto& pVisAtts = fpPVModel->GetCu << 
1349       // Transform into world coordinates if  << 
1350       if (fpCurrentObjectTransformation->xx() << 
1351           fpCurrentObjectTransformation->yy() << 
1352           fpCurrentObjectTransformation->zz() << 
1353         const auto& vertices = tet.GetVertice << 
1354         fVerticesByMaterial.insert(std::make_ << 
1355       } else {                                << 
1356         auto vertices = tet.GetVertices();    << 
1357         for (auto&& vertex: vertices) {       << 
1358           vertex = G4Point3D(vertex).transfor << 
1359         }                                     << 
1360         fVerticesByMaterial.insert(std::make_ << 
1361       }                                       << 
1362       if (fNameAndVisAttsByMaterial.find(mate << 
1363         // Store name and vis attributes of f << 
1364         fNameAndVisAttsByMaterial[material] = << 
1365     }                                         << 
1366     catch (const std::bad_cast&) {            << 
1367       G4ExceptionDescription ed;              << 
1368       ed << "Called for a mesh that is not a  << 
1369       G4Exception("PseudoSceneForTetVertices" << 
1370     }                                         << 
1371   }                                           << 
1372 }                                             << 
1373                                               << 
1374 void G4VSceneHandler::StandardSpecialMeshRend << 
1375 // Standard way of special mesh rendering.    << 
1376 // MySceneHandler::AddCompound(const G4Mesh&  << 
1377 // appropriate or implement its own special m << 
1378 {                                             << 
1379   G4bool implemented = false;                 << 
1380   switch (mesh.GetMeshType()) {               << 
1381     case G4Mesh::rectangle: [[fallthrough]];  << 
1382     case G4Mesh::nested3DRectangular:         << 
1383       switch (fpViewer->GetViewParameters().G << 
1384         case G4ViewParameters::meshAsDefault: << 
1385           [[fallthrough]];                    << 
1386         case G4ViewParameters::meshAsDots:    << 
1387           Draw3DRectMeshAsDots(mesh);  // Rec << 
1388           implemented = true;                 << 
1389           break;                              << 
1390         case G4ViewParameters::meshAsSurfaces << 
1391           Draw3DRectMeshAsSurfaces(mesh);  // << 
1392           implemented = true;                 << 
1393           break;                              << 
1394       }                                       << 
1395       break;                                  << 
1396     case G4Mesh::tetrahedron:                 << 
1397       switch (fpViewer->GetViewParameters().G << 
1398         case G4ViewParameters::meshAsDefault: << 
1399           [[fallthrough]];                    << 
1400         case G4ViewParameters::meshAsDots:    << 
1401           DrawTetMeshAsDots(mesh);  // Tetrah << 
1402           implemented = true;                 << 
1403           break;                              << 
1404         case G4ViewParameters::meshAsSurfaces << 
1405           DrawTetMeshAsSurfaces(mesh);  // Te << 
1406           implemented = true;                 << 
1407           break;                              << 
1408       }                                       << 
1409       break;                                  << 
1410     case G4Mesh::cylinder: [[fallthrough]];   << 
1411     case G4Mesh::sphere: [[fallthrough]];     << 
1412     case G4Mesh::invalid: break;              << 
1413   }                                           << 
1414   if (implemented) {                          << 
1415     // Draw container if not marked invisible << 
1416     auto container = mesh.GetContainerVolume( << 
1417     auto containerLogical = container->GetLog << 
1418     auto containerVisAtts = containerLogical- << 
1419     if (containerVisAtts == nullptr || contai << 
1420       auto solid = containerLogical->GetSolid << 
1421       auto polyhedron = solid->GetPolyhedron( << 
1422       // Always draw as wireframe             << 
1423       G4VisAttributes tmpVisAtts;             << 
1424       if (containerVisAtts != nullptr) tmpVis << 
1425       tmpVisAtts.SetForceWireframe();         << 
1426       polyhedron->SetVisAttributes(tmpVisAtts << 
1427       BeginPrimitives(mesh.GetTransform());   << 
1428       AddPrimitive(*polyhedron);              << 
1429       EndPrimitives();                        << 
1430     }                                         << 
1431   } else {                                    << 
1432     // Invoke base class function             << 
1433     G4VSceneHandler::AddCompound(mesh);       << 
1434   }                                           << 
1435   return;                                     << 
1436 }                                             << 
1437                                               << 
1438 void G4VSceneHandler::Draw3DRectMeshAsDots(co << 
1439 // For a rectangular 3-D mesh, draw as colour << 
1440 // one dot randomly placed in each visible me << 
1441 {                                             << 
1442   // Check                                    << 
1443   if (mesh.GetMeshType() != G4Mesh::rectangle << 
1444       mesh.GetMeshType() != G4Mesh::nested3DR << 
1445     G4ExceptionDescription ed;                << 
1446     ed << "Called with a mesh that is not rec << 
1447     G4Exception("G4VSceneHandler::Draw3DRectM << 
1448     return;                                   << 
1449   }                                           << 
1450                                               << 
1451   static G4bool firstPrint = true;            << 
1452   const auto& verbosity = G4VisManager::GetVe << 
1453   G4bool print = firstPrint && verbosity >= G << 
1454   if (print) {                                << 
1455     G4cout                                    << 
1456     << "Special case drawing of 3D rectangula << 
1457     << '\n' << mesh                           << 
1458     << G4endl;                                << 
1459   }                                           << 
1460                                               << 
1461   const auto& container = mesh.GetContainerVo << 
1462                                               << 
1463   // This map is static so that once filled i << 
1464   static std::map<G4String,std::map<const G4M << 
1465   auto& dotsByMaterial = dotsByMaterialAndMes << 
1466                                               << 
1467   // Fill map if not already filled           << 
1468   if (dotsByMaterial.empty()) {               << 
1469                                               << 
1470     // Get positions and material one cell at << 
1471     // The pseudo scene allows a "private" de << 
1472     // Instantiate a temporary G4PhysicalVolu << 
1473     G4ModelingParameters tmpMP;               << 
1474     tmpMP.SetCulling(true);  // This avoids d << 
1475     tmpMP.SetCullingInvisible(true);  // ...  << 
1476     const G4bool useFullExtent = true;  // To << 
1477     G4PhysicalVolumeModel tmpPVModel          << 
1478     (container,                               << 
1479      G4PhysicalVolumeModel::UNLIMITED,        << 
1480      G4Transform3D(),  // so that positions a << 
1481      &tmpMP,                                  << 
1482      useFullExtent);                          << 
1483     // Accumulate information in temporary ma << 
1484     std::multimap<const G4Material*,const G4T << 
1485     std::map<const G4Material*,G4VSceneHandle << 
1486     // Instantiate the pseudo scene           << 
1487     PseudoSceneFor3DRectMeshPositions pseudoS << 
1488     (&tmpPVModel,&mesh,positionByMaterial,nam << 
1489     // Make private descent into the paramete << 
1490     tmpPVModel.DescribeYourselfTo(pseudoScene << 
1491     // Now we have a map of positions by mate << 
1492     // Also a map of name and colour by mater << 
1493                                               << 
1494     const auto& prms = mesh.GetThreeDRectPara << 
1495     const auto& halfX = prms.fHalfX;          << 
1496     const auto& halfY = prms.fHalfY;          << 
1497     const auto& halfZ = prms.fHalfZ;          << 
1498                                               << 
1499     // Fill the permanent (static) map of dot << 
1500     G4int nDotsTotal = 0;                     << 
1501     for (const auto& entry: nameAndVisAttsByM << 
1502       G4int nDots = 0;                        << 
1503       const auto& material = entry.first;     << 
1504       const auto& nameAndVisAtts = nameAndVis << 
1505       const auto& name = nameAndVisAtts.fName << 
1506       const auto& visAtts = nameAndVisAtts.fV << 
1507       G4Polymarker dots;                      << 
1508       dots.SetInfo(name);                     << 
1509       dots.SetVisAttributes(visAtts);         << 
1510       dots.SetMarkerType(G4Polymarker::dots); << 
1511       dots.SetSize(G4VMarker::screen,1.);     << 
1512       // Enter empty polymarker into the map  << 
1513       dotsByMaterial[material] = dots;        << 
1514       // Now fill it in situ                  << 
1515       auto& dotsInMap = dotsByMaterial[materi << 
1516       const auto& range = positionByMaterial. << 
1517       for (auto posByMat = range.first; posBy << 
1518         dotsInMap.push_back(GetPointInBox(pos << 
1519         ++nDots;                              << 
1520       }                                       << 
1521                                               << 
1522       if (print) {                            << 
1523         G4cout                                << 
1524         << std::setw(30) << std::left << name << 
1525         << ": " << std::setw(7) << nDots << " << 
1526         << ": colour " << std::fixed << std:: << 
1527         << visAtts.GetColour() << std::defaul << 
1528         << G4endl;                            << 
1529       }                                       << 
1530                                               << 
1531       nDotsTotal += nDots;                    << 
1532     }                                         << 
1533                                               << 
1534     if (print) {                              << 
1535       G4cout << "Total number of dots: " << n << 
1536     }                                         << 
1537   }                                           << 
1538                                               << 
1539   // Some subsequent expressions apply only t << 
1540   auto pPVModel = dynamic_cast<G4PhysicalVolu << 
1541                                               << 
1542   G4String parameterisationName;              << 
1543   if (pPVModel) {                             << 
1544     parameterisationName = pPVModel->GetFullP << 
1545   }                                           << 
1546                                               << 
1547   // Draw the dots by material                << 
1548   // Ensure they are "hidden", i.e., use the  << 
1549   auto keepVP = fpViewer->GetViewParameters() << 
1550   auto vp = fpViewer->GetViewParameters();    << 
1551   vp.SetMarkerHidden();                       << 
1552   fpViewer->SetViewParameters(vp);            << 
1553   // Now we transform to world coordinates    << 
1554   BeginPrimitives (mesh.GetTransform());      << 
1555   for (const auto& entry: dotsByMaterial) {   << 
1556     const auto& dots = entry.second;          << 
1557     // The current "leaf" node in the PVPath  << 
1558     // been converted into polymarkers by mat << 
1559     // its name to that of the material (whos << 
1560     // so that its appearance in the scene tr << 
1561     // an appropriate name and its visibility << 
1562     if (pPVModel) {                           << 
1563       const auto& fullPVPath = pPVModel->GetF << 
1564       auto leafPV = fullPVPath.back().GetPhys << 
1565       leafPV->SetName(dots.GetInfo());        << 
1566     }                                         << 
1567     // Add dots to the scene                  << 
1568     AddPrimitive(dots);                       << 
1569   }                                           << 
1570   EndPrimitives ();                           << 
1571   // Restore view parameters                  << 
1572   fpViewer->SetViewParameters(keepVP);        << 
1573   // Restore parameterisation name            << 
1574   if (pPVModel) {                             << 
1575     pPVModel->GetFullPVPath().back().GetPhysi << 
1576   }                                           << 
1577                                               << 
1578   firstPrint = false;                         << 
1579   return;                                     << 
1580 }                                             << 
1581                                               << 
1582 void G4VSceneHandler::Draw3DRectMeshAsSurface << 
1583 // For a rectangular 3-D mesh, draw as surfac << 
1584 // with inner shared faces removed.           << 
1585 {                                             << 
1586   // Check                                    << 
1587   if (mesh.GetMeshType() != G4Mesh::rectangle << 
1588       mesh.GetMeshType() != G4Mesh::nested3DR << 
1589     G4ExceptionDescription ed;                << 
1590     ed << "Called with a mesh that is not rec << 
1591     G4Exception("G4VSceneHandler::Draw3DRectM << 
1592     return;                                   << 
1593   }                                           << 
1594                                               << 
1595   static G4bool firstPrint = true;            << 
1596   const auto& verbosity = G4VisManager::GetVe << 
1597   G4bool print = firstPrint && verbosity >= G << 
1598   if (print) {                                << 
1599     G4cout                                    << 
1600     << "Special case drawing of 3D rectangula << 
1601     << '\n' << mesh                           << 
1602     << G4endl;                                << 
1603   }                                           << 
1604                                               << 
1605   const auto& container = mesh.GetContainerVo << 
1606                                               << 
1607   // This map is static so that once filled i << 
1608   static std::map<G4String,std::map<const G4M << 
1609   auto& boxesByMaterial = boxesByMaterialAndM << 
1610                                               << 
1611   // Fill map if not already filled           << 
1612   if (boxesByMaterial.empty()) {              << 
1613                                               << 
1614     // Get positions and material one cell at << 
1615     // The pseudo scene allows a "private" de << 
1616     // Instantiate a temporary G4PhysicalVolu << 
1617     G4ModelingParameters tmpMP;               << 
1618     tmpMP.SetCulling(true);  // This avoids d << 
1619     tmpMP.SetCullingInvisible(true);  // ...  << 
1620     const G4bool useFullExtent = true;  // To << 
1621     G4PhysicalVolumeModel tmpPVModel          << 
1622     (container,                               << 
1623      G4PhysicalVolumeModel::UNLIMITED,        << 
1624      G4Transform3D(),  // so that positions a << 
1625      &tmpMP,                                  << 
1626      useFullExtent);                          << 
1627     // Accumulate information in temporary ma << 
1628     std::multimap<const G4Material*,const G4T << 
1629     std::map<const G4Material*,G4VSceneHandle << 
1630     // Instantiate the pseudo scene           << 
1631     PseudoSceneFor3DRectMeshPositions pseudoS << 
1632     (&tmpPVModel,&mesh,positionByMaterial,nam << 
1633     // Make private descent into the paramete << 
1634     tmpPVModel.DescribeYourselfTo(pseudoScene << 
1635     // Now we have a map of positions by mate << 
1636     // Also a map of name and colour by mater << 
1637                                               << 
1638     const auto& prms = mesh.GetThreeDRectPara << 
1639     const auto& sizeX = 2.*prms.fHalfX;       << 
1640     const auto& sizeY = 2.*prms.fHalfY;       << 
1641     const auto& sizeZ = 2.*prms.fHalfZ;       << 
1642                                               << 
1643     // Fill the permanent (static) map of box << 
1644     G4int nBoxesTotal = 0, nFacetsTotal = 0;  << 
1645     for (const auto& entry: nameAndVisAttsByM << 
1646       G4int nBoxes = 0;                       << 
1647       const auto& material = entry.first;     << 
1648       const auto& nameAndVisAtts = nameAndVis << 
1649       const auto& name = nameAndVisAtts.fName << 
1650       const auto& visAtts = nameAndVisAtts.fV << 
1651       // Transfer positions into a vector rea << 
1652       std::vector<G4ThreeVector> positionsFor << 
1653       const auto& range = positionByMaterial. << 
1654       for (auto posByMat = range.first; posBy << 
1655         const auto& position = posByMat->seco << 
1656         positionsForPolyhedron.push_back(posi << 
1657         ++nBoxes;                             << 
1658       }                                       << 
1659       // The polyhedron will be in local coor << 
1660       // Add an empty place-holder to the map << 
1661       auto& polyhedron = boxesByMaterial[mate << 
1662       // Replace with the desired polyhedron  << 
1663       polyhedron = G4PolyhedronBoxMesh(sizeX, << 
1664       polyhedron.SetVisAttributes(visAtts);   << 
1665       polyhedron.SetInfo(name);               << 
1666                                               << 
1667       if (print) {                            << 
1668         G4cout                                << 
1669         << std::setw(30) << std::left << name << 
1670         << ": " << std::setw(7) << nBoxes <<  << 
1671         << " (" << std::setw(7) << 6*nBoxes < << 
1672         << ": reduced to " << std::setw(7) << << 
1673         << std::setw(2) << std::fixed << std: << 
1674         << "%): colour " << std::fixed << std << 
1675         << visAtts.GetColour() << std::defaul << 
1676         << G4endl;                            << 
1677       }                                       << 
1678                                               << 
1679       nBoxesTotal += nBoxes;                  << 
1680       nFacetsTotal += polyhedron.GetNoFacets( << 
1681     }                                         << 
1682                                               << 
1683     if (print) {                              << 
1684       G4cout << "Total number of boxes: " <<  << 
1685       << ": reduced to " << nFacetsTotal << " << 
1686       << std::setw(2) << std::fixed << std::s << 
1687       << G4endl;                              << 
1688     }                                         << 
1689   }                                           << 
1690                                               << 
1691   // Some subsequent expressions apply only t << 
1692   auto pPVModel = dynamic_cast<G4PhysicalVolu << 
1693                                               << 
1694   G4String parameterisationName;              << 
1695   if (pPVModel) {                             << 
1696     parameterisationName = pPVModel->GetFullP << 
1697   }                                           << 
1698                                               << 
1699   // Draw the boxes by material               << 
1700   // Now we transform to world coordinates    << 
1701   BeginPrimitives (mesh.GetTransform());      << 
1702   for (const auto& entry: boxesByMaterial) {  << 
1703     const auto& poly = entry.second;          << 
1704     // The current "leaf" node in the PVPath  << 
1705     // been converted into polyhedra by mater << 
1706     // its name to that of the material (whos << 
1707     // so that its appearance in the scene tr << 
1708     // an appropriate name and its visibility << 
1709     if (pPVModel) {                           << 
1710       const auto& fullPVPath = pPVModel->GetF << 
1711       auto leafPV = fullPVPath.back().GetPhys << 
1712       leafPV->SetName(poly.GetInfo());        << 
1713     }                                         << 
1714     AddPrimitive(poly);                       << 
1715   }                                           << 
1716   EndPrimitives ();                           << 
1717   // Restore parameterisation name            << 
1718   if (pPVModel) {                             << 
1719     pPVModel->GetFullPVPath().back().GetPhysi << 
1720   }                                           << 
1721                                               << 
1722   firstPrint = false;                         << 
1723   return;                                     << 
1724 }                                             << 
1725                                               << 
1726 void G4VSceneHandler::DrawTetMeshAsDots(const << 
1727 // For a tetrahedron mesh, draw as coloured d << 
1728 // one dot randomly placed in each visible me << 
1729 {                                             << 
1730   // Check                                    << 
1731   if (mesh.GetMeshType() != G4Mesh::tetrahedr << 
1732     G4ExceptionDescription ed;                << 
1733     ed << "Called with mesh that is not a tet << 
1734     G4Exception("G4VSceneHandler::DrawTetMesh << 
1735     return;                                   << 
1736   }                                           << 
1737                                               << 
1738   static G4bool firstPrint = true;            << 
1739   const auto& verbosity = G4VisManager::GetVe << 
1740   G4bool print = firstPrint && verbosity >= G << 
1741                                               << 
1742   if (print) {                                << 
1743     G4cout                                    << 
1744     << "Special case drawing of tetrahedron m << 
1745     << '\n' << mesh                           << 
1746     << G4endl;                                << 
1747   }                                           << 
1748                                               << 
1749   const auto& container = mesh.GetContainerVo << 
1750                                               << 
1751   // This map is static so that once filled i << 
1752   static std::map<G4String,std::map<const G4M << 
1753   auto& dotsByMaterial = dotsByMaterialAndMes << 
1754                                               << 
1755   // Fill map if not already filled           << 
1756   if (dotsByMaterial.empty()) {               << 
1757                                               << 
1758     // Get vertices and colour one cell at a  << 
1759     // The pseudo scene allows a "private" de << 
1760     // Instantiate a temporary G4PhysicalVolu << 
1761     G4ModelingParameters tmpMP;               << 
1762     tmpMP.SetCulling(true);  // This avoids d << 
1763     tmpMP.SetCullingInvisible(true);  // ...  << 
1764     const G4bool useFullExtent = true;  // To << 
1765     G4PhysicalVolumeModel tmpPVModel          << 
1766     (container,                               << 
1767      G4PhysicalVolumeModel::UNLIMITED,        << 
1768      G4Transform3D(),  // so that positions a << 
1769      &tmpMP,                                  << 
1770      useFullExtent);                          << 
1771     // Accumulate information in temporary ma << 
1772     std::multimap<const G4Material*,std::vect << 
1773     std::map<const G4Material*,G4VSceneHandle << 
1774     // Instantiate a pseudo scene             << 
1775     PseudoSceneForTetVertices pseudoScene     << 
1776     (&tmpPVModel,&mesh,verticesByMaterial,nam << 
1777     // Make private descent into the paramete << 
1778     tmpPVModel.DescribeYourselfTo(pseudoScene << 
1779     // Now we have a map of vertices by mater << 
1780     // Also a map of name and colour by mater << 
1781                                               << 
1782     // Fill the permanent (static) map of dot << 
1783     G4int nDotsTotal = 0;                     << 
1784     for (const auto& entry: nameAndVisAttsByM << 
1785       G4int nDots = 0;                        << 
1786       const auto& material = entry.first;     << 
1787       const auto& nameAndVisAtts = nameAndVis << 
1788       const auto& name = nameAndVisAtts.fName << 
1789       const auto& visAtts = nameAndVisAtts.fV << 
1790       G4Polymarker dots;                      << 
1791       dots.SetVisAttributes(visAtts);         << 
1792       dots.SetMarkerType(G4Polymarker::dots); << 
1793       dots.SetSize(G4VMarker::screen,1.);     << 
1794       dots.SetInfo(name);                     << 
1795       // Enter empty polymarker into the map  << 
1796       dotsByMaterial[material] = dots;        << 
1797       // Now fill it in situ                  << 
1798       auto& dotsInMap = dotsByMaterial[materi << 
1799       const auto& range = verticesByMaterial. << 
1800       for (auto vByMat = range.first; vByMat  << 
1801         dotsInMap.push_back(GetPointInTet(vBy << 
1802         ++nDots;                              << 
1803       }                                       << 
1804                                               << 
1805       if (print) {                            << 
1806         G4cout                                << 
1807         << std::setw(30) << std::left << name << 
1808         << ": " << std::setw(7) << nDots << " << 
1809         << ": colour " << std::fixed << std:: << 
1810         << visAtts.GetColour() << std::defaul << 
1811         << G4endl;                            << 
1812       }                                       << 
1813                                               << 
1814       nDotsTotal += nDots;                    << 
1815     }                                         << 
1816                                               << 
1817     if (print) {                              << 
1818       G4cout << "Total number of dots: " << n << 
1819     }                                         << 
1820   }                                           << 
1821                                               << 
1822   // Some subsequent expressions apply only t << 
1823   auto pPVModel = dynamic_cast<G4PhysicalVolu << 
1824                                               << 
1825   G4String parameterisationName;              << 
1826   if (pPVModel) {                             << 
1827     parameterisationName = pPVModel->GetFullP << 
1828   }                                           << 
1829                                               << 
1830   // Draw the dots by material                << 
1831   // Ensure they are "hidden", i.e., use the  << 
1832   auto keepVP = fpViewer->GetViewParameters() << 
1833   auto vp = fpViewer->GetViewParameters();    << 
1834   vp.SetMarkerHidden();                       << 
1835   fpViewer->SetViewParameters(vp);            << 
1836                                               << 
1837   // Now we transform to world coordinates    << 
1838   BeginPrimitives (mesh.GetTransform());      << 
1839   for (const auto& entry: dotsByMaterial) {   << 
1840     const auto& dots = entry.second;          << 
1841     // The current "leaf" node in the PVPath  << 
1842     // been converted into polymarkers by mat << 
1843     // its name to that of the material (whos << 
1844     // so that its appearance in the scene tr << 
1845     // an appropriate name and its visibility << 
1846     if (pPVModel) {                           << 
1847       const auto& fullPVPath = pPVModel->GetF << 
1848       auto leafPV = fullPVPath.back().GetPhys << 
1849       leafPV->SetName(dots.GetInfo());        << 
1850     }                                         << 
1851     AddPrimitive(dots);                       << 
1852   }                                           << 
1853   EndPrimitives ();                           << 
1854                                               << 
1855   // Restore view parameters                  << 
1856   fpViewer->SetViewParameters(keepVP);        << 
1857   // Restore parameterisation name            << 
1858   if (pPVModel) {                             << 
1859     pPVModel->GetFullPVPath().back().GetPhysi << 
1860   }                                           << 
1861                                               << 
1862   firstPrint = false;                         << 
1863   return;                                     << 
1864 }                                             << 
1865                                               << 
1866 void G4VSceneHandler::DrawTetMeshAsSurfaces(c << 
1867 // For a tetrahedron mesh, draw as surfaces b << 
1868 // with inner shared faces removed.           << 
1869 {                                             << 
1870   // Check                                    << 
1871   if (mesh.GetMeshType() != G4Mesh::tetrahedr << 
1872     G4ExceptionDescription ed;                << 
1873     ed << "Called with mesh that is not a tet << 
1874     G4Exception("G4VSceneHandler::DrawTetMesh << 
1875     return;                                   << 
1876   }                                           << 
1877                                               << 
1878   static G4bool firstPrint = true;            << 
1879   const auto& verbosity = G4VisManager::GetVe << 
1880   G4bool print = firstPrint && verbosity >= G << 
1881                                               << 
1882   if (print) {                                << 
1883     G4cout                                    << 
1884     << "Special case drawing of tetrahedron m << 
1885     << '\n' << mesh                           << 
1886     << G4endl;                                << 
1887   }                                           << 
1888                                               << 
1889   // This map is static so that once filled i << 
1890   static std::map<G4String,std::map<const G4M << 
1891   auto& surfacesByMaterial = surfacesByMateri << 
1892                                               << 
1893   // Fill map if not already filled           << 
1894   if (surfacesByMaterial.empty()) {           << 
1895                                               << 
1896     // Get vertices and colour one cell at a  << 
1897     // The pseudo scene allows a "private" de << 
1898     // Instantiate a temporary G4PhysicalVolu << 
1899     G4ModelingParameters tmpMP;               << 
1900     tmpMP.SetCulling(true);  // This avoids d << 
1901     tmpMP.SetCullingInvisible(true);  // ...  << 
1902     const G4bool useFullExtent = true;  // To << 
1903     G4PhysicalVolumeModel tmpPVModel          << 
1904     (mesh.GetContainerVolume(),               << 
1905      G4PhysicalVolumeModel::UNLIMITED,        << 
1906      G4Transform3D(),  // so that positions a << 
1907      &tmpMP,                                  << 
1908      useFullExtent);                          << 
1909     // Accumulate information in temporary ma << 
1910     std::multimap<const G4Material*,std::vect << 
1911     std::map<const G4Material*,G4VSceneHandle << 
1912     // Instantiate a pseudo scene             << 
1913     PseudoSceneForTetVertices pseudoScene     << 
1914     (&tmpPVModel,&mesh,verticesByMaterial,nam << 
1915     // Make private descent into the paramete << 
1916     tmpPVModel.DescribeYourselfTo(pseudoScene << 
1917     // Now we have a map of vertices by mater << 
1918     // Also a map of name and colour by mater << 
1919                                               << 
1920     // Fill the permanent (static) map of sur << 
1921     G4int nTetsTotal = 0, nFacetsTotal = 0;   << 
1922     for (const auto& entry: nameAndVisAttsByM << 
1923       G4int nTets = 0;                        << 
1924       const auto& material = entry.first;     << 
1925       const auto& nameAndVisAtts = nameAndVis << 
1926       const auto& name = nameAndVisAtts.fName << 
1927       const auto& visAtts = nameAndVisAtts.fV << 
1928       // Transfer vertices into a vector read << 
1929       std::vector<G4ThreeVector> verticesForP << 
1930       const auto& range = verticesByMaterial. << 
1931       for (auto vByMat = range.first; vByMat  << 
1932         const std::vector<G4ThreeVector>& ver << 
1933         for (const auto& vertex: vertices)    << 
1934           verticesForPolyhedron.push_back(ver << 
1935         ++nTets;                              << 
1936       }                                       << 
1937       // The polyhedron will be in local coor << 
1938       // Add an empty place-holder to the map << 
1939       auto& polyhedron = surfacesByMaterial[m << 
1940       // Replace with the desired polyhedron  << 
1941       polyhedron = G4PolyhedronTetMesh(vertic << 
1942       polyhedron.SetVisAttributes(visAtts);   << 
1943       polyhedron.SetInfo(name);               << 
1944                                               << 
1945       if (print) {                            << 
1946         G4cout                                << 
1947         << std::setw(30) << std::left << name << 
1948         << ": " << std::setw(7) << nTets << " << 
1949         << " (" << std::setw(7) << 4*nTets << << 
1950         << ": reduced to " << std::setw(7) << << 
1951         << std::setw(2) << std::fixed << std: << 
1952         << "%): colour " << std::fixed << std << 
1953         << visAtts.GetColour() << std::defaul << 
1954         << G4endl;                            << 
1955      }                                        << 
1956                                               << 
1957       nTetsTotal += nTets;                    << 
1958       nFacetsTotal += polyhedron.GetNoFacets( << 
1959     }                                         << 
1960                                               << 
1961     if (print) {                              << 
1962       G4cout << "Total number of tetrahedra:  << 
1963       << ": reduced to " << nFacetsTotal << " << 
1964       << std::setw(2) << std::fixed << std::s << 
1965       << G4endl;                              << 
1966     }                                         << 
1967   }                                           << 
1968                                               << 
1969   // Some subsequent expressions apply only t << 
1970   auto pPVModel = dynamic_cast<G4PhysicalVolu << 
1971                                               << 
1972   G4String parameterisationName;              << 
1973   if (pPVModel) {                             << 
1974     parameterisationName = pPVModel->GetFullP << 
1975   }                                           << 
1976                                               << 
1977   // Draw the surfaces by material            << 
1978   // Now we transform to world coordinates    << 
1979   BeginPrimitives (mesh.GetTransform());      << 
1980   for (const auto& entry: surfacesByMaterial) << 
1981     const auto& poly = entry.second;          << 
1982     // The current "leaf" node in the PVPath  << 
1983     // been converted into polyhedra by mater << 
1984     // its name to that of the material (whos << 
1985     // so that its appearance in the scene tr << 
1986     // an appropriate name and its visibility << 
1987     if (pPVModel) {                           << 
1988       const auto& fullPVPath = pPVModel->GetF << 
1989       auto leafPV = fullPVPath.back().GetPhys << 
1990       leafPV->SetName(poly.GetInfo());        << 
1991     }                                         << 
1992     AddPrimitive(poly);                       << 
1993   }                                           << 
1994   EndPrimitives ();                           << 
1995                                               << 
1996   // Restore parameterisation name            << 
1997   if (pPVModel) {                             << 
1998     pPVModel->GetFullPVPath().back().GetPhysi << 
1999   }                                           << 
2000                                               << 
2001   firstPrint = false;                         << 
2002   return;                                     << 
2003 }                                             << 
2004                                               << 
2005 G4ThreeVector                                 << 
2006 G4VSceneHandler::GetPointInBox(const G4ThreeV << 
2007                                G4double halfX << 
2008                                G4double halfY << 
2009                                G4double halfZ << 
2010 {                                             << 
2011   G4double x = pos.getX() + (2.*G4QuickRand() << 
2012   G4double y = pos.getY() + (2.*G4QuickRand() << 
2013   G4double z = pos.getZ() + (2.*G4QuickRand() << 
2014   return G4ThreeVector(x, y, z);              << 
2015 }                                             << 
2016                                               << 
2017 G4ThreeVector                                 << 
2018 G4VSceneHandler::GetPointInTet(const std::vec << 
2019 {                                             << 
2020   G4double p = G4QuickRand();                 << 
2021   G4double q = G4QuickRand();                 << 
2022   G4double r = G4QuickRand();                 << 
2023   if (p + q > 1.)                             << 
2024   {                                           << 
2025     p = 1. - p;                               << 
2026     q = 1. - q;                               << 
2027   }                                           << 
2028   if (q + r > 1.)                             << 
2029   {                                           << 
2030     G4double tmp = r;                         << 
2031     r = 1. - p - q;                           << 
2032     q = 1. - tmp;                             << 
2033   }                                           << 
2034   else if (p + q + r > 1.)                    << 
2035   {                                           << 
2036     G4double tmp = r;                         << 
2037     r = p + q + r - 1.;                       << 
2038     p = 1. - q - tmp;                         << 
2039   }                                           << 
2040   G4double a = 1. - p - q - r;                << 
2041   return vertices[0]*a + vertices[1]*p + vert << 
2042 }                                                800 }
2043                                                  801