Garfield::TetrahedralTree Class Reference

Helper class for searches in field maps. More...

#include <TetrahedralTree.hh>

Public Member Functions
	TetrahedralTree (const Vec3 &origin, const Vec3 &halfDimension)
	~TetrahedralTree ()
void	InsertMeshNode (Vec3 point, const int nodeIndex)
void	InsertTetrahedron (const double elemBoundingBox[6], const int elemIndex)
std::vector< int >	GetTetListInBlock (const Vec3 &point)

Detailed Description

Helper class for searches in field maps.

This class stores the mesh nodes and elements in an Octree data structure to optimize the element search operations

Author: Ali Sheharyar

Organization: Texas A&M University at Qatar

Definition at line 57 of file TetrahedralTree.hh.

Constructor & Destructor Documentation

TetrahedralTree()

Garfield::TetrahedralTree::TetrahedralTree	(	const Vec3 &	origin,
		const Vec3 &	halfDimension
	)

TetrahedralTree.cc This class stores the mesh nodes and elements in an Octree data structure to optimize the element search operations

Author: Ali Sheharyar Organization: Texas A&M University at Qatar

Definition at line 14 of file TetrahedralTree.cc.

    : m_origin(origin), m_halfDimension(halfDimension) {
 
  min.x = origin.x - halfDimension.x;
  min.y = origin.y - halfDimension.y;
  min.z = origin.z - halfDimension.z;
  max.x = origin.x + halfDimension.x;
  max.y = origin.y + halfDimension.y;
  max.z = origin.z + halfDimension.z;
 
  // Initially, there are no children
  for (int i = 0; i < 8; ++i) children[i] = NULL;
}

~TetrahedralTree()

Garfield::TetrahedralTree::~TetrahedralTree

(

)

Definition at line 28 of file TetrahedralTree.cc.

                                  {
  // Recursively destroy octants
  for (int i = 0; i < 8; ++i) delete children[i];
}

Member Function Documentation

GetTetListInBlock()

std::vector< int > Garfield::TetrahedralTree::GetTetListInBlock

(

const Vec3 &

point

)

Definition at line 129 of file TetrahedralTree.cc.

                                                                   {
 
  const TetrahedralTree* octreeNode = GetBlockFromPoint(point);
 
  if (octreeNode) {
    return octreeNode->tetList;
  }
 
  return std::vector<int>();
}

Referenced by Garfield::ComponentFieldMap::FindElement13(), and Garfield::ComponentFieldMap::FindElement5().

InsertMeshNode()

void Garfield::TetrahedralTree::InsertMeshNode	(	Vec3	point,
		const int	nodeIndex
	)

Definition at line 68 of file TetrahedralTree.cc.

                                                              {
  // check if it is a leaf node
  if (IsLeafNode()) {
    // add the new point if the block is not full
    if (!this->IsFull()) {
      iBlockElems.push_back(OctreeBlockElem(point, nodeIndex));
    } else {
      // block is full, so we need to partition it.
      // Split the current node and create new empty trees for each
      // child octant.
      for (int i = 0; i < 8; ++i) {
        // Compute new bounding box for this child
        Vec3 newOrigin = m_origin;
        newOrigin.x += m_halfDimension.x * (i & 4 ? .5f : -.5f);
        newOrigin.y += m_halfDimension.y * (i & 2 ? .5f : -.5f);
        newOrigin.z += m_halfDimension.z * (i & 1 ? .5f : -.5f);
        children[i] = new TetrahedralTree(newOrigin, m_halfDimension * .5f);
      }
 
      // move the nodes from the partitioned node (now marked as interior) to
      // its children
      while (!this->IsEmpty()) {
        OctreeBlockElem bElem = iBlockElems.back();
        iBlockElems.pop_back();
        int octant = GetOctantContainingPoint(bElem.point);
        children[octant]->InsertMeshNode(bElem.point, bElem.nodeIndex);
      }
 
      // insert the new node in the appropriate octant
      children[GetOctantContainingPoint(point)]
          ->InsertMeshNode(point, nodeIndex);
    }
  } else {
    // We are at an interior node. Insert recursively into the
    // appropriate child octant
    int octant = GetOctantContainingPoint(point);
    children[octant]->InsertMeshNode(point, nodeIndex);
  }
}

Referenced by InsertMeshNode().

InsertTetrahedron()

void Garfield::TetrahedralTree::InsertTetrahedron	(	const double	elemBoundingBox[6],
		const int	elemIndex
	)

Definition at line 108 of file TetrahedralTree.cc.

                                                             {
 
  if (IsLeafNode()) {
    // add the element to the list of this octant
    tetList.push_back(elemIndex);
  } else {
    // check which child overlaps with the element's bounding box
    for (int i = 0; i < 8; i++) {
      Vec3 elem_min(elemBoundingBox[0], elemBoundingBox[1], elemBoundingBox[2]);
      Vec3 elem_max(elemBoundingBox[3], elemBoundingBox[4], elemBoundingBox[5]);
 
      if (children[i]->DoesBoxOverlap(elem_min, elem_max))
        children[i]->InsertTetrahedron(elemBoundingBox, elemIndex);
    }
  }
}

Referenced by InsertTetrahedron().

---

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

• TetrahedralTree.hh
• TetrahedralTree.cc