Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/CSG/src/G4Trap.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/CSG/src/G4Trap.cc (Version 11.3.0) and /geometry/solids/CSG/src/G4Trap.cc (Version 3.2)


  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 //
                                                   >>  23 //
                                                   >>  24 // $Id: G4Trap.cc,v 1.11.2.1 2001/06/28 19:09:02 gunter Exp $
                                                   >>  25 // GEANT4 tag $Name:  $
                                                   >>  26 //
                                                   >>  27 // class G4Trap
                                                   >>  28 //
 26 // Implementation for G4Trap class                 29 // Implementation for G4Trap class
 27 //                                                 30 //
                                                   >>  31 // History:
 28 // 21.03.95 P.Kent: Modified for `tolerant' ge     32 // 21.03.95 P.Kent: Modified for `tolerant' geometry
 29 // 09.09.96 V.Grichine: Final modifications be <<  33 //  9.09.96 V. Grichine: Final modifications before to commit
 30 // 08.12.97 J.Allison: Added "nominal" constru <<  34 //  1.11.96 V.Grichine Costructor for Right Angular Wedge from STEP & G4Trd/Para
 31 // 28.04.05 V.Grichine: new SurfaceNormal acco <<  35 //  8.12.97 J.Allison: Added "nominal" constructor and method SetAllParameters.
 32 // 18.04.17 E.Tcherniaev: complete revision, s <<  36 //  4.06.99 S.Giani: Fixed CalculateExtent in rotated case. 
 33 // ------------------------------------------- <<  37 // 19.11.99 V.Grichine, kUndefined was added to Eside enum
                                                   >>  38 // 13.12.99 V.Grichine, bug fixed in DistanceToIn(p,v)
 34                                                    39 
 35 #include "G4Trap.hh"                               40 #include "G4Trap.hh"
 36                                                << 
 37 #if !defined(G4GEOM_USE_UTRAP)                 << 
 38                                                << 
 39 #include "globals.hh"                          << 
 40 #include "G4GeomTools.hh"                      << 
 41                                                << 
 42 #include "G4VoxelLimits.hh"                        41 #include "G4VoxelLimits.hh"
 43 #include "G4AffineTransform.hh"                    42 #include "G4AffineTransform.hh"
 44 #include "G4BoundingEnvelope.hh"               << 
 45                                                    43 
 46 #include "G4VPVParameterisation.hh"                44 #include "G4VPVParameterisation.hh"
 47                                                    45 
 48 #include "G4QuickRand.hh"                      << 
 49                                                << 
 50 #include "G4VGraphicsScene.hh"                     46 #include "G4VGraphicsScene.hh"
 51 #include "G4Polyhedron.hh"                         47 #include "G4Polyhedron.hh"
                                                   >>  48 #include "G4NURBS.hh"
                                                   >>  49 #include "G4NURBSbox.hh"
                                                   >>  50 
                                                   >>  51 ////////////////////////////////////////////////////////////////////////
                                                   >>  52 //
                                                   >>  53 // Accuracy of coplanarity
 52                                                    54 
 53 using namespace CLHEP;                         <<  55 const G4double kCoplanar_Tolerance = 1E-4 ;
 54                                                    56 
 55 //////////////////////////////////////////////     57 //////////////////////////////////////////////////////////////////////////
 56 //                                                 58 //
 57 // Constructor - check and set half-widths as  <<  59 // Private enum: Not for external use 
 58 // final check of coplanarity                  <<  60     
 59                                                <<  61 enum Eside {kUndefined,ks0,ks1,ks2,ks3,kPZ,kMZ};
 60 G4Trap::G4Trap( const G4String& pName,         << 
 61                       G4double pDz,            << 
 62                       G4double pTheta, G4doubl << 
 63                       G4double pDy1, G4double  << 
 64                       G4double pAlp1,          << 
 65                       G4double pDy2, G4double  << 
 66                       G4double pAlp2 )         << 
 67   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 
 68 {                                              << 
 69   fDz = pDz;                                   << 
 70   fTthetaCphi = std::tan(pTheta)*std::cos(pPhi << 
 71   fTthetaSphi = std::tan(pTheta)*std::sin(pPhi << 
 72                                                    62 
 73   fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx2; fTalp <<  63 ////////////////////////////////////////////////////////////////////////
 74   fDy2 = pDy2; fDx3 = pDx3; fDx4 = pDx4; fTalp <<  64 //
                                                   >>  65 // Destructor
 75                                                    66 
 76   CheckParameters();                           <<  67 G4Trap::~G4Trap()
 77   MakePlanes();                                <<  68 {
                                                   >>  69     ;
 78 }                                                  70 }
 79                                                    71 
 80 //////////////////////////////////////////////     72 //////////////////////////////////////////////////////////////////////////
 81 //                                                 73 //
 82 // Constructor - Design of trapezoid based on  <<  74 // Constructor - check and set half-widths as well as angles: 
 83 // which are its vertices. Checking of planari <<  75 // final check of coplanarity
                                                   >>  76 
                                                   >>  77 G4Trap::G4Trap( const G4String& pName,
                                                   >>  78           G4double pDz,
                                                   >>  79           G4double pTheta, G4double pPhi,
                                                   >>  80           G4double pDy1, G4double pDx1, G4double pDx2,
                                                   >>  81     G4double pAlp1,
                                                   >>  82           G4double pDy2, G4double pDx3, G4double pDx4,
                                                   >>  83           G4double pAlp2) : G4CSGSolid(pName)
                                                   >>  84 {
                                                   >>  85   if ( pDz > 0 && pDy1 > 0 && pDx1 > 0 && 
                                                   >>  86        pDx2 > 0 && pDy2 > 0 && pDx3 > 0 && pDx4 > 0 )
                                                   >>  87   {
                                                   >>  88     fDz=pDz;
                                                   >>  89     fTthetaCphi=tan(pTheta)*cos(pPhi);
                                                   >>  90     fTthetaSphi=tan(pTheta)*sin(pPhi);
                                                   >>  91       
                                                   >>  92     fDy1=pDy1;
                                                   >>  93     fDx1=pDx1;
                                                   >>  94     fDx2=pDx2;
                                                   >>  95     fTalpha1=tan(pAlp1);
                                                   >>  96      
                                                   >>  97     fDy2=pDy2;
                                                   >>  98     fDx3=pDx3;
                                                   >>  99     fDx4=pDx4;
                                                   >> 100     fTalpha2=tan(pAlp2);
                                                   >> 101 
                                                   >> 102     MakePlanes();
                                                   >> 103   }
                                                   >> 104   else G4Exception("Error in G4Trap::G4Trap - Invalid Length G4Trap parameters");
                                                   >> 105 }
                                                   >> 106 
                                                   >> 107 ////////////////////////////////////////////////////////////////////////////
                                                   >> 108 //
                                                   >> 109 // Constructor - Design of trapezoid based on 8 G4ThreeVector parameters, 
                                                   >> 110 // which are its vertices. Checking of planarity with preparation of 
 84 // fPlanes[] and than calculation of other mem    111 // fPlanes[] and than calculation of other members
 85                                                   112 
 86 G4Trap::G4Trap( const G4String& pName,            113 G4Trap::G4Trap( const G4String& pName,
 87                 const G4ThreeVector pt[8] )    << 114           const G4ThreeVector pt[8]) : G4CSGSolid(pName)
 88   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 
 89 {                                                 115 {
 90   // Start with check of centering - the cente << 116     if (   pt[0].z()<0 && pt[0].z()==pt[1].z() && pt[0].z()==pt[2].z() && pt[0].z()==pt[3].z()
 91   // should cross the origin of frame          << 117   && pt[4].z()>0 && pt[4].z()==pt[5].z() && pt[4].z()==pt[6].z() && pt[4].z()==pt[7].z()
 92   //                                           << 118   && (pt[0].z()+pt[4].z())== 0
 93   if (  pt[0].z() >= 0                         << 119   && pt[0].y()==pt[1].y() && pt[2].y()==pt[3].y()
 94         || pt[0].z() != pt[1].z()              << 120   && pt[4].y()==pt[5].y() && pt[6].y()==pt[7].y()
 95         || pt[0].z() != pt[2].z()              << 121   && (pt[0].y()+pt[2].y()+pt[4].y()+pt[6].y())==0      )
 96         || pt[0].z() != pt[3].z()              << 122      {
 97                                                << 123         G4bool good;
 98         || pt[4].z() <= 0                      << 124     
 99         || pt[4].z() != pt[5].z()              << 125 // Bottom side with normal approx. -Y
100         || pt[4].z() != pt[6].z()              << 126       good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]);
101         || pt[4].z() != pt[7].z()              << 127       if (!good)
102                                                << 128     {
103         || std::fabs( pt[0].z() + pt[4].z() )  << 129         G4Exception("G4Trap::G4Trap - face at ~-Y not planar");
104                                                << 130 
105         || pt[0].y() != pt[1].y()              << 131     }
106         || pt[2].y() != pt[3].y()              << 132 // Top side with normal approx. +Y
107         || pt[4].y() != pt[5].y()              << 133       good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
108         || pt[6].y() != pt[7].y()              << 134       if (!good)
109                                                << 135     {
110         || std::fabs(pt[0].y()+pt[2].y()+pt[4] << 136         G4Exception("G4Trap::G4Trap - face at ~+Y not planar");
111         || std::fabs(pt[0].x()+pt[1].x()+pt[4] << 137     }
112                      pt[2].x()+pt[3].x()+pt[6] << 138 // Front side with normal approx. -X
113   {                                            << 139       good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
114     std::ostringstream message;                << 140       if (!good)
115     message << "Invalid vertice coordinates fo << 141     {
116     G4Exception("G4Trap::G4Trap()", "GeomSolid << 142         G4Exception("G4Trap::G4Trap - face at ~-X not planar");
117                 FatalException, message);      << 143     }
118   }                                            << 144 // Back side iwth normal approx. +X
                                                   >> 145       good=MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
                                                   >> 146       if (!good)
                                                   >> 147     {
                                                   >> 148         G4Exception("G4Trap::G4Trap - face at ~+X not planar");
                                                   >> 149     }
                                                   >> 150 
                                                   >> 151      fDz = (pt[7]).z() ;
                                                   >> 152       
                                                   >> 153      fDy1 = ((pt[2]).y()-(pt[1]).y())*0.5 ;
                                                   >> 154      fDx1 = ((pt[1]).x()-(pt[0]).x())*0.5 ;
                                                   >> 155      fDx2 = ((pt[3]).x()-(pt[2]).x())*0.5 ;
                                                   >> 156      fTalpha1 = ((pt[2]).x()+(pt[3]).x()-(pt[1]).x()-(pt[0]).x())*0.25/fDy1 ;
                                                   >> 157 
                                                   >> 158      fDy2 = ((pt[6]).y()-(pt[5]).y())*0.5 ;
                                                   >> 159      fDx3 = ((pt[5]).x()-(pt[4]).x())*0.5 ;
                                                   >> 160      fDx4 = ((pt[7]).x()-(pt[6]).x())*0.5 ;
                                                   >> 161      fTalpha2 = ((pt[6]).x()+(pt[7]).x()-(pt[5]).x()-(pt[4]).x())*0.25/fDy2 ;
119                                                   162 
120   // Set parameters                            << 163      fTthetaCphi = ((pt[4]).x()+fDy2*fTalpha2+fDx3)/fDz ;
121   //                                           << 164      fTthetaSphi = ((pt[4]).y()+fDy2)/fDz ;
122   fDz = (pt[7]).z();                           << 
123                                                << 
124   fDy1     = ((pt[2]).y()-(pt[1]).y())*0.5;    << 
125   fDx1     = ((pt[1]).x()-(pt[0]).x())*0.5;    << 
126   fDx2     = ((pt[3]).x()-(pt[2]).x())*0.5;    << 
127   fTalpha1 = ((pt[2]).x()+(pt[3]).x()-(pt[1]). << 
128                                                << 
129   fDy2     = ((pt[6]).y()-(pt[5]).y())*0.5;    << 
130   fDx3     = ((pt[5]).x()-(pt[4]).x())*0.5;    << 
131   fDx4     = ((pt[7]).x()-(pt[6]).x())*0.5;    << 
132   fTalpha2 = ((pt[6]).x()+(pt[7]).x()-(pt[5]). << 
133                                                   165 
134   fTthetaCphi = ((pt[4]).x()+fDy2*fTalpha2+fDx << 166   }
135   fTthetaSphi = ((pt[4]).y()+fDy2)/fDz;        << 167     else
                                                   >> 168   {
                                                   >> 169       G4Exception("Error in G4Trap::G4Trap - Invalid vertice coordinates");
                                                   >> 170   }
136                                                   171 
137   CheckParameters();                           << 172     
138   MakePlanes(pt);                              << 
139 }                                                 173 }
140                                                   174 
141 ////////////////////////////////////////////// << 175 //////////////////////////////////////////////////////////////////////////////
142 //                                                176 //
143 // Constructor for Right Angular Wedge from ST    177 // Constructor for Right Angular Wedge from STEP
144                                                   178 
145 G4Trap::G4Trap( const G4String& pName,            179 G4Trap::G4Trap( const G4String& pName,
146                       G4double pZ,             << 180           G4double pZ,
147                       G4double pY,             << 181           G4double pY,
148                       G4double pX, G4double pL << 182     G4double pX, G4double pLTX) : G4CSGSolid(pName) 
149   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 183          
150 {                                              << 184 {
151   fDz  = 0.5*pZ; fTthetaCphi = 0; fTthetaSphi  << 185     G4bool good;
152   fDy1 = 0.5*pY; fDx1 = 0.5*pX; fDx2 = 0.5*pLT << 186 
153   fDy2 = fDy1;   fDx3 = fDx1;   fDx4 = fDx2;   << 187     if (pZ>0 && pY>0 && pX>0 && pLTX>0 && pLTX<=pX)
154                                                << 188   {
155   CheckParameters();                           << 189      fDz = 0.5*pZ ;
156   MakePlanes();                                << 190      fTthetaCphi = 0 ;
                                                   >> 191      fTthetaSphi = 0 ;
                                                   >> 192       
                                                   >> 193      fDy1 = 0.5*pY;
                                                   >> 194      fDx1 = 0.5*pX ;
                                                   >> 195      fDx2 = 0.5*pLTX;
                                                   >> 196      fTalpha1 =  0.5*(pLTX - pX)/pY;
                                                   >> 197      
                                                   >> 198      fDy2 = fDy1 ;
                                                   >> 199      fDx3 = fDx1;
                                                   >> 200      fDx4 = fDx2 ;
                                                   >> 201      fTalpha2 = fTalpha1 ;
                                                   >> 202 
                                                   >> 203      G4ThreeVector pt[8] ;
                                                   >> 204      
                                                   >> 205      pt[0]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 206            pt[1]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 207      pt[2]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 208      pt[3]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 209      pt[4]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 210      pt[5]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 211      pt[6]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 212      pt[7]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 213 // Bottom side with normal approx. -Y
                                                   >> 214       good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]);
                                                   >> 215       if (!good)
                                                   >> 216     {
                                                   >> 217         G4Exception("G4Trap::G4Trap - face at ~-Y not planar");
                                                   >> 218 
                                                   >> 219     }
                                                   >> 220 // Top side with normal approx. +Y
                                                   >> 221       good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
                                                   >> 222       if (!good)
                                                   >> 223     {
                                                   >> 224         G4Exception("G4Trap::G4Trap - face at ~+Y not planar");
                                                   >> 225     }
                                                   >> 226 // Front side with normal approx. -X
                                                   >> 227       good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
                                                   >> 228       if (!good)
                                                   >> 229     {
                                                   >> 230         G4Exception("G4Trap::G4Trap - face at ~-X not planar");
                                                   >> 231     }
                                                   >> 232 // Back side iwth normal approx. +X
                                                   >> 233       good=MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
                                                   >> 234       if (!good)
                                                   >> 235     {
                                                   >> 236         G4Exception("G4Trap::G4Trap - face at ~+X not planar");
                                                   >> 237     }
                                                   >> 238   }
                                                   >> 239     else
                                                   >> 240   {
                                                   >> 241       G4Exception("Error in G4Trap::G4Trap - Invalid Length Trapmeters");
                                                   >> 242   }
157 }                                                 243 }
158                                                   244 
159 ////////////////////////////////////////////// << 245 ///////////////////////////////////////////////////////////////////////////////
160 //                                                246 //
161 // Constructor for G4Trd                          247 // Constructor for G4Trd
162                                                   248 
163 G4Trap::G4Trap( const G4String& pName,            249 G4Trap::G4Trap( const G4String& pName,
164                       G4double pDx1,  G4double << 250           G4double pDx1,  G4double pDx2,
165                       G4double pDy1,  G4double << 251           G4double pDy1,  G4double pDy2,
166                       G4double pDz )           << 252     G4double pDz) : G4CSGSolid(pName)
167   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 253 {
168 {                                              << 254     G4bool good;
169   fDz  = pDz;  fTthetaCphi = 0; fTthetaSphi =  << 255 
170   fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx1; fTalp << 256     if (pDz>0 && pDy1>0 && pDx1>0 && pDx2>0 && pDy2>0 )
171   fDy2 = pDy2; fDx3 = pDx2; fDx4 = pDx2; fTalp << 257   {
172                                                << 258      fDz = pDz;
173   CheckParameters();                           << 259      fTthetaCphi = 0 ;
174   MakePlanes();                                << 260      fTthetaSphi = 0 ;
                                                   >> 261       
                                                   >> 262      fDy1 = pDy1 ;
                                                   >> 263      fDx1 = pDx1 ;
                                                   >> 264      fDx2 = pDx1 ;
                                                   >> 265      fTalpha1 = 0 ;
                                                   >> 266      
                                                   >> 267      fDy2 = pDy2 ;
                                                   >> 268      fDx3 = pDx2 ;
                                                   >> 269      fDx4 = pDx2 ;
                                                   >> 270      fTalpha2 = 0 ;
                                                   >> 271 
                                                   >> 272      G4ThreeVector pt[8] ;
                                                   >> 273      
                                                   >> 274      pt[0]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 275            pt[1]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 276      pt[2]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 277      pt[3]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 278      pt[4]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 279      pt[5]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 280      pt[6]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 281      pt[7]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 282 // Bottom side with normal approx. -Y
                                                   >> 283       good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]);
                                                   >> 284       if (!good)
                                                   >> 285     {
                                                   >> 286         G4Exception("G4Trap::G4Trap - face at ~-Y not planar");
                                                   >> 287 
                                                   >> 288     }
                                                   >> 289 // Top side with normal approx. +Y
                                                   >> 290       good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
                                                   >> 291       if (!good)
                                                   >> 292     {
                                                   >> 293         G4Exception("G4Trap::G4Trap - face at ~+Y not planar");
                                                   >> 294     }
                                                   >> 295 // Front side with normal approx. -X
                                                   >> 296       good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
                                                   >> 297       if (!good)
                                                   >> 298     {
                                                   >> 299         G4Exception("G4Trap::G4Trap - face at ~-X not planar");
                                                   >> 300     }
                                                   >> 301 // Back side iwth normal approx. +X
                                                   >> 302       good=MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
                                                   >> 303       if (!good)
                                                   >> 304     {
                                                   >> 305         G4Exception("G4Trap::G4Trap - face at ~+X not planar");
                                                   >> 306     }
                                                   >> 307   }
                                                   >> 308     else
                                                   >> 309   {
                                                   >> 310       G4Exception("Error in G4Trap::G4Trap - Invalid Length G4Trapmeters");
                                                   >> 311   }
175 }                                                 312 }
176                                                   313 
177 ////////////////////////////////////////////// << 314 ////////////////////////////////////////////////////////////////////////////
178 //                                                315 //
179 // Constructor for G4Para                         316 // Constructor for G4Para
180                                                   317 
181 G4Trap::G4Trap( const G4String& pName,            318 G4Trap::G4Trap( const G4String& pName,
182                       G4double pDx, G4double p << 319     G4double pDx, G4double pDy,
183                       G4double pDz,            << 320           G4double pDz,
184                       G4double pAlpha,         << 321           G4double pAlpha,
185                       G4double pTheta, G4doubl << 322     G4double pTheta, G4double pPhi) : G4CSGSolid(pName)
186   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 323          
187 {                                              << 324 {
188   fDz = pDz;                                   << 325     G4bool good;
189   fTthetaCphi = std::tan(pTheta)*std::cos(pPhi << 326 
190   fTthetaSphi = std::tan(pTheta)*std::sin(pPhi << 327     if (pDz>0 && pDy>0 && pDx>0 )
191                                                << 328   {
192   fDy1 = pDy; fDx1 = pDx; fDx2 = pDx; fTalpha1 << 329      fDz = pDz ;
193   fDy2 = pDy; fDx3 = pDx; fDx4 = pDx; fTalpha2 << 330      fTthetaCphi = tan(pTheta)*cos(pPhi) ;
194                                                << 331      fTthetaSphi = tan(pTheta)*sin(pPhi) ;
195   CheckParameters();                           << 332       
196   MakePlanes();                                << 333      fDy1 = pDy ;
                                                   >> 334      fDx1 = pDx ;
                                                   >> 335      fDx2 = pDx ;
                                                   >> 336      fTalpha1 = tan(pAlpha) ;
                                                   >> 337      
                                                   >> 338      fDy2 = pDy ;
                                                   >> 339      fDx3 = pDx ;
                                                   >> 340      fDx4 = pDx ;
                                                   >> 341      fTalpha2 = fTalpha1 ;
                                                   >> 342 
                                                   >> 343      G4ThreeVector pt[8] ;
                                                   >> 344      
                                                   >> 345      pt[0]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 346            pt[1]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 347      pt[2]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 348      pt[3]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 349      pt[4]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 350      pt[5]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 351      pt[6]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 352      pt[7]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 353 // Bottom side with normal approx. -Y
                                                   >> 354       good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]);
                                                   >> 355       if (!good)
                                                   >> 356     {
                                                   >> 357         G4Exception("G4Trap::G4Trap - face at ~-Y not planar");
                                                   >> 358 
                                                   >> 359     }
                                                   >> 360 // Top side with normal approx. +Y
                                                   >> 361       good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
                                                   >> 362       if (!good)
                                                   >> 363     {
                                                   >> 364         G4Exception("G4Trap::G4Trap - face at ~+Y not planar");
                                                   >> 365     }
                                                   >> 366 // Front side with normal approx. -X
                                                   >> 367       good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
                                                   >> 368       if (!good)
                                                   >> 369     {
                                                   >> 370         G4Exception("G4Trap::G4Trap - face at ~-X not planar");
                                                   >> 371     }
                                                   >> 372 // Back side iwth normal approx. +X
                                                   >> 373       good=MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
                                                   >> 374       if (!good)
                                                   >> 375     {
                                                   >> 376         G4Exception("G4Trap::G4Trap - face at ~+X not planar");
                                                   >> 377     }
                                                   >> 378   }
                                                   >> 379     else
                                                   >> 380   {
                                                   >> 381       G4Exception("Error in G4Trap::G4Trap - Invalid Length G4Trapmeters");
                                                   >> 382   }
197 }                                                 383 }
198                                                   384 
199 ////////////////////////////////////////////// << 385 ///////////////////////////////////////////////////////////////////////////
200 //                                                386 //
201 // Nominal constructor for G4Trap whose parame    387 // Nominal constructor for G4Trap whose parameters are to be set by
202 // a G4VParamaterisation later.  Check and set    388 // a G4VParamaterisation later.  Check and set half-widths as well as
203 // angles: final check of coplanarity             389 // angles: final check of coplanarity
204                                                   390 
205 G4Trap::G4Trap( const G4String& pName )        << 391 G4Trap::G4Trap( const G4String& pName) :
206   : G4CSGSolid (pName), halfCarTolerance(0.5*k << 392   G4CSGSolid (pName),
207     fDz(1.), fTthetaCphi(0.), fTthetaSphi(0.), << 393   fDz         (1.),
208     fDy1(1.), fDx1(1.), fDx2(1.), fTalpha1(0.) << 394   fTthetaCphi (0.),
209     fDy2(1.), fDx3(1.), fDx4(1.), fTalpha2(0.) << 395   fTthetaSphi (0.),
                                                   >> 396   fDy1        (1.),
                                                   >> 397   fDx1        (1.),
                                                   >> 398   fDx2        (1.),
                                                   >> 399   fTalpha1    (0.),
                                                   >> 400   fDy2        (1.),
                                                   >> 401   fDx3        (1.),
                                                   >> 402   fDx4        (1.),
                                                   >> 403   fTalpha2    (0.)
210 {                                                 404 {
211   MakePlanes();                                << 405   ;
212 }                                                 406 }
213                                                   407 
214 ////////////////////////////////////////////// << 408 ///////////////////////////////////////////////////////////////////////
215 //                                             << 
216 // Fake default constructor - sets only member << 
217 //                            for usage restri << 
218 //                                             << 
219 G4Trap::G4Trap( __void__& a )                  << 
220   : G4CSGSolid(a), halfCarTolerance(0.5*kCarTo << 
221     fDz(1.), fTthetaCphi(0.), fTthetaSphi(0.), << 
222     fDy1(1.), fDx1(1.), fDx2(1.), fTalpha1(0.) << 
223     fDy2(1.), fDx3(1.), fDx4(1.), fTalpha2(0.) << 
224 {                                              << 
225   MakePlanes();                                << 
226 }                                              << 
227                                                << 
228 ////////////////////////////////////////////// << 
229 //                                             << 
230 // Destructor                                  << 
231                                                << 
232 G4Trap::~G4Trap() = default;                   << 
233                                                << 
234 ////////////////////////////////////////////// << 
235 //                                             << 
236 // Copy constructor                            << 
237                                                << 
238 G4Trap::G4Trap(const G4Trap& rhs)              << 
239   : G4CSGSolid(rhs), halfCarTolerance(rhs.half << 
240     fDz(rhs.fDz), fTthetaCphi(rhs.fTthetaCphi) << 
241     fDy1(rhs.fDy1), fDx1(rhs.fDx1), fDx2(rhs.f << 
242     fDy2(rhs.fDy2), fDx3(rhs.fDx3), fDx4(rhs.f << 
243 {                                              << 
244   for (G4int i=0; i<4; ++i) { fPlanes[i] = rhs << 
245   for (G4int i=0; i<6; ++i) { fAreas[i] = rhs. << 
246   fTrapType = rhs.fTrapType;                   << 
247 }                                              << 
248                                                << 
249 ////////////////////////////////////////////// << 
250 //                                             << 
251 // Assignment operator                         << 
252                                                << 
253 G4Trap& G4Trap::operator = (const G4Trap& rhs) << 
254 {                                              << 
255   // Check assignment to self                  << 
256   //                                           << 
257   if (this == &rhs)  { return *this; }         << 
258                                                << 
259   // Copy base class data                      << 
260   //                                           << 
261   G4CSGSolid::operator=(rhs);                  << 
262                                                << 
263   // Copy data                                 << 
264   //                                           << 
265   halfCarTolerance = rhs.halfCarTolerance;     << 
266   fDz = rhs.fDz; fTthetaCphi = rhs.fTthetaCphi << 
267   fDy1 = rhs.fDy1; fDx1 = rhs.fDx1; fDx2 = rhs << 
268   fDy2 = rhs.fDy2; fDx3 = rhs.fDx3; fDx4 = rhs << 
269   for (G4int i=0; i<4; ++i) { fPlanes[i] = rhs << 
270   for (G4int i=0; i<6; ++i) { fAreas[i] = rhs. << 
271   fTrapType = rhs.fTrapType;                   << 
272   return *this;                                << 
273 }                                              << 
274                                                << 
275 ////////////////////////////////////////////// << 
276 //                                                409 //
277 // Set all parameters, as for constructor - ch    410 // Set all parameters, as for constructor - check and set half-widths
278 // as well as angles: final check of coplanari    411 // as well as angles: final check of coplanarity
279                                                   412 
280 void G4Trap::SetAllParameters ( G4double pDz,     413 void G4Trap::SetAllParameters ( G4double pDz,
281                                 G4double pThet << 414         G4double pTheta,
282                                 G4double pPhi, << 415         G4double pPhi,
283                                 G4double pDy1, << 416         G4double pDy1,
284                                 G4double pDx1, << 417         G4double pDx1,
285                                 G4double pDx2, << 418         G4double pDx2,
286                                 G4double pAlp1 << 419         G4double pAlp1,
287                                 G4double pDy2, << 420         G4double pDy2,
288                                 G4double pDx3, << 421         G4double pDx3,
289                                 G4double pDx4, << 422         G4double pDx4,
290                                 G4double pAlp2 << 423         G4double pAlp2)
291 {                                              << 424 {
292   // Reset data of the base class              << 425     if (pDz>0 && pDy1>0 && pDx1>0 && pDx2>0 && pDy2>0 && pDx3>0 && pDx4>0)
293   fCubicVolume = 0;                            << 426   {
294   fSurfaceArea = 0;                            << 427      fDz=pDz;
295   fRebuildPolyhedron = true;                   << 428      fTthetaCphi=tan(pTheta)*cos(pPhi);
296                                                << 429      fTthetaSphi=tan(pTheta)*sin(pPhi);
297   // Set parameters                            << 430       
298   fDz = pDz;                                   << 431      fDy1=pDy1;
299   fTthetaCphi = std::tan(pTheta)*std::cos(pPhi << 432      fDx1=pDx1;
300   fTthetaSphi = std::tan(pTheta)*std::sin(pPhi << 433      fDx2=pDx2;
                                                   >> 434      fTalpha1=tan(pAlp1);
                                                   >> 435      
                                                   >> 436      fDy2=pDy2;
                                                   >> 437      fDx3=pDx3;
                                                   >> 438      fDx4=pDx4;
                                                   >> 439      fTalpha2=tan(pAlp2);
301                                                   440 
302   fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx2; fTalp << 441      MakePlanes();
303   fDy2 = pDy2; fDx3 = pDx3; fDx4 = pDx4; fTalp << 442   }
304                                                << 443     else
305   CheckParameters();                           << 444     {
306   MakePlanes();                                << 445        G4Exception("Error in G4Trap::SetAll - Invalid Length G4Trap parameters");
                                                   >> 446     }
307 }                                                 447 }
308                                                   448 
309 //////////////////////////////////////////////    449 //////////////////////////////////////////////////////////////////////////
310 //                                                450 //
311 // Check length parameters                     << 451 // Checking of coplanarity
312                                                   452 
313 void G4Trap::CheckParameters()                 << 453 G4bool G4Trap::MakePlanes()
314 {                                                 454 {
315   if (fDz<=0 ||                                << 455   G4bool good = true;
316       fDy1<=0 || fDx1<=0 || fDx2<=0 ||         << 
317       fDy2<=0 || fDx3<=0 || fDx4<=0)           << 
318   {                                            << 
319     std::ostringstream message;                << 
320     message << "Invalid Length Parameters for  << 
321             << "\n  X - " <<fDx1<<", "<<fDx2<< << 
322             << "\n  Y - " <<fDy1<<", "<<fDy2   << 
323             << "\n  Z - " <<fDz;               << 
324     G4Exception("G4Trap::CheckParameters()", " << 
325                 FatalException, message);      << 
326   }                                            << 
327 }                                              << 
328                                                   456 
329 ////////////////////////////////////////////// << 457   G4ThreeVector pt[8] ;
330 //                                             << 458      
331 // Compute vertices and set side planes        << 459   pt[0]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 460   pt[1]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 461   pt[2]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 462   pt[3]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 463   pt[4]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 464   pt[5]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 465   pt[6]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 466   pt[7]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 467   // Bottom side with normal approx. -Y
332                                                   468 
333 void G4Trap::MakePlanes()                      << 469   good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]) ;
334 {                                              << 
335   G4double DzTthetaCphi = fDz*fTthetaCphi;     << 
336   G4double DzTthetaSphi = fDz*fTthetaSphi;     << 
337   G4double Dy1Talpha1   = fDy1*fTalpha1;       << 
338   G4double Dy2Talpha2   = fDy2*fTalpha2;       << 
339                                                   470 
340   G4ThreeVector pt[8] =                        << 471   if (!good) G4Exception("G4Trap::G4Trap - face at ~-Y not planar");
341   {                                            << 
342     G4ThreeVector(-DzTthetaCphi-Dy1Talpha1-fDx << 
343     G4ThreeVector(-DzTthetaCphi-Dy1Talpha1+fDx << 
344     G4ThreeVector(-DzTthetaCphi+Dy1Talpha1-fDx << 
345     G4ThreeVector(-DzTthetaCphi+Dy1Talpha1+fDx << 
346     G4ThreeVector( DzTthetaCphi-Dy2Talpha2-fDx << 
347     G4ThreeVector( DzTthetaCphi-Dy2Talpha2+fDx << 
348     G4ThreeVector( DzTthetaCphi+Dy2Talpha2-fDx << 
349     G4ThreeVector( DzTthetaCphi+Dy2Talpha2+fDx << 
350   };                                           << 
351                                                   472 
352   MakePlanes(pt);                              << 473   // Top side with normal approx. +Y
353 }                                              << 
354                                                   474 
355 ////////////////////////////////////////////// << 475   good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
356 //                                             << 
357 // Set side planes, check planarity            << 
358                                                   476 
359 void G4Trap::MakePlanes(const G4ThreeVector pt << 477   if (!good) G4Exception("G4Trap::G4Trap - face at ~+Y not planar");
360 {                                              << 
361   constexpr G4int iface[4][4] = { {0,4,5,1}, { << 
362   const static G4String side[4] = { "~-Y", "~+ << 
363                                                   478 
364   for (G4int i=0; i<4; ++i)                    << 479   // Front side with normal approx. -X
365   {                                            << 
366     if (MakePlane(pt[iface[i][0]],             << 
367                   pt[iface[i][1]],             << 
368                   pt[iface[i][2]],             << 
369                   pt[iface[i][3]],             << 
370                   fPlanes[i])) continue;       << 
371                                                << 
372     // Non planar side face                    << 
373     G4ThreeVector normal(fPlanes[i].a,fPlanes[ << 
374     G4double dmax = 0;                         << 
375     for (G4int k=0; k<4; ++k)                  << 
376     {                                          << 
377       G4double dist = normal.dot(pt[iface[i][k << 
378       if (std::abs(dist) > std::abs(dmax)) dma << 
379     }                                          << 
380     std::ostringstream message;                << 
381     message << "Side face " << side[i] << " is << 
382             << GetName() << "\nDiscrepancy: "  << 
383     StreamInfo(message);                       << 
384     G4Exception("G4Trap::MakePlanes()", "GeomS << 
385                 FatalException, message);      << 
386   }                                            << 
387                                                   480 
388   // Re-compute parameters                     << 481   good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
389   SetCachedValues();                           << 
390 }                                              << 
391                                                   482 
392 ////////////////////////////////////////////// << 483   if (!good) G4Exception("G4Trap::G4Trap - face at ~-X not planar");
393 //                                             << 484    
394 // Calculate the coef's of the plane p1->p2->p << 485   // Back side iwth normal approx. +X
395 // where the ThreeVectors 1-4 are in anti-cloc << 
396 // from infront of the plane (i.e. from normal << 
397 //                                             << 
398 // Return true if the points are coplanar, fal << 
399                                                   486 
400 G4bool G4Trap::MakePlane( const G4ThreeVector& << 487   good=MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
401                           const G4ThreeVector& << 
402                           const G4ThreeVector& << 
403                           const G4ThreeVector& << 
404                                 TrapSidePlane& << 
405 {                                              << 
406   G4ThreeVector normal = ((p4 - p2).cross(p3 - << 
407   if (std::abs(normal.x()) < DBL_EPSILON) norm << 
408   if (std::abs(normal.y()) < DBL_EPSILON) norm << 
409   if (std::abs(normal.z()) < DBL_EPSILON) norm << 
410   normal = normal.unit();                      << 
411                                                << 
412   G4ThreeVector centre = (p1 + p2 + p3 + p4)*0 << 
413   plane.a =  normal.x();                       << 
414   plane.b =  normal.y();                       << 
415   plane.c =  normal.z();                       << 
416   plane.d = -normal.dot(centre);               << 
417                                                << 
418   // compute distances and check planarity     << 
419   G4double d1 = std::abs(normal.dot(p1) + plan << 
420   G4double d2 = std::abs(normal.dot(p2) + plan << 
421   G4double d3 = std::abs(normal.dot(p3) + plan << 
422   G4double d4 = std::abs(normal.dot(p4) + plan << 
423   G4double dmax = std::max(std::max(std::max(d << 
424                                                   488 
425   return dmax <= 1000 * kCarTolerance;         << 489   if (!good) G4Exception("G4Trap::G4Trap - face at ~+X not planar");
                                                   >> 490     
                                                   >> 491   return good;
426 }                                                 492 }
427                                                   493 
428 ////////////////////////////////////////////// << 494 //////////////////////////////////////////////////////////////////////////////
429 //                                                495 //
430 // Recompute parameters using planes           << 496 // Calculate the coef's of the plane p1->p2->p3->p4->p1
431                                                << 497 // where the ThreeVectors 1-4 are in anti-clockwise order when viewed from
432 void G4Trap::SetCachedValues()                 << 498 // infront of the plane.
433 {                                              << 
434   // Set indeces                               << 
435   constexpr  G4int iface[6][4] =               << 
436       { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2, << 
437                                                << 
438   // Get vertices                              << 
439   G4ThreeVector pt[8];                         << 
440   GetVertices(pt);                             << 
441                                                << 
442   // Set face areas                            << 
443   for (G4int i=0; i<6; ++i)                    << 
444   {                                            << 
445     fAreas[i] = G4GeomTools::QuadAreaNormal(pt << 
446                                             pt << 
447                                             pt << 
448                                             pt << 
449   }                                            << 
450   for (G4int i=1; i<6; ++i) { fAreas[i] += fAr << 
451                                                << 
452   // Define type of trapezoid                  << 
453   fTrapType = 0;                               << 
454   if (fPlanes[0].b  == -1 && fPlanes[1].b == 1 << 
455       std::abs(fPlanes[0].a) < DBL_EPSILON &&  << 
456       std::abs(fPlanes[0].c) < DBL_EPSILON &&  << 
457       std::abs(fPlanes[1].a) < DBL_EPSILON &&  << 
458       std::abs(fPlanes[1].c) < DBL_EPSILON)    << 
459   {                                            << 
460     fTrapType = 1; // YZ section is a rectangl << 
461     if (std::abs(fPlanes[2].a + fPlanes[3].a)  << 
462         std::abs(fPlanes[2].c - fPlanes[3].c)  << 
463         fPlanes[2].b == 0 &&                   << 
464         fPlanes[3].b == 0)                     << 
465     {                                          << 
466       fTrapType = 2; // ... and XZ section is  << 
467       fPlanes[2].a = -fPlanes[3].a;            << 
468       fPlanes[2].c =  fPlanes[3].c;            << 
469     }                                          << 
470     if (std::abs(fPlanes[2].a + fPlanes[3].a)  << 
471         std::abs(fPlanes[2].b - fPlanes[3].b)  << 
472         fPlanes[2].c == 0 &&                   << 
473         fPlanes[3].c == 0)                     << 
474     {                                          << 
475       fTrapType = 3; // ... and XY section is  << 
476       fPlanes[2].a = -fPlanes[3].a;            << 
477       fPlanes[2].b =  fPlanes[3].b;            << 
478     }                                          << 
479   }                                            << 
480 }                                              << 
481                                                << 
482 ////////////////////////////////////////////// << 
483 //                                                499 //
484 // Get volume                                  << 500 // Return true if the ThreeVectors are coplanar + set coef;s
                                                   >> 501 //        false if ThreeVectors are not coplanar
485                                                   502 
486 G4double G4Trap::GetCubicVolume()              << 503 G4bool G4Trap::MakePlane( const G4ThreeVector& p1,
                                                   >> 504         const G4ThreeVector& p2,
                                                   >> 505               const G4ThreeVector& p3,
                                                   >> 506         const G4ThreeVector& p4,
                                                   >> 507         TrapSidePlane& plane )
487 {                                                 508 {
488   if (fCubicVolume == 0)                       << 509     G4double a,b,c,s;
489   {                                            << 510     G4ThreeVector v12,v13,v14,Vcross;
490     G4ThreeVector pt[8];                       << 
491     GetVertices(pt);                           << 
492                                                   511 
493     G4double dz  = pt[4].z() - pt[0].z();      << 512     G4bool good;
494     G4double dy1 = pt[2].y() - pt[0].y();      << 
495     G4double dx1 = pt[1].x() - pt[0].x();      << 
496     G4double dx2 = pt[3].x() - pt[2].x();      << 
497     G4double dy2 = pt[6].y() - pt[4].y();      << 
498     G4double dx3 = pt[5].x() - pt[4].x();      << 
499     G4double dx4 = pt[7].x() - pt[6].x();      << 
500                                                   513 
501     fCubicVolume = ((dx1 + dx2 + dx3 + dx4)*(d << 514     v12 = p2-p1;
502                     (dx4 + dx3 - dx2 - dx1)*(d << 515     v13 = p3-p1;
503   }                                            << 516     v14 = p4-p1;
504   return fCubicVolume;                         << 517     Vcross=v12.cross(v13);
505 }                                              << 
506                                                   518 
507 ////////////////////////////////////////////// << 519     if (fabs(Vcross.dot(v14)/(Vcross.mag()*v14.mag())) > kCoplanar_Tolerance)
508 //                                             << 520     {
509 // Get surface area                            << 521        good=false;
510                                                << 
511 G4double G4Trap::GetSurfaceArea()              << 
512 {                                              << 
513   if (fSurfaceArea == 0)                       << 
514   {                                            << 
515     G4ThreeVector pt[8];                       << 
516     G4int iface [6][4] =                       << 
517       { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2, << 
518                                                << 
519     GetVertices(pt);                           << 
520     for (const auto & i : iface)               << 
521     {                                          << 
522       fSurfaceArea += G4GeomTools::QuadAreaNor << 
523                                                << 
524                                                << 
525                                                << 
526     }                                             522     }
527   }                                            << 523     else
528   return fSurfaceArea;                         << 524     {
                                                   >> 525     
                                                   >> 526 // a,b,c correspond to the x/y/z components of the normal vector to the plane
                                                   >> 527      
                                                   >> 528             a=(p2.y()-p1.y())*(p1.z()+p2.z())+(p3.y()-p2.y())*(p2.z()+p3.z());
                                                   >> 529       a+=(p4.y()-p3.y())*(p3.z()+p4.z())+(p1.y()-p4.y())*(p4.z()+p1.z()); // may be delete ?
                                                   >> 530     
                                                   >> 531       b=(p2.z()-p1.z())*(p1.x()+p2.x())+(p3.z()-p2.z())*(p2.x()+p3.x());
                                                   >> 532       b+=(p4.z()-p3.z())*(p3.x()+p4.x())+(p1.z()-p4.z())*(p4.x()+p1.x()); // ?
                                                   >> 533       
                                                   >> 534       c=(p2.x()-p1.x())*(p1.y()+p2.y())+(p3.x()-p2.x())*(p2.y()+p3.y());
                                                   >> 535       c+=(p4.x()-p3.x())*(p3.y()+p4.y())+(p1.x()-p4.x())*(p4.y()+p1.y());  // ?
                                                   >> 536 // Let create diagonals 4-2 and 3-1 than (4-2)x(3-1) provides vector perpendicular to the
                                                   >> 537 // plane directed to outside !!! and a,b,c, = f(1,2,3,4)     
                                                   >> 538      //a = +(p4.y() - p2.y())*(p3.z() - p1.z()) - (p3.y() - p1.y())*(p4.z() - p2.z()) ;
                                                   >> 539      //b = -(p4.x() - p2.x())*(p3.z() - p1.z()) + (p3.x() - p1.x())*(p4.z() - p2.z()) ; 
                                                   >> 540      //c = +(p4.x() - p2.x())*(p3.y() - p1.y()) - (p3.x() - p1.x())*(p4.y() - p2.y()) ;
                                                   >> 541      s=sqrt(a*a+b*b+c*c);   // so now vector plane.(a,b,c) is unit 
                                                   >> 542 
                                                   >> 543      if( s > 0 )
                                                   >> 544      {
                                                   >> 545     plane.a=a/s;
                                                   >> 546     plane.b=b/s;
                                                   >> 547     plane.c=c/s;
                                                   >> 548      }
                                                   >> 549      else 
                                                   >> 550                 G4Exception("Invalid parameters in G4Trap::MakePlane") ;
                                                   >> 551 
                                                   >> 552 // Calculate D: p1 in in plane so D=-n.p1.Vect()
                                                   >> 553      
                                                   >> 554    plane.d=-(plane.a*p1.x()+plane.b*p1.y()+plane.c*p1.z());
                                                   >> 555    good=true;
                                                   >> 556  }
                                                   >> 557  return good;
529 }                                                 558 }
530                                                   559 
531 ////////////////////////////////////////////// << 560 //////////////////////////////////////////////////////////////////////////////
532 //                                                561 //
533 // Dispatch to parameterisation for replicatio    562 // Dispatch to parameterisation for replication mechanism dimension
534 // computation & modification.                    563 // computation & modification.
535                                                   564 
536 void G4Trap::ComputeDimensions(       G4VPVPar << 565  void G4Trap::ComputeDimensions(G4VPVParameterisation* p,
537                                 const G4int n,    566                                 const G4int n,
538                                 const G4VPhysi << 567                                 const G4VPhysicalVolume* pRep)
539 {                                                 568 {
540   p->ComputeDimensions(*this,n,pRep);          << 569     p->ComputeDimensions(*this,n,pRep);
541 }                                                 570 }
542                                                   571 
543 ////////////////////////////////////////////// << 
544 //                                             << 
545 // Get bounding box                            << 
546                                                << 
547 void G4Trap::BoundingLimits(G4ThreeVector& pMi << 
548 {                                              << 
549   G4ThreeVector pt[8];                         << 
550   GetVertices(pt);                             << 
551                                                   572 
552   G4double xmin = kInfinity, xmax = -kInfinity << 573 ////////////////////////////////////////////////////////////////////////
553   G4double ymin = kInfinity, ymax = -kInfinity << 
554   for (const auto & i : pt)                    << 
555   {                                            << 
556     G4double x = i.x();                        << 
557     if (x < xmin) xmin = x;                    << 
558     if (x > xmax) xmax = x;                    << 
559     G4double y = i.y();                        << 
560     if (y < ymin) ymin = y;                    << 
561     if (y > ymax) ymax = y;                    << 
562   }                                            << 
563                                                << 
564   G4double dz   = GetZHalfLength();            << 
565   pMin.set(xmin,ymin,-dz);                     << 
566   pMax.set(xmax,ymax, dz);                     << 
567                                                << 
568   // Check correctness of the bounding box     << 
569   //                                           << 
570   if (pMin.x() >= pMax.x() || pMin.y() >= pMax << 
571   {                                            << 
572     std::ostringstream message;                << 
573     message << "Bad bounding box (min >= max)  << 
574             << GetName() << " !"               << 
575             << "\npMin = " << pMin             << 
576             << "\npMax = " << pMax;            << 
577     G4Exception("G4Trap::BoundingLimits()", "G << 
578                 JustWarning, message);         << 
579     DumpInfo();                                << 
580   }                                            << 
581 }                                              << 
582                                                << 
583 ////////////////////////////////////////////// << 
584 //                                                574 //
585 // Calculate extent under transform and specif    575 // Calculate extent under transform and specified limit
586                                                   576 
587 G4bool G4Trap::CalculateExtent( const EAxis pA    577 G4bool G4Trap::CalculateExtent( const EAxis pAxis,
588                                 const G4VoxelL    578                                 const G4VoxelLimits& pVoxelLimit,
589                                 const G4Affine    579                                 const G4AffineTransform& pTransform,
590                                       G4double    580                                       G4double& pMin, G4double& pMax) const
591 {                                                 581 {
592   G4ThreeVector bmin, bmax;                    << 582   G4double xMin, xMax, yMin, yMax, zMin, zMax;
593   G4bool exist;                                << 583   G4bool flag;
594                                                   584 
595   // Check bounding box (bbox)                 << 585   if (!pTransform.IsRotated())
596   //                                           << 586   {  
597   BoundingLimits(bmin,bmax);                   << 587     // Special case handling for unrotated trapezoids
598   G4BoundingEnvelope bbox(bmin,bmax);          << 588     // Compute z/x/y/ mins and maxs respecting limits, with early returns
599 #ifdef G4BBOX_EXTENT                           << 589     // if outside limits. Then switch() on pAxis
600   return bbox.CalculateExtent(pAxis,pVoxelLimi << 590 
601 #endif                                         << 591     G4int i ; 
602   if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVox << 592     G4double xoffset;
603   {                                            << 593     G4double yoffset;
604     return exist = pMin < pMax;                << 594     G4double zoffset;
605   }                                            << 595     G4double temp[8] ;     // some points for intersection with zMin/zMax
                                                   >> 596     G4ThreeVector pt[8];   // vertices after translation
                                                   >> 597     
                                                   >> 598     xoffset=pTransform.NetTranslation().x();      
                                                   >> 599     yoffset=pTransform.NetTranslation().y();
                                                   >> 600     zoffset=pTransform.NetTranslation().z();
                                                   >> 601  
                                                   >> 602     pt[0]=G4ThreeVector(xoffset-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,
                                                   >> 603                         yoffset-fDz*fTthetaSphi-fDy1,zoffset-fDz);
                                                   >> 604     pt[1]=G4ThreeVector(xoffset-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,
                                                   >> 605                   yoffset-fDz*fTthetaSphi-fDy1,zoffset-fDz);
                                                   >> 606     pt[2]=G4ThreeVector(xoffset-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,
                                                   >> 607                   yoffset-fDz*fTthetaSphi+fDy1,zoffset-fDz);
                                                   >> 608     pt[3]=G4ThreeVector(xoffset-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,
                                                   >> 609                   yoffset-fDz*fTthetaSphi+fDy1,zoffset-fDz);
                                                   >> 610     pt[4]=G4ThreeVector(xoffset+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,
                                                   >> 611                   yoffset+fDz*fTthetaSphi-fDy2,zoffset+fDz);
                                                   >> 612     pt[5]=G4ThreeVector(xoffset+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,
                                                   >> 613                   yoffset+fDz*fTthetaSphi-fDy2,zoffset+fDz);
                                                   >> 614     pt[6]=G4ThreeVector(xoffset+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,
                                                   >> 615                   yoffset+fDz*fTthetaSphi+fDy2,zoffset+fDz);
                                                   >> 616     pt[7]=G4ThreeVector(xoffset+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,
                                                   >> 617                   yoffset+fDz*fTthetaSphi+fDy2,zoffset+fDz);
                                                   >> 618     zMin=zoffset-fDz;
                                                   >> 619     zMax=zoffset+fDz;
606                                                   620 
607   // Set bounding envelope (benv) and calculat << 621     if ( pVoxelLimit.IsZLimited() )
608   //                                           << 
609   G4ThreeVector pt[8];                         << 
610   GetVertices(pt);                             << 
611                                                << 
612   G4ThreeVectorList baseA(4), baseB(4);        << 
613   baseA[0] = pt[0];                            << 
614   baseA[1] = pt[1];                            << 
615   baseA[2] = pt[3];                            << 
616   baseA[3] = pt[2];                            << 
617                                                << 
618   baseB[0] = pt[4];                            << 
619   baseB[1] = pt[5];                            << 
620   baseB[2] = pt[7];                            << 
621   baseB[3] = pt[6];                            << 
622                                                << 
623   std::vector<const G4ThreeVectorList *> polyg << 
624   polygons[0] = &baseA;                        << 
625   polygons[1] = &baseB;                        << 
626                                                << 
627   G4BoundingEnvelope benv(bmin,bmax,polygons); << 
628   exist = benv.CalculateExtent(pAxis,pVoxelLim << 
629   return exist;                                << 
630 }                                              << 
631                                                << 
632 ////////////////////////////////////////////// << 
633 //                                             << 
634 // Return whether point is inside/outside/on_s << 
635                                                << 
636 EInside G4Trap::Inside( const G4ThreeVector& p << 
637 {                                              << 
638   switch (fTrapType)                           << 
639   {                                            << 
640     case 0: // General case                    << 
641     {                                             622     {
642       G4double dz = std::abs(p.z())-fDz;       << 623       if ( zMin > pVoxelLimit.GetMaxZExtent() + kCarTolerance ||
643       G4double dy1 = fPlanes[0].b*p.y()+fPlane << 624            zMax < pVoxelLimit.GetMinZExtent() - kCarTolerance    )
644       G4double dy2 = fPlanes[1].b*p.y()+fPlane << 625       {
645       G4double dy = std::max(dz,std::max(dy1,d << 626         return false;
646                                                << 627       }
647       G4double dx1 = fPlanes[2].a*p.x()+fPlane << 628       else
648                    + fPlanes[2].c*p.z()+fPlane << 629       {
649       G4double dx2 = fPlanes[3].a*p.x()+fPlane << 630         if ( zMin < pVoxelLimit.GetMinZExtent() )
650                    + fPlanes[3].c*p.z()+fPlane << 631   {
651       G4double dist = std::max(dy,std::max(dx1 << 632     zMin = pVoxelLimit.GetMinZExtent() ;
652                                                << 633   }
653       return (dist > halfCarTolerance) ? kOuts << 634   if ( zMax > pVoxelLimit.GetMaxZExtent() )
654         ((dist > -halfCarTolerance) ? kSurface << 635   {
                                                   >> 636     zMax = pVoxelLimit.GetMaxZExtent() ;
                                                   >> 637   }
                                                   >> 638       }
655     }                                             639     }
656     case 1: // YZ section is a rectangle       << 640     temp[0] = pt[0].y()+(pt[4].y()-pt[0].y())*(zMin-pt[0].z())/(pt[4].z()-pt[0].z()) ;
                                                   >> 641     temp[1] = pt[0].y()+(pt[4].y()-pt[0].y())*(zMax-pt[0].z())/(pt[4].z()-pt[0].z()) ;
                                                   >> 642     temp[2] = pt[2].y()+(pt[6].y()-pt[2].y())*(zMin-pt[2].z())/(pt[6].z()-pt[2].z()) ;
                                                   >> 643     temp[3] = pt[2].y()+(pt[6].y()-pt[2].y())*(zMax-pt[2].z())/(pt[6].z()-pt[2].z()) ;
                                                   >> 644 
                                                   >> 645     yMax = yoffset - fabs(fDz*fTthetaSphi) - fDy1 - fDy2 ;
                                                   >> 646     yMin = -yMax ;
                                                   >> 647 
                                                   >> 648     for( i = 0 ; i < 4 ; i++ )
                                                   >> 649     {
                                                   >> 650       if( temp[i] > yMax ) yMax = temp[i] ;
                                                   >> 651       if( temp[i] < yMin ) yMin = temp[i] ;
                                                   >> 652     }    
                                                   >> 653     if ( pVoxelLimit.IsYLimited() )
657     {                                             654     {
658       G4double dz = std::abs(p.z())-fDz;       << 655       if ( yMin > pVoxelLimit.GetMaxYExtent() + kCarTolerance ||
659       G4double dy = std::max(dz,std::abs(p.y() << 656            yMax < pVoxelLimit.GetMinYExtent() - kCarTolerance    )
660       G4double dx1 = fPlanes[2].a*p.x()+fPlane << 657       {
661                    + fPlanes[2].c*p.z()+fPlane << 658         return false;
662       G4double dx2 = fPlanes[3].a*p.x()+fPlane << 659       }
663                    + fPlanes[3].c*p.z()+fPlane << 660       else
664       G4double dist = std::max(dy,std::max(dx1 << 661       {
665                                                << 662   if ( yMin < pVoxelLimit.GetMinYExtent() )
666       return (dist > halfCarTolerance) ? kOuts << 663   {
667         ((dist > -halfCarTolerance) ? kSurface << 664     yMin = pVoxelLimit.GetMinYExtent() ;
                                                   >> 665   }
                                                   >> 666   if ( yMax > pVoxelLimit.GetMaxYExtent() )
                                                   >> 667   {
                                                   >> 668     yMax = pVoxelLimit.GetMaxYExtent() ;
                                                   >> 669   }
                                                   >> 670       }
668     }                                             671     }
669     case 2: // YZ section is a rectangle and   << 672     temp[0] = pt[0].x()+(pt[4].x()-pt[0].x())*(zMin-pt[0].z())/(pt[4].z()-pt[0].z()) ;
670     {       // XZ section is an isosceles trap << 673     temp[1] = pt[0].x()+(pt[4].x()-pt[0].x())*(zMax-pt[0].z())/(pt[4].z()-pt[0].z()) ;
671       G4double dz = std::abs(p.z())-fDz;       << 674     temp[2] = pt[2].x()+(pt[6].x()-pt[2].x())*(zMin-pt[2].z())/(pt[6].z()-pt[2].z()) ;
672       G4double dy = std::max(dz,std::abs(p.y() << 675     temp[3] = pt[2].x()+(pt[6].x()-pt[2].x())*(zMax-pt[2].z())/(pt[6].z()-pt[2].z()) ;
673       G4double dx = fPlanes[3].a*std::abs(p.x( << 676     temp[4] = pt[3].x()+(pt[7].x()-pt[3].x())*(zMin-pt[3].z())/(pt[7].z()-pt[3].z()) ;
674                   + fPlanes[3].c*p.z()+fPlanes << 677     temp[5] = pt[3].x()+(pt[7].x()-pt[3].x())*(zMax-pt[3].z())/(pt[7].z()-pt[3].z()) ;
675       G4double dist = std::max(dy,dx);         << 678     temp[6] = pt[1].x()+(pt[5].x()-pt[1].x())*(zMin-pt[1].z())/(pt[5].z()-pt[1].z()) ;
676                                                << 679     temp[7] = pt[1].x()+(pt[5].x()-pt[1].x())*(zMax-pt[1].z())/(pt[5].z()-pt[1].z()) ;
677       return (dist > halfCarTolerance) ? kOuts << 680       
678         ((dist > -halfCarTolerance) ? kSurface << 681     xMax = xoffset - fabs(fDz*fTthetaCphi) - fDx1 - fDx2 -fDx3 - fDx4 ;
                                                   >> 682     xMin = -xMax ;
                                                   >> 683 
                                                   >> 684     for( i = 0 ; i < 8 ; i++ )
                                                   >> 685     {
                                                   >> 686       if( temp[i] > xMax) xMax = temp[i] ;
                                                   >> 687       if( temp[i] < xMin) xMin = temp[i] ;
                                                   >> 688     }                                           
                                                   >> 689     if (pVoxelLimit.IsXLimited())   // xMax/Min = f(yMax/Min) ?
                                                   >> 690     {
                                                   >> 691       if ( xMin > pVoxelLimit.GetMaxXExtent() + kCarTolerance ||
                                                   >> 692            xMax < pVoxelLimit.GetMinXExtent() - kCarTolerance    )
                                                   >> 693       {
                                                   >> 694   return false;
                                                   >> 695       }
                                                   >> 696       else
                                                   >> 697       {
                                                   >> 698         if ( xMin < pVoxelLimit.GetMinXExtent() )
                                                   >> 699   {
                                                   >> 700     xMin = pVoxelLimit.GetMinXExtent() ;
                                                   >> 701   }
                                                   >> 702   if ( xMax > pVoxelLimit.GetMaxXExtent() )
                                                   >> 703   {
                                                   >> 704     xMax = pVoxelLimit.GetMaxXExtent() ;
                                                   >> 705   }
                                                   >> 706       }
679     }                                             707     }
680     case 3: // YZ section is a rectangle and   << 708     switch (pAxis)
681     {       // XY section is an isosceles trap << 709     {
682       G4double dz = std::abs(p.z())-fDz;       << 710       case kXAxis:
683       G4double dy = std::max(dz,std::abs(p.y() << 711      pMin=xMin;
684       G4double dx = fPlanes[3].a*std::abs(p.x( << 712      pMax=xMax;
685                   + fPlanes[3].b*p.y()+fPlanes << 713      break;
686       G4double dist = std::max(dy,dx);         << 714 
687                                                << 715       case kYAxis:
688       return (dist > halfCarTolerance) ? kOuts << 716      pMin=yMin;
689         ((dist > -halfCarTolerance) ? kSurface << 717      pMax=yMax;
                                                   >> 718      break;
                                                   >> 719 
                                                   >> 720       case kZAxis:
                                                   >> 721      pMin=zMin;
                                                   >> 722      pMax=zMax;
                                                   >> 723      break;
                                                   >> 724       default:
                                                   >> 725      break;
                                                   >> 726     }
                                                   >> 727     pMin -= kCarTolerance;
                                                   >> 728     pMax += kCarTolerance;
                                                   >> 729 
                                                   >> 730     flag = true;
                                                   >> 731   }
                                                   >> 732   else    // General rotated case - 
                                                   >> 733   {
                                                   >> 734     G4bool existsAfterClip = false ;
                                                   >> 735     G4ThreeVectorList*       vertices;
                                                   >> 736     pMin                   = +kInfinity;
                                                   >> 737     pMax                   = -kInfinity;
                                                   >> 738       
                                                   >> 739     // Calculate rotated vertex coordinates. Operator 'new' is called
                                                   >> 740 
                                                   >> 741     vertices = CreateRotatedVertices(pTransform);
                                                   >> 742       
                                                   >> 743     xMin = +kInfinity; yMin = +kInfinity; zMin = +kInfinity;
                                                   >> 744     xMax = -kInfinity; yMax = -kInfinity; zMax = -kInfinity;
                                                   >> 745       
                                                   >> 746     for( G4int nv = 0 ; nv < 8 ; nv++ )
                                                   >> 747     { 
                                                   >> 748       if( (*vertices)[nv].x() > xMax ) xMax = (*vertices)[nv].x();
                                                   >> 749       if( (*vertices)[nv].y() > yMax ) yMax = (*vertices)[nv].y();
                                                   >> 750       if( (*vertices)[nv].z() > zMax ) zMax = (*vertices)[nv].z();
                                                   >> 751       
                                                   >> 752       if( (*vertices)[nv].x() < xMin ) xMin = (*vertices)[nv].x();
                                                   >> 753       if( (*vertices)[nv].y() < yMin ) yMin = (*vertices)[nv].y();
                                                   >> 754       if( (*vertices)[nv].z() < zMin ) zMin = (*vertices)[nv].z();
690     }                                             755     }
691   }                                            << 756     if ( pVoxelLimit.IsZLimited() )
692   return kOutside;                             << 
693 }                                              << 
694                                                << 
695 ////////////////////////////////////////////// << 
696 //                                             << 
697 // Determine side, and return corresponding no << 
698                                                << 
699 G4ThreeVector G4Trap::SurfaceNormal( const G4T << 
700 {                                              << 
701   G4double nx = 0, ny = 0, nz = 0;             << 
702   G4double dz = std::abs(p.z()) - fDz;         << 
703   nz = std::copysign(G4double(std::abs(dz) <=  << 
704                                                << 
705   switch (fTrapType)                           << 
706   {                                            << 
707     case 0: // General case                    << 
708     {                                             757     {
709       for (G4int i=0; i<2; ++i)                << 758       if ( zMin > pVoxelLimit.GetMaxZExtent() + kCarTolerance ||
                                                   >> 759            zMax < pVoxelLimit.GetMinZExtent() - kCarTolerance    )
710       {                                           760       {
711         G4double dy = fPlanes[i].b*p.y() + fPl << 761         delete vertices ;    //  'new' in the function called
712         if (std::abs(dy) > halfCarTolerance) c << 762   return false;
713         ny  = fPlanes[i].b;                    << 
714         nz += fPlanes[i].c;                    << 
715         break;                                 << 
716       }                                           763       }
717       for (G4int i=2; i<4; ++i)                << 764       else
718       {                                           765       {
719         G4double dx = fPlanes[i].a*p.x() +     << 766         if ( zMin < pVoxelLimit.GetMinZExtent() )
720                       fPlanes[i].b*p.y() + fPl << 767   {
721         if (std::abs(dx) > halfCarTolerance) c << 768     zMin = pVoxelLimit.GetMinZExtent() ;
722         nx  = fPlanes[i].a;                    << 769   }
723         ny += fPlanes[i].b;                    << 770   if ( zMax > pVoxelLimit.GetMaxZExtent() )
724         nz += fPlanes[i].c;                    << 771   {
725         break;                                 << 772     zMax = pVoxelLimit.GetMaxZExtent() ;
                                                   >> 773   }
726       }                                           774       }
727       break;                                   << 775     } 
728     }                                          << 776     if ( pVoxelLimit.IsYLimited() )
729     case 1: // YZ section - rectangle          << 
730     {                                             777     {
731       G4double dy = std::abs(p.y()) + fPlanes[ << 778       if ( yMin > pVoxelLimit.GetMaxYExtent() + kCarTolerance ||
732       ny = std::copysign(G4double(std::abs(dy) << 779            yMax < pVoxelLimit.GetMinYExtent() - kCarTolerance    )
733       for (G4int i=2; i<4; ++i)                << 
734       {                                           780       {
735         G4double dx = fPlanes[i].a*p.x() +     << 781         delete vertices ;    //  'new' in the function called
736                       fPlanes[i].b*p.y() + fPl << 782   return false;
737         if (std::abs(dx) > halfCarTolerance) c << 783       }
738         nx  = fPlanes[i].a;                    << 784       else
739         ny += fPlanes[i].b;                    << 785       {
740         nz += fPlanes[i].c;                    << 786         if ( yMin < pVoxelLimit.GetMinYExtent() )
741         break;                                 << 787   {
                                                   >> 788     yMin = pVoxelLimit.GetMinYExtent() ;
                                                   >> 789   }
                                                   >> 790   if ( yMax > pVoxelLimit.GetMaxYExtent() )
                                                   >> 791         {
                                                   >> 792     yMax = pVoxelLimit.GetMaxYExtent() ;
                                                   >> 793   }
742       }                                           794       }
743       break;                                   << 
744     }                                             795     }
745     case 2: // YZ section - rectangle, XZ sect << 796     if ( pVoxelLimit.IsXLimited() )
746     {                                             797     {
747       G4double dy = std::abs(p.y()) + fPlanes[ << 798       if ( xMin > pVoxelLimit.GetMaxXExtent() + kCarTolerance ||
748       ny = std::copysign(G4double(std::abs(dy) << 799            xMax < pVoxelLimit.GetMinXExtent() - kCarTolerance    )
749       G4double dx = fPlanes[3].a*std::abs(p.x( << 800       {
750                     fPlanes[3].c*p.z() + fPlan << 801         delete vertices ;    //  'new' in the function called
751       G4double k = std::abs(dx) <= halfCarTole << 802   return false ;
752       nx  = std::copysign(k, p.x())*fPlanes[3] << 803       } 
753       nz += k*fPlanes[3].c;                    << 804       else
754       break;                                   << 805       {
                                                   >> 806         if ( xMin < pVoxelLimit.GetMinXExtent() )
                                                   >> 807   {
                                                   >> 808     xMin = pVoxelLimit.GetMinXExtent() ;
                                                   >> 809   }
                                                   >> 810   if ( xMax > pVoxelLimit.GetMaxXExtent() )
                                                   >> 811   {
                                                   >> 812     xMax = pVoxelLimit.GetMaxXExtent() ;
                                                   >> 813         }
                                                   >> 814       }
755     }                                             815     }
756     case 3: // YZ section - rectangle, XY sect << 816     switch (pAxis)
757     {                                             817     {
758       G4double dy = std::abs(p.y()) + fPlanes[ << 818       case kXAxis:
759       ny = std::copysign(G4double(std::abs(dy) << 819      pMin=xMin;
760       G4double dx = fPlanes[3].a*std::abs(p.x( << 820      pMax=xMax;
761                     fPlanes[3].b*p.y() + fPlan << 821      break;
762       G4double k = std::abs(dx) <= halfCarTole << 822 
763       nx  = std::copysign(k, p.x())*fPlanes[3] << 823       case kYAxis:
764       ny += k*fPlanes[3].b;                    << 824      pMin=yMin;
765       break;                                   << 825      pMax=yMax;
766     }                                          << 826      break;
767   }                                            << 827 
768                                                << 828       case kZAxis:
769   // Return normal                             << 829      pMin=zMin;
770   //                                           << 830      pMax=zMax;
771   G4double mag2 = nx*nx + ny*ny + nz*nz;       << 831      break;
772   if (mag2 == 1)      return { nx,ny,nz };     << 832 
773   else if (mag2 != 0) return G4ThreeVector(nx, << 833       default:
774   else                                         << 834      break;
775   {                                            << 835     }
776     // Point is not on the surface             << 836     if ( pMin != kInfinity || pMax != -kInfinity )
777     //                                         << 837     {
778 #ifdef G4CSGDEBUG                              << 838       existsAfterClip=true;
779     std::ostringstream message;                << 839         
780     G4long oldprc = message.precision(16);     << 840       // Add tolerance to avoid precision troubles
781     message << "Point p is not on surface (!?) << 841 
782             << GetName() << G4endl;            << 842       pMin -= kCarTolerance ;
783     message << "Position:\n";                  << 843       pMax += kCarTolerance ;     
784     message << "   p.x() = " << p.x()/mm << "  << 844     }
785     message << "   p.y() = " << p.y()/mm << "  << 845     delete vertices ;          //  'new' in the function called
786     message << "   p.z() = " << p.z()/mm << "  << 846     flag = existsAfterClip ;
787     G4cout.precision(oldprc) ;                 << 847   }
788     G4Exception("G4Trap::SurfaceNormal(p)", "G << 848   return flag;
789                 JustWarning, message );        << 849 }
790     DumpInfo();                                << 850 
791 #endif                                         << 851 
792     return ApproxSurfaceNormal(p);             << 852 ////////////////////////////////////////////////////////////////////////
793   }                                            << 853 //
794 }                                              << 854 // Return whether point inside/outside/on surface, using tolerance
795                                                << 855 
796 ////////////////////////////////////////////// << 856 EInside G4Trap::Inside(const G4ThreeVector& p) const
797 //                                             << 857 {
798 // Algorithm for SurfaceNormal() following the << 858     EInside in;
799 // for points not on the surface               << 859     G4double Dist;
                                                   >> 860     G4int i;
                                                   >> 861     if (fabs(p.z())<=fDz-kCarTolerance/2)
                                                   >> 862   {
                                                   >> 863       in=kInside;
                                                   >> 864       for (i=0;i<4;i++)
                                                   >> 865     {
                                                   >> 866         Dist=fPlanes[i].a*p.x()+fPlanes[i].b*p.y()+fPlanes[i].c*p.z()+fPlanes[i].d;
                                                   >> 867         if (Dist>kCarTolerance/2)
                                                   >> 868       {
                                                   >> 869           return in=kOutside;
                                                   >> 870       }
                                                   >> 871         else if (Dist>-kCarTolerance/2)
                                                   >> 872       {
                                                   >> 873           in=kSurface;
                                                   >> 874       } 
                                                   >> 875     }
                                                   >> 876   }
                                                   >> 877     else if (fabs(p.z())<=fDz+kCarTolerance/2)
                                                   >> 878   {
                                                   >> 879       in=kSurface;
                                                   >> 880       for (i=0;i<4;i++)
                                                   >> 881     {
                                                   >> 882         Dist=fPlanes[i].a*p.x()+fPlanes[i].b*p.y()+fPlanes[i].c*p.z()+fPlanes[i].d;
                                                   >> 883         if (Dist>kCarTolerance/2)
                                                   >> 884       {
                                                   >> 885           return in=kOutside;
                                                   >> 886       }
                                                   >> 887     }
800                                                   888 
801 G4ThreeVector G4Trap::ApproxSurfaceNormal( con << 889   }
802 {                                              << 890     else
803   G4double dist = -DBL_MAX;                    << 891   {
804   G4int iside = 0;                             << 892       in=kOutside;
805   for (G4int i=0; i<4; ++i)                    << 893   }
806   {                                            << 894     return in;
807     G4double d = fPlanes[i].a*p.x() +          << 895 }
808                  fPlanes[i].b*p.y() +          << 896 
809                  fPlanes[i].c*p.z() + fPlanes[ << 897 /////////////////////////////////////////////////////////////////////////////
810     if (d > dist) { dist = d; iside = i; }     << 898 //
811   }                                            << 899 // Calculate side nearest to p, and return normal
812                                                << 900 // If 2+ sides equidistant, first side's normal returned (arbitrarily)
813   G4double distz = std::abs(p.z()) - fDz;      << 901 
814   if (dist > distz)                            << 902 G4ThreeVector G4Trap::SurfaceNormal( const G4ThreeVector& p) const
815     return { fPlanes[iside].a, fPlanes[iside]. << 903 {
816   else                                         << 904     G4double safe=kInfinity,Dist,safez;
817     return { 0, 0, (G4double)((p.z() < 0) ? -1 << 905     G4int i,imin=0;
818 }                                              << 906     for (i=0;i<4;i++)
819                                                << 907   {
820 ////////////////////////////////////////////// << 908       Dist=fabs(fPlanes[i].a*p.x()+fPlanes[i].b*p.y()+fPlanes[i].c*p.z()+fPlanes[i].d);
821 //                                             << 909       if (Dist<safe)
822 // Calculate distance to shape from outside    << 910     {
823 //  - return kInfinity if no intersection      << 911        safe=Dist;
                                                   >> 912         imin=i;
                                                   >> 913     }
                                                   >> 914   }
                                                   >> 915 
                                                   >> 916     safez=fabs(fabs(p.z())-fDz);
                                                   >> 917     if (safe<safez)
                                                   >> 918   {
                                                   >> 919       return G4ThreeVector(fPlanes[imin].a,fPlanes[imin].b,fPlanes[imin].c);
                                                   >> 920   }
                                                   >> 921     else
                                                   >> 922   {
                                                   >> 923       if (p.z()>0)
                                                   >> 924     {
                                                   >> 925         return G4ThreeVector(0,0,1);
                                                   >> 926     }
                                                   >> 927       else
                                                   >> 928     {
                                                   >> 929         return G4ThreeVector(0,0,-1);
                                                   >> 930     }
                                                   >> 931   }
                                                   >> 932 }
                                                   >> 933 
                                                   >> 934 ////////////////////////////////////////////////////////////////////////////
                                                   >> 935 //
                                                   >> 936 // Calculate distance to shape from outside - return kInfinity if no intersection
                                                   >> 937 //
                                                   >> 938 // ALGORITHM:
                                                   >> 939 // For each component, calculate pair of minimum and maximum intersection
                                                   >> 940 // values for which the particle is in the extent of the shape
                                                   >> 941 // - The smallest (MAX minimum) allowed distance of the pairs is intersect
824                                                   942 
825 G4double G4Trap::DistanceToIn(const G4ThreeVec    943 G4double G4Trap::DistanceToIn(const G4ThreeVector& p,
826                               const G4ThreeVec << 944             const G4ThreeVector& v) const
827 {                                                 945 {
828   // Z intersections                           << 946 
829   //                                           << 947     G4double snxt;    // snxt = default return value
830   if ((std::abs(p.z()) - fDz) >= -halfCarToler << 948     G4double max,smax,smin;
831     return kInfinity;                          << 949     G4double pdist,Comp,vdist;
832   G4double invz = (-v.z() == 0) ? DBL_MAX : -1 << 950     G4int i;
833   G4double dz = (invz < 0) ? fDz : -fDz;       << 951 //
834   G4double tzmin = (p.z() + dz)*invz;          << 952 // Z Intersection range
835   G4double tzmax = (p.z() - dz)*invz;          << 953 //
836                                                << 954     if (v.z() > 0 )
837   // Y intersections                           << 955     {
838   //                                           << 956        max = fDz - p.z() ;
839   G4double tymin = 0, tymax = DBL_MAX;         << 957 
840   G4int i = 0;                                 << 958        if (max > 0.5*kCarTolerance)
841   for ( ; i<2; ++i)                            << 959        {
842   {                                            << 960     smax = max/v.z();
843     G4double cosa = fPlanes[i].b*v.y() + fPlan << 961     smin = (-fDz-p.z())/v.z();
844     G4double dist = fPlanes[i].b*p.y() + fPlan << 962        }
845     if (dist >= -halfCarTolerance)             << 963        else
846     {                                          << 964        {
847       if (cosa >= 0) return kInfinity;         << 965     return snxt=kInfinity;
848       G4double tmp  = -dist/cosa;              << 966        }
849       if (tymin < tmp) tymin = tmp;            << 967     }
                                                   >> 968     else if (v.z() < 0 )
                                                   >> 969     {
                                                   >> 970        max = - fDz - p.z() ;
                                                   >> 971 
                                                   >> 972        if (max < -0.5*kCarTolerance )
                                                   >> 973        {
                                                   >> 974     smax=max/v.z();
                                                   >> 975     smin=(fDz-p.z())/v.z();
                                                   >> 976        }
                                                   >> 977        else
                                                   >> 978        {
                                                   >> 979     return snxt=kInfinity;
                                                   >> 980        }
850     }                                             981     }
851     else if (cosa > 0)                         << 982     else
852     {                                             983     {
853       G4double tmp  = -dist/cosa;              << 984        if (fabs(p.z())<fDz - 0.5*kCarTolerance) // Inside was <=fDz
854       if (tymax > tmp) tymax = tmp;            << 985        {
855     }                                          << 986     smin=0;
856   }                                            << 987     smax=kInfinity;
857                                                << 988        }
858   // Z intersections                           << 989        else
859   //                                           << 990        {
860   G4double txmin = 0, txmax = DBL_MAX;         << 991     return snxt=kInfinity;
861   for ( ; i<4; ++i)                            << 992        }
862   {                                            << 993     }
863     G4double cosa = fPlanes[i].a*v.x()+fPlanes << 994 
864     G4double dist = fPlanes[i].a*p.x()+fPlanes << 995     for (i=0;i<4;i++)
865                     fPlanes[i].d;              << 996     {
866     if (dist >= -halfCarTolerance)             << 997        pdist=fPlanes[i].a*p.x()+fPlanes[i].b*p.y()+fPlanes[i].c*p.z()+fPlanes[i].d;
867     {                                          << 998        
868       if (cosa >= 0) return kInfinity;         << 999        Comp=fPlanes[i].a*v.x()+fPlanes[i].b*v.y()+fPlanes[i].c*v.z();
869       G4double tmp  = -dist/cosa;              << 1000 
870       if (txmin < tmp) txmin = tmp;            << 1001        if ( pdist >= -0.5*kCarTolerance )      // was >0
                                                   >> 1002        {
                                                   >> 1003 //
                                                   >> 1004 // Outside the plane -> this is an extent entry distance
                                                   >> 1005 //
                                                   >> 1006     if (Comp >= 0)   // was >0
                                                   >> 1007     {
                                                   >> 1008        return snxt=kInfinity ;
                                                   >> 1009     }
                                                   >> 1010     else 
                                                   >> 1011     {
                                                   >> 1012        vdist=-pdist/Comp;
                                                   >> 1013 
                                                   >> 1014        if (vdist>smin)
                                                   >> 1015        {
                                                   >> 1016     if (vdist<smax)
                                                   >> 1017     {
                                                   >> 1018        smin = vdist;
                                                   >> 1019     }
                                                   >> 1020     else
                                                   >> 1021     {
                                                   >> 1022        return snxt=kInfinity;
                                                   >> 1023     }
                                                   >> 1024        }
                                                   >> 1025     }
                                                   >> 1026        }
                                                   >> 1027        else
                                                   >> 1028        {
                                                   >> 1029 //
                                                   >> 1030 // Inside the plane -> couble  be an extent exit distance (smax)
                                                   >> 1031 //
                                                   >> 1032     if (Comp>0)  // Will leave extent
                                                   >> 1033     {
                                                   >> 1034        vdist=-pdist/Comp;
                                                   >> 1035 
                                                   >> 1036        if (vdist<smax)
                                                   >> 1037        {
                                                   >> 1038     if (vdist>smin)
                                                   >> 1039     {
                                                   >> 1040        smax=vdist;
                                                   >> 1041     }
                                                   >> 1042     else
                                                   >> 1043     {
                                                   >> 1044            return snxt=kInfinity;
                                                   >> 1045     }
                                                   >> 1046        }  
                                                   >> 1047     }
                                                   >> 1048        }
                                                   >> 1049    }
                                                   >> 1050 //
                                                   >> 1051 // Checks in non z plane intersections ensure smin<smax
                                                   >> 1052 //
                                                   >> 1053     if (smin >=0 )
                                                   >> 1054     {
                                                   >> 1055        snxt = smin ;
871     }                                             1056     }
872     else if (cosa > 0)                         << 1057     else
873     {                                             1058     {
874       G4double tmp  = -dist/cosa;              << 1059        snxt = 0 ;
875       if (txmax > tmp) txmax = tmp;            << 
876     }                                             1060     }
877   }                                            << 1061     return snxt;
878                                                << 
879   // Find distance                             << 
880   //                                           << 
881   G4double tmin = std::max(std::max(txmin,tymi << 
882   G4double tmax = std::min(std::min(txmax,tyma << 
883                                                << 
884   if (tmax <= tmin + halfCarTolerance) return  << 
885   return (tmin < halfCarTolerance ) ? 0. : tmi << 
886 }                                                 1062 }
887                                                   1063 
888 ////////////////////////////////////////////// << 1064 ///////////////////////////////////////////////////////////////////////////
889 //                                                1065 //
890 // Calculate exact shortest distance to any bo    1066 // Calculate exact shortest distance to any boundary from outside
891 // This is the best fast estimation of the sho    1067 // This is the best fast estimation of the shortest distance to trap
892 // - return 0 if point is inside               << 1068 // - Returns 0 is ThreeVector inside
893                                                   1069 
894 G4double G4Trap::DistanceToIn( const G4ThreeVe << 1070 G4double G4Trap::DistanceToIn(const G4ThreeVector& p) const
895 {                                                 1071 {
896   switch (fTrapType)                           << 1072     G4double safe,Dist;
897   {                                            << 1073     G4int i;
898     case 0: // General case                    << 1074     safe=fabs(p.z())-fDz;
899     {                                          << 1075     for (i=0;i<4;i++)
900       G4double dz = std::abs(p.z())-fDz;       << 1076     {
901       G4double dy1 = fPlanes[0].b*p.y()+fPlane << 1077       Dist=fPlanes[i].a*p.x()+fPlanes[i].b*p.y()+fPlanes[i].c*p.z()+fPlanes[i].d;
902       G4double dy2 = fPlanes[1].b*p.y()+fPlane << 1078 
903       G4double dy = std::max(dz,std::max(dy1,d << 1079       if (Dist > safe) safe=Dist;
904                                                << 1080     }
905       G4double dx1 = fPlanes[2].a*p.x()+fPlane << 1081     if (safe<0) safe=0;
906                    + fPlanes[2].c*p.z()+fPlane << 1082     return safe;  
907       G4double dx2 = fPlanes[3].a*p.x()+fPlane << 1083 }
908                    + fPlanes[3].c*p.z()+fPlane << 1084 
909       G4double dist = std::max(dy,std::max(dx1 << 1085 /////////////////////////////////////////////////////////////////////////////////
910       return (dist > 0) ? dist : 0.;           << 1086 //
911     }                                          << 1087 // Calcluate distance to surface of shape from inside
912     case 1: // YZ section is a rectangle       << 1088 // Calculate distance to x/y/z planes - smallest is exiting distance
                                                   >> 1089 
                                                   >> 1090 G4double G4Trap::DistanceToOut(const G4ThreeVector& p,const G4ThreeVector& v,
                                                   >> 1091              const G4bool calcNorm,
                                                   >> 1092              G4bool *validNorm,G4ThreeVector *n) const
                                                   >> 1093 {
                                                   >> 1094     Eside side = kUndefined ;
                                                   >> 1095     G4double snxt;    // snxt = return value
                                                   >> 1096     G4double pdist,Comp,vdist,max;
                                                   >> 1097 //
                                                   >> 1098 // Z Intersections
                                                   >> 1099 //
                                                   >> 1100     if (v.z()>0)
                                                   >> 1101   {
                                                   >> 1102       max=fDz-p.z();
                                                   >> 1103       if (max>kCarTolerance/2)
                                                   >> 1104     {
                                                   >> 1105        snxt=max/v.z();
                                                   >> 1106        side=kPZ;
                                                   >> 1107     }
                                                   >> 1108       else
                                                   >> 1109     {
                                                   >> 1110         if (calcNorm)
                                                   >> 1111       {
                                                   >> 1112           *validNorm=true;
                                                   >> 1113           *n=G4ThreeVector(0,0,1);
                                                   >> 1114       }
                                                   >> 1115         return snxt=0;
                                                   >> 1116     }
                                                   >> 1117   }
                                                   >> 1118     else if (v.z()<0)
                                                   >> 1119   {
                                                   >> 1120       max=-fDz-p.z();
                                                   >> 1121       if (max<-kCarTolerance/2)
                                                   >> 1122     {
                                                   >> 1123        snxt=max/v.z();
                                                   >> 1124        side=kMZ;
                                                   >> 1125     }
                                                   >> 1126       else
                                                   >> 1127     {
                                                   >> 1128         if (calcNorm)
                                                   >> 1129       {
                                                   >> 1130           *validNorm=true;
                                                   >> 1131           *n=G4ThreeVector(0,0,-1);
                                                   >> 1132       }
                                                   >> 1133         return snxt=0;
                                                   >> 1134     }
                                                   >> 1135   }
                                                   >> 1136     else
913     {                                             1137     {
914       G4double dz = std::abs(p.z())-fDz;       << 1138        snxt=kInfinity;
915       G4double dy = std::max(dz,std::abs(p.y() << 
916       G4double dx1 = fPlanes[2].a*p.x()+fPlane << 
917                    + fPlanes[2].c*p.z()+fPlane << 
918       G4double dx2 = fPlanes[3].a*p.x()+fPlane << 
919                    + fPlanes[3].c*p.z()+fPlane << 
920       G4double dist = std::max(dy,std::max(dx1 << 
921       return (dist > 0) ? dist : 0.;           << 
922     }                                          << 
923     case 2: // YZ section is a rectangle and   << 
924     {       // XZ section is an isosceles trap << 
925       G4double dz = std::abs(p.z())-fDz;       << 
926       G4double dy = std::max(dz,std::abs(p.y() << 
927       G4double dx = fPlanes[3].a*std::abs(p.x( << 
928                   + fPlanes[3].c*p.z()+fPlanes << 
929       G4double dist = std::max(dy,dx);         << 
930       return (dist > 0) ? dist : 0.;           << 
931     }                                          << 
932     case 3: // YZ section is a rectangle and   << 
933     {       // XY section is an isosceles trap << 
934       G4double dz = std::abs(p.z())-fDz;       << 
935       G4double dy = std::max(dz,std::abs(p.y() << 
936       G4double dx = fPlanes[3].a*std::abs(p.x( << 
937                   + fPlanes[3].b*p.y()+fPlanes << 
938       G4double dist = std::max(dy,dx);         << 
939       return (dist > 0) ? dist : 0.;           << 
940     }                                             1139     }
941   }                                            << 
942   return 0.;                                   << 
943 }                                              << 
944                                                   1140 
945 ////////////////////////////////////////////// << 
946 //                                                1141 //
947 // Calculate distance to surface of shape from << 1142 // Intersections with planes[0] (expanded because of setting enum)
948 // find normal at exit point, if required      << 1143 //
949 // - when leaving the surface, return 0        << 1144     pdist=fPlanes[0].a*p.x()+fPlanes[0].b*p.y()+fPlanes[0].c*p.z()+fPlanes[0].d;
950                                                << 1145     Comp=fPlanes[0].a*v.x()+fPlanes[0].b*v.y()+fPlanes[0].c*v.z();
951 G4double G4Trap::DistanceToOut(const G4ThreeVe << 1146     if (pdist>0)
952                                const G4bool ca << 1147   {
953                                      G4bool* v << 1148 // Outside the plane
954 {                                              << 1149       if (Comp>0)
955   // Z intersections                           << 1150     {
956   //                                           << 1151 // Leaving immediately
957   if ((std::abs(p.z()) - fDz) >= -halfCarToler << 1152         if (calcNorm)
958   {                                            << 1153         {
959     if (calcNorm)                              << 1154           *validNorm=true;
960     {                                          << 1155           *n=G4ThreeVector(fPlanes[0].a,fPlanes[0].b,fPlanes[0].c);
961       *validNorm = true;                       << 1156         }
962       n->set(0, 0, (p.z() < 0) ? -1 : 1);      << 1157         return snxt=0;
963     }                                          << 1158     }
964     return 0;                                  << 1159   }
965   }                                            << 1160     else if (pdist<-kCarTolerance/2)
966   G4double vz = v.z();                         << 1161   {
967   G4double tmax = (vz == 0) ? DBL_MAX : (std:: << 1162 // Inside the plane
968   G4int iside = (vz < 0) ? -4 : -2; // little  << 1163       if (Comp>0)
969                                                << 1164     {
970   // Y intersections                           << 1165 // Will leave extent
971   //                                           << 1166         vdist=-pdist/Comp;
972   G4int i = 0;                                 << 1167         if (vdist<snxt)
973   for ( ; i<2; ++i)                            << 1168       {
974   {                                            << 1169          snxt=vdist;
975     G4double cosa = fPlanes[i].b*v.y() + fPlan << 1170          side=ks0;
976     if (cosa > 0)                              << 1171       }
977     {                                          << 1172     }
978       G4double dist = fPlanes[i].b*p.y() + fPl << 1173   }
979       if (dist >= -halfCarTolerance)           << 1174     else
980       {                                        << 1175   {
981         if (calcNorm)                          << 1176 // On surface
982         {                                      << 1177       if (Comp>0)
983           *validNorm = true;                   << 1178     {
984           n->set(0, fPlanes[i].b, fPlanes[i].c << 1179         if (calcNorm)
985         }                                      << 1180         {
986         return 0;                              << 1181           *validNorm=true;
987       }                                        << 1182           *n=G4ThreeVector(fPlanes[0].a,fPlanes[0].b,fPlanes[0].c);
988       G4double tmp = -dist/cosa;               << 1183         }
989       if (tmax > tmp) { tmax = tmp; iside = i; << 1184         return snxt=0;
990     }                                          << 1185     }
991   }                                            << 1186   }
992                                                   1187 
993   // X intersections                           << 
994   //                                           << 
995   for ( ; i<4; ++i)                            << 
996   {                                            << 
997     G4double cosa = fPlanes[i].a*v.x()+fPlanes << 
998     if (cosa > 0)                              << 
999     {                                          << 
1000       G4double dist = fPlanes[i].a*p.x() +    << 
1001                       fPlanes[i].b*p.y() + fP << 
1002       if (dist >= -halfCarTolerance)          << 
1003       {                                       << 
1004         if (calcNorm)                         << 
1005         {                                     << 
1006            *validNorm = true;                 << 
1007            n->set(fPlanes[i].a, fPlanes[i].b, << 
1008         }                                     << 
1009         return 0;                             << 
1010       }                                       << 
1011       G4double tmp = -dist/cosa;              << 
1012       if (tmax > tmp) { tmax = tmp; iside = i << 
1013     }                                         << 
1014   }                                           << 
1015                                                  1188 
1016   // Set normal, if required, and return dist << 1189 //
1017   //                                          << 1190 // Intersections with planes[1] (expanded because of setting enum)
1018   if (calcNorm)                               << 1191 //
1019   {                                           << 1192     pdist=fPlanes[1].a*p.x()+fPlanes[1].b*p.y()+fPlanes[1].c*p.z()+fPlanes[1].d;
1020     *validNorm = true;                        << 1193     Comp=fPlanes[1].a*v.x()+fPlanes[1].b*v.y()+fPlanes[1].c*v.z();
1021     if (iside < 0)                            << 1194     if (pdist>0)
1022       n->set(0, 0, iside + 3); // (-4+3)=-1,  << 1195   {
                                                   >> 1196 // Outside the plane
                                                   >> 1197       if (Comp>0)
                                                   >> 1198     {
                                                   >> 1199 // Leaving immediately
                                                   >> 1200         if (calcNorm)
                                                   >> 1201         {
                                                   >> 1202           *validNorm=true;
                                                   >> 1203           *n=G4ThreeVector(fPlanes[1].a,fPlanes[1].b,fPlanes[1].c);
                                                   >> 1204         }
                                                   >> 1205         return snxt=0;
                                                   >> 1206     }
                                                   >> 1207   }
                                                   >> 1208     else if (pdist<-kCarTolerance/2)
                                                   >> 1209   {
                                                   >> 1210 // Inside the plane
                                                   >> 1211       if (Comp>0)
                                                   >> 1212     {
                                                   >> 1213 // Will leave extent
                                                   >> 1214         vdist=-pdist/Comp;
                                                   >> 1215         if (vdist<snxt)
                                                   >> 1216       {
                                                   >> 1217          snxt=vdist;
                                                   >> 1218          side=ks1;
                                                   >> 1219       }
                                                   >> 1220     }
                                                   >> 1221   }
1023     else                                         1222     else
1024       n->set(fPlanes[iside].a, fPlanes[iside] << 1223   {
1025   }                                           << 1224 // On surface
1026   return tmax;                                << 1225       if (Comp>0)
                                                   >> 1226     {
                                                   >> 1227         if (calcNorm)
                                                   >> 1228         {
                                                   >> 1229           *validNorm=true;
                                                   >> 1230           *n=G4ThreeVector(fPlanes[1].a,fPlanes[1].b,fPlanes[1].c);
                                                   >> 1231         }
                                                   >> 1232         return snxt=0;
                                                   >> 1233     }
                                                   >> 1234   }
                                                   >> 1235 
                                                   >> 1236 //
                                                   >> 1237 // Intersections with planes[2] (expanded because of setting enum)
                                                   >> 1238 //
                                                   >> 1239     pdist=fPlanes[2].a*p.x()+fPlanes[2].b*p.y()+fPlanes[2].c*p.z()+fPlanes[2].d;
                                                   >> 1240     Comp=fPlanes[2].a*v.x()+fPlanes[2].b*v.y()+fPlanes[2].c*v.z();
                                                   >> 1241     if (pdist>0)
                                                   >> 1242   {
                                                   >> 1243 // Outside the plane
                                                   >> 1244       if (Comp>0)
                                                   >> 1245     {
                                                   >> 1246 // Leaving immediately
                                                   >> 1247         if (calcNorm)
                                                   >> 1248         {
                                                   >> 1249           *validNorm=true;
                                                   >> 1250           *n=G4ThreeVector(fPlanes[2].a,fPlanes[2].b,fPlanes[2].c);
                                                   >> 1251         }
                                                   >> 1252         return snxt=0;
                                                   >> 1253     }
                                                   >> 1254   }
                                                   >> 1255     else if (pdist<-kCarTolerance/2)
                                                   >> 1256   {
                                                   >> 1257 // Inside the plane
                                                   >> 1258       if (Comp>0)
                                                   >> 1259     {
                                                   >> 1260 // Will leave extent
                                                   >> 1261         vdist=-pdist/Comp;
                                                   >> 1262         if (vdist<snxt)
                                                   >> 1263       {
                                                   >> 1264          snxt=vdist;
                                                   >> 1265          side=ks2;
                                                   >> 1266       }
                                                   >> 1267     }
                                                   >> 1268   }
                                                   >> 1269     else
                                                   >> 1270   {
                                                   >> 1271 // On surface
                                                   >> 1272       if (Comp>0)
                                                   >> 1273     {
                                                   >> 1274         if (calcNorm)
                                                   >> 1275         {
                                                   >> 1276           *validNorm=true;
                                                   >> 1277            *n=G4ThreeVector(fPlanes[2].a,fPlanes[2].b,fPlanes[2].c);
                                                   >> 1278         }
                                                   >> 1279         return snxt=0;
                                                   >> 1280     }
                                                   >> 1281   }
                                                   >> 1282 
                                                   >> 1283 //
                                                   >> 1284 // Intersections with planes[3] (expanded because of setting enum)
                                                   >> 1285 //
                                                   >> 1286     pdist=fPlanes[3].a*p.x()+fPlanes[3].b*p.y()+fPlanes[3].c*p.z()+fPlanes[3].d;
                                                   >> 1287     Comp=fPlanes[3].a*v.x()+fPlanes[3].b*v.y()+fPlanes[3].c*v.z();
                                                   >> 1288     if (pdist>0)
                                                   >> 1289   {
                                                   >> 1290 // Outside the plane
                                                   >> 1291       if (Comp>0)
                                                   >> 1292     {
                                                   >> 1293 // Leaving immediately
                                                   >> 1294         if (calcNorm)
                                                   >> 1295         {
                                                   >> 1296           *validNorm=true;
                                                   >> 1297           *n=G4ThreeVector(fPlanes[3].a,fPlanes[3].b,fPlanes[3].c);
                                                   >> 1298         }
                                                   >> 1299         return snxt=0;
                                                   >> 1300     }
                                                   >> 1301   }
                                                   >> 1302     else if (pdist<-kCarTolerance/2)
                                                   >> 1303   {
                                                   >> 1304 // Inside the plane
                                                   >> 1305       if (Comp>0)
                                                   >> 1306     {
                                                   >> 1307 // Will leave extent
                                                   >> 1308         vdist=-pdist/Comp;
                                                   >> 1309         if (vdist<snxt)
                                                   >> 1310       {
                                                   >> 1311          snxt=vdist;
                                                   >> 1312          side=ks3;
                                                   >> 1313       }
                                                   >> 1314     }
                                                   >> 1315   }
                                                   >> 1316     else
                                                   >> 1317   {
                                                   >> 1318 // On surface
                                                   >> 1319       if (Comp>0)
                                                   >> 1320     {
                                                   >> 1321         if (calcNorm)
                                                   >> 1322         {
                                                   >> 1323           *validNorm=true;
                                                   >> 1324           *n=G4ThreeVector(fPlanes[3].a,fPlanes[3].b,fPlanes[3].c);
                                                   >> 1325         }
                                                   >> 1326         return snxt=0;
                                                   >> 1327     }
                                                   >> 1328   }
                                                   >> 1329 
                                                   >> 1330 // set normal
                                                   >> 1331     if (calcNorm)
                                                   >> 1332   {
                                                   >> 1333       *validNorm=true;
                                                   >> 1334       switch(side)
                                                   >> 1335       {
                                                   >> 1336     case ks0:
                                                   >> 1337         *n=G4ThreeVector(fPlanes[0].a,fPlanes[0].b,fPlanes[0].c);
                                                   >> 1338         break;
                                                   >> 1339     case ks1:
                                                   >> 1340         *n=G4ThreeVector(fPlanes[1].a,fPlanes[1].b,fPlanes[1].c);
                                                   >> 1341         break;
                                                   >> 1342     case ks2:
                                                   >> 1343         *n=G4ThreeVector(fPlanes[2].a,fPlanes[2].b,fPlanes[2].c);
                                                   >> 1344         break;
                                                   >> 1345     case ks3:
                                                   >> 1346         *n=G4ThreeVector(fPlanes[3].a,fPlanes[3].b,fPlanes[3].c);
                                                   >> 1347         break;
                                                   >> 1348     case kMZ:
                                                   >> 1349         *n=G4ThreeVector(0,0,-1);
                                                   >> 1350         break;
                                                   >> 1351     case kPZ:
                                                   >> 1352         *n=G4ThreeVector(0,0,1);
                                                   >> 1353         break;
                                                   >> 1354     default:
                                                   >> 1355         break;
                                                   >> 1356       }
                                                   >> 1357   }
                                                   >> 1358     return snxt;
1027 }                                                1359 }
1028                                                  1360 
1029 ///////////////////////////////////////////// << 1361 //////////////////////////////////////////////////////////////////////////////
1030 //                                               1362 //
1031 // Calculate exact shortest distance to any b    1363 // Calculate exact shortest distance to any boundary from inside
1032 // - Returns 0 is ThreeVector outside            1364 // - Returns 0 is ThreeVector outside
1033                                                  1365 
1034 G4double G4Trap::DistanceToOut( const G4Three << 1366 G4double G4Trap::DistanceToOut(const G4ThreeVector& p) const
1035 {                                                1367 {
1036 #ifdef G4CSGDEBUG                             << 1368   G4double safe,Dist;
1037   if( Inside(p) == kOutside )                 << 1369   G4int i;
1038   {                                           << 1370   safe=fDz-fabs(p.z());
1039     std::ostringstream message;               << 1371 
1040     G4long oldprc = message.precision(16);    << 1372   if (safe<0) safe=0;
1041     message << "Point p is outside (!?) of so << 1373   else
1042     message << "Position:\n";                 << 
1043     message << "   p.x() = " << p.x()/mm << " << 
1044     message << "   p.y() = " << p.y()/mm << " << 
1045     message << "   p.z() = " << p.z()/mm << " << 
1046     G4cout.precision(oldprc);                 << 
1047     G4Exception("G4Trap::DistanceToOut(p)", " << 
1048                 JustWarning, message );       << 
1049     DumpInfo();                               << 
1050   }                                           << 
1051 #endif                                        << 
1052   switch (fTrapType)                          << 
1053   {                                              1374   {
1054     case 0: // General case                   << 1375     for (i=0;i<4;i++)
1055     {                                         << 
1056       G4double dz = std::abs(p.z())-fDz;      << 
1057       G4double dy1 = fPlanes[0].b*p.y()+fPlan << 
1058       G4double dy2 = fPlanes[1].b*p.y()+fPlan << 
1059       G4double dy = std::max(dz,std::max(dy1, << 
1060                                               << 
1061       G4double dx1 = fPlanes[2].a*p.x()+fPlan << 
1062                    + fPlanes[2].c*p.z()+fPlan << 
1063       G4double dx2 = fPlanes[3].a*p.x()+fPlan << 
1064                    + fPlanes[3].c*p.z()+fPlan << 
1065       G4double dist = std::max(dy,std::max(dx << 
1066       return (dist < 0) ? -dist : 0.;         << 
1067     }                                         << 
1068     case 1: // YZ section is a rectangle      << 
1069     {                                            1376     {
1070       G4double dz = std::abs(p.z())-fDz;      << 1377      Dist=-(fPlanes[i].a*p.x()+fPlanes[i].b*p.y()+fPlanes[i].c*p.z()+fPlanes[i].d);
1071       G4double dy = std::max(dz,std::abs(p.y( << 1378 
1072       G4double dx1 = fPlanes[2].a*p.x()+fPlan << 1379       if (Dist<safe) safe=Dist;
1073                    + fPlanes[2].c*p.z()+fPlan << 
1074       G4double dx2 = fPlanes[3].a*p.x()+fPlan << 
1075                    + fPlanes[3].c*p.z()+fPlan << 
1076       G4double dist = std::max(dy,std::max(dx << 
1077       return (dist < 0) ? -dist : 0.;         << 
1078     }                                         << 
1079     case 2: // YZ section is a rectangle and  << 
1080     {       // XZ section is an isosceles tra << 
1081       G4double dz = std::abs(p.z())-fDz;      << 
1082       G4double dy = std::max(dz,std::abs(p.y( << 
1083       G4double dx = fPlanes[3].a*std::abs(p.x << 
1084                   + fPlanes[3].c*p.z()+fPlane << 
1085       G4double dist = std::max(dy,dx);        << 
1086       return (dist < 0) ? -dist : 0.;         << 
1087     }                                         << 
1088     case 3: // YZ section is a rectangle and  << 
1089     {       // XY section is an isosceles tra << 
1090       G4double dz = std::abs(p.z())-fDz;      << 
1091       G4double dy = std::max(dz,std::abs(p.y( << 
1092       G4double dx = fPlanes[3].a*std::abs(p.x << 
1093                   + fPlanes[3].b*p.y()+fPlane << 
1094       G4double dist = std::max(dy,dx);        << 
1095       return (dist < 0) ? -dist : 0.;         << 
1096     }                                            1380     }
                                                   >> 1381     if (safe<0) safe=0;
1097   }                                              1382   }
1098   return 0.;                                  << 1383   return safe;  
1099 }                                                1384 }
1100                                                  1385 
1101 /////////////////////////////////////////////    1386 //////////////////////////////////////////////////////////////////////////
1102 //                                               1387 //
1103 // GetEntityType                              << 1388 // Create a List containing the transformed vertices
1104                                               << 1389 // Ordering [0-3] -fDz cross section
1105 G4GeometryType G4Trap::GetEntityType() const  << 1390 //          [4-7] +fDz cross section such that [0] is below [4],
1106 {                                             << 1391 //                                             [1] below [5] etc.
1107   return {"G4Trap"};                          << 1392 // Note:
                                                   >> 1393 //  Caller has deletion resposibility
                                                   >> 1394 
                                                   >> 1395 G4ThreeVectorList*
                                                   >> 1396 G4Trap::CreateRotatedVertices(const G4AffineTransform& pTransform) const
                                                   >> 1397 {
                                                   >> 1398     G4ThreeVectorList *vertices;
                                                   >> 1399     vertices=new G4ThreeVectorList();
                                                   >> 1400     vertices->reserve(8);
                                                   >> 1401     if (vertices)
                                                   >> 1402   {
                                                   >> 1403       G4ThreeVector vertex0(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 1404       G4ThreeVector vertex1(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,-fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 1405       G4ThreeVector vertex2(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 1406       G4ThreeVector vertex3(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,-fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 1407       G4ThreeVector vertex4(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 1408       G4ThreeVector vertex5(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,+fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 1409       G4ThreeVector vertex6(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 1410       G4ThreeVector vertex7(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,+fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 1411 
                                                   >> 1412       vertices->push_back(pTransform.TransformPoint(vertex0));
                                                   >> 1413       vertices->push_back(pTransform.TransformPoint(vertex1));
                                                   >> 1414       vertices->push_back(pTransform.TransformPoint(vertex2));
                                                   >> 1415       vertices->push_back(pTransform.TransformPoint(vertex3));
                                                   >> 1416       vertices->push_back(pTransform.TransformPoint(vertex4));
                                                   >> 1417       vertices->push_back(pTransform.TransformPoint(vertex5));
                                                   >> 1418       vertices->push_back(pTransform.TransformPoint(vertex6));
                                                   >> 1419       vertices->push_back(pTransform.TransformPoint(vertex7));
                                                   >> 1420   }
                                                   >> 1421     else
                                                   >> 1422   {
                                                   >> 1423       G4Exception("G4Trap::CreateRotatedVertices Out of memory - Cannot alloc vertices");
                                                   >> 1424   }
                                                   >> 1425     return vertices;
1108 }                                                1426 }
1109                                                  1427 
1110 ///////////////////////////////////////////// << 1428 ///////////////////////////////////////////////////////////////////////////////
1111 //                                               1429 //
1112 // IsFaceted                                  << 1430 // Methods for visualisation
1113                                                  1431 
1114 G4bool G4Trap::IsFaceted() const              << 1432 void G4Trap::DescribeYourselfTo (G4VGraphicsScene& scene) const
1115 {                                                1433 {
1116   return true;                                << 1434   scene.AddThis (*this);
1117 }                                                1435 }
1118                                                  1436 
1119 ///////////////////////////////////////////// << 1437 G4Polyhedron* G4Trap::CreatePolyhedron () const
1120 //                                            << 
1121 // Make a clone of the object                 << 
1122 //                                            << 
1123 G4VSolid* G4Trap::Clone() const               << 
1124 {                                                1438 {
1125   return new G4Trap(*this);                   << 1439     G4double phi = atan2(fTthetaSphi, fTthetaCphi);
                                                   >> 1440     G4double alpha1 = atan(fTalpha1);
                                                   >> 1441     G4double alpha2 = atan(fTalpha2);
                                                   >> 1442     G4double theta = atan(sqrt
                                                   >> 1443                           (fTthetaCphi*fTthetaCphi+fTthetaSphi*fTthetaSphi));
                                                   >> 1444     return new G4PolyhedronTrap(fDz, theta, phi, fDy1, fDx1, fDx2, alpha1,
                                                   >> 1445                                 fDy2, fDx3, fDx4, alpha2);
1126 }                                                1446 }
1127                                                  1447 
1128 ///////////////////////////////////////////// << 1448 G4NURBS* G4Trap::CreateNURBS () const
1129 //                                            << 
1130 // Stream object contents to an output stream << 
1131                                               << 
1132 std::ostream& G4Trap::StreamInfo( std::ostrea << 
1133 {                                                1449 {
1134   G4double phi    = GetPhi();                 << 1450    // return new G4NURBSbox (fDx, fDy, fDz);
1135   G4double theta  = GetTheta();               << 1451    return 0 ;
1136   G4double alpha1 = GetAlpha1();              << 
1137   G4double alpha2 = GetAlpha2();              << 
1138                                               << 
1139   G4long oldprc = os.precision(16);           << 
1140   os << "------------------------------------ << 
1141      << "    *** Dump for solid: " << GetName << 
1142      << "    ================================ << 
1143      << " Solid type: G4Trap\n"               << 
1144      << " Parameters:\n"                      << 
1145      << "    half length Z: " << fDz/mm << "  << 
1146      << "    half length Y, face -Dz: " << fD << 
1147      << "    half length X, face -Dz, side -D << 
1148      << "    half length X, face -Dz, side +D << 
1149      << "    half length Y, face +Dz: " << fD << 
1150      << "    half length X, face +Dz, side -D << 
1151      << "    half length X, face +Dz, side +D << 
1152      << "    theta: " << theta/degree << " de << 
1153      << "    phi:   " << phi/degree << " degr << 
1154      << "    alpha, face -Dz: " << alpha1/deg << 
1155      << "    alpha, face +Dz: " << alpha2/deg << 
1156      << "------------------------------------ << 
1157   os.precision(oldprc);                       << 
1158                                               << 
1159   return os;                                  << 
1160 }                                                1452 }
1161                                                  1453 
1162 ///////////////////////////////////////////// << 
1163 //                                            << 
1164 // Compute vertices from planes               << 
1165                                                  1454 
1166 void G4Trap::GetVertices(G4ThreeVector pt[8]) << 1455 // ********************************  End of G4Trap.cc   ********************************
1167 {                                             << 
1168   for (G4int i=0; i<8; ++i)                   << 
1169   {                                           << 
1170     G4int iy = (i==0 || i==1 || i==4 || i==5) << 
1171     G4int ix = (i==0 || i==2 || i==4 || i==6) << 
1172     G4double z = (i < 4) ? -fDz : fDz;        << 
1173     G4double y = -(fPlanes[iy].c*z + fPlanes[ << 
1174     G4double x = -(fPlanes[ix].b*y + fPlanes[ << 
1175                    + fPlanes[ix].d)/fPlanes[i << 
1176     pt[i].set(x,y,z);                         << 
1177   }                                           << 
1178 }                                             << 
1179                                                  1456 
1180 ///////////////////////////////////////////// << 
1181 //                                            << 
1182 // Generate random point on the surface       << 
1183                                                  1457 
1184 G4ThreeVector G4Trap::GetPointOnSurface() con << 
1185 {                                             << 
1186   // Set indeces                              << 
1187   constexpr G4int iface [6][4] =              << 
1188     { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2,6 << 
1189                                               << 
1190   // Set vertices                             << 
1191   G4ThreeVector pt[8];                        << 
1192   GetVertices(pt);                            << 
1193                                               << 
1194   // Select face                              << 
1195   //                                          << 
1196   G4double select = fAreas[5]*G4QuickRand();  << 
1197   G4int k = 5;                                << 
1198   k -= (G4int)(select <= fAreas[4]);          << 
1199   k -= (G4int)(select <= fAreas[3]);          << 
1200   k -= (G4int)(select <= fAreas[2]);          << 
1201   k -= (G4int)(select <= fAreas[1]);          << 
1202   k -= (G4int)(select <= fAreas[0]);          << 
1203                                               << 
1204   // Select sub-triangle                      << 
1205   //                                          << 
1206   G4int i0 = iface[k][0];                     << 
1207   G4int i1 = iface[k][1];                     << 
1208   G4int i2 = iface[k][2];                     << 
1209   G4int i3 = iface[k][3];                     << 
1210   G4double s2 = G4GeomTools::TriangleAreaNorm << 
1211   if (select > fAreas[k] - s2) i0 = i2;       << 
1212                                               << 
1213   // Generate point                           << 
1214   //                                          << 
1215   G4double u = G4QuickRand();                 << 
1216   G4double v = G4QuickRand();                 << 
1217   if (u + v > 1.) { u = 1. - u; v = 1. - v; } << 
1218   return (1.-u-v)*pt[i0] + u*pt[i1] + v*pt[i3 << 
1219 }                                             << 
1220                                                  1458 
1221 ///////////////////////////////////////////// << 
1222 //                                            << 
1223 // Methods for visualisation                  << 
1224                                               << 
1225 void G4Trap::DescribeYourselfTo ( G4VGraphics << 
1226 {                                             << 
1227   scene.AddSolid (*this);                     << 
1228 }                                             << 
1229                                                  1459 
1230 G4Polyhedron* G4Trap::CreatePolyhedron () con << 
1231 {                                             << 
1232   G4double phi = std::atan2(fTthetaSphi, fTth << 
1233   G4double alpha1 = std::atan(fTalpha1);      << 
1234   G4double alpha2 = std::atan(fTalpha2);      << 
1235   G4double theta = std::atan(std::sqrt(fTthet << 
1236                                       +fTthet << 
1237                                               << 
1238   return new G4PolyhedronTrap(fDz, theta, phi << 
1239                               fDy1, fDx1, fDx << 
1240                               fDy2, fDx3, fDx << 
1241 }                                             << 
1242                                                  1460 
1243 #endif                                        << 
1244                                                  1461