Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/specific/src/G4UPolycone.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/G4UPolycone.cc (Version 11.3.0) and /geometry/solids/specific/src/G4UPolycone.cc (Version 10.2.p3)


  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 G4UPolycone wrapper class << 
 27 //                                                 26 //
 28 // 31.10.13 G.Cosmo, CERN                      <<  27 // $Id:$
                                                   >>  28 //
                                                   >>  29 // Implementation of G4UPolycone wrapper class
 29 // -------------------------------------------     30 // --------------------------------------------------------------------
 30                                                    31 
 31 #include "G4Polycone.hh"                           32 #include "G4Polycone.hh"
 32 #include "G4UPolycone.hh"                          33 #include "G4UPolycone.hh"
 33                                                    34 
 34 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G     35 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G4GEOM_USE_PARTIAL_USOLIDS) )
 35                                                    36 
 36 #include "G4GeomTools.hh"                      << 
 37 #include "G4AffineTransform.hh"                << 
 38 #include "G4VPVParameterisation.hh"                37 #include "G4VPVParameterisation.hh"
 39 #include "G4BoundingEnvelope.hh"               << 
 40                                                << 
 41 using namespace CLHEP;                         << 
 42                                                    38 
 43 //////////////////////////////////////////////     39 ////////////////////////////////////////////////////////////////////////
 44 //                                                 40 //
 45 // Constructor (GEANT3 style parameters)           41 // Constructor (GEANT3 style parameters)
 46 //                                             <<  42 //  
 47 G4UPolycone::G4UPolycone( const G4String& name <<  43 G4UPolycone::G4UPolycone( const G4String& name, 
 48                               G4double phiStar     44                               G4double phiStart,
 49                               G4double phiTota     45                               G4double phiTotal,
 50                               G4int numZPlanes     46                               G4int numZPlanes,
 51                         const G4double zPlane[     47                         const G4double zPlane[],
 52                         const G4double rInner[     48                         const G4double rInner[],
 53                         const G4double rOuter[     49                         const G4double rOuter[]  )
 54   : Base_t(name, phiStart, phiTotal, numZPlane <<  50   : G4USolid(name,  new UPolycone(name, phiStart, phiTotal,
                                                   >>  51                                   numZPlanes, zPlane, rInner, rOuter))
 55 {                                                  52 {
 56   fGenericPcon = false;                        << 
 57   SetOriginalParameters();                     << 
 58   wrStart = phiStart;                          << 
 59   while (wrStart < 0)                          << 
 60   {                                            << 
 61     wrStart += twopi;                          << 
 62   }                                            << 
 63   wrDelta = phiTotal;                          << 
 64   if (wrDelta <= 0 || wrDelta >= twopi*(1-DBL_ << 
 65   {                                            << 
 66     wrStart = 0;                               << 
 67     wrDelta = twopi;                           << 
 68   }                                            << 
 69   rzcorners.resize(0);                         << 
 70   for (G4int i=0; i<numZPlanes; ++i)           << 
 71   {                                            << 
 72     G4double z = zPlane[i];                    << 
 73     G4double r = rOuter[i];                    << 
 74     rzcorners.emplace_back(r,z);               << 
 75   }                                            << 
 76   for (G4int i=numZPlanes-1; i>=0; --i)        << 
 77   {                                            << 
 78     G4double z = zPlane[i];                    << 
 79     G4double r = rInner[i];                    << 
 80     rzcorners.emplace_back(r,z);               << 
 81   }                                            << 
 82   std::vector<G4int> iout;                     << 
 83   G4GeomTools::RemoveRedundantVertices(rzcorne << 
 84 }                                                  53 }
 85                                                    54 
 86                                                    55 
 87 //////////////////////////////////////////////     56 ////////////////////////////////////////////////////////////////////////
 88 //                                                 57 //
 89 // Constructor (generic parameters)                58 // Constructor (generic parameters)
 90 //                                                 59 //
 91 G4UPolycone::G4UPolycone(const G4String& name, <<  60 G4UPolycone::G4UPolycone(const G4String& name, 
 92                                G4double phiSta     61                                G4double phiStart,
 93                                G4double phiTot     62                                G4double phiTotal,
 94                                G4int    numRZ,     63                                G4int    numRZ,
 95                          const G4double r[],       64                          const G4double r[],
 96                          const G4double z[]        65                          const G4double z[]   )
 97   : Base_t(name, phiStart, phiTotal, numRZ, r, <<  66   : G4USolid(name, new UPolycone(name, phiStart, phiTotal, numRZ, r, z))
 98 {                                              <<  67 { 
 99   fGenericPcon = true;                         << 
100   SetOriginalParameters();                     << 
101   wrStart = phiStart; while (wrStart < 0) wrSt << 
102   wrDelta = phiTotal;                          << 
103   if (wrDelta <= 0 || wrDelta >= twopi*(1-DBL_ << 
104   {                                            << 
105     wrStart = 0;                               << 
106     wrDelta = twopi;                           << 
107   }                                            << 
108   rzcorners.resize(0);                         << 
109   for (G4int i=0; i<numRZ; ++i)                << 
110   {                                            << 
111     rzcorners.emplace_back(r[i],z[i]);         << 
112   }                                            << 
113   std::vector<G4int> iout;                     << 
114   G4GeomTools::RemoveRedundantVertices(rzcorne << 
115 }                                                  68 }
116                                                    69 
117                                                    70 
118 //////////////////////////////////////////////     71 ////////////////////////////////////////////////////////////////////////
119 //                                                 72 //
120 // Fake default constructor - sets only member     73 // Fake default constructor - sets only member data and allocates memory
121 //                            for usage restri     74 //                            for usage restricted to object persistency.
122 //                                                 75 //
123 G4UPolycone::G4UPolycone( __void__& a )            76 G4UPolycone::G4UPolycone( __void__& a )
124   : Base_t(a)                                  <<  77   : G4USolid(a)
125 {                                                  78 {
126 }                                                  79 }
127                                                    80 
128                                                    81 
129 //////////////////////////////////////////////     82 ////////////////////////////////////////////////////////////////////////
130 //                                                 83 //
131 // Destructor                                      84 // Destructor
132 //                                                 85 //
133 G4UPolycone::~G4UPolycone() = default;         <<  86 G4UPolycone::~G4UPolycone()
                                                   >>  87 {
                                                   >>  88 }
134                                                    89 
135                                                    90 
136 //////////////////////////////////////////////     91 ////////////////////////////////////////////////////////////////////////
137 //                                                 92 //
138 // Copy constructor                                93 // Copy constructor
139 //                                                 94 //
140 G4UPolycone::G4UPolycone( const G4UPolycone& s <<  95 G4UPolycone::G4UPolycone( const G4UPolycone &source )
141   : Base_t( source )                           <<  96   : G4USolid( source )
142 {                                                  97 {
143   fGenericPcon = source.fGenericPcon;          << 
144   fOriginalParameters = source.fOriginalParame << 
145   wrStart   = source.wrStart;                  << 
146   wrDelta   = source.wrDelta;                  << 
147   rzcorners = source.rzcorners;                << 
148 }                                                  98 }
149                                                    99 
150                                                   100 
151 //////////////////////////////////////////////    101 ////////////////////////////////////////////////////////////////////////
152 //                                                102 //
153 // Assignment operator                            103 // Assignment operator
154 //                                                104 //
155 G4UPolycone& G4UPolycone::operator=( const G4U << 105 G4UPolycone &G4UPolycone::operator=( const G4UPolycone &source )
156 {                                                 106 {
157   if (this == &source) return *this;              107   if (this == &source) return *this;
158                                                << 108   
159   Base_t::operator=( source );                 << 109   G4USolid::operator=( source );
160   fGenericPcon = source.fGenericPcon;          << 110   
161   fOriginalParameters = source.fOriginalParame << 
162   wrStart   = source.wrStart;                  << 
163   wrDelta   = source.wrDelta;                  << 
164   rzcorners = source.rzcorners;                << 
165                                                << 
166   return *this;                                   111   return *this;
167 }                                                 112 }
168                                                   113 
169                                                   114 
170 //////////////////////////////////////////////    115 ////////////////////////////////////////////////////////////////////////
171 //                                                116 //
172 // Accessors & modifiers                          117 // Accessors & modifiers
173 //                                                118 //
174 G4double G4UPolycone::GetStartPhi() const         119 G4double G4UPolycone::GetStartPhi() const
175 {                                                 120 {
176   return wrStart;                              << 121   return GetShape()->GetStartPhi();
177 }                                              << 
178 G4double G4UPolycone::GetDeltaPhi() const      << 
179 {                                              << 
180   return wrDelta;                              << 
181 }                                                 122 }
182 G4double G4UPolycone::GetEndPhi() const           123 G4double G4UPolycone::GetEndPhi() const
183 {                                                 124 {
184   return (wrStart + wrDelta);                  << 125   return GetShape()->GetEndPhi();
185 }                                              << 
186 G4double G4UPolycone::GetSinStartPhi() const   << 
187 {                                              << 
188   if (!IsOpen()) return 0.;                    << 
189   G4double phi = GetStartPhi();                << 
190   return std::sin(phi);                        << 
191 }                                              << 
192 G4double G4UPolycone::GetCosStartPhi() const   << 
193 {                                              << 
194   if (!IsOpen()) return 1.;                    << 
195   G4double phi = GetStartPhi();                << 
196   return std::cos(phi);                        << 
197 }                                              << 
198 G4double G4UPolycone::GetSinEndPhi() const     << 
199 {                                              << 
200   if (!IsOpen()) return 0.;                    << 
201   G4double phi = GetEndPhi();                  << 
202   return std::sin(phi);                        << 
203 }                                              << 
204 G4double G4UPolycone::GetCosEndPhi() const     << 
205 {                                              << 
206   if (!IsOpen()) return 1.;                    << 
207   G4double phi = GetEndPhi();                  << 
208   return std::cos(phi);                        << 
209 }                                                 126 }
210 G4bool G4UPolycone::IsOpen() const                127 G4bool G4UPolycone::IsOpen() const
211 {                                                 128 {
212   return (wrDelta < twopi);                    << 129   return GetShape()->IsOpen();
213 }                                                 130 }
214 G4int G4UPolycone::GetNumRZCorner() const         131 G4int G4UPolycone::GetNumRZCorner() const
215 {                                                 132 {
216   return rzcorners.size();                     << 133   return GetShape()->GetNumRZCorner();
217 }                                                 134 }
218 G4PolyconeSideRZ G4UPolycone::GetCorner(G4int     135 G4PolyconeSideRZ G4UPolycone::GetCorner(G4int index) const
219 {                                                 136 {
220   G4TwoVector rz = rzcorners.at(index);        << 137   UPolyconeSideRZ pside = GetShape()->GetCorner(index);
221   G4PolyconeSideRZ psiderz = { rz.x(), rz.y()  << 138   G4PolyconeSideRZ psiderz = { pside.r, pside.z };
222                                                   139 
223   return psiderz;                                 140   return psiderz;
224 }                                                 141 }
225 G4PolyconeHistorical* G4UPolycone::GetOriginal    142 G4PolyconeHistorical* G4UPolycone::GetOriginalParameters() const
226 {                                                 143 {
227   return new G4PolyconeHistorical(fOriginalPar << 144   UPolyconeHistorical* pars = GetShape()->GetOriginalParameters();
228 }                                              << 145   G4PolyconeHistorical* pdata = new G4PolyconeHistorical(pars->fNumZPlanes);
229 void G4UPolycone::SetOriginalParameters()      << 146   pdata->Start_angle = pars->fStartAngle;
230 {                                              << 147   pdata->Opening_angle = pars->fOpeningAngle;
231   vecgeom::PolyconeHistorical* original_parame << 148   for (G4int i=0; i<pars->fNumZPlanes; ++i)
232                                                << 149   {
233   fOriginalParameters.Start_angle   = original << 150     pdata->Z_values[i] = pars->fZValues[i];
234   fOriginalParameters.Opening_angle = original << 151     pdata->Rmin[i] = pars->Rmin[i];
235   fOriginalParameters.Num_z_planes  = original << 152     pdata->Rmax[i] = pars->Rmax[i];
236                                                << 
237   delete [] fOriginalParameters.Z_values;      << 
238   delete [] fOriginalParameters.Rmin;          << 
239   delete [] fOriginalParameters.Rmax;          << 
240                                                << 
241   G4int numPlanes = fOriginalParameters.Num_z_ << 
242   fOriginalParameters.Z_values = new G4double[ << 
243   fOriginalParameters.Rmin = new G4double[numP << 
244   fOriginalParameters.Rmax = new G4double[numP << 
245   for (G4int i=0; i<numPlanes; ++i)            << 
246   {                                            << 
247     fOriginalParameters.Z_values[i] = original << 
248     fOriginalParameters.Rmin[i]     = original << 
249     fOriginalParameters.Rmax[i]     = original << 
250   }                                               153   }
                                                   >> 154   return pdata;
251 }                                                 155 }
252 void G4UPolycone::SetOriginalParameters(G4Poly    156 void G4UPolycone::SetOriginalParameters(G4PolyconeHistorical* pars)
253 {                                                 157 {
254   fOriginalParameters = *pars;                 << 158   UPolyconeHistorical* pdata = GetShape()->GetOriginalParameters();
                                                   >> 159   pdata->fStartAngle = pars->Start_angle;
                                                   >> 160   pdata->fOpeningAngle = pars->Opening_angle;
                                                   >> 161   pdata->fNumZPlanes = pars->Num_z_planes;
                                                   >> 162   for (G4int i=0; i<pdata->fNumZPlanes; ++i)
                                                   >> 163   {
                                                   >> 164     pdata->fZValues[i] = pars->Z_values[i];
                                                   >> 165     pdata->Rmin[i] = pars->Rmin[i];
                                                   >> 166     pdata->Rmax[i] = pars->Rmax[i];
                                                   >> 167   }
255   fRebuildPolyhedron = true;                      168   fRebuildPolyhedron = true;
256   Reset();                                     << 
257 }                                                 169 }
258                                                << 
259 G4bool G4UPolycone::Reset()                       170 G4bool G4UPolycone::Reset()
260 {                                                 171 {
261   if (fGenericPcon)                            << 172   GetShape()->Reset();
262   {                                            << 173   return 0;
263     std::ostringstream message;                << 
264     message << "Solid " << GetName() << " buil << 
265             << G4endl << "Not applicable to th << 
266     G4Exception("G4UPolycone::Reset()", "GeomS << 
267                 JustWarning, message, "Paramet << 
268     return true;  // error code set            << 
269   }                                            << 
270                                                << 
271   //                                           << 
272   // Rebuild polycone based on original parame << 
273   //                                           << 
274   wrStart = fOriginalParameters.Start_angle;   << 
275   while (wrStart < 0.)                         << 
276   {                                            << 
277     wrStart += twopi;                          << 
278   }                                            << 
279   wrDelta = fOriginalParameters.Opening_angle; << 
280   if (wrDelta <= 0. || wrDelta >= twopi*(1-DBL << 
281   {                                            << 
282     wrStart = 0.;                              << 
283     wrDelta = twopi;                           << 
284   }                                            << 
285   rzcorners.resize(0);                         << 
286   for (G4int i=0; i<fOriginalParameters.Num_z_ << 
287     {                                          << 
288       G4double z = fOriginalParameters.Z_value << 
289       G4double r = fOriginalParameters.Rmax[i] << 
290       rzcorners.emplace_back(r,z);             << 
291     }                                          << 
292   for (G4int i=fOriginalParameters.Num_z_plane << 
293     {                                          << 
294       G4double z = fOriginalParameters.Z_value << 
295       G4double r = fOriginalParameters.Rmin[i] << 
296       rzcorners.emplace_back(r,z);             << 
297     }                                          << 
298   std::vector<G4int> iout;                     << 
299   G4GeomTools::RemoveRedundantVertices(rzcorne << 
300                                                << 
301   return false;  // error code unset           << 
302 }                                                 174 }
303                                                   175 
304 //////////////////////////////////////////////    176 ////////////////////////////////////////////////////////////////////////
305 //                                                177 //
306 // Dispatch to parameterisation for replicatio    178 // Dispatch to parameterisation for replication mechanism dimension
307 // computation & modification.                    179 // computation & modification.
308 //                                                180 //
309 void G4UPolycone::ComputeDimensions(G4VPVParam    181 void G4UPolycone::ComputeDimensions(G4VPVParameterisation* p,
310                                     const G4in    182                                     const G4int n,
311                                     const G4VP    183                                     const G4VPhysicalVolume* pRep)
312 {                                                 184 {
313   p->ComputeDimensions(*(G4Polycone*)this,n,pR    185   p->ComputeDimensions(*(G4Polycone*)this,n,pRep);
314 }                                                 186 }
315                                                   187 
316                                                   188 
317 //////////////////////////////////////////////    189 //////////////////////////////////////////////////////////////////////////
318 //                                                190 //
319 // Make a clone of the object                     191 // Make a clone of the object
320                                                   192 
321 G4VSolid* G4UPolycone::Clone() const              193 G4VSolid* G4UPolycone::Clone() const
322 {                                                 194 {
323   return new G4UPolycone(*this);                  195   return new G4UPolycone(*this);
324 }                                                 196 }
325                                                   197 
326 ////////////////////////////////////////////// << 
327 //                                             << 
328 // Get bounding box                            << 
329                                                << 
330 void G4UPolycone::BoundingLimits(G4ThreeVector << 
331                                  G4ThreeVector << 
332 {                                              << 
333   static G4bool checkBBox = true;              << 
334   static G4bool checkPhi  = true;              << 
335                                                << 
336   G4double rmin = kInfinity, rmax = -kInfinity << 
337   G4double zmin = kInfinity, zmax = -kInfinity << 
338                                                << 
339   for (G4int i=0; i<GetNumRZCorner(); ++i)     << 
340   {                                            << 
341     G4PolyconeSideRZ corner = GetCorner(i);    << 
342     if (corner.r < rmin) rmin = corner.r;      << 
343     if (corner.r > rmax) rmax = corner.r;      << 
344     if (corner.z < zmin) zmin = corner.z;      << 
345     if (corner.z > zmax) zmax = corner.z;      << 
346   }                                            << 
347                                                << 
348   if (IsOpen())                                << 
349   {                                            << 
350     G4TwoVector vmin,vmax;                     << 
351     G4GeomTools::DiskExtent(rmin,rmax,         << 
352                             GetSinStartPhi(),G << 
353                             GetSinEndPhi(),Get << 
354                             vmin,vmax);        << 
355     pMin.set(vmin.x(),vmin.y(),zmin);          << 
356     pMax.set(vmax.x(),vmax.y(),zmax);          << 
357   }                                            << 
358   else                                         << 
359   {                                            << 
360     pMin.set(-rmax,-rmax, zmin);               << 
361     pMax.set( rmax, rmax, zmax);               << 
362   }                                            << 
363                                                << 
364   // Check correctness of the bounding box     << 
365   //                                           << 
366   if (pMin.x() >= pMax.x() || pMin.y() >= pMax << 
367   {                                            << 
368     std::ostringstream message;                << 
369     message << "Bad bounding box (min >= max)  << 
370             << GetName() << " !"               << 
371             << "\npMin = " << pMin             << 
372             << "\npMax = " << pMax;            << 
373     G4Exception("G4UPolycone::BoundingLimits() << 
374                 JustWarning, message);         << 
375     StreamInfo(G4cout);                        << 
376   }                                            << 
377                                                << 
378   // Check consistency of bounding boxes       << 
379   //                                           << 
380   if (checkBBox)                               << 
381   {                                            << 
382     U3Vector vmin, vmax;                       << 
383     Extent(vmin,vmax);                         << 
384     if (std::abs(pMin.x()-vmin.x()) > kCarTole << 
385         std::abs(pMin.y()-vmin.y()) > kCarTole << 
386         std::abs(pMin.z()-vmin.z()) > kCarTole << 
387         std::abs(pMax.x()-vmax.x()) > kCarTole << 
388         std::abs(pMax.y()-vmax.y()) > kCarTole << 
389         std::abs(pMax.z()-vmax.z()) > kCarTole << 
390     {                                          << 
391       std::ostringstream message;              << 
392       message << "Inconsistency in bounding bo << 
393               << GetName() << " !"             << 
394               << "\nBBox min: wrapper = " << p << 
395               << "\nBBox max: wrapper = " << p << 
396       G4Exception("G4UPolycone::BoundingLimits << 
397                   JustWarning, message);       << 
398       checkBBox = false;                       << 
399     }                                          << 
400   }                                            << 
401                                                << 
402   // Check consistency of angles               << 
403   //                                           << 
404   if (checkPhi)                                << 
405   {                                            << 
406     if (GetStartPhi() != Base_t::GetStartPhi() << 
407         GetEndPhi()   != Base_t::GetEndPhi()   << 
408         IsOpen()      != (Base_t::GetDeltaPhi( << 
409     {                                          << 
410       std::ostringstream message;              << 
411       message << "Inconsistency in Phi angles  << 
412               << GetName() << " !"             << 
413               << "\nPhi start  : wrapper = " < << 
414               << " solid = " <<     Base_t::Ge << 
415               << "\nPhi end    : wrapper = " < << 
416               << " solid = " <<     Base_t::Ge << 
417               << "\nPhi is open: wrapper = " < << 
418               << " solid = "                   << 
419               << ((Base_t::GetDeltaPhi() < two << 
420       G4Exception("G4UPolycone::BoundingLimits << 
421                   JustWarning, message);       << 
422       checkPhi = false;                        << 
423     }                                          << 
424   }                                            << 
425 }                                              << 
426                                                << 
427 ////////////////////////////////////////////// << 
428 //                                             << 
429 // Calculate extent under transform and specif << 
430                                                << 
431 G4bool G4UPolycone::CalculateExtent(const EAxi << 
432                                     const G4Vo << 
433                                     const G4Af << 
434                                           G4do << 
435 {                                              << 
436   G4ThreeVector bmin, bmax;                    << 
437   G4bool exist;                                << 
438                                                << 
439   // Check bounding box (bbox)                 << 
440   //                                           << 
441   BoundingLimits(bmin,bmax);                   << 
442   G4BoundingEnvelope bbox(bmin,bmax);          << 
443 #ifdef G4BBOX_EXTENT                           << 
444   return bbox.CalculateExtent(pAxis,pVoxelLimi << 
445 #endif                                         << 
446   if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVox << 
447   {                                            << 
448     return exist = pMin < pMax;                << 
449   }                                            << 
450                                                << 
451   // To find the extent, RZ contour of the pol << 
452   // in triangles. The extent is calculated as << 
453   // all sub-polycones formed by rotation of t << 
454   //                                           << 
455   G4TwoVectorList contourRZ;                   << 
456   G4TwoVectorList triangles;                   << 
457   std::vector<G4int> iout;                     << 
458   G4double eminlim = pVoxelLimit.GetMinExtent( << 
459   G4double emaxlim = pVoxelLimit.GetMaxExtent( << 
460                                                << 
461   // get RZ contour, ensure anticlockwise orde << 
462   for (G4int i=0; i<GetNumRZCorner(); ++i)     << 
463   {                                            << 
464     G4PolyconeSideRZ corner = GetCorner(i);    << 
465     contourRZ.emplace_back(corner.r,corner.z); << 
466   }                                            << 
467   G4GeomTools::RemoveRedundantVertices(contour << 
468   G4double area = G4GeomTools::PolygonArea(con << 
469   if (area < 0.) std::reverse(contourRZ.begin( << 
470                                                << 
471   // triangulate RZ countour                   << 
472   if (!G4GeomTools::TriangulatePolygon(contour << 
473   {                                            << 
474     std::ostringstream message;                << 
475     message << "Triangulation of RZ contour ha << 
476             << GetName() << " !"               << 
477             << "\nExtent has been calculated u << 
478     G4Exception("G4UPolycone::CalculateExtent( << 
479                 "GeomMgt1002", JustWarning, me << 
480     return bbox.CalculateExtent(pAxis,pVoxelLi << 
481   }                                            << 
482                                                << 
483   // set trigonometric values                  << 
484   const G4int NSTEPS = 24;            // numbe << 
485   G4double astep  = twopi/NSTEPS;     // max a << 
486                                                << 
487   G4double sphi   = GetStartPhi();             << 
488   G4double ephi   = GetEndPhi();               << 
489   G4double dphi   = IsOpen() ? ephi-sphi : two << 
490   G4int    ksteps = (dphi <= astep) ? 1 : (G4i << 
491   G4double ang    = dphi/ksteps;               << 
492                                                << 
493   G4double sinHalf = std::sin(0.5*ang);        << 
494   G4double cosHalf = std::cos(0.5*ang);        << 
495   G4double sinStep = 2.*sinHalf*cosHalf;       << 
496   G4double cosStep = 1. - 2.*sinHalf*sinHalf;  << 
497                                                << 
498   G4double sinStart = GetSinStartPhi();        << 
499   G4double cosStart = GetCosStartPhi();        << 
500   G4double sinEnd   = GetSinEndPhi();          << 
501   G4double cosEnd   = GetCosEndPhi();          << 
502                                                << 
503   // define vectors and arrays                 << 
504   std::vector<const G4ThreeVectorList *> polyg << 
505   polygons.resize(ksteps+2);                   << 
506   G4ThreeVectorList pols[NSTEPS+2];            << 
507   for (G4int k=0; k<ksteps+2; ++k) pols[k].res << 
508   for (G4int k=0; k<ksteps+2; ++k) polygons[k] << 
509   G4double r0[6],z0[6]; // contour with origin << 
510   G4double r1[6];       // shifted radii of ex << 
511                                                << 
512   // main loop along triangles                 << 
513   pMin = kInfinity;                            << 
514   pMax =-kInfinity;                            << 
515   G4int ntria = triangles.size()/3;            << 
516   for (G4int i=0; i<ntria; ++i)                << 
517   {                                            << 
518     G4int i3 = i*3;                            << 
519     for (G4int k=0; k<3; ++k)                  << 
520     {                                          << 
521       G4int e0 = i3+k, e1 = (k<2) ? e0+1 : i3; << 
522       G4int k2 = k*2;                          << 
523       // set contour with original edges of tr << 
524       r0[k2+0] = triangles[e0].x(); z0[k2+0] = << 
525       r0[k2+1] = triangles[e1].x(); z0[k2+1] = << 
526       // set shifted radii                     << 
527       r1[k2+0] = r0[k2+0];                     << 
528       r1[k2+1] = r0[k2+1];                     << 
529       if (z0[k2+1] - z0[k2+0] <= 0) continue;  << 
530       r1[k2+0] /= cosHalf;                     << 
531       r1[k2+1] /= cosHalf;                     << 
532     }                                          << 
533                                                << 
534     // rotate countour, set sequence of 6-side << 
535     G4double sinCur = sinStart*cosHalf + cosSt << 
536     G4double cosCur = cosStart*cosHalf - sinSt << 
537     for (G4int j=0; j<6; ++j) pols[0][j].set(r << 
538     for (G4int k=1; k<ksteps+1; ++k)           << 
539     {                                          << 
540       for (G4int j=0; j<6; ++j) pols[k][j].set << 
541       G4double sinTmp = sinCur;                << 
542       sinCur = sinCur*cosStep + cosCur*sinStep << 
543       cosCur = cosCur*cosStep - sinTmp*sinStep << 
544     }                                          << 
545     for (G4int j=0; j<6; ++j) pols[ksteps+1][j << 
546                                                << 
547     // set sub-envelope and adjust extent      << 
548     G4double emin,emax;                        << 
549     G4BoundingEnvelope benv(polygons);         << 
550     if (!benv.CalculateExtent(pAxis,pVoxelLimi << 
551     if (emin < pMin) pMin = emin;              << 
552     if (emax > pMax) pMax = emax;              << 
553     if (eminlim > pMin && emaxlim < pMax) retu << 
554   }                                            << 
555   return (pMin < pMax);                        << 
556 }                                              << 
557                                                   198 
558 //////////////////////////////////////////////    199 ////////////////////////////////////////////////////////////////////////
559 //                                                200 //
560 // CreatePolyhedron                               201 // CreatePolyhedron
561 //                                                202 //
562 G4Polyhedron* G4UPolycone::CreatePolyhedron()     203 G4Polyhedron* G4UPolycone::CreatePolyhedron() const
563 {                                                 204 {
564   return new G4PolyhedronPcon(wrStart, wrDelta << 205   G4PolyconeHistorical* original_parameters = GetOriginalParameters();
                                                   >> 206   G4PolyhedronPcon*
                                                   >> 207   polyhedron = new G4PolyhedronPcon( original_parameters->Start_angle,
                                                   >> 208                                      original_parameters->Opening_angle,
                                                   >> 209                                      original_parameters->Num_z_planes,
                                                   >> 210                                      original_parameters->Z_values,
                                                   >> 211                                      original_parameters->Rmin,
                                                   >> 212                                      original_parameters->Rmax );
                                                   >> 213 
                                                   >> 214   delete original_parameters;  // delete local copy 
                                                   >> 215 
                                                   >> 216   return polyhedron;
565 }                                                 217 }
566                                                   218 
567 #endif  // G4GEOM_USE_USOLIDS                     219 #endif  // G4GEOM_USE_USOLIDS
568                                                   220