HepPolyhedron Class Reference

#include <HepPolyhedron.h>

Inheritance diagram for HepPolyhedron:

Public Member Functions
	HepPolyhedron ()
	HepPolyhedron (const HepPolyhedron &from)
virtual	~HepPolyhedron ()
HepPolyhedron &	operator= (const HepPolyhedron &from)
G4int	GetNoVertices () 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	GetNextEdgeIndeces (G4int &i1, G4int &i2, G4int &edgeFlag, G4int &iface1, G4int &iface2) 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 195 of file HepPolyhedron.h.

Constructor & Destructor Documentation

HepPolyhedron::HepPolyhedron ( )

inline

Definition at line 240 of file HepPolyhedron.h.

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

HepPolyhedron::HepPolyhedron

(

const HepPolyhedron &

from

)

Definition at line 107 of file HepPolyhedron.cc.

References AllocateMemory(), nface, nvert, pF, and pV.

: 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];
}

virtual HepPolyhedron::~HepPolyhedron ( )

inlinevirtual

Definition at line 246 of file HepPolyhedron.h.

References pF, and pV.

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

Member Function Documentation

HepPolyhedron HepPolyhedron::add

(

const HepPolyhedron &

p

)

const

Definition at line 2261 of file HepPolyhedron.cc.

References processor.

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

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

protected

Definition at line 244 of file HepPolyhedron.cc.

References nface, nvert, pF, and pV.

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

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

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 1358 of file HepPolyhedron.cc.

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

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

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

void HepPolyhedron::CreatePrism ( )

protected

Definition at line 270 of file HepPolyhedron.cc.

References pF.

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

{
  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);
}

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 1289 of file HepPolyhedron.cc.

References AllocateMemory(), pF, and pV.

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

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

protected

Definition at line 140 of file HepPolyhedron.cc.

References test::v.

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

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

protected

Definition at line 168 of file HepPolyhedron.cc.

References n, and HepGeom::BasicVector3D< T >::unit().

{
  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();
}

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

Definition at line 1065 of file HepPolyhedron.cc.

References n.

Referenced by G4CutTubs::CreatePolyhedron().

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

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

Definition at line 1099 of file HepPolyhedron.cc.

References n.

{
  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]);
    }
  }
}

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

Definition at line 1024 of file HepPolyhedron.cc.

Referenced by G4GMocrenFileSceneHandler::AddSolid().

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

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

Definition at line 1045 of file HepPolyhedron.cc.

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

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

Definition at line 955 of file HepPolyhedron.cc.

References G4ThreadLocal, and test::v.

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

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

Definition at line 1008 of file HepPolyhedron.cc.

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

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

Definition at line 1121 of file HepPolyhedron.cc.

References G4ThreadLocal, and n.

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

G4bool HepPolyhedron::GetNextNormal

(

G4Normal3D &

normal

)

const

Definition at line 1201 of file HepPolyhedron.cc.

References G4ThreadLocal.

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

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

G4bool HepPolyhedron::GetNextUnitNormal

(

G4Normal3D &

normal

)

const

Definition at line 1222 of file HepPolyhedron.cc.

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

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

Definition at line 905 of file HepPolyhedron.cc.

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

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

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

Definition at line 923 of file HepPolyhedron.cc.

References G4ThreadLocal, and test::v.

{
  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
  }
}

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

Definition at line 858 of file HepPolyhedron.cc.

References G4ThreadLocal, and test::v.

Referenced by G4GMocrenFileSceneHandler::AddPrimitive().

{
  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
  }
}

G4int HepPolyhedron::GetNoFacets ( ) const

inline

Definition at line 255 of file HepPolyhedron.h.

References nface.

Referenced by G4XXXSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4HepRepSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), and G4CutTubs::CreatePolyhedron().

{ return nface; }

G4Normal3D HepPolyhedron::GetNormal

(

G4int

iFace

)

const

Definition at line 1151 of file HepPolyhedron.cc.

References test::v.

{
  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]);
}

G4int HepPolyhedron::GetNoVertices ( ) const

inline

Definition at line 252 of file HepPolyhedron.h.

References nvert.

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

{ return nvert; }

G4int HepPolyhedron::GetNumberOfRotationSteps ( )

static

Definition at line 196 of file HepPolyhedron.cc.

References fNumberOfRotationSteps.

Referenced by G4UGenericPolycone::CreatePolyhedron(), G4GenericPolycone::CreatePolyhedron(), G4VTwistedFaceted::CreatePolyhedron(), G4TwistedTubs::CreatePolyhedron(), G4CSGSolid::GetPolyhedron(), G4BooleanSolid::GetPolyhedron(), G4VCSGfaceted::GetPolyhedron(), G4EllipticalTube::GetPolyhedron(), G4VTwistedFaceted::GetPolyhedron(), G4Ellipsoid::GetPolyhedron(), G4Tet::GetPolyhedron(), G4Paraboloid::GetPolyhedron(), G4ReflectedSolid::GetPolyhedron(), G4Hype::GetPolyhedron(), G4GenericTrap::GetPolyhedron(), G4TwistedTubs::GetPolyhedron(), G4EllipticalCone::GetPolyhedron(), G4DisplacedSolid::GetPolyhedron(), G4TessellatedSolid::GetPolyhedron(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronHype::HepPolyhedronHype(), HepPolyhedronParaboloid::HepPolyhedronParaboloid(), HepPolyhedronSphere::HepPolyhedronSphere(), HepPolyhedronTorus::HepPolyhedronTorus(), and RotateAroundZ().

{
  return fNumberOfRotationSteps;
}

G4double HepPolyhedron::GetSurfaceArea

(

)

const

Definition at line 1238 of file HepPolyhedron.cc.

References nface, pF, pV, and test::v.

{
  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.;
}

G4Normal3D HepPolyhedron::GetUnitNormal

(

G4int

iFace

)

const

Definition at line 1176 of file HepPolyhedron.cc.

References test::v.

{
  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();
}

G4Point3D HepPolyhedron::GetVertex

(

G4int

index

)

const

Definition at line 885 of file HepPolyhedron.cc.

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

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

G4double HepPolyhedron::GetVolume

(

)

const

Definition at line 1260 of file HepPolyhedron.cc.

References nface, pF, pV, and test::v.

{
  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.;
}

HepPolyhedron HepPolyhedron::intersect

(

const HepPolyhedron &

p

)

const

Definition at line 2276 of file HepPolyhedron.cc.

References processor.

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

void HepPolyhedron::InvertFacets ( )

protected

Definition at line 807 of file HepPolyhedron.cc.

References nface, pF, and test::v.

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

{
  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];
    }
  }
}

HepPolyhedron & HepPolyhedron::operator=

(

const HepPolyhedron &

from

)

Definition at line 121 of file HepPolyhedron.cc.

References AllocateMemory(), nface, nvert, pF, and pV.

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

void HepPolyhedron::ResetNumberOfRotationSteps ( )

static

Definition at line 231 of file HepPolyhedron.cc.

References DEFAULT_NUMBER_OF_STEPS, and fNumberOfRotationSteps.

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

{
  fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS;
}

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 423 of file HepPolyhedron.cc.

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

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

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

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 290 of file HepPolyhedron.cc.

References pF.

Referenced by RotateAroundZ().

{
  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);
    }
  }
}

void HepPolyhedron::SetNumberOfRotationSteps ( G4int  n )

static

Definition at line 209 of file HepPolyhedron.cc.

References fNumberOfRotationSteps, and n.

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

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

void HepPolyhedron::SetReferences ( )

protected

Definition at line 670 of file HepPolyhedron.cc.

References nface, nvert, pF, and test::v.

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

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

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

protected

Definition at line 352 of file HepPolyhedron.cc.

References python.hepunit::perMillion, pF, and python.hepunit::pi.

Referenced by RotateAroundZ().

{
  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 = (i == 3) ? ii[0] : ii[i+1];
      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);
  }
}

HepPolyhedron HepPolyhedron::subtract

(

const HepPolyhedron &

p

)

const

Definition at line 2291 of file HepPolyhedron.cc.

References processor.

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

HepPolyhedron & HepPolyhedron::Transform

(

const G4Transform3D &

t

)

Definition at line 833 of file HepPolyhedron.cc.

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

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4EllipticalTube::CreatePolyhedron(), G4ReflectedSolid::CreatePolyhedron(), G4DisplacedSolid::CreatePolyhedron(), and G4ArrowModel::G4ArrowModel().

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

Friends And Related Function Documentation

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

friend

Definition at line 92 of file HepPolyhedron.cc.

                                                                     {
  ostr << std::endl;
  ostr << "Nverteces=" << 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;
}

Field Documentation

G4ThreadLocal G4int HepPolyhedron::fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

staticprotected

Definition at line 199 of file HepPolyhedron.h.

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

G4int HepPolyhedron::nface

protected

Definition at line 200 of file HepPolyhedron.h.

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

G4int HepPolyhedron::nvert

protected

Definition at line 200 of file HepPolyhedron.h.

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

G4Facet* HepPolyhedron::pF

protected

Definition at line 202 of file HepPolyhedron.h.

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

G4Point3D* HepPolyhedron::pV

protected

Definition at line 201 of file HepPolyhedron.h.

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

---

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

• HepPolyhedron.h
• HepPolyhedron.cc