tree.h

Go to the documentation of this file.

// LIC// ====================================================================
// LIC// This file forms part of oomph-lib, the object-oriented,
// LIC// multi-physics finite-element library, available
// LIC// at http://www.oomph-lib.org.
// LIC//
// LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel
// LIC//
// LIC// This library is free software; you can redistribute it and/or
// LIC// modify it under the terms of the GNU Lesser General Public
// LIC// License as published by the Free Software Foundation; either
// LIC// version 2.1 of the License, or (at your option) any later version.
// LIC//
// LIC// This library is distributed in the hope that it will be useful,
// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// LIC// Lesser General Public License for more details.
// LIC//
// LIC// You should have received a copy of the GNU Lesser General Public
// LIC// License along with this library; if not, write to the Free Software
// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// LIC// 02110-1301  USA.
// LIC//
// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
// LIC//
// LIC//====================================================================
// Header file for generic tree structures
#ifndef OOMPH_TREE_HEADER
#define OOMPH_TREE_HEADER
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
#ifdef OOMPH_HAS_MPI
#include "mpi.h"
#endif
 
// OOMPH-LIB headers
#include "Vector.h"
#include "map_matrix.h"
 
namespace oomph
{
  // Forward class definition for class representing the root of a Tree
  class TreeRoot;
 
  class RefineableElement;
 
  class Mesh;
 
  //========================================================================
  //=================================================================
  class Tree
  {
  public:
    virtual ~Tree();
 
    Tree(const Tree& dummy) = delete;
 
    void operator=(const Tree&) = delete;
 
    RefineableElement* object_pt() const
    {
      return Object_pt;
    }
 
    void flush_object()
    {
      Object_pt = 0;
    }
 
    Tree* son_pt(const int& son_index) const
    {
      // 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];
      }
    }
 
 
    void set_son_pt(const Vector<Tree*>& son_pt)
    {
      Son_pt = son_pt;
    }
 
    unsigned nsons() const
    {
      return Son_pt.size();
    }
 
    void flush_sons()
    {
      Son_pt.clear();
    }
 
    TreeRoot*& root_pt()
    {
      return Root_pt;
    }
 
    TreeRoot* root_pt() const
    {
      return Root_pt;
    }
 
    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();
 
    virtual Tree* construct_son(RefineableElement* const& object_pt,
                                Tree* const& father_pt,
                                const int& son_type) = 0;
 
    typedef void (Tree::*VoidMemberFctPt)();
 
    typedef void (Tree::*VoidMeshPtArgumentMemberFctPt)(Mesh*& mesh_pt);
 
 
    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*>&);
 
    void stick_all_tree_nodes_into_vector(Vector<Tree*>&);
 
    int son_type() const
    {
      return Son_type;
    }
 
    bool is_leaf()
    {
      // If there are no sons, it's a leaf, return true
      if (Son_pt.size() == 0)
      {
        return true;
      }
      // Otherwise return false
      else
      {
        return false;
      }
    }
 
    Tree* father_pt() const
    {
      return Father_pt;
    }
 
    void set_father_pt(Tree* const& father_pt)
    {
      Father_pt = father_pt;
    }
 
    unsigned level() const
    {
      return Level;
    }
 
    static double& max_neighbour_finding_tolerance()
    {
      return Max_neighbour_finding_tolerance;
    }
 
  public:
    static const int OMEGA;
 
  protected:
    Tree()
    {
      // Throw an error
      throw OomphLibError("Don't call an empty constructor for a Tree object",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    Tree(RefineableElement* const& object_pt);
 
    Tree(RefineableElement* const& object_pt,
         Tree* const& father_pt,
         const int& son_type);
 
    TreeRoot* Root_pt;
 
  protected:
    Tree* Father_pt;
 
    Vector<Tree*> Son_pt;
 
    int Level;
 
    int Son_type;
 
    RefineableElement* Object_pt;
 
    static double Max_neighbour_finding_tolerance;
  };
 
 
  //===================================================================
  //==================================================================
  class TreeRoot : public virtual Tree
  {
  protected:
    std::map<int, TreeRoot*> Neighbour_pt;
 
 
    std::map<int, bool> Neighbour_periodic;
 
  public:
    TreeRoot(RefineableElement* const& object_pt) : Tree(object_pt)
    {
      // TreeRoot is the Root
      Root_pt = this;
    }
 
 
    TreeRoot(const TreeRoot& dummy) = delete;
 
    void operator=(const TreeRoot&) = delete;
 
    TreeRoot*& neighbour_pt(const int& direction)
    {
      return Neighbour_pt[direction];
    }
 
    bool is_neighbour_periodic(const int& direction)
    {
      return Neighbour_periodic[direction];
    }
 
    void set_neighbour_periodic(const int& direction)
    {
      Neighbour_periodic[direction] = true;
    }
 
    void set_neighbour_nonperiodic(const int& direction)
    {
      Neighbour_periodic[direction] = false;
    }
 
    unsigned nneighbour()
    {
      // Loop over the neighbours and test whether they are non-null
      unsigned count = 0;
      for (std::map<int, TreeRoot*>::iterator it = Neighbour_pt.begin();
           it != Neighbour_pt.end();
           it++)
      {
        if (Neighbour_pt[it->first] != 0)
        {
          count++;
        }
      }
      // Return number counted
      return count;
    }
  };
 
 
  //================================================================
  //=================================================================
  class TreeForest
  {
  public:
    TreeForest(Vector<TreeRoot*>& trees_pt);
 
    TreeForest()
    {
      // Throw an error
      throw OomphLibError(
        "Don't call an empty constructor for a TreeForest object",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
 
    TreeForest(const TreeForest& dummy) = delete;
 
    void operator=(const TreeForest&) = delete;
 
    virtual ~TreeForest();
 
    void stick_leaves_into_vector(Vector<Tree*>& forest_nodes);
 
    void stick_all_tree_nodes_into_vector(Vector<Tree*>& all_forest_nodes);
 
    virtual void check_all_neighbours(DocInfo& doc_info) = 0;
 
    virtual void open_hanging_node_files(
      DocInfo& doc_info, Vector<std::ofstream*>& output_stream) = 0;
 
    void close_hanging_node_files(DocInfo& doc_info,
                                  Vector<std::ofstream*>& output_stream);
 
    unsigned ntree()
    {
      return Trees_pt.size();
    }
 
    TreeRoot* tree_pt(const unsigned& i) const
    {
      return Trees_pt[i];
    }
 
    void flush_trees()
    {
      // Clear Trees_pt vector
      Trees_pt.clear();
    }
 
  protected:
    Vector<TreeRoot*> Trees_pt;
  };
 
} // namespace oomph
 
#endif