Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/specific/src/G4UGenericPolycone.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /geometry/solids/specific/src/G4UGenericPolycone.cc (Version 11.3.0) and /geometry/solids/specific/src/G4UGenericPolycone.cc (Version 11.1.2)


  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 of G4UGenericPolycone wrappe     26 // Implementation of G4UGenericPolycone wrapper class
 27 //                                                 27 //
 28 // 30.10.13 G.Cosmo, CERN                          28 // 30.10.13 G.Cosmo, CERN
 29 // -------------------------------------------     29 // --------------------------------------------------------------------
 30                                                    30 
 31 #include "G4GenericPolycone.hh"                    31 #include "G4GenericPolycone.hh"
 32 #include "G4UGenericPolycone.hh"                   32 #include "G4UGenericPolycone.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 "G4GeomTools.hh"                          36 #include "G4GeomTools.hh"
 37 #include "G4AffineTransform.hh"                    37 #include "G4AffineTransform.hh"
 38 #include "G4VPVParameterisation.hh"                38 #include "G4VPVParameterisation.hh"
 39 #include "G4BoundingEnvelope.hh"                   39 #include "G4BoundingEnvelope.hh"
 40                                                    40 
 41 #include "G4Polyhedron.hh"                         41 #include "G4Polyhedron.hh"
 42                                                    42 
 43 using namespace CLHEP;                             43 using namespace CLHEP;
 44                                                    44 
 45 //////////////////////////////////////////////     45 ////////////////////////////////////////////////////////////////////////
 46 //                                                 46 //
 47 // Constructor (generic parameters)                47 // Constructor (generic parameters)
 48 //                                                 48 //
 49 G4UGenericPolycone::G4UGenericPolycone(const G     49 G4UGenericPolycone::G4UGenericPolycone(const G4String& name,
 50                                              G     50                                              G4double phiStart,
 51                                              G     51                                              G4double phiTotal,
 52                                              G     52                                              G4int    numRZ,
 53                                        const G     53                                        const G4double r[],
 54                                        const G     54                                        const G4double z[]   )
 55   : Base_t(name, phiStart, phiTotal, numRZ, r,     55   : Base_t(name, phiStart, phiTotal, numRZ, r, z)
 56 {                                                  56 {
 57   wrStart = phiStart; while (wrStart < 0) wrSt     57   wrStart = phiStart; while (wrStart < 0) wrStart += twopi;
 58   wrDelta = phiTotal;                              58   wrDelta = phiTotal;
 59   if (wrDelta <= 0 || wrDelta >= twopi*(1-DBL_     59   if (wrDelta <= 0 || wrDelta >= twopi*(1-DBL_EPSILON))
 60   {                                                60   {
 61     wrStart = 0;                                   61     wrStart = 0;
 62     wrDelta = twopi;                               62     wrDelta = twopi;
 63   }                                                63   }
 64   rzcorners.resize(0);                             64   rzcorners.resize(0);
 65   for (G4int i=0; i<numRZ; ++i)                    65   for (G4int i=0; i<numRZ; ++i)
 66   {                                                66   {
 67     rzcorners.emplace_back(r[i],z[i]);         <<  67     rzcorners.push_back(G4TwoVector(r[i],z[i]));
 68   }                                                68   }
 69   std::vector<G4int> iout;                         69   std::vector<G4int> iout;
 70   G4GeomTools::RemoveRedundantVertices(rzcorne     70   G4GeomTools::RemoveRedundantVertices(rzcorners,iout,2*kCarTolerance);
 71 }                                                  71 }
 72                                                    72 
 73                                                    73 
 74 //////////////////////////////////////////////     74 ////////////////////////////////////////////////////////////////////////
 75 //                                                 75 //
 76 // Fake default constructor - sets only member     76 // Fake default constructor - sets only member data and allocates memory
 77 //                            for usage restri     77 //                            for usage restricted to object persistency.
 78 //                                                 78 //
 79 G4UGenericPolycone::G4UGenericPolycone(__void_     79 G4UGenericPolycone::G4UGenericPolycone(__void__& a)
 80   : Base_t(a)                                      80   : Base_t(a)
 81 {                                                  81 {
 82 }                                                  82 }
 83                                                    83 
 84                                                    84 
 85 //////////////////////////////////////////////     85 //////////////////////////////////////////////////////////////////////////
 86 //                                                 86 //
 87 // Destructor                                      87 // Destructor
 88 //                                                 88 //
 89 G4UGenericPolycone::~G4UGenericPolycone() = de <<  89 G4UGenericPolycone::~G4UGenericPolycone()
                                                   >>  90 {
                                                   >>  91 }
 90                                                    92 
 91                                                    93 
 92 //////////////////////////////////////////////     94 //////////////////////////////////////////////////////////////////////////
 93 //                                                 95 //
 94 // Copy constructor                                96 // Copy constructor
 95 //                                                 97 //
 96 G4UGenericPolycone::G4UGenericPolycone(const G     98 G4UGenericPolycone::G4UGenericPolycone(const G4UGenericPolycone& source)
 97   : Base_t(source)                                 99   : Base_t(source)
 98 {                                                 100 {
 99   wrStart   = source.wrStart;                     101   wrStart   = source.wrStart;
100   wrDelta   = source.wrDelta;                     102   wrDelta   = source.wrDelta;
101   rzcorners = source.rzcorners;                   103   rzcorners = source.rzcorners;
102 }                                                 104 }
103                                                   105 
104                                                   106 
105 //////////////////////////////////////////////    107 //////////////////////////////////////////////////////////////////////////
106 //                                                108 //
107 // Assignment operator                            109 // Assignment operator
108 //                                                110 //
109 G4UGenericPolycone&                               111 G4UGenericPolycone&
110 G4UGenericPolycone::operator=(const G4UGeneric    112 G4UGenericPolycone::operator=(const G4UGenericPolycone& source)
111 {                                                 113 {
112   if (this == &source) return *this;              114   if (this == &source) return *this;
113                                                   115 
114   Base_t::operator=( source );                    116   Base_t::operator=( source );
115   wrStart   = source.wrStart;                     117   wrStart   = source.wrStart;
116   wrDelta   = source.wrDelta;                     118   wrDelta   = source.wrDelta;
117   rzcorners = source.rzcorners;                   119   rzcorners = source.rzcorners;
118                                                   120 
119   return *this;                                   121   return *this;
120 }                                                 122 }
121                                                   123 
122 G4double G4UGenericPolycone::GetStartPhi() con    124 G4double G4UGenericPolycone::GetStartPhi() const
123 {                                                 125 {
124   return wrStart;                                 126   return wrStart;
125 }                                                 127 }
126 G4double G4UGenericPolycone::GetEndPhi() const    128 G4double G4UGenericPolycone::GetEndPhi() const
127 {                                                 129 {
128   return (wrStart + wrDelta);                     130   return (wrStart + wrDelta);
129 }                                                 131 }
130 G4double G4UGenericPolycone::GetSinStartPhi()     132 G4double G4UGenericPolycone::GetSinStartPhi() const
131 {                                                 133 {
132   if (IsOpen()) return 0.;                        134   if (IsOpen()) return 0.;
133   G4double phi = GetStartPhi();                   135   G4double phi = GetStartPhi();
134   return std::sin(phi);                           136   return std::sin(phi);
135 }                                                 137 }
136 G4double G4UGenericPolycone::GetCosStartPhi()     138 G4double G4UGenericPolycone::GetCosStartPhi() const
137 {                                                 139 {
138   if (IsOpen()) return 1.;                        140   if (IsOpen()) return 1.;
139   G4double phi = GetStartPhi();                   141   G4double phi = GetStartPhi();
140   return std::cos(phi);                           142   return std::cos(phi);
141 }                                                 143 }
142 G4double G4UGenericPolycone::GetSinEndPhi() co    144 G4double G4UGenericPolycone::GetSinEndPhi() const
143 {                                                 145 {
144   if (IsOpen()) return 0.;                        146   if (IsOpen()) return 0.;
145   G4double phi = GetEndPhi();                     147   G4double phi = GetEndPhi();
146   return std::sin(phi);                           148   return std::sin(phi);
147 }                                                 149 }
148 G4double G4UGenericPolycone::GetCosEndPhi() co    150 G4double G4UGenericPolycone::GetCosEndPhi() const
149 {                                                 151 {
150   if (IsOpen()) return 1.;                        152   if (IsOpen()) return 1.;
151   G4double phi = GetEndPhi();                     153   G4double phi = GetEndPhi();
152   return std::cos(phi);                           154   return std::cos(phi);
153 }                                                 155 }
154 G4bool G4UGenericPolycone::IsOpen() const         156 G4bool G4UGenericPolycone::IsOpen() const
155 {                                                 157 {
156   return (wrDelta < twopi);                       158   return (wrDelta < twopi);
157 }                                                 159 }
158 G4int G4UGenericPolycone::GetNumRZCorner() con    160 G4int G4UGenericPolycone::GetNumRZCorner() const
159 {                                                 161 {
160   return rzcorners.size();                        162   return rzcorners.size();
161 }                                                 163 }
162 G4PolyconeSideRZ G4UGenericPolycone::GetCorner    164 G4PolyconeSideRZ G4UGenericPolycone::GetCorner(G4int index) const
163 {                                                 165 {
164   G4TwoVector rz = rzcorners.at(index);           166   G4TwoVector rz = rzcorners.at(index);
165   G4PolyconeSideRZ psiderz = { rz.x(), rz.y()     167   G4PolyconeSideRZ psiderz = { rz.x(), rz.y() };
166                                                   168 
167   return psiderz;                                 169   return psiderz;
168 }                                                 170 }
169                                                   171 
170 //////////////////////////////////////////////    172 //////////////////////////////////////////////////////////////////////////
171 //                                                173 //
172 // Make a clone of the object                     174 // Make a clone of the object
173                                                   175 
174 G4VSolid* G4UGenericPolycone::Clone() const       176 G4VSolid* G4UGenericPolycone::Clone() const
175 {                                                 177 {
176   return new G4UGenericPolycone(*this);           178   return new G4UGenericPolycone(*this);
177 }                                                 179 }
178                                                   180 
179 //////////////////////////////////////////////    181 //////////////////////////////////////////////////////////////////////////
180 //                                                182 //
181 // Get bounding box                               183 // Get bounding box
182                                                   184 
183 void                                              185 void
184 G4UGenericPolycone::BoundingLimits(G4ThreeVect    186 G4UGenericPolycone::BoundingLimits(G4ThreeVector& pMin,
185                                    G4ThreeVect    187                                    G4ThreeVector& pMax) const
186 {                                                 188 {
187   G4double rmin = kInfinity, rmax = -kInfinity    189   G4double rmin = kInfinity, rmax = -kInfinity;
188   G4double zmin = kInfinity, zmax = -kInfinity    190   G4double zmin = kInfinity, zmax = -kInfinity;
189                                                   191 
190   for (G4int i=0; i<GetNumRZCorner(); ++i)        192   for (G4int i=0; i<GetNumRZCorner(); ++i)
191   {                                               193   {
192     G4PolyconeSideRZ corner = GetCorner(i);       194     G4PolyconeSideRZ corner = GetCorner(i);
193     if (corner.r < rmin) rmin = corner.r;         195     if (corner.r < rmin) rmin = corner.r;
194     if (corner.r > rmax) rmax = corner.r;         196     if (corner.r > rmax) rmax = corner.r;
195     if (corner.z < zmin) zmin = corner.z;         197     if (corner.z < zmin) zmin = corner.z;
196     if (corner.z > zmax) zmax = corner.z;         198     if (corner.z > zmax) zmax = corner.z;
197   }                                               199   }
198                                                   200 
199   if (IsOpen())                                   201   if (IsOpen())
200   {                                               202   {
201     G4TwoVector vmin,vmax;                        203     G4TwoVector vmin,vmax;
202     G4GeomTools::DiskExtent(rmin,rmax,            204     G4GeomTools::DiskExtent(rmin,rmax,
203                             GetSinStartPhi(),G    205                             GetSinStartPhi(),GetCosStartPhi(),
204                             GetSinEndPhi(),Get    206                             GetSinEndPhi(),GetCosEndPhi(),
205                             vmin,vmax);           207                             vmin,vmax);
206     pMin.set(vmin.x(),vmin.y(),zmin);             208     pMin.set(vmin.x(),vmin.y(),zmin);
207     pMax.set(vmax.x(),vmax.y(),zmax);             209     pMax.set(vmax.x(),vmax.y(),zmax);
208   }                                               210   }
209   else                                            211   else
210   {                                               212   {
211     pMin.set(-rmax,-rmax, zmin);                  213     pMin.set(-rmax,-rmax, zmin);
212     pMax.set( rmax, rmax, zmax);                  214     pMax.set( rmax, rmax, zmax);
213   }                                               215   }
214                                                   216 
215   // Check correctness of the bounding box        217   // Check correctness of the bounding box
216   //                                              218   //
217   if (pMin.x() >= pMax.x() || pMin.y() >= pMax    219   if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
218   {                                               220   {
219     std::ostringstream message;                   221     std::ostringstream message;
220     message << "Bad bounding box (min >= max)     222     message << "Bad bounding box (min >= max) for solid: "
221             << GetName() << " !"                  223             << GetName() << " !"
222             << "\npMin = " << pMin                224             << "\npMin = " << pMin
223             << "\npMax = " << pMax;               225             << "\npMax = " << pMax;
224     G4Exception("G4UGenericPolycone::BoundingL    226     G4Exception("G4UGenericPolycone::BoundingLimits()", "GeomMgt0001",
225                 JustWarning, message);            227                 JustWarning, message);
226     StreamInfo(G4cout);                           228     StreamInfo(G4cout);
227   }                                               229   }
228 }                                                 230 }
229                                                   231 
230 //////////////////////////////////////////////    232 //////////////////////////////////////////////////////////////////////////
231 //                                                233 //
232 // Calculate extent under transform and specif    234 // Calculate extent under transform and specified limit
233                                                   235 
234 G4bool                                            236 G4bool
235 G4UGenericPolycone::CalculateExtent(const EAxi    237 G4UGenericPolycone::CalculateExtent(const EAxis pAxis,
236                                     const G4Vo    238                                     const G4VoxelLimits& pVoxelLimit,
237                                     const G4Af    239                                     const G4AffineTransform& pTransform,
238                                           G4do    240                                           G4double& pMin, G4double& pMax) const
239 {                                                 241 {
240   G4ThreeVector bmin, bmax;                       242   G4ThreeVector bmin, bmax;
241   G4bool exist;                                   243   G4bool exist;
242                                                   244 
243   // Check bounding box (bbox)                    245   // Check bounding box (bbox)
244   //                                              246   //
245   BoundingLimits(bmin,bmax);                      247   BoundingLimits(bmin,bmax);
246   G4BoundingEnvelope bbox(bmin,bmax);             248   G4BoundingEnvelope bbox(bmin,bmax);
247 #ifdef G4BBOX_EXTENT                              249 #ifdef G4BBOX_EXTENT
248   return bbox.CalculateExtent(pAxis,pVoxelLimi    250   return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
249 #endif                                            251 #endif
250   if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVox    252   if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
251   {                                               253   {
252     return exist = pMin < pMax;                << 254     return exist = (pMin < pMax) ? true : false;
253   }                                               255   }
254                                                   256 
255   // To find the extent, RZ contour of the pol    257   // To find the extent, RZ contour of the polycone is subdivided
256   // in triangles. The extent is calculated as    258   // in triangles. The extent is calculated as cumulative extent of
257   // all sub-polycones formed by rotation of t    259   // all sub-polycones formed by rotation of triangles around Z
258   //                                              260   //
259   G4TwoVectorList contourRZ;                      261   G4TwoVectorList contourRZ;
260   G4TwoVectorList triangles;                      262   G4TwoVectorList triangles;
261   G4double eminlim = pVoxelLimit.GetMinExtent(    263   G4double eminlim = pVoxelLimit.GetMinExtent(pAxis);
262   G4double emaxlim = pVoxelLimit.GetMaxExtent(    264   G4double emaxlim = pVoxelLimit.GetMaxExtent(pAxis);
263                                                   265 
264   // get RZ contour, ensure anticlockwise orde    266   // get RZ contour, ensure anticlockwise order of corners
265   for (G4int i=0; i<GetNumRZCorner(); ++i)        267   for (G4int i=0; i<GetNumRZCorner(); ++i)
266   {                                               268   {
267     G4PolyconeSideRZ corner = GetCorner(i);       269     G4PolyconeSideRZ corner = GetCorner(i);
268     contourRZ.emplace_back(corner.r,corner.z); << 270     contourRZ.push_back(G4TwoVector(corner.r,corner.z));
269   }                                               271   }
270   G4double area = G4GeomTools::PolygonArea(con    272   G4double area = G4GeomTools::PolygonArea(contourRZ);
271   if (area < 0.) std::reverse(contourRZ.begin(    273   if (area < 0.) std::reverse(contourRZ.begin(),contourRZ.end());
272                                                   274 
273   // triangulate RZ countour                      275   // triangulate RZ countour
274   if (!G4GeomTools::TriangulatePolygon(contour    276   if (!G4GeomTools::TriangulatePolygon(contourRZ,triangles))
275   {                                               277   {
276     std::ostringstream message;                   278     std::ostringstream message;
277     message << "Triangulation of RZ contour ha    279     message << "Triangulation of RZ contour has failed for solid: "
278             << GetName() << " !"                  280             << GetName() << " !"
279             << "\nExtent has been calculated u    281             << "\nExtent has been calculated using boundary box";
280     G4Exception("G4UGenericPolycone::Calculate    282     G4Exception("G4UGenericPolycone::CalculateExtent()",
281                 "GeomMgt1002", JustWarning, me    283                 "GeomMgt1002", JustWarning, message);
282     return bbox.CalculateExtent(pAxis,pVoxelLi    284     return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
283   }                                               285   }
284                                                   286 
285   // set trigonometric values                     287   // set trigonometric values
286   const G4int NSTEPS = 24;            // numbe    288   const G4int NSTEPS = 24;            // number of steps for whole circle
287   G4double astep  = twopi/NSTEPS;     // max a    289   G4double astep  = twopi/NSTEPS;     // max angle for one step
288                                                   290 
289   G4double sphi   = GetStartPhi();                291   G4double sphi   = GetStartPhi();
290   G4double ephi   = GetEndPhi();                  292   G4double ephi   = GetEndPhi();
291   G4double dphi   = IsOpen() ? ephi-sphi : two    293   G4double dphi   = IsOpen() ? ephi-sphi : twopi;
292   G4int    ksteps = (dphi <= astep) ? 1 : (G4i    294   G4int    ksteps = (dphi <= astep) ? 1 : (G4int)((dphi-deg)/astep) + 1;
293   G4double ang    = dphi/ksteps;                  295   G4double ang    = dphi/ksteps;
294                                                   296 
295   G4double sinHalf = std::sin(0.5*ang);           297   G4double sinHalf = std::sin(0.5*ang);
296   G4double cosHalf = std::cos(0.5*ang);           298   G4double cosHalf = std::cos(0.5*ang);
297   G4double sinStep = 2.*sinHalf*cosHalf;          299   G4double sinStep = 2.*sinHalf*cosHalf;
298   G4double cosStep = 1. - 2.*sinHalf*sinHalf;     300   G4double cosStep = 1. - 2.*sinHalf*sinHalf;
299                                                   301 
300   G4double sinStart = GetSinStartPhi();           302   G4double sinStart = GetSinStartPhi();
301   G4double cosStart = GetCosStartPhi();           303   G4double cosStart = GetCosStartPhi();
302   G4double sinEnd   = GetSinEndPhi();             304   G4double sinEnd   = GetSinEndPhi();
303   G4double cosEnd   = GetCosEndPhi();             305   G4double cosEnd   = GetCosEndPhi();
304                                                   306 
305   // define vectors and arrays                    307   // define vectors and arrays
306   std::vector<const G4ThreeVectorList *> polyg    308   std::vector<const G4ThreeVectorList *> polygons;
307   polygons.resize(ksteps+2);                      309   polygons.resize(ksteps+2);
308   G4ThreeVectorList pols[NSTEPS+2];               310   G4ThreeVectorList pols[NSTEPS+2];
309   for (G4int k=0; k<ksteps+2; ++k) pols[k].res    311   for (G4int k=0; k<ksteps+2; ++k) pols[k].resize(6);
310   for (G4int k=0; k<ksteps+2; ++k) polygons[k]    312   for (G4int k=0; k<ksteps+2; ++k) polygons[k] = &pols[k];
311   G4double r0[6],z0[6]; // contour with origin    313   G4double r0[6],z0[6]; // contour with original edges of triangle
312   G4double r1[6];       // shifted radii of ex    314   G4double r1[6];       // shifted radii of external edges of triangle
313                                                   315 
314   // main loop along triangles                    316   // main loop along triangles
315   pMin = kInfinity;                               317   pMin = kInfinity;
316   pMax =-kInfinity;                               318   pMax =-kInfinity;
317   G4int ntria = triangles.size()/3;               319   G4int ntria = triangles.size()/3;
318   for (G4int i=0; i<ntria; ++i)                   320   for (G4int i=0; i<ntria; ++i)
319   {                                               321   {
320     G4int i3 = i*3;                               322     G4int i3 = i*3;
321     for (G4int k=0; k<3; ++k)                     323     for (G4int k=0; k<3; ++k)
322     {                                             324     {
323       G4int e0 = i3+k, e1 = (k<2) ? e0+1 : i3;    325       G4int e0 = i3+k, e1 = (k<2) ? e0+1 : i3;
324       G4int k2 = k*2;                             326       G4int k2 = k*2;
325       // set contour with original edges of tr    327       // set contour with original edges of triangle
326       r0[k2+0] = triangles[e0].x(); z0[k2+0] =    328       r0[k2+0] = triangles[e0].x(); z0[k2+0] = triangles[e0].y();
327       r0[k2+1] = triangles[e1].x(); z0[k2+1] =    329       r0[k2+1] = triangles[e1].x(); z0[k2+1] = triangles[e1].y();
328       // set shifted radii                        330       // set shifted radii
329       r1[k2+0] = r0[k2+0];                        331       r1[k2+0] = r0[k2+0];
330       r1[k2+1] = r0[k2+1];                        332       r1[k2+1] = r0[k2+1];
331       if (z0[k2+1] - z0[k2+0] <= 0) continue;     333       if (z0[k2+1] - z0[k2+0] <= 0) continue;
332       r1[k2+0] /= cosHalf;                        334       r1[k2+0] /= cosHalf;
333       r1[k2+1] /= cosHalf;                        335       r1[k2+1] /= cosHalf;
334     }                                             336     }
335                                                   337 
336     // rotate countour, set sequence of 6-side    338     // rotate countour, set sequence of 6-sided polygons
337     G4double sinCur = sinStart*cosHalf + cosSt    339     G4double sinCur = sinStart*cosHalf + cosStart*sinHalf;
338     G4double cosCur = cosStart*cosHalf - sinSt    340     G4double cosCur = cosStart*cosHalf - sinStart*sinHalf;
339     for (G4int j=0; j<6; ++j)                     341     for (G4int j=0; j<6; ++j)
340     {                                             342     {
341       pols[0][j].set(r0[j]*cosStart,r0[j]*sinS    343       pols[0][j].set(r0[j]*cosStart,r0[j]*sinStart,z0[j]);
342     }                                             344     }
343     for (G4int k=1; k<ksteps+1; ++k)              345     for (G4int k=1; k<ksteps+1; ++k)
344     {                                             346     {
345       for (G4int j=0; j<6; ++j)                   347       for (G4int j=0; j<6; ++j)
346       {                                           348       {
347         pols[k][j].set(r1[j]*cosCur,r1[j]*sinC    349         pols[k][j].set(r1[j]*cosCur,r1[j]*sinCur,z0[j]);
348       }                                           350       }
349       G4double sinTmp = sinCur;                   351       G4double sinTmp = sinCur;
350       sinCur = sinCur*cosStep + cosCur*sinStep    352       sinCur = sinCur*cosStep + cosCur*sinStep;
351       cosCur = cosCur*cosStep - sinTmp*sinStep    353       cosCur = cosCur*cosStep - sinTmp*sinStep;
352     }                                             354     }
353     for (G4int j=0; j<6; ++j)                     355     for (G4int j=0; j<6; ++j)
354     {                                             356     {
355       pols[ksteps+1][j].set(r0[j]*cosEnd,r0[j]    357       pols[ksteps+1][j].set(r0[j]*cosEnd,r0[j]*sinEnd,z0[j]);
356     }                                             358     }
357                                                   359 
358     // set sub-envelope and adjust extent         360     // set sub-envelope and adjust extent
359     G4double emin,emax;                           361     G4double emin,emax;
360     G4BoundingEnvelope benv(polygons);            362     G4BoundingEnvelope benv(polygons);
361     if (!benv.CalculateExtent(pAxis,pVoxelLimi    363     if (!benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,emin,emax)) continue;
362     if (emin < pMin) pMin = emin;                 364     if (emin < pMin) pMin = emin;
363     if (emax > pMax) pMax = emax;                 365     if (emax > pMax) pMax = emax;
364     if (eminlim > pMin && emaxlim < pMax) retu    366     if (eminlim > pMin && emaxlim < pMax) return true; // max possible extent
365   }                                               367   }
366   return (pMin < pMax);                           368   return (pMin < pMax);
367 }                                                 369 }
368                                                   370 
369 //////////////////////////////////////////////    371 ////////////////////////////////////////////////////////////////////////
370 //                                                372 //
371 // CreatePolyhedron                               373 // CreatePolyhedron
372                                                   374 
373 G4Polyhedron* G4UGenericPolycone::CreatePolyhe    375 G4Polyhedron* G4UGenericPolycone::CreatePolyhedron() const
374 {                                                 376 {
375   return new G4PolyhedronPcon(wrStart, wrDelta    377   return new G4PolyhedronPcon(wrStart, wrDelta, rzcorners);
376 }                                                 378 }
377                                                   379 
378 #endif  // G4GEOM_USE_USOLIDS                     380 #endif  // G4GEOM_USE_USOLIDS
379                                                   381