source: trunk/source/geometry/navigation/test/testG4Navigator5.cc@ 1326

Last change on this file since 1326 was 1316, checked in by garnier, 15 years ago

update geant4-09-04-beta-cand-01 interfaces-V09-03-09 vis-V09-03-08
File size: 17.6 KB
Line 
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//
27// $Id: testG4Navigator5.cc,v 1.6 2006/06/29 18:37:26 gunter Exp $
28// GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
29//
30//
31// Locate & Step within replicated geometry (without full voxels)
32// consisting of tubes (replicated in r,phi...) P.Kent August 96
33
34#include <assert.h>
35#include "ApproxEqual.hh"
36
37// Global defs
38#include "globals.hh"
39
40#include "G4Navigator.hh"
41
42#include "G4LogicalVolume.hh"
43#include "G4VPhysicalVolume.hh"
44#include "G4PVPlacement.hh"
45#include "G4PVReplica.hh"
46#include "G4Box.hh"
47#include "G4Tubs.hh"
48
49#include "G4GeometryManager.hh"
50
51#include "G4RotationMatrix.hh"
52#include "G4ThreeVector.hh"
53
54G4VPhysicalVolume* BuildGeometry()
55{
56
57 G4Box *worldBox= new G4Box ("cube",50,50,50);
58 G4Tubs *fullTube= new G4Tubs("tube",0,10,10,0,2*pi);
59 G4Tubs *fullTubeSlice= new G4Tubs("tube slice",0,2,10,0,2*pi);
60
61 G4Tubs *hollowTube= new G4Tubs("hollow tube",2,8,10,0,2*pi);
62 G4Tubs *hollowTubeSlice= new G4Tubs("hollow tube slice",2,4,10,0,2*pi);
63
64 G4Tubs *hphiTube= new G4Tubs("phi tube",2,8,10,-pi*0.5,pi);
65 G4Tubs *hphiTubeSlice= new G4Tubs("phi tube slice",2,8,10,0,pi*0.25);
66
67
68 G4Tubs *allTube= new G4Tubs("all tube",2,10,10,0,2*pi);
69 G4Tubs *allTubeZSlice= new G4Tubs("all tube z slice",2,10,2,0,2*pi);
70 G4Tubs *allTubeZRSlice=new G4Tubs("all tube zr slice",2,6,2,0,2*pi);
71 G4Tubs *allTubeZRPSlice=new G4Tubs("all tube zrp slice",2,6,
72 2,-pi*0.25,pi*0.5);
73
74
75 G4LogicalVolume *worldLog=new G4LogicalVolume(worldBox,0,
76 "World",0,0,0);
77 // Logical with no field,sensitive detector or user limits
78
79 G4PVPlacement *worldPhys=new G4PVPlacement(0,G4ThreeVector(0,0,0),
80 "World",worldLog,
81 0,false,0);
82 // Note: no mother pointer set
83
84
85 // Full (solid) Tube containing r replicas
86 G4LogicalVolume *fullTubeLog=new G4LogicalVolume(fullTube,
87 0,
88 "Container",
89 0,0,0);
90 G4PVPlacement *fullTubePhys=new G4PVPlacement(0,G4ThreeVector(0,0,35),
91 "Container",
92 fullTubeLog,
93 worldPhys,false,0);
94 G4LogicalVolume *fullTubeSliceLog=new G4LogicalVolume(fullTubeSlice,
95 0,
96 "Slice",
97 0,0,0);
98// G4PVReplica *fullTubeSlicePhys=
99 new G4PVReplica("TubeSlice",
100 fullTubeSliceLog,fullTubePhys,
101 kRho,5,2,0);
102
103
104 // hollow Tube containing r replicas
105 G4LogicalVolume *hollowTubeLog=new G4LogicalVolume(hollowTube,
106 0,
107 "Container",
108 0,0,0);
109 G4PVPlacement *hollowTubePhys=new G4PVPlacement(0,G4ThreeVector(0,0,-35),
110 "Container",
111 hollowTubeLog,
112 worldPhys,false,0);
113
114 G4LogicalVolume *hollowTubeSliceLog=new G4LogicalVolume(hollowTubeSlice,
115 0,
116 "Slice",
117 0,0,0);
118// G4PVReplica *hollowTubeSlicePhys=
119 new G4PVReplica("HollowTubeSlice",
120 hollowTubeSliceLog,hollowTubePhys,
121 kRho,3,2,2);
122
123
124 // Hollow Tube containing phi replicas
125 G4LogicalVolume *hphiTubeLog=new G4LogicalVolume(hphiTube,
126 0,
127 "Container",
128 0,0,0);
129 G4PVPlacement *hphiTubePhys=new G4PVPlacement(0,G4ThreeVector(35,0,0),
130 "Container",
131 hphiTubeLog,
132 worldPhys,false,0);
133
134 G4LogicalVolume *hphiTubeSliceLog=new G4LogicalVolume(hphiTubeSlice,
135 0,
136 "Slice",
137 0,0,0);
138// G4PVReplica *hphiTubeSlicePhys=
139 new G4PVReplica("hphiTubeSlice",
140 hphiTubeSliceLog,hphiTubePhys,
141 kPhi,4,pi*0.25,-pi*0.5);
142
143 // Tube replicated along z, then r then phi (!)
144
145 G4LogicalVolume *allTubeLog=new G4LogicalVolume(allTube,
146 0,
147 "Container",
148 0,0,0);
149 G4PVPlacement *allTubePhys=new G4PVPlacement(0,G4ThreeVector(0,35,0),
150 "Container",
151 allTubeLog,
152 worldPhys,false,0);
153
154 G4LogicalVolume *allTubeZSliceLog=new G4LogicalVolume(allTubeZSlice,
155 0,
156 "Slice",
157 0,0,0);
158 G4PVReplica *allTubeZSlicePhys=new G4PVReplica("allTubeZSlice",
159 allTubeZSliceLog,
160 allTubePhys,
161 kZAxis,5,4);
162
163 G4LogicalVolume *allTubeZRSliceLog=new G4LogicalVolume(allTubeZRSlice,
164 0,
165 "Slice",
166 0,0,0);
167 G4PVReplica *allTubeZRSlicePhys=new G4PVReplica("allTubeZRSlice",
168 allTubeZRSliceLog,
169 allTubeZSlicePhys,
170 kRho,2,4,2);
171
172 G4LogicalVolume *allTubeZRPSliceLog=new G4LogicalVolume(allTubeZRPSlice,
173 0,
174 "Slice",
175 0,0,0);
176// G4PVReplica *allTubeZRPSlicePhys=
177 new G4PVReplica("allTubeZRPSlice",
178 allTubeZRPSliceLog,
179 allTubeZRSlicePhys,
180 kPhi,4,pi*0.5,-pi*0.25);
181
182
183 return worldPhys;
184}
185
186
187//
188// Test LocateGlobalPointAndSetup
189//
190G4bool testG4NavigatorLocate(G4VPhysicalVolume *pTopNode)
191{
192 MyNavigator myNav;
193 G4VPhysicalVolume *located;
194 myNav.SetWorldVolume(pTopNode);
195
196 assert(!myNav.LocateGlobalPointAndSetup(G4ThreeVector(kInfinity,0,0),0,false));
197 located=myNav.LocateGlobalPointAndSetup(G4ThreeVector(50,50,50),0,false);
198 assert(located->GetName()=="World");
199 located=myNav.LocateGlobalPointAndSetup(G4ThreeVector(0,0,35),0,false);
200 assert(located->GetName()=="TubeSlice");
201 assert(ApproxEqual(myNav.CurrentLocalCoordinate(),
202 G4ThreeVector(0,0,0)));
203 located=myNav.LocateGlobalPointAndSetup(G4ThreeVector(0,0,-35),0,false);
204 assert(located->GetName()=="World");
205 located=myNav.LocateGlobalPointAndSetup(G4ThreeVector(4,0,-35),0,false);
206 assert(located->GetName()=="HollowTubeSlice");
207 assert(ApproxEqual(myNav.CurrentLocalCoordinate(),
208 G4ThreeVector(4,0,0)));
209 located=myNav.LocateGlobalPointAndSetup(G4ThreeVector(37,0.5,0),0,false);
210 assert(located->GetName()=="hphiTubeSlice");
211
212 located=myNav.LocateGlobalPointAndSetup(G4ThreeVector(3,35,0),0,false);
213 assert(located->GetName()=="allTubeZRPSlice");
214 assert(ApproxEqual(myNav.CurrentLocalCoordinate(),
215 G4ThreeVector(3,0,0)));
216
217 return true;
218}
219
220//
221// Test ComputeStep
222//
223G4bool testG4NavigatorSteps(G4VPhysicalVolume *pTopNode)
224{
225 MyNavigator myNav;
226 G4VPhysicalVolume *located;
227 G4double Step,physStep,safety;
228 G4ThreeVector pos,dir,origin,xHat(1,0,0),yHat(0,1,0),zHat(0,0,1);
229 G4ThreeVector mxHat(-1,0,0),myHat(0,-1,0),mzHat(0,0,-1);
230 myNav.SetWorldVolume(pTopNode);
231
232 pos=G4ThreeVector(0,0,49);
233 dir=mzHat;
234 physStep=kInfinity;
235 located=myNav.LocateGlobalPointAndSetup(pos);
236 assert(located->GetName()=="World");
237 Step=myNav.ComputeStep(pos,dir,physStep,safety);
238 assert(ApproxEqual(Step,4));
239 assert(ApproxEqual(safety,1));
240 pos+=Step*dir;
241 myNav.SetGeometricallyLimitedStep();
242 located=myNav.LocateGlobalPointAndSetup(pos);
243 assert(located->GetName()=="TubeSlice");
244 Step=myNav.ComputeStep(pos,dir,physStep,safety);
245 assert(ApproxEqual(Step,20));
246 assert(safety==0);
247 Step=10;
248 pos+=Step*dir;
249 located=myNav.LocateGlobalPointAndSetup(pos);
250 assert(located->GetName()=="TubeSlice");
251 Step=myNav.ComputeStep(pos,dir,physStep,safety);
252 assert(ApproxEqual(Step,10));
253 assert(ApproxEqual(safety,2));
254
255 pos=G4ThreeVector(-10,-10,35);
256 dir=(xHat+yHat).unit();
257 physStep=kInfinity;
258 located=myNav.LocateGlobalPointAndSetup(pos);
259 assert(located->GetName()=="World");
260 Step=myNav.ComputeStep(pos,dir,physStep,safety);
261 assert(ApproxEqual(Step,std::sqrt(200.)-10.));
262 assert(ApproxEqual(safety,std::sqrt(200.)-10.));
263 pos+=Step*dir;
264 myNav.SetGeometricallyLimitedStep();
265 located=myNav.LocateGlobalPointAndSetup(pos);
266 assert(located->GetName()=="TubeSlice");
267 Step=myNav.ComputeStep(pos,dir,physStep,safety);
268 assert(ApproxEqual(Step,2));
269 assert(ApproxEqual(safety,0));
270 pos+=Step*dir;
271 myNav.SetGeometricallyLimitedStep();
272 located=myNav.LocateGlobalPointAndSetup(pos);
273 assert(located->GetName()=="TubeSlice");
274 Step=myNav.ComputeStep(pos,dir,physStep,safety);
275 assert(ApproxEqual(Step,2));
276 assert(ApproxEqual(safety,0));
277 pos+=Step*dir;
278 myNav.SetGeometricallyLimitedStep();
279 located=myNav.LocateGlobalPointAndSetup(pos);
280 assert(located->GetName()=="TubeSlice");
281 Step=myNav.ComputeStep(pos,dir,physStep,safety);
282 assert(ApproxEqual(Step,2));
283 assert(ApproxEqual(safety,0));
284 pos+=Step*dir;
285 myNav.SetGeometricallyLimitedStep();
286 located=myNav.LocateGlobalPointAndSetup(pos);
287 assert(located->GetName()=="TubeSlice");
288 Step=myNav.ComputeStep(pos,dir,physStep,safety);
289 assert(ApproxEqual(Step,2));
290 assert(ApproxEqual(safety,0));
291 pos+=Step*dir;
292 myNav.SetGeometricallyLimitedStep();
293 located=myNav.LocateGlobalPointAndSetup(pos);
294 assert(located->GetName()=="TubeSlice");
295 Step=myNav.ComputeStep(pos,dir,physStep,safety);
296 assert(ApproxEqual(Step,4));
297 assert(ApproxEqual(safety,0));
298 pos+=Step*dir;
299 myNav.SetGeometricallyLimitedStep();
300 located=myNav.LocateGlobalPointAndSetup(pos);
301 assert(located->GetName()=="TubeSlice");
302 Step=myNav.ComputeStep(pos,dir,physStep,safety);
303 assert(ApproxEqual(Step,2));
304 assert(ApproxEqual(safety,0));
305 pos+=Step*dir;
306 myNav.SetGeometricallyLimitedStep();
307 located=myNav.LocateGlobalPointAndSetup(pos);
308 assert(located->GetName()=="TubeSlice");
309 Step=myNav.ComputeStep(pos,dir,physStep,safety);
310 assert(ApproxEqual(Step,2));
311 assert(ApproxEqual(safety,0));
312 pos+=Step*dir;
313 myNav.SetGeometricallyLimitedStep();
314 located=myNav.LocateGlobalPointAndSetup(pos);
315 assert(located->GetName()=="TubeSlice");
316 Step=myNav.ComputeStep(pos,dir,physStep,safety);
317 assert(ApproxEqual(Step,2));
318 assert(ApproxEqual(safety,0));
319 pos+=Step*dir;
320 myNav.SetGeometricallyLimitedStep();
321 located=myNav.LocateGlobalPointAndSetup(pos);
322 assert(located->GetName()=="TubeSlice");
323 Step=myNav.ComputeStep(pos,dir,physStep,safety);
324 assert(ApproxEqual(Step,2));
325 assert(ApproxEqual(safety,0));
326 pos+=Step*dir;
327 myNav.SetGeometricallyLimitedStep();
328 located=myNav.LocateGlobalPointAndSetup(pos);
329 assert(located->GetName()=="World");
330
331
332
333 pos=G4ThreeVector(10,10,-35);
334 dir=(mxHat+myHat).unit();
335 physStep=kInfinity;
336 located=myNav.LocateGlobalPointAndSetup(pos);
337 assert(located->GetName()=="World");
338 Step=myNav.ComputeStep(pos,dir,physStep,safety);
339 assert(ApproxEqual(Step,std::sqrt(200.)-8.));
340 assert(ApproxEqual(safety,std::sqrt(200.)-8.));
341 pos+=Step*dir;
342 myNav.SetGeometricallyLimitedStep();
343 located=myNav.LocateGlobalPointAndSetup(pos);
344 assert(located->GetName()=="HollowTubeSlice");
345 Step=myNav.ComputeStep(pos,dir,physStep,safety);
346 assert(ApproxEqual(Step,2));
347 assert(ApproxEqual(safety,0));
348 pos+=Step*dir;
349 myNav.SetGeometricallyLimitedStep();
350 located=myNav.LocateGlobalPointAndSetup(pos);
351 assert(located->GetName()=="HollowTubeSlice");
352 Step=myNav.ComputeStep(pos,dir,physStep,safety);
353 assert(ApproxEqual(Step,2));
354 assert(ApproxEqual(safety,0));
355 pos+=Step*dir;
356 myNav.SetGeometricallyLimitedStep();
357 located=myNav.LocateGlobalPointAndSetup(pos);
358 assert(located->GetName()=="HollowTubeSlice");
359 Step=myNav.ComputeStep(pos,dir,physStep,safety);
360 assert(ApproxEqual(Step,2));
361 assert(ApproxEqual(safety,0));
362 pos+=Step*dir;
363 myNav.SetGeometricallyLimitedStep();
364 located=myNav.LocateGlobalPointAndSetup(pos);
365 assert(located->GetName()=="World");
366 Step=myNav.ComputeStep(pos,dir,physStep,safety);
367 assert(ApproxEqual(Step,4));
368 assert(ApproxEqual(safety,0));
369 pos+=Step*dir;
370 myNav.SetGeometricallyLimitedStep();
371 located=myNav.LocateGlobalPointAndSetup(pos);
372 assert(located->GetName()=="HollowTubeSlice");
373 Step=myNav.ComputeStep(pos,dir,physStep,safety);
374 assert(ApproxEqual(Step,2));
375 assert(ApproxEqual(safety,0));
376 pos+=Step*dir;
377 myNav.SetGeometricallyLimitedStep();
378 located=myNav.LocateGlobalPointAndSetup(pos);
379 assert(located->GetName()=="HollowTubeSlice");
380 Step=myNav.ComputeStep(pos,dir,physStep,safety);
381 assert(ApproxEqual(Step,2));
382 assert(ApproxEqual(safety,0));
383 pos+=Step*dir;
384 myNav.SetGeometricallyLimitedStep();
385 located=myNav.LocateGlobalPointAndSetup(pos);
386 assert(located->GetName()=="HollowTubeSlice");
387 Step=myNav.ComputeStep(pos,dir,physStep,safety);
388 assert(ApproxEqual(Step,2));
389 assert(ApproxEqual(safety,0));
390 pos+=Step*dir;
391 myNav.SetGeometricallyLimitedStep();
392 located=myNav.LocateGlobalPointAndSetup(pos);
393 assert(located->GetName()=="World");
394
395
396
397 pos=G4ThreeVector(39,-10,0);
398 dir=yHat;
399 physStep=kInfinity;
400 located=myNav.LocateGlobalPointAndSetup(pos);
401 assert(located->GetName()=="World");
402 Step=myNav.ComputeStep(pos,dir,physStep,safety);
403 assert(ApproxEqual(Step,10.-std::sqrt(48.)));
404 assert(ApproxEqual(safety,std::sqrt(116.)-8.));
405 pos+=Step*dir;
406 myNav.SetGeometricallyLimitedStep();
407 located=myNav.LocateGlobalPointAndSetup(pos);
408 assert(located->GetName()=="hphiTubeSlice");
409 Step=myNav.ComputeStep(pos,dir,physStep,safety);
410 assert(ApproxEqual(Step,std::sqrt(48.)-4.));
411 assert(ApproxEqual(safety,0));
412 pos+=Step*dir;
413 myNav.SetGeometricallyLimitedStep();
414 located=myNav.LocateGlobalPointAndSetup(pos);
415 assert(located->GetName()=="hphiTubeSlice");
416 Step=myNav.ComputeStep(pos,dir,physStep,safety);
417 assert(ApproxEqual(Step,4));
418 assert(ApproxEqual(safety,0));
419 pos+=Step*dir;
420 myNav.SetGeometricallyLimitedStep();
421 located=myNav.LocateGlobalPointAndSetup(pos);
422 assert(located->GetName()=="hphiTubeSlice");
423 Step=myNav.ComputeStep(pos,dir,physStep,safety);
424 assert(ApproxEqual(Step,4));
425 assert(ApproxEqual(safety,0));
426 pos+=Step*dir;
427 myNav.SetGeometricallyLimitedStep();
428 located=myNav.LocateGlobalPointAndSetup(pos);
429 assert(located->GetName()=="hphiTubeSlice");
430 Step=myNav.ComputeStep(pos,dir,physStep,safety);
431 assert(ApproxEqual(Step,std::sqrt(48.)-4.));
432 assert(ApproxEqual(safety,0));
433 pos+=Step*dir;
434 myNav.SetGeometricallyLimitedStep();
435 located=myNav.LocateGlobalPointAndSetup(pos);
436 assert(located->GetName()=="World");
437
438
439 pos=G4ThreeVector(12,35,0);
440 dir=mxHat;
441 physStep=kInfinity;
442 located=myNav.LocateGlobalPointAndSetup(pos);
443 assert(located->GetName()=="World");
444 Step=myNav.ComputeStep(pos,dir,physStep,safety);
445 assert(ApproxEqual(Step,2));
446 assert(ApproxEqual(safety,2));
447 pos+=Step*dir;
448 myNav.SetGeometricallyLimitedStep();
449 located=myNav.LocateGlobalPointAndSetup(pos);
450 assert(located->GetName()=="allTubeZRPSlice");
451 Step=myNav.ComputeStep(pos,dir,physStep,safety);
452 assert(ApproxEqual(Step,4));
453 assert(ApproxEqual(safety,0));
454 pos+=Step*dir;
455 myNav.SetGeometricallyLimitedStep();
456 located=myNav.LocateGlobalPointAndSetup(pos);
457 assert(located->GetName()=="allTubeZRPSlice");
458 Step=myNav.ComputeStep(pos,dir,physStep,safety);
459 assert(ApproxEqual(Step,4));
460 assert(ApproxEqual(safety,0));
461 Step=2;
462 pos+=Step*dir;
463 located=myNav.LocateGlobalPointAndSetup(pos);
464 assert(located->GetName()=="allTubeZRPSlice");
465 dir=zHat;
466 Step=myNav.ComputeStep(pos,dir,physStep,safety);
467 assert(ApproxEqual(Step,2));
468 assert(ApproxEqual(safety,2));
469 pos+=Step*dir;
470 myNav.SetGeometricallyLimitedStep();
471 located=myNav.LocateGlobalPointAndSetup(pos);
472 assert(located->GetName()=="allTubeZRPSlice");
473 Step=myNav.ComputeStep(pos,dir,physStep,safety);
474 assert(ApproxEqual(Step,4));
475 assert(ApproxEqual(safety,0));
476 pos+=Step*dir;
477 myNav.SetGeometricallyLimitedStep();
478 located=myNav.LocateGlobalPointAndSetup(pos);
479 assert(located->GetName()=="allTubeZRPSlice");
480 Step=myNav.ComputeStep(pos,dir,physStep,safety);
481 assert(ApproxEqual(Step,4));
482 assert(ApproxEqual(safety,0));
483 pos+=Step*dir;
484 myNav.SetGeometricallyLimitedStep();
485 located=myNav.LocateGlobalPointAndSetup(pos);
486 assert(located->GetName()=="World");
487
488 return true;
489}
490
491int main()
492{
493 G4VPhysicalVolume *myTopNode;
494 myTopNode=BuildGeometry(); // Build the geometry
495 G4GeometryManager::GetInstance()->CloseGeometry(false);
496 testG4NavigatorLocate(myTopNode);
497 testG4NavigatorSteps(myTopNode);
498
499 G4GeometryManager::GetInstance()->OpenGeometry();
500 return 0;
501}
Note: See TracBrowser for help on using the repository browser.