ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4AssemblyVolume.hh
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4AssemblyVolume.hh
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // Class G4AssemblyVolume
27 //
28 // Class description:
29 //
30 // G4AssemblyVolume is a helper class to make the build process of geometry
31 // easier. It allows to combine several volumes together in an arbitrary way
32 // in 3D space and then work with the result as with a single logical volume
33 // for placement.
34 // The resulting objects are independent copies of each of the assembled
35 // logical volumes. The placements are not, however, bound one to each other
36 // when placement is done. They are seen as independent physical volumes in
37 // space.
38 
39 // Radovan Chytracek, John Apostolakis, Gabriele Cosmo: created - November 2000
40 // Ivana Hrivnacova: extended to support assembly of assemblies
41 // of volumes and reflections - March 2006
42 // ----------------------------------------------------------------------
43 #ifndef G4_ASSEMBLYVOLUME_H
44 #define G4_ASSEMBLYVOLUME_H
45 
46 #include <vector>
47 
48 #include "G4Transform3D.hh"
49 #include "G4AssemblyTriplet.hh"
50 
51 class G4VPhysicalVolume;
52 
54 {
55  public: // with description
56 
59  G4ThreeVector& translation,
60  G4RotationMatrix* rotation);
62  //
63  // Constructors & destructor.
64  // At destruction all the generated physical volumes and associated
65  // rotation matrices of the imprints will be destroyed.
66  //
67  // The rotation matrix passed as argument can be nullptr (identity) or an
68  // address even of an object on the upper stack frame. During assembly
69  // imprint, a new matrix is created anyway and it is kept track of it so
70  // it can be automatically deleted later at the end of the application.
71  // This policy is adopted since user has no control on the way the
72  // rotations are combined.
73 
74  void AddPlacedVolume( G4LogicalVolume* pPlacedVolume,
75  G4ThreeVector& translation,
76  G4RotationMatrix* rotation);
77  //
78  // Place the given volume 'pPlacedVolume' inside the assembly.
79  //
80  // The adopted approach:
81  //
82  // - Place it w.r.t. the assembly coordinate system.
83  // This step is applied to each of the participating volumes.
84  //
85  // The other possible approaches:
86  //
87  // - Place w.r.t. the firstly added volume.
88  // When placed the first, the virtual coordinate system becomes
89  // the coordinate system of the first one.
90  // Every next volume being added into the assembly will be placed
91  // w.r.t to the first one.
92  //
93  // - Place w.r.t the last placed volume.
94  // When placed the first, the virtual coordinate system becomes
95  // the coordinate system of the first one.
96  // Every next volume being added into the assembly will be placed
97  // w.r.t to the previous one.
98  //
99  // The rotation matrix passed as argument can be nullptr (identity) or an
100  // address even of an object on the upper stack frame. During assembly
101  // imprint, a new matrix is created anyway and it is kept track of it so
102  // it can be automatically deleted later at the end of the application.
103  // This policy is adopted since user has no control on the way the
104  // rotations are combined.
105 
106  void AddPlacedVolume( G4LogicalVolume* pPlacedVolume,
107  G4Transform3D& transformation);
108  //
109  // The same as previous, but takes complete 3D transformation in space
110  // as its argument.
111 
112  void AddPlacedAssembly( G4AssemblyVolume* pAssembly,
113  G4Transform3D& transformation);
114  //
115  // The same as previous AddPlacedVolume(), but takes an assembly volume
116  // as its argument.
117 
118  void AddPlacedAssembly( G4AssemblyVolume* pAssembly,
119  G4ThreeVector& translation,
120  G4RotationMatrix* rotation);
121  //
122  // The same as above AddPlacedVolume(), but takes an assembly volume
123  // as its argument with translation and rotation.
124 
125  void MakeImprint( G4LogicalVolume* pMotherLV,
126  G4ThreeVector& translationInMother,
127  G4RotationMatrix* pRotationInMother,
128  G4int copyNumBase = 0,
129  G4bool surfCheck = false );
130  //
131  // Creates instance of an assembly volume inside the given mother volume.
132 
133  void MakeImprint( G4LogicalVolume* pMotherLV,
134  G4Transform3D& transformation,
135  G4int copyNumBase = 0,
136  G4bool surfCheck = false );
137  //
138  // The same as previous Imprint() method, but takes complete 3D
139  // transformation in space as its argument.
140 
141  inline std::vector<G4VPhysicalVolume*>::iterator GetVolumesIterator();
142  inline std::size_t TotalImprintedVolumes() const;
143  //
144  // Methods to access the physical volumes imprinted with the assembly.
145  inline G4Transform3D& GetImprintTransformation(unsigned int imprintID);
146  // Method to access transformation for each imprint
147 
148  inline std::vector<G4AssemblyTriplet>::iterator GetTripletsIterator();
149  inline std::size_t TotalTriplets() const;
150  //
151  // Methods to access the triplets which are part of the assembly
152 
153  inline unsigned int GetImprintsCount() const;
154  //
155  // Return the number of made imprints.
156 
157  unsigned int GetInstanceCount() const;
158  //
159  // Return the number of existing instance of G4AssemblyVolume class.
160 
161  inline unsigned int GetAssemblyID() const;
162  //
163  // Return instance number of this concrete object.
164 
165  protected:
166 
167  inline void SetInstanceCount( unsigned int value );
168  inline void SetAssemblyID( unsigned int value );
169 
170  void InstanceCountPlus();
171  void InstanceCountMinus();
172 
173  inline void SetImprintsCount( unsigned int value );
174  inline void ImprintsCountPlus();
175  inline void ImprintsCountMinus();
176  //
177  // Internal counting mechanism, used to compute unique the names of
178  // physical volumes created by MakeImprint() methods.
179 
180  private:
181 
182  void MakeImprint( G4AssemblyVolume* pAssembly,
183  G4LogicalVolume* pMotherLV,
184  G4Transform3D& transformation,
185  G4int copyNumBase = 0,
186  G4bool surfCheck = false );
187  //
188  // Function for placement of the given assembly in the given mother
189  // (called recursively if the assembly contains an assembly).
190 
191  private:
192 
193  std::vector<G4AssemblyTriplet> fTriplets;
194  //
195  // Participating volumes represented as a vector of
196  // <logical volume, translation, rotation>.
197 
198  std::vector<G4VPhysicalVolume*> fPVStore;
199  //
200  // We need to keep list of physical volumes created by MakeImprint() method
201  // in order to be able to cleanup the objects when not needed anymore.
202  // This requires the user to keep assembly objects in memory during the
203  // whole job or during the life-time of G4Navigator, logical volume store
204  // and physical volume store keep pointers to physical volumes generated by
205  // the assembly volume.
206  // When an assembly object is about to die it will destroy all its
207  // generated physical volumes and rotation matrices as well !
208 
209  unsigned int fImprintsCounter;
210  //
211  // Number of imprints of the given assembly volume.
212 
213  static G4ThreadLocal unsigned int fsInstanceCounter;
214  //
215  // Class instance counter.
216 
217  unsigned int fAssemblyID = 0;
218  //
219  // Assembly object ID derived from instance counter at construction time.
220 
221  std::map<unsigned int, G4Transform3D> fImprintsTransf;
222  //
223  // Container of transformations for each imprint (used by GDML persistency)
224 };
225 
226 #include "G4AssemblyVolume.icc"
227 
228 #endif // G4_ASSEMBLYVOLUME_H