oomph::QuadTreeForest Class Reference

#include <quadtree.h>

Inheritance diagram for oomph::QuadTreeForest:

Public Member Functions
	QuadTreeForest ()
	Default constructor (empty and broken) More...
	QuadTreeForest (Vector< TreeRoot * > &trees_pt)
	QuadTreeForest (const QuadTreeForest &dummy)=delete
	Broken copy constructor. More...
void	operator= (const QuadTreeForest &)=delete
	Broken assignment operator. More...
virtual	~QuadTreeForest ()
void	check_all_neighbours (DocInfo &doc_info)
void	open_hanging_node_files (DocInfo &doc_info, Vector< std::ofstream * > &output_stream)
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	construct_north_equivalents ()
	Construct the rotation schemes. More...
void	find_neighbours ()
	Construct the neighbour lookup scheme. More...
QuadTreeRoot *	quadtree_pt (const unsigned &i)
QuadTreeRoot *	quad_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 QuadTreeForest consists of a collection of QuadTreeRoots. Each member tree can have neighbours to its S/W/N/E and the orientation of their compasses can differ, allowing for complex, unstructured meshes.

Constructor & Destructor Documentation

QuadTreeForest() [1/3]

oomph::QuadTreeForest::QuadTreeForest ( )

inline

Default constructor (empty and broken)

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

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

QuadTreeForest() [2/3]

oomph::QuadTreeForest::QuadTreeForest

(

Vector< TreeRoot * > &

trees_pt

)

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

Constructor for QuadTreeForest:

Pass:

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

Note that the pointers to the neighbour's of each tree must have been allocated before the constructor is called, otherwise the relative rotation scheme will not be constructed correctly.

    : TreeForest(trees_pt)
  {
#ifdef LEAK_CHECK
    LeakCheckNames::QuadTreeForest_build += 1;
#endif
 
    // Don't setup neighbours etc. if forest is empty
    if (trees_pt.size() == 0)
    {
      return;
    }
 
    using namespace QuadTreeNames;
 
    // Setup the neighbours
    find_neighbours();
 
    // Construct the rotation scheme, note that all neighbour pointers must
    // be set before the constructor is called
    construct_north_equivalents();
  }

References construct_north_equivalents(), and find_neighbours().

QuadTreeForest() [3/3]

oomph::QuadTreeForest::QuadTreeForest ( const QuadTreeForest &  dummy )

delete

Broken copy constructor.

~QuadTreeForest()

virtual oomph::QuadTreeForest::~QuadTreeForest ( )

inlinevirtual

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

{}

Member Function Documentation

check_all_neighbours()

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

virtual

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.

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

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;
    QuadTree::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 quadtree 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 quadtree neighbour finding: " << max_error
                 << " is OK" << std::endl;
      oomph_info
        << "i.e. less than QuadTree::max_neighbour_finding_tolerance()="
        << QuadTree::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::QuadTree::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().

construct_north_equivalents()

void oomph::QuadTreeForest::construct_north_equivalents ( )

private

Construct the rotation schemes.

Construct the rotation scheme for the quadtree forest. Note that all pointers to neighbours must have been allocated for this to work.

  {
    using namespace QuadTreeNames;
 
    unsigned numtrees = ntree();
    // Loop over all the trees
    for (unsigned i = 0; i < numtrees; i++)
    {
      // Find the pointer to the northern neighbour
      QuadTreeRoot* neigh_pt = quad_neigh_pt(i, N);
      // If there is a neighbour
      if (neigh_pt != 0)
      {
        // Find the direction of the present tree, as viewed from the neighbour
        int direction = neigh_pt->direction_of_neighbour(quadtree_pt(i));
 
        // Set up the rotation scheme
        switch (direction)
        {
            // If N neighbour has this tree on S, north equivalent is N
          case S:
            quadtree_pt(i)->north_equivalent(N) = N;
            break;
            // If N neighbour has this tree on W, north equivalent is E
          case W:
            quadtree_pt(i)->north_equivalent(N) = E;
            break;
            // If N neighbour has this tree on N, north equivalent is S
          case N:
            quadtree_pt(i)->north_equivalent(N) = S;
            break;
            // If N neighbour has this tree on E, north equivalent is W
          case E:
            quadtree_pt(i)->north_equivalent(N) = W;
            break;
            // If N neighbour does not have pointer to this tree, die
          default:
            std::ostringstream error_stream;
            error_stream
              << "Tree " << i
              << "'s Northern neighbour has no neighbour pointer to Tree " << i
              << std::endl;
 
            throw OomphLibError(error_stream.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
        }
      }
 
      // Find the pointer to the eastern neighbour
      neigh_pt = quad_neigh_pt(i, E);
      // If there is a neighbour
      if (neigh_pt != 0)
      {
        // Find the direction of the present tree, as viewed from the neighbour
        int direction = neigh_pt->direction_of_neighbour(quadtree_pt(i));
 
        // Set up the rotation scheme
        switch (direction)
        {
            // If E neighbour has this tree on W, north equivalent is N
          case W:
            quadtree_pt(i)->north_equivalent(E) = N;
            break;
            // If E neighbour has this tree on N, north equivalent is E
          case N:
            quadtree_pt(i)->north_equivalent(E) = E;
            break;
            // If E neighbour has this tree on E, north equivalent is S
          case E:
            quadtree_pt(i)->north_equivalent(E) = S;
            break;
            // If E neighbour has this tree on S, north equivalent is W
          case S:
            quadtree_pt(i)->north_equivalent(E) = W;
            break;
            // If E neighbour does not have pointer to this tree, die
          default:
            std::ostringstream error_stream;
            error_stream
              << "Tree " << i
              << "'s Eastern neighbour has no neighbour pointer to Tree " << i
              << std::endl;
 
            throw OomphLibError(error_stream.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
        }
      }
 
      // Find the pointer to the southern neighbour
      neigh_pt = quad_neigh_pt(i, S);
      // If there is a neighbour
      if (neigh_pt != 0)
      {
        // Find the direction of the present tree, as viewed from the neighbour
        int direction = neigh_pt->direction_of_neighbour(quadtree_pt(i));
 
        // Set up the rotation scheme
        switch (direction)
        {
            // If S neighbour has this tree on N, north equivalent is N
          case N:
            quadtree_pt(i)->north_equivalent(S) = N;
            break;
            // If S neighbour has this tree on E, north equivalent is E
          case E:
            quadtree_pt(i)->north_equivalent(S) = E;
            break;
            // If S neighbour has this tree on S, north equivalent is S
          case S:
            quadtree_pt(i)->north_equivalent(S) = S;
            break;
            // If S neighbour has this tree on W, north equivalent is W
          case W:
            quadtree_pt(i)->north_equivalent(S) = W;
            break;
            // If S neighbour does not have pointer to this tree, die
          default:
            std::ostringstream error_stream;
            error_stream
              << "Tree " << i
              << "'s Southern neighbour has no neighbour pointer to Tree " << i
              << std::endl;
 
            throw OomphLibError(error_stream.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
        }
      }
 
      // Find the pointer to the western neighbour
      neigh_pt = quad_neigh_pt(i, W);
      // If there is a neighbour
      if (neigh_pt != 0)
      {
        // Find the direction of the present tree, as viewed from the neighbour
        int direction = neigh_pt->direction_of_neighbour(quadtree_pt(i));
 
        // Set up the rotation scheme
        switch (direction)
        {
            // If W neighbour has this tree on E, north equivalent is N
          case E:
            quadtree_pt(i)->north_equivalent(W) = N;
            break;
            // If W neighbour has this tree on S, north equivalent is E
          case S:
            quadtree_pt(i)->north_equivalent(W) = E;
            break;
            // If W neighbour has this tree on W, north equivalent is S
          case W:
            quadtree_pt(i)->north_equivalent(W) = S;
            break;
            // If W neighbour has this tree on N, north equivalent is W
          case N:
            quadtree_pt(i)->north_equivalent(W) = W;
            break;
            // If W neighbour does not have pointer to this tree, die
          default:
            std::ostringstream error_stream;
            error_stream
              << "Tree " << i
              << "'s Western neighbour has no neighbour pointer to Tree " << i
              << std::endl;
 
            throw OomphLibError(error_stream.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
        }
      }
    }
  }

References oomph::QuadTreeRoot::direction_of_neighbour(), Global_Physical_Variables::E, i, N, oomph::QuadTreeRoot::north_equivalent(), oomph::TreeForest::ntree(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, quad_neigh_pt(), quadtree_pt(), oomph::QuadTreeNames::S, and oomph::QuadTreeNames::W.

Referenced by QuadTreeForest().

find_neighbours()

void oomph::QuadTreeForest::find_neighbours ( )

private

Construct the neighbour lookup scheme.

Setup the neighbour lookup schemes for all constituent quadtrees.

  {
    using namespace QuadTreeNames;
 
    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: 4
    unsigned n_vertex_node = 4;
 
    // Find potentially 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<QuadElementBase*>(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 potentially neighbouring trees
    // i.e. trees that share at least one node
    Vector<std::set<unsigned>> potentially_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 potentially connected
          if (i != j)
          {
            potentially_neighb_tree[i].insert(j);
          }
        }
      }
    }
 
 
    // Loop over all trees
    for (unsigned i = 0; i < numtrees; i++)
    {
      // Loop over their potential neighbours
      for (std::set<unsigned>::iterator it = potentially_neighb_tree[i].begin();
           it != potentially_neighb_tree[i].end();
           it++)
      {
        unsigned j = (*it);
 
        // is it the Northern neighbour ?
        bool is_N_neighbour =
          ((Trees_pt[j]->object_pt()->get_node_number(
              Trees_pt[i]->object_pt()->node_pt(n * (n - 1))) != -1) &&
           (Trees_pt[j]->object_pt()->get_node_number(
              Trees_pt[i]->object_pt()->node_pt(n * n - 1)) != -1));
 
 
        // is it the Southern neighbour ?
        bool is_S_neighbour =
          ((Trees_pt[j]->object_pt()->get_node_number(
              Trees_pt[i]->object_pt()->node_pt(0)) != -1) &&
           (Trees_pt[j]->object_pt()->get_node_number(
              Trees_pt[i]->object_pt()->node_pt(n - 1)) != -1));
 
 
        // is it the Eastern neighbour ?
        bool is_E_neighbour =
          ((Trees_pt[j]->object_pt()->get_node_number(
              Trees_pt[i]->object_pt()->node_pt(n - 1)) != -1) &&
           (Trees_pt[j]->object_pt()->get_node_number(
              Trees_pt[i]->object_pt()->node_pt(n * n - 1)) != -1));
 
        // is it the Western neighbour ?
        bool is_W_neighbour =
          ((Trees_pt[j]->object_pt()->get_node_number(
              Trees_pt[i]->object_pt()->node_pt(0)) != -1) &&
           (Trees_pt[j]->object_pt()->get_node_number(
              Trees_pt[i]->object_pt()->node_pt(n * (n - 1))) != -1));
 
 
        if (is_N_neighbour) Trees_pt[i]->neighbour_pt(N) = Trees_pt[j];
        if (is_S_neighbour) Trees_pt[i]->neighbour_pt(S) = Trees_pt[j];
        if (is_E_neighbour) Trees_pt[i]->neighbour_pt(E) = Trees_pt[j];
        if (is_W_neighbour) Trees_pt[i]->neighbour_pt(W) = Trees_pt[j];
      }
    }
 
 
    // Old hacky version with horrendous scaling
    if (false)
    {
      // Loop over all trees
      for (unsigned i = 0; i < numtrees; i++)
      {
        // Loop over all the other elements
        for (unsigned j = 0; j < numtrees; j++)
        {
          if (j != i) // make sure we are not looking at the element itself
          {
            // is it the Northern neighbour ?
            bool is_N_neighbour =
              ((Trees_pt[j]->object_pt()->get_node_number(
                  Trees_pt[i]->object_pt()->node_pt(n * (n - 1))) != -1) &&
               (Trees_pt[j]->object_pt()->get_node_number(
                  Trees_pt[i]->object_pt()->node_pt(n * n - 1)) != -1));
 
 
            // is it the Southern neighbour ?
            bool is_S_neighbour =
              ((Trees_pt[j]->object_pt()->get_node_number(
                  Trees_pt[i]->object_pt()->node_pt(0)) != -1) &&
               (Trees_pt[j]->object_pt()->get_node_number(
                  Trees_pt[i]->object_pt()->node_pt(n - 1)) != -1));
 
 
            // is it the Eastern neighbour ?
            bool is_E_neighbour =
              ((Trees_pt[j]->object_pt()->get_node_number(
                  Trees_pt[i]->object_pt()->node_pt(n - 1)) != -1) &&
               (Trees_pt[j]->object_pt()->get_node_number(
                  Trees_pt[i]->object_pt()->node_pt(n * n - 1)) != -1));
 
            // is it the Western neighbour ?
            bool is_W_neighbour =
              ((Trees_pt[j]->object_pt()->get_node_number(
                  Trees_pt[i]->object_pt()->node_pt(0)) != -1) &&
               (Trees_pt[j]->object_pt()->get_node_number(
                  Trees_pt[i]->object_pt()->node_pt(n * (n - 1))) != -1));
 
 
            if (is_N_neighbour) Trees_pt[i]->neighbour_pt(N) = Trees_pt[j];
            if (is_S_neighbour) Trees_pt[i]->neighbour_pt(S) = Trees_pt[j];
            if (is_E_neighbour) Trees_pt[i]->neighbour_pt(E) = Trees_pt[j];
            if (is_W_neighbour) Trees_pt[i]->neighbour_pt(W) = Trees_pt[j];
          }
        }
      }
    }
  }

References Global_Physical_Variables::E, i, j, n, N, oomph::TreeForest::ntree(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::QuadTreeNames::S, oomph::TreeForest::Trees_pt, and oomph::QuadTreeNames::W.

Referenced by QuadTreeForest().

open_hanging_node_files()

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

virtual

Open output files that will store any hanging nodes in the forest and return a vector of the streams.

Open output files that will stored any hanging nodes that are

created in the mesh refinement process.

Implements oomph::TreeForest.

  {
    // In 2D, there will be four output files
    for (unsigned i = 0; i < 4; i++)
    {
      output_stream.push_back(new std::ofstream);
    }
 
    // If we are documenting the output, open the files
    if (doc_info.is_doc_enabled())
    {
      std::ostringstream fullname;
      fullname << doc_info.directory() << "/hang_nodes_s" << doc_info.number()
               << ".dat";
      output_stream[0]->open(fullname.str().c_str());
      fullname.str("");
      fullname << doc_info.directory() << "/hang_nodes_n" << doc_info.number()
               << ".dat";
      output_stream[1]->open(fullname.str().c_str());
      fullname.str("");
      fullname << doc_info.directory() << "/hang_nodes_w" << doc_info.number()
               << ".dat";
      output_stream[2]->open(fullname.str().c_str());
      fullname.str("");
      fullname << doc_info.directory() << "/hang_nodes_e" << doc_info.number()
               << ".dat";
      output_stream[3]->open(fullname.str().c_str());
    }
  }

References oomph::DocInfo::directory(), i, oomph::DocInfo::is_doc_enabled(), and oomph::DocInfo::number().

operator=()

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

delete

Broken assignment operator.

quad_neigh_pt()

QuadTreeRoot* oomph::QuadTreeForest::quad_neigh_pt ( const unsigned &  i, const int &  direction  )

inlineprivate

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

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

References i.

Referenced by construct_north_equivalents().

quadtree_pt()

QuadTreeRoot* oomph::QuadTreeForest::quadtree_pt ( const unsigned &  i )

inlineprivate

Return pointer to i-th root quadtree in this forest. (Performs a dynamic cast from the TreeRoot to a QuadTreeRoot).

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

References i.

Referenced by construct_north_equivalents().

self_test()

unsigned oomph::QuadTreeForest::self_test

(

)

Self-test: Check all neighbours. Return success (0) if the max. distance between corresponding points in the neighbours is less than the tolerance specified in the static value QuadTree::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 neigbour. 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;
    QuadTree::doc_neighbours(
      all_forest_nodes_pt, neighbours_file, neighbours_txt_file, max_error);
    if (max_error > QuadTree::max_neighbour_finding_tolerance())
    {
      oomph_info << "\n \n Failed self_test() for QuadTree: Max. error "
                 << max_error << std::endl
                 << std::endl;
      return 1;
    }
    else
    {
      oomph_info << "\n \n Passed self_test() for QuadTree: Max. error "
                 << max_error << std::endl
                 << std::endl;
      return 0;
    }
  }

References oomph::QuadTree::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:

• quadtree.h
• quadtree.cc