#include <HepPolyhedron.h>

Inheritance diagram for HepPolyhedronTetMesh:

Public Member Functions
	HepPolyhedronTetMesh (const std::vector< G4ThreeVector > &tetrahedra)

	~HepPolyhedronTetMesh () override

Public Member Functions inherited from HepPolyhedron
	HepPolyhedron ()

	HepPolyhedron (G4int Nvert, G4int Nface)

	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=nullptr, G4int *iFaces=nullptr) const

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

G4bool	GetNextFacet (G4int &n, G4Point3D nodes, G4int edgeFlags=nullptr, G4Normal3D *normals=nullptr) 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

void	SetVertex (G4int index, const G4Point3D &v)

void	SetFacet (G4int index, G4int iv1, G4int iv2, G4int iv3, G4int iv4=0)

void	SetReferences ()

void	JoinCoplanarFacets (G4double tolerance)

void	InvertFacets ()

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])

G4Point3D	vertexUnweightedMean () const

Additional Inherited Members
Static Public Member Functions inherited from HepPolyhedron
static G4int	GetNumberOfRotationSteps ()

static void	SetNumberOfRotationSteps (G4int n)

static void	ResetNumberOfRotationSteps ()

Protected Member Functions inherited from HepPolyhedron
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	RotateContourAroundZ (G4int nstep, G4double phi, G4double dphi, const std::vector< G4TwoVector > &rz, G4int nodeVis, G4int edgeVis)

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

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

Protected Attributes inherited from HepPolyhedron
G4int	nvert

G4int	nface

G4Point3D *	pV

G4Facet *	pF

Static Protected Attributes inherited from HepPolyhedron
static G4ThreadLocal G4int	fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

Detailed Description

Definition at line 617 of file HepPolyhedron.h.

Constructor & Destructor Documentation

◆ HepPolyhedronTetMesh()

HepPolyhedronTetMesh::HepPolyhedronTetMesh ( const std::vector< G4ThreeVector > & tetrahedra )

Definition at line 2920 of file HepPolyhedron.cc.

{
  // Check size of input vector
  G4int nnodes = (G4int)tetrahedra.size();
  if (nnodes == 0)
  {
    std::cerr
      << "HepPolyhedronTetMesh: Empty tetrahedron mesh" << std::endl;
    return;
  }
  G4int ntet = nnodes/4;
  if (nnodes != ntet*4)
  {
    std::cerr << "HepPolyhedronTetMesh: Number of nodes = " << nnodes
              << " in tetrahedron mesh is NOT multiple of 4"
              << std::endl;
    return;
  }
 
  // Find coincident vertices using hash table techniques.
  // This could be done using std::unordered_map, but the code
  // below runs faster.
  std::vector<G4int> iheads(nnodes, -1);
  std::vector<std::pair<G4int,G4int>> ipairs(nnodes,std::pair(-1,-1));
  for (G4int i = 0; i < nnodes; ++i)
  {
    // Generate hash key
    G4ThreeVector point = tetrahedra[i];
    auto key = std::hash<G4double>()(point.x());
    key ^= std::hash<G4double>()(point.y());
    key ^= std::hash<G4double>()(point.z());
    key %= nnodes;
    // Check head of the list
    if (iheads[key] < 0)
    {
      iheads[key] = i;
      ipairs[i].first = i;
      continue;
    }
    // Loop along the list
    for (G4int icur = iheads[key], iprev = 0;;)
    {
      G4int icheck = ipairs[icur].first;
      if (tetrahedra[icheck] == point)
      {
        ipairs[i].first = icheck; // coincident vertex
        break;
      }
      iprev = icur;
      icur = ipairs[icur].second;
      // Append vertex to the list
      if (icur < 0)
      {
        ipairs[i].first = i;
        ipairs[iprev].second = i;
        break;
      }
    }
  }
 
  // Create vector of original facets
  struct facet
  {
    G4int i1, i2, i3;
    facet() : i1(0), i2(0), i3(0) {};
    facet(G4int k1, G4int k2, G4int k3) : i1(k1), i2(k2), i3(k3) {};
  };
  G4int nfacets = nnodes;
  std::vector<facet> ifacets(nfacets);
  for (G4int i = 0; i < nfacets; i += 4)
  {
    G4int i0 = ipairs[i + 0].first;
    G4int i1 = ipairs[i + 1].first;
    G4int i2 = ipairs[i + 2].first;
    G4int i3 = ipairs[i + 3].first;
    if (i0 > i1) std::swap(i0, i1);
    if (i0 > i2) std::swap(i0, i2);
    if (i0 > i3) std::swap(i0, i3);
    if (i1 > i2) std::swap(i1, i2);
    if (i1 > i3) std::swap(i1, i3);
    G4ThreeVector e1 = tetrahedra[i1] - tetrahedra[i0];
    G4ThreeVector e2 = tetrahedra[i2] - tetrahedra[i0];
    G4ThreeVector e3 = tetrahedra[i3] - tetrahedra[i0];
    G4double volume = (e1.cross(e2)).dot(e3);
    if (volume > 0.) std::swap(i2, i3);
    ifacets[i + 0] = facet(i0, i1, i2);
    ifacets[i + 1] = facet(i0, i2, i3);
    ifacets[i + 2] = facet(i0, i3, i1);
    ifacets[i + 3] = facet(i1, i3, i2);
  }
 
  // Find shared facets
  std::fill(iheads.begin(), iheads.end(), -1);
  std::fill(ipairs.begin(), ipairs.end(), std::pair(-1,-1));
  for (G4int i = 0; i < nfacets; ++i)
  {
    // Check head of the list
    G4int key = ifacets[i].i1;
    if (iheads[key] < 0)
    {
      iheads[key] = i;
      ipairs[i].first = i;
      continue;
    }
    // Loop along the list
    G4int i2 = ifacets[i].i2, i3 = ifacets[i].i3;
    for (G4int icur = iheads[key], iprev = -1;;)
    {
      G4int icheck = ipairs[icur].first;
      if (ifacets[icheck].i2 == i3 && ifacets[icheck].i3 == i2)
      {
        if (iprev < 0)
        {
          iheads[key] = ipairs[icur].second;
        }
        else
        {
          ipairs[iprev].second = ipairs[icur].second;
        }
        ipairs[icur].first = -1; // shared facet
        ipairs[icur].second = -1;
        break;
      }
      iprev = icur;
      icur = ipairs[icur].second;
      // Append facet to the list
      if (icur < 0)
      {
        ipairs[i].first = i;
        ipairs[iprev].second = i;
        break;
      }
    }
  }
 
  // Count vertices and facets skipping shared facets
  std::fill(iheads.begin(), iheads.end(), -1);
  G4int nver = 0, nfac = 0;
  for (G4int i = 0; i < nfacets; ++i)
  {
    if (ipairs[i].first < 0) continue;
    G4int i1 = ifacets[i].i1;
    G4int i2 = ifacets[i].i2;
    G4int i3 = ifacets[i].i3;
    if (iheads[i1] < 0) iheads[i1] = nver++;
    if (iheads[i2] < 0) iheads[i2] = nver++;
    if (iheads[i3] < 0) iheads[i3] = nver++;
    nfac++;
  }
 
  // Construct polyhedron
  AllocateMemory(nver, nfac);
  for (G4int i = 0; i < nnodes; ++i)
  {
    G4int k = iheads[i];
    if (k >= 0) SetVertex(k + 1, tetrahedra[i]);
  }
  for (G4int i = 0, k = 0; i < nfacets; ++i)
  {
    if (ipairs[i].first < 0) continue;
    G4int i1 = iheads[ifacets[i].i1] + 1;
    G4int i2 = iheads[ifacets[i].i2] + 1;
    G4int i3 = iheads[ifacets[i].i3] + 1;
    SetFacet(++k, i1, i2, i3);
  }
  SetReferences();
}

◆ ~HepPolyhedronTetMesh()

HepPolyhedronTetMesh::~HepPolyhedronTetMesh ( )

overridedefault

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HepPolyhedronTetMesh()

◆ ~HepPolyhedronTetMesh()