adp_solver_base.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/solver/base.hpp>
#include <kernel/global/alg_dof_parti.hpp>
#include <kernel/global/matrix.hpp>
#include <kernel/global/filter.hpp>
#include <kernel/global/vector.hpp>
#include <kernel/global/pmdcdsc_matrix.hpp>
 
namespace FEAT
{
  namespace Solver
  {
    template<typename Matrix_, typename Filter_, typename SolverBase_ = Solver::SolverBase<typename Matrix_::VectorTypeL>>
#ifndef DOXYGEN
    class ADPSolverBase;
#else // DOXYGEN
    class ADPSolverBase :
      public SolverBase_
    {
    protected:
      explicit ADPSolverBase(const GlobalMatrixType& matrix, const GlobalFilterType& filter);
 
      const Dist::Comm* _get_comm() const;
 
      Index _get_num_owned_dofs() const;
 
      Index _get_num_global_dofs() const;
 
      Index _get_global_dof_offset() const;
 
      Index _get_mat_num_nze() const;
 
      const DataType* _get_mat_vals() const;
 
      const IndexType* _get_mat_row_ptr() const;
 
      const IndexType* _get_mat_col_idx() const;
 
      const DataType* _get_vec_def_vals(const VectorType& vec_def);
 
      DataType* _get_vec_def_vals(VectorType& vec_def);
 
      DataType* _get_vec_cor_vals(VectorType& vec_cor);
 
      void _upload_vec_def(const VectorType& vec_def);
 
      void _upload_vec_cor(const VectorType& vec_cor);
 
      void _download_vec_def(VectorType& vec_def);
 
      void _download_vec_cor(VectorType& vec_cor);
    }; // class ADPSolverBase
#endif // DOXYGEN
 
    template<typename LocalMatrix_, typename Mirror_, typename GlobalFilter_, typename SolverBase_>
    class ADPSolverBase<Global::Matrix<LocalMatrix_, Mirror_, Mirror_>, GlobalFilter_, SolverBase_> :
      //public SolverBase<Global::Vector<typename LocalMatrix_::VectorTypeL, Mirror_>>
      public SolverBase_
    {
    public:
      typedef LocalMatrix_ LocalMatrixType;
      typedef typename LocalMatrixType::VectorTypeL LocalVectorType;
      typedef Mirror_ MirrorType;
 
      typedef Global::Matrix<LocalMatrixType, MirrorType, MirrorType> GlobalMatrixType;
      typedef Global::Vector<LocalVectorType, MirrorType> GlobalVectorType;
      typedef GlobalFilter_ GlobalFilterType;
 
      //typedef SolverBase<GlobalVectorType> BaseClass;
      typedef SolverBase_ BaseClass;
 
      typedef GlobalVectorType VectorType;
 
      typedef Global::AlgDofParti<LocalVectorType, MirrorType> AlgDofPartiType;
      typedef Global::AlgDofPartiMatrix<LocalMatrixType, MirrorType> ADPMatrixType;
      typedef Global::AlgDofPartiVector<LocalVectorType, MirrorType> ADPVectorType;
 
      typedef typename AlgDofPartiType::DataType DataType;
      typedef typename AlgDofPartiType::IndexType IndexType;
 
    private:
      AlgDofPartiType _alg_dof_parti;
      ADPMatrixType _adp_matrix;
      ADPVectorType _adp_vec_def, _adp_vec_cor;
 
    protected:
      const GlobalMatrixType& _system_matrix;
      const GlobalFilterType& _system_filter;
 
      explicit ADPSolverBase(const GlobalMatrixType& matrix, const GlobalFilterType& filter) :
        BaseClass(),
        _alg_dof_parti(),
        _adp_matrix(),
        _adp_vec_def(),
        _adp_vec_cor(),
        _system_matrix(matrix),
        _system_filter(filter)
      {
      }
 
    public:
      const Dist::Comm* _get_comm() const
      {
        return this->_system_matrix.get_comm();
      }
 
      virtual void init_symbolic() override
      {
        BaseClass::init_symbolic();
 
        // assemble the algebraic dof partitioning
        _alg_dof_parti.assemble_by_gate(*this->_system_matrix.get_row_gate());
 
        // upload the matrix structure
        _adp_matrix = ADPMatrixType(&this->_alg_dof_parti);
        _adp_matrix.upload_symbolic(this->_system_matrix);
 
        // create two vectors
        _adp_vec_def = ADPVectorType(&this->_alg_dof_parti);
        _adp_vec_cor = ADPVectorType(&this->_alg_dof_parti);
 
        // format matrix and vectors
        _adp_matrix.owned().format();
        _adp_vec_def.owned().format();
        _adp_vec_cor.owned().format();
      }
 
      virtual void init_numeric() override
      {
        BaseClass::init_numeric();
 
        // upload matrix values
        _adp_matrix.upload_numeric(this->_system_matrix);
 
        // filter matrix
        _adp_matrix.filter_matrix(this->_system_filter);
      }
 
      virtual void done_symbolic() override
      {
        _adp_vec_cor.clear();
        _adp_vec_def.clear();
        _adp_matrix.clear();
        _alg_dof_parti.clear();
 
        BaseClass::done_symbolic();
      }
 
    protected:
      Index _get_num_owned_dofs() const
      {
        return this->_alg_dof_parti.get_num_owned_dofs();
      }
 
      Index _get_num_global_dofs() const
      {
        return this->_alg_dof_parti.get_num_global_dofs();
      }
 
      Index _get_global_dof_offset() const
      {
        return this->_alg_dof_parti.get_global_dof_offset();
      }
 
      Index _get_mat_num_nze() const
      {
        return this->_adp_matrix.owned().used_elements();
      }
 
      const DataType* _get_mat_vals() const
      {
        return this->_adp_matrix.owned().val();
      }
 
      const IndexType* _get_mat_row_ptr() const
      {
        return this->_adp_matrix.owned().row_ptr();
      }
 
      const IndexType* _get_mat_col_idx() const
      {
        return this->_adp_matrix.owned().col_ind();
      }
 
      const DataType* _get_vec_def_vals(const VectorType&)
      {
        return this->_adp_vec_def.owned().elements();
      }
 
      DataType* _get_vec_def_vals(VectorType&)
      {
        return this->_adp_vec_def.owned().elements();
      }
 
      DataType* _get_vec_cor_vals(VectorType&)
      {
        return this->_adp_vec_cor.owned().elements();
      }
 
      void _upload_vec_def(const VectorType& vec_def)
      {
        this->_adp_vec_def.upload(vec_def);
      }
 
      void _upload_vec_cor(const VectorType& vec_cor)
      {
        this->_adp_vec_cor.upload(vec_cor);
      }
 
      void _download_vec_def(VectorType& vec_def)
      {
        this->_adp_vec_def.download(vec_def);
      }
 
      void _download_vec_cor(VectorType& vec_cor)
      {
        this->_adp_vec_cor.download(vec_cor);
      }
    }; // class ADPSolverBase<Global::Matrix<...>, ...>
 
 
    template<typename MatrixB_, typename MatrixD_, typename GlobalFilter_, typename SolverBase_>
    class ADPSolverBase<Global::PMDCDSCMatrix<MatrixB_, MatrixD_>, GlobalFilter_, SolverBase_> :
      //public SolverBase<typename Global::PMDCDSCMatrix<MatrixB_, MatrixD_>::VectorTypeL>
      public SolverBase_
    {
    public:
      typedef Global::PMDCDSCMatrix<MatrixB_, MatrixD_> GlobalMatrixType;
      typedef GlobalFilter_ GlobalFilterType;
 
      typedef typename GlobalMatrixType::LocalMatrixTypeS LocalMatrixTypeS;
 
      typedef typename GlobalMatrixType::VectorTypeL GlobalVectorType;
 
      //typedef SolverBase<GlobalVectorType> BaseClass;
      typedef SolverBase_ BaseClass;
 
      typedef GlobalVectorType VectorType;
 
      typedef typename LocalMatrixTypeS::DataType DataType;
      typedef typename LocalMatrixTypeS::IndexType IndexType;
 
    private:
      Index _glob_dof_offset;
      // the total global DOF count
      Index _glob_dof_count;
      LocalMatrixTypeS _matrix_slice;
 
    protected:
      const GlobalMatrixType& _system_matrix;
      const GlobalFilterType& _system_filter;
 
      explicit ADPSolverBase(const GlobalMatrixType& matrix, const GlobalFilterType& filter) :
        BaseClass(),
        _glob_dof_offset(0),
        _glob_dof_count(0),
        _system_matrix(matrix),
        _system_filter(filter)
      {
      }
 
    public:
      const Dist::Comm* _get_comm() const
      {
        return this->_system_matrix.get_comm();
      }
 
      virtual void init_symbolic() override
      {
        BaseClass::init_symbolic();
 
        // assemble matrix slice structure
        _matrix_slice = _system_matrix.asm_adp_symbolic(_glob_dof_offset, _glob_dof_count);
      }
 
      virtual void init_numeric() override
      {
        BaseClass::init_numeric();
 
        // upload matrix values
        _system_matrix.asm_adp_numeric(_matrix_slice);
 
        // filter matrix
        this->_system_filter.local().filter_mat(_matrix_slice);
      }
 
      virtual void done_symbolic() override
       {
        _matrix_slice.clear();
        BaseClass::done_symbolic();
      }
 
    protected:
 
      Index _get_num_global_dofs() const
      {
        return _glob_dof_count;
      }
 
      Index _get_global_dof_offset() const
      {
        return _glob_dof_offset;
      }
 
      Index _get_num_owned_dofs() const
      {
        return _matrix_slice.rows();
      }
 
      Index _get_mat_num_nze() const
      {
        return _matrix_slice.used_elements();
      }
 
      const DataType* _get_mat_vals() const
      {
        return _matrix_slice.val();
      }
 
      const IndexType* _get_mat_row_ptr() const
      {
        return _matrix_slice.row_ptr();
      }
 
      const IndexType* _get_mat_col_idx() const
      {
        return _matrix_slice.col_ind();
      }
 
      const DataType* _get_vec_def_vals(const VectorType& vec_def)
      {
        return vec_def.local().elements();
      }
 
      DataType* _get_vec_def_vals(VectorType& vec_def)
      {
        return vec_def.local().elements();
      }
 
      DataType* _get_vec_cor_vals(VectorType& vec_cor)
      {
        return vec_cor.local().elements();
      }
 
      void _upload_vec_def(const VectorType&)
      {
        // nothing to do here
      }
 
      void _upload_vec_cor(const VectorType&)
      {
        // nothing to do here
      }
 
      void _download_vec_def(VectorType&)
      {
        // nothing to do here
      }
 
      void _download_vec_cor(VectorType&)
      {
        // nothing to do here
      }
    }; // class ADPSolverBase<Global::PMDCDSCMatrix<...>, ...>
  } // namespace Solver
} // namespace FEAT