G4PolyhedronTube Class Reference

#include <G4Polyhedron.hh>

Inheritance diagram for G4PolyhedronTube:

Public Member Functions
HepPolyhedron	add (const HepPolyhedron &p) const
G4int	createPolyhedron (G4int Nnodes, G4int Nfaces, const G4double xyz[][3], const G4int faces[][4])
G4int	createTwistedTrap (G4double Dz, const G4double xy1[][2], const G4double xy2[][2])
	G4PolyhedronTube (G4double Rmin, G4double Rmax, G4double Dz)
void	GetFacet (G4int iFace, G4int &n, G4int *iNodes, G4int *edgeFlags=0, G4int *iFaces=0) const
void	GetFacet (G4int iFace, G4int &n, G4Point3D *nodes, G4int *edgeFlags=0, G4Normal3D *normals=0) const
G4bool	GetNextEdge (G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag) const
G4bool	GetNextEdge (G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
G4bool	GetNextEdgeIndeces (G4int &i1, G4int &i2, G4int &edgeFlag) const
G4bool	GetNextEdgeIndeces (G4int &i1, G4int &i2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
G4bool	GetNextEdgeIndices (G4int &i1, G4int &i2, G4int &edgeFlag) const
G4bool	GetNextEdgeIndices (G4int &i1, G4int &i2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
G4bool	GetNextFacet (G4int &n, G4Point3D *nodes, G4int *edgeFlags=0, G4Normal3D *normals=0) const
G4bool	GetNextNormal (G4Normal3D &normal) const
G4bool	GetNextUnitNormal (G4Normal3D &normal) const
G4bool	GetNextVertex (G4Point3D &vertex, G4int &edgeFlag) const
G4bool	GetNextVertex (G4Point3D &vertex, G4int &edgeFlag, G4Normal3D &normal) const
G4bool	GetNextVertexIndex (G4int &index, G4int &edgeFlag) const
G4int	GetNoFacets () const
G4Normal3D	GetNormal (G4int iFace) const
G4int	GetNoVerteces () const
G4int	GetNoVertices () const
G4int	GetNumberOfRotationStepsAtTimeOfCreation () const
G4double	GetSurfaceArea () const
G4Normal3D	GetUnitNormal (G4int iFace) const
G4Point3D	GetVertex (G4int index) const
const G4VisAttributes *	GetVisAttributes () const
G4double	GetVolume () const
HepPolyhedron	intersect (const HepPolyhedron &p) const
G4bool	operator!= (const G4Visible &right) const
void	SetVisAttributes (const G4VisAttributes &)
void	SetVisAttributes (const G4VisAttributes *)
HepPolyhedron	subtract (const HepPolyhedron &p) const
HepPolyhedron &	Transform (const G4Transform3D &t)
virtual	~G4PolyhedronTube ()

Static Public Member Functions
static G4int	GetNumberOfRotationSteps ()
static void	ResetNumberOfRotationSteps ()
static void	SetNumberOfRotationSteps (G4int n)

Protected Member Functions
void	AllocateMemory (G4int Nvert, G4int Nface)
G4bool	CheckSnip (const std::vector< G4TwoVector > &contour, G4int a, G4int b, G4int c, G4int n, const G4int *V)
void	CreatePrism ()
G4int	FindNeighbour (G4int iFace, G4int iNode, G4int iOrder) const
G4Normal3D	FindNodeNormal (G4int iFace, G4int iNode) const
void	InvertFacets ()
void	RotateAroundZ (G4int nstep, G4double phi, G4double dphi, G4int np1, G4int np2, const G4double *z, G4double *r, G4int nodeVis, G4int edgeVis)
void	RotateContourAroundZ (G4int nstep, G4double phi, G4double dphi, const std::vector< G4TwoVector > &rz, G4int nodeVis, G4int edgeVis)
void	RotateEdge (G4int k1, G4int k2, G4double r1, G4double r2, G4int v1, G4int v2, G4int vEdge, G4bool ifWholeCircle, G4int ns, G4int &kface)
void	SetReferences ()
void	SetSideFacets (G4int ii[4], G4int vv[4], G4int *kk, G4double *r, G4double dphi, G4int ns, G4int &kface)
G4bool	TriangulatePolygon (const std::vector< G4TwoVector > &polygon, std::vector< G4int > &result)

Protected Attributes
G4bool	fAllocatedVisAttributes
const G4VisAttributes *	fpVisAttributes
G4int	nface
G4int	nvert
G4Facet *	pF
G4Point3D *	pV

Static Protected Attributes
static G4ThreadLocal G4int	fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

Private Attributes
G4int	fNumberOfRotationStepsAtTimeOfCreation

Detailed Description

Definition at line 237 of file G4Polyhedron.hh.

Constructor & Destructor Documentation

G4PolyhedronTube()

G4PolyhedronTube::G4PolyhedronTube	(	G4double	Rmin,
		G4double	Rmax,
		G4double	Dz
	)

Definition at line 137 of file G4Polyhedron.cc.

                                                                            :
  G4Polyhedron (HepPolyhedronTube (Rmin, Rmax, Dz)) {}

~G4PolyhedronTube()

G4PolyhedronTube::~G4PolyhedronTube ( )

virtual

Definition at line 140 of file G4Polyhedron.cc.

{}

Member Function Documentation

add()

HepPolyhedron HepPolyhedron::add ( const HepPolyhedron &  p ) const

inherited

Definition at line 2788 of file HepPolyhedron.cc.

{
  G4int ierr;
  BooleanProcessor processor;
  return processor.execute(OP_UNION, *this, p,ierr);
}

References processor.

AllocateMemory()

void HepPolyhedron::AllocateMemory ( G4int  Nvert, G4int  Nface  )

protectedinherited

Definition at line 296 of file HepPolyhedron.cc.

{
  if (nvert == Nvert && nface == Nface) return;
  if (pV != 0) delete [] pV;
  if (pF != 0) delete [] pF;
  if (Nvert > 0 && Nface > 0) {
    nvert = Nvert;
    nface = Nface;
    pV    = new G4Point3D[nvert+1];
    pF    = new G4Facet[nface+1];
  }else{
    nvert = 0; nface = 0; pV = 0; pF = 0;
  }
}

References HepPolyhedron::nface, HepPolyhedron::nvert, HepPolyhedron::pF, and HepPolyhedron::pV.

Referenced by HepPolyhedron::createPolyhedron(), HepPolyhedron::createTwistedTrap(), G4PolyhedronArbitrary::G4PolyhedronArbitrary(), HepPolyhedron::HepPolyhedron(), HepPolyhedronTet::HepPolyhedronTet(), HepPolyhedronTrap::HepPolyhedronTrap(), HepPolyhedronTrd2::HepPolyhedronTrd2(), HepPolyhedron::operator=(), HepPolyhedron::RotateAroundZ(), and HepPolyhedron::RotateContourAroundZ().

CheckSnip()

G4bool HepPolyhedron::CheckSnip ( const std::vector< G4TwoVector > &  contour, G4int  a, G4int  b, G4int  c, G4int  n, const G4int *  V  )

protectedinherited

Definition at line 985 of file HepPolyhedron.cc.

{
  static const G4double kCarTolerance = 1.e-9;
 
  // check orientation of Triangle
  G4double Ax = contour[V[a]].x(), Ay = contour[V[a]].y();
  G4double Bx = contour[V[b]].x(), By = contour[V[b]].y();
  G4double Cx = contour[V[c]].x(), Cy = contour[V[c]].y();
  if ((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax) < kCarTolerance) return false;
 
  // check that there is no point inside Triangle
  G4double xmin = std::min(std::min(Ax,Bx),Cx);
  G4double xmax = std::max(std::max(Ax,Bx),Cx);
  G4double ymin = std::min(std::min(Ay,By),Cy);
  G4double ymax = std::max(std::max(Ay,By),Cy);
 
  for (G4int i=0; i<n; ++i)
  {
    if((i == a) || (i == b) || (i == c)) continue;
    G4double Px = contour[V[i]].x();
    if (Px < xmin || Px > xmax) continue;
    G4double Py = contour[V[i]].y();
    if (Py < ymin || Py > ymax) continue;
    // if (PointInTriangle(Ax,Ay,Bx,By,Cx,Cy,Px,Py)) return false;
    if ((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax) > 0.)
    {
      if ((Ax-Cx)*(Py-Cy) - (Ay-Cy)*(Px-Cx) < 0.) continue;
      if ((Bx-Ax)*(Py-Ay) - (By-Ay)*(Px-Ax) < 0.) continue;
      if ((Cx-Bx)*(Py-By) - (Cy-By)*(Px-Bx) < 0.) continue;
    }
    else
    {
      if ((Ax-Cx)*(Py-Cy) - (Ay-Cy)*(Px-Cx) > 0.) continue;
      if ((Bx-Ax)*(Py-Ay) - (By-Ay)*(Px-Ax) > 0.) continue;
      if ((Cx-Bx)*(Py-By) - (Cy-By)*(Px-Bx) > 0.) continue;
    }
    return false;
  }
  return true;
}

References kCarTolerance, G4INCL::Math::max(), G4INCL::Math::min(), and CLHEP::detail::n.

Referenced by HepPolyhedron::TriangulatePolygon().

createPolyhedron()

G4int HepPolyhedron::createPolyhedron ( G4int  Nnodes, G4int  Nfaces, const G4double  xyz[][3], const G4int  faces[][4]  )

inherited

Creates user defined polyhedron. This function allows to the user to define arbitrary polyhedron. The faces of the polyhedron should be either triangles or planar quadrilateral. Nodes of a face are defined by indexes pointing to the elements in the xyz array. Numeration of the elements in the array starts from 1 (like in fortran). The indexes can be positive or negative. Negative sign means that the corresponding edge is invisible. The normal of the face should be directed to exterior of the polyhedron.

Parameters

Nnodes	number of nodes
Nfaces	number of faces
xyz	nodes
faces	faces (quadrilaterals or triangles)

Returns

status of the operation - is non-zero in case of problem

Definition at line 1737 of file HepPolyhedron.cc.

{
  AllocateMemory(Nnodes, Nfaces);
  if (nvert == 0) return 1;
 
  for (G4int i=0; i<Nnodes; i++) {
    pV[i+1] = G4Point3D(xyz[i][0], xyz[i][1], xyz[i][2]);
  }
  for (G4int k=0; k<Nfaces; k++) {
    pF[k+1] = G4Facet(faces[k][0],0,faces[k][1],0,faces[k][2],0,faces[k][3],0);
  }
  SetReferences();
  return 0;
}

References HepPolyhedron::AllocateMemory(), HepPolyhedron::nvert, HepPolyhedron::pF, HepPolyhedron::pV, and HepPolyhedron::SetReferences().

Referenced by G4CutTubs::CreatePolyhedron(), G4Tet::CreatePolyhedron(), G4TwistedTubs::CreatePolyhedron(), and G4VTwistedFaceted::CreatePolyhedron().

CreatePrism()

void HepPolyhedron::CreatePrism ( )

protectedinherited

Definition at line 322 of file HepPolyhedron.cc.

{
  enum {DUMMY, BOTTOM, LEFT, BACK, RIGHT, FRONT, TOP};
 
  pF[1] = G4Facet(1,LEFT,  4,BACK,  3,RIGHT,  2,FRONT);
  pF[2] = G4Facet(5,TOP,   8,BACK,  4,BOTTOM, 1,FRONT);
  pF[3] = G4Facet(8,TOP,   7,RIGHT, 3,BOTTOM, 4,LEFT);
  pF[4] = G4Facet(7,TOP,   6,FRONT, 2,BOTTOM, 3,BACK);
  pF[5] = G4Facet(6,TOP,   5,LEFT,  1,BOTTOM, 2,RIGHT);
  pF[6] = G4Facet(5,FRONT, 6,RIGHT, 7,BACK,   8,LEFT);
}

References HepPolyhedron::pF.

Referenced by HepPolyhedronTrap::HepPolyhedronTrap(), and HepPolyhedronTrd2::HepPolyhedronTrd2().

createTwistedTrap()

G4int HepPolyhedron::createTwistedTrap ( G4double  Dz, const G4double  xy1[][2], const G4double  xy2[][2]  )

inherited

Creates polyhedron for twisted trapezoid. The trapezoid is given by two bases perpendicular to the z-axis.

Parameters

Dz	half length in z
xy1	1st base (at z = -Dz)
xy2	2nd base (at z = +Dz)

Returns

status of the operation - is non-zero in case of problem

Definition at line 1668 of file HepPolyhedron.cc.

{
  AllocateMemory(12,18);
 
  pV[ 1] = G4Point3D(xy1[0][0],xy1[0][1],-Dz);
  pV[ 2] = G4Point3D(xy1[1][0],xy1[1][1],-Dz);
  pV[ 3] = G4Point3D(xy1[2][0],xy1[2][1],-Dz);
  pV[ 4] = G4Point3D(xy1[3][0],xy1[3][1],-Dz);
 
  pV[ 5] = G4Point3D(xy2[0][0],xy2[0][1], Dz);
  pV[ 6] = G4Point3D(xy2[1][0],xy2[1][1], Dz);
  pV[ 7] = G4Point3D(xy2[2][0],xy2[2][1], Dz);
  pV[ 8] = G4Point3D(xy2[3][0],xy2[3][1], Dz);
 
  pV[ 9] = (pV[1]+pV[2]+pV[5]+pV[6])/4.;
  pV[10] = (pV[2]+pV[3]+pV[6]+pV[7])/4.;
  pV[11] = (pV[3]+pV[4]+pV[7]+pV[8])/4.;
  pV[12] = (pV[4]+pV[1]+pV[8]+pV[5])/4.;
 
  enum {DUMMY, BOTTOM,
        LEFT_BOTTOM,  LEFT_FRONT,   LEFT_TOP,  LEFT_BACK,
        BACK_BOTTOM,  BACK_LEFT,    BACK_TOP,  BACK_RIGHT,
        RIGHT_BOTTOM, RIGHT_BACK,   RIGHT_TOP, RIGHT_FRONT,
        FRONT_BOTTOM, FRONT_RIGHT,  FRONT_TOP, FRONT_LEFT,
        TOP};
 
  pF[ 1]=G4Facet(1,LEFT_BOTTOM, 4,BACK_BOTTOM, 3,RIGHT_BOTTOM, 2,FRONT_BOTTOM);
 
  pF[ 2]=G4Facet(4,BOTTOM,     -1,LEFT_FRONT,  -12,LEFT_BACK,    0,0);
  pF[ 3]=G4Facet(1,FRONT_LEFT, -5,LEFT_TOP,    -12,LEFT_BOTTOM,  0,0);
  pF[ 4]=G4Facet(5,TOP,        -8,LEFT_BACK,   -12,LEFT_FRONT,   0,0);
  pF[ 5]=G4Facet(8,BACK_LEFT,  -4,LEFT_BOTTOM, -12,LEFT_TOP,     0,0);
 
  pF[ 6]=G4Facet(3,BOTTOM,     -4,BACK_LEFT,   -11,BACK_RIGHT,   0,0);
  pF[ 7]=G4Facet(4,LEFT_BACK,  -8,BACK_TOP,    -11,BACK_BOTTOM,  0,0);
  pF[ 8]=G4Facet(8,TOP,        -7,BACK_RIGHT,  -11,BACK_LEFT,    0,0);
  pF[ 9]=G4Facet(7,RIGHT_BACK, -3,BACK_BOTTOM, -11,BACK_TOP,     0,0);
 
  pF[10]=G4Facet(2,BOTTOM,     -3,RIGHT_BACK,  -10,RIGHT_FRONT,  0,0);
  pF[11]=G4Facet(3,BACK_RIGHT, -7,RIGHT_TOP,   -10,RIGHT_BOTTOM, 0,0);
  pF[12]=G4Facet(7,TOP,        -6,RIGHT_FRONT, -10,RIGHT_BACK,   0,0);
  pF[13]=G4Facet(6,FRONT_RIGHT,-2,RIGHT_BOTTOM,-10,RIGHT_TOP,    0,0);
 
  pF[14]=G4Facet(1,BOTTOM,     -2,FRONT_RIGHT,  -9,FRONT_LEFT,   0,0);
  pF[15]=G4Facet(2,RIGHT_FRONT,-6,FRONT_TOP,    -9,FRONT_BOTTOM, 0,0);
  pF[16]=G4Facet(6,TOP,        -5,FRONT_LEFT,   -9,FRONT_RIGHT,  0,0);
  pF[17]=G4Facet(5,LEFT_FRONT, -1,FRONT_BOTTOM, -9,FRONT_TOP,    0,0);
 
  pF[18]=G4Facet(5,FRONT_TOP, 6,RIGHT_TOP, 7,BACK_TOP, 8,LEFT_TOP);
 
  return 0;
}

References HepPolyhedron::AllocateMemory(), HepPolyhedron::pF, and HepPolyhedron::pV.

FindNeighbour()

G4int HepPolyhedron::FindNeighbour ( G4int  iFace, G4int  iNode, G4int  iOrder  ) const

protectedinherited

Definition at line 192 of file HepPolyhedron.cc.

{
  G4int i;
  for (i=0; i<4; i++) {
    if (iNode == std::abs(pF[iFace].edge[i].v)) break;
  }
  if (i == 4) {
    std::cerr
      << "HepPolyhedron::FindNeighbour: face " << iFace
      << " has no node " << iNode
      << std::endl;
    return 0;
  }
  if (iOrder < 0) {
    if ( --i < 0) i = 3;
    if (pF[iFace].edge[i].v == 0) i = 2;
  }
  return (pF[iFace].edge[i].v > 0) ? 0 : pF[iFace].edge[i].f;
}

FindNodeNormal()

G4Normal3D HepPolyhedron::FindNodeNormal ( G4int  iFace, G4int  iNode  ) const

protectedinherited

Definition at line 220 of file HepPolyhedron.cc.

{
  G4Normal3D   normal = GetUnitNormal(iFace);
  G4int          k = iFace, iOrder = 1, n = 1;
 
  for(;;) {
    k = FindNeighbour(k, iNode, iOrder);
    if (k == iFace) break;
    if (k > 0) {
      n++;
      normal += GetUnitNormal(k);
    }else{
      if (iOrder < 0) break;
      k = iFace;
      iOrder = -iOrder;
    }
  }
  return normal.unit();
}

References CLHEP::detail::n, and CLHEP::normal().

GetFacet() [1/2]

void HepPolyhedron::GetFacet ( G4int  iFace, G4int &  n, G4int *  iNodes, G4int *  edgeFlags = 0, G4int *  iFaces = 0  ) const

inherited

Definition at line 1444 of file HepPolyhedron.cc.

{
  if (iFace < 1 || iFace > nface) {
    std::cerr
      << "HepPolyhedron::GetFacet: irrelevant index " << iFace
      << std::endl;
    n = 0;
  }else{
    G4int i, k;
    for (i=0; i<4; i++) {
      k = pF[iFace].edge[i].v;
      if (k == 0) break;
      if (iFaces != 0) iFaces[i] = pF[iFace].edge[i].f;
      if (k > 0) {
        iNodes[i] = k;
        if (edgeFlags != 0) edgeFlags[i] = 1;
      }else{
        iNodes[i] = -k;
        if (edgeFlags != 0) edgeFlags[i] = -1;
      }
    }
    n = i;
  }
}

References CLHEP::detail::n.

Referenced by G4CutTubs::CreatePolyhedron().

GetFacet() [2/2]

void HepPolyhedron::GetFacet ( G4int  iFace, G4int &  n, G4Point3D *  nodes, G4int *  edgeFlags = 0, G4Normal3D *  normals = 0  ) const

inherited

Definition at line 1478 of file HepPolyhedron.cc.

{
  G4int iNodes[4];
  GetFacet(index, n, iNodes, edgeFlags);
  if (n != 0) {
    for (G4int i=0; i<n; i++) {
      nodes[i] = pV[iNodes[i]];
      if (normals != 0) normals[i] = FindNodeNormal(index,iNodes[i]);
    }
  }
}

References CLHEP::detail::n, and geant4_check_module_cycles::nodes.

GetNextEdge() [1/2]

G4bool HepPolyhedron::GetNextEdge ( G4Point3D &  p1, G4Point3D &  p2, G4int &  edgeFlag  ) const

inherited

Definition at line 1403 of file HepPolyhedron.cc.

{
  G4int i1,i2;
  G4bool rep = GetNextEdgeIndices(i1,i2,edgeFlag);
  p1 = pV[i1];
  p2 = pV[i2];
  return rep;
}

Referenced by G4GMocrenFileSceneHandler::AddSolid(), and G4GMocrenFileSceneHandler::ExtractDetector().

GetNextEdge() [2/2]

G4bool HepPolyhedron::GetNextEdge ( G4Point3D &  p1, G4Point3D &  p2, G4int &  edgeFlag, G4int &  iface1, G4int &  iface2  ) const

inherited

Definition at line 1424 of file HepPolyhedron.cc.

{
  G4int i1,i2;
  G4bool rep = GetNextEdgeIndices(i1,i2,edgeFlag,iface1,iface2);
  p1 = pV[i1];
  p2 = pV[i2];
  return rep;
}

GetNextEdgeIndeces() [1/2]

G4bool HepPolyhedron::GetNextEdgeIndeces ( G4int &  i1, G4int &  i2, G4int &  edgeFlag  ) const

inlineinherited

Definition at line 321 of file HepPolyhedron.h.

  {return GetNextEdgeIndices(i1,i2,edgeFlag);}  // Old spelling.

References HepPolyhedron::GetNextEdgeIndices().

GetNextEdgeIndeces() [2/2]

G4bool HepPolyhedron::GetNextEdgeIndeces ( G4int &  i1, G4int &  i2, G4int &  edgeFlag, G4int &  iface1, G4int &  iface2  ) const

inlineinherited

Definition at line 315 of file HepPolyhedron.h.

  {return GetNextEdgeIndices(i1,i2,edgeFlag,iface1,iface2);}  // Old spelling

References HepPolyhedron::GetNextEdgeIndices().

GetNextEdgeIndices() [1/2]

G4bool HepPolyhedron::GetNextEdgeIndices ( G4int &  i1, G4int &  i2, G4int &  edgeFlag  ) const

inherited

Definition at line 1387 of file HepPolyhedron.cc.

{
  G4int kface1, kface2;
  return GetNextEdgeIndices(i1, i2, edgeFlag, kface1, kface2);
}

GetNextEdgeIndices() [2/2]

G4bool HepPolyhedron::GetNextEdgeIndices ( G4int &  i1, G4int &  i2, G4int &  edgeFlag, G4int &  iface1, G4int &  iface2  ) const

inherited

Definition at line 1334 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace    = 1;
  static G4ThreadLocal G4int iQVertex = 0;
  static G4ThreadLocal G4int iOrder   = 1;
  G4int  k1, k2, kflag, kface1, kface2;
 
  if (iFace == 1 && iQVertex == 0) {
    k2 = pF[nface].edge[0].v;
    k1 = pF[nface].edge[3].v;
    if (k1 == 0) k1 = pF[nface].edge[2].v;
    if (std::abs(k1) > std::abs(k2)) iOrder = -1;
  }
 
  do {
    k1     = pF[iFace].edge[iQVertex].v;
    kflag  = k1;
    k1     = std::abs(k1);
    kface1 = iFace;
    kface2 = pF[iFace].edge[iQVertex].f;
    if (iQVertex >= 3 || pF[iFace].edge[iQVertex+1].v == 0) {
      iQVertex = 0;
      k2 = std::abs(pF[iFace].edge[iQVertex].v);
      iFace++;
    }else{
      iQVertex++;
      k2 = std::abs(pF[iFace].edge[iQVertex].v);
    }
  } while (iOrder*k1 > iOrder*k2);
 
  i1 = k1; i2 = k2; edgeFlag = (kflag > 0) ? 1 : 0;
  iface1 = kface1; iface2 = kface2;
 
  if (iFace > nface) {
    iFace  = 1; iOrder = 1;
    return false;
  }else{
    return true;
  }
}

References G4ThreadLocal.

Referenced by HepPolyhedron::GetNextEdgeIndeces().

GetNextFacet()

G4bool HepPolyhedron::GetNextFacet ( G4int &  n, G4Point3D *  nodes, G4int *  edgeFlags = 0, G4Normal3D *  normals = 0  ) const

inherited

Definition at line 1500 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace = 1;
 
  if (edgeFlags == 0) {
    GetFacet(iFace, n, nodes);
  }else if (normals == 0) {
    GetFacet(iFace, n, nodes, edgeFlags);
  }else{
    GetFacet(iFace, n, nodes, edgeFlags, normals);
  }
 
  if (++iFace > nface) {
    iFace  = 1;
    return false;
  }else{
    return true;
  }
}

References G4ThreadLocal, CLHEP::detail::n, and geant4_check_module_cycles::nodes.

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), and std::hash< G4Polyhedron >::operator()().

GetNextNormal()

G4bool HepPolyhedron::GetNextNormal ( G4Normal3D &  normal ) const

inherited

Definition at line 1580 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace = 1;
  normal = GetNormal(iFace);
  if (++iFace > nface) {
    iFace = 1;
    return false;
  }else{
    return true;
  }
}

References G4ThreadLocal, and CLHEP::normal().

Referenced by G4HepRepFileSceneHandler::AddPrimitive().

GetNextUnitNormal()

G4bool HepPolyhedron::GetNextUnitNormal ( G4Normal3D &  normal ) const

inherited

Definition at line 1601 of file HepPolyhedron.cc.

{
  G4bool rep = GetNextNormal(normal);
  normal = normal.unit();
  return rep;
}

References CLHEP::normal().

Referenced by Geant4_SoPolyhedron::computeBBox(), Geant4_SoPolyhedron::generateAlternateRep(), and Geant4_SoPolyhedron::generatePrimitives().

GetNextVertex() [1/2]

G4bool HepPolyhedron::GetNextVertex ( G4Point3D &  vertex, G4int &  edgeFlag  ) const

inherited

Definition at line 1284 of file HepPolyhedron.cc.

{
  G4int index;
  G4bool rep = GetNextVertexIndex(index, edgeFlag);
  vertex = pV[index];
  return rep;
}

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), Geant4_SoPolyhedron::computeBBox(), Geant4_SoPolyhedron::generateAlternateRep(), and Geant4_SoPolyhedron::generatePrimitives().

GetNextVertex() [2/2]

G4bool HepPolyhedron::GetNextVertex ( G4Point3D &  vertex, G4int &  edgeFlag, G4Normal3D &  normal  ) const

inherited

Definition at line 1302 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace = 1;
  static G4ThreadLocal G4int iNode = 0;
 
  if (nface == 0) return false;  // empty polyhedron
 
  G4int k = pF[iFace].edge[iNode].v;
  if (k > 0) { edgeFlag = 1; } else { edgeFlag = -1; k = -k; }
  vertex = pV[k];
  normal = FindNodeNormal(iFace,k);
  if (iNode >= 3 || pF[iFace].edge[iNode+1].v == 0) {
    iNode = 0;
    if (++iFace > nface) iFace = 1;
    return false;                // last node
  }else{
    ++iNode;
    return true;                 // not last node
  }
}

References G4ThreadLocal, and CLHEP::normal().

GetNextVertexIndex()

G4bool HepPolyhedron::GetNextVertexIndex ( G4int &  index, G4int &  edgeFlag  ) const

inherited

Definition at line 1237 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace = 1;
  static G4ThreadLocal G4int iQVertex = 0;
  G4int vIndex = pF[iFace].edge[iQVertex].v;
 
  edgeFlag = (vIndex > 0) ? 1 : 0;
  index = std::abs(vIndex);
 
  if (iQVertex >= 3 || pF[iFace].edge[iQVertex+1].v == 0) {
    iQVertex = 0;
    if (++iFace > nface) iFace = 1;
    return false;  // Last Edge
  }else{
    ++iQVertex;
    return true;  // not Last Edge
  }
}

References G4ThreadLocal.

Referenced by G4GMocrenFileSceneHandler::AddPrimitive().

GetNoFacets()

G4int HepPolyhedron::GetNoFacets ( ) const

inlineinherited

Definition at line 294 of file HepPolyhedron.h.

{ return nface; }

References HepPolyhedron::nface.

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), Geant4_SoPolyhedron::computeBBox(), G4CutTubs::CreatePolyhedron(), G4PhysicalVolumeModel::DescribeSolid(), Geant4_SoPolyhedron::generateAlternateRep(), and Geant4_SoPolyhedron::generatePrimitives().

GetNormal()

G4Normal3D HepPolyhedron::GetNormal ( G4int  iFace ) const

inherited

Definition at line 1530 of file HepPolyhedron.cc.

{
  if (iFace < 1 || iFace > nface) {
    std::cerr
      << "HepPolyhedron::GetNormal: irrelevant index " << iFace
      << std::endl;
    return G4Normal3D();
  }
 
  G4int i0  = std::abs(pF[iFace].edge[0].v);
  G4int i1  = std::abs(pF[iFace].edge[1].v);
  G4int i2  = std::abs(pF[iFace].edge[2].v);
  G4int i3  = std::abs(pF[iFace].edge[3].v);
  if (i3 == 0) i3 = i0;
  return (pV[i2] - pV[i0]).cross(pV[i3] - pV[i1]);
}

GetNoVerteces()

G4int HepPolyhedron::GetNoVerteces ( ) const

inlineinherited

Definition at line 291 of file HepPolyhedron.h.

{ return nvert; }  // Old spelling.

References HepPolyhedron::nvert.

GetNoVertices()

G4int HepPolyhedron::GetNoVertices ( ) const

inlineinherited

Definition at line 290 of file HepPolyhedron.h.

{ return nvert; }

References HepPolyhedron::nvert.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4CutTubs::CreatePolyhedron(), and Geant4_SoPolyhedron::generateAlternateRep().

GetNumberOfRotationSteps()

G4int HepPolyhedron::GetNumberOfRotationSteps ( )

staticinherited

Definition at line 248 of file HepPolyhedron.cc.

{
  return fNumberOfRotationSteps;
}

References HepPolyhedron::fNumberOfRotationSteps.

Referenced by G4TwistedTubs::CreatePolyhedron(), G4VTwistedFaceted::CreatePolyhedron(), G4ArrowModel::G4ArrowModel(), G4ViewParameters::G4ViewParameters(), G4ReflectedSolid::GetPolyhedron(), G4BooleanSolid::GetPolyhedron(), G4DisplacedSolid::GetPolyhedron(), G4MultiUnion::GetPolyhedron(), G4ScaledSolid::GetPolyhedron(), G4CSGSolid::GetPolyhedron(), G4Ellipsoid::GetPolyhedron(), G4EllipticalCone::GetPolyhedron(), G4EllipticalTube::GetPolyhedron(), G4GenericTrap::GetPolyhedron(), G4Hype::GetPolyhedron(), G4Paraboloid::GetPolyhedron(), G4TessellatedSolid::GetPolyhedron(), G4Tet::GetPolyhedron(), G4TwistedTubs::GetPolyhedron(), G4VCSGfaceted::GetPolyhedron(), G4VTwistedFaceted::GetPolyhedron(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronHype::HepPolyhedronHype(), HepPolyhedronHyperbolicMirror::HepPolyhedronHyperbolicMirror(), HepPolyhedronParaboloid::HepPolyhedronParaboloid(), HepPolyhedronSphere::HepPolyhedronSphere(), HepPolyhedronTorus::HepPolyhedronTorus(), HepPolyhedron::RotateAroundZ(), and HepPolyhedron::RotateContourAroundZ().

GetNumberOfRotationStepsAtTimeOfCreation()

G4int G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation ( ) const

inlineinherited

Definition at line 131 of file G4Polyhedron.hh.

                                                         {
    return fNumberOfRotationStepsAtTimeOfCreation;
  }

References G4Polyhedron::fNumberOfRotationStepsAtTimeOfCreation.

Referenced by G4ReflectedSolid::GetPolyhedron(), G4BooleanSolid::GetPolyhedron(), G4DisplacedSolid::GetPolyhedron(), G4MultiUnion::GetPolyhedron(), G4ScaledSolid::GetPolyhedron(), G4CSGSolid::GetPolyhedron(), G4Ellipsoid::GetPolyhedron(), G4EllipticalCone::GetPolyhedron(), G4EllipticalTube::GetPolyhedron(), G4GenericTrap::GetPolyhedron(), G4Hype::GetPolyhedron(), G4Paraboloid::GetPolyhedron(), G4TessellatedSolid::GetPolyhedron(), G4Tet::GetPolyhedron(), G4TwistedTubs::GetPolyhedron(), G4VCSGfaceted::GetPolyhedron(), and G4VTwistedFaceted::GetPolyhedron().

GetSurfaceArea()

G4double HepPolyhedron::GetSurfaceArea ( ) const

inherited

Definition at line 1617 of file HepPolyhedron.cc.

{
  G4double srf = 0.;
  for (G4int iFace=1; iFace<=nface; iFace++) {
    G4int i0 = std::abs(pF[iFace].edge[0].v);
    G4int i1 = std::abs(pF[iFace].edge[1].v);
    G4int i2 = std::abs(pF[iFace].edge[2].v);
    G4int i3 = std::abs(pF[iFace].edge[3].v);
    if (i3 == 0) i3 = i0;
    srf += ((pV[i2] - pV[i0]).cross(pV[i3] - pV[i1])).mag();
  }
  return srf/2.;
}

References HepPolyhedron::nface, HepPolyhedron::pF, and HepPolyhedron::pV.

GetUnitNormal()

G4Normal3D HepPolyhedron::GetUnitNormal ( G4int  iFace ) const

inherited

Definition at line 1555 of file HepPolyhedron.cc.

{
  if (iFace < 1 || iFace > nface) {
    std::cerr
      << "HepPolyhedron::GetUnitNormal: irrelevant index " << iFace
      << std::endl;
    return G4Normal3D();
  }
 
  G4int i0  = std::abs(pF[iFace].edge[0].v);
  G4int i1  = std::abs(pF[iFace].edge[1].v);
  G4int i2  = std::abs(pF[iFace].edge[2].v);
  G4int i3  = std::abs(pF[iFace].edge[3].v);
  if (i3 == 0) i3 = i0;
  return ((pV[i2] - pV[i0]).cross(pV[i3] - pV[i1])).unit();
}

GetVertex()

G4Point3D HepPolyhedron::GetVertex ( G4int  index ) const

inherited

Definition at line 1264 of file HepPolyhedron.cc.

{
  if (index <= 0 || index > nvert) {
    std::cerr
      << "HepPolyhedron::GetVertex: irrelevant index " << index
      << std::endl;
    return G4Point3D();
  }
  return pV[index];
}

Referenced by G4GMocrenFileSceneHandler::AddSolid(), and G4CutTubs::CreatePolyhedron().

GetVisAttributes()

const G4VisAttributes * G4Visible::GetVisAttributes ( ) const

inherited

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4VSceneHandler::GetColour(), G4VSceneHandler::GetTextColour(), and G4VSceneHandler::LoadAtts().

GetVolume()

G4double HepPolyhedron::GetVolume ( ) const

inherited

Definition at line 1639 of file HepPolyhedron.cc.

{
  G4double v = 0.;
  for (G4int iFace=1; iFace<=nface; iFace++) {
    G4int i0 = std::abs(pF[iFace].edge[0].v);
    G4int i1 = std::abs(pF[iFace].edge[1].v);
    G4int i2 = std::abs(pF[iFace].edge[2].v);
    G4int i3 = std::abs(pF[iFace].edge[3].v);
    G4Point3D pt;
    if (i3 == 0) {
      i3 = i0;
      pt = (pV[i0]+pV[i1]+pV[i2]) * (1./3.);
    }else{
      pt = (pV[i0]+pV[i1]+pV[i2]+pV[i3]) * 0.25;
    }
    v += ((pV[i2] - pV[i0]).cross(pV[i3] - pV[i1])).dot(pt);
  }
  return v/6.;
}

References HepPolyhedron::nface, HepPolyhedron::pF, and HepPolyhedron::pV.

intersect()

HepPolyhedron HepPolyhedron::intersect ( const HepPolyhedron &  p ) const

inherited

Definition at line 2803 of file HepPolyhedron.cc.

{
  G4int ierr;
  BooleanProcessor processor;
  return processor.execute(OP_INTERSECTION, *this, p,ierr);
}

References processor.

InvertFacets()

void HepPolyhedron::InvertFacets ( )

protectedinherited

Definition at line 1186 of file HepPolyhedron.cc.

{
  if (nface <= 0) return;
  G4int i, k, nnode, v[4],f[4];
  for (i=1; i<=nface; i++) {
    nnode =  (pF[i].edge[3].v == 0) ? 3 : 4;
    for (k=0; k<nnode; k++) {
      v[k] = (k+1 == nnode) ? pF[i].edge[0].v : pF[i].edge[k+1].v;
      if (v[k] * pF[i].edge[k].v < 0) v[k] = -v[k];
      f[k] = pF[i].edge[k].f;
    }
    for (k=0; k<nnode; k++) {
      pF[i].edge[nnode-1-k].v = v[k];
      pF[i].edge[nnode-1-k].f = f[k];
    }
  }
}

References G4Facet::edge, G4Facet::G4Edge::f, HepPolyhedron::nface, HepPolyhedron::pF, and G4Facet::G4Edge::v.

Referenced by G4PolyhedronArbitrary::InvertFacets(), and HepPolyhedron::Transform().

operator!=()

G4bool G4Visible::operator!= ( const G4Visible &  right ) const

inherited

Definition at line 103 of file G4Visible.cc.

                                                           {
  if (fpVisAttributes && right.fpVisAttributes)
    return *fpVisAttributes != *right.fpVisAttributes;
  else if (!fpVisAttributes && !right.fpVisAttributes) return false;
  else return true;
}

References G4Visible::fpVisAttributes.

ResetNumberOfRotationSteps()

void HepPolyhedron::ResetNumberOfRotationSteps ( )

staticinherited

Definition at line 283 of file HepPolyhedron.cc.

{
  fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS;
}

References DEFAULT_NUMBER_OF_STEPS, and HepPolyhedron::fNumberOfRotationSteps.

Referenced by G4PhysicalVolumeModel::DescribeSolid(), and G4VSceneHandler::RequestPrimitives().

RotateAroundZ()

void HepPolyhedron::RotateAroundZ ( G4int  nstep, G4double  phi, G4double  dphi, G4int  np1, G4int  np2, const G4double *  z, G4double *  r, G4int  nodeVis, G4int  edgeVis  )

protectedinherited

Definition at line 475 of file HepPolyhedron.cc.

{
  static const G4double wholeCircle   = twopi;
 
  //   S E T   R O T A T I O N   P A R A M E T E R S
 
  G4bool ifWholeCircle = (std::abs(dphi-wholeCircle) < perMillion) ? true : false;
  G4double delPhi = ifWholeCircle ? wholeCircle : dphi;
  G4int nSphi = nstep;
  if (nSphi <= 0) nSphi = GetNumberOfRotationSteps()*delPhi/wholeCircle + 0.5;
  if (nSphi == 0) nSphi = 1;
  G4int nVphi = ifWholeCircle ? nSphi : nSphi + 1;
  G4bool ifClosed = np1 > 0 ? false : true; // true if external polyline is closed
 
  //   C O U N T   V E R T I C E S
 
  G4int absNp1 = std::abs(np1);
  G4int absNp2 = std::abs(np2);
  G4int i1beg = 0;
  G4int i1end = absNp1-1;
  G4int i2beg = absNp1;
  G4int i2end = absNp1+absNp2-1;
  G4int i, j, k;
 
  for(i=i1beg; i<=i2end; i++) {
    if (std::abs(r[i]) < spatialTolerance) r[i] = 0.;
  }
 
  // external polyline - check position of nodes relative to Z
  //
  G4int Nverts = 0;
  for (i=i1beg; i<=i1end; i++) {
    Nverts += (r[i] == 0.) ? 1 : nVphi;
  }
 
  // internal polyline
  //
  G4bool ifSide1 = false; // whether to create bottom faces
  G4bool ifSide2 = false; // whether to create top faces
 
  if (r[i2beg] != r[i1beg] || z[i2beg] != z[i1beg]) { // first node
    Nverts += (r[i2beg] == 0.) ? 1 : nVphi;
    ifSide1 = true;
  }
 
  for(i=i2beg+1; i<i2end; i++) { // intermediate nodes
    Nverts += (r[i] == 0.) ? 1 : nVphi;
  }
 
  if (r[i2end] != r[i1end] || z[i2end] != z[i1end]) { // last node
    if (absNp2 > 1) Nverts += (r[i2end] == 0.) ? 1 : nVphi;
    ifSide2 = true;
  }
 
  //   C O U N T   F A C E S
 
  // external lateral faces
  //
  G4int Nfaces = ifClosed ? absNp1*nSphi : (absNp1-1)*nSphi;
 
  // internal lateral faces
  //
  if (absNp2 > 1) {
    for(i=i2beg; i<i2end; i++) {
      if (r[i] > 0. || r[i+1] > 0.) Nfaces += nSphi;
    }
 
    if (ifClosed) {
      if (r[i2end] > 0. || r[i2beg] > 0.) Nfaces += nSphi;
    }
  }
 
  // bottom and top faces
  //
  if (!ifClosed) {
    if (ifSide1 && (r[i1beg] > 0. || r[i2beg] > 0.)) Nfaces += nSphi;
    if (ifSide2 && (r[i1end] > 0. || r[i2end] > 0.)) Nfaces += nSphi;
  }
 
  // phi_wedge faces
  //
  if (!ifWholeCircle) {
    Nfaces += ifClosed ? 2*absNp1 : 2*(absNp1-1);
  }
 
  //   A L L O C A T E   M E M O R Y
 
  AllocateMemory(Nverts, Nfaces);
  if (pV == nullptr || pF == nullptr) return;
 
  //   G E N E R A T E   V E R T I C E S
 
  G4int *kk; // array of start indices along polylines
  kk = new G4int[absNp1+absNp2];
 
  // external polyline
  //
  k = 1; // free position in array of vertices pV
  for(i=i1beg; i<=i1end; i++) {
    kk[i] = k;
    if (r[i] == 0.)
    { pV[k++] = G4Point3D(0, 0, z[i]); } else { k += nVphi; }
  }
 
  // first point of internal polyline
  //
  i = i2beg;
  if (ifSide1) {
    kk[i] = k;
    if (r[i] == 0.)
    { pV[k++] = G4Point3D(0, 0, z[i]); } else { k += nVphi; }
  }else{
    kk[i] = kk[i1beg];
  }
 
  // intermediate points of internal polyline
  //
  for(i=i2beg+1; i<i2end; i++) {
    kk[i] = k;
    if (r[i] == 0.)
    { pV[k++] = G4Point3D(0, 0, z[i]); } else { k += nVphi; }
  }
 
  // last point of internal polyline
  //
  if (absNp2 > 1) {
    i = i2end;
    if (ifSide2) {
      kk[i] = k;
      if (r[i] == 0.) pV[k] = G4Point3D(0, 0, z[i]);
    }else{
      kk[i] = kk[i1end];
    }
  }
 
  // set vertices
  //
  G4double cosPhi, sinPhi;
 
  for(j=0; j<nVphi; j++) {
    cosPhi = std::cos(phi+j*delPhi/nSphi);
    sinPhi = std::sin(phi+j*delPhi/nSphi);
    for(i=i1beg; i<=i2end; i++) {
      if (r[i] != 0.)
        pV[kk[i]+j] = G4Point3D(r[i]*cosPhi,r[i]*sinPhi,z[i]);
    }
  }
 
  //   G E N E R A T E   F A C E S
 
  //  external faces
  //
  G4int v1,v2;
 
  k = 1; // free position in array of faces pF
  v2 = ifClosed ? nodeVis : 1;
  for(i=i1beg; i<i1end; i++) {
    v1 = v2;
    if (!ifClosed && i == i1end-1) {
      v2 = 1;
    }else{
      v2 = (r[i] == r[i+1] && r[i+1] == r[i+2]) ? -1 : nodeVis;
    }
    RotateEdge(kk[i], kk[i+1], r[i], r[i+1], v1, v2,
               edgeVis, ifWholeCircle, nSphi, k);
  }
  if (ifClosed) {
    RotateEdge(kk[i1end], kk[i1beg], r[i1end],r[i1beg], nodeVis, nodeVis,
               edgeVis, ifWholeCircle, nSphi, k);
  }
 
  // internal faces
  //
  if (absNp2 > 1) {
    v2 = ifClosed ? nodeVis : 1;
    for(i=i2beg; i<i2end; i++) {
      v1 = v2;
      if (!ifClosed && i==i2end-1) {
        v2 = 1;
      }else{
        v2 = (r[i] == r[i+1] && r[i+1] == r[i+2]) ? -1 :  nodeVis;
      }
      RotateEdge(kk[i+1], kk[i], r[i+1], r[i], v2, v1,
                 edgeVis, ifWholeCircle, nSphi, k);
    }
    if (ifClosed) {
      RotateEdge(kk[i2beg], kk[i2end], r[i2beg], r[i2end], nodeVis, nodeVis,
                 edgeVis, ifWholeCircle, nSphi, k);
    }
  }
 
  // bottom and top faces
  //
  if (!ifClosed) {
    if (ifSide1) {
      RotateEdge(kk[i2beg], kk[i1beg], r[i2beg], r[i1beg], 1, 1,
                 -1, ifWholeCircle, nSphi, k);
    }
    if (ifSide2) {
      RotateEdge(kk[i1end], kk[i2end], r[i1end], r[i2end], 1, 1,
                 -1, ifWholeCircle, nSphi, k);
    }
  }
 
  // phi_wedge faces in case of incomplete circle
  //
  if (!ifWholeCircle) {
 
    G4int  ii[4], vv[4];
 
    if (ifClosed) {
      for (i=i1beg; i<=i1end; i++) {
        ii[0] = i;
        ii[3] = (i == i1end) ? i1beg : i+1;
        ii[1] = (absNp2 == 1) ? i2beg : ii[0]+absNp1;
        ii[2] = (absNp2 == 1) ? i2beg : ii[3]+absNp1;
        vv[0] = -1;
        vv[1] = 1;
        vv[2] = -1;
        vv[3] = 1;
        SetSideFacets(ii, vv, kk, r, delPhi, nSphi, k);
      }
    }else{
      for (i=i1beg; i<i1end; i++) {
        ii[0] = i;
        ii[3] = i+1;
        ii[1] = (absNp2 == 1) ? i2beg : ii[0]+absNp1;
        ii[2] = (absNp2 == 1) ? i2beg : ii[3]+absNp1;
        vv[0] = (i == i1beg)   ? 1 : -1;
        vv[1] = 1;
        vv[2] = (i == i1end-1) ? 1 : -1;
        vv[3] = 1;
        SetSideFacets(ii, vv, kk, r, delPhi, nSphi, k);
      }
    }
  }
 
  delete [] kk; // free memory
 
  // final check
  //
  if (k-1 != nface) {
    std::cerr
      << "HepPolyhedron::RotateAroundZ: number of generated faces ("
      << k-1 << ") is not equal to the number of allocated faces ("
      << nface << ")"
      << std::endl;
  }
}

References HepPolyhedron::AllocateMemory(), HepPolyhedron::GetNumberOfRotationSteps(), HepPolyhedron::nface, perMillion, HepPolyhedron::pF, HepPolyhedron::pV, HepPolyhedron::RotateEdge(), HepPolyhedron::SetSideFacets(), spatialTolerance, and twopi.

Referenced by HepPolyhedronCons::HepPolyhedronCons(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), HepPolyhedronHype::HepPolyhedronHype(), HepPolyhedronHyperbolicMirror::HepPolyhedronHyperbolicMirror(), HepPolyhedronParaboloid::HepPolyhedronParaboloid(), HepPolyhedronPgon::HepPolyhedronPgon(), HepPolyhedronSphere::HepPolyhedronSphere(), and HepPolyhedronTorus::HepPolyhedronTorus().

RotateContourAroundZ()

void HepPolyhedron::RotateContourAroundZ ( G4int  nstep, G4double  phi, G4double  dphi, const std::vector< G4TwoVector > &  rz, G4int  nodeVis, G4int  edgeVis  )

protectedinherited

Definition at line 750 of file HepPolyhedron.cc.

{
  //   S E T   R O T A T I O N   P A R A M E T E R S
 
  G4bool ifWholeCircle = (std::abs(dphi - twopi) < perMillion) ? true : false;
  G4double delPhi = (ifWholeCircle) ? twopi : dphi;
  G4int nSphi = nstep;
  if (nSphi <= 0) nSphi = GetNumberOfRotationSteps()*delPhi/twopi + 0.5;
  if (nSphi == 0) nSphi = 1;
  G4int nVphi = (ifWholeCircle) ? nSphi : nSphi + 1;
 
  //   C A L C U L A T E   A R E A
 
  G4int Nrz = rz.size();
  G4double area = 0;
  for (G4int i = 0; i < Nrz; ++i)
  {
    G4int k = (i == 0) ? Nrz - 1 : i - 1;
    area += rz[k].x()*rz[i].y() - rz[i].x()*rz[k].y();
  }
 
  //   P R E P A R E   P O L Y L I N E
 
  G4double *r = new G4double[Nrz];
  G4double *z = new G4double[Nrz];
  for (G4int i = 0; i < Nrz; ++i)
  {
    r[i] = rz[i].x();
    z[i] = rz[i].y();
    if (std::abs(r[i]) < spatialTolerance) r[i] = 0.;
  }
 
  //   C O U N T   V E R T I C E S   A N D   F A C E S
 
  G4int Nverts = 0;
  for(G4int i = 0; i < Nrz; ++i) Nverts += (r[i] == 0.) ? 1 : nVphi;
 
  G4int Nedges = Nrz;
  for (G4int i = 0; i < Nrz; ++i)
  {
    G4int k = (i == 0) ? Nrz - 1 : i - 1;
    Nedges -= (r[k] == 0 && r[i] == 0);
  }
 
  G4int Nfaces = Nedges*nSphi;               // lateral faces
  if (!ifWholeCircle) Nfaces += 2*(Nrz - 2); // phi_wedge faces
 
  //   A L L O C A T E   M E M O R Y
 
  AllocateMemory(Nverts, Nfaces);
  if (pV == nullptr || pF == nullptr)
  {
    delete [] r;
    delete [] z;
    return;
  }
 
  //   S E T   V E R T I C E S
 
  G4int *kk = new G4int[Nrz]; // start indices along contour
  G4int kfree = 1; // current free position in array of vertices pV
 
  // set start indices, set vertices for nodes with r == 0
  for(G4int i = 0; i < Nrz; ++i)
  {
    kk[i] = kfree;
    if (r[i] == 0.) pV[kfree++] = G4Point3D(0, 0, z[i]);
    if (r[i] != 0.) kfree += nVphi;
  }
 
  // set vertices by rotating r
  for(G4int j = 0; j < nVphi; ++j)
  {
    G4double cosPhi = std::cos(phi + j*delPhi/nSphi);
    G4double sinPhi = std::sin(phi + j*delPhi/nSphi);
    for(G4int i = 0; i < Nrz; ++i)
    {
      if (r[i] != 0.)
        pV[kk[i] + j] = G4Point3D(r[i]*cosPhi, r[i]*sinPhi, z[i]);
    }
  }
 
  //   S E T   F A C E S
 
  kfree = 1; // current free position in array of faces pF
  for(G4int i = 0; i < Nrz; ++i)
  {
    G4int i1 = (i < Nrz - 1) ? i + 1 : 0; // inverse order if area > 0
    G4int i2 = i;
    if (area < 0.) std::swap(i1, i2);
    RotateEdge(kk[i1], kk[i2], r[i1], r[i2], nodeVis, nodeVis,
               edgeVis, ifWholeCircle, nSphi, kfree);
  }
 
  //    S E T   P H I _ W E D G E   F A C E S
 
  if (!ifWholeCircle)
  {
    std::vector<G4int> triangles;
    TriangulatePolygon(rz, triangles);
 
    G4int ii[4], vv[4];
    G4int ntria = triangles.size()/3;
    for (G4int i = 0; i < ntria; ++i)
    {
      G4int i1 = triangles[0 + i*3];
      G4int i2 = triangles[1 + i*3];
      G4int i3 = triangles[2 + i*3];
      if (area < 0.) std::swap(i1, i3);
      G4int v1 = (std::abs(i2-i1) == 1 || std::abs(i2-i1) == Nrz-1) ? 1 : -1;
      G4int v2 = (std::abs(i3-i2) == 1 || std::abs(i3-i2) == Nrz-1) ? 1 : -1;
      G4int v3 = (std::abs(i1-i3) == 1 || std::abs(i1-i3) == Nrz-1) ? 1 : -1;
      ii[0] = i1; ii[1] = i2; ii[2] = i2; ii[3] = i3;
      vv[0] = v1; vv[1] = -1; vv[2] = v2; vv[3] = v3;
      SetSideFacets(ii, vv, kk, r, delPhi, nSphi, kfree);
    }
  }
 
  // free memory
  delete [] r;
  delete [] z;
  delete [] kk;
 
  // final check
  if (kfree - 1 != nface)
  {
    std::cerr
      << "HepPolyhedron::RotateContourAroundZ: number of generated faces ("
      << kfree-1 << ") is not equal to the number of allocated faces ("
      << nface << ")"
      << std::endl;
  }
}

References HepPolyhedron::AllocateMemory(), HepPolyhedron::GetNumberOfRotationSteps(), HepPolyhedron::nface, perMillion, HepPolyhedron::pF, HepPolyhedron::pV, HepPolyhedron::RotateEdge(), HepPolyhedron::SetSideFacets(), spatialTolerance, HepPolyhedron::TriangulatePolygon(), and twopi.

Referenced by HepPolyhedronPgon::HepPolyhedronPgon().

RotateEdge()

void HepPolyhedron::RotateEdge ( G4int  k1, G4int  k2, G4double  r1, G4double  r2, G4int  v1, G4int  v2, G4int  vEdge, G4bool  ifWholeCircle, G4int  ns, G4int &  kface  )

protectedinherited

Definition at line 342 of file HepPolyhedron.cc.

{
  if (r1 == 0. && r2 == 0.) return;
 
  G4int i;
  G4int i1  = k1;
  G4int i2  = k2;
  G4int ii1 = ifWholeCircle ? i1 : i1+nds;
  G4int ii2 = ifWholeCircle ? i2 : i2+nds;
  G4int vv  = ifWholeCircle ? vEdge : 1;
 
  if (nds == 1) {
    if (r1 == 0.) {
      pF[kface++]   = G4Facet(i1,0,    v2*i2,0, (i2+1),0);
    }else if (r2 == 0.) {
      pF[kface++]   = G4Facet(i1,0,    i2,0,    v1*(i1+1),0);
    }else{
      pF[kface++]   = G4Facet(i1,0,    v2*i2,0, (i2+1),0, v1*(i1+1),0);
    }
  }else{
    if (r1 == 0.) {
      pF[kface++]   = G4Facet(vv*i1,0,    v2*i2,0, vEdge*(i2+1),0);
      for (i2++,i=1; i<nds-1; i2++,i++) {
        pF[kface++] = G4Facet(vEdge*i1,0, v2*i2,0, vEdge*(i2+1),0);
      }
      pF[kface++]   = G4Facet(vEdge*i1,0, v2*i2,0, vv*ii2,0);
    }else if (r2 == 0.) {
      pF[kface++]   = G4Facet(vv*i1,0,    vEdge*i2,0, v1*(i1+1),0);
      for (i1++,i=1; i<nds-1; i1++,i++) {
        pF[kface++] = G4Facet(vEdge*i1,0, vEdge*i2,0, v1*(i1+1),0);
      }
      pF[kface++]   = G4Facet(vEdge*i1,0, vv*i2,0,    v1*ii1,0);
    }else{
      pF[kface++]   = G4Facet(vv*i1,0,    v2*i2,0, vEdge*(i2+1),0,v1*(i1+1),0);
      for (i1++,i2++,i=1; i<nds-1; i1++,i2++,i++) {
        pF[kface++] = G4Facet(vEdge*i1,0, v2*i2,0, vEdge*(i2+1),0,v1*(i1+1),0);
      }
      pF[kface++]   = G4Facet(vEdge*i1,0, v2*i2,0, vv*ii2,0,      v1*ii1,0);
    }
  }
}

References HepPolyhedron::pF.

Referenced by HepPolyhedron::RotateAroundZ(), and HepPolyhedron::RotateContourAroundZ().

SetNumberOfRotationSteps()

void HepPolyhedron::SetNumberOfRotationSteps ( G4int  n )

staticinherited

Definition at line 261 of file HepPolyhedron.cc.

{
  const G4int nMin = 3;
  if (n < nMin) {
    std::cerr
      << "HepPolyhedron::SetNumberOfRotationSteps: attempt to set the\n"
      << "number of steps per circle < " << nMin << "; forced to " << nMin
      << std::endl;
    fNumberOfRotationSteps = nMin;
  }else{
    fNumberOfRotationSteps = n;
  }
}

References HepPolyhedron::fNumberOfRotationSteps, and CLHEP::detail::n.

Referenced by G4PhysicalVolumeModel::DescribeSolid(), G4ArrowModel::G4ArrowModel(), and G4VSceneHandler::RequestPrimitives().

SetReferences()

void HepPolyhedron::SetReferences ( )

protectedinherited

Definition at line 1037 of file HepPolyhedron.cc.

{
  if (nface <= 0) return;
 
  struct edgeListMember {
    edgeListMember *next;
    G4int v2;
    G4int iface;
    G4int iedge;
  } *edgeList, *freeList, **headList;
 
 
  //   A L L O C A T E   A N D   I N I T I A T E   L I S T S
 
  edgeList = new edgeListMember[2*nface];
  headList = new edgeListMember*[nvert];
 
  G4int i;
  for (i=0; i<nvert; i++) {
    headList[i] = 0;
  }
  freeList = edgeList;
  for (i=0; i<2*nface-1; i++) {
    edgeList[i].next = &edgeList[i+1];
  }
  edgeList[2*nface-1].next = 0;
 
  //   L O O P   A L O N G   E D G E S
 
  G4int iface, iedge, nedge, i1, i2, k1, k2;
  edgeListMember *prev, *cur;
 
  for(iface=1; iface<=nface; iface++) {
    nedge = (pF[iface].edge[3].v == 0) ? 3 : 4;
    for (iedge=0; iedge<nedge; iedge++) {
      i1 = iedge;
      i2 = (iedge < nedge-1) ? iedge+1 : 0;
      i1 = std::abs(pF[iface].edge[i1].v);
      i2 = std::abs(pF[iface].edge[i2].v);
      k1 = (i1 < i2) ? i1 : i2;          // k1 = ::min(i1,i2);
      k2 = (i1 > i2) ? i1 : i2;          // k2 = ::max(i1,i2);
 
      // check head of the List corresponding to k1
      cur = headList[k1];
      if (cur == 0) {
        headList[k1] = freeList;
        if (!freeList) {
          std::cerr
          << "Polyhedron::SetReferences: bad link "
          << std::endl;
          break;
        }
        freeList = freeList->next;
        cur = headList[k1];
        cur->next = 0;
        cur->v2 = k2;
        cur->iface = iface;
        cur->iedge = iedge;
        continue;
      }
 
      if (cur->v2 == k2) {
        headList[k1] = cur->next;
        cur->next = freeList;
        freeList = cur;
        pF[iface].edge[iedge].f = cur->iface;
        pF[cur->iface].edge[cur->iedge].f = iface;
        i1 = (pF[iface].edge[iedge].v < 0) ? -1 : 1;
        i2 = (pF[cur->iface].edge[cur->iedge].v < 0) ? -1 : 1;
        if (i1 != i2) {
          std::cerr
            << "Polyhedron::SetReferences: different edge visibility "
            << iface << "/" << iedge << "/"
            << pF[iface].edge[iedge].v << " and "
            << cur->iface << "/" << cur->iedge << "/"
            << pF[cur->iface].edge[cur->iedge].v
            << std::endl;
        }
        continue;
      }
 
      // check List itself
      for (;;) {
        prev = cur;
        cur = prev->next;
        if (cur == 0) {
          prev->next = freeList;
          if (!freeList) {
            std::cerr
            << "Polyhedron::SetReferences: bad link "
            << std::endl;
            break;
          }
          freeList = freeList->next;
          cur = prev->next;
          cur->next = 0;
          cur->v2 = k2;
          cur->iface = iface;
          cur->iedge = iedge;
          break;
        }
 
        if (cur->v2 == k2) {
          prev->next = cur->next;
          cur->next = freeList;
          freeList = cur;
          pF[iface].edge[iedge].f = cur->iface;
          pF[cur->iface].edge[cur->iedge].f = iface;
          i1 = (pF[iface].edge[iedge].v < 0) ? -1 : 1;
          i2 = (pF[cur->iface].edge[cur->iedge].v < 0) ? -1 : 1;
            if (i1 != i2) {
              std::cerr
                << "Polyhedron::SetReferences: different edge visibility "
                << iface << "/" << iedge << "/"
                << pF[iface].edge[iedge].v << " and "
                << cur->iface << "/" << cur->iedge << "/"
                << pF[cur->iface].edge[cur->iedge].v
                << std::endl;
            }
          break;
        }
      }
    }
  }
 
  //  C H E C K   T H A T   A L L   L I S T S   A R E   E M P T Y
 
  for (i=0; i<nvert; i++) {
    if (headList[i] != 0) {
      std::cerr
        << "Polyhedron::SetReferences: List " << i << " is not empty"
        << std::endl;
    }
  }
 
  //   F R E E   M E M O R Y
 
  delete [] edgeList;
  delete [] headList;
}

References G4Facet::edge, G4Facet::G4Edge::f, HepPolyhedron::nface, HepPolyhedron::nvert, HepPolyhedron::pF, and G4Facet::G4Edge::v.

Referenced by HepPolyhedron::createPolyhedron(), HepPolyhedronCons::HepPolyhedronCons(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), HepPolyhedronHype::HepPolyhedronHype(), HepPolyhedronHyperbolicMirror::HepPolyhedronHyperbolicMirror(), HepPolyhedronParaboloid::HepPolyhedronParaboloid(), HepPolyhedronPgon::HepPolyhedronPgon(), HepPolyhedronSphere::HepPolyhedronSphere(), HepPolyhedronTorus::HepPolyhedronTorus(), and G4PolyhedronArbitrary::SetReferences().

SetSideFacets()

void HepPolyhedron::SetSideFacets ( G4int  ii[4], G4int  vv[4], G4int *  kk, G4double *  r, G4double  dphi, G4int  ns, G4int &  kface  )

protectedinherited

Definition at line 404 of file HepPolyhedron.cc.

{
  G4int k1, k2, k3, k4;
 
  if (std::abs(dphi-pi) < perMillion) { // half a circle
    for (G4int i=0; i<4; i++) {
      k1 = ii[i];
      k2 = ii[(i+1)%4];
      if (r[k1] == 0. && r[k2] == 0.) vv[i] = -1;
    }
  }
 
  if (ii[1] == ii[2]) {
    k1 = kk[ii[0]];
    k2 = kk[ii[2]];
    k3 = kk[ii[3]];
    pF[kface++] = G4Facet(vv[0]*k1,0, vv[2]*k2,0, vv[3]*k3,0);
    if (r[ii[0]] != 0.) k1 += nds;
    if (r[ii[2]] != 0.) k2 += nds;
    if (r[ii[3]] != 0.) k3 += nds;
    pF[kface++] = G4Facet(vv[2]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
  }else if (kk[ii[0]] == kk[ii[1]]) {
    k1 = kk[ii[0]];
    k2 = kk[ii[2]];
    k3 = kk[ii[3]];
    pF[kface++] = G4Facet(vv[1]*k1,0, vv[2]*k2,0, vv[3]*k3,0);
    if (r[ii[0]] != 0.) k1 += nds;
    if (r[ii[2]] != 0.) k2 += nds;
    if (r[ii[3]] != 0.) k3 += nds;
    pF[kface++] = G4Facet(vv[2]*k3,0, vv[1]*k2,0, vv[3]*k1,0);
  }else if (kk[ii[2]] == kk[ii[3]]) {
    k1 = kk[ii[0]];
    k2 = kk[ii[1]];
    k3 = kk[ii[2]];
    pF[kface++] = G4Facet(vv[0]*k1,0, vv[1]*k2,0, vv[3]*k3,0);
    if (r[ii[0]] != 0.) k1 += nds;
    if (r[ii[1]] != 0.) k2 += nds;
    if (r[ii[2]] != 0.) k3 += nds;
    pF[kface++] = G4Facet(vv[1]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
  }else{
    k1 = kk[ii[0]];
    k2 = kk[ii[1]];
    k3 = kk[ii[2]];
    k4 = kk[ii[3]];
    pF[kface++] = G4Facet(vv[0]*k1,0, vv[1]*k2,0, vv[2]*k3,0, vv[3]*k4,0);
    if (r[ii[0]] != 0.) k1 += nds;
    if (r[ii[1]] != 0.) k2 += nds;
    if (r[ii[2]] != 0.) k3 += nds;
    if (r[ii[3]] != 0.) k4 += nds;
    pF[kface++] = G4Facet(vv[2]*k4,0, vv[1]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
  }
}

References perMillion, HepPolyhedron::pF, and pi.

Referenced by HepPolyhedron::RotateAroundZ(), and HepPolyhedron::RotateContourAroundZ().

SetVisAttributes() [1/2]

void G4Visible::SetVisAttributes ( const G4VisAttributes &  VA )

inherited

Definition at line 85 of file G4Visible.cc.

                                                           {
  // Allocate G4VisAttributes on the heap in case the user specifies a
  // short-lived VA for a long-lived G4Visible.  Flag so that it can
  // be deleted in the destructor.
  // First delete any G4VisAttributes already on the heap...
  if (fAllocatedVisAttributes) delete fpVisAttributes;
  fpVisAttributes = new G4VisAttributes(VA);
  fAllocatedVisAttributes = true;
}

References G4Visible::fAllocatedVisAttributes, and G4Visible::fpVisAttributes.

SetVisAttributes() [2/2]

void G4Visible::SetVisAttributes ( const G4VisAttributes *  pVA )

inherited

Definition at line 96 of file G4Visible.cc.

                                                            {
  // First delete any G4VisAttributes already on the heap...
  if (fAllocatedVisAttributes) delete fpVisAttributes;
  fpVisAttributes = pVA;
  fAllocatedVisAttributes = false;
}

References G4Visible::fAllocatedVisAttributes, and G4Visible::fpVisAttributes.

Referenced by G4OpenGLSceneHandler::AddCompound(), G4Qt3DSceneHandler::AddCompound(), G4VisCommandSceneAddArrow2D::Arrow2D::Arrow2D(), G4DrawVoxels::ComputeVoxelPolyhedra(), G4AxesModel::Construct(), G4PhysicalVolumeModel::DescribeSolid(), G4GPSModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4ScoringBox::Draw(), G4ScoringCylinder::Draw(), G4ScoreLogColorMap::DrawColorChartBar(), G4VScoreColorMap::DrawColorChartBar(), G4ScoreLogColorMap::DrawColorChartText(), G4VScoreColorMap::DrawColorChartText(), G4ScoringBox::DrawColumn(), G4ScoringCylinder::DrawColumn(), G4OpenGLStoredViewer::DrawDisplayLists(), anonymous_namespace{G4LogicalVolumeModel.cc}::DrawPoint(), G4TrajectoryDrawerUtils::DrawWithoutTime(), G4TrajectoryDrawerUtils::DrawWithTime(), G4ArrowModel::G4ArrowModel(), G4VisCommandSceneAddLogo::G4Logo::G4Logo(), G4VisCommandSceneAddLine::Line::Line(), G4VisCommandSceneAddLine2D::Line2D::Line2D(), G4VisCommandSceneAddDate::Date::operator()(), G4VisCommandSceneAddEventID::EventID::operator()(), G4VisCommandSceneAddFrame::Frame::operator()(), G4VisCommandSceneAddLogo2D::Logo2D::operator()(), G4VSceneHandler::RequestPrimitives(), G4VisCommandSceneAddScale::Scale::Scale(), G4VisCommandSceneAddText::SetNewValue(), and G4VisCommandSceneAddText2D::SetNewValue().

subtract()

HepPolyhedron HepPolyhedron::subtract ( const HepPolyhedron &  p ) const

inherited

Definition at line 2818 of file HepPolyhedron.cc.

{
  G4int ierr;
  BooleanProcessor processor;
  return processor.execute(OP_SUBTRACTION, *this, p,ierr);
}

References processor.

Transform()

HepPolyhedron & HepPolyhedron::Transform ( const G4Transform3D &  t )

inherited

Definition at line 1212 of file HepPolyhedron.cc.

{
  if (nvert > 0) {
    for (G4int i=1; i<=nvert; i++) { pV[i] = t * pV[i]; }
 
    //  C H E C K   D E T E R M I N A N T   A N D
    //  I N V E R T   F A C E T S   I F   I T   I S   N E G A T I V E
 
    G4Vector3D d = t * G4Vector3D(0,0,0);
    G4Vector3D x = t * G4Vector3D(1,0,0) - d;
    G4Vector3D y = t * G4Vector3D(0,1,0) - d;
    G4Vector3D z = t * G4Vector3D(0,0,1) - d;
    if ((x.cross(y))*z < 0) InvertFacets();
  }
  return *this;
}

References HepGeom::BasicVector3D< T >::cross(), HepPolyhedron::InvertFacets(), HepPolyhedron::nvert, and HepPolyhedron::pV.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4ReflectedSolid::CreatePolyhedron(), G4DisplacedSolid::CreatePolyhedron(), G4ScaledSolid::CreatePolyhedron(), G4EllipticalTube::CreatePolyhedron(), G4ScoringBox::Draw(), G4ScoringCylinder::Draw(), G4ScoringBox::DrawColumn(), G4ScoringCylinder::DrawColumn(), G4GMocrenFileSceneHandler::ExtractDetector(), G4ArrowModel::G4ArrowModel(), G4ASCIITreeSceneHandler::RequestPrimitives(), and G4VisCommandsTouchable::SetNewValue().

TriangulatePolygon()

G4bool HepPolyhedron::TriangulatePolygon ( const std::vector< G4TwoVector > &  polygon, std::vector< G4int > &  result  )

protectedinherited

Definition at line 907 of file HepPolyhedron.cc.

{
  result.resize(0);
  G4int n = polygon.size();
  if (n < 3) return false;
 
  // calculate area
  //
  G4double area = 0.;
  for(G4int i = 0; i < n; ++i)
  {
    G4int k = (i == 0) ? n - 1 : i - 1;
    area += polygon[k].x()*polygon[i].y() - polygon[i].x()*polygon[k].y();
  }
 
  // allocate and initialize list of Vertices
  // we want a counter-clockwise polygon in V
  //
  G4int* V = new G4int[n];
  if (area > 0.)
    for (G4int i = 0; i < n; ++i) V[i] = i;
  else
    for (G4int i = 0; i < n; ++i) V[i] = (n - 1) - i;
 
  //  Triangulation: remove nv-2 Vertices, creating 1 triangle every time
  //
  G4int nv = n;
  G4int count = 2*nv; // error detection counter
  for(G4int b = nv - 1; nv > 2; )
  {
    // ERROR: if we loop, it is probably a non-simple polygon
    if ((count--) <= 0)
    {
      delete [] V;
      if (area < 0.) std::reverse(result.begin(),result.end());
      return false;
    }
 
    // three consecutive vertices in current polygon, <a,b,c>
    G4int a = (b   < nv) ? b   : 0; // previous
          b = (a+1 < nv) ? a+1 : 0; // current
    G4int c = (b+1 < nv) ? b+1 : 0; // next
 
    if (CheckSnip(polygon, a,b,c, nv,V))
    {
      // output Triangle
      result.push_back(V[a]);
      result.push_back(V[b]);
      result.push_back(V[c]);
 
      // remove vertex b from remaining polygon
      nv--;
      for(G4int i = b; i < nv; ++i) V[i] = V[i+1];
 
      count = 2*nv; // resest error detection counter
    }
  }
  delete [] V;
  if (area < 0.) std::reverse(result.begin(),result.end());
  return true;
}

References HepPolyhedron::CheckSnip(), and CLHEP::detail::n.

Referenced by HepPolyhedron::RotateContourAroundZ().

Field Documentation

fAllocatedVisAttributes

G4bool G4Visible::fAllocatedVisAttributes

protectedinherited

Definition at line 83 of file G4Visible.hh.

Referenced by G4Visible::G4Visible(), G4Visible::operator=(), G4Visible::SetVisAttributes(), and G4Visible::~G4Visible().

fNumberOfRotationSteps

G4ThreadLocal G4int HepPolyhedron::fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

staticprotectedinherited

Definition at line 217 of file HepPolyhedron.h.

Referenced by G4Polyhedron::G4Polyhedron(), HepPolyhedron::GetNumberOfRotationSteps(), HepPolyhedron::ResetNumberOfRotationSteps(), and HepPolyhedron::SetNumberOfRotationSteps().

fNumberOfRotationStepsAtTimeOfCreation

G4int G4Polyhedron::fNumberOfRotationStepsAtTimeOfCreation

privateinherited

Definition at line 135 of file G4Polyhedron.hh.

Referenced by G4Polyhedron::G4Polyhedron(), and G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation().

fpVisAttributes

const G4VisAttributes* G4Visible::fpVisAttributes

protectedinherited

Definition at line 82 of file G4Visible.hh.

Referenced by G4Visible::G4Visible(), G4Visible::operator!=(), G4Visible::operator=(), G4Visible::SetVisAttributes(), and G4Visible::~G4Visible().

nface

G4int HepPolyhedron::nface

protectedinherited

Definition at line 218 of file HepPolyhedron.h.

Referenced by G4PolyhedronArbitrary::AddFacet(), HepPolyhedron::AllocateMemory(), HepPolyhedron::GetNoFacets(), HepPolyhedron::GetSurfaceArea(), HepPolyhedron::GetVolume(), HepPolyhedron::HepPolyhedron(), HepPolyhedron::InvertFacets(), HepPolyhedron::operator=(), HepPolyhedron::RotateAroundZ(), HepPolyhedron::RotateContourAroundZ(), and HepPolyhedron::SetReferences().

nvert

G4int HepPolyhedron::nvert

protectedinherited

Definition at line 218 of file HepPolyhedron.h.

Referenced by G4PolyhedronArbitrary::AddFacet(), G4PolyhedronArbitrary::AddVertex(), HepPolyhedron::AllocateMemory(), HepPolyhedron::createPolyhedron(), HepPolyhedron::GetNoVerteces(), HepPolyhedron::GetNoVertices(), HepPolyhedron::HepPolyhedron(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), HepPolyhedron::operator=(), HepPolyhedron::SetReferences(), and HepPolyhedron::Transform().

pF

G4Facet* HepPolyhedron::pF

protectedinherited

Definition at line 220 of file HepPolyhedron.h.

Referenced by G4PolyhedronArbitrary::AddFacet(), HepPolyhedron::AllocateMemory(), HepPolyhedron::createPolyhedron(), HepPolyhedron::CreatePrism(), HepPolyhedron::createTwistedTrap(), HepPolyhedron::GetSurfaceArea(), HepPolyhedron::GetVolume(), HepPolyhedron::HepPolyhedron(), HepPolyhedronTet::HepPolyhedronTet(), HepPolyhedron::InvertFacets(), HepPolyhedron::operator=(), HepPolyhedron::RotateAroundZ(), HepPolyhedron::RotateContourAroundZ(), HepPolyhedron::RotateEdge(), HepPolyhedron::SetReferences(), HepPolyhedron::SetSideFacets(), and HepPolyhedron::~HepPolyhedron().

pV

G4Point3D* HepPolyhedron::pV

protectedinherited

Definition at line 219 of file HepPolyhedron.h.

Referenced by G4PolyhedronArbitrary::AddVertex(), HepPolyhedron::AllocateMemory(), HepPolyhedron::createPolyhedron(), HepPolyhedron::createTwistedTrap(), HepPolyhedron::GetSurfaceArea(), HepPolyhedron::GetVolume(), HepPolyhedron::HepPolyhedron(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), HepPolyhedronTet::HepPolyhedronTet(), HepPolyhedronTrap::HepPolyhedronTrap(), HepPolyhedronTrd2::HepPolyhedronTrd2(), HepPolyhedron::operator=(), HepPolyhedron::RotateAroundZ(), HepPolyhedron::RotateContourAroundZ(), HepPolyhedron::Transform(), and HepPolyhedron::~HepPolyhedron().

---

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

• source/graphics_reps/include/G4Polyhedron.hh
• source/graphics_reps/src/G4Polyhedron.cc