#include <G4GenericTrap.hh>

Inheritance diagram for G4GenericTrap:

Public Member Functions
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const

G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const

G4VSolid *	Clone () const

virtual void	ComputeDimensions (G4VPVParameterisation p, const G4int n, const G4VPhysicalVolume pRep)

G4Polyhedron *	CreatePolyhedron () const

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4double	DistanceToIn (const G4ThreeVector &p) const

G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const

G4double	DistanceToOut (const G4ThreeVector &p) const

G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool validNorm=nullptr, G4ThreeVector n=nullptr) const

void	DumpInfo () const

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

	G4GenericTrap (__void__ &)

	G4GenericTrap (const G4GenericTrap &rhs)

	G4GenericTrap (const G4String &name, G4double halfZ, const std::vector< G4TwoVector > &vertices)

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

G4double	GetCubicVolume ()

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

G4GeometryType	GetEntityType () const

G4VisExtent	GetExtent () const

G4String	GetName () const

G4int	GetNofVertices () const

G4ThreeVector	GetPointOnSurface () const

G4Polyhedron *	GetPolyhedron () const

G4double	GetSurfaceArea ()

G4double	GetTolerance () const

G4double	GetTwistAngle (G4int index) const

G4TwoVector	GetVertex (G4int index) const

const std::vector< G4TwoVector > &	GetVertices () const

G4int	GetVisSubdivisions () const

G4double	GetZHalfLength () const

EInside	Inside (const G4ThreeVector &p) const

G4bool	IsTwisted () const

G4GenericTrap &	operator= (const G4GenericTrap &rhs)

G4bool	operator== (const G4VSolid &s) const

void	SetName (const G4String &name)

void	SetVisSubdivisions (G4int subdiv)

std::ostream &	StreamInfo (std::ostream &os) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

	~G4GenericTrap ()

Protected Member Functions
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const

Protected Attributes
G4Polyhedron *	fpPolyhedron = nullptr

G4bool	fRebuildPolyhedron = false

G4double	kCarTolerance

Private Types
enum	ESide { kUndef , kXY0 , kXY1 , kXY2 , kXY3 , kMZ , kPZ }

Private Member Functions
G4bool	CheckOrder (const std::vector< G4TwoVector > &vertices) const

void	ClipPolygonToSimpleLimits (G4ThreeVectorList &pPolygon, G4ThreeVectorList &outputPolygon, const G4VoxelLimits &pVoxelLimit) const

void	ComputeBBox ()

G4bool	ComputeIsTwisted ()

G4TessellatedSolid *	CreateTessellatedSolid () const

G4double	DistToPlane (const G4ThreeVector &p, const G4ThreeVector &v, const G4int ipl) const

G4double	DistToTriangle (const G4ThreeVector &p, const G4ThreeVector &v, const G4int ipl) const

G4double	GetFaceCubicVolume (const G4ThreeVector &p0, const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3) const

G4double	GetFaceSurfaceArea (const G4ThreeVector &p0, const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3) const

G4ThreeVector	GetMaximumBBox () const

G4ThreeVector	GetMinimumBBox () const

G4double	GetTwistedFaceSurfaceArea (const G4ThreeVector &p0, const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3) const

EInside	InsidePolygone (const G4ThreeVector &p, const std::vector< G4TwoVector > &poly) const

G4bool	IsSegCrossing (const G4TwoVector &a, const G4TwoVector &b, const G4TwoVector &c, const G4TwoVector &d) const

G4bool	IsSegCrossingZ (const G4TwoVector &a, const G4TwoVector &b, const G4TwoVector &c, const G4TwoVector &d) const

G4VFacet *	MakeDownFacet (const std::vector< G4ThreeVector > &fromVertices, G4int ind1, G4int ind2, G4int ind3) const

G4VFacet *	MakeSideFacet (const G4ThreeVector &downVertex0, const G4ThreeVector &downVertex1, const G4ThreeVector &upVertex1, const G4ThreeVector &upVertex0) const

G4VFacet *	MakeUpFacet (const std::vector< G4ThreeVector > &fromVertices, G4int ind1, G4int ind2, G4int ind3) const

G4ThreeVector	NormalToPlane (const G4ThreeVector &p, const G4int ipl) const

void	ReorderVertices (std::vector< G4ThreeVector > &vertices) const

G4double	SafetyToFace (const G4ThreeVector &p, const G4int iseg) const

void	SetTwistAngle (G4int index, G4double twist)

Private Attributes
G4double	fCubicVolume = 0.0

G4double	fDz

G4bool	fIsTwisted = false

G4ThreeVector	fMaxBBoxVector

G4ThreeVector	fMinBBoxVector

G4String	fshapeName

G4double	fSurfaceArea = 0.0

G4TessellatedSolid *	fTessellatedSolid = nullptr

G4double	fTwist [4]

std::vector< G4TwoVector >	fVertices

G4int	fVisSubdivisions = 0

G4double	halfCarTolerance

Static Private Attributes
static const G4int	fgkNofVertices = 8

static const G4double	fgkTolerance = 1E-3

Detailed Description

Definition at line 79 of file G4GenericTrap.hh.

Member Enumeration Documentation

◆ ESide

enum G4GenericTrap::ESide

private

Enumerator
kUndef
kXY0
kXY1
kXY2
kXY3
kMZ
kPZ

Definition at line 221 of file G4GenericTrap.hh.

221{kUndef,kXY0,kXY1,kXY2,kXY3,kMZ,kPZ};

G4GenericTrap::kUndef

@ kUndef

Definition: G4GenericTrap.hh:221

G4GenericTrap::kMZ

@ kMZ

Definition: G4GenericTrap.hh:221

G4GenericTrap::kXY3

@ kXY3

Definition: G4GenericTrap.hh:221

G4GenericTrap::kXY1

@ kXY1

Definition: G4GenericTrap.hh:221

G4GenericTrap::kXY2

@ kXY2

Definition: G4GenericTrap.hh:221

G4GenericTrap::kXY0

@ kXY0

Definition: G4GenericTrap.hh:221

G4GenericTrap::kPZ

@ kPZ

Definition: G4GenericTrap.hh:221

Constructor & Destructor Documentation

◆ G4GenericTrap() [1/3]

G4GenericTrap::G4GenericTrap	(	const G4String &	name,
		G4double	halfZ,
		const std::vector< G4TwoVector > &	vertices
	)

Definition at line 65 of file G4GenericTrap.cc.

  : G4VSolid(name), fDz(halfZ), fVertices(),
    fMinBBoxVector(G4ThreeVector(0,0,0)), fMaxBBoxVector(G4ThreeVector(0,0,0))
{
  // General constructor
  const G4double min_length=5*1.e-6;
  G4double length = 0.;
  G4int k=0;
  G4String errorDescription = "InvalidSetup in \" ";
  errorDescription += name;
  errorDescription += "\""; 
 
  halfCarTolerance = kCarTolerance*0.5;
 
  // Check vertices size
 
  if ( G4int(vertices.size()) != fgkNofVertices )
  {
    G4Exception("G4GenericTrap::G4GenericTrap()", "GeomSolids0002",
                FatalErrorInArgument, "Number of vertices != 8");
  }            
  
  // Check dZ
  // 
  if (halfZ < kCarTolerance)
  {
     G4Exception("G4GenericTrap::G4GenericTrap()", "GeomSolids0002",
                FatalErrorInArgument, "dZ is too small or negative");
  }           
 
  // Check Ordering and Copy vertices 
  //
  if(CheckOrder(vertices))
  {
    for (G4int i=0; i<fgkNofVertices; ++i) {fVertices.push_back(vertices[i]);}
  }
  else
  { 
    for (auto i=0; i <4; ++i) {fVertices.push_back(vertices[3-i]);}
    for (auto i=0; i <4; ++i) {fVertices.push_back(vertices[7-i]);}
  }
 
   // Check length of segments and Adjust
  // 
  for (auto j=0; j<2; ++j)
  {
    for (auto i=1; i<4; ++i)
    {
      k = j*4+i;
      length = (fVertices[k]-fVertices[k-1]).mag();
      if ( ( length < min_length) && ( length > kCarTolerance ) )
      {
        std::ostringstream message;
        message << "Length segment is too small." << G4endl
                << "Distance between " << fVertices[k-1] << " and "
                << fVertices[k] << " is only " << length << " mm !"; 
        G4Exception("G4GenericTrap::G4GenericTrap()", "GeomSolids1001",
                    JustWarning, message, "Vertices will be collapsed.");
        fVertices[k]=fVertices[k-1];
      }
    }
  }
 
  // Compute Twist
  //
  for( auto i=0; i<4; ++i) { fTwist[i]=0.; }
  fIsTwisted = ComputeIsTwisted();
 
  // Compute Bounding Box 
  //
  ComputeBBox();
  
  // If not twisted - create tessellated solid 
  // (an alternative implementation for testing)
  //
#ifdef G4TESS_TEST
   if ( !fIsTwisted )  { fTessellatedSolid = CreateTessellatedSolid(); }
#endif
}

References CheckOrder(), ComputeBBox(), ComputeIsTwisted(), CreateTessellatedSolid(), FatalErrorInArgument, fgkNofVertices, fIsTwisted, fTessellatedSolid, fTwist, fVertices, G4endl, G4Exception(), halfCarTolerance, JustWarning, G4VSolid::kCarTolerance, and G4InuclParticleNames::name().

Referenced by Clone().

◆ ~G4GenericTrap()

G4GenericTrap::~G4GenericTrap ( )

Definition at line 158 of file G4GenericTrap.cc.

{
  delete fTessellatedSolid;
}

References fTessellatedSolid.

◆ G4GenericTrap() [2/3]

G4GenericTrap::G4GenericTrap ( __void__ & a )

Definition at line 148 of file G4GenericTrap.cc.

  : G4VSolid(a), halfCarTolerance(0.), fDz(0.), fVertices(),
    fMinBBoxVector(G4ThreeVector(0,0,0)), fMaxBBoxVector(G4ThreeVector(0,0,0))
{
  // Fake default constructor - sets only member data and allocates memory
  //                            for usage restricted to object persistency.
}

◆ G4GenericTrap() [3/3]

G4GenericTrap::G4GenericTrap ( const G4GenericTrap & rhs )

Definition at line 165 of file G4GenericTrap.cc.

  : G4VSolid(rhs),
    halfCarTolerance(rhs.halfCarTolerance),
    fDz(rhs.fDz), fVertices(rhs.fVertices),
    fIsTwisted(rhs.fIsTwisted),
    fMinBBoxVector(rhs.fMinBBoxVector), fMaxBBoxVector(rhs.fMaxBBoxVector),
    fVisSubdivisions(rhs.fVisSubdivisions),
    fSurfaceArea(rhs.fSurfaceArea), fCubicVolume(rhs.fCubicVolume) 
{
   for (auto i=0; i<4; ++i)  { fTwist[i] = rhs.fTwist[i]; }
#ifdef G4TESS_TEST
   if (rhs.fTessellatedSolid && !fIsTwisted )
   { fTessellatedSolid = CreateTessellatedSolid(); } 
#endif
}

References CreateTessellatedSolid(), fIsTwisted, fTessellatedSolid, and fTwist.

Member Function Documentation

◆ BoundingLimits()

void G4GenericTrap::BoundingLimits	(	G4ThreeVector &	pMin,
		G4ThreeVector &	pMax
	)		const

virtual

Reimplemented from G4VSolid.

Definition at line 1176 of file G4GenericTrap.cc.

{
  pMin = GetMinimumBBox();
  pMax = GetMaximumBBox();
 
  // Check correctness of the bounding box
  //
  if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
  {
    std::ostringstream message;
    message << "Bad bounding box (min >= max) for solid: "
            << GetName() << " !"
            << "\npMin = " << pMin
            << "\npMax = " << pMax;
    G4Exception("G4GenericTrap::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

References G4VSolid::DumpInfo(), G4Exception(), GetMaximumBBox(), GetMinimumBBox(), G4VSolid::GetName(), JustWarning, pMax, and pMin.

Referenced by CalculateExtent().

◆ CalculateClippedPolygonExtent()

void G4VSolid::CalculateClippedPolygonExtent	(	G4ThreeVectorList &	pPolygon,
		const G4VoxelLimits &	pVoxelLimit,
		const EAxis	pAxis,
		G4double &	pMin,
		G4double &	pMax
	)		const

protectedinherited

Definition at line 489 of file G4VSolid.cc.

{
  G4int noLeft,i;
  G4double component;
 
  ClipPolygon(pPolygon,pVoxelLimit,pAxis);
  noLeft = pPolygon.size();
 
  if ( noLeft )
  {
    for (i=0; i<noLeft; ++i)
    {
      component = pPolygon[i].operator()(pAxis);
 
      if (component < pMin)
      {
        pMin = component;
      }
      if (component > pMax)
      {
        pMax = component;
      }
    }
  }
}

References G4VSolid::ClipPolygon(), pMax, and pMin.

Referenced by G4VSolid::ClipBetweenSections(), and G4VSolid::ClipCrossSection().

◆ CalculateExtent()

G4bool G4GenericTrap::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pmin,
		G4double &	pmax
	)		const

virtual

Implements G4VSolid.

Definition at line 1200 of file G4GenericTrap.cc.

{
  G4ThreeVector bmin, bmax;
  G4bool exist;
 
  // Check bounding box (bbox)
  //
  BoundingLimits(bmin,bmax);
  G4BoundingEnvelope bbox(bmin,bmax);
#ifdef G4BBOX_EXTENT
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
#endif
  if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
  {
    return exist = (pMin < pMax) ? true : false;
  }
 
  // Set bounding envelope (benv) and calculate extent
  //
  // To build the bounding envelope with plane faces each side face of
  // the trapezoid is subdivided in triangles. Subdivision is done by
  // duplication of vertices in the bases in a way that the envelope be
  // a convex polyhedron (some faces of the envelope can be degenerate)
  //
  G4double dz = GetZHalfLength();
  G4ThreeVectorList baseA(8), baseB(8);
  for (G4int i=0; i<4; ++i)
  {
    G4TwoVector va = GetVertex(i);
    G4TwoVector vb = GetVertex(i+4);
    baseA[2*i].set(va.x(),va.y(),-dz);
    baseB[2*i].set(vb.x(),vb.y(), dz);
  }
  for (G4int i=0; i<4; ++i)
  {
    G4int k1=2*i, k2=(2*i+2)%8;
    G4double ax = (baseA[k2].x()-baseA[k1].x());
    G4double ay = (baseA[k2].y()-baseA[k1].y());
    G4double bx = (baseB[k2].x()-baseB[k1].x());
    G4double by = (baseB[k2].y()-baseB[k1].y());
    G4double znorm = ax*by - ay*bx;
    baseA[k1+1] = (znorm < 0.0) ? baseA[k2] : baseA[k1];
    baseB[k1+1] = (znorm < 0.0) ? baseB[k1] : baseB[k2];
  }
 
  std::vector<const G4ThreeVectorList *> polygons(2);
  polygons[0] = &baseA;
  polygons[1] = &baseB;
 
  G4BoundingEnvelope benv(bmin,bmax,polygons);
  exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
  return exist;
}

References G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), BoundingLimits(), G4BoundingEnvelope::CalculateExtent(), GetVertex(), GetZHalfLength(), pMax, pMin, CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

◆ CheckOrder()

G4bool G4GenericTrap::CheckOrder ( const std::vector< G4TwoVector > & vertices ) const

private

Definition at line 1560 of file G4GenericTrap.cc.

{
  // Test if the vertices are in a clockwise order, if not reorder them.
  // Also test if they're well defined without crossing opposite segments
 
  G4bool clockwise_order=true;
  G4double sum1 = 0.;
  G4double sum2 = 0.;
  G4int j;
 
  for (G4int i=0; i<4; ++i)
  {
    j = (i+1)%4;
    sum1 += vertices[i].x()*vertices[j].y() - vertices[j].x()*vertices[i].y();
    sum2 += vertices[i+4].x()*vertices[j+4].y()
          - vertices[j+4].x()*vertices[i+4].y();
  }
  if (sum1*sum2 < -fgkTolerance)
  {
     std::ostringstream message;
     message << "Lower/upper faces defined with opposite clockwise - "
             << GetName();
     G4Exception("G4GenericTrap::CheckOrder()", "GeomSolids0002",
                FatalException, message);
   }
   
   if ((sum1 > 0.)||(sum2 > 0.))
   {
     std::ostringstream message;
     message << "Vertices must be defined in clockwise XY planes - "
             << GetName();
     G4Exception("G4GenericTrap::CheckOrder()", "GeomSolids1001",
                 JustWarning,message, "Re-ordering...");
     clockwise_order = false;
   }
 
   // Check for illegal crossings
   //
   G4bool illegal_cross = false;
   illegal_cross = IsSegCrossingZ(vertices[0],vertices[4],
                                  vertices[1],vertices[5]);
     
   if (!illegal_cross)
   {
     illegal_cross = IsSegCrossingZ(vertices[2],vertices[6],
                                    vertices[3],vertices[7]);
   }
   // +/- dZ planes
   if (!illegal_cross)
   {
     illegal_cross = IsSegCrossing(vertices[0],vertices[1],
                                   vertices[2],vertices[3]);
   }
   if (!illegal_cross)
   {
     illegal_cross = IsSegCrossing(vertices[0],vertices[3],
                                   vertices[1],vertices[2]);
   }
   if (!illegal_cross)
   {
     illegal_cross = IsSegCrossing(vertices[4],vertices[5],
                                   vertices[6],vertices[7]);
   }
   if (!illegal_cross)
   {
     illegal_cross = IsSegCrossing(vertices[4],vertices[7],
                                   vertices[5],vertices[6]);
   }
 
   if (illegal_cross)
   {
      std::ostringstream message;
      message << "Malformed polygone with opposite sides - " << GetName();
      G4Exception("G4GenericTrap::CheckOrderAndSetup()",
                  "GeomSolids0002", FatalException, message);
   }
   return clockwise_order;
}

References FatalException, fgkTolerance, G4Exception(), G4VSolid::GetName(), IsSegCrossing(), IsSegCrossingZ(), and JustWarning.

Referenced by G4GenericTrap().

◆ ClipBetweenSections()

void G4VSolid::ClipBetweenSections	(	G4ThreeVectorList *	pVertices,
		const G4int	pSectionIndex,
		const G4VoxelLimits &	pVoxelLimit,
		const EAxis	pAxis,
		G4double &	pMin,
		G4double &	pMax
	)		const

protectedinherited

Definition at line 444 of file G4VSolid.cc.

{
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

References G4VSolid::CalculateClippedPolygonExtent(), pMax, and pMin.

◆ ClipCrossSection()

void G4VSolid::ClipCrossSection	(	G4ThreeVectorList *	pVertices,
		const G4int	pSectionIndex,
		const G4VoxelLimits &	pVoxelLimit,
		const EAxis	pAxis,
		G4double &	pMin,
		G4double &	pMax
	)		const

protectedinherited

Definition at line 414 of file G4VSolid.cc.

{
 
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

References G4VSolid::CalculateClippedPolygonExtent(), pMax, and pMin.

◆ ClipPolygon()

void G4VSolid::ClipPolygon	(	G4ThreeVectorList &	pPolygon,
		const G4VoxelLimits &	pVoxelLimit,
		const EAxis	pAxis
	)		const

protectedinherited

Definition at line 539 of file G4VSolid.cc.

{
  G4ThreeVectorList outputPolygon;
 
  if ( pVoxelLimit.IsLimited() )
  {
    if (pVoxelLimit.IsXLimited() ) // && pAxis != kXAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kXAxis,pVoxelLimit.GetMinXExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kXAxis,-kInfinity,pVoxelLimit.GetMaxXExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( !pPolygon.size() )       return;
      else                          outputPolygon.clear();
    }
    if ( pVoxelLimit.IsYLimited() ) // && pAxis != kYAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kYAxis,pVoxelLimit.GetMinYExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kYAxis,-kInfinity,pVoxelLimit.GetMaxYExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( !pPolygon.size() )       return;
      else                          outputPolygon.clear();
    }
    if ( pVoxelLimit.IsZLimited() ) // && pAxis != kZAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kZAxis,pVoxelLimit.GetMinZExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kZAxis,-kInfinity,pVoxelLimit.GetMaxZExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      // Return after final clip - no cleanup
    }
  }
}

References G4VoxelLimits::AddLimit(), G4VSolid::ClipPolygonToSimpleLimits(), G4VoxelLimits::GetMaxXExtent(), G4VoxelLimits::GetMaxYExtent(), G4VoxelLimits::GetMaxZExtent(), G4VoxelLimits::GetMinXExtent(), G4VoxelLimits::GetMinYExtent(), G4VoxelLimits::GetMinZExtent(), G4VoxelLimits::IsLimited(), G4VoxelLimits::IsXLimited(), G4VoxelLimits::IsYLimited(), G4VoxelLimits::IsZLimited(), kInfinity, kXAxis, kYAxis, and kZAxis.

Referenced by G4VSolid::CalculateClippedPolygonExtent().

◆ ClipPolygonToSimpleLimits()

void G4VSolid::ClipPolygonToSimpleLimits	(	G4ThreeVectorList &	pPolygon,
		G4ThreeVectorList &	outputPolygon,
		const G4VoxelLimits &	pVoxelLimit
	)		const

privateinherited

Definition at line 612 of file G4VSolid.cc.

{
  G4int i;
  G4int noVertices=pPolygon.size();
  G4ThreeVector vEnd,vStart;
 
  for (i = 0 ; i < noVertices ; ++i )
  {
    vStart = pPolygon[i];
    if ( i == noVertices-1 )    vEnd = pPolygon[0];
    else                        vEnd = pPolygon[i+1];
 
    if ( pVoxelLimit.Inside(vStart) )
    {
      if (pVoxelLimit.Inside(vEnd))
      {
        // vStart and vEnd inside -> output end point
        //
        outputPolygon.push_back(vEnd);
      }
      else
      {
        // vStart inside, vEnd outside -> output crossing point
        //
        pVoxelLimit.ClipToLimits(vStart,vEnd);
        outputPolygon.push_back(vEnd);
      }
    }
    else
    {
      if (pVoxelLimit.Inside(vEnd))
      {
        // vStart outside, vEnd inside -> output inside section
        //
        pVoxelLimit.ClipToLimits(vStart,vEnd);
        outputPolygon.push_back(vStart);
        outputPolygon.push_back(vEnd);
      }
      else  // Both point outside -> no output
      {
        // outputPolygon.push_back(vStart);
        // outputPolygon.push_back(vEnd);
      }
    }
  }
}

References G4VoxelLimits::ClipToLimits(), and G4VoxelLimits::Inside().

Referenced by G4VSolid::ClipPolygon().

◆ Clone()

G4VSolid * G4GenericTrap::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1266 of file G4GenericTrap.cc.

{
  return new G4GenericTrap(*this);
}

References G4GenericTrap().

◆ ComputeBBox()

void G4GenericTrap::ComputeBBox ( )

private

Definition at line 1959 of file G4GenericTrap.cc.

{
  // Computes bounding box for a shape.
 
  G4double minX, maxX, minY, maxY;
  minX = maxX = fVertices[0].x();
  minY = maxY = fVertices[0].y();
   
  for (G4int i=1; i< fgkNofVertices; i++)
  {
    if (minX>fVertices[i].x()) { minX=fVertices[i].x(); }
    if (maxX<fVertices[i].x()) { maxX=fVertices[i].x(); }
    if (minY>fVertices[i].y()) { minY=fVertices[i].y(); }
    if (maxY<fVertices[i].y()) { maxY=fVertices[i].y(); }
  }
  fMinBBoxVector = G4ThreeVector(minX,minY,-fDz);
  fMaxBBoxVector = G4ThreeVector(maxX,maxY, fDz);
}

References fDz, fgkNofVertices, fMaxBBoxVector, fMinBBoxVector, and fVertices.

Referenced by G4GenericTrap().

◆ ComputeDimensions()

void G4VSolid::ComputeDimensions	(	G4VPVParameterisation *	p,
		const G4int	n,
		const G4VPhysicalVolume *	pRep
	)

virtualinherited

Reimplemented in G4TwistedTubs, G4VTwistedFaceted, G4ReflectedSolid, G4DisplacedSolid, G4IntersectionSolid, G4ScaledSolid, G4SubtractionSolid, G4UnionSolid, G4Box, G4Cons, G4Orb, G4Para, G4Sphere, G4Torus, G4Trap, G4Trd, G4Tubs, G4Ellipsoid, G4Hype, G4Polycone, G4Polyhedra, and G4Tet.

Definition at line 137 of file G4VSolid.cc.

{
    std::ostringstream message;
    message << "Illegal call to G4VSolid::ComputeDimensions()" << G4endl
            << "Method not overloaded by derived class !";
    G4Exception("G4VSolid::ComputeDimensions()", "GeomMgt0003",
                FatalException, message);
}

References FatalException, G4endl, and G4Exception().

Referenced by G4SmartVoxelHeader::BuildNodes(), G4PVParameterised::CheckOverlaps(), G4VPrimitiveScorer::ComputeSolid(), G4ScoreSplittingProcess::CreateTouchableForSubStep(), G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4LogicalVolume::GetMass(), G4Navigator::GetMotherToDaughterTransform(), G4ITNavigator1::GetMotherToDaughterTransform(), G4ITNavigator2::GetMotherToDaughterTransform(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), G4PSSphereSurfaceFlux::ProcessHits(), G4PSVolumeFlux::ProcessHits(), G4Navigator::SetupHierarchy(), G4ITNavigator1::SetupHierarchy(), and G4ITNavigator2::SetupHierarchy().

◆ ComputeIsTwisted()

G4bool G4GenericTrap::ComputeIsTwisted ( )

private

Definition at line 1512 of file G4GenericTrap.cc.

{
  // Computes tangents of twist angles (angles between projections on XY plane 
  // of corresponding -dz +dz edges). 
 
  G4bool twisted = false;
  G4double dx1, dy1, dx2, dy2;
  G4int nv = fgkNofVertices/2;
 
  for ( G4int i=0; i<4; ++i )
  {
    dx1 = fVertices[(i+1)%nv].x()-fVertices[i].x();
    dy1 = fVertices[(i+1)%nv].y()-fVertices[i].y();
    if ( (dx1 == 0) && (dy1 == 0) ) { continue; }
 
    dx2 = fVertices[nv+(i+1)%nv].x()-fVertices[nv+i].x();
    dy2 = fVertices[nv+(i+1)%nv].y()-fVertices[nv+i].y();
 
    if ( dx2 == 0 && dy2 == 0 ) { continue; }
    G4double twist_angle = std::fabs(dy1*dx2 - dx1*dy2);        
    if ( twist_angle < fgkTolerance ) { continue; }
    twisted = true;
    SetTwistAngle(i,twist_angle);
 
    // Check on big angles, potentially navigation problem
 
    twist_angle = std::acos( (dx1*dx2 + dy1*dy2)
                           / (std::sqrt(dx1*dx1+dy1*dy1)
                             * std::sqrt(dx2*dx2+dy2*dy2)) );
   
    if ( std::fabs(twist_angle) > 0.5*pi+kCarTolerance )
    {
      std::ostringstream message;
      message << "Twisted Angle is bigger than 90 degrees - " << GetName()
              << G4endl
              << "     Potential problem of malformed Solid !" << G4endl
              << "     TwistANGLE = " << twist_angle
              << "*rad  for lateral plane N= " << i;
      G4Exception("G4GenericTrap::ComputeIsTwisted()", "GeomSolids1002",
                  JustWarning, message);
    }
  }
 
  return twisted;
}

References fgkNofVertices, fgkTolerance, fVertices, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, G4VSolid::kCarTolerance, pi, and SetTwistAngle().

Referenced by G4GenericTrap().

◆ CreatePolyhedron()

G4Polyhedron * G4GenericTrap::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 2041 of file G4GenericTrap.cc.

{
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid != nullptr )
  { 
    return fTessellatedSolid->CreatePolyhedron();
  }  
#endif 
  
  // Approximation of Twisted Side
  // Construct extra Points, if Twisted Side
  //
  G4PolyhedronArbitrary* polyhedron;
  size_t nVertices, nFacets;
 
  G4int subdivisions=0;
  G4int i;
  if(fIsTwisted)
  {
    if ( GetVisSubdivisions()!= 0 )
    {
      subdivisions=GetVisSubdivisions();
    }
    else
    {
      // Estimation of Number of Subdivisions for smooth visualisation
      //
      G4double maxTwist=0.;
      for(i=0; i<4; ++i)
      {
        if(GetTwistAngle(i)>maxTwist) { maxTwist=GetTwistAngle(i); }
      }
 
      // Computes bounding vectors for the shape
      //
      G4double Dx,Dy;
      G4ThreeVector minVec = GetMinimumBBox();
      G4ThreeVector maxVec = GetMaximumBBox();
      Dx = 0.5*(maxVec.x()- minVec.y());
      Dy = 0.5*(maxVec.y()- minVec.y());
      if (Dy > Dx)  { Dx=Dy; }
    
      subdivisions=8*G4int(maxTwist/(Dx*Dx*Dx)*fDz);
      if (subdivisions<4)  { subdivisions=4; }
      if (subdivisions>30) { subdivisions=30; }
    }
  }
  G4int sub4=4*subdivisions;
  nVertices = 8+subdivisions*4;
  nFacets = 6+subdivisions*4;
  G4double cf=1./(subdivisions+1);
  polyhedron = new G4PolyhedronArbitrary (nVertices, nFacets);
 
  // Add Vertex
  //
  for (i=0; i<4; ++i)
  {
    polyhedron->AddVertex(G4ThreeVector(fVertices[i].x(),
                                        fVertices[i].y(),-fDz));
  }
  for( i=0; i<subdivisions; ++i)
  {
    for(G4int j=0;j<4;j++)
    {
      G4TwoVector u=fVertices[j]+cf*(i+1)*( fVertices[j+4]-fVertices[j]);
      polyhedron->AddVertex(G4ThreeVector(u.x(),u.y(),-fDz+cf*2*fDz*(i+1)));
    }    
  }
  for (i=4; i<8; ++i)
  {
    polyhedron->AddVertex(G4ThreeVector(fVertices[i].x(),
                                        fVertices[i].y(),fDz));
  }
 
  // Add Facets
  //
  polyhedron->AddFacet(1,4,3,2);  //Z-plane
  for (i=0; i<subdivisions+1; ++i)
  {
    G4int is=i*4;
    polyhedron->AddFacet(5+is,8+is,4+is,1+is);
    polyhedron->AddFacet(8+is,7+is,3+is,4+is);
    polyhedron->AddFacet(7+is,6+is,2+is,3+is);
    polyhedron->AddFacet(6+is,5+is,1+is,2+is); 
  }
  polyhedron->AddFacet(5+sub4,6+sub4,7+sub4,8+sub4);  //Z-plane
 
  polyhedron->SetReferences();
  polyhedron->InvertFacets();
 
  return (G4Polyhedron*) polyhedron;
}

References G4PolyhedronArbitrary::AddFacet(), G4PolyhedronArbitrary::AddVertex(), G4TessellatedSolid::CreatePolyhedron(), fDz, fIsTwisted, fTessellatedSolid, fVertices, GetMaximumBBox(), GetMinimumBBox(), GetTwistAngle(), GetVisSubdivisions(), G4PolyhedronArbitrary::InvertFacets(), G4PolyhedronArbitrary::SetReferences(), CLHEP::Hep3Vector::x(), CLHEP::Hep2Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep2Vector::y().

Referenced by GetPolyhedron().

◆ CreateTessellatedSolid()

G4TessellatedSolid * G4GenericTrap::CreateTessellatedSolid ( ) const

private

Definition at line 1898 of file G4GenericTrap.cc.

{
  // 3D vertices
  //
  G4int nv = fgkNofVertices/2;
  std::vector<G4ThreeVector> downVertices;
  for ( G4int i=0; i<nv; ++i )
  { 
    downVertices.push_back(G4ThreeVector(fVertices[i].x(),
                                         fVertices[i].y(), -fDz));
  }
 
  std::vector<G4ThreeVector> upVertices;
  for ( G4int i=nv; i<2*nv; ++i )
  { 
    upVertices.push_back(G4ThreeVector(fVertices[i].x(),
                                       fVertices[i].y(), fDz));
  }
                                         
  // Reorder vertices if they are not ordered anti-clock wise
  //
  G4ThreeVector cross 
    = (downVertices[1]-downVertices[0]).cross(downVertices[2]-downVertices[1]);
   G4ThreeVector cross1 
    = (upVertices[1]-upVertices[0]).cross(upVertices[2]-upVertices[1]);
  if ( (cross.z() > 0.0) || (cross1.z() > 0.0) )
  {
    ReorderVertices(downVertices);
    ReorderVertices(upVertices);
  }
    
  G4TessellatedSolid* tessellatedSolid = new G4TessellatedSolid(GetName());
  
  G4VFacet* facet = 0;
  facet = MakeDownFacet(downVertices, 0, 1, 2);
  if (facet)  { tessellatedSolid->AddFacet( facet ); }
  facet = MakeDownFacet(downVertices, 0, 2, 3);
  if (facet)  { tessellatedSolid->AddFacet( facet ); }
  facet = MakeUpFacet(upVertices, 0, 2, 1);
  if (facet)  { tessellatedSolid->AddFacet( facet ); }
  facet = MakeUpFacet(upVertices, 0, 3, 2);
  if (facet)  { tessellatedSolid->AddFacet( facet ); }
 
  // The quadrangular sides
  //
  for ( G4int i = 0; i < nv; ++i )
  {
    G4int j = (i+1) % nv;
    facet = MakeSideFacet(downVertices[j], downVertices[i], 
                          upVertices[i], upVertices[j]);
 
    if ( facet )  { tessellatedSolid->AddFacet( facet ); }
  }
 
  tessellatedSolid->SetSolidClosed(true);
 
  return tessellatedSolid;
}  

References G4TessellatedSolid::AddFacet(), fDz, fgkNofVertices, fVertices, G4VSolid::GetName(), MakeDownFacet(), MakeSideFacet(), MakeUpFacet(), ReorderVertices(), G4TessellatedSolid::SetSolidClosed(), and CLHEP::Hep3Vector::z().

Referenced by G4GenericTrap(), and operator=().

◆ DescribeYourselfTo()

void G4GenericTrap::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 2006 of file G4GenericTrap.cc.

{
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  { 
    return fTessellatedSolid->DescribeYourselfTo(scene);
  }
#endif  
  
  scene.AddSolid(*this);
}

References G4VGraphicsScene::AddSolid(), G4TessellatedSolid::DescribeYourselfTo(), and fTessellatedSolid.

◆ DistanceToIn() [1/2]

G4double G4GenericTrap::DistanceToIn ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 800 of file G4GenericTrap.cc.

{
  // Computes the closest distance from given point to this shape
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  {
    return fTessellatedSolid->DistanceToIn(p);
  }  
#endif
 
  G4double safz = std::fabs(p.z())-fDz;
  if(safz<0) { safz=0; }
 
  G4int iseg;
  G4double safe  = safz;
  G4double safxy = safz;
 
  for (iseg=0; iseg<4; ++iseg)
  { 
    safxy = SafetyToFace(p,iseg);
    if (safxy>safe)  { safe=safxy; }
  }
 
  return safe;
}

References G4TessellatedSolid::DistanceToIn(), fDz, fTessellatedSolid, SafetyToFace(), and CLHEP::Hep3Vector::z().

◆ DistanceToIn() [2/2]

G4double G4GenericTrap::DistanceToIn	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v
	)		const

virtual

Implements G4VSolid.

Definition at line 732 of file G4GenericTrap.cc.

{
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  { 
    return fTessellatedSolid->DistanceToIn(p, v);
  }  
#endif
    
  G4double dist[5];
  G4ThreeVector n;
 
  // Check lateral faces
  //
  G4int i;
  for (i=0; i<4; ++i)
  {
    dist[i]=DistToPlane(p, v, i);  
  }
 
  // Check Z planes
  //
  dist[4]=kInfinity;
  if (std::fabs(p.z())>fDz-halfCarTolerance)
  {
    if (v.z())
    {
      G4ThreeVector pt;
      if (p.z()>0)
      {
        dist[4] = (fDz-p.z())/v.z();
      }
      else
      {   
        dist[4] = (-fDz-p.z())/v.z();
      }   
      if (dist[4]<-halfCarTolerance)
      {
        dist[4]=kInfinity;
      }
      else
      {
        if(dist[4]<halfCarTolerance)
        {
          if(p.z()>0)  { n=G4ThreeVector(0,0,1); }
          else         { n=G4ThreeVector(0,0,-1); }
          if (n.dot(v)<0) { dist[4]=0.; }
          else            { dist[4]=kInfinity; }
        }
        pt=p+dist[4]*v;
        if (Inside(pt)==kOutside)  { dist[4]=kInfinity; }
      }
    }
  }   
  G4double distmin = dist[0];
  for (i=1; i<5 ; ++i)
  {
    if (dist[i] < distmin)  { distmin = dist[i]; }
  }
 
  if (distmin<halfCarTolerance)  { distmin=0.; }
 
  return distmin;
}    

References G4TessellatedSolid::DistanceToIn(), DistToPlane(), fDz, fTessellatedSolid, halfCarTolerance, Inside(), kInfinity, kOutside, CLHEP::detail::n, and CLHEP::Hep3Vector::z().

◆ DistanceToOut() [1/2]

G4double G4GenericTrap::DistanceToOut ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 1149 of file G4GenericTrap.cc.

{
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  { 
    return fTessellatedSolid->DistanceToOut(p);
  }  
#endif
 
  G4double safz = fDz-std::fabs(p.z());
  if (safz<0) { safz = 0; }
 
  G4double safe  = safz;
  G4double safxy = safz;
 
  for (G4int iseg=0; iseg<4; ++iseg)
  { 
    safxy = std::fabs(SafetyToFace(p,iseg));
    if (safxy < safe)  { safe = safxy; }
  }
 
  return safe;
}    

References G4TessellatedSolid::DistanceToOut(), fDz, fTessellatedSolid, SafetyToFace(), and CLHEP::Hep3Vector::z().

◆ DistanceToOut() [2/2]

G4double G4GenericTrap::DistanceToOut	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4bool	calcNorm = `false`,
		G4bool *	validNorm = `nullptr`,
		G4ThreeVector *	n = `nullptr`
	)		const

virtual

Implements G4VSolid.

Definition at line 904 of file G4GenericTrap.cc.

{
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  { 
    return fTessellatedSolid->DistanceToOut(p, v, calcNorm, validNorm, n);
  }
#endif
 
  G4double distmin;
  G4bool lateral_cross = false;
  ESide side = kUndef;
 
  if (calcNorm)  { *validNorm = true; } // All normals are valid
 
  if (v.z() < 0)
  {
    distmin=(-fDz-p.z())/v.z();
    if (calcNorm) { side=kMZ; *n=G4ThreeVector(0,0,-1); }
  }
  else
  {
    if (v.z() > 0)
    { 
      distmin = (fDz-p.z())/v.z(); 
      if (calcNorm) { side=kPZ; *n=G4ThreeVector(0,0,1); } 
    }
    else            { distmin = kInfinity; }
  }      
 
  G4double dz2 =0.5/fDz;
  G4double xa,xb,xc,xd;
  G4double ya,yb,yc,yd;
 
  for (G4int ipl=0; ipl<4; ++ipl)
  {
    G4int j = (ipl+1)%4;
    xa=fVertices[ipl].x();
    ya=fVertices[ipl].y();
    xb=fVertices[ipl+4].x();
    yb=fVertices[ipl+4].y();
    xc=fVertices[j].x();
    yc=fVertices[j].y();
    xd=fVertices[4+j].x();
    yd=fVertices[4+j].y();
 
    if ( ((std::fabs(xb-xd)+std::fabs(yb-yd))<halfCarTolerance)
      || ((std::fabs(xa-xc)+std::fabs(ya-yc))<halfCarTolerance) )
    {
      G4double q=DistToTriangle(p,v,ipl) ;
      if ( (q>=0) && (q<distmin) )
      {
        distmin=q;
        lateral_cross=true;
        side=ESide(ipl+1);
      }
      continue;
    }
    G4double tx1 =dz2*(xb-xa);
    G4double ty1 =dz2*(yb-ya);
    G4double tx2 =dz2*(xd-xc);
    G4double ty2 =dz2*(yd-yc);
    G4double dzp =fDz+p.z();
    G4double xs1 =xa+tx1*dzp;
    G4double ys1 =ya+ty1*dzp;
    G4double xs2 =xc+tx2*dzp;
    G4double ys2 =yc+ty2*dzp;
    G4double dxs =xs2-xs1;
    G4double dys =ys2-ys1;
    G4double dtx =tx2-tx1;
    G4double dty =ty2-ty1;
    G4double a = (dtx*v.y()-dty*v.x()+(tx1*ty2-tx2*ty1)*v.z())*v.z();
    G4double b = dxs*v.y()-dys*v.x()+(dtx*p.y()-dty*p.x()+ty2*xs1-ty1*xs2
               + tx1*ys2-tx2*ys1)*v.z();
    G4double c=dxs*p.y()-dys*p.x()+xs1*ys2-xs2*ys1;
    G4double q=kInfinity;
 
    if (std::fabs(a) < kCarTolerance)
    {           
      if (std::fabs(b) < kCarTolerance) { continue; }
      q=-c/b;
         
      // Check for Point on the Surface
      //
      if ((q > -halfCarTolerance) && (q < distmin))
      {
        if (q < halfCarTolerance)
        {
          if (NormalToPlane(p,ipl).dot(v)<0.)  { continue; }
        }
        distmin =q;
        lateral_cross=true;
        side=ESide(ipl+1);
      }   
      continue;
    }
    G4double d=b*b-4*a*c;
    if (d >= 0.)
    {
      if (a > 0)  { q=0.5*(-b-std::sqrt(d))/a; }
      else        { q=0.5*(-b+std::sqrt(d))/a; }
 
      // Check for Point on the Surface
      //
      if (q > -halfCarTolerance )
      {
        if (q < distmin)
        {
          if(q < halfCarTolerance)
          {
            if (NormalToPlane(p,ipl).dot(v)<0.)  // Check second root
            {
              if (a > 0)  { q=0.5*(-b+std::sqrt(d))/a; }
              else        { q=0.5*(-b-std::sqrt(d))/a; }
              if (( q > halfCarTolerance) && (q < distmin))
              {
                distmin=q;
                lateral_cross = true;
                side=ESide(ipl+1);
              }
              continue;
            }
          }
          distmin = q;
          lateral_cross = true;
          side=ESide(ipl+1);
        }
      }
      else
      {
        if (a > 0)  { q=0.5*(-b+std::sqrt(d))/a; }
        else        { q=0.5*(-b-std::sqrt(d))/a; }
 
        // Check for Point on the Surface
        //
        if ((q > -halfCarTolerance) && (q < distmin))
        {
          if (q < halfCarTolerance)
          {
            if (NormalToPlane(p,ipl).dot(v)<0.)  // Check second root
            {
              if (a > 0)  { q=0.5*(-b-std::sqrt(d))/a; }
              else        { q=0.5*(-b+std::sqrt(d))/a; }
              if ( ( q > halfCarTolerance) && (q < distmin) )
              {
                distmin=q;
                lateral_cross = true;
                side=ESide(ipl+1);
              }
              continue;
            }  
          }
          distmin =q;
          lateral_cross = true;
          side=ESide(ipl+1);
        }   
      }
    }
  }
  if (!lateral_cross)  // Make sure that track crosses the top or bottom
  {
    if (distmin >= kInfinity)  { distmin=kCarTolerance; }
    G4ThreeVector pt=p+distmin*v;
    
    // Check if propagated point is in the polygon
    //
    G4int i=0;
    if (v.z()>0.) { i=4; }
    std::vector<G4TwoVector> xy;
    for ( G4int j=0; j<4; j++)  { xy.push_back(fVertices[i+j]); }
 
    // Check Inside
    //
    if (InsidePolygone(pt,xy)==kOutside)
    { 
      if(calcNorm)
      {
        if (v.z()>0) {side= kPZ; *n = G4ThreeVector(0,0,1);}
        else         { side=kMZ; *n = G4ThreeVector(0,0,-1);}
      } 
      return 0.;
    }
    else
    {
      if(v.z()>0) {side=kPZ;}
      else        {side=kMZ;}
    }
  }
 
  if (calcNorm)
  {
    G4ThreeVector pt=p+v*distmin;     
    switch (side)
    {
      case kXY0:
        *n=NormalToPlane(pt,0);
        break;
      case kXY1:
        *n=NormalToPlane(pt,1);
        break;
      case kXY2:
        *n=NormalToPlane(pt,2);
        break;
      case kXY3:
        *n=NormalToPlane(pt,3);
        break;
      case kPZ:
        *n=G4ThreeVector(0,0,1);
        break;
      case kMZ:
        *n=G4ThreeVector(0,0,-1);
        break;
      default:
        DumpInfo();
        std::ostringstream message;
        G4int oldprc = message.precision(16);
        message << "Undefined side for valid surface normal to solid." << G4endl
                << "Position:" << G4endl
                << "  p.x() = "   << p.x()/mm << " mm" << G4endl
                << "  p.y() = "   << p.y()/mm << " mm" << G4endl
                << "  p.z() = "   << p.z()/mm << " mm" << G4endl
                << "Direction:" << G4endl
                << "  v.x() = "   << v.x() << G4endl
                << "  v.y() = "   << v.y() << G4endl
                << "  v.z() = "   << v.z() << G4endl
                << "Proposed distance :" << G4endl
                << "  distmin = " << distmin/mm << " mm";
        message.precision(oldprc);
        G4Exception("G4GenericTrap::DistanceToOut(p,v,..)",
                    "GeomSolids1002", JustWarning, message);
        break;
     }
  }
 
  if (distmin<halfCarTolerance)  { distmin=0.; }
 
  return distmin;
}    

References G4TessellatedSolid::DistanceToOut(), DistToTriangle(), CLHEP::Hep3Vector::dot(), G4VSolid::DumpInfo(), fDz, fTessellatedSolid, fVertices, G4endl, G4Exception(), halfCarTolerance, InsidePolygone(), JustWarning, G4VSolid::kCarTolerance, kInfinity, kMZ, kOutside, kPZ, kUndef, kXY0, kXY1, kXY2, kXY3, mm, CLHEP::detail::n, NormalToPlane(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ DistToPlane()

G4double G4GenericTrap::DistToPlane	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4int	ipl
	)		const

private

Definition at line 574 of file G4GenericTrap.cc.

{
  // Computes distance to plane ipl :
  // ipl=0 : points 0,4,1,5
  // ipl=1 : points 1,5,2,6
  // ipl=2 : points 2,6,3,7
  // ipl=3 : points 3,7,0,4
 
  G4double xa,xb,xc,xd,ya,yb,yc,yd;
  
  G4int j = (ipl+1)%4;
  
  xa=fVertices[ipl].x();
  ya=fVertices[ipl].y();
  xb=fVertices[ipl+4].x();
  yb=fVertices[ipl+4].y();
  xc=fVertices[j].x();
  yc=fVertices[j].y();
  xd=fVertices[4+j].x();
  yd=fVertices[4+j].y();
 
  G4double dz2 =0.5/fDz;
  G4double tx1 =dz2*(xb-xa);
  G4double ty1 =dz2*(yb-ya);
  G4double tx2 =dz2*(xd-xc);
  G4double ty2 =dz2*(yd-yc);
  G4double dzp =fDz+p.z();
  G4double xs1 =xa+tx1*dzp;
  G4double ys1 =ya+ty1*dzp;
  G4double xs2 =xc+tx2*dzp;
  G4double ys2 =yc+ty2*dzp;
  G4double dxs =xs2-xs1;
  G4double dys =ys2-ys1;
  G4double dtx =tx2-tx1;
  G4double dty =ty2-ty1;
 
  G4double a = (dtx*v.y()-dty*v.x()+(tx1*ty2-tx2*ty1)*v.z())*v.z();
  G4double b = dxs*v.y()-dys*v.x()+(dtx*p.y()-dty*p.x()+ty2*xs1-ty1*xs2
             + tx1*ys2-tx2*ys1)*v.z();
  G4double c=dxs*p.y()-dys*p.x()+xs1*ys2-xs2*ys1;
  G4double q=kInfinity;
  G4double x1,x2,y1,y2,xp,yp,zi;
 
  if (std::fabs(a)<kCarTolerance)
  {           
    if (std::fabs(b)<kCarTolerance)  { return kInfinity; }
    q=-c/b;
 
    // Check if Point is on the Surface
 
    if (q>-halfCarTolerance)
    {
      if (q<halfCarTolerance)
      {
        if (NormalToPlane(p,ipl).dot(v)<=0)
          { if(Inside(p) != kOutside) { return 0.; } }
        else
          { return kInfinity; }
      }
 
      // Check the Intersection
      //
      zi=p.z()+q*v.z();
      if (std::fabs(zi)<fDz)
      {
        x1=xs1+tx1*v.z()*q;
        x2=xs2+tx2*v.z()*q;
        xp=p.x()+q*v.x();
        y1=ys1+ty1*v.z()*q;
        y2=ys2+ty2*v.z()*q;
        yp=p.y()+q*v.y();
        zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
        if (zi<=halfCarTolerance)  { return q; }
      }
    }
    return kInfinity;
  }      
  G4double d=b*b-4*a*c;
  if (d>=0)
  {
    if (a>0) { q=0.5*(-b-std::sqrt(d))/a; }
    else     { q=0.5*(-b+std::sqrt(d))/a; }
 
    // Check if Point is on the Surface
    //
    if (q>-halfCarTolerance)
    {
      if(q<halfCarTolerance)
      {
        if (NormalToPlane(p,ipl).dot(v)<=0)
        {
          if(Inside(p)!= kOutside) { return 0.; }
        }
        else  // Check second root; return kInfinity
        {
          if (a>0) { q=0.5*(-b+std::sqrt(d))/a; }
          else     { q=0.5*(-b-std::sqrt(d))/a; }
          if (q<=halfCarTolerance) { return kInfinity; }
        }
      }
      // Check the Intersection
      //
      zi=p.z()+q*v.z();
      if (std::fabs(zi)<fDz)
      {
        x1=xs1+tx1*v.z()*q;
        x2=xs2+tx2*v.z()*q;
        xp=p.x()+q*v.x();
        y1=ys1+ty1*v.z()*q;
        y2=ys2+ty2*v.z()*q;
        yp=p.y()+q*v.y();
        zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
        if (zi<=halfCarTolerance)  { return q; }
      }
    }
    if (a>0)  { q=0.5*(-b+std::sqrt(d))/a; }
    else      { q=0.5*(-b-std::sqrt(d))/a; }
 
    // Check if Point is on the Surface
    //
    if (q>-halfCarTolerance)
    {
      if(q<halfCarTolerance)
      {
        if (NormalToPlane(p,ipl).dot(v)<=0)
        {
          if(Inside(p) != kOutside)  { return 0.; }
        }
        else   // Check second root; return kInfinity.
        {
          if (a>0) { q=0.5*(-b-std::sqrt(d))/a; }
          else     { q=0.5*(-b+std::sqrt(d))/a; }
          if (q<=halfCarTolerance)  { return kInfinity; }
        }
      }
      // Check the Intersection
      //
      zi=p.z()+q*v.z();
      if (std::fabs(zi)<fDz)
      {
        x1=xs1+tx1*v.z()*q;
        x2=xs2+tx2*v.z()*q;
        xp=p.x()+q*v.x();
        y1=ys1+ty1*v.z()*q;
        y2=ys2+ty2*v.z()*q;
        yp=p.y()+q*v.y();
        zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
        if (zi<=halfCarTolerance)  { return q; }
      }
    }
  }
  return kInfinity;
}      

References CLHEP::Hep3Vector::dot(), fDz, fVertices, halfCarTolerance, Inside(), G4VSolid::kCarTolerance, kInfinity, kOutside, NormalToPlane(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToIn().

◆ DistToTriangle()

G4double G4GenericTrap::DistToTriangle	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4int	ipl
	)		const

private

Definition at line 849 of file G4GenericTrap.cc.

{
  G4double xa=fVertices[ipl].x();
  G4double ya=fVertices[ipl].y();
  G4double xb=fVertices[ipl+4].x();
  G4double yb=fVertices[ipl+4].y();
  G4int j=(ipl+1)%4;
  G4double xc=fVertices[j].x();
  G4double yc=fVertices[j].y();
  G4double zab=2*fDz;
  G4double zac=0;
  
  if ( (std::fabs(xa-xc)+std::fabs(ya-yc)) < halfCarTolerance )
  {
    xc=fVertices[j+4].x();
    yc=fVertices[j+4].y();
    zac=2*fDz;
    zab=2*fDz;
 
    //Line case
    //
    if ( (std::fabs(xb-xc)+std::fabs(yb-yc)) < halfCarTolerance )
    {
      return kInfinity;
    }
  }
  G4double a=(yb-ya)*zac-(yc-ya)*zab;
  G4double b=(xc-xa)*zab-(xb-xa)*zac;
  G4double c=(xb-xa)*(yc-ya)-(xc-xa)*(yb-ya);
  G4double d=-xa*a-ya*b+fDz*c;
  G4double t=a*v.x()+b*v.y()+c*v.z();
 
  if (t!=0)
  {
    t=-(a*p.x()+b*p.y()+c*p.z()+d)/t;
  }
  if ( (t<halfCarTolerance) && (t>-halfCarTolerance) )
  {
    if (NormalToPlane(p,ipl).dot(v)<kCarTolerance)
    {
      t=kInfinity;
    }
    else
    {
      t=0;
    }
  }
  if (Inside(p+v*t) != kSurface)  { t=kInfinity; }
 
  return t;
} 

References CLHEP::Hep3Vector::dot(), fDz, fVertices, halfCarTolerance, Inside(), G4VSolid::kCarTolerance, kInfinity, kSurface, NormalToPlane(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToOut().

◆ DumpInfo()

void G4VSolid::DumpInfo ( ) const

inlineinherited

◆ EstimateCubicVolume()

G4double G4VSolid::EstimateCubicVolume	(	G4int	nStat,
		G4double	epsilon
	)		const

inherited

Definition at line 203 of file G4VSolid.cc.

{
  G4int iInside=0;
  G4double px,py,pz,minX,maxX,minY,maxY,minZ,maxZ,volume,halfepsilon;
  G4ThreeVector p;
  EInside in;
 
  // values needed for CalculateExtent signature
 
  G4VoxelLimits limit;                // Unlimited
  G4AffineTransform origin;
 
  // min max extents of pSolid along X,Y,Z
 
  CalculateExtent(kXAxis,limit,origin,minX,maxX);
  CalculateExtent(kYAxis,limit,origin,minY,maxY);
  CalculateExtent(kZAxis,limit,origin,minZ,maxZ);
 
  // limits
 
  if(nStat < 100)    nStat   = 100;
  if(epsilon > 0.01) epsilon = 0.01;
  halfepsilon = 0.5*epsilon;
 
  for(auto i = 0; i < nStat; ++i )
  {
    px = minX-halfepsilon+(maxX-minX+epsilon)*G4QuickRand();
    py = minY-halfepsilon+(maxY-minY+epsilon)*G4QuickRand();
    pz = minZ-halfepsilon+(maxZ-minZ+epsilon)*G4QuickRand();
    p  = G4ThreeVector(px,py,pz);
    in = Inside(p);
    if(in != kOutside) ++iInside;
  }
  volume = (maxX-minX+epsilon)*(maxY-minY+epsilon)
         * (maxZ-minZ+epsilon)*iInside/nStat;
  return volume;
}

References G4VSolid::CalculateExtent(), epsilon(), G4QuickRand(), G4VSolid::Inside(), kOutside, kXAxis, kYAxis, kZAxis, and maxZ.

Referenced by G4VSolid::GetCubicVolume(), G4BooleanSolid::GetCubicVolume(), and G4VCSGfaceted::GetCubicVolume().

◆ EstimateSurfaceArea()

G4double G4VSolid::EstimateSurfaceArea	(	G4int	nStat,
		G4double	ell
	)		const

inherited

Definition at line 265 of file G4VSolid.cc.

{
  static const G4double s2 = 1./std::sqrt(2.);
  static const G4double s3 = 1./std::sqrt(3.);
  static const G4ThreeVector directions[64] =
  {
    G4ThreeVector(  0,  0,  0), G4ThreeVector( -1,  0,  0), // (  ,  ,  ) ( -,  ,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,  ) (-+,  ,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,  ) ( -, -,  )
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,  ) (-+, -,  )
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,  ) ( -, +,  )
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,  ) (-+, +,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,  ) ( -,-+,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,  ) (-+,-+,  )
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,  , -) ( -,  , -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,  , -) (-+,  , -)
    G4ThreeVector(  0,-s2,-s2), G4ThreeVector(-s3,-s3,-s3), // (  , -, -) ( -, -, -)
    G4ThreeVector( s3,-s3,-s3), G4ThreeVector(  0,-s2,-s2), // ( +, -, -) (-+, -, -)
 
    G4ThreeVector(  0, s2,-s2), G4ThreeVector(-s3, s3,-s3), // (  , +, -) ( -, +, -)
    G4ThreeVector( s3, s3,-s3), G4ThreeVector(  0, s2,-s2), // ( +, +, -) (-+, +, -)
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,-+, -) ( -,-+, -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,-+, -) (-+,-+, -)
 
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,  , +) ( -,  , +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,  , +) (-+,  , +)
    G4ThreeVector(  0,-s2, s2), G4ThreeVector(-s3,-s3, s3), // (  , -, +) ( -, -, +)
    G4ThreeVector( s3,-s3, s3), G4ThreeVector(  0,-s2, s2), // ( +, -, +) (-+, -, +)
 
    G4ThreeVector(  0, s2, s2), G4ThreeVector(-s3, s3, s3), // (  , +, +) ( -, +, +)
    G4ThreeVector( s3, s3, s3), G4ThreeVector(  0, s2, s2), // ( +, +, +) (-+, +, +)
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,-+, +) ( -,-+, +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,-+, +) (-+,-+, +)
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector( -1,  0,  0), // (  ,  ,-+) ( -,  ,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,-+) (-+,  ,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,-+) ( -, -,-+)
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,-+) (-+, -,-+)
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,-+) ( -, +,-+)
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,-+) (-+, +,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,-+) ( -,-+,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,-+) (-+,-+,-+)
  };
 
  G4ThreeVector bmin, bmax;
  BoundingLimits(bmin, bmax);
 
  G4double dX = bmax.x() - bmin.x();
  G4double dY = bmax.y() - bmin.y();
  G4double dZ = bmax.z() - bmin.z();
 
  // Define statistics and shell thickness
  //
  G4int npoints = (nstat < 1000) ? 1000 : nstat;
  G4double coeff = 0.5 / std::cbrt(G4double(npoints));
  G4double eps = (ell > 0) ? ell : coeff * std::min(std::min(dX, dY), dZ);
  G4double del = 1.8 * eps; // shold be more than sqrt(3.)
 
  G4double minX = bmin.x() - eps;
  G4double minY = bmin.y() - eps;
  G4double minZ = bmin.z() - eps;
 
  G4double dd = 2. * eps;
  dX += dd;
  dY += dd;
  dZ += dd;
 
  // Calculate surface area
  //
  G4int icount = 0;
  for(auto i = 0; i < npoints; ++i)
  {
    G4double px = minX + dX*G4QuickRand();
    G4double py = minY + dY*G4QuickRand();
    G4double pz = minZ + dZ*G4QuickRand();
    G4ThreeVector p  = G4ThreeVector(px, py, pz);
    EInside in = Inside(p);
    G4double dist = 0;
    if (in == kInside)
    {
      if (DistanceToOut(p) >= eps) continue;
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kInside) icase += 1;
      if (Inside(G4ThreeVector(px+del, py, pz)) != kInside) icase += 2;
      if (Inside(G4ThreeVector(px, py-del, pz)) != kInside) icase += 4;
      if (Inside(G4ThreeVector(px, py+del, pz)) != kInside) icase += 8;
      if (Inside(G4ThreeVector(px, py, pz-del)) != kInside) icase += 16;
      if (Inside(G4ThreeVector(px, py, pz+del)) != kInside) icase += 32;
      if (icase == 0) continue;
      G4ThreeVector v = directions[icase];
      dist = DistanceToOut(p, v);
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= v.dot(n);
    }
    else if (in == kOutside)
    {
      if (DistanceToIn(p) >= eps) continue;
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kOutside) icase += 1;
      if (Inside(G4ThreeVector(px+del, py, pz)) != kOutside) icase += 2;
      if (Inside(G4ThreeVector(px, py-del, pz)) != kOutside) icase += 4;
      if (Inside(G4ThreeVector(px, py+del, pz)) != kOutside) icase += 8;
      if (Inside(G4ThreeVector(px, py, pz-del)) != kOutside) icase += 16;
      if (Inside(G4ThreeVector(px, py, pz+del)) != kOutside) icase += 32;
      if (icase == 0) continue;
      G4ThreeVector v = directions[icase];
      dist = DistanceToIn(p, v);
      if (dist == kInfinity) continue;
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= -(v.dot(n));
    }
    if (dist < eps) ++icount;
  }
  return dX*dY*dZ*icount/npoints/dd;
}

References G4VSolid::BoundingLimits(), G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), CLHEP::Hep3Vector::dot(), eps, G4QuickRand(), G4VSolid::Inside(), kInfinity, kInside, kOutside, G4INCL::Math::min(), CLHEP::detail::n, G4VSolid::SurfaceNormal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4VSolid::GetSurfaceArea(), G4MultiUnion::GetSurfaceArea(), and G4VCSGfaceted::GetSurfaceArea().

◆ GetConstituentSolid() [1/2]

G4VSolid * G4VSolid::GetConstituentSolid ( G4int no )

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 170 of file G4VSolid.cc.

171{ return nullptr; }

◆ GetConstituentSolid() [2/2]

const G4VSolid * G4VSolid::GetConstituentSolid ( G4int no ) const

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 167 of file G4VSolid.cc.

168{ return nullptr; }

Referenced by G4BooleanSolid::StackPolyhedron().

◆ GetCubicVolume()

G4double G4GenericTrap::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1423 of file G4GenericTrap.cc.

{
  if (fCubicVolume == 0.0)
  {
    if(fIsTwisted)
    {
      fCubicVolume = G4VSolid::GetCubicVolume();
    }
    else
    {
      // Set vertices
      G4ThreeVector v0(fVertices[0].x(),fVertices[0].y(),-fDz);
      G4ThreeVector v1(fVertices[1].x(),fVertices[1].y(),-fDz);
      G4ThreeVector v2(fVertices[2].x(),fVertices[2].y(),-fDz);
      G4ThreeVector v3(fVertices[3].x(),fVertices[3].y(),-fDz);
      G4ThreeVector v4(fVertices[4].x(),fVertices[4].y(), fDz);
      G4ThreeVector v5(fVertices[5].x(),fVertices[5].y(), fDz);
      G4ThreeVector v6(fVertices[6].x(),fVertices[6].y(), fDz);
      G4ThreeVector v7(fVertices[7].x(),fVertices[7].y(), fDz);
 
      // Find Cubic Volume
      fCubicVolume = GetFaceCubicVolume(v0,v1,v2,v3)  // -fDz plane
                   + GetFaceCubicVolume(v1,v0,v4,v5)  //  Lat plane
                   + GetFaceCubicVolume(v2,v1,v5,v6)  //  Lat plane
                   + GetFaceCubicVolume(v3,v2,v6,v7)  //  Lat plane
                   + GetFaceCubicVolume(v0,v3,v7,v4)  //  Lat plane
                   + GetFaceCubicVolume(v7,v6,v5,v4); // +fDz plane
    }
  }
  return fCubicVolume;
}

References fCubicVolume, fDz, fIsTwisted, fVertices, G4VSolid::GetCubicVolume(), and GetFaceCubicVolume().

◆ GetDisplacedSolidPtr() [1/2]

G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( )

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 176 of file G4VSolid.cc.

177{ return nullptr; }

◆ GetDisplacedSolidPtr() [2/2]

const G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( ) const

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 173 of file G4VSolid.cc.

174{ return nullptr; }

◆ GetEntityType()

G4GeometryType G4GenericTrap::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 1259 of file G4GenericTrap.cc.

{
  return G4String("G4GenericTrap");
}

Referenced by StreamInfo().

◆ GetExtent()

G4VisExtent G4GenericTrap::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 2021 of file G4GenericTrap.cc.

{
  // Computes bounding vectors for the shape
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid != nullptr )
  { 
    return fTessellatedSolid->GetExtent();
  } 
#endif
   
  G4ThreeVector minVec = GetMinimumBBox();
  G4ThreeVector maxVec = GetMaximumBBox();
  return G4VisExtent (minVec.x(), maxVec.x(),
                      minVec.y(), maxVec.y(),
                      minVec.z(), maxVec.z()); 
}    

References fTessellatedSolid, G4TessellatedSolid::GetExtent(), GetMaximumBBox(), GetMinimumBBox(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ GetFaceCubicVolume()

G4double G4GenericTrap::GetFaceCubicVolume	(	const G4ThreeVector &	p0,
		const G4ThreeVector &	p1,
		const G4ThreeVector &	p2,
		const G4ThreeVector &	p3
	)		const

private

Definition at line 1500 of file G4GenericTrap.cc.

{
  // Returns contribution of the facet to the volume of the solid.
  // Orientation of the facet is important, normal should point to outside. 
  return (((p2-p0).cross(p3-p1)).dot(p0)) / 6.;
}

Referenced by GetCubicVolume().

◆ GetFaceSurfaceArea()

G4double G4GenericTrap::GetFaceSurfaceArea	(	const G4ThreeVector &	p0,
		const G4ThreeVector &	p1,
		const G4ThreeVector &	p2,
		const G4ThreeVector &	p3
	)		const

private

Definition at line 1457 of file G4GenericTrap.cc.

{
  // Returns area of the facet 
  return 0.5*((p2-p0).cross(p3-p1)).mag();
}

Referenced by GetPointOnSurface(), and GetSurfaceArea().

◆ GetMaximumBBox()

G4ThreeVector G4GenericTrap::GetMaximumBBox ( ) const

inlineprivate

Referenced by BoundingLimits(), CreatePolyhedron(), and GetExtent().

◆ GetMinimumBBox()

G4ThreeVector G4GenericTrap::GetMinimumBBox ( ) const

inlineprivate

Referenced by BoundingLimits(), CreatePolyhedron(), and GetExtent().

◆ GetName()

G4String G4VSolid::GetName ( ) const

inlineinherited

◆ GetNofVertices()

G4int G4GenericTrap::GetNofVertices ( ) const

inline

◆ GetPointOnSurface()

G4ThreeVector G4GenericTrap::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1296 of file G4GenericTrap.cc.

{
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  { 
    return fTessellatedSolid->GetPointOnSurface();
  }  
#endif
 
  G4ThreeVector point;
  G4TwoVector u,v,w;
  G4double rand,area,chose,cf,lambda0,lambda1,alfa,beta,zp;
  G4int ipl,j;
 
  std::vector<G4ThreeVector> vertices;
  for (auto i=0; i<4; ++i)
  {
    vertices.push_back(G4ThreeVector(fVertices[i].x(),fVertices[i].y(),-fDz));
  }
  for (auto i=4; i<8; ++i)
  {
    vertices.push_back(G4ThreeVector(fVertices[i].x(),fVertices[i].y(),fDz));
  }
 
  // Surface Area of Planes(only estimation for twisted)
  //
  G4double Surface0=GetFaceSurfaceArea(vertices[0],vertices[1],
                                       vertices[2],vertices[3]);//-fDz plane 
  G4double Surface1=GetFaceSurfaceArea(vertices[0],vertices[1],
                                       vertices[5],vertices[4]);// Lat plane
  G4double Surface2=GetFaceSurfaceArea(vertices[3],vertices[0],
                                       vertices[4],vertices[7]);// Lat plane
  G4double Surface3=GetFaceSurfaceArea(vertices[2],vertices[3],
                                       vertices[7],vertices[6]);// Lat plane
  G4double Surface4=GetFaceSurfaceArea(vertices[2],vertices[1],
                                       vertices[5],vertices[6]);// Lat plane
  G4double Surface5=GetFaceSurfaceArea(vertices[4],vertices[5],
                                       vertices[6],vertices[7]);// fDz plane
  rand = G4UniformRand();
  area = Surface0+Surface1+Surface2+Surface3+Surface4+Surface5;
  chose = rand*area;
 
  if ( ( chose < Surface0)
    || ( chose > (Surface0+Surface1+Surface2+Surface3+Surface4)) )
  {                                        // fDz or -fDz Plane
    ipl = G4int(G4UniformRand()*4);
    j = (ipl+1)%4;
    if(chose < Surface0)
    { 
      zp = -fDz;
      u = fVertices[ipl]; v = fVertices[j];
      w = fVertices[(ipl+3)%4]; 
    }
    else
    {
      zp = fDz;
      u = fVertices[ipl+4]; v = fVertices[j+4];
      w = fVertices[(ipl+3)%4+4]; 
    }
    alfa = G4UniformRand();
    beta = G4UniformRand();
    lambda1=alfa*beta;
    lambda0=alfa-lambda1;
    v = v-u;
    w = w-u;
    v = u+lambda0*v+lambda1*w;
  }
  else                                     // Lateral Plane Twisted or Not
  {
    if (chose < Surface0+Surface1) { ipl=0; }
    else if (chose < Surface0+Surface1+Surface2) { ipl=1; }
    else if (chose < Surface0+Surface1+Surface2+Surface3) { ipl=2; }
    else { ipl=3; }
    j = (ipl+1)%4;
    zp = -fDz+G4UniformRand()*2*fDz;
    cf = 0.5*(fDz-zp)/fDz;
    u = fVertices[ipl+4]+cf*( fVertices[ipl]-fVertices[ipl+4]);
    v = fVertices[j+4]+cf*(fVertices[j]-fVertices[j+4]); 
    v = u+(v-u)*G4UniformRand();
  }
  point=G4ThreeVector(v.x(),v.y(),zp);
 
  return point;
}

References anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, fDz, fTessellatedSolid, fVertices, G4UniformRand, GetFaceSurfaceArea(), G4TessellatedSolid::GetPointOnSurface(), CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

◆ GetPolyhedron()

G4Polyhedron * G4GenericTrap::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1980 of file G4GenericTrap.cc.

{
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  { 
    return fTessellatedSolid->GetPolyhedron();
  }
#endif  
  
  if ( (fpPolyhedron == nullptr)
    || fRebuildPolyhedron
    || (fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
        fpPolyhedron->GetNumberOfRotationSteps()) )
  {
    G4AutoLock l(&polyhedronMutex);
    delete fpPolyhedron;
    fpPolyhedron = CreatePolyhedron();
    fRebuildPolyhedron = false;
    l.unlock();
  }
  return fpPolyhedron;
}    

References CreatePolyhedron(), fpPolyhedron, fRebuildPolyhedron, fTessellatedSolid, HepPolyhedron::GetNumberOfRotationSteps(), G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation(), G4TessellatedSolid::GetPolyhedron(), anonymous_namespace{G4GenericTrap.cc}::polyhedronMutex, and G4TemplateAutoLock< _Mutex_t >::unlock().

◆ GetSurfaceArea()

G4double G4GenericTrap::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1384 of file G4GenericTrap.cc.

{
  // Set vertices
  G4ThreeVector v0(fVertices[0].x(),fVertices[0].y(),-fDz);
  G4ThreeVector v1(fVertices[1].x(),fVertices[1].y(),-fDz);
  G4ThreeVector v2(fVertices[2].x(),fVertices[2].y(),-fDz);
  G4ThreeVector v3(fVertices[3].x(),fVertices[3].y(),-fDz);
  G4ThreeVector v4(fVertices[4].x(),fVertices[4].y(), fDz);
  G4ThreeVector v5(fVertices[5].x(),fVertices[5].y(), fDz);
  G4ThreeVector v6(fVertices[6].x(),fVertices[6].y(), fDz);
  G4ThreeVector v7(fVertices[7].x(),fVertices[7].y(), fDz);
 
  // Find Surface Area
  if (fSurfaceArea == 0.0)
  {
    if(fIsTwisted)
    {
      fSurfaceArea = GetFaceSurfaceArea(v0,v1,v2,v3)        // -fDz plane
                   + GetTwistedFaceSurfaceArea(v1,v0,v4,v5) //  Lat plane
                   + GetTwistedFaceSurfaceArea(v2,v1,v5,v6) //  Lat plane
                   + GetTwistedFaceSurfaceArea(v3,v2,v6,v7) //  Lat plane
                   + GetTwistedFaceSurfaceArea(v0,v3,v7,v4) //  Lat plane
                   + GetFaceSurfaceArea(v7,v6,v5,v4);       // +fDz plane
    }
    else
    {
      fSurfaceArea = GetFaceSurfaceArea(v0,v1,v2,v3)  // -fDz plane
                   + GetFaceSurfaceArea(v1,v0,v4,v5)  //  Lat plane
                   + GetFaceSurfaceArea(v2,v1,v5,v6)  //  Lat plane
                   + GetFaceSurfaceArea(v3,v2,v6,v7)  //  Lat plane
                   + GetFaceSurfaceArea(v0,v3,v7,v4)  //  Lat plane
                   + GetFaceSurfaceArea(v7,v6,v5,v4); // +fDz plane
    }
  }
  return fSurfaceArea;
}

References fDz, fIsTwisted, fSurfaceArea, fVertices, GetFaceSurfaceArea(), and GetTwistedFaceSurfaceArea().

◆ GetTolerance()

G4double G4VSolid::GetTolerance ( ) const

inlineinherited

Referenced by G4NavigationLogger::CheckDaughterEntryPoint(), G4ParameterisedNavigation::ComputeStep(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::ReportOutsideMother(), and G4NavigationLogger::ReportVolumeAndIntersection().

◆ GetTwistAngle()

G4double G4GenericTrap::GetTwistAngle ( G4int index ) const

inline

Referenced by CreatePolyhedron(), NormalToPlane(), and SurfaceNormal().

◆ GetTwistedFaceSurfaceArea()

G4double G4GenericTrap::GetTwistedFaceSurfaceArea	(	const G4ThreeVector &	p0,
		const G4ThreeVector &	p1,
		const G4ThreeVector &	p2,
		const G4ThreeVector &	p3
	)		const

private

Definition at line 1469 of file G4GenericTrap.cc.

{
  G4int nstep = 100;
  G4ThreeVector dels1 = (p1 - p0)/nstep;
  G4ThreeVector dels2 = (p2 - p3)/nstep;
  G4double area = 0;
  for (G4int is = 0; is < nstep; ++is)
  {
    G4ThreeVector s0 = p0 + dels1*is;
    G4ThreeVector s1 = s0 + dels1;
    G4ThreeVector s3 = p3 + dels2*is;
    G4ThreeVector s2 = s3 + dels2;
    G4ThreeVector delt1 = (s3 - s0)/nstep;
    G4ThreeVector delt2 = (s2 - s1)/nstep;
    for (G4int it = 0; it < nstep; ++it)
    {
      G4ThreeVector t0 = s0 + delt1*it;
      G4ThreeVector t1 = t0 + delt1;
      G4ThreeVector t3 = s1 + delt2*it;
      G4ThreeVector t2 = t3 + delt2;
      area += 0.5*((t2-t0).cross(t3-t1)).mag();
    }
  }
  return area;
}

References G4InuclParticleNames::s0.

Referenced by GetSurfaceArea().

◆ GetVertex()

G4TwoVector G4GenericTrap::GetVertex ( G4int index ) const

inline

Referenced by CalculateExtent().

◆ GetVertices()

const std::vector< G4TwoVector > & G4GenericTrap::GetVertices ( ) const

inline

Referenced by G4GDMLWriteSolids::GenTrapWrite().

◆ GetVisSubdivisions()

G4int G4GenericTrap::GetVisSubdivisions ( ) const

inline

Referenced by CreatePolyhedron().

◆ GetZHalfLength()

G4double G4GenericTrap::GetZHalfLength ( ) const

inline

Referenced by CalculateExtent(), and G4GDMLWriteSolids::GenTrapWrite().

◆ Inside()

EInside G4GenericTrap::Inside ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 318 of file G4GenericTrap.cc.

{
  // Test if point is inside this shape
 
#ifdef G4TESS_TEST
   if ( fTessellatedSolid )
   { 
     return fTessellatedSolid->Inside(p);
   }
#endif  
 
  EInside innew=kOutside;
  std::vector<G4TwoVector> xy;
 
  if (std::fabs(p.z()) <= fDz+halfCarTolerance)  // First check Z range
  {
    // Compute intersection between Z plane containing point and the shape
    //
    G4double cf = 0.5*(fDz-p.z())/fDz;
    for (auto i=0; i<4; ++i)
    {
      xy.push_back(fVertices[i+4]+cf*( fVertices[i]-fVertices[i+4]));
    }
 
    innew=InsidePolygone(p,xy);
 
    if( (innew==kInside) || (innew==kSurface) )
    { 
      if(std::fabs(p.z()) > fDz-halfCarTolerance)  { innew=kSurface; }
    }
  }
  return innew;    
} 

References fDz, fTessellatedSolid, fVertices, halfCarTolerance, G4TessellatedSolid::Inside(), InsidePolygone(), kInside, kOutside, kSurface, and CLHEP::Hep3Vector::z().

Referenced by DistanceToIn(), DistToPlane(), and DistToTriangle().

◆ InsidePolygone()

EInside G4GenericTrap::InsidePolygone	(	const G4ThreeVector &	p,
		const std::vector< G4TwoVector > &	poly
	)		const

private

Definition at line 216 of file G4GenericTrap.cc.

{
  EInside  in = kInside;
  G4double cross, len2;
  G4int count=0;
 
  for (G4int i=0; i<4; ++i)
  {
    G4int j = (i+1) % 4;
 
    cross = (p.x()-poly[i].x())*(poly[j].y()-poly[i].y())-
            (p.y()-poly[i].y())*(poly[j].x()-poly[i].x());
 
    len2=(poly[i]-poly[j]).mag2();
    if (len2 > kCarTolerance)
    {
      if(cross*cross<=len2*halfCarTolerance*halfCarTolerance)  // Surface check
      {
        G4double test;
 
        // Check if p lies between the two extremes of the segment
        //
        G4int iMax;
        G4int iMin;
 
        if (poly[j].x() > poly[i].x())
        {
          iMax = j;
          iMin = i;
        }
        else {
          iMax = i;
          iMin = j;
        }
        if ( p.x() > poly[iMax].x()+halfCarTolerance
          || p.x() < poly[iMin].x()-halfCarTolerance )
        {
          return kOutside;
        }
 
        if (poly[j].y() > poly[i].y())
        {
          iMax = j;
          iMin = i;
        }
        else
        {
          iMax = i;
          iMin = j;
        }
        if ( p.y() > poly[iMax].y()+halfCarTolerance
          || p.y() < poly[iMin].y()-halfCarTolerance )
        {
          return kOutside;
        }
 
        if ( poly[iMax].x() != poly[iMin].x() )
        {
          test = (p.x()-poly[iMin].x())/(poly[iMax].x()-poly[iMin].x())
               * (poly[iMax].y()-poly[iMin].y())+poly[iMin].y();
        }
        else
        {
          test = p.y();
        }
 
        // Check if point is Inside Segment
        // 
        if( (test>=(poly[iMin].y()-halfCarTolerance))
         && (test<=(poly[iMax].y()+halfCarTolerance)) )
        { 
          return kSurface;
        }
        else
        {
          return kOutside;
        }
      }
      else if (cross<0.)  { return kOutside; }
    }
    else
    {
      ++count;
    }
  }
 
  // All collapsed vertices, Tet like
  //
  if(count==4)
  { 
    if ( (std::fabs(p.x()-poly[0].x())
         +std::fabs(p.y()-poly[0].y())) > halfCarTolerance )
    {
      in = kOutside;
    }
  }
  return in;
}

References halfCarTolerance, G4VSolid::kCarTolerance, kInside, kOutside, kSurface, mcscore::test(), CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

Referenced by DistanceToOut(), and Inside().

◆ IsSegCrossing()

G4bool G4GenericTrap::IsSegCrossing	(	const G4TwoVector &	a,
		const G4TwoVector &	b,
		const G4TwoVector &	c,
		const G4TwoVector &	d
	)		const

private

Definition at line 1656 of file G4GenericTrap.cc.

{ 
  // Check if segments [A,B] and [C,D] are crossing
 
  G4bool stand1 = false;
  G4bool stand2 = false;
  G4double dx1,dx2,xm=0.,ym=0.,a1=0.,a2=0.,b1=0.,b2=0.;
  dx1=(b-a).x();
  dx2=(d-c).x();
 
  if( std::fabs(dx1) < fgkTolerance )  { stand1 = true; }
  if( std::fabs(dx2) < fgkTolerance )  { stand2 = true; }
  if (!stand1)
  {
    a1 = (b.x()*a.y()-a.x()*b.y())/dx1;
    b1 = (b-a).y()/dx1;
  }
  if (!stand2)
  {
    a2 = (d.x()*c.y()-c.x()*d.y())/dx2;
    b2 = (d-c).y()/dx2;
  }   
  if (stand1 && stand2)
  {
    // Segments parallel and vertical
    //
    if (std::fabs(a.x()-c.x())<fgkTolerance)
    {
       // Check if segments are overlapping
       //
       if ( ((c.y()-a.y())*(c.y()-b.y())<-fgkTolerance)
         || ((d.y()-a.y())*(d.y()-b.y())<-fgkTolerance)
         || ((a.y()-c.y())*(a.y()-d.y())<-fgkTolerance)
         || ((b.y()-c.y())*(b.y()-d.y())<-fgkTolerance) )  { return true; }
 
       return false;
    }
    // Different x values
    //
    return false;
  }
   
  if (stand1)    // First segment vertical
  {
    xm = a.x();
    ym = a2+b2*xm; 
  }
  else
  {
    if (stand2)  // Second segment vertical
    {
      xm = c.x();
      ym = a1+b1*xm;
    }
    else  // Normal crossing
    {
      if (std::fabs(b1-b2) < fgkTolerance)
      {
        // Parallel segments, are they aligned
        //
        if (std::fabs(c.y()-(a1+b1*c.x())) > fgkTolerance)  { return false; }
 
        // Aligned segments, are they overlapping
        //
        if ( ((c.x()-a.x())*(c.x()-b.x())<-fgkTolerance)
          || ((d.x()-a.x())*(d.x()-b.x())<-fgkTolerance)
          || ((a.x()-c.x())*(a.x()-d.x())<-fgkTolerance)
          || ((b.x()-c.x())*(b.x()-d.x())<-fgkTolerance) )  { return true; }
 
        return false;
      }
      xm = (a1-a2)/(b2-b1);
      ym = (a1*b2-a2*b1)/(b2-b1);
    }
  }
 
  // Check if crossing point is both between A,B and C,D
  //
  G4double check = (xm-a.x())*(xm-b.x())+(ym-a.y())*(ym-b.y());
  if (check > -fgkTolerance)  { return false; }
  check = (xm-c.x())*(xm-d.x())+(ym-c.y())*(ym-d.y());
  if (check > -fgkTolerance)  { return false; }
 
  return true;
}

References fgkTolerance, CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

Referenced by CheckOrder().

◆ IsSegCrossingZ()

G4bool G4GenericTrap::IsSegCrossingZ	(	const G4TwoVector &	a,
		const G4TwoVector &	b,
		const G4TwoVector &	c,
		const G4TwoVector &	d
	)		const

private

Definition at line 1746 of file G4GenericTrap.cc.

{ 
  // Check if segments [A,B] and [C,D] are crossing when
  // A and C are on -dZ and B and D are on +dZ
 
  // Calculate the Intersection point between two lines in 3D
  //
  G4ThreeVector temp1,temp2;
  G4ThreeVector v1,v2,p1,p2,p3,p4,dv;
  G4double q,det;
  p1=G4ThreeVector(a.x(),a.y(),-fDz);
  p2=G4ThreeVector(c.x(),c.y(),-fDz);
  p3=G4ThreeVector(b.x(),b.y(),fDz);
  p4=G4ThreeVector(d.x(),d.y(),fDz);
  v1=p3-p1;
  v2=p4-p2;
  dv=p2-p1;
 
  // In case of Collapsed Vertices No crossing
  //
  if( (std::fabs(dv.x()) < kCarTolerance )&&
      (std::fabs(dv.y()) < kCarTolerance ) )  { return false; }
    
  if( (std::fabs((p4-p3).x()) < kCarTolerance )&&
      (std::fabs((p4-p3).y()) < kCarTolerance ) )  { return false; }
 
  // First estimate if Intersection is possible( if det is 0)
  //
  det = dv.x()*v1.y()*v2.z()+dv.y()*v1.z()*v2.x()
      - dv.x()*v1.z()*v2.y()-dv.y()*v1.x()*v2.z();
   
  if (std::fabs(det)<kCarTolerance)  //Intersection
  {
    temp1 = v1.cross(v2);
    temp2 = (p2-p1).cross(v2);
    if (temp1.dot(temp2) < 0)  { return false; } // intersection negative
    q = temp1.mag();
 
    if ( q < kCarTolerance )  { return false; }  // parallel lines
    q = ((dv).cross(v2)).mag()/q;
   
    if(q < 1.-kCarTolerance)  { return true; }
  }
  return false;
}

References CLHEP::Hep3Vector::cross(), CLHEP::Hep3Vector::dot(), fDz, G4VSolid::kCarTolerance, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::x(), CLHEP::Hep2Vector::x(), CLHEP::Hep3Vector::y(), CLHEP::Hep2Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by CheckOrder().

◆ IsTwisted()

G4bool G4GenericTrap::IsTwisted ( ) const

inline

◆ MakeDownFacet()

G4VFacet * G4GenericTrap::MakeDownFacet	(	const std::vector< G4ThreeVector > &	fromVertices,
		G4int	ind1,
		G4int	ind2,
		G4int	ind3
	)		const

private

Definition at line 1796 of file G4GenericTrap.cc.

{
  // Create a triangular facet from the polygon points given by indices
  // forming the down side ( the normal goes in -z)
  // Do not create facet if 2 vertices are the same
 
  if ( (fromVertices[ind1] == fromVertices[ind2]) ||
       (fromVertices[ind2] == fromVertices[ind3]) ||
       (fromVertices[ind1] == fromVertices[ind3]) )  { return 0; }
 
  std::vector<G4ThreeVector> vertices;
  vertices.push_back(fromVertices[ind1]);
  vertices.push_back(fromVertices[ind2]);
  vertices.push_back(fromVertices[ind3]);
  
  // first vertex most left
  //
  G4ThreeVector cross=(vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]);
 
  if ( cross.z() > 0.0 )
  {
    // Should not happen, as vertices should have been reordered at this stage
 
    std::ostringstream message;
    message << "Vertices in wrong order - " << GetName();
    G4Exception("G4GenericTrap::MakeDownFacet", "GeomSolids0002",
                FatalException, message);
  }
  
  return new G4TriangularFacet(vertices[0], vertices[1], vertices[2], ABSOLUTE);
}

References ABSOLUTE, FatalException, G4Exception(), G4VSolid::GetName(), and CLHEP::Hep3Vector::z().

Referenced by CreateTessellatedSolid().

◆ MakeSideFacet()

G4VFacet * G4GenericTrap::MakeSideFacet	(	const G4ThreeVector &	downVertex0,
		const G4ThreeVector &	downVertex1,
		const G4ThreeVector &	upVertex1,
		const G4ThreeVector &	upVertex0
	)		const

private

Definition at line 1869 of file G4GenericTrap.cc.

{
  // Creates a triangular facet from the polygon points given by indices
  // forming the upper side ( z>0 )
 
  if ( (downVertex0 == downVertex1) && (upVertex0 == upVertex1) )
  {
    return nullptr;
  }
 
  if ( downVertex0 == downVertex1 )
  {
    return new G4TriangularFacet(downVertex0, upVertex1, upVertex0, ABSOLUTE);
  }
 
  if ( upVertex0 == upVertex1 )
  {
    return new G4TriangularFacet(downVertex0, downVertex1, upVertex0, ABSOLUTE);
  }
 
  return new G4QuadrangularFacet(downVertex0, downVertex1, 
                                 upVertex1, upVertex0, ABSOLUTE);   
}    

References ABSOLUTE.

Referenced by CreateTessellatedSolid().

◆ MakeUpFacet()

G4VFacet * G4GenericTrap::MakeUpFacet	(	const std::vector< G4ThreeVector > &	fromVertices,
		G4int	ind1,
		G4int	ind2,
		G4int	ind3
	)		const

private

Definition at line 1832 of file G4GenericTrap.cc.

{
  // Create a triangular facet from the polygon points given by indices
  // forming the upper side ( z>0 )
 
  // Do not create facet if 2 vertices are the same
  //
  if ( (fromVertices[ind1] == fromVertices[ind2]) ||
       (fromVertices[ind2] == fromVertices[ind3]) ||
       (fromVertices[ind1] == fromVertices[ind3]) )  { return nullptr; }
 
  std::vector<G4ThreeVector> vertices;
  vertices.push_back(fromVertices[ind1]);
  vertices.push_back(fromVertices[ind2]);
  vertices.push_back(fromVertices[ind3]);
  
  // First vertex most left
  //
  G4ThreeVector cross=(vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]);
 
  if ( cross.z() < 0.0 )
  {
    // Should not happen, as vertices should have been reordered at this stage
 
    std::ostringstream message;
    message << "Vertices in wrong order - " << GetName();
    G4Exception("G4GenericTrap::MakeUpFacet", "GeomSolids0002",
                FatalException, message);
  }
  
  return new G4TriangularFacet(vertices[0], vertices[1], vertices[2], ABSOLUTE);
}      

References ABSOLUTE, FatalException, G4Exception(), G4VSolid::GetName(), and CLHEP::Hep3Vector::z().

Referenced by CreateTessellatedSolid().

◆ NormalToPlane()

G4ThreeVector G4GenericTrap::NormalToPlane	(	const G4ThreeVector &	p,
		const G4int	ipl
	)		const

private

Definition at line 489 of file G4GenericTrap.cc.

{
  // Return normal to given lateral plane ipl
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  { 
    return fTessellatedSolid->SurfaceNormal(p);
  }  
#endif   
 
  G4ThreeVector lnorm, norm(0.,0.,0.), p0,p1,p2;
 
  G4double  distz = fDz-p.z();
  G4int i=ipl;  // current plane index
 
  G4TwoVector u,v;  
  G4ThreeVector r1,r2,r3,r4;
  G4double cf = 0.5*(fDz-p.z())/fDz;
  G4int j=(i+1)%4;
 
  u=fVertices[i+4]+cf*(fVertices[i]-fVertices[i+4]);
  v=fVertices[j+4]+cf*(fVertices[j]-fVertices[j+4]);
 
  // Compute cross product
  //
  p0=G4ThreeVector(u.x(),u.y(),p.z());
      
  if (std::fabs(distz)<halfCarTolerance)
  {
    p1=G4ThreeVector(fVertices[i].x(),fVertices[i].y(),-fDz);
    distz=-1;
  }
  else
  {
    p1=G4ThreeVector(fVertices[i+4].x(),fVertices[i+4].y(),fDz);
  }  
  p2=G4ThreeVector(v.x(),v.y(),p.z());
 
  // Collapsed vertices
  //
  if ( (p2-p0).mag2() < kCarTolerance )
  {
    if ( std::fabs(p.z()+fDz) > halfCarTolerance )
    {
      p2=G4ThreeVector(fVertices[j].x(),fVertices[j].y(),-fDz);
    }
    else
    {
      p2=G4ThreeVector(fVertices[j+4].x(),fVertices[j+4].y(),fDz);
    }
  }
  lnorm=-(p1-p0).cross(p2-p0);
  if (distz>-halfCarTolerance)  { lnorm=-lnorm.unit(); }
  else                          { lnorm=lnorm.unit();  }
 
  // Adjust Normal for Twisted Surface
  //
  if( (fIsTwisted) && (GetTwistAngle(ipl)!=0) )
  {
    G4double normP=(p2-p0).mag();
    if(normP)
    {
      G4double proj=(p-p0).dot(p2-p0)/normP;
      if (proj<0)     { proj=0; }
      if (proj>normP) { proj=normP; }
 
      r1=G4ThreeVector(fVertices[i+4].x(),fVertices[i+4].y(),fDz);
      r2=G4ThreeVector(fVertices[j+4].x(),fVertices[j+4].y(),fDz);
      r3=G4ThreeVector(fVertices[i].x(),fVertices[i].y(),-fDz);
      r4=G4ThreeVector(fVertices[j].x(),fVertices[j].y(),-fDz);
      r1=r1+proj*(r2-r1)/normP;
      r3=r3+proj*(r4-r3)/normP;
      r2=r1-r3;
      r4=r2.cross(p2-p0);r4=r4.unit();
      lnorm=r4;
    }
  }  // End if fIsTwisted
 
  return lnorm;
}    

References CLHEP::Hep3Vector::cross(), fDz, fIsTwisted, fTessellatedSolid, fVertices, GetTwistAngle(), halfCarTolerance, G4VSolid::kCarTolerance, G4TessellatedSolid::SurfaceNormal(), CLHEP::Hep3Vector::unit(), CLHEP::Hep2Vector::x(), CLHEP::Hep2Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToOut(), DistToPlane(), DistToTriangle(), and SafetyToFace().

◆ operator=()

G4GenericTrap & G4GenericTrap::operator= ( const G4GenericTrap & rhs )

Definition at line 183 of file G4GenericTrap.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   halfCarTolerance = rhs.halfCarTolerance;
   fDz = rhs.fDz; fVertices = rhs.fVertices;
   fIsTwisted = rhs.fIsTwisted; fTessellatedSolid = nullptr;
   fMinBBoxVector = rhs.fMinBBoxVector; fMaxBBoxVector = rhs.fMaxBBoxVector;
   fVisSubdivisions = rhs.fVisSubdivisions;
   fSurfaceArea = rhs.fSurfaceArea; fCubicVolume = rhs.fCubicVolume;
 
   for (auto i=0; i<4; ++i)  { fTwist[i] = rhs.fTwist[i]; }
#ifdef G4TESS_TEST
   if (rhs.fTessellatedSolid && !fIsTwisted )
   { delete fTessellatedSolid; fTessellatedSolid = CreateTessellatedSolid(); } 
#endif
   fRebuildPolyhedron = false;
   delete fpPolyhedron; fpPolyhedron = nullptr;
 
   return *this;
}

References CreateTessellatedSolid(), fCubicVolume, fDz, fIsTwisted, fMaxBBoxVector, fMinBBoxVector, fpPolyhedron, fRebuildPolyhedron, fSurfaceArea, fTessellatedSolid, fTwist, fVertices, fVisSubdivisions, halfCarTolerance, and G4VSolid::operator=().

◆ operator==()

G4bool G4VSolid::operator== ( const G4VSolid & s ) const

inlineinherited

◆ ReorderVertices()

void G4GenericTrap::ReorderVertices ( std::vector< G4ThreeVector > & vertices ) const

private

Definition at line 1641 of file G4GenericTrap.cc.

{
  // Reorder the vector of vertices 
 
  std::vector<G4ThreeVector> oldVertices(vertices);
 
  for ( size_t i=0; i<oldVertices.size(); ++i )
  {
    vertices[i] = oldVertices[oldVertices.size()-1-i];
  }  
} 

Referenced by CreateTessellatedSolid().

◆ SafetyToFace()

G4double G4GenericTrap::SafetyToFace	(	const G4ThreeVector &	p,
		const G4int	iseg
	)		const

private

Definition at line 830 of file G4GenericTrap.cc.

{
  // Estimate distance to lateral plane defined by segment iseg in range [0,3]
  // Might be negative: plane seen only from inside
 
  G4ThreeVector p1,norm;
  G4double safe;
 
  p1=G4ThreeVector(fVertices[iseg].x(),fVertices[iseg].y(),-fDz);
  
  norm=NormalToPlane(p,iseg);
  safe = (p-p1).dot(norm); // Can be negative
 
  return safe;
}

References fDz, fVertices, and NormalToPlane().

Referenced by DistanceToIn(), and DistanceToOut().

◆ SetName()

void G4VSolid::SetName ( const G4String & name )

inherited

Definition at line 127 of file G4VSolid.cc.

{
  fshapeName = name;
  G4SolidStore::GetInstance()->SetMapValid(false);
}

References G4VSolid::fshapeName, G4SolidStore::GetInstance(), G4InuclParticleNames::name(), and G4SolidStore::SetMapValid().

Referenced by export_G4VSolid(), G4MultiUnion::G4MultiUnion(), and G4GDMLRead::StripNames().

◆ SetTwistAngle()

void G4GenericTrap::SetTwistAngle	(	G4int	index,
		G4double	twist
	)

inlineprivate

Referenced by ComputeIsTwisted().

◆ SetVisSubdivisions()

void G4GenericTrap::SetVisSubdivisions ( G4int subdiv )

inline

◆ StreamInfo()

std::ostream & G4GenericTrap::StreamInfo ( std::ostream & os ) const

virtual

Implements G4VSolid.

Definition at line 1273 of file G4GenericTrap.cc.

{
  G4int oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " *** \n"
     << "    =================================================== \n"
     << " Solid geometry type: " << GetEntityType()  << G4endl
     << "   half length Z: " << fDz/mm << " mm \n"
     << "   list of vertices:\n";
     
  for ( G4int i=0; i<fgkNofVertices; ++i )
  {
    os << std::setw(5) << "#" << i 
       << "   vx = " << fVertices[i].x()/mm << " mm" 
       << "   vy = " << fVertices[i].y()/mm << " mm" << G4endl;
  }
  os.precision(oldprc);
 
  return os;
} 

References fDz, fgkNofVertices, fVertices, G4endl, GetEntityType(), G4VSolid::GetName(), and mm.

◆ SurfaceNormal()

G4ThreeVector G4GenericTrap::SurfaceNormal ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 354 of file G4GenericTrap.cc.

{
  // Calculate side nearest to p, and return normal
  // If two sides are equidistant, sum of the Normal is returned
 
#ifdef G4TESS_TEST
  if ( fTessellatedSolid )
  {
    return fTessellatedSolid->SurfaceNormal(p);
  }  
#endif   
 
  G4ThreeVector lnorm, sumnorm(0.,0.,0.), apprnorm(0.,0.,1.),
                p0, p1, p2, r1, r2, r3, r4;
  G4int noSurfaces = 0; 
  G4double distxy,distz;
  G4bool zPlusSide=false;
 
  distz = fDz-std::fabs(p.z());
  if (distz < halfCarTolerance)
  {
    if(p.z()>0)
    {
      zPlusSide=true;
      sumnorm=G4ThreeVector(0,0,1);
    }
    else
    {
      sumnorm=G4ThreeVector(0,0,-1);
    }
    ++noSurfaces;
  } 
 
  // Check lateral planes
  //
  std:: vector<G4TwoVector> vertices;  
  G4double cf = 0.5*(fDz-p.z())/fDz;
  for (auto i=0; i<4; ++i)
  {
    vertices.push_back(fVertices[i+4]+cf*(fVertices[i]-fVertices[i+4]));
  }
 
  // Compute distance for lateral planes
  //
  for (G4int q=0; q<4; ++q)
  {
    p0=G4ThreeVector(vertices[q].x(),vertices[q].y(),p.z());
    if(zPlusSide)
    {
      p1=G4ThreeVector(fVertices[q].x(),fVertices[q].y(),-fDz);
    }
    else
    {
      p1=G4ThreeVector(fVertices[q+4].x(),fVertices[q+4].y(),fDz); 
    }
    p2=G4ThreeVector(vertices[(q+1)%4].x(),vertices[(q+1)%4].y(),p.z());
 
    // Collapsed vertices
    //
    if ( (p2-p0).mag2() < kCarTolerance )
    {
      if ( std::fabs(p.z()+fDz) > kCarTolerance )
      {
        p2=G4ThreeVector(fVertices[(q+1)%4].x(),fVertices[(q+1)%4].y(),-fDz);
      }
      else
      {
        p2=G4ThreeVector(fVertices[(q+1)%4+4].x(),fVertices[(q+1)%4+4].y(),fDz);
      }
    }
    lnorm = (p1-p0).cross(p2-p0);
    lnorm = lnorm.unit();
    if(zPlusSide)  { lnorm=-lnorm; }
 
    // Adjust Normal for Twisted Surface
    //
    if ( (fIsTwisted) && (GetTwistAngle(q)!=0) )
    {
      G4double normP=(p2-p0).mag();
      if(normP)
      {
        G4double proj=(p-p0).dot(p2-p0)/normP;
        if(proj<0)     { proj=0; }
        if(proj>normP) { proj=normP; }
        G4int j=(q+1)%4;
        r1=G4ThreeVector(fVertices[q+4].x(),fVertices[q+4].y(),fDz);
        r2=G4ThreeVector(fVertices[j+4].x(),fVertices[j+4].y(),fDz);
        r3=G4ThreeVector(fVertices[q].x(),fVertices[q].y(),-fDz);
        r4=G4ThreeVector(fVertices[j].x(),fVertices[j].y(),-fDz);
        r1=r1+proj*(r2-r1)/normP;
        r3=r3+proj*(r4-r3)/normP;
        r2=r1-r3;
        r4=r2.cross(p2-p0); r4=r4.unit();
        lnorm=r4;
      }
    }   // End if fIsTwisted
 
    distxy=std::fabs((p0-p).dot(lnorm));
    if ( distxy<halfCarTolerance )
    {
      ++noSurfaces;
 
      // Negative sign for Normal is taken for Outside Normal
      //
      sumnorm=sumnorm+lnorm;
    }
 
    // For ApproxSurfaceNormal
    //
    if (distxy<distz)
    {
      distz=distxy;
      apprnorm=lnorm;
    }      
  }  // End for loop
 
  // Calculate final Normal, add Normal in the Corners and Touching Sides
  //
  if ( noSurfaces == 0 )
  {
#ifdef G4SPECSDEBUG
    G4Exception("G4GenericTrap::SurfaceNormal(p)", "GeomSolids1002",
                JustWarning, "Point p is not on surface !?" );
#endif
    sumnorm=apprnorm;
    // Add Approximative Surface Normal Calculation?
  }
  else if ( noSurfaces == 1 )  { ; }
  else                         { sumnorm = sumnorm.unit(); }
 
  return sumnorm ; 
}    

References CLHEP::Hep3Vector::cross(), fDz, fIsTwisted, fTessellatedSolid, fVertices, G4Exception(), GetTwistAngle(), halfCarTolerance, JustWarning, G4VSolid::kCarTolerance, G4TessellatedSolid::SurfaceNormal(), CLHEP::Hep3Vector::unit(), and CLHEP::Hep3Vector::z().

Field Documentation

◆ fCubicVolume

G4double G4GenericTrap::fCubicVolume = 0.0

private

Definition at line 225 of file G4GenericTrap.hh.

Referenced by GetCubicVolume(), and operator=().

◆ fDz

G4double G4GenericTrap::fDz

private

Definition at line 212 of file G4GenericTrap.hh.

Referenced by ComputeBBox(), CreatePolyhedron(), CreateTessellatedSolid(), DistanceToIn(), DistanceToOut(), DistToPlane(), DistToTriangle(), GetCubicVolume(), GetPointOnSurface(), GetSurfaceArea(), Inside(), IsSegCrossingZ(), NormalToPlane(), operator=(), SafetyToFace(), StreamInfo(), and SurfaceNormal().

◆ fgkNofVertices

const G4int G4GenericTrap::fgkNofVertices = 8

staticprivate

Definition at line 205 of file G4GenericTrap.hh.

Referenced by ComputeBBox(), ComputeIsTwisted(), CreateTessellatedSolid(), G4GenericTrap(), and StreamInfo().

◆ fgkTolerance

const G4double G4GenericTrap::fgkTolerance = 1E-3

staticprivate

Definition at line 206 of file G4GenericTrap.hh.

Referenced by CheckOrder(), ComputeIsTwisted(), and IsSegCrossing().

◆ fIsTwisted

G4bool G4GenericTrap::fIsTwisted = false

private

Definition at line 214 of file G4GenericTrap.hh.

Referenced by CreatePolyhedron(), G4GenericTrap(), GetCubicVolume(), GetSurfaceArea(), NormalToPlane(), operator=(), and SurfaceNormal().

◆ fMaxBBoxVector

G4ThreeVector G4GenericTrap::fMaxBBoxVector

private

Definition at line 218 of file G4GenericTrap.hh.

Referenced by ComputeBBox(), and operator=().

◆ fMinBBoxVector

G4ThreeVector G4GenericTrap::fMinBBoxVector

private

Definition at line 217 of file G4GenericTrap.hh.

Referenced by ComputeBBox(), and operator=().

◆ fpPolyhedron

G4Polyhedron* G4GenericTrap::fpPolyhedron = nullptr

mutableprotected

Definition at line 199 of file G4GenericTrap.hh.

Referenced by GetPolyhedron(), and operator=().

◆ fRebuildPolyhedron

G4bool G4GenericTrap::fRebuildPolyhedron = false

mutableprotected

Definition at line 198 of file G4GenericTrap.hh.

Referenced by GetPolyhedron(), and operator=().

◆ fshapeName

G4String G4VSolid::fshapeName

privateinherited

Definition at line 312 of file G4VSolid.hh.

Referenced by G4VSolid::operator=(), and G4VSolid::SetName().

◆ fSurfaceArea

G4double G4GenericTrap::fSurfaceArea = 0.0

private

Definition at line 224 of file G4GenericTrap.hh.

Referenced by GetSurfaceArea(), and operator=().

◆ fTessellatedSolid

G4TessellatedSolid* G4GenericTrap::fTessellatedSolid = nullptr

private

Definition at line 216 of file G4GenericTrap.hh.

Referenced by CreatePolyhedron(), DescribeYourselfTo(), DistanceToIn(), DistanceToOut(), G4GenericTrap(), GetExtent(), GetPointOnSurface(), GetPolyhedron(), Inside(), NormalToPlane(), operator=(), SurfaceNormal(), and ~G4GenericTrap().

◆ fTwist

G4double G4GenericTrap::fTwist[4]

private

Definition at line 215 of file G4GenericTrap.hh.

Referenced by G4GenericTrap(), and operator=().

◆ fVertices

std::vector<G4TwoVector> G4GenericTrap::fVertices

private

Definition at line 213 of file G4GenericTrap.hh.

Referenced by ComputeBBox(), ComputeIsTwisted(), CreatePolyhedron(), CreateTessellatedSolid(), DistanceToOut(), DistToPlane(), DistToTriangle(), G4GenericTrap(), GetCubicVolume(), GetPointOnSurface(), GetSurfaceArea(), Inside(), NormalToPlane(), operator=(), SafetyToFace(), StreamInfo(), and SurfaceNormal().

◆ fVisSubdivisions

G4int G4GenericTrap::fVisSubdivisions = 0

private

Definition at line 219 of file G4GenericTrap.hh.

Referenced by operator=().

◆ halfCarTolerance

G4double G4GenericTrap::halfCarTolerance

private

Definition at line 208 of file G4GenericTrap.hh.

Referenced by DistanceToIn(), DistanceToOut(), DistToPlane(), DistToTriangle(), G4GenericTrap(), Inside(), InsidePolygone(), NormalToPlane(), operator=(), and SurfaceNormal().

◆ kCarTolerance

G4double G4VSolid::kCarTolerance

protectedinherited

Definition at line 299 of file G4VSolid.hh.

The documentation for this class was generated from the following files:

source/geometry/solids/specific/include/G4GenericTrap.hh
source/geometry/solids/specific/src/G4GenericTrap.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ESide

Constructor & Destructor Documentation

◆ G4GenericTrap() [1/3]

◆ ~G4GenericTrap()

◆ G4GenericTrap() [2/3]

◆ G4GenericTrap() [3/3]

Member Function Documentation

◆ BoundingLimits()

◆ CalculateClippedPolygonExtent()

◆ CalculateExtent()

◆ CheckOrder()

◆ ClipBetweenSections()

◆ ClipCrossSection()

◆ ClipPolygon()

◆ ClipPolygonToSimpleLimits()

◆ Clone()

◆ ComputeBBox()

◆ ComputeDimensions()

◆ ComputeIsTwisted()

◆ CreatePolyhedron()

◆ CreateTessellatedSolid()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ DistToPlane()

◆ DistToTriangle()

◆ DumpInfo()

◆ EstimateCubicVolume()

◆ EstimateSurfaceArea()

◆ GetConstituentSolid() [1/2]

◆ GetConstituentSolid() [2/2]

◆ GetCubicVolume()

◆ GetDisplacedSolidPtr() [1/2]

◆ GetDisplacedSolidPtr() [2/2]

◆ GetEntityType()

◆ GetExtent()

◆ GetFaceCubicVolume()

◆ GetFaceSurfaceArea()

◆ GetMaximumBBox()

◆ GetMinimumBBox()

◆ GetName()

◆ GetNofVertices()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ GetTolerance()

◆ GetTwistAngle()

◆ GetTwistedFaceSurfaceArea()

◆ GetVertex()

◆ GetVertices()

◆ GetVisSubdivisions()

◆ GetZHalfLength()

◆ Inside()

◆ InsidePolygone()

◆ IsSegCrossing()

◆ IsSegCrossingZ()

◆ IsTwisted()

◆ MakeDownFacet()

◆ MakeSideFacet()

◆ MakeUpFacet()

◆ NormalToPlane()

◆ operator=()

◆ operator==()

◆ ReorderVertices()

◆ SafetyToFace()

◆ SetName()

◆ SetTwistAngle()

◆ SetVisSubdivisions()

◆ StreamInfo()