| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // 7 //
26 // Implementation of G4EnclosingCylinder, a ut << 8 // $Id: G4EnclosingCylinder.cc,v 1.2 2000/11/02 16:54:50 gcosmo Exp $
27 // for a quick check of geometry. << 9 // GEANT4 tag $Name: geant4-03-01 $
>> 10 //
>> 11 //
>> 12 // --------------------------------------------------------------------
>> 13 // GEANT 4 class source file
>> 14 //
>> 15 //
>> 16 // G4EnclosingCylinder.cc
>> 17 //
>> 18 // Implementation of a utility class for a quick check of geometry.
28 // 19 //
29 // Author: David C. Williams (davidw@scipp.ucs <<
30 // ------------------------------------------- 20 // --------------------------------------------------------------------
31 21
32 #include "G4EnclosingCylinder.hh" 22 #include "G4EnclosingCylinder.hh"
33 #include "G4PhysicalConstants.hh" <<
34 #include "G4ReduciblePolygon.hh" 23 #include "G4ReduciblePolygon.hh"
35 #include "G4GeometryTolerance.hh" <<
36 24
>> 25 //
37 // Constructor 26 // Constructor
38 // 27 //
39 G4EnclosingCylinder::G4EnclosingCylinder( cons << 28 G4EnclosingCylinder::G4EnclosingCylinder( const G4ReduciblePolygon *rz,
40 << 29 G4bool thePhiIsOpen,
41 << 30 G4double theStartPhi,
42 << 31 G4double theTotalPhi )
43 : startPhi(theStartPhi), totalPhi(theTotalPh <<
44 concave(theTotalPhi > pi) <<
45 { 32 {
46 // << 33 //
47 // Obtain largest r and smallest and largest << 34 // Obtain largest r and smallest and largest z
48 // << 35 //
49 radius = rz->Amax(); << 36 radius = rz->Amax();
50 zHi = rz->Bmax(); << 37 zHi = rz->Bmax();
51 zLo = rz->Bmin(); << 38 zLo = rz->Bmin();
52 << 39
53 G4double kCarTolerance = G4GeometryTolerance << 40 //
54 ->GetSurfaceToleran << 41 // Save phi info
55 // << 42 //
56 // Save phi info << 43 phiIsOpen = thePhiIsOpen;
57 // << 44 if ( phiIsOpen )
58 phiIsOpen = thePhiIsOpen; << 45 {
59 if ( phiIsOpen ) << 46 startPhi = theStartPhi;
60 { << 47 totalPhi = theTotalPhi;
61 rx1 = std::cos(startPhi); << 48
62 ry1 = std::sin(startPhi); << 49 rx1 = cos(startPhi);
63 dx1 = +ry1*10*kCarTolerance; << 50 ry1 = sin(startPhi);
64 dy1 = -rx1*10*kCarTolerance; << 51 dx1 = +ry1*10*kCarTolerance;
65 << 52 dy1 = -rx1*10*kCarTolerance;
66 rx2 = std::cos(startPhi+totalPhi); << 53
67 ry2 = std::sin(startPhi+totalPhi); << 54 rx2 = cos(startPhi+totalPhi);
68 dx2 = -ry2*10*kCarTolerance; << 55 ry2 = sin(startPhi+totalPhi);
69 dy2 = +rx2*10*kCarTolerance; << 56 dx2 = -ry2*10*kCarTolerance;
70 } << 57 dy2 = +rx2*10*kCarTolerance;
71 << 58
72 // << 59 concave = totalPhi > M_PI;
73 // Add safety << 60 }
74 // << 61
75 radius += 10*kCarTolerance; << 62 //
76 zLo -= 10*kCarTolerance; << 63 // Add safety
77 zHi += 10*kCarTolerance; << 64 //
>> 65 radius += 10*kCarTolerance;
>> 66 zLo -= 10*kCarTolerance;
>> 67 zHi += 10*kCarTolerance;
78 } 68 }
79 69
80 // Fake default constructor - sets only member <<
81 // for usage restri <<
82 // 70 //
83 G4EnclosingCylinder::G4EnclosingCylinder( __vo << 71 // Destructor
84 : radius(0.), zLo(0.), zHi(0.), phiIsOpen(fals << 72 //
85 concave(false) << 73 G4EnclosingCylinder::~G4EnclosingCylinder() {;}
86 { <<
87 } <<
88 74
>> 75
>> 76 //
89 // Outside 77 // Outside
90 // 78 //
91 // Decide very rapidly if the point is outside 79 // Decide very rapidly if the point is outside the cylinder
92 // 80 //
93 // If one is not certain, return false 81 // If one is not certain, return false
94 // 82 //
95 G4bool G4EnclosingCylinder::MustBeOutside( con << 83 G4bool G4EnclosingCylinder::MustBeOutside( const G4ThreeVector &p ) const
96 { 84 {
97 if (p.perp() > radius) return true; << 85 if (p.perp() > radius) return true;
98 if (p.z() < zLo) return true; << 86 if (p.z() < zLo) return true;
99 if (p.z() > zHi) return true; << 87 if (p.z() > zHi) return true;
100 << 88
101 if (phiIsOpen) << 89 if (phiIsOpen) {
102 { << 90 if (concave) {
103 if (concave) << 91 if ( ((p.x()-dx1)*ry1 - (p.y()-dy1)*rx1) < 0) return false;
104 { << 92 if ( ((p.x()-dx2)*ry2 - (p.y()-dy2)*rx2) > 0) return false;
105 if ( ((p.x()-dx1)*ry1 - (p.y()-dy1)*rx1) << 93 }
106 if ( ((p.x()-dx2)*ry2 - (p.y()-dy2)*rx2) << 94 else {
107 } << 95 if ( ((p.x()-dx1)*ry1 - (p.y()-dy1)*rx1) > 0) return true;
108 else << 96 if ( ((p.x()-dx2)*ry2 - (p.y()-dy2)*rx2) < 0) return true;
109 { << 97 }
110 if ( ((p.x()-dx1)*ry1 - (p.y()-dy1)*rx1) << 98 }
111 if ( ((p.x()-dx2)*ry2 - (p.y()-dy2)*rx2) << 99
112 } << 100 return false;
113 } <<
114 <<
115 return false; <<
116 } 101 }
117 << 102
>> 103
>> 104 //
118 // Misses 105 // Misses
119 // 106 //
120 // Decide very rapidly if the trajectory is go 107 // Decide very rapidly if the trajectory is going to miss the cylinder
121 // 108 //
122 // If one is not sure, return false 109 // If one is not sure, return false
123 // 110 //
124 G4bool G4EnclosingCylinder::ShouldMiss( const << 111 G4bool G4EnclosingCylinder::ShouldMiss( const G4ThreeVector &p, const G4ThreeVector &v ) const
125 const <<
126 { 112 {
127 if (!MustBeOutside(p)) return false; << 113 if (!MustBeOutside(p)) return false;
128 << 114
129 G4double cross = p.x()*v.y() - p.y()*v.x(); << 115 G4double cross = p.x()*v.y() - p.y()*v.x();
130 if (cross > radius) return true; << 116 if (cross > radius) return true;
131 << 117
132 if (p.perp() > radius) << 118 if (p.perp() > radius) {
133 { << 119 G4double dot = p.x()*v.x() + p.y()*v.y();
134 G4double dot = p.x()*v.x() + p.y()*v.y(); << 120 if (dot > 0) return true;
135 if (dot > 0) return true; << 121 }
136 } <<
137 122
138 return false; << 123 return false;
139 } << 124 }
140 125