characteristic(2rheolef) [debian man page]

characteristic(2rheolef)					    rheolef-6.1 					  characteristic(2rheolef)

NAME

       characteristic - the Lagrange-Galerkin method implemented

SYNOPSYS

	The class characteristic implements the Lagrange-Galerkin method:
	It is the extension of the method of characteristic from the finite
	difference to the finite element context.

EXAMPLE

	The following code compute the Riesz representer (see riesz(4)),
	denoted by lh of u(x)=uh(x+dh(x)) where ah is the
	deformation vector field. The deformation field dh=-dt*uh
	in Lagrange-Galerkin methods, where ah is the advection field
	and dt a time step.

	 geo omega;
	 field dh = ...;
	 field uh = ...;
	 characteristic X (dh);
	 field lh = riesz(Xh, compose(uh, X));

	The Riesz representer is the lh vector field defined by:

	       lh(i) = integrate uh(x+dh(x)) phi_i(x) dx

	where phi_i is the i-th basis function in the space Xh
	and the integral is evaluated by using a quadrature formulae.
	By default the quadrature formule is Gauss-Lobatto with
	the order equal to the polynomial order of Xh
	(order 1: trapeze, order 2: simpson, etc).
	Recall that this choice of quadrature formulae guaranties inconditional
	stability at any polynomial order.
	Alternative quadrature formulae or order can be used by using the
	additional quadrature option argument to the riesz function.

IMPLEMENTATION

       template<class T, class M = rheo_default_memory_model>
       class characteristic_basic : public smart_pointer<characteristic_rep<T,M> > {
       public:
	 typedef characteristic_rep<T,M> rep;
	 typedef smart_pointer<rep>	 base;

       // allocator:

	 characteristic_basic(const field_basic<T,M>& dh);

       // accesors:

	 const field_basic<T,M>& get_displacement() const;

	 const characteristic_on_quadrature<T,M>&
	 get_pre_computed (
	   const space_basic<T,M>&	 Xh,
	   const field_basic<T,M>&	 dh,
	   const quadrature_option_type& qopt) const;

       };
       typedef characteristic_basic<Float> characteristic;

IMPLEMENTATION

       template<class T, class M>
       inline
       field_o_characteristic<T,M>
       compose (const field_basic<T,M>& uh, characteristic_basic<T,M>& X)

IMPLEMENTATION

       template <class T, class M>
       field_basic<T,M>
       riesz (
	   const space_basic<T,M>&	       Xh,
	   const field_o_characteristic<T,M>&  f,
	   quadrature_option_type	       qopt
	      = quadrature_option_type(quadrature_option_type::max_family,0));

SEE ALSO

       riesz(4)

rheolef-6.1							    rheolef-6.1 					  characteristic(2rheolef)

Check Out this Related Man Page

quadrature(7rheolef)						    rheolef-6.1 					      quadrature(7rheolef)

NAME

       quadrature - quadrature formulae on the reference lement

SYNOPSYS

       The  quadrature	class  defines	a container for a quadrature formulae on the reference element (see reference_element(2)).  This container
       stores the nodes coordinates and the weights.

THE CONSTRUCTOR TAKES TWO ARGUMENTS

	the reference element K and the order r of the quadrature formulae.  The formulae is exact when computing the integral of a polynom p that
       degree is less or equal to order r.

			 n
	   /		___
	   | p(x) dx =	    p(x_q) w_q
	   / K		/__
			q=1

LIMITATIONS

       The formulae is optimal when it uses a minimal number of nodes n.  Optimal quadrature formula are hard-coded in this class.  Not all refer-
       ence elements and orders are yet implemented. This class will be completed in the future.

IMPLEMENTATION

       template<class T>
       class quadrature {
       public:

       // typedefs:

	   typedef typename quadrature_on_geo<T>::size_type		    size_type;
	   typedef quadrature_option_type::family_type			    family_type;
	   typedef typename std::vector<weighted_point<T> >::const_iterator const_iterator;

       // allocators:

	   quadrature (quadrature_option_type opt = quadrature_option_type());

       // modifiers:

	   void set_order  (size_type order);
	   void set_family (family_type ft);

       // accessors:

	   size_type	  get_order() const;
	   family_type	  get_family() const;
	   std::string	  get_family_name() const;
	   size_type	  size	(reference_element hat_K) const;
	   const_iterator begin (reference_element hat_K) const;
	   const_iterator end	(reference_element hat_K) const;
	   template<class U>
	   friend std::ostream& operator<< (std::ostream&, const quadrature<U>&);
       protected:
	   quadrature_option_type	 _options;
	   mutable quadrature_on_geo<T>  _quad [reference_element::max_variant];
	   mutable std::vector<bool>	 _initialized;
	   void _initialize (reference_element hat_K) const;
       private:
	   quadrature (const quadrature<T>&);
	   quadrature operator= (const quadrature<T>&);
       };

SEE ALSO

       reference_element(2)

rheolef-6.1							    rheolef-6.1 					      quadrature(7rheolef)

Linux and UNIX Man Pages

characteristic(2rheolef) [debian man page]

Check Out this Related Man Page