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; SEE ALSO
mixed_solver(4) rheolef-6.1 rheolef-6.1 solver_abtb(2rheolef)
Check Out this Related Man Page
form(2rheolef) rheolef-6.1 form(2rheolef) NAME
form - representation of a finite element bilinear form DESCRIPTION
The form class groups four sparse matrix, associated to a bilinear form on two finite element spaces: a: U*V ----> IR (u,v) |---> a(u,v) The operator A associated to the bilinear form is defined by: A: U ----> V' u |---> A(u) where u and v are fields (see field(2)), and A(u) is such that a(u,v)=<A(u),v> for all u in U and v in V and where <.,.> denotes the dual- ity product between V and V'. Since V is a finite dimensional spaces, the duality product is the euclidian product in IR^dim(V). Since both U and V are finite dimensional spaces, the linear operator can be represented by a matrix. The form class is represented by four sparse matrix in csr format (see csr(2)), associated to unknown and blocked degrees of freedom of origin and destination spaces (see space(2)). EXAMPLE
The operator A associated to a bilinear form a(.,.) by the relation (Au,v) = a(u,v) could be applied by using a sample matrix notation A*u, as shown by the following code: geo omega("square"); space V (omega,"P1"); form a (V,V,"grad_grad"); field uh = interpolate (fct, V); field vh = a*uh; cout << v; The form-field vh=a*uh operation is equivalent to the following matrix-vector operations: vh.set_u() = a.uu()*uh.u() + a.ub()*uh.b(); vh.set_b() = a.bu()*uh.u() + a.bb()*uh.b(); ALGABRA
Forms, as matrices (see csr(2)), support linear algebra: Adding or substracting two forms writes a+b and a-b, respectively, and multiplying a form by a field uh writes a*uh. Thus, any linear combination of forms is available. IMPLEMENTATION
template<class T, class M> class form_basic { public : // typedefs: typedef typename csr<T,M>::size_type size_type; typedef T value_type; typedef typename scalar_traits<T>::type float_type; typedef geo_basic<float_type,M> geo_type; typedef space_basic<float_type,M> space_type; // allocator/deallocator: form_basic (); form_basic (const form_basic<T,M>&); form_basic (const space_type& X, const space_type& Y, const std::string& name = "", quadrature_option_type qopt = quadrature_option_type(quadrature_option_type::max_family,0)); form_basic (const space_type& X, const space_type& Y, const std::string& name, const geo_basic<T,M>& gamma, quadrature_option_type qopt = quadrature_option_type(quadrature_option_type::max_family,0)); form_basic (const space_type& X, const space_type& Y, const std::string& name, const field_basic<T,M>& weight, quadrature_option_type qopt = quadrature_option_type(quadrature_option_type::max_family,0)); form_basic (const space_type& X, const space_type& Y, const std::string& name, const band_basic<T,M>& bh, quadrature_option_type qopt = quadrature_option_type(quadrature_option_type::max_family,0)); // allocators from initializer list (c++ 2011): #ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST form_basic (const std::initializer_list<form_concat_value<T,M> >& init_list); form_basic (const std::initializer_list<form_concat_line <T,M> >& init_list); #endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST // accessors: const space_type& get_first_space() const; const space_type& get_second_space() const; const geo_type& get_geo() const; const communicator& comm() const; // linear algebra: form_basic<T,M> operator+ (const form_basic<T,M>& b) const; form_basic<T,M> operator- (const form_basic<T,M>& b) const; form_basic<T,M>& operator*= (const T& lambda); field_basic<T,M> operator* (const field_basic<T,M>& xh) const; #ifdef TO_CLEAN template <class Expr> field_basic<T,M> operator* (const field_expr<Expr>& xh) const; #endif // TO_CLEAN field_basic<T,M> trans_mult (const field_basic<T,M>& yh) const; float_type operator () (const field_basic<T,M>& uh, const field_basic<T,M>& vh) const; // io: odiststream& put (odiststream& ops, bool show_partition = true) const; void dump (std::string name) const; // accessors & modifiers to unknown & blocked parts: const csr<T,M>& uu() const { return _uu; } const csr<T,M>& ub() const { return _ub; } const csr<T,M>& bu() const { return _bu; } const csr<T,M>& bb() const { return _bb; } csr<T,M>& set_uu() { return _uu; } csr<T,M>& set_ub() { return _ub; } csr<T,M>& set_bu() { return _bu; } csr<T,M>& set_bb() { return _bb; } // data protected: space_type _X; space_type _Y; csr<T,M> _uu; csr<T,M> _ub; csr<T,M> _bu; csr<T,M> _bb; // internals: void assembly (const form_element<T,M>& form_e, const geo_basic<T,M>& X_geo, const geo_basic<T,M>& Y_geo, bool X_geo_is_background = true); void form_init ( const std::string& name, bool has_weight, const field_basic<T,M>& weight, quadrature_option_type qopt); }; template<class T, class M> form_basic<T,M> trans (const form_basic<T,M>& a); typedef form_basic<Float,rheo_default_memory_model> form; SEE ALSO
field(2), csr(2), space(2), csr(2) rheolef-6.1 rheolef-6.1 form(2rheolef)