Loading...
Searching...
No Matches
field_expr_terminal.h
Go to the documentation of this file.
#ifndef _RHEOLEF_FIELD_EXPR_TERMINAL_H
#define _RHEOLEF_FIELD_EXPR_TERMINAL_H
//
// terminals (leaves) for the non-linear expression tree
//
// 0) utilities
// 0.1) concepts
// 0.2) terminal wrapper for exprs
// 0.2) utility for evaluation on sides
// 1) class-function
// 1.1) base class for the class-function family
// 1.2) general function or class-function
// 1.3) normal to a surface
// 1.4) h_local
// 1.5) penalty
// 2) field and such
// 2.1) field
// 2.2) jump of a field
// 3) convected field, as compose(uh,X) where X is a characteristic
//
#include "rheolef/field.h"
#include "rheolef/field_wdof_sliced.h"
#include "rheolef/field_expr_utilities.h"
#include "rheolef/expression.h"
#include "rheolef/form.h"
#include "rheolef/basis_on_pointset.h"
#include "rheolef/test.h"
#include "rheolef/characteristic.h"
namespace rheolef {
// -------------------------------------------------------------------
// 0) utilities
// -------------------------------------------------------------------
namespace details {
#ifdef TO_CLEAN
// -------------------------------------------------------------------
// 0.1) concepts
// -------------------------------------------------------------------
// Define a trait type for detecting field expression valid arguments
// -> constant and field_convertible are valid terminals:
template<class Expr, class Sfinae = void> struct is_field_expr_v2_nonlinear_arg : std::false_type {};
template<class Expr> struct is_field_expr_v2_nonlinear_arg <Expr, typename std::enable_if<
is_field_expr_v2_constant<Expr>::value>::type> : std::true_type {};
template<class Expr> struct is_field_expr_v2_nonlinear_arg <Expr, typename std::enable_if<
has_field_rdof_interface<Expr>::value
>::type> : std::true_type {};
// Define a trait type for detecting linear & homogeneous expressions
// these expressions should act homogeneously in the same finite element space
template<class Expr> struct is_field_expr_affine_homogeneous <Expr, typename std::enable_if<
is_field_expr_v2_constant<Expr>::value>::type> : std::true_type {};
template<class Expr> struct is_field_expr_affine_homogeneous <Expr, typename std::enable_if<
has_field_rdof_interface<Expr>::value
>::type> : std::true_type {};
#endif // TO_CLEAN
// -------------------------------------------------------------------
// 0.2) terminal wrapper for exprs
// -------------------------------------------------------------------
template <class Expr, class Sfinae = void>
struct field_expr_v2_nonlinear_terminal_wrapper_traits
{
// catch-all case: non-terminals are not wrapped
typedef Expr type;
};
// -------------------------------------------------------------------
// 0.3) utility for evaluation on sides
// -------------------------------------------------------------------
template<class T, class M>
const geo_element& global_get_side (const geo_basic<T,M>& omega, const geo_element& L, const side_information_type& sid);
} // namespace details
// ---------------------------------------------------------------------------
// 1. field-function
// ---------------------------------------------------------------------------
// 1.1. base class for the field-function family
// ---------------------------------------------------------------------------
namespace details {
template<class T>
class field_expr_v2_nonlinear_terminal_function_base_rep {
public:
// typedefs:
typedef geo_element::size_type size_type;
typedef rheo_default_memory_model memory_type; // TODO: deduce it
typedef T scalar_type;
typedef T float_type;
// allocators:
field_expr_v2_nonlinear_terminal_function_base_rep ();
field_expr_v2_nonlinear_terminal_function_base_rep (const field_expr_v2_nonlinear_terminal_function_base_rep<T>&);
// accessors:
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
template<class M>
const geo_element&
get_side (
const geo_basic<float_type,M>& omega_K,
const geo_element& K,
const side_information_type& sid) const;
// data:
protected:
mutable piola_on_pointset<float_type> _pops;
};
// ---------------------------------------------------------------------------
// 1.2) general function or class-function
// ---------------------------------------------------------------------------
template<class Function>
class field_expr_v2_nonlinear_terminal_function_rep
: field_expr_v2_nonlinear_terminal_function_base_rep
<typename float_traits<typename details::function_traits<Function>::result_type>::type>
{
public:
// typedefs:
typedef geo_element::size_type size_type;
typedef rheo_default_memory_model memory_type; // TODO: how to deduce it ?
typedef typename details::function_traits<Function>::copiable_type function_type;
typedef typename details::function_traits<Function>::result_type result_type;
typedef typename details::function_traits<Function>::template arg<0>::type argument_type;
typedef typename scalar_traits<result_type>::type scalar_type;
typedef typename float_traits<result_type>::type float_type;
typedef result_type value_type;
typedef field_expr_v2_nonlinear_terminal_function_base_rep<float_type> base;
// alocators:
field_expr_v2_nonlinear_terminal_function_rep(const Function& f);
// accessors:
static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<result_type>::value;
space_constant::valued_type valued_tag() const {
return space_constant::valued_tag_traits<result_type>::value; }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::initialize (pops, iopt); }
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::initialize (Xh, pops, iopt); }
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const
{
const Eigen::Matrix<piola<float_type>,Eigen::Dynamic,1>& piola = base::_pops.get_piola (omega_K, K);
reference_element hat_K = K.variant();
size_type loc_nnod = piola.size();
value.resize (loc_nnod);
for (size_type loc_inod = 0; loc_inod < loc_nnod; ++loc_inod) {
const point_basic<float_type>& xi = piola[loc_inod].F;
value[loc_inod] = _f (xi);
}
}
void evaluate_on_side (
const geo_basic<float_type,memory_type>& omega_L,
const geo_element& L,
const side_information_type& sid,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const
// TODO QUESTION_SIDE: is there some rotation and orientation to apply to the value order ?
{ evaluate (omega_L, base::get_side(omega_L,L,sid), value); }
template<class Value>
bool valued_check() const {
static const bool status = is_equal<Value,result_type>::value;
check_macro (status, "unexpected result_type");
return status;
}
// data:
protected:
function_type _f;
// working area:
public:
mutable std::array<
Eigen::Matrix<scalar_type,Eigen::Dynamic,1>
,reference_element::max_variant> _scalar_val;
mutable std::array<
Eigen::Matrix<point_basic<scalar_type>,Eigen::Dynamic,1>
,reference_element::max_variant> _vector_val;
mutable std::array<
Eigen::Matrix<tensor_basic<scalar_type>,Eigen::Dynamic,1>
,reference_element::max_variant> _tensor_val;
mutable std::array<
Eigen::Matrix<tensor3_basic<scalar_type>,Eigen::Dynamic,1>
,reference_element::max_variant> _tensor3_val;
mutable std::array<
Eigen::Matrix<tensor4_basic<scalar_type>,Eigen::Dynamic,1>
,reference_element::max_variant> _tensor4_val;
};
template<class Function>
field_expr_v2_nonlinear_terminal_function_rep<Function>::field_expr_v2_nonlinear_terminal_function_rep (const Function& f)
: base(),
_f(f),
_scalar_val(),
_vector_val(),
_tensor_val(),
_tensor3_val(),
_tensor4_val()
{
}
template<class Function>
class field_expr_v2_nonlinear_terminal_function : public smart_pointer<field_expr_v2_nonlinear_terminal_function_rep<Function> >
{
public:
// typedefs:
typedef field_expr_v2_nonlinear_terminal_function_rep<Function> rep;
typedef smart_pointer<rep> base;
typedef typename rep::size_type size_type;
typedef typename rep::memory_type memory_type;
typedef typename rep::result_type result_type;
typedef typename rep::argument_type argument_type;
typedef typename rep::value_type value_type;
typedef typename rep::scalar_type scalar_type;
typedef typename rep::float_type float_type;
static const space_constant::valued_type valued_hint = rep::valued_hint;
// alocators:
explicit field_expr_v2_nonlinear_terminal_function (const Function& f)
: base(new_macro(rep(f))) {}
template<class TrueFunction,
class Sfinae = typename std::enable_if<std::is_function<TrueFunction>::value, TrueFunction>::type>
explicit field_expr_v2_nonlinear_terminal_function (TrueFunction f)
: base(new_macro(rep(std::ptr_fun(f)))) {}
template <class Constant,
class Sfinae = typename std::enable_if <is_field_expr_v2_constant<Constant>::value, Constant>::type>
explicit field_expr_v2_nonlinear_terminal_function (const Constant& c)
: base(new_macro(rep(f_constant<point_basic<float_type>,result_type>(c)))) {}
// accessors:
space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::data().initialize (pops, iopt); }
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::data().initialize (Xh, pops, iopt); }
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const
{ return base::data().evaluate (omega_K, K, value); }
void evaluate_on_side (
const geo_basic<float_type,memory_type>& omega_L,
const geo_element& L,
const side_information_type& sid,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const
{ return base::data().evaluate_on_side (omega_L, L, sid, value); }
template<class Value>
bool valued_check() const {
return base::data().template valued_check<Value>(); }
};
// concept::
template<class F> struct is_field_expr_v2_nonlinear_arg <field_expr_v2_nonlinear_terminal_function<F> > : std::true_type {};
//template<class F> struct has_field_lazy_interface <field_expr_v2_nonlinear_terminal_function<F> > : std::true_type {};
template<class F> struct is_field_expr_v2_nonlinear_arg <F,
typename std::enable_if<
std::conjunction<
std::negation<has_field_rdof_interface<F>> // filter: has op()(i_com,j_cmp) inherited from field_rdof
,is_field_function<F>
>::value
>::type
> : std::true_type {};
// wrapper:
template <class Expr>
struct field_expr_v2_nonlinear_terminal_wrapper_traits <Expr,
typename std::enable_if<
std::conjunction<
std::negation<has_field_rdof_interface<Expr>> // filter: has op()(i_com,j_cmp) inherited from field_rdof
,is_field_function<Expr>
>::value
>::type
>
{
typedef field_expr_v2_nonlinear_terminal_function<Expr> type;
};
// wrapper for Expr=constant (used by nary compose to wrap constant args)
template <class Expr>
struct field_expr_v2_nonlinear_terminal_wrapper_traits <Expr,
typename std::enable_if<
is_field_expr_v2_constant<Expr>::value
>::type
>
{
typedef typename promote<Expr,Float>::type float_type; // promote int to Float, at least
typedef f_constant<point_basic<float_type>,Expr> fun_t;
typedef field_expr_v2_nonlinear_terminal_function<fun_t> type;
};
// ---------------------------------------------------------------------------
// 1.3) normal to a surface
// ---------------------------------------------------------------------------
// the special class-function, used in nonlinear field expressions:
template<class T>
struct normal_pseudo_function : std::unary_function <point_basic<T>, point_basic<T> > {
point_basic<T> operator() (const point_basic<T>&) const {
fatal_macro ("special normal() class-function should not be directly evaluated");
return point_basic<T>();
}
};
template<class T>
class field_expr_v2_nonlinear_terminal_function_rep<normal_pseudo_function<T> >
: field_expr_v2_nonlinear_terminal_function_base_rep<T> {
public:
// typedefs:
typedef field_expr_v2_nonlinear_terminal_function_base_rep<T> base;
typedef geo_element::size_type size_type;
typedef rheo_default_memory_model memory_type; // TODO: deduce it
typedef normal_pseudo_function<T> function_type;
typedef point_basic<T> result_type;
typedef point_basic<T> argument_type;
typedef T scalar_type;
typedef T float_type;
typedef result_type value_type;
// alocators:
field_expr_v2_nonlinear_terminal_function_rep (const function_type&);
field_expr_v2_nonlinear_terminal_function_rep (const field_expr_v2_nonlinear_terminal_function_rep<normal_pseudo_function<T> >&);
// accessors:
static const space_constant::valued_type valued_hint = space_constant::vector;
space_constant::valued_type valued_tag() const { return space_constant::vector; }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const;
void evaluate_on_side (
const geo_basic<float_type,memory_type>& omega_L,
const geo_element& L,
const side_information_type& sid,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const;
void evaluate_internal(
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
const T& sign,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const;
template<class Value>
bool valued_check() const {
static const bool status = details::is_equal<Value,result_type>::value;
check_macro (status, "unexpected result_type");
return status;
}
// data:
mutable bool _is_on_interface, _is_inside_on_local_sides; // normal sign fix
};
} // namespace details
// the normal() pseudo-function
template<class T>
inline
details::field_expr_v2_nonlinear_terminal_function <details::normal_pseudo_function<T> >
normal_basic()
{
return details::field_expr_v2_nonlinear_terminal_function
<details::normal_pseudo_function<T> >
(details::normal_pseudo_function<T>());
}
inline
details::field_expr_v2_nonlinear_terminal_function <details::normal_pseudo_function<Float> >
normal()
{
return normal_basic<Float>();
}
// ---------------------------------------------------------------------------
// 1.4) h_local
// ---------------------------------------------------------------------------
namespace details {
// the special class-function, used in nonlinear field expressions:
template<class T>
struct h_local_pseudo_function : std::unary_function <point_basic<T>, T> {
T operator() (const point_basic<T>&) const {
fatal_macro ("special h_local() class-function should not be directly evaluated");
return 0;
}
};
template<class T>
class field_expr_v2_nonlinear_terminal_function_rep<h_local_pseudo_function<T> >
: field_expr_v2_nonlinear_terminal_function_base_rep<T> {
public:
// typedefs:
typedef field_expr_v2_nonlinear_terminal_function_base_rep<T> base;
typedef geo_element::size_type size_type;
typedef rheo_default_memory_model memory_type; // TODO: deduce it
typedef h_local_pseudo_function<T> function_type;
typedef T result_type;
typedef point_basic<T> argument_type;
typedef T scalar_type;
typedef T float_type;
typedef result_type value_type;
// alocators:
field_expr_v2_nonlinear_terminal_function_rep (const function_type&);
field_expr_v2_nonlinear_terminal_function_rep (const field_expr_v2_nonlinear_terminal_function_rep<h_local_pseudo_function<T> >&);
// accessors:
static const space_constant::valued_type valued_hint = space_constant::scalar;
space_constant::valued_type valued_tag() const { return space_constant::scalar; }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const;
void evaluate_on_side (
const geo_basic<float_type,memory_type>& omega_L,
const geo_element& L,
const side_information_type& sid,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const;
template<class Value>
bool valued_check() const {
static const bool status = details::is_equal<Value,result_type>::value;
check_macro (status, "unexpected result_type");
return status;
}
};
} // namespace details
// the h_local() pseudo-function
template<class T>
inline
details::field_expr_v2_nonlinear_terminal_function <details::h_local_pseudo_function<T> >
h_local_basic()
{
return details::field_expr_v2_nonlinear_terminal_function
<details::h_local_pseudo_function<T> >
(details::h_local_pseudo_function<T>());
}
inline
details::field_expr_v2_nonlinear_terminal_function <details::h_local_pseudo_function<Float> >
h_local()
{
return h_local_basic<Float>();
}
// ---------------------------------------------------------------------------
// 1.5) penalty
// ---------------------------------------------------------------------------
// the special class-function, used in nonlinear field expressions:
namespace details {
template<class T>
struct penalty_pseudo_function : std::unary_function <point_basic<T>, T> {
T operator() (const point_basic<T>&) const {
fatal_macro ("special penalty() class-function should not be directly evaluated");
return 0;
}
};
template<class T>
class field_expr_v2_nonlinear_terminal_function_rep<penalty_pseudo_function<T> >
: field_expr_v2_nonlinear_terminal_function_base_rep<T> {
public:
// typedefs:
typedef field_expr_v2_nonlinear_terminal_function_base_rep<T> base;
typedef geo_element::size_type size_type;
typedef rheo_default_memory_model memory_type; // TODO: deduce it
typedef penalty_pseudo_function<T> function_type;
typedef T result_type;
typedef point_basic<T> argument_type;
typedef T scalar_type;
typedef T float_type;
typedef result_type value_type;
// alocators:
field_expr_v2_nonlinear_terminal_function_rep (const function_type&);
field_expr_v2_nonlinear_terminal_function_rep (const field_expr_v2_nonlinear_terminal_function_rep<penalty_pseudo_function<T> >&);
// accessors:
static const space_constant::valued_type valued_hint = space_constant::scalar;
space_constant::valued_type valued_tag() const { return space_constant::scalar; }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const;
void evaluate_on_side (
const geo_basic<float_type,memory_type>& omega_L,
const geo_element& L,
const side_information_type& sid,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const;
template<class Value>
bool valued_check() const {
static const bool status = details::is_equal<Value,result_type>::value;
check_macro (status, "unexpected result_type");
return status;
}
protected:
// internal:
T evaluate_measure (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K) const;
void evaluate_internal(
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
const geo_element& L,
Eigen::Matrix<result_type,Eigen::Dynamic,1>& value) const;
};
} // namespace details
// the penalty() pseudo-function
template<class T>
inline
details::field_expr_v2_nonlinear_terminal_function <details::penalty_pseudo_function<T> >
penalty_basic()
{
return details::field_expr_v2_nonlinear_terminal_function
<details::penalty_pseudo_function<T> >
(details::penalty_pseudo_function<T>());
}
inline
details::field_expr_v2_nonlinear_terminal_function <details::penalty_pseudo_function<Float> >
penalty()
{
return penalty_basic<Float>();
}
// ---------------------------------------------------------------------------
// 2) field and such
// ---------------------------------------------------------------------------
// 2.1) field
// ---------------------------------------------------------------------------
namespace details {
template<class T, class M, details::differentiate_option::type Diff>
class field_expr_v2_nonlinear_terminal_field_rep {
public:
// typedefs:
using size_type = geo_element::size_type;
using memory_type = M;
using scalar_type = T;
using float_type = typename float_traits<T>::type;
using result_type = typename std::conditional<
Diff == details::differentiate_option::divergence
,T // TODO: support also div(tensor) -> vector
,undeterminated_basic<T>
>::type;
using value_type = result_type;
// allocators:
template <class Expr,
class Sfinae = typename std::enable_if<details::has_field_rdof_interface<Expr>::value>::type>
explicit field_expr_v2_nonlinear_terminal_field_rep (const Expr& expr, const differentiate_option& gopt);
#ifdef TO_CLEAN
// --------------------------------------------
// field_lazy interface:
// --------------------------------------------
const geo_type& get_geo() const { return _uh.get_geo(); }
const band_type& get_band() const { return _uh.get_band(); }
const space_type& get_space() const { return _uh.get_space(); }
bool is_on_band () const { return _expr.is_on_band(); }
void initialize (const geo_type& omega_K) { _uh.initialize (omega_K); }
#endif // TO_CLEAN
// --------------------------------------------
// accessors for the affine & homogeneous case:
// --------------------------------------------
bool have_homogeneous_space (space_basic<scalar_type,memory_type>& Vh) const {
Vh = _uh.get_space();
return true;
}
// minimal forward iterator interface:
using const_iterator = typename field_basic<T,M>::const_iterator;
const_iterator begin_dof() const { return _uh.begin_dof(); }
// --------------------------------------------
// accessors for the general nonlinear case:
// --------------------------------------------
static const space_constant::valued_type valued_hint = space_constant::last_valued;
space_constant::valued_type valued_tag() const;
void initialize (
const piola_on_pointset<T>& pops,
const integrate_option& iopt);
void initialize (
const space_basic<T,M>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
const geo_element& get_side (const geo_element& K, const side_information_type& sid) const;
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const;
template<class Value>
void evaluate_on_side (
const geo_basic<float_type,memory_type>& omega_L,
const geo_element& L,
const side_information_type& sid,
Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const;
template<class Value>
bool valued_check() const;
// data:
differentiate_option _gopt;
field_basic<T,M> _uh;
test_basic<T,M,details::vf_tag_01> _u_test;
mutable bool _use_dom2bgd;
mutable bool _use_bgd2dom;
mutable bool _have_dg_on_sides;
mutable reference_element _tilde_L;
// working data:
mutable basis_on_pointset<T> _piola_on_geo_basis; // for DF, for Hdiv RT ect
mutable std::vector<size_type> _dis_inod_geo; // idem
bool _need_vector_piola;
public:
mutable std::array<
Eigen::Matrix<T,Eigen::Dynamic,1>
,reference_element::max_variant> _scalar_val;
mutable std::array<
Eigen::Matrix<point_basic<T>,Eigen::Dynamic,1>
,reference_element::max_variant> _vector_val;
mutable std::array<
Eigen::Matrix<tensor_basic<T>,Eigen::Dynamic,1>
,reference_element::max_variant> _tensor_val;
mutable std::array<
Eigen::Matrix<tensor3_basic<T>,Eigen::Dynamic,1>
,reference_element::max_variant> _tensor3_val;
mutable std::array<
Eigen::Matrix<tensor4_basic<T>,Eigen::Dynamic,1>
,reference_element::max_variant> _tensor4_val;
};
// inlined:
template<class T, class M, details::differentiate_option::type Diff>
template <class Expr, class Sfinae>
inline
field_expr_v2_nonlinear_terminal_field_rep<T,M,Diff>::field_expr_v2_nonlinear_terminal_field_rep (const Expr& expr, const differentiate_option& gopt)
: _gopt(gopt),
_uh(expr),
_u_test(_uh.get_space()),
_use_dom2bgd(false),
_use_bgd2dom(false),
_have_dg_on_sides(false),
_tilde_L(),
_piola_on_geo_basis(),
_dis_inod_geo(),
_need_vector_piola(false),
_scalar_val(),
_vector_val(),
_tensor_val(),
_tensor3_val(),
_tensor4_val()
{
// e.g. Hdiv RTk: use DF for piola vector/tensor transformation
_need_vector_piola
= _uh.valued_tag() != space_constant::scalar &&
! _uh.get_space().get_constitution().is_hierarchical();
}
template<class T, class M, details::differentiate_option::type Diff>
template<class Value>
inline
bool
field_expr_v2_nonlinear_terminal_field_rep<T,M,Diff>::valued_check() const
{
switch (Diff) {
case details::differentiate_option::none: {
space_constant::valued_type valued_tag = space_constant::valued_tag_traits<Value>::value;
bool status = (_uh.valued_tag() == valued_tag) ||
(_uh.valued_tag() == space_constant::unsymmetric_tensor &&
valued_tag == space_constant::tensor);
check_macro (status,
"unexpected "<< _uh.valued()
<< "-valued field while a " << space_constant::valued_name(valued_tag)
<< "-valued one is expected in expression");
return status;
}
case details::differentiate_option::gradient: {
#ifdef TODO
base::_fops.template grad_valued_check<Value>();
#endif // TODO
return true;
}
case details::differentiate_option::divergence: {
#ifdef TODO
base::_fops.template div_valued_check<Value>();
#endif // TODO
return true;
}
case details::differentiate_option::curl: {
#ifdef TODO
base::_fops.template curl_valued_check<Value>();
#endif // TODO
return true;
}
}
}
template<class T, class M, details::differentiate_option::type Diff>
class field_expr_v2_nonlinear_terminal_field : public smart_pointer<field_expr_v2_nonlinear_terminal_field_rep<T,M,Diff> >
{
public:
// typedefs:
using rep = field_expr_v2_nonlinear_terminal_field_rep<T,M,Diff>;
using base = smart_pointer<rep>;
using size_type = typename rep::size_type;
using memory_type = typename rep::memory_type;
using result_type = typename rep::result_type;
using float_type = typename rep::float_type;
using scalar_type = typename rep::scalar_type;
using value_type = typename rep::value_type;
static const space_constant::valued_type valued_hint = rep::valued_hint;
// alocators:
template <class Expr,
class Sfinae = typename std::enable_if<details::has_field_rdof_interface<Expr>::value>::type>
explicit field_expr_v2_nonlinear_terminal_field (const Expr& expr, const differentiate_option& gopt = differentiate_option())
: base(new_macro(rep(expr,gopt))) {}
#ifdef TO_CLEAN
// --------------------------------------------
// field_lazy interface:
// --------------------------------------------
const geo_type& get_geo() const { return base::data().get_geo(); }
const band_type& get_band() const { return base::data().get_band(); }
const space_type& get_space() const { return base::data().get_space(); }
bool is_on_band () const { return base::data().is_on_band(); }
void initialize (const geo_type& omega_K) { base::data().initialize (omega_K); }
#endif // TO_CLEAN
// --------------------------------------------
// accessors for the affine & homogeneous case:
// --------------------------------------------
bool have_homogeneous_space (space_basic<scalar_type,memory_type>& Vh) const {
return base::data().have_homogeneous_space (Vh); }
// minimal forward iterator interface:
using const_iterator = typename rep::const_iterator;
const_iterator begin_dof() const { return base::data().begin_dof(); }
// --------------------------------------------
// accessors for the general nonlinear case:
// --------------------------------------------
space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }
const geo_basic<T,M>& get_geo() const { return base::data().get_geo(); }
const field_basic<T,M>& expr() const { return base::data()._uh; }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::data().initialize (pops, iopt); }
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::data().initialize (Xh, pops, iopt); }
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const
{ base::data().evaluate (omega_K, K, value); }
template<class Value>
void evaluate_on_side (
const geo_basic<float_type,memory_type>& omega_L,
const geo_element& L,
const side_information_type& sid,
Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const
{ base::data().evaluate_on_side (omega_L, L, sid, value); }
template<class Value>
bool valued_check() const {
return base::data().template valued_check<Value>();
}
};
// concepts:
template<class T, class M, details::differentiate_option::type Diff>
struct is_field_expr_v2_nonlinear_arg <field_expr_v2_nonlinear_terminal_field<T,M,Diff> > : std::true_type {};
//template<class T, class M, details::differentiate_option::type Diff>
//struct has_field_lazy_interface <field_expr_v2_nonlinear_terminal_field<T,M,Diff> > : std::true_type {};
// field terminal is affine-homogeneous whentere is no differentiation
// e.g. when diff=grad then P1 transforms to (P0)^d and then non-homogeneous space ?
// TODO: field yh_P0_d = grad(xh_P1); => space should be computed on the fly ?
template<class T, class M>
struct is_field_expr_affine_homogeneous <field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::none>>: std::true_type {};
// wrapper:
template <class Expr>
struct field_expr_v2_nonlinear_terminal_wrapper_traits <Expr,
typename std::enable_if<
has_field_rdof_interface<Expr>::value
>::type
>
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
typedef field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::none> type;
};
} // namespace details
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::gradient
>
>::type
grad (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::gradient> (expr);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::gradient
>
>::type
grad_s (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
static details::differentiate_option gopt;
gopt.surfacic = true;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::gradient> (expr, gopt);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::gradient
>
>::type
grad_h (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
static details::differentiate_option gopt;
gopt.broken = true;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::gradient> (expr, gopt);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::gradient
>
>::type
D (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
details::differentiate_option gopt;
gopt.symmetrized = true;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::gradient> (expr, gopt);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::gradient
>
>::type
Ds (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
details::differentiate_option gopt;
gopt.symmetrized = true;
gopt.surfacic = true;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::gradient> (expr, gopt);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::gradient
>
>::type
Dh (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
details::differentiate_option gopt;
gopt.symmetrized = true;
gopt.broken = true;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::gradient> (expr, gopt);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::divergence
>
>::type
div (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::divergence> (expr);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::divergence
>
>::type
div_s (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
static details::differentiate_option gopt;
gopt.surfacic = true;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::divergence> (expr, gopt);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::divergence
>
>::type
div_h (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
static details::differentiate_option gopt;
gopt.broken = true;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::divergence> (expr, gopt);
}
template<class Expr>
inline
typename
std::enable_if<
details::has_field_rdof_interface<Expr>::value
,details::field_expr_v2_nonlinear_terminal_field<
typename Expr::scalar_type
,typename Expr::memory_type
,details::differentiate_option::curl
>
>::type
curl (const Expr& expr)
{
typedef typename Expr::scalar_type T;
typedef typename Expr::memory_type M;
return details::field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::curl> (expr);
}
// TODO: bcurl(uh) = Batchelor curl ?
// TODO: curl_s(uh) curl_h(uh)...?
// ----------------------------------------------------------------------------
// 2.2) jump of a field
// ----------------------------------------------------------------------------
namespace details {
template<class T, class M>
class field_expr_v2_nonlinear_terminal_field_dg_rep {
public:
// typedefs:
typedef geo_element::size_type size_type;
typedef M memory_type;
typedef undeterminated_basic<T> result_type;
typedef result_type value_type;
typedef T scalar_type;
typedef typename float_traits<T>::type float_type;
// alocators:
template <class Expr,
class Sfinae = typename std::enable_if<details::has_field_rdof_interface<Expr>::value>::type>
explicit field_expr_v2_nonlinear_terminal_field_dg_rep(const Expr& expr, const float_type& c0, const float_type& c1)
: _expr0(expr), _expr1(expr),
_c0(c0), _c1(c1)
{}
// accessors:
static const space_constant::valued_type valued_hint = space_constant::last_valued;
space_constant::valued_type valued_tag() const { return _expr0.valued_tag(); }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const;
template<class Value>
bool valued_check() const {
space_constant::valued_type valued_tag = space_constant::valued_tag_traits<Value>::value;
bool status = _expr0.valued_tag() == valued_tag;
check_macro (status,
"unexpected "<< space_constant::valued_name(_expr0.valued_tag())
<< "-valued field while a " << space_constant::valued_name(valued_tag)
<< "-valued one is expected in expression");
return status;
}
// data:
protected:
field_expr_v2_nonlinear_terminal_field<T,M,details::differentiate_option::none> _expr0, _expr1;
float_type _c0, _c1;
};
template<class T, class M>
class field_expr_v2_nonlinear_terminal_field_dg : public smart_pointer<field_expr_v2_nonlinear_terminal_field_dg_rep<T,M> >
{
public:
// typedefs:
typedef field_expr_v2_nonlinear_terminal_field_dg_rep<T,M> rep;
typedef smart_pointer<rep> base;
typedef typename rep::size_type size_type;
typedef typename rep::memory_type memory_type;
typedef typename rep::result_type result_type;
typedef typename rep::float_type float_type;
typedef typename rep::scalar_type scalar_type;
typedef typename rep::value_type value_type;
static const space_constant::valued_type valued_hint = rep::valued_hint;
// alocators:
template <class Expr,
class Sfinae = typename std::enable_if<details::has_field_rdof_interface<Expr>::value>::type>
explicit field_expr_v2_nonlinear_terminal_field_dg(const Expr& expr, const float_type& c0, const float_type& c1)
: base(new_macro(rep(expr,c0,c1))) {}
// accessors:
space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::data().initialize (pops, iopt); }
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::data().initialize (Xh, pops, iopt); }
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const
{ base::data().evaluate (omega_K, K, value); }
template<class Value>
bool valued_check() const
{ return base::data().template valued_check<Value>(); }
};
template<class T, class M> struct is_field_expr_v2_nonlinear_arg <field_expr_v2_nonlinear_terminal_field_dg<T,M> > : std::true_type {};
//template<class T, class M> struct has_field_lazy_interface <field_expr_v2_nonlinear_terminal_field_dg<T,M> > : std::true_type {};
} // namespace details
#define _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg(op,c0,c1) \
template<class Expr> \
inline \
typename \
std::enable_if< \
details::has_field_rdof_interface<Expr>::value \
,details::field_expr_v2_nonlinear_terminal_field_dg< \
typename Expr::scalar_type \
,typename Expr::memory_type \
> \
>::type \
op (const Expr& expr) \
{ \
return details::field_expr_v2_nonlinear_terminal_field_dg \
<typename Expr::scalar_type ,typename Expr::memory_type> \
(expr, c0, c1); \
}
_RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg (jump, 1, -1)
_RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg (average, 0.5, 0.5)
_RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg (inner, 1, 0)
_RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg (outer, 0, 1)
#undef _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg
// ---------------------------------------------------------------------------
// 3) convected field, as compose(uh,X) where X is a characteristic
// ---------------------------------------------------------------------------
namespace details {
template<class T, class M>
class field_expr_v2_nonlinear_terminal_field_o_characteristic_rep {
public:
// typedefs:
typedef geo_element::size_type size_type;
typedef M memory_type;
typedef undeterminated_basic<T> result_type;
typedef result_type value_type;
typedef T scalar_type;
typedef typename float_traits<T>::type float_type;
// alocators:
field_expr_v2_nonlinear_terminal_field_o_characteristic_rep (const field_o_characteristic<T,M>& uoX);
field_expr_v2_nonlinear_terminal_field_o_characteristic_rep (const field_basic<T,M>& uh, const characteristic_basic<T,M>& X);
// accessors:
static const space_constant::valued_type valued_hint = space_constant::last_valued;
space_constant::valued_type valued_tag() const { return _uh.valued_tag(); }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt);
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const;
template<class Value>
bool valued_check() const {
space_constant::valued_type valued_tag = space_constant::valued_tag_traits<Value>::value;
bool status = (_uh.valued_tag() == valued_tag);
check_macro (status,
"unexpected "<<_uh.valued()
<< "-valued field while a " << space_constant::valued_name(valued_tag)
<< "-valued one is expected in expression");
return status;
}
// internal:
template<class Result>
void _check () const;
// data:
field_basic<T,M> _uh;
characteristic_basic<T,M> _X;
mutable fem_on_pointset<T> _fops;
mutable disarray<T,M> _scalar_val;
mutable disarray<point_basic<T>,M> _vector_val;
mutable disarray<tensor_basic<T>,M> _tensor_val;
mutable disarray<tensor3_basic<T>,M> _tensor3_val;
mutable disarray<tensor4_basic<T>,M> _tensor4_val;
mutable size_type _start_q;
};
template<class T, class M>
field_expr_v2_nonlinear_terminal_field_o_characteristic_rep<T,M>::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep (
const field_basic<T,M>& uh,
const characteristic_basic<T,M>& X)
: _uh (uh),
_X (X),
_fops(),
_scalar_val(),
_vector_val(),
_tensor_val(),
_tensor3_val(),
_tensor4_val(),
_start_q(0)
{
}
template<class T, class M>
field_expr_v2_nonlinear_terminal_field_o_characteristic_rep<T,M>::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep (
const field_o_characteristic<T,M>& uoX)
: _uh (uoX.get_field()),
_X (uoX.get_characteristic()),
_fops(),
_scalar_val(),
_vector_val(),
_tensor_val(),
_tensor3_val(),
_tensor4_val(),
_start_q(0)
{
}
template<class T, class M>
class field_expr_v2_nonlinear_terminal_field_o_characteristic :
public smart_pointer<field_expr_v2_nonlinear_terminal_field_o_characteristic_rep<T,M> >
{
public:
// typedefs:
typedef field_expr_v2_nonlinear_terminal_field_o_characteristic_rep<T,M> rep;
typedef smart_pointer<rep> base;
typedef typename rep::size_type size_type;
typedef typename rep::memory_type memory_type;
typedef typename rep::result_type result_type;
typedef typename rep::float_type float_type;
typedef typename rep::scalar_type scalar_type;
typedef typename rep::value_type value_type;
static const space_constant::valued_type valued_hint = rep::valued_hint;
// alocators:
field_expr_v2_nonlinear_terminal_field_o_characteristic (const field_o_characteristic<T,M>& uoX)
: base(new_macro(rep(uoX))) {}
field_expr_v2_nonlinear_terminal_field_o_characteristic (const field_basic<T,M>& uh, const characteristic_basic<T,M>& X)
: base(new_macro(rep(uh,X))) {}
// accessors:
space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }
void initialize (
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::data().initialize (pops, iopt); }
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt)
{ base::data().initialize (Xh, pops, iopt); }
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const
{ base::data().evaluate (omega_K, K, value); }
template<class Value>
bool valued_check() const {
return base::data().template valued_check<Value>();
}
};
template<class T, class M> struct is_field_expr_v2_nonlinear_arg <field_expr_v2_nonlinear_terminal_field_o_characteristic<T,M> > : std::true_type {};
//template<class T, class M> struct has_field_lazy_interface <field_expr_v2_nonlinear_terminal_field_o_characteristic<T,M> > : std::true_type {};
} // namespace details
// compose a field with a characteristic
template<class T, class M>
inline
details::field_expr_v2_nonlinear_terminal_field_o_characteristic<T,M>
compose (const field_basic<T,M>& uh, const characteristic_basic<T,M>& X)
{
return details::field_expr_v2_nonlinear_terminal_field_o_characteristic<T,M> (uh,X);
}
} // namespace rheolef
#endif // _RHEOLEF_FIELD_EXPR_TERMINAL_H
rheolef::basis_on_pointset
Definition basis_on_pointset.h:192
rheolef::characteristic_basic
Definition characteristic.h:194
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep
Definition field_expr_terminal.h:1123
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::field_expr_v2_nonlinear_terminal_field_dg_rep
field_expr_v2_nonlinear_terminal_field_dg_rep(const Expr &expr, const float_type &c0, const float_type &c1)
Definition field_expr_terminal.h:1138
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::valued_check
bool valued_check() const
Definition field_expr_terminal.h:1165
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.cc:500
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::_c1
float_type _c1
Definition field_expr_terminal.h:1177
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::scalar_type
T scalar_type
Definition field_expr_terminal.h:1131
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::memory_type
M memory_type
Definition field_expr_terminal.h:1128
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::_expr1
field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none > _expr1
Definition field_expr_terminal.h:1176
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:1145
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::_c0
float_type _c0
Definition field_expr_terminal.h:1177
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::value_type
result_type value_type
Definition field_expr_terminal.h:1130
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::float_type
float_traits< T >::type float_type
Definition field_expr_terminal.h:1132
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::result_type
undeterminated_basic< T > result_type
Definition field_expr_terminal.h:1129
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::size_type
geo_element::size_type size_type
Definition field_expr_terminal.h:1127
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::_expr0
field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none > _expr0
Definition field_expr_terminal.h:1176
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:1147
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg
Definition field_expr_terminal.h:1182
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::valued_check
bool valued_check() const
Definition field_expr_terminal.h:1226
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:1207
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::result_type
rep::result_type result_type
Definition field_expr_terminal.h:1190
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::value_type
rep::value_type value_type
Definition field_expr_terminal.h:1193
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::field_expr_v2_nonlinear_terminal_field_dg
field_expr_v2_nonlinear_terminal_field_dg(const Expr &expr, const float_type &c0, const float_type &c1)
Definition field_expr_terminal.h:1200
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.h:1219
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:1194
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::float_type
rep::float_type float_type
Definition field_expr_terminal.h:1191
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::base
smart_pointer< rep > base
Definition field_expr_terminal.h:1187
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::memory_type
rep::memory_type memory_type
Definition field_expr_terminal.h:1189
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::size_type
rep::size_type size_type
Definition field_expr_terminal.h:1188
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::rep
field_expr_v2_nonlinear_terminal_field_dg_rep< T, M > rep
Definition field_expr_terminal.h:1186
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::initialize
void initialize(const space_basic< float_type, memory_type > &Xh, const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:1212
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:1205
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::scalar_type
rep::scalar_type scalar_type
Definition field_expr_terminal.h:1192
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep
Definition field_expr_terminal.h:1265
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_uh
field_basic< T, M > _uh
Definition field_expr_terminal.h:1318
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_vector_val
disarray< point_basic< T >, M > _vector_val
Definition field_expr_terminal.h:1322
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_X
characteristic_basic< T, M > _X
Definition field_expr_terminal.h:1319
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::valued_check
bool valued_check() const
Definition field_expr_terminal.h:1303
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.cc:570
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_check
void _check() const
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_fops
fem_on_pointset< T > _fops
Definition field_expr_terminal.h:1320
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_start_q
size_type _start_q
Definition field_expr_terminal.h:1326
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::scalar_type
T scalar_type
Definition field_expr_terminal.h:1273
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.cc:607
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_tensor_val
disarray< tensor_basic< T >, M > _tensor_val
Definition field_expr_terminal.h:1323
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::memory_type
M memory_type
Definition field_expr_terminal.h:1270
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:1283
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_tensor3_val
disarray< tensor3_basic< T >, M > _tensor3_val
Definition field_expr_terminal.h:1324
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep
field_expr_v2_nonlinear_terminal_field_o_characteristic_rep(const field_o_characteristic< T, M > &uoX)
Definition field_expr_terminal.h:1344
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_scalar_val
disarray< T, M > _scalar_val
Definition field_expr_terminal.h:1321
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::value_type
result_type value_type
Definition field_expr_terminal.h:1272
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::float_type
float_traits< T >::type float_type
Definition field_expr_terminal.h:1274
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::result_type
undeterminated_basic< T > result_type
Definition field_expr_terminal.h:1271
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::size_type
geo_element::size_type size_type
Definition field_expr_terminal.h:1269
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:1285
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_tensor4_val
disarray< tensor4_basic< T >, M > _tensor4_val
Definition field_expr_terminal.h:1325
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic
Definition field_expr_terminal.h:1361
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::valued_check
bool valued_check() const
Definition field_expr_terminal.h:1406
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:1387
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::result_type
rep::result_type result_type
Definition field_expr_terminal.h:1369
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::value_type
rep::value_type value_type
Definition field_expr_terminal.h:1372
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::field_expr_v2_nonlinear_terminal_field_o_characteristic
field_expr_v2_nonlinear_terminal_field_o_characteristic(const field_o_characteristic< T, M > &uoX)
Definition field_expr_terminal.h:1377
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.h:1399
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:1373
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::rep
field_expr_v2_nonlinear_terminal_field_o_characteristic_rep< T, M > rep
Definition field_expr_terminal.h:1365
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::float_type
rep::float_type float_type
Definition field_expr_terminal.h:1370
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::base
smart_pointer< rep > base
Definition field_expr_terminal.h:1366
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::memory_type
rep::memory_type memory_type
Definition field_expr_terminal.h:1368
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::size_type
rep::size_type size_type
Definition field_expr_terminal.h:1367
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::initialize
void initialize(const space_basic< float_type, memory_type > &Xh, const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:1392
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::field_expr_v2_nonlinear_terminal_field_o_characteristic
field_expr_v2_nonlinear_terminal_field_o_characteristic(const field_basic< T, M > &uh, const characteristic_basic< T, M > &X)
Definition field_expr_terminal.h:1380
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:1385
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::scalar_type
rep::scalar_type scalar_type
Definition field_expr_terminal.h:1371
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep
Definition field_expr_terminal.h:632
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_tilde_L
reference_element _tilde_L
Definition field_expr_terminal.h:719
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_vector_val
std::array< Eigen::Matrix< point_basic< T >, Eigen::Dynamic, 1 >,reference_element::max_variant > _vector_val
Definition field_expr_terminal.h:730
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_uh
field_basic< T, M > _uh
Definition field_expr_terminal.h:714
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::size_type
geo_element::size_type size_type
Definition field_expr_terminal.h:636
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::get_side
const geo_element & get_side(const geo_element &K, const side_information_type &sid) const
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_need_vector_piola
bool _need_vector_piola
Definition field_expr_terminal.h:723
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::valued_check
bool valued_check() const
Definition field_expr_terminal.h:771
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::result_type
typename std::conditional< Diff==details::differentiate_option::divergence,T,undeterminated_basic< T > >::type result_type
Definition field_expr_terminal.h:640
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_tensor_val
std::array< Eigen::Matrix< tensor_basic< T >, Eigen::Dynamic, 1 >,reference_element::max_variant > _tensor_val
Definition field_expr_terminal.h:733
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::initialize
void initialize(const piola_on_pointset< T > &pops, const integrate_option &iopt)
Definition field_expr_terminal.cc:402
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_use_bgd2dom
bool _use_bgd2dom
Definition field_expr_terminal.h:717
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_gopt
differentiate_option _gopt
Definition field_expr_terminal.h:713
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::field_expr_v2_nonlinear_terminal_field_rep
field_expr_v2_nonlinear_terminal_field_rep(const Expr &expr, const differentiate_option &gopt)
Definition field_expr_terminal.h:745
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.cc:424
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_scalar_val
std::array< Eigen::Matrix< T, Eigen::Dynamic, 1 >,reference_element::max_variant > _scalar_val
Definition field_expr_terminal.h:727
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::begin_dof
const_iterator begin_dof() const
Definition field_expr_terminal.h:675
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_have_dg_on_sides
bool _have_dg_on_sides
Definition field_expr_terminal.h:718
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:681
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_dis_inod_geo
std::vector< size_type > _dis_inod_geo
Definition field_expr_terminal.h:722
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_piola_on_geo_basis
basis_on_pointset< T > _piola_on_geo_basis
Definition field_expr_terminal.h:721
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::value_type
result_type value_type
Definition field_expr_terminal.h:645
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::have_homogeneous_space
bool have_homogeneous_space(space_basic< scalar_type, memory_type > &Vh) const
Definition field_expr_terminal.h:669
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_tensor3_val
std::array< Eigen::Matrix< tensor3_basic< T >, Eigen::Dynamic, 1 >,reference_element::max_variant > _tensor3_val
Definition field_expr_terminal.h:736
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::const_iterator
typename field_basic< T, M >::const_iterator const_iterator
Definition field_expr_terminal.h:674
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_use_dom2bgd
bool _use_dom2bgd
Definition field_expr_terminal.h:716
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::memory_type
M memory_type
Definition field_expr_terminal.h:637
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_tensor4_val
std::array< Eigen::Matrix< tensor4_basic< T >, Eigen::Dynamic, 1 >,reference_element::max_variant > _tensor4_val
Definition field_expr_terminal.h:739
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::evaluate_on_side
void evaluate_on_side(const geo_basic< float_type, memory_type > &omega_L, const geo_element &L, const side_information_type &sid, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.cc:436
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_u_test
test_basic< T, M, details::vf_tag_01 > _u_test
Definition field_expr_terminal.h:715
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::float_type
typename float_traits< T >::type float_type
Definition field_expr_terminal.h:639
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::scalar_type
T scalar_type
Definition field_expr_terminal.h:638
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.cc:449
rheolef::details::field_expr_v2_nonlinear_terminal_field
Definition field_expr_terminal.h:807
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::expr
const field_basic< T, M > & expr() const
Definition field_expr_terminal.h:857
rheolef::details::field_expr_v2_nonlinear_terminal_field::valued_check
bool valued_check() const
Definition field_expr_terminal.h:886
rheolef::details::field_expr_v2_nonlinear_terminal_field::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:859
rheolef::details::field_expr_v2_nonlinear_terminal_field::memory_type
typename rep::memory_type memory_type
Definition field_expr_terminal.h:814
rheolef::details::field_expr_v2_nonlinear_terminal_field::size_type
typename rep::size_type size_type
Definition field_expr_terminal.h:813
rheolef::details::field_expr_v2_nonlinear_terminal_field::rep
field_expr_v2_nonlinear_terminal_field_rep< T, M, Diff > rep
Definition field_expr_terminal.h:811
rheolef::details::field_expr_v2_nonlinear_terminal_field::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.h:871
rheolef::details::field_expr_v2_nonlinear_terminal_field::result_type
typename rep::result_type result_type
Definition field_expr_terminal.h:815
rheolef::details::field_expr_v2_nonlinear_terminal_field::value_type
typename rep::value_type value_type
Definition field_expr_terminal.h:818
rheolef::details::field_expr_v2_nonlinear_terminal_field::begin_dof
const_iterator begin_dof() const
Definition field_expr_terminal.h:849
rheolef::details::field_expr_v2_nonlinear_terminal_field::const_iterator
typename rep::const_iterator const_iterator
Definition field_expr_terminal.h:848
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:820
rheolef::details::field_expr_v2_nonlinear_terminal_field::float_type
typename rep::float_type float_type
Definition field_expr_terminal.h:816
rheolef::details::field_expr_v2_nonlinear_terminal_field::base
smart_pointer< rep > base
Definition field_expr_terminal.h:812
rheolef::details::field_expr_v2_nonlinear_terminal_field::have_homogeneous_space
bool have_homogeneous_space(space_basic< scalar_type, memory_type > &Vh) const
Definition field_expr_terminal.h:845
rheolef::details::field_expr_v2_nonlinear_terminal_field::field_expr_v2_nonlinear_terminal_field
field_expr_v2_nonlinear_terminal_field(const Expr &expr, const differentiate_option &gopt=differentiate_option())
Definition field_expr_terminal.h:826
rheolef::details::field_expr_v2_nonlinear_terminal_field::evaluate_on_side
void evaluate_on_side(const geo_basic< float_type, memory_type > &omega_L, const geo_element &L, const side_information_type &sid, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.h:878
rheolef::details::field_expr_v2_nonlinear_terminal_field::initialize
void initialize(const space_basic< float_type, memory_type > &Xh, const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:864
rheolef::details::field_expr_v2_nonlinear_terminal_field::scalar_type
typename rep::scalar_type scalar_type
Definition field_expr_terminal.h:817
rheolef::details::field_expr_v2_nonlinear_terminal_field::get_geo
const geo_basic< T, M > & get_geo() const
Definition field_expr_terminal.h:856
rheolef::details::field_expr_v2_nonlinear_terminal_field::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:855
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.cc:57
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::scalar_type
T scalar_type
Definition field_expr_terminal.h:107
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::get_side
const geo_element & get_side(const geo_basic< float_type, M > &omega_K, const geo_element &K, const side_information_type &sid) const
Definition field_expr_terminal.cc:103
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::field_expr_v2_nonlinear_terminal_function_base_rep
field_expr_v2_nonlinear_terminal_function_base_rep()
Definition field_expr_terminal.cc:46
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep< float_type >::_pops
piola_on_pointset< float_type > _pops
Definition field_expr_terminal.h:135
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::field_expr_v2_nonlinear_terminal_function_base_rep
field_expr_v2_nonlinear_terminal_function_base_rep(const field_expr_v2_nonlinear_terminal_function_base_rep< T > &)
Definition field_expr_terminal.cc:51
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::memory_type
rheo_default_memory_model memory_type
Definition field_expr_terminal.h:106
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::initialize
void initialize(const space_basic< float_type, memory_type > &Xh, const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.cc:65
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::float_type
T float_type
Definition field_expr_terminal.h:108
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::size_type
geo_element::size_type size_type
Definition field_expr_terminal.h:105
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::field_expr_v2_nonlinear_terminal_function_rep
field_expr_v2_nonlinear_terminal_function_rep(const function_type &)
Definition field_expr_terminal.cc:196
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::argument_type
point_basic< T > argument_type
Definition field_expr_terminal.h:461
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::valued_check
bool valued_check() const
Definition field_expr_terminal.h:498
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::base
field_expr_v2_nonlinear_terminal_function_base_rep< T > base
Definition field_expr_terminal.h:456
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::scalar_type
T scalar_type
Definition field_expr_terminal.h:462
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:473
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::function_type
h_local_pseudo_function< T > function_type
Definition field_expr_terminal.h:459
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::result_type
T result_type
Definition field_expr_terminal.h:460
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::memory_type
rheo_default_memory_model memory_type
Definition field_expr_terminal.h:458
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::value_type
result_type value_type
Definition field_expr_terminal.h:464
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::float_type
T float_type
Definition field_expr_terminal.h:463
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::size_type
geo_element::size_type size_type
Definition field_expr_terminal.h:457
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:475
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::field_expr_v2_nonlinear_terminal_function_rep
field_expr_v2_nonlinear_terminal_function_rep(const function_type &)
Definition field_expr_terminal.cc:114
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::argument_type
point_basic< T > argument_type
Definition field_expr_terminal.h:365
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::valued_check
bool valued_check() const
Definition field_expr_terminal.h:408
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::base
field_expr_v2_nonlinear_terminal_function_base_rep< T > base
Definition field_expr_terminal.h:360
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::scalar_type
T scalar_type
Definition field_expr_terminal.h:366
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::_is_on_interface
bool _is_on_interface
Definition field_expr_terminal.h:414
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::_is_inside_on_local_sides
bool _is_inside_on_local_sides
Definition field_expr_terminal.h:414
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::function_type
normal_pseudo_function< T > function_type
Definition field_expr_terminal.h:363
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:377
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::result_type
point_basic< T > result_type
Definition field_expr_terminal.h:364
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::memory_type
rheo_default_memory_model memory_type
Definition field_expr_terminal.h:362
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::value_type
result_type value_type
Definition field_expr_terminal.h:368
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::float_type
T float_type
Definition field_expr_terminal.h:367
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::size_type
geo_element::size_type size_type
Definition field_expr_terminal.h:361
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:379
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::field_expr_v2_nonlinear_terminal_function_rep
field_expr_v2_nonlinear_terminal_function_rep(const function_type &)
Definition field_expr_terminal.cc:289
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::argument_type
point_basic< T > argument_type
Definition field_expr_terminal.h:549
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::valued_check
bool valued_check() const
Definition field_expr_terminal.h:586
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::base
field_expr_v2_nonlinear_terminal_function_base_rep< T > base
Definition field_expr_terminal.h:544
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::scalar_type
T scalar_type
Definition field_expr_terminal.h:550
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:561
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::result_type
T result_type
Definition field_expr_terminal.h:548
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::memory_type
rheo_default_memory_model memory_type
Definition field_expr_terminal.h:546
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::value_type
result_type value_type
Definition field_expr_terminal.h:552
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::float_type
T float_type
Definition field_expr_terminal.h:551
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::function_type
penalty_pseudo_function< T > function_type
Definition field_expr_terminal.h:547
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::size_type
geo_element::size_type size_type
Definition field_expr_terminal.h:545
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:563
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep
Definition field_expr_terminal.h:144
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::base
field_expr_v2_nonlinear_terminal_function_base_rep< float_type > base
Definition field_expr_terminal.h:156
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::_f
function_type _f
Definition field_expr_terminal.h:210
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::_tensor_val
std::array< Eigen::Matrix< tensor_basic< scalar_type >, Eigen::Dynamic, 1 >,reference_element::max_variant > _tensor_val
Definition field_expr_terminal.h:221
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::function_type
details::function_traits< Function >::copiable_type function_type
Definition field_expr_terminal.h:150
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::argument_type
details::function_traits< Function >::template arg< 0 >::type argument_type
Definition field_expr_terminal.h:152
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::valued_check
bool valued_check() const
Definition field_expr_terminal.h:203
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::result_type
details::function_traits< Function >::result_type result_type
Definition field_expr_terminal.h:151
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::_tensor3_val
std::array< Eigen::Matrix< tensor3_basic< scalar_type >, Eigen::Dynamic, 1 >,reference_element::max_variant > _tensor3_val
Definition field_expr_terminal.h:224
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:169
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::_tensor4_val
std::array< Eigen::Matrix< tensor4_basic< scalar_type >, Eigen::Dynamic, 1 >,reference_element::max_variant > _tensor4_val
Definition field_expr_terminal.h:227
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::_scalar_val
std::array< Eigen::Matrix< scalar_type, Eigen::Dynamic, 1 >,reference_element::max_variant > _scalar_val
Definition field_expr_terminal.h:215
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:164
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::_vector_val
std::array< Eigen::Matrix< point_basic< scalar_type >, Eigen::Dynamic, 1 >,reference_element::max_variant > _vector_val
Definition field_expr_terminal.h:218
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< result_type, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.h:180
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::scalar_type
scalar_traits< result_type >::type scalar_type
Definition field_expr_terminal.h:153
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::memory_type
rheo_default_memory_model memory_type
Definition field_expr_terminal.h:149
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::initialize
void initialize(const space_basic< float_type, memory_type > &Xh, const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:174
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::value_type
result_type value_type
Definition field_expr_terminal.h:155
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::field_expr_v2_nonlinear_terminal_function_rep
field_expr_v2_nonlinear_terminal_function_rep(const Function &f)
Definition field_expr_terminal.h:231
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::evaluate_on_side
void evaluate_on_side(const geo_basic< float_type, memory_type > &omega_L, const geo_element &L, const side_information_type &sid, Eigen::Matrix< result_type, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.h:194
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::size_type
geo_element::size_type size_type
Definition field_expr_terminal.h:148
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::float_type
float_traits< result_type >::type float_type
Definition field_expr_terminal.h:154
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:166
rheolef::details::field_expr_v2_nonlinear_terminal_function
Definition field_expr_terminal.h:244
rheolef::details::field_expr_v2_nonlinear_terminal_function::field_expr_v2_nonlinear_terminal_function
field_expr_v2_nonlinear_terminal_function(TrueFunction f)
Definition field_expr_terminal.h:266
rheolef::details::field_expr_v2_nonlinear_terminal_function::field_expr_v2_nonlinear_terminal_function
field_expr_v2_nonlinear_terminal_function(const Function &f)
Definition field_expr_terminal.h:261
rheolef::details::field_expr_v2_nonlinear_terminal_function::valued_check
bool valued_check() const
Definition field_expr_terminal.h:303
rheolef::details::field_expr_v2_nonlinear_terminal_function::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:278
rheolef::details::field_expr_v2_nonlinear_terminal_function::result_type
rep::result_type result_type
Definition field_expr_terminal.h:252
rheolef::details::field_expr_v2_nonlinear_terminal_function::value_type
rep::value_type value_type
Definition field_expr_terminal.h:254
rheolef::details::field_expr_v2_nonlinear_terminal_function< Expr >::valued_hint
static const space_constant::valued_type valued_hint
Definition field_expr_terminal.h:257
rheolef::details::field_expr_v2_nonlinear_terminal_function::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< result_type, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.h:289
rheolef::details::field_expr_v2_nonlinear_terminal_function::field_expr_v2_nonlinear_terminal_function
field_expr_v2_nonlinear_terminal_function(const Constant &c)
Definition field_expr_terminal.h:271
rheolef::details::field_expr_v2_nonlinear_terminal_function::float_type
rep::float_type float_type
Definition field_expr_terminal.h:256
rheolef::details::field_expr_v2_nonlinear_terminal_function::base
smart_pointer< rep > base
Definition field_expr_terminal.h:249
rheolef::details::field_expr_v2_nonlinear_terminal_function::rep
field_expr_v2_nonlinear_terminal_function_rep< Function > rep
Definition field_expr_terminal.h:248
rheolef::details::field_expr_v2_nonlinear_terminal_function::memory_type
rep::memory_type memory_type
Definition field_expr_terminal.h:251
rheolef::details::field_expr_v2_nonlinear_terminal_function::size_type
rep::size_type size_type
Definition field_expr_terminal.h:250
rheolef::details::field_expr_v2_nonlinear_terminal_function::argument_type
rep::argument_type argument_type
Definition field_expr_terminal.h:253
rheolef::details::field_expr_v2_nonlinear_terminal_function::initialize
void initialize(const space_basic< float_type, memory_type > &Xh, const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
Definition field_expr_terminal.h:283
rheolef::details::field_expr_v2_nonlinear_terminal_function::evaluate_on_side
void evaluate_on_side(const geo_basic< float_type, memory_type > &omega_L, const geo_element &L, const side_information_type &sid, Eigen::Matrix< result_type, Eigen::Dynamic, 1 > &value) const
Definition field_expr_terminal.h:295
rheolef::details::field_expr_v2_nonlinear_terminal_function::valued_tag
space_constant::valued_type valued_tag() const
Definition field_expr_terminal.h:276
rheolef::details::field_expr_v2_nonlinear_terminal_function::scalar_type
rep::scalar_type scalar_type
Definition field_expr_terminal.h:255
rheolef::disarray
see the disarray page for the full documentation
Definition disarray.h:497
rheolef::fem_on_pointset
Definition fem_on_pointset.h:117
rheolef::field_basic::const_iterator
Definition field.h:612
rheolef::field_basic
Definition field.h:219
rheolef::field_basic::get_space
const space_type & get_space() const
Definition field.h:270
rheolef::field_o_characteristic
Definition characteristic.h:248
rheolef::geo_basic
generic mesh with rerefence counting
Definition geo.h:1089
rheolef::geo_element
see the geo_element page for the full documentation
Definition geo_element.h:102
rheolef::geo_element::size_type
reference_element::size_type size_type
Definition geo_element.h:125
rheolef::geo_element::variant
variant_type variant() const
Definition geo_element.h:161
rheolef::integrate_option
see the integrate_option page for the full documentation
Definition integrate_option.h:125
rheolef::piola_on_pointset
Definition piola_on_pointset.h:142
rheolef::point_basic
Definition point.h:86
rheolef::reference_element
see the reference_element page for the full documentation
Definition reference_element.h:66
rheolef::reference_element::max_variant
static const variant_type max_variant
Definition reference_element.h:82
rheolef::smart_pointer_base::data
const T & data() const
Definition smart_pointer.h:266
rheolef::smart_pointer< field_expr_v2_nonlinear_terminal_function_rep< Function > >::smart_pointer
smart_pointer(field_expr_v2_nonlinear_terminal_function_rep< Function > *p=0)
Definition smart_pointer.h:357
rheolef::space_basic
the finite element space
Definition space.h:382
rheolef::test_basic
Definition test.h:207
rheolef::type
rheolef::std::enable_if< details::is_field_expr_v2_nonlinear_arg< Expr1 >::value &&! details::is_field_expr_v2_constant< Expr1 >::value &&details::is_field_expr_v2_nonlinear_arg< Expr2 >::value &&! details::is_field_expr_v2_constant< Expr2 >::value, details::field_expr_v2_nonlinear_node_binary< details::function_traits< Function >::functor_type, details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr1 >::type, details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr2 >::type > > type
rheo_default_memory_model
#define rheo_default_memory_model
Definition communicator.h:153
fatal_macro
#define fatal_macro(message)
Definition dis_macros.h:33
get_geo
void get_geo(istream &in, my_geo &omega)
Definition field2gmsh_pos.cc:126
T
Expr1::float_type T
Definition field_expr.h:230
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
_RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg
#define _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg(op, c0, c1)
Definition field_expr_terminal.h:1234
rheolef::details
Definition compiler_eigen.h:39
rheolef::details::global_get_side
const geo_element & global_get_side(const geo_basic< T, M > &omega_L, const geo_element &L, const side_information_type &sid)
Definition field_expr_terminal.cc:75
rheolef::space_constant::valued_type
valued_type
Definition space_constant.h:133
rheolef::space_constant::tensor
@ tensor
Definition space_constant.h:136
rheolef::space_constant::scalar
@ scalar
Definition space_constant.h:134
rheolef::space_constant::unsymmetric_tensor
@ unsymmetric_tensor
Definition space_constant.h:137
rheolef::space_constant::vector
@ vector
Definition space_constant.h:135
rheolef::space_constant::last_valued
@ last_valued
Definition space_constant.h:141
rheolef::space_constant::valued_name
const std::string & valued_name(valued_type valued_tag)
Definition space_constant.cc:43
rheolef
This file is part of Rheolef.
Definition compiler_eigen.h:39
rheolef::h_local_basic
details::field_expr_v2_nonlinear_terminal_function< details::h_local_pseudo_function< T > > h_local_basic()
Definition field_expr_terminal.h:511
rheolef::compose
std::enable_if< sizeof...(Exprs)>=3, details::field_expr_v2_nonlinear_node_nary< typenamedetails::function_traits< Function >::functor_type, typenamedetails::field_expr_v2_nonlinear_terminal_wrapper_traits< Exprs >::type... > >::type compose(const Function &f, const Exprs &... exprs)
see the compose page for the full documentation
Definition compose.h:247
rheolef::grad_s
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::gradient > >::type grad_s(const Expr &expr)
grad_s(uh): see the expression page for the full documentation
Definition field_expr_terminal.h:948
rheolef::grad
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::gradient > >::type grad(const Expr &expr)
grad(uh): see the expression page for the full documentation
Definition field_expr_terminal.h:930
rheolef::D
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::gradient > >::type D(const Expr &expr)
D(uh): see the expression page for the full documentation.
Definition field_expr_terminal.h:988
rheolef::normal_basic
details::field_expr_v2_nonlinear_terminal_function< details::normal_pseudo_function< T > > normal_basic()
Definition field_expr_terminal.h:423
rheolef::div
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::divergence > >::type div(const Expr &expr)
div(uh): see the expression page for the full documentation
Definition field_expr_terminal.h:1050
rheolef::div_h
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::divergence > >::type div_h(const Expr &expr)
div_h(uh): see the expression page for the full documentation
Definition field_expr_terminal.h:1088
rheolef::curl
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::curl > >::type curl(const Expr &expr)
curl(uh): see the expression page for the full documentation
Definition field_expr_terminal.h:1108
rheolef::_RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg
_RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg(jump, 1, -1) _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg(average
rheolef::penalty_basic
details::field_expr_v2_nonlinear_terminal_function< details::penalty_pseudo_function< T > > penalty_basic()
Definition field_expr_terminal.h:610
rheolef::grad_h
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::gradient > >::type grad_h(const Expr &expr)
grad_h(uh): see the expression page for the full documentation
Definition field_expr_terminal.h:968
rheolef::normal
details::field_expr_v2_nonlinear_terminal_function< details::normal_pseudo_function< Float > > normal()
normal: see the expression page for the full documentation
Definition field_expr_terminal.h:432
rheolef::Dh
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::gradient > >::type Dh(const Expr &expr)
Dh(uh): see the expression page for the full documentation.
Definition field_expr_terminal.h:1029
rheolef::h_local
details::field_expr_v2_nonlinear_terminal_function< details::h_local_pseudo_function< Float > > h_local()
h_local: see the expression page for the full documentation
Definition field_expr_terminal.h:520
rheolef::penalty
details::field_expr_v2_nonlinear_terminal_function< details::penalty_pseudo_function< Float > > penalty()
penalty(): see the expression page for the full documentation
Definition field_expr_terminal.h:619
rheolef::div_s
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::divergence > >::type div_s(const Expr &expr)
div_s(uh): see the expression page for the full documentation
Definition field_expr_terminal.h:1068
rheolef::Ds
std::enable_if< details::has_field_rdof_interface< Expr >::value, details::field_expr_v2_nonlinear_terminal_field< typenameExpr::scalar_type, typenameExpr::memory_type, details::differentiate_option::gradient > >::type Ds(const Expr &expr)
Ds(uh): see the expression page for the full documentation.
Definition field_expr_terminal.h:1008
std
STL namespace.
f
Definition cavity_dg.h:29
rheolef::details::differentiate_option
Definition piola.h:41
rheolef::details::differentiate_option::divergence
@ divergence
Definition piola.h:45
rheolef::details::differentiate_option::gradient
@ gradient
Definition piola.h:44
rheolef::details::differentiate_option::none
@ none
Definition piola.h:43
rheolef::details::differentiate_option::curl
@ curl
Definition piola.h:46
rheolef::details::f_constant
Definition space_constant.h:295
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< has_field_rdof_interface< Expr >::value >::type >::T
Expr::scalar_type T
Definition field_expr_terminal.h:911
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< has_field_rdof_interface< Expr >::value >::type >::type
field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none > type
Definition field_expr_terminal.h:913
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< has_field_rdof_interface< Expr >::value >::type >::M
Expr::memory_type M
Definition field_expr_terminal.h:912
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< is_field_expr_v2_constant< Expr >::value >::type >::float_type
promote< Expr, Float >::type float_type
Definition field_expr_terminal.h:339
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< is_field_expr_v2_constant< Expr >::value >::type >::type
field_expr_v2_nonlinear_terminal_function< fun_t > type
Definition field_expr_terminal.h:341
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< is_field_expr_v2_constant< Expr >::value >::type >::fun_t
f_constant< point_basic< float_type >, Expr > fun_t
Definition field_expr_terminal.h:340
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< std::conjunction< std::negation< has_field_rdof_interface< Expr > >, is_field_function< Expr > >::value >::type >::type
field_expr_v2_nonlinear_terminal_function< Expr > type
Definition field_expr_terminal.h:329
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits
Definition field_expr_terminal.h:82
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits::type
Expr type
Definition field_expr_terminal.h:84
rheolef::details::function_traits
Definition field_expr_utilities.h:184
rheolef::details::h_local_pseudo_function
Definition field_expr_terminal.h:443
rheolef::details::h_local_pseudo_function::operator()
T operator()(const point_basic< T > &) const
Definition field_expr_terminal.h:444
rheolef::details::has_field_rdof_interface
Definition field_concept.h:58
rheolef::details::type
rheolef::details::is_equal
Definition space_constant.h:36
rheolef::details::is_field_expr_affine_homogeneous
Definition field_concept.h:100
rheolef::details::is_field_expr_v2_nonlinear_arg
Definition field_concept.h:88
rheolef::details::normal_pseudo_function
Definition field_expr_terminal.h:348
rheolef::details::normal_pseudo_function::operator()
point_basic< T > operator()(const point_basic< T > &) const
Definition field_expr_terminal.h:349
rheolef::details::penalty_pseudo_function
Definition field_expr_terminal.h:531
rheolef::details::penalty_pseudo_function::operator()
T operator()(const point_basic< T > &) const
Definition field_expr_terminal.h:532
rheolef::float_traits::type
T type
Definition Float.h:94
rheolef::piola
Definition piola.h:67
rheolef::piola::F
point_basic< T > F
Definition piola.h:79
rheolef::promote::type
promote_not_specialized_for_this_case< T1, T2 > type
Definition promote.h:30
rheolef::scalar_traits::type
T type
Definition point.h:323
rheolef::side_information_type
Definition reference_element_face_transformation.h:37
rheolef::space_constant::valued_tag_traits::value
static const valued_type value
Definition space_constant.h:159
rheolef::undeterminated_basic
helper for generic field value_type: T, point_basic<T> or tensor_basic<T>
Definition undeterminated.h:32
M
Expr1::memory_type M
Definition vec_expr_v2.h:416