G4VTwistedFaceted is a base class for twisted boxoids: G4TwistedTrd, G4TwistedTrap and G4TwistedBox. More...

#include <G4VTwistedFaceted.hh>

Inheritance diagram for G4VTwistedFaceted:

Public Member Functions
	G4VTwistedFaceted (const G4String &pname, G4double PhiTwist, G4double pDz, G4double pTheta, G4double pPhi, G4double pDy1, G4double pDx1, G4double pDx2, G4double pDy2, G4double pDx3, G4double pDx4, G4double pAlph)
	~G4VTwistedFaceted () override
void	ComputeDimensions (G4VPVParameterisation , const G4int, const G4VPhysicalVolume ) override
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcnorm=false, G4bool validnorm=nullptr, G4ThreeVector n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
EInside	Inside (const G4ThreeVector &p) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
G4ThreeVector	GetPointOnSurface () const override
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4Polyhedron *	CreatePolyhedron () const override
G4Polyhedron *	GetPolyhedron () const override
G4VisExtent	GetExtent () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4double	GetTwistAngle () const
G4double	GetDx1 () const
G4double	GetDx2 () const
G4double	GetDx3 () const
G4double	GetDx4 () const
G4double	GetDy1 () const
G4double	GetDy2 () const
G4double	GetDz () const
G4double	GetPhi () const
G4double	GetTheta () const
G4double	GetAlpha () const
G4double	Xcoef (G4double u, G4double phi, G4double ftg) const
G4double	GetValueA (G4double phi) const
G4double	GetValueB (G4double phi) const
G4double	GetValueD (G4double phi) const
G4GeometryType	GetEntityType () const override
	G4VTwistedFaceted (__void__ &)
	G4VTwistedFaceted (const G4VTwistedFaceted &rhs)
G4VTwistedFaceted &	operator= (const G4VTwistedFaceted &rhs)
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
virtual G4int	GetNumOfConstituents () const
virtual G4bool	IsFaceted () const
virtual G4VSolid *	Clone () const
void	DumpInfo () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

Protected Attributes
G4bool	fRebuildPolyhedron = false
G4Polyhedron *	fpPolyhedron = nullptr
G4double	fCubicVolume = 0.0
G4double	fSurfaceArea = 0.0
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Additional Inherited Members
Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, 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	ClipBetweenSections (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

Detailed Description

G4VTwistedFaceted is a base class for twisted boxoids: G4TwistedTrd, G4TwistedTrap and G4TwistedBox.

Definition at line 53 of file G4VTwistedFaceted.hh.

Constructor & Destructor Documentation

◆ G4VTwistedFaceted() [1/3]

G4VTwistedFaceted::G4VTwistedFaceted	(	const G4String &	pname,
		G4double	PhiTwist,
		G4double	pDz,
		G4double	pTheta,
		G4double	pPhi,
		G4double	pDy1,
		G4double	pDx1,
		G4double	pDx2,
		G4double	pDy2,
		G4double	pDx3,
		G4double	pDx4,
		G4double	pAlph )

Constructs a faceted solid, given its parameters.

Parameters

[in]	pName	The solid name.
[in]	pPhiTwist	Twist angle.
[in]	pDz	Half-length along Z axis.
[in]	pTheta	Polar angle of the line joining the centres of the faces at -/+pDz.
[in]	pPhi	Azimuthal angle of the line joining the centres of the faces at -/+pDz.
[in]	pDy1	Half Y length at -pDz.
[in]	pDx1	Half X length at -pDz, y=-pDy1.
[in]	pDx2	Half X length at -pDz, y=+pDy1.
[in]	pDy2	Half Y length at +pDz.
[in]	pDx3	Half X length at +pDz, y=-pDy2.
[in]	pDx4	Half X length at +pDz, y=+pDy2.
[in]	pAlph	Angle with respect to the Y axis from centre of side.

Definition at line 61 of file G4VTwistedFaceted.cc.

  : G4VSolid(pname),
    fLowerEndcap(nullptr), fUpperEndcap(nullptr), fSide0(nullptr),
    fSide90(nullptr), fSide180(nullptr), fSide270(nullptr)
{
 
  G4double pDytmp ;
  G4double fDxUp ;
  G4double fDxDown ;
 
  fDx1 = pDx1 ;
  fDx2 = pDx2 ;
  fDx3 = pDx3 ;
  fDx4 = pDx4 ;
  fDy1 = pDy1 ;
  fDy2 = pDy2 ;
  fDz  = pDz  ;
 
  G4double kAngTolerance
    = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
 
  // maximum values
  //
  fDxDown = ( fDx1 > fDx2 ? fDx1 : fDx2 ) ;
  fDxUp   = ( fDx3 > fDx4 ? fDx3 : fDx4 ) ;
  fDx     = ( fDxUp > fDxDown ? fDxUp : fDxDown ) ;
  fDy     = ( fDy1 > fDy2 ? fDy1 : fDy2 ) ;
  
  // planarity check
  //
  if ( fDx1 != fDx2 && fDx3 != fDx4 )
  {
    pDytmp = fDy1 * ( fDx3 - fDx4 ) / ( fDx1 - fDx2 ) ;
    if ( std::fabs(pDytmp - fDy2) > kCarTolerance )
    {
      std::ostringstream message;
      message << "Not planar surface in untwisted Trapezoid: "
              << GetName() << G4endl
              << "fDy2 is " << fDy2 << " but should be "
              << pDytmp << ".";
      G4Exception("G4VTwistedFaceted::G4VTwistedFaceted()", "GeomSolids0002",
                  FatalErrorInArgument, message);
    }
  }
 
#ifdef G4TWISTDEBUG
  if ( fDx1 == fDx2 && fDx3 == fDx4 )
  { 
      G4cout << "Trapezoid is a box" << G4endl ;
  }
  
#endif
 
  if ( (  fDx1 == fDx2 && fDx3 != fDx4 ) || ( fDx1 != fDx2 && fDx3 == fDx4 ) )
  {
    std::ostringstream message;
    message << "Not planar surface in untwisted Trapezoid: "
            << GetName() << G4endl
            << "One endcap is rectangular, the other is a trapezoid." << G4endl
            << "For planarity reasons they have to be rectangles or trapezoids "
            << "on both sides.";
    G4Exception("G4VTwistedFaceted::G4VTwistedFaceted()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  // twist angle
  //
  fPhiTwist = PhiTwist ;
 
  // tilt angle
  //
  fAlph = pAlph ; 
  fTAlph = std::tan(fAlph) ;
  
  fTheta = pTheta ;
  fPhi   = pPhi ;
 
  // dx in surface equation
  //
  fdeltaX = 2 * fDz * std::tan(fTheta) * std::cos(fPhi)  ;
 
  // dy in surface equation
  //
  fdeltaY = 2 * fDz * std::tan(fTheta) * std::sin(fPhi)  ;
 
  if  ( ( fDx1  <= 2*kCarTolerance)
         || ( fDx2  <= 2*kCarTolerance)
         || ( fDx3  <= 2*kCarTolerance)
         || ( fDx4  <= 2*kCarTolerance)
         || ( fDy1  <= 2*kCarTolerance)
         || ( fDy2  <= 2*kCarTolerance)
         || ( fDz   <= 2*kCarTolerance) 
         || ( std::fabs(fPhiTwist) <= 2*kAngTolerance )
         || ( std::fabs(fPhiTwist) >= pi/2 )
         || ( std::fabs(fAlph) >= pi/2 )
         || fTheta >= pi/2 || fTheta < 0 
      )
  {
    std::ostringstream message;
    message << "Invalid dimensions. Too small, or twist angle too big: "
            << GetName() << G4endl
            << "fDx 1-4 = " << fDx1/cm << ", " << fDx2/cm << ", "
            << fDx3/cm << ", " << fDx4/cm << " cm" << G4endl 
            << "fDy 1-2 = " << fDy1/cm << ", " << fDy2/cm << ", "
            << " cm" << G4endl 
            << "fDz = " << fDz/cm << " cm" << G4endl 
            << " twistangle " << fPhiTwist/deg << " deg" << G4endl 
            << " phi,theta = " << fPhi/deg << ", "  << fTheta/deg << " deg";
    G4Exception("G4TwistedTrap::G4VTwistedFaceted()",
                "GeomSolids0002", FatalErrorInArgument, message);
  }
  CreateSurfaces();
}

Referenced by G4TwistedBox::G4TwistedBox(), G4TwistedBox::G4TwistedBox(), G4TwistedBox::G4TwistedBox(), G4TwistedTrap::G4TwistedTrap(), G4TwistedTrap::G4TwistedTrap(), G4TwistedTrap::G4TwistedTrap(), G4TwistedTrap::G4TwistedTrap(), G4TwistedTrd::G4TwistedTrd(), G4TwistedTrd::G4TwistedTrd(), G4TwistedTrd::G4TwistedTrd(), G4VTwistedFaceted(), and operator=().

◆ ~G4VTwistedFaceted()

G4VTwistedFaceted::~G4VTwistedFaceted ( )

override

Destructor.

Definition at line 202 of file G4VTwistedFaceted.cc.

{
  delete fLowerEndcap ; 
  delete fUpperEndcap ; 
 
  delete fSide0   ; 
  delete fSide90  ; 
  delete fSide180 ; 
  delete fSide270 ; 
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

◆ G4VTwistedFaceted() [2/3]

G4VTwistedFaceted::G4VTwistedFaceted ( __void__ & a )

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 191 of file G4VTwistedFaceted.cc.

  : G4VSolid(a),
    fLowerEndcap(nullptr), fUpperEndcap(nullptr),
    fSide0(nullptr), fSide90(nullptr), fSide180(nullptr), fSide270(nullptr)
{
}

◆ G4VTwistedFaceted() [3/3]

G4VTwistedFaceted::G4VTwistedFaceted ( const G4VTwistedFaceted & rhs )

Copy constructor and assignment operator.

Definition at line 218 of file G4VTwistedFaceted.cc.

  : G4VSolid(rhs),
    fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea),
    fTheta(rhs.fTheta), fPhi(rhs.fPhi),
    fDy1(rhs.fDy1), fDx1(rhs.fDx1), fDx2(rhs.fDx2), fDy2(rhs.fDy2),
    fDx3(rhs.fDx3), fDx4(rhs.fDx4), fDz(rhs.fDz), fDx(rhs.fDx), fDy(rhs.fDy),
    fAlph(rhs.fAlph), fTAlph(rhs.fTAlph), fdeltaX(rhs.fdeltaX),
    fdeltaY(rhs.fdeltaY), fPhiTwist(rhs.fPhiTwist), fLowerEndcap(nullptr),
    fUpperEndcap(nullptr), fSide0(nullptr), fSide90(nullptr), fSide180(nullptr), fSide270(nullptr)
{
  CreateSurfaces();
}

Member Function Documentation

◆ BoundingLimits()

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

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 279 of file G4VTwistedFaceted.cc.

{
  G4double cosPhi = std::cos(fPhi);
  G4double sinPhi = std::sin(fPhi);
  G4double tanTheta = std::tan(fTheta);
  G4double tanAlpha = fTAlph;
 
  G4double xmid1 = fDy1*tanAlpha;
  G4double x1 = std::abs(xmid1 + fDx1);
  G4double x2 = std::abs(xmid1 - fDx1);
  G4double x3 = std::abs(xmid1 + fDx2);
  G4double x4 = std::abs(xmid1 - fDx2);
  G4double xmax1 = std::max(std::max(std::max(x1, x2), x3), x4);
  G4double rmax1 = std::sqrt(xmax1*xmax1 + fDy1*fDy1);
 
  G4double xmid2 = fDy2*tanAlpha;
  G4double x5 = std::abs(xmid2 + fDx3);
  G4double x6 = std::abs(xmid2 - fDx3);
  G4double x7 = std::abs(xmid2 + fDx4);
  G4double x8 = std::abs(xmid2 - fDx4);
  G4double xmax2 = std::max(std::max(std::max(x5, x6), x7), x8);
  G4double rmax2 = std::sqrt(xmax2*xmax2 + fDy2*fDy2);
 
  G4double x0 = fDz*tanTheta*cosPhi;
  G4double y0 = fDz*tanTheta*sinPhi;
  G4double xmin = std::min(-x0 - rmax1, x0 - rmax2);
  G4double ymin = std::min(-y0 - rmax1, y0 - rmax2);
  G4double xmax = std::max(-x0 + rmax1, x0 + rmax2);
  G4double ymax = std::max(-y0 + rmax1, y0 + rmax2);
  pMin.set(xmin, ymin,-fDz);
  pMax.set(xmax, ymax, fDz);
}

Referenced by CalculateExtent().

◆ CalculateExtent()

G4bool G4VTwistedFaceted::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pMin,
		G4double &	pMax ) const

overridevirtual

Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pTransform	The internal transformation applied to the solid.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns: True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 318 of file G4VTwistedFaceted.cc.

{
  G4ThreeVector bmin, bmax;
 
  // Get bounding box
  BoundingLimits(bmin,bmax);
 
  // Find extent
  G4BoundingEnvelope bbox(bmin,bmax);
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
}

◆ ComputeDimensions()

void G4VTwistedFaceted::ComputeDimensions	(	G4VPVParameterisation *	,
		const G4int	,
		const G4VPhysicalVolume *	)

overridevirtual

Dispatch method for parameterisation replication mechanism and dimension computation.

Reimplemented from G4VSolid.

Definition at line 266 of file G4VTwistedFaceted.cc.

{
  G4Exception("G4VTwistedFaceted::ComputeDimensions()",
              "GeomSolids0001", FatalException,
              "G4VTwistedFaceted does not support Parameterisation.");
}

◆ CreatePolyhedron()

G4Polyhedron * G4VTwistedFaceted::CreatePolyhedron ( ) const

overridevirtual

Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".

Reimplemented from G4VSolid.

Definition at line 1123 of file G4VTwistedFaceted.cc.

{
  // number of meshes
  const G4int k =
  G4int(G4Polyhedron::GetNumberOfRotationSteps() *
        std::abs(fPhiTwist) / twopi) + 2;
  const G4int n = k;
 
  const G4int nnodes = 4*(k-1)*(n-2) + 2*k*k ;
  const G4int nfaces = 4*(k-1)*(n-1) + 2*(k-1)*(k-1) ;
 
  auto  ph = new G4Polyhedron;
  typedef G4double G4double3[3];
  typedef G4int G4int4[4];
  auto xyz = new G4double3[nnodes];  // number of nodes 
  auto faces = new G4int4[nfaces] ;  // number of faces
 
  fLowerEndcap->GetFacets(k,k,xyz,faces,0) ;
  fUpperEndcap->GetFacets(k,k,xyz,faces,1) ;
  fSide270->GetFacets(k,n,xyz,faces,2) ;
  fSide0->GetFacets(k,n,xyz,faces,3) ;
  fSide90->GetFacets(k,n,xyz,faces,4) ;
  fSide180->GetFacets(k,n,xyz,faces,5) ;
 
  ph->createPolyhedron(nnodes,nfaces,xyz,faces);
 
  return ph;
}

Referenced by GetPolyhedron().

◆ DescribeYourselfTo()

void G4VTwistedFaceted::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Methods for creating graphical representations (i.e. for visualisation).

Implements G4VSolid.

Definition at line 829 of file G4VTwistedFaceted.cc.

{
  scene.AddSolid (*this);
}

◆ DistanceToIn() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.

Parameters

[in] p The point at offset p.

Returns: The safety distance to enter the shape.

Implements G4VSolid.

Definition at line 554 of file G4VTwistedFaceted.cc.

{
   // DistanceToIn(p):
   // Calculate distance to surface of shape from `outside',
   // allowing for tolerance
   //
   
   //
   // Calculate DistanceToIn(p) 
   //
   
   EInside currentside = Inside(p);
 
   switch (currentside)
   {
      case (kInside) :
      {
      }
 
      case (kSurface) :
      {
         return 0;
      }
 
      case (kOutside) :
      {
         // Initialize
         //
         G4double distance = kInfinity;   
 
         // Find intersections and choose nearest one
         //
         G4VTwistSurface* surfaces[6];
 
         surfaces[0] = fSide0;
         surfaces[1] = fSide90 ;
         surfaces[2] = fSide180 ;
         surfaces[3] = fSide270 ;
         surfaces[4] = fLowerEndcap;
         surfaces[5] = fUpperEndcap;
 
         G4ThreeVector xx;
         G4ThreeVector bestxx;
         for (const auto & surface : surfaces)
         {
            G4double tmpdistance = surface->DistanceTo(p, xx);
            if (tmpdistance < distance)
            {
               distance = tmpdistance;
               bestxx = xx;
            }
         }
         return distance;
      }
 
      default:
      {
         G4Exception("G4VTwistedFaceted::DistanceToIn(p)", "GeomSolids0003",
                     FatalException, "Unknown point location!");
      }
   } // switch end
 
   return 0.;
}

◆ DistanceToIn() [2/2]

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

overridevirtual

Concrete implementations of the expected query interfaces for solids, as defined in the base class G4VSolid.

Implements G4VSolid.

Definition at line 475 of file G4VTwistedFaceted.cc.

{
 
   // DistanceToIn (p, v):
   // Calculate distance to surface of shape from `outside' 
   // along with the v, allowing for tolerance.
   // The function returns kInfinity if no intersection or
   // just grazing within tolerance.
 
   //
   // Calculate DistanceToIn(p,v)
   //
   
   EInside currentside = Inside(p);
 
   if (currentside == kInside)
   {
   }
   else if (currentside == kSurface)
   {
     // particle is just on a boundary.
     // if the particle is entering to the volume, return 0
     //
     G4ThreeVector normal = SurfaceNormal(p);
     if (normal*v < 0)
     {
       return 0;
     } 
   }
      
   // now, we can take smallest positive distance.
   
   // Initialize
   //
   G4double distance = kInfinity;   
 
   // Find intersections and choose nearest one
   //
   G4VTwistSurface *surfaces[6];
 
   surfaces[0] = fSide0;
   surfaces[1] = fSide90 ;
   surfaces[2] = fSide180 ;
   surfaces[3] = fSide270 ;
   surfaces[4] = fLowerEndcap;
   surfaces[5] = fUpperEndcap;
   
   G4ThreeVector xx;
   G4ThreeVector bestxx;
   for (const auto & surface : surfaces)
   {
#ifdef G4TWISTDEBUG
      G4cout << G4endl << "surface " << &surface - &*surfaces << ": " << G4endl << G4endl ;
#endif
      G4double tmpdistance = surface->DistanceToIn(p, v, xx);
#ifdef G4TWISTDEBUG
      G4cout << "Solid DistanceToIn : distance = " << tmpdistance << G4endl ; 
      G4cout << "intersection point = " << xx << G4endl ;
#endif 
      if (tmpdistance < distance)
      {
         distance = tmpdistance;
         bestxx = xx;
      }
   }
 
#ifdef G4TWISTDEBUG
   G4cout << "best distance = " << distance << G4endl ;
#endif
 
   // timer.Stop();
   return distance;
}

◆ DistanceToOut() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an inside point 'p'. The distance can be an underestimate.

Parameters

[in] p The point at offset p.

Returns: The safety distance to exit the shape.

Implements G4VSolid.

Definition at line 708 of file G4VTwistedFaceted.cc.

{
   // DistanceToOut(p):
   // Calculate distance to surface of shape from `inside', 
   // allowing for tolerance
   
   //
   // Calculate DistanceToOut(p)
   //
   
   EInside currentside = Inside(p);
   G4double     retval = kInfinity;   
 
   switch (currentside)
   {
      case (kOutside) :
      {
#ifdef G4SPECSDEBUG
        G4int oldprc = G4cout.precision(16) ;
        G4cout << G4endl ;
        DumpInfo();
        G4cout << "Position:"  << G4endl << G4endl ;
        G4cout << "p.x() = "   << p.x()/mm << " mm" << G4endl ;
        G4cout << "p.y() = "   << p.y()/mm << " mm" << G4endl ;
        G4cout << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl ;
        G4cout.precision(oldprc) ;
        G4Exception("G4VTwistedFaceted::DistanceToOut(p)", "GeomSolids1002",
                    JustWarning, "Point p is outside !?" );
#endif
        break;
      }
      case (kSurface) :
      {
        retval = 0;
        break;
      }
      
      case (kInside) :
      {
        // Initialize
        //
        G4double distance = kInfinity;
   
        // find intersections and choose nearest one
        //
        G4VTwistSurface* surfaces[6];
 
        surfaces[0] = fSide0;
        surfaces[1] = fSide90 ;
        surfaces[2] = fSide180 ;
        surfaces[3] = fSide270 ;
        surfaces[4] = fLowerEndcap;
        surfaces[5] = fUpperEndcap;
 
        G4ThreeVector xx;
        G4ThreeVector bestxx;
        for (const auto & surface : surfaces)
        {
          G4double tmpdistance = surface->DistanceTo(p, xx);
          if (tmpdistance < distance)
          {
            distance = tmpdistance;
            bestxx = xx;
          }
        }
        retval = distance;
        break;
      }
      
      default :
      {
        G4Exception("G4VTwistedFaceted::DistanceToOut(p)", "GeomSolids0003",
                    FatalException, "Unknown point location!");
        break;
      }
   } // switch end
 
   return retval;
}

◆ DistanceToOut() [2/2]

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

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from a point at an offset 'p' inside or on the surface of the shape. Intersections with surfaces, when the point is less than Tolerance/2 from a surface must be ignored.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.
[in]	calcNorm	Flag to indicate if to calculate the normal or not.
[out]	validNorm	Flag set to true if the solid lies entirely behind or on the exiting surface. It is set false if the solid does not lie entirely behind or on the exiting surface. 'calcNorm' must be true, otherwise it is unused.
[out]	n	The exiting outwards normal vector (undefined Magnitude). 'calcNorm' must be true, otherwise it is unused.

Returns: The distance to exit the shape.

Implements G4VSolid.

Definition at line 624 of file G4VTwistedFaceted.cc.

{
   // DistanceToOut (p, v):
   // Calculate distance to surface of shape from `inside'
   // along with the v, allowing for tolerance.
   // The function returns kInfinity if no intersection or
   // just grazing within tolerance.
 
   //
   // Calculate DistanceToOut(p,v)
   //
   
   EInside currentside = Inside(p);
 
   if (currentside == kOutside)
   {
   }
   else if (currentside == kSurface)
   {
      // particle is just on a boundary.
      // if the particle is exiting from the volume, return 0
      //
      G4ThreeVector normal = SurfaceNormal(p);
      if (normal*v > 0)
      {
            if (calcNorm)
            {
               *norm = normal;
               *validNorm = true;
            }
            // timer.Stop();
            return 0;
      }
   }
      
   // now, we can take smallest positive distance.
   
   // Initialize
   G4double distance = kInfinity;
       
   // find intersections and choose nearest one.
   G4VTwistSurface *surfaces[6];
 
   surfaces[0] = fSide0;
   surfaces[1] = fSide90 ;
   surfaces[2] = fSide180 ;
   surfaces[3] = fSide270 ;
   surfaces[4] = fLowerEndcap;
   surfaces[5] = fUpperEndcap;
 
   G4int besti = -1;
   G4ThreeVector xx;
   G4ThreeVector bestxx;
   for (auto i=0; i<6 ; ++i)
   {
      G4double tmpdistance = surfaces[i]->DistanceToOut(p, v, xx);
      if (tmpdistance < distance)
      {
         distance = tmpdistance;
         bestxx = xx; 
         besti = i;
      }
   }
 
   if (calcNorm)
   {
      if (besti != -1)
      {
         *norm = (surfaces[besti]->GetNormal(p, true));
         *validNorm = surfaces[besti]->IsValidNorm();
      }
   }
 
   return distance;
}

◆ GetAlpha()

G4double G4VTwistedFaceted::GetAlpha ( ) const

inline

Definition at line 178 of file G4VTwistedFaceted.hh.

178{ return fAlph ; }

Referenced by G4TwistedTrap::GetTiltAngleAlpha().

◆ GetCubicVolume()

G4double G4VTwistedFaceted::GetCubicVolume ( )

overridevirtual

Returning an estimation of the solid volume (capacity) and surface area, in internal units.

Reimplemented from G4VSolid.

Definition at line 974 of file G4VTwistedFaceted.cc.

{
  if(fCubicVolume == 0)
  {
    G4AutoLock l(&vtwMutex);
    fCubicVolume = ((fDx1 + fDx2 + fDx3 + fDx4)*(fDy1 + fDy2) +
                    (fDx4 + fDx3 - fDx2 - fDx1)*(fDy2 - fDy1)/3)*fDz;
    l.unlock();
  }
  return fCubicVolume;
}

◆ GetDx1()

G4double G4VTwistedFaceted::GetDx1 ( ) const

inline

Definition at line 169 of file G4VTwistedFaceted.hh.

169{ return fDx1 ; }

Referenced by G4TwistedTrap::GetX1HalfLength(), G4TwistedTrd::GetX1HalfLength(), and G4TwistedBox::GetXHalfLength().

◆ GetDx2()

G4double G4VTwistedFaceted::GetDx2 ( ) const

inline

Definition at line 170 of file G4VTwistedFaceted.hh.

170{ return fDx2 ; }

Referenced by G4TwistedTrap::GetX2HalfLength().

◆ GetDx3()

G4double G4VTwistedFaceted::GetDx3 ( ) const

inline

Definition at line 171 of file G4VTwistedFaceted.hh.

171{ return fDx3 ; }

Referenced by G4TwistedTrd::GetX2HalfLength(), and G4TwistedTrap::GetX3HalfLength().

◆ GetDx4()

G4double G4VTwistedFaceted::GetDx4 ( ) const

inline

Definition at line 172 of file G4VTwistedFaceted.hh.

172{ return fDx4 ; }

Referenced by G4TwistedTrap::GetX4HalfLength().

◆ GetDy1()

G4double G4VTwistedFaceted::GetDy1 ( ) const

inline

Definition at line 173 of file G4VTwistedFaceted.hh.

173{ return fDy1 ; }

Referenced by G4TwistedTrap::GetY1HalfLength(), G4TwistedTrd::GetY1HalfLength(), and G4TwistedBox::GetYHalfLength().

◆ GetDy2()

G4double G4VTwistedFaceted::GetDy2 ( ) const

inline

Definition at line 174 of file G4VTwistedFaceted.hh.

174{ return fDy2 ; }

Referenced by G4TwistedTrap::GetY2HalfLength(), and G4TwistedTrd::GetY2HalfLength().

◆ GetDz()

G4double G4VTwistedFaceted::GetDz ( ) const

inline

Definition at line 175 of file G4VTwistedFaceted.hh.

175{ return fDz ; }

Referenced by G4TwistedBox::GetZHalfLength(), G4TwistedTrap::GetZHalfLength(), and G4TwistedTrd::GetZHalfLength().

◆ GetEntityType()

G4GeometryType G4VTwistedFaceted::GetEntityType ( ) const

overridevirtual

Returns the type ID, "G4VTwistedFaceted" of the solid.

Implements G4VSolid.

Definition at line 1016 of file G4VTwistedFaceted.cc.

{
  return {"G4VTwistedFaceted"};
}

◆ GetExtent()

G4VisExtent G4VTwistedFaceted::GetExtent ( ) const

overridevirtual

Provides extent (bounding box) as possible hint to the graphics view.

Reimplemented from G4VSolid.

Definition at line 838 of file G4VTwistedFaceted.cc.

{
  G4double maxRad = std::sqrt( fDx*fDx + fDy*fDy);
 
  return { -maxRad, maxRad ,
           -maxRad, maxRad ,
           -fDz, fDz };
}

◆ GetPhi()

G4double G4VTwistedFaceted::GetPhi ( ) const

inline

Definition at line 176 of file G4VTwistedFaceted.hh.

176{ return fPhi ; }

Referenced by G4TwistedTrap::GetAzimuthalAnglePhi().

◆ GetPointOnSurface()

G4ThreeVector G4VTwistedFaceted::GetPointOnSurface ( ) const

overridevirtual

Returns a random point located and uniformly distributed on the surface of the solid.

Reimplemented from G4VSolid.

Definition at line 1046 of file G4VTwistedFaceted.cc.

{
 
  G4double phi = fPhiTwist*(G4QuickRand() - 0.5);
  G4double u , umin, umax ;  //  variable for twisted surfaces
  G4double y  ;              //  variable for flat surface (top and bottom)
 
  // Compute the areas. Attention: Only correct for trapezoids
  // where the twisting is done along the z-axis. In the general case
  // the computed surface area is more difficult. However this simplification
  // does not affect the tracking through the solid. 
 
  G4double a1 = fSide0->GetSurfaceArea();
  G4double a2 = fSide90->GetSurfaceArea();
  G4double a3 = fSide180->GetSurfaceArea() ;
  G4double a4 = fSide270->GetSurfaceArea() ;
  G4double a5 = fLowerEndcap->GetSurfaceArea() ;
  G4double a6 = fUpperEndcap->GetSurfaceArea() ;
 
#ifdef G4TWISTDEBUG
  G4cout << "Surface 0   deg = " << a1 << G4endl ;
  G4cout << "Surface 90  deg = " << a2 << G4endl ;
  G4cout << "Surface 180 deg = " << a3 << G4endl ;
  G4cout << "Surface 270 deg = " << a4 << G4endl ;
  G4cout << "Surface Lower   = " << a5 << G4endl ;
  G4cout << "Surface Upper   = " << a6 << G4endl ;
#endif 
 
  G4double chose = (a1 + a2 + a3 + a4 + a5 + a6)*G4QuickRand() ;
 
  if(chose < a1)
  {
    umin = fSide0->GetBoundaryMin(phi) ;
    umax = fSide0->GetBoundaryMax(phi) ;
    u = umin + (umax - umin)*G4QuickRand();
    return  fSide0->SurfacePoint(phi, u, true) ;   // point on 0 deg surface
  }
  if( (chose >= a1) && (chose < a1 + a2 ) )
  {
    umin = fSide90->GetBoundaryMin(phi) ;
    umax = fSide90->GetBoundaryMax(phi) ;
    u = umin + (umax - umin)*G4QuickRand();
    return fSide90->SurfacePoint(phi, u, true);   // point on 90 deg surface
  }
  if( (chose >= a1 + a2 ) && (chose < a1 + a2 + a3 ) )
  {
    umin = fSide180->GetBoundaryMin(phi) ;
    umax = fSide180->GetBoundaryMax(phi) ;
    u = umin + (umax - umin)*G4QuickRand();
    return fSide180->SurfacePoint(phi, u, true); // point on 180 deg surface
  }
  if( (chose >= a1 + a2 + a3  ) && (chose < a1 + a2 + a3 + a4  ) )
  {
    umin = fSide270->GetBoundaryMin(phi) ;
    umax = fSide270->GetBoundaryMax(phi) ;
    u = umin + (umax - umin)*G4QuickRand();
    return fSide270->SurfacePoint(phi, u, true); // point on 270 deg surface
  }
  if( (chose >= a1 + a2 + a3 + a4  ) && (chose < a1 + a2 + a3 + a4 + a5 ) )
  {
    y = fDy1*(2.*G4QuickRand() - 1.);
    umin = fLowerEndcap->GetBoundaryMin(y) ;
    umax = fLowerEndcap->GetBoundaryMax(y) ;
    u = umin + (umax - umin)*G4QuickRand();
    return fLowerEndcap->SurfacePoint(u,y,true); // point on lower endcap
  }
  y = fDy2*(2.*G4QuickRand() - 1.);
  umin = fUpperEndcap->GetBoundaryMin(y) ;
  umax = fUpperEndcap->GetBoundaryMax(y) ;
  u = umin + (umax - umin)*G4QuickRand();
  return fUpperEndcap->SurfacePoint(u,y,true); // point on upper endcap
}

◆ GetPolyhedron()

G4Polyhedron * G4VTwistedFaceted::GetPolyhedron ( ) const

overridevirtual

Smart access function - creates on request and stores for future access. A null pointer means "not available".

Reimplemented from G4VSolid.

Definition at line 1025 of file G4VTwistedFaceted.cc.

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

Referenced by G4TwistedBox::G4TwistedBox(), G4TwistedTrap::G4TwistedTrap(), G4TwistedTrd::G4TwistedTrd(), G4TwistedBox::operator=(), G4TwistedTrap::operator=(), and G4TwistedTrd::operator=().

◆ GetSurfaceArea()

G4double G4VTwistedFaceted::GetSurfaceArea ( )

overridevirtual

Returns an estimation of the solid surface area in internal units. This method may be overloaded by derived classes to compute the exact geometrical quantity for solids where this is possible, or anyway to cache the computed value. Note: the computed value is NOT cached.

Reimplemented from G4VSolid.

Definition at line 989 of file G4VTwistedFaceted.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&vtwMutex);
    G4TwoVector vv[8];
    vv[0] = G4TwoVector(-fDx1 - fDy1*fTAlph,-fDy1);
    vv[1] = G4TwoVector( fDx1 - fDy1*fTAlph,-fDy1);
    vv[2] = G4TwoVector(-fDx2 + fDy1*fTAlph, fDy1);
    vv[3] = G4TwoVector( fDx2 + fDy1*fTAlph, fDy1);
    vv[4] = G4TwoVector(-fDx3 - fDy2*fTAlph,-fDy2);
    vv[5] = G4TwoVector( fDx3 - fDy2*fTAlph,-fDy2);
    vv[6] = G4TwoVector(-fDx4 + fDy2*fTAlph, fDy2);
    vv[7] = G4TwoVector( fDx4 + fDy2*fTAlph, fDy2);
    fSurfaceArea = 2.*(fDy1*(fDx1 + fDx2) + fDy2*(fDx3 + fDx4)) +
      GetLateralFaceArea(vv[0], vv[1], vv[4], vv[5]) +
      GetLateralFaceArea(vv[1], vv[3], vv[5], vv[7]) +
      GetLateralFaceArea(vv[3], vv[2], vv[7], vv[6]) +
      GetLateralFaceArea(vv[2], vv[0], vv[6], vv[4]);
    l.unlock();
  }
  return fSurfaceArea;
}

◆ GetTheta()

G4double G4VTwistedFaceted::GetTheta ( ) const

inline

Definition at line 177 of file G4VTwistedFaceted.hh.

177{ return fTheta ; }

Referenced by G4TwistedTrap::GetPolarAngleTheta().

◆ GetTwistAngle()

G4double G4VTwistedFaceted::GetTwistAngle ( ) const

inline

Accessors.

Definition at line 168 of file G4VTwistedFaceted.hh.

168{ return fPhiTwist; }

Referenced by G4TwistedBox::GetPhiTwist(), G4TwistedTrap::GetPhiTwist(), and G4TwistedTrd::GetPhiTwist().

◆ GetValueA()

G4double G4VTwistedFaceted::GetValueA ( G4double phi ) const

inline

Definition at line 264 of file G4VTwistedFaceted.hh.

{
  return ( fDx4 + fDx2  + ( fDx4 - fDx2 ) * ( 2 * phi ) / fPhiTwist  ) ;
}

Referenced by Xcoef().

◆ GetValueB()

G4double G4VTwistedFaceted::GetValueB ( G4double phi ) const

inline

Definition at line 276 of file G4VTwistedFaceted.hh.

{
  return ( fDy2 + fDy1  + ( fDy2 - fDy1 ) * ( 2 * phi ) / fPhiTwist ) ;
}

Referenced by Inside(), and Xcoef().

◆ GetValueD()

G4double G4VTwistedFaceted::GetValueD ( G4double phi ) const

inline

Definition at line 270 of file G4VTwistedFaceted.hh.

{
  return ( fDx3 + fDx1  + ( fDx3 - fDx1 ) * ( 2 * phi ) / fPhiTwist  ) ;
}

Referenced by Xcoef().

◆ Inside()

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

overridevirtual

Returns the characterisation of a point at offset 'p' respect to the shape.

Parameters

[in] p The point at offset p.

Returns: kOutside if the point is outside the shapes boundaries plus Tolerance/2; kSurface if the point is less than Tolerance/2 from a surface; kInside otherwise.

Implements G4VSolid.

Definition at line 338 of file G4VTwistedFaceted.cc.

{
 
   EInside tmpin = kOutside ;
 
   G4double phi = p.z()/(2*fDz) * fPhiTwist ;  // rotate the point to z=0
   G4double cphi = std::cos(-phi) ;
   G4double sphi = std::sin(-phi) ;
 
   G4double px  = p.x() + fdeltaX * ( -phi/fPhiTwist) ;  // shift
   G4double py  = p.y() + fdeltaY * ( -phi/fPhiTwist) ;
   G4double pz  = p.z() ;
 
   G4double posx = px * cphi - py * sphi   ;  // rotation
   G4double posy = px * sphi + py * cphi   ;
   G4double posz = pz  ;
 
   G4double xMin = Xcoef(posy,phi,fTAlph) - 2*Xcoef(posy,phi,0.) ; 
   G4double xMax = Xcoef(posy,phi,fTAlph) ;  
 
   G4double yMax = GetValueB(phi)/2. ;  // b(phi)/2 is limit
   G4double yMin = -yMax ;
 
#ifdef G4TWISTDEBUG
 
   G4cout << "inside called: p = " << p << G4endl ; 
   G4cout << "fDx1 = " << fDx1 << G4endl ;
   G4cout << "fDx2 = " << fDx2 << G4endl ;
   G4cout << "fDx3 = " << fDx3 << G4endl ;
   G4cout << "fDx4 = " << fDx4 << G4endl ;
 
   G4cout << "fDy1 = " << fDy1 << G4endl ;
   G4cout << "fDy2 = " << fDy2 << G4endl ;
 
   G4cout << "fDz  = " << fDz  << G4endl ;
 
   G4cout << "Tilt angle alpha = " << fAlph << G4endl ;
   G4cout << "phi,theta = " << fPhi << " , " << fTheta << G4endl ;
 
   G4cout << "Twist angle = " << fPhiTwist << G4endl ;
 
   G4cout << "posx = " << posx << G4endl ;
   G4cout << "posy = " << posy << G4endl ;
   G4cout << "xMin = " << xMin << G4endl ;
   G4cout << "xMax = " << xMax << G4endl ;
   G4cout << "yMin = " << yMin << G4endl ;
   G4cout << "yMax = " << yMax << G4endl ;
 
#endif 
 
 
  if ( posx <= xMax - kCarTolerance*0.5
    && posx >= xMin + kCarTolerance*0.5 )
  {
    if ( posy <= yMax - kCarTolerance*0.5
      && posy >= yMin + kCarTolerance*0.5 )
    {
      if      (std::fabs(posz) <= fDz - kCarTolerance*0.5 )
      {
        tmpin = kInside ;
      }
      else if (std::fabs(posz) <= fDz + kCarTolerance*0.5 )
      {
        tmpin = kSurface ;
      }
    }
    else if ( posy <= yMax + kCarTolerance*0.5
           && posy >= yMin - kCarTolerance*0.5 )
    {
      if (std::fabs(posz) <= fDz + kCarTolerance*0.5 ) { tmpin = kSurface ; }
    }
  }
  else if ( posx <= xMax + kCarTolerance*0.5
         && posx >= xMin - kCarTolerance*0.5 )
  {
    if ( posy <= yMax + kCarTolerance*0.5
      && posy >= yMin - kCarTolerance*0.5 )
    {
      if (std::fabs(posz) <= fDz + kCarTolerance*0.5) { tmpin = kSurface ; }
    }
  }
 
#ifdef G4TWISTDEBUG
  G4cout << "inside = " << tmpin << G4endl ;
#endif
 
  return tmpin;
 
}

Referenced by DistanceToIn(), DistanceToIn(), DistanceToOut(), and DistanceToOut().

◆ operator=()

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

Definition at line 235 of file G4VTwistedFaceted.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   fTheta = rhs.fTheta; fPhi = rhs.fPhi;
   fDy1= rhs.fDy1; fDx1= rhs.fDx1; fDx2= rhs.fDx2; fDy2= rhs.fDy2;
   fDx3= rhs.fDx3; fDx4= rhs.fDx4; fDz= rhs.fDz; fDx= rhs.fDx; fDy= rhs.fDy;
   fAlph= rhs.fAlph; fTAlph= rhs.fTAlph; fdeltaX= rhs.fdeltaX;
   fdeltaY= rhs.fdeltaY; fPhiTwist= rhs.fPhiTwist; fLowerEndcap= nullptr;
   fUpperEndcap= nullptr; fSide0= nullptr; fSide90= nullptr; fSide180= nullptr; fSide270= nullptr;
   fCubicVolume= rhs.fCubicVolume; fSurfaceArea= rhs.fSurfaceArea;
   fRebuildPolyhedron = false;
   delete fpPolyhedron; fpPolyhedron = nullptr;
 
   CreateSurfaces();
 
   return *this;
}

Referenced by G4TwistedBox::operator=(), G4TwistedTrap::operator=(), and G4TwistedTrd::operator=().

◆ StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 792 of file G4VTwistedFaceted.cc.

{
  //
  // Stream object contents to an output stream
  //
  G4long oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: G4VTwistedFaceted\n"
     << " Parameters: \n"
     << "  polar angle theta = "   <<  fTheta/degree      << " deg" << G4endl
     << "  azimuthal angle phi = "  << fPhi/degree        << " deg" << G4endl  
     << "  tilt angle  alpha = "   << fAlph/degree        << " deg" << G4endl  
     << "  TWIST angle = "         << fPhiTwist/degree    << " deg" << G4endl  
     << "  Half length along y (lower endcap) = "         << fDy1/cm << " cm"
     << G4endl 
     << "  Half length along x (lower endcap, bottom) = " << fDx1/cm << " cm"
     << G4endl 
     << "  Half length along x (lower endcap, top) = "    << fDx2/cm << " cm"
     << G4endl 
     << "  Half length along y (upper endcap) = "         << fDy2/cm << " cm"
     << G4endl 
     << "  Half length along x (upper endcap, bottom) = " << fDx3/cm << " cm"
     << G4endl 
     << "  Half length along x (upper endcap, top) = "    << fDx4/cm << " cm"
     << G4endl 
     << "-----------------------------------------------------------\n";
  os.precision(oldprc);
 
  return os;
}

◆ SurfaceNormal()

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

overridevirtual

Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset 'p'.

Parameters

[in] p The point at offset p.

Returns: The outwards pointing unit normal.

Implements G4VSolid.

Definition at line 432 of file G4VTwistedFaceted.cc.

{
   //
   // return the normal unit vector to the Hyperbolical Surface at a point 
   // p on (or nearly on) the surface
   //
   // Which of the three or four surfaces are we closest to?
   //
 
 
   G4double distance = kInfinity;
 
   G4VTwistSurface* surfaces[6];
 
   surfaces[0] = fSide0 ;
   surfaces[1] = fSide90 ;
   surfaces[2] = fSide180 ;
   surfaces[3] = fSide270 ;
   surfaces[4] = fLowerEndcap;
   surfaces[5] = fUpperEndcap;
 
   G4ThreeVector xx;
   G4ThreeVector bestxx;
   G4int i;
   G4int besti = -1;
   for (i=0; i< 6; i++)
   {
      G4double tmpdistance = surfaces[i]->DistanceTo(p, xx);
      if (tmpdistance < distance)
      {
         distance = tmpdistance;
         bestxx = xx;
         besti = i; 
      }
   }
 
   return surfaces[besti]->GetNormal(bestxx, true);
}

Referenced by DistanceToIn(), and DistanceToOut().

◆ Xcoef()

G4double G4VTwistedFaceted::Xcoef	(	G4double	u,
		G4double	phi,
		G4double	ftg ) const

inline

Definition at line 282 of file G4VTwistedFaceted.hh.

{
  return GetValueA(phi)/2. + (GetValueD(phi)-GetValueA(phi))/4.
    - u*( ( GetValueD(phi)-GetValueA(phi) ) / ( 2 * GetValueB(phi) ) - ftg );
}

Referenced by Inside().

Member Data Documentation

◆ fCubicVolume

G4double G4VTwistedFaceted::fCubicVolume = 0.0

protected

Definition at line 207 of file G4VTwistedFaceted.hh.

Referenced by G4VTwistedFaceted(), G4TwistedBox::GetCubicVolume(), G4TwistedTrd::GetCubicVolume(), GetCubicVolume(), and operator=().

◆ fpPolyhedron

G4Polyhedron* G4VTwistedFaceted::fpPolyhedron = nullptr

mutableprotected

Definition at line 205 of file G4VTwistedFaceted.hh.

Referenced by G4TwistedBox::G4TwistedBox(), G4TwistedTrap::G4TwistedTrap(), G4TwistedTrd::G4TwistedTrd(), GetPolyhedron(), G4TwistedBox::operator=(), G4TwistedTrap::operator=(), G4TwistedTrd::operator=(), operator=(), and ~G4VTwistedFaceted().

◆ fRebuildPolyhedron

G4bool G4VTwistedFaceted::fRebuildPolyhedron = false

mutableprotected

Definition at line 204 of file G4VTwistedFaceted.hh.

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

◆ fSurfaceArea

G4double G4VTwistedFaceted::fSurfaceArea = 0.0

protected

Definition at line 208 of file G4VTwistedFaceted.hh.

Referenced by G4VTwistedFaceted(), G4TwistedBox::GetSurfaceArea(), G4TwistedTrd::GetSurfaceArea(), GetSurfaceArea(), and operator=().

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

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4VTwistedFaceted() [1/3]

◆ ~G4VTwistedFaceted()

◆ G4VTwistedFaceted() [2/3]

◆ G4VTwistedFaceted() [3/3]

Member Function Documentation

◆ BoundingLimits()

◆ CalculateExtent()

◆ ComputeDimensions()

◆ CreatePolyhedron()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetAlpha()

◆ GetCubicVolume()

◆ GetDx1()

◆ GetDx2()

◆ GetDx3()

◆ GetDx4()

◆ GetDy1()

◆ GetDy2()

◆ GetDz()

◆ GetEntityType()

◆ GetExtent()

◆ GetPhi()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ GetTheta()

◆ GetTwistAngle()

◆ GetValueA()

◆ GetValueB()

◆ GetValueD()

◆ Inside()

◆ operator=()

◆ StreamInfo()

◆ SurfaceNormal()

◆ Xcoef()

Member Data Documentation

◆ fCubicVolume

◆ fpPolyhedron

◆ fRebuildPolyhedron

◆ fSurfaceArea