| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // Implementation for G4UHype wrapper class 26 // Implementation for G4UHype wrapper class
27 // 27 //
28 // 16-10-2017 G.Cosmo, CERN 28 // 16-10-2017 G.Cosmo, CERN
29 // ------------------------------------------- 29 // --------------------------------------------------------------------
30 30
31 #include "G4Hype.hh" 31 #include "G4Hype.hh"
32 32
33 #include "G4UHype.hh" 33 #include "G4UHype.hh"
34 34
35 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G 35 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G4GEOM_USE_PARTIAL_USOLIDS) )
36 36
37 #include "G4AffineTransform.hh" 37 #include "G4AffineTransform.hh"
38 #include "G4VPVParameterisation.hh" 38 #include "G4VPVParameterisation.hh"
39 #include "G4BoundingEnvelope.hh" 39 #include "G4BoundingEnvelope.hh"
40 #include "G4Polyhedron.hh" 40 #include "G4Polyhedron.hh"
41 41
42 ////////////////////////////////////////////// 42 ////////////////////////////////////////////////////////////////////////
43 // 43 //
44 // Constructor 44 // Constructor
45 45
46 G4UHype::G4UHype(const G4String& pName, 46 G4UHype::G4UHype(const G4String& pName,
47 G4double newInnerRadiu 47 G4double newInnerRadius,
48 G4double newOuterRadiu 48 G4double newOuterRadius,
49 G4double newInnerStere 49 G4double newInnerStereo,
50 G4double newOuterStere 50 G4double newOuterStereo,
51 G4double newHalfLenZ) 51 G4double newHalfLenZ)
52 : Base_t(pName, newInnerRadius, newOuterRadi 52 : Base_t(pName, newInnerRadius, newOuterRadius,
53 newInnerStereo, newOuterSter 53 newInnerStereo, newOuterStereo, newHalfLenZ)
54 { } 54 { }
55 55
56 ////////////////////////////////////////////// 56 //////////////////////////////////////////////////////////////////////////
57 // 57 //
58 // Fake default constructor - sets only member 58 // Fake default constructor - sets only member data and allocates memory
59 // for usage restri 59 // for usage restricted to object persistency.
60 60
61 G4UHype::G4UHype( __void__& a ) 61 G4UHype::G4UHype( __void__& a )
62 : Base_t(a) 62 : Base_t(a)
63 { } 63 { }
64 64
65 ////////////////////////////////////////////// 65 //////////////////////////////////////////////////////////////////////////
66 // 66 //
67 // Destructor 67 // Destructor
68 68
69 G4UHype::~G4UHype() = default; 69 G4UHype::~G4UHype() = default;
70 70
71 ////////////////////////////////////////////// 71 //////////////////////////////////////////////////////////////////////////
72 // 72 //
73 // Copy constructor 73 // Copy constructor
74 74
75 G4UHype::G4UHype(const G4UHype& rhs) 75 G4UHype::G4UHype(const G4UHype& rhs)
76 : Base_t(rhs) 76 : Base_t(rhs)
77 { } 77 { }
78 78
79 ////////////////////////////////////////////// 79 //////////////////////////////////////////////////////////////////////////
80 // 80 //
81 // Assignment operator 81 // Assignment operator
82 82
83 G4UHype& G4UHype::operator = (const G4UHype& r 83 G4UHype& G4UHype::operator = (const G4UHype& rhs)
84 { 84 {
85 // Check assignment to self 85 // Check assignment to self
86 // 86 //
87 if (this == &rhs) { return *this; } 87 if (this == &rhs) { return *this; }
88 88
89 // Copy base class data 89 // Copy base class data
90 // 90 //
91 Base_t::operator=(rhs); 91 Base_t::operator=(rhs);
92 92
93 return *this; 93 return *this;
94 } 94 }
95 95
96 ////////////////////////////////////////////// 96 //////////////////////////////////////////////////////////////////////////
97 // 97 //
98 // Accessors 98 // Accessors
99 99
100 G4double G4UHype::GetInnerRadius () const 100 G4double G4UHype::GetInnerRadius () const
101 { 101 {
102 return GetRmin(); 102 return GetRmin();
103 } 103 }
104 104
105 G4double G4UHype::GetOuterRadius () const 105 G4double G4UHype::GetOuterRadius () const
106 { 106 {
107 return GetRmax(); 107 return GetRmax();
108 } 108 }
109 109
110 G4double G4UHype::GetZHalfLength () const 110 G4double G4UHype::GetZHalfLength () const
111 { 111 {
112 return GetDz(); 112 return GetDz();
113 } 113 }
114 114
115 G4double G4UHype::GetInnerStereo () const 115 G4double G4UHype::GetInnerStereo () const
116 { 116 {
117 return GetStIn(); 117 return GetStIn();
118 } 118 }
119 119
120 G4double G4UHype::GetOuterStereo () const 120 G4double G4UHype::GetOuterStereo () const
121 { 121 {
122 return GetStOut(); 122 return GetStOut();
123 } 123 }
124 124
125 ////////////////////////////////////////////// 125 //////////////////////////////////////////////////////////////////////////
126 // 126 //
127 // Modifiers 127 // Modifiers
128 128
129 void G4UHype::SetInnerRadius (G4double newIRad 129 void G4UHype::SetInnerRadius (G4double newIRad)
130 { 130 {
131 SetParameters(newIRad, GetRmax(), GetStIn(), 131 SetParameters(newIRad, GetRmax(), GetStIn(), GetStOut(), GetDz());
132 fRebuildPolyhedron = true; 132 fRebuildPolyhedron = true;
133 } 133 }
134 134
135 void G4UHype::SetOuterRadius (G4double newORad 135 void G4UHype::SetOuterRadius (G4double newORad)
136 { 136 {
137 SetParameters(GetRmin(), newORad, GetStIn(), 137 SetParameters(GetRmin(), newORad, GetStIn(), GetStOut(), GetDz());
138 fRebuildPolyhedron = true; 138 fRebuildPolyhedron = true;
139 } 139 }
140 140
141 void G4UHype::SetZHalfLength (G4double newHLZ) 141 void G4UHype::SetZHalfLength (G4double newHLZ)
142 { 142 {
143 SetParameters(GetRmin(), GetRmax(), GetStIn( 143 SetParameters(GetRmin(), GetRmax(), GetStIn(), GetStOut(), newHLZ);
144 fRebuildPolyhedron = true; 144 fRebuildPolyhedron = true;
145 } 145 }
146 146
147 void G4UHype::SetInnerStereo (G4double newISte 147 void G4UHype::SetInnerStereo (G4double newISte)
148 { 148 {
149 SetParameters(GetRmin(), GetRmax(), newISte, 149 SetParameters(GetRmin(), GetRmax(), newISte, GetStOut(), GetDz());
150 fRebuildPolyhedron = true; 150 fRebuildPolyhedron = true;
151 } 151 }
152 152
153 void G4UHype::SetOuterStereo (G4double newOSte 153 void G4UHype::SetOuterStereo (G4double newOSte)
154 { 154 {
155 SetParameters(GetRmin(), GetRmax(), GetStIn( 155 SetParameters(GetRmin(), GetRmax(), GetStIn(), newOSte, GetDz());
156 fRebuildPolyhedron = true; 156 fRebuildPolyhedron = true;
157 } 157 }
158 158
159 159
160 ////////////////////////////////////////////// 160 ////////////////////////////////////////////////////////////////////////
161 // 161 //
162 // Dispatch to parameterisation for replicatio 162 // Dispatch to parameterisation for replication mechanism dimension
163 // computation & modification. 163 // computation & modification.
164 164
165 void G4UHype::ComputeDimensions(G4VPVParameter 165 void G4UHype::ComputeDimensions(G4VPVParameterisation* p,
166 const G4int n, 166 const G4int n,
167 const G4VPhysi 167 const G4VPhysicalVolume* pRep)
168 { 168 {
169 p->ComputeDimensions(*(G4Hype*)this,n,pRep); 169 p->ComputeDimensions(*(G4Hype*)this,n,pRep);
170 } 170 }
171 171
172 172
173 ////////////////////////////////////////////// 173 //////////////////////////////////////////////////////////////////////////
174 // 174 //
175 // Make a clone of the object 175 // Make a clone of the object
176 176
177 G4VSolid* G4UHype::Clone() const 177 G4VSolid* G4UHype::Clone() const
178 { 178 {
179 return new G4UHype(*this); 179 return new G4UHype(*this);
180 } 180 }
181 181
182 ////////////////////////////////////////////// 182 //////////////////////////////////////////////////////////////////////////
183 // 183 //
184 // Get bounding box 184 // Get bounding box
185 185
186 void G4UHype::BoundingLimits(G4ThreeVector& pM 186 void G4UHype::BoundingLimits(G4ThreeVector& pMin,
187 G4ThreeVector& pM 187 G4ThreeVector& pMax) const
188 { 188 {
189 G4double endORadius = GetEndInnerRadius(); 189 G4double endORadius = GetEndInnerRadius();
190 pMin.set(-endORadius,-endORadius,-GetDz()); 190 pMin.set(-endORadius,-endORadius,-GetDz());
191 pMax.set( endORadius, endORadius, GetDz()); 191 pMax.set( endORadius, endORadius, GetDz());
192 192
193 // Check correctness of the bounding box 193 // Check correctness of the bounding box
194 // 194 //
195 if (pMin.x() >= pMax.x() || pMin.y() >= pMax 195 if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
196 { 196 {
197 std::ostringstream message; 197 std::ostringstream message;
198 message << "Bad bounding box (min >= max) 198 message << "Bad bounding box (min >= max) for solid: "
199 << GetName() << " !" 199 << GetName() << " !"
200 << "\npMin = " << pMin 200 << "\npMin = " << pMin
201 << "\npMax = " << pMax; 201 << "\npMax = " << pMax;
202 G4Exception("G4UHype::BoundingLimits()", " 202 G4Exception("G4UHype::BoundingLimits()", "GeomMgt0001",
203 JustWarning, message); 203 JustWarning, message);
204 StreamInfo(G4cout); 204 StreamInfo(G4cout);
205 } 205 }
206 } 206 }
207 207
208 ////////////////////////////////////////////// 208 //////////////////////////////////////////////////////////////////////////
209 // 209 //
210 // Calculate extent under transform and specif 210 // Calculate extent under transform and specified limit
211 211
212 G4bool 212 G4bool
213 G4UHype::CalculateExtent(const EAxis pAxis, 213 G4UHype::CalculateExtent(const EAxis pAxis,
214 const G4VoxelLimits& 214 const G4VoxelLimits& pVoxelLimit,
215 const G4AffineTransfo 215 const G4AffineTransform& pTransform,
216 G4double& pMin, 216 G4double& pMin, G4double& pMax) const
217 { 217 {
218 G4ThreeVector bmin, bmax; 218 G4ThreeVector bmin, bmax;
219 219
220 // Get bounding box 220 // Get bounding box
221 BoundingLimits(bmin,bmax); 221 BoundingLimits(bmin,bmax);
222 222
223 // Find extent 223 // Find extent
224 G4BoundingEnvelope bbox(bmin,bmax); 224 G4BoundingEnvelope bbox(bmin,bmax);
225 return bbox.CalculateExtent(pAxis,pVoxelLimi 225 return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
226 } 226 }
227 227
228 ////////////////////////////////////////////// 228 ////////////////////////////////////////////////////////////////////////
229 // 229 //
230 // CreatePolyhedron 230 // CreatePolyhedron
231 // 231 //
232 G4Polyhedron* G4UHype::CreatePolyhedron() cons 232 G4Polyhedron* G4UHype::CreatePolyhedron() const
233 { 233 {
234 return new G4PolyhedronHype(GetRmin(), GetRm 234 return new G4PolyhedronHype(GetRmin(), GetRmax(),
235 GetTIn2(), GetTO 235 GetTIn2(), GetTOut2(), GetDz());
236 } 236 }
237 237
238 #endif // G4GEOM_USE_USOLIDS 238 #endif // G4GEOM_USE_USOLIDS
239 239