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