transfer.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/lafem/base.hpp>
#include <kernel/util/exception.hpp>
 
#include <utility>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<typename Matrix_>
    class Transfer
    {
    public:
      typedef typename Matrix_::DataType DataType;
      typedef typename Matrix_::IndexType IndexType;
 
      typedef Matrix_ MatrixType;
      typedef typename Matrix_::VectorTypeL VectorType;
 
      template <typename DT2_, typename IT2_>
      using TransferTypeByDI = Transfer<typename Matrix_::template ContainerTypeByDI<DT2_, IT2_>>;
 
      static constexpr bool is_global = false;
      static constexpr bool is_local = true;
 
    protected:
      Matrix_ _mat_prol;
      Matrix_ _mat_rest;
      Matrix_ _mat_trunc;
 
    public:
      Transfer()
      {
      }
 
      explicit Transfer(Matrix_&& mat_prol, Matrix_&& mat_rest) :
        _mat_prol(std::forward<Matrix_>(mat_prol)),
        _mat_rest(std::forward<Matrix_>(mat_rest)),
        _mat_trunc()
      {
      }
 
 
      explicit Transfer(Matrix_&& mat_prol, Matrix_&& mat_rest, Matrix_&& mat_trunc) :
        _mat_prol(std::forward<Matrix_>(mat_prol)),
        _mat_rest(std::forward<Matrix_>(mat_rest)),
        _mat_trunc(std::forward<Matrix_>(mat_trunc))
      {
      }
 
      Transfer(Transfer&& other) :
        _mat_prol(std::forward<Matrix_>(other._mat_prol)),
        _mat_rest(std::forward<Matrix_>(other._mat_rest)),
        _mat_trunc(std::forward<Matrix_>(other._mat_trunc))
      {
      }
 
      virtual ~Transfer()
      {
      }
 
      Transfer& operator=(Transfer&& other)
      {
        if(this == &other)
          return *this;
 
        _mat_prol = std::forward<Matrix_>(other._mat_prol);
        _mat_rest = std::forward<Matrix_>(other._mat_rest);
        _mat_trunc = std::forward<Matrix_>(other._mat_trunc);
 
        return *this;
      }
 
      template<typename Matrix2_>
      void convert(const Transfer<Matrix2_>& other)
      {
        if((void*)this == (void*)&other)
          return;
 
        _mat_prol.convert(other.get_mat_prol());
        _mat_rest.convert(other.get_mat_rest());
        _mat_trunc.convert(other.get_mat_trunc());
      }
 
      Transfer clone(CloneMode clone_mode = CloneMode::Weak) const
      {
        return Transfer(_mat_prol.clone(clone_mode), _mat_rest.clone(clone_mode), _mat_trunc.clone(clone_mode));
      }
 
      std::size_t bytes() const
      {
        return _mat_prol.bytes() + _mat_rest.bytes() + _mat_trunc.bytes();
      }
 
      void compile()
      {
        // nothing to do here...
      }
 
      Matrix_& get_mat_prol()
      {
        return _mat_prol;
      }
 
      const Matrix_& get_mat_prol() const
      {
        return _mat_prol;
      }
 
      Matrix_& get_mat_rest()
      {
        return _mat_rest;
      }
 
      const Matrix_& get_mat_rest() const
      {
        return _mat_rest;
      }
 
      Matrix_& get_mat_trunc()
      {
        return _mat_trunc;
      }
 
      const Matrix_& get_mat_trunc() const
      {
        return _mat_trunc;
      }
 
      bool is_ghost() const
      {
        return false;
      }
 
      bool trunc(const VectorType& vec_fine, VectorType& vec_coarse) const
      {
        _mat_trunc.apply(vec_coarse, vec_fine);
        return true;
      }
 
      bool trunc_send(const VectorType& DOXY(vec_fine)) const
      {
        XABORTM("This function must not be called");
      }
 
      bool rest(const VectorType& vec_fine, VectorType& vec_coarse) const
      {
        _mat_rest.apply(vec_coarse, vec_fine);
        return true;
      }
 
      bool rest_send(const VectorType& DOXY(vec_fine)) const
      {
        XABORTM("This function must not be called");
      }
 
      bool prol(VectorType& vec_fine, const VectorType& vec_coarse) const
      {
        _mat_prol.apply(vec_fine, vec_coarse);
        return true;
      }
 
      bool prol_recv(VectorType& DOXY(vec_fine)) const
      {
        XABORTM("This function must not be called");
      }
 
      void prol_cancel() const
      {
        XABORTM("This function must not be called");
      }
    }; // class Transfer<...>
  } // namespace LAFEM
} // namespace FEAT