G4TwistTubsFlatSide Class Reference

#include <G4TwistTubsFlatSide.hh>

Inheritance diagram for G4TwistTubsFlatSide:

Public Member Functions
	G4TwistTubsFlatSide (const G4String &name, const G4RotationMatrix &rot, const G4ThreeVector &tlate, const G4ThreeVector &n, const EAxis axis1=kRho, const EAxis axis2=kPhi, G4double axis0min=-kInfinity, G4double axis1min=-kInfinity, G4double axis0max=kInfinity, G4double axis1max=kInfinity)
	G4TwistTubsFlatSide (const G4String &name, G4double EndInnerRadius[2], G4double EndOuterRadius[2], G4double DPhi, G4double EndPhi[2], G4double EndZ[2], G4int handedness)
	~G4TwistTubsFlatSide () override
G4ThreeVector	GetNormal (const G4ThreeVector &, G4bool isGlobal=false) override
G4int	DistanceToSurface (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector gxx[], G4double distance[], G4int areacode[], G4bool isvalid[], EValidate validate=kValidateWithTol) override
G4int	DistanceToSurface (const G4ThreeVector &gp, G4ThreeVector gxx[], G4double distance[], G4int areacode[]) override
G4ThreeVector	SurfacePoint (G4double, G4double, G4bool isGlobal=false) override
G4double	GetBoundaryMin (G4double phi) override
G4double	GetBoundaryMax (G4double phi) override
G4double	GetSurfaceArea () override
void	GetFacets (G4int m, G4int n, G4double xyz[][3], G4int faces[][4], G4int iside) override
	G4TwistTubsFlatSide (__void__ &)
Public Member Functions inherited from G4VTwistSurface
	G4VTwistSurface (const G4String &name)
	G4VTwistSurface (const G4String &name, const G4RotationMatrix &rot, const G4ThreeVector &tlate, G4int handedness, const EAxis axis1, const EAxis axis2, G4double axis0min=-kInfinity, G4double axis1min=-kInfinity, G4double axis0max=kInfinity, G4double axis1max=kInfinity)
virtual	~G4VTwistSurface ()
virtual G4int	AmIOnLeftSide (const G4ThreeVector &me, const G4ThreeVector &vec, G4bool withTol=true)
virtual G4double	DistanceToBoundary (G4int areacode, G4ThreeVector &xx, const G4ThreeVector &p)
virtual G4double	DistanceToIn (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)
virtual G4double	DistanceToOut (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)
virtual G4double	DistanceTo (const G4ThreeVector &gp, G4ThreeVector &gxx)
void	DebugPrint () const
virtual G4String	GetName () const
virtual void	GetBoundaryParameters (const G4int &areacode, G4ThreeVector &d, G4ThreeVector &x0, G4int &boundarytype) const
virtual G4ThreeVector	GetBoundaryAtPZ (G4int areacode, const G4ThreeVector &p) const
G4double	DistanceToPlaneWithV (const G4ThreeVector &p, const G4ThreeVector &v, const G4ThreeVector &x0, const G4ThreeVector &n0, G4ThreeVector &xx)
G4double	DistanceToPlane (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &n0, G4ThreeVector &xx)
G4double	DistanceToPlane (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &t1, const G4ThreeVector &t2, G4ThreeVector &xx, G4ThreeVector &n)
G4double	DistanceToLine (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &d, G4ThreeVector &xx)
G4bool	IsAxis0 (G4int areacode) const
G4bool	IsAxis1 (G4int areacode) const
G4bool	IsOutside (G4int areacode) const
G4bool	IsInside (G4int areacode, G4bool testbitmode=false) const
G4bool	IsBoundary (G4int areacode, G4bool testbitmode=false) const
G4bool	IsCorner (G4int areacode, G4bool testbitmode=false) const
G4bool	IsValidNorm () const
G4bool	IsSameBoundary (G4VTwistSurface *surface1, G4int areacode1, G4VTwistSurface *surface2, G4int areacode2) const
G4int	GetAxisType (G4int areacode, G4int whichaxis) const
G4ThreeVector	ComputeGlobalPoint (const G4ThreeVector &lp) const
G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &gp) const
G4ThreeVector	ComputeGlobalDirection (const G4ThreeVector &lp) const
G4ThreeVector	ComputeLocalDirection (const G4ThreeVector &gp) const
void	SetAxis (G4int i, const EAxis axis)
void	SetNeighbours (G4VTwistSurface *ax0min, G4VTwistSurface *ax1min, G4VTwistSurface *ax0max, G4VTwistSurface *ax1max)
G4int	GetNode (G4int i, G4int j, G4int m, G4int n, G4int iside)
G4int	GetFace (G4int i, G4int j, G4int m, G4int n, G4int iside)
G4int	GetEdgeVisibility (G4int i, G4int j, G4int m, G4int n, G4int number, G4int orientation)
	G4VTwistSurface (__void__ &)

Protected Member Functions
G4int	GetAreaCode (const G4ThreeVector &xx, G4bool withTol=true) override
Protected Member Functions inherited from G4VTwistSurface
G4VTwistSurface **	GetNeighbours ()
G4int	GetNeighbours (G4int areacode, G4VTwistSurface *surfaces[])
G4ThreeVector	GetCorner (G4int areacode) const
void	GetBoundaryAxis (G4int areacode, EAxis axis[]) const
void	GetBoundaryLimit (G4int areacode, G4double limit[]) const
virtual void	SetBoundary (const G4int &axiscode, const G4ThreeVector &direction, const G4ThreeVector &x0, const G4int &boundarytype)
void	SetCorner (G4int areacode, G4double x, G4double y, G4double z)

Additional Inherited Members
Public Types inherited from G4VTwistSurface
enum	EValidate { kDontValidate = 0 , kValidateWithTol = 1 , kValidateWithoutTol = 2 , kUninitialized = 3 }
Static Public Attributes inherited from G4VTwistSurface
static const G4int	sOutside = 0x00000000
static const G4int	sInside = 0x10000000
static const G4int	sBoundary = 0x20000000
static const G4int	sCorner = 0x40000000
static const G4int	sC0Min1Min = 0x40000101
static const G4int	sC0Max1Min = 0x40000201
static const G4int	sC0Max1Max = 0x40000202
static const G4int	sC0Min1Max = 0x40000102
static const G4int	sAxisMin = 0x00000101
static const G4int	sAxisMax = 0x00000202
static const G4int	sAxisX = 0x00000404
static const G4int	sAxisY = 0x00000808
static const G4int	sAxisZ = 0x00000C0C
static const G4int	sAxisRho = 0x00001010
static const G4int	sAxisPhi = 0x00001414
static const G4int	sAxis0 = 0x0000FF00
static const G4int	sAxis1 = 0x000000FF
static const G4int	sSizeMask = 0x00000303
static const G4int	sAxisMask = 0x0000FCFC
static const G4int	sAreaMask = 0XF0000000
Protected Attributes inherited from G4VTwistSurface
EAxis	fAxis [2]
G4double	fAxisMin [2]
G4double	fAxisMax [2]
CurrentStatus	fCurStatWithV
CurrentStatus	fCurStat
G4RotationMatrix	fRot
G4ThreeVector	fTrans
G4int	fHandedness
G4SurfCurNormal	fCurrentNormal
G4bool	fIsValidNorm
G4double	kCarTolerance

Detailed Description

Definition at line 41 of file G4TwistTubsFlatSide.hh.

Constructor & Destructor Documentation

G4TwistTubsFlatSide() [1/3]

G4TwistTubsFlatSide::G4TwistTubsFlatSide	(	const G4String &	name,
		const G4RotationMatrix &	rot,
		const G4ThreeVector &	tlate,
		const G4ThreeVector &	n,
		const EAxis	axis1 = kRho,
		const EAxis	axis2 = kPhi,
		G4double	axis0min = -kInfinity,
		G4double	axis1min = -kInfinity,
		G4double	axis0max = kInfinity,
		G4double	axis1max = kInfinity )

Definition at line 39 of file G4TwistTubsFlatSide.cc.

  : G4VTwistSurface(name, rot, tlate, 0, axis0, axis1,
                    axis0min, axis1min, axis0max, axis1max)
{   
   if (axis0 == kPhi && axis1 == kRho)
   {
      G4Exception("G4TwistTubsFlatSide::G4TwistTubsFlatSide()",
                  "GeomSolids0002", FatalErrorInArgument,
                  "Should swap axis0 and axis1!");
   }
   
   G4ThreeVector normal = rot.inverse()*n;
   fCurrentNormal.normal = normal.unit();   // in local coordinate system
   fIsValidNorm = true;
 
   SetCorners();
   SetBoundaries();
 
   fSurfaceArea = 1. ;  // NOTE: not yet implemented!
}

G4TwistTubsFlatSide() [2/3]

G4TwistTubsFlatSide::G4TwistTubsFlatSide	(	const G4String &	name,
		G4double	EndInnerRadius[2],
		G4double	EndOuterRadius[2],
		G4double	DPhi,
		G4double	EndPhi[2],
		G4double	EndZ[2],
		G4int	handedness )

Definition at line 69 of file G4TwistTubsFlatSide.cc.

  : G4VTwistSurface(name)
{
   fHandedness = handedness;   // +z = +ve, -z = -ve
   fAxis[0]    = kRho;         // in local coordinate system
   fAxis[1]    = kPhi;
   G4int i     = (handedness < 0 ? 0 : 1);
   fAxisMin[0] = EndInnerRadius[i];  // Inner-hype radius at z=0
   fAxisMax[0] = EndOuterRadius[i];  // Outer-hype radius at z=0
   fAxisMin[1] = -0.5*DPhi;
   fAxisMax[1] = -fAxisMin[1];
   fCurrentNormal.normal.set(0, 0, (fHandedness < 0 ? -1 : 1)); 
         // Unit vector, in local coordinate system
   fRot.rotateZ(EndPhi[i]);
   fTrans.set(0, 0, EndZ[i]);
   fIsValidNorm = true;
 
   SetCorners();
   SetBoundaries();
 
   fSurfaceArea =  0.5*DPhi * (EndOuterRadius[i]*EndOuterRadius[i]  
                             - EndInnerRadius[i]*EndInnerRadius[i] ) ;
}

~G4TwistTubsFlatSide()

G4TwistTubsFlatSide::~G4TwistTubsFlatSide ( )

overridedefault

G4TwistTubsFlatSide() [3/3]

G4TwistTubsFlatSide::G4TwistTubsFlatSide

(

__void__ &

a

)

Definition at line 102 of file G4TwistTubsFlatSide.cc.

  : G4VTwistSurface(a)
{
}

Member Function Documentation

DistanceToSurface() [1/2]

G4int G4TwistTubsFlatSide::DistanceToSurface ( const G4ThreeVector & gp, const G4ThreeVector & gv, G4ThreeVector gxx[], G4double distance[], G4int areacode[], G4bool isvalid[], EValidate validate = kValidateWithTol )

overridevirtual

Implements G4VTwistSurface.

Definition at line 131 of file G4TwistTubsFlatSide.cc.

{
   fCurStatWithV.ResetfDone(validate, &gp, &gv);
   
   if (fCurStatWithV.IsDone())
   {
      for (G4int i=0; i<fCurStatWithV.GetNXX(); ++i)
      {
         gxx[i] = fCurStatWithV.GetXX(i);
         distance[i] = fCurStatWithV.GetDistance(i);
         areacode[i] = fCurStatWithV.GetAreacode(i);
         isvalid[i]  = fCurStatWithV.IsValid(i);
      }
      return fCurStatWithV.GetNXX();
   }
   else  // initialize
   {
      for (G4int i=0; i<2; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         isvalid[i]  = false;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
 
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector v = ComputeLocalDirection(gv);
 
   //
   // special case!
   // if p is on surface, distance = 0. 
   //
 
   if (std::fabs(p.z()) == 0.)    // if p is on the plane
   {
      distance[0] = 0;
      G4ThreeVector xx = p;
      gxx[0] = ComputeGlobalPoint(xx);
      
      if (validate == kValidateWithTol)
      {
         areacode[0] = GetAreaCode(xx);
         if (!IsOutside(areacode[0]))
         {
            isvalid[0] = true;
         }
      }
      else if (validate == kValidateWithoutTol)
      {
         areacode[0] = GetAreaCode(xx, false);
         if (IsInside(areacode[0]))
         {
            isvalid[0] = true;
         }
      }
      else  // kDontValidate
      {
         areacode[0] = sInside;
         isvalid[0] = true;
      }
      return 1;
   }
   //
   // special case end
   //
   
   if (v.z() == 0)
   { 
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0], 
                                     isvalid[0], 0, validate, &gp, &gv);
      return 0;
   }
   
   distance[0] = - (p.z() / v.z());
      
   G4ThreeVector xx = p + distance[0]*v;
   gxx[0] = ComputeGlobalPoint(xx);
 
   if (validate == kValidateWithTol)
   {
      areacode[0] = GetAreaCode(xx);
      if (!IsOutside(areacode[0]))
      {
         if (distance[0] >= 0) isvalid[0] = true;
      }
   }
   else if (validate == kValidateWithoutTol)
   {
      areacode[0] = GetAreaCode(xx, false);
      if (IsInside(areacode[0]))
      {
         if (distance[0] >= 0) isvalid[0] = true;
      }
   }
   else  // kDontValidate
   {
      areacode[0] = sInside;
         if (distance[0] >= 0) isvalid[0] = true;
   }
 
   fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                  isvalid[0], 1, validate, &gp, &gv);
 
#ifdef G4TWISTDEBUG
   G4cerr << "ERROR - G4TwistTubsFlatSide::DistanceToSurface(p,v)" << G4endl;
   G4cerr << "        Name        : " << GetName() << G4endl;
   G4cerr << "        xx          : " << xx << G4endl;
   G4cerr << "        gxx[0]      : " << gxx[0] << G4endl;
   G4cerr << "        dist[0]     : " << distance[0] << G4endl;
   G4cerr << "        areacode[0] : " << areacode[0] << G4endl;
   G4cerr << "        isvalid[0]  : " << isvalid[0]  << G4endl;
#endif
   return 1;
}

DistanceToSurface() [2/2]

G4int G4TwistTubsFlatSide::DistanceToSurface ( const G4ThreeVector & gp, G4ThreeVector gxx[], G4double distance[], G4int areacode[] )

overridevirtual

Implements G4VTwistSurface.

Definition at line 256 of file G4TwistTubsFlatSide.cc.

{
   // Calculate distance to plane in local coordinate,
   // then return distance and global intersection points.
   //  
 
   fCurStat.ResetfDone(kDontValidate, &gp);
 
   if (fCurStat.IsDone())
   {
      for (G4int i=0; i<fCurStat.GetNXX(); ++i)
      {
         gxx[i] = fCurStat.GetXX(i);
         distance[i] = fCurStat.GetDistance(i);
         areacode[i] = fCurStat.GetAreacode(i);
      }
      return fCurStat.GetNXX();
   }
   else   // initialize
   {
      for (auto i=0; i<2; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
   
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector xx;
 
   // The plane is placed on origin with making its normal 
   // parallel to z-axis. 
   if (std::fabs(p.z()) <= 0.5 * kCarTolerance) // if p is on plane, return 1
   {
     distance[0] = 0;
      xx = p;
   }
   else
   {
      distance[0] = std::fabs(p.z());
      xx.set(p.x(), p.y(), 0);  
   }
 
   gxx[0] = ComputeGlobalPoint(xx);
   areacode[0] = sInside;
   G4bool isvalid = true;
   fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                             isvalid, 1, kDontValidate, &gp);
   return 1;
}

GetAreaCode()

G4int G4TwistTubsFlatSide::GetAreaCode ( const G4ThreeVector & xx, G4bool withTol = true )

overrideprotectedvirtual

Implements G4VTwistSurface.

Definition at line 314 of file G4TwistTubsFlatSide.cc.

{
   const G4double rtol
     = 0.5*G4GeometryTolerance::GetInstance()->GetRadialTolerance();
   
   G4int areacode = sInside;
 
   if (fAxis[0] == kRho && fAxis[1] == kPhi)
   {
      G4int rhoaxis = 0;
 
      G4ThreeVector dphimin;   // direction of phi-minimum boundary
      G4ThreeVector dphimax;   // direction of phi-maximum boundary
      dphimin = GetCorner(sC0Max1Min);
      dphimax = GetCorner(sC0Max1Max);   
      
      if (withTol)
      {
         G4bool isoutside = false;
 
         // test boundary of rho-axis
 
         if (xx.getRho() <= fAxisMin[rhoaxis] + rtol)
         {
            areacode |= (sAxis0 & (sAxisRho|sAxisMin)) | sBoundary; // rho-min
            if (xx.getRho() < fAxisMin[rhoaxis] - rtol) isoutside = true; 
            
         }
         else if (xx.getRho() >= fAxisMax[rhoaxis] - rtol)
         {
            areacode |= (sAxis0 & (sAxisRho|sAxisMax)) | sBoundary; // rho-max
            if (xx.getRho() > fAxisMax[rhoaxis] + rtol) isoutside = true;
         }         
         
         // test boundary of phi-axis
 
         if (AmIOnLeftSide(xx, dphimin) >= 0)            // xx is on dphimin
         {
            areacode |= (sAxis1 & (sAxisPhi | sAxisMin)); 
            if   ((areacode & sBoundary) != 0) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary;
 
            if (AmIOnLeftSide(xx, dphimin) > 0) isoutside = true; 
 
         }
         else if (AmIOnLeftSide(xx, dphimax) <= 0)       // xx is on dphimax
         {
            areacode |= (sAxis1 & (sAxisPhi | sAxisMax)); 
            if   ((areacode & sBoundary) != 0) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary;
 
            if (AmIOnLeftSide(xx, dphimax) < 0) isoutside = true;
         }
         
         // if isoutside = true, clear inside bit.
         // if not on boundary, add axis information. 
 
         if (isoutside)
         {
            G4int tmpareacode = areacode & (~sInside);
            areacode = tmpareacode;
         }
         else if ((areacode & sBoundary) != sBoundary)
         {
            areacode |= (sAxis0 & sAxisRho) | (sAxis1 & sAxisPhi);
         }
 
      }
      else
      {
         // out of boundary of rho-axis
 
         if (xx.getRho() < fAxisMin[rhoaxis])
         {
            areacode |= (sAxis0 & (sAxisRho | sAxisMin)) | sBoundary;
         }
         else if (xx.getRho() > fAxisMax[rhoaxis])
         {
            areacode |= (sAxis0 & (sAxisRho | sAxisMax)) | sBoundary;
         }
         
         // out of boundary of phi-axis
 
         if (AmIOnLeftSide(xx, dphimin, false) >= 0)  // xx is leftside or
         {
           areacode |= (sAxis1 & (sAxisPhi | sAxisMin)) ; // boundary of dphimin
           if   ((areacode & sBoundary) != 0) areacode |= sCorner; // xx is on corner
           else                        areacode |= sBoundary;
 
         }
         else if (AmIOnLeftSide(xx, dphimax, false) <= 0) // xx is rightside or
         {
           areacode |= (sAxis1 & (sAxisPhi | sAxisMax)); // boundary of dphimax
           if   ((areacode & sBoundary) != 0) areacode |= sCorner;  // xx is on corner
           else                        areacode |= sBoundary;
           
         }
 
         if ((areacode & sBoundary) != sBoundary) {
            areacode |= (sAxis0 & sAxisRho) | (sAxis1 & sAxisPhi);
         }
 
      }
      return areacode;
   }
   else
   {
      std::ostringstream message;
      message << "Feature NOT implemented !" << G4endl
              << "        fAxis[0] = " << fAxis[0] << G4endl
              << "        fAxis[1] = " << fAxis[1];
      G4Exception("G4TwistTubsFlatSide::GetAreaCode()", "GeomSolids0001",
                  FatalException, message);
   }
   return areacode;
}

Referenced by DistanceToSurface().

GetBoundaryMax()

G4double G4TwistTubsFlatSide::GetBoundaryMax ( G4double phi )

inlineoverridevirtual

Implements G4VTwistSurface.

Definition at line 125 of file G4TwistTubsFlatSide.hh.

{
  G4ThreeVector dphimax = GetCorner(sC0Max1Max);   
  return  std::atan2( dphimax.y(), dphimax.x() );  
}

Referenced by GetFacets().

GetBoundaryMin()

G4double G4TwistTubsFlatSide::GetBoundaryMin ( G4double phi )

inlineoverridevirtual

Implements G4VTwistSurface.

Definition at line 118 of file G4TwistTubsFlatSide.hh.

{
  G4ThreeVector dphimin = GetCorner(sC0Max1Min);
  return  std::atan2( dphimin.y(), dphimin.x() );  
}

Referenced by GetFacets().

GetFacets()

void G4TwistTubsFlatSide::GetFacets ( G4int m, G4int n, G4double xyz[][3], G4int faces[][4], G4int iside )

overridevirtual

Implements G4VTwistSurface.

Definition at line 527 of file G4TwistTubsFlatSide.cc.

{
  G4ThreeVector p ;
 
  G4double rmin = fAxisMin[0] ;
  G4double rmax = fAxisMax[0] ;
  G4double phimin, phimax ;
 
  G4double r,phi ;
  G4int nnode,nface ;
 
  for ( G4int i = 0 ; i<n ; ++i )
  {
    r = rmin + i*(rmax-rmin)/(n-1) ;
 
    phimin = GetBoundaryMin(r) ; 
    phimax = GetBoundaryMax(r) ;
 
    for ( G4int j = 0 ; j<k ; ++j )
    {
      phi = phimin + j*(phimax-phimin)/(k-1) ;
 
      nnode = GetNode(i,j,k,n,iside) ;
      p = SurfacePoint(phi,r,true) ;  // surface point in global coord.system
 
      xyz[nnode][0] = p.x() ;
      xyz[nnode][1] = p.y() ;
      xyz[nnode][2] = p.z() ;
 
      if ( i<n-1 && j<k-1 )    // conterclock wise filling
      {
        nface = GetFace(i,j,k,n,iside) ;
 
        if (fHandedness < 0)   // lower side
        {
          faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,-1)
                          * ( GetNode(i  ,j  ,k,n,iside)+1) ;  
          faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,-1)
                          * ( GetNode(i  ,j+1,k,n,iside)+1) ;
          faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,-1)
                          * ( GetNode(i+1,j+1,k,n,iside)+1) ;
          faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,-1)
                          * ( GetNode(i+1,j  ,k,n,iside)+1) ;
        }
        else                   // upper side
        {
          faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,1)
                          * ( GetNode(i  ,j  ,k,n,iside)+1) ;  
          faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,1)
                          * ( GetNode(i+1,j  ,k,n,iside)+1) ;
          faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,1)
                          * ( GetNode(i+1,j+1,k,n,iside)+1) ;
          faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,1)
                          * ( GetNode(i  ,j+1,k,n,iside)+1) ;
        }
      }
    }
  }
}

GetNormal()

G4ThreeVector G4TwistTubsFlatSide::GetNormal ( const G4ThreeVector & , G4bool isGlobal = false )

overridevirtual

Implements G4VTwistSurface.

Definition at line 115 of file G4TwistTubsFlatSide.cc.

{
   if (isGlobal)
   {
      return ComputeGlobalDirection(fCurrentNormal.normal);
   }
   else
   {
      return fCurrentNormal.normal;
   }
}

GetSurfaceArea()

G4double G4TwistTubsFlatSide::GetSurfaceArea ( )

inlineoverridevirtual

Implements G4VTwistSurface.

Definition at line 84 of file G4TwistTubsFlatSide.hh.

{ return fSurfaceArea ; }

SurfacePoint()

G4ThreeVector G4TwistTubsFlatSide::SurfacePoint ( G4double phi, G4double rho, G4bool isGlobal = false )

inlineoverridevirtual

Implements G4VTwistSurface.

Definition at line 108 of file G4TwistTubsFlatSide.hh.

{
  G4ThreeVector SurfPoint (rho*std::cos(phi) , rho*std::sin(phi) , 0);
 
  if (isGlobal) { return (fRot * SurfPoint + fTrans); }
  return SurfPoint;
}

Referenced by GetFacets().

---

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

• G4TwistTubsFlatSide.hh
• G4TwistTubsFlatSide.cc