linear_matrix_solver.h

// This file is part of HermesCommon
//
// Copyright (c) 2009 hp-FEM group at the University of Nevada, Reno (UNR).
// Email: hpfem-group@unr.edu, home page: http://hpfem.org/.
//
// Hermes2D is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the License,
// or (at your option) any later version.
//
// Hermes2D is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Hermes2D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#ifndef __HERMES_COMMON_SOLVER_H_
#define __HERMES_COMMON_SOLVER_H_

#include "precond.h"
#include "dp_interface.h"
#include "exceptions.h"
#include "mixins.h"

using namespace Hermes::Algebra;

namespace Hermes
{
  namespace Solvers
  {
    using namespace Hermes::Preconditioners;
    enum FactorizationScheme
    {
      HERMES_FACTORIZE_FROM_SCRATCH,              

      HERMES_REUSE_MATRIX_REORDERING,             

      HERMES_REUSE_MATRIX_REORDERING_AND_SCALING, 


      HERMES_REUSE_FACTORIZATION_COMPLETELY       

    };

    template <typename Scalar>
    class LinearMatrixSolver : public Hermes::Mixins::Loggable, public Hermes::Mixins::TimeMeasurable
    {
    public:
      LinearMatrixSolver();

      virtual ~LinearMatrixSolver();

      virtual bool solve() = 0;

      Scalar *get_sln_vector();

      int get_error();
      double get_time();
      virtual int get_matrix_size() = 0;

      virtual void set_factorization_scheme(FactorizationScheme reuse_scheme) { };

      virtual void set_factorization_scheme();

    protected:
      Scalar *sln;
      int error;
      double time;  
    };

    template <typename Scalar>
    class DirectSolver : public LinearMatrixSolver<Scalar>
    {
    public:
      DirectSolver(unsigned int factorization_scheme = HERMES_FACTORIZE_FROM_SCRATCH)
        : LinearMatrixSolver<Scalar>(), factorization_scheme(factorization_scheme) {};

    protected:
      virtual void set_factorization_scheme(FactorizationScheme reuse_scheme);

      unsigned int factorization_scheme;
    };

    template <typename Scalar>
    class IterSolver : public LinearMatrixSolver<Scalar>
    {
    public:
      IterSolver() : LinearMatrixSolver<Scalar>(), max_iters(10000), tolerance(1e-8), precond_yes(false) {};

      virtual int get_num_iters() = 0;
      virtual double get_residual() = 0;

      void set_tolerance(double tol);

      void set_max_iters(int iters);

      virtual void set_precond(const char *name) = 0;

      virtual void set_precond(Precond<Scalar> *pc) = 0;

    protected:
      int max_iters;          
      double tolerance;       
      bool precond_yes;
    };

    template<typename Scalar>
    HERMES_API LinearMatrixSolver<Scalar>*
      create_linear_solver(Matrix<Scalar>* matrix, Vector<Scalar>* rhs);
  }
} // End of documentation group Solvers.
#endif