# solver_abtb(2rheolef) [debian man page]

```solver_abtb(2rheolef)						    rheolef-6.1 					     solver_abtb(2rheolef)

NAME
solver_abtb -- direct or iterative solver iterface for mixed linear systems

SYNOPSIS
solver_abtb stokes	  (a,b,mp);
solver_abtb elasticity (a,b,c,mp);

DESCRIPTION
The solver_abtb class provides direct or iterative algorithms for some mixed problem:

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

where  A  is  symmetric	positive definite and C is symmetric positive.	By default, iterative algorithms are considered for tridimensional
problems and direct methods otherwise.  Such mixed linear problems appears for instance with the discretization of Stokes problems.  The  C
matrix  can  be	zero  and  then the corresponding argument can be omitted when invoking the constructor.  Non-zero C matrix appears for of
Stokes problems with stabilized P1-P1 element, or for nearly incompressible elasticity problems.

DIRECT ALGORITHM
When the kernel of B^T is not reduced to zero, then the pressure p is defined up to a constant and the system is singular. In the  case	of
iterative  methods,  this is not a problem.  But when using direct method, the system is then completed to impose a constraint on the pres-
sure term and the whole matrix is factored one time for all.

ITERATIVE ALGORITHM
The preconditionned conjugate gradient algorithm is used, where the mp matrix is used as preconditionner. See see mixed_solver(4).

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

IMPLEMENTATION
template <class T, class M = rheo_default_memory_model>
class solver_abtb_basic {
public:

// typedefs:

typedef typename csr<T,M>::size_type size_type;

// allocators:

solver_abtb_basic ();
solver_abtb_basic (const csr<T,M>& a, const csr<T,M>& b, const csr<T,M>& mp,
const solver_option_type& opt = solver_option_type());
solver_abtb_basic (const csr<T,M>& a, const csr<T,M>& b, const csr<T,M>& c, const csr<T,M>& mp,
const solver_option_type& opt = solver_option_type());

// accessors:

void solve (const vec<T,M>& f, const vec<T,M>& g, vec<T,M>& u, vec<T,M>& p) const;

protected:
// internal
void init();
// data:
mutable solver_option_type _opt;
csr<T,M>	   _a;
csr<T,M>	   _b;
csr<T,M>	   _c;
csr<T,M>	   _mp;
solver_basic<T,M> _sA;
solver_basic<T,M> _sa;
solver_basic<T,M> _smp;
bool		   _need_constraint;
};
typedef solver_abtb_basic<Float,rheo_default_memory_model> solver_abtb;

mixed_solver(4)

rheolef-6.1							    rheolef-6.1 					     solver_abtb(2rheolef)```

## Check Out this Related Man Page

```asr(2rheolef)							    rheolef-6.1 						     asr(2rheolef)

NAME
asr - associative sparse matrix (rheolef-6.1)

SYNOPSYS
Associative sparse matrix container stored row by row
using the STL map class.

IMPLEMENTATION NOTE
Implementation use MPI-1.1 and is inspired from Mat_MPI in PETSc-2.0.22.

TO DO
For  efficiency	purpose,  the  assembly  phase	may access directly to the asr representation, without crossing the reference counting and
pointer handler.  Something like the iterator for dense vectors.

IMPLEMENTATION
template<class R>
class basic_asr : public smart_pointer<R> {
public:

// typedefs:

typedef typename R::size_type	  size_type;
typedef typename R::element_type	  element_type;
typedef typename R::memory_type	  memory_type;
typedef distributor::communicator_type communicator_type;

// allocators/deallocators:

basic_asr (size_type dis_nrow = 0, size_type dis_ncol = 0);
basic_asr (const distributor& row_ownership, const distributor& col_ownership);
explicit basic_asr (const csr<element_type,memory_type>&);

// accessors:

const communicator_type& comm() const;

// local sizes
size_type nrow () const;
size_type ncol () const;
size_type nnz () const;

// global sizes
size_type dis_nrow () const;
size_type dis_ncol () const;
size_type dis_nnz () const;
const distributor& row_ownership() const;
const distributor& col_ownership() const;

// range on local memory
size_type row_first_index () const;
size_type row_last_index () const;
size_type col_first_index () const;
size_type col_last_index () const;

// global modifiers:

element_type& dis_entry (size_type dis_i, size_type dis_j);
void dis_entry_assembly();
void dis_entry_assembly_begin ();
void dis_entry_assembly_end ();
void resize (size_type dis_nrow = 0, size_type dis_ncol = 0);

// output:

void dump (const std::string& name) const;
};
template <class T, class M = rheo_default_memory_model>
class asr
{
typedef M memory_type;
};
template <class T>
class asr<T,sequential> : public basic_asr<asr_seq_rep<T> > {
public:
typedef typename basic_asr<asr_seq_rep<T> >::size_type size_type;
typedef sequential memory_type;
asr (size_type dis_nrow = 0, size_type dis_ncol = 0);
asr (const distributor& row_ownership, const distributor& col_ownertship);
explicit asr(const csr<T,memory_type>&);
};
#ifdef _RHEOLEF_HAVE_MPI
template <class T>
class asr<T,distributed> : public basic_asr<asr_mpi_rep<T> > {
public:
typedef distributed memory_type;
typedef typename basic_asr<asr_mpi_rep<T> >::size_type size_type;
asr (size_type dis_nrow = 0, size_type dis_ncol = 0);
asr (const distributor& row_ownership, const distributor& col_ownertship);
explicit asr(const csr<T,memory_type>&);
};
#endif // _RHEOLEF_HAVE_MPI

// inputs/outputs:
template <class T, class M>
idiststream& operator >> (idiststream& s, asr<T,M>& x);

template <class T, class M>
odiststream& operator << (odiststream& s, const asr<T,M>& x);

rheolef-6.1							    rheolef-6.1 						     asr(2rheolef)```
Man Page