| 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 G4UOrb wrapper class << 26 // $Id:$
27 // 27 //
28 // 30.10.13 G.Cosmo, CERN/PH << 28 //
>> 29 // Implementation for G4UOrb wrapper class
29 // ------------------------------------------- 30 // --------------------------------------------------------------------
30 31
31 #include "G4Orb.hh" 32 #include "G4Orb.hh"
32 #include "G4UOrb.hh" 33 #include "G4UOrb.hh"
33 <<
34 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G <<
35 <<
36 #include "G4TwoVector.hh" <<
37 #include "G4AffineTransform.hh" <<
38 #include "G4GeometryTolerance.hh" <<
39 #include "G4BoundingEnvelope.hh" <<
40 <<
41 #include "G4VPVParameterisation.hh" 34 #include "G4VPVParameterisation.hh"
42 #include "G4PhysicalConstants.hh" <<
43 <<
44 using namespace CLHEP; <<
45 35
46 ////////////////////////////////////////////// 36 ////////////////////////////////////////////////////////////////////////
47 // 37 //
48 // constructor - check positive radius 38 // constructor - check positive radius
49 // 39 //
50 40
51 G4UOrb::G4UOrb( const G4String& pName, G4doubl 41 G4UOrb::G4UOrb( const G4String& pName, G4double pRmax )
52 : Base_t(pName, pRmax) << 42 : G4USolid(pName, new UOrb(pName, pRmax))
53 { 43 {
54 } 44 }
55 45
56 ////////////////////////////////////////////// 46 ///////////////////////////////////////////////////////////////////////
57 // 47 //
58 // Fake default constructor - sets only member 48 // Fake default constructor - sets only member data and allocates memory
59 // for usage restri 49 // for usage restricted to object persistency.
60 // 50 //
61 G4UOrb::G4UOrb( __void__& a ) 51 G4UOrb::G4UOrb( __void__& a )
62 : Base_t(a) << 52 : G4USolid(a)
63 { 53 {
64 } 54 }
65 55
66 ////////////////////////////////////////////// 56 /////////////////////////////////////////////////////////////////////
67 // 57 //
68 // Destructor 58 // Destructor
69 59
70 G4UOrb::~G4UOrb() = default; << 60 G4UOrb::~G4UOrb()
>> 61 {
>> 62 }
71 63
72 ////////////////////////////////////////////// 64 //////////////////////////////////////////////////////////////////////////
73 // 65 //
74 // Copy constructor 66 // Copy constructor
75 67
76 G4UOrb::G4UOrb(const G4UOrb& rhs) 68 G4UOrb::G4UOrb(const G4UOrb& rhs)
77 : Base_t(rhs) << 69 : G4USolid(rhs)
78 { 70 {
79 } 71 }
80 72
81 ////////////////////////////////////////////// 73 //////////////////////////////////////////////////////////////////////////
82 // 74 //
83 // Assignment operator 75 // Assignment operator
84 76
85 G4UOrb& G4UOrb::operator = (const G4UOrb& rhs) 77 G4UOrb& G4UOrb::operator = (const G4UOrb& rhs)
86 { 78 {
87 // Check assignment to self 79 // Check assignment to self
88 // 80 //
89 if (this == &rhs) { return *this; } 81 if (this == &rhs) { return *this; }
90 82
91 // Copy base class data 83 // Copy base class data
92 // 84 //
93 Base_t::operator=(rhs); << 85 G4USolid::operator=(rhs);
94 86
95 return *this; 87 return *this;
96 } 88 }
97 89
98 ////////////////////////////////////////////// 90 //////////////////////////////////////////////////////////////////////////
99 // 91 //
100 // Accessors & modifiers <<
101 <<
102 G4double G4UOrb::GetRadius() const <<
103 { <<
104 return Base_t::GetRadius(); <<
105 } <<
106 <<
107 void G4UOrb::SetRadius(G4double newRmax) <<
108 { <<
109 Base_t::SetRadius(newRmax); <<
110 fRebuildPolyhedron = true; <<
111 } <<
112 <<
113 G4double G4UOrb::GetRadialTolerance() const <<
114 { <<
115 return Base_t::GetRadialTolerance(); <<
116 } <<
117 <<
118 ////////////////////////////////////////////// <<
119 // <<
120 // Dispatch to parameterisation for replicatio 92 // Dispatch to parameterisation for replication mechanism dimension
121 // computation & modification. 93 // computation & modification.
122 94
123 void G4UOrb::ComputeDimensions( G4VPVPar 95 void G4UOrb::ComputeDimensions( G4VPVParameterisation* p,
124 const G4int n, 96 const G4int n,
125 const G4VPhysic 97 const G4VPhysicalVolume* pRep )
126 { 98 {
127 p->ComputeDimensions(*(G4Orb*)this,n,pRep); 99 p->ComputeDimensions(*(G4Orb*)this,n,pRep);
128 } 100 }
129 101
130 ////////////////////////////////////////////// 102 //////////////////////////////////////////////////////////////////////////
131 // 103 //
132 // Make a clone of the object 104 // Make a clone of the object
133 105
134 G4VSolid* G4UOrb::Clone() const 106 G4VSolid* G4UOrb::Clone() const
135 { 107 {
136 return new G4UOrb(*this); 108 return new G4UOrb(*this);
137 } 109 }
138 <<
139 ////////////////////////////////////////////// <<
140 // <<
141 // Get bounding box <<
142 <<
143 void G4UOrb::BoundingLimits(G4ThreeVector& pMi <<
144 { <<
145 G4double radius = GetRadius(); <<
146 pMin.set(-radius,-radius,-radius); <<
147 pMax.set( radius, radius, radius); <<
148 <<
149 // Check correctness of the bounding box <<
150 // <<
151 if (pMin.x() >= pMax.x() || pMin.y() >= pMax <<
152 { <<
153 std::ostringstream message; <<
154 message << "Bad bounding box (min >= max) <<
155 << GetName() << " !" <<
156 << "\npMin = " << pMin <<
157 << "\npMax = " << pMax; <<
158 G4Exception("G4UOrb::BoundingLimits()", "G <<
159 JustWarning, message); <<
160 StreamInfo(G4cout); <<
161 } <<
162 } <<
163 <<
164 ////////////////////////////////////////////// <<
165 // <<
166 // Calculate extent under transform and specif <<
167 <<
168 G4bool <<
169 G4UOrb::CalculateExtent(const EAxis pAxis, <<
170 const G4VoxelLimits& p <<
171 const G4AffineTransfor <<
172 G4double& pMin, G4doub <<
173 { <<
174 G4ThreeVector bmin, bmax; <<
175 G4bool exist; <<
176 <<
177 // Get bounding box <<
178 BoundingLimits(bmin,bmax); <<
179 <<
180 // Check bounding box <<
181 G4BoundingEnvelope bbox(bmin,bmax); <<
182 #ifdef G4BBOX_EXTENT <<
183 if (true) return bbox.CalculateExtent(pAxis, <<
184 #endif <<
185 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVox <<
186 { <<
187 return exist = pMin < pMax; <<
188 } <<
189 <<
190 // Find bounding envelope and calculate exte <<
191 // <<
192 static const G4int NTHETA = 8; // number of <<
193 static const G4int NPHI = 16; // number of <<
194 static const G4double sinHalfTheta = std::si <<
195 static const G4double cosHalfTheta = std::co <<
196 static const G4double sinHalfPhi = std::si <<
197 static const G4double cosHalfPhi = std::co <<
198 static const G4double sinStepTheta = 2.*sinH <<
199 static const G4double cosStepTheta = 1. - 2. <<
200 static const G4double sinStepPhi = 2.*sinH <<
201 static const G4double cosStepPhi = 1. - 2. <<
202 <<
203 G4double radius = GetRadius(); <<
204 G4double rtheta = radius/cosHalfTheta; <<
205 G4double rphi = rtheta/cosHalfPhi; <<
206 <<
207 // set reference circle <<
208 G4TwoVector xy[NPHI]; <<
209 G4double sinCurPhi = sinHalfPhi; <<
210 G4double cosCurPhi = cosHalfPhi; <<
211 for (auto & k : xy) <<
212 { <<
213 k.set(cosCurPhi,sinCurPhi); <<
214 G4double sinTmpPhi = sinCurPhi; <<
215 sinCurPhi = sinCurPhi*cosStepPhi + cosCurP <<
216 cosCurPhi = cosCurPhi*cosStepPhi - sinTmpP <<
217 } <<
218 <<
219 // set bounding circles <<
220 G4ThreeVectorList circles[NTHETA]; <<
221 for (auto & circle : circles) circle.resize( <<
222 <<
223 G4double sinCurTheta = sinHalfTheta; <<
224 G4double cosCurTheta = cosHalfTheta; <<
225 for (auto & circle : circles) <<
226 { <<
227 G4double z = rtheta*cosCurTheta; <<
228 G4double rho = rphi*sinCurTheta; <<
229 for (G4int k=0; k<NPHI; ++k) <<
230 { <<
231 circle[k].set(rho*xy[k].x(),rho*xy[k].y( <<
232 } <<
233 G4double sinTmpTheta = sinCurTheta; <<
234 sinCurTheta = sinCurTheta*cosStepTheta + c <<
235 cosCurTheta = cosCurTheta*cosStepTheta - s <<
236 } <<
237 <<
238 // set envelope and calculate extent <<
239 std::vector<const G4ThreeVectorList *> polyg <<
240 polygons.resize(NTHETA); <<
241 for (G4int i=0; i<NTHETA; ++i) polygons[i] = <<
242 <<
243 G4BoundingEnvelope benv(bmin,bmax,polygons); <<
244 exist = benv.CalculateExtent(pAxis,pVoxelLim <<
245 return exist; <<
246 } <<
247 <<
248 ////////////////////////////////////////////// <<
249 // <<
250 // Create polyhedron for visualization <<
251 <<
252 G4Polyhedron* G4UOrb::CreatePolyhedron() const <<
253 { <<
254 return new G4PolyhedronSphere(0., GetRadius( <<
255 } <<
256 <<
257 #endif // G4GEOM_USE_USOLIDS <<
258 110