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