NAME

       riesz - approximate a Riesz representer

SYNOPSYS

       The  riesz  function  is  now  obsolete:  it  has  been  now  suppersetted  by the integrate function see
       integrate(4).

        template <class Expr>
        field riesz (space, Expr expr);
        field riesz (space, Expr expr, quadrature_option_type);
        field riesz (space, Expr expr, domain);
        field riesz (space, Expr expr, domain, quadrature_option_type);

       The domain can be also provided by its name as a string.  The old-fashioned code:

NOTE

       The riesz function is now  obsolete:  it  has  been  now  suppersetted  by  the  integrate  function  see
       integrate(4).  The old-fashioned code:

            field l1h = riesz (Xh, f);
            field l2h = riesz (Xh, f, "boundary");

       writes now:

            test v (Xh);
            field l1h = integrate (f*v);
            field l2h = integrate ("boundary", f*v);

       The riesz function is still present in the library for backward compatibility purpose.

DESCRIPTION

       Let  f  be  any  continuous  function, its Riesz representer in the finite element space Xh on the domain
       Omega is defind by:

                       /
                       |
         dual(lh,vh) = |      f(x) vh(x) dx
                       |
                      / Omega

       for all vh in Xh, where dual denotes the duality between Xh and its dual. As Xh is a  finite  dimensional
       space,  its dual is identified as Xh and the duality product as the Euclidian one.  The Riesz representer
       is thus the lh field of Xh where its i-th degree of freedom is:

                       /
                       |
         dual(lh,vh) = |      f(x) phi_i(x) dx
                       |
                      / Omega

       where phi_i is the i-th basis function in Xh.  The integral is evaluated by using a  quadrature  formula.
       By  default  the  quadrature  formule  is  the  Gauss  one  with the order equal to 2*k-1 where $k is the
       polynomial degree in Xh.  Alternative quadrature formula and order is available by  passing  an  optional
       variable to riesz.

       The function riesz implements the approximation of the Riesz representer by using some quadrature formula
       for  the  evaluation  of  the  integrals.   Its argument can be any function, class-function or linear or
       nonlinear expressions mixing fields and continuous functions.

EXAMPLE

       The following code compute the Riesz representant, denoted by lh of f(x), and the integral of f over  the
       domain omega:

         Float f(const point& x);
         ...
         space Xh (omega_h, "P1");
         field lh = riesz (Xh, f);
         Float int_f = dual(lh, 1);

OPTIONS

       An  optional  argument  specifies  the  quadrature formula used for the computation of the integral.  The
       domain of integration is by default the mesh associated to the  finite  element  space.   An  alternative
       domain  dom, e.g. a part of the boundary can be supplied as an extra argument.  This domain can be also a
       band associated to the banded level set method.

IMPLEMENTATION

       template <class T, class M, class Function>
       inline
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           const quadrature_option_type& qopt
              = quadrature_option_type())

IMPLEMENTATION

       template <class T, class M, class Function>
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           const geo_basic<T,M>&         dom,
           const quadrature_option_type& qopt
              = quadrature_option_type())

IMPLEMENTATION

       template <class T, class M, class Function>
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           std::string                   dom_name,
           const quadrature_option_type& qopt
              = quadrature_option_type())

IMPLEMENTATION

       template <class T, class M, class Function>
       field_basic<T,M>
       riesz (
           const space_basic<T,M>&       Xh,
           const Function&               f,
           const band_basic<T,M>&        gh,
           const quadrature_option_type& qopt
              = quadrature_option_type())

SEE ALSO

       integrate(4), integrate(4)

rheolef-6.7                                        rheolef-6.7                                   riesz(4rheolef)