double_vector_with_halo.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//====================================================================
#ifndef OOMPH_DOUBLE_VECTOR_WITH_HALO_CLASS_HEADER
#define OOMPH_DOUBLE_VECTOR_WITH_HALO_CLASS_HEADER
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
#include <map>
#include "double_vector.h"
 
namespace oomph
{
  class DoubleVectorWithHaloEntries;
 
  //=====================================================================
  //=====================================================================
  class DoubleVectorHaloScheme
  {
    friend class DoubleVectorWithHaloEntries;
 
    std::map<unsigned, unsigned> Local_index;
 
    Vector<unsigned> Haloed_eqns;
 
    Vector<int> Haloed_n;
 
    Vector<int> Haloed_displacement;
 
    Vector<unsigned> Halo_eqns;
 
    Vector<int> Halo_n;
 
    Vector<int> Halo_displacement;
 
 
    LinearAlgebraDistribution* Distribution_pt;
 
  public:
    DoubleVectorHaloScheme(LinearAlgebraDistribution* const& dist_pt,
                           const Vector<unsigned>& required_global_eqn);
 
    inline unsigned n_halo_values() const
    {
      return Local_index.size();
    }
 
    inline LinearAlgebraDistribution*& distribution_pt()
    {
      return Distribution_pt;
    }
 
    void setup_halo_dofs(const std::map<unsigned, double*>& halo_data_pt,
                         Vector<double*>& halo_dof_pt);
 
 
    inline unsigned local_index(const unsigned& global_eqn)
    {
      // Does the entry exist in the map
      std::map<unsigned, unsigned>::iterator it = Local_index.find(global_eqn);
      // If it does return it
      if (it != Local_index.end())
      {
        return it->second;
      }
      // Otherwise throw an error
      else
      {
        std::ostringstream error_stream;
        error_stream << "Global equation " << global_eqn << " "
                     << "has not been set as halo\n";
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
        return 0;
      }
    }
  };
 
 
  class DoubleVectorWithHaloEntries : public DoubleVector
  {
    DoubleVectorHaloScheme* Halo_scheme_pt;
 
    Vector<double> Halo_value;
 
  public:
    DoubleVectorWithHaloEntries() : DoubleVector(), Halo_scheme_pt(0) {}
 
    DoubleVectorWithHaloEntries(
      const LinearAlgebraDistribution* const& dist_pt,
      DoubleVectorHaloScheme* const& halo_scheme_pt = 0,
      const double& v = 0.0)
      : DoubleVector(dist_pt, v)
    {
      // construct the halo scheme
      this->build_halo_scheme(halo_scheme_pt);
    }
 
    DoubleVectorWithHaloEntries(
      const LinearAlgebraDistribution& dist,
      DoubleVectorHaloScheme* const& halo_scheme_pt = 0,
      const double& v = 0.0)
      : DoubleVector(dist, v)
    {
      // construct the halo scheme
      this->build_halo_scheme(halo_scheme_pt);
    }
 
    ~DoubleVectorWithHaloEntries() {}
 
 
    DoubleVectorWithHaloEntries(const DoubleVectorWithHaloEntries& new_vector)
      : DoubleVector(new_vector)
    {
      // Build the appropriate halo scheme
      this->build_halo_scheme(new_vector.halo_scheme_pt());
    }
 
    DoubleVectorWithHaloEntries(
      const DoubleVector& new_vector,
      DoubleVectorHaloScheme* const& halo_scheme_pt = 0)
      : DoubleVector(new_vector)
    {
      // Construct the halo scheme
      this->build_halo_scheme(halo_scheme_pt);
    }
 
    void operator=(const DoubleVectorWithHaloEntries& old_vector)
    {
      this->build(old_vector);
      // Do some other stuff
      this->build_halo_scheme(old_vector.halo_scheme_pt());
    }
 
    inline double& global_value(const unsigned& i)
    {
      // Only need to worry about the distributed case if
      // we have compiled with MPI
#ifdef OOMPH_HAS_MPI
      if (this->distributed())
      {
        const unsigned first_row_local = this->first_row();
        const unsigned n_row_local = this->nrow_local();
 
        // If we are in range then just call the local value
        if ((i >= first_row_local) && (i < first_row_local + n_row_local))
        {
          return (*this)[i - first_row_local];
        }
        // Otherwise the entry is not stored in the local processor
        // and we must have haloed it
        else
        {
#ifdef PARANOID
          if (Halo_scheme_pt == 0)
          {
            std::ostringstream error_stream;
            error_stream
              << "Halo data requested, but no halo scheme has been setup\n"
              << "You should call this->build_halo_scheme(halo_scheme_pt).\n"
              << "You may wish to setup the scheme for the Problem using \n"
              << "Problem::setup_dof_halo_scheme()\n";
 
            throw OomphLibError(error_stream.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
          }
#endif
          return Halo_value[Halo_scheme_pt->local_index(i)];
        }
      }
      // If not distributed the global entry is
      // the local entry
      else
#endif
      {
        return (*this)[i];
      }
    }
 
    const double& global_value(const unsigned& i) const
    {
      // Only need to worry about the distributed case if
      // we have compiled with MPI
#ifdef OOMPH_HAS_MPI
      if (this->distributed())
      {
        const unsigned first_row_local = this->first_row();
        const unsigned n_row_local = this->nrow_local();
 
        // If we are in range then just call the local value
        if ((i >= first_row_local) && (i < first_row_local + n_row_local))
        {
          return (*this)[i - first_row_local];
        }
        // Otherwise the entry is not stored in the local processor
        // and we must have haloed it
        else
        {
#ifdef PARANOID
          if (Halo_scheme_pt == 0)
          {
            std::ostringstream error_stream;
            error_stream
              << "Halo data requested, but no halo scheme has been setup\n"
              << "You should call this->build_halo_scheme(halo_scheme_pt).\n"
              << "You may wish to setup the scheme for the Problem using \n"
              << "Problem::setup_dof_halo_scheme()\n";
 
            throw OomphLibError(error_stream.str(),
                                OOMPH_CURRENT_FUNCTION,
                                OOMPH_EXCEPTION_LOCATION);
          }
#endif
          return Halo_value[Halo_scheme_pt->local_index(i)];
        }
      }
      // If not distributed the global entry is
      // the local entry
      else
#endif
      {
        return (*this)[i];
      }
    }
 
 
    void synchronise();
 
    void sum_all_halo_and_haloed_values();
 
    DoubleVectorHaloScheme*& halo_scheme_pt()
    {
      return Halo_scheme_pt;
    }
 
    DoubleVectorHaloScheme* const& halo_scheme_pt() const
    {
      return Halo_scheme_pt;
    }
 
 
    void build_halo_scheme(DoubleVectorHaloScheme* const& halo_scheme_pt);
  };
 
} // namespace oomph
#endif