HepPolyhedron Class Reference

#include <HepPolyhedron.h>

Inheritance diagram for HepPolyhedron:

Public Member Functions
	HepPolyhedron ()
	HepPolyhedron (const HepPolyhedron &from)
	HepPolyhedron (HepPolyhedron &&from)
virtual	~HepPolyhedron ()
HepPolyhedron &	operator= (const HepPolyhedron &from)
HepPolyhedron &	operator= (HepPolyhedron &&from)
G4int	GetNoVertices () const
G4int	GetNoVerteces () const
G4int	GetNoFacets () const
HepPolyhedron &	Transform (const G4Transform3D &t)
G4bool	GetNextVertexIndex (G4int &index, G4int &edgeFlag) const
G4Point3D	GetVertex (G4int index) const
G4bool	GetNextVertex (G4Point3D &vertex, G4int &edgeFlag) const
G4bool	GetNextVertex (G4Point3D &vertex, G4int &edgeFlag, G4Normal3D &normal) const
G4bool	GetNextEdgeIndices (G4int &i1, G4int &i2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
G4bool	GetNextEdgeIndeces (G4int &i1, G4int &i2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
G4bool	GetNextEdgeIndices (G4int &i1, G4int &i2, G4int &edgeFlag) const
G4bool	GetNextEdgeIndeces (G4int &i1, G4int &i2, G4int &edgeFlag) const
G4bool	GetNextEdge (G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag) const
G4bool	GetNextEdge (G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
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	GetNextFacet (G4int &n, G4Point3D *nodes, G4int *edgeFlags=0, G4Normal3D *normals=0) const
G4Normal3D	GetNormal (G4int iFace) const
G4Normal3D	GetUnitNormal (G4int iFace) const
G4bool	GetNextNormal (G4Normal3D &normal) const
G4bool	GetNextUnitNormal (G4Normal3D &normal) const
HepPolyhedron	add (const HepPolyhedron &p) const
HepPolyhedron	subtract (const HepPolyhedron &p) const
HepPolyhedron	intersect (const HepPolyhedron &p) const
G4double	GetSurfaceArea () const
G4double	GetVolume () const
G4int	createTwistedTrap (G4double Dz, const G4double xy1[][2], const G4double xy2[][2])
G4int	createPolyhedron (G4int Nnodes, G4int Nfaces, const G4double xyz[][3], const G4int faces[][4])

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

Protected Member Functions
void	AllocateMemory (G4int Nvert, G4int Nface)
G4int	FindNeighbour (G4int iFace, G4int iNode, G4int iOrder) const
G4Normal3D	FindNodeNormal (G4int iFace, G4int iNode) const
void	CreatePrism ()
void	RotateEdge (G4int k1, G4int k2, G4double r1, G4double r2, G4int v1, G4int v2, G4int vEdge, G4bool ifWholeCircle, G4int ns, G4int &kface)
void	SetSideFacets (G4int ii[4], G4int vv[4], G4int *kk, G4double *r, G4double dphi, G4int ns, G4int &kface)
void	RotateAroundZ (G4int nstep, G4double phi, G4double dphi, G4int np1, G4int np2, const G4double *z, G4double *r, G4int nodeVis, G4int edgeVis)
void	SetReferences ()
void	InvertFacets ()

Protected Attributes
G4int	nvert
G4int	nface
G4Point3D *	pV
G4Facet *	pF

Static Protected Attributes
static G4ThreadLocal G4int	fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

Friends
std::ostream &	operator<< (std::ostream &, const HepPolyhedron &ph)

Detailed Description

Definition at line 204 of file HepPolyhedron.h.

Constructor & Destructor Documentation

HepPolyhedron() [1/3]

HepPolyhedron::HepPolyhedron ( )

inline

Definition at line 249 of file HepPolyhedron.h.

: nvert(0), nface(0), pV(0), pF(0) {}

HepPolyhedron() [2/3]

HepPolyhedron::HepPolyhedron

(

const HepPolyhedron &

from

)

Definition at line 107 of file HepPolyhedron.cc.

: nvert(0), nface(0), pV(0), pF(0)
{
  AllocateMemory(from.nvert, from.nface);
  for (G4int i=1; i<=nvert; i++) pV[i] = from.pV[i];
  for (G4int k=1; k<=nface; k++) pF[k] = from.pF[k];
}

HepPolyhedron() [3/3]

HepPolyhedron::HepPolyhedron

(

HepPolyhedron &&

from

)

Definition at line 121 of file HepPolyhedron.cc.

: nvert(0), nface(0), pV(nullptr), pF(nullptr)
{
  nvert = from.nvert;
  nface = from.nface;
  pV = from.pV;
  pF = from.pF;
 
  // Release the data from the source object
  from.nvert = 0;
  from.nface = 0;
  from.pV = nullptr;
  from.pF = nullptr;
}

~HepPolyhedron()

virtual HepPolyhedron::~HepPolyhedron ( )

inlinevirtual

Definition at line 258 of file HepPolyhedron.h.

{ delete [] pV; delete [] pF; }

Member Function Documentation

add()

HepPolyhedron HepPolyhedron::add

(

const HepPolyhedron &

p

)

const

Definition at line 2414 of file HepPolyhedron.cc.

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

AllocateMemory()

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

protected

Definition at line 292 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;
  }
}

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

createPolyhedron()

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

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 1418 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;
}

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

CreatePrism()

void HepPolyhedron::CreatePrism ( )

protected

Definition at line 318 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);
}

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

createTwistedTrap()

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

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 1349 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;
}

FindNeighbour()

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

protected

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

protected

Definition at line 216 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();
}

GetFacet() [1/2]

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

Definition at line 1125 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;
  }
}

Referenced by G4CutTubs::CreatePolyhedron().

GetFacet() [2/2]

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

Definition at line 1159 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]);
    }
  }
}

GetNextEdge() [1/2]

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

Definition at line 1084 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().

GetNextEdge() [2/2]

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

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

inline

Definition at line 298 of file HepPolyhedron.h.

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

GetNextEdgeIndeces() [2/2]

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

inline

Definition at line 292 of file HepPolyhedron.h.

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

GetNextEdgeIndices() [1/2]

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

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

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

Referenced by GetNextEdgeIndeces().

GetNextFacet()

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

Definition at line 1181 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;
  }
}

GetNextNormal()

G4bool HepPolyhedron::GetNextNormal

(

G4Normal3D &

normal

)

const

Definition at line 1261 of file HepPolyhedron.cc.

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

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), and G4HepRepSceneHandler::AddPrimitive().

GetNextUnitNormal()

G4bool HepPolyhedron::GetNextUnitNormal

(

G4Normal3D &

normal

)

const

Definition at line 1282 of file HepPolyhedron.cc.

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

GetNextVertex() [1/2]

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

Definition at line 965 of file HepPolyhedron.cc.

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

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), and G4HepRepSceneHandler::AddPrimitive().

GetNextVertex() [2/2]

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

Definition at line 983 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
  }
}

GetNextVertexIndex()

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

Definition at line 918 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
  }
}

Referenced by G4GMocrenFileSceneHandler::AddPrimitive().

GetNoFacets()

G4int HepPolyhedron::GetNoFacets ( ) const

inline

Definition at line 271 of file HepPolyhedron.h.

{ return nface; }

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepSceneHandler::AddPrimitive(), G4XXXFileSceneHandler::AddPrimitive(), G4XXXSceneHandler::AddPrimitive(), G4XXXSGSceneHandler::AddPrimitive(), G4XXXStoredSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4CutTubs::CreatePolyhedron(), and G4PhysicalVolumeModel::DescribeSolid().

GetNormal()

G4Normal3D HepPolyhedron::GetNormal

(

G4int

iFace

)

const

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

inline

Definition at line 268 of file HepPolyhedron.h.

{ return nvert; }  // Old spelling.

GetNoVertices()

G4int HepPolyhedron::GetNoVertices ( ) const

inline

Definition at line 267 of file HepPolyhedron.h.

{ return nvert; }

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

GetNumberOfRotationSteps()

G4int HepPolyhedron::GetNumberOfRotationSteps ( )

static

Definition at line 244 of file HepPolyhedron.cc.

{
  return fNumberOfRotationSteps;
}

Referenced by G4GenericPolycone::CreatePolyhedron(), 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(), and RotateAroundZ().

GetSurfaceArea()

G4double HepPolyhedron::GetSurfaceArea

(

)

const

Definition at line 1298 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.;
}

GetUnitNormal()

G4Normal3D HepPolyhedron::GetUnitNormal

(

G4int

iFace

)

const

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

Definition at line 945 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().

GetVolume()

G4double HepPolyhedron::GetVolume

(

)

const

Definition at line 1320 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.;
}

intersect()

HepPolyhedron HepPolyhedron::intersect

(

const HepPolyhedron &

p

)

const

Definition at line 2429 of file HepPolyhedron.cc.

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

InvertFacets()

void HepPolyhedron::InvertFacets ( )

protected

Definition at line 867 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];
    }
  }
}

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

operator=() [1/2]

HepPolyhedron & HepPolyhedron::operator=

(

const HepPolyhedron &

from

)

Definition at line 142 of file HepPolyhedron.cc.

{
  if (this != &from) {
    AllocateMemory(from.nvert, from.nface);
    for (G4int i=1; i<=nvert; i++) pV[i] = from.pV[i];
    for (G4int k=1; k<=nface; k++) pF[k] = from.pF[k];
  }
  return *this;
}

operator=() [2/2]

HepPolyhedron & HepPolyhedron::operator=

(

HepPolyhedron &&

from

)

Definition at line 160 of file HepPolyhedron.cc.

{
  if (this != &from) {
    delete [] pV;
    delete [] pF;
    nvert = from.nvert;
    nface = from.nface;
    pV = from.pV;
    pF = from.pF;
 
    // Release the data from the source object
    from.nvert = 0;
    from.nface = 0;
    from.pV = nullptr;
    from.pF = nullptr;
  }
  return *this;
}

ResetNumberOfRotationSteps()

void HepPolyhedron::ResetNumberOfRotationSteps ( )

static

Definition at line 279 of file HepPolyhedron.cc.

{
  fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS;
}

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  )

protected

Definition at line 471 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 > 0) ?
    nstep : G4int(delPhi*GetNumberOfRotationSteps()/wholeCircle+.5);
  if (nSphi == 0) nSphi = 1;
  G4int        nVphi    = ifWholeCircle ? nSphi : nSphi+1;
  G4bool ifClosed = np1 > 0 ? false : true;
  
  //   C O U N T   V E R T E 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.;
  }
 
  j = 0;                                                // external nodes
  for (i=i1beg; i<=i1end; i++) {
    j += (r[i] == 0.) ? 1 : nVphi;
  }
 
  G4bool ifSide1 = false;                           // internal nodes
  G4bool ifSide2 = false;
 
  if (r[i2beg] != r[i1beg] || z[i2beg] != z[i1beg]) {
    j += (r[i2beg] == 0.) ? 1 : nVphi;
    ifSide1 = true;
  }
 
  for(i=i2beg+1; i<i2end; i++) {
    j += (r[i] == 0.) ? 1 : nVphi;
  }
  
  if (r[i2end] != r[i1end] || z[i2end] != z[i1end]) {
    if (absNp2 > 1) j += (r[i2end] == 0.) ? 1 : nVphi;
    ifSide2 = true;
  }
 
  //   C O U N T   F A C E S
 
  k = ifClosed ? absNp1*nSphi : (absNp1-1)*nSphi;       // external faces
 
  if (absNp2 > 1) {                                     // internal faces
    for(i=i2beg; i<i2end; i++) {
      if (r[i] > 0. || r[i+1] > 0.)       k += nSphi;
    }
 
    if (ifClosed) {
      if (r[i2end] > 0. || r[i2beg] > 0.) k += nSphi;
    }
  }
 
  if (!ifClosed) {                                      // side faces
    if (ifSide1 && (r[i1beg] > 0. || r[i2beg] > 0.)) k += nSphi;
    if (ifSide2 && (r[i1end] > 0. || r[i2end] > 0.)) k += nSphi;
  }
 
  if (!ifWholeCircle) {                                 // phi_side faces
    k += ifClosed ? 2*absNp1 : 2*(absNp1-1);
  }
 
  //   A L L O C A T E   M E M O R Y
 
  AllocateMemory(j, k);
 
  //   G E N E R A T E   V E R T E C E S
 
  G4int *kk;
  kk = new G4int[absNp1+absNp2];
 
  k = 1;
  for(i=i1beg; i<=i1end; i++) {
    kk[i] = k;
    if (r[i] == 0.)
    { pV[k++] = G4Point3D(0, 0, z[i]); } else { k += nVphi; }
  }
 
  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];
  }
 
  for(i=i2beg+1; i<i2end; i++) {
    kk[i] = k;
    if (r[i] == 0.)
    { pV[k++] = G4Point3D(0, 0, z[i]); } else { k += nVphi; }
  }
 
  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];
    }
  }
 
  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   E X T E R N A L   F A C E S
 
  G4int v1,v2;
 
  k = 1;
  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);
  }
 
  //   G E N E R A T E   I N T E R N A L   F A C E S
 
  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);
    }
  }
 
  //   G E N E R A T E   S I D E   F A C E S
 
  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);
    }
  }
 
  //   G E N E R A T E   S I D E   F A C E S  for the 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, dphi, 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, dphi, nSphi, k);
      }
    }      
  }
 
  delete [] kk;
 
  if (k-1 != nface) {
    std::cerr
      << "Polyhedron::RotateAroundZ: number of generated faces ("
      << k-1 << ") is not equal to the number of allocated faces ("
      << nface << ")"
      << std::endl;
  }
}

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

RotateEdge()

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

protected

Definition at line 338 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);
    }
  }
}

Referenced by RotateAroundZ().

SetNumberOfRotationSteps()

void HepPolyhedron::SetNumberOfRotationSteps ( G4int  n )

static

Definition at line 257 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;
  }    
}

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

SetReferences()

void HepPolyhedron::SetReferences ( )

protected

Definition at line 718 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;
}

Referenced by 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  )

protected

Definition at line 400 of file HepPolyhedron.cc.

{
  G4int k1, k2, k3, k4;
  
  if (std::abs((G4double)(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);
  }
}

Referenced by RotateAroundZ().

subtract()

HepPolyhedron HepPolyhedron::subtract

(

const HepPolyhedron &

p

)

const

Definition at line 2444 of file HepPolyhedron.cc.

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

Transform()

HepPolyhedron & HepPolyhedron::Transform

(

const G4Transform3D &

t

)

Definition at line 893 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;
}

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

Friends And Related Function Documentation

operator<<

std::ostream & operator<< ( std::ostream &  ostr, const HepPolyhedron &  ph  )

friend

Definition at line 92 of file HepPolyhedron.cc.

                                                                     {
  ostr << std::endl;
  ostr << "Nvertices=" << ph.nvert << ", Nfacets=" << ph.nface << std::endl;
  G4int i;
  for (i=1; i<=ph.nvert; i++) {
     ostr << "xyz(" << i << ")="
          << ph.pV[i].x() << ' ' << ph.pV[i].y() << ' ' << ph.pV[i].z()
          << std::endl;
  }
  for (i=1; i<=ph.nface; i++) {
    ostr << "face(" << i << ")=" << ph.pF[i] << std::endl;
  }
  return ostr;
}

Member Data Documentation

fNumberOfRotationSteps

G4ThreadLocal G4int HepPolyhedron::fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

staticprotected

Definition at line 208 of file HepPolyhedron.h.

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

nface

G4int HepPolyhedron::nface

protected

Definition at line 209 of file HepPolyhedron.h.

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

nvert

G4int HepPolyhedron::nvert

protected

Definition at line 209 of file HepPolyhedron.h.

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

pF

G4Facet* HepPolyhedron::pF

protected

Definition at line 211 of file HepPolyhedron.h.

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

pV

G4Point3D* HepPolyhedron::pV

protected

Definition at line 210 of file HepPolyhedron.h.

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

---

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

• HepPolyhedron.h
• HepPolyhedron.cc