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)
	Constructor.
	~TetrahedralTree ()
	Destructor.
void	InsertMeshNode (Vec3 point, const int index)
	Insert a mesh node (a vertex/point) to the tree.
void	InsertMeshElement (const double bb[6], const int index)
	Insert a mesh element with given bounding box and index to the tree.
std::vector< int >	GetElementsInBlock (const Vec3 &point) const
	Get all elements linked to a block corresponding to the given 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 56 of file TetrahedralTree.hh.

Constructor & Destructor Documentation

TetrahedralTree()

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

Constructor.

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) {
  m_min.x = origin.x - halfDimension.x;
  m_min.y = origin.y - halfDimension.y;
  m_min.z = origin.z - halfDimension.z;
  m_max.x = origin.x + halfDimension.x;
  m_max.y = origin.y + halfDimension.y;
  m_max.z = origin.z + halfDimension.z;
 
  // Initially, there are no children
  for (int i = 0; i < 8; ++i) children[i] = nullptr;
}

~TetrahedralTree()

Garfield::TetrahedralTree::~TetrahedralTree

(

)

Destructor.

Definition at line 27 of file TetrahedralTree.cc.

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

Member Function Documentation

GetElementsInBlock()

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

(

const Vec3 &

point

)

const

Get all elements linked to a block corresponding to the given point.

Definition at line 108 of file TetrahedralTree.cc.

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

InsertMeshElement()

void Garfield::TetrahedralTree::InsertMeshElement	(	const double	bb[6],
		const int	index
	)

Insert a mesh element with given bounding box and index to the tree.

Definition at line 92 of file TetrahedralTree.cc.

                                                                           {
  if (IsLeafNode()) {
    // Add the element to the list of this octant.
    elements.push_back(index);
    return;
  } 
  // Check which children overlap with the element's bounding box.
  for (int i = 0; i < 8; i++) {
    if (!children[i]->DoesBoxOverlap(bb)) continue;
    children[i]->InsertMeshElement(bb, index);
  }
}

Referenced by InsertMeshElement().

InsertMeshNode()

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

Insert a mesh node (a vertex/point) to the tree.

Definition at line 54 of file TetrahedralTree.cc.

                                                                {
  // Check if it is a leaf node.
  if (!IsLeafNode()) {
    // We are at an interior node. Insert recursively into the
    // appropriate child octant.
    int octant = GetOctantContainingPoint(point);
    children[octant]->InsertMeshNode(point, index);
    return;
  }
  
  // Add the new point if the block is not full.
  if (nodes.size() < BlockCapacity) {
    nodes.push_back(std::make_pair(point, index));
    return;
  } 
  // 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 mesh nodes from the partitioned node (now marked as interior) to
  // its children.
  while (!nodes.empty()) {
    auto node = nodes.back();
    nodes.pop_back();
    const int oct = GetOctantContainingPoint(node.first);
    children[oct]->InsertMeshNode(node.first, node.second);
  }
  // Insert the new point in the appropriate octant.
  children[GetOctantContainingPoint(point)]->InsertMeshNode(point, index);
}

Referenced by InsertMeshNode().

---

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

• TetrahedralTree.hh
• TetrahedralTree.cc