Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/volumes/src/G4GeometryWorkspace.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 /geometry/volumes/src/G4GeometryWorkspace.cc (Version 11.3.0) and /geometry/volumes/src/G4GeometryWorkspace.cc (Version 10.0.p4)


  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 //
                                                   >>  26 //
                                                   >>  27 // $Id: G4GeometryWorkspace.cc 81646 2014-06-04 09:28:37Z gcosmo $
                                                   >>  28 //
 25 //                                                 29 // 
 26 // G4GeometryWorkspace - implementation        <<  30 // Class G4GeometryWorkspace - implementation
 27 //                                                 31 //
 28 // Authors: John Apostolakis (CERN), Andrea Do <<  32 // ----------------------------------------------------------------------
 29 // ------------------------------------------- << 
 30                                                    33 
 31 #include "G4GeometryWorkspace.hh"                  34 #include "G4GeometryWorkspace.hh"
                                                   >>  35 
                                                   >>  36 #include "G4PVReplica.hh"
                                                   >>  37 #include "G4PVParameterised.hh"
                                                   >>  38 #include "G4VPVParameterisation.hh"
 32 #include "G4PhysicalVolumeStore.hh"                39 #include "G4PhysicalVolumeStore.hh"
                                                   >>  40 #include "G4VSolid.hh"
                                                   >>  41 
                                                   >>  42 #include "G4LogicalVolume.hh"
                                                   >>  43 #include "G4VPhysicalVolume.hh"
                                                   >>  44 #include "G4PVReplica.hh"
                                                   >>  45 #include "G4Region.hh"
                                                   >>  46 
 33 #include "G4AutoLock.hh"                           47 #include "G4AutoLock.hh"
 34                                                    48 
 35 namespace                                          49 namespace
 36 {                                                  50 {
 37   G4Mutex mutex_init = G4MUTEX_INITIALIZER;    <<  51   G4Mutex solidclone = G4MUTEX_INITIALIZER;
 38   G4GeometryWorkspace::pool_type thePool;      << 
 39 }                                              << 
 40                                                << 
 41 // ------------------------------------------- << 
 42 //                                             << 
 43 G4GeometryWorkspace::pool_type* G4GeometryWork << 
 44 {                                              << 
 45   return &thePool;                             << 
 46 }                                                  52 }
 47                                                    53 
 48 // -------------------------------------------     54 // ----------------------------------------------------------------------
 49 //                                                 55 //
 50 G4GeometryWorkspace::G4GeometryWorkspace()         56 G4GeometryWorkspace::G4GeometryWorkspace()
                                                   >>  57   : fVerbose(false)
 51 {                                                  58 {
 52   fpLogicalVolumeSIM=                              59   fpLogicalVolumeSIM=
 53       &const_cast<G4LVManager&>(G4LogicalVolum     60       &const_cast<G4LVManager&>(G4LogicalVolume::GetSubInstanceManager());
 54   fpPhysicalVolumeSIM=                             61   fpPhysicalVolumeSIM=
 55       &const_cast<G4PVManager&>( G4VPhysicalVo     62       &const_cast<G4PVManager&>( G4VPhysicalVolume::GetSubInstanceManager() );
 56   fpReplicaSIM=                                    63   fpReplicaSIM=
 57       &const_cast<G4PVRManager&>(G4PVReplica::     64       &const_cast<G4PVRManager&>(G4PVReplica::GetSubInstanceManager());
 58   fpRegionSIM=                                     65   fpRegionSIM=
 59       &const_cast<G4RegionManager&>(G4Region::     66       &const_cast<G4RegionManager&>(G4Region::GetSubInstanceManager());
 60                                                    67 
 61   // Create a work area for Logical Volumes in     68   // Create a work area for Logical Volumes in this thread
 62   // then capture its address                      69   // then capture its address
 63   //                                           << 
 64   InitialiseWorkspace();                           70   InitialiseWorkspace();
 65                                                    71   
 66   fLogicalVolumeOffset = fpLogicalVolumeSIM->G <<  72   fLogicalVolumeOffset= fpLogicalVolumeSIM->GetOffset();
 67                                                    73 
 68   fPhysicalVolumeOffset = fpPhysicalVolumeSIM- <<  74   fPhysicalVolumeOffset= fpPhysicalVolumeSIM->GetOffset();
 69                                                    75 
 70   fReplicaOffset = fpReplicaSIM->GetOffset();  <<  76   fReplicaOffset= fpReplicaSIM->GetOffset();
 71                                                    77 
 72   fRegionOffset = fpRegionSIM->GetOffset();    <<  78   fRegionOffset= fpRegionSIM->GetOffset();
                                                   >>  79 }
                                                   >>  80 
                                                   >>  81 // ----------------------------------------------------------------------
                                                   >>  82 //
                                                   >>  83 G4GeometryWorkspace::~G4GeometryWorkspace()
                                                   >>  84 {  
 73 }                                                  85 }
 74                                                    86 
 75 // -------------------------------------------     87 // ----------------------------------------------------------------------
 76 //                                                 88 //
 77 void                                               89 void
 78 G4GeometryWorkspace::UseWorkspace()                90 G4GeometryWorkspace::UseWorkspace()
 79 {                                                  91 {
                                                   >>  92   if( fVerbose ) 
                                                   >>  93   { 
                                                   >>  94     G4cout << "G4GeometryWorkspace::UseWorkspace: Start " << G4endl;
                                                   >>  95   }
                                                   >>  96 
                                                   >>  97   // Implementation originally in:
                                                   >>  98   //   G4WorkerThread::BuildGeometryAndPhysicsVector()
                                                   >>  99   // and improved for G4PVParamaterised
                                                   >> 100   
 80   // Geometry related, split classes mechanism    101   // Geometry related, split classes mechanism: instantiate sub-instance
 81   // for this thread                              102   // for this thread
 82   //                                           << 
 83   fpLogicalVolumeSIM->UseWorkArea(fLogicalVolu    103   fpLogicalVolumeSIM->UseWorkArea(fLogicalVolumeOffset);
 84   fpPhysicalVolumeSIM->UseWorkArea(fPhysicalVo    104   fpPhysicalVolumeSIM->UseWorkArea(fPhysicalVolumeOffset);
 85                                                   105   
 86   fpReplicaSIM->UseWorkArea(fReplicaOffset);      106   fpReplicaSIM->UseWorkArea(fReplicaOffset);
 87   fpRegionSIM->UseWorkArea(fRegionOffset);        107   fpRegionSIM->UseWorkArea(fRegionOffset);
 88                                                   108 
 89   // When recycling a workspace                   109   // When recycling a workspace 
 90   //   - it must be a lightweight operation, t    110   //   - it must be a lightweight operation, to reuse a valid work area
 91   //   - so it must NOT Initialise anything!      111   //   - so it must NOT Initialise anything!
 92   // Do not call InitialisePhysicalVolumes();     112   // Do not call InitialisePhysicalVolumes();
                                                   >> 113 
                                                   >> 114   if( fVerbose )
                                                   >> 115   { 
                                                   >> 116      G4cout << "G4GeometryWorkspace::UseWorkspace:  End " << G4endl;
                                                   >> 117   }
 93 }                                                 118 }
 94                                                   119 
 95 // -------------------------------------------    120 // ----------------------------------------------------------------------
 96 //                                                121 //
 97 void G4GeometryWorkspace::ReleaseWorkspace()      122 void G4GeometryWorkspace::ReleaseWorkspace()
 98 {                                                 123 {
 99   fpLogicalVolumeSIM->UseWorkArea(nullptr);    << 124   fpLogicalVolumeSIM->UseWorkArea(0);
100   fpPhysicalVolumeSIM->UseWorkArea(nullptr);   << 125   fpPhysicalVolumeSIM->UseWorkArea(0);
101                                                   126   
102   fpReplicaSIM->UseWorkArea(nullptr);          << 127   fpReplicaSIM->UseWorkArea(0);
103   fpRegionSIM->UseWorkArea(nullptr);           << 128   fpRegionSIM->UseWorkArea(0);
104 }                                                 129 }
105                                                   130 
106 // -------------------------------------------    131 // ----------------------------------------------------------------------
107 //                                                132 //
108 void G4GeometryWorkspace::InitialisePhysicalVo    133 void G4GeometryWorkspace::InitialisePhysicalVolumes()
109 {                                                 134 {
110   G4PhysicalVolumeStore* physVolStore = G4Phys    135   G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
111   for (auto physVol : *physVolStore)           << 136   for (size_t ip=0; ip<physVolStore->size(); ip++)
112   {                                               137   {
                                                   >> 138     G4VPhysicalVolume* physVol = (*physVolStore)[ip];
113     G4LogicalVolume *logicalVol = physVol->Get    139     G4LogicalVolume *logicalVol = physVol->GetLogicalVolume();
114                                                   140  
115     // Use shadow pointer                         141     // Use shadow pointer
116     //                                            142     //
117     G4VSolid* solid = logicalVol->GetMasterSol << 143     G4VSolid *solid = logicalVol->GetMasterSolid();
118     auto g4PVReplica = dynamic_cast<G4PVReplic << 144     G4PVReplica *g4PVReplica = 0;
119     if (g4PVReplica == nullptr)                << 145     g4PVReplica = dynamic_cast<G4PVReplica*>(physVol);
                                                   >> 146     if (!g4PVReplica)
120     {                                             147     {
121       // Placement volume                         148       // Placement volume
122       //                                       << 149       logicalVol->InitialiseWorker(logicalVol,solid,0);
123       logicalVol->InitialiseWorker(logicalVol, << 
124     }                                             150     }
125     else                                          151     else
126     {                                             152     {          
127       g4PVReplica->InitialiseWorker(g4PVReplic    153       g4PVReplica->InitialiseWorker(g4PVReplica);
128       logicalVol->InitialiseWorker(logicalVol, << 154       if( ! g4PVReplica->IsParameterised() )
129                                                << 155       {
130       // If the replica's solid (in LV) is cha << 156         logicalVol->InitialiseWorker(logicalVol,solid,0);
131       // it must be thread-private             << 157 
132       //                                       << 158         // If the replica's solid (in LV) is changed during navigation,
133       CloneReplicaSolid( g4PVReplica );        << 159         // it must be thread-private
                                                   >> 160         //
                                                   >> 161         CloneReplicaSolid( g4PVReplica );
                                                   >> 162       }
                                                   >> 163       else
                                                   >> 164       {
                                                   >> 165         G4PVParameterised *paramVol = dynamic_cast<G4PVParameterised*>(physVol);
                                                   >> 166         if (!paramVol)
                                                   >> 167         {
                                                   >> 168           G4Exception("G4GeometryWorkspace::CreateAndUseWorkspace()",
                                                   >> 169                       "GeomVol0003", FatalException,
                                                   >> 170                       "Cannot find Parameterisation for parameterised volume.");
                                                   >> 171         }
                                                   >> 172         CloneParameterisedSolids( paramVol );
                                                   >> 173       }
134     }                                             174     }
135   }                                               175   }
                                                   >> 176   if( fVerbose )
                                                   >> 177   {
                                                   >> 178     G4cout << "G4GeometryWorkspace::InitialisePhysicalVolumes: "
                                                   >> 179            << "Copying geometry - Done!" << G4endl;
                                                   >> 180   }
136 }                                                 181 }
137                                                   182 
138 // -------------------------------------------    183 // ----------------------------------------------------------------------
139 // Create a clone of the solid for this replic    184 // Create a clone of the solid for this replica in this thread
140 //                                                185 //
141 G4bool G4GeometryWorkspace::CloneReplicaSolid( << 186 G4bool G4GeometryWorkspace::CloneReplicaSolid( G4PVReplica *replicaPV )
142 {                                                 187 {
143   G4LogicalVolume* logicalV = replicaPV->GetLo << 188   // The solid Ptr is in the Logical Volume
144   G4VSolid* solid = logicalV->GetSolid();      << 189   //
                                                   >> 190   G4LogicalVolume *logicalV= replicaPV ->GetLogicalVolume();
                                                   >> 191   G4VSolid *solid= logicalV->GetSolid();
145                                                   192 
146   G4AutoLock aLock(&mutex_init);               << 193   G4AutoLock aLock(&solidclone);
147   G4VSolid* workerSolid = solid->Clone();      << 194   G4VSolid *workerSolid = solid->Clone();
148   aLock.unlock();                                 195   aLock.unlock();
149                                                   196 
150   if( workerSolid != nullptr )                 << 197   if( workerSolid )
151   {                                               198   {
152     logicalV->InitialiseWorker(logicalV,worker << 199     logicalV->InitialiseWorker(logicalV,workerSolid,0);
153   }                                               200   }
154   else                                            201   else
155   {                                               202   {
156     // In the case that not all solids support    203     // In the case that not all solids support(ed) the Clone()
157     // method, we do similar thing here to dyn    204     // method, we do similar thing here to dynamically cast
158     // and then get the clone method           << 205     // and then get the clone method.
159     //                                            206     //
160     G4ExceptionDescription ed;                    207     G4ExceptionDescription ed;
161     ed << "ERROR - Unable to initialise geomet    208     ed << "ERROR - Unable to initialise geometry for worker node." << "\n"
162        << "A solid lacks the Clone() method -     209        << "A solid lacks the Clone() method - or Clone() failed." << "\n"
163        << "   Type of solid: " << solid->GetEn    210        << "   Type of solid: " << solid->GetEntityType() << "\n"
164        << "   Parameters: " << *solid;            211        << "   Parameters: " << *solid;
165     G4Exception("G4GeometryWorkspace::CloneRep << 212     G4Exception("G4GeometryWorkspace::CloneParameterisedVolume()",
166                 "GeomVol0003", FatalException,    213                 "GeomVol0003", FatalException, ed);
167     return false;                                 214     return false; 
168   }                                               215   }
169   return true; // It Worked                       216   return true; // It Worked
170 }                                                 217 }
171                                                   218 
172 // -------------------------------------------    219 // ----------------------------------------------------------------------
                                                   >> 220 // Each G4PVParameterised instance, has associated with it at least one
                                                   >> 221 // solid for each worker thread.
                                                   >> 222 // *Simple* Parameterisations have a single type of solid, and the
                                                   >> 223 // pointer points to the same instance of a solid during the  simulation.
                                                   >> 224 // For this case, it is possible to adapt automatically to
                                                   >> 225 // multi-threading, simply by cloning the solid - so long
                                                   >> 226 // as all solids support the Clone() method.
                                                   >> 227 //
                                                   >> 228 G4bool G4GeometryWorkspace::
                                                   >> 229 CloneParameterisedSolids( G4PVParameterised *paramVol )
                                                   >> 230 {
                                                   >> 231   // Check whether it is a simple parameterisation or not
                                                   >> 232   //
                                                   >> 233   G4VPVParameterisation *param= paramVol->GetParameterisation();
                                                   >> 234   unsigned int numCopies= paramVol->GetMultiplicity();
                                                   >> 235   unsigned int numDifferent= 0;
                                                   >> 236 
                                                   >> 237   G4LogicalVolume *logicalV= paramVol->GetLogicalVolume();
                                                   >> 238   G4VSolid *solid= logicalV->GetSolid();
                                                   >> 239   
                                                   >> 240   for( unsigned int i=0; i< numCopies; i++)
                                                   >> 241   {
                                                   >> 242     G4VSolid *solidChk= param->ComputeSolid(i, paramVol);
                                                   >> 243     if( solidChk != solid)
                                                   >> 244     {
                                                   >> 245       numDifferent++;
                                                   >> 246     }
                                                   >> 247   }
                                                   >> 248   if( numDifferent>0 )
                                                   >> 249   {
                                                   >> 250     G4ExceptionDescription ed;
                                                   >> 251     ed << "ERROR - Parameterisation using several instances of Solids \n"
                                                   >> 252        << "potentially to support different types of solids. \n"
                                                   >> 253        << "Geant4-MT currently does not support this type of \n"
                                                   >> 254        << "parameterisation, sorry !";
                                                   >> 255     G4Exception("G4GeometryWorkspace::CloneParameterisedVolume()",
                                                   >> 256                 "GeomVol0001", FatalException, ed);
                                                   >> 257   }
                                                   >> 258   
                                                   >> 259   // Threads may attempt to clone a solids simultaneously.
                                                   >> 260   // Those cloned solids will be registered into a shared solid
                                                   >> 261   // store (C++ container). Need a lock to guarantee thread safety
                                                   >> 262   //
                                                   >> 263   G4AutoLock aLock(&solidclone);
                                                   >> 264   G4VSolid *workerSolid = solid->Clone();
                                                   >> 265   aLock.unlock();
                                                   >> 266   if( workerSolid )
                                                   >> 267   {
                                                   >> 268     logicalV->InitialiseWorker(logicalV,workerSolid,0);
                                                   >> 269   }
                                                   >> 270   else
                                                   >> 271   {
                                                   >> 272     // In the case that not all solids support(ed) the Clone()
                                                   >> 273     // method, we do similar thing here to dynamically cast
                                                   >> 274     // and then get the clone method
                                                   >> 275     //
                                                   >> 276     G4ExceptionDescription ed;
                                                   >> 277     ed << "ERROR - Unable to initialise geometry for worker node. \n"
                                                   >> 278        << "A solid lacks the Clone() method - or Clone() failed. \n"
                                                   >> 279        << "   Type of solid: " << solid->GetEntityType() << "\n"
                                                   >> 280        << "   Parameters: " << *solid;
                                                   >> 281     G4Exception("G4GeometryWorkspace::CloneParameterisedVolume()",
                                                   >> 282                 "GeomVol0003", FatalException, ed);
                                                   >> 283   }
                                                   >> 284   return true; // It Worked
                                                   >> 285 }
                                                   >> 286 
                                                   >> 287 // ----------------------------------------------------------------------
173 //                                                288 //
174 void G4GeometryWorkspace::InitialiseWorkspace(    289 void G4GeometryWorkspace::InitialiseWorkspace()
175 {                                                 290 {
                                                   >> 291   if( fVerbose )
                                                   >> 292   {
                                                   >> 293     G4cout << "G4GeometryWorkspace::InitialiseWorkspace():"
                                                   >> 294            << " Copying geometry - Start " << G4endl;
                                                   >> 295   }
                                                   >> 296   
                                                   >> 297   // Implementation originally in:
                                                   >> 298   //   G4WorkerThread::BuildGeometryAndPhysicsVector()
                                                   >> 299   // and improved for G4PVParamaterised
                                                   >> 300   
176   // Geometry related, split classes mechanism    301   // Geometry related, split classes mechanism:
177   // Do *NOT* instantiate sub-instance for thi    302   // Do *NOT* instantiate sub-instance for this thread, just copy the contents!
178   //                                              303   //
179   fpLogicalVolumeSIM->SlaveCopySubInstanceArra    304   fpLogicalVolumeSIM->SlaveCopySubInstanceArray();
180   fpPhysicalVolumeSIM->SlaveCopySubInstanceArr    305   fpPhysicalVolumeSIM->SlaveCopySubInstanceArray();
181   fpReplicaSIM->SlaveCopySubInstanceArray();      306   fpReplicaSIM->SlaveCopySubInstanceArray();
182   fpRegionSIM->SlaveInitializeSubInstance();      307   fpRegionSIM->SlaveInitializeSubInstance();
183                                                   308 
184   InitialisePhysicalVolumes();                    309   InitialisePhysicalVolumes();
                                                   >> 310   
                                                   >> 311   if( fVerbose )
                                                   >> 312   {
                                                   >> 313     G4cout << "G4GeometryWorkspace::InitialiseWorkspace: "
                                                   >> 314            << "Copying geometry - Done!" << G4endl;
                                                   >> 315   }
185 }                                                 316 }
186                                                   317 
187 // -------------------------------------------    318 // ----------------------------------------------------------------------
188 //                                                319 //
189 void G4GeometryWorkspace::DestroyWorkspace()      320 void G4GeometryWorkspace::DestroyWorkspace()
190 {                                                 321 {
191   G4PhysicalVolumeStore* physVolStore = G4Phys    322   G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
192   for (auto physVol : *physVolStore)           << 323   for (size_t ip=0; ip<physVolStore->size(); ip++)
193   {                                               324   {
194     G4LogicalVolume* logicalVol = physVol->Get << 325     G4VPhysicalVolume* physVol = (*physVolStore)[ip];
195     auto g4PVReplica = dynamic_cast<G4PVReplic << 326     G4LogicalVolume *logicalVol = physVol->GetLogicalVolume();
196     if (g4PVReplica != nullptr)                << 327     G4PVReplica *g4PVReplica = 0;
                                                   >> 328     g4PVReplica =  dynamic_cast<G4PVReplica*>(physVol);
                                                   >> 329     if (g4PVReplica)
197     {                                             330     {
198       g4PVReplica->TerminateWorker(g4PVReplica    331       g4PVReplica->TerminateWorker(g4PVReplica);
                                                   >> 332       G4PVParameterised *paramVol = 0;
                                                   >> 333       paramVol =  dynamic_cast<G4PVParameterised*>(physVol);
                                                   >> 334       if (paramVol)
                                                   >> 335       {
                                                   >> 336         // G4VSolid *solid = logicalVol->fSolid;
                                                   >> 337         logicalVol->TerminateWorker(logicalVol);
                                                   >> 338         // if( solid->IsClone() ) delete solid;
                                                   >> 339       }
                                                   >> 340       else
                                                   >> 341       {
                                                   >> 342         logicalVol->TerminateWorker(logicalVol);
                                                   >> 343       }
                                                   >> 344     }
                                                   >> 345     else
                                                   >> 346     {
                                                   >> 347       logicalVol->TerminateWorker(logicalVol);
199     }                                             348     }
200     logicalVol->TerminateWorker(logicalVol);   << 
201   }                                               349   }
202                                                << 
203   // Threads may attempt to free memory simult << 
204   // Need a lock to guarantee thread safety    << 
205   //                                           << 
206   G4AutoLock aLock(&mutex_init);               << 
207   fpLogicalVolumeSIM->FreeSlave();                350   fpLogicalVolumeSIM->FreeSlave();
208   fpPhysicalVolumeSIM->FreeSlave();               351   fpPhysicalVolumeSIM->FreeSlave();
209   fpReplicaSIM->FreeSlave();                      352   fpReplicaSIM->FreeSlave();
210   fpRegionSIM->FreeSlave();                       353   fpRegionSIM->FreeSlave();
211   aLock.unlock();                              << 
212 }                                                 354 }
213                                                   355