#include <tree.h>

Inheritance diagram for oomph::Tree:

Public Types
typedef void(Tree::*	VoidMemberFctPt) ()
	Function pointer to argument-free void Tree member function. More...

typedef void(Tree::*	VoidMeshPtArgumentMemberFctPt) (Mesh *&mesh_pt)

Public Member Functions
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...

virtual Tree *	construct_son (RefineableElement const &object_pt, Tree const &father_pt, const int &son_type)=0

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 double &	max_neighbour_finding_tolerance ()

Static Public Attributes
static const int	OMEGA = 26
	Default value for an unassigned neighbour. More...

Protected Member Functions
	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)

Protected Attributes
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...

Static Protected Attributes
static double	Max_neighbour_finding_tolerance = 1.0e-14

Detailed Description

A generalised tree base class that abstracts the common functionality between the quad- and octrees used in mesh adaptation in two and three dimensions, respectively.

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

The objects contained in the tree must be RefineableElements.

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 Trees are only generated by splitting existing Trees. Therefore, the constructors are protected. The only Tree that "Joe User" can create is the (derived) class TreeRoot.

Member Typedef Documentation

◆ VoidMemberFctPt

typedef void(Tree::* oomph::Tree::VoidMemberFctPt) ()

Function pointer to argument-free void Tree member function.

◆ VoidMeshPtArgumentMemberFctPt

typedef void(Tree::* oomph::Tree::VoidMeshPtArgumentMemberFctPt) (Mesh *&mesh_pt)

Function pointer to a void Tree member function that takes a pointer to a mesh as its argument

Constructor & Destructor Documentation

◆ ~Tree()

oomph::Tree::~Tree ( )

virtual

Destructor. Note: Deleting a tree also deletes the objects associated with its non-leave nodes.

Destructor for Tree: Recursively kill all sons and the associated objects of the non-leaf nodes. However, the objects of the leaf nodes are not destroyed. Their destruction is handled by the Mesh destructor.

   {
     // Loop over all the sons and delete them
     unsigned nsons = Son_pt.size();
     for (unsigned i = 0; i < nsons; i++)
     {
       // This will call the son's destructor (a subtle recursion)
       delete Son_pt[i];
       Son_pt[i] = 0;
     }
  
     // Delete the object only if the Tree has sons (is not a leaf node)
     if (nsons > 0)
     {
       delete Object_pt;
       Object_pt = 0;
     }
   }

References i, nsons(), Object_pt, and Son_pt.

◆ Tree() [1/4]

oomph::Tree::Tree ( const Tree & dummy )

delete

Broken copy constructor.

◆ Tree() [2/4]

oomph::Tree::Tree ( )

inlineprotected

Default constructor (empty and broken)

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

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ Tree() [3/4]

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

protected

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

Constructor for empty (root) Tree: No father, no sons. Pass pointer to the object that this tree (root) contains. Protected because Trees can only be created internally, during the split operation.

                                                 : Object_pt(object_pt)
   {
     // No father node:
     Father_pt = 0;
  
     // I'm not a son, so I don't have a son type either....
     Son_type = OMEGA;
  
     // I am the root
     Level = 0;
  
     // Root pointer must be set in the TreeRoot constructor
     Root_pt = 0;
  
     // No sons just yet:
     Son_pt.resize(0);
  
     // Tell the object which tree it's represented by
     object_pt->set_tree_pt(this);
   };

References Father_pt, Level, object_pt(), OMEGA, Root_pt, oomph::RefineableElement::set_tree_pt(), Son_pt, and Son_type.

◆ Tree() [4/4]

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

protected

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 it is. Protected because Trees can only be created internally, during the split operation. Only TreeRoots can be created externally.

Constructor for Tree: This one has a father and is a son of a certain type, but has no sons of its own (just yet), so it's a leaf node. Protected because Trees can only be created internally, during the split operation.

     : Object_pt(object_pt)
   {
     // Set the father node
     Father_pt = father_pt;
  
     // Set the son type
     Son_type = son_type;
  
     // My level is one deeper than that of my father
     Level = father_pt->Level + 1;
  
     // I have no sons of my own just yet:
     Son_pt.resize(0);
  
     // Inherit root pointer from father
     Root_pt = father_pt->Root_pt;
  
     // Tell the object which tree it's represented by
     object_pt->set_tree_pt(this);
   }

References father_pt(), Father_pt, Level, object_pt(), Root_pt, oomph::RefineableElement::set_tree_pt(), Son_pt, son_type(), and Son_type.

Member Function Documentation

◆ construct_son()

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

pure virtual

A function that constructs a specific type of tree. This MUST be overloaded for each specific tree type. The use of such a function allows the generic implementation of split_if_required().

Implemented in oomph::QuadTree, oomph::OcTree, and oomph::BinaryTree.

Referenced by split_if_required().

◆ deactivate_object()

void oomph::Tree::deactivate_object ( )

Call the RefineableElement's deactivate_element() function.

Call the RefineableElement's deactivate_element() function that is used to perform any final changes to internal data storage of deactivated objects.

   {
     // Call the function
     object_pt()->deactivate_element();
   }

References oomph::RefineableElement::deactivate_element(), and object_pt().

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), and oomph::TreeBasedRefineableMeshBase::p_adapt_mesh().

◆ father_pt()

Tree* oomph::Tree::father_pt ( ) const

inline

Return pointer to father: NULL if it's a root node.

     {
       return Father_pt;
     }

References Father_pt.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), oomph::BinaryTree::construct_son(), oomph::OcTree::construct_son(), oomph::QuadTree::construct_son(), oomph::RefineableElement::father_element_pt(), oomph::RefineableLinearisedAxisymmetricQCrouzeixRaviartElement::further_build(), oomph::RefineableAxisymmetricQCrouzeixRaviartElement::further_build(), oomph::RefineableGeneralisedNewtonianAxisymmetricQCrouzeixRaviartElement::further_build(), oomph::RefineableLinearisedQCrouzeixRaviartElement::further_build(), oomph::RefineablePolarCrouzeixRaviartElement::further_build(), oomph::RefineableQSphericalCrouzeixRaviartElement::further_build(), oomph::RefineableElement::get_father_at_refinement_level(), oomph::TreeBasedRefineableMeshBase::refine_as_in_reference_mesh(), set_father_pt(), split_if_required(), and Tree().

◆ flush_object()

void oomph::Tree::flush_object ( )

inline

Flush the object represented by the tree.

     {
       Object_pt = 0;
     }

References Object_pt.

◆ flush_sons()

void oomph::Tree::flush_sons ( )

inline

Flush the sons.

     {
       Son_pt.clear();
     }

References Son_pt.

Referenced by oomph::RefineableBrickMesh< ELEMENT >::setup_octree_forest(), and oomph::RefineableQuadMesh< ELEMENT >::setup_quadtree_forest().

◆ is_leaf()

bool oomph::Tree::is_leaf ( )

inline

Return true if the tree is a leaf node.

     {
       // If there are no sons, it's a leaf, return true
       if (Son_pt.size() == 0)
       {
         return true;
       }
       // Otherwise return false
       else
       {
         return false;
       }
     }

References Son_pt.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), oomph::OcTree::doc_true_edge_neighbours(), and oomph::TreeBasedRefineableMeshBase::refine_as_in_reference_mesh().

◆ level()

unsigned oomph::Tree::level ( ) const

inline

Return the level of the Tree (root=0)

     {
       return Level;
     }

References Level.

Referenced by OscRingNStProblem< ELEMENT >::doc_solution(), and OscRingNStProblem< ELEMENT >::doc_solution_historic().

◆ max_neighbour_finding_tolerance()

static double& oomph::Tree::max_neighbour_finding_tolerance ( )

inlinestatic

Max. allowed discrepancy in neighbour finding routine (distance between points when identified from two neighbouring elements)

     {
       return Max_neighbour_finding_tolerance;
     }

References Max_neighbour_finding_tolerance.

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

◆ merge_sons_if_required()

void oomph::Tree::merge_sons_if_required ( Mesh *& mesh_pt )

If required, merge the four sons for unrefinement – criterion: bool object_pt()-> sons_to_be_unrefined() = true

If required, kill the sons to perform unrefinement.

Unrefinement is performed if

 object_pt()->sons_to_be_unrefined()

returns true.

   {
     // Check if unrefinement is required
     if (Object_pt->sons_to_be_unrefined())
     {
       // Rebuild the father from sons
       object_pt()->rebuild_from_sons(mesh_pt);
  
       // Find the number of sons
       unsigned n_sons = nsons();
       // Kill all the sons
       for (unsigned ison = 0; ison < n_sons; ison++)
       {
         // Unbuild the element by marking the nodes as obsolete
         son_pt(ison)->object_pt()->unbuild();
  
         // Delete the object. This must be done here, because the
         // destructor of a tree does not delete the leaf nodes
         // (the actual elements that are used in the mesh).
         // In general, the destruction of the leaf nodes is handled by the
         // mesh destructors.
         delete son_pt(ison)->object_pt();
  
         // Now delete the tree representation
         delete son_pt(ison);
       }
  
       Son_pt.resize(0);
  
       // Have merged my sons -- can't do it again...
       Object_pt->deselect_sons_for_unrefinement();
     }
   }

References oomph::RefineableElement::deselect_sons_for_unrefinement(), nsons(), object_pt(), Object_pt, oomph::RefineableElement::rebuild_from_sons(), son_pt(), Son_pt, oomph::RefineableElement::sons_to_be_unrefined(), and oomph::RefineableElement::unbuild().

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh().

◆ nsons()

unsigned oomph::Tree::nsons ( ) const

inline

Return number of sons (zero if it's a leaf node)

     {
       return Son_pt.size();
     }

References Son_pt.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::check_integrity(), merge_sons_if_required(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::node_created_by_son_of_neighbour(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::node_created_by_son_of_neighbour(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::oc_hang_helper(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::quad_hang_helper(), oomph::TreeBasedRefineableMeshBase::refine_as_in_reference_mesh(), oomph::RefineableBrickMesh< ELEMENT >::setup_octree_forest(), oomph::RefineableQuadMesh< ELEMENT >::setup_quadtree_forest(), oomph::TreeForest::stick_all_tree_nodes_into_vector(), oomph::TreeForest::stick_leaves_into_vector(), and ~Tree().

◆ object_pt()

RefineableElement* oomph::Tree::object_pt ( ) const

inline

Return the pointer to the object (RefineableElement) represented by the tree

     {
       return Object_pt;
     }

References Object_pt.

◆ operator=()

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

delete

Broken assignment operator.

◆ p_refine_if_required()

template<class ELEMENT >

void oomph::Tree::p_refine_if_required ( Mesh *& mesh_pt )

If required, p-refine the leaf – criterion: bool object_pt()-> to_be_p_refined() = true or bool object_pt()-> to_be_p_unrefined() = true

If required, p-refine/unrefine the leaf element

p-refinement is performed if

 object_pt()->to_be_p_refined()

returns true. p-unrefinement is performed if

 object_pt()->to_be_p_unrefined()

returns true.

If this is the case, then we execute

 object_pt()->p_refine(+/-1,mesh_pt,clone_pt)

to p-refine the element, where mesh_pt is a pointer to the mesh that the element lives in, and clone_pt is a pointer to a GeneralisedElement that has all the information that would be needed from the father element during h-refinement.

   {
 #ifdef PARANOID
     if (Son_pt.size() != 0)
     {
       std::string error_message =
         "Can't p-refine non-leaf elements (or at least I can't see\n";
       error_message +=
         "why you would want me to... If you're sure, then hack me... \n";
  
       throw OomphLibError(
         error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     if (Object_pt == 0)
     {
       std::stringstream error_message;
       error_message
         << "No object defined in p_refine_if_required. Father nodes:\n";
  
       RefineableElement* el_pt = Father_pt->object_pt();
       unsigned nnod = el_pt->nnode();
       for (unsigned j = 0; j < nnod; j++)
       {
         Node* nod_pt = el_pt->node_pt(j);
         unsigned n = nod_pt->ndim();
         for (unsigned i = 0; i < n; i++)
         {
           error_message << nod_pt->x(i) << " ";
         }
         error_message << "\n";
       }
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
 #endif
  
     // Cast to p-refineable element
     PRefineableElement* p_ref_obj_pt =
       dynamic_cast<PRefineableElement*>(Object_pt);
  
     // Check if we can p-refine the element
     if (p_ref_obj_pt == 0)
     {
       throw OomphLibError("Element cannot be p-refined",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
  
  
     // Create a temporary clone of the element to be refined.
     // This is required so that the element can read data from "itself"
     // while it rebuilds itself with a new p-order. Only the information
     // required for the p-refinement is copied across.
  
     // Make new element (using ELEMENT's standard constructor)
     ELEMENT* clone_pt = new ELEMENT();
  
     // Do initial setup with myself as the clone's adopted father
     clone_pt->initial_setup(this);
  
     // All that is left to do is to "build" the clone. It has the same
     // nodes as me, so we can just copy across their pointers
     for (unsigned j = 0; j < clone_pt->nnode(); j++)
     {
       clone_pt->node_pt(j) = p_ref_obj_pt->node_pt(j);
     }
  
  
     // Check if refinement is required
     if (p_ref_obj_pt->to_be_p_refined())
     {
       // Perform the split for the element in question and return Vector
       // of pointers to the newly created elements
       p_ref_obj_pt->p_refine(1, mesh_pt, clone_pt);
     }
     // Check if unrefinement is required
     else if (p_ref_obj_pt->to_be_p_unrefined())
     {
       // Perform the split for the element in question and return Vector
       // of pointers to the newly created elements
       p_ref_obj_pt->p_refine(-1, mesh_pt, clone_pt);
     }
  
  
     // Delete the temporary copy of the element
     delete clone_pt;
   }

References Father_pt, i, j, n, oomph::Node::ndim(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), object_pt(), Object_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::PRefineableElement::p_refine(), Son_pt, oomph::Global_string_for_annotation::string(), oomph::PRefineableElement::to_be_p_refined(), oomph::PRefineableElement::to_be_p_unrefined(), and oomph::Node::x().

◆ root_pt() [1/2]

TreeRoot*& oomph::Tree::root_pt ( )

inline

Return pointer to root of the tree.

     {
       return Root_pt;
     }

References Root_pt.

Referenced by oomph::OcTree::doc_face_neighbours(), oomph::BinaryTree::doc_neighbours(), oomph::QuadTree::doc_neighbours(), oomph::OcTree::doc_true_edge_neighbours(), oomph::RefineablePolarTaylorHoodElement::get_interpolated_values(), oomph::RefineablePolarCrouzeixRaviartElement::get_interpolated_values(), oomph::QuadTree::gteq_edge_neighbour(), oomph::RefineableElement::root_element_pt(), oomph::RefineableBrickMesh< ELEMENT >::setup_octree_forest(), and oomph::RefineableQuadMesh< ELEMENT >::setup_quadtree_forest().

◆ root_pt() [2/2]

TreeRoot* oomph::Tree::root_pt ( ) const

inline

Return pointer to root of the tree (const version)

     {
       return Root_pt;
     }

References Root_pt.

◆ set_father_pt()

void oomph::Tree::set_father_pt ( Tree *const & father_pt )

inline

Set the father.

     {
       Father_pt = father_pt;
     }

References father_pt(), and Father_pt.

Referenced by oomph::RefineableBrickMesh< ELEMENT >::setup_octree_forest(), and oomph::RefineableQuadMesh< ELEMENT >::setup_quadtree_forest().

◆ set_son_pt()

void oomph::Tree::set_son_pt ( const Vector< Tree * > & son_pt )

inline

Set vector of pointers to sons, indexed by the appropriate enum that identies son types. (To aid code readability specific enums have been defined for specific trees. However, these are simply aliases for ints and the general interface can be implemented once, here).

     {
       Son_pt = son_pt;
     }

References son_pt(), and Son_pt.

Referenced by oomph::RefineableBrickMesh< ELEMENT >::setup_octree_forest(), and oomph::RefineableQuadMesh< ELEMENT >::setup_quadtree_forest().

◆ son_pt()

Tree* oomph::Tree::son_pt ( const int & son_index ) const

inline

Return pointer to the son for a given index. Note that to aid code readability specific enums have been defined for specific trees. However, these are simply aliases for ints and the general interface can be implemented once, here.

     {
       // If there are no sons, return NULL (0)
       if (Son_pt.size() == 0)
       {
         return 0;
       }
       // Otherwise, return the pointer to the appropriate son
       else
       {
         return Son_pt[son_index];
       }
     }

References Son_pt.

◆ son_type()

int oomph::Tree::son_type ( ) const

inline

Return son type.

     {
       return Son_type;
     }

References Son_type.

◆ split_if_required()

template<class ELEMENT >

void oomph::Tree::split_if_required

If required, split the leaf and create its sons – criterion: bool object_pt()-> to_be_refined() = true

If required, split the leaf element and create its sons

Split is performed if

 object_pt()->to_be_refined()

returns true.

If this is the case, then we execute

 object_pt()->split(new_elements_pt)

to create the sons. Pointers to the son objects are then inserted into the son pointers of the present element. This turns the present element into a "grey" (=non-leaf) node.

   {
 #ifdef PARANOID
     if (Son_pt.size() != 0)
     {
       std::string error_message =
         "Can't split non-leaf elements (or at least I can't see\n";
       error_message +=
         "why you would want me to... If you're sure, then hack me... \n";
  
       throw OomphLibError(
         error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     if (Object_pt == 0)
     {
       std::stringstream error_message;
       error_message
         << "No object defined in split_if_required. Father nodes:\n";
  
       RefineableElement* el_pt = Father_pt->object_pt();
       unsigned nnod = el_pt->nnode();
       for (unsigned j = 0; j < nnod; j++)
       {
         Node* nod_pt = el_pt->node_pt(j);
         unsigned n = nod_pt->ndim();
         for (unsigned i = 0; i < n; i++)
         {
           error_message << nod_pt->x(i) << " ";
         }
         error_message << "\n";
       }
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
 #endif
  
     // Check if refinement is required
     if (Object_pt->to_be_refined())
     {
       // Perform the split for the element in question and return Vector
       // of pointers to the newly created elements
       Vector<ELEMENT*> new_elements_pt;
       Object_pt->split(new_elements_pt);
  
       // Find the number of sons constructed by the element
       unsigned n_sons = new_elements_pt.size();
  
       // Turn the new elements into QuadTrees and assign
       // the pointers to the present element's sons
       Son_pt.resize(n_sons);
       Tree* father_pt = this;
       for (unsigned i_son = 0; i_son < n_sons; i_son++)
       {
         Son_pt[i_son] = construct_son(new_elements_pt[i_son], father_pt, i_son);
         // Now that the son knows its position in the tree, we can set it
         // up as a proper element (e.g. p-refineable stuff)
         Son_pt[i_son]->object_pt()->initial_setup();
       }
     }
   }

References construct_son(), father_pt(), Father_pt, i, j, n, oomph::Node::ndim(), oomph::FiniteElement::nnode(), oomph::FiniteElement::node_pt(), object_pt(), Object_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Son_pt, oomph::RefineableElement::split(), oomph::Global_string_for_annotation::string(), oomph::RefineableElement::to_be_refined(), and oomph::Node::x().

◆ stick_all_tree_nodes_into_vector()

void oomph::Tree::stick_all_tree_nodes_into_vector ( Vector< Tree * > & all_tree_nodes )

Traverse and stick pointers to all "nodes" into Vector.

Traverse Tree: Preorder traverse and stick pointer to all nodes (incl. "grey"=non-leaf ones) into Vector

   {
     all_tree_nodes.push_back(this);
  
     // If the Tree has sons
     unsigned numsons = Son_pt.size();
     if (numsons > 0)
     {
       // Now do the sons (if they exist)
       for (unsigned i = 0; i < numsons; i++)
       {
         Son_pt[i]->stick_all_tree_nodes_into_vector(all_tree_nodes);
       }
     }
   }

References i, and Son_pt.

Referenced by oomph::BinaryTree::self_test(), oomph::OcTree::self_test(), oomph::QuadTree::self_test(), oomph::RefineableBrickMesh< ELEMENT >::setup_octree_forest(), oomph::RefineableQuadMesh< ELEMENT >::setup_quadtree_forest(), and oomph::TreeForest::stick_all_tree_nodes_into_vector().

◆ stick_leaves_into_vector()

void oomph::Tree::stick_leaves_into_vector ( Vector< Tree * > & tree_nodes )

Traverse tree and stick pointers to leaf "nodes" (only) into Vector.

Traverse Tree: Preorder traverse and stick pointers to leaf nodes (only) into Vector

   {
     // If the Tree has sons
     unsigned numsons = Son_pt.size();
     if (numsons > 0)
     {
       // Now do the sons (if they exist)
       for (unsigned i = 0; i < numsons; i++)
       {
         Son_pt[i]->stick_leaves_into_vector(tree_nodes);
       }
     }
     else
     {
       tree_nodes.push_back(this);
     }
   }

References i, and Son_pt.

Referenced by oomph::TreeForest::stick_leaves_into_vector().

◆ traverse_all() [1/2]

void oomph::Tree::traverse_all ( Tree::VoidMemberFctPt member_function )

Traverse the tree and execute void Tree member function member_function() at all its "nodes"

Preorder traverse the tree and execute void Tree member function at all nodes

   {
     // Process the object contained in (well, pointed to) by current
     // Tree
     (this->*member_function)();
  
     // Now do the sons (if they exist)
     unsigned numsons = Son_pt.size();
     for (unsigned i = 0; i < numsons; i++)
     {
       Son_pt[i]->traverse_all(member_function);
     }
   }

References i, and Son_pt.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), and oomph::TreeBasedRefineableMeshBase::p_adapt_mesh().

◆ traverse_all() [2/2]

void oomph::Tree::traverse_all	(	Tree::VoidMeshPtArgumentMemberFctPt	member_function,
		Mesh *&	mesh_pt
	)

Traverse the tree and excute void Tree member function that takes a pointer to a mesh as an argument

Preorder traverse the tree and execute a void Tree member function that takes one argument at all nodes.

   {
     // Process the object contained in (well, pointed to) by current
     // Tree
     (this->*member_function)(mesh_pt);
  
     // Now do the sons (if they exist)
     unsigned numsons = Son_pt.size();
     for (unsigned i = 0; i < numsons; i++)
     {
       Son_pt[i]->traverse_all(member_function, mesh_pt);
     }
   }

References i, and Son_pt.

◆ traverse_all_but_leaves()

void oomph::Tree::traverse_all_but_leaves ( Tree::VoidMemberFctPt member_function )

Traverse the tree and execute void Tree member function member_function() at all its "nodes" aparat from the leaves

Preorder traverse the tree and execute a void Tree member function for all elements that are not leaf elements.

   {
     // Find the number of sons
     unsigned n_sons = Son_pt.size();
     // If the Tree has sons,
     if (n_sons > 0)
     {
       // Execute the function
       (this->*member_function)();
       // Proceed to the sons
       for (unsigned i = 0; i < n_sons; i++)
       {
         Son_pt[i]->traverse_all_but_leaves(member_function);
       }
     }
     // If the tree has no sons, the function will not be executed
   }

References i, and Son_pt.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh().

◆ traverse_leaves() [1/2]

void oomph::Tree::traverse_leaves ( Tree::VoidMemberFctPt member_function )

Traverse the tree and execute void Tree member function member_function() only at its leaves

Preorder traverse the tree and execute void Tree member function at the leaves only (ignore "grey" = non-leaf nodes)

   {
     // If the Tree has sons
     unsigned numsons = Son_pt.size();
     if (numsons > 0)
     {
       // Proceed to the sons (if they exist)
       for (unsigned i = 0; i < numsons; i++)
       {
         Son_pt[i]->traverse_leaves(member_function);
       }
     }
     else
     {
       // Call the member function
       (this->*member_function)();
     }
   }

References i, and Son_pt.

Referenced by oomph::TreeBasedRefineableMesh< ELEMENT >::p_refine_elements_if_required(), and oomph::TreeBasedRefineableMesh< ELEMENT >::split_elements_if_required().

◆ traverse_leaves() [2/2]

void oomph::Tree::traverse_leaves	(	Tree::VoidMeshPtArgumentMemberFctPt	member_function,
		Mesh *&	mesh_pt
	)

Traverse the tree and execute void Tree member function that takes a pointer to a mesh as an argument only at its leaves

Preorder traverse the tree and execute void Tree member function that takes one argument at the leaves only (ignore "grey" = non-leaf nodes)

   {
     // If the Tree has sons
     unsigned numsons = Son_pt.size();
     if (numsons > 0)
     {
       // Proceed to the sons (if they exist)
       for (unsigned i = 0; i < numsons; i++)
       {
         Son_pt[i]->traverse_leaves(member_function, mesh_pt);
       }
     }
     else
     {
       // Call the member function
       (this->*member_function)(mesh_pt);
     }
   }

References i, and Son_pt.

Member Data Documentation

◆ Father_pt

Tree* oomph::Tree::Father_pt

protected

Pointer to the Father of the Tree.

Referenced by father_pt(), oomph::OcTree::gteq_edge_neighbour(), oomph::BinaryTree::gteq_edge_neighbour(), oomph::QuadTree::gteq_edge_neighbour(), oomph::OcTree::gteq_face_neighbour(), p_refine_if_required(), set_father_pt(), split_if_required(), and Tree().

◆ Level

int oomph::Tree::Level

protected

Level of the Tree (level 0 = root)

Referenced by oomph::OcTree::gteq_edge_neighbour(), oomph::BinaryTree::gteq_edge_neighbour(), oomph::QuadTree::gteq_edge_neighbour(), oomph::OcTree::gteq_face_neighbour(), oomph::OcTree::gteq_true_edge_neighbour(), level(), and Tree().

◆ Max_neighbour_finding_tolerance

double oomph::Tree::Max_neighbour_finding_tolerance = 1.0e-14

staticprotected

Max. allowed discrepancy in neighbour finding routine (distance between points when identified from two neighbouring elements)

Maximum tolerance for neighbour finding (distance between points when identified from the two neighbours)

Referenced by oomph::OcTree::doc_face_neighbours(), oomph::OcTree::doc_true_edge_neighbours(), max_neighbour_finding_tolerance(), oomph::BinaryTree::self_test(), oomph::OcTree::self_test(), and oomph::QuadTree::self_test().

◆ Object_pt

RefineableElement* oomph::Tree::Object_pt

protected

Pointer to the object represented by the tree.

Referenced by flush_object(), merge_sons_if_required(), object_pt(), p_refine_if_required(), split_if_required(), and ~Tree().

◆ OMEGA

const int oomph::Tree::OMEGA = 26

static

Default value for an unassigned neighbour.

Static value used to represent unassigned quantities. This has to remain consistent with the enumerations in the Octree and Quadtree namespaces!

Referenced by oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 2 >::build(), oomph::OcTreeForest::construct_up_right_equivalents(), oomph::BinaryTreeRoot::direction_of_neighbour(), oomph::QuadTreeRoot::direction_of_neighbour(), oomph::OcTreeRoot::direction_of_neighbour(), oomph::OcTree::doc_face_neighbours(), oomph::OcTree::doc_true_edge_neighbours(), oomph::OcTree::gteq_edge_neighbour(), oomph::MGSolver< DIM >::level_up_local_coord_of_node(), oomph::HelmholtzMGPreconditioner< DIM >::level_up_local_coord_of_node(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 3 >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 2 >::rebuild_from_sons(), oomph::OcTreeRoot::right_equivalent(), oomph::RefineableQElement< 3 >::setup_father_bounds(), oomph::RefineableQElement< 1 >::setup_father_bounds(), oomph::RefineableQElement< 2 >::setup_father_bounds(), oomph::MGSolver< DIM >::setup_interpolation_matrices(), oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices(), oomph::BinaryTree::setup_static_data(), oomph::OcTree::setup_static_data(), oomph::QuadTree::setup_static_data(), Tree(), and oomph::OcTreeRoot::up_equivalent().

◆ Root_pt

TreeRoot* oomph::Tree::Root_pt

protected

Pointer to the root of the tree.

Referenced by oomph::OcTree::gteq_edge_neighbour(), oomph::BinaryTree::gteq_edge_neighbour(), oomph::QuadTree::gteq_edge_neighbour(), oomph::OcTree::gteq_face_neighbour(), oomph::OcTree::gteq_true_edge_neighbour(), root_pt(), Tree(), and oomph::TreeRoot::TreeRoot().

◆ Son_pt

Vector<Tree*> oomph::Tree::Son_pt

protected

◆ Son_type

int oomph::Tree::Son_type

protected

Son type (e.g. SW/SE/NW/NE in a quadtree)

Referenced by oomph::OcTree::gteq_edge_neighbour(), oomph::BinaryTree::gteq_edge_neighbour(), oomph::QuadTree::gteq_edge_neighbour(), oomph::OcTree::gteq_face_neighbour(), son_type(), and Tree().

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

◆ VoidMemberFctPt

◆ VoidMeshPtArgumentMemberFctPt

Constructor & Destructor Documentation

◆ ~Tree()

◆ Tree() [1/4]

◆ Tree() [2/4]

◆ Tree() [3/4]

◆ Tree() [4/4]

Member Function Documentation

◆ construct_son()

◆ deactivate_object()

◆ father_pt()

◆ flush_object()

◆ flush_sons()

◆ is_leaf()

◆ level()

◆ max_neighbour_finding_tolerance()

◆ merge_sons_if_required()

◆ nsons()

◆ object_pt()

◆ operator=()

◆ p_refine_if_required()

◆ root_pt() [1/2]

◆ root_pt() [2/2]

◆ set_father_pt()

◆ set_son_pt()

◆ son_pt()

◆ son_type()

◆ split_if_required()

◆ stick_all_tree_nodes_into_vector()

◆ stick_leaves_into_vector()

◆ traverse_all() [1/2]

◆ traverse_all() [2/2]

◆ traverse_all_but_leaves()

◆ traverse_leaves() [1/2]

◆ traverse_leaves() [2/2]

Member Data Documentation

◆ Father_pt

◆ Level

◆ Max_neighbour_finding_tolerance

◆ Object_pt

◆ OMEGA

◆ Root_pt

◆ Son_pt

◆ Son_type