mass(3rheolef) [debian man page]

mass(3rheolef)							    rheolef-6.1 						    mass(3rheolef)

NAME

       mass -- L2 scalar product

SYNOPSIS

	       form(const space& V, const space& V, "mass");
	       form(const space& M, const space& V, "mass");
	       form (const space& V, const space& V, "mass", const domain& gamma);
	       form_diag(const space& V, "mass");

DESCRIPTION

       Assembly the matrix associated to the L2 scalar product of the finite element space V.

			/
			|
	       m(u,v) = | u v dx
			|
			/ Omega

       The V space may be either a P0, P1, P2, bubble, P1d and P1d finite element spaces for building a form see form(2).

       The  use of quadrature formulae is sometime usefull for building diagonal matrix.  These approximate matrix are eay to invert.  This proce-
       dure is available for P0 and P1 approximations.

       Notes that when dealing with discontinuous finite element space, i.e.  P0 and P1d, the corresponding mass matrix is block diagonal, and the
       inv_mass form may be usefull.

       When two different space M and V are supplied, assembly the matrix associated to the projection operator from one finite element space M to
       space V.

			/
			|
	       m(q,v) = | q v dx
			|
			/ Omega

       for all q in M and v in V.

       This form is usefull for instance to convert discontinuous gradient components to a continuous approximation.  The transpose  operator  may
       also be usefull to performs the opposite operation.

       The following $V$ and $M$ space approximation combinations are supported for the mass form: P0-P1, P0-P1d, P1d-P2, P1-P1d and P1-P2.

EXAMPLE

       The following piece of code build the mass matrix associated to the P1 approximation:

	       geo g("square");
	       space V(g, "P1");
	       form m(V, V, "mass");

       The use of lumped mass form write also:

	       form_diag md(V, "mass");

       The following piece of code build the projection form:

	       geo g("square");
	       space V(g, "P1");
	       space M(g, "P0");
	       form m(M, V, "mass");

SCALAR PRODUCT ON THE BOUNDARY

       Assembly  the  matrix  associated to the L2 scalar product related to a boundary domain of a mesh and a specified polynomial approximation.
       These forms are usefull when defining non-homogeneous Neumann or Robin boundary conditions.

       Let W be a space of functions defined on Gamma, a subset of the boundary of the whole domain Omega.

			/
			|
	       m(u,v) = | u v dx
			|
			/ Gamma

       for all u, v in W.  Let V a space of functions defined on Omega and gamma the trace operator from V into W.  For all u in W and v in V:

			 /
			 |
	       mb(u,v) = | u gamma(v) dx
			 |
			 / Gamma

       For all u and v in V:

			 /
			 |
	       ab(u,v) = | gamma(u) gamma(v) dx
			 |
			 / Gamma

EXAMPLE

       The following piece of code build forms for the P1 approximation, assuming that the mesh contains a domain named boundary:

	       geo omega ("square");
	       domain gamma = omega.boundary();
	       space V	(omega, "P1");
	       space W	(omega, gamma, "P1");
	       form  m	(W, W, "mass");
	       form  mb (W, V, "mass");
	       form  ab (V, V, "mass", gamma);

SEE ALSO

       form(2)

rheolef-6.1							    rheolef-6.1 						    mass(3rheolef)

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)