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 5.1.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 // G4LogicalVolume                             <<  23 //
                                                   >>  24 // $Id: G4LogicalVolume.hh,v 1.12 2003/04/03 10:26:53 gcosmo Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-05-01-patch-01 $
                                                   >>  26 //
                                                   >>  27 // 
                                                   >>  28 // class G4LogicalVolume
 27 //                                                 29 //
 28 // Class description:                              30 // Class description:
 29 //                                                 31 //
 30 // Represents a leaf node or unpositioned subt     32 // Represents a leaf node or unpositioned subtree in the geometry hierarchy.
 31 // Logical volumes are named, and may have dau     33 // Logical volumes are named, and may have daughters ascribed to them.
 32 // They are responsible for retrieval of the p     34 // They are responsible for retrieval of the physical and tracking attributes
 33 // of the physical volume that it represents:      35 // of the physical volume that it represents: solid, material, magnetic field,
 34 // and optionally, user limits, sensitive dete <<  36 // and optionally, user limits, sensitive detectors.
 35 //                                                 37 //
 36 // Get and Set functionality is provided for a     38 // Get and Set functionality is provided for all attributes, but note that
 37 // most set functions should not be used  when     39 // most set functions should not be used  when the geometry is `closed'.
 38 // As a  further development, `Guard' checks c     40 // As a  further development, `Guard' checks can be added to ensure
 39 // only legal operations at tracking time.         41 // only legal operations at tracking time.
 40 //                                                 42 //
 41 // On construction, solid, material and name m     43 // On construction, solid, material and name must be specified.
 42 //                                                 44 //
 43 // Daughters are ascribed and managed by means     45 // Daughters are ascribed and managed by means of a simple
 44 // GetNoDaughters,Get/SetDaughter(n),AddDaught <<  46 // GetNoDaughters,Get&SetDaughter(n),AddDaughter interface.
 45 //                                                 47 //
 46 // Smart voxels as used for tracking optimisat     48 // Smart voxels as used for tracking optimisation. They're also an attribute.
 47 //                                                 49 //
 48 // Logical volumes self register to the logica     50 // Logical volumes self register to the logical volume Store on construction,
 49 // and deregister on destruction.                  51 // and deregister on destruction.
 50 //                                                 52 //
 51 // NOTE: This class is currently *NOT* subclas     53 // NOTE: This class is currently *NOT* subclassed, since not meant to
 52 //       act as a base class. Therefore, the d     54 //       act as a base class. Therefore, the destructor is NOT virtual.
 53 //                                                 55 //
 54 // Data members:                                   56 // Data members:
 55 //                                                 57 //
 56 //    std::vector<G4VPhysicalVolume*> fDaughte <<  58 //    G4std::vector<G4VPhysicalVolume*> fDaughters
 57 //    - Vector of daughters. Given initial siz     59 //    - Vector of daughters. Given initial size of 0.
 58 //    G4FieldManager* fFieldManager                60 //    G4FieldManager* fFieldManager
 59 //    - Pointer (possibly 0) to (magnetic or o     61 //    - Pointer (possibly 0) to (magnetic or other) field manager object.
 60 //    G4Material* fMaterial                        62 //    G4Material* fMaterial
 61 //    - Pointer to material at this node.          63 //    - Pointer to material at this node.
 62 //    G4String fName                               64 //    G4String fName
 63 //    - Name of logical volume.                    65 //    - Name of logical volume.
 64 //    G4VSensitiveDetector *fSensitiveDetector     66 //    G4VSensitiveDetector *fSensitiveDetector
 65 //    - Pointer (possibly 0) to `Hit' object.      67 //    - Pointer (possibly 0) to `Hit' object.
 66 //    G4VSolid* fSolid                             68 //    G4VSolid* fSolid
 67 //    - Pointer to solid.                          69 //    - Pointer to solid.
 68 //    G4UserLimits* fUserLimits                    70 //    G4UserLimits* fUserLimits
 69 //    - Pointer (possibly 0) to user Step limi     71 //    - Pointer (possibly 0) to user Step limit object for this node.
 70 //    G4SmartVoxelHeader* fVoxel                   72 //    G4SmartVoxelHeader* fVoxel
 71 //    - Pointer (possibly 0) to optimisation i     73 //    - Pointer (possibly 0) to optimisation info objects.
 72 //    G4bool fOptimise                             74 //    G4bool fOptimise
 73 //    - Flag to identify if optimisation shoul     75 //    - Flag to identify if optimisation should be applied or not.
 74 //    G4bool fRootRegion                           76 //    G4bool fRootRegion
 75 //    - Flag to identify if the logical volume     77 //    - Flag to identify if the logical volume is a root region.
 76 //    G4double fSmartless                          78 //    G4double fSmartless
 77 //    - Quality for optimisation, average numb     79 //    - Quality for optimisation, average number of voxels to be spent
 78 //      per content.                               80 //      per content.
 79 //    const G4VisAttributes* fVisAttributes        81 //    const G4VisAttributes* fVisAttributes
 80 //    - Pointer (possibly 0) to visualization      82 //    - Pointer (possibly 0) to visualization attributes.
                                                   >>  83 //    G4FastSimulationManager* fFastSimulationManager
                                                   >>  84 //    - Pointer (possibly 0) to G4FastSimulationManager object.
 81 //    G4Region* fRegion                            85 //    G4Region* fRegion
 82 //    - Pointer to the cuts region (if any)        86 //    - Pointer to the cuts region (if any)
 83 //    G4MaterialCutsCouple* fCutsCouple            87 //    G4MaterialCutsCouple* fCutsCouple
 84 //    - Pointer (possibly 0) to associated pro     88 //    - Pointer (possibly 0) to associated production cuts.
 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                           89 //    G4bool fIsEnvelope
 92 //    - Flags if the Logical Volume is an enve     90 //    - Flags if the Logical Volume is an envelope for a FastSimulationManager.
                                                   >>  91 //    G4double fBiasWeight
                                                   >>  92 //    - Weight used in the event biasing technique.
 93                                                    93 
 94 // 15.01.13 G.Cosmo, A.Dotti: Modified for thr <<  94 // History:
 95 // 12.11.04 G.Cosmo: Added GetMass() method fo << 
 96 // 24.09.02 G.Cosmo: Added flags and accessors     95 // 24.09.02 G.Cosmo: Added flags and accessors for region cuts handling
 97 // 17.05.02 G.Cosmo: Added IsToOptimise() meth     96 // 17.05.02 G.Cosmo: Added IsToOptimise() method and related flag
 98 // 18.04.01 G.Cosmo: Migrated to STL vector        97 // 18.04.01 G.Cosmo: Migrated to STL vector
 99 // 12.02.99 S.Giani: Added user defined optimi     98 // 12.02.99 S.Giani: Added user defined optimisation quality
                                                   >>  99 // 09.11.98 J.Apostolakis:  Changed G4MagneticField to G4FieldManager
100 // 09.11.98 M.Verderi, J.Apostolakis: Added Bi    100 // 09.11.98 M.Verderi, J.Apostolakis: Added BiasWeight member and accessors
101 // 10.20.97 P.M.DeFreitas, J.Apostolakis: Adde << 101 // 10.20.97 P.M.DeFreitas: Added pointer to a FastSimulation
102 // 11.07.95 P.Kent: Initial version            << 102 //          J.Apostolakis: & flag to indicate if it is an Envelope for it
103 // ------------------------------------------- << 103 // 19.11.96 J.Allison: Replaced G4Visible with explicit const G4VisAttributes*
104 #ifndef G4LOGICALVOLUME_HH                     << 104 // 19.08.96 P.Kent: Split -> hh/icc/cc files; G4VSensitiveDetector change
105 #define G4LOGICALVOLUME_HH 1                   << 105 // 11.07.95 P.Kent: Initial version.
106                                                   106 
107 #include <vector>                              << 107 #ifndef G4LOGICALVOLUME_HH
108 #include <memory>                              << 108 #define G4LOGICALVOLUME_HH
109                                                   109 
110 #include "G4Types.hh"                          << 110 #include "globals.hh"
111 #include "G4Region.hh"           // Required b << 111 #include "G4Region.hh"
112 #include "G4VPhysicalVolume.hh"  // Need opera    112 #include "G4VPhysicalVolume.hh"  // Need operator == for vector fdaughters
113 #include "G4GeomSplitter.hh"     // Needed for << 113 #include "g4std/vector"
114 #include "G4Threading.hh"                      << 114 #include <assert.h>
115                                                   115 
116 // Forward declarations                           116 // Forward declarations
117 //                                                117 //
118 class G4FieldManager;                             118 class G4FieldManager;
119 class G4Material;                                 119 class G4Material;
120 class G4VSensitiveDetector;                       120 class G4VSensitiveDetector;
121 class G4VSolid;                                   121 class G4VSolid;
122 class G4UserLimits;                               122 class G4UserLimits;
123 class G4SmartVoxelHeader;                         123 class G4SmartVoxelHeader;
                                                   >> 124 class G4VisAttributes;
124 class G4FastSimulationManager;                    125 class G4FastSimulationManager;
125 class G4MaterialCutsCouple;                       126 class G4MaterialCutsCouple;
126 class G4VisAttributes;                         << 
127                                                << 
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                                                   127 
182 class G4LogicalVolume                             128 class G4LogicalVolume
183 {                                                 129 {
184   public:                                      << 130   typedef G4std::vector<G4VPhysicalVolume*> G4PhysicalVolumeList;
185                                                << 131 
                                                   >> 132   public:  // with description
                                                   >> 133   
186     G4LogicalVolume(G4VSolid* pSolid,             134     G4LogicalVolume(G4VSolid* pSolid,
187                     G4Material* pMaterial,        135                     G4Material* pMaterial,
188               const G4String& name,               136               const G4String& name,
189                     G4FieldManager* pFieldMgr  << 137                     G4FieldManager* pFieldMgr=0,
190                     G4VSensitiveDetector* pSDe << 138                     G4VSensitiveDetector* pSDetector=0,
191                     G4UserLimits* pULimits = n << 139                     G4UserLimits* pULimits=0,
192                     G4bool optimise = true);   << 140                     G4bool optimise=true);
193       // Constructor. The solid and material p    141       // Constructor. The solid and material pointer must be non null.
194       // The parameters for field, detector an    142       // The parameters for field, detector and user limits are optional.
195       // The volume also enters itself into th    143       // The volume also enters itself into the logical volume Store.
196       // Optimisation of the geometry (voxelis    144       // Optimisation of the geometry (voxelisation) for the volume
197       // hierarchy is applied by default. For     145       // hierarchy is applied by default. For parameterised volumes in
198       // the hierarchy, optimisation is -alway    146       // the hierarchy, optimisation is -always- applied.
199                                                   147 
200     virtual ~G4LogicalVolume();                << 148     ~G4LogicalVolume();
201       // Destructor. Removes the logical volum    149       // Destructor. Removes the logical volume from the logical volume Store.
202       // This class is NOT meant to act as bas << 150       // NOT virtual, since not meant to act as base class.
203       // circumstances of extended types used  << 
204                                                   151 
205     G4LogicalVolume(const G4LogicalVolume&) =  << 152     inline G4String GetName() const;
206     G4LogicalVolume& operator=(const G4Logical << 153     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    154       // Returns and sets the name of the logical volume.
212                                                   155 
213     inline std::size_t GetNoDaughters() const; << 156     inline G4int GetNoDaughters() const;
214       // Returns the number of daughters (0 to    157       // Returns the number of daughters (0 to n).
215     inline G4VPhysicalVolume* GetDaughter(cons << 158     inline G4VPhysicalVolume* GetDaughter(const G4int i) const;
216       // Returns the ith daughter. Note number << 159       // Return the ith daughter. Note numbering starts from 0,
217       // and no bounds checking is performed.     160       // and no bounds checking is performed.
218     void AddDaughter(G4VPhysicalVolume* p);    << 161     inline void AddDaughter(G4VPhysicalVolume* p);
219       // Adds the volume p as a daughter of th << 162       // Add the volume p as a daughter of the current logical volume.
220     inline G4bool IsDaughter(const G4VPhysical    163     inline G4bool IsDaughter(const G4VPhysicalVolume* p) const;
221       // Returns true if the volume p is a dau    164       // Returns true if the volume p is a daughter of the current
222       // logical volume.                          165       // logical volume.
223     G4bool IsAncestor(const G4VPhysicalVolume*    166     G4bool IsAncestor(const G4VPhysicalVolume* p) const;
224       // Returns true if the volume p is part     167       // Returns true if the volume p is part of the hierarchy of
225       // volumes established by the current lo    168       // volumes established by the current logical volume. Scans
226       // recursively the volume tree.             169       // recursively the volume tree.
227     void RemoveDaughter(const G4VPhysicalVolum << 170     inline void RemoveDaughter(const G4VPhysicalVolume* p);
228       // Removes the volume p from the List of << 171       // Remove the volume p from the List of daughter of the current
229       // logical volume.                          172       // logical volume.
230     void ClearDaughters();                     << 173 
231       // Clears the list of daughters. Used by << 174     inline G4VSolid* GetSolid() const;
232       // the geometry tree is cleared, since m << 175     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.         176       // Gets and sets the current solid.
244                                                   177 
245     G4Material* GetMaterial() const;           << 178     inline G4Material* GetMaterial() const;
246     void SetMaterial(G4Material* pMaterial);   << 179     inline void SetMaterial(G4Material *pMaterial);
247       // Gets and sets the current material.      180       // Gets and sets the current material.
248     void UpdateMaterial(G4Material* pMaterial) << 181 
249       // Sets material and corresponding Mater << 182     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.               183       // Gets current FieldManager.
274     void SetFieldManager(G4FieldManager* pFiel << 184     void SetFieldManager(G4FieldManager *pFieldMgr, G4bool forceToAllDaughters); 
275       // Sets FieldManager and propagates it:     185       // Sets FieldManager and propagates it:
276       //  i) only to daughters with G4FieldMan << 186       //  i) only to daughters with G4FieldManager = 0
277       //     if forceToAllDaughters=false         187       //     if forceToAllDaughters=false
278       // ii) to all daughters                     188       // ii) to all daughters
279       //     if forceToAllDaughters=true          189       //     if forceToAllDaughters=true
280                                                   190 
281     G4VSensitiveDetector* GetSensitiveDetector << 191     inline G4VSensitiveDetector* GetSensitiveDetector() const;
282       // Gets current SensitiveDetector.          192       // Gets current SensitiveDetector.
283     void SetSensitiveDetector(G4VSensitiveDete << 193     inline void SetSensitiveDetector(G4VSensitiveDetector *pSDetector);
284       // Sets SensitiveDetector (can be nullpt << 194       // Sets SensitiveDetector (can be 0).
285                                                   195 
286     inline G4UserLimits* GetUserLimits() const    196     inline G4UserLimits* GetUserLimits() const;
287     inline void SetUserLimits(G4UserLimits *pU    197     inline void SetUserLimits(G4UserLimits *pULimits);
288       // Gets and sets current UserLimits.        198       // Gets and sets current UserLimits.
289                                                   199 
290     inline G4SmartVoxelHeader* GetVoxelHeader(    200     inline G4SmartVoxelHeader* GetVoxelHeader() const;
291     inline void SetVoxelHeader(G4SmartVoxelHea    201     inline void SetVoxelHeader(G4SmartVoxelHeader *pVoxel);
292       // Gets and sets current VoxelHeader.       202       // Gets and sets current VoxelHeader.
293                                                   203     
294     inline G4double GetSmartless() const;         204     inline G4double GetSmartless() const;
295     inline void SetSmartless(G4double s);         205     inline void SetSmartless(G4double s);
296       // Gets and sets user defined optimisati    206       // Gets and sets user defined optimisation quality.
297                                                   207 
298     inline G4bool IsToOptimise() const;           208     inline G4bool IsToOptimise() const;
299       // Replies if geometry optimisation (vox    209       // Replies if geometry optimisation (voxelisation) is to be
300       // applied for this volume hierarchy.       210       // applied for this volume hierarchy.
301     inline void SetOptimisation(G4bool optim);    211     inline void SetOptimisation(G4bool optim);
302       // Specifies if to apply or not geometry    212       // Specifies if to apply or not geometry optimisation to this
303       // volume hierarchy. Note that for param    213       // volume hierarchy. Note that for parameterised volumes in the
304       // hierarchy, optimisation is always app    214       // hierarchy, optimisation is always applied. 
305                                                   215 
306     inline G4bool IsRootRegion() const;           216     inline G4bool IsRootRegion() const;
307       // Replies if the logical volume represe    217       // Replies if the logical volume represents a root region or not.
308     inline void SetRegionRootFlag(G4bool rreg)    218     inline void SetRegionRootFlag(G4bool rreg);
309       // Sets/unsets the volume as a root regi    219       // Sets/unsets the volume as a root region for cuts.
310     inline G4bool IsRegion() const;               220     inline G4bool IsRegion() const;
311       // Replies if the logical volume is part    221       // Replies if the logical volume is part of a cuts region or not.
312     inline void SetRegion(G4Region* reg);         222     inline void SetRegion(G4Region* reg);
313       // Sets/unsets the volume as cuts region    223       // Sets/unsets the volume as cuts region.
314     inline G4Region* GetRegion() const;           224     inline G4Region* GetRegion() const;
315       // Return the region to which the volume    225       // Return the region to which the volume belongs, if any.
316     inline void PropagateRegion();                226     inline void PropagateRegion();
317       // Propagates region pointer to daughter    227       // Propagates region pointer to daughters.
318                                                   228 
319     const G4MaterialCutsCouple* GetMaterialCut << 229     inline const G4MaterialCutsCouple* GetMaterialCutsCouple() const;
320     void SetMaterialCutsCouple(G4MaterialCutsC << 230     inline void SetMaterialCutsCouple(G4MaterialCutsCouple* cuts);
321       // Accessors for production cuts.           231       // Accessors for production cuts.
322                                                   232 
323     G4bool operator == (const G4LogicalVolume&    233     G4bool operator == (const G4LogicalVolume& lv) const;
324       // Equality defined by address only.        234       // Equality defined by address only.
325       // Returns true if objects are at same a    235       // Returns true if objects are at same address, else false.
326                                                   236 
327     const G4VisAttributes* GetVisAttributes () << 237     inline const G4VisAttributes* GetVisAttributes () const;
328     void SetVisAttributes (const G4VisAttribut << 238     inline void  SetVisAttributes (const G4VisAttributes* pVA);
329     void SetVisAttributes (const G4VisAttribut << 239     inline void  SetVisAttributes (const G4VisAttributes& VA);
330       // Gets and sets visualization attribute    240       // Gets and sets visualization attributes.
331       // Arguments are converted to shared_ptr << 
332                                                   241 
                                                   >> 242     inline void BecomeEnvelopeForFastSimulation(G4FastSimulationManager* );
                                                   >> 243       // Makes this an Envelope for given FastSimulationManager. 
                                                   >> 244       // Ensures that all its daughter volumes get it too - unless they 
                                                   >> 245       // have one already.
                                                   >> 246     void  ClearEnvelopeForFastSimulation(G4LogicalVolume* motherLV= 0);
                                                   >> 247       // Erase volume's Envelope status and propagate the FastSimulationManager 
                                                   >> 248       // of its mother volume to itself and its daughters.
333     inline G4FastSimulationManager* GetFastSim    249     inline G4FastSimulationManager* GetFastSimulationManager () const;
334       // Gets current FastSimulationManager po << 250       // Gets current FastSimulationManager pointer.
335                                                   251 
336     inline void SetBiasWeight (G4double w);       252     inline void SetBiasWeight (G4double w);
337     inline G4double GetBiasWeight() const;        253     inline G4double GetBiasWeight() const;
338       // Sets and gets bias weight.               254       // Sets and gets bias weight.
339                                                   255 
340   public:                                      << 256   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                                                   257 
378     void AssignFieldManager(G4FieldManager* fl << 258     void  SetFastSimulationManager (G4FastSimulationManager* pPA, 
379       // Set the FieldManager - only at this l << 259                                     G4bool IsEnvelope);
380                                                << 260       // Sets the fast simulation manager. Private method called by the
381     static G4VSolid* GetSolid(G4LVData& instLV << 261       // public SetIsEnvelope method with IsEnvelope = true. It is 
382     static void SetSolid(G4LVData& instLVdata, << 262       // then called recursivaly to the daughters to propagate the 
383       // Optimised Methods - passing thread in << 263       // FastSimulationManager pointer with IsEnvelope = false.
384                                                << 264 
385     G4bool ChangeDaughtersType(EVolume atype); << 265     G4LogicalVolume* FindMotherLogicalVolumeForEnvelope(); 
386       // Change the type of the daughters volu << 266 
387       // Meant for the user who wants to use t << 267     G4LogicalVolume(const G4LogicalVolume&);
388       // the contents of a volume.             << 268     G4LogicalVolume& operator=(const G4LogicalVolume&);
389       // Returns: success (true) or failure (f << 269       // Private copy-constructor and assignment operator.
390                                                   270 
391   private:                                        271   private:
392                                                   272 
393     using G4PhysicalVolumeList = std::vector<G << 273     // Data members:   
394                                                << 
395     G4GEOM_DLL static G4LVManager subInstanceM << 
396       // This new field helps to use the class << 
397                                                   274 
398     G4PhysicalVolumeList fDaughters;              275     G4PhysicalVolumeList fDaughters;
399       // Vector of daughters. Given initial si    276       // Vector of daughters. Given initial size of 0.
                                                   >> 277     G4FieldManager* fFieldManager;
                                                   >> 278       // Pointer (possibly 0) to (magnetic or other) field manager object.
                                                   >> 279     G4Material* fMaterial;
                                                   >> 280       // Pointer to material at this node.
400     G4String fName;                               281     G4String fName;
401       // Name of logical volume.                  282       // Name of logical volume.
402     G4UserLimits* fUserLimits = nullptr;       << 283     G4VSensitiveDetector* fSensitiveDetector;
403       // Pointer (possibly nullptr) to user St << 284       // Pointer (possibly 0) to `Hit' object.
404     G4SmartVoxelHeader* fVoxel = nullptr;      << 285     G4VSolid* fSolid;
405       // Pointer (possibly nullptr) to optimis << 286       // Pointer to solid.
406     G4double fSmartless = 2.0;                 << 287     G4UserLimits* fUserLimits;
                                                   >> 288       // Pointer (possibly 0) to user Step limit object for this node.
                                                   >> 289     G4SmartVoxelHeader* fVoxel;
                                                   >> 290       // Pointer (possibly 0) to optimisation info objects.
                                                   >> 291     G4bool fOptimise;
                                                   >> 292       // Flag to identify if optimisation should be applied or not.
                                                   >> 293     G4bool fRootRegion;
                                                   >> 294       // Flag to identify if the logical volume is a root region.
                                                   >> 295     G4double fSmartless;
407       // Quality for optimisation, average num    296       // Quality for optimisation, average number of voxels to be spent
408       // per content.                             297       // per content.
409     G4Region* fRegion = nullptr;               << 298     const G4VisAttributes* fVisAttributes;
410       // Pointer to the cuts region (if any).  << 299       // Pointer (possibly 0) to visualization attributes.
411     G4double fBiasWeight = 1.0;                << 300     G4FastSimulationManager* fFastSimulationManager;
                                                   >> 301       // Pointer (possibly 0) to G4FastSimulationManager object.
                                                   >> 302     G4Region* fRegion;
                                                   >> 303       // Pointer to the cuts region (if any)
                                                   >> 304     G4MaterialCutsCouple* fCutsCouple;
                                                   >> 305       // Pointer (possibly 0) to associated production cuts.
                                                   >> 306     G4bool fIsEnvelope;
                                                   >> 307       // Flags if the Logical Volume is an envelope for a
                                                   >> 308       // FastSimulationManager.
                                                   >> 309     G4double fBiasWeight;
412       // Weight used in the event biasing tech    310       // 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 };                                                311 };
436                                                   312 
437 #include "G4LogicalVolume.icc"                    313 #include "G4LogicalVolume.icc"
438                                                   314 
439 #endif                                            315 #endif
440                                                   316