mixed_solver(4rheolef) [debian man page]

mixed_solver(4rheolef)						    rheolef-6.1 					    mixed_solver(4rheolef)

NAME

       pcg_abtb, pcg_abtbc, pminres_abtb, pminres_abtbc -- solvers for mixed linear problems

SYNOPSIS

	   template <class Matrix, class Vector, class Solver, class Preconditioner, class Size, class Real>
	   int pcg_abtb (const Matrix& A, const Matrix& B, Vector& u, Vector& p,
	     const Vector& Mf, const Vector& Mg, const Preconditioner& S1,
	     const Solver& inner_solver_A, Size& max_iter, Real& tol,
	     odiststream *p_derr = 0, std::string label = "pcg_abtb");

	   template <class Matrix, class Vector, class Solver, class Preconditioner, class Size, class Real>
	   int pcg_abtbc (const Matrix& A, const Matrix& B, const Matrix& C, Vector& u, Vector& p,
	     const Vector& Mf, const Vector& Mg, const Preconditioner& S1,
	     const Solver& inner_solver_A, Size& max_iter, Real& tol,
	     odiststream *p_derr = 0, std::string label = "pcg_abtbc");

       The synopsis is the same with the pminres algorithm.

EXAMPLES

       See the user's manual for practical examples for the nearly incompressible elasticity, the Stokes and the Navier-Stokes problems.

DESCRIPTION

       Preconditioned conjugate gradient algorithm on the pressure p applied to the stabilized stokes problem:

	      [ A  B^T ] [ u ]	  [ Mf ]
	      [        ] [   ]	= [    ]
	      [ B  -C  ] [ p ]	  [ Mg ]

       where A is symmetric positive definite and C is symmetric positive and semi-definite.  Such mixed linear problems appears for instance with
       the discretization of Stokes problems with stabilized P1-P1 element, or with nearly incompressible elasticity.  Formaly u  =  inv(A)*(Mf  -
       B^T*p) and the reduced system writes for all non-singular matrix S1:

	    inv(S1)*(B*inv(A)*B^T)*p = inv(S1)*(B*inv(A)*Mf - Mg)

       Uzawa  or  conjugate  gradient  algorithms are considered on the reduced problem.  Here, S1 is some preconditioner for the Schur complement
       S=B*inv(A)*B^T.	Both direct or iterative solvers for S1*q = t are supported.  Application of inv(A) is performed via a call  to  a  solver
       for  systems such as A*v = b.  This last system may be solved either by direct or iterative algorithms, thus, a general matrix solver class
       is submitted to the algorithm.  For most applications, such as the Stokes problem, the mass matrix for the p variable is a good S1  precon-
       ditioner  for the Schur complement.  The stoping criteria is expressed using the S1 matrix, i.e. in L2 norm when this choice is considered.
       It is scaled by the L2 norm of the right-hand side of the reduced system, also in S1 norm.

rheolef-6.1							    rheolef-6.1 					    mixed_solver(4rheolef)

solver(2rheolef)						    rheolef-6.1 						  solver(2rheolef)

NAME

       solver - direct or interative solver interface

DESCRIPTION

	The class implements a matrix factorization:
	LU factorization for an unsymmetric matrix and
	Choleski fatorisation for a symmetric one.

	Let a be a square invertible matrix in
	csr format (see csr(2)).

	       csr<Float> a;

	We get the factorization by:

	       solver<Float> sa (a);

	Each call to the direct solver for a*x = b writes either:

	       vec<Float> x = sa.solve(b);

	When the matrix is modified in a computation loop but
	conserves its sparsity pattern, an efficient re-factorization
	writes:

	       sa.update_values (new_a);
	       x = sa.solve(b);

	This approach skip the long step of the symbolic factization step.

ITERATIVE SOLVER

	The factorization can also be incomplete, i.e. a pseudo-inverse,
	suitable for preconditionning iterative methods.
	In that case, the sa.solve(b) call runs a conjugate gradient
	when the matrix is symmetric, or a generalized minimum residual
	algorithm when the matrix is unsymmetric.

AUTOMATIC CHOICE AND CUSTOMIZATION

	The symmetry of the matrix is tested via the a.is_symmetric() property
	(see csr(2)) while the choice between direct or iterative solver
	is switched from the a.pattern_dimension() value. When the pattern
	is 3D, an iterative method is faster and less memory consuming.
	Otherwhise, for 1D or 2D problems, the direct method is prefered.

	These default choices can be supersetted by using explicit options:

	       solver_option_type opt;
	       opt.iterative = true;
	       solver<Float> sa (a, opt);

	See the solver.h header for the complete list of available options.

IMPLEMENTATION NOTE

	The implementation bases on the pastix library.

IMPLEMENTATION

       template <class T, class M = rheo_default_memory_model>
       class solver_basic : public smart_pointer<solver_rep<T,M> > {
       public:
       // typedefs:

	 typedef solver_rep<T,M>    rep;
	 typedef smart_pointer<rep> base;

       // allocator:

	 solver_basic ();
	 explicit solver_basic (const csr<T,M>& a, const solver_option_type& opt = solver_option_type());
	 void update_values (const csr<T,M>& a);

       // accessors:

	 vec<T,M> trans_solve (const vec<T,M>& b) const;
	 vec<T,M> solve       (const vec<T,M>& b) const;
       };
       // factorizations:
       template <class T, class M>
       solver_basic<T,M> ldlt(const csr<T,M>& a, const solver_option_type& opt = solver_option_type());
       template <class T, class M>
       solver_basic<T,M> lu  (const csr<T,M>& a, const solver_option_type& opt = solver_option_type());
       template <class T, class M>
       solver_basic<T,M> ic0 (const csr<T,M>& a, const solver_option_type& opt = solver_option_type());
       template <class T, class M>
       solver_basic<T,M> ilu0(const csr<T,M>& a, const solver_option_type& opt = solver_option_type());

       typedef solver_basic<Float> solver;

SEE ALSO

       csr(2), csr(2)

rheolef-6.1							    rheolef-6.1 						  solver(2rheolef)