| 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 // ********************************************************************
25 // 22 //
26 // G4SolidExtentList implementation; a list of <<
27 // 23 //
28 // Author: David C. Williams (davidw@scipp.ucs << 24 // $Id: G4SolidExtentList.cc,v 1.3 2002/10/28 11:47:53 gcosmo Exp $
>> 25 // GEANT4 tag $Name: geant4-05-02-patch-01 $
>> 26 //
>> 27 //
>> 28 // --------------------------------------------------------------------
>> 29 // GEANT 4 class source file
>> 30 //
>> 31 //
>> 32 // G4SolidExtentList.cc
>> 33 //
>> 34 // Implementation of a list of (voxel) extents along one axis
>> 35 //
29 // ------------------------------------------- 36 // --------------------------------------------------------------------
30 37
31 #include "G4SolidExtentList.hh" 38 #include "G4SolidExtentList.hh"
32 #include "G4VoxelLimits.hh" 39 #include "G4VoxelLimits.hh"
33 #include "G4GeometryTolerance.hh" <<
34 40
>> 41
>> 42 //
35 // Constructor (default) 43 // Constructor (default)
36 // 44 //
37 G4SolidExtentList::G4SolidExtentList() 45 G4SolidExtentList::G4SolidExtentList()
38 { 46 {
39 axis = kZAxis; 47 axis = kZAxis;
40 minLimit = -INT_MAX/2; << 48 limited = false;
41 maxLimit = INT_MAX/2; << 49 minLimit = -DBL_MAX;
>> 50 maxLimit = +DBL_MAX;
42 } 51 }
43 52
>> 53
>> 54 //
44 // Constructor (limited case) 55 // Constructor (limited case)
45 // 56 //
46 G4SolidExtentList::G4SolidExtentList( const EA 57 G4SolidExtentList::G4SolidExtentList( const EAxis targetAxis,
47 const G4 58 const G4VoxelLimits &voxelLimits )
48 { 59 {
49 axis = targetAxis; 60 axis = targetAxis;
50 61
51 limited = voxelLimits.IsLimited( axis ); 62 limited = voxelLimits.IsLimited( axis );
52 if (limited) 63 if (limited)
53 { 64 {
54 minLimit = voxelLimits.GetMinExtent( axis 65 minLimit = voxelLimits.GetMinExtent( axis );
55 maxLimit = voxelLimits.GetMaxExtent( axis 66 maxLimit = voxelLimits.GetMaxExtent( axis );
56 } 67 }
57 else 68 else
58 { 69 {
59 minLimit = -INT_MAX/2; << 70 minLimit = -DBL_MAX;
60 maxLimit = INT_MAX/2; << 71 maxLimit = +DBL_MAX;
61 } 72 }
62 } 73 }
63 74
>> 75
>> 76 //
64 // Destructor 77 // Destructor
65 // 78 //
66 G4SolidExtentList::~G4SolidExtentList() = defa << 79 G4SolidExtentList::~G4SolidExtentList()
>> 80 {
>> 81 }
>> 82
67 83
>> 84 //
68 // AddSurface 85 // AddSurface
69 // 86 //
70 // 87 //
71 void G4SolidExtentList::AddSurface( const G4Cl << 88 void G4SolidExtentList::AddSurface( const G4ClippablePolygon &surface )
72 { 89 {
73 // 90 //
74 // Keep track of four surfaces 91 // Keep track of four surfaces
75 // 92 //
76 G4double smin=.0, smax=0.; << 93 G4double min, max;
77 94
78 surface.GetExtent( axis, smin, smax ); << 95 surface.GetExtent( axis, min, max );
79 96
80 if (smin > maxLimit) << 97 if (min > maxLimit)
81 { 98 {
82 // 99 //
83 // Nearest surface beyond maximum limit 100 // Nearest surface beyond maximum limit
84 // 101 //
85 if (surface.InFrontOf(minAbove,axis)) minA 102 if (surface.InFrontOf(minAbove,axis)) minAbove = surface;
86 } 103 }
87 else if (smax < minLimit) << 104 else if (max < minLimit)
88 { 105 {
89 // 106 //
90 // Nearest surface below minimum limit 107 // Nearest surface below minimum limit
91 // 108 //
92 if (surface.BehindOf(maxBelow,axis)) maxBe 109 if (surface.BehindOf(maxBelow,axis)) maxBelow = surface;
93 } 110 }
94 else 111 else
95 { 112 {
96 // 113 //
97 // Max and min surfaces inside 114 // Max and min surfaces inside
98 // 115 //
99 if (surface.BehindOf(maxSurface,axis)) max 116 if (surface.BehindOf(maxSurface,axis)) maxSurface = surface;
100 if (surface.InFrontOf(minSurface,axis)) mi 117 if (surface.InFrontOf(minSurface,axis)) minSurface = surface;
101 } 118 }
102 } 119 }
103 120
>> 121
>> 122
>> 123 //
104 // GetExtent 124 // GetExtent
105 // 125 //
106 // Return extent after processing all surfaces 126 // Return extent after processing all surfaces
107 // 127 //
108 G4bool G4SolidExtentList::GetExtent( G4double& << 128 G4bool G4SolidExtentList::GetExtent( G4double &min, G4double &max ) const
109 { 129 {
110 G4double kCarTolerance = G4GeometryTolerance <<
111 ->GetSurfaceToleran <<
112 // 130 //
113 // Did we have any surfaces within the limit 131 // Did we have any surfaces within the limits?
114 // 132 //
115 if (minSurface.Empty()) 133 if (minSurface.Empty())
116 { 134 {
117 // 135 //
118 // Nothing! Do we have anything above? 136 // Nothing! Do we have anything above?
119 // 137 //
120 if (minAbove.Empty()) return false; 138 if (minAbove.Empty()) return false;
121 139
122 // 140 //
123 // Yup. Is it facing inwards? 141 // Yup. Is it facing inwards?
124 // 142 //
125 if (minAbove.GetNormal().operator()(axis) 143 if (minAbove.GetNormal().operator()(axis) < 0) return false;
126 144
127 // 145 //
128 // No. We must be entirely within the soli 146 // No. We must be entirely within the solid
129 // 147 //
130 emax = maxLimit + kCarTolerance; << 148 max = maxLimit + kCarTolerance;
131 emin = minLimit - kCarTolerance; << 149 min = minLimit - kCarTolerance;
132 return true; 150 return true;
133 } 151 }
134 152
135 // 153 //
136 // Check max surface 154 // Check max surface
137 // 155 //
138 if (maxSurface.GetNormal().operator()(axis) 156 if (maxSurface.GetNormal().operator()(axis) < 0)
139 { 157 {
140 // 158 //
141 // Inward facing: max limit must be embedd 159 // Inward facing: max limit must be embedded within solid
142 // 160 //
143 emax = maxLimit + kCarTolerance; << 161 max = maxLimit + kCarTolerance;
144 } 162 }
145 else 163 else
146 { 164 {
147 G4double sMin=0., sMax=0.; << 165 G4double sMin, sMax;
148 maxSurface.GetExtent( axis, sMin, sMax ); 166 maxSurface.GetExtent( axis, sMin, sMax );
149 emax = ( (sMax > maxLimit) ? maxLimit : sM << 167 max = ( (sMax > maxLimit) ? maxLimit : sMax ) + kCarTolerance;
150 } 168 }
151 169
152 // 170 //
153 // Check min surface 171 // Check min surface
154 // 172 //
155 if (minSurface.GetNormal().operator()(axis) 173 if (minSurface.GetNormal().operator()(axis) > 0)
156 { 174 {
157 // 175 //
158 // Inward facing: max limit must be embedd 176 // Inward facing: max limit must be embedded within solid
159 // 177 //
160 emin = minLimit - kCarTolerance; << 178 min = minLimit - kCarTolerance;
161 } 179 }
162 else 180 else
163 { 181 {
164 G4double sMin=0., sMax=0.; << 182 G4double sMin, sMax;
165 minSurface.GetExtent( axis, sMin, sMax ); 183 minSurface.GetExtent( axis, sMin, sMax );
166 emin = ( (sMin < minLimit) ? minLimit : sM << 184 min = ( (sMin < minLimit) ? minLimit : sMin ) - kCarTolerance;
167 } 185 }
168 186
169 return true; 187 return true;
170 } 188 }
171 189
172 190