Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/management/src/G4LogicalVolume.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/management/src/G4LogicalVolume.cc (Version 11.3.0) and /geometry/management/src/G4LogicalVolume.cc (Version 9.0.p2)


  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: G4LogicalVolume.cc,v 1.32 2006/11/30 10:39:28 gcosmo Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-08-03-patch-01 $
                                                   >>  29 //
 25 //                                                 30 // 
 26 // class G4LogicalVolume implementation        <<  31 // class G4LogicalVolume Implementation
 27 //                                                 32 //
 28 // 15.01.13 G.Cosmo, A.Dotti: Modified for thr <<  33 // History:
 29 // 01.03.05 G.Santin: Added flag for optional      34 // 01.03.05 G.Santin: Added flag for optional propagation of GetMass()
 30 // 17.05.02 G.Cosmo: Added flag for optional o     35 // 17.05.02 G.Cosmo: Added flag for optional optimisation
 31 // 12.02.99 S.Giani: Default initialization of     36 // 12.02.99 S.Giani: Default initialization of voxelization quality
 32 // 04.08.97 P.M.DeFreitas: Added methods for p     37 // 04.08.97 P.M.DeFreitas: Added methods for parameterised simulation 
                                                   >>  38 // 19.08.96 P.Kent: Modified for G4VSensitive Detector
 33 // 11.07.95 P.Kent: Initial version                39 // 11.07.95 P.Kent: Initial version
 34 // -------------------------------------------     40 // --------------------------------------------------------------------
 35                                                    41 
 36 #include "G4LogicalVolume.hh"                      42 #include "G4LogicalVolume.hh"
 37 #include "G4LogicalVolumeStore.hh"                 43 #include "G4LogicalVolumeStore.hh"
 38 #include "G4VSolid.hh"                             44 #include "G4VSolid.hh"
 39 #include "G4Material.hh"                           45 #include "G4Material.hh"
 40 #include "G4VPVParameterisation.hh"                46 #include "G4VPVParameterisation.hh"
 41 #include "G4VisAttributes.hh"                      47 #include "G4VisAttributes.hh"
 42                                                    48 
 43 #include "G4UnitsTable.hh"                         49 #include "G4UnitsTable.hh"
 44                                                    50 
 45 G4LVData::G4LVData() {;}                       << 
 46                                                << 
 47 // This new field helps to use the class G4LVM << 
 48 //                                             << 
 49 G4LVManager G4LogicalVolume::subInstanceManage << 
 50                                                << 
 51 // These macros change the references to field << 
 52 // in the class G4LVData.                      << 
 53 //                                             << 
 54 #define G4MT_solid     ((subInstanceManager.of << 
 55 #define G4MT_sdetector ((subInstanceManager.of << 
 56 #define G4MT_fmanager  ((subInstanceManager.of << 
 57 #define G4MT_material  ((subInstanceManager.of << 
 58 #define G4MT_mass      ((subInstanceManager.of << 
 59 #define G4MT_ccouple   ((subInstanceManager.of << 
 60 #define G4MT_instance  (subInstanceManager.off << 
 61                                                << 
 62 // *******************************************     51 // ********************************************************************
 63 // Constructor - sets member data and adds to      52 // Constructor - sets member data and adds to logical Store,
 64 //               voxel pointer for optimisatio     53 //               voxel pointer for optimisation set to 0 by default.
 65 //               Initialises daughter vector t     54 //               Initialises daughter vector to 0 length.
 66 // *******************************************     55 // ********************************************************************
 67 //                                                 56 //
 68 G4LogicalVolume::G4LogicalVolume( G4VSolid* pS     57 G4LogicalVolume::G4LogicalVolume( G4VSolid* pSolid,
 69                                   G4Material*      58                                   G4Material* pMaterial,
 70                             const G4String& na     59                             const G4String& name,
 71                                   G4FieldManag     60                                   G4FieldManager* pFieldMgr,
 72                                   G4VSensitive     61                                   G4VSensitiveDetector* pSDetector,
 73                                   G4UserLimits     62                                   G4UserLimits* pULimits,
 74                                   G4bool optim     63                                   G4bool optimise )
 75  : fDaughters(0,(G4VPhysicalVolume*)nullptr),  <<  64  : fDaughters(0,(G4VPhysicalVolume*)0), fFieldManager(pFieldMgr),
 76    fOptimise(optimise)                         <<  65    fVoxel(0), fOptimise(optimise), fRootRegion(false), fSmartless(2.),
                                                   >>  66    fMass(0.), fVisAttributes(0), fRegion(0), fCutsCouple(0)
 77 {                                                  67 {
 78   // Initialize 'Shadow'/master pointers - for << 
 79   //                                           << 
 80   fSolid = pSolid;                             << 
 81   fSensitiveDetector = pSDetector;             << 
 82   fFieldManager = pFieldMgr;                   << 
 83                                                << 
 84   instanceID = subInstanceManager.CreateSubIns << 
 85   AssignFieldManager(pFieldMgr);               << 
 86                                                << 
 87   G4MT_mass = 0.;                              << 
 88   G4MT_ccouple = nullptr;                      << 
 89                                                << 
 90   SetSolid(pSolid);                                68   SetSolid(pSolid);
 91   SetMaterial(pMaterial);                          69   SetMaterial(pMaterial);
 92   SetName(name);                                   70   SetName(name);
 93   SetSensitiveDetector(pSDetector);                71   SetSensitiveDetector(pSDetector);
 94   SetUserLimits(pULimits);                         72   SetUserLimits(pULimits);    
 95                                                << 
 96   // Initialize 'Shadow' data structure - for  << 
 97   //                                           << 
 98   lvdata = new G4LVData();                     << 
 99   lvdata->fSolid = pSolid;                     << 
100   lvdata->fMaterial = pMaterial;               << 
101                                                << 
102   //                                               73   //
103   // Add to store                                  74   // Add to store
104   //                                               75   //
105   G4LogicalVolumeStore::Register(this);            76   G4LogicalVolumeStore::Register(this);
106 }                                                  77 }
107                                                    78 
108 // *******************************************     79 // ********************************************************************
109 // Fake default constructor - sets only member     80 // Fake default constructor - sets only member data and allocates memory
110 //                            for usage restri     81 //                            for usage restricted to object persistency.
111 // *******************************************     82 // ********************************************************************
112 //                                                 83 //
113 G4LogicalVolume::G4LogicalVolume( __void__& )      84 G4LogicalVolume::G4LogicalVolume( __void__& )
114  : fDaughters(0,(G4VPhysicalVolume*)nullptr),  <<  85  : fDaughters(0,(G4VPhysicalVolume*)0), fFieldManager(0),
                                                   >>  86    fMaterial(0), fName(""), fSensitiveDetector(0), fSolid(0), fUserLimits(0),
                                                   >>  87    fVoxel(0), fOptimise(true), fRootRegion(false), fSmartless(2.),
                                                   >>  88    fMass(0.), fVisAttributes(0), fRegion(0), fCutsCouple(0), fBiasWeight(0.)
115 {                                                  89 {
116   instanceID = subInstanceManager.CreateSubIns << 
117                                                << 
118   SetSensitiveDetector(nullptr);    // G4MT_sd << 
119   SetFieldManager(nullptr, false);  // G4MT_fm << 
120                                                << 
121   G4MT_mass = 0.;                              << 
122   G4MT_ccouple = nullptr;                      << 
123                                                << 
124   // Add to store                                  90   // Add to store
125   //                                               91   //
126   G4LogicalVolumeStore::Register(this);            92   G4LogicalVolumeStore::Register(this);
127 }                                                  93 }
128                                                    94 
129 // *******************************************     95 // ********************************************************************
130 // Destructor - Removes itself from solid Stor     96 // Destructor - Removes itself from solid Store
131 // NOTE: Not virtual                               97 // NOTE: Not virtual
132 // *******************************************     98 // ********************************************************************
133 //                                                 99 //
134 G4LogicalVolume::~G4LogicalVolume()               100 G4LogicalVolume::~G4LogicalVolume()
135 {                                                 101 {
136   if (!fLock && fRootRegion)  // De-register r << 102   // Avoid de-registration of root region if treating the first world volume
137   {                           // and flagged a << 
138     fRegion->RemoveRootLogicalVolume(this, tru << 
139   }                                            << 
140   delete lvdata;                               << 
141   G4LogicalVolumeStore::DeRegister(this);      << 
142 }                                              << 
143                                                << 
144 // ******************************************* << 
145 // SetName - Set volume name and notify store  << 
146 // ******************************************* << 
147 //                                             << 
148 void G4LogicalVolume::SetName(const G4String&  << 
149 {                                              << 
150   fName = pName;                               << 
151   G4LogicalVolumeStore::GetInstance()->SetMapV << 
152 }                                              << 
153                                                << 
154 // ******************************************* << 
155 // InitialiseWorker                            << 
156 //                                             << 
157 // This method is similar to the constructor.  << 
158 // thread to achieve the same effect as that o << 
159 // to register the new created instance. This  << 
160 // It does not create a new G4LogicalVolume in << 
161 // for the fields encapsulated by the class G4 << 
162 // ******************************************* << 
163 //                                             << 
164 void G4LogicalVolume::                         << 
165 InitialiseWorker( G4LogicalVolume* /*pMasterOb << 
166                   G4VSolid* pSolid,            << 
167                   G4VSensitiveDetector* pSDete << 
168 {                                              << 
169   subInstanceManager.SlaveCopySubInstanceArray << 
170                                                << 
171   SetSolid(pSolid);                            << 
172   SetSensitiveDetector(pSDetector); //  How th << 
173   AssignFieldManager(fFieldManager);           << 
174    // Should be set - but a per-thread copy is << 
175    // Must not call SetFieldManager(), which p << 
176                                                << 
177 #ifdef CLONE_FIELD_MGR                         << 
178   // Create a field FieldManager by cloning    << 
179   //                                              103   //
180   G4FieldManager workerFldMgr = fFieldManager- << 104   if( (fRootRegion) && (this != (*G4LogicalVolumeStore::GetInstance())[0]) )
181   if( created || (GetFieldManager() != workerF << 105     { fRegion->RemoveRootLogicalVolume(this); }
182   {                                            << 
183     SetFieldManager(fFieldManager, false); //  << 
184   }                                            << 
185   else                                         << 
186   {                                            << 
187     // Field manager existed and is equal to c << 
188     //                                         << 
189     AssignFieldManager(workerFldMgr);          << 
190   }                                            << 
191 #endif                                         << 
192 }                                              << 
193                                                   106 
194 // ******************************************* << 107   G4LogicalVolumeStore::DeRegister(this);
195 // Clean                                       << 
196 // ******************************************* << 
197 //                                             << 
198 void G4LogicalVolume::Clean()                  << 
199 {                                              << 
200   subInstanceManager.FreeSlave();              << 
201 }                                              << 
202                                                << 
203 // ******************************************* << 
204 // TerminateWorker                             << 
205 //                                             << 
206 // This method is similar to the destructor. I << 
207 // thread to achieve the partial effect as tha << 
208 // For G4LogicalVolume instances, nothing more << 
209 // ******************************************* << 
210 //                                             << 
211 void G4LogicalVolume::                         << 
212 TerminateWorker( G4LogicalVolume* /*pMasterObj << 
213 {                                              << 
214 }                                              << 
215                                                << 
216 // ******************************************* << 
217 // GetSubInstanceManager                       << 
218 //                                             << 
219 // Returns the private data instance manager.  << 
220 // ******************************************* << 
221 //                                             << 
222 const G4LVManager& G4LogicalVolume::GetSubInst << 
223 {                                              << 
224   return subInstanceManager;                   << 
225 }                                              << 
226                                                << 
227 // ******************************************* << 
228 // GetFieldManager                             << 
229 // ******************************************* << 
230 //                                             << 
231 G4FieldManager* G4LogicalVolume::GetFieldManag << 
232 {                                              << 
233   return G4MT_fmanager;                        << 
234 }                                              << 
235                                                << 
236 // ******************************************* << 
237 // AssignFieldManager                          << 
238 // ******************************************* << 
239 //                                             << 
240 void G4LogicalVolume::AssignFieldManager( G4Fi << 
241 {                                              << 
242   G4MT_fmanager= fldMgr;                       << 
243   if(G4Threading::IsMasterThread())  { fFieldM << 
244 }                                              << 
245                                                << 
246 // ******************************************* << 
247 // IsExtended                                  << 
248 // ******************************************* << 
249 //                                             << 
250 G4bool G4LogicalVolume::IsExtended() const     << 
251 {                                              << 
252   return false;                                << 
253 }                                                 108 }
254                                                   109 
255 // *******************************************    110 // ********************************************************************
256 // SetFieldManager                                111 // SetFieldManager
257 // *******************************************    112 // ********************************************************************
258 //                                                113 //
259 void                                              114 void
260 G4LogicalVolume::SetFieldManager(G4FieldManage    115 G4LogicalVolume::SetFieldManager(G4FieldManager* pNewFieldMgr,
261                                  G4bool           116                                  G4bool          forceAllDaughters) 
262 {                                                 117 {
263   AssignFieldManager(pNewFieldMgr);            << 118   fFieldManager = pNewFieldMgr;
264                                                   119 
265   auto NoDaughters = GetNoDaughters();         << 120   G4int NoDaughters = GetNoDaughters();
266   while ( (NoDaughters--)>0 )                     121   while ( (NoDaughters--)>0 )
267   {                                               122   {
268     G4LogicalVolume* DaughterLogVol;              123     G4LogicalVolume* DaughterLogVol; 
269     DaughterLogVol = GetDaughter(NoDaughters)-    124     DaughterLogVol = GetDaughter(NoDaughters)->GetLogicalVolume();
270     if ( forceAllDaughters || (DaughterLogVol- << 125     if ( forceAllDaughters || (DaughterLogVol->GetFieldManager() == 0) )
271     {                                             126     {
272       DaughterLogVol->SetFieldManager(pNewFiel    127       DaughterLogVol->SetFieldManager(pNewFieldMgr, forceAllDaughters);
273     }                                             128     }
274   }                                               129   }
275 }                                                 130 }
276                                                   131 
277 // ******************************************* << 
278 // AddDaughter                                 << 
279 // ******************************************* << 
280 //                                             << 
281 void G4LogicalVolume::AddDaughter(G4VPhysicalV << 
282 {                                              << 
283   EVolume daughterType = pNewDaughter->VolumeT << 
284                                                << 
285   // The type of the navigation needed is dete << 
286   //                                           << 
287   if( fDaughters.empty() )                     << 
288   {                                            << 
289     fDaughtersVolumeType = daughterType;       << 
290   }                                            << 
291   else                                         << 
292   {                                            << 
293     // Check consistency of detector descripti << 
294                                                << 
295     // 1. A replica or parameterised volume ca << 
296     //                                         << 
297     if( fDaughters[0]->IsReplicated() )        << 
298     {                                          << 
299       std::ostringstream message;              << 
300       message << "ERROR - Attempt to place a v << 
301         << G4endl                              << 
302         << "        already containing a repli << 
303         << "        A volume can either contai << 
304         << "        or a unique replica or par << 
305         << "           Mother logical volume:  << 
306         << "           Placing volume: " << pN << 
307         << G4endl;                             << 
308       G4Exception("G4LogicalVolume::AddDaughte << 
309                   FatalException, message,     << 
310                   "Replica or parameterised vo << 
311     }                                          << 
312     else                                       << 
313     {                                          << 
314       // 2. Ensure that Placement and External << 
315       //                                       << 
316       if(  daughterType != fDaughtersVolumeTyp << 
317       {                                        << 
318         std::ostringstream message;            << 
319         message << "ERROR - Attempt to place a << 
320           << G4endl                            << 
321           << "        already containing a dif << 
322           << "        A volume can either cont << 
323           << "        - one or more placements << 
324           << "        - one or more 'external' << 
325           << "          Mother logical volume: << 
326           << "          Volume being placed: " << 
327           << G4endl;                           << 
328         G4Exception("G4LogicalVolume::AddDaugh << 
329                     FatalException, message,   << 
330                     "Cannot mix placements and << 
331       }                                        << 
332     }                                          << 
333   }                                            << 
334                                                << 
335   // Invalidate previous calculation of mass - << 
336   //                                           << 
337   G4MT_mass = 0.;                              << 
338   fDaughters.push_back(pNewDaughter);          << 
339                                                << 
340   G4LogicalVolume* pDaughterLogical = pNewDaug << 
341                                                << 
342   // Propagate the Field Manager, if the daugh << 
343   //                                           << 
344   G4FieldManager* pDaughterFieldManager = pDau << 
345                                                << 
346   // Avoid propagating the fieldManager pointe << 
347   // and daughter's one is null as well...     << 
348   //                                           << 
349   if( (G4MT_fmanager != nullptr ) && (pDaughte << 
350   {                                            << 
351     pDaughterLogical->SetFieldManager(G4MT_fma << 
352   }                                            << 
353   if (fRegion != nullptr)                      << 
354   {                                            << 
355     PropagateRegion();                         << 
356     fRegion->RegionModified(true);             << 
357   }                                            << 
358 }                                              << 
359                                                << 
360 // ******************************************* << 
361 // RemoveDaughter                              << 
362 // ******************************************* << 
363 //                                             << 
364 void G4LogicalVolume::RemoveDaughter(const G4V << 
365 {                                              << 
366   for (auto i=fDaughters.cbegin(); i!=fDaughte << 
367   {                                            << 
368     if (**i==*p)                               << 
369     {                                          << 
370       fDaughters.erase(i);                     << 
371       break;                                   << 
372     }                                          << 
373   }                                            << 
374   if (fRegion != nullptr)                      << 
375   {                                            << 
376     fRegion->RegionModified(true);             << 
377   }                                            << 
378   G4MT_mass = 0.;                              << 
379 }                                              << 
380                                                << 
381 // ******************************************* << 
382 // ClearDaughters                              << 
383 // ******************************************* << 
384 //                                             << 
385 void G4LogicalVolume::ClearDaughters()         << 
386 {                                              << 
387   fDaughters.erase(fDaughters.cbegin(), fDaugh << 
388   if (fRegion != nullptr)                      << 
389   {                                            << 
390     fRegion->RegionModified(true);             << 
391   }                                            << 
392   G4MT_mass = 0.;                              << 
393 }                                              << 
394                                                << 
395 // ******************************************* << 
396 // ResetMass                                   << 
397 // ******************************************* << 
398 //                                             << 
399 void G4LogicalVolume::ResetMass()              << 
400 {                                              << 
401   G4MT_mass= 0.0;                              << 
402 }                                              << 
403                                                << 
404 // ******************************************* << 
405 // GetSolid                                    << 
406 // ******************************************* << 
407 //                                             << 
408 G4VSolid* G4LogicalVolume::GetSolid(G4LVData & << 
409 {                                              << 
410   return instLVdata.fSolid;                    << 
411 }                                              << 
412                                                << 
413 G4VSolid* G4LogicalVolume::GetSolid() const    << 
414 {                                              << 
415   return this->GetSolid( subInstanceManager.of << 
416 }                                              << 
417                                                << 
418 // ******************************************* << 
419 // SetSolid                                    << 
420 // ******************************************* << 
421 //                                             << 
422 void G4LogicalVolume::SetSolid(G4VSolid *pSoli << 
423 {                                              << 
424                                                << 
425   G4MT_solid = pSolid;                         << 
426   this->ResetMass();                           << 
427 }                                              << 
428                                                << 
429 void G4LogicalVolume::SetSolid(G4LVData& instL << 
430 {                                              << 
431   instLVdata.fSolid = pSolid;                  << 
432   instLVdata.fMass = 0.0;                      << 
433 }                                              << 
434                                                << 
435 // ******************************************* << 
436 // GetMaterial                                 << 
437 // ******************************************* << 
438 //                                             << 
439 G4Material* G4LogicalVolume::GetMaterial() con << 
440 {                                              << 
441   return G4MT_material;                        << 
442 }                                              << 
443                                                << 
444 // ******************************************* << 
445 // SetMaterial                                 << 
446 // ******************************************* << 
447 //                                             << 
448 void G4LogicalVolume::SetMaterial(G4Material*  << 
449 {                                              << 
450   G4MT_material = pMaterial;                   << 
451   G4MT_mass = 0.0;                             << 
452 }                                              << 
453                                                << 
454 // ******************************************* << 
455 // UpdateMaterial                              << 
456 // ******************************************* << 
457 //                                             << 
458 void G4LogicalVolume::UpdateMaterial(G4Materia << 
459 {                                              << 
460   G4MT_material=pMaterial;                     << 
461   if (fRegion != nullptr) { G4MT_ccouple = fRe << 
462   G4MT_mass = 0.0;                             << 
463 }                                              << 
464                                                << 
465 // ******************************************* << 
466 // GetSensitiveDetector                        << 
467 // ******************************************* << 
468 //                                             << 
469 G4VSensitiveDetector* G4LogicalVolume::GetSens << 
470 {                                              << 
471   return G4MT_sdetector;                       << 
472 }                                              << 
473                                                << 
474 // ******************************************* << 
475 // SetSensitiveDetector                        << 
476 // ******************************************* << 
477 //                                             << 
478 void G4LogicalVolume::SetSensitiveDetector(G4V << 
479 {                                              << 
480   G4MT_sdetector = pSDetector;                 << 
481   if (G4Threading::IsMasterThread())  { fSensi << 
482 }                                              << 
483                                                << 
484 // ******************************************* << 
485 // GetMaterialCutsCouple                       << 
486 // ******************************************* << 
487 //                                             << 
488 const G4MaterialCutsCouple* G4LogicalVolume::G << 
489 {                                              << 
490   return G4MT_ccouple;                         << 
491 }                                              << 
492                                                << 
493 // ******************************************* << 
494 // SetMaterialCutsCouple                       << 
495 // ******************************************* << 
496 //                                             << 
497 void G4LogicalVolume::SetMaterialCutsCouple(G4 << 
498 {                                              << 
499   G4MT_ccouple = cuts;                         << 
500 }                                              << 
501                                                   132 
502 // *******************************************    133 // ********************************************************************
503 // IsAncestor                                     134 // IsAncestor
504 //                                                135 //
505 // Finds out if the current logical volume is     136 // Finds out if the current logical volume is an ancestor of a given 
506 // physical volume                                137 // physical volume
507 // *******************************************    138 // ********************************************************************
508 //                                                139 //
509 G4bool                                            140 G4bool
510 G4LogicalVolume::IsAncestor(const G4VPhysicalV    141 G4LogicalVolume::IsAncestor(const G4VPhysicalVolume* aVolume) const
511 {                                                 142 {
512   G4bool isDaughter = IsDaughter(aVolume);        143   G4bool isDaughter = IsDaughter(aVolume);
513   if (!isDaughter)                                144   if (!isDaughter)
514   {                                               145   {
515     for (auto itDau = fDaughters.cbegin(); itD << 146     for (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
                                                   >> 147          itDau != fDaughters.end(); itDau++)
516     {                                             148     {
517       isDaughter = (*itDau)->GetLogicalVolume(    149       isDaughter = (*itDau)->GetLogicalVolume()->IsAncestor(aVolume);
518       if (isDaughter)  break;                     150       if (isDaughter)  break;
519     }                                             151     }
520   }                                               152   }
521   return isDaughter;                              153   return isDaughter;
522 }                                                 154 }
523                                                   155 
524 // *******************************************    156 // ********************************************************************
525 // TotalVolumeEntities                            157 // TotalVolumeEntities
526 //                                                158 //
527 // Returns the total number of physical volume    159 // Returns the total number of physical volumes (replicated or placed)
528 // in the tree represented by the current logi    160 // in the tree represented by the current logical volume.
529 // *******************************************    161 // ********************************************************************
530 //                                                162 //
531 G4int G4LogicalVolume::TotalVolumeEntities() c    163 G4int G4LogicalVolume::TotalVolumeEntities() const
532 {                                                 164 {
533   G4int vols = 1;                              << 165   static G4int vols = 0;
534   for (auto itDau = fDaughters.cbegin(); itDau << 166 
                                                   >> 167   vols++;
                                                   >> 168   for (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
                                                   >> 169        itDau != fDaughters.end(); itDau++)
535   {                                               170   {
536     G4VPhysicalVolume* physDaughter = (*itDau)    171     G4VPhysicalVolume* physDaughter = (*itDau);
537     vols += physDaughter->GetMultiplicity()    << 172     for (G4int i=0; i<physDaughter->GetMultiplicity(); i++)
538            *physDaughter->GetLogicalVolume()-> << 173     {
                                                   >> 174       physDaughter->GetLogicalVolume()->TotalVolumeEntities();
                                                   >> 175     }
539   }                                               176   }
540   return vols;                                    177   return vols;
541 }                                                 178 }
542                                                   179 
543 // *******************************************    180 // ********************************************************************
544 // GetMass                                        181 // GetMass
545 //                                                182 //
546 // Returns the mass of the logical volume tree    183 // Returns the mass of the logical volume tree computed from the
547 // estimated geometrical volume of each solid     184 // estimated geometrical volume of each solid and material associated
548 // to the logical volume and its daughters.       185 // to the logical volume and its daughters.
549 // NOTE: the computation may require considera    186 // NOTE: the computation may require considerable amount of time,
550 //       depending from the complexity of the     187 //       depending from the complexity of the geometry tree.
551 //       The returned value is cached and can     188 //       The returned value is cached and can be used for successive
552 //       calls (default), unless recomputation    189 //       calls (default), unless recomputation is forced by providing
553 //       'true' for the boolean argument in in    190 //       'true' for the boolean argument in input. Computation should
554 //       be forced if the geometry setup has c    191 //       be forced if the geometry setup has changed after the previous
555 //       call. By setting the 'propagate' bool    192 //       call. By setting the 'propagate' boolean flag to 'false' the 
556 //       method returns the mass of the presen    193 //       method returns the mass of the present logical volume only 
557 //       (subtracted for the volume occupied b    194 //       (subtracted for the volume occupied by the daughter volumes).
558 //       The extra argument 'parMaterial' is i    195 //       The extra argument 'parMaterial' is internally used to
559 //       consider cases of geometrical paramet    196 //       consider cases of geometrical parameterisations by material.
560 // *******************************************    197 // ********************************************************************
561 //                                                198 //
562 G4double G4LogicalVolume::GetMass(G4bool force    199 G4double G4LogicalVolume::GetMass(G4bool forced,
563                                   G4bool propa    200                                   G4bool propagate,
564                                   G4Material*     201                                   G4Material* parMaterial)
565 {                                                 202 {
566   // Return the cached non-zero value, if not     203   // Return the cached non-zero value, if not forced
567   //                                              204   //
568   if ( ((G4MT_mass) != 0.0) && (!forced) )  {  << 205   if ( (fMass) && (!forced) ) return fMass;
569                                                   206 
570   // Global density and computed mass associat    207   // Global density and computed mass associated to the logical
571   // volume without considering its daughters     208   // volume without considering its daughters
572   //                                              209   //
573   G4Material* logMaterial = parMaterial != nul << 210   G4Material* logMaterial = parMaterial ? parMaterial : fMaterial;
574   if (logMaterial == nullptr)                  << 211   if (!logMaterial)
575   {                                               212   {
576     std::ostringstream message;                << 213     G4cerr << "ERROR - G4LogicalVolume::GetMass()" << G4endl
577     message << "No material associated to the  << 214            << "        No material is associated to the logical volume: "
578             << fName << " !" << G4endl         << 215            << fName << " !  Sorry, cannot compute the mass ..." << G4endl;
579             << "Sorry, cannot compute the mass << 216     G4Exception("G4LogicalVolume::GetMass()", "InvalidSetup", FatalException,
580     G4Exception("G4LogicalVolume::GetMass()",  << 217     "No material associated to the logical volume !");
581                 FatalException, message);      << 218   }
582     return 0.0;                                << 219   if (!fSolid)
583   }                                            << 220   {
584   if ( GetSolid() == nullptr )                 << 221     G4cerr << "ERROR - G4LogicalVolume::GetMass()" << G4endl
585   {                                            << 222            << "        No solid is associated to the logical volume: "
586     std::ostringstream message;                << 223            << fName << " !  Sorry, cannot compute the mass ..." << G4endl;
587     message << "No solid is associated to the  << 224     G4Exception("G4LogicalVolume::GetMass()", "InvalidSetup", FatalException,
588             << fName << " !" << G4endl         << 225     "No solid associated to the logical volume !");
589             << "Sorry, cannot compute the mass << 
590     G4Exception("G4LogicalVolume::GetMass()",  << 
591                 FatalException, message);      << 
592     return 0.0;                                << 
593   }                                               226   }
594   G4double globalDensity = logMaterial->GetDen    227   G4double globalDensity = logMaterial->GetDensity();
595   G4double motherMass = GetSolid()->GetCubicVo << 228   fMass = fSolid->GetCubicVolume() * globalDensity;
596   G4double massSum = motherMass;               << 229 
597                                                << 
598   // For each daughter in the tree, subtract t    230   // For each daughter in the tree, subtract the mass occupied
599   // and if required by the propagate flag, ad    231   // and if required by the propagate flag, add the real daughter's
600   // one computed recursively                     232   // one computed recursively
601                                                   233 
602   for (auto itDau = fDaughters.cbegin(); itDau << 234   for (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
                                                   >> 235        itDau != fDaughters.end(); itDau++)
603   {                                               236   {
604     G4VPhysicalVolume* physDaughter = (*itDau)    237     G4VPhysicalVolume* physDaughter = (*itDau);
605     G4LogicalVolume* logDaughter = physDaughte    238     G4LogicalVolume* logDaughter = physDaughter->GetLogicalVolume();
606     G4double subMass = 0.0;                    << 239     G4double subMass=0.;
607     G4VSolid* daughterSolid = nullptr;         << 240     G4VSolid* daughterSolid = 0;
608     G4Material* daughterMaterial = nullptr;    << 241     G4Material* daughterMaterial = 0;
609                                                   242 
610     // Compute the mass to subtract and to add    243     // Compute the mass to subtract and to add for each daughter
611     // considering its multiplicity (i.e. repl    244     // considering its multiplicity (i.e. replicated or not) and
612     // eventually its parameterisation (by sol    245     // eventually its parameterisation (by solid and/or by material)
613     //                                            246     //
614     for (auto i=0; i<physDaughter->GetMultipli << 247     for (G4int i=0; i<physDaughter->GetMultiplicity(); i++)
615     {                                             248     {
616       G4VPVParameterisation* physParam = physD << 249       G4VPVParameterisation*
617       if (physParam != nullptr)                << 250         physParam = physDaughter->GetParameterisation();
                                                   >> 251       if (physParam)
618       {                                           252       {
619         daughterSolid = physParam->ComputeSoli    253         daughterSolid = physParam->ComputeSolid(i, physDaughter);
620         daughterSolid->ComputeDimensions(physP    254         daughterSolid->ComputeDimensions(physParam, i, physDaughter);
621         daughterMaterial = physParam->ComputeM    255         daughterMaterial = physParam->ComputeMaterial(i, physDaughter);
622       }                                           256       }
623       else                                        257       else
624       {                                           258       {
625         daughterSolid = logDaughter->GetSolid(    259         daughterSolid = logDaughter->GetSolid();
626         daughterMaterial = logDaughter->GetMat    260         daughterMaterial = logDaughter->GetMaterial();
627       }                                           261       }
628       subMass = daughterSolid->GetCubicVolume(    262       subMass = daughterSolid->GetCubicVolume() * globalDensity;
629                                                   263 
630       // Subtract the daughter's portion for t    264       // Subtract the daughter's portion for the mass and, if required,
631       // add the real daughter's mass computed    265       // add the real daughter's mass computed recursively
632       //                                          266       //
633       massSum -= subMass;                      << 267       fMass -= subMass;
634       if (propagate)                              268       if (propagate)
635       {                                           269       {
636         massSum += logDaughter->GetMass(true,  << 270         fMass += logDaughter->GetMass(true, true, daughterMaterial);
637       }                                           271       }
638     }                                             272     }
639   }                                               273   }
640   G4MT_mass = massSum;                         << 
641   return massSum;                              << 
642 }                                              << 
643                                                   274 
644 // ******************************************* << 275   return fMass;
645 // Change the daughters volume type -- checkin << 
646 //                                             << 
647 //  Undertakes primitive checking, to ensure t << 
648 //  are made:                                  << 
649 //    - any type to 'external'  ( user respons << 
650 //    - the type proposed is checked against t << 
651 //       (for potential switch back to 'intern << 
652 //  Returns success (true) or failure (false)  << 
653 //                                             << 
654 G4bool G4LogicalVolume::ChangeDaughtersType(EV << 
655 {                                              << 
656   G4bool works = false;                        << 
657   if( aType == kExternal )                     << 
658   {                                            << 
659     // It is the responsibility of External Na << 
660     //                                         << 
661     fDaughtersVolumeType = aType;              << 
662     works = true;                              << 
663   }                                            << 
664   else                                         << 
665   {                                            << 
666     EVolume expectedVType = DeduceDaughtersTyp << 
667     works = (expectedVType == aType);          << 
668     if ( works )                               << 
669     {                                          << 
670       fDaughtersVolumeType = aType;            << 
671     }                                          << 
672   }                                            << 
673   return works;                                << 
674 }                                                 276 }
675                                                   277 
676 // ******************************************* << 
677 // SetVisAttributes - copy version             << 
678 // ******************************************* << 
679 //                                             << 
680 void G4LogicalVolume::SetVisAttributes (const     278 void G4LogicalVolume::SetVisAttributes (const G4VisAttributes& VA)
681 {                                                 279 {
682   if (G4Threading::IsWorkerThread()) return;   << 280   fVisAttributes = new G4VisAttributes(VA);
683   fVisAttributes = std::make_shared<const G4Vi << 
684 }                                              << 
685                                                << 
686 // ******************************************* << 
687 // SetVisAttributes                            << 
688 // ******************************************* << 
689 //                                             << 
690 void G4LogicalVolume::SetVisAttributes (const  << 
691 {                                              << 
692   if (G4Threading::IsWorkerThread()) return;   << 
693   fVisAttributes = std::shared_ptr<const G4Vis << 
694 }                                                 281 }
695                                                   282