Linux and UNIX Man Pages

Linux & Unix Commands - Search Man Pages

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

vec(2rheolef)							    rheolef-6.1 						     vec(2rheolef)

NAME
vec - vector in distributed environment (rheolef-6.1) SYNOPSYS
STL-like vector container for a sequential or distributed memory machine model. Additional operation fom classical algebra. EXAMPLE
A sample usage of the class is: int main(int argc, char**argv) { environment distributed(argc, argv); vec<double> x(100, 3.14); dout << x << endl; } IMPLEMENTATION NOTE
Implementation use array<T,M>. IMPLEMENTATION
template <class T, class M = rheo_default_memory_model> class vec : public array<T, M> { public: // typedef: typedef array<T, M> base; typedef typename base::size_type size_type; typedef std::ptrdiff_t difference_type; #ifdef TODO // pb compile avec boost sur foehn: typedef typename base::difference_type difference_type; #endif // TODO typedef basic_range<size_type, difference_type> range_type; typedef typename base::reference reference; typedef typename base::const_reference const_reference; typedef typename base::iterator iterator; typedef typename base::const_iterator const_iterator; // allocator/deallocator: vec (const distributor& ownership, const T& init_val = std::numeric_limits<T>::max()); vec(size_type dis_size = 0, const T& init_val = std::numeric_limits<T>::max()); void resize ( const distributor& ownership, const T& init_val = std::numeric_limits<T>::max()); void resize ( size_type size = 0, const T& init_val = std::numeric_limits<T>::max()); // accessors: const_reference operator[] (size_type i) const; reference operator[] (size_type i); T max_abs () const; // range: vec(const vec_range<T,M>& vr); vec(const vec_range_const<T,M>& vr); vec<T,M>& operator= (const vec_range<T,M>& vr); vec<T,M>& operator= (const vec_range_const<T,M>& vr); vec_range_const<T,M> operator[] (const range_type& r) const; vec_range<T,M> operator[] (const range_type& r); // assignment to a constant: vec<T,M>& operator= (const int& expr); vec<T,M>& operator= (const T& expr); // expression template: template<typename Expr> vec (const Expr& expr); template<typename Expr> vec<T,M>& operator= (const vec_expr<Expr>& expr); template<typename Expr> vec<T,M>& operator+= (const Expr& expr); template<typename Expr> vec<T,M>& operator-= (const Expr& expr); // initializer list (c++ 2011): #ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST vec (const std::initializer_list<vec_concat_value<T,M> >& init_list); vec<T,M>& operator= (const std::initializer_list<vec_concat_value<T,M> >& init_list); #endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST }; rheolef-6.1 rheolef-6.1 vec(2rheolef)
Man Page

Featured Tech Videos