sparse_layout.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/util/memory_pool.hpp>
#include <kernel/lafem/forward.hpp>
#include <kernel/lafem/base.hpp>
 
#include <vector>
 
namespace FEAT
{
  namespace LAFEM
  {
    namespace Intern
    {
      template <SparseLayoutId LT_>
      struct LayoutId;
 
      template <>
      struct LayoutId<SparseLayoutId::lt_csr>
      {
        template<typename DT_, typename IT_>
        using MatrixType = SparseMatrixCSR<DT_, IT_>;
      };
 
      template <>
      struct LayoutId<SparseLayoutId::lt_cscr>
      {
        template<typename DT_, typename IT_>
        using MatrixType = SparseMatrixCSCR<DT_, IT_>;
      };
 
      template <>
      struct LayoutId<SparseLayoutId::lt_banded>
      {
        template<typename DT_, typename IT_>
        using MatrixType = SparseMatrixBanded<DT_, IT_>;
      };
 
    } // namespace Intern
 
    template <typename IT_, SparseLayoutId Layout_>
    class SparseLayout
    {
    public:
      std::vector<IT_*> _indices;
      std::vector<Index> _indices_size;
      std::vector<Index> _scalar_index;
 
      template<typename DT_>
      using MatrixType = typename Intern::LayoutId<Layout_>::template MatrixType<DT_, IT_>;
 
      SparseLayout() :
        _indices(),
        _indices_size(),
        _scalar_index()
      {
      }
 
      SparseLayout(const std::vector<IT_ *> & indices, const std::vector<Index> & indices_size, const std::vector<Index> & scalar_index) :
        _indices(indices),
        _indices_size(indices_size),
        _scalar_index(scalar_index)
      {
        for(auto i : this->_indices)
          MemoryPool::increase_memory(i);
      }
 
      SparseLayout(SparseLayout && other) :
        _indices(std::move(other._indices)),
        _indices_size(std::move(other._indices_size)),
        _scalar_index(std::move(other._scalar_index))
      {
      }
 
      virtual ~SparseLayout()
      {
        for(auto i : this->_indices)
          MemoryPool::release_memory(i);
      }
 
      SparseLayout & operator= (SparseLayout && other)
      {
        _indices = std::move(other._indices);
        _indices_size = std::move(other._indices_size);
        _scalar_index = std::move(other._scalar_index);
 
        return *this;
      }
 
      const std::vector<IT_*> & get_indices() const
      {
        return _indices;
      }
 
      const std::vector<Index> & get_indices_size() const
      {
        return _indices_size;
      }
 
      const std::vector<Index> & get_scalar_index() const
      {
        return _scalar_index;
      }
    };
  } // namespace LAFEM
} // namespace FEAT