HierarchicWrapper.hpp

#pragma once

#include <boost/numeric/mtl/mtl_fwd.hpp>
#include <dune/functions/functionspacebases/sizeinfo.hh>

#include <amdis/utility/MultiIndex.hpp>

namespace AMDiS
{
  template <class Matrix>
  class HierarchicMatrixWrapper
  {
  public:
    explicit HierarchicMatrixWrapper(Matrix& matrix)
      : matrix_(matrix)
    {}

    template <class RowIndex, class ColIndex>
    auto& operator()(RowIndex const& row, ColIndex const& col)
    {
      return matrix_(flatMultiIndex(row), flatMultiIndex(col));
    }

    template <class RowIndex, class ColIndex>
    auto const& operator()(RowIndex const& row, ColIndex const& col) const
    {
      return matrix_(flatMultiIndex(row), flatMultiIndex(col));
    }


  private:
    Matrix& matrix_;
  };

  template <class Matrix>
  HierarchicMatrixWrapper<Matrix> hierarchicMatrixWrapper(Matrix& matrix)
  {
    return {matrix};
  }


  template <class Vector>
  class HierarchicVectorWrapper
  {
  public:
    explicit HierarchicVectorWrapper(Vector& vector)
      : vector_(vector)
    {}

    template <class Index>
    auto& operator[](Index const& idx)
    {
      return vector_[flatMultiIndex(idx)];
    }

    template <class Index>
    auto const& operator[](Index const& idx) const
    {
      return vector_[flatMultiIndex(idx)];
    }

    template <class Basis>
    void resize(Dune::Functions::SizeInfo<Basis> const& s)
    {
      resizeImpl(vector_, s);
    }

    std::size_t size() const
    {
      return sizeImpl(vector_);
    }

  protected:

    template <class Vec, class Basis>
    void_t<decltype( std::declval<Vec>().resize(std::size_t(0)) )>
    resizeImpl(Vec& vec, Dune::Functions::SizeInfo<Basis> const& s)
    {
      vec.resize(std::size_t(s));
    }

    template <class Vec, class Basis>
    void_t<decltype( std::declval<Vec>().change_dim(std::size_t(0)) )>
    resizeImpl(Vec& vec, Dune::Functions::SizeInfo<Basis> const& s)
    {
      vec.change_dim(std::size_t(s));
    }

    template <class... Params>
    std::size_t sizeImpl(mtl::vec::dense_vector<Params...> const& v) const
    {
      return mtl::size(v);
    }

    template <class V>
    using HasSizeMember = decltype(std::declval<V>().size());

    template <class V,
      std::enable_if_t<Dune::Std::is_detected<HasSizeMember, V>::value, int> = 0>
    std::size_t sizeImpl(V const& v) const
    {
      return v.size();
    }

  private:
    Vector& vector_;
  };

  template <class Vector>
  auto hierarchicVectorWrapper(Vector& vector)
  {
    return HierarchicVectorWrapper<Vector>{vector};
  }

} // end namespace AMDiS