oomph::QuadTree Class Reference

#include <quadtree.h>

Inheritance diagram for oomph::QuadTree:

Public Member Functions
virtual	~QuadTree ()
	QuadTree (const QuadTree &dummy)=delete
	Broken copy constructor. More...
void	operator= (const QuadTree &)=delete
	Broken assignment operator. More...
Tree *	construct_son (RefineableElement *const &object_pt, Tree *const &father_pt, const int &son_type)
QuadTree *	gteq_edge_neighbour (const int &direction, Vector< unsigned > &translate_s, Vector< double > &s_lo, Vector< double > &s_hi, int &edge, int &diff_level, bool &in_neighbouring_tree) const
void	stick_neighbouring_leaves_into_vector (Vector< const QuadTree * > &tree_neighbouring_nodes, Vector< Vector< double >> &tree_neighbouring_s_lo, Vector< Vector< double >> &tree_neighbouring_s_hi, Vector< int > &tree_neighbouring_diff_level, const QuadTree *my_neigh_pt, const int &direction) 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 ()
	Setup the static data, rotation and 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
	QuadTree ()
	Default constructor (empty and broken) More...
	QuadTree (RefineableElement *const &object_pt)
	QuadTree (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
	Bool 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
QuadTree *	gteq_edge_neighbour (const int &direction, double &s_diff, int &diff_level, bool &in_neighbouring_tree, int max_level, QuadTreeRoot *const &orig_root_pt) const

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

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

QuadTree class: Recursively defined, generalised quadtree.

A QuadTree has:

• a pointer to the object (of type RefineableQElement<2>) that it represents in a mesh refinement context.
• Vector of pointers to its four (SW/SE/NW/NE) sons (which are themselves quadtrees). If the Vector of pointers to the sons has zero length, the QuadTree is a "leaf node" in the overall quadtree.
• a pointer to its father. If this pointer is NULL, the QuadTree is the the root node of the overall quadtree. 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 quadtrees.

The objects contained in the quadtree are assumed to be (topologically) rectangular elements whose geometry is parametrised by local coordinates \( {\bf s} \in [-1,1]^2 \).

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

Constructor & Destructor Documentation

~QuadTree()

virtual oomph::QuadTree::~QuadTree ( )

inlinevirtual

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

{}

QuadTree() [1/4]

oomph::QuadTree::QuadTree ( const QuadTree &  dummy )

delete

Broken copy constructor.

QuadTree() [2/4]

oomph::QuadTree::QuadTree ( )

inlineprotected

Default constructor (empty and broken)

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

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by construct_son().

QuadTree() [3/4]

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

inlineprotected

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

: Tree(object_pt) {}

QuadTree() [4/4]

oomph::QuadTree::QuadTree ( 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 (SE/SW/NE/NW) it is. Protected because QuadTrees can only be created internally, during the split operation. Only QuadTreeRoots can be created externally.

      : Tree(object_pt, father_pt, son_type)
    {
    }

Member Function Documentation

construct_son()

Tree* oomph::QuadTree::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 QuadTree and not a general Tree.

Implements oomph::Tree.

    {
      QuadTree* temp_quad_pt = new QuadTree(object_pt, father_pt, son_type);
      return temp_quad_pt;
    }

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

doc_neighbours()

void oomph::QuadTree::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 quadtree (nodes) contained in the Vector forest_node_pt. Output into neighbours_file which can be viewed from tecplot with QuadTreeNeighbours.mcr Neighbour info and errors are displayed on neighbours_txt_file. Finally, compute the max. error between vertices when viewed from neighhbouring element. If the two filestreams are closed, output is suppressed.

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

  {
    using namespace QuadTreeNames;
 
    int diff_level;
    double s_diff;
    bool in_neighbouring_tree;
    int edge = OMEGA;
 
    Vector<double> s(2);
    Vector<double> x(2);
    Vector<int> prev_son_type;
 
    Vector<unsigned> translate_s(2);
    Vector<double> s_lo(2);
    Vector<double> s_hi(2);
 
    Vector<double> x_small(2);
    Vector<double> x_large(2);
 
    // 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
      QuadTree* el_pt = dynamic_cast<QuadTree*>(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<2>*>(el_pt->object_pt())
            ->output_corners(neighbours_file, "BLACK");
        }
 
        // Loop over directions to find neighbours
        // ----------------------------------------
        for (int direction = N; direction <= W; direction++)
        {
          // Initialise difference in levels and coordinate offset
          diff_level = 0;
          s_diff = 0.0;
 
          // Find greater-or-equal-sized neighbour...
          QuadTree* neighb_pt =
            el_pt->gteq_edge_neighbour(direction,
                                       translate_s,
                                       s_lo,
                                       s_hi,
                                       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<2>*>(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=2 \n";
              }
 
              // (Lower)/(left) vertex:
              //-----------------------
 
              // Get coordinates in large (neighbour) element
              s[0] = s_lo[0];
              s[1] = s_lo[1];
              neighb_pt->object_pt()->get_x(s, x_large);
 
              // Get coordinates in small element
              Vector<double> s(2);
              s[0] = S_base(0, direction);
              s[1] = S_base(1, 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)
              {
                for (int i = 0; i < 2; i++)
                {
                  error += pow(x_small[i] - x_large[i], 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] << " " << x_large[1] << "  0 \n";
              }
 
              // (Upper)/(right) vertex:
              //------------------------
 
              // Get coordinates in large (neighbour) element
              s[0] = s_hi[0];
              s[1] = s_hi[1];
              neighb_pt->object_pt()->get_x(s, x_large);
 
              // Get coordinates in small element
              s[0] = S_base(0, direction) + S_step(0, direction);
              s[1] = S_base(1, direction) + S_step(1, 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)
              {
                for (int i = 0; i < 2; i++)
                {
                  error += pow(x_small[i] - x_large[i], 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] << " " << x_large[1] << "  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=2 \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.00  0 \n";
              neighbours_file << "ZONE I=2 \n";
              neighbours_file << "-0.05 -0.05  0 \n";
              neighbours_file << "-0.05 -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(), MeshRefinement::max_error, N, oomph::RefineableElement::nodes_built(), oomph::RefineableElement::number(), oomph::Tree::object_pt(), oomph::BinaryTreeNames::OMEGA, Eigen::bfloat16_impl::pow(), oomph::Tree::root_pt(), s, sqrt(), oomph::QuadTreeNames::W, and plotDoE::x.

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

gteq_edge_neighbour() [1/2]

QuadTree * oomph::QuadTree::gteq_edge_neighbour ( const int &  direction, double &  s_diff, int &  diff_level, bool &  in_neighbouring_tree, int  max_level, QuadTreeRoot *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 (N/E/S/W).

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

Parameters:

• direction: N/S/E/W: Direction in which neighbour has to be found.
• s_diff: Offset of lower/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' (N/S/E/W). When viewed from the neighbour, this edge is ‘edge’ (N/S/E/W). [If there's no relative rotation between neighbours then this is a mere reflection, e.g. direction=N --> edge=S etc.]
• diff_level <= 0 indicates the difference in quadtree 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 QuadTreeNames;
 
#ifdef PARANOID
    if ((direction != S) && (direction != E) && (direction != N) &&
        (direction != W))
    {
      std::ostringstream error_stream;
      error_stream << "Direction " << direction << " is not N, S, E, W"
                   << std::endl;
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    QuadTree* next_el_pt;
    QuadTree* return_el_pt;
 
    // STEP 1: Find the neighbour's father
    //--------
 
    // Does the element have a father?
    if (Father_pt != 0)
    {
      // If the present quadrant (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<QuadTree*>(Father_pt)->gteq_edge_neighbour(
          direction,
          s_diff,
          diff_level,
          in_neighbouring_tree,
          max_level,
          orig_root_pt);
      }
      // If the present quadrant 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<QuadTree*>(Father_pt);
      }
 
      // We're about to ascend one level:
      diff_level -= 1;
 
      // Work out position of lower (or left) corner of present edge
      // in its father element
      s_diff += pow(0.5, -diff_level) * S_direct(direction, Son_type);
 
      // 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 neighbours father
        else
        {
          int son_quadrant = Reflect(direction, Son_type);
 
          // If the root of the neighbour's father is not our root, we
          // might need to rotate
          if (orig_root_pt != next_el_pt->Root_pt)
          {
            // Get the north equivalent of the next element
            int my_north =
              dynamic_cast<QuadTreeRoot*>(Root_pt)->north_equivalent(direction);
            son_quadrant = Rotate(my_north, son_quadrant);
          }
 
          // The next element in the tree is the appropriate son of the
          // neighbour's father
          return_el_pt =
            dynamic_cast<QuadTree*>(next_el_pt->Son_pt[son_quadrant]);
 
          // Work out position of lower (or left) corner of present edge
          // in next higher element
          s_diff -= pow(0.5, -diff_level) * S_direct(direction, Son_type);
 
          // 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<QuadTreeRoot*>(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 Global_Physical_Variables::E, oomph::Tree::Father_pt, gteq_edge_neighbour(), Is_adjacent, oomph::Tree::Level, N, oomph::TreeRoot::neighbour_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Eigen::bfloat16_impl::pow(), Reflect, oomph::Tree::Root_pt, Rotate, oomph::QuadTreeNames::S, S_direct, oomph::Tree::Son_pt, oomph::Tree::Son_type, and oomph::QuadTreeNames::W.

gteq_edge_neighbour() [2/2]

QuadTree * oomph::QuadTree::gteq_edge_neighbour	(	const int &	direction,
		Vector< unsigned > &	translate_s,
		Vector< double > &	s_lo,
		Vector< double > &	s_hi,
		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 and orientation of neighbour:

• The vector translate_s turns the index of the local coordinate in the present quadtree into that of the neighbour. If there are no rotations then translate_s[i] = i, but if, for example, the neighbour's eastern face is adjacent to our northern face translate_s[0] = 1 and translate_s[1] = 0. Of course, this could be deduced after the fact, but it's easier to do it here.
• In the present quadtree, the lower left (south west) vertex is located at local coordinates (-1,-1). This point is located at the local coordinates (s_lo[0], s_lo[1]) in the neighbouring quadtree.
• ditto with s_hi: In the present quadtree, the upper right (north east) vertex is located at local coordinates (1,1). This point is located at the local coordinates (s_hi[0], s_hi[1]) in the neighbouring quadtree.
• We're looking for a neighbour in the specified direction. When viewed from the neighbouring quadtree, the edge that separates the present quadtree from its neighbour is the neighbour's edge edge. If there's no rotation between the two quadtrees, this is a simple reflection: For instance, if we're looking for a neighhbour in the N [orthern] direction, edge will be S [outh]
• 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 quadtree.
• 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 and orientation of neighbour:

• The vector translate_s turns the index of the local coordinate in the present quadtree into that of the neighbour. If there are no rotations then translate_s[i] = i, but if, for example, the neighbour's eastern face is adjacent to our northern face translate_s[0] = 1 and translate_s[1] = 0. Of course, this could be deduced after the fact, but it's easier to do it here.
• Let's have a look at the current quadtree's edge in the specified direction. The edge will be parallel to one of the two local coordinates in the element. This edge has two vertices. The vertex at the minimum value of the local coordinate (the "lo" vertex) is located at the local coordinates (s_lo[0], s_lo[1]) in the neighbouring quadtree.
• ditto with s_hi: The vertex at the maximum value of the local coordinate located at the local coordinates (s_hi[0], s_hi[1]) in the neighbouring quadtree.
• We're looking for a neighbour in the specified direction. When viewed from the neighbouring quadtree, the edge that separates the present quadtree from its neighbour is the neighbour's edge edge. If there's no rotation between the two quadtrees, this is a simple reflection: For instance, if we're looking for a neighhbour in the N [orthern] direction, edge will be S [outh]
• 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 quadtree.
• in_neighbouring_tree returns true is 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 QuadTreeNames;
 
#ifdef PARANOID
    if ((direction != S) && (direction != E) && (direction != N) &&
        (direction != W))
    {
      std::ostringstream error_stream;
      error_stream << "Direction " << direction << " is not N, S, E, W"
                   << 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 in to 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:
    QuadTreeRoot* orig_root_pt = dynamic_cast<QuadTreeRoot*>(Root_pt);
 
    // Initialise offset in local coordinate
    double s_diff = 0;
 
    // Initialise difference in level
    diff_level = 0;
 
    // Find neighbour
    QuadTree* return_pt = gteq_edge_neighbour(direction,
                                              s_diff,
                                              diff_level,
                                              in_neighbouring_tree,
                                              max_level,
                                              orig_root_pt);
 
    QuadTree* neighb_pt = return_pt;
 
    // If neighbour exists: What's the direction of the interfacial
    // edge when viewed from within the neighbour element?
    if (neighb_pt != 0)
    {
      // Rotate things around (the orientation of N in the neighbour might be
      // be different from that in the present element)
      // Initialise the direction
      int new_dir = direction;
      // If the neighbour has a different root, then there could be a possible
      // rotation, find it
      if (neighb_pt->root_pt() != Root_pt)
      {
        new_dir = Rotate(orig_root_pt->north_equivalent(direction), direction);
      }
 
      s_lo[0] = S_base(0, Reflect_edge[new_dir]) +
                S_step(0, Reflect_edge[new_dir]) * s_diff;
      s_lo[1] = S_base(1, Reflect_edge[new_dir]) +
                S_step(1, Reflect_edge[new_dir]) * s_diff;
 
      s_hi[0] = S_base(0, Reflect_edge[new_dir]) +
                S_step(0, Reflect_edge[new_dir]) * pow(2.0, diff_level) +
                S_step(0, Reflect_edge[new_dir]) * s_diff;
      s_hi[1] = S_base(1, Reflect_edge[new_dir]) +
                S_step(1, Reflect_edge[new_dir]) * pow(2.0, diff_level) +
                S_step(1, Reflect_edge[new_dir]) * s_diff;
 
      Vector<double> s_lo_new(2), s_hi_new(2);
 
      // What's the direction of the interfacial edge when viewed from within
      // the neighbour element?
      edge = Reflect_edge[new_dir];
 
      // Set up the translation scheme for the local coordinates
      {
        bool swap = false;
        // Do we need to switch the coordinate
        switch (direction)
        {
            // If the direction is north or south,
            // but the neighbour's coordinate s[1] is not constant, we must swap
          case N:
          case S:
            if (s_lo[1] != s_hi[1])
            {
              swap = true;
            }
            break;
            // If the direction is east or west
            // but the neighbour's corodinate s[0] is not constant, we must swap
          case E:
          case W:
            if (s_lo[0] != s_hi[0])
            {
              swap = true;
            }
            break;
          // Catch all totally un-necessary
          default:
            std::ostringstream error_stream;
            error_stream << "Direction " << direction << " is not N, S, E, W"
                         << std::endl;
 
            throw OomphLibError(error_stream.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
        }
 
        // If we must swap, then do so
        if (swap)
        {
          translate_s[0] = 1;
          translate_s[1] = 0;
        }
        // Othewise, it's just a straight translation
        else
        {
          translate_s[0] = 0;
          translate_s[1] = 1;
        }
      }
 
      // Reverse directions?
      s_lo_new[0] = s_lo[0];
      s_lo_new[1] = s_lo[1];
      s_hi_new[0] = s_hi[0];
      s_hi_new[1] = s_hi[1];
 
      if (((edge == N) || (edge == S)) &&
          ((Rotate_angle(direction, new_dir) == 90) ||
           (Rotate_angle(direction, new_dir) == 180)))
      {
        s_lo_new[0] = -s_lo[0];
        s_hi_new[0] = -s_hi[0];
      }
      if (((edge == E) || (edge == W)) &&
          ((Rotate_angle(direction, new_dir) == 270) ||
           (Rotate_angle(direction, new_dir) == 180)))
      {
        s_lo_new[1] = -s_lo[1];
        s_hi_new[1] = -s_hi[1];
      }
 
      s_lo[0] = s_lo_new[0];
      s_lo[1] = s_lo_new[1];
      s_hi[0] = s_hi_new[0];
      s_hi[1] = s_hi_new[1];
    }
    return return_pt;
  }

References Global_Physical_Variables::E, oomph::Tree::Level, N, oomph::QuadTreeRoot::north_equivalent(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Eigen::bfloat16_impl::pow(), Reflect_edge, oomph::Tree::root_pt(), oomph::Tree::Root_pt, Rotate, Rotate_angle, oomph::QuadTreeNames::S, S_base, S_step, swap(), and oomph::QuadTreeNames::W.

Referenced by oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::check_integrity(), oomph::RefineableQElement< 2 >::check_integrity(), doc_neighbours(), gteq_edge_neighbour(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::node_created_by_neighbour(), oomph::RefineableQElement< 2 >::node_created_by_neighbour(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::node_created_by_son_of_neighbour(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::quad_hang_helper(), oomph::RefineableQElement< 2 >::quad_hang_helper(), and stick_neighbouring_leaves_into_vector().

operator=()

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

delete

Broken assignment operator.

self_test()

unsigned oomph::QuadTree::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_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;
    QuadTree::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 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 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::QuadTree::setup_static_data ( )

static

Setup the static data, rotation and reflection schemes, etc.

Setup the static data stored in the QuadTree – this needs to be called before QuadTrees can be used. Automatically called by RefineableQuadMesh constructor.

  {
    using namespace QuadTreeNames;
 
 
#ifdef PARANOID
    if (Tree::OMEGA != QuadTree::OMEGA)
    {
      std::ostringstream error_stream;
      error_stream << "Inconsistent enumeration!  \n    Tree::OMEGA="
                   << Tree::OMEGA << "\nQuadTree::OMEGA=" << QuadTree::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[SW] = "YELLOW";
    Colour[SE] = "YELLOW";
    Colour[NW] = "YELLOW";
    Colour[NE] = "YELLOW";
    Colour[E] = "CYAN";
    Colour[W] = "RED";
    Colour[N] = "GREEN";
    Colour[S] = "BLUE";
    Colour[OMEGA] = "YELLOW";
 
    // S_base(i,direction):  Initial value for coordinate s[i] on the
    // edge indicated by direction (S/E/N/W)
    //
    // S_step(i,direction) Increments for coordinate s[i] when progressing
    // along the edge indicated by direction (S/E/N/W)
    S_base.resize(2, 27);
    S_step.resize(2, 27);
 
    S_base(0, N) = -1.0;
    S_base(1, N) = 1.0;
    S_step(0, N) = 2.0;
    S_step(1, N) = 0.0;
 
    S_base(0, S) = -1.0;
    S_base(1, S) = -1.0;
    S_step(0, S) = 2.0;
    S_step(1, S) = 0.0;
 
    S_base(0, W) = -1.0;
    S_base(1, W) = -1.0;
    S_step(0, W) = 0.0;
    S_step(1, W) = 2.0;
 
    S_base(0, E) = 1.0;
    S_base(1, E) = -1.0;
    S_step(0, E) = 0.0;
    S_step(1, E) = 2.0;
 
    // Translate (enumerated) directions into strings
    Direct_string.resize(27);
 
    Direct_string[SW] = "SW";
    Direct_string[NW] = "NW";
    Direct_string[SE] = "SE";
    Direct_string[NE] = "NE";
 
    Direct_string[S] = "S";
    Direct_string[N] = "N";
    Direct_string[E] = "E";
    Direct_string[W] = "W";
    Direct_string[OMEGA] = "OMEGA";
 
    // Build direction/quadrant adjacency scheme
    // Is_adjacent(i_vertex_or_edge,j_quadrant):
    // Is edge/vertex adjacent to quadrant?
    Is_adjacent.resize(27, 27);
 
    Is_adjacent(N, NW) = true;
    Is_adjacent(E, NW) = false;
    Is_adjacent(S, NW) = false;
    Is_adjacent(W, NW) = true;
    Is_adjacent(NW, NW) = true;
    Is_adjacent(NE, NW) = false;
    Is_adjacent(SW, NW) = false;
    Is_adjacent(SE, NW) = false;
 
    Is_adjacent(N, NE) = true;
    Is_adjacent(E, NE) = true;
    Is_adjacent(S, NE) = false;
    Is_adjacent(W, NE) = false;
    Is_adjacent(NW, NE) = false;
    Is_adjacent(NE, NE) = true;
    Is_adjacent(SW, NE) = false;
    Is_adjacent(SE, NE) = false;
 
    Is_adjacent(N, SW) = false;
    Is_adjacent(E, SW) = false;
    Is_adjacent(S, SW) = true;
    Is_adjacent(W, SW) = true;
    Is_adjacent(NW, SW) = false;
    Is_adjacent(NE, SW) = false;
    Is_adjacent(SW, SW) = true;
    Is_adjacent(SE, SW) = false;
 
 
    Is_adjacent(N, SE) = false;
    Is_adjacent(E, SE) = true;
    Is_adjacent(S, SE) = true;
    Is_adjacent(W, SE) = false;
    Is_adjacent(NW, SE) = false;
    Is_adjacent(NE, SE) = false;
    Is_adjacent(SW, SE) = false;
    Is_adjacent(SE, SE) = true;
 
    // Rotation scheme: If north becomes NorthIs then
    // direction becomes Rotate(NorthIs,direction)
    // Initialise to OMEGA
    Rotate.resize(27, 27);
 
    Rotate(N, N) = N;
    Rotate(N, E) = E;
    Rotate(N, S) = S;
    Rotate(N, W) = W;
    Rotate(N, NW) = NW;
    Rotate(N, NE) = NE;
    Rotate(N, SE) = SE;
    Rotate(N, SW) = SW;
 
    Rotate(W, N) = W;
    Rotate(W, E) = N;
    Rotate(W, S) = E;
    Rotate(W, W) = S;
    Rotate(W, NW) = SW;
    Rotate(W, NE) = NW;
    Rotate(W, SE) = NE;
    Rotate(W, SW) = SE;
 
    Rotate(S, N) = S;
    Rotate(S, E) = W;
    Rotate(S, S) = N;
    Rotate(S, W) = E;
    Rotate(S, NW) = SE;
    Rotate(S, NE) = SW;
    Rotate(S, SE) = NW;
    Rotate(S, SW) = NE;
 
    Rotate(E, N) = E;
    Rotate(E, E) = S;
    Rotate(E, S) = W;
    Rotate(E, W) = N;
    Rotate(E, NW) = NE;
    Rotate(E, NE) = SE;
    Rotate(E, SE) = SW;
    Rotate(E, SW) = NW;
 
    // Angle betwen rotated coordinates:
    // old_direction becomes new_direction then the angle between
    // the axes is Rotate_angle(old_direction,new_direction)
    Rotate_angle.resize(27, 27);
 
    Rotate_angle(N, N) = 0;
    Rotate_angle(N, W) = 90;
    Rotate_angle(N, S) = 180;
    Rotate_angle(N, E) = 270;
 
    Rotate_angle(S, S) = 0;
    Rotate_angle(S, E) = 90;
    Rotate_angle(S, N) = 180;
    Rotate_angle(S, W) = 270;
 
    Rotate_angle(W, W) = 0;
    Rotate_angle(W, S) = 90;
    Rotate_angle(W, E) = 180;
    Rotate_angle(W, N) = 270;
 
    Rotate_angle(E, E) = 0;
    Rotate_angle(E, N) = 90;
    Rotate_angle(E, W) = 180;
    Rotate_angle(E, S) = 270;
 
    // Reflection scheme:
    // Reflect(direction,quadrant): Get mirror of quadrant in direction
    Reflect.resize(27, 27);
 
    Reflect(N, NW) = SW;
    Reflect(E, NW) = NE;
    Reflect(S, NW) = SW;
    Reflect(W, NW) = NE;
    Reflect(NW, NW) = SE;
    Reflect(NE, NW) = SE;
    Reflect(SW, NW) = SE;
    Reflect(SE, NW) = SE;
 
    Reflect(N, NE) = SE;
    Reflect(E, NE) = NW;
    Reflect(S, NE) = SE;
    Reflect(W, NE) = NW;
    Reflect(NW, NE) = SW;
    Reflect(NE, NE) = SW;
    Reflect(SW, NE) = SW;
    Reflect(SE, NE) = SW;
 
    Reflect(N, SW) = NW;
    Reflect(E, SW) = SE;
    Reflect(S, SW) = NW;
    Reflect(W, SW) = SE;
    Reflect(NW, SW) = NE;
    Reflect(NE, SW) = NE;
    Reflect(SW, SW) = NE;
    Reflect(SE, SW) = NE;
 
    Reflect(N, SE) = NE;
    Reflect(E, SE) = SW;
    Reflect(S, SE) = NE;
    Reflect(W, SE) = SW;
    Reflect(NW, SE) = NW;
    Reflect(NE, SE) = NW;
    Reflect(SW, SE) = NW;
    Reflect(SE, SE) = NW;
 
    // S_direct(direction,son_quadrant): The lower left corner of
    // my son_quadrant has an offset of h/2 S_direct(direction,son_quadrant)
    // in the direction. [Look in the positive direction along the
    // edge 'direction' and measure the offset of the lower left corner
    // of the son quadrant in this direction]
    S_direct.resize(27, 27);
 
    S_direct(W, NW) = 1;
    S_direct(E, NW) = 1;
    S_direct(N, NW) = 0;
    S_direct(S, NW) = 0;
 
    S_direct(W, NE) = 1;
    S_direct(E, NE) = 1;
    S_direct(N, NE) = 1;
    S_direct(S, NE) = 1;
 
    S_direct(W, SW) = 0;
    S_direct(E, SW) = 0;
    S_direct(N, SW) = 0;
    S_direct(S, SW) = 0;
 
    S_direct(W, SE) = 0;
    S_direct(E, SE) = 0;
    S_direct(N, SE) = 1;
    S_direct(S, SE) = 1;
 
    // Get opposite edge, e.g. Reflect_edge(N)=S
    Reflect_edge.resize(27);
 
    Reflect_edge[N] = S;
    Reflect_edge[S] = N;
    Reflect_edge[E] = W;
    Reflect_edge[W] = E;
  }

References Colour, Direct_string, Global_Physical_Variables::E, Is_adjacent, N, oomph::QuadTreeNames::NE, oomph::QuadTreeNames::NW, oomph::Tree::OMEGA, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Reflect, Reflect_edge, oomph::DenseMatrix< T >::resize(), Rotate, Rotate_angle, oomph::QuadTreeNames::S, S_base, S_direct, S_step, oomph::QuadTreeNames::SE, Static_data_has_been_setup, oomph::QuadTreeNames::SW, and oomph::QuadTreeNames::W.

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

stick_neighbouring_leaves_into_vector()

void oomph::QuadTree::stick_neighbouring_leaves_into_vector	(	Vector< const QuadTree * > &	tree_neighbouring_nodes,
		Vector< Vector< double >> &	tree_neighbouring_s_lo,
		Vector< Vector< double >> &	tree_neighbouring_s_hi,
		Vector< int > &	tree_neighbouring_diff_level,
		const QuadTree *	my_neigh_pt,
		const int &	direction
	)		const

Traverse Tree: Preorder traverse and stick pointers to neighbouring 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++)
      {
        dynamic_cast<QuadTree*>(Son_pt[i])
          ->stick_neighbouring_leaves_into_vector(tree_neighbouring_nodes,
                                                  tree_neighbouring_s_lo,
                                                  tree_neighbouring_s_hi,
                                                  tree_neighbouring_diff_level,
                                                  my_neigh_pt,
                                                  direction);
      }
    }
    else
    {
      // Required data for neighbour-finding routine
      Vector<unsigned> translate_s(2);
      Vector<double> s_lo(2), s_hi(2);
      int edge, diff_level;
      bool in_neighbouring_tree;
      QuadTree* neigh_pt;
 
      // Get neighbouring tree
      neigh_pt = gteq_edge_neighbour(direction,
                                     translate_s,
                                     s_lo,
                                     s_hi,
                                     edge,
                                     diff_level,
                                     in_neighbouring_tree);
 
      // Check if the neighbour is the same as the tree passed in
      // (i.e. Am I a neighbour of the master element's tree?)
      if (neigh_pt == my_neigh_pt)
      {
        // Add the element and the diff_level to passed vectors
        tree_neighbouring_nodes.push_back(this);
        tree_neighbouring_s_lo.push_back(s_lo);
        tree_neighbouring_s_hi.push_back(s_hi);
        tree_neighbouring_diff_level.push_back(diff_level);
      }
    }
  }

References gteq_edge_neighbour(), i, and oomph::Tree::Son_pt.

Member Data Documentation

Colour

Vector< std::string > oomph::QuadTree::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::QuadTree::Direct_string

static

Translate (enumerated) directions into strings.

Translate (enumerated) directions into strings (static data)

Referenced by oomph::QuadTreeRoot::north_equivalent(), and setup_static_data().

Is_adjacent

DenseMatrix< bool > oomph::QuadTree::Is_adjacent

staticprivate

Array of direction/quadrant adjacency scheme: Is_adjacent(i_vertex_or_edge,j_quadrant): Is edge/vertex adjacent to quadrant?

Array of direction/quadrant adjacency scheme: Is_adjacent(i_vertex_or_edge,j_quadrant): Is edge/vertex adjacent to quadrant? (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

Reflect

DenseMatrix< int > oomph::QuadTree::Reflect

staticprivate

Reflection scheme: Reflect(direction,quadrant): Get mirror of quadrant in specified direction. E.g. Reflect(S,NE)=SE

Reflection scheme: Reflect(direction,quadrant): Get mirror of quadrant in specified direction. E.g. Reflect(S,NE)=SE (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

Reflect_edge

Vector< int > oomph::QuadTree::Reflect_edge

staticprivate

Get opposite edge, e.g. Reflect_edge[N]=S.

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

Referenced by gteq_edge_neighbour(), and setup_static_data().

Rotate

DenseMatrix< int > oomph::QuadTree::Rotate

staticprivate

Rotate coordinates: If North becomes NorthIs then direction becomes Rotate(NorthIs,direction). E.g. Rotate(E,NW)=NE;

Rotate coordinates: If north becomes NorthIs then direction becomes Rotate(NorthIs,direction). E.g. Rotate(E,NW)=NE; (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

Rotate_angle

DenseMatrix< int > oomph::QuadTree::Rotate_angle

staticprivate

Angle betwen rotated coordinates: If old_direction becomes new_direction then the angle between the axes (in anti-clockwise direction is Rotate_angle(old_direction,new_direction); E.g. Rotate_angle(E,N)=90;

Angle betwen rotated coordinates: If old_direction becomes new_direction then the angle between the axes (in anti-clockwise direction is Rotate_angle(old_direction,new_direction); E.g. Rotate_angle(E,N)=90; (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

S_base

DenseMatrix< double > oomph::QuadTree::S_base

staticprivate

S_base(i,direction): Initial value for coordinate s[i] on the edge indicated by direction (S/E/N/W)

S_base(i,direction): Initial value for coordinate s[i] on the edge indicated by direction (S/E/N/W) (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

S_direct

DenseMatrix< int > oomph::QuadTree::S_direct

staticprivate

S_direct(direction,son_quadrant): The lower left corner of son_quadrant has an offset of h/2 S_direct(direction,son_quadrant) in the specified direction. E.g. S_direct(S,NE)=1 and S_direct(S,NW)=0

S_direct(direction,son_quadrant): The lower left corner of son_quadrant has an offset of h/2 S_direct(direction,son_quadrant) in the specified direction. E.g. S_direct(S,NE)=1 and S_direct(S,NW)=0 (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

S_step

DenseMatrix< double > oomph::QuadTree::S_step

staticprivate

S_step(i,direction) Increments for coordinate s[i] when progressing along the edge indicated by direction (S/E/N/W); Left/lower vertex: S_base; Right/upper vertex: S_base + S_step

S_step(i,direction) Increments for coordinate s[i] when progressing along the edge indicated by direction (S/E/N/W); Left/lower vertex: S_base; Right/upper vertex: S_base + S_step (static data)

Referenced by gteq_edge_neighbour(), and setup_static_data().

Static_data_has_been_setup

bool oomph::QuadTree::Static_data_has_been_setup = false

staticprotected

Bool indicating that static member data has been setup.

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

---

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

• quadtree.h
• quadtree.cc