sparse_matrix_bwrappedcsr.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_csr.hpp>
#include <kernel/lafem/sparse_matrix_bcsr.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<typename DT_, typename IT_, int BlockSize_>
    class SparseMatrixBWrappedCSR : public LAFEM::SparseMatrixCSR<DT_, IT_>
    {
    public:
      typedef DT_ DataType;
      typedef IT_ IndexType;
 
      static constexpr int BlockHeight = BlockSize_;
      static constexpr int BlockWidth = BlockSize_;
 
      typedef LAFEM::SparseMatrixCSR<DT_, IT_> BaseClass;
      typedef LAFEM::SparseMatrixBCSR<DT_, IT_, BlockSize_, BlockSize_> PretendType;
 
      typedef typename PretendType::VectorTypeL VectorTypeL;
      typedef typename PretendType::VectorTypeR VectorTypeR;
 
      using BaseClass::BaseClass;
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      using ContainerType = SparseMatrixBWrappedCSR<DT2_, IT2_, BlockSize_>;
 
      template <typename DataType2_, typename IndexType2_>
      using ContainerTypeByDI = ContainerType<DataType2_, IndexType2_>;
 
      SparseMatrixBWrappedCSR()
      {
      }
 
      explicit SparseMatrixBWrappedCSR(BaseClass&& other) :
        BaseClass(std::forward<BaseClass>(other))
      {
      }
 
      VectorTypeL create_vector_l() const
      {
        return VectorTypeL(this->rows());
      }
 
      VectorTypeR create_vector_r() const
      {
        return VectorTypeR(this->columns());
      }
 
      template <typename DT2_, typename IT2_>
      void convert(const SparseMatrixCSR<DT2_, IT2_> & other)
      {
        BaseClass::convert(other);
      }
 
      SparseMatrixBWrappedCSR clone(CloneMode mode = CloneMode::Weak) const
      {
        return SparseMatrixBWrappedCSR(BaseClass::clone(mode));
      }
 
      LAFEM::SparseMatrixCSR<DT_, IT_>& unwrap()
      {
        return *this;
      }
 
      const LAFEM::SparseMatrixCSR<DT_, IT_>& unwrap() const
      {
        return *this;
      }
    };
  } // namespace LAFEM
} // namespace FEAT