binary_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 binary tree and binary tree forest classes
#ifndef OOMPH_BINARY_TREE_HEADER
#define OOMPH_BINARY_TREE_HEADER
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
// oomph-lib headers
#include "tree.h"
#include "matrices.h"
 
namespace oomph
{
  //======================================================================
  //======================================================================
  namespace BinaryTreeNames
  {
    enum
    {
      L,
      R,
      OMEGA = 26
    };
  }; // namespace BinaryTreeNames
 
  // Forward class definition for class representing the root of a BinaryTree
  class BinaryTreeRoot;
 
  //======================================================================
  //======================================================================
  class BinaryTree : public virtual Tree
  {
  public:
    virtual ~BinaryTree() {}
 
    BinaryTree(const BinaryTree& dummy) = delete;
 
    void operator=(const BinaryTree&) = delete;
 
    Tree* construct_son(RefineableElement* const& object_pt,
                        Tree* const& father_pt,
                        const int& son_type)
    {
      BinaryTree* temp_binary_pt =
        new BinaryTree(object_pt, father_pt, son_type);
      return temp_binary_pt;
    }
 
    BinaryTree* gteq_edge_neighbour(const int& direction,
                                    Vector<double>& s_in_neighbour,
                                    int& edge,
                                    int& diff_level,
                                    bool& in_neighbouring_tree) const;
 
    unsigned self_test();
 
    static void setup_static_data();
 
    static void doc_neighbours(Vector<Tree*> forest_nodes_pt,
                               std::ofstream& neighbours_file,
                               std::ofstream& neighbours_txt_file,
                               double& max_error);
 
    static Vector<std::string> Direct_string;
 
  protected:
    BinaryTree()
    {
      throw OomphLibError(
        "Don't call an empty constructor for a BinaryTree object",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
 
    BinaryTree(RefineableElement* const& object_pt) : Tree(object_pt) {}
 
    BinaryTree(RefineableElement* const& object_pt,
               Tree* const& father_pt,
               const int& son_type)
      : Tree(object_pt, father_pt, son_type)
    {
    }
 
    static bool Static_data_has_been_setup;
 
  private:
    BinaryTree* gteq_edge_neighbour(const int& direction,
                                    double& s_diff,
                                    int& diff_level,
                                    bool& in_neighbouring_tree,
                                    int max_level,
                                    BinaryTreeRoot* const& orig_root_pt) const;
 
    static Vector<std::string> Colour;
 
    static Vector<double> S_base;
 
    static Vector<int> Reflect_edge;
 
    static DenseMatrix<bool> Is_adjacent;
 
    static DenseMatrix<int> Reflect;
  };
 
 
  //======================================================================
  //======================================================================
  class BinaryTreeRoot : public virtual BinaryTree, public virtual TreeRoot
  {
  public:
    BinaryTreeRoot(RefineableElement* const& object_pt)
      : Tree(object_pt), BinaryTree(object_pt), TreeRoot(object_pt)
    {
#ifdef PARANOID
      // Check that static member data has been setup
      if (!Static_data_has_been_setup)
      {
        std::string error_message =
          "Static member data hasn't been setup yet.\n";
        error_message +=
          "Call BinaryTree::setup_static_data() before creating\n";
        error_message += "any BinaryTreeRoots\n";
 
        throw OomphLibError(
          error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
    }
 
    BinaryTreeRoot(const BinaryTreeRoot& dummy) = delete;
 
    void operator=(const BinaryTreeRoot&) = delete;
 
    int direction_of_neighbour(BinaryTreeRoot* binary_tree_root_pt)
    {
      using namespace BinaryTreeNames;
 
      if (Neighbour_pt[L] == binary_tree_root_pt)
      {
        return L;
      }
      if (Neighbour_pt[R] == binary_tree_root_pt)
      {
        return R;
      }
 
      // If we get here, it's not a neighbour
      return OMEGA;
    }
  };
 
 
  //======================================================================
  //======================================================================
  class BinaryTreeForest : public TreeForest
  {
  public:
    BinaryTreeForest()
    {
      // Throw an error
      throw OomphLibError(
        "Don't call an empty constructor for a BinaryTreeForest object",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
 
    BinaryTreeForest(Vector<TreeRoot*>& trees_pt);
 
    BinaryTreeForest(const BinaryTreeForest& dummy) = delete;
 
    void operator=(const BinaryTreeForest&) = delete;
 
    virtual ~BinaryTreeForest() {}
 
    void check_all_neighbours(DocInfo& doc_info);
 
    void open_hanging_node_files(DocInfo& doc_info,
                                 Vector<std::ofstream*>& output_stream)
    {
    }
 
    unsigned self_test();
 
  private:
    void find_neighbours();
 
    BinaryTreeRoot* binary_tree_pt(const unsigned& i)
    {
      return dynamic_cast<BinaryTreeRoot*>(Trees_pt[i]);
    }
 
    BinaryTreeRoot* binary_neigh_pt(const unsigned& i, const int& direction)
    {
      return dynamic_cast<BinaryTreeRoot*>(
        Trees_pt[i]->neighbour_pt(direction));
    }
  };
 
} // namespace oomph
 
#endif