form_weighted.h

Go to the documentation of this file.

# ifndef _RHEOLEF_FORM_WEIGHTED_H
# define _RHEOLEF_FORM_WEIGHTED_H
#include "rheolef/form.h"
namespace rheolef { 

template<class T, class M>
template<class WeightFunction>
void
form_basic<T,M>::form_init (
    const std::string&      name,
    bool                    has_weight,
    WeightFunction          weight,
    const quadrature_option_type& qopt)
{
    if (name == "" || name == "nul" || name == "null") {
      // empty name => nul form, but with declared csr matrix sizes
      _uu.resize (_Y.iu_ownership(), _X.iu_ownership());
      _ub.resize (_Y.iu_ownership(), _X.ib_ownership());
      _bu.resize (_Y.ib_ownership(), _X.iu_ownership());
      _bb.resize (_Y.ib_ownership(), _X.ib_ownership());
      return;
    }
    typedef typename form_basic<T,M>::float_type float_type;
    bool X_is_on_domain = (_X.get_geo().data().variant() == geo_abstract_base_rep<float_type>::geo_domain);
    bool Y_is_on_domain = (_Y.get_geo().data().variant() == geo_abstract_base_rep<float_type>::geo_domain);
    geo_basic<T,M> omega;
    if (X_is_on_domain == Y_is_on_domain) {
      omega = _X.get_geo();
    } else {
      omega = _X.get_geo().get_background_geo();
    }
    form_element<T,M> form_e (name, _X, _Y, omega, qopt);

    if (has_weight) form_e.set_weight (weight);

    if (X_is_on_domain == Y_is_on_domain) {
      assembly (form_e, _X.get_geo(), _Y.get_geo());
    } else if (X_is_on_domain) {
      check_macro (_X.get_geo().get_background_geo() == _Y.get_geo(), 
        "form between incompatible geo " << _X.get_geo().name() << " and " << _Y.get_geo().name());
      const geo_basic<T,M>& Y_gamma = _X.get_geo().get_background_domain();
      bool X_geo_is_background = false;
      assembly (form_e, _X.get_geo(), Y_gamma, X_geo_is_background);
    } else { // Y_is_on_domain
      check_macro (_Y.get_geo().get_background_geo() == _X.get_geo(),
        "form between incompatible geo " << _X.get_geo().name() << " and " << _Y.get_geo().name());
      const geo_basic<T,M>& X_gamma = _Y.get_geo().get_background_domain();
      bool X_geo_is_background = true;
      assembly (form_e, X_gamma, _Y.get_geo(), X_geo_is_background);
    }
}
template<class T, class M>
template<class Function>
inline
form_basic<T,M>::form_basic (
  const space_type& X, 
  const space_type& Y,
  const std::string& name,
  Function weight,
  const quadrature_option_type& qopt)
  : _X(X),
    _Y(Y),
    _uu(),
    _ub(),
    _bu(),
    _bb()
{
    form_init (name, true, weight, qopt);
}
template<class T, class M>
template<class WeightFunction>
void
form_basic<T,M>::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,
    const quadrature_option_type& qopt)
{
    const geo_basic<T,M>& omega = _X.get_geo().get_background_geo();
    form_element<T,M> form_e (name, _X, _Y, omega, qopt);
    if (has_weight) form_e.set_weight (weight, w_omega);
    assembly (form_e, gamma, gamma);
}
template<class T, class M>
template<class Function>
form_basic<T,M>::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)
  : _X(X), 
    _Y(Y), 
    _uu(),
    _ub(),
    _bu(),
    _bb()
{
    form_init_on_domain (name, gamma, true, weight, compact(gamma), qopt);
}

}// namespace rheolef
# endif /* _RHEOLEF_FORM_WEIGHTED_H */