form.h

Go to the documentation of this file.

# ifndef _RHEOLEF_FORM_H
# define _RHEOLEF_FORM_H

#include "rheolef/csr.h"
#include "rheolef/field.h"
#include "rheolef/form_element.h"
#include "rheolef/quadrature.h"
namespace rheolef { 

template <class T, class M> class form_concat_value;
template <class T, class M> class form_concat_line;

template <class T, class M> class band_basic;

template<class T, class M>
class form_basic {
public :

    typedef typename csr<T,M>::size_type    size_type;
    typedef T                               value_type;
    typedef typename scalar_traits<T>::type float_type;
    typedef geo_basic<float_type,M>         geo_type;
    typedef space_basic<float_type,M>       space_type;

// allocator/deallocator:

    form_basic ();
    form_basic (const form_basic<T,M>&);

    form_basic (const space_type& X, const space_type& Y,
        const std::string& name = "",
        const quadrature_option_type& qopt = quadrature_option_type(quadrature_option_type::max_family,0));

    form_basic (const space_type& X, const space_type& Y,
        const std::string& name,
        const field_basic<T,M>& weight, 
        const quadrature_option_type& qopt = quadrature_option_type(quadrature_option_type::max_family,0));

    form_basic (const space_type& X, const space_type& Y,
        const std::string& name,
        const band_basic<T,M>& bh, 
        const quadrature_option_type& qopt = quadrature_option_type(quadrature_option_type::max_family,0));

    template<class Function>
    form_basic (const space_type& X, const space_type& Y,
        const std::string& name,
        Function weight,
        const quadrature_option_type& qopt = quadrature_option_type(quadrature_option_type::max_family,0));

    form_basic (const space_type& X, const space_type& Y,
        const std::string& name,
        const geo_basic<T,M>& gamma,
        const quadrature_option_type& qopt = quadrature_option_type(quadrature_option_type::max_family,0));

    form_basic (const space_type& X, const space_type& Y,
        const std::string& name,
        const geo_basic<T,M>& gamma,
        const field_basic<T,M>& weight,
        const quadrature_option_type& qopt = quadrature_option_type(quadrature_option_type::max_family,0));

    template<class Function>
    form_basic (
        const space_type& X, 
        const space_type& Y,
        const std::string& name,
        const geo_basic<T,M>& gamma,
        Function weight,
        const quadrature_option_type& qopt = quadrature_option_type(quadrature_option_type::max_family,0));


#ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST
    form_basic (const std::initializer_list<form_concat_value<T,M> >& init_list);
    form_basic (const std::initializer_list<form_concat_line <T,M> >& init_list);
#endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST


    const space_type& get_first_space() const;
    const space_type& get_second_space() const;
    const geo_type&   get_geo() const;

    const communicator& comm() const;


    form_basic<T,M>  operator+  (const form_basic<T,M>& b) const;
    form_basic<T,M>  operator-  (const form_basic<T,M>& b) const;
    form_basic<T,M>  operator*  (const form_basic<T,M>& b) const;
    form_basic<T,M>& operator*= (const T& lambda);
    field_basic<T,M> operator*  (const field_basic<T,M>& xh) const;
    field_basic<T,M> trans_mult (const field_basic<T,M>& yh) const;
    float_type operator () (const field_basic<T,M>& uh, const field_basic<T,M>& vh) const;


    odiststream& put (odiststream& ops, bool show_partition = true) const;
    void dump (std::string name) const;


    const csr<T,M>&     uu() const { return _uu; }
    const csr<T,M>&     ub() const { return _ub; }
    const csr<T,M>&     bu() const { return _bu; }
    const csr<T,M>&     bb() const { return _bb; }
          csr<T,M>& set_uu()       { return _uu; }
          csr<T,M>& set_ub()       { return _ub; }
          csr<T,M>& set_bu()       { return _bu; }
          csr<T,M>& set_bb()       { return _bb; }

protected:
    space_type  _X;
    space_type  _Y;
    csr<T,M>    _uu;
    csr<T,M>    _ub;
    csr<T,M>    _bu;
    csr<T,M>    _bb;

    void assembly (const form_element<T,M>&   form_e, 
                   const geo_basic<T,M>&      X_geo,
                   const geo_basic<T,M>&      Y_geo,
                   bool  X_geo_is_background = true);

    template<class WeightFunction>
    void form_init (
                   const std::string&      name,
                   bool                    has_weight,
                   WeightFunction          weight,
                   const quadrature_option_type& qopt);
    template<class WeightFunction>
    void form_init_on_domain (
                   const std::string&      name,
                   const geo_basic<T,M>&   gamma,
                   bool                    has_weight,
                   WeightFunction          weight,
                   const geo_basic<T,M>&   w_omega, // the domain where the fct weight is defined
                   const quadrature_option_type& qopt);
};
template<class T, class M> form_basic<T,M> trans (const form_basic<T,M>& a);
template<class T, class M> field_basic<T,M> diag (const form_basic<T,M>& a);
template<class T, class M> form_basic<T,M>  diag (const field_basic<T,M>& dh);
typedef form_basic<Float,rheo_default_memory_model> form;
@endcode


template<class T, class M>
inline
form_basic<T,M>::form_basic ()
: _X(), _Y(), _uu(), _ub(), _bu(), _bb()
{
}
template<class T, class M>
inline
form_basic<T,M>::form_basic (const form_basic<T,M>& a)
: _X(a._X), _Y(a._Y), _uu(a._uu), _ub(a._ub), _bu(a._bu), _bb(a._bb)
{
}
template<class T, class M>
inline
const typename form_basic<T,M>::space_type&
form_basic<T,M>::get_first_space() const
{
  return _X;
}
template<class T, class M>
inline
const typename form_basic<T,M>::space_type&
form_basic<T,M>::get_second_space() const
{
  return _Y;
}
template<class T, class M>
inline
const typename form_basic<T,M>::geo_type&
form_basic<T,M>::get_geo() const
{
  return _X.get_geo();
}
template<class T, class M>
inline
const communicator&
form_basic<T,M>::comm() const
{
  return get_geo().comm();
}
template<class T, class M>
inline
form_basic<T,M>
form_basic<T,M>::operator+ (const form_basic<T,M>& b) const
{
  form_basic<T,M> c (get_first_space(), get_second_space());
  c._uu = _uu + b._uu;
  c._ub = _ub + b._ub;
  c._bu = _bu + b._bu;
  c._bb = _bb + b._bb;
  return c;
}
template<class T, class M>
inline
form_basic<T,M>
form_basic<T,M>::operator- (const form_basic<T,M>& b) const
{
  form_basic<T,M> c (get_first_space(), get_second_space());
  c._uu = _uu - b._uu;
  c._ub = _ub - b._ub;
  c._bu = _bu - b._bu;
  c._bb = _bb - b._bb;
  return c;
}
template<class T, class M>
inline
form_basic<T,M>
form_basic<T,M>::operator* (const form_basic<T,M>& b) const
{
  form_basic<T,M> c (b.get_first_space(), get_second_space());
  c._uu = _uu*b._uu + _ub*b._bu;
  c._ub = _uu*b._ub + _ub*b._bb;
  c._bu = _bu*b._uu + _bb*b._bu;
  c._bb = _bu*b._ub + _bb*b._bb;
  return c;
}
template<class T, class M>
inline
form_basic<T,M>&
form_basic<T,M>::operator*= (const T& lambda)
{
  _uu *= lambda;
  _ub *= lambda;
  _bu *= lambda;
  _bb *= lambda;
  return *this;
}
template<class T, class M>
inline
form_basic<T,M>
operator* (const T& lambda, const form_basic<T,M>& a)
{
  form_basic<T,M> b = a;
  b *= lambda;
  return b;
}
template<class T, class M>
inline
form_basic<T,M>
operator- (const form_basic<T,M>& a)
{
  return T(-1)*a;
}

}// namespace rheolef
# endif /* _RHEOLEF_FORM_H */