Geant4-11
G4ReflectionFactory.hh
Go to the documentation of this file.
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// G4ReflectionFactory
27//
28// Class description:
29//
30// Class providing functions for volumes placements with a general
31// transfomation that can contain reflection.
32// Reflection is then applied to a solid: a new G4ReflectedSolid
33// instance is created and is placed with a transformation containing
34// pure rotation and translation only.
35// The pair of constituent and reflected logical volumes is
36// considered as a generalized logical volume that is addressed
37// by user specifying the constituent logical volume.
38//
39// Decomposition of a general transformation that can include reflection
40// in a "reflection-free" transformation:
41//
42// x(inM') = TG*x(inM) TG - general transformation
43// = T*(R*x(inM)) T - "reflection-free" transformation
44// = T* x(inReflM)
45//
46// Daughters transformation:
47// When a volume V containing daughter D with transformation TD
48// is placed in mother M with a general tranformation TGV,
49// the TGV is decomposed. New reflected volume ReflV containing
50// a new daughter ReflD with reflected transformation ReflTD is created:
51//
52// x(inV) = TD * x(inD);
53// x(inM) = TGV * x(inV)
54// = TV * R * x(inV)
55// = TV * R * TD * x(inD)
56// = TV * R*TD*R-1 * R*x(inD)
57// = TV * ReflTD * x(inReflD)
58
59// Author: Ivana Hrivnacova (Ivana.Hrivnacova@cern.ch), 16.10.2001
60// --------------------------------------------------------------------
61#ifndef G4_REFLECTION_FACTORY_HH
62#define G4_REFLECTION_FACTORY_HH
63
64#include "G4Types.hh"
65#include "G4Transform3D.hh"
66#include "geomdefs.hh"
67
68#include <map>
69
71class G4LogicalVolume;
72class G4VSolid;
74
75using G4PhysicalVolumesPair = std::pair<G4VPhysicalVolume*, G4VPhysicalVolume*>;
77 std::less<G4LogicalVolume*> >;
79{
80 using LogicalVolumesMapIterator = G4ReflectedVolumesMap::const_iterator;
81
82 public: // with description
83
84 virtual ~G4ReflectionFactory();
85 // Virtual destructor.
86
88 // Gets pointer to the instance of the singleton.
89
90 G4PhysicalVolumesPair Place(const G4Transform3D& transform3D,
91 const G4String& name,
93 G4LogicalVolume* motherLV,
94 G4bool isMany,
95 G4int copyNo,
96 G4bool surfCheck = false);
97 // Evaluates the passed transformation; if it contains reflection
98 // it performs its decomposition, creates new reflected solid and
99 // logical volume (or retrieves them from a map if the reflected
100 // objects were already created), transforms the daughters (if present)
101 // and place it in the given mother.
102 // The result is a pair of physical volumes;
103 // the second physical volume is a placement in a reflected mother
104 // or 0 if mother LV was not reflected.
105
107 G4LogicalVolume* LV,
108 G4LogicalVolume* motherLV,
109 EAxis axis,
110 G4int nofReplicas,
111 G4double width,
112 G4double offset = 0.);
113 // Creates replica in the given mother.
114 // The result is a pair of physical volumes;
115 // the second physical volume is a replica in a reflected mother
116 // or 0 if mother LV was not reflected.
117
119 G4LogicalVolume* LV,
120 G4LogicalVolume* motherLV,
121 EAxis axis,
122 G4int nofDivisions,
123 G4double width,
124 G4double offset);
126 G4LogicalVolume* LV,
127 G4LogicalVolume* motherLV,
128 EAxis axis,
129 G4int nofDivisions,
130 G4double offset);
132 G4LogicalVolume* LV,
133 G4LogicalVolume* motherLV,
134 EAxis axis,
135 G4double width,
136 G4double offset);
137 // Creates division in the given mother.
138 // The result is a pair of physical volumes;
139 // the second physical volume is a division in a reflected mother
140 // or nullptr if mother LV was not reflected.
141
142 void SetVerboseLevel(G4int verboseLevel);
143 G4int GetVerboseLevel() const;
144 // Sets/gets verbosity level.
145
146 void SetVolumesNameExtension(const G4String& nameExtension);
147 const G4String& GetVolumesNameExtension() const;
148 // Returns the name extension for the reflected solids
149 // and logical volumes.
150
151 void SetScalePrecision(G4double scaleValue);
153 // Sets/gets precision factor for the scale consistency check
154 // The default value is set to 10*kCarTolerance.
155
157 // Returns the consituent volume of the given reflected volume,
158 // nullptr if the given reflected volume was not found.
159
161 // Returns the reflected volume of the given consituent volume,
162 // nullptr if the given volume was not reflected.
163
165 // Returns true if the given volume has been already reflected
166 // (is in the map of constituent volumes).
167
169 // Returns true if the given volume is a reflected volume
170 // (is in the map reflected volumes).
171
173 // Returns a handle to the internal map of volumes which have
174 // been reflected, after that placement or replication is performed.
175
176 void Clean();
177 // Clear maps of constituent and reflected volumes.
178 // To be used exclusively when volumes are removed from the stores.
179
182 // Disabled copy constructor and assignment operator.
183
184 protected:
185
187 // Protected singleton constructor.
188
189 private:
190
191 G4LogicalVolume* ReflectLV(G4LogicalVolume* LV, G4bool surfCheck = false);
192 // Gets/creates the reflected solid and logical volume
193 // and copies + transforms LV daughters.
194
196 // Creates the reflected solid and logical volume
197 // and add the logical volumes pair in the maps.
198
200 G4LogicalVolume* refLV, G4bool surfCheck = false);
201 // Reflects daughters recursively.
202
204 G4LogicalVolume* refLV, G4bool surfCheck = false);
205 // Copies and transforms daughter of PVPlacement type of
206 // a constituent volume into a reflected volume.
207
209 // Copies and transforms daughter of PVReplica type of
210 // a constituent volume into a reflected volume.
211
213 // Copies and transforms daughter of PVDivision type of
214 // a constituent volume into a reflected volume.
215
217 G4LogicalVolume* refLV, G4bool surfChk = false);
218 // Not implemented yet.
219 // Should copy and transform daughter of PVReplica type of
220 // a constituent volume into a reflected volume.
221
222 G4bool IsReflection(const G4Scale3D& scale) const;
223 // Returns true if the scale is negative, false otherwise.
224
225 void CheckScale(const G4Scale3D& scale) const;
226 // Checks if scale correspond to fScale, if not gives exception.
227
229 // Checks if the division factory is instanciated,
230 // if not gives exception.
231
232 void PrintConstituentLVMap();
233 // Temporary - for debugging purpose.
234
235 private:
236
239 static const G4Scale3D fScale;
241
246};
247
248#endif
std::pair< G4VPhysicalVolume *, G4VPhysicalVolume * > G4PhysicalVolumesPair
std::map< G4LogicalVolume *, G4LogicalVolume *, std::less< G4LogicalVolume * > > G4ReflectedVolumesMap
double G4double
Definition: G4Types.hh:83
bool G4bool
Definition: G4Types.hh:86
int G4int
Definition: G4Types.hh:85
G4LogicalVolume * ReflectLV(G4LogicalVolume *LV, G4bool surfCheck=false)
G4bool IsReflection(const G4Scale3D &scale) const
const G4String & GetVolumesNameExtension() const
G4bool IsReflected(G4LogicalVolume *lv) const
G4PhysicalVolumesPair Divide(const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, EAxis axis, G4int nofDivisions, G4double width, G4double offset)
G4LogicalVolume * GetReflectedLV(G4LogicalVolume *lv) const
static G4ReflectionFactory * Instance()
void SetVerboseLevel(G4int verboseLevel)
G4ReflectedVolumesMap::const_iterator LogicalVolumesMapIterator
void ReflectPVPlacement(G4VPhysicalVolume *PV, G4LogicalVolume *refLV, G4bool surfCheck=false)
G4double GetScalePrecision() const
G4VPVDivisionFactory * GetPVDivisionFactory() const
void CheckScale(const G4Scale3D &scale) const
G4PhysicalVolumesPair Place(const G4Transform3D &transform3D, const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, G4bool isMany, G4int copyNo, G4bool surfCheck=false)
static const G4Scale3D fScale
static G4ThreadLocal G4ReflectionFactory * fInstance
G4ReflectedVolumesMap fConstituentLVMap
G4ReflectionFactory(const G4ReflectionFactory &)=delete
G4bool IsConstituent(G4LogicalVolume *lv) const
G4ReflectionFactory & operator=(const G4ReflectionFactory &)=delete
void ReflectPVReplica(G4VPhysicalVolume *PV, G4LogicalVolume *refLV)
void SetScalePrecision(G4double scaleValue)
void ReflectDaughters(G4LogicalVolume *LV, G4LogicalVolume *refLV, G4bool surfCheck=false)
void ReflectPVParameterised(G4VPhysicalVolume *PV, G4LogicalVolume *refLV, G4bool surfChk=false)
void ReflectPVDivision(G4VPhysicalVolume *PV, G4LogicalVolume *refLV)
const G4ReflectedVolumesMap & GetReflectedVolumesMap() const
static const G4String fDefaultNameExtension
G4LogicalVolume * GetConstituentLV(G4LogicalVolume *reflLV) const
G4LogicalVolume * CreateReflectedLV(G4LogicalVolume *LV)
G4ReflectedVolumesMap fReflectedLVMap
G4PhysicalVolumesPair Replicate(const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, EAxis axis, G4int nofReplicas, G4double width, G4double offset=0.)
void SetVolumesNameExtension(const G4String &nameExtension)
EAxis
Definition: geomdefs.hh:54
const char * name(G4int ptype)
#define G4ThreadLocal
Definition: tls.hh:77