| 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() = default;
67 67
68 // AddSurface 68 // AddSurface
69 // 69 //
70 // 70 //
71 void G4SolidExtentList::AddSurface( const G4Cl 71 void G4SolidExtentList::AddSurface( const G4ClippablePolygon& surface )
72 { 72 {
73 // 73 //
74 // Keep track of four surfaces 74 // Keep track of four surfaces
75 // 75 //
76 G4double smin=.0, smax=0.; 76 G4double smin=.0, smax=0.;
77 77
78 surface.GetExtent( axis, smin, smax ); 78 surface.GetExtent( axis, smin, smax );
79 79
80 if (smin > maxLimit) 80 if (smin > maxLimit)
81 { 81 {
82 // 82 //
83 // Nearest surface beyond maximum limit 83 // Nearest surface beyond maximum limit
84 // 84 //
85 if (surface.InFrontOf(minAbove,axis)) minA 85 if (surface.InFrontOf(minAbove,axis)) minAbove = surface;
86 } 86 }
87 else if (smax < minLimit) 87 else if (smax < minLimit)
88 { 88 {
89 // 89 //
90 // Nearest surface below minimum limit 90 // Nearest surface below minimum limit
91 // 91 //
92 if (surface.BehindOf(maxBelow,axis)) maxBe 92 if (surface.BehindOf(maxBelow,axis)) maxBelow = surface;
93 } 93 }
94 else 94 else
95 { 95 {
96 // 96 //
97 // Max and min surfaces inside 97 // Max and min surfaces inside
98 // 98 //
99 if (surface.BehindOf(maxSurface,axis)) max 99 if (surface.BehindOf(maxSurface,axis)) maxSurface = surface;
100 if (surface.InFrontOf(minSurface,axis)) mi 100 if (surface.InFrontOf(minSurface,axis)) minSurface = surface;
101 } 101 }
102 } 102 }
103 103
104 // GetExtent 104 // GetExtent
105 // 105 //
106 // Return extent after processing all surfaces 106 // Return extent after processing all surfaces
107 // 107 //
108 G4bool G4SolidExtentList::GetExtent( G4double& 108 G4bool G4SolidExtentList::GetExtent( G4double& emin, G4double& emax ) const
109 { 109 {
110 G4double kCarTolerance = G4GeometryTolerance 110 G4double kCarTolerance = G4GeometryTolerance::GetInstance()
111 ->GetSurfaceToleran 111 ->GetSurfaceTolerance();
112 // 112 //
113 // Did we have any surfaces within the limit 113 // Did we have any surfaces within the limits?
114 // 114 //
115 if (minSurface.Empty()) 115 if (minSurface.Empty())
116 { 116 {
117 // 117 //
118 // Nothing! Do we have anything above? 118 // Nothing! Do we have anything above?
119 // 119 //
120 if (minAbove.Empty()) return false; 120 if (minAbove.Empty()) return false;
121 121
122 // 122 //
123 // Yup. Is it facing inwards? 123 // Yup. Is it facing inwards?
124 // 124 //
125 if (minAbove.GetNormal().operator()(axis) 125 if (minAbove.GetNormal().operator()(axis) < 0) return false;
126 126
127 // 127 //
128 // No. We must be entirely within the soli 128 // No. We must be entirely within the solid
129 // 129 //
130 emax = maxLimit + kCarTolerance; 130 emax = maxLimit + kCarTolerance;
131 emin = minLimit - kCarTolerance; 131 emin = minLimit - kCarTolerance;
132 return true; 132 return true;
133 } 133 }
134 134
135 // 135 //
136 // Check max surface 136 // Check max surface
137 // 137 //
138 if (maxSurface.GetNormal().operator()(axis) 138 if (maxSurface.GetNormal().operator()(axis) < 0)
139 { 139 {
140 // 140 //
141 // Inward facing: max limit must be embedd 141 // Inward facing: max limit must be embedded within solid
142 // 142 //
143 emax = maxLimit + kCarTolerance; 143 emax = maxLimit + kCarTolerance;
144 } 144 }
145 else 145 else
146 { 146 {
147 G4double sMin=0., sMax=0.; 147 G4double sMin=0., sMax=0.;
148 maxSurface.GetExtent( axis, sMin, sMax ); 148 maxSurface.GetExtent( axis, sMin, sMax );
149 emax = ( (sMax > maxLimit) ? maxLimit : sM 149 emax = ( (sMax > maxLimit) ? maxLimit : sMax ) + kCarTolerance;
150 } 150 }
151 151
152 // 152 //
153 // Check min surface 153 // Check min surface
154 // 154 //
155 if (minSurface.GetNormal().operator()(axis) 155 if (minSurface.GetNormal().operator()(axis) > 0)
156 { 156 {
157 // 157 //
158 // Inward facing: max limit must be embedd 158 // Inward facing: max limit must be embedded within solid
159 // 159 //
160 emin = minLimit - kCarTolerance; 160 emin = minLimit - kCarTolerance;
161 } 161 }
162 else 162 else
163 { 163 {
164 G4double sMin=0., sMax=0.; 164 G4double sMin=0., sMax=0.;
165 minSurface.GetExtent( axis, sMin, sMax ); 165 minSurface.GetExtent( axis, sMin, sMax );
166 emin = ( (sMin < minLimit) ? minLimit : sM 166 emin = ( (sMin < minLimit) ? minLimit : sMin ) - kCarTolerance;
167 } 167 }
168 168
169 return true; 169 return true;
170 } 170 }
171 171
172 172