matrix_mirror_buffer.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/forward.hpp>
#include <kernel/util/assertion.hpp>
#include <kernel/util/type_traits.hpp>
#include <kernel/lafem/container.hpp>
#include <kernel/adjacency/graph.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    template < typename DT_, typename IT_ = Index>
    class MatrixMirrorBuffer : public Container<DT_, IT_>
    {
    public:
 
      typedef DT_ DataType;
      typedef IT_ IndexType;
      typedef DT_ ValueType;
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      using ContainerType = MatrixMirrorBuffer<DT2_, IT2_>;
 
      template <typename DataType2_, typename IndexType2_>
      using ContainerTypeByDI = ContainerType<DataType2_, IndexType2_>;
 
      explicit MatrixMirrorBuffer() :
        Container<DT_, IT_> (0)
      {
      }
 
      MatrixMirrorBuffer(Index rows_in, Index columns_in, Index used_elements_in, Index entries_per_nonzero_in) :
        Container<DT_, IT_>(rows_in * columns_in)
      {
        this->_scalar_index.push_back(rows_in);
        this->_scalar_index.push_back(columns_in);
        this->_scalar_index.push_back(used_elements_in);
        this->_scalar_index.push_back(entries_per_nonzero_in);
 
        this->_indices.push_back(MemoryPool::template allocate_memory<IT_>(used_elements()));
        this->_indices_size.push_back(used_elements());
 
        this->_indices.push_back(MemoryPool::template allocate_memory<IT_>(rows() + 1));
        this->_indices_size.push_back(rows() + 1);
 
        this->_elements.push_back(MemoryPool::template allocate_memory<DT_>(used_elements() * entries_per_nonzero()));
        this->_elements_size.push_back(used_elements() * entries_per_nonzero());
      }
 
      explicit MatrixMirrorBuffer(const Adjacency::Graph & graph, Index entries_per_nonzero_in) :
        Container<DT_, IT_>(0)
      {
        Index num_rows = graph.get_num_nodes_domain();
        Index num_cols = graph.get_num_nodes_image();
        Index num_nnze = graph.get_num_indices();
 
        // create temporary vectors
        LAFEM::DenseVector<IT_, IT_> vrow_ptr(num_rows+1);
        LAFEM::DenseVector<IT_, IT_> vcol_idx(num_nnze);
        LAFEM::DenseVector<DT_, IT_> vdata(num_nnze * entries_per_nonzero_in, DT_(0));
 
        const Index * dom_ptr(graph.get_domain_ptr());
        const Index * img_idx(graph.get_image_idx());
        IT_ * prow_ptr(vrow_ptr.elements());
        IT_ * pcol_idx(vcol_idx.elements());
 
        // build row-end
        prow_ptr[0] = IT_(dom_ptr[0]);
        for(Index i(0); i < num_rows; ++i)
          prow_ptr[i+1] = IT_(dom_ptr[i+1]);
 
        // build col-idx
        for(Index i(0); i < num_nnze; ++i)
          pcol_idx[i] = IT_(img_idx[i]);
 
        // build the matrix
        this->move(MatrixMirrorBuffer<DT_, IT_>(num_rows, num_cols, entries_per_nonzero_in, vcol_idx, vdata, vrow_ptr));
      }
 
      explicit MatrixMirrorBuffer(const Index rows_in, const Index columns_in, Index entries_per_nonzero_in,
                               DenseVector<IT_, IT_> & col_ind_in, DenseVector<DT_, IT_> & val_in, DenseVector<IT_, IT_> & row_ptr_in) :
        Container<DT_, IT_>(rows_in * columns_in)
      {
        XASSERT(val_in.size() % entries_per_nonzero_in == 0);
        XASSERT(val_in.size() == col_ind_in.size() * entries_per_nonzero_in);
 
        this->_scalar_index.push_back(rows_in);
        this->_scalar_index.push_back(columns_in);
        this->_scalar_index.push_back(col_ind_in.size());
        this->_scalar_index.push_back(entries_per_nonzero_in);
 
        this->_elements.push_back(val_in.elements());
        this->_elements_size.push_back(val_in.size());
        this->_indices.push_back(col_ind_in.elements());
        this->_indices_size.push_back(col_ind_in.size());
        this->_indices.push_back(row_ptr_in.elements());
        this->_indices_size.push_back(row_ptr_in.size());
 
        for (Index i(0) ; i < this->_elements.size() ; ++i)
          MemoryPool::increase_memory(this->_elements.at(i));
        for (Index i(0) ; i < this->_indices.size() ; ++i)
          MemoryPool::increase_memory(this->_indices.at(i));
      }
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      explicit MatrixMirrorBuffer(std::vector<char> input) :
        Container<DT_, IT_>(0)
      {
        deserialize<DT2_, IT2_>(input);
      }
 
      MatrixMirrorBuffer(MatrixMirrorBuffer && other) :
        Container<DT_, IT_>(std::forward<MatrixMirrorBuffer>(other))
      {
      }
 
      MatrixMirrorBuffer & operator= (MatrixMirrorBuffer && other)
      {
        this->move(std::forward<MatrixMirrorBuffer>(other));
 
        return *this;
      }
 
      MatrixMirrorBuffer clone(CloneMode clone_mode = CloneMode::Weak) const
      {
        MatrixMirrorBuffer t;
        t.clone(*this, clone_mode);
        return t;
      }
 
      template<typename DT2_, typename IT2_>
      void clone(const MatrixMirrorBuffer<DT2_, IT2_> & other, CloneMode clone_mode = CloneMode::Weak)
      {
        Container<DT_, IT_>::clone(other, clone_mode);
      }
 
      template <typename DT2_, typename IT2_>
      void convert(const MatrixMirrorBuffer<DT2_, IT2_> & other)
      {
        this->assign(other);
      }
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      void deserialize(std::vector<char> input)
      {
        this->template _deserialize<DT2_, IT2_>(FileMode::fm_csr, input);
      }
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      std::vector<char> serialize() const
      {
        return this->template _serialize<DT2_, IT2_>(FileMode::fm_csr);
      }
 
      template <Perspective = Perspective::native>
      Index rows() const
      {
        return this->_scalar_index.at(1);
      }
 
      template <Perspective = Perspective::native>
      Index columns() const
      {
        return this->_scalar_index.at(2);
      }
 
      template <Perspective = Perspective::native>
      Index used_elements() const
      {
        return this->_scalar_index.at(3);
      }
 
      template <Perspective = Perspective::native>
      Index entries_per_nonzero() const
      {
        return this->_scalar_index.at(4);
      }
 
      template <Perspective = Perspective::native>
      Index val_size() const
      {
        return this->_scalar_index.at(3) * this->_scalar_index.at(4);
      }
 
      IT_ * col_ind()
      {
        if (this->_indices.size() == 0)
          return nullptr;
 
        return this->_indices.at(0);
      }
 
      IT_ const * col_ind() const
      {
        if (this->_indices.size() == 0)
          return nullptr;
 
        return this->_indices.at(0);
      }
 
      DT_ * val()
      {
        if (this->_elements.size() == 0)
          return nullptr;
 
        return this->_elements.at(0);
      }
 
      DT_ const * val() const
      {
        if (this->_elements.size() == 0)
          return nullptr;
 
        return this->_elements.at(0);
      }
 
      IT_ * row_ptr()
      {
        if (this->_indices.size() == 0)
          return nullptr;
 
        return this->_indices.at(1);
      }
 
      IT_ const * row_ptr() const
      {
        if (this->_indices.size() == 0)
          return nullptr;
 
        return this->_indices.at(1);
      }
 
    }; //MatrixMirrorBuffer
 
  } // namespace LAFEM
} // namespace FEAT