slip_filter.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
 
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/lafem/sparse_matrix_bcsr.hpp>
#include <kernel/lafem/dense_vector_blocked.hpp>
#include <kernel/lafem/sparse_vector_blocked.hpp>
#include <kernel/lafem/arch/slip_filter.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<
      typename DT_,
      typename IT_,
      int BlockSize_>
    class SlipFilter
    {
      public:
        typedef DT_ DataType;
        typedef IT_ IndexType;
        static constexpr int BlockSize = BlockSize_;
        typedef Tiny::Vector<DataType, BlockSize> ValueType;
        typedef DenseVectorBlocked<DT_, IT_, BlockSize_> VectorType;
 
        template <typename DT2_ = DT_, typename IT2_ = IT_>
        using FilterType = SlipFilter<DT2_, IT2_, BlockSize_>;
 
        template <typename DT2_ = DT_, typename IT2_ = IT_>
        using FilterTypeByDI = FilterType<DT2_, IT2_>;
 
        static_assert(BlockSize > 1, "BlockSize has to be >= 2 in SlipFilter!");
 
      private:
        SparseVectorBlocked<DT_, IT_, BlockSize_> _nu;
        SparseVectorBlocked<DT_, IT_, BlockSize_> _sv;
 
      public:
        SlipFilter() :
          _nu(),
          _sv()
          {
          }
 
        explicit SlipFilter(Index num_vertices, Index num_dofs) :
          _nu(num_vertices),
          _sv(num_dofs)
          {
          }
 
        SlipFilter(SlipFilter && other) :
          _nu(std::move(other._nu)),
          _sv(std::move(other._sv))
          {
          }
 
        SlipFilter & operator=(SlipFilter && other)
        {
          if(this != &other)
          {
            _sv = std::forward<decltype(other._sv)>(other._sv);
            _nu = std::forward<decltype(other._nu)>(other._nu);
          }
          return *this;
        }
 
        virtual ~SlipFilter()
        {
        }
 
        SlipFilter clone(CloneMode clone_mode = CloneMode::Deep) const
        {
          SlipFilter other;
          other.clone(*this, clone_mode);
          return other;
        }
 
        void clone(const SlipFilter & other, CloneMode clone_mode = CloneMode::Deep)
        {
          _nu.clone(other.get_nu(), clone_mode);
          _sv.clone(other.get_filter_vector(), clone_mode);
        }
 
        template<typename DT2_, typename IT2_, int BS_>
        void convert(const SlipFilter<DT2_, IT2_, BS_>& other)
        {
          _nu.convert(other.get_nu());
          _sv.convert(other.get_filter_vector());
        }
 
        void clear()
        {
          _nu.clear();
          _sv.clear();
        }
 
        std::size_t bytes() const
        {
          return _nu.bytes() + _sv.bytes();
        }
 
        SparseVectorBlocked<DT_, IT_, BlockSize>& get_filter_vector()
        {
          return _sv;
        }
        const SparseVectorBlocked<DT_, IT_, BlockSize>& get_filter_vector() const
        {
          return _sv;
        }
 
        SparseVectorBlocked<DT_, IT_, BlockSize>& get_nu()
        {
          return _nu;
        }
        const SparseVectorBlocked<DT_, IT_, BlockSize>& get_nu() const
        {
          return _nu;
        }
 
        void add(IndexType idx, ValueType val)
        {
          _sv(idx, val);
        }
 
        Index size() const
        {
          return _sv.size();
        }
 
        Index used_elements() const
        {
          return _sv.used_elements();
        }
 
        IT_* get_indices()
        {
          return _sv.indices();
        }
 
        const IT_* get_indices() const
        {
          return _sv.indices();
        }
 
        ValueType* get_values()
        {
          return _sv.elements();
        }
 
        const ValueType* get_values() const
        {
          return _sv.elements();
        }
 
        bool empty() const
        {
          return _sv.used_elements() <= Index(0);
        }
 
        void filter_rhs(VectorType& vector) const
        {
          if(_sv.empty())
            return;
          XASSERTM(_sv.size() == vector.size(), "Vector size does not match!");
          if(_sv.used_elements() > Index(0))
            Arch::SlipFilter::template filter_rhs<BlockSize_>
              (vector.template elements<Perspective::pod>(), _sv.template elements<Perspective::pod>(), _sv.indices(), _sv.used_elements());
        }
 
        void filter_sol(VectorType& vector) const
        {
          if(_sv.empty())
            return;
          // same as rhs
          filter_rhs(vector);
        }
 
        void filter_def(VectorType& vector) const
        {
          if(_sv.empty())
            return;
          XASSERTM(_sv.size() == vector.size(), "Vector size does not match!");
          if(_sv.used_elements() > Index(0))
            Arch::SlipFilter::template filter_def<BlockSize_>
              (vector.template elements<Perspective::pod>(), _sv.template elements<Perspective::pod>(), _sv.indices(), _sv.used_elements() );
        }
 
        void filter_cor(VectorType& vector) const
        {
          // same as def
          filter_def(vector);
        }
    }; // class SlipFilter<...>
  } // namespace LAFEM
} // namespace FEAT