none_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/lafem/dense_vector.hpp>
#include <kernel/lafem/dense_vector_blocked.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<
      typename DataType_,
      typename IndexType_ = Index>
    class NoneFilter
    {
    public:
      typedef DataType_ DataType;
      typedef IndexType_ IndexType;
 
      typedef DenseVector<DataType, IndexType> VectorType;
 
      template <typename DT2_ = DataType_, typename IT2_ = IndexType_>
      using FilterType = NoneFilter<DT2_, IT2_>;
 
      template <typename DataType2_, typename IndexType2_>
      using FilterTypeByDI = FilterType<DataType2_, IndexType2_>;
 
      static constexpr bool is_global = false;
      static constexpr bool is_local = true;
 
      NoneFilter clone(CloneMode /*clone_mode*/ = CloneMode::Deep) const
      {
        return NoneFilter();
      }
 
      void clone(const NoneFilter & /*other*/, CloneMode /*clone_mode*/ = CloneMode::Deep)
      {
        // do nothing
      }
 
      template<typename DT2_, typename IT2_>
      void convert(const NoneFilter<DT2_, IT2_>&)
      {
      }
 
      std::size_t bytes() const
      {
        return 0;
      }
 
      void filter_rhs(VectorType& DOXY(vector)) const
      {
      }
 
      void filter_sol(VectorType& DOXY(vector)) const
      {
      }
 
      void filter_def(VectorType& DOXY(vector)) const
      {
      }
 
      void filter_cor(VectorType& DOXY(vector)) const
      {
      }
 
      template<typename MT_>
      void filter_mat(MT_& DOXY(matrix)) const
      {
      }
    }; // class NoneFilter<...>
 
    template<
      typename DataType_,
      typename IndexType_,
      int BlockSize_
    >
    class NoneFilterBlocked
    {
    public:
      typedef DataType_ DataType;
      typedef IndexType_ IndexType;
 
      static constexpr int BlockSize = BlockSize_;
 
      typedef DenseVectorBlocked<DataType, IndexType, BlockSize> VectorType;
 
      template <typename DT2_ = DataType_, typename IT2_ = IndexType_, int BS_ = BlockSize_>
      using FilterType = NoneFilterBlocked<DT2_, IT2_, BS_>;
 
      template <typename DataType2_, typename IndexType2_, int BlockSize2_>
      using FilterTypeByDI = FilterType<DataType2_, IndexType2_, BlockSize2_>;
 
      NoneFilterBlocked clone(CloneMode /*clone_mode*/ = CloneMode::Deep) const
      {
        return NoneFilterBlocked();
      }
 
      void clone(const NoneFilterBlocked & /*other*/, CloneMode /*clone_mode*/ = CloneMode::Deep)
      {
        // do nothing
      }
 
      template<typename DT2_, typename IT2_>
      void convert(const NoneFilterBlocked<DT2_, IT2_, BlockSize>&)
      {
      }
 
      std::size_t bytes() const
      {
        return 0;
      }
 
      void filter_rhs(VectorType& DOXY(vector)) const
      {
      }
 
      void filter_sol(VectorType& DOXY(vector)) const
      {
      }
 
      void filter_def(VectorType& DOXY(vector)) const
      {
      }
 
      void filter_cor(VectorType& DOXY(vector)) const
      {
      }
 
      template<typename MT_>
      void filter_mat(MT_& DOXY(matrix)) const
      {
      }
    }; // class NoneFilterBlocked<...>
  } // namespace LAFEM
} // namespace FEAT