Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/management/include/G4LogicalVolume.hh

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/include/G4LogicalVolume.hh (Version 11.3.0) and /geometry/management/include/G4LogicalVolume.hh (Version 3.1)


                                                   >>   1 // This code implementation is the intellectual property of
                                                   >>   2 // the GEANT4 collaboration.
  1 //                                                  3 //
  2 // ******************************************* <<   4 // By copying, distributing or modifying the Program (or any work
  3 // * License and Disclaimer                    <<   5 // based on the Program) you indicate your acceptance of this statement,
  4 // *                                           <<   6 // and all its terms.
  5 // * The  Geant4 software  is  copyright of th << 
  6 // * the Geant4 Collaboration.  It is provided << 
  7 // * conditions of the Geant4 Software License << 
  8 // * LICENSE and available at  http://cern.ch/ << 
  9 // * include a list of copyright holders.      << 
 10 // *                                           << 
 11 // * Neither the authors of this software syst << 
 12 // * institutes,nor the agencies providing fin << 
 13 // * work  make  any representation or  warran << 
 14 // * regarding  this  software system or assum << 
 15 // * use.  Please see the license in the file  << 
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                           << 
 18 // * This  code  implementation is the result  << 
 19 // * technical work of the GEANT4 collaboratio << 
 20 // * By using,  copying,  modifying or  distri << 
 21 // * any work based  on the software)  you  ag << 
 22 // * use  in  resulting  scientific  publicati << 
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // ******************************************* << 
 25 //                                                  7 //
 26 // G4LogicalVolume                             <<   8 // $Id: G4LogicalVolume.hh,v 1.6 2000/11/01 15:39:32 gcosmo Exp $
                                                   >>   9 // GEANT4 tag $Name: geant4-03-01 $
                                                   >>  10 //
                                                   >>  11 // 
                                                   >>  12 // class G4LogicalVolume
 27 //                                                 13 //
 28 // Class description:                              14 // Class description:
 29 //                                                 15 //
 30 // Represents a leaf node or unpositioned subt     16 // Represents a leaf node or unpositioned subtree in the geometry hierarchy.
 31 // Logical volumes are named, and may have dau     17 // Logical volumes are named, and may have daughters ascribed to them.
 32 // They are responsible for retrieval of the p     18 // They are responsible for retrieval of the physical and tracking attributes
 33 // of the physical volume that it represents:      19 // of the physical volume that it represents: solid, material, magnetic field,
 34 // and optionally, user limits, sensitive dete <<  20 // and optionally, user limits, sensitive detectors.
 35 //                                                 21 //
 36 // Get and Set functionality is provided for a     22 // Get and Set functionality is provided for all attributes, but note that
 37 // most set functions should not be used  when     23 // most set functions should not be used  when the geometry is `closed'.
 38 // As a  further development, `Guard' checks c     24 // As a  further development, `Guard' checks can be added to ensure
 39 // only legal operations at tracking time.         25 // only legal operations at tracking time.
 40 //                                                 26 //
 41 // On construction, solid, material and name m     27 // On construction, solid, material and name must be specified.
 42 //                                                 28 //
 43 // Daughters are ascribed and managed by means     29 // Daughters are ascribed and managed by means of a simple
 44 // GetNoDaughters,Get/SetDaughter(n),AddDaught <<  30 // GetNoDaughters,Get&SetDaughter(n),AddDaughter interface.
 45 //                                                 31 //
 46 // Smart voxels as used for tracking optimisat <<  32 // Smart voxels as used for tracking optimisation are also an attribute.
 47 //                                                 33 //
 48 // Logical volumes self register to the logica     34 // Logical volumes self register to the logical volume Store on construction,
 49 // and deregister on destruction.                  35 // and deregister on destruction.
 50 //                                                 36 //
 51 // NOTE: This class is currently *NOT* subclas     37 // NOTE: This class is currently *NOT* subclassed, since not meant to
 52 //       act as a base class. Therefore, the d     38 //       act as a base class. Therefore, the destructor is NOT virtual.
 53 //                                                 39 //
 54 // Data members:                                   40 // Data members:
 55 //                                                 41 //
 56 //    std::vector<G4VPhysicalVolume*> fDaughte <<  42 //    G4RWTPtrOrderedVector<G4VPhysicalVolume> fDaughters
 57 //    - Vector of daughters. Given initial siz     43 //    - Vector of daughters. Given initial size of 0.
 58 //    G4FieldManager* fFieldManager            <<  44 //    G4FieldManager *fFieldManager
 59 //    - Pointer (possibly 0) to (magnetic or o <<  45 //    - Pointer (possibly NULL) to (magnetic or other) field manager object.
 60 //    G4Material* fMaterial                    <<  46 //    G4Material *fMaterial
 61 //    - Pointer to material at this node.          47 //    - Pointer to material at this node.
 62 //    G4String fName                               48 //    G4String fName
 63 //    - Name of logical volume.                    49 //    - Name of logical volume.
 64 //    G4VSensitiveDetector *fSensitiveDetector     50 //    G4VSensitiveDetector *fSensitiveDetector
 65 //    - Pointer (possibly 0) to `Hit' object.  <<  51 //    - Pointer (possibly NULL) to `Hit' object.
 66 //    G4VSolid* fSolid                         <<  52 //    G4VSolid *fSolid
 67 //    - Pointer to solid.                          53 //    - Pointer to solid.
 68 //    G4UserLimits* fUserLimits                <<  54 //    G4UserLimits *fUserLimits
 69 //    - Pointer (possibly 0) to user Step limi <<  55 //    - Pointer (possibly NULL) to user Step limit object for this node.
 70 //    G4SmartVoxelHeader* fVoxel               <<  56 //    G4SmartVoxelHeader *fVoxel
 71 //    - Pointer (possibly 0) to optimisation i <<  57 //    - Pointer (possibly NULL) to optimisation info objects.
 72 //    G4bool fOptimise                         << 
 73 //    - Flag to identify if optimisation shoul << 
 74 //    G4bool fRootRegion                       << 
 75 //    - Flag to identify if the logical volume << 
 76 //    G4double fSmartless                          58 //    G4double fSmartless
 77 //    - Quality for optimisation, average numb     59 //    - Quality for optimisation, average number of voxels to be spent
 78 //      per content.                               60 //      per content.
 79 //    const G4VisAttributes* fVisAttributes        61 //    const G4VisAttributes* fVisAttributes
 80 //    - Pointer (possibly 0) to visualization  <<  62 //    - Pointer (possibly NULL) to visualization attributes.
 81 //    G4Region* fRegion                        <<  63 //    G4FastSimulationManager *fFastSimulationManager
 82 //    - Pointer to the cuts region (if any)    <<  64 //    - Pointer (possibly NULL) to G4FastSimulationManager object.
 83 //    G4MaterialCutsCouple* fCutsCouple        << 
 84 //    - Pointer (possibly 0) to associated pro << 
 85 //    G4double fBiasWeight                     << 
 86 //    - Weight used in the event biasing techn << 
 87 //                                             << 
 88 // Following data members has been moved to G4 << 
 89 //    G4FastSimulationManager* fFastSimulation << 
 90 //    - Pointer (possibly 0) to G4FastSimulati << 
 91 //    G4bool fIsEnvelope                           65 //    G4bool fIsEnvelope
 92 //    - Flags if the Logical Volume is an enve     66 //    - Flags if the Logical Volume is an envelope for a FastSimulationManager.
                                                   >>  67 //    G4double fBiasWeight
                                                   >>  68 //    - Weight used in the event biasing technique.
 93                                                    69 
 94 // 15.01.13 G.Cosmo, A.Dotti: Modified for thr <<  70 // History:
 95 // 12.11.04 G.Cosmo: Added GetMass() method fo << 
 96 // 24.09.02 G.Cosmo: Added flags and accessors << 
 97 // 17.05.02 G.Cosmo: Added IsToOptimise() meth << 
 98 // 18.04.01 G.Cosmo: Migrated to STL vector    << 
 99 // 12.02.99 S.Giani: Added user defined optimi     71 // 12.02.99 S.Giani: Added user defined optimisation quality
100 // 09.11.98 M.Verderi, J.Apostolakis: Added Bi <<  72 // 09.11.98 J. Apostolakis:  Changed G4MagneticField to G4FieldManager
101 // 10.20.97 P.M.DeFreitas, J.Apostolakis: Adde <<  73 // 09.11.98 M. Verderi & JA. : added  BiasWeight member and Get/Set methods
102 // 11.07.95 P.Kent: Initial version            <<  74 // 10.20.97 P. MoraDeFreitas : added pointer to a FastSimulation
103 // ------------------------------------------- <<  75 //          (J.Apostolakis)      & flag to indicate if it is an Envelope for it
104 #ifndef G4LOGICALVOLUME_HH                     <<  76 // 19.11.96 J.Allison Replaced G4Visible with explicit const G4VisAttributes*.
105 #define G4LOGICALVOLUME_HH 1                   <<  77 // 19.08.96 P.Kent    Split -> hh/icc/cc files; G4VSensitiveDetector change
                                                   >>  78 // 11.07.95 P.Kent    Initial version.
106                                                    79 
107 #include <vector>                              <<  80 #ifndef G4LOGICALVOLUME_HH
108 #include <memory>                              <<  81 #define G4LOGICALVOLUME_HH
109                                                    82 
110 #include "G4Types.hh"                          <<  83 #include "globals.hh"
111 #include "G4Region.hh"           // Required b <<  84 #include "G4VPhysicalVolume.hh" // Need operator == for vector fdaughters
112 #include "G4VPhysicalVolume.hh"  // Need opera <<  85 #include "g4rw/tpordvec.h"
113 #include "G4GeomSplitter.hh"     // Needed for <<  86 #include <assert.h>
114 #include "G4Threading.hh"                      << 
115                                                    87 
116 // Forward declarations                            88 // Forward declarations
117 //                                             << 
118 class G4FieldManager;                              89 class G4FieldManager;
119 class G4Material;                                  90 class G4Material;
120 class G4VSensitiveDetector;                        91 class G4VSensitiveDetector;
121 class G4VSolid;                                    92 class G4VSolid;
122 class G4UserLimits;                                93 class G4UserLimits;
123 class G4SmartVoxelHeader;                          94 class G4SmartVoxelHeader;
124 class G4FastSimulationManager;                 << 
125 class G4MaterialCutsCouple;                    << 
126 class G4VisAttributes;                             95 class G4VisAttributes;
127                                                <<  96 class G4FastSimulationManager;
128 class G4LVData                                 << 
129 {                                              << 
130   // Encapsulates the fields associated to the << 
131   // G4LogicalVolume that may not be read-only << 
132                                                << 
133   public:                                      << 
134                                                << 
135     G4LVData();                                << 
136     void initialize()                          << 
137     {                                          << 
138       fSolid = nullptr;                        << 
139       fSensitiveDetector = nullptr;            << 
140       fFieldManager = nullptr;                 << 
141       fMaterial = nullptr;                     << 
142       fMass = 0.0;                             << 
143       fCutsCouple = nullptr;                   << 
144     }                                          << 
145                                                << 
146   public:                                      << 
147                                                << 
148     G4VSolid* fSolid = nullptr;                << 
149       // Pointer to solid.                     << 
150     G4VSensitiveDetector* fSensitiveDetector = << 
151       // Pointer to sensitive detector.        << 
152     G4FieldManager* fFieldManager = nullptr;   << 
153       // Pointer (possibly nullptr) to (magnet << 
154     G4Material* fMaterial = nullptr;           << 
155       // Pointer to material at this node.     << 
156     G4double fMass = 0.0;                      << 
157       // Mass of the logical volume tree.      << 
158     G4MaterialCutsCouple* fCutsCouple = nullpt << 
159       // Pointer (possibly nullptr) to associa << 
160 };                                             << 
161                                                << 
162 // The type G4LVManager is introduced to encap << 
163 // both the master thread and worker threads t << 
164 // the fields encapsulated by the class G4LVDa << 
165 // initializes the value for these fields, it  << 
166 // definition defined below. For every G4Logic << 
167 // a corresponding G4LVData instance. All G4LV << 
168 // by the class G4LVManager as an array.       << 
169 // The field "int instanceID" is added to the  << 
170 // The value of this field in each G4LogicalVo << 
171 // of the corresponding G4LVData instance.     << 
172 // In order to use the class G4LVManager, we a << 
173 // G4LogicalVolume as follows: "static G4LVMan << 
174 // For the master thread, the array for G4LVDa << 
175 // along with G4LogicalVolume instances are cr << 
176 // it copies the array of G4LVData instances f << 
177 // In addition, it invokes a method similiar t << 
178 // to achieve the partial effect for each inst << 
179 //                                             << 
180 using G4LVManager = G4GeomSplitter<G4LVData>;  << 
181                                                    97 
182 class G4LogicalVolume                              98 class G4LogicalVolume
183 {                                                  99 {
184   public:                                      << 100   public:  // with description
185                                                << 101   
186     G4LogicalVolume(G4VSolid* pSolid,          << 102     G4LogicalVolume(G4VSolid *pSolid, G4Material *pMaterial,
187                     G4Material* pMaterial,     << 103         const G4String& name,
188               const G4String& name,            << 104         G4FieldManager *pFieldMgr=0,
189                     G4FieldManager* pFieldMgr  << 105         G4VSensitiveDetector *pSDetector=0,
190                     G4VSensitiveDetector* pSDe << 106         G4UserLimits *pULimits=0);
191                     G4UserLimits* pULimits = n << 107       // Constructor. The solid and material pointer must be non null. The
192                     G4bool optimise = true);   << 108       // parameters for field, detector and user limits are optional.
193       // Constructor. The solid and material p << 
194       // The parameters for field, detector an << 
195       // The volume also enters itself into th    109       // The volume also enters itself into the logical volume Store.
196       // Optimisation of the geometry (voxelis << 
197       // hierarchy is applied by default. For  << 
198       // the hierarchy, optimisation is -alway << 
199                                                   110 
200     virtual ~G4LogicalVolume();                << 111     ~G4LogicalVolume();
201       // Destructor. Removes the logical volum    112       // Destructor. Removes the logical volume from the logical volume Store.
202       // This class is NOT meant to act as bas << 113       // NOT virtual, since not meant to act as base class.
203       // circumstances of extended types used  << 
204                                                   114 
205     G4LogicalVolume(const G4LogicalVolume&) =  << 115     inline G4String GetName() const;
206     G4LogicalVolume& operator=(const G4Logical << 116     inline void SetName(const G4String& pName);
207       // Copy-constructor and assignment opera << 
208                                                << 
209     inline const G4String& GetName() const;    << 
210     void SetName(const G4String& pName);       << 
211       // Returns and sets the name of the logi    117       // Returns and sets the name of the logical volume.
212                                                   118 
213     inline std::size_t GetNoDaughters() const; << 119     inline G4int GetNoDaughters() const;
214       // Returns the number of daughters (0 to    120       // Returns the number of daughters (0 to n).
215     inline G4VPhysicalVolume* GetDaughter(cons << 121     inline G4VPhysicalVolume* GetDaughter(const G4int i) const;
216       // Returns the ith daughter. Note number << 122       // Return the ith daughter. Note numbering starts from 0,
217       // and no bounds checking is performed.     123       // and no bounds checking is performed.
218     void AddDaughter(G4VPhysicalVolume* p);    << 124     inline void AddDaughter(G4VPhysicalVolume* p);
219       // Adds the volume p as a daughter of th << 125       // Add the volume p as a daughter of the current logical volume.
220     inline G4bool IsDaughter(const G4VPhysical    126     inline G4bool IsDaughter(const G4VPhysicalVolume* p) const;
221       // Returns true if the volume p is a dau << 127       // Returns true is the volume p is a daughter of the current
222       // logical volume.                          128       // logical volume.
223     G4bool IsAncestor(const G4VPhysicalVolume* << 129     inline void RemoveDaughter(const G4VPhysicalVolume* p);
224       // Returns true if the volume p is part  << 130       // Remove the volume p from the List of daughter of the current
225       // volumes established by the current lo << 
226       // recursively the volume tree.          << 
227     void RemoveDaughter(const G4VPhysicalVolum << 
228       // Removes the volume p from the List of << 
229       // logical volume.                          131       // logical volume.
230     void ClearDaughters();                     << 132 
231       // Clears the list of daughters. Used by << 133     inline G4VSolid* GetSolid() const;
232       // the geometry tree is cleared, since m << 134     inline void SetSolid(G4VSolid *pSolid);
233     G4int TotalVolumeEntities() const;         << 
234       // Returns the total number of physical  << 
235       // in the tree represented by the curren << 
236     inline EVolume CharacteriseDaughters() con << 
237       // Characterise the daughters of this lo << 
238     inline EVolume DeduceDaughtersType() const << 
239       // Used by CharacteriseDaughters().      << 
240                                                << 
241     G4VSolid* GetSolid() const;                << 
242     void SetSolid(G4VSolid* pSolid);           << 
243       // Gets and sets the current solid.         135       // Gets and sets the current solid.
244                                                   136 
245     G4Material* GetMaterial() const;           << 137     inline G4Material* GetMaterial() const;
246     void SetMaterial(G4Material* pMaterial);   << 138     inline void SetMaterial(G4Material *pMaterial);
247       // Gets and sets the current material.      139       // Gets and sets the current material.
248     void UpdateMaterial(G4Material* pMaterial) << 140 
249       // Sets material and corresponding Mater << 141     inline G4FieldManager* GetFieldManager() const;
250       // This method is invoked by G4Navigator << 
251       // material parameterization.            << 
252     G4double GetMass(G4bool forced = false, G4 << 
253                      G4Material* parMaterial = << 
254       // Returns the mass of the logical volum << 
255       // estimated geometrical volume of each  << 
256       // to the logical volume and (by default << 
257       // NOTE: the computation may require a c << 
258       //       depending from the complexity o << 
259       //       The returned value is cached an << 
260       //       calls (default), unless recompu << 
261       //       'true' for the boolean argument << 
262       //       be forced if the geometry setup << 
263       //       call. By setting the 'propagate << 
264       //       method returns the mass of the  << 
265       //       (subtracted for the volume occu << 
266       //       An optional argument to specify << 
267     void ResetMass();                          << 
268       // Ensure that cached value of Mass is i << 
269       //  state, e.g. change of size of Solid, << 
270       //              or the addition/deletion << 
271                                                << 
272     G4FieldManager* GetFieldManager() const;   << 
273       // Gets current FieldManager.               142       // Gets current FieldManager.
274     void SetFieldManager(G4FieldManager* pFiel << 143     void SetFieldManager(G4FieldManager *pFieldMgr, G4bool forceToAllDaughters); 
275       // Sets FieldManager and propagates it:     144       // Sets FieldManager and propagates it:
276       //  i) only to daughters with G4FieldMan << 145       //  i) only to daughters with G4FieldManager = 0
277       //     if forceToAllDaughters=false         146       //     if forceToAllDaughters=false
278       // ii) to all daughters                     147       // ii) to all daughters
279       //     if forceToAllDaughters=true          148       //     if forceToAllDaughters=true
280                                                   149 
281     G4VSensitiveDetector* GetSensitiveDetector << 150     inline G4VSensitiveDetector* GetSensitiveDetector() const;
282       // Gets current SensitiveDetector.          151       // Gets current SensitiveDetector.
283     void SetSensitiveDetector(G4VSensitiveDete << 152     inline void SetSensitiveDetector(G4VSensitiveDetector *pSDetector);
284       // Sets SensitiveDetector (can be nullpt << 153       // Sets SensitiveDetector (can be NULL).
285                                                   154 
286     inline G4UserLimits* GetUserLimits() const    155     inline G4UserLimits* GetUserLimits() const;
287     inline void SetUserLimits(G4UserLimits *pU    156     inline void SetUserLimits(G4UserLimits *pULimits);
288       // Gets and sets current UserLimits.        157       // Gets and sets current UserLimits.
289                                                   158 
290     inline G4SmartVoxelHeader* GetVoxelHeader(    159     inline G4SmartVoxelHeader* GetVoxelHeader() const;
291     inline void SetVoxelHeader(G4SmartVoxelHea    160     inline void SetVoxelHeader(G4SmartVoxelHeader *pVoxel);
292       // Gets and sets current VoxelHeader.       161       // Gets and sets current VoxelHeader.
293                                                   162     
294     inline G4double GetSmartless() const;      << 163     inline G4double GetSmartless();
295     inline void SetSmartless(G4double s);         164     inline void SetSmartless(G4double s);
296       // Gets and sets user defined optimisati    165       // Gets and sets user defined optimisation quality.
297                                                   166 
298     inline G4bool IsToOptimise() const;        << 167     G4bool operator == ( const G4LogicalVolume& lv) const;
299       // Replies if geometry optimisation (vox << 168       // Equality defined by address only- return true if objects are at
300       // applied for this volume hierarchy.    << 169       // same address, else false.
301     inline void SetOptimisation(G4bool optim); << 170 
302       // Specifies if to apply or not geometry << 171     inline const G4VisAttributes* GetVisAttributes () const;
303       // volume hierarchy. Note that for param << 172     inline void  SetVisAttributes (const G4VisAttributes* pVA);
304       // hierarchy, optimisation is always app << 173     inline void  SetVisAttributes (const G4VisAttributes& VA);
305                                                << 
306     inline G4bool IsRootRegion() const;        << 
307       // Replies if the logical volume represe << 
308     inline void SetRegionRootFlag(G4bool rreg) << 
309       // Sets/unsets the volume as a root regi << 
310     inline G4bool IsRegion() const;            << 
311       // Replies if the logical volume is part << 
312     inline void SetRegion(G4Region* reg);      << 
313       // Sets/unsets the volume as cuts region << 
314     inline G4Region* GetRegion() const;        << 
315       // Return the region to which the volume << 
316     inline void PropagateRegion();             << 
317       // Propagates region pointer to daughter << 
318                                                << 
319     const G4MaterialCutsCouple* GetMaterialCut << 
320     void SetMaterialCutsCouple(G4MaterialCutsC << 
321       // Accessors for production cuts.        << 
322                                                << 
323     G4bool operator == (const G4LogicalVolume& << 
324       // Equality defined by address only.     << 
325       // Returns true if objects are at same a << 
326                                                << 
327     const G4VisAttributes* GetVisAttributes () << 
328     void SetVisAttributes (const G4VisAttribut << 
329     void SetVisAttributes (const G4VisAttribut << 
330       // Gets and sets visualization attribute    174       // Gets and sets visualization attributes.
331       // Arguments are converted to shared_ptr << 
332                                                   175 
                                                   >> 176     inline void BecomeEnvelopeForFastSimulation(G4FastSimulationManager* );
                                                   >> 177       // Makes this an Envelope for given FastSimulationManager. 
                                                   >> 178       // Ensures that all its daughter volumes get it too - unless they 
                                                   >> 179       // have one already.
                                                   >> 180     void  ClearEnvelopeForFastSimulation(G4LogicalVolume* motherLV= 0);
                                                   >> 181       // Erase volume's Envelope status and propagate the FastSimulationManager 
                                                   >> 182       // of its mother volume to itself and its daughters.
333     inline G4FastSimulationManager* GetFastSim    183     inline G4FastSimulationManager* GetFastSimulationManager () const;
334       // Gets current FastSimulationManager po << 184       // Gets current FastSimulationManager pointer.
335                                                   185 
336     inline void SetBiasWeight (G4double w);       186     inline void SetBiasWeight (G4double w);
337     inline G4double GetBiasWeight() const;        187     inline G4double GetBiasWeight() const;
338       // Sets and gets bias weight.               188       // Sets and gets bias weight.
339                                                   189 
340   public:                                      << 190   private:
341                                                << 
342     G4LogicalVolume(__void__&);                << 
343       // Fake default constructor for usage re << 
344       // persistency for clients requiring pre << 
345       // persistifiable objects.               << 
346                                                << 
347     virtual G4bool IsExtended() const;         << 
348       // Return true if it is not a base-class << 
349                                                << 
350     inline G4FieldManager* GetMasterFieldManag << 
351       // Gets current FieldManager for the mas << 
352     inline G4VSensitiveDetector* GetMasterSens << 
353       // Gets current SensitiveDetector for th << 
354     inline G4VSolid* GetMasterSolid() const;   << 
355       // Gets current Solid for the master thr << 
356                                                << 
357     inline G4int GetInstanceID() const;        << 
358       // Returns the instance ID.              << 
359                                                << 
360     static const G4LVManager& GetSubInstanceMa << 
361       // Returns the private data instance man << 
362                                                << 
363     static void Clean();                       << 
364       // Clear memory allocated by sub-instanc << 
365                                                << 
366     inline void Lock();                        << 
367       // Set lock identifier for final deletio << 
368                                                << 
369     void InitialiseWorker(G4LogicalVolume* ptr << 
370                           G4VSolid* pSolid, G4 << 
371       // This method is similar to the constru << 
372       // thread to achieve the partial effect  << 
373                                                << 
374     void TerminateWorker(G4LogicalVolume* ptrM << 
375       // This method is similar to the destruc << 
376       // thread to achieve the partial effect  << 
377                                                   191 
378     void AssignFieldManager(G4FieldManager* fl << 192     void  SetFastSimulationManager (G4FastSimulationManager* pPA, 
379       // Set the FieldManager - only at this l << 193                   G4bool IsEnvelope);
380                                                << 194       // Sets the fast simulation manager. Private method called by the
381     static G4VSolid* GetSolid(G4LVData& instLV << 195       // public SetIsEnvelope method with IsEnvelope = TRUE. It is 
382     static void SetSolid(G4LVData& instLVdata, << 196       // then called recursivaly to the daughters to propagate the 
383       // Optimised Methods - passing thread in << 197       // FastSimulationManager pointer with IsEnvelope = FALSE.
384                                                << 198 
385     G4bool ChangeDaughtersType(EVolume atype); << 199     G4LogicalVolume* FindMotherLogicalVolumeForEnvelope(); 
386       // Change the type of the daughters volu << 200 
387       // Meant for the user who wants to use t << 201     G4LogicalVolume(const G4LogicalVolume&);
388       // the contents of a volume.             << 202     G4LogicalVolume& operator=(const G4LogicalVolume&);
389       // Returns: success (true) or failure (f << 203       // Private copy-constructor and assignment operator.
390                                                   204 
391   private:                                        205   private:
392                                                   206 
393     using G4PhysicalVolumeList = std::vector<G << 207     // Data members:   
394                                                   208 
395     G4GEOM_DLL static G4LVManager subInstanceM << 209     G4RWTPtrOrderedVector<G4VPhysicalVolume> fDaughters;    
396       // This new field helps to use the class << 
397                                                << 
398     G4PhysicalVolumeList fDaughters;           << 
399       // Vector of daughters. Given initial si    210       // Vector of daughters. Given initial size of 0.
                                                   >> 211     G4FieldManager *fFieldManager;
                                                   >> 212       // Pointer (possibly NULL) to (magnetic or other) field manager object.
                                                   >> 213     G4Material *fMaterial;
                                                   >> 214       // Pointer to material at this node.
400     G4String fName;                               215     G4String fName;
401       // Name of logical volume.                  216       // Name of logical volume.
402     G4UserLimits* fUserLimits = nullptr;       << 217     G4VSensitiveDetector *fSensitiveDetector;
403       // Pointer (possibly nullptr) to user St << 218       // Pointer (possibly NULL) to `Hit' object.
404     G4SmartVoxelHeader* fVoxel = nullptr;      << 219     G4VSolid *fSolid;
405       // Pointer (possibly nullptr) to optimis << 220       // Pointer to solid.
406     G4double fSmartless = 2.0;                 << 221     G4UserLimits *fUserLimits;
                                                   >> 222       // Pointer (possibly NULL) to user Step limit object for this node.
                                                   >> 223     G4SmartVoxelHeader *fVoxel;
                                                   >> 224       // Pointer (possibly NULL) to optimisation info objects.
                                                   >> 225     G4double fSmartless;
407       // Quality for optimisation, average num    226       // Quality for optimisation, average number of voxels to be spent
408       // per content.                             227       // per content.
409     G4Region* fRegion = nullptr;               << 228     const G4VisAttributes* fVisAttributes;
410       // Pointer to the cuts region (if any).  << 229       // Pointer (possibly NULL) to visualization attributes.
411     G4double fBiasWeight = 1.0;                << 230     G4FastSimulationManager *fFastSimulationManager;
                                                   >> 231       // Pointer (possibly NULL) to G4FastSimulationManager object.
                                                   >> 232     G4bool fIsEnvelope;
                                                   >> 233       // Flags if the Logical Volume is an envelope for a
                                                   >> 234       // FastSimulationManager.
                                                   >> 235     G4double fBiasWeight;
412       // Weight used in the event biasing tech    236       // Weight used in the event biasing technique.
413     std::shared_ptr<const G4VisAttributes> fVi << 
414       // Pointer to visualization attributes.  << 
415                                                << 
416     // Shadow of master pointers.              << 
417     // Each worker thread can access this fiel << 
418     // through these pointers.                 << 
419     //                                         << 
420     G4VSolid* fSolid = nullptr;                << 
421     G4VSensitiveDetector* fSensitiveDetector = << 
422     G4FieldManager* fFieldManager = nullptr;   << 
423     G4LVData* lvdata = nullptr;  // For use of << 
424                                                << 
425     G4int instanceID;                          << 
426       // This new field is used as instance ID << 
427     EVolume fDaughtersVolumeType;              << 
428       // Are contents of volume placements, re << 
429     G4bool fOptimise = true;                   << 
430       // Flag to identify if optimisation shou << 
431     G4bool fRootRegion = false;                << 
432       // Flag to identify if the logical volum << 
433     G4bool fLock = false;                      << 
434       // Flag to identify if entity is locked  << 
435 };                                                237 };
436                                                   238 
437 #include "G4LogicalVolume.icc"                    239 #include "G4LogicalVolume.icc"
438                                                   240 
439 #endif                                            241 #endif
440                                                   242