| Geant4 Cross Reference |
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 // ********************************************************************
>> 22 //
>> 23 //
>> 24 // $Id: G4PVParameterised.cc,v 1.2 2003/11/02 16:06:06 gcosmo Exp $
>> 25 // GEANT4 tag $Name: geant4-07-00-patch-01 $
>> 26 //
25 // 27 //
26 // class G4PVParameterised implementation << 28 // class G4PVParameterised
>> 29 //
>> 30 // Implementation
27 // 31 //
28 // 29.07.95, P.Kent - first non-stub version <<
29 // ------------------------------------------- 32 // ----------------------------------------------------------------------
30 33
31 #include "G4PVParameterised.hh" 34 #include "G4PVParameterised.hh"
32 #include "G4VPVParameterisation.hh" <<
33 #include "G4AffineTransform.hh" <<
34 #include "G4UnitsTable.hh" <<
35 #include "G4VSolid.hh" <<
36 #include "G4LogicalVolume.hh" <<
37 35
38 // ------------------------------------------- <<
39 // Constructor <<
40 // <<
41 G4PVParameterised::G4PVParameterised( const G4 36 G4PVParameterised::G4PVParameterised( const G4String& pName,
42 G4 37 G4LogicalVolume* pLogical,
43 G4 << 38 G4VPhysicalVolume* pMother,
44 const EA 39 const EAxis pAxis,
45 const G4 40 const G4int nReplicas,
46 G4 << 41 G4VPVParameterisation *pParam)
47 G4 << 42 : G4PVReplica(pName, pLogical, pMother, pAxis, nReplicas, 0, 0),
48 : G4PVReplica(pName, nReplicas, pAxis, pLogica <<
49 pMotherPhysical != nullptr ? pMo <<
50 fparam(pParam) 43 fparam(pParam)
51 { 44 {
52 G4LogicalVolume* motherLogical= pMotherPhysi <<
53 pMotherPhysical->GetLogicalVolume() : nu <<
54 <<
55 SetMotherLogical( motherLogical ); <<
56 if( motherLogical != nullptr ) <<
57 { <<
58 // Registration moved here to ensure that <<
59 motherLogical->AddDaughter(this); <<
60 } <<
61 <<
62 #ifdef G4VERBOSE 45 #ifdef G4VERBOSE
63 if ((pMotherPhysical != nullptr) && (pMother << 46 if ((pMother) && (pMother->IsParameterised()))
64 { 47 {
65 std::ostringstream message, hint; << 48 G4cout << "WARNING - G4PVParameterised::G4PVParameterised()" << G4endl
66 message << "A parameterised volume is bein << 49 << " A parameterised volume is being placed" << G4endl
67 << "inside another parameterised v << 50 << " inside another parameterised volume !" << G4endl
68 hint << "To make sure that no overlaps are << 51 << " To make sure that no overlaps are generated," << G4endl
69 << "you should verify the mother repl << 52 << " you should verify the mother replicated shapes" << G4endl
70 << "are of the same type and dimensio << 53 << " are of the same type and dimensions." << G4endl
71 << " Mother physical volume: " << p << 54 << " Mother physical volume: " << pMother->GetName() << G4endl
72 << " Parameterised volume: " << pNa << 55 << " Parameterised volume: " << pName << G4endl
73 << " (To switch this warning off, co << 56 << " (To switch this warning off, compile with G4_NO_VERBOSE)" << G4endl;
74 G4Exception("G4PVParameterised::G4PVParame <<
75 JustWarning, message, G4String <<
76 } 57 }
77 #endif 58 #endif
78 if (pSurfChk) { CheckOverlaps(); } <<
79 } 59 }
80 60
81 // ------------------------------------------- <<
82 // Constructor <<
83 // <<
84 G4PVParameterised::G4PVParameterised( const G4 61 G4PVParameterised::G4PVParameterised( const G4String& pName,
85 G4 62 G4LogicalVolume* pLogical,
86 G4 63 G4LogicalVolume* pMotherLogical,
87 const EA 64 const EAxis pAxis,
88 const G4 65 const G4int nReplicas,
89 G4 << 66 G4VPVParameterisation *pParam)
90 G4 << 67 : G4PVReplica(pName, pLogical, pMotherLogical, pAxis, nReplicas, 0, 0),
91 : G4PVReplica(pName, nReplicas, pAxis, pLogi <<
92 fparam(pParam) 68 fparam(pParam)
93 { 69 {
94 SetMotherLogical( pMotherLogical ); <<
95 if( pMotherLogical != nullptr ) <<
96 { <<
97 // Registration moved here to ensure that <<
98 pMotherLogical->AddDaughter(this); <<
99 } <<
100 if (pSurfChk) { CheckOverlaps(); } <<
101 } 70 }
102 71
103 // ------------------------------------------- << 72 G4PVParameterised::~G4PVParameterised()
104 // Fake default constructor - sets only member <<
105 // for usage restri <<
106 // <<
107 G4PVParameterised::G4PVParameterised( __void__ <<
108 : G4PVReplica(a) <<
109 { 73 {
110 } 74 }
111 75
112 // ------------------------------------------- <<
113 // Destructor <<
114 // <<
115 G4PVParameterised::~G4PVParameterised() = defa <<
116 <<
117 // ------------------------------------------- <<
118 // GetParameterisation <<
119 // <<
120 G4VPVParameterisation* G4PVParameterised::GetP 76 G4VPVParameterisation* G4PVParameterised::GetParameterisation() const
121 { 77 {
122 return fparam; 78 return fparam;
123 } 79 }
124 80
125 // ------------------------------------------- <<
126 // IsParameterised <<
127 // <<
128 G4bool G4PVParameterised::IsParameterised() co 81 G4bool G4PVParameterised::IsParameterised() const
129 { 82 {
130 return true; 83 return true;
131 } 84 }
132 85
133 // ------------------------------------------- <<
134 // VolumeType <<
135 // <<
136 EVolume G4PVParameterised::VolumeType() const <<
137 { <<
138 return kParameterised; <<
139 } <<
140 <<
141 // ------------------------------------------- <<
142 // GetReplicationData <<
143 // <<
144 void G4PVParameterised::GetReplicationData( EA 86 void G4PVParameterised::GetReplicationData( EAxis& axis,
145 G4 87 G4int& nReplicas,
146 G4 88 G4double& width,
147 G4 89 G4double& offset,
148 G4 90 G4bool& consuming) const
149 { 91 {
150 axis = faxis; 92 axis = faxis;
151 nReplicas = fnReplicas; 93 nReplicas = fnReplicas;
152 width = fwidth; 94 width = fwidth;
153 offset = foffset; 95 offset = foffset;
154 consuming = false; 96 consuming = false;
155 } <<
156 <<
157 // ------------------------------------------- <<
158 // SetRegularStructureId <<
159 // <<
160 void G4PVParameterised::SetRegularStructureId <<
161 { <<
162 G4PVReplica::SetRegularStructureId( code ); <<
163 // To undertake additional preparation, a de <<
164 // redefine this method, while calling also <<
165 } <<
166 <<
167 <<
168 // ------------------------------------------- <<
169 // CheckOverlaps <<
170 // <<
171 G4bool <<
172 G4PVParameterised::CheckOverlaps(G4int res, G4 <<
173 G4bool verbos <<
174 { <<
175 if (res<=0) { return false; } <<
176 <<
177 G4int trials = 0; <<
178 G4bool retval = false; <<
179 G4VSolid *solidA = nullptr, *solidB = nullpt <<
180 G4LogicalVolume* motherLog = GetMotherLogica <<
181 G4VSolid *motherSolid = motherLog->GetSolid( <<
182 std::vector<G4ThreeVector> points; <<
183 <<
184 if (verbose) <<
185 { <<
186 G4cout << "Checking overlaps for parameter <<
187 << GetName() << " ... "; <<
188 } <<
189 <<
190 for (auto i=0; i<GetMultiplicity(); ++i) <<
191 { <<
192 solidA = fparam->ComputeSolid(i, this); <<
193 solidA->ComputeDimensions(fparam, i, this) <<
194 fparam->ComputeTransformation(i, this); <<
195 <<
196 // Create the transformation from daughter <<
197 // <<
198 G4AffineTransform Tm( GetRotation(), GetTr <<
199 <<
200 // Generate random points on surface accor <<
201 // transform them to the mother's coordina <<
202 // with the mother volume, cache them in a <<
203 // the daughters <<
204 // <<
205 for (auto n=0; n<res; ++n) <<
206 { <<
207 G4ThreeVector mp = Tm.TransformPoint(sol <<
208 <<
209 // Checking overlaps with the mother vol <<
210 // <<
211 if (motherSolid->Inside(mp)==kOutside) <<
212 { <<
213 G4double distin = motherSolid->Distanc <<
214 if (distin > tol) <<
215 { <<
216 ++trials; retval = true; <<
217 std::ostringstream message; <<
218 message << "Overlap with mother volu <<
219 << " Overlap is dete <<
220 << GetName() << ", parameter <<
221 << " with its mothe <<
222 << motherLog->GetName() << G <<
223 << " at mother loca <<
224 << "overlapping by at least: <<
225 << G4BestUnit(distin, "Lengt <<
226 if (trials>=maxErr) <<
227 { <<
228 message << G4endl <<
229 << "NOTE: Reached maximum <<
230 << "- of overlaps reports <<
231 } <<
232 G4Exception("G4PVParameterised::Chec <<
233 "GeomVol1002", JustWarni <<
234 if (trials>=maxErr) { return true; <<
235 } <<
236 } <<
237 points.push_back(mp); <<
238 } <<
239 <<
240 // Checking overlaps with each other param <<
241 // <<
242 for (auto j=i+1; j<GetMultiplicity(); ++j) <<
243 { <<
244 solidB = fparam->ComputeSolid(j,this); <<
245 solidB->ComputeDimensions(fparam, j, thi <<
246 fparam->ComputeTransformation(j, this); <<
247 <<
248 // Create the transformation for daughte <<
249 // <<
250 G4AffineTransform Td( GetRotation(), Get <<
251 <<
252 for (const auto & point : points) <<
253 { <<
254 // Transform each point according to d <<
255 // <<
256 G4ThreeVector md = Td.InverseTransform <<
257 <<
258 if (solidB->Inside(md)==kInside) <<
259 { <<
260 G4double distout = solidB->DistanceT <<
261 if (distout > tol) <<
262 { <<
263 ++trials; retval = true; <<
264 std::ostringstream message; <<
265 message << "Overlap within paramet <<
266 << " Overlap is d <<
267 << GetName() << ", paramet <<
268 << " with paramet <<
269 << G4endl <<
270 << " at local poi <<
271 << "overlapping by at leas <<
272 << G4BestUnit(distout, "Le <<
273 << ", related to volume in <<
274 if (trials>=maxErr) <<
275 { <<
276 message << G4endl <<
277 << "NOTE: Reached maximu <<
278 << "- of overlaps report <<
279 } <<
280 G4Exception("G4PVParameterised::Ch <<
281 "GeomVol1002", JustWar <<
282 if (trials>=maxErr) { return true <<
283 } <<
284 } <<
285 } <<
286 } <<
287 } <<
288 if (verbose) <<
289 { <<
290 G4cout << "OK! " << G4endl; <<
291 } <<
292 <<
293 return retval; <<
294 } 97 }
295 98