G4TwistTrapParallelSide Class Reference

#include <G4TwistTrapParallelSide.hh>

Inheritance diagram for G4TwistTrapParallelSide:

Public Types
enum	EValidate { kDontValidate = 0 , kValidateWithTol = 1 , kValidateWithoutTol = 2 , kUninitialized = 3 }

Public Member Functions
virtual G4int	AmIOnLeftSide (const G4ThreeVector &me, const G4ThreeVector &vec, G4bool withTol=true)
G4ThreeVector	ComputeGlobalDirection (const G4ThreeVector &lp) const
G4ThreeVector	ComputeGlobalPoint (const G4ThreeVector &lp) const
G4ThreeVector	ComputeLocalDirection (const G4ThreeVector &gp) const
G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &gp) const
void	DebugPrint () const
virtual G4double	DistanceTo (const G4ThreeVector &gp, G4ThreeVector &gxx)
virtual G4double	DistanceToBoundary (G4int areacode, G4ThreeVector &xx, const G4ThreeVector &p)
virtual G4double	DistanceToIn (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)
G4double	DistanceToLine (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &d, G4ThreeVector &xx)
virtual G4double	DistanceToOut (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)
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	DistanceToPlaneWithV (const G4ThreeVector &p, const G4ThreeVector &v, const G4ThreeVector &x0, const G4ThreeVector &n0, G4ThreeVector &xx)
virtual G4int	DistanceToSurface (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector gxx[], G4double distance[], G4int areacode[], G4bool isvalid[], EValidate validate=kValidateWithTol)
virtual G4int	DistanceToSurface (const G4ThreeVector &gp, G4ThreeVector gxx[], G4double distance[], G4int areacode[])
	G4TwistTrapParallelSide (__void__ &)
	G4TwistTrapParallelSide (const G4String &name, G4double PhiTwist, G4double pDz, G4double pTheta, G4double pPhi, G4double pDy1, G4double pDx1, G4double pDx2, G4double pDy2, G4double pDx3, G4double pDx4, G4double pAlph, G4double AngleSide)
G4int	GetAxisType (G4int areacode, G4int whichaxis) const
virtual G4ThreeVector	GetBoundaryAtPZ (G4int areacode, const G4ThreeVector &p) const
virtual void	GetBoundaryParameters (const G4int &areacode, G4ThreeVector &d, G4ThreeVector &x0, G4int &boundarytype) const
G4int	GetEdgeVisibility (G4int i, G4int j, G4int m, G4int n, G4int number, G4int orientation)
G4int	GetFace (G4int i, G4int j, G4int m, G4int n, G4int iside)
virtual G4String	GetName () const
G4int	GetNode (G4int i, G4int j, G4int m, G4int n, G4int iside)
virtual G4ThreeVector	GetNormal (const G4ThreeVector &xx, G4bool isGlobal=false)
G4bool	IsAxis0 (G4int areacode) const
G4bool	IsAxis1 (G4int areacode) const
G4bool	IsBoundary (G4int areacode, G4bool testbitmode=false) const
G4bool	IsCorner (G4int areacode, G4bool testbitmode=false) const
G4bool	IsInside (G4int areacode, G4bool testbitmode=false) const
G4bool	IsOutside (G4int areacode) const
G4bool	IsSameBoundary (G4VTwistSurface *surface1, G4int areacode1, G4VTwistSurface *surface2, G4int areacode2) const
G4bool	IsValidNorm () const
void	SetAxis (G4int i, const EAxis axis)
void	SetNeighbours (G4VTwistSurface *ax0min, G4VTwistSurface *ax1min, G4VTwistSurface *ax0max, G4VTwistSurface *ax1max)
virtual	~G4TwistTrapParallelSide ()

Static Public Attributes
static const G4int	sAreaMask = 0XF0000000
static const G4int	sAxis0 = 0x0000FF00
static const G4int	sAxis1 = 0x000000FF
static const G4int	sAxisMask = 0x0000FCFC
static const G4int	sAxisMax = 0x00000202
static const G4int	sAxisMin = 0x00000101
static const G4int	sAxisPhi = 0x00001414
static const G4int	sAxisRho = 0x00001010
static const G4int	sAxisX = 0x00000404
static const G4int	sAxisY = 0x00000808
static const G4int	sAxisZ = 0x00000C0C
static const G4int	sBoundary = 0x20000000
static const G4int	sC0Max1Max = 0x40000202
static const G4int	sC0Max1Min = 0x40000201
static const G4int	sC0Min1Max = 0x40000102
static const G4int	sC0Min1Min = 0x40000101
static const G4int	sCorner = 0x40000000
static const G4int	sInside = 0x10000000
static const G4int	sOutside = 0x00000000
static const G4int	sSizeMask = 0x00000303

Protected Member Functions
void	GetBoundaryAxis (G4int areacode, EAxis axis[]) const
void	GetBoundaryLimit (G4int areacode, G4double limit[]) const
G4ThreeVector	GetCorner (G4int areacode) const
G4VTwistSurface **	GetNeighbours ()
G4int	GetNeighbours (G4int areacode, G4VTwistSurface *surfaces[])
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)

Protected Attributes
EAxis	fAxis [2]
G4double	fAxisMax [2]
G4double	fAxisMin [2]
G4SurfCurNormal	fCurrentNormal
CurrentStatus	fCurStat
CurrentStatus	fCurStatWithV
G4int	fHandedness
G4bool	fIsValidNorm
G4RotationMatrix	fRot
G4ThreeVector	fTrans
G4double	kCarTolerance

Private Member Functions
virtual G4int	GetAreaCode (const G4ThreeVector &xx, G4bool withTol=true)
virtual G4double	GetBoundaryMax (G4double phi)
virtual G4double	GetBoundaryMin (G4double phi)
virtual void	GetFacets (G4int m, G4int n, G4double xyz[][3], G4int faces[][4], G4int iside)
void	GetPhiUAtX (G4ThreeVector p, G4double &phi, G4double &u)
virtual G4double	GetSurfaceArea ()
G4double	GetValueB (G4double phi)
G4ThreeVector	NormAng (G4double phi, G4double u)
G4ThreeVector	ProjectPoint (const G4ThreeVector &p, G4bool isglobal=false)
virtual void	SetBoundaries ()
virtual void	SetCorners ()
virtual G4ThreeVector	SurfacePoint (G4double phi, G4double u, G4bool isGlobal=false)
G4double	Xcoef (G4double u)

Private Attributes
G4double	fa1md1
G4double	fa2md2
G4double	fAlph
G4SurfSideQuery	fAmIOnLeftSide
G4double	fAngleSide
Boundary	fBoundaries [4]
G4ThreeVector	fCorners [4]
G4double	fdeltaX
G4double	fdeltaY
G4double	fDx1
G4double	fDx2
G4double	fDx3
G4double	fDx3minus1
G4double	fDx3plus1
G4double	fDx4
G4double	fDx4minus2
G4double	fDx4plus2
G4double	fDy1
G4double	fDy2
G4double	fDy2minus1
G4double	fDy2plus1
G4double	fDz
G4String	fName
G4VTwistSurface *	fNeighbours [4]
G4double	fPhi
G4double	fPhiTwist
G4double	fTAlph
G4double	fTheta

Detailed Description

Definition at line 41 of file G4TwistTrapParallelSide.hh.

Member Enumeration Documentation

EValidate

enum G4VTwistSurface::EValidate

inherited

Enumerator
kDontValidate
kValidateWithTol
kValidateWithoutTol
kUninitialized

Definition at line 52 of file G4VTwistSurface.hh.

                  { kDontValidate = 0, kValidateWithTol = 1, 
                    kValidateWithoutTol = 2, kUninitialized = 3 };

Constructor & Destructor Documentation

G4TwistTrapParallelSide() [1/2]

G4TwistTrapParallelSide::G4TwistTrapParallelSide	(	const G4String &	name,
		G4double	PhiTwist,
		G4double	pDz,
		G4double	pTheta,
		G4double	pPhi,
		G4double	pDy1,
		G4double	pDx1,
		G4double	pDx2,
		G4double	pDy2,
		G4double	pDx3,
		G4double	pDx4,
		G4double	pAlph,
		G4double	AngleSide
	)

Definition at line 40 of file G4TwistTrapParallelSide.cc.

  : G4VTwistSurface(name)
{  
  
  fAxis[0]    = kXAxis; // in local coordinate system
  fAxis[1]    = kZAxis;
  fAxisMin[0] = -kInfinity ;  // X Axis boundary
  fAxisMax[0] = kInfinity ;   //   depends on z !!
  fAxisMin[1] = -pDz ;        // Z Axis boundary
  fAxisMax[1] = pDz ;
  
  fDx1  = pDx1 ;
  fDx2  = pDx2 ;
  fDx3  = pDx3 ;
  fDx4  = pDx4 ;
 
  fDy1   = pDy1 ;
  fDy2   = pDy2 ;
 
  fDz   = pDz ;
 
  fAlph = pAlph  ;
  fTAlph = std::tan(fAlph) ;
 
  fTheta = pTheta ;
  fPhi   = pPhi ;
 
  // precalculate frequently used parameters
  //
  fDx4plus2  = fDx4 + fDx2 ;
  fDx4minus2 = fDx4 - fDx2 ;
  fDx3plus1  = fDx3 + fDx1 ; 
  fDx3minus1 = fDx3 - fDx1 ;
  fDy2plus1  = fDy2 + fDy1 ;
  fDy2minus1 = fDy2 - fDy1 ;
 
  fa1md1 = 2*fDx2 - 2*fDx1  ; 
  fa2md2 = 2*fDx4 - 2*fDx3 ;
 
  fPhiTwist = PhiTwist ;    // dphi
  fAngleSide = AngleSide ;  // 0,90,180,270 deg
 
  fdeltaX = 2*fDz*std::tan(fTheta)*std::cos(fPhi); // dx in surface equation
  fdeltaY = 2*fDz*std::tan(fTheta)*std::sin(fPhi); // dy in surface equation
  
  fRot.rotateZ( AngleSide ) ; 
  
  fTrans.set(0, 0, 0);  // No Translation
  fIsValidNorm = false;
  
  SetCorners() ;
  SetBoundaries() ;
}

References fa1md1, fa2md2, fAlph, fAngleSide, G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, fdeltaX, fdeltaY, fDx1, fDx2, fDx3, fDx3minus1, fDx3plus1, fDx4, fDx4minus2, fDx4plus2, fDy1, fDy2, fDy2minus1, fDy2plus1, fDz, G4VTwistSurface::fIsValidNorm, fPhi, fPhiTwist, G4VTwistSurface::fRot, fTAlph, fTheta, G4VTwistSurface::fTrans, kInfinity, kXAxis, kZAxis, CLHEP::HepRotation::rotateZ(), CLHEP::Hep3Vector::set(), SetBoundaries(), and SetCorners().

~G4TwistTrapParallelSide()

G4TwistTrapParallelSide::~G4TwistTrapParallelSide ( )

virtual

Definition at line 122 of file G4TwistTrapParallelSide.cc.

{
}

G4TwistTrapParallelSide() [2/2]

G4TwistTrapParallelSide::G4TwistTrapParallelSide

(

__void__ &

a

)

Definition at line 110 of file G4TwistTrapParallelSide.cc.

  : G4VTwistSurface(a), fTheta(0.), fPhi(0.), fDy1(0.), fDx1(0.), fDx2(0.), 
    fDy2(0.), fDx3(0.), fDx4(0.), fDz(0.), fAlph(0.), fTAlph(0.), fPhiTwist(0.),
    fAngleSide(0.), fdeltaX(0.), fdeltaY(0.), fDx4plus2(0.), fDx4minus2(0.), 
    fDx3plus1(0.), fDx3minus1(0.), fDy2plus1(0.), fDy2minus1(0.), fa1md1(0.), 
    fa2md2(0.)
{
}

Member Function Documentation

AmIOnLeftSide()

G4int G4VTwistSurface::AmIOnLeftSide ( const G4ThreeVector &  me, const G4ThreeVector &  vec, G4bool  withTol = true  )

virtualinherited

Definition at line 147 of file G4VTwistSurface.cc.

{
   // AmIOnLeftSide returns phi-location of "me"
   // (phi relation between me and vec projected on z=0 plane).
   // If "me" is on -ve-phi-side of "vec", it returns 1.
   // On the other hand, if "me" is on +ve-phi-side of "vec",
   // it returns -1.
   // (The return value represents z-coordinate of normal vector
   //  of me.cross(vec).)
   // If me is on boundary of vec, return 0.
 
   const G4double kAngTolerance
     = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
 
   G4RotationMatrix unitrot;
   const G4RotationMatrix rottol    = unitrot.rotateZ(0.5*kAngTolerance);
   const G4RotationMatrix invrottol = unitrot.rotateZ(-1.*kAngTolerance);
 
   if (fAmIOnLeftSide.me == me 
       && fAmIOnLeftSide.vec == vec
       && fAmIOnLeftSide.withTol == withtol)
   {
      return fAmIOnLeftSide.amIOnLeftSide;
   }
   
   fAmIOnLeftSide.me      = me;
   fAmIOnLeftSide.vec     = vec;
   fAmIOnLeftSide.withTol = withtol;
   
   G4ThreeVector met   = (G4ThreeVector(me.x(), me.y(), 0.)).unit();
   G4ThreeVector vect  = (G4ThreeVector(vec.x(), vec.y(), 0.)).unit();
   
   G4ThreeVector ivect = invrottol * vect;
   G4ThreeVector rvect = rottol * vect;
 
   G4double metcrossvect = met.x() * vect.y() - met.y() * vect.x();
   
   if (withtol)
   {
      if (met.x() * ivect.y() - met.y() * ivect.x() > 0 && 
          metcrossvect >= 0)  {
         fAmIOnLeftSide.amIOnLeftSide = 1;
      } else if (met.x() * rvect.y() - met.y() * rvect.x() < 0 &&
                 metcrossvect <= 0)  {
         fAmIOnLeftSide.amIOnLeftSide = -1;
      } else {
         fAmIOnLeftSide.amIOnLeftSide = 0;
      }
   }
   else
   {
      if (metcrossvect > 0) {    
         fAmIOnLeftSide.amIOnLeftSide = 1;
      } else if (metcrossvect < 0 ) {
         fAmIOnLeftSide.amIOnLeftSide = -1;
      } else {       
         fAmIOnLeftSide.amIOnLeftSide = 0;
      }
   }
 
#ifdef G4TWISTDEBUG
   G4cout << "         === G4VTwistSurface::AmIOnLeftSide() =============="
          << G4endl;
   G4cout << "             Name , returncode  : " << fName << " " 
                       << fAmIOnLeftSide.amIOnLeftSide <<  G4endl;
   G4cout << "             me, vec    : " << std::setprecision(14) << me 
                                          << " " << vec  << G4endl;
   G4cout << "             met, vect  : " << met << " " << vect  << G4endl;
   G4cout << "             ivec, rvec : " << ivect << " " << rvect << G4endl;
   G4cout << "             met x vect : " << metcrossvect << G4endl;
   G4cout << "             met x ivec : " << met.cross(ivect) << G4endl;
   G4cout << "             met x rvec : " << met.cross(rvect) << G4endl;
   G4cout << "         =============================================="
          << G4endl;
#endif
 
   return fAmIOnLeftSide.amIOnLeftSide;
}

References G4VTwistSurface::G4SurfSideQuery::amIOnLeftSide, CLHEP::Hep3Vector::cross(), G4VTwistSurface::fAmIOnLeftSide, G4VTwistSurface::fName, G4cout, G4endl, G4GeometryTolerance::GetAngularTolerance(), G4GeometryTolerance::GetInstance(), G4VTwistSurface::G4SurfSideQuery::me, CLHEP::HepRotation::rotateZ(), G4VTwistSurface::G4SurfSideQuery::vec, G4VTwistSurface::G4SurfSideQuery::withTol, CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistTubsFlatSide::GetAreaCode(), and G4TwistTubsHypeSide::GetAreaCodeInPhi().

ComputeGlobalDirection()

G4ThreeVector G4VTwistSurface::ComputeGlobalDirection ( const G4ThreeVector &  lp ) const

inlineinherited

Referenced by G4TwistTrapFlatSide::GetNormal(), G4TwistTubsFlatSide::GetNormal(), G4TwistBoxSide::GetNormal(), G4TwistTrapAlphaSide::GetNormal(), GetNormal(), G4TwistTubsHypeSide::GetNormal(), G4TwistTubsSide::GetNormal(), and G4VTwistSurface::IsSameBoundary().

ComputeGlobalPoint()

G4ThreeVector G4VTwistSurface::ComputeGlobalPoint ( const G4ThreeVector &  lp ) const

inlineinherited

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4VTwistSurface::IsSameBoundary().

ComputeLocalDirection()

G4ThreeVector G4VTwistSurface::ComputeLocalDirection ( const G4ThreeVector &  gp ) const

inlineinherited

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsHypeSide::GetNormal().

ComputeLocalPoint()

G4ThreeVector G4VTwistSurface::ComputeLocalPoint ( const G4ThreeVector &  gp ) const

inlineinherited

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetNormal(), G4TwistTrapAlphaSide::GetNormal(), GetNormal(), G4TwistTubsHypeSide::GetNormal(), G4TwistTubsSide::GetNormal(), and G4TwistTubsHypeSide::Inside().

DebugPrint()

void G4VTwistSurface::DebugPrint ( ) const

inherited

Definition at line 1139 of file G4VTwistSurface.cc.

{
   G4ThreeVector A = fRot * GetCorner(sC0Min1Min) + fTrans;
   G4ThreeVector B = fRot * GetCorner(sC0Max1Min) + fTrans;
   G4ThreeVector C = fRot * GetCorner(sC0Max1Max) + fTrans;
   G4ThreeVector D = fRot * GetCorner(sC0Min1Max) + fTrans;
  
   G4cout << "/* G4VTwistSurface::DebugPrint():--------------------------"
          << G4endl;
   G4cout << "/* Name = " << fName << G4endl;
   G4cout << "/* Axis = " << std::hex << fAxis[0] << " "
          << std::hex << fAxis[1] 
          << " (0,1,2,3,5 = kXAxis,kYAxis,kZAxis,kRho,kPhi)"
          << std::dec << G4endl;
   G4cout << "/* BoundaryLimit(in local) fAxis0(min, max) = ("<<fAxisMin[0] 
          << ", " << fAxisMax[0] << ")" << G4endl;
   G4cout << "/* BoundaryLimit(in local) fAxis1(min, max) = ("<<fAxisMin[1] 
          << ", " << fAxisMax[1] << ")" << G4endl;
   G4cout << "/* Cornar point sC0Min1Min = " << A << G4endl;
   G4cout << "/* Cornar point sC0Max1Min = " << B << G4endl;
   G4cout << "/* Cornar point sC0Max1Max = " << C << G4endl;
   G4cout << "/* Cornar point sC0Min1Max = " << D << G4endl;
   G4cout << "/*---------------------------------------------------------"
          << G4endl;
}

References A, B(), C(), D(), G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4VTwistSurface::fName, G4VTwistSurface::fRot, G4VTwistSurface::fTrans, G4cout, G4endl, G4VTwistSurface::GetCorner(), G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, and G4VTwistSurface::sC0Min1Min.

DistanceTo()

G4double G4VTwistSurface::DistanceTo ( const G4ThreeVector &  gp, G4ThreeVector &  gxx  )

virtualinherited

Definition at line 577 of file G4VTwistSurface.cc.

{
#ifdef G4TWISTDEBUG
   G4cout << "~~~~~ G4VTwistSurface::DistanceTo(p) - Start ~~~~~~~~~" << G4endl;
   G4cout << "      Name : " << fName << G4endl;
   G4cout << "      gp   : " << gp << G4endl;
   G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
#endif
 
 
   G4ThreeVector gxx[G4VSURFACENXX];
   G4double      distance[G4VSURFACENXX]  ; 
   G4int         areacode[G4VSURFACENXX]  ;
   
   for (G4int i = 0 ; i<G4VSURFACENXX ; ++i )
   {
     distance[i] = kInfinity ;
     areacode[i] = sOutside ;
   }
 
   DistanceToSurface(gp, gxx, distance, areacode);
   gxxbest = gxx[0];
 
#ifdef G4TWISTDEBUG
   G4cout << "~~~~~ G4VTwistSurface::DistanceTo(p) - return ~~~~~~~~" << G4endl;
   G4cout << "      Name     : " << fName << G4endl; 
   G4cout << "      gxx      : " << gxxbest << G4endl; 
   G4cout << "      bestdist : " << distance[0] << G4endl;
   G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
#endif
 
   return distance[0];
}

References G4VTwistSurface::DistanceToSurface(), G4VTwistSurface::fName, G4cout, G4endl, G4VSURFACENXX, kInfinity, and G4VTwistSurface::sOutside.

Referenced by G4TwistedTubs::DistanceToIn(), G4VTwistedFaceted::DistanceToIn(), G4TwistedTubs::DistanceToOut(), G4VTwistedFaceted::DistanceToOut(), G4TwistedTubs::SurfaceNormal(), and G4VTwistedFaceted::SurfaceNormal().

DistanceToBoundary()

G4double G4VTwistSurface::DistanceToBoundary ( G4int  areacode, G4ThreeVector &  xx, const G4ThreeVector &  p  )

virtualinherited

Definition at line 231 of file G4VTwistSurface.cc.

{
   // DistanceToBoundary 
   //
   // return distance to nearest boundary from arbitrary point p 
   // in local coodinate.
   // Argument areacode must be one of them:
   // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
   // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
   //
 
   G4ThreeVector d;    // direction vector of the boundary
   G4ThreeVector x0;   // reference point of the boundary
   G4double      dist = kInfinity;
   G4int         boundarytype;
 
   if (IsAxis0(areacode) && IsAxis1(areacode))
   {
      std::ostringstream message;
      message << "Point is in the corner area." << G4endl
              << "        Point is in the corner area. This function returns"
              << G4endl
              << "        a direction vector of a boundary line." << G4endl
              << "        areacode = " << areacode;
      G4Exception("G4VTwistSurface::DistanceToBoundary()", "GeomSolids0003",
                  FatalException, message);
   }
   else if (IsAxis0(areacode) || IsAxis1(areacode))
   {
      GetBoundaryParameters(areacode, d, x0, boundarytype);
      if (boundarytype == sAxisPhi)
      {
         G4double t = x0.getRho() / p.getRho();
         xx.set(t*p.x(), t*p.y(), x0.z());
         dist = (xx - p).mag();
      }
      else
      { 
         // linear boundary
         // sAxisX, sAxisY, sAxisZ, sAxisRho
         dist = DistanceToLine(p, x0, d, xx);
      }
   }
   else
   {
      std::ostringstream message;
      message << "Bad areacode of boundary." << G4endl
              << "        areacode = " << areacode;
      G4Exception("G4VTwistSurface::DistanceToBoundary()", "GeomSolids0003",
                  FatalException, message);
   }
   return dist;
}

References G4VTwistSurface::DistanceToLine(), FatalException, G4endl, G4Exception(), G4VTwistSurface::GetBoundaryParameters(), CLHEP::Hep3Vector::getRho(), G4VTwistSurface::IsAxis0(), G4VTwistSurface::IsAxis1(), kInfinity, G4VTwistSurface::sAxisPhi, CLHEP::Hep3Vector::set(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4TwistTubsSide::DistanceToSurface().

DistanceToIn()

G4double G4VTwistSurface::DistanceToIn ( const G4ThreeVector &  gp, const G4ThreeVector &  gv, G4ThreeVector &  gxxbest  )

virtualinherited

Definition at line 290 of file G4VTwistSurface.cc.

{
#ifdef G4TWISTDEBUG
   G4cout << " ~~~~ G4VTwistSurface::DistanceToIn(p,v) - Start ~~~~" << G4endl;
   G4cout << "      Name : " << fName << G4endl;
   G4cout << "      gp   : " << gp << G4endl;
   G4cout << "      gv   : " <<  gv << G4endl;
   G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
#endif
   
   G4ThreeVector gxx[G4VSURFACENXX];
   G4double      distance[G4VSURFACENXX]  ; 
   G4int         areacode[G4VSURFACENXX]  ;
   G4bool        isvalid[G4VSURFACENXX]   ; 
   
   for (G4int i = 0 ; i<G4VSURFACENXX ; ++i )
   {
     distance[i] = kInfinity ;
     areacode[i] = sOutside ;
     isvalid[i] = false ;
   }
 
   G4double      bestdistance   = kInfinity;
#ifdef G4TWISTDEBUG
   G4int         besti          = -1;  
#endif
   G4ThreeVector bestgxx(kInfinity, kInfinity, kInfinity);
 
   G4int         nxx = DistanceToSurface(gp, gv, gxx, distance, areacode, 
                                         isvalid, kValidateWithTol);
 
   for (G4int i=0; i<nxx; ++i)
   {
 
      // skip this intersection if:
      //   - invalid intersection
      //   - particle goes outword the surface
 
      if (!isvalid[i])
      {
         // xx[i] is sOutside or distance[i] < 0
         continue;      
      }
 
      G4ThreeVector normal = GetNormal(gxx[i], true);
 
      if ((normal * gv) >= 0)
      {
 
#ifdef G4TWISTDEBUG
         G4cout << "   G4VTwistSurface::DistanceToIn(p,v): "
                << "particle goes outword the surface." << G4endl;
#endif 
         continue; 
      }
      
      //
      // accept this intersection if the intersection is inside.
      //
 
      if (IsInside(areacode[i]))
      {
         if (distance[i] < bestdistance)
         {
            bestdistance = distance[i];
            bestgxx = gxx[i];
#ifdef G4TWISTDEBUG
            besti   = i;
            G4cout << "   G4VTwistSurface::DistanceToIn(p,v): "
                   << " areacode sInside name, distance = "
                   << fName <<  " "<< bestdistance << G4endl;
#endif 
         }
 
      //
      // else, the intersection is on boundary or corner.
      //
 
      }
      else
      {
         G4VTwistSurface* neighbours[2];
         G4bool      isaccepted[2] = {false, false};
         G4int       nneighbours   = GetNeighbours(areacode[i], neighbours);
            
         for (G4int j=0; j<nneighbours; ++j)
         {
            // if on corner, nneighbours = 2.
            // if on boundary, nneighbours = 1.
 
            G4ThreeVector tmpgxx[G4VSURFACENXX];
            G4double      tmpdist[G4VSURFACENXX] ;
            G4int         tmpareacode[G4VSURFACENXX] ;
            G4bool        tmpisvalid[G4VSURFACENXX] ;
 
            for (G4int l = 0 ; l<G4VSURFACENXX ; ++l )
            {
              tmpdist[l] = kInfinity ;
              tmpareacode[l] = sOutside ;
              tmpisvalid[l] = false ;
            }
 
            G4int tmpnxx = neighbours[j]->DistanceToSurface(
                                          gp, gv, tmpgxx, tmpdist,
                                          tmpareacode, tmpisvalid,
                                          kValidateWithTol);
            G4ThreeVector neighbournormal;
 
            for (G4int k=0; k< tmpnxx; ++k)
            {
               //  
               // if tmpxx[k] is valid && sInside, the final winner must
               // be neighbour surface. return kInfinity. 
               // else , choose tmpxx on same boundary of xx, then check normal 
               //  
 
               if (IsInside(tmpareacode[k]))
               {
#ifdef G4TWISTDEBUG
                  G4cout << "   G4VTwistSurface:DistanceToIn(p,v): "
                         << " intersection "<< tmpgxx[k] << G4endl
                         << "   is inside of neighbour surface of " << fName 
                         << " . returning kInfinity." << G4endl;
                  G4cout << "~~ G4VTwistSurface::DistanceToIn(p,v) - return ~~"
                         << G4endl;
                  G4cout << "      No intersections " << G4endl; 
                  G4cout << "      Name : " << fName << G4endl; 
                  G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
                         << G4endl;
#endif 
                  if (tmpisvalid[k])  return kInfinity;
                  continue;
 
               //  
               // if tmpxx[k] is valid && sInside, the final winner must
               // be neighbour surface. return .  
               //
 
               }
               else if (IsSameBoundary(this,areacode[i],
                                       neighbours[j], tmpareacode[k]))
               { 
                  // tmpxx[k] is same boundary (or corner) of xx.
                 
                  neighbournormal = neighbours[j]->GetNormal(tmpgxx[k], true);
                  if (neighbournormal * gv < 0) isaccepted[j] = true;
               }
            } 
 
            // if nneighbours = 1, chabge isaccepted[1] before
            // exiting neighboursurface loop.  
 
            if (nneighbours == 1) isaccepted[1] = true;
 
         } // neighboursurface loop end
 
         // now, we can accept xx intersection
 
         if (isaccepted[0] == true && isaccepted[1] == true)
         {
            if (distance[i] < bestdistance)
            {
               bestdistance = distance[i];
               gxxbest = gxx[i];
#ifdef G4TWISTDEBUG
               besti = i;
               G4cout << "   G4VTwistSurface::DistanceToIn(p,v): "
                      << " areacode sBoundary & sBoundary distance = "
                      << fName  << " " << distance[i] << G4endl;
#endif 
            }
         }
      } // else end
   } // intersection loop end
 
   gxxbest = bestgxx;
 
#ifdef G4TWISTDEBUG
   if (besti < 0)
   {
      G4cout << "~~~ G4VTwistSurface::DistanceToIn(p,v) - return ~~~" << G4endl;
      G4cout << "      No intersections " << G4endl; 
      G4cout << "      Name : " << fName << G4endl; 
      G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
   }
   else
   {
      G4cout << "~~~ G4VTwistSurface::DistanceToIn(p,v) : return ~~~" << G4endl;
      G4cout << "      Name, i  : " << fName << " , " << besti << G4endl; 
      G4cout << "      gxx[i]   : " << gxxbest << G4endl; 
      G4cout << "      bestdist : " << bestdistance << G4endl;
      G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
   } 
 
#endif
 
   return bestdistance;
}

References G4VTwistSurface::DistanceToSurface(), G4VTwistSurface::fName, G4cout, G4endl, G4VSURFACENXX, G4VTwistSurface::GetNeighbours(), G4VTwistSurface::GetNormal(), G4VTwistSurface::IsInside(), G4VTwistSurface::IsSameBoundary(), kInfinity, G4VTwistSurface::kValidateWithTol, CLHEP::normal(), and G4VTwistSurface::sOutside.

Referenced by G4TwistedTubs::DistanceToIn(), and G4VTwistedFaceted::DistanceToIn().

DistanceToLine()

G4double G4VTwistSurface::DistanceToLine ( const G4ThreeVector &  p, const G4ThreeVector &  x0, const G4ThreeVector &  d, G4ThreeVector &  xx  )

inlineinherited

Referenced by G4VTwistSurface::DistanceToBoundary(), G4TwistTubsHypeSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

DistanceToOut()

G4double G4VTwistSurface::DistanceToOut ( const G4ThreeVector &  gp, const G4ThreeVector &  gv, G4ThreeVector &  gxxbest  )

virtualinherited

Definition at line 494 of file G4VTwistSurface.cc.

{
#ifdef G4TWISTDEBUG
   G4cout << "~~~~~ G4VTwistSurface::DistanceToOut(p,v) - Start ~~~~" << G4endl;
   G4cout << "      Name : " << fName << G4endl;
   G4cout << "      gp   : " << gp << G4endl;
   G4cout << "      gv   : " <<  gv << G4endl;
   G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
#endif
 
   G4ThreeVector gxx[G4VSURFACENXX];
   G4double      distance[G4VSURFACENXX]; 
   G4int         areacode[G4VSURFACENXX];
   G4bool        isvalid[G4VSURFACENXX]; 
   
   for ( G4int i = 0 ; i<G4VSURFACENXX ; ++i )
   {
     distance[i] = kInfinity ;
     areacode[i] = sOutside ;
     isvalid[i] = false ;
   }
 
   G4int         nxx;
   G4double      bestdistance   = kInfinity;
 
   nxx = DistanceToSurface(gp, gv, gxx, distance, areacode,
                           isvalid, kValidateWithTol);
 
   for (G4int i=0; i<nxx; ++i)
   {
      if (!(isvalid[i]))
      {
         continue;
      }
 
      G4ThreeVector normal = GetNormal(gxx[i], true);
      if (normal * gv <= 0)
      {
         // particle goes toword inside of solid, return kInfinity
#ifdef G4TWISTDEBUG
          G4cout << "   G4VTwistSurface::DistanceToOut(p,v): normal*gv < 0 " 
                 << fName << " " << normal 
                 << G4endl;
#endif 
      }
      else
      {
         // gxx[i] is accepted.
         if (distance[i] < bestdistance)
         {
            bestdistance = distance[i];
            gxxbest = gxx[i];
         }
      } 
   }
 
#ifdef G4TWISTDEBUG
   if (besti < 0)
   {
      G4cout << "~~ G4VTwistSurface::DistanceToOut(p,v) - return ~~" << G4endl;
      G4cout << "      No intersections   " << G4endl; 
      G4cout << "      Name     : " << fName << G4endl; 
      G4cout << "      bestdist : " << bestdistance << G4endl;
      G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
   }
   else
   {
      G4cout << "~~ G4VTwistSurface::DistanceToOut(p,v) : return ~~" << G4endl;
      G4cout << "      Name, i  : " << fName << " , " << i << G4endl; 
      G4cout << "      gxx[i]   : " << gxxbest << G4endl; 
      G4cout << "      bestdist : " << bestdistance << G4endl;
      G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
   } 
#endif
 
   return bestdistance;
}

References G4VTwistSurface::DistanceToSurface(), G4VTwistSurface::fName, G4cout, G4endl, G4VSURFACENXX, G4VTwistSurface::GetNormal(), kInfinity, G4VTwistSurface::kValidateWithTol, CLHEP::normal(), and G4VTwistSurface::sOutside.

Referenced by G4TwistedTubs::DistanceToOut(), and G4VTwistedFaceted::DistanceToOut().

DistanceToPlane() [1/2]

G4double G4VTwistSurface::DistanceToPlane ( const G4ThreeVector &  p, const G4ThreeVector &  x0, const G4ThreeVector &  n0, G4ThreeVector &  xx  )

inlineinherited

Referenced by G4TwistTubsSide::DistanceToPlane(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

DistanceToPlane() [2/2]

G4double G4VTwistSurface::DistanceToPlane ( const G4ThreeVector &  p, const G4ThreeVector &  x0, const G4ThreeVector &  t1, const G4ThreeVector &  t2, G4ThreeVector &  xx, G4ThreeVector &  n  )

inlineinherited

DistanceToPlaneWithV()

G4double G4VTwistSurface::DistanceToPlaneWithV ( const G4ThreeVector &  p, const G4ThreeVector &  v, const G4ThreeVector &  x0, const G4ThreeVector &  n0, G4ThreeVector &  xx  )

inlineinherited

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

DistanceToSurface() [1/2]

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

virtual

Implements G4VTwistSurface.

Definition at line 183 of file G4TwistTrapParallelSide.cc.

{
  static const G4double pihalf = pi/2 ;
  const G4double ctol = 0.5 * kCarTolerance;
 
  G4bool IsParallel = false ;
  G4bool IsConverged =  false ;
 
  G4int nxx = 0 ;  // number of physical solutions
 
  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<G4VSURFACENXX ; ++i)
    {
      distance[i] = kInfinity;
      areacode[i] = sOutside;
      isvalid[i]  = false;
      gxx[i].set(kInfinity, kInfinity, kInfinity);
    }
  }
 
  G4ThreeVector p = ComputeLocalPoint(gp);
  G4ThreeVector v = ComputeLocalDirection(gv);
  
#ifdef G4TWISTDEBUG
  G4cout << "Local point p = " << p << G4endl ;
  G4cout << "Local direction v = " << v << G4endl ; 
#endif
 
  G4double phi,u ;  // parameters
 
  // temporary variables
 
  G4double      tmpdist = kInfinity ;
  G4ThreeVector tmpxx;
  G4int         tmpareacode = sOutside ;
  G4bool        tmpisvalid  = false ;
 
  std::vector<Intersection> xbuf ;
  Intersection xbuftmp ;
  
  // prepare some variables for the intersection finder
 
  G4double L = 2*fDz ;
 
  G4double phixz = fPhiTwist * ( p.x() * v.z() - p.z() * v.x() ) ;
  G4double phiyz = fPhiTwist * ( p.y() * v.z() - p.z() * v.y() ) ;
 
  // special case vz = 0
 
  if ( v.z() == 0. )
  {
    if ( std::fabs(p.z()) <= L )       // intersection possible in z
    {
      phi = p.z() * fPhiTwist / L ;  // phi is determined by the z-position 
 
      u = (2*(fdeltaY*phi*v.x() - fPhiTwist*p.y()*v.x() - fdeltaX*phi*v.y()
              + fPhiTwist*p.x()*v.y()) + (fDy2plus1*fPhiTwist
              + 2*fDy2minus1*phi)*(v.x()*std::cos(phi) + v.y()*std::sin(phi)))
        / (2.* fPhiTwist*(v.y()*std::cos(phi) - v.x()*std::sin(phi)));
 
      xbuftmp.phi = phi ;
      xbuftmp.u = u ;
      xbuftmp.areacode = sOutside ;
      xbuftmp.distance = kInfinity ;
      xbuftmp.isvalid = false ;
 
      xbuf.push_back(xbuftmp) ; // store it to xbuf
    }
    else                              // no intersection possible
    {
      distance[0] = kInfinity;
      gxx[0].set(kInfinity,kInfinity,kInfinity);
      isvalid[0] = false ;
      areacode[0] = sOutside ;
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0],
                                     areacode[0], isvalid[0],
                                     0, validate, &gp, &gv);
      
      return 0;
    }  // end std::fabs(p.z() <= L 
  } // end v.z() == 0
  else   // general solution for non-zero vz
  {
    G4double c[9],srd[8],si[8] ;  
 
    c[8] = -3600*(-2*phiyz + fDy2plus1*fPhiTwist*v.z()) ;
    c[7] = -7200*(phixz - 2*fDz*v.y() + (fdeltaY + fDy2minus1)*v.z()) ;
    c[6] = 120*(-52*phiyz - 120*fDz*v.x() + 60*fdeltaX*v.z()
         + 11*fDy2plus1*fPhiTwist*v.z()) ;
    c[5] = 240*(16*phixz - 52*fDz*v.y() + 26*fdeltaY*v.z()
         + 11*fDy2minus1*v.z()) ;
    c[4] = 12*(127*phiyz + 640*fDz*v.x() - 320*fdeltaX*v.z()
         + 4*fDy2plus1*fPhiTwist*v.z()) ;
    c[3] = -404*phixz + 3048*fDz*v.y() - 1524*fdeltaY*v.z()
         + 96*fDy2minus1*v.z() ;
    c[2] = -72*phiyz + 404*(-2*fDz*v.x() + fdeltaX*v.z()) ;
    c[1] = 12*(phixz - 12*fDz*v.y() + 6*fdeltaY*v.z()) ;
    c[0] = 24*fDz*v.x() - 12*fdeltaX*v.z() ;
 
 
#ifdef G4TWISTDEBUG
    G4cout << "coef = " << c[0] << " " 
           <<  c[1] << " "  
           <<  c[2] << " "  
           <<  c[3] << " "  
           <<  c[4] << " "  
           <<  c[5] << " "  
           <<  c[6] << " "  
           <<  c[7] << " "  
           <<  c[8] << G4endl ;
#endif    
 
    G4JTPolynomialSolver trapEq ;
    G4int num = trapEq.FindRoots(c,8,srd,si);
 
    for (G4int i = 0 ; i<num ; ++i )   // loop over all mathematical solutions
    {
      if ( si[i]==0.0 )   // only real solutions
      {
#ifdef G4TWISTDEBUG
        G4cout << "Solution " << i << " : " << srd[i] << G4endl ;
#endif
        phi = std::fmod(srd[i] , pihalf)  ;
        u = (1/std::cos(phi)*(2*phixz + 4*fDz*phi*v.x()
          - 2*fdeltaX*phi*v.z() + (fDy2plus1*fPhiTwist
          + 2*fDy2minus1*phi)*v.z()* std::sin(phi)))/(2.*fPhiTwist*v.z()) ;
 
        xbuftmp.phi = phi ;
        xbuftmp.u = u ;
        xbuftmp.areacode = sOutside ;
        xbuftmp.distance = kInfinity ;
        xbuftmp.isvalid = false ;
        
        xbuf.push_back(xbuftmp) ;  // store it to xbuf
      
#ifdef G4TWISTDEBUG
        G4cout << "solution " << i << " = " << phi << " , " << u  << G4endl ;
#endif
 
      }  // end if real solution
    }  // end loop i
  }  // end general case
 
  nxx = xbuf.size() ;  // save the number of  solutions
 
  G4ThreeVector xxonsurface  ;       // point on surface
  G4ThreeVector surfacenormal  ;     // normal vector  
  G4double deltaX  ; // distance between intersection point and point on surface
  G4double theta  ;                  // angle between track and surfacenormal
  G4double factor ;                  // a scaling factor
  G4int maxint = 30 ;                // number of iterations
 
 
  for ( size_t k = 0 ; k<xbuf.size() ; ++k )
  {
#ifdef G4TWISTDEBUG
    G4cout << "Solution " << k << " : " 
           << "reconstructed phiR = " << xbuf[k].phi
           << ", uR = " << xbuf[k].u << G4endl ; 
#endif
    
    phi = xbuf[k].phi ;  // get the stored values for phi and u
    u = xbuf[k].u ;
 
    IsConverged = false ;   // no convergence at the beginning
    
    for ( G4int i = 1 ; i<maxint ; ++i )
    {
      xxonsurface = SurfacePoint(phi,u) ;
      surfacenormal = NormAng(phi,u) ;
      tmpdist = DistanceToPlaneWithV(p, v, xxonsurface, surfacenormal, tmpxx); 
      deltaX = ( tmpxx - xxonsurface ).mag() ; 
      theta = std::fabs(std::acos(v*surfacenormal) - pihalf) ;
      if ( theta < 0.001 )
      { 
        factor = 50 ;
        IsParallel = true ;
      }
      else
      {
        factor = 1 ;
      }
 
#ifdef G4TWISTDEBUG
      G4cout << "Step i = " << i << ", distance = "
             << tmpdist << ", " << deltaX << G4endl ;
      G4cout << "X = " << tmpxx << G4endl ;
#endif
      
      GetPhiUAtX(tmpxx, phi, u); // new point xx is accepted and phi/u replaced
      
#ifdef G4TWISTDEBUG
      G4cout << "approximated phi = " << phi << ", u = " << u << G4endl ; 
#endif
      
      if ( deltaX <= factor*ctol ) { IsConverged = true ; break ; }
    }  // end iterative loop (i)
    
    if ( std::fabs(tmpdist)<ctol ) tmpdist = 0 ; 
 
#ifdef G4TWISTDEBUG
    G4cout << "refined solution "  << phi << " , " << u  <<  G4endl ;
    G4cout << "distance = " << tmpdist << G4endl ;
    G4cout << "local X = " << tmpxx << G4endl ;
#endif
    
    tmpisvalid = false ;  // init 
 
    if ( IsConverged )
    {
      if (validate == kValidateWithTol)
      {
        tmpareacode = GetAreaCode(tmpxx);
        if (!IsOutside(tmpareacode))
        {
          if (tmpdist >= 0) tmpisvalid = true;
        }
      }
      else if (validate == kValidateWithoutTol)
      {
        tmpareacode = GetAreaCode(tmpxx, false);
        if (IsInside(tmpareacode))
        {
          if (tmpdist >= 0) tmpisvalid = true;
        }
      }
      else  // kDontValidate
      {
        G4Exception("G4TwistTrapParallelSide::DistanceToSurface()",
                    "GeomSolids0001", FatalException,
                    "Feature NOT implemented !");
      }
    } 
    else
    {
      tmpdist = kInfinity;     // no convergence after 10 steps 
      tmpisvalid = false ;     // solution is not vaild
    }  
 
    // store the found values 
    xbuf[k].xx = tmpxx ;
    xbuf[k].distance = tmpdist ;
    xbuf[k].areacode = tmpareacode ;
    xbuf[k].isvalid = tmpisvalid ;
  }  // end loop over physical solutions (variable k)
 
  std::sort(xbuf.begin() , xbuf.end(), DistanceSort ) ;  // sorting
 
#ifdef G4TWISTDEBUG
  G4cout << G4endl << "list xbuf after sorting : " << G4endl ;
  G4cout << G4endl << G4endl ;
#endif
 
  // erase identical intersection (within kCarTolerance) 
  xbuf.erase(std::unique(xbuf.begin(),xbuf.end(),EqualIntersection),xbuf.end());
 
 
  // add guesses
 
  G4int nxxtmp = xbuf.size() ;
 
  if ( nxxtmp<2 || IsParallel  )
  {
    // positive end
#ifdef G4TWISTDEBUG
    G4cout << "add guess at +z/2 .. " << G4endl ;
#endif
 
    phi = fPhiTwist/2 ;
    u   =  0 ;
    
    xbuftmp.phi = phi ;
    xbuftmp.u = u ;
    xbuftmp.areacode = sOutside ;
    xbuftmp.distance = kInfinity ;
    xbuftmp.isvalid = false ;
    
    xbuf.push_back(xbuftmp) ;  // store it to xbuf
 
#ifdef G4TWISTDEBUG
    G4cout << "add guess at -z/2 .. " << G4endl ;
#endif
 
    phi = -fPhiTwist/2 ;
    u   = 0 ;
 
    xbuftmp.phi = phi ;
    xbuftmp.u = u ;
    xbuftmp.areacode = sOutside ;
    xbuftmp.distance = kInfinity ;
    xbuftmp.isvalid = false ;
    
    xbuf.push_back(xbuftmp) ;  // store it to xbuf
 
    for ( size_t k = nxxtmp ; k<xbuf.size() ; ++k )
    {
#ifdef G4TWISTDEBUG
      G4cout << "Solution " << k << " : " 
             << "reconstructed phiR = " << xbuf[k].phi
             << ", uR = " << xbuf[k].u << G4endl ; 
#endif
      
      phi = xbuf[k].phi ;  // get the stored values for phi and u
      u   = xbuf[k].u ;
 
      IsConverged = false ;   // no convergence at the beginning
      
      for ( G4int i = 1 ; i<maxint ; ++i )
      {
        xxonsurface = SurfacePoint(phi,u) ;
        surfacenormal = NormAng(phi,u) ;
        tmpdist = DistanceToPlaneWithV(p, v, xxonsurface, surfacenormal, tmpxx); 
        deltaX = ( tmpxx - xxonsurface ).mag() ; 
        theta = std::fabs(std::acos(v*surfacenormal) - pihalf) ;
        if ( theta < 0.001 )
        { 
          factor = 50 ;    
        }
        else
        {
          factor = 1 ;
        }
        
#ifdef G4TWISTDEBUG
        G4cout << "Step i = " << i << ", distance = "
               << tmpdist << ", " << deltaX << G4endl ;
        G4cout << "X = " << tmpxx << G4endl ;
#endif
 
        GetPhiUAtX(tmpxx, phi, u) ; // new point xx accepted and phi/u replaced
 
#ifdef G4TWISTDEBUG
        G4cout << "approximated phi = " << phi << ", u = " << u << G4endl ; 
#endif
      
        if ( deltaX <= factor*ctol ) { IsConverged = true ; break ; }
      }  // end iterative loop (i)
 
      if ( std::fabs(tmpdist)<ctol ) tmpdist = 0 ; 
 
#ifdef G4TWISTDEBUG
      G4cout << "refined solution "  << phi << " , " << u  <<  G4endl ;
      G4cout << "distance = " << tmpdist << G4endl ;
      G4cout << "local X = " << tmpxx << G4endl ;
#endif
 
      tmpisvalid = false ;  // init 
 
      if ( IsConverged )
      {
        if (validate == kValidateWithTol)
        {
          tmpareacode = GetAreaCode(tmpxx);
          if (!IsOutside(tmpareacode))
          {
            if (tmpdist >= 0) tmpisvalid = true;
          }
        }
        else if (validate == kValidateWithoutTol)
        {
          tmpareacode = GetAreaCode(tmpxx, false);
          if (IsInside(tmpareacode))
          {
            if (tmpdist >= 0) tmpisvalid = true;
          }
        }
        else  // kDontValidate
        {
          G4Exception("G4TwistedBoxSide::DistanceToSurface()",
                      "GeomSolids0001", FatalException,
                      "Feature NOT implemented !");
        }
        
      } 
      else
      {
        tmpdist = kInfinity;     // no convergence after 10 steps 
        tmpisvalid = false ;     // solution is not vaild
      }  
 
      // store the found values 
      xbuf[k].xx = tmpxx ;
      xbuf[k].distance = tmpdist ;
      xbuf[k].areacode = tmpareacode ;
      xbuf[k].isvalid = tmpisvalid ;
 
    }  // end loop over physical solutions 
  }  // end less than 2 solutions
 
  // sort again
  std::sort(xbuf.begin() , xbuf.end(), DistanceSort ) ;  // sorting
 
  // erase identical intersection (within kCarTolerance) 
  xbuf.erase(std::unique(xbuf.begin(),xbuf.end(),EqualIntersection),xbuf.end());
 
#ifdef G4TWISTDEBUG
  G4cout << G4endl << "list xbuf after sorting : " << G4endl ;
  G4cout << G4endl << G4endl ;
#endif
 
  nxx = xbuf.size() ;   // determine number of solutions again.
 
  for ( size_t i = 0 ; i<xbuf.size() ; ++i )
  {
    distance[i] = xbuf[i].distance;
    gxx[i]      = ComputeGlobalPoint(xbuf[i].xx);
    areacode[i] = xbuf[i].areacode ;
    isvalid[i]  = xbuf[i].isvalid ;
    
    fCurStatWithV.SetCurrentStatus(i, gxx[i], distance[i], areacode[i],
                                     isvalid[i], nxx, validate, &gp, &gv);
#ifdef G4TWISTDEBUG
    G4cout << "element Nr. " << i 
           << ", local Intersection = " << xbuf[i].xx 
           << ", distance = " << xbuf[i].distance 
           << ", u = " << xbuf[i].u 
           << ", phi = " << xbuf[i].phi 
           << ", isvalid = " << xbuf[i].isvalid 
           << G4endl ;
#endif
  }  // end for( i ) loop
 
#ifdef G4TWISTDEBUG
  G4cout << "G4TwistTrapParallelSide finished " << G4endl ;
  G4cout << nxx << " possible physical solutions found" << G4endl ;
  for ( G4int k= 0 ; k< nxx ; ++k )
  {
    G4cout << "global intersection Point found: " << gxx[k] << G4endl ;
    G4cout << "distance = " << distance[k] << G4endl ;
    G4cout << "isvalid = " << isvalid[k] << G4endl ;
  }
#endif
 
  return nxx ;
}

References Intersection::areacode, G4VTwistSurface::ComputeGlobalPoint(), G4VTwistSurface::ComputeLocalDirection(), G4VTwistSurface::ComputeLocalPoint(), Intersection::distance, DistanceSort(), G4VTwistSurface::DistanceToPlaneWithV(), EqualIntersection(), FatalException, G4VTwistSurface::fCurStatWithV, fdeltaX, fdeltaY, fDy2minus1, fDy2plus1, fDz, G4JTPolynomialSolver::FindRoots(), fPhiTwist, G4cout, G4endl, G4Exception(), G4VSURFACENXX, GetAreaCode(), G4VTwistSurface::CurrentStatus::GetAreacode(), G4VTwistSurface::CurrentStatus::GetDistance(), G4VTwistSurface::CurrentStatus::GetNXX(), GetPhiUAtX(), G4VTwistSurface::CurrentStatus::GetXX(), G4VTwistSurface::CurrentStatus::IsDone(), G4VTwistSurface::IsInside(), G4VTwistSurface::IsOutside(), G4VTwistSurface::CurrentStatus::IsValid(), Intersection::isvalid, G4VTwistSurface::kCarTolerance, kInfinity, G4VTwistSurface::kValidateWithoutTol, G4VTwistSurface::kValidateWithTol, L, NormAng(), Intersection::phi, pi, G4VTwistSurface::CurrentStatus::ResetfDone(), CLHEP::Hep3Vector::set(), G4VTwistSurface::CurrentStatus::SetCurrentStatus(), G4VTwistSurface::sOutside, SurfacePoint(), Intersection::u, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

DistanceToSurface() [2/2]

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

virtual

Implements G4VTwistSurface.

Definition at line 642 of file G4TwistTrapParallelSide.cc.

{  
  const G4double ctol = 0.5 * kCarTolerance;
 
  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 (G4int i=0; i<G4VSURFACENXX; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
   
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector xx;  // intersection point
   G4ThreeVector xxonsurface ; // interpolated intersection point 
 
   // the surfacenormal at that surface point
   G4double phiR = 0  ; // 
   G4double uR = 0 ;
 
   G4ThreeVector surfacenormal ; 
   G4double deltaX ;
   
   G4int maxint = 20 ;
 
   for ( G4int i = 1 ; i<maxint ; ++i )
   {
     xxonsurface = SurfacePoint(phiR,uR) ;
     surfacenormal = NormAng(phiR,uR) ;
     distance[0] = DistanceToPlane(p, xxonsurface, surfacenormal, xx); // new XX
     deltaX = ( xx - xxonsurface ).mag() ; 
 
#ifdef G4TWISTDEBUG
     G4cout << "i = " << i << ", distance = "
            << distance[0] << ", " << deltaX << G4endl ;
     G4cout << "X = " << xx << G4endl ;
#endif
 
     // the new point xx is accepted and phi/psi replaced
     GetPhiUAtX(xx, phiR, uR) ;
     
     if ( deltaX <= ctol ) { break ; }
   }
 
   // check validity of solution ( valid phi,psi ) 
 
   G4double halfphi = 0.5*fPhiTwist ;
   G4double uMax = GetBoundaryMax(phiR) ;
   G4double uMin = GetBoundaryMin(phiR) ;
 
   if (  phiR > halfphi ) phiR =  halfphi ;
   if ( phiR < -halfphi ) phiR = -halfphi ;
   if ( uR > uMax ) uR = uMax ;
   if ( uR < uMin ) uR = uMin ;
 
   xxonsurface = SurfacePoint(phiR,uR) ;
   distance[0] = (  p - xx ).mag() ;
   if ( distance[0] <= ctol ) { distance[0] = 0 ; } 
 
   // end of validity 
 
#ifdef G4TWISTDEBUG
   G4cout << "refined solution "  << phiR << " , " << uR << " , " <<  G4endl ;
   G4cout << "distance = " << distance[0] << G4endl ;
   G4cout << "X = " << xx << G4endl ;
#endif
 
   G4bool isvalid = true;
   gxx[0]      = ComputeGlobalPoint(xx);
   
#ifdef G4TWISTDEBUG
   G4cout << "intersection Point found: " << gxx[0] << G4endl ;
   G4cout << "distance = " << distance[0] << G4endl ;
#endif
 
   fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                            isvalid, 1, kDontValidate, &gp);
   return 1;
}

References G4VTwistSurface::ComputeGlobalPoint(), G4VTwistSurface::ComputeLocalPoint(), G4VTwistSurface::DistanceToPlane(), G4VTwistSurface::fCurStat, fPhiTwist, G4cout, G4endl, G4VSURFACENXX, G4VTwistSurface::CurrentStatus::GetAreacode(), GetBoundaryMax(), GetBoundaryMin(), G4VTwistSurface::CurrentStatus::GetDistance(), G4VTwistSurface::CurrentStatus::GetNXX(), GetPhiUAtX(), G4VTwistSurface::CurrentStatus::GetXX(), G4VTwistSurface::CurrentStatus::IsDone(), G4VTwistSurface::kCarTolerance, G4VTwistSurface::kDontValidate, kInfinity, NormAng(), G4VTwistSurface::CurrentStatus::ResetfDone(), CLHEP::Hep3Vector::set(), G4VTwistSurface::CurrentStatus::SetCurrentStatus(), G4VTwistSurface::sOutside, and SurfacePoint().

GetAreaCode()

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

privatevirtual

Implements G4VTwistSurface.

Definition at line 742 of file G4TwistTrapParallelSide.cc.

{
   // We must use the function in local coordinate system.
   // See the description of DistanceToSurface(p,v).
   
   const G4double ctol = 0.5 * kCarTolerance;
 
   G4double phi ;
   G4double yprime ;
   GetPhiUAtX(xx, phi,yprime ) ;
 
   G4double fXAxisMax = GetBoundaryMax(phi) ;
   G4double fXAxisMin = GetBoundaryMin(phi) ;
 
#ifdef G4TWISTDEBUG
   G4cout << "GetAreaCode: phi = " << phi << G4endl ;
   G4cout << "GetAreaCode: yprime = " << yprime << G4endl ;
   G4cout << "Intervall is " << fXAxisMin << " to " << fXAxisMax << G4endl ;
#endif
 
   G4int areacode = sInside;
   
   if (fAxis[0] == kXAxis && fAxis[1] == kZAxis)
   {
      G4int zaxis = 1;
      
      if (withTol)
      {
        G4bool isoutside = false;
        
        // test boundary of xaxis
 
         if (yprime < fXAxisMin + ctol)
         {
            areacode |= (sAxis0 & (sAxisX | sAxisMin)) | sBoundary; 
            if (yprime <= fXAxisMin - ctol) isoutside = true;
 
         }
         else if (yprime > fXAxisMax - ctol)
         {
            areacode |= (sAxis0 & (sAxisX | sAxisMax)) | sBoundary;
            if (yprime >= fXAxisMax + ctol)  isoutside = true;
         }
 
         // test boundary of z-axis
 
         if (xx.z() < fAxisMin[zaxis] + ctol)
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMin)); 
 
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary;
            if (xx.z() <= fAxisMin[zaxis] - ctol) isoutside = true;
 
         }
         else if (xx.z() > fAxisMax[zaxis] - ctol)
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMax));
 
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary; 
            if (xx.z() >= fAxisMax[zaxis] + ctol) 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 & sAxisX) | (sAxis1 & sAxisZ);
         }           
         
      }
      else
      {
         // boundary of y-axis
 
         if (yprime < fXAxisMin )
         {
            areacode |= (sAxis0 & (sAxisX | sAxisMin)) | sBoundary;
         }
         else if (yprime > fXAxisMax)
         {
            areacode |= (sAxis0 & (sAxisX | sAxisMax)) | sBoundary;
         }
         
         // boundary of z-axis
 
         if (xx.z() < fAxisMin[zaxis])
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMin));
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary; 
           
         }
         else if (xx.z() > fAxisMax[zaxis])
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMax)) ;
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary; 
         }
 
         if ((areacode & sBoundary) != sBoundary)
         {
            areacode |= (sAxis0 & sAxisX) | (sAxis1 & sAxisZ);
         }           
      }
      return areacode;
   }
   else
   {
      G4Exception("G4TwistTrapParallelSide::GetAreaCode()",
                  "GeomSolids0001", FatalException,
                  "Feature NOT implemented !");
   }
   return areacode;
}

References FatalException, G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4cout, G4endl, G4Exception(), GetBoundaryMax(), GetBoundaryMin(), GetPhiUAtX(), G4VTwistSurface::kCarTolerance, kXAxis, kZAxis, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sAxisX, G4VTwistSurface::sAxisZ, G4VTwistSurface::sBoundary, G4VTwistSurface::sCorner, G4VTwistSurface::sInside, and CLHEP::Hep3Vector::z().

Referenced by DistanceToSurface().

GetAxisType()

G4int G4VTwistSurface::GetAxisType ( G4int  areacode, G4int  whichaxis  ) const

inlineinherited

GetBoundaryAtPZ()

G4ThreeVector G4VTwistSurface::GetBoundaryAtPZ ( G4int  areacode, const G4ThreeVector &  p  ) const

virtualinherited

Definition at line 698 of file G4VTwistSurface.cc.

{
   // areacode must be one of them:
   // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
   // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
 
   if (areacode & sAxis0 && areacode & sAxis1)
   {
     std::ostringstream message;
     message << "Point is in the corner area." << G4endl
             << "        This function returns "
             << "a direction vector of a boundary line." << G4endl
             << "        areacode = " << areacode;
     G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0003",
                 FatalException, message);
   }
 
   G4ThreeVector d;
   G4ThreeVector x0;
   G4int         boundarytype;
   G4bool        found = false;
   
   for (G4int i=0; i<4; ++i)
   {
      if (fBoundaries[i].GetBoundaryParameters(areacode, d, x0, 
                                               boundarytype))
      {
         found = true;
         continue;
      }
   }
 
   if (!found)
   {
     std::ostringstream message;
     message << "Not registered boundary." << G4endl
             << "        Boundary at areacode " << areacode << G4endl
             << "        is not registered.";
     G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0002",
                 FatalException, message);
   }
 
   if (((boundarytype & sAxisPhi) == sAxisPhi) ||
       ((boundarytype & sAxisRho) == sAxisRho))
   {
     std::ostringstream message;
     message << "Not a z-depended line boundary." << G4endl
             << "        Boundary at areacode " << areacode << G4endl
             << "        is not a z-depended line.";
     G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0002",
                 FatalException, message);
   }
   return ((p.z() - x0.z()) / d.z()) * d + x0;
}

References FatalException, G4VTwistSurface::fBoundaries, G4endl, G4Exception(), G4VTwistSurface::GetBoundaryParameters(), G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisPhi, G4VTwistSurface::sAxisRho, and CLHEP::Hep3Vector::z().

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4TwistTubsHypeSide::GetBoundaryMax(), and G4TwistTubsHypeSide::GetBoundaryMin().

GetBoundaryAxis()

void G4VTwistSurface::GetBoundaryAxis ( G4int  areacode, EAxis  axis[]  ) const

protectedinherited

Definition at line 783 of file G4VTwistSurface.cc.

{
   if ((areacode & sBoundary) != sBoundary) {
     G4Exception("G4VTwistSurface::GetBoundaryAxis()", "GeomSolids0003",
                 FatalException, "Not located on a boundary!");
   }
   for (G4int i=0; i<2; ++i)
   {
      G4int whichaxis = 0 ;
      if (i == 0) {
         whichaxis = sAxis0;
      } else if (i == 1) {
         whichaxis = sAxis1;
      }
      
      // extracted axiscode of whichaxis
      G4int axiscode = whichaxis & sAxisMask & areacode ; 
      if (axiscode) {
         if (axiscode == (whichaxis & sAxisX)) {
            axis[i] = kXAxis;
         } else if (axiscode == (whichaxis & sAxisY)) {
            axis[i] = kYAxis;
         } else if (axiscode == (whichaxis & sAxisZ)) {
            axis[i] = kZAxis;
         } else if (axiscode == (whichaxis & sAxisRho)) {
            axis[i] = kRho;
         } else if (axiscode == (whichaxis & sAxisPhi)) {
            axis[i] = kPhi;
         } else {
           std::ostringstream message;
           message << "Not supported areacode." << G4endl
                   << "        areacode " << areacode;
           G4Exception("G4VTwistSurface::GetBoundaryAxis()", "GeomSolids0001",
                       FatalException, message);
         }
      }
   }
}

References FatalException, G4endl, G4Exception(), kPhi, kRho, kXAxis, kYAxis, kZAxis, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMask, G4VTwistSurface::sAxisPhi, G4VTwistSurface::sAxisRho, G4VTwistSurface::sAxisX, G4VTwistSurface::sAxisY, G4VTwistSurface::sAxisZ, and G4VTwistSurface::sBoundary.

GetBoundaryLimit()

void G4VTwistSurface::GetBoundaryLimit ( G4int  areacode, G4double  limit[]  ) const

protectedinherited

Definition at line 825 of file G4VTwistSurface.cc.

{
   if (areacode & sCorner) {
      if (areacode & sC0Min1Min) {
         limit[0] = fAxisMin[0];
         limit[1] = fAxisMin[1];
      } else if (areacode & sC0Max1Min) {
         limit[0] = fAxisMax[0];
         limit[1] = fAxisMin[1];
      } else if (areacode & sC0Max1Max) {
         limit[0] = fAxisMax[0];
         limit[1] = fAxisMax[1];
      } else if (areacode & sC0Min1Max) {
         limit[0] = fAxisMin[0];
         limit[1] = fAxisMax[1];
      }
   } else if (areacode & sBoundary) {
      if (areacode & (sAxis0 | sAxisMin)) {
         limit[0] = fAxisMin[0];
      } else if (areacode & (sAxis1 | sAxisMin)) {
         limit[0] = fAxisMin[1];
      } else if (areacode & (sAxis0 | sAxisMax)) {
         limit[0] = fAxisMax[0];
      } else if (areacode & (sAxis1 | sAxisMax)) {
         limit[0] = fAxisMax[1];
      }
   } else {
     std::ostringstream message;
     message << "Not located on a boundary!" << G4endl
             << "          areacode " << areacode;
     G4Exception("G4VTwistSurface::GetBoundaryLimit()", "GeomSolids1002",
                 JustWarning, message);
   }
}

References G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4endl, G4Exception(), JustWarning, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sBoundary, G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, and G4VTwistSurface::sCorner.

GetBoundaryMax()

G4double G4TwistTrapParallelSide::GetBoundaryMax ( G4double  phi )

inlineprivatevirtual

Implements G4VTwistSurface.

Definition at line 185 of file G4TwistTrapParallelSide.hh.

{
  return (fDx2 + fDx4 + fDy2plus1*fTAlph)/ 2.
       + ((fDx4minus2 + fDy2minus1*fTAlph)*phi)/fPhiTwist ;
}

References fDx2, fDx4, fDx4minus2, fDy2minus1, fDy2plus1, fPhiTwist, and fTAlph.

Referenced by DistanceToSurface(), GetAreaCode(), and GetFacets().

GetBoundaryMin()

G4double G4TwistTrapParallelSide::GetBoundaryMin ( G4double  phi )

inlineprivatevirtual

Implements G4VTwistSurface.

Definition at line 178 of file G4TwistTrapParallelSide.hh.

{
  return  -(fPhiTwist*(fDx2 + fDx4 - fDy2plus1*fTAlph)
          + 2*fDx4minus2*phi - 2*fDy2minus1*fTAlph*phi)/(2.*fPhiTwist) ;
}

References fDx2, fDx4, fDx4minus2, fDy2minus1, fDy2plus1, fPhiTwist, and fTAlph.

Referenced by DistanceToSurface(), GetAreaCode(), and GetFacets().

GetBoundaryParameters()

void G4VTwistSurface::GetBoundaryParameters ( const G4int &  areacode, G4ThreeVector &  d, G4ThreeVector &  x0, G4int &  boundarytype  ) const

virtualinherited

Definition at line 668 of file G4VTwistSurface.cc.

{
   // areacode must be one of them:
   // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
   // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
   
   for (G4int i=0; i<4; ++i)
   {
      if (fBoundaries[i].GetBoundaryParameters(areacode, d, x0,
                                               boundarytype))
      {
         return;
      }
   }
 
   std::ostringstream message;
   message << "Not registered boundary." << G4endl
           << "        Boundary at areacode " << std::hex << areacode
           << std::dec << G4endl
           << "        is not registered.";
   G4Exception("G4VTwistSurface::GetBoundaryParameters()", "GeomSolids0002",
               FatalException, message);
}

References FatalException, G4VTwistSurface::fBoundaries, G4endl, G4Exception(), and G4VTwistSurface::GetBoundaryParameters().

Referenced by G4VTwistSurface::DistanceToBoundary(), G4TwistTubsSide::DistanceToSurface(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryParameters(), and G4VTwistSurface::IsSameBoundary().

GetCorner()

G4ThreeVector G4VTwistSurface::GetCorner ( G4int  areacode ) const

inlineprotectedinherited

Referenced by G4VTwistSurface::DebugPrint(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsFlatSide::GetBoundaryMax(), G4TwistTubsFlatSide::GetBoundaryMin(), G4VTwistSurface::IsSameBoundary(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), and G4TwistTubsSide::SetBoundaries().

GetEdgeVisibility()

G4int G4VTwistSurface::GetEdgeVisibility ( G4int  i, G4int  j, G4int  m, G4int  n, G4int  number, G4int  orientation  )

inherited

Definition at line 1031 of file G4VTwistSurface.cc.

{
  // clockwise filling         -> positive orientation
  // counter clockwise filling -> negative orientation 
 
  //
  //   d    C    c
  //     +------+ 
  //     |      |
  //     |      |
  //     |      |
  //   D |      |B
  //     |      |
  //     |      |
  //     |      |
  //     +------+
  //    a   A    b
  //    
  //  a = +--+    A = ---+
  //  b = --++    B = --+-
  //  c = -++-    C = -+--
  //  d = ++--    D = +---
 
 
  // check first invisible faces
 
  if ( ( i>0 && i<n-2 ) && ( j>0 && j<k-2 ) )
  {
    return -1 ;   // always invisible, signs:   ----
  }
  
  // change first the vertex number (depends on the orientation)
  // 0,1,2,3  -> 3,2,1,0
  if ( orientation < 0 ) { number = ( 3 - number ) ;  }
  
  // check true edges
  if ( ( j>=1 && j<=k-3 ) )
  {
    if ( i == 0 )  {        // signs (A):  ---+  
      return ( number == 3 ) ? 1 : -1 ;
    }
    
    else if ( i == n-2 ) {  // signs (C):  -+--
      return  ( number == 1 ) ? 1 : -1 ; 
    }
    
    else
    {
      std::ostringstream message;
      message << "Not correct face number: " << GetName() << " !";
      G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
                  "GeomSolids0003", FatalException, message);
    }
  }
  
  if ( ( i>=1 && i<=n-3 ) )
  {
    if ( j == 0 )  {        // signs (D):  +---
      return ( number == 0 ) ? 1 : -1 ;
    }
 
    else if ( j == k-2 ) {  // signs (B):  --+-
      return  ( number == 2 ) ? 1 : -1 ; 
    }
 
    else
    {
      std::ostringstream message;
      message << "Not correct face number: " << GetName() << " !";
      G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
                  "GeomSolids0003", FatalException, message);
    }
  }
  
  // now the corners
  if ( i == 0 && j == 0 ) {          // signs (a) : +--+
    return ( number == 0 || number == 3 ) ? 1 : -1 ;
  }
  else if ( i == 0 && j == k-2 ) {   // signs (b) : --++
    return ( number == 2 || number == 3 ) ? 1 : -1 ;
  }
  else if ( i == n-2 && j == k-2 ) { // signs (c) : -++-
    return ( number == 1 || number == 2 ) ? 1 : -1 ;
  }
  else if ( i == n-2 && j == 0 ) {   // signs (d) : ++--
    return ( number == 0 || number == 1 ) ? 1 : -1 ;
  }
  else
  {
    std::ostringstream message;
    message << "Not correct face number: " << GetName() << " !";
    G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
                "GeomSolids0003", FatalException, message);
  }
 
  std::ostringstream message;
  message << "Not correct face number: " << GetName() << " !";
  G4Exception("G4TwistSurface::G4GetEdgeVisibility()", "GeomSolids0003",
              FatalException, message);
 
  return 0 ;
}

References FatalException, G4Exception(), G4VTwistSurface::GetName(), and CLHEP::detail::n.

Referenced by G4TwistBoxSide::GetFacets(), G4TwistTrapAlphaSide::GetFacets(), G4TwistTrapFlatSide::GetFacets(), GetFacets(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), and G4TwistTubsSide::GetFacets().

GetFace()

G4int G4VTwistSurface::GetFace ( G4int  i, G4int  j, G4int  m, G4int  n, G4int  iside  )

inherited

Definition at line 906 of file G4VTwistSurface.cc.

{
  // this is the face mapping function
  // (i,j) -> face number
 
  if ( iside == 0 ) {
    return i * ( k - 1 ) + j ;
  }
 
  else if ( iside == 1 ) {
    return (k-1)*(k-1) + i*(k-1) + j ;
  }
 
  else if ( iside == 2 ) {
    return 2*(k-1)*(k-1) + i*(k-1) + j ;
  }
 
  else if ( iside == 3 ) {
    return 2*(k-1)*(k-1) + (n-1)*(k-1) + i*(k-1) + j ;
  }
  
  else if ( iside == 4 ) {
    return 2*(k-1)*(k-1) + 2*(n-1)*(k-1) + i*(k-1) + j ;
  }
  
  else if ( iside == 5 ) {
    return 2*(k-1)*(k-1) + 3*(n-1)*(k-1) + i*(k-1) + j ;
  }
 
  else {
    std::ostringstream message;
    message << "Not correct side number: "
            << GetName() << G4endl
            << "iside is " << iside << " but should be "
            << "0,1,2,3,4 or 5" << ".";
    G4Exception("G4TwistSurface::G4GetFace()", "GeomSolids0002",
                FatalException, message);
  }
 
  return -1 ;  // wrong face
}

References FatalException, G4endl, G4Exception(), G4VTwistSurface::GetName(), and CLHEP::detail::n.

Referenced by G4TwistBoxSide::GetFacets(), G4TwistTrapAlphaSide::GetFacets(), G4TwistTrapFlatSide::GetFacets(), GetFacets(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), and G4TwistTubsSide::GetFacets().

GetFacets()

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

privatevirtual

Implements G4VTwistSurface.

Definition at line 1024 of file G4TwistTrapParallelSide.cc.

{
  G4double phi ;
  G4double z, u ;     // the two parameters for the surface equation
  G4ThreeVector p ;  // a point on the surface, given by (z,u)
 
  G4int nnode ;
  G4int nface ;
 
  G4double umin, umax ;
 
  // calculate the (n-1)*(k-1) vertices
 
  for ( G4int i = 0 ; i<n ; ++i )
  {
    z = -fDz+i*(2.*fDz)/(n-1) ;
    phi = z*fPhiTwist/(2*fDz) ;
    umin = GetBoundaryMin(phi) ;
    umax = GetBoundaryMax(phi) ;
 
    for ( G4int j = 0 ; j<k ; ++j )
    {
      nnode = GetNode(i,j,k,n,iside) ;
      u = umax - j*(umax-umin)/(k-1) ;
      p = SurfacePoint(phi,u,true) ;  // surface point in global coords
 
      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) ;
        faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,-1)
                        * (GetNode(i  ,j  ,k,n,iside)+1) ; // fortran numbering
        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) ;
      }
    }
  }
}

References fDz, fPhiTwist, GetBoundaryMax(), GetBoundaryMin(), G4VTwistSurface::GetEdgeVisibility(), G4VTwistSurface::GetFace(), G4VTwistSurface::GetNode(), CLHEP::detail::n, SurfacePoint(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

GetName()

virtual G4String G4VTwistSurface::GetName ( ) const

inlinevirtualinherited

Definition at line 107 of file G4VTwistSurface.hh.

{ return fName; }

References G4VTwistSurface::fName.

Referenced by G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistBoxSide::G4TwistBoxSide(), G4VTwistSurface::GetEdgeVisibility(), G4VTwistSurface::GetFace(), G4VTwistSurface::GetNode(), and G4TwistTubsHypeSide::Inside().

GetNeighbours() [1/2]

G4VTwistSurface ** G4VTwistSurface::GetNeighbours ( )

inlineprotectedinherited

Definition at line 183 of file G4VTwistSurface.hh.

{ return fNeighbours; } 

References G4VTwistSurface::fNeighbours.

Referenced by G4VTwistSurface::DistanceToIn().

GetNeighbours() [2/2]

G4int G4VTwistSurface::GetNeighbours ( G4int  areacode, G4VTwistSurface *  surfaces[]  )

inlineprotectedinherited

GetNode()

G4int G4VTwistSurface::GetNode ( G4int  i, G4int  j, G4int  m, G4int  n, G4int  iside  )

inherited

Definition at line 952 of file G4VTwistSurface.cc.

{
  // this is the node mapping function
  // (i,j) -> node number
  // Depends on the side iside and the used meshing of the surface
 
  if ( iside == 0 )
  {
    // lower endcap is kxk squared. 
    // n = k 
    return i * k + j ;
  }
 
  if ( iside == 1 )
  {
    // upper endcap is kxk squared. Shift by k*k
    // n = k 
    return  k*k + i*k + j ;
  }
 
  else if ( iside == 2 )
  {
    // front side.
    if      ( i == 0 )   { return       j ;  }
    else if ( i == n-1 ) { return k*k + j ;  } 
    else                 { return 2*k*k + 4*(i-1)*(k-1) + j ; }
  }
 
  else if ( iside == 3 )
  {
    // right side
    if      ( i == 0 )   { return       (j+1)*k - 1 ; } 
    else if ( i == n-1 ) { return k*k + (j+1)*k - 1 ; }
    else
    {
      return 2*k*k + 4*(i-1)*(k-1) + (k-1) + j ;
    }
  }
  else if ( iside == 4 )
  {
    // back side
    if      ( i == 0 )   { return   k*k - 1 - j ; }    // reversed order
    else if ( i == n-1 ) { return 2*k*k - 1 - j ; }    // reversed order 
    else
    {
      return 2*k*k + 4*(i-1)*(k-1) + 2*(k-1) + j ; // normal order
    }
  }
  else if ( iside == 5 )
  {
    // left side 
    if      ( i == 0 )   { return k*k   - (j+1)*k ; }  // reversed order
    else if ( i == n-1)  { return 2*k*k - (j+1)*k ; }  // reverded order
    else
    {
      if ( j == k-1 ) { return 2*k*k + 4*(i-1)*(k-1) ; } // special case
      else
      {
        return 2*k*k + 4*(i-1)*(k-1) + 3*(k-1) + j ; // normal order
      }
    }
  }
  else
  {
    std::ostringstream message;
    message << "Not correct side number: "
            << GetName() << G4endl
            << "iside is " << iside << " but should be "
            << "0,1,2,3,4 or 5" << ".";
    G4Exception("G4TwistSurface::G4GetNode()", "GeomSolids0002",
                FatalException, message);
  } 
  return -1 ;  // wrong node 
} 

References FatalException, G4endl, G4Exception(), G4VTwistSurface::GetName(), and CLHEP::detail::n.

Referenced by G4TwistBoxSide::GetFacets(), G4TwistTrapAlphaSide::GetFacets(), G4TwistTrapFlatSide::GetFacets(), GetFacets(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), and G4TwistTubsSide::GetFacets().

GetNormal()

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

virtual

Implements G4VTwistSurface.

Definition at line 129 of file G4TwistTrapParallelSide.cc.

{
   // GetNormal returns a normal vector at a surface (or very close
   // to surface) point at tmpxx.
   // If isGlobal=true, it returns the normal in global coordinate.
   //
 
   G4ThreeVector xx;
   if (isGlobal)
   {
      xx = ComputeLocalPoint(tmpxx);
      if ((xx - fCurrentNormal.p).mag() < 0.5 * kCarTolerance)
      {
         return ComputeGlobalDirection(fCurrentNormal.normal);
      }
   }
   else
   {
      xx = tmpxx;
      if (xx == fCurrentNormal.p)
      {
         return fCurrentNormal.normal;
      }
   }
 
   G4double phi ;
   G4double u ;
 
   GetPhiUAtX(xx,phi,u) ;   // phi,u for point xx close to surface 
 
   G4ThreeVector normal =  NormAng(phi,u) ;  // the normal vector at phi,u
 
#ifdef G4TWISTDEBUG
   G4cout  << "normal vector = " << normal << G4endl ;
   G4cout << "phi = " << phi << " , u = " << u << G4endl ;
#endif
 
   //    normal = normal/normal.mag() ;
 
   if (isGlobal)
   {
      fCurrentNormal.normal = ComputeGlobalDirection(normal.unit());
   }
   else
   {
      fCurrentNormal.normal = normal.unit();
   }
   return fCurrentNormal.normal;
}

References G4VTwistSurface::ComputeGlobalDirection(), G4VTwistSurface::ComputeLocalPoint(), G4VTwistSurface::fCurrentNormal, G4cout, G4endl, GetPhiUAtX(), G4VTwistSurface::kCarTolerance, CLHEP::normal(), G4VTwistSurface::G4SurfCurNormal::normal, NormAng(), and G4VTwistSurface::G4SurfCurNormal::p.

GetPhiUAtX()

void G4TwistTrapParallelSide::GetPhiUAtX ( G4ThreeVector  p, G4double &  phi, G4double &  u  )

private

Definition at line 972 of file G4TwistTrapParallelSide.cc.

{
  // find closest point XX on surface for a given point p
  // X0 is a point on the surface,  d is the direction
  // ( both for a fixed z = pz)
  
  // phi is given by the z coordinate of p
 
  phi = p.z()/(2*fDz)*fPhiTwist ;
 
  u = ((-(fdeltaX*phi) + fPhiTwist*p.x())* std::cos(phi)
    + (-(fdeltaY*phi) + fPhiTwist*p.y())*std::sin(phi))/fPhiTwist ;
}

References fdeltaX, fdeltaY, fDz, fPhiTwist, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToSurface(), GetAreaCode(), GetNormal(), and ProjectPoint().

GetSurfaceArea()

G4double G4TwistTrapParallelSide::GetSurfaceArea ( )

inlineprivatevirtual

Implements G4VTwistSurface.

Definition at line 192 of file G4TwistTrapParallelSide.hh.

{
  return 2*fDx4plus2*fDz ;
}

References fDx4plus2, and fDz.

GetValueB()

G4double G4TwistTrapParallelSide::GetValueB ( G4double  phi )

inlineprivate

Definition at line 150 of file G4TwistTrapParallelSide.hh.

{
  return ( fDy2plus1 + fDy2minus1 * ( 2 * phi ) / fPhiTwist ) ;
}

References fDy2minus1, fDy2plus1, and fPhiTwist.

Referenced by Xcoef().

IsAxis0()

G4bool G4VTwistSurface::IsAxis0 ( G4int  areacode ) const

inlineinherited

Referenced by G4VTwistSurface::DistanceToBoundary().

IsAxis1()

G4bool G4VTwistSurface::IsAxis1 ( G4int  areacode ) const

inlineinherited

Referenced by G4VTwistSurface::DistanceToBoundary().

IsBoundary()

G4bool G4VTwistSurface::IsBoundary ( G4int  areacode, G4bool  testbitmode = false  ) const

inlineinherited

Referenced by G4TwistTubsHypeSide::Inside(), and G4VTwistSurface::IsSameBoundary().

IsCorner()

G4bool G4VTwistSurface::IsCorner ( G4int  areacode, G4bool  testbitmode = false  ) const

inlineinherited

Referenced by G4VTwistSurface::IsSameBoundary().

IsInside()

G4bool G4VTwistSurface::IsInside ( G4int  areacode, G4bool  testbitmode = false  ) const

inlineinherited

Referenced by G4VTwistSurface::DistanceToIn(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsHypeSide::Inside().

IsOutside()

G4bool G4VTwistSurface::IsOutside ( G4int  areacode ) const

inlineinherited

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), G4TwistTubsHypeSide::GetAreaCode(), and G4TwistTubsHypeSide::Inside().

IsSameBoundary()

G4bool G4VTwistSurface::IsSameBoundary ( G4VTwistSurface *  surface1, G4int  areacode1, G4VTwistSurface *  surface2, G4int  areacode2  ) const

inherited

Definition at line 616 of file G4VTwistSurface.cc.

{
   //
   // IsSameBoundary
   //
   // checking tool whether two boundaries on different surfaces are same or not.
   //
 
   G4bool testbitmode = true;
   G4bool iscorner[2] = {IsCorner(areacode1, testbitmode), 
                         IsCorner(areacode2, testbitmode)};
 
   if (iscorner[0] && iscorner[1])
   {
      // on corner 
      G4ThreeVector corner1 = 
           surf1->ComputeGlobalPoint(surf1->GetCorner(areacode1));
      G4ThreeVector corner2 = 
           surf2->ComputeGlobalPoint(surf2->GetCorner(areacode2));
 
      if ((corner1 - corner2).mag() < kCarTolerance) { return true; }
      else                                           { return false; }
   }
   else if ((IsBoundary(areacode1, testbitmode) && (!iscorner[0])) &&
            (IsBoundary(areacode2, testbitmode) && (!iscorner[1])))
   {
      // on boundary  
      G4ThreeVector d1, d2, ld1, ld2;
      G4ThreeVector x01, x02, lx01, lx02;
      G4int         type1, type2;
      surf1->GetBoundaryParameters(areacode1, ld1, lx01, type1);
      surf2->GetBoundaryParameters(areacode2, ld2, lx02, type2);
 
      x01 = surf1->ComputeGlobalPoint(lx01);
      x02 = surf2->ComputeGlobalPoint(lx02);
      d1  = surf1->ComputeGlobalDirection(ld1);
      d2  = surf2->ComputeGlobalDirection(ld2);
 
      if ((x01 - x02).mag() < kCarTolerance &&
          (d1 - d2).mag() < kCarTolerance) { return true; }
      else                                 { return false; }
   }
   else
   {
      return false;
   }
}

References G4VTwistSurface::ComputeGlobalDirection(), G4VTwistSurface::ComputeGlobalPoint(), d1, d2, G4VTwistSurface::GetBoundaryParameters(), G4VTwistSurface::GetCorner(), G4VTwistSurface::IsBoundary(), G4VTwistSurface::IsCorner(), and G4VTwistSurface::kCarTolerance.

Referenced by G4VTwistSurface::DistanceToIn().

IsValidNorm()

G4bool G4VTwistSurface::IsValidNorm ( ) const

inlineinherited

Definition at line 144 of file G4VTwistSurface.hh.

{ return fIsValidNorm; }

References G4VTwistSurface::fIsValidNorm.

Referenced by G4TwistedTubs::DistanceToOut(), and G4VTwistedFaceted::DistanceToOut().

NormAng()

G4ThreeVector G4TwistTrapParallelSide::NormAng ( G4double  phi, G4double  u  )

inlineprivate

Definition at line 198 of file G4TwistTrapParallelSide.hh.

{
  // function to calculate the norm at a given point on the surface
  // replace a1-d1
 
  G4ThreeVector nvec(-2*fDz*std::sin(phi) ,
                      2*fDz*std::cos(phi) ,
                     -(fDy2minus1 + fPhiTwist*u + fdeltaY*std::cos(phi)
                     -fdeltaX*std::sin(phi))) ;
  return nvec.unit();
}

References fdeltaX, fdeltaY, fDy2minus1, fDz, fPhiTwist, and CLHEP::Hep3Vector::unit().

Referenced by DistanceToSurface(), and GetNormal().

ProjectPoint()

G4ThreeVector G4TwistTrapParallelSide::ProjectPoint ( const G4ThreeVector &  p, G4bool  isglobal = false  )

private

Definition at line 990 of file G4TwistTrapParallelSide.cc.

{
  // Get Rho at p.z() on Hyperbolic Surface.
  G4ThreeVector tmpp;
  if (isglobal)
  {
     tmpp = fRot.inverse()*p - fTrans;
  }
  else
  {
     tmpp = p;
  }
 
  G4double phi ;
  G4double u ;
 
  GetPhiUAtX( tmpp, phi, u ) ;  // calculate (phi, u) for p close to surface
  
  G4ThreeVector xx = SurfacePoint(phi,u) ; // transform back to Cartesian coords
 
  if (isglobal)
  {
     return (fRot * xx + fTrans);
  }
  else
  {
     return xx;
  }
}

References G4VTwistSurface::fRot, G4VTwistSurface::fTrans, GetPhiUAtX(), CLHEP::HepRotation::inverse(), and SurfacePoint().

SetAxis()

void G4VTwistSurface::SetAxis ( G4int  i, const EAxis  axis  )

inlineinherited

Definition at line 156 of file G4VTwistSurface.hh.

{ fAxis[i] = axis; }

References G4VTwistSurface::fAxis.

SetBoundaries()

void G4TwistTrapParallelSide::SetBoundaries ( )

privatevirtual

Implements G4VTwistSurface.

Definition at line 927 of file G4TwistTrapParallelSide.cc.

{
   // Set direction-unit vector of boundary-lines in local coodinate. 
   //   
 
  G4ThreeVector direction;
   
  if (fAxis[0] == kXAxis && fAxis[1] == kZAxis)
  {
    // sAxis0 & sAxisMin
    direction = GetCorner(sC0Min1Max) - GetCorner(sC0Min1Min);
    direction = direction.unit();
    SetBoundary(sAxis0 & (sAxisX | sAxisMin), direction, 
                GetCorner(sC0Min1Min), sAxisZ) ;
      
      // sAxis0 & sAxisMax
    direction = GetCorner(sC0Max1Max) - GetCorner(sC0Max1Min);
    direction = direction.unit();
    SetBoundary(sAxis0 & (sAxisX | sAxisMax), direction, 
                GetCorner(sC0Max1Min), sAxisZ);
    
    // sAxis1 & sAxisMin
    direction = GetCorner(sC0Max1Min) - GetCorner(sC0Min1Min);
    direction = direction.unit();
    SetBoundary(sAxis1 & (sAxisZ | sAxisMin), direction, 
                GetCorner(sC0Min1Min), sAxisX);
    
    // sAxis1 & sAxisMax
    direction = GetCorner(sC0Max1Max) - GetCorner(sC0Min1Max);
    direction = direction.unit();
    SetBoundary(sAxis1 & (sAxisZ | sAxisMax), direction, 
                GetCorner(sC0Min1Max), sAxisX);
  }
  else
  {
    G4Exception("G4TwistTrapParallelSide::SetCorners()",
                "GeomSolids0001", FatalException,
                "Feature NOT implemented !");
  }
}

References FatalException, G4VTwistSurface::fAxis, G4Exception(), G4VTwistSurface::GetCorner(), kXAxis, kZAxis, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sAxisX, G4VTwistSurface::sAxisZ, G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, G4VTwistSurface::SetBoundary(), and CLHEP::Hep3Vector::unit().

Referenced by G4TwistTrapParallelSide().

SetBoundary()

void G4VTwistSurface::SetBoundary ( const G4int &  axiscode, const G4ThreeVector &  direction, const G4ThreeVector &  x0, const G4int &  boundarytype  )

protectedvirtualinherited

Definition at line 863 of file G4VTwistSurface.cc.

{
   G4int code = (~sAxisMask) & axiscode;
   if ((code == (sAxis0 & sAxisMin)) ||
       (code == (sAxis0 & sAxisMax)) ||
       (code == (sAxis1 & sAxisMin)) ||
       (code == (sAxis1 & sAxisMax)))
   {
      G4bool done = false;
      for (auto i=0; i<4; ++i)
      {
         if (fBoundaries[i].IsEmpty())
         {
            fBoundaries[i].SetFields(axiscode, direction,
                                     x0, boundarytype);
            done = true;
            break;
         }
      }
 
      if (!done)
      {
         G4Exception("G4VTwistSurface::SetBoundary()", "GeomSolids0003",
                      FatalException, "Number of boundary exceeding 4!");
      }
   }
   else
   {
      std::ostringstream message;
      message << "Invalid axis-code." << G4endl
              << "        axiscode = "
              << std::hex << axiscode << std::dec;
      G4Exception("G4VTwistSurface::SetBoundary()", "GeomSolids0003",
                  FatalException, message);
   }
}

References FatalException, G4VTwistSurface::fBoundaries, G4endl, G4Exception(), G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, and G4VTwistSurface::Boundary::SetFields().

Referenced by G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), and G4TwistTubsSide::SetBoundaries().

SetCorner()

void G4VTwistSurface::SetCorner ( G4int  areacode, G4double  x, G4double  y, G4double  z  )

protectedinherited

Definition at line 757 of file G4VTwistSurface.cc.

{
   if ((areacode & sCorner) != sCorner)
   {
     std::ostringstream message;
     message << "Area code must represents corner." << G4endl
             << "        areacode " << areacode;
     G4Exception("G4VTwistSurface::SetCorner()", "GeomSolids0002",
                 FatalException, message);
   }
 
   if ((areacode & sC0Min1Min) == sC0Min1Min) {
      fCorners[0].set(x, y, z);
   } else if ((areacode & sC0Max1Min) == sC0Max1Min) {
      fCorners[1].set(x, y, z);
   } else if ((areacode & sC0Max1Max) == sC0Max1Max) {
      fCorners[2].set(x, y, z);
   } else if ((areacode & sC0Min1Max) == sC0Min1Max) {
      fCorners[3].set(x, y, z);
   }
}

References FatalException, G4VTwistSurface::fCorners, G4endl, G4Exception(), G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, G4VTwistSurface::sCorner, and CLHEP::Hep3Vector::set().

Referenced by G4TwistBoxSide::SetCorners(), G4TwistTrapAlphaSide::SetCorners(), G4TwistTrapFlatSide::SetCorners(), SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::SetCorners(), and G4TwistTubsHypeSide::SetCorners().

SetCorners()

void G4TwistTrapParallelSide::SetCorners ( )

privatevirtual

Implements G4VTwistSurface.

Definition at line 869 of file G4TwistTrapParallelSide.cc.

{
 
  // Set Corner points in local coodinate.   
 
  if (fAxis[0] == kXAxis && fAxis[1] == kZAxis)
  {
    G4double x, y, z;
 
    // corner of Axis0min and Axis1min
 
    x = -fdeltaX/2. + (-fDx2 + fDy1*fTAlph)*std::cos(fPhiTwist/2.)
      + fDy1*std::sin(fPhiTwist/2.) ;
    y = -fdeltaY/2. + fDy1*std::cos(fPhiTwist/2.)
      + (fDx2 - fDy1*fTAlph)*std::sin(fPhiTwist/2.) ;
    z = -fDz ;
 
    SetCorner(sC0Min1Min, x, y, z);
      
    // corner of Axis0max and Axis1min
 
    x = -fdeltaX/2. + (fDx2 + fDy1*fTAlph)*std::cos(fPhiTwist/2.)
      + fDy1*std::sin(fPhiTwist/2.) ;
    y = -fdeltaY/2. + fDy1*std::cos(fPhiTwist/2.)
      - (fDx2 + fDy1*fTAlph)*std::sin(fPhiTwist/2.) ;
    z = -fDz;
 
    SetCorner(sC0Max1Min, x, y, z);
      
    // corner of Axis0max and Axis1max
    x = fdeltaX/2. + (fDx4 + fDy2*fTAlph)*std::cos(fPhiTwist/2.)
      - fDy2*std::sin(fPhiTwist/2.) ;
    y = fdeltaY/2. + fDy2*std::cos(fPhiTwist/2.)
      + (fDx4 + fDy2*fTAlph)*std::sin(fPhiTwist/2.) ;
    z = fDz ;
 
    SetCorner(sC0Max1Max, x, y, z);
      
    // corner of Axis0min and Axis1max
    x = fdeltaX/2. + (-fDx4 + fDy2*fTAlph)*std::cos(fPhiTwist/2.)
      - fDy2*std::sin(fPhiTwist/2.) ;
    y = fdeltaY/2. + fDy2*std::cos(fPhiTwist/2.)
      + (-fDx4 + fDy2*fTAlph)*std::sin(fPhiTwist/2.) ;
    z = fDz ;
 
    SetCorner(sC0Min1Max, x, y, z);
  }
  else
  {
    G4Exception("G4TwistTrapParallelSide::SetCorners()",
                "GeomSolids0001", FatalException,
                "Method NOT implemented !");
  }
}

References FatalException, G4VTwistSurface::fAxis, fdeltaX, fdeltaY, fDx2, fDx4, fDy1, fDy2, fDz, fPhiTwist, fTAlph, G4Exception(), kXAxis, kZAxis, G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, and G4VTwistSurface::SetCorner().

Referenced by G4TwistTrapParallelSide().

SetNeighbours()

void G4VTwistSurface::SetNeighbours ( G4VTwistSurface *  ax0min, G4VTwistSurface *  ax1min, G4VTwistSurface *  ax0max, G4VTwistSurface *  ax1max  )

inlineinherited

Referenced by G4TwistedTubs::CreateSurfaces(), and G4VTwistedFaceted::CreateSurfaces().

SurfacePoint()

G4ThreeVector G4TwistTrapParallelSide::SurfacePoint ( G4double  phi, G4double  u, G4bool  isGlobal = false  )

inlineprivatevirtual

Implements G4VTwistSurface.

Definition at line 162 of file G4TwistTrapParallelSide.hh.

{
  // function to calculate a point on the surface, given by parameters phi,u
 
  G4ThreeVector SurfPoint ( u*std::cos(phi) - Xcoef(phi)*std::sin(phi)
                          + fdeltaX*phi/fPhiTwist,
                            u*std::sin(phi) + Xcoef(phi)*std::cos(phi)
                          + fdeltaY*phi/fPhiTwist,
                            2*fDz*phi/fPhiTwist  );
  if (isGlobal) { return (fRot * SurfPoint + fTrans); }
  return SurfPoint;
}

References fdeltaX, fdeltaY, fDz, fPhiTwist, G4VTwistSurface::fRot, G4VTwistSurface::fTrans, and Xcoef().

Referenced by DistanceToSurface(), GetFacets(), and ProjectPoint().

Xcoef()

G4double G4TwistTrapParallelSide::Xcoef ( G4double  u )

inlineprivate

Definition at line 156 of file G4TwistTrapParallelSide.hh.

{
  return GetValueB(phi)/2. ;
}

References GetValueB().

Referenced by SurfacePoint().

Field Documentation

fa1md1

G4double G4TwistTrapParallelSide::fa1md1

private

Definition at line 140 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fa2md2

G4double G4TwistTrapParallelSide::fa2md2

private

Definition at line 141 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fAlph

G4double G4TwistTrapParallelSide::fAlph

private

Definition at line 124 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fAmIOnLeftSide

G4SurfSideQuery G4VTwistSurface::fAmIOnLeftSide

privateinherited

Definition at line 342 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::AmIOnLeftSide(), and G4VTwistSurface::G4VTwistSurface().

fAngleSide

G4double G4TwistTrapParallelSide::fAngleSide

private

Definition at line 129 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fAxis

EAxis G4VTwistSurface::fAxis[2]

protectedinherited

Definition at line 308 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::SetAxis(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), G4TwistBoxSide::SetCorners(), G4TwistTrapAlphaSide::SetCorners(), G4TwistTrapFlatSide::SetCorners(), SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::SetCorners(), and G4TwistTubsHypeSide::SetCorners().

fAxisMax

G4double G4VTwistSurface::fAxisMax[2]

protectedinherited

Definition at line 310 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsSide::GetBoundaryMax(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), G4TwistTubsSide::GetFacets(), G4TwistTubsHypeSide::GetSurfaceArea(), G4TwistTubsSide::GetSurfaceArea(), and G4TwistTubsFlatSide::SetCorners().

fAxisMin

G4double G4VTwistSurface::fAxisMin[2]

protectedinherited

Definition at line 309 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsSide::GetBoundaryMin(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), G4TwistTubsSide::GetFacets(), G4TwistTubsHypeSide::GetSurfaceArea(), G4TwistTubsSide::GetSurfaceArea(), and G4TwistTubsFlatSide::SetCorners().

fBoundaries

Boundary G4VTwistSurface::fBoundaries[4]

privateinherited

Definition at line 331 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryParameters(), and G4VTwistSurface::SetBoundary().

fCorners

G4ThreeVector G4VTwistSurface::fCorners[4]

privateinherited

Definition at line 330 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::G4VTwistSurface(), and G4VTwistSurface::SetCorner().

fCurrentNormal

G4SurfCurNormal G4VTwistSurface::fCurrentNormal

protectedinherited

Definition at line 322 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistTrapFlatSide::GetNormal(), G4TwistTubsFlatSide::GetNormal(), G4TwistBoxSide::GetNormal(), G4TwistTrapAlphaSide::GetNormal(), GetNormal(), G4TwistTubsHypeSide::GetNormal(), and G4TwistTubsSide::GetNormal().

fCurStat

CurrentStatus G4VTwistSurface::fCurStat

protectedinherited

Definition at line 312 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), and G4TwistTubsHypeSide::DistanceToSurface().

fCurStatWithV

CurrentStatus G4VTwistSurface::fCurStatWithV

protectedinherited

Definition at line 311 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

fdeltaX

G4double G4TwistTrapParallelSide::fdeltaX

private

Definition at line 131 of file G4TwistTrapParallelSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapParallelSide(), GetPhiUAtX(), NormAng(), SetCorners(), and SurfacePoint().

fdeltaY

G4double G4TwistTrapParallelSide::fdeltaY

private

Definition at line 132 of file G4TwistTrapParallelSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapParallelSide(), GetPhiUAtX(), NormAng(), SetCorners(), and SurfacePoint().

fDx1

G4double G4TwistTrapParallelSide::fDx1

private

Definition at line 115 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fDx2

G4double G4TwistTrapParallelSide::fDx2

private

Definition at line 116 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide(), GetBoundaryMax(), GetBoundaryMin(), and SetCorners().

fDx3

G4double G4TwistTrapParallelSide::fDx3

private

Definition at line 119 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fDx3minus1

G4double G4TwistTrapParallelSide::fDx3minus1

private

Definition at line 137 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fDx3plus1

G4double G4TwistTrapParallelSide::fDx3plus1

private

Definition at line 136 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fDx4

G4double G4TwistTrapParallelSide::fDx4

private

Definition at line 120 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide(), GetBoundaryMax(), GetBoundaryMin(), and SetCorners().

fDx4minus2

G4double G4TwistTrapParallelSide::fDx4minus2

private

Definition at line 135 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide(), GetBoundaryMax(), and GetBoundaryMin().

fDx4plus2

G4double G4TwistTrapParallelSide::fDx4plus2

private

Definition at line 134 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide(), and GetSurfaceArea().

fDy1

G4double G4TwistTrapParallelSide::fDy1

private

Definition at line 114 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide(), and SetCorners().

fDy2

G4double G4TwistTrapParallelSide::fDy2

private

Definition at line 118 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide(), and SetCorners().

fDy2minus1

G4double G4TwistTrapParallelSide::fDy2minus1

private

Definition at line 139 of file G4TwistTrapParallelSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapParallelSide(), GetBoundaryMax(), GetBoundaryMin(), GetValueB(), and NormAng().

fDy2plus1

G4double G4TwistTrapParallelSide::fDy2plus1

private

Definition at line 138 of file G4TwistTrapParallelSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapParallelSide(), GetBoundaryMax(), GetBoundaryMin(), and GetValueB().

fDz

G4double G4TwistTrapParallelSide::fDz

private

Definition at line 122 of file G4TwistTrapParallelSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapParallelSide(), GetFacets(), GetPhiUAtX(), GetSurfaceArea(), NormAng(), SetCorners(), and SurfacePoint().

fHandedness

G4int G4VTwistSurface::fHandedness

protectedinherited

Definition at line 315 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistTrapFlatSide::GetFacets(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), G4TwistTubsSide::GetFacets(), G4TwistTubsHypeSide::GetNormal(), G4TwistTubsSide::GetNormal(), G4TwistTubsHypeSide::Inside(), and G4TwistTubsHypeSide::SetCorners().

fIsValidNorm

G4bool G4VTwistSurface::fIsValidNorm

protectedinherited

Definition at line 323 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), and G4VTwistSurface::IsValidNorm().

fName

G4String G4VTwistSurface::fName

privateinherited

Definition at line 332 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::AmIOnLeftSide(), G4VTwistSurface::DebugPrint(), G4VTwistSurface::DistanceTo(), G4VTwistSurface::DistanceToIn(), G4VTwistSurface::DistanceToOut(), and G4VTwistSurface::GetName().

fNeighbours

G4VTwistSurface* G4VTwistSurface::fNeighbours[4]

privateinherited

Definition at line 328 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::G4VTwistSurface(), and G4VTwistSurface::GetNeighbours().

fPhi

G4double G4TwistTrapParallelSide::fPhi

private

Definition at line 112 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fPhiTwist

G4double G4TwistTrapParallelSide::fPhiTwist

private

Definition at line 127 of file G4TwistTrapParallelSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapParallelSide(), GetBoundaryMax(), GetBoundaryMin(), GetFacets(), GetPhiUAtX(), GetValueB(), NormAng(), SetCorners(), and SurfacePoint().

fRot

G4RotationMatrix G4VTwistSurface::fRot

protectedinherited

Definition at line 313 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistTubsHypeSide::GetRhoAtPZ(), G4TwistTubsSide::ProjectAtPXPZ(), G4TwistBoxSide::ProjectPoint(), G4TwistTrapAlphaSide::ProjectPoint(), ProjectPoint(), G4TwistBoxSide::SurfacePoint(), G4TwistTrapAlphaSide::SurfacePoint(), SurfacePoint(), G4TwistTrapFlatSide::SurfacePoint(), G4TwistTubsFlatSide::SurfacePoint(), G4TwistTubsHypeSide::SurfacePoint(), and G4TwistTubsSide::SurfacePoint().

fTAlph

G4double G4TwistTrapParallelSide::fTAlph

private

Definition at line 125 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide(), GetBoundaryMax(), GetBoundaryMin(), and SetCorners().

fTheta

G4double G4TwistTrapParallelSide::fTheta

private

Definition at line 111 of file G4TwistTrapParallelSide.hh.

Referenced by G4TwistTrapParallelSide().

fTrans

G4ThreeVector G4VTwistSurface::fTrans

protectedinherited

Definition at line 314 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistTubsHypeSide::GetRhoAtPZ(), G4TwistTubsSide::ProjectAtPXPZ(), G4TwistBoxSide::ProjectPoint(), G4TwistTrapAlphaSide::ProjectPoint(), ProjectPoint(), G4TwistBoxSide::SurfacePoint(), G4TwistTrapAlphaSide::SurfacePoint(), SurfacePoint(), G4TwistTrapFlatSide::SurfacePoint(), G4TwistTubsFlatSide::SurfacePoint(), G4TwistTubsHypeSide::SurfacePoint(), and G4TwistTubsSide::SurfacePoint().

kCarTolerance

G4double G4VTwistSurface::kCarTolerance

protectedinherited

Definition at line 324 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToPlane(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4TwistBoxSide::GetNormal(), G4TwistTrapAlphaSide::GetNormal(), GetNormal(), G4TwistTubsHypeSide::GetNormal(), G4TwistTubsSide::GetNormal(), and G4VTwistSurface::IsSameBoundary().

sAreaMask

const G4int G4VTwistSurface::sAreaMask = 0XF0000000

staticinherited

Definition at line 235 of file G4VTwistSurface.hh.

sAxis0

const G4int G4VTwistSurface::sAxis0 = 0x0000FF00

staticinherited

Definition at line 231 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsHypeSide::GetBoundaryMax(), G4TwistTubsHypeSide::GetBoundaryMin(), G4VTwistSurface::Boundary::GetBoundaryParameters(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), and G4VTwistSurface::SetBoundary().

sAxis1

const G4int G4VTwistSurface::sAxis1 = 0x000000FF

staticinherited

Definition at line 232 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), G4VTwistSurface::GetBoundaryLimit(), G4VTwistSurface::Boundary::GetBoundaryParameters(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), and G4VTwistSurface::SetBoundary().

sAxisMask

const G4int G4VTwistSurface::sAxisMask = 0x0000FCFC

staticinherited

Definition at line 234 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::GetBoundaryAxis().

sAxisMax

const G4int G4VTwistSurface::sAxisMax = 0x00000202

staticinherited

Definition at line 225 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsHypeSide::GetBoundaryMax(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), and G4VTwistSurface::SetBoundary().

sAxisMin

const G4int G4VTwistSurface::sAxisMin = 0x00000101

staticinherited

Definition at line 224 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsHypeSide::GetBoundaryMin(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), and G4VTwistSurface::SetBoundary().

sAxisPhi

const G4int G4VTwistSurface::sAxisPhi = 0x00001414

staticinherited

Definition at line 230 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DistanceToBoundary(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), G4TwistTubsFlatSide::SetBoundaries(), and G4TwistTubsHypeSide::SetBoundaries().

sAxisRho

const G4int G4VTwistSurface::sAxisRho = 0x00001010

staticinherited

Definition at line 229 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsFlatSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), and G4TwistTubsFlatSide::SetBoundaries().

sAxisX

const G4int G4VTwistSurface::sAxisX = 0x00000404

staticinherited

Definition at line 226 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAxis(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), and G4TwistTubsSide::SetBoundaries().

sAxisY

const G4int G4VTwistSurface::sAxisY = 0x00000808

staticinherited

Definition at line 227 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAxis(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), and G4TwistTrapFlatSide::SetBoundaries().

sAxisZ

const G4int G4VTwistSurface::sAxisZ = 0x00000C0C

staticinherited

Definition at line 228 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAxis(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), and G4TwistTubsSide::SetBoundaries().

sBoundary

const G4int G4VTwistSurface::sBoundary = 0x20000000

staticinherited

Definition at line 218 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryAxis(), and G4VTwistSurface::GetBoundaryLimit().

sC0Max1Max

const G4int G4VTwistSurface::sC0Max1Max = 0x40000202

staticinherited

Definition at line 222 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistTubsFlatSide::GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsFlatSide::GetBoundaryMax(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), G4VTwistSurface::SetCorner(), G4TwistBoxSide::SetCorners(), G4TwistTrapAlphaSide::SetCorners(), G4TwistTrapFlatSide::SetCorners(), SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::SetCorners(), and G4TwistTubsHypeSide::SetCorners().

sC0Max1Min

const G4int G4VTwistSurface::sC0Max1Min = 0x40000201

staticinherited

Definition at line 221 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistTubsFlatSide::GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsFlatSide::GetBoundaryMin(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), G4VTwistSurface::SetCorner(), G4TwistBoxSide::SetCorners(), G4TwistTrapAlphaSide::SetCorners(), G4TwistTrapFlatSide::SetCorners(), SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::SetCorners(), and G4TwistTubsHypeSide::SetCorners().

sC0Min1Max

const G4int G4VTwistSurface::sC0Min1Max = 0x40000102

staticinherited

Definition at line 223 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4VTwistSurface::GetBoundaryLimit(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), G4VTwistSurface::SetCorner(), G4TwistBoxSide::SetCorners(), G4TwistTrapAlphaSide::SetCorners(), G4TwistTrapFlatSide::SetCorners(), SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::SetCorners(), and G4TwistTubsHypeSide::SetCorners().

sC0Min1Min

const G4int G4VTwistSurface::sC0Min1Min = 0x40000101

staticinherited

Definition at line 220 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4VTwistSurface::GetBoundaryLimit(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), G4VTwistSurface::SetCorner(), G4TwistBoxSide::SetCorners(), G4TwistTrapAlphaSide::SetCorners(), G4TwistTrapFlatSide::SetCorners(), SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::SetCorners(), and G4TwistTubsHypeSide::SetCorners().

sCorner

const G4int G4VTwistSurface::sCorner = 0x40000000

staticinherited

Definition at line 219 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), and G4VTwistSurface::SetCorner().

sInside

const G4int G4VTwistSurface::sInside = 0x10000000

staticinherited

Definition at line 217 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), and G4TwistTubsHypeSide::GetAreaCodeInPhi().

sOutside

const G4int G4VTwistSurface::sOutside = 0x00000000

staticinherited

Definition at line 216 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::CurrentStatus::CurrentStatus(), G4VTwistSurface::DistanceTo(), G4VTwistSurface::DistanceToIn(), G4VTwistSurface::DistanceToOut(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4VTwistSurface::CurrentStatus::ResetfDone().

sSizeMask

const G4int G4VTwistSurface::sSizeMask = 0x00000303

staticinherited

Definition at line 233 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::Boundary::GetBoundaryParameters().

---

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

• source/geometry/solids/specific/include/G4TwistTrapParallelSide.hh
• source/geometry/solids/specific/src/G4TwistTrapParallelSide.cc