directlinearsolver.h

Go to the documentation of this file.

#ifndef _DIRECT_LINEAR_SOLVER_H_
#define _DIRECT_LINEAR_SOLVER_H_

#include <lac/vector.h>
#include <lac/block_sparsity_pattern.h>
#include <lac/block_sparse_matrix.h>
#include <lac/compressed_simple_sparsity_pattern.h>
#include <lac/solver_cg.h>
#include <lac/precondition.h>
#include <lac/full_matrix.h>
#include <lac/sparse_direct.h>

#include <dofs/dof_tools.h>

#include <numerics/vector_tools.h>

#include <vector>

#include "parameterreader.h"

namespace DOpE
{
  template <typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
    class DirectLinearSolverWithMatrix
  {
  public:
    DirectLinearSolverWithMatrix(ParameterReader &param_reader);
    ~DirectLinearSolverWithMatrix();
   
    static void declare_params(ParameterReader &param_reader);
 
    template<typename PROBLEM>
      void ReInit(PROBLEM& pde);

    template<typename PROBLEM, typename INTEGRATOR>
      void Solve(PROBLEM& pde, INTEGRATOR& integr, VECTOR &rhs, VECTOR &solution, bool force_matrix_build=false);
     
  protected:

  private:
    SPARSITYPATTERN _sparsity_pattern;
    MATRIX _matrix;

    dealii::SparseDirectUMFPACK* _A_direct;

    double _linear_global_tol, _linear_tol;
    int  _linear_maxiter;
  };

/*********************************Implementation************************************************/
 
  template <typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
    void DirectLinearSolverWithMatrix<SPARSITYPATTERN,MATRIX,VECTOR>::declare_params(ParameterReader &/*param_reader*/) 
  {
  }

  /******************************************************/

  template <typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
    DirectLinearSolverWithMatrix<SPARSITYPATTERN,MATRIX,VECTOR>::DirectLinearSolverWithMatrix(
      ParameterReader &/*param_reader*/) 
  {
    _A_direct = NULL;
  }

/******************************************************/

template <typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
 DirectLinearSolverWithMatrix<SPARSITYPATTERN,MATRIX,VECTOR>::~DirectLinearSolverWithMatrix()
{
  if(_A_direct != NULL)
  {
    delete _A_direct;
  }
}

/******************************************************/

template <typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
  template<typename PROBLEM>
  void  DirectLinearSolverWithMatrix<SPARSITYPATTERN,MATRIX,VECTOR>::ReInit(PROBLEM& pde)
{
  _matrix.clear();
  pde.ComputeSparsityPattern(_sparsity_pattern);
  _matrix.reinit(_sparsity_pattern);
  
  if(_A_direct != NULL)
  {
    delete _A_direct;
    _A_direct= NULL;
  }
}

/******************************************************/

template <typename SPARSITYPATTERN, typename MATRIX, typename VECTOR>
  template<typename PROBLEM, typename INTEGRATOR>
  void DirectLinearSolverWithMatrix<SPARSITYPATTERN,MATRIX,VECTOR>::Solve(PROBLEM& pde,
                                                                          INTEGRATOR& integr,
                                                                          VECTOR &rhs, 
                                                                          VECTOR &solution, 
                                                                          bool force_matrix_build)
{
  if(force_matrix_build)
  { 
    integr.ComputeMatrix (pde,_matrix);    
  }

  integr.ApplyNewtonBoundaryValues(pde,_matrix,rhs,solution);
  
  if(_A_direct == NULL)
  {
    _A_direct = new dealii::SparseDirectUMFPACK;
    _A_direct->initialize(_matrix);
  }
  else if(force_matrix_build)
  {
     _A_direct->factorize(_matrix);
  }
 
  dealii::Vector<double> sol;
  sol = rhs;
  _A_direct->solve(sol);
  solution = sol;

  pde.GetDoFConstraints().distribute(solution);

}


}
#endif