power_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
 
#include <kernel/lafem/power_vector.hpp>
#include <kernel/lafem/meta_element.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<
      typename SubFilter_,
      int count_>
    class PowerFilter
    {
      // Note: the case = 1 is specialized below
      static_assert(count_ > 1, "invalid block size");
 
      // declare this class template as a friend for recursive inheritance
      template<typename,int>
      friend class PowerFilter;
 
      typedef PowerFilter<SubFilter_, count_-1> RestClass;
 
    public:
      typedef SubFilter_ SubFilterType;
      typedef typename SubFilter_::DataType DataType;
      typedef typename SubFilter_::IndexType IndexType;
 
      static constexpr int num_blocks = count_;
 
      typedef PowerVector<typename SubFilter_::VectorType, count_> VectorType;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using FilterType = PowerFilter<typename SubFilterType::template FilterType<DT2_, IT2_>, count_>;
 
      template <typename DataType2_, typename IndexType2_>
      using FilterTypeByDI = FilterType<DataType2_, IndexType2_>;
 
    protected:
      SubFilterType _first;
      RestClass _rest;
 
      explicit PowerFilter(SubFilterType&& the_first, RestClass&& the_rest) :
        _first(std::move(the_first)),
        _rest(std::move(the_rest))
      {
      }
 
    public:
      PowerFilter()
      {
      }
 
      PowerFilter(PowerFilter&& other) :
        _first(std::move(other._first)),
        _rest(std::move(other._rest))
      {
      }
 
      PowerFilter& operator=(PowerFilter&& other)
      {
        if(this != &other)
        {
          _first = std::move(other._first);
          _rest = std::move(other._rest);
        }
        return *this;
      }
 
      PowerFilter clone(CloneMode clone_mode = CloneMode::Deep) const
      {
        return PowerFilter(first().clone(clone_mode), rest().clone(clone_mode));
      }
 
      void clone(const PowerFilter & other, CloneMode clone_mode = CloneMode::Deep)
      {
        _first.clone(other._first.get_filter_vector(), clone_mode);
        _rest.clone(other._rest, clone_mode);
      }
 
      template<typename SubFilter2_>
      void convert(const PowerFilter<SubFilter2_, count_>& other)
      {
        _first.convert(other._first);
        _rest.convert(other._rest);
      }
 
      std::size_t bytes() const
      {
        return _first.bytes() + _rest.bytes();
      }
 
      SubFilterType& first()
      {
        return _first;
      }
 
      const SubFilterType& first() const
      {
        return _first;
      }
 
      RestClass& rest()
      {
        return _rest;
      }
 
      const RestClass& rest() const
      {
        return _rest;
      }
 
      template<int i_>
      SubFilterType& at()
      {
        static_assert((0 <= i_) && (i_ < count_), "invalid sub-filter index");
        return PowerElement<i_, SubFilterType>::get(*this);
      }
 
      template<int i_>
      const SubFilterType& at() const
      {
        static_assert((0 <= i_) && (i_ < count_), "invalid sub-filter index");
        return PowerElement<i_, SubFilterType>::get(*this);
      }
 
      SubFilterType& get(int i)
      {
        XASSERTM((0 <= i) && (i < count_), "invalid sub-filter index");
        return (i == 0) ? _first : _rest.get(i-1);
      }
 
      const SubFilterType& get(int i) const
      {
        XASSERTM((0 <= i) && (i < count_), "invalid sub-filter index");
        return (i == 0) ? _first : _rest.get(i-1);
      }
 
      void filter_rhs(VectorType& vector) const
      {
        first().filter_rhs(vector.first());
        rest().filter_rhs(vector.rest());
      }
 
      void filter_sol(VectorType& vector) const
      {
        first().filter_sol(vector.first());
        rest().filter_sol(vector.rest());
      }
 
      void filter_def(VectorType& vector) const
      {
        first().filter_def(vector.first());
        rest().filter_def(vector.rest());
      }
 
      void filter_cor(VectorType& vector) const
      {
        first().filter_cor(vector.first());
        rest().filter_cor(vector.rest());
      }
    }; // class PowerFilter<...>
 
    template<typename SubFilter_>
    class PowerFilter<SubFilter_, 1>
    {
      template<typename,int>
      friend class PowerFilter;
 
    public:
      typedef SubFilter_ SubFilterType;
      typedef typename SubFilter_::DataType DataType;
      typedef typename SubFilter_::IndexType IndexType;
 
      static constexpr int num_blocks = 1;
 
      typedef PowerVector<typename SubFilter_::VectorType, 1> VectorType;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using FilterType = PowerFilter<typename SubFilterType::template FilterType<DT2_, IT2_>, Index(1)>;
 
      template <typename DataType2_, typename IndexType2_>
      using FilterTypeByDI = FilterType<DataType2_, IndexType2_>;
 
    protected:
      SubFilterType _first;
 
      explicit PowerFilter(SubFilterType&& the_first) :
        _first(std::move(the_first))
      {
      }
 
    public:
      PowerFilter()
      {
      }
 
      PowerFilter(PowerFilter&& other) :
        _first(std::move(other._first))
      {
      }
 
      PowerFilter& operator=(PowerFilter&& other)
      {
        if(this != &other)
        {
          _first = std::move(other._first);
        }
        return *this;
      }
 
      PowerFilter clone(CloneMode clone_mode = CloneMode::Deep) const
      {
        return PowerFilter(first().clone(clone_mode));
      }
 
      void clone(const PowerFilter & other, CloneMode clone_mode = CloneMode::Deep)
      {
        _first.clone(other._first.get_filter_vector(), clone_mode);
      }
 
      template<typename SubFilter2_>
      void convert(const PowerFilter<SubFilter2_, 1>& other)
      {
        _first.convert(other._first);
      }
 
      std::size_t bytes() const
      {
        return _first.bytes();
      }
 
      SubFilterType& first()
      {
        return _first;
      }
 
      const SubFilterType& first() const
      {
        return _first;
      }
 
      template<int i_>
      SubFilterType& at()
      {
        static_assert(i_ != 0, "invalid sub-filter index");
        return _first;
      }
 
      template<int i_>
      const SubFilterType& at() const
      {
        static_assert(i_ != 0, "invalid sub-filter index");
        return _first;
      }
 
      SubFilterType& get(int i)
      {
        XASSERTM(i == 0, "invalid sub-filter index");
        return _first;
      }
 
      const SubFilterType& get(int i) const
      {
        XASSERTM(i == 0, "invalid sub-filter index");
        return _first;
      }
 
      void filter_rhs(VectorType& vector) const
      {
        first().filter_rhs(vector.first());
      }
 
      void filter_sol(VectorType& vector) const
      {
        first().filter_sol(vector.first());
      }
 
      void filter_def(VectorType& vector) const
      {
        first().filter_def(vector.first());
      }
 
      void filter_cor(VectorType& vector) const
      {
        first().filter_cor(vector.first());
      }
    };
  } // namespace LAFEM
} // namespace FEAT