OEMSolver.h

// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ==  http://www.amdis-fem.org                                              ==
// ==                                                                        ==
// ============================================================================
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.



/** \file OEMSolver.h */

/**
 * \defgroup Solver Solver module
 * @{ <img src="solver.png"> @}
 * 
 * \brief
 * Contains all classes needed for solving linear and non linear equation
 * systems.
 */

#ifndef AMDIS_OEM_SOLVER_H
#define AMDIS_OEM_SOLVER_H

#include "Global.h"
#include "AMDiS_fwd.h"
#include "Initfile.h"
#include "SolverMatrix.h"
#include "DOFVector.h"
#include "SystemVector.h"
#include "DOFMatrix.h"
#include "BasePreconditioner.h"
#include "Mapper.h"

#ifdef HAVE_PARALLEL_DOMAIN_AMDIS
#include "parallel/ParallelMapper.h"
#endif
//#include "ITL_Preconditioner.h"

namespace AMDiS {

  /**
   * \ingroup Solver
   * 
   *\brief
   * Solver for linear equation systems.
   */
  class OEMSolver
  {
  public:

    typedef DOFMatrix::base_matrix_type   matrix_type;
    typedef DOFMatrix::value_type         value_type;

    /// The constructor reads needed parameters and sets solvers \ref name.
    OEMSolver(std::string str) 
      : name(str),
	tolerance(0),
	relative(0),
	max_iter(1000),
	info(0),
	residual(0),
	print_cycle(100),
	iterations(-1),
	error(-1),
	multipleRhs(false)
    {}

    ///
    virtual ~OEMSolver() 
    {}

    void initParameters()
    {
      FUNCNAME("OEMSolver::initParameters()");
      
      Parameters::get(name + "->tolerance", tolerance);
      Parameters::get(name + "->relative tolerance", relative);
      Parameters::get(name + "->max iteration", max_iter);
      Parameters::get(name + "->print cycle", print_cycle);
      Parameters::get(name + "->info", info);
    }


    /// Solve a linear system for a vectorial problem.
    virtual int solveSystem(const SolverMatrix<Matrix<DOFMatrix*> >& A,
			    SystemVector& x, 
			    SystemVector& b,
			    VectorialMapper&) 
    {
      FUNCNAME("OEMSolver::solveSystem()");
      TEST_EXIT(false)("This linear solver is not suitable for sequentiell problems\n");
      return -1;
    }

    inline int solveSystem(const SolverMatrix<Matrix<DOFMatrix*> >& A,
			   SystemVector& x,
			   SystemVector& b) 
    {
      VectorialMapper mapper(A);
      return solveSystem(A, x, b, mapper);
    }

#ifdef HAVE_PARALLEL_DOMAIN_AMDIS
    virtual int solveSystem(const SolverMatrix<Matrix<DOFMatrix*> >& A,
			    SystemVector& x, 
			    SystemVector& b,
			    ParallelMapper&) 
    { 
      FUNCNAME("OEMSolver::solveSystem()");
      TEST_EXIT(false)("This linear solver is not suitable for domaindecomposition problems\n");
      return -1;
    }
#endif

    /** \name getting methods
     * \{ 
     */

    /// Returns solvers \ref name.
    inline std::string getName() const
    { 
      return name; 
    }

    /// Returns \ref tolerance
    inline double getTolerance() const
    {
      return tolerance;
    }  

    /// Returns \ref max_iter
    inline int getMaxIterations() const
    {
      return max_iter;
    }

    /// Returns number of iterations in last run of an iterative solver
    inline int getIterations() 
    {
      return iterations;
    }

    /// Returns error code in last run of an iterative solver
    inline int getErrorCode() 
    {
      return error;
    }

    /// Returns info
    inline int getInfo()
    {
      return info;
    }

    /// Returns \ref print_cycle
    inline int getPrint_cycle() const
    {
      return print_cycle;
    }

    /// Returns \ref residual
    inline double getResidual() const
    {
      return residual;
    }

    /// Returns \ref relative
    inline double getRelative() const
    {
      return relative;
    }

    /// Returns \ref multipleRhs
    inline bool getMultipleRhs() const
    {
      return multipleRhs;
    }


    /** \} */ 

    /** \name setting methods
     * \{ 
     */

    /// Sets \ref tolerance
    inline void setTolerance(double tol) 
    {
      tolerance = tol;
    }

    inline void setResidual(double r)
    {
      residual = r;
    }

    /// Sets \ref relative
    inline void setRelative(double rel) 
    {
      relative = rel;
    }

    /// Sets \ref max_iter
    inline void setMaxIterations(int i) 
    {
      max_iter = i;
    }

    inline void setIterations(int i)
    {
      iterations=i;
    }

    /// set the \ref error
    inline void setErrorCode(int code)
    {
      error=code;
    }
  
    /// Sets \ref info
    inline void setInfo(int i) 
    {
      info = i;
    }

    inline void setMultipleRhs(bool b)
    {
      multipleRhs = b;
    }

    /** \} */

  protected:
    /// solvers name.
    std::string name;

    /// Solver tolerance |r|. Set in OEMSolver's constructor. 
    double tolerance;

    /// Relative solver tolerance |r|/|r0|. Set in OEMSolver's constructor. 
    double relative;

    /// maximal number of iterations. Set in OEMSolver's constructor.
    int max_iter;

    /// info level during solving the system. Set in OEMSolver's constructor.
    int info;

    /// current residual.
    double residual;

    /// Print cycle, after how many iterations the residuum norm is logged.
    int print_cycle;

    /// How many iterations were performed in last solver (not set by UmfPack)
    int iterations;

    /// Error code  in last solver (not set by UmfPack)
    int error;

    /** \brief
     * If true, the solver has to solve multiple right hand sides with the same
     * matrix. Some solvers, e.g. direct once, may take advanteges from this knowledge,
     * as they can do the factorization of the matrix only once.
     */
    bool multipleRhs;
  };

  /** 
   * \ingroup Solver
   *
   * \brief
   * Interface for creators of concrete OEMSolvers. 
   */
  class OEMSolverCreator : public CreatorInterface<OEMSolver>
  { 
  public:
    virtual ~OEMSolverCreator() {}

    /// Sets \ref problem
    void setName(std::string str) 
    { 
      name = str; 
    }

  protected:
    /** \brief
     * Pointer to the problem the solver will belong to. Needed as parameter
     * when constructing an OEMSolver
     */
    std::string name;
  };
}

//#include "ITL_Solver.h"

#endif // AMDIS_OEM_SOLVER_H