oomph::BinaryTree Class Reference

#include <binary_tree.h>

Inheritance diagram for oomph::BinaryTree:

Public Member Functions
virtual	~BinaryTree ()
	BinaryTree (const BinaryTree &dummy)=delete
	Broken copy constructor. More...
void	operator= (const BinaryTree &)=delete
	Broken assignment operator. More...
Tree *	construct_son (RefineableElement *const &object_pt, Tree *const &father_pt, const int &son_type)
BinaryTree *	gteq_edge_neighbour (const int &direction, Vector< double > &s_in_neighbour, int &edge, int &diff_level, bool &in_neighbouring_tree) const
unsigned	self_test ()
Public Member Functions inherited from oomph::Tree
virtual	~Tree ()
	Tree (const Tree &dummy)=delete
	Broken copy constructor. More...
void	operator= (const Tree &)=delete
	Broken assignment operator. More...
RefineableElement *	object_pt () const
void	flush_object ()
	Flush the object represented by the tree. More...
Tree *	son_pt (const int &son_index) const
void	set_son_pt (const Vector< Tree * > &son_pt)
unsigned	nsons () const
	Return number of sons (zero if it's a leaf node) More...
void	flush_sons ()
	Flush the sons. More...
TreeRoot *&	root_pt ()
	Return pointer to root of the tree. More...
TreeRoot *	root_pt () const
	Return pointer to root of the tree (const version) More...
template<class ELEMENT >
void	split_if_required ()
template<class ELEMENT >
void	p_refine_if_required (Mesh *&mesh_pt)
void	merge_sons_if_required (Mesh *&mesh_pt)
void	deactivate_object ()
	Call the RefineableElement's deactivate_element() function. More...
void	traverse_all (Tree::VoidMemberFctPt member_function)
void	traverse_all (Tree::VoidMeshPtArgumentMemberFctPt member_function, Mesh *&mesh_pt)
void	traverse_all_but_leaves (Tree::VoidMemberFctPt member_function)
void	traverse_leaves (Tree::VoidMemberFctPt member_function)
void	traverse_leaves (Tree::VoidMeshPtArgumentMemberFctPt member_function, Mesh *&mesh_pt)
void	stick_leaves_into_vector (Vector< Tree * > &)
	Traverse tree and stick pointers to leaf "nodes" (only) into Vector. More...
void	stick_all_tree_nodes_into_vector (Vector< Tree * > &)
	Traverse and stick pointers to all "nodes" into Vector. More...
int	son_type () const
	Return son type. More...
bool	is_leaf ()
	Return true if the tree is a leaf node. More...
Tree *	father_pt () const
	Return pointer to father: NULL if it's a root node. More...
void	set_father_pt (Tree *const &father_pt)
	Set the father. More...
unsigned	level () const
	Return the level of the Tree (root=0) More...

Static Public Member Functions
static void	setup_static_data ()
	Set up the static data, reflection schemes, etc. More...
static void	doc_neighbours (Vector< Tree * > forest_nodes_pt, std::ofstream &neighbours_file, std::ofstream &neighbours_txt_file, double &max_error)
Static Public Member Functions inherited from oomph::Tree
static double &	max_neighbour_finding_tolerance ()

Static Public Attributes
static Vector< std::string >	Direct_string
	Translate (enumerated) directions into strings. More...
Static Public Attributes inherited from oomph::Tree
static const int	OMEGA = 26
	Default value for an unassigned neighbour. More...

Protected Member Functions
	BinaryTree ()
	Default constructor (empty and broken) More...
	BinaryTree (RefineableElement *const &object_pt)
	BinaryTree (RefineableElement *const &object_pt, Tree *const &father_pt, const int &son_type)
Protected Member Functions inherited from oomph::Tree
	Tree ()
	Default constructor (empty and broken) More...
	Tree (RefineableElement *const &object_pt)
	Tree (RefineableElement *const &object_pt, Tree *const &father_pt, const int &son_type)

Static Protected Attributes
static bool	Static_data_has_been_setup = false
	Boolean indicating that static member data has been setup. More...
Static Protected Attributes inherited from oomph::Tree
static double	Max_neighbour_finding_tolerance = 1.0e-14

Private Member Functions
BinaryTree *	gteq_edge_neighbour (const int &direction, double &s_diff, int &diff_level, bool &in_neighbouring_tree, int max_level, BinaryTreeRoot *const &orig_root_pt) const

Static Private Attributes
static Vector< std::string >	Colour
	Colours for neighbours in various directions. More...
static Vector< double >	S_base
static Vector< int >	Reflect_edge
	Get opposite edge, e.g. Reflect_edge[L]=R. More...
static DenseMatrix< bool >	Is_adjacent
static DenseMatrix< int >	Reflect

Additional Inherited Members
Public Types inherited from oomph::Tree
typedef void(Tree::*	VoidMemberFctPt) ()
	Function pointer to argument-free void Tree member function. More...
typedef void(Tree::*	VoidMeshPtArgumentMemberFctPt) (Mesh *&mesh_pt)
Protected Attributes inherited from oomph::Tree
TreeRoot *	Root_pt
	Pointer to the root of the tree. More...
Tree *	Father_pt
	Pointer to the Father of the Tree. More...
Vector< Tree * >	Son_pt
	Vector of pointers to the sons of the Tree. More...
int	Level
	Level of the Tree (level 0 = root) More...
int	Son_type
	Son type (e.g. SW/SE/NW/NE in a quadtree) More...
RefineableElement *	Object_pt
	Pointer to the object represented by the tree. More...

Detailed Description

BinaryTree class: Recursively defined, generalised binary tree.

A BinaryTree has:

• a pointer to the object (of type RefineableQElement<1>) that it represents in a mesh refinement context.
• a Vector of pointers to its two (L/R) sons (which are themselves binary trees). If the Vector of pointers to the sons has zero length, the BinaryTree is a "leaf node" in the overall binary tree.
• a pointer to its father. If this pointer is NULL, the BinaryTree is the root node of the overall binary tree. This data is stored in the Tree base class.

The tree can also be part of a forest. If that is the case, the root will have pointers to the roots of neighbouring binary trees.

The objects contained in the binary tree are assumed to be line elements whose geometry is parametrised by local coordinates \( {\bf s} \in [-1,1] \).

The tree can be traversed and actions performed at all its "nodes" or only at the leaf "nodes" ("nodes" without sons).

Finally, the leaf "nodes" can be split depending on a criteria defined by the object.

Note that BinaryTrees are only generated by splitting existing BinaryTrees. Therefore, the constructors are protected. The only BinaryTree that "Joe User" can create is the (derived) class BinaryTreeRoot.

Constructor & Destructor Documentation

~BinaryTree()

virtual oomph::BinaryTree::~BinaryTree ( )

inlinevirtual

Destructor. Note: Deleting a binary tree also deletes the objects associated with all non-leaf nodes!

{}

BinaryTree() [1/4]

oomph::BinaryTree::BinaryTree ( const BinaryTree &  dummy )

delete

Broken copy constructor.

BinaryTree() [2/4]

oomph::BinaryTree::BinaryTree ( )

inlineprotected

Default constructor (empty and broken)

    {
      throw OomphLibError(
        "Don't call an empty constructor for a BinaryTree object",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by construct_son().

BinaryTree() [3/4]

oomph::BinaryTree::BinaryTree ( RefineableElement *const &  object_pt )

inlineprotected

Default constructor for empty (root) tree: no father, no sons; just pass a pointer to its object. Protected because BinaryTrees can only be created internally, during the split operation. Only BinaryTreeRoots can be created externally.

: Tree(object_pt) {}

BinaryTree() [4/4]

oomph::BinaryTree::BinaryTree ( RefineableElement *const &  object_pt, Tree *const &  father_pt, const int &  son_type  )

inlineprotected

Constructor for tree that has a father: Pass it the pointer to its object, the pointer to its father and tell it what type of son (L/R) it is. Protected because BinaryTrees can only be created internally, during the split operation. Only BinaryTreeRoots can be created externally.

      : Tree(object_pt, father_pt, son_type)
    {
    }

Member Function Documentation

construct_son()

Tree* oomph::BinaryTree::construct_son ( RefineableElement *const &  object_pt, Tree *const &  father_pt, const int &  son_type  )

inlinevirtual

Overload the function construct_son to ensure that the son is a specific BinaryTree and not a general Tree.

Implements oomph::Tree.

    {
      BinaryTree* temp_binary_pt =
        new BinaryTree(object_pt, father_pt, son_type);
      return temp_binary_pt;
    }

References BinaryTree(), oomph::Tree::father_pt(), oomph::Tree::object_pt(), and oomph::Tree::son_type().

doc_neighbours()

void oomph::BinaryTree::doc_neighbours ( Vector< Tree * >  forest_nodes_pt, std::ofstream &  neighbours_file, std::ofstream &  neighbours_txt_file, double &  max_error  )

static

Doc/check all neighbours of binary tree (nodes) contained in the Vector forest_node_pt. Output into neighbours_file which can be viewed from tecplot with BinaryTreeNeighbours.mcr. Neighbour info and errors are displayed on neighbours_txt_file. Finally, compute the maximum error between vertices when viewed from the neighbouring element. If the two filestreams are closed, output is suppressed.

Doc/check all neighbours of binary tree ("nodes") contained in the Vector forest_node_pt. Output into neighbours_file which can be viewed from tecplot with BinaryTreeNeighbours.mcr. Neighbour info and errors are displayed on neighbours_txt_file. Finally, compute the maximum error between vertices when viewed from neighbouring element. Output is suppressed if the output streams are closed.

  {
    using namespace BinaryTreeNames;
 
    int diff_level;
    double s_diff;
    bool in_neighbouring_tree;
    int edge = OMEGA;
 
    Vector<double> s(1);
    Vector<double> x(1);
    Vector<int> prev_son_type;
 
    Vector<double> s_in_neighbour(1);
 
    Vector<double> x_small(1);
    Vector<double> x_large(1);
 
    // Initialise error in vertex positions
    max_error = 0.0;
 
    // Loop over all elements to assign numbers for plotting
    // -----------------------------------------------------
    unsigned long num_nodes = forest_nodes_pt.size();
    for (unsigned long i = 0; i < num_nodes; i++)
    {
      // Set number
      forest_nodes_pt[i]->object_pt()->set_number(i);
    }
 
    // Loop over all elements for checks
    // ---------------------------------
    for (unsigned long i = 0; i < num_nodes; i++)
    {
      // Doc the element itself
      BinaryTree* el_pt = dynamic_cast<BinaryTree*>(forest_nodes_pt[i]);
 
      // If the object is incomplete, complain
      if (el_pt->object_pt()->nodes_built())
      {
        // Print it
        if (neighbours_file.is_open())
        {
          dynamic_cast<RefineableQElement<1>*>(el_pt->object_pt())
            ->output_corners(neighbours_file, "BLACK");
        }
 
        // Loop over directions to find neighbours
        // ---------------------------------------
        for (int direction = L; direction <= R; direction++)
        {
          // Initialise difference in levels and coordinate offset
          diff_level = 0;
          s_diff = 0.0;
 
          // Find greater-or-equal-sized neighbour...
          BinaryTree* neighb_pt = el_pt->gteq_edge_neighbour(
            direction, s_in_neighbour, edge, diff_level, in_neighbouring_tree);
 
          // If neighbour exist and nodes are created: Doc it
          if ((neighb_pt != 0) && (neighb_pt->object_pt()->nodes_built()))
          {
            // Doc neighbour stats
            if (neighbours_txt_file.is_open())
            {
              neighbours_txt_file
                << Direct_string[direction] << " neighbour of "
                << el_pt->object_pt()->number() << " is "
                << neighb_pt->object_pt()->number() << " diff_level "
                << diff_level << " s_diff " << s_diff
                << " inside neighbour the edge is " << Direct_string[edge]
                << std::endl
                << std::endl;
            }
 
            // Plot neighbour in the appropriate colour
            if (neighbours_file.is_open())
            {
              dynamic_cast<RefineableQElement<1>*>(neighb_pt->object_pt())
                ->output_corners(neighbours_file, Colour[direction]);
            }
 
            // Check that local coordinates in the larger element (obtained
            // via s_diff) lead to the same spatial point as the node vertices
            // in the current element
            {
              if (neighbours_file.is_open())
              {
                neighbours_file << "ZONE I=1 \n";
              }
 
              // Left vertex:
              // ------------
 
              // Get coordinates in large (neighbour) element
              s[0] = s_in_neighbour[0];
              neighb_pt->object_pt()->get_x(s, x_large);
 
              // Get coordinates in small element
              Vector<double> s(1);
              s[0] = S_base[direction];
              el_pt->object_pt()->get_x(s, x_small);
 
              // Need to exclude periodic nodes from this check. There can
              // only be periodic nodes if we have moved into the neighbour
              bool is_periodic = false;
              if (in_neighbouring_tree)
              {
                // Is the node periodic?
                is_periodic =
                  el_pt->root_pt()->is_neighbour_periodic(direction);
              }
 
              double error = 0.0;
              // Only bother to calculate the error if the node is NOT periodic
              if (is_periodic == false)
              {
                error += pow(x_small[0] - x_large[0], 2);
              }
 
              // Take the root of the square error
              error = sqrt(error);
              if (neighbours_txt_file.is_open())
              {
                neighbours_txt_file << "Error (1) " << error << std::endl;
              }
 
              if (std::fabs(error) > max_error)
              {
                max_error = std::fabs(error);
              }
 
              if (neighbours_file.is_open())
              {
                neighbours_file << x_large[0] << "  0 \n";
              }
 
              // Right vertex:
              // -------------
 
              // Get coordinates in large (neighbour) element
              s[0] = s_in_neighbour[0];
              neighb_pt->object_pt()->get_x(s, x_large);
 
              // Get coordinates in small element
              s[0] = S_base[direction];
              el_pt->object_pt()->get_x(s, x_small);
 
              error = 0.0;
              // Only do this if we are NOT periodic
              if (is_periodic == false)
              {
                error += pow(x_small[0] - x_large[0], 2);
              }
              // Take the root of the square error
              error = sqrt(error);
 
              // error =
              // sqrt(pow(x_small[0]-x_large[0],2)+pow(x_small[1]-x_large[1],2));
              if (neighbours_txt_file.is_open())
              {
                neighbours_txt_file << "Error (2) " << error << std::endl;
              }
 
              if (std::fabs(error) > max_error)
              {
                max_error = std::fabs(error);
              }
 
              if (neighbours_file.is_open())
              {
                neighbours_file << x_large[0] << "  0 \n";
              }
            }
            //        else
            //         {
            //          // No neighbour: write dummy zone so tecplot can find
            //          four
            //          // neighbours for every element
            //          if (neighbours_file.is_open())
            //            {
            //             neighbours_file << "ZONE I=1 \n";
            //             neighbours_file << "-0.05 -0.05   0 \n";
            //             neighbours_file << "-0.05 -0.05   0 \n";
            //            }
            //         }
          }
          // If neighbour does not exist: Insert blank zones into file
          // so that tecplot can find four neighbours for every element
          else
          {
            if (neighbours_file.is_open())
            {
              neighbours_file << "ZONE \n 0.00  0 \n";
              neighbours_file << "ZONE I=1 \n";
              neighbours_file << "-0.05  0 \n";
              neighbours_file << "-0.05  0 \n";
            }
          }
        }
      } // End of case when element can be documented
    }
  }

References calibrate::error, boost::multiprecision::fabs(), oomph::FiniteElement::get_x(), gteq_edge_neighbour(), i, oomph::TreeRoot::is_neighbour_periodic(), L, MeshRefinement::max_error, oomph::RefineableElement::nodes_built(), oomph::RefineableElement::number(), oomph::Tree::object_pt(), oomph::BinaryTreeNames::OMEGA, Eigen::bfloat16_impl::pow(), R, oomph::Tree::root_pt(), s, sqrt(), and plotDoE::x.

Referenced by oomph::BinaryTreeForest::check_all_neighbours(), self_test(), and oomph::BinaryTreeForest::self_test().

gteq_edge_neighbour() [1/2]

BinaryTree * oomph::BinaryTree::gteq_edge_neighbour ( const int &  direction, double &  s_diff, int &  diff_level, bool &  in_neighbouring_tree, int  max_level, BinaryTreeRoot *const &  orig_root_pt  ) const

private

Find greater or equal-sized edge neighbour in direction. Auxiliary internal routine which passes additional information around.

Find ‘greater-or-equal-sized edge neighbour’ in given direction (L/R).

This is an auxiliary routine which allows neighbour finding in adjacent binary trees. Needs to keep track of previous son types and the maximum level to which search is performed.

Parameters:

• direction (L/R): Direction in which neighbour has to be found.
• s_diff: Offset of left vertex from corresponding vertex in neighbour. Note that this is input/output as it needs to be incremented/decremented during the recursive calls to this function.
• edge: We're looking for the neighbour across our edge 'direction' (L/R). When viewed from the neighbour, this edge is ‘edge’ (L/R). Since there is no relative rotation between neighbours this is a mere reflection, e.g. direction=L --> edge=R etc.
• diff_level <= 0 indicates the difference in binary tree levels between the current element and its neighbour.
• max_level is the maximum level to which the neighbour search is allowed to proceed. This is again necessary because in a forest, the neighbour search isn't based on pure recursion.
• orig_root_pt identifies the root node of the element whose neighbour we're really trying to find by all these recursive calls.

  {
    using namespace BinaryTreeNames;
 
#ifdef PARANOID
    if ((direction != L) && (direction != R))
    {
      std::ostringstream error_stream;
      error_stream << "Direction " << direction << " is not L or R"
                   << std::endl;
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    BinaryTree* next_el_pt;
    BinaryTree* return_el_pt;
 
    // STEP 1: Find the neighbour's father
    // -------
 
    // Does the element have a father?
    if (Father_pt != 0)
    {
      // If the present segment (whose location inside its father element
      // is specified by Son_type) is adjacent to the father's edge in the
      // required direction, then its neighbour has a different father
      // ---> we need to climb up the tree to the father and find his
      // neighbour in the required direction. Note that this is the cunning
      // recursive part. The returning may not stop until we hit the very
      // top of the tree, when the element does NOT have a father.
      if (Is_adjacent(direction, Son_type))
      {
        next_el_pt = dynamic_cast<BinaryTree*>(Father_pt)->gteq_edge_neighbour(
          direction,
          s_diff,
          diff_level,
          in_neighbouring_tree,
          max_level,
          orig_root_pt);
      }
      // If the present segment is not adjacent to the father's edge in the
      // required direction, then the neighbour has the same father and is
      // obtained by the appropriate reflection inside the father element.
      // This will only be called if we have not left the original tree.
      else
      {
        next_el_pt = dynamic_cast<BinaryTree*>(Father_pt);
      }
 
      // We're about to ascend one level
      diff_level -= 1;
 
      // Work out position of left corner of present edge in its father element
      s_diff += pow(0.5, -diff_level);
 
      // STEP 2: We have now located the neighbour's father and need to
      // ------- find the appropriate son.
 
      // Buffer cases where the neighbour (and hence its father) lie outside
      // the boundary
      if (next_el_pt != 0)
      {
        // If the father is a leaf then we can't descend to the same
        // level as the present node ---> simply return the father himself
        // as the (greater) neighbour. Same applies if we are about to
        // descend lower than the max_level (in a  neighbouring tree).
        if ((next_el_pt->Son_pt.size() == 0) ||
            (next_el_pt->Level > max_level - 1))
        {
          return_el_pt = next_el_pt;
        }
        // We have located the neighbour's father: The position of the
        // neighbour is obtained by `reflecting' the position of the
        // node itself. We know exactly how to reflect because we know which
        // son type we are and we have the pointer to the neighbour's father.
        else
        {
          int son_segment = Reflect(direction, Son_type);
 
          // The next element in the tree is the appropriate son of the
          // neighbour's father
          return_el_pt =
            dynamic_cast<BinaryTree*>(next_el_pt->Son_pt[son_segment]);
 
          // Work out position of left corner of present edge in next
          // higher element
          s_diff -= pow(0.5, -diff_level);
 
          // We have just descended one level
          diff_level += 1;
        }
      }
      // The neighbour's father lies outside the boundary --> the neighbour
      // itself does too --> return NULL
      else
      {
        return_el_pt = 0;
      }
    }
    // Element does not have a father --> check if it has a neighbouring
    // tree in the appropriate direction
    else
    {
      // Find neighbouring root
      if (Root_pt->neighbour_pt(direction) != 0)
      {
        // In this case we have moved to a neighbour, so set the flag
        in_neighbouring_tree = true;
        return_el_pt =
          dynamic_cast<BinaryTreeRoot*>(Root_pt->neighbour_pt(direction));
      }
      // No neighbouring tree, so there really is no neighbour --> return NULL
      else
      {
        return_el_pt = 0;
      }
    }
 
    return return_el_pt;
  }

References oomph::Tree::Father_pt, gteq_edge_neighbour(), Is_adjacent, L, oomph::Tree::Level, oomph::TreeRoot::neighbour_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Eigen::bfloat16_impl::pow(), R, Reflect, oomph::Tree::Root_pt, oomph::Tree::Son_pt, and oomph::Tree::Son_type.

gteq_edge_neighbour() [2/2]

BinaryTree * oomph::BinaryTree::gteq_edge_neighbour	(	const int &	direction,
		Vector< double > &	s_in_neighbour,
		int &	edge,
		int &	diff_level,
		bool &	in_neighbouring_tree
	)		const

Return pointer to greater or equal-sized edge neighbour in specified direction; also provide info regarding the relative size of the neighbour:

• In the present binary tree, the left vertex is located at the local coordinate s = -1. This point is located at the local coordinate s = s_in_neighbour[0] in the neighbouring binary tree.
• We're looking for a neighbour in the specified direction. When viewed from the neighbouring binary tree, the edge that separates the present binary tree from its neighbour is the neighbour's edge edge. Since in 1D there can be no rotation between the two binary trees, this is a simple reflection. For instance, if we're looking for a neighhbour in the L [eft] direction, edge will be R [ight].
• diff_level <= 0 indicates the difference in refinement levels between the two neighbours. If diff_level==0, the neighbour has the same size as the current binary tree.
• in_neighbouring_tree indicates whether the neighbour is actually in another tree in the forest. The introduction of this flag was necessitated by periodic problems where a TreeRoot can be its own neighbour.

Return pointer to greater or equal-sized edge neighbour in specified direction; also provide info regarding the relative size of the neighbour:

• In the present binary tree, the left vertex is located at the local coordinate s = -1. This point is located at the local coordinate s = s_in_neighbour[0] in the neighbouring binary tree.
• We're looking for a neighbour in the specified direction. When viewed from the neighbouring binary tree, the edge that separates the present binary tree from its neighbour is the neighbour's edge edge. Since in 1D there can be no rotation between the two binary trees, this is a simple reflection. For instance, if we're looking for a neighhbour in the L [eft] direction, edge will be R [ight].
• diff_level <= 0 indicates the difference in refinement levels between the two neighbours. If diff_level==0, the neighbour has the same size as the current binary tree.
• in_neighbouring_tree returns true if we have had to flip to a different root, even if that root is actually the same (as it can be in periodic problems).

  {
    using namespace BinaryTreeNames;
 
#ifdef PARANOID
    if ((direction != L) && (direction != R))
    {
      std::ostringstream error_stream;
      error_stream << "Direction " << direction << " is not L or R"
                   << std::endl;
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Initialise in_neighbouring tree to false. It will be set to true
    // during the recursion if we do actually hop over into the neighbour
    in_neighbouring_tree = false;
 
    // Maximum level to which we're allowed to descend (we only want
    // greater-or-equal-sized neighbours)
    int max_level = Level;
 
    // Current element has the following root:
    BinaryTreeRoot* orig_root_pt = dynamic_cast<BinaryTreeRoot*>(Root_pt);
 
    // Initialise offset in local coordinate
    double s_diff = 0;
 
    // Initialise difference in level
    diff_level = 0;
 
    // Find neighbour
    BinaryTree* return_pt = gteq_edge_neighbour(direction,
                                                s_diff,
                                                diff_level,
                                                in_neighbouring_tree,
                                                max_level,
                                                orig_root_pt);
 
    BinaryTree* neighb_pt = return_pt;
 
    // If neighbour exists...
    if (neighb_pt != 0)
    {
      // What's the direction of the interfacial edge when viewed from within
      // the neighbour element?
      edge = Reflect_edge[direction];
 
      // What's the local coordinate s at which this edge is located in the
      // neighbouring element?
      s_in_neighbour[0] = S_base[edge];
    }
    return return_pt;
  }

References L, oomph::Tree::Level, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, R, Reflect_edge, oomph::Tree::Root_pt, and S_base.

Referenced by oomph::RefineableQElement< 1 >::check_integrity(), doc_neighbours(), gteq_edge_neighbour(), and oomph::RefineableQElement< 1 >::node_created_by_neighbour().

operator=()

void oomph::BinaryTree::operator= ( const BinaryTree &  )

delete

Broken assignment operator.

self_test()

unsigned oomph::BinaryTree::self_test

(

)

Self-test: Check all neighbours. Return success (0) if the maximum distance between corresponding points in the neighbours is less than the tolerance specified in the static value BinaryTree::Max_neighbour_finding_tolerance.

Self-test: Check neighbour finding routine. For each element in the tree and for each vertex, determine the distance between the vertex and its position in the neighbour. If the difference is less than Tree::Max_neighbour_finding_tolerance return success (0), otherwise failure (1).

  {
    // Stick pointers to all nodes into Vector and number elements
    // in the process
    Vector<Tree*> all_nodes_pt;
    stick_all_tree_nodes_into_vector(all_nodes_pt);
    long int count = 0;
    unsigned long num_nodes = all_nodes_pt.size();
    for (unsigned long i = 0; i < num_nodes; i++)
    {
      all_nodes_pt[i]->object_pt()->set_number(++count);
    }
 
    // Check neighbours (distance between hanging nodes) -- don't print
    // (keep output streams closed)
    double max_error = 0.0;
    std::ofstream neighbours_file;
    std::ofstream neighbours_txt_file;
    BinaryTree::doc_neighbours(
      all_nodes_pt, neighbours_file, neighbours_txt_file, max_error);
 
    if (max_error > Max_neighbour_finding_tolerance)
    {
      oomph_info << "\n \n Failed self_test() for BinaryTree: Max. error "
                 << max_error << std::endl
                 << std::endl;
      return 1;
    }
    else
    {
      oomph_info << "\n \n Passed self_test() for BinaryTree: Max. error "
                 << max_error << std::endl
                 << std::endl;
      return 0;
    }
  }

References doc_neighbours(), i, MeshRefinement::max_error, oomph::Tree::Max_neighbour_finding_tolerance, oomph::oomph_info, and oomph::Tree::stick_all_tree_nodes_into_vector().

setup_static_data()

void oomph::BinaryTree::setup_static_data ( )

static

Set up the static data, reflection schemes, etc.

Set up the static data stored in the BinaryTree – this needs to be called before BinaryTrees can be used. Automatically called by RefineableLineMesh constructor.

  {
    using namespace BinaryTreeNames;
 
#ifdef PARANOID
    if (Tree::OMEGA != BinaryTree::OMEGA)
    {
      std::ostringstream error_stream;
      error_stream << "Inconsistent enumeration!  \n    Tree::OMEGA="
                   << Tree::OMEGA << "\nBinaryTree::OMEGA=" << BinaryTree::OMEGA
                   << std::endl;
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Set flag to indicate that static data has been setup
    Static_data_has_been_setup = true;
 
    // Tecplot colours for neighbours in various directions
    Colour.resize(27);
 
    Colour[L] = "RED";
    Colour[R] = "CYAN";
    Colour[OMEGA] = "YELLOW";
 
    // S_base(direction): Initial value for coordinate s on the
    // edge indicated by direction (L/R)
    S_base.resize(27);
 
    S_base[L] = -1.0;
    S_base[R] = 1.0;
 
    // Translate (enumerated) directions into strings
    Direct_string.resize(27);
 
    Direct_string[L] = "L";
    Direct_string[R] = "R";
    Direct_string[OMEGA] = "OMEGA";
 
    // Build direction/segment adjacency scheme:
    // Is_adjacent(i_vertex,j_segment): Is vertex adjacent to segment?
    Is_adjacent.resize(27, 27);
 
    Is_adjacent(L, L) = true;
    Is_adjacent(R, L) = false;
    Is_adjacent(L, R) = false;
    Is_adjacent(R, R) = true;
 
    // Build reflection scheme: Reflect(direction,segment):
    // Get mirror of segment in direction
    Reflect.resize(27, 27);
 
    Reflect(L, L) = R;
    Reflect(R, L) = R;
    Reflect(L, R) = L;
    Reflect(R, R) = L;
 
    // Get opposite edge, e.g. Reflect_edge(L)=R
    Reflect_edge.resize(27);
 
    Reflect_edge[L] = R;
    Reflect_edge[R] = L;
  }

References Colour, Direct_string, Is_adjacent, L, oomph::Tree::OMEGA, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, R, Reflect, Reflect_edge, oomph::DenseMatrix< T >::resize(), S_base, and Static_data_has_been_setup.

Referenced by oomph::RefineableLineMesh< ELEMENT >::RefineableLineMesh().

Member Data Documentation

Colour

Vector< std::string > oomph::BinaryTree::Colour

staticprivate

Colours for neighbours in various directions.

Colours for neighbours in various directions (static data).

Referenced by setup_static_data().

Direct_string

Vector< std::string > oomph::BinaryTree::Direct_string

static

Translate (enumerated) directions into strings.

Translate (enumerated) directions into strings (static data).

Referenced by setup_static_data().

Is_adjacent

DenseMatrix< bool > oomph::BinaryTree::Is_adjacent

staticprivate

Array of direction/segment adjacency scheme: Is_adjacent(i_vertex,j_segment): Is vertex adjacent to segment?

Array of direction/segment adjacency scheme: Is_adjacent(i_vertex,j_segment): Is vertex adjacent to segment? (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

Reflect

DenseMatrix< int > oomph::BinaryTree::Reflect

staticprivate

Reflection scheme: Reflect(direction,segment): Get mirror of segment in specified direction. E.g. Reflect(L,L)=R.

Reflection scheme: Reflect(direction,segment): Get mirror of segment in specified direction. E.g. Reflect(L,L)=R (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

Reflect_edge

Vector< int > oomph::BinaryTree::Reflect_edge

staticprivate

Get opposite edge, e.g. Reflect_edge[L]=R.

Get opposite edge, e.g. Reflect_edge[N]=S (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

S_base

Vector< double > oomph::BinaryTree::S_base

staticprivate

S_base(direction): Initial value for coordinate s on the edge indicated by direction (L/R)

S_base(direction): Initial value for coordinate s on the edge indicated by direction (L/R) (static data).

Referenced by gteq_edge_neighbour(), and setup_static_data().

Static_data_has_been_setup

bool oomph::BinaryTree::Static_data_has_been_setup = false

staticprotected

Boolean indicating that static member data has been setup.

Referenced by oomph::BinaryTreeRoot::BinaryTreeRoot(), and setup_static_data().

---

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

• binary_tree.h
• binary_tree.cc