Login or Register to Ask a Question and Join Our Community

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

distributor(2rheolef)						    rheolef-6.1 					     distributor(2rheolef)

NAME

       distributor - data distribution table (rheolef-6.1)

SYNOPSYS

       Used by "array"(1), "asr"(1) and "csr"(1).  and such classes that distribute data as chunk.

IMPLEMENTATION

       class distributor : public Vector<std::allocator<int>::size_type> {
       public:

       // typedefs:

	       typedef std::allocator<int>::size_type size_type;
	       typedef Vector<size_type>	      _base;
	       typedef _base::iterator		      iterator;
	       typedef _base::const_iterator	      const_iterator;
	       typedef int			      tag_type;
	       typedef communicator		      communicator_type;

       // constants:

	       static const size_type decide = size_type(-1);

       // allocators/deallocators:

	       distributor(
		       size_type dis_size = 0,
		       const communicator_type& c = communicator_type(),
		       size_type loc_size = decide);

	       distributor(const distributor&);
	       ~distributor();

	       void resize(
		       size_type dis_size = 0,
		       const communicator_type& c = communicator_type(),
		       size_type loc_size = decide);

       // accessors:

	       const communicator_type& comm() const;

	       /// global and local sizes
	       size_type dis_size () const;

	       /// current process id
	       size_type process () const;

	       /// number of processes
	       size_type n_process () const;

	       /// find iproc associated to a global index dis_i: CPU=log(nproc)
	       size_type find_owner (size_type dis_i) const;

	       /// global index range and local size owned by ip-th process
	       size_type first_index (size_type ip) const;
	       size_type last_index (size_type ip) const;
	       size_type size (size_type ip) const;

	       /// global index range and local size owned by current process
	       size_type first_index () const;
	       size_type last_index () const;
	       size_type size () const;

	       /// true when dis_i in [first_index(ip):last_index(ip)[
	       bool is_owned (size_type dis_i, size_type ip) const;

	       // the same with ip=current process
	       bool is_owned (size_type dis_i) const;

	       /// returns a new tag
	       static tag_type get_new_tag();

       // comparators:

	       bool operator== (const distributor&) const;
	       bool operator!= (const distributor&) const;
       // data:
       protected:
	       communicator_type _comm;
       };

rheolef-6.1							    rheolef-6.1 					     distributor(2rheolef)
Man Page