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/global/muxer.hpp>
#include <kernel/global/vector.hpp>
#include <kernel/lafem/transfer.hpp>
 
namespace FEAT
{
  namespace Global
  {
    template<typename LocalTransfer_, typename Mirror_>
    class Transfer
    {
    public:
      typedef LocalTransfer_ LocalTransferType;
      typedef typename LocalTransfer_::MatrixType LocalMatrixType;
      typedef typename LocalTransfer_::VectorType LocalVectorType;
 
      typedef Global::Vector<LocalVectorType, Mirror_> VectorType;
 
      typedef Global::Muxer<LocalVectorType, Mirror_> MuxerType;
 
      template <typename DT2_, typename IT2_>
      using TransferTypeByDI = Transfer<
        typename LocalTransfer_::template TransferTypeByDI<DT2_, IT2_>,
        typename Mirror_::template MirrorType<DT2_, IT2_> >;
 
      static constexpr bool is_global = true;
      static constexpr bool is_local = false;
 
    public:
      const MuxerType* _coarse_muxer;
      LocalTransfer_ _transfer;
      mutable LocalVectorType _vec_tmp;
 
    public:
      Transfer() :
        _coarse_muxer(nullptr)
      {
      }
 
      Transfer(Transfer&& other) :
        _coarse_muxer(other._coarse_muxer),
        _transfer(std::forward<LocalTransfer_>(other._transfer)),
        _vec_tmp(std::forward<LocalVectorType>(other._vec_tmp))
      {
      }
 
      template<typename... Args_>
      explicit Transfer(const MuxerType* coarse_muxer, Args_&&... args) :
        _coarse_muxer(coarse_muxer),
        _transfer(std::forward<Args_>(args)...),
        _vec_tmp(_transfer.get_mat_rest().create_vector_l())
      {
      }
 
      virtual ~Transfer()
      {
      }
 
      Transfer& operator=(Transfer&& other)
      {
        if(this == &other)
          return *this;
 
        _coarse_muxer = other._coarse_muxer;
        _transfer = std::forward<LocalTransfer_>(other._transfer);
        _vec_tmp = std::forward<LocalVectorType>(other._vec_tmp);
 
        return *this;
      }
 
      template<typename LocalTransfer2_, typename Mirror2_>
      void convert(MuxerType* coarse_muxer, const Transfer<LocalTransfer2_, Mirror2_>& other)
      {
        if((void*)this == (void*)&other)
          return;
 
        _coarse_muxer = coarse_muxer;
        _transfer.convert(other._transfer);
        _vec_tmp.convert(other._vec_tmp);
      }
 
      Transfer clone(LAFEM::CloneMode clone_mode = LAFEM::CloneMode::Weak) const
      {
        return Transfer(_coarse_muxer, _transfer.clone(clone_mode));
      }
 
      LocalTransfer_& local()
      {
        return _transfer;
      }
 
      const LocalTransfer_& local() const
      {
        return _transfer;
      }
 
      std::size_t bytes() const
      {
        return _transfer.bytes() + _vec_tmp.bytes();
      }
 
      void compile()
      {
        _transfer.compile();
        _vec_tmp = _transfer.get_mat_rest().create_vector_l();
      }
 
      LocalVectorType& get_vec_temp()
      {
        return _vec_tmp;
      }
 
      LocalMatrixType& get_mat_prol()
      {
        return _transfer.get_mat_prol();
      }
 
      const LocalMatrixType& get_mat_prol() const
      {
        return _transfer.get_mat_prol();
      }
 
      LocalMatrixType& get_mat_rest()
      {
        return _transfer.get_mat_rest();
      }
 
      const LocalMatrixType& get_mat_rest() const
      {
        return _transfer.get_mat_rest();
      }
 
      LocalMatrixType& get_mat_trunc()
      {
        return _transfer.get_mat_trunc();
      }
 
      const LocalMatrixType& get_mat_trunc() const
      {
        return _transfer.get_mat_trunc();
      }
 
      bool is_ghost() const
      {
        return (_coarse_muxer != nullptr) && _coarse_muxer->is_ghost();
      }
 
      bool trunc(const VectorType& vec_fine, VectorType& vec_coarse) const
      {
        if((_coarse_muxer == nullptr) || (!_coarse_muxer->is_child()))
        {
          _transfer.trunc(vec_fine.local(), vec_coarse.local());
        }
        else
        {
          XASSERT(_coarse_muxer->is_parent());
          _transfer.trunc(vec_fine.local(), _vec_tmp);
          _coarse_muxer->join(_vec_tmp, vec_coarse.local());
        }
        vec_coarse.sync_0();
        return true;
      }
 
      bool trunc_send(const VectorType& vec_fine) const
      {
        XASSERT(_coarse_muxer != nullptr);
        XASSERT(_coarse_muxer->is_ghost());
        _transfer.trunc(vec_fine.local(), _vec_tmp);
        _coarse_muxer->join_send(_vec_tmp);
        return true;
      }
 
      bool rest(const VectorType& vec_fine, VectorType& vec_coarse) const
      {
        if((_coarse_muxer == nullptr) || (!_coarse_muxer->is_child()))
        {
          _transfer.rest(vec_fine.local(), vec_coarse.local());
        }
        else
        {
          XASSERT(_coarse_muxer->is_parent());
          _transfer.rest(vec_fine.local(), _vec_tmp);
          _coarse_muxer->join(_vec_tmp, vec_coarse.local());
        }
        vec_coarse.sync_0();
        return true;
      }
 
      bool rest_send(const VectorType& vec_fine) const
      {
        XASSERT(_coarse_muxer != nullptr);
        XASSERT(_coarse_muxer->is_ghost());
        _transfer.rest(vec_fine.local(), _vec_tmp);
        _coarse_muxer->join_send(_vec_tmp);
        return true;
      }
 
      bool prol(VectorType& vec_fine, const VectorType& vec_coarse) const
      {
        if((_coarse_muxer == nullptr) || (!_coarse_muxer->is_child()))
        {
          _transfer.prol(vec_fine.local(), vec_coarse.local());
        }
        else
        {
          XASSERT(_coarse_muxer->is_child());
          XASSERT(_coarse_muxer->is_parent());
          _coarse_muxer->split(_vec_tmp, vec_coarse.local());
          _transfer.prol(vec_fine.local(), _vec_tmp);
        }
        vec_fine.sync_0();
        return true;
      }
 
      void prol_cancel() const
      {
        XASSERTM(false, "this function must not be called");
      }
 
      bool prol_recv(VectorType& vec_fine) const
      {
        XASSERT(_coarse_muxer != nullptr);
        XASSERT(_coarse_muxer->is_ghost());
        _coarse_muxer->split_recv(_vec_tmp);
        _transfer.prol(vec_fine.local(), _vec_tmp);
        vec_fine.sync_0();
        return true;
      }
    }; // class Transfer<..>
  } // namespace Global
} // namespace FEAT