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 8.1.p2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 //
                                                   >>  27 // $Id: G4Trap.cc,v 1.41 2006/06/29 18:45:41 gunter Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-08-01-patch-01 $
                                                   >>  29 //
                                                   >>  30 // class G4Trap
                                                   >>  31 //
 26 // Implementation for G4Trap class                 32 // Implementation for G4Trap class
 27 //                                                 33 //
 28 // 21.03.95 P.Kent: Modified for `tolerant' ge <<  34 // History:
                                                   >>  35 //
                                                   >>  36 // 28.04.05 V.Grichine: new SurfaceNormal according to J. Apostolakis proposal 
                                                   >>  37 // 26.04.05 V.Grichine: new SurfaceNormal is default 
                                                   >>  38 // 19.04.05 V.Grichine: bug fixed in G4Trap("name",G4ThreeVector[8] vp)
                                                   >>  39 // 12.12.04 V.Grichine: SurfaceNormal with edges/vertices 
                                                   >>  40 // 15.11.04 V.Grichine: bug fixed in G4Trap("name",G4ThreeVector[8] vp)
                                                   >>  41 // 13.12.99 V.Grichine: bug fixed in DistanceToIn(p,v)
                                                   >>  42 // 19.11.99 V.Grichine: kUndef was added to Eside enum
                                                   >>  43 // 04.06.99 S.Giani: Fixed CalculateExtent in rotated case. 
                                                   >>  44 // 08.12.97 J.Allison: Added "nominal" constructor and method SetAllParameters.
                                                   >>  45 // 01.11.96 V.Grichine: Costructor for Right Angular Wedge from STEP, G4Trd/Para
 29 // 09.09.96 V.Grichine: Final modifications be     46 // 09.09.96 V.Grichine: Final modifications before to commit
 30 // 08.12.97 J.Allison: Added "nominal" constru <<  47 // 21.03.95 P.Kent: Modified for `tolerant' geometry
 31 // 28.04.05 V.Grichine: new SurfaceNormal acco <<  48 //
 32 // 18.04.17 E.Tcherniaev: complete revision, s <<  49 //////////////////////////////////////////////////////////////////////////////////// 
 33 // ------------------------------------------- << 
 34                                                    50 
 35 #include "G4Trap.hh"                               51 #include "G4Trap.hh"
 36                                                << 
 37 #if !defined(G4GEOM_USE_UTRAP)                 << 
 38                                                << 
 39 #include "globals.hh"                              52 #include "globals.hh"
 40 #include "G4GeomTools.hh"                      << 
 41                                                    53 
 42 #include "G4VoxelLimits.hh"                        54 #include "G4VoxelLimits.hh"
 43 #include "G4AffineTransform.hh"                    55 #include "G4AffineTransform.hh"
 44 #include "G4BoundingEnvelope.hh"               << 
 45                                                    56 
 46 #include "G4VPVParameterisation.hh"                57 #include "G4VPVParameterisation.hh"
 47                                                    58 
 48 #include "G4QuickRand.hh"                      <<  59 #include "Randomize.hh"
 49                                                    60 
 50 #include "G4VGraphicsScene.hh"                     61 #include "G4VGraphicsScene.hh"
 51 #include "G4Polyhedron.hh"                         62 #include "G4Polyhedron.hh"
                                                   >>  63 #include "G4NURBS.hh"
                                                   >>  64 #include "G4NURBSbox.hh"
 52                                                    65 
 53 using namespace CLHEP;                             66 using namespace CLHEP;
 54                                                    67 
                                                   >>  68 ////////////////////////////////////////////////////////////////////////
                                                   >>  69 //
                                                   >>  70 // Accuracy of coplanarity
                                                   >>  71 
                                                   >>  72 const G4double kCoplanar_Tolerance = 1E-4 ;
                                                   >>  73 
                                                   >>  74 //////////////////////////////////////////////////////////////////////////
                                                   >>  75 //
                                                   >>  76 // Private enum: Not for external use 
                                                   >>  77     
                                                   >>  78 enum Eside {kUndef,ks0,ks1,ks2,ks3,kPZ,kMZ};
                                                   >>  79 
 55 //////////////////////////////////////////////     80 //////////////////////////////////////////////////////////////////////////
 56 //                                                 81 //
 57 // Constructor - check and set half-widths as  <<  82 // Constructor - check and set half-widths as well as angles: 
 58 // final check of coplanarity                      83 // final check of coplanarity
 59                                                    84 
 60 G4Trap::G4Trap( const G4String& pName,             85 G4Trap::G4Trap( const G4String& pName,
 61                       G4double pDz,                86                       G4double pDz,
 62                       G4double pTheta, G4doubl     87                       G4double pTheta, G4double pPhi,
 63                       G4double pDy1, G4double      88                       G4double pDy1, G4double pDx1, G4double pDx2,
 64                       G4double pAlp1,              89                       G4double pAlp1,
 65                       G4double pDy2, G4double      90                       G4double pDy2, G4double pDx3, G4double pDx4,
 66                       G4double pAlp2 )         <<  91                       G4double pAlp2)
 67   : G4CSGSolid(pName), halfCarTolerance(0.5*kC <<  92   : G4CSGSolid(pName)
 68 {                                                  93 {
 69   fDz = pDz;                                   <<  94   if ( pDz > 0 && pDy1 > 0 && pDx1 > 0 && 
 70   fTthetaCphi = std::tan(pTheta)*std::cos(pPhi <<  95        pDx2 > 0 && pDy2 > 0 && pDx3 > 0 && pDx4 > 0 )
 71   fTthetaSphi = std::tan(pTheta)*std::sin(pPhi <<  96   {
 72                                                <<  97     fDz=pDz;
 73   fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx2; fTalp <<  98     fTthetaCphi=std::tan(pTheta)*std::cos(pPhi);
 74   fDy2 = pDy2; fDx3 = pDx3; fDx4 = pDx4; fTalp <<  99     fTthetaSphi=std::tan(pTheta)*std::sin(pPhi);
                                                   >> 100       
                                                   >> 101     fDy1=pDy1;
                                                   >> 102     fDx1=pDx1;
                                                   >> 103     fDx2=pDx2;
                                                   >> 104     fTalpha1=std::tan(pAlp1);
                                                   >> 105      
                                                   >> 106     fDy2=pDy2;
                                                   >> 107     fDx3=pDx3;
                                                   >> 108     fDx4=pDx4;
                                                   >> 109     fTalpha2=std::tan(pAlp2);
 75                                                   110 
 76   CheckParameters();                           << 111     MakePlanes();
 77   MakePlanes();                                << 112   }
                                                   >> 113   else
                                                   >> 114   {
                                                   >> 115     G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl
                                                   >> 116            << "        Invalid dimensions !" << G4endl
                                                   >> 117            << "          X - "
                                                   >> 118            << pDx1 << ", " << pDx2 << ", " << pDx3 << ", " << pDx4 << G4endl
                                                   >> 119            << "          Y - " << pDy1 << ", " << pDy2 << G4endl
                                                   >> 120            << "          Z - " << pDz << G4endl;
                                                   >> 121     G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 122                 "Invalid length G4Trap parameters.");
                                                   >> 123   }
 78 }                                                 124 }
 79                                                   125 
 80 ////////////////////////////////////////////// << 126 ////////////////////////////////////////////////////////////////////////////
 81 //                                                127 //
 82 // Constructor - Design of trapezoid based on  << 128 // Constructor - Design of trapezoid based on 8 G4ThreeVector parameters, 
 83 // which are its vertices. Checking of planari << 129 // which are its vertices. Checking of planarity with preparation of 
 84 // fPlanes[] and than calculation of other mem    130 // fPlanes[] and than calculation of other members
 85                                                   131 
 86 G4Trap::G4Trap( const G4String& pName,            132 G4Trap::G4Trap( const G4String& pName,
 87                 const G4ThreeVector pt[8] )       133                 const G4ThreeVector pt[8] )
 88   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 134   : G4CSGSolid(pName)
 89 {                                                 135 {
 90   // Start with check of centering - the cente    136   // Start with check of centering - the center of gravity trap line
 91   // should cross the origin of frame             137   // should cross the origin of frame
 92   //                                           << 
 93   if (  pt[0].z() >= 0                         << 
 94         || pt[0].z() != pt[1].z()              << 
 95         || pt[0].z() != pt[2].z()              << 
 96         || pt[0].z() != pt[3].z()              << 
 97                                                << 
 98         || pt[4].z() <= 0                      << 
 99         || pt[4].z() != pt[5].z()              << 
100         || pt[4].z() != pt[6].z()              << 
101         || pt[4].z() != pt[7].z()              << 
102                                                << 
103         || std::fabs( pt[0].z() + pt[4].z() )  << 
104                                                << 
105         || pt[0].y() != pt[1].y()              << 
106         || pt[2].y() != pt[3].y()              << 
107         || pt[4].y() != pt[5].y()              << 
108         || pt[6].y() != pt[7].y()              << 
109                                                << 
110         || std::fabs(pt[0].y()+pt[2].y()+pt[4] << 
111         || std::fabs(pt[0].x()+pt[1].x()+pt[4] << 
112                      pt[2].x()+pt[3].x()+pt[6] << 
113   {                                            << 
114     std::ostringstream message;                << 
115     message << "Invalid vertice coordinates fo << 
116     G4Exception("G4Trap::G4Trap()", "GeomSolid << 
117                 FatalException, message);      << 
118   }                                            << 
119                                                << 
120   // Set parameters                            << 
121   //                                           << 
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                                                   138 
134   fTthetaCphi = ((pt[4]).x()+fDy2*fTalpha2+fDx << 139   if (   pt[0].z() < 0 
135   fTthetaSphi = ((pt[4]).y()+fDy2)/fDz;        << 140       && pt[0].z() == pt[1].z() && pt[0].z() == pt[2].z() && pt[0].z() == pt[3].z()
                                                   >> 141       && pt[4].z() > 0 
                                                   >> 142       && pt[4].z() == pt[5].z() && pt[4].z() == pt[6].z() && pt[4].z() == pt[7].z()
                                                   >> 143       && ( pt[0].z() + pt[4].z() ) == 0
                                                   >> 144       && pt[0].y() == pt[1].y() && pt[2].y() == pt[3].y()
                                                   >> 145       && pt[4].y() == pt[5].y() && pt[6].y() == pt[7].y()
                                                   >> 146       && ( pt[0].y() + pt[2].y() + pt[4].y() + pt[6].y() ) == 0 
                                                   >> 147       && ( pt[0].x() + pt[1].x() + pt[4].x() + pt[5].x() + 
                                                   >> 148            pt[2].x() + pt[3].x() + pt[6].x() + pt[7].x() ) == 0 )
                                                   >> 149   {
                                                   >> 150     G4bool good;
                                                   >> 151     
                                                   >> 152     // Bottom side with normal approx. -Y
                                                   >> 153     
                                                   >> 154     good = MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]);
                                                   >> 155 
                                                   >> 156     if (!good)
                                                   >> 157     {
                                                   >> 158       DumpInfo();
                                                   >> 159       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 160                   "Face at ~-Y not planar.");
                                                   >> 161     }
                                                   >> 162 
                                                   >> 163     // Top side with normal approx. +Y
                                                   >> 164     
                                                   >> 165     good = MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
                                                   >> 166 
                                                   >> 167     if (!good)
                                                   >> 168     {
                                                   >> 169       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 170       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 171                   "Face at ~+Y not planar.");
                                                   >> 172     }
                                                   >> 173 
                                                   >> 174     // Front side with normal approx. -X
                                                   >> 175     
                                                   >> 176     good = MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
                                                   >> 177 
                                                   >> 178     if (!good)
                                                   >> 179     {
                                                   >> 180       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 181       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 182                   "Face at ~-X not planar.");
                                                   >> 183     }
                                                   >> 184 
                                                   >> 185     // Back side iwth normal approx. +X
                                                   >> 186     
                                                   >> 187     good = MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
                                                   >> 188     if (!good)
                                                   >> 189     {
                                                   >> 190       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 191       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 192                   "Face at ~+X not planar.");
                                                   >> 193     }
                                                   >> 194     fDz = (pt[7]).z() ;
                                                   >> 195       
                                                   >> 196     fDy1     = ((pt[2]).y()-(pt[1]).y())*0.5;
                                                   >> 197     fDx1     = ((pt[1]).x()-(pt[0]).x())*0.5;
                                                   >> 198     fDx2     = ((pt[3]).x()-(pt[2]).x())*0.5;
                                                   >> 199     fTalpha1 = ((pt[2]).x()+(pt[3]).x()-(pt[1]).x()-(pt[0]).x())*0.25/fDy1;
                                                   >> 200 
                                                   >> 201     fDy2     = ((pt[6]).y()-(pt[5]).y())*0.5;
                                                   >> 202     fDx3     = ((pt[5]).x()-(pt[4]).x())*0.5;
                                                   >> 203     fDx4     = ((pt[7]).x()-(pt[6]).x())*0.5;
                                                   >> 204     fTalpha2 = ((pt[6]).x()+(pt[7]).x()-(pt[5]).x()-(pt[4]).x())*0.25/fDy2;
136                                                   205 
137   CheckParameters();                           << 206     fTthetaCphi = ((pt[4]).x()+fDy2*fTalpha2+fDx3)/fDz;
138   MakePlanes(pt);                              << 207     fTthetaSphi = ((pt[4]).y()+fDy2)/fDz;
                                                   >> 208   }
                                                   >> 209   else
                                                   >> 210   {
                                                   >> 211     G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 212     G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 213                   "Invalid vertice coordinates.");
                                                   >> 214   }
139 }                                                 215 }
140                                                   216 
141 ////////////////////////////////////////////// << 217 //////////////////////////////////////////////////////////////////////////////
142 //                                                218 //
143 // Constructor for Right Angular Wedge from ST    219 // Constructor for Right Angular Wedge from STEP
144                                                   220 
145 G4Trap::G4Trap( const G4String& pName,            221 G4Trap::G4Trap( const G4String& pName,
146                       G4double pZ,                222                       G4double pZ,
147                       G4double pY,                223                       G4double pY,
148                       G4double pX, G4double pL    224                       G4double pX, G4double pLTX )
149   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 225   : G4CSGSolid(pName) 
                                                   >> 226          
150 {                                                 227 {
151   fDz  = 0.5*pZ; fTthetaCphi = 0; fTthetaSphi  << 228   G4bool good;
152   fDy1 = 0.5*pY; fDx1 = 0.5*pX; fDx2 = 0.5*pLT << 229 
153   fDy2 = fDy1;   fDx3 = fDx1;   fDx4 = fDx2;   << 230   if ( pZ>0 && pY>0 && pX>0 && pLTX>0 && pLTX<=pX )
                                                   >> 231   {
                                                   >> 232     fDz = 0.5*pZ ;
                                                   >> 233     fTthetaCphi = 0 ;
                                                   >> 234     fTthetaSphi = 0 ;
                                                   >> 235 
                                                   >> 236     fDy1 = 0.5*pY;
                                                   >> 237     fDx1 = 0.5*pX ;
                                                   >> 238     fDx2 = 0.5*pLTX;
                                                   >> 239     fTalpha1 =  0.5*(pLTX - pX)/pY;
                                                   >> 240 
                                                   >> 241     fDy2 = fDy1 ;
                                                   >> 242     fDx3 = fDx1;
                                                   >> 243     fDx4 = fDx2 ;
                                                   >> 244     fTalpha2 = fTalpha1 ;
                                                   >> 245 
                                                   >> 246     G4ThreeVector pt[8] ;
                                                   >> 247 
                                                   >> 248     pt[0]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,
                                                   >> 249                         -fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 250     pt[1]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,
                                                   >> 251                         -fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 252     pt[2]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,
                                                   >> 253                         -fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 254     pt[3]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,
                                                   >> 255                         -fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 256     pt[4]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,
                                                   >> 257                         +fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 258     pt[5]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,
                                                   >> 259                         +fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 260     pt[6]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,
                                                   >> 261                         +fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 262     pt[7]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,
                                                   >> 263                         +fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 264 
                                                   >> 265     // Bottom side with normal approx. -Y
                                                   >> 266     //
                                                   >> 267     good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]);
                                                   >> 268     if (!good)
                                                   >> 269     {
                                                   >> 270       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 271       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 272                   "Face at ~-Y not planar.");
                                                   >> 273     }
                                                   >> 274 
                                                   >> 275     // Top side with normal approx. +Y
                                                   >> 276     //
                                                   >> 277     good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
                                                   >> 278     if (!good)
                                                   >> 279     {
                                                   >> 280       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 281       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 282                   "Face at ~+Y not planar.");
                                                   >> 283     }
154                                                   284 
155   CheckParameters();                           << 285     // Front side with normal approx. -X
156   MakePlanes();                                << 286     //
                                                   >> 287     good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
                                                   >> 288     if (!good)
                                                   >> 289     {
                                                   >> 290       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 291       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 292                   "Face at ~-X not planar.");
                                                   >> 293     }
                                                   >> 294 
                                                   >> 295     // Back side iwth normal approx. +X
                                                   >> 296     //
                                                   >> 297     good=MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
                                                   >> 298     if (!good)
                                                   >> 299     {
                                                   >> 300       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 301       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 302                   "Face at ~+X not planar.");
                                                   >> 303     }
                                                   >> 304   }
                                                   >> 305     else
                                                   >> 306   {
                                                   >> 307     G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 308     G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 309                 "Invalid length G4Trap parameters.");
                                                   >> 310   }
157 }                                                 311 }
158                                                   312 
159 ////////////////////////////////////////////// << 313 ///////////////////////////////////////////////////////////////////////////////
160 //                                                314 //
161 // Constructor for G4Trd                          315 // Constructor for G4Trd
162                                                   316 
163 G4Trap::G4Trap( const G4String& pName,            317 G4Trap::G4Trap( const G4String& pName,
164                       G4double pDx1,  G4double    318                       G4double pDx1,  G4double pDx2,
165                       G4double pDy1,  G4double    319                       G4double pDy1,  G4double pDy2,
166                       G4double pDz )              320                       G4double pDz )
167   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 321   : G4CSGSolid(pName)
168 {                                                 322 {
169   fDz  = pDz;  fTthetaCphi = 0; fTthetaSphi =  << 323   G4bool good;
170   fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx1; fTalp << 324 
171   fDy2 = pDy2; fDx3 = pDx2; fDx4 = pDx2; fTalp << 325   if ( pDz>0 && pDy1>0 && pDx1>0 && pDx2>0 && pDy2>0 )
                                                   >> 326   {
                                                   >> 327     fDz = pDz;
                                                   >> 328     fTthetaCphi = 0 ;
                                                   >> 329     fTthetaSphi = 0 ;
                                                   >> 330       
                                                   >> 331     fDy1 = pDy1 ;
                                                   >> 332     fDx1 = pDx1 ;
                                                   >> 333     fDx2 = pDx1 ;
                                                   >> 334     fTalpha1 = 0 ;
                                                   >> 335      
                                                   >> 336     fDy2 = pDy2 ;
                                                   >> 337     fDx3 = pDx2 ;
                                                   >> 338     fDx4 = pDx2 ;
                                                   >> 339     fTalpha2 = 0 ;
                                                   >> 340 
                                                   >> 341     G4ThreeVector pt[8] ;
                                                   >> 342      
                                                   >> 343     pt[0]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,
                                                   >> 344                         -fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 345     pt[1]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,
                                                   >> 346                         -fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 347     pt[2]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,
                                                   >> 348                         -fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 349     pt[3]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,
                                                   >> 350                         -fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 351     pt[4]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,
                                                   >> 352                         +fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 353     pt[5]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,
                                                   >> 354                         +fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 355     pt[6]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,
                                                   >> 356                         +fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 357     pt[7]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,
                                                   >> 358                         +fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 359 
                                                   >> 360     // Bottom side with normal approx. -Y
                                                   >> 361     //
                                                   >> 362     good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]);
                                                   >> 363     if (!good)
                                                   >> 364     {
                                                   >> 365       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 366       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 367                   "Face at ~-Y not planar.");
                                                   >> 368     }
                                                   >> 369 
                                                   >> 370     // Top side with normal approx. +Y
                                                   >> 371     //
                                                   >> 372     good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
                                                   >> 373     if (!good)
                                                   >> 374     {
                                                   >> 375       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 376       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 377                   "Face at ~+Y not planar.");
                                                   >> 378     }
172                                                   379 
173   CheckParameters();                           << 380     // Front side with normal approx. -X
174   MakePlanes();                                << 381     //
                                                   >> 382     good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
                                                   >> 383     if (!good)
                                                   >> 384     {
                                                   >> 385       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 386       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 387                   "Face at ~-X not planar.");
                                                   >> 388     }
                                                   >> 389 
                                                   >> 390     // Back side iwth normal approx. +X
                                                   >> 391     //
                                                   >> 392     good=MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
                                                   >> 393     if (!good)
                                                   >> 394     {
                                                   >> 395       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 396       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 397                   "Face at ~+X not planar.");
                                                   >> 398     }
                                                   >> 399   }
                                                   >> 400   else
                                                   >> 401   {
                                                   >> 402     G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 403     G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 404                 "Invalid length G4Trap parameters.");
                                                   >> 405   }
175 }                                                 406 }
176                                                   407 
177 ////////////////////////////////////////////// << 408 ////////////////////////////////////////////////////////////////////////////
178 //                                                409 //
179 // Constructor for G4Para                         410 // Constructor for G4Para
180                                                   411 
181 G4Trap::G4Trap( const G4String& pName,            412 G4Trap::G4Trap( const G4String& pName,
182                       G4double pDx, G4double p    413                       G4double pDx, G4double pDy,
183                       G4double pDz,               414                       G4double pDz,
184                       G4double pAlpha,            415                       G4double pAlpha,
185                       G4double pTheta, G4doubl << 416                       G4double pTheta, G4double pPhi)
186   : G4CSGSolid(pName), halfCarTolerance(0.5*kC << 417   : G4CSGSolid(pName)       
187 {                                                 418 {
188   fDz = pDz;                                   << 419   G4bool good;
189   fTthetaCphi = std::tan(pTheta)*std::cos(pPhi << 420 
190   fTthetaSphi = std::tan(pTheta)*std::sin(pPhi << 421   if ( pDz>0 && pDy>0 && pDx>0 )
                                                   >> 422   {
                                                   >> 423     fDz = pDz ;
                                                   >> 424     fTthetaCphi = std::tan(pTheta)*std::cos(pPhi) ;
                                                   >> 425     fTthetaSphi = std::tan(pTheta)*std::sin(pPhi) ;
                                                   >> 426      
                                                   >> 427     fDy1 = pDy ;
                                                   >> 428     fDx1 = pDx ;
                                                   >> 429     fDx2 = pDx ;
                                                   >> 430     fTalpha1 = std::tan(pAlpha) ;
                                                   >> 431     
                                                   >> 432     fDy2 = pDy ;
                                                   >> 433     fDx3 = pDx ;
                                                   >> 434     fDx4 = pDx ;
                                                   >> 435     fTalpha2 = fTalpha1 ;
                                                   >> 436 
                                                   >> 437     G4ThreeVector pt[8] ;
                                                   >> 438      
                                                   >> 439     pt[0]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,
                                                   >> 440                         -fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 441     pt[1]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,
                                                   >> 442                         -fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 443     pt[2]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,
                                                   >> 444                         -fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 445     pt[3]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,
                                                   >> 446                         -fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 447     pt[4]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,
                                                   >> 448                         +fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 449     pt[5]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,
                                                   >> 450                         +fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 451     pt[6]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,
                                                   >> 452                         +fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 453     pt[7]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,
                                                   >> 454                         +fDz*fTthetaSphi+fDy2,+fDz);
191                                                   455 
192   fDy1 = pDy; fDx1 = pDx; fDx2 = pDx; fTalpha1 << 456     // Bottom side with normal approx. -Y
193   fDy2 = pDy; fDx3 = pDx; fDx4 = pDx; fTalpha2 << 457     //
                                                   >> 458     good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]);
                                                   >> 459     if (!good)
                                                   >> 460     {
                                                   >> 461       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 462       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 463                   "Face at ~-Y not planar.");
                                                   >> 464     }
194                                                   465 
195   CheckParameters();                           << 466     // Top side with normal approx. +Y
196   MakePlanes();                                << 467     //
                                                   >> 468     good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
                                                   >> 469     if (!good)
                                                   >> 470     {
                                                   >> 471       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 472       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 473                   "Face at ~+Y not planar.");
                                                   >> 474     }
                                                   >> 475 
                                                   >> 476     // Front side with normal approx. -X
                                                   >> 477     //
                                                   >> 478     good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
                                                   >> 479     if (!good)
                                                   >> 480     {
                                                   >> 481       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 482       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 483                   "Face at ~-X not planar.");
                                                   >> 484     }
                                                   >> 485 
                                                   >> 486     // Back side iwth normal approx. +X
                                                   >> 487     //
                                                   >> 488     good=MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
                                                   >> 489     if (!good)
                                                   >> 490     {
                                                   >> 491       G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 492       G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 493                   "Face at ~+X not planar.");
                                                   >> 494     }
                                                   >> 495   }
                                                   >> 496   else
                                                   >> 497   {
                                                   >> 498     G4cerr << "ERROR - G4Trap()::G4Trap(): " << GetName() << G4endl;
                                                   >> 499     G4Exception("G4Trap::G4Trap()", "InvalidSetup", FatalException,
                                                   >> 500                 "Invalid length G4Trap parameters.");
                                                   >> 501   }
197 }                                                 502 }
198                                                   503 
199 ////////////////////////////////////////////// << 504 ///////////////////////////////////////////////////////////////////////////
200 //                                                505 //
201 // Nominal constructor for G4Trap whose parame    506 // Nominal constructor for G4Trap whose parameters are to be set by
202 // a G4VParamaterisation later.  Check and set    507 // a G4VParamaterisation later.  Check and set half-widths as well as
203 // angles: final check of coplanarity             508 // angles: final check of coplanarity
204                                                   509 
205 G4Trap::G4Trap( const G4String& pName )           510 G4Trap::G4Trap( const G4String& pName )
206   : G4CSGSolid (pName), halfCarTolerance(0.5*k << 511   : G4CSGSolid (pName),
207     fDz(1.), fTthetaCphi(0.), fTthetaSphi(0.), << 512     fDz         (1.),
208     fDy1(1.), fDx1(1.), fDx2(1.), fTalpha1(0.) << 513     fTthetaCphi (0.),
209     fDy2(1.), fDx3(1.), fDx4(1.), fTalpha2(0.) << 514     fTthetaSphi (0.),
                                                   >> 515     fDy1        (1.),
                                                   >> 516     fDx1        (1.),
                                                   >> 517     fDx2        (1.),
                                                   >> 518     fTalpha1    (0.),
                                                   >> 519     fDy2        (1.),
                                                   >> 520     fDx3        (1.),
                                                   >> 521     fDx4        (1.),
                                                   >> 522     fTalpha2    (0.)
210 {                                                 523 {
211   MakePlanes();                                << 524  MakePlanes();
212 }                                                 525 }
213                                                   526 
214 ////////////////////////////////////////////// << 527 ///////////////////////////////////////////////////////////////////////
215 //                                                528 //
216 // Fake default constructor - sets only member    529 // Fake default constructor - sets only member data and allocates memory
217 //                            for usage restri    530 //                            for usage restricted to object persistency.
218 //                                                531 //
219 G4Trap::G4Trap( __void__& a )                     532 G4Trap::G4Trap( __void__& a )
220   : G4CSGSolid(a), halfCarTolerance(0.5*kCarTo << 533   : G4CSGSolid(a)
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 {                                                 534 {
225   MakePlanes();                                << 
226 }                                                 535 }
227                                                   536 
228 ////////////////////////////////////////////// << 537 ////////////////////////////////////////////////////////////////////////
229 //                                                538 //
230 // Destructor                                     539 // Destructor
231                                                   540 
232 G4Trap::~G4Trap() = default;                   << 541 G4Trap::~G4Trap()
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 {                                                 542 {
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 }                                                 543 }
274                                                   544 
275 ////////////////////////////////////////////// << 545 ///////////////////////////////////////////////////////////////////////
276 //                                                546 //
277 // Set all parameters, as for constructor - ch    547 // Set all parameters, as for constructor - check and set half-widths
278 // as well as angles: final check of coplanari    548 // as well as angles: final check of coplanarity
279                                                   549 
280 void G4Trap::SetAllParameters ( G4double pDz,     550 void G4Trap::SetAllParameters ( G4double pDz,
281                                 G4double pThet    551                                 G4double pTheta,
282                                 G4double pPhi,    552                                 G4double pPhi,
283                                 G4double pDy1,    553                                 G4double pDy1,
284                                 G4double pDx1,    554                                 G4double pDx1,
285                                 G4double pDx2,    555                                 G4double pDx2,
286                                 G4double pAlp1    556                                 G4double pAlp1,
287                                 G4double pDy2,    557                                 G4double pDy2,
288                                 G4double pDx3,    558                                 G4double pDx3,
289                                 G4double pDx4,    559                                 G4double pDx4,
290                                 G4double pAlp2    560                                 G4double pAlp2 )
291 {                                                 561 {
292   // Reset data of the base class              << 562   fCubicVolume= 0.;
293   fCubicVolume = 0;                            << 563   fpPolyhedron = 0;
294   fSurfaceArea = 0;                            << 564   if ( pDz>0 && pDy1>0 && pDx1>0 && pDx2>0 && pDy2>0 && pDx3>0 && pDx4>0 )
295   fRebuildPolyhedron = true;                   << 565   {
296                                                << 566     fDz=pDz;
297   // Set parameters                            << 567     fTthetaCphi=std::tan(pTheta)*std::cos(pPhi);
298   fDz = pDz;                                   << 568     fTthetaSphi=std::tan(pTheta)*std::sin(pPhi);
299   fTthetaCphi = std::tan(pTheta)*std::cos(pPhi << 569      
300   fTthetaSphi = std::tan(pTheta)*std::sin(pPhi << 570     fDy1=pDy1;
301                                                << 571     fDx1=pDx1;
302   fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx2; fTalp << 572     fDx2=pDx2;
303   fDy2 = pDy2; fDx3 = pDx3; fDx4 = pDx4; fTalp << 573     fTalpha1=std::tan(pAlp1);
                                                   >> 574     
                                                   >> 575     fDy2=pDy2;
                                                   >> 576     fDx3=pDx3;
                                                   >> 577     fDx4=pDx4;
                                                   >> 578     fTalpha2=std::tan(pAlp2);
304                                                   579 
305   CheckParameters();                           << 580     MakePlanes();
306   MakePlanes();                                << 581   }
307 }                                              << 582   else
308                                                << 583   {
309 ////////////////////////////////////////////// << 584     G4cerr << "ERROR - G4Trap()::SetAllParameters(): " << GetName() << G4endl
310 //                                             << 585            << "        Invalid dimensions !" << G4endl
311 // Check length parameters                     << 586            << "          X - "
312                                                << 587            << pDx1 << ", " << pDx2 << ", " << pDx3 << ", " << pDx4 << G4endl
313 void G4Trap::CheckParameters()                 << 588            << "          Y - " << pDy1 << ", " << pDy2 << G4endl
314 {                                              << 589            << "          Z - " << pDz << G4endl;
315   if (fDz<=0 ||                                << 590     G4Exception("G4Trap::SetAllParameters()", "InvalidSetup",
316       fDy1<=0 || fDx1<=0 || fDx2<=0 ||         << 591                 FatalException, "Invalid Length Parameters.");
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   }                                               592   }
327 }                                                 593 }
328                                                   594 
329 //////////////////////////////////////////////    595 //////////////////////////////////////////////////////////////////////////
330 //                                                596 //
331 // Compute vertices and set side planes        << 597 // Checking of coplanarity
332                                                << 598 
333 void G4Trap::MakePlanes()                      << 599 G4bool G4Trap::MakePlanes()
334 {                                              << 600 {
335   G4double DzTthetaCphi = fDz*fTthetaCphi;     << 601   G4bool good = true;
336   G4double DzTthetaSphi = fDz*fTthetaSphi;     << 602 
337   G4double Dy1Talpha1   = fDy1*fTalpha1;       << 603   G4ThreeVector pt[8] ;
338   G4double Dy2Talpha2   = fDy2*fTalpha2;       << 604      
339                                                << 605   pt[0]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,
340   G4ThreeVector pt[8] =                        << 606                       -fDz*fTthetaSphi-fDy1,-fDz);
341   {                                            << 607   pt[1]=G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,
342     G4ThreeVector(-DzTthetaCphi-Dy1Talpha1-fDx << 608                       -fDz*fTthetaSphi-fDy1,-fDz);
343     G4ThreeVector(-DzTthetaCphi-Dy1Talpha1+fDx << 609   pt[2]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,
344     G4ThreeVector(-DzTthetaCphi+Dy1Talpha1-fDx << 610                       -fDz*fTthetaSphi+fDy1,-fDz);
345     G4ThreeVector(-DzTthetaCphi+Dy1Talpha1+fDx << 611   pt[3]=G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,
346     G4ThreeVector( DzTthetaCphi-Dy2Talpha2-fDx << 612                       -fDz*fTthetaSphi+fDy1,-fDz);
347     G4ThreeVector( DzTthetaCphi-Dy2Talpha2+fDx << 613   pt[4]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,
348     G4ThreeVector( DzTthetaCphi+Dy2Talpha2-fDx << 614                       +fDz*fTthetaSphi-fDy2,+fDz);
349     G4ThreeVector( DzTthetaCphi+Dy2Talpha2+fDx << 615   pt[5]=G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,
350   };                                           << 616                       +fDz*fTthetaSphi-fDy2,+fDz);
351                                                << 617   pt[6]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,
352   MakePlanes(pt);                              << 618                       +fDz*fTthetaSphi+fDy2,+fDz);
353 }                                              << 619   pt[7]=G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,
354                                                << 620                       +fDz*fTthetaSphi+fDy2,+fDz);
355 ////////////////////////////////////////////// << 
356 //                                             << 
357 // Set side planes, check planarity            << 
358                                                   621 
359 void G4Trap::MakePlanes(const G4ThreeVector pt << 622   // Bottom side with normal approx. -Y
360 {                                              << 623   //
361   constexpr G4int iface[4][4] = { {0,4,5,1}, { << 624   good=MakePlane(pt[0],pt[4],pt[5],pt[1],fPlanes[0]) ;
362   const static G4String side[4] = { "~-Y", "~+ << 625   if (!good)
                                                   >> 626   {
                                                   >> 627     G4cerr << "ERROR - G4Trap()::MakePlanes(): " << GetName() << G4endl;
                                                   >> 628     G4Exception("G4Trap::MakePlanes()", "InvalidSetup", FatalException,
                                                   >> 629                 "Face at ~-Y not planar.");
                                                   >> 630   }
363                                                   631 
364   for (G4int i=0; i<4; ++i)                    << 632   // Top side with normal approx. +Y
                                                   >> 633   //
                                                   >> 634   good=MakePlane(pt[2],pt[3],pt[7],pt[6],fPlanes[1]);
                                                   >> 635   if (!good)
365   {                                               636   {
366     if (MakePlane(pt[iface[i][0]],             << 637     G4cerr << "ERROR - G4Trap()::MakePlanes(): " << GetName() << G4endl;
367                   pt[iface[i][1]],             << 638     G4Exception("G4Trap::MakePlanes()", "InvalidSetup", FatalException,
368                   pt[iface[i][2]],             << 639                 "Face at ~+Y not planar.");
369                   pt[iface[i][3]],             << 640   }
370                   fPlanes[i])) continue;       << 
371                                                   641 
372     // Non planar side face                    << 642   // Front side with normal approx. -X
373     G4ThreeVector normal(fPlanes[i].a,fPlanes[ << 643   //
374     G4double dmax = 0;                         << 644   good=MakePlane(pt[0],pt[2],pt[6],pt[4],fPlanes[2]);
375     for (G4int k=0; k<4; ++k)                  << 645   if (!good)
376     {                                          << 646   {
377       G4double dist = normal.dot(pt[iface[i][k << 647     G4cerr << "ERROR - G4Trap()::MakePlanes(): " << GetName() << G4endl;
378       if (std::abs(dist) > std::abs(dmax)) dma << 648     G4Exception("G4Trap::MakePlanes()", "InvalidSetup", FatalException,
379     }                                          << 649                 "Face at ~-X not planar.");
380     std::ostringstream message;                << 650   }
381     message << "Side face " << side[i] << " is << 651    
382             << GetName() << "\nDiscrepancy: "  << 652   // Back side iwth normal approx. +X
383     StreamInfo(message);                       << 653   //
384     G4Exception("G4Trap::MakePlanes()", "GeomS << 654   good = MakePlane(pt[1],pt[5],pt[7],pt[3],fPlanes[3]);
385                 FatalException, message);      << 655   if ( !good )
                                                   >> 656   {
                                                   >> 657     G4cerr << "ERROR - G4Trap()::MakePlanes(): " << GetName() << G4endl;
                                                   >> 658     G4Exception("G4Trap::MakePlanes()", "InvalidSetup", FatalException,
                                                   >> 659                 "Face at ~+X not planar");
386   }                                               660   }
387                                                   661 
388   // Re-compute parameters                     << 662   return good;
389   SetCachedValues();                           << 
390 }                                                 663 }
391                                                   664 
392 ////////////////////////////////////////////// << 665 //////////////////////////////////////////////////////////////////////////////
393 //                                                666 //
394 // Calculate the coef's of the plane p1->p2->p    667 // Calculate the coef's of the plane p1->p2->p3->p4->p1
395 // where the ThreeVectors 1-4 are in anti-cloc << 668 // where the ThreeVectors 1-4 are in anti-clockwise order when viewed from
396 // from infront of the plane (i.e. from normal << 669 // infront of the plane (i.e. from normal direction).
397 //                                                670 //
398 // Return true if the points are coplanar, fal << 671 // Return true if the ThreeVectors are coplanar + set coef;s
                                                   >> 672 //        false if ThreeVectors are not coplanar
399                                                   673 
400 G4bool G4Trap::MakePlane( const G4ThreeVector&    674 G4bool G4Trap::MakePlane( const G4ThreeVector& p1,
401                           const G4ThreeVector&    675                           const G4ThreeVector& p2,
402                           const G4ThreeVector&    676                           const G4ThreeVector& p3,
403                           const G4ThreeVector&    677                           const G4ThreeVector& p4,
404                                 TrapSidePlane&    678                                 TrapSidePlane& plane )
405 {                                                 679 {
406   G4ThreeVector normal = ((p4 - p2).cross(p3 - << 680   G4double a, b, c, s;
407   if (std::abs(normal.x()) < DBL_EPSILON) norm << 681   G4ThreeVector v12, v13, v14, Vcross;
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                                                   682 
425   return dmax <= 1000 * kCarTolerance;         << 683   G4bool good;
426 }                                              << 
427                                                   684 
428 ////////////////////////////////////////////// << 685   v12    = p2 - p1;
429 //                                             << 686   v13    = p3 - p1;
430 // Recompute parameters using planes           << 687   v14    = p4 - p1;
                                                   >> 688   Vcross = v12.cross(v13);
431                                                   689 
432 void G4Trap::SetCachedValues()                 << 690   if (std::fabs(Vcross.dot(v14)/(Vcross.mag()*v14.mag())) > kCoplanar_Tolerance)
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 //                                             << 
484 // Get volume                                  << 
485                                                << 
486 G4double G4Trap::GetCubicVolume()              << 
487 {                                              << 
488   if (fCubicVolume == 0)                       << 
489   {                                               691   {
490     G4ThreeVector pt[8];                       << 692     good = false;
491     GetVertices(pt);                           << 
492                                                << 
493     G4double dz  = pt[4].z() - pt[0].z();      << 
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                                                << 
501     fCubicVolume = ((dx1 + dx2 + dx3 + dx4)*(d << 
502                     (dx4 + dx3 - dx2 - dx1)*(d << 
503   }                                               693   }
504   return fCubicVolume;                         << 694   else
505 }                                              << 
506                                                << 
507 ////////////////////////////////////////////// << 
508 //                                             << 
509 // Get surface area                            << 
510                                                << 
511 G4double G4Trap::GetSurfaceArea()              << 
512 {                                              << 
513   if (fSurfaceArea == 0)                       << 
514   {                                               695   {
515     G4ThreeVector pt[8];                       << 696     // a,b,c correspond to the x/y/z components of the
516     G4int iface [6][4] =                       << 697     // normal vector to the plane
517       { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2, << 698      
518                                                << 699     //  a  = (p2.y()-p1.y())*(p1.z()+p2.z())+(p3.y()-p2.y())*(p2.z()+p3.z());
519     GetVertices(pt);                           << 700     //  a += (p4.y()-p3.y())*(p3.z()+p4.z())+(p1.y()-p4.y())*(p4.z()+p1.z()); // ?   
520     for (const auto & i : iface)               << 701     // b  = (p2.z()-p1.z())*(p1.x()+p2.x())+(p3.z()-p2.z())*(p2.x()+p3.x());
                                                   >> 702     // b += (p4.z()-p3.z())*(p3.x()+p4.x())+(p1.z()-p4.z())*(p4.x()+p1.x()); // ?      
                                                   >> 703     // c  = (p2.x()-p1.x())*(p1.y()+p2.y())+(p3.x()-p2.x())*(p2.y()+p3.y());
                                                   >> 704     // c += (p4.x()-p3.x())*(p3.y()+p4.y())+(p1.x()-p4.x())*(p4.y()+p1.y()); // ?
                                                   >> 705 
                                                   >> 706     // Let create diagonals 4-2 and 3-1 than (4-2)x(3-1) provides
                                                   >> 707     // vector perpendicular to the plane directed to outside !!!
                                                   >> 708     // and a,b,c, = f(1,2,3,4) external relative to trap normal
                                                   >> 709 
                                                   >> 710     a = +(p4.y() - p2.y())*(p3.z() - p1.z())
                                                   >> 711         - (p3.y() - p1.y())*(p4.z() - p2.z());
                                                   >> 712 
                                                   >> 713     b = -(p4.x() - p2.x())*(p3.z() - p1.z())
                                                   >> 714         + (p3.x() - p1.x())*(p4.z() - p2.z());
                                                   >> 715  
                                                   >> 716     c = +(p4.x() - p2.x())*(p3.y() - p1.y())
                                                   >> 717         - (p3.x() - p1.x())*(p4.y() - p2.y());
                                                   >> 718 
                                                   >> 719     s = std::sqrt( a*a + b*b + c*c ); // so now vector plane.(a,b,c) is unit 
                                                   >> 720 
                                                   >> 721     if( s > 0 )
                                                   >> 722     {
                                                   >> 723       plane.a = a/s;
                                                   >> 724       plane.b = b/s;
                                                   >> 725       plane.c = c/s;
                                                   >> 726     }
                                                   >> 727     else
521     {                                             728     {
522       fSurfaceArea += G4GeomTools::QuadAreaNor << 729       G4cerr << "ERROR - G4Trap()::MakePlane(): " << GetName() << G4endl;
523                                                << 730       G4Exception("G4Trap::MakePlanes()", "InvalidSetup", FatalException,
524                                                << 731                   "Invalid parameters: norm.mod() <= 0") ;
525                                                << 
526     }                                             732     }
                                                   >> 733     // Calculate D: p1 in in plane so D=-n.p1.Vect()
                                                   >> 734     
                                                   >> 735     plane.d = -( plane.a*p1.x() + plane.b*p1.y() + plane.c*p1.z() );
                                                   >> 736 
                                                   >> 737     good = true;
527   }                                               738   }
528   return fSurfaceArea;                         << 739   return good;
529 }                                                 740 }
530                                                   741 
531 ////////////////////////////////////////////// << 742 //////////////////////////////////////////////////////////////////////////////
532 //                                                743 //
533 // Dispatch to parameterisation for replicatio    744 // Dispatch to parameterisation for replication mechanism dimension
534 // computation & modification.                    745 // computation & modification.
535                                                   746 
536 void G4Trap::ComputeDimensions(       G4VPVPar    747 void G4Trap::ComputeDimensions(       G4VPVParameterisation* p,
537                                 const G4int n,    748                                 const G4int n,
538                                 const G4VPhysi    749                                 const G4VPhysicalVolume* pRep )
539 {                                                 750 {
540   p->ComputeDimensions(*this,n,pRep);             751   p->ComputeDimensions(*this,n,pRep);
541 }                                                 752 }
542                                                   753 
543 ////////////////////////////////////////////// << 
544 //                                             << 
545 // Get bounding box                            << 
546                                                << 
547 void G4Trap::BoundingLimits(G4ThreeVector& pMi << 
548 {                                              << 
549   G4ThreeVector pt[8];                         << 
550   GetVertices(pt);                             << 
551                                                   754 
552   G4double xmin = kInfinity, xmax = -kInfinity << 755 ////////////////////////////////////////////////////////////////////////
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 //                                                756 //
585 // Calculate extent under transform and specif    757 // Calculate extent under transform and specified limit
586                                                   758 
587 G4bool G4Trap::CalculateExtent( const EAxis pA    759 G4bool G4Trap::CalculateExtent( const EAxis pAxis,
588                                 const G4VoxelL    760                                 const G4VoxelLimits& pVoxelLimit,
589                                 const G4Affine    761                                 const G4AffineTransform& pTransform,
590                                       G4double    762                                       G4double& pMin, G4double& pMax) const
591 {                                                 763 {
592   G4ThreeVector bmin, bmax;                    << 764   G4double xMin, xMax, yMin, yMax, zMin, zMax;
593   G4bool exist;                                << 765   G4bool flag;
594                                                   766 
595   // Check bounding box (bbox)                 << 767   if (!pTransform.IsRotated())
596   //                                           << 768   {  
597   BoundingLimits(bmin,bmax);                   << 769     // Special case handling for unrotated trapezoids
598   G4BoundingEnvelope bbox(bmin,bmax);          << 770     // Compute z/x/y/ mins and maxs respecting limits, with early returns
599 #ifdef G4BBOX_EXTENT                           << 771     // if outside limits. Then switch() on pAxis
600   return bbox.CalculateExtent(pAxis,pVoxelLimi << 772 
601 #endif                                         << 773     G4int i ; 
602   if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVox << 774     G4double xoffset;
603   {                                            << 775     G4double yoffset;
604     return exist = pMin < pMax;                << 776     G4double zoffset;
                                                   >> 777     G4double temp[8] ;     // some points for intersection with zMin/zMax
                                                   >> 778     G4ThreeVector pt[8];   // vertices after translation
                                                   >> 779     
                                                   >> 780     xoffset=pTransform.NetTranslation().x();      
                                                   >> 781     yoffset=pTransform.NetTranslation().y();
                                                   >> 782     zoffset=pTransform.NetTranslation().z();
                                                   >> 783  
                                                   >> 784     pt[0]=G4ThreeVector(xoffset-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,
                                                   >> 785                         yoffset-fDz*fTthetaSphi-fDy1,zoffset-fDz);
                                                   >> 786     pt[1]=G4ThreeVector(xoffset-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,
                                                   >> 787                         yoffset-fDz*fTthetaSphi-fDy1,zoffset-fDz);
                                                   >> 788     pt[2]=G4ThreeVector(xoffset-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,
                                                   >> 789                         yoffset-fDz*fTthetaSphi+fDy1,zoffset-fDz);
                                                   >> 790     pt[3]=G4ThreeVector(xoffset-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,
                                                   >> 791                         yoffset-fDz*fTthetaSphi+fDy1,zoffset-fDz);
                                                   >> 792     pt[4]=G4ThreeVector(xoffset+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,
                                                   >> 793                         yoffset+fDz*fTthetaSphi-fDy2,zoffset+fDz);
                                                   >> 794     pt[5]=G4ThreeVector(xoffset+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,
                                                   >> 795                         yoffset+fDz*fTthetaSphi-fDy2,zoffset+fDz);
                                                   >> 796     pt[6]=G4ThreeVector(xoffset+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,
                                                   >> 797                         yoffset+fDz*fTthetaSphi+fDy2,zoffset+fDz);
                                                   >> 798     pt[7]=G4ThreeVector(xoffset+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,
                                                   >> 799                         yoffset+fDz*fTthetaSphi+fDy2,zoffset+fDz);
                                                   >> 800     zMin=zoffset-fDz;
                                                   >> 801     zMax=zoffset+fDz;
                                                   >> 802 
                                                   >> 803     if ( pVoxelLimit.IsZLimited() )
                                                   >> 804     {
                                                   >> 805       if ( (zMin > pVoxelLimit.GetMaxZExtent() + kCarTolerance)
                                                   >> 806         || (zMax < pVoxelLimit.GetMinZExtent() - kCarTolerance) )
                                                   >> 807       {
                                                   >> 808         return false;
                                                   >> 809       }
                                                   >> 810       else
                                                   >> 811       {
                                                   >> 812         if ( zMin < pVoxelLimit.GetMinZExtent() )
                                                   >> 813         {
                                                   >> 814           zMin = pVoxelLimit.GetMinZExtent() ;
                                                   >> 815         }
                                                   >> 816         if ( zMax > pVoxelLimit.GetMaxZExtent() )
                                                   >> 817         {
                                                   >> 818           zMax = pVoxelLimit.GetMaxZExtent() ;
                                                   >> 819         }
                                                   >> 820       }
                                                   >> 821     }
                                                   >> 822     temp[0] = pt[0].y()+(pt[4].y()-pt[0].y())*(zMin-pt[0].z())
                                                   >> 823                        /(pt[4].z()-pt[0].z()) ;
                                                   >> 824     temp[1] = pt[0].y()+(pt[4].y()-pt[0].y())*(zMax-pt[0].z())
                                                   >> 825                        /(pt[4].z()-pt[0].z()) ;
                                                   >> 826     temp[2] = pt[2].y()+(pt[6].y()-pt[2].y())*(zMin-pt[2].z())
                                                   >> 827                        /(pt[6].z()-pt[2].z()) ;
                                                   >> 828     temp[3] = pt[2].y()+(pt[6].y()-pt[2].y())*(zMax-pt[2].z())
                                                   >> 829                        /(pt[6].z()-pt[2].z()) ;
                                                   >> 830 
                                                   >> 831     yMax = yoffset - std::fabs(fDz*fTthetaSphi) - fDy1 - fDy2 ;
                                                   >> 832     yMin = -yMax ;
                                                   >> 833 
                                                   >> 834     for( i = 0 ; i < 4 ; i++ )
                                                   >> 835     {
                                                   >> 836       if( temp[i] > yMax ) yMax = temp[i] ;
                                                   >> 837       if( temp[i] < yMin ) yMin = temp[i] ;
                                                   >> 838     }    
                                                   >> 839     if ( pVoxelLimit.IsYLimited() )
                                                   >> 840     {
                                                   >> 841       if ( (yMin > pVoxelLimit.GetMaxYExtent() + kCarTolerance)
                                                   >> 842         || (yMax < pVoxelLimit.GetMinYExtent() - kCarTolerance) )
                                                   >> 843       {
                                                   >> 844         return false;
                                                   >> 845       }
                                                   >> 846       else
                                                   >> 847       {
                                                   >> 848         if ( yMin < pVoxelLimit.GetMinYExtent() )
                                                   >> 849         {
                                                   >> 850           yMin = pVoxelLimit.GetMinYExtent() ;
                                                   >> 851         }
                                                   >> 852         if ( yMax > pVoxelLimit.GetMaxYExtent() )
                                                   >> 853         {
                                                   >> 854           yMax = pVoxelLimit.GetMaxYExtent() ;
                                                   >> 855         }
                                                   >> 856       }
                                                   >> 857     }
                                                   >> 858     temp[0] = pt[0].x()+(pt[4].x()-pt[0].x())
                                                   >> 859                        *(zMin-pt[0].z())/(pt[4].z()-pt[0].z()) ;
                                                   >> 860     temp[1] = pt[0].x()+(pt[4].x()-pt[0].x())
                                                   >> 861                        *(zMax-pt[0].z())/(pt[4].z()-pt[0].z()) ;
                                                   >> 862     temp[2] = pt[2].x()+(pt[6].x()-pt[2].x())
                                                   >> 863                        *(zMin-pt[2].z())/(pt[6].z()-pt[2].z()) ;
                                                   >> 864     temp[3] = pt[2].x()+(pt[6].x()-pt[2].x())
                                                   >> 865                        *(zMax-pt[2].z())/(pt[6].z()-pt[2].z()) ;
                                                   >> 866     temp[4] = pt[3].x()+(pt[7].x()-pt[3].x())
                                                   >> 867                        *(zMin-pt[3].z())/(pt[7].z()-pt[3].z()) ;
                                                   >> 868     temp[5] = pt[3].x()+(pt[7].x()-pt[3].x())
                                                   >> 869                        *(zMax-pt[3].z())/(pt[7].z()-pt[3].z()) ;
                                                   >> 870     temp[6] = pt[1].x()+(pt[5].x()-pt[1].x())
                                                   >> 871                        *(zMin-pt[1].z())/(pt[5].z()-pt[1].z()) ;
                                                   >> 872     temp[7] = pt[1].x()+(pt[5].x()-pt[1].x())
                                                   >> 873                        *(zMax-pt[1].z())/(pt[5].z()-pt[1].z()) ;
                                                   >> 874       
                                                   >> 875     xMax = xoffset - std::fabs(fDz*fTthetaCphi) - fDx1 - fDx2 -fDx3 - fDx4 ;
                                                   >> 876     xMin = -xMax ;
                                                   >> 877 
                                                   >> 878     for( i = 0 ; i < 8 ; i++ )
                                                   >> 879     {
                                                   >> 880       if( temp[i] > xMax) xMax = temp[i] ;
                                                   >> 881       if( temp[i] < xMin) xMin = temp[i] ;
                                                   >> 882     }                                            
                                                   >> 883     if (pVoxelLimit.IsXLimited())   // xMax/Min = f(yMax/Min) ?
                                                   >> 884     {
                                                   >> 885       if ( (xMin > pVoxelLimit.GetMaxXExtent() + kCarTolerance)
                                                   >> 886         || (xMax < pVoxelLimit.GetMinXExtent() - kCarTolerance) )
                                                   >> 887       {
                                                   >> 888         return false;
                                                   >> 889       }
                                                   >> 890       else
                                                   >> 891       {
                                                   >> 892         if ( xMin < pVoxelLimit.GetMinXExtent() )
                                                   >> 893         {
                                                   >> 894           xMin = pVoxelLimit.GetMinXExtent() ;
                                                   >> 895         }
                                                   >> 896         if ( xMax > pVoxelLimit.GetMaxXExtent() )
                                                   >> 897         {
                                                   >> 898           xMax = pVoxelLimit.GetMaxXExtent() ;
                                                   >> 899         }
                                                   >> 900       }
                                                   >> 901     }
                                                   >> 902     switch (pAxis)
                                                   >> 903     {
                                                   >> 904       case kXAxis:
                                                   >> 905         pMin=xMin;
                                                   >> 906         pMax=xMax;
                                                   >> 907         break;
                                                   >> 908 
                                                   >> 909       case kYAxis:
                                                   >> 910         pMin=yMin;
                                                   >> 911         pMax=yMax;
                                                   >> 912         break;
                                                   >> 913 
                                                   >> 914       case kZAxis:
                                                   >> 915         pMin=zMin;
                                                   >> 916         pMax=zMax;
                                                   >> 917         break;
                                                   >> 918 
                                                   >> 919       default:
                                                   >> 920         break;
                                                   >> 921     }
                                                   >> 922     pMin -= kCarTolerance;
                                                   >> 923     pMax += kCarTolerance;
                                                   >> 924 
                                                   >> 925     flag = true;
605   }                                               926   }
                                                   >> 927   else    // General rotated case -
                                                   >> 928   {
                                                   >> 929     G4bool existsAfterClip = false ;
                                                   >> 930     G4ThreeVectorList*       vertices;
                                                   >> 931     pMin                   = +kInfinity;
                                                   >> 932     pMax                   = -kInfinity;
                                                   >> 933       
                                                   >> 934     // Calculate rotated vertex coordinates. Operator 'new' is called
                                                   >> 935 
                                                   >> 936     vertices = CreateRotatedVertices(pTransform);
                                                   >> 937       
                                                   >> 938     xMin = +kInfinity; yMin = +kInfinity; zMin = +kInfinity;
                                                   >> 939     xMax = -kInfinity; yMax = -kInfinity; zMax = -kInfinity;
                                                   >> 940       
                                                   >> 941     for( G4int nv = 0 ; nv < 8 ; nv++ )
                                                   >> 942     { 
                                                   >> 943       if( (*vertices)[nv].x() > xMax ) xMax = (*vertices)[nv].x();
                                                   >> 944       if( (*vertices)[nv].y() > yMax ) yMax = (*vertices)[nv].y();
                                                   >> 945       if( (*vertices)[nv].z() > zMax ) zMax = (*vertices)[nv].z();
                                                   >> 946       
                                                   >> 947       if( (*vertices)[nv].x() < xMin ) xMin = (*vertices)[nv].x();
                                                   >> 948       if( (*vertices)[nv].y() < yMin ) yMin = (*vertices)[nv].y();
                                                   >> 949       if( (*vertices)[nv].z() < zMin ) zMin = (*vertices)[nv].z();
                                                   >> 950     }
                                                   >> 951     if ( pVoxelLimit.IsZLimited() )
                                                   >> 952     {
                                                   >> 953       if ( (zMin > pVoxelLimit.GetMaxZExtent() + kCarTolerance)
                                                   >> 954         || (zMax < pVoxelLimit.GetMinZExtent() - kCarTolerance) )
                                                   >> 955       {
                                                   >> 956         delete vertices ;    //  'new' in the function called
                                                   >> 957         return false;
                                                   >> 958       }
                                                   >> 959       else
                                                   >> 960       {
                                                   >> 961         if ( zMin < pVoxelLimit.GetMinZExtent() )
                                                   >> 962         {
                                                   >> 963           zMin = pVoxelLimit.GetMinZExtent() ;
                                                   >> 964         }
                                                   >> 965         if ( zMax > pVoxelLimit.GetMaxZExtent() )
                                                   >> 966         {
                                                   >> 967           zMax = pVoxelLimit.GetMaxZExtent() ;
                                                   >> 968         }
                                                   >> 969       }
                                                   >> 970     } 
                                                   >> 971     if ( pVoxelLimit.IsYLimited() )
                                                   >> 972     {
                                                   >> 973       if ( (yMin > pVoxelLimit.GetMaxYExtent() + kCarTolerance)
                                                   >> 974         || (yMax < pVoxelLimit.GetMinYExtent() - kCarTolerance) )
                                                   >> 975       {
                                                   >> 976         delete vertices ;    //  'new' in the function called
                                                   >> 977         return false;
                                                   >> 978       }
                                                   >> 979       else
                                                   >> 980       {
                                                   >> 981         if ( yMin < pVoxelLimit.GetMinYExtent() )
                                                   >> 982         {
                                                   >> 983           yMin = pVoxelLimit.GetMinYExtent() ;
                                                   >> 984         }
                                                   >> 985         if ( yMax > pVoxelLimit.GetMaxYExtent() )
                                                   >> 986         {
                                                   >> 987           yMax = pVoxelLimit.GetMaxYExtent() ;
                                                   >> 988         }
                                                   >> 989       }
                                                   >> 990     }
                                                   >> 991     if ( pVoxelLimit.IsXLimited() )
                                                   >> 992     {
                                                   >> 993       if ( (xMin > pVoxelLimit.GetMaxXExtent() + kCarTolerance)
                                                   >> 994         || (xMax < pVoxelLimit.GetMinXExtent() - kCarTolerance) )
                                                   >> 995       {
                                                   >> 996         delete vertices ;    //  'new' in the function called
                                                   >> 997         return false ;
                                                   >> 998       } 
                                                   >> 999       else
                                                   >> 1000       {
                                                   >> 1001         if ( xMin < pVoxelLimit.GetMinXExtent() )
                                                   >> 1002         {
                                                   >> 1003           xMin = pVoxelLimit.GetMinXExtent() ;
                                                   >> 1004         }
                                                   >> 1005         if ( xMax > pVoxelLimit.GetMaxXExtent() )
                                                   >> 1006         {
                                                   >> 1007           xMax = pVoxelLimit.GetMaxXExtent() ;
                                                   >> 1008         }
                                                   >> 1009       }
                                                   >> 1010     }
                                                   >> 1011     switch (pAxis)
                                                   >> 1012     {
                                                   >> 1013       case kXAxis:
                                                   >> 1014         pMin=xMin;
                                                   >> 1015         pMax=xMax;
                                                   >> 1016         break;
606                                                   1017 
607   // Set bounding envelope (benv) and calculat << 1018       case kYAxis:
608   //                                           << 1019         pMin=yMin;
609   G4ThreeVector pt[8];                         << 1020         pMax=yMax;
610   GetVertices(pt);                             << 1021         break;
611                                                   1022 
612   G4ThreeVectorList baseA(4), baseB(4);        << 1023       case kZAxis:
613   baseA[0] = pt[0];                            << 1024         pMin=zMin;
614   baseA[1] = pt[1];                            << 1025         pMax=zMax;
615   baseA[2] = pt[3];                            << 1026         break;
616   baseA[3] = pt[2];                            << 1027 
617                                                << 1028       default:
618   baseB[0] = pt[4];                            << 1029         break;
619   baseB[1] = pt[5];                            << 1030     }
620   baseB[2] = pt[7];                            << 1031     if ( (pMin != kInfinity) || (pMax != -kInfinity) )
621   baseB[3] = pt[6];                            << 1032     {
622                                                << 1033       existsAfterClip=true;
623   std::vector<const G4ThreeVectorList *> polyg << 1034         
624   polygons[0] = &baseA;                        << 1035       // Add tolerance to avoid precision troubles
625   polygons[1] = &baseB;                        << 1036       //
626                                                << 1037       pMin -= kCarTolerance ;
627   G4BoundingEnvelope benv(bmin,bmax,polygons); << 1038       pMax += kCarTolerance ;      
628   exist = benv.CalculateExtent(pAxis,pVoxelLim << 1039     }
629   return exist;                                << 1040     delete vertices ;          //  'new' in the function called
                                                   >> 1041     flag = existsAfterClip ;
                                                   >> 1042   }
                                                   >> 1043   return flag;
630 }                                                 1044 }
631                                                   1045 
632 ////////////////////////////////////////////// << 1046 
                                                   >> 1047 ////////////////////////////////////////////////////////////////////////
633 //                                                1048 //
634 // Return whether point is inside/outside/on_s << 1049 // Return whether point inside/outside/on surface, using tolerance
635                                                   1050 
636 EInside G4Trap::Inside( const G4ThreeVector& p    1051 EInside G4Trap::Inside( const G4ThreeVector& p ) const
637 {                                                 1052 {
638   switch (fTrapType)                           << 1053   EInside in;
                                                   >> 1054   G4double Dist;
                                                   >> 1055   G4int i;
                                                   >> 1056   if ( std::fabs(p.z()) <= fDz-kCarTolerance*0.5)
639   {                                               1057   {
640     case 0: // General case                    << 1058     in = kInside;
                                                   >> 1059 
                                                   >> 1060     for ( i = 0;i < 4;i++ )
                                                   >> 1061     {
                                                   >> 1062       Dist = fPlanes[i].a*p.x() + fPlanes[i].b*p.y()
                                                   >> 1063             +fPlanes[i].c*p.z() + fPlanes[i].d;
                                                   >> 1064 
                                                   >> 1065       if      (Dist >  kCarTolerance*0.5)  return in = kOutside;
                                                   >> 1066       else if (Dist > -kCarTolerance*0.5)         in = kSurface;
                                                   >> 1067        
                                                   >> 1068     }
                                                   >> 1069   }
                                                   >> 1070   else if (std::fabs(p.z()) <= fDz+kCarTolerance*0.5)
                                                   >> 1071   {
                                                   >> 1072     in = kSurface;
                                                   >> 1073 
                                                   >> 1074     for ( i = 0; i < 4; i++ )
641     {                                             1075     {
642       G4double dz = std::abs(p.z())-fDz;       << 1076       Dist =  fPlanes[i].a*p.x() + fPlanes[i].b*p.y()
643       G4double dy1 = fPlanes[0].b*p.y()+fPlane << 1077              +fPlanes[i].c*p.z() + fPlanes[i].d;
644       G4double dy2 = fPlanes[1].b*p.y()+fPlane << 
645       G4double dy = std::max(dz,std::max(dy1,d << 
646                                                << 
647       G4double dx1 = fPlanes[2].a*p.x()+fPlane << 
648                    + fPlanes[2].c*p.z()+fPlane << 
649       G4double dx2 = fPlanes[3].a*p.x()+fPlane << 
650                    + fPlanes[3].c*p.z()+fPlane << 
651       G4double dist = std::max(dy,std::max(dx1 << 
652                                                << 
653       return (dist > halfCarTolerance) ? kOuts << 
654         ((dist > -halfCarTolerance) ? kSurface << 
655     }                                          << 
656     case 1: // YZ section is a rectangle       << 
657     {                                          << 
658       G4double dz = std::abs(p.z())-fDz;       << 
659       G4double dy = std::max(dz,std::abs(p.y() << 
660       G4double dx1 = fPlanes[2].a*p.x()+fPlane << 
661                    + fPlanes[2].c*p.z()+fPlane << 
662       G4double dx2 = fPlanes[3].a*p.x()+fPlane << 
663                    + fPlanes[3].c*p.z()+fPlane << 
664       G4double dist = std::max(dy,std::max(dx1 << 
665                                                << 
666       return (dist > halfCarTolerance) ? kOuts << 
667         ((dist > -halfCarTolerance) ? kSurface << 
668     }                                          << 
669     case 2: // YZ section is a rectangle and   << 
670     {       // XZ section is an isosceles trap << 
671       G4double dz = std::abs(p.z())-fDz;       << 
672       G4double dy = std::max(dz,std::abs(p.y() << 
673       G4double dx = fPlanes[3].a*std::abs(p.x( << 
674                   + fPlanes[3].c*p.z()+fPlanes << 
675       G4double dist = std::max(dy,dx);         << 
676                                                << 
677       return (dist > halfCarTolerance) ? kOuts << 
678         ((dist > -halfCarTolerance) ? kSurface << 
679     }                                          << 
680     case 3: // YZ section is a rectangle and   << 
681     {       // XY section is an isosceles trap << 
682       G4double dz = std::abs(p.z())-fDz;       << 
683       G4double dy = std::max(dz,std::abs(p.y() << 
684       G4double dx = fPlanes[3].a*std::abs(p.x( << 
685                   + fPlanes[3].b*p.y()+fPlanes << 
686       G4double dist = std::max(dy,dx);         << 
687                                                   1078 
688       return (dist > halfCarTolerance) ? kOuts << 1079       if (Dist > kCarTolerance*0.5)        return in = kOutside;      
689         ((dist > -halfCarTolerance) ? kSurface << 
690     }                                             1080     }
691   }                                               1081   }
692   return kOutside;                             << 1082   else  in = kOutside;
                                                   >> 1083   
                                                   >> 1084   return in;
693 }                                                 1085 }
694                                                   1086 
695 ////////////////////////////////////////////// << 1087 /////////////////////////////////////////////////////////////////////////////
696 //                                                1088 //
697 // Determine side, and return corresponding no << 1089 // Calculate side nearest to p, and return normal
                                                   >> 1090 // If 2+ sides equidistant, first side's normal returned (arbitrarily)
698                                                   1091 
699 G4ThreeVector G4Trap::SurfaceNormal( const G4T    1092 G4ThreeVector G4Trap::SurfaceNormal( const G4ThreeVector& p ) const
700 {                                                 1093 {
701   G4double nx = 0, ny = 0, nz = 0;             << 1094   G4int i, imin = 0, noSurfaces = 0;
702   G4double dz = std::abs(p.z()) - fDz;         << 1095   G4double dist, distz, distx, disty, distmx, distmy, safe = kInfinity;
703   nz = std::copysign(G4double(std::abs(dz) <=  << 1096   G4double delta    = 0.5*kCarTolerance;
                                                   >> 1097   G4ThreeVector norm, sumnorm(0.,0.,0.);
704                                                   1098 
705   switch (fTrapType)                           << 1099   for (i = 0; i < 4; i++)
706   {                                               1100   {
707     case 0: // General case                    << 1101     dist =  std::fabs(fPlanes[i].a*p.x() + fPlanes[i].b*p.y()
708     {                                          << 1102           + fPlanes[i].c*p.z() + fPlanes[i].d);
709       for (G4int i=0; i<2; ++i)                << 1103     if ( dist < safe )
710       {                                        << 
711         G4double dy = fPlanes[i].b*p.y() + fPl << 
712         if (std::abs(dy) > halfCarTolerance) c << 
713         ny  = fPlanes[i].b;                    << 
714         nz += fPlanes[i].c;                    << 
715         break;                                 << 
716       }                                        << 
717       for (G4int i=2; i<4; ++i)                << 
718       {                                        << 
719         G4double dx = fPlanes[i].a*p.x() +     << 
720                       fPlanes[i].b*p.y() + fPl << 
721         if (std::abs(dx) > halfCarTolerance) c << 
722         nx  = fPlanes[i].a;                    << 
723         ny += fPlanes[i].b;                    << 
724         nz += fPlanes[i].c;                    << 
725         break;                                 << 
726       }                                        << 
727       break;                                   << 
728     }                                          << 
729     case 1: // YZ section - rectangle          << 
730     {                                             1104     {
731       G4double dy = std::abs(p.y()) + fPlanes[ << 1105       safe = dist;
732       ny = std::copysign(G4double(std::abs(dy) << 1106       imin = i;
733       for (G4int i=2; i<4; ++i)                << 
734       {                                        << 
735         G4double dx = fPlanes[i].a*p.x() +     << 
736                       fPlanes[i].b*p.y() + fPl << 
737         if (std::abs(dx) > halfCarTolerance) c << 
738         nx  = fPlanes[i].a;                    << 
739         ny += fPlanes[i].b;                    << 
740         nz += fPlanes[i].c;                    << 
741         break;                                 << 
742       }                                        << 
743       break;                                   << 
744     }                                          << 
745     case 2: // YZ section - rectangle, XZ sect << 
746     {                                          << 
747       G4double dy = std::abs(p.y()) + fPlanes[ << 
748       ny = std::copysign(G4double(std::abs(dy) << 
749       G4double dx = fPlanes[3].a*std::abs(p.x( << 
750                     fPlanes[3].c*p.z() + fPlan << 
751       G4double k = std::abs(dx) <= halfCarTole << 
752       nx  = std::copysign(k, p.x())*fPlanes[3] << 
753       nz += k*fPlanes[3].c;                    << 
754       break;                                   << 
755     }                                          << 
756     case 3: // YZ section - rectangle, XY sect << 
757     {                                          << 
758       G4double dy = std::abs(p.y()) + fPlanes[ << 
759       ny = std::copysign(G4double(std::abs(dy) << 
760       G4double dx = fPlanes[3].a*std::abs(p.x( << 
761                     fPlanes[3].b*p.y() + fPlan << 
762       G4double k = std::abs(dx) <= halfCarTole << 
763       nx  = std::copysign(k, p.x())*fPlanes[3] << 
764       ny += k*fPlanes[3].b;                    << 
765       break;                                   << 
766     }                                             1107     }
767   }                                               1108   }
                                                   >> 1109   distz  = std::fabs( std::fabs( p.z() ) - fDz );
768                                                   1110 
769   // Return normal                             << 1111   distmy = std::fabs( fPlanes[0].a*p.x() + fPlanes[0].b*p.y()
770   //                                           << 1112                     + fPlanes[0].c*p.z() + fPlanes[0].d      );
771   G4double mag2 = nx*nx + ny*ny + nz*nz;       << 1113 
772   if (mag2 == 1)      return { nx,ny,nz };     << 1114   disty  = std::fabs( fPlanes[1].a*p.x() + fPlanes[1].b*p.y()
773   else if (mag2 != 0) return G4ThreeVector(nx, << 1115                     + fPlanes[1].c*p.z() + fPlanes[1].d      );
774   else                                         << 1116 
                                                   >> 1117   distmx = std::fabs( fPlanes[2].a*p.x() + fPlanes[2].b*p.y()
                                                   >> 1118                     + fPlanes[2].c*p.z() + fPlanes[2].d      );
                                                   >> 1119 
                                                   >> 1120   distx  = std::fabs( fPlanes[3].a*p.x() + fPlanes[3].b*p.y()
                                                   >> 1121                     + fPlanes[3].c*p.z() + fPlanes[3].d      );
                                                   >> 1122 
                                                   >> 1123   G4ThreeVector nX  = G4ThreeVector(fPlanes[3].a,fPlanes[3].b,fPlanes[3].c);
                                                   >> 1124   G4ThreeVector nmX = G4ThreeVector(fPlanes[2].a,fPlanes[2].b,fPlanes[2].c);
                                                   >> 1125   G4ThreeVector nY  = G4ThreeVector(fPlanes[1].a,fPlanes[1].b,fPlanes[1].c);
                                                   >> 1126   G4ThreeVector nmY = G4ThreeVector(fPlanes[0].a,fPlanes[0].b,fPlanes[0].c);
                                                   >> 1127   G4ThreeVector nZ  = G4ThreeVector(0.,0.,1.0);
                                                   >> 1128 
                                                   >> 1129   if (distx <= delta)      
                                                   >> 1130   {
                                                   >> 1131     noSurfaces ++;
                                                   >> 1132     sumnorm += nX;     
                                                   >> 1133   }
                                                   >> 1134   if (distmx <= delta)      
                                                   >> 1135   {
                                                   >> 1136     noSurfaces ++;
                                                   >> 1137     sumnorm += nmX;      
                                                   >> 1138   }
                                                   >> 1139   if (disty <= delta)
                                                   >> 1140   {
                                                   >> 1141     noSurfaces ++;
                                                   >> 1142     sumnorm += nY;  
                                                   >> 1143   }
                                                   >> 1144   if (distmy <= delta)
                                                   >> 1145   {
                                                   >> 1146     noSurfaces ++;
                                                   >> 1147     sumnorm += nmY;  
                                                   >> 1148   }
                                                   >> 1149   if (distz <= delta)  
                                                   >> 1150   {
                                                   >> 1151     noSurfaces ++;
                                                   >> 1152     if ( p.z() >= 0.)  sumnorm += nZ;
                                                   >> 1153     else               sumnorm -= nZ; 
                                                   >> 1154   }
                                                   >> 1155   if ( noSurfaces == 0 )
775   {                                               1156   {
776     // Point is not on the surface             << 
777     //                                         << 
778 #ifdef G4CSGDEBUG                                 1157 #ifdef G4CSGDEBUG
779     std::ostringstream message;                << 1158     G4Exception("G4Trap::SurfaceNormal(p)", "Notification", JustWarning, 
780     G4long oldprc = message.precision(16);     << 1159                 "Point p is not on surface !?" );
781     message << "Point p is not on surface (!?) << 1160 #endif 
782             << GetName() << G4endl;            << 1161      norm = ApproxSurfaceNormal(p);
783     message << "Position:\n";                  << 
784     message << "   p.x() = " << p.x()/mm << "  << 
785     message << "   p.y() = " << p.y()/mm << "  << 
786     message << "   p.z() = " << p.z()/mm << "  << 
787     G4cout.precision(oldprc) ;                 << 
788     G4Exception("G4Trap::SurfaceNormal(p)", "G << 
789                 JustWarning, message );        << 
790     DumpInfo();                                << 
791 #endif                                         << 
792     return ApproxSurfaceNormal(p);             << 
793   }                                               1162   }
                                                   >> 1163   else if ( noSurfaces == 1 ) norm = sumnorm;
                                                   >> 1164   else                        norm = sumnorm.unit();
                                                   >> 1165   return norm;
794 }                                                 1166 }
795                                                   1167 
796 ////////////////////////////////////////////// << 1168 ////////////////////////////////////////////////////////////////////////////////////
797 //                                                1169 //
798 // Algorithm for SurfaceNormal() following the    1170 // Algorithm for SurfaceNormal() following the original specification
799 // for points not on the surface                  1171 // for points not on the surface
800                                                   1172 
801 G4ThreeVector G4Trap::ApproxSurfaceNormal( con    1173 G4ThreeVector G4Trap::ApproxSurfaceNormal( const G4ThreeVector& p ) const
802 {                                                 1174 {
803   G4double dist = -DBL_MAX;                    << 1175   G4double safe=kInfinity,Dist,safez;
804   G4int iside = 0;                             << 1176   G4int i,imin=0;
805   for (G4int i=0; i<4; ++i)                    << 1177   for (i=0;i<4;i++)
806   {                                            << 1178   {
807     G4double d = fPlanes[i].a*p.x() +          << 1179     Dist=std::fabs(fPlanes[i].a*p.x()+fPlanes[i].b*p.y()
808                  fPlanes[i].b*p.y() +          << 1180         +fPlanes[i].c*p.z()+fPlanes[i].d);
809                  fPlanes[i].c*p.z() + fPlanes[ << 1181     if (Dist<safe)
810     if (d > dist) { dist = d; iside = i; }     << 1182     {
                                                   >> 1183       safe=Dist;
                                                   >> 1184       imin=i;
                                                   >> 1185     }
                                                   >> 1186   }
                                                   >> 1187   safez=std::fabs(std::fabs(p.z())-fDz);
                                                   >> 1188   if (safe<safez)
                                                   >> 1189   {
                                                   >> 1190     return G4ThreeVector(fPlanes[imin].a,fPlanes[imin].b,fPlanes[imin].c);
811   }                                               1191   }
812                                                << 
813   G4double distz = std::abs(p.z()) - fDz;      << 
814   if (dist > distz)                            << 
815     return { fPlanes[iside].a, fPlanes[iside]. << 
816   else                                            1192   else
817     return { 0, 0, (G4double)((p.z() < 0) ? -1 << 1193   {
                                                   >> 1194     if (p.z()>0)
                                                   >> 1195     {
                                                   >> 1196       return G4ThreeVector(0,0,1);
                                                   >> 1197     }
                                                   >> 1198     else
                                                   >> 1199     {
                                                   >> 1200       return G4ThreeVector(0,0,-1);
                                                   >> 1201     }
                                                   >> 1202   }
818 }                                                 1203 }
819                                                   1204 
820 ////////////////////////////////////////////// << 1205 ////////////////////////////////////////////////////////////////////////////
                                                   >> 1206 //
                                                   >> 1207 // Calculate distance to shape from outside - return kInfinity if no intersection
821 //                                                1208 //
822 // Calculate distance to shape from outside    << 1209 // ALGORITHM:
823 //  - return kInfinity if no intersection      << 1210 // For each component, calculate pair of minimum and maximum intersection
                                                   >> 1211 // values for which the particle is in the extent of the shape
                                                   >> 1212 // - The smallest (MAX minimum) allowed distance of the pairs is intersect
824                                                   1213 
825 G4double G4Trap::DistanceToIn(const G4ThreeVec << 1214 G4double G4Trap::DistanceToIn( const G4ThreeVector& p,
826                               const G4ThreeVec << 1215                                const G4ThreeVector& v ) const
827 {                                                 1216 {
828   // Z intersections                           << 
829   //                                           << 
830   if ((std::abs(p.z()) - fDz) >= -halfCarToler << 
831     return kInfinity;                          << 
832   G4double invz = (-v.z() == 0) ? DBL_MAX : -1 << 
833   G4double dz = (invz < 0) ? fDz : -fDz;       << 
834   G4double tzmin = (p.z() + dz)*invz;          << 
835   G4double tzmax = (p.z() - dz)*invz;          << 
836                                                   1217 
837   // Y intersections                           << 1218   G4double snxt;    // snxt = default return value
                                                   >> 1219   G4double max,smax,smin;
                                                   >> 1220   G4double pdist,Comp,vdist;
                                                   >> 1221   G4int i;
                                                   >> 1222   //
                                                   >> 1223   // Z Intersection range
838   //                                              1224   //
839   G4double tymin = 0, tymax = DBL_MAX;         << 1225   if ( v.z() > 0 )
840   G4int i = 0;                                 << 
841   for ( ; i<2; ++i)                            << 
842   {                                               1226   {
843     G4double cosa = fPlanes[i].b*v.y() + fPlan << 1227     max = fDz - p.z() ;
844     G4double dist = fPlanes[i].b*p.y() + fPlan << 1228     if (max > 0.5*kCarTolerance)
845     if (dist >= -halfCarTolerance)             << 
846     {                                             1229     {
847       if (cosa >= 0) return kInfinity;         << 1230       smax = max/v.z();
848       G4double tmp  = -dist/cosa;              << 1231       smin = (-fDz-p.z())/v.z();
849       if (tymin < tmp) tymin = tmp;            << 
850     }                                             1232     }
851     else if (cosa > 0)                         << 1233     else
852     {                                             1234     {
853       G4double tmp  = -dist/cosa;              << 1235       return snxt=kInfinity;
854       if (tymax > tmp) tymax = tmp;            << 
855     }                                             1236     }
856   }                                               1237   }
857                                                << 1238   else if (v.z() < 0 )
858   // Z intersections                           << 
859   //                                           << 
860   G4double txmin = 0, txmax = DBL_MAX;         << 
861   for ( ; i<4; ++i)                            << 
862   {                                               1239   {
863     G4double cosa = fPlanes[i].a*v.x()+fPlanes << 1240     max = - fDz - p.z() ;
864     G4double dist = fPlanes[i].a*p.x()+fPlanes << 1241     if (max < -0.5*kCarTolerance )
865                     fPlanes[i].d;              << 
866     if (dist >= -halfCarTolerance)             << 
867     {                                             1242     {
868       if (cosa >= 0) return kInfinity;         << 1243       smax=max/v.z();
869       G4double tmp  = -dist/cosa;              << 1244       smin=(fDz-p.z())/v.z();
870       if (txmin < tmp) txmin = tmp;            << 
871     }                                             1245     }
872     else if (cosa > 0)                         << 1246     else
873     {                                             1247     {
874       G4double tmp  = -dist/cosa;              << 1248       return snxt=kInfinity;
875       if (txmax > tmp) txmax = tmp;            << 1249     }
                                                   >> 1250   }
                                                   >> 1251   else
                                                   >> 1252   {
                                                   >> 1253     if (std::fabs(p.z())<fDz - 0.5*kCarTolerance) // Inside was <=fDz
                                                   >> 1254     {
                                                   >> 1255       smin=0;
                                                   >> 1256       smax=kInfinity;
                                                   >> 1257     }
                                                   >> 1258     else
                                                   >> 1259     {
                                                   >> 1260       return snxt=kInfinity;
876     }                                             1261     }
877   }                                               1262   }
878                                                   1263 
879   // Find distance                             << 1264   for (i=0;i<4;i++)
                                                   >> 1265   {
                                                   >> 1266     pdist=fPlanes[i].a*p.x()+fPlanes[i].b*p.y()
                                                   >> 1267          +fPlanes[i].c*p.z()+fPlanes[i].d;
                                                   >> 1268     Comp=fPlanes[i].a*v.x()+fPlanes[i].b*v.y()+fPlanes[i].c*v.z();
                                                   >> 1269     if ( pdist >= -0.5*kCarTolerance )      // was >0
                                                   >> 1270     {
                                                   >> 1271       //
                                                   >> 1272       // Outside the plane -> this is an extent entry distance
                                                   >> 1273       //
                                                   >> 1274       if (Comp >= 0)   // was >0
                                                   >> 1275       {
                                                   >> 1276         return snxt=kInfinity ;
                                                   >> 1277       }
                                                   >> 1278       else 
                                                   >> 1279       {
                                                   >> 1280         vdist=-pdist/Comp;
                                                   >> 1281         if (vdist>smin)
                                                   >> 1282         {
                                                   >> 1283           if (vdist<smax)
                                                   >> 1284           {
                                                   >> 1285             smin = vdist;
                                                   >> 1286           }
                                                   >> 1287           else
                                                   >> 1288           {
                                                   >> 1289             return snxt=kInfinity;
                                                   >> 1290           }
                                                   >> 1291         }
                                                   >> 1292       }
                                                   >> 1293     }
                                                   >> 1294     else
                                                   >> 1295     {
                                                   >> 1296       //
                                                   >> 1297       // Inside the plane -> couble  be an extent exit distance (smax)
                                                   >> 1298       //
                                                   >> 1299       if (Comp>0)  // Will leave extent
                                                   >> 1300       {
                                                   >> 1301         vdist=-pdist/Comp;
                                                   >> 1302         if (vdist<smax)
                                                   >> 1303         {
                                                   >> 1304           if (vdist>smin)
                                                   >> 1305           {
                                                   >> 1306             smax=vdist;
                                                   >> 1307           }
                                                   >> 1308           else
                                                   >> 1309           {
                                                   >> 1310             return snxt=kInfinity;
                                                   >> 1311           }
                                                   >> 1312         }  
                                                   >> 1313       }
                                                   >> 1314     }
                                                   >> 1315   }
880   //                                              1316   //
881   G4double tmin = std::max(std::max(txmin,tymi << 1317   // Checks in non z plane intersections ensure smin<smax
882   G4double tmax = std::min(std::min(txmax,tyma << 1318   //
883                                                << 1319   if (smin >=0 )
884   if (tmax <= tmin + halfCarTolerance) return  << 1320   {
885   return (tmin < halfCarTolerance ) ? 0. : tmi << 1321     snxt = smin ;
                                                   >> 1322   }
                                                   >> 1323   else
                                                   >> 1324   {
                                                   >> 1325     snxt = 0 ;
                                                   >> 1326   }
                                                   >> 1327   return snxt;
886 }                                                 1328 }
887                                                   1329 
888 ////////////////////////////////////////////// << 1330 ///////////////////////////////////////////////////////////////////////////
889 //                                                1331 //
890 // Calculate exact shortest distance to any bo    1332 // Calculate exact shortest distance to any boundary from outside
891 // This is the best fast estimation of the sho    1333 // This is the best fast estimation of the shortest distance to trap
892 // - return 0 if point is inside               << 1334 // - Returns 0 is ThreeVector inside
893                                                   1335 
894 G4double G4Trap::DistanceToIn( const G4ThreeVe    1336 G4double G4Trap::DistanceToIn( const G4ThreeVector& p ) const
895 {                                                 1337 {
896   switch (fTrapType)                           << 1338   G4double safe=0.0,Dist;
                                                   >> 1339   G4int i;
                                                   >> 1340   safe=std::fabs(p.z())-fDz;
                                                   >> 1341   for (i=0;i<4;i++)
897   {                                               1342   {
898     case 0: // General case                    << 1343     Dist=fPlanes[i].a*p.x()+fPlanes[i].b*p.y()
899     {                                          << 1344         +fPlanes[i].c*p.z()+fPlanes[i].d;
900       G4double dz = std::abs(p.z())-fDz;       << 1345     if (Dist > safe) safe=Dist;
901       G4double dy1 = fPlanes[0].b*p.y()+fPlane << 
902       G4double dy2 = fPlanes[1].b*p.y()+fPlane << 
903       G4double dy = std::max(dz,std::max(dy1,d << 
904                                                << 
905       G4double dx1 = fPlanes[2].a*p.x()+fPlane << 
906                    + fPlanes[2].c*p.z()+fPlane << 
907       G4double dx2 = fPlanes[3].a*p.x()+fPlane << 
908                    + fPlanes[3].c*p.z()+fPlane << 
909       G4double dist = std::max(dy,std::max(dx1 << 
910       return (dist > 0) ? dist : 0.;           << 
911     }                                          << 
912     case 1: // YZ section is a rectangle       << 
913     {                                          << 
914       G4double dz = std::abs(p.z())-fDz;       << 
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     }                                          << 
941   }                                               1346   }
942   return 0.;                                   << 1347   if (safe<0) safe=0;
                                                   >> 1348   return safe;  
943 }                                                 1349 }
944                                                   1350 
945 ////////////////////////////////////////////// << 1351 /////////////////////////////////////////////////////////////////////////////////
946 //                                                1352 //
947 // Calculate distance to surface of shape from << 1353 // Calculate distance to surface of shape from inside
948 // find normal at exit point, if required      << 1354 // Calculate distance to x/y/z planes - smallest is exiting distance
949 // - when leaving the surface, return 0        << 
950                                                   1355 
951 G4double G4Trap::DistanceToOut(const G4ThreeVe    1356 G4double G4Trap::DistanceToOut(const G4ThreeVector& p, const G4ThreeVector& v,
952                                const G4bool ca    1357                                const G4bool calcNorm,
953                                      G4bool* v << 1358                                      G4bool *validNorm, G4ThreeVector *n) const
954 {                                                 1359 {
955   // Z intersections                           << 1360   Eside side = kUndef;
                                                   >> 1361   G4double snxt;    // snxt = return value
                                                   >> 1362   G4double pdist,Comp,vdist,max;
                                                   >> 1363   //
                                                   >> 1364   // Z Intersections
956   //                                              1365   //
957   if ((std::abs(p.z()) - fDz) >= -halfCarToler << 1366   if (v.z()>0)
                                                   >> 1367   {
                                                   >> 1368     max=fDz-p.z();
                                                   >> 1369     if (max>kCarTolerance/2)
                                                   >> 1370     {
                                                   >> 1371       snxt=max/v.z();
                                                   >> 1372       side=kPZ;
                                                   >> 1373     }
                                                   >> 1374     else
                                                   >> 1375     {
                                                   >> 1376       if (calcNorm)
                                                   >> 1377       {
                                                   >> 1378         *validNorm=true;
                                                   >> 1379         *n=G4ThreeVector(0,0,1);
                                                   >> 1380       }
                                                   >> 1381       return snxt=0;
                                                   >> 1382     }
                                                   >> 1383   }
                                                   >> 1384   else if (v.z()<0)
958   {                                               1385   {
959     if (calcNorm)                              << 1386     max=-fDz-p.z();
                                                   >> 1387     if (max<-kCarTolerance/2)
                                                   >> 1388     {
                                                   >> 1389       snxt=max/v.z();
                                                   >> 1390       side=kMZ;
                                                   >> 1391     }
                                                   >> 1392     else
960     {                                             1393     {
961       *validNorm = true;                       << 1394       if (calcNorm)
962       n->set(0, 0, (p.z() < 0) ? -1 : 1);      << 1395       {
                                                   >> 1396         *validNorm=true;
                                                   >> 1397         *n=G4ThreeVector(0,0,-1);
                                                   >> 1398       }
                                                   >> 1399       return snxt=0;
963     }                                             1400     }
964     return 0;                                  << 
965   }                                               1401   }
966   G4double vz = v.z();                         << 1402   else
967   G4double tmax = (vz == 0) ? DBL_MAX : (std:: << 1403   {
968   G4int iside = (vz < 0) ? -4 : -2; // little  << 1404     snxt=kInfinity;
                                                   >> 1405   }
969                                                   1406 
970   // Y intersections                           << 
971   //                                              1407   //
972   G4int i = 0;                                 << 1408   // Intersections with planes[0] (expanded because of setting enum)
973   for ( ; i<2; ++i)                            << 1409   //
                                                   >> 1410   pdist=fPlanes[0].a*p.x()+fPlanes[0].b*p.y()+fPlanes[0].c*p.z()+fPlanes[0].d;
                                                   >> 1411   Comp=fPlanes[0].a*v.x()+fPlanes[0].b*v.y()+fPlanes[0].c*v.z();
                                                   >> 1412   if (pdist>0)
974   {                                               1413   {
975     G4double cosa = fPlanes[i].b*v.y() + fPlan << 1414     // Outside the plane
976     if (cosa > 0)                              << 1415     if (Comp>0)
977     {                                             1416     {
978       G4double dist = fPlanes[i].b*p.y() + fPl << 1417       // Leaving immediately
979       if (dist >= -halfCarTolerance)           << 1418       if (calcNorm)
980       {                                           1419       {
981         if (calcNorm)                          << 1420         *validNorm=true;
982         {                                      << 1421         *n=G4ThreeVector(fPlanes[0].a,fPlanes[0].b,fPlanes[0].c);
983           *validNorm = true;                   << 
984           n->set(0, fPlanes[i].b, fPlanes[i].c << 
985         }                                      << 
986         return 0;                              << 
987       }                                           1422       }
988       G4double tmp = -dist/cosa;               << 1423       return snxt=0;
989       if (tmax > tmp) { tmax = tmp; iside = i; << 1424     }
                                                   >> 1425   }
                                                   >> 1426   else if (pdist<-kCarTolerance/2)
                                                   >> 1427   {
                                                   >> 1428     // Inside the plane
                                                   >> 1429     if (Comp>0)
                                                   >> 1430     {
                                                   >> 1431       // Will leave extent
                                                   >> 1432       vdist=-pdist/Comp;
                                                   >> 1433       if (vdist<snxt)
                                                   >> 1434       {
                                                   >> 1435         snxt=vdist;
                                                   >> 1436         side=ks0;
                                                   >> 1437       }
                                                   >> 1438     }
                                                   >> 1439   }
                                                   >> 1440   else
                                                   >> 1441   {
                                                   >> 1442     // On surface
                                                   >> 1443     if (Comp>0)
                                                   >> 1444     {
                                                   >> 1445       if (calcNorm)
                                                   >> 1446       {
                                                   >> 1447         *validNorm=true;
                                                   >> 1448         *n=G4ThreeVector(fPlanes[0].a,fPlanes[0].b,fPlanes[0].c);
                                                   >> 1449       }
                                                   >> 1450       return snxt=0;
990     }                                             1451     }
991   }                                               1452   }
992                                                   1453 
993   // X intersections                           << 
994   //                                              1454   //
995   for ( ; i<4; ++i)                            << 1455   // Intersections with planes[1] (expanded because of setting enum)
                                                   >> 1456   //
                                                   >> 1457   pdist=fPlanes[1].a*p.x()+fPlanes[1].b*p.y()+fPlanes[1].c*p.z()+fPlanes[1].d;
                                                   >> 1458   Comp=fPlanes[1].a*v.x()+fPlanes[1].b*v.y()+fPlanes[1].c*v.z();
                                                   >> 1459   if (pdist>0)
996   {                                               1460   {
997     G4double cosa = fPlanes[i].a*v.x()+fPlanes << 1461     // Outside the plane
998     if (cosa > 0)                              << 1462     if (Comp>0)
999     {                                             1463     {
1000       G4double dist = fPlanes[i].a*p.x() +    << 1464       // Leaving immediately
1001                       fPlanes[i].b*p.y() + fP << 1465       if (calcNorm)
1002       if (dist >= -halfCarTolerance)          << 
1003       {                                          1466       {
1004         if (calcNorm)                         << 1467         *validNorm=true;
1005         {                                     << 1468         *n=G4ThreeVector(fPlanes[1].a,fPlanes[1].b,fPlanes[1].c);
1006            *validNorm = true;                 << 1469       }
1007            n->set(fPlanes[i].a, fPlanes[i].b, << 1470       return snxt=0;
1008         }                                     << 1471     }
1009         return 0;                             << 1472   }
                                                   >> 1473   else if (pdist<-kCarTolerance/2)
                                                   >> 1474   {
                                                   >> 1475     // Inside the plane
                                                   >> 1476     if (Comp>0)
                                                   >> 1477     {
                                                   >> 1478       // Will leave extent
                                                   >> 1479       vdist=-pdist/Comp;
                                                   >> 1480       if (vdist<snxt)
                                                   >> 1481       {
                                                   >> 1482         snxt=vdist;
                                                   >> 1483         side=ks1;
1010       }                                          1484       }
1011       G4double tmp = -dist/cosa;              << 1485     }
1012       if (tmax > tmp) { tmax = tmp; iside = i << 1486   }
                                                   >> 1487   else
                                                   >> 1488   {
                                                   >> 1489     // On surface
                                                   >> 1490     if (Comp>0)
                                                   >> 1491     {
                                                   >> 1492       if (calcNorm)
                                                   >> 1493       {
                                                   >> 1494         *validNorm=true;
                                                   >> 1495         *n=G4ThreeVector(fPlanes[1].a,fPlanes[1].b,fPlanes[1].c);
                                                   >> 1496       }
                                                   >> 1497       return snxt=0;
                                                   >> 1498     }
                                                   >> 1499   }
                                                   >> 1500 
                                                   >> 1501   //
                                                   >> 1502   // Intersections with planes[2] (expanded because of setting enum)
                                                   >> 1503   //
                                                   >> 1504   pdist=fPlanes[2].a*p.x()+fPlanes[2].b*p.y()+fPlanes[2].c*p.z()+fPlanes[2].d;
                                                   >> 1505   Comp=fPlanes[2].a*v.x()+fPlanes[2].b*v.y()+fPlanes[2].c*v.z();
                                                   >> 1506   if (pdist>0)
                                                   >> 1507   {
                                                   >> 1508     // Outside the plane
                                                   >> 1509     if (Comp>0)
                                                   >> 1510     {
                                                   >> 1511       // Leaving immediately
                                                   >> 1512       if (calcNorm)
                                                   >> 1513       {
                                                   >> 1514         *validNorm=true;
                                                   >> 1515         *n=G4ThreeVector(fPlanes[2].a,fPlanes[2].b,fPlanes[2].c);
                                                   >> 1516       }
                                                   >> 1517       return snxt=0;
                                                   >> 1518     }
                                                   >> 1519   }
                                                   >> 1520   else if (pdist<-kCarTolerance/2)
                                                   >> 1521   {
                                                   >> 1522     // Inside the plane
                                                   >> 1523     if (Comp>0)
                                                   >> 1524     {
                                                   >> 1525       // Will leave extent
                                                   >> 1526       vdist=-pdist/Comp;
                                                   >> 1527       if (vdist<snxt)
                                                   >> 1528       {
                                                   >> 1529         snxt=vdist;
                                                   >> 1530         side=ks2;
                                                   >> 1531       }
                                                   >> 1532     }
                                                   >> 1533   }
                                                   >> 1534   else
                                                   >> 1535   {
                                                   >> 1536     // On surface
                                                   >> 1537     if (Comp>0)
                                                   >> 1538     {
                                                   >> 1539       if (calcNorm)
                                                   >> 1540       {
                                                   >> 1541         *validNorm=true;
                                                   >> 1542         *n=G4ThreeVector(fPlanes[2].a,fPlanes[2].b,fPlanes[2].c);
                                                   >> 1543       }
                                                   >> 1544       return snxt=0;
1013     }                                            1545     }
1014   }                                              1546   }
1015                                                  1547 
1016   // Set normal, if required, and return dist << 
1017   //                                             1548   //
                                                   >> 1549   // Intersections with planes[3] (expanded because of setting enum)
                                                   >> 1550   //
                                                   >> 1551   pdist=fPlanes[3].a*p.x()+fPlanes[3].b*p.y()+fPlanes[3].c*p.z()+fPlanes[3].d;
                                                   >> 1552   Comp=fPlanes[3].a*v.x()+fPlanes[3].b*v.y()+fPlanes[3].c*v.z();
                                                   >> 1553   if (pdist>0)
                                                   >> 1554   {
                                                   >> 1555     // Outside the plane
                                                   >> 1556     if (Comp>0)
                                                   >> 1557     {
                                                   >> 1558       // Leaving immediately
                                                   >> 1559       if (calcNorm)
                                                   >> 1560       {
                                                   >> 1561         *validNorm=true;
                                                   >> 1562         *n=G4ThreeVector(fPlanes[3].a,fPlanes[3].b,fPlanes[3].c);
                                                   >> 1563       }
                                                   >> 1564       return snxt=0;
                                                   >> 1565     }
                                                   >> 1566   }
                                                   >> 1567   else if (pdist<-kCarTolerance/2)
                                                   >> 1568   {
                                                   >> 1569     // Inside the plane
                                                   >> 1570     if (Comp>0)
                                                   >> 1571     {
                                                   >> 1572       // Will leave extent
                                                   >> 1573       vdist=-pdist/Comp;
                                                   >> 1574       if (vdist<snxt)
                                                   >> 1575       {
                                                   >> 1576         snxt=vdist;
                                                   >> 1577         side=ks3;
                                                   >> 1578       }
                                                   >> 1579     }
                                                   >> 1580   }
                                                   >> 1581   else
                                                   >> 1582   {
                                                   >> 1583     // On surface
                                                   >> 1584     if (Comp>0)
                                                   >> 1585     {
                                                   >> 1586       if (calcNorm)
                                                   >> 1587       {
                                                   >> 1588         *validNorm=true;
                                                   >> 1589         *n=G4ThreeVector(fPlanes[3].a,fPlanes[3].b,fPlanes[3].c);
                                                   >> 1590       }
                                                   >> 1591       return snxt=0;
                                                   >> 1592     }
                                                   >> 1593   }
                                                   >> 1594 
                                                   >> 1595   // set normal
1018   if (calcNorm)                                  1596   if (calcNorm)
1019   {                                              1597   {
1020     *validNorm = true;                        << 1598     *validNorm=true;
1021     if (iside < 0)                            << 1599     switch(side)
1022       n->set(0, 0, iside + 3); // (-4+3)=-1,  << 1600     {
1023     else                                      << 1601       case ks0:
1024       n->set(fPlanes[iside].a, fPlanes[iside] << 1602         *n=G4ThreeVector(fPlanes[0].a,fPlanes[0].b,fPlanes[0].c);
                                                   >> 1603         break;
                                                   >> 1604       case ks1:
                                                   >> 1605         *n=G4ThreeVector(fPlanes[1].a,fPlanes[1].b,fPlanes[1].c);
                                                   >> 1606         break;
                                                   >> 1607       case ks2:
                                                   >> 1608         *n=G4ThreeVector(fPlanes[2].a,fPlanes[2].b,fPlanes[2].c);
                                                   >> 1609         break;
                                                   >> 1610       case ks3:
                                                   >> 1611         *n=G4ThreeVector(fPlanes[3].a,fPlanes[3].b,fPlanes[3].c);
                                                   >> 1612         break;
                                                   >> 1613       case kMZ:
                                                   >> 1614         *n=G4ThreeVector(0,0,-1);
                                                   >> 1615         break;
                                                   >> 1616       case kPZ:
                                                   >> 1617         *n=G4ThreeVector(0,0,1);
                                                   >> 1618         break;
                                                   >> 1619       default:
                                                   >> 1620         G4cout.precision(16);
                                                   >> 1621         G4cout << G4endl;
                                                   >> 1622         DumpInfo();
                                                   >> 1623         G4cout << "Position:"  << G4endl << G4endl;
                                                   >> 1624         G4cout << "p.x() = "   << p.x()/mm << " mm" << G4endl;
                                                   >> 1625         G4cout << "p.y() = "   << p.y()/mm << " mm" << G4endl;
                                                   >> 1626         G4cout << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl;
                                                   >> 1627         G4cout << "Direction:" << G4endl << G4endl;
                                                   >> 1628         G4cout << "v.x() = "   << v.x() << G4endl;
                                                   >> 1629         G4cout << "v.y() = "   << v.y() << G4endl;
                                                   >> 1630         G4cout << "v.z() = "   << v.z() << G4endl << G4endl;
                                                   >> 1631         G4cout << "Proposed distance :" << G4endl << G4endl;
                                                   >> 1632         G4cout << "snxt = "    << snxt/mm << " mm" << G4endl << G4endl;
                                                   >> 1633         G4Exception("G4Trap::DistanceToOut(p,v,..)","Notification",JustWarning,
                                                   >> 1634                     "Undefined side for valid surface normal to solid.");
                                                   >> 1635         break;
                                                   >> 1636     }
1025   }                                              1637   }
1026   return tmax;                                << 1638   return snxt;
1027 }                                                1639 }
1028                                                  1640 
1029 ///////////////////////////////////////////// << 1641 //////////////////////////////////////////////////////////////////////////////
1030 //                                               1642 //
1031 // Calculate exact shortest distance to any b    1643 // Calculate exact shortest distance to any boundary from inside
1032 // - Returns 0 is ThreeVector outside            1644 // - Returns 0 is ThreeVector outside
1033                                                  1645 
1034 G4double G4Trap::DistanceToOut( const G4Three    1646 G4double G4Trap::DistanceToOut( const G4ThreeVector& p ) const
1035 {                                                1647 {
                                                   >> 1648   G4double safe=0.0,Dist;
                                                   >> 1649   G4int i;
                                                   >> 1650 
1036 #ifdef G4CSGDEBUG                                1651 #ifdef G4CSGDEBUG
1037   if( Inside(p) == kOutside )                    1652   if( Inside(p) == kOutside )
1038   {                                              1653   {
1039     std::ostringstream message;               << 1654      G4cout.precision(16) ;
1040     G4long oldprc = message.precision(16);    << 1655      G4cout << G4endl ;
1041     message << "Point p is outside (!?) of so << 1656      DumpInfo();
1042     message << "Position:\n";                 << 1657      G4cout << "Position:"  << G4endl << G4endl ;
1043     message << "   p.x() = " << p.x()/mm << " << 1658      G4cout << "p.x() = "   << p.x()/mm << " mm" << G4endl ;
1044     message << "   p.y() = " << p.y()/mm << " << 1659      G4cout << "p.y() = "   << p.y()/mm << " mm" << G4endl ;
1045     message << "   p.z() = " << p.z()/mm << " << 1660      G4cout << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl ;
1046     G4cout.precision(oldprc);                 << 1661      G4Exception("G4Trap::DistanceToOut(p)",
1047     G4Exception("G4Trap::DistanceToOut(p)", " << 1662                  "Notification", JustWarning, "Point p is outside !?" );
1048                 JustWarning, message );       << 
1049     DumpInfo();                               << 
1050   }                                              1663   }
1051 #endif                                           1664 #endif
1052   switch (fTrapType)                          << 1665 
                                                   >> 1666   safe=fDz-std::fabs(p.z());
                                                   >> 1667   if (safe<0) safe=0;
                                                   >> 1668   else
1053   {                                              1669   {
1054     case 0: // General case                   << 1670     for (i=0;i<4;i++)
1055     {                                            1671     {
1056       G4double dz = std::abs(p.z())-fDz;      << 1672       Dist=-(fPlanes[i].a*p.x()+fPlanes[i].b*p.y()
1057       G4double dy1 = fPlanes[0].b*p.y()+fPlan << 1673             +fPlanes[i].c*p.z()+fPlanes[i].d);
1058       G4double dy2 = fPlanes[1].b*p.y()+fPlan << 1674       if (Dist<safe) safe=Dist;
1059       G4double dy = std::max(dz,std::max(dy1, << 1675     }
1060                                               << 1676     if (safe<0) safe=0;
1061       G4double dx1 = fPlanes[2].a*p.x()+fPlan << 1677   }
1062                    + fPlanes[2].c*p.z()+fPlan << 1678   return safe;  
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     {                                         << 
1070       G4double dz = std::abs(p.z())-fDz;      << 
1071       G4double dy = std::max(dz,std::abs(p.y( << 
1072       G4double dx1 = fPlanes[2].a*p.x()+fPlan << 
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     }                                         << 
1097   }                                           << 
1098   return 0.;                                  << 
1099 }                                                1679 }
1100                                                  1680 
1101 /////////////////////////////////////////////    1681 //////////////////////////////////////////////////////////////////////////
1102 //                                               1682 //
1103 // GetEntityType                              << 1683 // Create a List containing the transformed vertices
1104                                               << 1684 // Ordering [0-3] -fDz cross section
1105 G4GeometryType G4Trap::GetEntityType() const  << 1685 //          [4-7] +fDz cross section such that [0] is below [4],
1106 {                                             << 1686 //                                             [1] below [5] etc.
1107   return {"G4Trap"};                          << 1687 // Note:
                                                   >> 1688 //  Caller has deletion resposibility
                                                   >> 1689 
                                                   >> 1690 G4ThreeVectorList*
                                                   >> 1691 G4Trap::CreateRotatedVertices( const G4AffineTransform& pTransform ) const
                                                   >> 1692 {
                                                   >> 1693   G4ThreeVectorList *vertices;
                                                   >> 1694   vertices=new G4ThreeVectorList();
                                                   >> 1695   vertices->reserve(8);
                                                   >> 1696   if (vertices)
                                                   >> 1697   {
                                                   >> 1698     G4ThreeVector vertex0(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,
                                                   >> 1699                           -fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 1700     G4ThreeVector vertex1(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,
                                                   >> 1701                           -fDz*fTthetaSphi-fDy1,-fDz);
                                                   >> 1702     G4ThreeVector vertex2(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,
                                                   >> 1703                           -fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 1704     G4ThreeVector vertex3(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,
                                                   >> 1705                           -fDz*fTthetaSphi+fDy1,-fDz);
                                                   >> 1706     G4ThreeVector vertex4(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,
                                                   >> 1707                           +fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 1708     G4ThreeVector vertex5(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,
                                                   >> 1709                           +fDz*fTthetaSphi-fDy2,+fDz);
                                                   >> 1710     G4ThreeVector vertex6(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,
                                                   >> 1711                           +fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 1712     G4ThreeVector vertex7(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,
                                                   >> 1713                           +fDz*fTthetaSphi+fDy2,+fDz);
                                                   >> 1714 
                                                   >> 1715     vertices->push_back(pTransform.TransformPoint(vertex0));
                                                   >> 1716     vertices->push_back(pTransform.TransformPoint(vertex1));
                                                   >> 1717     vertices->push_back(pTransform.TransformPoint(vertex2));
                                                   >> 1718     vertices->push_back(pTransform.TransformPoint(vertex3));
                                                   >> 1719     vertices->push_back(pTransform.TransformPoint(vertex4));
                                                   >> 1720     vertices->push_back(pTransform.TransformPoint(vertex5));
                                                   >> 1721     vertices->push_back(pTransform.TransformPoint(vertex6));
                                                   >> 1722     vertices->push_back(pTransform.TransformPoint(vertex7));
                                                   >> 1723   }
                                                   >> 1724   else
                                                   >> 1725   {
                                                   >> 1726     DumpInfo();
                                                   >> 1727     G4Exception("G4Trap::CreateRotatedVertices()",
                                                   >> 1728                 "FatalError", FatalException,
                                                   >> 1729                 "Error in allocation of vertices. Out of memory !");
                                                   >> 1730   }
                                                   >> 1731   return vertices;
1108 }                                                1732 }
1109                                                  1733 
1110 /////////////////////////////////////////////    1734 //////////////////////////////////////////////////////////////////////////
1111 //                                               1735 //
1112 // IsFaceted                                  << 1736 // GetEntityType
1113                                               << 
1114 G4bool G4Trap::IsFaceted() const              << 
1115 {                                             << 
1116   return true;                                << 
1117 }                                             << 
1118                                                  1737 
1119 ///////////////////////////////////////////// << 1738 G4GeometryType G4Trap::GetEntityType() const
1120 //                                            << 
1121 // Make a clone of the object                 << 
1122 //                                            << 
1123 G4VSolid* G4Trap::Clone() const               << 
1124 {                                                1739 {
1125   return new G4Trap(*this);                   << 1740   return G4String("G4Trap");
1126 }                                                1741 }
1127                                                  1742 
1128 /////////////////////////////////////////////    1743 //////////////////////////////////////////////////////////////////////////
1129 //                                               1744 //
1130 // Stream object contents to an output stream    1745 // Stream object contents to an output stream
1131                                                  1746 
1132 std::ostream& G4Trap::StreamInfo( std::ostrea    1747 std::ostream& G4Trap::StreamInfo( std::ostream& os ) const
1133 {                                                1748 {
1134   G4double phi    = GetPhi();                 << 
1135   G4double theta  = GetTheta();               << 
1136   G4double alpha1 = GetAlpha1();              << 
1137   G4double alpha2 = GetAlpha2();              << 
1138                                               << 
1139   G4long oldprc = os.precision(16);           << 
1140   os << "------------------------------------    1749   os << "-----------------------------------------------------------\n"
1141      << "    *** Dump for solid: " << GetName << 1750      << "    *** Dump for solid - " << GetName() << " ***\n"
1142      << "    ================================    1751      << "    ===================================================\n"
1143      << " Solid type: G4Trap\n"                  1752      << " Solid type: G4Trap\n"
1144      << " Parameters:\n"                      << 1753      << " Parameters: \n"
1145      << "    half length Z: " << fDz/mm << "  << 1754      << "    half length Z: " << fDz/mm << " mm \n"
1146      << "    half length Y, face -Dz: " << fD << 1755      << "    half length Y of face -fDz: " << fDy1/mm << " mm \n"
1147      << "    half length X, face -Dz, side -D << 1756      << "    half length X of side -fDy1, face -fDz: " << fDx1/mm << " mm \n"
1148      << "    half length X, face -Dz, side +D << 1757      << "    half length X of side +fDy1, face -fDz: " << fDx2/mm << " mm \n"
1149      << "    half length Y, face +Dz: " << fD << 1758      << "    half length Y of face +fDz: " << fDy2/mm << " mm \n"
1150      << "    half length X, face +Dz, side -D << 1759      << "    half length X of side -fDy2, face +fDz: " << fDx3/mm << " mm \n"
1151      << "    half length X, face +Dz, side +D << 1760      << "    half length X of side +fDy2, face +fDz: " << fDx4/mm << " mm \n"
1152      << "    theta: " << theta/degree << " de << 1761      << "    std::tan(theta)*std::cos(phi): " << fTthetaCphi/degree << " degrees \n"
1153      << "    phi:   " << phi/degree << " degr << 1762      << "    std::tan(theta)*std::sin(phi): " << fTthetaSphi/degree << " degrees \n"
1154      << "    alpha, face -Dz: " << alpha1/deg << 1763      << "    std::tan(alpha), -fDz: " << fTalpha1/degree << " degrees \n"
1155      << "    alpha, face +Dz: " << alpha2/deg << 1764      << "    std::tan(alpha), +fDz: " << fTalpha2/degree << " degrees \n"
                                                   >> 1765      << "    trap side plane equations:\n"
                                                   >> 1766      << "        " << fPlanes[0].a << " X + " << fPlanes[0].b << " Y + "
                                                   >> 1767                    << fPlanes[0].c << " Z + " << fPlanes[0].d << " = 0\n"
                                                   >> 1768      << "        " << fPlanes[1].a << " X + " << fPlanes[1].b << " Y + "
                                                   >> 1769                    << fPlanes[1].c << " Z + " << fPlanes[1].d << " = 0\n"
                                                   >> 1770      << "        " << fPlanes[2].a << " X + " << fPlanes[2].b << " Y + "
                                                   >> 1771                    << fPlanes[2].c << " Z + " << fPlanes[2].d << " = 0\n"
                                                   >> 1772      << "        " << fPlanes[3].a << " X + " << fPlanes[3].b << " Y + "
                                                   >> 1773                    << fPlanes[3].c << " Z + " << fPlanes[3].d << " = 0\n"
1156      << "------------------------------------    1774      << "-----------------------------------------------------------\n";
1157   os.precision(oldprc);                       << 
1158                                                  1775 
1159   return os;                                     1776   return os;
1160 }                                                1777 }
1161                                                  1778 
1162 ///////////////////////////////////////////// << 1779 /////////////////////////////////////////////////////////////////////////
1163 //                                               1780 //
1164 // Compute vertices from planes               << 1781 // GetPointOnPlane
                                                   >> 1782 //
                                                   >> 1783 // Auxiliary method for Get Point on Surface
1165                                                  1784 
1166 void G4Trap::GetVertices(G4ThreeVector pt[8]) << 1785 G4ThreeVector G4Trap::GetPointOnPlane(G4ThreeVector p0, G4ThreeVector p1, 
1167 {                                             << 1786                                       G4ThreeVector p2, G4ThreeVector p3,
1168   for (G4int i=0; i<8; ++i)                   << 1787                                       G4double& area) const
1169   {                                           << 1788 {
1170     G4int iy = (i==0 || i==1 || i==4 || i==5) << 1789   G4double lambda1, lambda2, chose, aOne, aTwo;
1171     G4int ix = (i==0 || i==2 || i==4 || i==6) << 1790   G4ThreeVector t, u, v, w, Area, normal;
1172     G4double z = (i < 4) ? -fDz : fDz;        << 1791   
1173     G4double y = -(fPlanes[iy].c*z + fPlanes[ << 1792   t = p1 - p0;
1174     G4double x = -(fPlanes[ix].b*y + fPlanes[ << 1793   u = p2 - p1;
1175                    + fPlanes[ix].d)/fPlanes[i << 1794   v = p3 - p2;
1176     pt[i].set(x,y,z);                         << 1795   w = p0 - p3;
1177   }                                           << 1796 
                                                   >> 1797   Area = G4ThreeVector(w.y()*v.z() - w.z()*v.y(),
                                                   >> 1798                        w.z()*v.x() - w.x()*v.z(),
                                                   >> 1799                        w.x()*v.y() - w.y()*v.x());
                                                   >> 1800   
                                                   >> 1801   aOne = 0.5*Area.mag();
                                                   >> 1802   
                                                   >> 1803   Area = G4ThreeVector(t.y()*u.z() - t.z()*u.y(),
                                                   >> 1804                        t.z()*u.x() - t.x()*u.z(),
                                                   >> 1805                        t.x()*u.y() - t.y()*u.x());
                                                   >> 1806   
                                                   >> 1807   aTwo = 0.5*Area.mag();
                                                   >> 1808   
                                                   >> 1809   area = aOne + aTwo;
                                                   >> 1810   
                                                   >> 1811   chose = RandFlat::shoot(0.,aOne+aTwo);
                                                   >> 1812 
                                                   >> 1813   if( (chose>=0.) && (chose < aOne) )
                                                   >> 1814   {
                                                   >> 1815     lambda1 = RandFlat::shoot(0.,1.);
                                                   >> 1816     lambda2 = RandFlat::shoot(0.,lambda1);
                                                   >> 1817     return (p2+lambda1*v+lambda2*w);    
                                                   >> 1818   }
                                                   >> 1819   
                                                   >> 1820   // else
                                                   >> 1821 
                                                   >> 1822   lambda1 = RandFlat::shoot(0.,1.);
                                                   >> 1823   lambda2 = RandFlat::shoot(0.,lambda1);
                                                   >> 1824 
                                                   >> 1825   return (p0+lambda1*t+lambda2*u);    
1178 }                                                1826 }
1179                                                  1827 
1180 ///////////////////////////////////////////// << 1828 ///////////////////////////////////////////////////////////////
1181 //                                               1829 //
1182 // Generate random point on the surface       << 1830 // GetPointOnSurface
1183                                                  1831 
1184 G4ThreeVector G4Trap::GetPointOnSurface() con    1832 G4ThreeVector G4Trap::GetPointOnSurface() const
1185 {                                                1833 {
1186   // Set indeces                              << 1834   G4double aOne, aTwo, aThree, aFour, aFive, aSix, chose;
1187   constexpr G4int iface [6][4] =              << 1835   G4ThreeVector One, Two, Three, Four, Five, Six, test;
1188     { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2,6 << 
1189                                               << 
1190   // Set vertices                             << 
1191   G4ThreeVector pt[8];                           1836   G4ThreeVector pt[8];
1192   GetVertices(pt);                            << 1837      
1193                                               << 1838   pt[0] = G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1-fDx1,
1194   // Select face                              << 1839                         -fDz*fTthetaSphi-fDy1,-fDz);
1195   //                                          << 1840   pt[1] = G4ThreeVector(-fDz*fTthetaCphi-fDy1*fTalpha1+fDx1,
1196   G4double select = fAreas[5]*G4QuickRand();  << 1841                         -fDz*fTthetaSphi-fDy1,-fDz);
1197   G4int k = 5;                                << 1842   pt[2] = G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1-fDx2,
1198   k -= (G4int)(select <= fAreas[4]);          << 1843                         -fDz*fTthetaSphi+fDy1,-fDz);
1199   k -= (G4int)(select <= fAreas[3]);          << 1844   pt[3] = G4ThreeVector(-fDz*fTthetaCphi+fDy1*fTalpha1+fDx2,
1200   k -= (G4int)(select <= fAreas[2]);          << 1845                         -fDz*fTthetaSphi+fDy1,-fDz);
1201   k -= (G4int)(select <= fAreas[1]);          << 1846   pt[4] = G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2-fDx3,
1202   k -= (G4int)(select <= fAreas[0]);          << 1847                         +fDz*fTthetaSphi-fDy2,+fDz);
1203                                               << 1848   pt[5] = G4ThreeVector(+fDz*fTthetaCphi-fDy2*fTalpha2+fDx3,
1204   // Select sub-triangle                      << 1849                         +fDz*fTthetaSphi-fDy2,+fDz);
1205   //                                          << 1850   pt[6] = G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2-fDx4,
1206   G4int i0 = iface[k][0];                     << 1851                         +fDz*fTthetaSphi+fDy2,+fDz);
1207   G4int i1 = iface[k][1];                     << 1852   pt[7] = G4ThreeVector(+fDz*fTthetaCphi+fDy2*fTalpha2+fDx4,
1208   G4int i2 = iface[k][2];                     << 1853                         +fDz*fTthetaSphi+fDy2,+fDz);
1209   G4int i3 = iface[k][3];                     << 1854   
1210   G4double s2 = G4GeomTools::TriangleAreaNorm << 1855   // make sure we provide the points in a clockwise fashion
1211   if (select > fAreas[k] - s2) i0 = i2;       << 1856 
1212                                               << 1857   One   = GetPointOnPlane(pt[0],pt[1],pt[3],pt[2], aOne);
1213   // Generate point                           << 1858   Two   = GetPointOnPlane(pt[4],pt[5],pt[7],pt[6], aTwo);
1214   //                                          << 1859   Three = GetPointOnPlane(pt[6],pt[7],pt[3],pt[2], aThree);
1215   G4double u = G4QuickRand();                 << 1860   Four  = GetPointOnPlane(pt[4],pt[5],pt[1],pt[0], aFour); 
1216   G4double v = G4QuickRand();                 << 1861   Five  = GetPointOnPlane(pt[0],pt[2],pt[6],pt[4], aFive);
1217   if (u + v > 1.) { u = 1. - u; v = 1. - v; } << 1862   Six   = GetPointOnPlane(pt[1],pt[3],pt[7],pt[5], aSix);
1218   return (1.-u-v)*pt[i0] + u*pt[i1] + v*pt[i3 << 1863  
                                                   >> 1864   chose = RandFlat::shoot(0.,aOne+aTwo+aThree+aFour+aFive+aSix);
                                                   >> 1865   if( (chose>=0.) && (chose<aOne) )                    
                                                   >> 1866     { return One; }
                                                   >> 1867   else if( (chose>=aOne) && (chose<aOne+aTwo) )  
                                                   >> 1868     { return Two; }
                                                   >> 1869   else if( (chose>=aOne+aTwo) && (chose<aOne+aTwo+aThree) )
                                                   >> 1870     { return Three; }
                                                   >> 1871   else if( (chose>=aOne+aTwo+aThree) && (chose<aOne+aTwo+aThree+aFour) )
                                                   >> 1872     { return Four; }
                                                   >> 1873   else if( (chose>=aOne+aTwo+aThree+aFour)
                                                   >> 1874         && (chose<aOne+aTwo+aThree+aFour+aFive) )
                                                   >> 1875     { return Five; }
                                                   >> 1876   return Six;
1219 }                                                1877 }
1220                                                  1878 
1221 /////////////////////////////////////////////    1879 //////////////////////////////////////////////////////////////////////////
1222 //                                               1880 //
1223 // Methods for visualisation                     1881 // Methods for visualisation
1224                                                  1882 
1225 void G4Trap::DescribeYourselfTo ( G4VGraphics    1883 void G4Trap::DescribeYourselfTo ( G4VGraphicsScene& scene ) const
1226 {                                                1884 {
1227   scene.AddSolid (*this);                        1885   scene.AddSolid (*this);
1228 }                                                1886 }
1229                                                  1887 
1230 G4Polyhedron* G4Trap::CreatePolyhedron () con    1888 G4Polyhedron* G4Trap::CreatePolyhedron () const
1231 {                                                1889 {
1232   G4double phi = std::atan2(fTthetaSphi, fTth    1890   G4double phi = std::atan2(fTthetaSphi, fTthetaCphi);
1233   G4double alpha1 = std::atan(fTalpha1);         1891   G4double alpha1 = std::atan(fTalpha1);
1234   G4double alpha2 = std::atan(fTalpha2);         1892   G4double alpha2 = std::atan(fTalpha2);
1235   G4double theta = std::atan(std::sqrt(fTthet << 1893   G4double theta = std::atan(std::sqrt(fTthetaCphi*fTthetaCphi+fTthetaSphi*fTthetaSphi));
1236                                       +fTthet << 
1237                                                  1894 
1238   return new G4PolyhedronTrap(fDz, theta, phi    1895   return new G4PolyhedronTrap(fDz, theta, phi,
1239                               fDy1, fDx1, fDx    1896                               fDy1, fDx1, fDx2, alpha1,
1240                               fDy2, fDx3, fDx    1897                               fDy2, fDx3, fDx4, alpha2);
1241 }                                                1898 }
1242                                                  1899 
1243 #endif                                        << 1900 G4NURBS* G4Trap::CreateNURBS () const
                                                   >> 1901 {
                                                   >> 1902    // return new G4NURBSbox (fDx, fDy, fDz);
                                                   >> 1903    return 0 ;
                                                   >> 1904 }
1244                                                  1905