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_component.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 {
// -------------------------------------------------------------------
// 0.1) concepts
// -------------------------------------------------------------------
// Define a trait type for filtering the field_basic class
template <class T> struct is_field : std::false_type {};
template <class T, class M> struct is_field <field_basic<T,M> > : std::true_type {};
// Define a trait type for detecting expression that are convertible to a field
template<class T> struct is_field_convertible : std::false_type {};
template<class T, class M> struct is_field_convertible <field_basic<T, M> > : std::true_type {};
template<class T, class M> struct is_field_convertible <field_indirect <T, M> > : std::true_type {};
template<class T, class M> struct is_field_convertible <field_indirect_const <T, M> > : std::true_type {};
template<class T, class M> struct is_field_convertible <field_component <T, M> > : std::true_type {};
template<class T, class M> struct is_field_convertible <field_component_const<T, M> > : std::true_type {};
// 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<
is_field_convertible<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
#ifdef TO_CLEAN
// Default defined in field.h
template<class T, class Sfinae = void> struct is_field_expr_affine_homogeneous : std::false_type {};
#endif // TO_CLEAN
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<
is_field_convertible<Expr>::value>::type> : std::true_type {};
// -------------------------------------------------------------------
// 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) const;
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt) const;
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) const
{ 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) const
{ 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) const
{ 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) const
{ 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 is_field_expr_v2_nonlinear_arg <F,
typename std::enable_if<
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<
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) const;
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt) const;
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) const;
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt) const;
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) const;
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt) const;
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::is_field_convertible<Expr>::value>::type>
explicit field_expr_v2_nonlinear_terminal_field_rep (const Expr& expr, const differentiate_option& gopt);
// --------------------------------------------
// 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) const;
void initialize (
const space_basic<T,M>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt) const;
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::is_field_convertible<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))) {}
// --------------------------------------------
// 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) const
{ 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) const
{ 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 {};
// 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<
is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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::is_field_convertible<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) const;
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt) 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>
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::is_field_convertible<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) const
{ 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) const
{ 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 {};
} // namespace details
#define _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg(op,c0,c1) \
template<class Expr> \
inline \
typename \
std::enable_if< \
details::is_field_convertible<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) const;
void initialize (
const space_basic<float_type,memory_type>& Xh,
const piola_on_pointset<float_type>& pops,
const integrate_option& iopt) 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>
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) const
{ 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) const
{ 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 {};
} // 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::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:716
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) const
Definition: field_expr_terminal.h:188
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::valued_tag
space_constant::valued_type valued_tag() const
Definition: field_expr_terminal.h:1186
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:421
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) const
Definition: field_expr_terminal.h:847
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:1157
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:1305
rheolef::geo_basic< T, M >
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic
Definition: field_expr_terminal.h:1339
rheolef::div
std::enable_if< details::is_field_convertible< 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)
div(uh): see the expression page for the full documentation
Definition: field_expr_terminal.h:1031
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:554
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:368
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:1146
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::function_type
details::function_traits< Function >::copiable_type function_type
Definition: field_expr_terminal.h:164
rheolef::details::penalty_pseudo_function
Definition: field_expr_terminal.h:538
rheolef::space_constant::last_valued
@ last_valued
Definition: space_constant.h:143
rheolef::details::field_expr_v2_nonlinear_terminal_field::valued_tag
space_constant::valued_type valued_tag() const
Definition: field_expr_terminal.h:838
rheo_default_memory_model
#define rheo_default_memory_model
Definition: distributed.h:113
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:1126
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::float_type
T float_type
Definition: field_expr_terminal.h:558
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::scalar_type
T scalar_type
Definition: field_expr_terminal.h:557
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:208
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::_c1
float_type _c1
Definition: field_expr_terminal.h:1158
rheolef::Ds
std::enable_if< details::is_field_convertible< 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)
Ds(uh): see the expression page for the full documentation.
Definition: field_expr_terminal.h:989
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::f_constant
Definition: space_constant.h:297
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:1360
rheolef::details::differentiate_option::divergence
@ divergence
Definition: piola.h:45
mkgeo_ball.expr
expr
Definition: mkgeo_ball.sh:361
rheolef::point_basic
Definition: point.h:87
rheolef::details::field_expr_v2_nonlinear_terminal_function::base
smart_pointer< rep > base
Definition: field_expr_terminal.h:263
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt) const
Definition: field_expr_terminal.h:1188
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::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::value_type
result_type value_type
Definition: field_expr_terminal.h:1252
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::value_type
result_type value_type
Definition: field_expr_terminal.h:1111
rheolef::field_o_characteristic
Definition: characteristic.h:248
rheolef::smart_pointer_base< T, details::constructor_copy< T > >::data
const T & data() const
Definition: smart_pointer.h:266
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::value_type
result_type value_type
Definition: field_expr_terminal.h:375
rheolef::piola::F
point_basic< T > F
Definition: piola.h:79
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:1200
rheolef::Function
rheolef::std Function
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:439
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::valued_tag
space_constant::valued_type valued_tag() const
Definition: field_expr_terminal.h:1365
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::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_uh
field_basic< T, M > _uh
Definition: field_expr_terminal.h:1298
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:1167
rheolef::smart_pointer_base
Definition: smart_pointer.h:131
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:386
rheolef::details::is_field_expr_affine_homogeneous
Definition: field.h:229
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:1119
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:593
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::size_type
geo_element::size_type size_type
Definition: field_expr_terminal.h:1249
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep
Definition: field_expr_terminal.h:1245
rheolef::valued_tag
space_constant::valued_type valued_tag() const
Definition: field_expr_recursive.h:579
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:556
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:1324
rheolef::details::field_expr_v2_nonlinear_terminal_function
Definition: field_expr_terminal.h:257
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::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt) const
Definition: field_expr_terminal.h:842
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::scalar_type
rep::scalar_type scalar_type
Definition: field_expr_terminal.h:1173
rheolef::details::normal_pseudo_function
Definition: field_expr_terminal.h:355
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits::type
Expr type
Definition: field_expr_terminal.h:98
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::value_type
typename rep::value_type value_type
Definition: field_expr_terminal.h:813
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:527
rheolef::value
rheolef::std value
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:370
rheolef::field_component_const
Definition: field.h:207
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::size_type
typename rep::size_type size_type
Definition: field_expr_terminal.h:808
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:1386
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:245
rheolef::details::differentiate_option::none
@ none
Definition: piola.h:43
rheolef::space_basic
the finite element space
Definition: space.h:352
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::scalar_type
T scalar_type
Definition: field_expr_terminal.h:1112
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::scalar_type
rep::scalar_type scalar_type
Definition: field_expr_terminal.h:1351
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< is_field_convertible< Expr >::value >::type >::M
Expr::memory_type M
Definition: field_expr_terminal.h:893
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:1181
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:608
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_gopt
differentiate_option _gopt
Definition: field_expr_terminal.h:708
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::float_type
rep::float_type float_type
Definition: field_expr_terminal.h:1350
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:734
mkgeo_ball.c
c
Definition: mkgeo_ball.sh:153
rheolef::details::h_local_pseudo_function
Definition: field_expr_terminal.h:450
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::size_type
geo_element::size_type size_type
Definition: field_expr_terminal.h:119
rheolef::space_constant::valued_type
valued_type
Definition: space_constant.h:135
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::value_type
result_type value_type
Definition: field_expr_terminal.h:559
rheolef::details::field_expr_v2_nonlinear_terminal_function::valued_hint
static const space_constant::valued_type valued_hint
Definition: field_expr_terminal.h:271
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::memory_type
rheo_default_memory_model memory_type
Definition: field_expr_terminal.h:120
rheolef::grad
std::enable_if< details::is_field_convertible< 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)
grad(uh): see the expression page for the full documentation
Definition: field_expr_terminal.h:911
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:415
rheolef::undeterminated_basic
helper for generic field value_type: T, point_basic<T> or tensor_basic<T>
Definition: undeterminated.h:32
rheolef::field_indirect_const
Definition: field.h:205
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::memory_type
rep::memory_type memory_type
Definition: field_expr_terminal.h:1348
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::_f
function_type _f
Definition: field_expr_terminal.h:224
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) const
Definition: field_expr_terminal.cc:571
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::size_type
geo_element::size_type size_type
Definition: field_expr_terminal.h:1108
rheolef::geo_element::variant
variant_type variant() const
Definition: geo_element.h:161
rheolef::details::field_expr_v2_nonlinear_terminal_field::expr
const field_basic< T, M > & expr() const
Definition: field_expr_terminal.h:840
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:505
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::_c0
float_type _c0
Definition: field_expr_terminal.h:1158
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::size_type
geo_element::size_type size_type
Definition: field_expr_terminal.h:643
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::memory_type
rheo_default_memory_model memory_type
Definition: field_expr_terminal.h:163
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::memory_type
typename rep::memory_type memory_type
Definition: field_expr_terminal.h:809
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) const
Definition: field_expr_terminal.h:297
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::initialize
void initialize(const piola_on_pointset< T > &pops, const integrate_option &iopt) const
Definition: field_expr_terminal.cc:402
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::scalar_type
T scalar_type
Definition: field_expr_terminal.h:1253
rheolef::div_h
std::enable_if< details::is_field_convertible< 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)
div_h(uh): see the expression page for the full documentation
Definition: field_expr_terminal.h:1069
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:1302
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::float_type
typename rep::float_type float_type
Definition: field_expr_terminal.h:811
rheolef::normal_basic
details::field_expr_v2_nonlinear_terminal_function< details::normal_pseudo_function< T > > normal_basic()
Definition: field_expr_terminal.h:430
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:664
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:854
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:552
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::value_type
rep::value_type value_type
Definition: field_expr_terminal.h:1352
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:553
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:728
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:1357
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::result_type
rep::result_type result_type
Definition: field_expr_terminal.h:1171
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::base
smart_pointer< rep > base
Definition: field_expr_terminal.h:1168
rheolef::side_information_type
Definition: reference_element_face_transformation.h:37
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::valued_hint
static const space_constant::valued_type valued_hint
Definition: field_expr_terminal.h:178
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:1303
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:1304
rheolef::reference_element
see the reference_element page for the full documentation
Definition: reference_element.h:66
rheolef::smart_pointer
see the smart_pointer page for the full documentation
Definition: smart_pointer.h:351
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::value_type
result_type value_type
Definition: field_expr_terminal.h:169
rheolef::details::field_expr_v2_nonlinear_terminal_function::rep
field_expr_v2_nonlinear_terminal_function_rep< Function > rep
Definition: field_expr_terminal.h:262
rheolef::integrate_option
see the integrate_option page for the full documentation
Definition: integrate_option.h:125
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:285
rheolef::space_constant::tensor
@ tensor
Definition: space_constant.h:138
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_need_vector_piola
bool _need_vector_piola
Definition: field_expr_terminal.h:718
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:1345
rheolef::space_constant::scalar
@ scalar
Definition: space_constant.h:136
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::scalar_type
T scalar_type
Definition: field_expr_terminal.h:469
rheolef::field_indirect
Definition: field.h:204
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< is_field_convertible< Expr >::value >::type >::type
field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none > type
Definition: field_expr_terminal.h:894
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_scalar_val
disarray< T, M > _scalar_val
Definition: field_expr_terminal.h:1301
rheolef::Dh
std::enable_if< details::is_field_convertible< 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)
Dh(uh): see the expression page for the full documentation.
Definition: field_expr_terminal.h:1010
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg
Definition: field_expr_terminal.h:1162
rheolef::details::field_expr_v2_nonlinear_terminal_function::size_type
rep::size_type size_type
Definition: field_expr_terminal.h:264
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:466
rheolef::test_basic< T, M, details::vf_tag_01 >
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:710
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::valued_tag
space_constant::valued_type valued_tag() const
Definition: field_expr_terminal.h:1128
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:303
rheolef::details::field_expr_v2_nonlinear_terminal_function::memory_type
rep::memory_type memory_type
Definition: field_expr_terminal.h:265
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) const
Definition: field_expr_terminal.h:1372
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::float_type
float_traits< T >::type float_type
Definition: field_expr_terminal.h:1254
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:1353
rheolef::details::function_traits
Definition: field_expr_utilities.h:188
rheolef::geo_element::size_type
reference_element::size_type size_type
Definition: geo_element.h:125
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_function_rep< h_local_pseudo_function< T > >::base
field_expr_v2_nonlinear_terminal_function_base_rep< T > base
Definition: field_expr_terminal.h:463
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:348
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::float_type
float_traits< T >::type float_type
Definition: field_expr_terminal.h:1113
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:1379
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) const
Definition: field_expr_terminal.h:1193
rheolef::type
rheolef::std type
rheolef::details::field_expr_v2_nonlinear_terminal_function::argument_type
rep::argument_type argument_type
Definition: field_expr_terminal.h:267
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:1283
rheolef::details::differentiate_option::symmetrized
bool symmetrized
Definition: piola.h:49
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:238
rheolef::details::differentiate_option
Definition: piola.h:41
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< is_field_function< Expr >::value >::type >::type
field_expr_v2_nonlinear_terminal_function< Expr > type
Definition: field_expr_terminal.h:336
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt) const
Definition: field_expr_terminal.cc:500
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt) const
Definition: field_expr_terminal.h:1367
rheolef::_f
BinaryFunction _f
Definition: field_expr_recursive.h:932
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::size_type
geo_element::size_type size_type
Definition: field_expr_terminal.h:162
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::float_type
T float_type
Definition: field_expr_terminal.h:470
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::scalar_type
T scalar_type
Definition: field_expr_terminal.h:121
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:1207
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::field_basic
Definition: field_expr_utilities.h:38
rheolef::details::differentiate_option::curl
@ curl
Definition: piola.h:46
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt) const
Definition: field_expr_terminal.h:183
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::memory_type
M memory_type
Definition: field_expr_terminal.h:644
rheolef::details::field_expr_v2_nonlinear_terminal_function::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt) const
Definition: field_expr_terminal.h:292
rheolef::grad_s
std::enable_if< details::is_field_convertible< 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)
grad_s(uh): see the expression page for the full documentation
Definition: field_expr_terminal.h:929
rheolef::space_constant::unsymmetric_tensor
@ unsymmetric_tensor
Definition: space_constant.h:139
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:828
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:194
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::memory_type
M memory_type
Definition: field_expr_terminal.h:1109
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:166
rheolef::field_component
Definition: field.h:206
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::float_type
rep::float_type float_type
Definition: field_expr_terminal.h:1172
fatal_macro
#define fatal_macro(message)
Definition: dis_macros.h:33
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_fops
fem_on_pointset< T > _fops
Definition: field_expr_terminal.h:1300
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits
Definition: field_expr_terminal.h:95
rheolef::details::field_expr_v2_nonlinear_terminal_function::float_type
rep::float_type float_type
Definition: field_expr_terminal.h:270
rheolef::piola_on_pointset< float_type >
rheolef::space_constant::valued_name
const std::string & valued_name(valued_type valued_tag)
Definition: space_constant.cc:43
rheolef::details::field_expr_v2_nonlinear_terminal_function::result_type
rep::result_type result_type
Definition: field_expr_terminal.h:266
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep
Definition: field_expr_terminal.h:639
rheolef::details::differentiate_option::gradient
@ gradient
Definition: piola.h:44
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::float_traits::type
T type
Definition: Float.h:94
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< h_local_pseudo_function< T > >::result_type
T result_type
Definition: field_expr_terminal.h:467
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:347
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:371
rheolef::details::penalty_pseudo_function::operator()
T operator()(const point_basic< T > &) const
Definition: field_expr_terminal.h:539
rheolef::details::field_expr_v2_nonlinear_terminal_field::valued_hint
static const space_constant::valued_type valued_hint
Definition: field_expr_terminal.h:815
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:372
rheolef::fem_on_pointset
Definition: fem_on_pointset.h:117
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep::result_type
undeterminated_basic< T > result_type
Definition: field_expr_terminal.h:1110
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:229
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:217
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_dis_inod_geo
std::vector< size_type > _dis_inod_geo
Definition: field_expr_terminal.h:717
rheolef::details::h_local_pseudo_function::operator()
T operator()(const point_basic< T > &) const
Definition: field_expr_terminal.h:451
rheolef::curl
std::enable_if< details::is_field_convertible< 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)
curl(uh): see the expression page for the full documentation
Definition: field_expr_terminal.h:1089
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:1265
rheolef::details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr, typename std::enable_if< is_field_convertible< Expr >::value >::type >::T
Expr::scalar_type T
Definition: field_expr_terminal.h:892
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:468
rheolef::promote_not_specialized_for_this_case
Definition: promote.h:26
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:465
mkgeo_obstacle.L
L
Definition: mkgeo_obstacle.sh:133
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::_pops
piola_on_pointset< float_type > _pops
Definition: field_expr_terminal.h:149
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::valued_hint
static const space_constant::valued_type valued_hint
Definition: field_expr_terminal.h:1175
rheolef::reference_element::max_variant
static const variant_type max_variant
Definition: reference_element.h:82
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::float_type
T float_type
Definition: field_expr_terminal.h:374
rheolef::D
std::enable_if< details::is_field_convertible< 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)
D(uh): see the expression page for the full documentation.
Definition: field_expr_terminal.h:969
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep
Definition: field_expr_terminal.h:155
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep
Definition: field_expr_terminal.h:115
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::float_type
typename float_traits< T >::type float_type
Definition: field_expr_terminal.h:646
rheolef::details::differentiate_option::broken
bool broken
Definition: piola.h:51
rheolef::disarray< T, M >
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::const_iterator
typename rep::const_iterator const_iterator
Definition: field_expr_terminal.h:831
rheolef::details::field_expr_v2_nonlinear_terminal_function::scalar_type
rep::scalar_type scalar_type
Definition: field_expr_terminal.h:269
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::result_type
rep::result_type result_type
Definition: field_expr_terminal.h:1349
rheolef::basis_on_pointset
Definition: basis_on_pointset.h:191
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::valued_hint
static const space_constant::valued_type valued_hint
Definition: field_expr_terminal.h:676
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:861
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::memory_type
M memory_type
Definition: field_expr_terminal.h:1250
rheolef::point_basic< T >
point_basic< T >
Definition: piola_fem.h:135
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< normal_pseudo_function< T > >::scalar_type
T scalar_type
Definition: field_expr_terminal.h:373
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::scalar_type
scalar_traits< result_type >::type scalar_type
Definition: field_expr_terminal.h:167
rheolef::compose
details::field_expr_v2_nonlinear_node_nary< typename details::function_traits< Function >::functor_type,typename details::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:246
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:367
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:626
rheolef::scalar_traits::type
T type
Definition: point.h:324
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg_rep
Definition: field_expr_terminal.h:1104
rheolef::details::field_expr_v2_nonlinear_terminal_function::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:317
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::value_type
result_type value_type
Definition: field_expr_terminal.h:652
rheolef::div_s
std::enable_if< details::is_field_convertible< 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)
div_s(uh): see the expression page for the full documentation
Definition: field_expr_terminal.h:1049
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:471
rheolef::space_constant::vector
@ vector
Definition: space_constant.h:137
rheolef::details::is_equal
Definition: space_constant.h:38
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::size_type
rep::size_type size_type
Definition: field_expr_terminal.h:1169
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:170
rheolef::details::field_expr_v2_nonlinear_terminal_function::valued_tag
space_constant::valued_type valued_tag() const
Definition: field_expr_terminal.h:290
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:369
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::float_type
float_traits< result_type >::type float_type
Definition: field_expr_terminal.h:168
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:235
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_start_q
size_type _start_q
Definition: field_expr_terminal.h:1306
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:722
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_check
void _check() const
rheolef::details::field_expr_v2_nonlinear_terminal_field
Definition: field_expr_terminal.h:801
rheolef::grad_h
std::enable_if< details::is_field_convertible< 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)
grad_h(uh): see the expression page for the full documentation
Definition: field_expr_terminal.h:949
rheolef::details::field_expr_v2_nonlinear_terminal_field::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:869
rheolef::details::normal_pseudo_function::operator()
point_basic< T > operator()(const point_basic< T > &) const
Definition: field_expr_terminal.h:356
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:651
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:551
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::result_type
typename rep::result_type result_type
Definition: field_expr_terminal.h:810
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::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_field::get_geo
const geo_basic< T, M > & get_geo() const
Definition: field_expr_terminal.h:839
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep< penalty_pseudo_function< T > >::result_type
T result_type
Definition: field_expr_terminal.h:555
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:821
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_uh
field_basic< T, M > _uh
Definition: field_expr_terminal.h:709
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::valued_tag
space_constant::valued_type valued_tag() const
Definition: field_expr_terminal.h:180
rheolef::penalty_basic
details::field_expr_v2_nonlinear_terminal_function< details::penalty_pseudo_function< T > > penalty_basic()
Definition: field_expr_terminal.h:617
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:464
f
Definition: cavity_dg.h:29
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:1157
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:280
rheolef::space_constant::valued_tag_traits
Definition: space_constant.h:161
rheolef::field_basic::const_iterator
Definition: field.h:518
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_use_bgd2dom
bool _use_bgd2dom
Definition: field_expr_terminal.h:712
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_use_dom2bgd
bool _use_dom2bgd
Definition: field_expr_terminal.h:711
rheolef::details::differentiate_option::surfacic
bool surfacic
Definition: piola.h:50
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:669
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:740
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::base
smart_pointer< rep > base
Definition: field_expr_terminal.h:1346
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::scalar_type
T scalar_type
Definition: field_expr_terminal.h:645
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_have_dg_on_sides
bool _have_dg_on_sides
Definition: field_expr_terminal.h:713
rheolef::details::field_expr_v2_nonlinear_terminal_field_dg::value_type
rep::value_type value_type
Definition: field_expr_terminal.h:1174
rheolef::details::is_field_expr_v2_nonlinear_arg
Definition: field_expr_terminal.h:74
rheolef::details::field_expr_v2_nonlinear_terminal_field< T, M, details::differentiate_option::none >::scalar_type
typename rep::scalar_type scalar_type
Definition: field_expr_terminal.h:812
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:1263
rheolef::std
Definition: vec_expr_v2.h:391
mkgeo_contraction.status
status
Definition: mkgeo_contraction.sh:290
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::_X
characteristic_basic< T, M > _X
Definition: field_expr_terminal.h:1299
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:725
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_function::field_expr_v2_nonlinear_terminal_function
field_expr_v2_nonlinear_terminal_function(const Function &f)
Definition: field_expr_terminal.h:275
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:518
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::begin_dof
const_iterator begin_dof() const
Definition: field_expr_terminal.h:670
M
Expr1::memory_type M
Definition: vec_expr_v2.h:385
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic_rep::result_type
undeterminated_basic< T > result_type
Definition: field_expr_terminal.h:1251
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:570
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:309
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_dg::memory_type
rep::memory_type memory_type
Definition: field_expr_terminal.h:1170
rheolef::details::is_field
Definition: field.h:228
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::_tilde_L
reference_element _tilde_L
Definition: field_expr_terminal.h:714
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:731
rheolef::details::field_expr_v2_nonlinear_terminal_field_rep::valued_check
bool valued_check() const
Definition: field_expr_terminal.h:766
rheolef::details::field_expr_v2_nonlinear_terminal_field_o_characteristic::size_type
rep::size_type size_type
Definition: field_expr_terminal.h:1347
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:346
rheolef::details::field_expr_v2_nonlinear_terminal_field::begin_dof
const_iterator begin_dof() const
Definition: field_expr_terminal.h:832
T
Expr1::float_type T
Definition: field_expr.h:218
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:232
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::float_type
T float_type
Definition: field_expr_terminal.h:122
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:482
rheolef::details::is_field_convertible
Definition: field_expr_terminal.h:65
rheolef::details::field_expr_v2_nonlinear_terminal_function_rep::result_type
details::function_traits< Function >::result_type result_type
Definition: field_expr_terminal.h:165
rheolef::characteristic_basic
Definition: characteristic.h:194
rheolef::details::field_expr_v2_nonlinear_terminal_function::value_type
rep::value_type value_type
Definition: field_expr_terminal.h:268
rheolef::piola_on_pointset::get_piola
const Eigen::Matrix< piola< T >, Eigen::Dynamic, 1 > & get_piola(const geo_basic< T, M > &omega, const geo_element &K) const
Definition: piola_on_pointset.h:239
rheolef::piola
Definition: piola.h:67
rheolef::details::field_expr_v2_nonlinear_terminal_function_base_rep::initialize
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt) const
Definition: field_expr_terminal.cc:57
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:241