G4VTwistedFaceted Class Reference

#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
G4ThreeVector	GetPointInSolid (G4double z) const
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4Polyhedron *	CreatePolyhedron () const override
G4Polyhedron *	GetPolyhedron () 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
G4VisExtent	GetExtent () const override
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 ()
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__ &)
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) 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

Definition at line 48 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 )

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

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

)

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

)

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

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

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

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

Reimplemented from G4VSolid.

Definition at line 1143 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

Implements G4VSolid.

Definition at line 823 of file G4VTwistedFaceted.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 548 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

Implements G4VSolid.

Definition at line 469 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

Implements G4VSolid.

Definition at line 702 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

Implements G4VSolid.

Definition at line 618 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 122 of file G4VTwistedFaceted.hh.

{ return fAlph  ; }

Referenced by G4TwistedTrap::GetTiltAngleAlpha().

GetCubicVolume()

G4double G4VTwistedFaceted::GetCubicVolume ( )

overridevirtual

Reimplemented from G4VSolid.

Definition at line 893 of file G4VTwistedFaceted.cc.

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

GetDx1()

G4double G4VTwistedFaceted::GetDx1 ( ) const

inline

Definition at line 113 of file G4VTwistedFaceted.hh.

{ return fDx1   ; }

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

GetDx2()

G4double G4VTwistedFaceted::GetDx2 ( ) const

inline

Definition at line 114 of file G4VTwistedFaceted.hh.

{ return fDx2   ; }

Referenced by G4TwistedTrap::GetX2HalfLength().

GetDx3()

G4double G4VTwistedFaceted::GetDx3 ( ) const

inline

Definition at line 115 of file G4VTwistedFaceted.hh.

{ return fDx3   ; }

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

GetDx4()

G4double G4VTwistedFaceted::GetDx4 ( ) const

inline

Definition at line 116 of file G4VTwistedFaceted.hh.

{ return fDx4   ; }

Referenced by G4TwistedTrap::GetX4HalfLength().

GetDy1()

G4double G4VTwistedFaceted::GetDy1 ( ) const

inline

Definition at line 117 of file G4VTwistedFaceted.hh.

{ return fDy1   ; }

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

GetDy2()

G4double G4VTwistedFaceted::GetDy2 ( ) const

inline

Definition at line 118 of file G4VTwistedFaceted.hh.

{ return fDy2   ; }

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

GetDz()

G4double G4VTwistedFaceted::GetDz ( ) const

inline

Definition at line 119 of file G4VTwistedFaceted.hh.

{ return fDz    ; }

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

GetEntityType()

G4GeometryType G4VTwistedFaceted::GetEntityType ( ) const

overridevirtual

Implements G4VSolid.

Definition at line 1006 of file G4VTwistedFaceted.cc.

{
  return {"G4VTwistedFaceted"};
}

GetExtent()

G4VisExtent G4VTwistedFaceted::GetExtent ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 832 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 120 of file G4VTwistedFaceted.hh.

{ return fPhi   ; }

Referenced by G4TwistedTrap::GetAzimuthalAnglePhi().

GetPointInSolid()

G4ThreeVector G4VTwistedFaceted::GetPointInSolid

(

G4double

z

)

const

Definition at line 1036 of file G4VTwistedFaceted.cc.

{
 
 
  // this routine is only used for a test
  // can be deleted ...
 
  if ( z == fDz ) z -= 0.1*fDz ;
  if ( z == -fDz ) z += 0.1*fDz ;
 
  G4double phi = z/(2*fDz)*fPhiTwist ;
 
  return { fdeltaX * phi/fPhiTwist, fdeltaY * phi/fPhiTwist, z };
}

GetPointOnSurface()

G4ThreeVector G4VTwistedFaceted::GetPointOnSurface ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 1055 of file G4VTwistedFaceted.cc.

{
 
  G4double phi = G4RandFlat::shoot(-fPhiTwist/2.,fPhiTwist/2.);
  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 = G4RandFlat::shoot(0.,a1 + a2 + a3 + a4 + a5 + a6) ;
 
  if(chose < a1)
  {
    umin = fSide0->GetBoundaryMin(phi) ;
    umax = fSide0->GetBoundaryMax(phi) ;
    u = G4RandFlat::shoot(umin,umax) ;
 
    return  fSide0->SurfacePoint(phi, u, true) ;   // point on 0deg surface
  }
 
  else if( (chose >= a1) && (chose < a1 + a2 ) )
  {
    umin = fSide90->GetBoundaryMin(phi) ;
    umax = fSide90->GetBoundaryMax(phi) ;
    
    u = G4RandFlat::shoot(umin,umax) ;
 
    return fSide90->SurfacePoint(phi, u, true);   // point on 90deg surface
  }
  else if( (chose >= a1 + a2 ) && (chose < a1 + a2 + a3 ) )
  {
    umin = fSide180->GetBoundaryMin(phi) ;
    umax = fSide180->GetBoundaryMax(phi) ;
    u = G4RandFlat::shoot(umin,umax) ;
 
    return fSide180->SurfacePoint(phi, u, true); // point on 180 deg surface
  }
  else if( (chose >= a1 + a2 + a3  ) && (chose < a1 + a2 + a3 + a4  ) )
  {
    umin = fSide270->GetBoundaryMin(phi) ;
    umax = fSide270->GetBoundaryMax(phi) ;
    u = G4RandFlat::shoot(umin,umax) ;
    return fSide270->SurfacePoint(phi, u, true); // point on 270 deg surface
  }
  else if( (chose >= a1 + a2 + a3 + a4  ) && (chose < a1 + a2 + a3 + a4 + a5 ) )
  {
    y = G4RandFlat::shoot(-fDy1,fDy1) ;
    umin = fLowerEndcap->GetBoundaryMin(y) ;
    umax = fLowerEndcap->GetBoundaryMax(y) ;
    u = G4RandFlat::shoot(umin,umax) ;
 
    return fLowerEndcap->SurfacePoint(u,y,true); // point on lower endcap
  }
  else
  {
    y = G4RandFlat::shoot(-fDy2,fDy2) ;
    umin = fUpperEndcap->GetBoundaryMin(y) ;
    umax = fUpperEndcap->GetBoundaryMax(y) ;
    u = G4RandFlat::shoot(umin,umax) ;
 
    return fUpperEndcap->SurfacePoint(u,y,true) ; // point on upper endcap
 
  }
}

GetPolyhedron()

G4Polyhedron * G4VTwistedFaceted::GetPolyhedron ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 1015 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

Reimplemented from G4VSolid.

Definition at line 981 of file G4VTwistedFaceted.cc.

{
  if (fSurfaceArea == 0.)
  {
    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]);
  }
  return fSurfaceArea;
}

GetTheta()

G4double G4VTwistedFaceted::GetTheta ( ) const

inline

Definition at line 121 of file G4VTwistedFaceted.hh.

{ return fTheta ; }

Referenced by G4TwistedTrap::GetPolarAngleTheta().

GetTwistAngle()

G4double G4VTwistedFaceted::GetTwistAngle ( ) const

inline

Definition at line 111 of file G4VTwistedFaceted.hh.

{ return fPhiTwist; }

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

GetValueA()

G4double G4VTwistedFaceted::GetValueA ( G4double phi ) const

inline

Definition at line 198 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 210 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 204 of file G4VTwistedFaceted.hh.

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

Referenced by Xcoef().

Inside()

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

overridevirtual

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

Implements G4VSolid.

Definition at line 786 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

Implements G4VSolid.

Definition at line 426 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 216 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 148 of file G4VTwistedFaceted.hh.

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

fpPolyhedron

G4Polyhedron* G4VTwistedFaceted::fpPolyhedron = nullptr

mutableprotected

Definition at line 146 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 145 of file G4VTwistedFaceted.hh.

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

fSurfaceArea

G4double G4VTwistedFaceted::fSurfaceArea = 0.0

protected

Definition at line 149 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:

• G4VTwistedFaceted.hh
• G4VTwistedFaceted.cc