asr(2rheolef) [linux 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)

domain_indirect(7rheolef)					    rheolef-6.1 					 domain_indirect(7rheolef)

NAME

       domain_indirect - a named part of a finite element mesh

DESCRIPTION

       The  domain_indirect  class  defines  a	container for a part of a finite element mesh.	This describes the connectivity of edges or faces.
       This class is usefull for boundary condition setting.

IMPLEMENTATION NOTE

       The domain class is splitted into two parts.  The first one is the domain_indirect class, that contains the main renumbering  features:	it
       acts  as  a  indirect  on  a  geo class(see geo(2)).  The second one is the domain class, that simply contains two smart_pointers: one on a
       domain_indirect and the second on the geo where renumbering is acting.  Thus, the domain class develops a complete geo-like interface,  via
       the  geo_abstract_rep  pure virtual class derivation, and can be used by the space class (see space(2)).  The split between domain_indirect
       and domain is necessary, because the geo class contains a list of domain_indirect.  It cannot contains  a  list	of  domain  classes,  that
       refers to the geo class itself: a loop in reference counting leads to a blocking situation in the automatic deallocation.

IMPLEMENTATION

       template <>
       class domain_indirect_basic<sequential> : public smart_pointer<domain_indirect_rep<sequential> > {
       public:

       // typedefs:

	   typedef domain_indirect_rep<sequential> rep;
	   typedef smart_pointer<rep>	     base;
	   typedef rep::size_type	     size_type;
	   typedef rep::iterator_ioige	     iterator_ioige;
	   typedef rep::const_iterator_ioige const_iterator_ioige;

       // allocators:

	   domain_indirect_basic ();

	   template <class T>
	   domain_indirect_basic (
	       const geo_basic<T,sequential>&  omega,
	       const std::string&	       name,
	       size_type		       map_dim,
	       const communicator&	       comm,
	       const std::vector<size_type>&   ie_list);

	   template <class U>
	   domain_indirect_basic (
	       array<geo_element_auto<heap_allocator<size_type> >,sequential, heap_allocator<size_type> >&
					       d_tmp,
	       const geo_basic<U, sequential>& omega,
	       std::vector<index_set>*	       ball);

	   void resize (size_type n);

       // accessors:

	   size_type size()	const;
	   size_type dis_size() const;
	   const distributor& ownership() const;

	   const_iterator_ioige ioige_begin() const;
	   const_iterator_ioige ioige_end()   const;
		 iterator_ioige ioige_begin();
		 iterator_ioige ioige_end();

	   const geo_element_indirect& oige (size_type ioige) const;

	   void set_name (std::string name);
	   void set_map_dimension (size_type map_dim);
	   std::string name ()	  const;
	   size_type map_dimension () const;

       // i/o:

	   odiststream& put (odiststream&) const;
	   template <class T>
	   idiststream& get (idiststream& ips, const geo_rep<T,sequential>& omega, std::vector<index_set> *ball);
       };

IMPLEMENTATION

       template <>
       class domain_indirect_basic<distributed> : public smart_pointer<domain_indirect_rep<distributed> > {
       public:

       // typedefs:

	   typedef domain_indirect_rep<distributed>  rep;
	   typedef smart_pointer<rep>		 base;
	   typedef rep::size_type		 size_type;

       // allocators:

	   domain_indirect_basic ();
	   template<class T>
	   domain_indirect_basic (
	       const geo_basic<T,distributed>& omega,
	       const std::string&	     name,
	       size_type		     map_dim,
	       const communicator&	     comm,
	       const std::vector<size_type>& ie_list);

       // accessors/modifiers:

	   size_type size()	const;
	   size_type dis_size() const;
	   const distributor& ownership() const;

	   const geo_element_indirect& oige (size_type ioige) const;

	   void set_name (std::string name);
	   void set_map_dimension (size_type map_dim);
	   std::string name () const;
	   size_type map_dimension () const;

       // distributed specific acessors:

	   const distributor& ini_ownership() const;
	   size_type ioige2ini_dis_ioige (size_type ioige) const;
	   size_type ini_ioige2dis_ioige (size_type ini_ioige) const;

       // i/o:

	   template <class T>
	   idiststream& get (idiststream& ips, const geo_rep<T,distributed>& omega);
	   template <class T>
	   odiststream& put (odiststream& ops, const geo_rep<T,distributed>& omega) const;
       };

SEE ALSO

       geo(2), space(2)

rheolef-6.1							    rheolef-6.1 					 domain_indirect(7rheolef)