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-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