oomph::BinaryTreeForest Class Reference

#include <binary_tree.h>

Inheritance diagram for oomph::BinaryTreeForest:

Public Member Functions
	BinaryTreeForest ()
	Default constructor (empty and broken) More...
	BinaryTreeForest (Vector< TreeRoot * > &trees_pt)
	BinaryTreeForest (const BinaryTreeForest &dummy)=delete
	Broken copy constructor. More...
void	operator= (const BinaryTreeForest &)=delete
	Broken assignment operator. More...
virtual	~BinaryTreeForest ()
void	check_all_neighbours (DocInfo &doc_info)
	Document and check all the neighbours in all the nodes in the forest. More...
void	open_hanging_node_files (DocInfo &doc_info, Vector< std::ofstream * > &output_stream)
	A line mesh cannot have hanging nodes so make this function empty. More...
unsigned	self_test ()
Public Member Functions inherited from oomph::TreeForest
	TreeForest (Vector< TreeRoot * > &trees_pt)
	TreeForest ()
	Default constructor (empty and broken) More...
	TreeForest (const TreeForest &dummy)=delete
	Broken copy constructor. More...
void	operator= (const TreeForest &)=delete
	Broken assignment operator. More...
virtual	~TreeForest ()
	Kill tree forest: Delete the constituent trees. More...
void	stick_leaves_into_vector (Vector< Tree * > &forest_nodes)
	Traverse forst and stick pointers to leaf "nodes" into Vector. More...
void	stick_all_tree_nodes_into_vector (Vector< Tree * > &all_forest_nodes)
	Traverse forest and stick pointers to all "nodes" into Vector. More...
void	close_hanging_node_files (DocInfo &doc_info, Vector< std::ofstream * > &output_stream)
unsigned	ntree ()
	Number of trees in forest. More...
TreeRoot *	tree_pt (const unsigned &i) const
	Return pointer to i-th tree in forest. More...
void	flush_trees ()
	Flush trees from forest. More...

Private Member Functions
void	find_neighbours ()
	Construct the neighbour lookup scheme. More...
BinaryTreeRoot *	binary_tree_pt (const unsigned &i)
BinaryTreeRoot *	binary_neigh_pt (const unsigned &i, const int &direction)

Additional Inherited Members
Protected Attributes inherited from oomph::TreeForest
Vector< TreeRoot * >	Trees_pt
	Vector containing the pointers to the trees. More...

Detailed Description

A BinaryTreeForest consists of a collection of BinaryTreeRoots. Each member tree can have neighbours to its left and right.

Constructor & Destructor Documentation

BinaryTreeForest() [1/3]

oomph::BinaryTreeForest::BinaryTreeForest ( )

inline

Default constructor (empty and broken)

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

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

BinaryTreeForest() [2/3]

oomph::BinaryTreeForest::BinaryTreeForest

(

Vector< TreeRoot * > &

trees_pt

)

Constructor: Pass vector of pointers to the roots of the constituent BinaryTrees

Constructor for BinaryTreeForest:

Pass:

• trees_pt[], the Vector of pointers to the constituent trees (BinaryTreeRoot objects)

    : TreeForest(trees_pt)
  {
#ifdef LEAK_CHECK
    LeakCheckNames::BinaryTreeForest_build += 1;
#endif
 
    using namespace BinaryTreeNames;
 
    // Set up the neighbours
    find_neighbours();
  }

References find_neighbours().

BinaryTreeForest() [3/3]

oomph::BinaryTreeForest::BinaryTreeForest ( const BinaryTreeForest &  dummy )

delete

Broken copy constructor.

~BinaryTreeForest()

virtual oomph::BinaryTreeForest::~BinaryTreeForest ( )

inlinevirtual

Destructor: Delete the constituent binary trees (and thus the objects associated with its non-leaf nodes!)

{}

Member Function Documentation

binary_neigh_pt()

BinaryTreeRoot* oomph::BinaryTreeForest::binary_neigh_pt ( const unsigned &  i, const int &  direction  )

inlineprivate

Given the number i of the root binary tree in this forest, return a pointer to its neighbour in the specified direction. NULL if neighbour doesn't exist. (This does the dynamic cast from a TreeRoot to a BinaryTreeRoot internally).

    {
      return dynamic_cast<BinaryTreeRoot*>(
        Trees_pt[i]->neighbour_pt(direction));
    }

References i.

binary_tree_pt()

BinaryTreeRoot* oomph::BinaryTreeForest::binary_tree_pt ( const unsigned &  i )

inlineprivate

Return pointer to i-th root binary tree in this forest (performs a dynamic cast from the TreeRoot to a BinaryTreeRoot).

    {
      return dynamic_cast<BinaryTreeRoot*>(Trees_pt[i]);
    }

References i.

check_all_neighbours()

void oomph::BinaryTreeForest::check_all_neighbours ( DocInfo &  doc_info )

virtual

Document and check all the neighbours in all the nodes in the forest.

Document and check all the neighbours of all the nodes in the forest. DocInfo object specifies the output directory and file numbers for the various files. If doc_info.disable_doc() has been called, no output is created.

Implements oomph::TreeForest.

  {
    // Create Vector of elements
    Vector<Tree*> all_tree_nodes_pt;
    this->stick_all_tree_nodes_into_vector(all_tree_nodes_pt);
 
    // Create storage for information files
    std::ofstream neigh_file;
    std::ofstream neigh_txt_file;
 
    // If we are documenting the results, then open the files
    if (doc_info.is_doc_enabled())
    {
      std::ostringstream fullname;
      fullname << doc_info.directory() << "/neighbours" << doc_info.number()
               << ".dat";
      oomph_info << "opened " << fullname.str() << " to doc neighbours"
                 << std::endl;
      neigh_file.open(fullname.str().c_str());
      fullname.str("");
      fullname << doc_info.directory() << "/neighbours" << doc_info.number()
               << ".txt";
      oomph_info << "opened " << fullname.str() << " to doc neighbours"
                 << std::endl;
      neigh_txt_file.open(fullname.str().c_str());
    }
 
    // Call the standard documentation function
    double max_error = 0.0;
    BinaryTree::doc_neighbours(
      all_tree_nodes_pt, neigh_file, neigh_txt_file, max_error);
 
    // If the error is too large, complain
    if (max_error > Tree::max_neighbour_finding_tolerance())
    {
      std::ostringstream error_stream;
      error_stream << "Max. error in binary tree neighbour finding: "
                   << max_error << " is too big" << std::endl;
      error_stream
        << "i.e. bigger than Tree::max_neighbour_finding_tolerance()="
        << Tree::max_neighbour_finding_tolerance() << std::endl;
 
      // Close the files if they were opened
      if (doc_info.is_doc_enabled())
      {
        neigh_file.close();
        neigh_txt_file.close();
      }
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
    else
    {
      oomph_info << "Max. error in binary tree neighbour finding: " << max_error
                 << " is OK" << std::endl;
      oomph_info
        << "i.e. less than BinaryTree::max_neighbour_finding_tolerance()="
        << BinaryTree::max_neighbour_finding_tolerance() << std::endl;
    }
 
    // Close the files if they were opened
    if (doc_info.is_doc_enabled())
    {
      neigh_file.close();
      neigh_txt_file.close();
    }
  }

References oomph::DocInfo::directory(), oomph::BinaryTree::doc_neighbours(), oomph::DocInfo::is_doc_enabled(), MeshRefinement::max_error, oomph::Tree::max_neighbour_finding_tolerance(), oomph::DocInfo::number(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, and oomph::TreeForest::stick_all_tree_nodes_into_vector().

find_neighbours()

void oomph::BinaryTreeForest::find_neighbours ( )

private

Construct the neighbour lookup scheme.

Set up the neighbour lookup schemes for all constituent binary trees.

  {
    using namespace BinaryTreeNames;
 
    unsigned numtrees = ntree();
    unsigned n = 0; // to store nnode1d
    if (numtrees > 0)
    {
      n = Trees_pt[0]->object_pt()->nnode_1d();
    }
    else
    {
      throw OomphLibError(
        "Trying to setup the neighbour scheme for an empty forest\n",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
 
    // Number of vertex nodes: 2
    unsigned n_vertex_node = 2;
 
    // Find connected trees by identifying those whose associated elements
    // share a common vertex node
    std::map<Node*, std::set<unsigned>> tree_assoc_with_vertex_node;
 
    // Loop over all trees
    for (unsigned i = 0; i < numtrees; i++)
    {
      // Loop over the vertex nodes of the associated element
      for (unsigned j = 0; j < n_vertex_node; j++)
      {
        Node* nod_pt = dynamic_cast<LineElementBase*>(Trees_pt[i]->object_pt())
                         ->vertex_node_pt(j);
        tree_assoc_with_vertex_node[nod_pt].insert(i);
      }
    }
 
    // For each tree we store a set of neighbouring trees
    // i.e. trees that share a node
    Vector<std::set<unsigned>> neighb_tree(numtrees);
 
    // Loop over vertex nodes
    for (std::map<Node*, std::set<unsigned>>::iterator it =
           tree_assoc_with_vertex_node.begin();
         it != tree_assoc_with_vertex_node.end();
         it++)
    {
      // Loop over connected elements twice
      for (std::set<unsigned>::iterator it_el1 = it->second.begin();
           it_el1 != it->second.end();
           it_el1++)
      {
        unsigned i = (*it_el1);
        for (std::set<unsigned>::iterator it_el2 = it->second.begin();
             it_el2 != it->second.end();
             it_el2++)
        {
          unsigned j = (*it_el2);
          // These two elements are connected
          if (i != j)
          {
            neighb_tree[i].insert(j);
          }
        }
      }
    }
 
    // Loop over all trees
    for (unsigned i = 0; i < numtrees; i++)
    {
      // Loop over their neighbours
      for (std::set<unsigned>::iterator it = neighb_tree[i].begin();
           it != neighb_tree[i].end();
           it++)
      {
        unsigned j = (*it);
 
        // is it the left-hand neighbour?
        bool is_L_neighbour = Trees_pt[j]->object_pt()->get_node_number(
                                Trees_pt[i]->object_pt()->node_pt(0)) != -1;
 
        // is it the right-hand neighbour?
        bool is_R_neighbour = Trees_pt[j]->object_pt()->get_node_number(
                                Trees_pt[i]->object_pt()->node_pt(n - 1)) != -1;
 
        if (is_L_neighbour) Trees_pt[i]->neighbour_pt(L) = Trees_pt[j];
        if (is_R_neighbour) Trees_pt[i]->neighbour_pt(R) = Trees_pt[j];
      }
    } // End of loop over all trees
  }

References i, j, L, n, oomph::TreeForest::ntree(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, R, and oomph::TreeForest::Trees_pt.

Referenced by BinaryTreeForest().

open_hanging_node_files()

void oomph::BinaryTreeForest::open_hanging_node_files ( DocInfo &  doc_info, Vector< std::ofstream * > &  output_stream  )

inlinevirtual

A line mesh cannot have hanging nodes so make this function empty.

Implements oomph::TreeForest.

    {
    }

operator=()

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

delete

Broken assignment operator.

self_test()

unsigned oomph::BinaryTreeForest::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_forest_nodes_pt;
    stick_all_tree_nodes_into_vector(all_forest_nodes_pt);
    long int count = 0;
    unsigned long num_nodes = all_forest_nodes_pt.size();
    for (unsigned long i = 0; i < num_nodes; i++)
    {
      all_forest_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_forest_nodes_pt, neighbours_file, neighbours_txt_file, max_error);
    if (max_error > BinaryTree::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 oomph::BinaryTree::doc_neighbours(), i, MeshRefinement::max_error, oomph::Tree::max_neighbour_finding_tolerance(), oomph::oomph_info, and oomph::TreeForest::stick_all_tree_nodes_into_vector().

---

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

• binary_tree.h
• binary_tree.cc