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 // Implementation for G4UEllipticalTube wrappe 26 // Implementation for G4UEllipticalTube wrapper class 27 // 27 // 28 // 13-08-2019 Gabriele Cosmo, CERN 28 // 13-08-2019 Gabriele Cosmo, CERN 29 // ------------------------------------------- 29 // -------------------------------------------------------------------- 30 30 31 #include "G4EllipticalTube.hh" 31 #include "G4EllipticalTube.hh" 32 #include "G4UEllipticalTube.hh" 32 #include "G4UEllipticalTube.hh" 33 33 34 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G 34 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G4GEOM_USE_PARTIAL_USOLIDS) ) 35 35 36 #include "G4AffineTransform.hh" 36 #include "G4AffineTransform.hh" 37 #include "G4VPVParameterisation.hh" 37 #include "G4VPVParameterisation.hh" 38 #include "G4PhysicalConstants.hh" 38 #include "G4PhysicalConstants.hh" 39 #include "G4BoundingEnvelope.hh" 39 #include "G4BoundingEnvelope.hh" 40 #include "G4Polyhedron.hh" 40 #include "G4Polyhedron.hh" 41 41 42 ////////////////////////////////////////////// 42 //////////////////////////////////////////////////////////////////////// 43 // 43 // 44 // Constructor - check & set half widths 44 // Constructor - check & set half widths 45 45 46 46 47 G4UEllipticalTube::G4UEllipticalTube(const G4S 47 G4UEllipticalTube::G4UEllipticalTube(const G4String& pName, 48 G4d 48 G4double dx, 49 G4d 49 G4double dy, 50 G4d 50 G4double dz ) 51 : Base_t(pName, dx, dy, dz) 51 : Base_t(pName, dx, dy, dz) 52 { } 52 { } 53 53 54 ////////////////////////////////////////////// 54 ////////////////////////////////////////////////////////////////////////// 55 // 55 // 56 // Fake default constructor - sets only member 56 // Fake default constructor - sets only member data and allocates memory 57 // for usage restri 57 // for usage restricted to object persistency. 58 58 59 G4UEllipticalTube::G4UEllipticalTube( __void__ 59 G4UEllipticalTube::G4UEllipticalTube( __void__& a ) 60 : Base_t(a) 60 : Base_t(a) 61 { } 61 { } 62 62 63 ////////////////////////////////////////////// 63 ////////////////////////////////////////////////////////////////////////// 64 // 64 // 65 // Destructor 65 // Destructor 66 66 67 G4UEllipticalTube::~G4UEllipticalTube() = defa << 67 G4UEllipticalTube::~G4UEllipticalTube() { } 68 68 69 ////////////////////////////////////////////// 69 ////////////////////////////////////////////////////////////////////////// 70 // 70 // 71 // Copy constructor 71 // Copy constructor 72 72 73 G4UEllipticalTube::G4UEllipticalTube(const G4U 73 G4UEllipticalTube::G4UEllipticalTube(const G4UEllipticalTube& rhs) 74 : Base_t(rhs) 74 : Base_t(rhs) 75 { } 75 { } 76 76 77 ////////////////////////////////////////////// 77 ////////////////////////////////////////////////////////////////////////// 78 // 78 // 79 // Assignment operator 79 // Assignment operator 80 80 81 G4UEllipticalTube& G4UEllipticalTube::operator 81 G4UEllipticalTube& G4UEllipticalTube::operator = (const G4UEllipticalTube& rhs) 82 { 82 { 83 // Check assignment to self 83 // Check assignment to self 84 // 84 // 85 if (this == &rhs) { return *this; } 85 if (this == &rhs) { return *this; } 86 86 87 // Copy base class data 87 // Copy base class data 88 // 88 // 89 Base_t::operator=(rhs); 89 Base_t::operator=(rhs); 90 90 91 return *this; 91 return *this; 92 } 92 } 93 93 94 ////////////////////////////////////////////// 94 ////////////////////////////////////////////////////////////////////////// 95 // 95 // 96 // Accessors 96 // Accessors 97 97 98 G4double G4UEllipticalTube::GetDx() const 98 G4double G4UEllipticalTube::GetDx() const 99 { 99 { 100 return Base_t::GetDx(); 100 return Base_t::GetDx(); 101 } 101 } 102 102 103 G4double G4UEllipticalTube::GetDy() const 103 G4double G4UEllipticalTube::GetDy() const 104 { 104 { 105 return Base_t::GetDy(); 105 return Base_t::GetDy(); 106 } 106 } 107 107 108 G4double G4UEllipticalTube::GetDz() const 108 G4double G4UEllipticalTube::GetDz() const 109 { 109 { 110 return Base_t::GetDz(); 110 return Base_t::GetDz(); 111 } 111 } 112 112 113 ////////////////////////////////////////////// 113 ////////////////////////////////////////////////////////////////////////// 114 // 114 // 115 // Modifiers 115 // Modifiers 116 116 117 void G4UEllipticalTube::SetDx(G4double dx) 117 void G4UEllipticalTube::SetDx(G4double dx) 118 { 118 { 119 Base_t::SetDx(dx); 119 Base_t::SetDx(dx); 120 } 120 } 121 121 122 void G4UEllipticalTube::SetDy(G4double dy) 122 void G4UEllipticalTube::SetDy(G4double dy) 123 { 123 { 124 Base_t::SetDy(dy); 124 Base_t::SetDy(dy); 125 } 125 } 126 126 127 void G4UEllipticalTube::SetDz(G4double dz) 127 void G4UEllipticalTube::SetDz(G4double dz) 128 { 128 { 129 Base_t::SetDz(dz); 129 Base_t::SetDz(dz); 130 } 130 } 131 131 132 ////////////////////////////////////////////// 132 ////////////////////////////////////////////////////////////////////////// 133 // 133 // 134 // Make a clone of the object 134 // Make a clone of the object 135 135 136 G4VSolid* G4UEllipticalTube::Clone() const 136 G4VSolid* G4UEllipticalTube::Clone() const 137 { 137 { 138 return new G4UEllipticalTube(*this); 138 return new G4UEllipticalTube(*this); 139 } 139 } 140 140 141 ////////////////////////////////////////////// 141 ////////////////////////////////////////////////////////////////////////// 142 // 142 // 143 // Get bounding box 143 // Get bounding box 144 144 145 void G4UEllipticalTube::BoundingLimits(G4Three 145 void G4UEllipticalTube::BoundingLimits(G4ThreeVector& pMin, 146 G4Three 146 G4ThreeVector& pMax) const 147 { 147 { 148 G4double dx = GetDx(); 148 G4double dx = GetDx(); 149 G4double dy = GetDy(); 149 G4double dy = GetDy(); 150 G4double dz = GetDz(); 150 G4double dz = GetDz(); 151 151 152 pMin.set(-dx,-dy,-dz); 152 pMin.set(-dx,-dy,-dz); 153 pMax.set( dx, dy, dz); 153 pMax.set( dx, dy, dz); 154 } 154 } 155 155 156 ////////////////////////////////////////////// 156 ////////////////////////////////////////////////////////////////////////// 157 // 157 // 158 // Calculate extent under transform and specif 158 // Calculate extent under transform and specified limit 159 159 160 G4bool 160 G4bool 161 G4UEllipticalTube::CalculateExtent(const EAxis 161 G4UEllipticalTube::CalculateExtent(const EAxis pAxis, 162 const G4Vox 162 const G4VoxelLimits& pVoxelLimit, 163 const G4Aff 163 const G4AffineTransform& pTransform, 164 G4dou 164 G4double& pMin, G4double& pMax) const 165 { 165 { 166 G4ThreeVector bmin, bmax; 166 G4ThreeVector bmin, bmax; 167 G4bool exist; 167 G4bool exist; 168 168 169 // Check bounding box (bbox) 169 // Check bounding box (bbox) 170 // 170 // 171 BoundingLimits(bmin,bmax); 171 BoundingLimits(bmin,bmax); 172 G4BoundingEnvelope bbox(bmin,bmax); 172 G4BoundingEnvelope bbox(bmin,bmax); 173 #ifdef G4BBOX_EXTENT 173 #ifdef G4BBOX_EXTENT 174 return bbox.CalculateExtent(pAxis,pVoxelLimi 174 return bbox.CalculateExtent(pAxis,pVoxelLimit, pTransform, pMin, pMax); 175 #endif 175 #endif 176 if (bbox.BoundingBoxVsVoxelLimits(pAxis, pVo 176 if (bbox.BoundingBoxVsVoxelLimits(pAxis, pVoxelLimit, pTransform, pMin, pMax)) 177 { 177 { 178 return exist = pMin < pMax; << 178 return exist = (pMin < pMax) ? true : false; 179 } 179 } 180 180 181 G4double dx = GetDx(); 181 G4double dx = GetDx(); 182 G4double dy = GetDy(); 182 G4double dy = GetDy(); 183 G4double dz = GetDz(); 183 G4double dz = GetDz(); 184 184 185 // Set bounding envelope (benv) and calculat 185 // Set bounding envelope (benv) and calculate extent 186 // 186 // 187 const G4int NSTEPS = 24; // number of steps 187 const G4int NSTEPS = 24; // number of steps for whole circle 188 G4double ang = twopi/NSTEPS; 188 G4double ang = twopi/NSTEPS; 189 189 190 G4double sinHalf = std::sin(0.5*ang); 190 G4double sinHalf = std::sin(0.5*ang); 191 G4double cosHalf = std::cos(0.5*ang); 191 G4double cosHalf = std::cos(0.5*ang); 192 G4double sinStep = 2.*sinHalf*cosHalf; 192 G4double sinStep = 2.*sinHalf*cosHalf; 193 G4double cosStep = 1. - 2.*sinHalf*sinHalf; 193 G4double cosStep = 1. - 2.*sinHalf*sinHalf; 194 G4double sx = dx/cosHalf; 194 G4double sx = dx/cosHalf; 195 G4double sy = dy/cosHalf; 195 G4double sy = dy/cosHalf; 196 196 197 G4double sinCur = sinHalf; 197 G4double sinCur = sinHalf; 198 G4double cosCur = cosHalf; 198 G4double cosCur = cosHalf; 199 G4ThreeVectorList baseA(NSTEPS), baseB(NSTEP 199 G4ThreeVectorList baseA(NSTEPS), baseB(NSTEPS); 200 for (G4int k=0; k<NSTEPS; ++k) 200 for (G4int k=0; k<NSTEPS; ++k) 201 { 201 { 202 baseA[k].set(sx*cosCur,sy*sinCur,-dz); 202 baseA[k].set(sx*cosCur,sy*sinCur,-dz); 203 baseB[k].set(sx*cosCur,sy*sinCur, dz); 203 baseB[k].set(sx*cosCur,sy*sinCur, dz); 204 204 205 G4double sinTmp = sinCur; 205 G4double sinTmp = sinCur; 206 sinCur = sinCur*cosStep + cosCur*sinStep; 206 sinCur = sinCur*cosStep + cosCur*sinStep; 207 cosCur = cosCur*cosStep - sinTmp*sinStep; 207 cosCur = cosCur*cosStep - sinTmp*sinStep; 208 } 208 } 209 209 210 std::vector<const G4ThreeVectorList *> polyg 210 std::vector<const G4ThreeVectorList *> polygons(2); 211 polygons[0] = &baseA; 211 polygons[0] = &baseA; 212 polygons[1] = &baseB; 212 polygons[1] = &baseB; 213 G4BoundingEnvelope benv(bmin, bmax, polygons 213 G4BoundingEnvelope benv(bmin, bmax, polygons); 214 exist = benv.CalculateExtent(pAxis, pVoxelLi 214 exist = benv.CalculateExtent(pAxis, pVoxelLimit, pTransform, pMin, pMax); 215 return exist; 215 return exist; 216 } 216 } 217 217 218 ////////////////////////////////////////////// 218 //////////////////////////////////////////////////////////////////////// 219 // 219 // 220 // CreatePolyhedron 220 // CreatePolyhedron 221 // 221 // 222 G4Polyhedron* G4UEllipticalTube::CreatePolyhed 222 G4Polyhedron* G4UEllipticalTube::CreatePolyhedron() const 223 { 223 { 224 // create cylinder with radius=1... 224 // create cylinder with radius=1... 225 // 225 // 226 G4Polyhedron* eTube = new G4PolyhedronTube(0 226 G4Polyhedron* eTube = new G4PolyhedronTube(0., 1., GetDz()); 227 227 228 // apply non-uniform scaling... 228 // apply non-uniform scaling... 229 // 229 // 230 eTube->Transform(G4Scale3D(GetDx(), GetDy(), 230 eTube->Transform(G4Scale3D(GetDx(), GetDy(), 1.)); 231 return eTube; 231 return eTube; 232 } 232 } 233 233 234 #endif // G4GEOM_USE_USOLIDS 234 #endif // G4GEOM_USE_USOLIDS 235 235