Loading...
Searching...
No Matches
form_expr_quadrature.h
Go to the documentation of this file.
#ifndef _RHEOLEF_FORM_EXPR_QUADRATURE_H
#define _RHEOLEF_FORM_EXPR_QUADRATURE_H
//
// variational expressions are integrated by using a quadrature formulae
//
// author: Pierre.Saramito@imag.fr
//
// date: 18 march 2018
//
// SUMMARY:
// 1. concept
// 2. terminals
// 2.1. integration on one element K
// 2.2. integration on element boundary partial K
// 3. unary function
// 3.1. unary node
// 3.2. unary calls
// 4. binary operators +- between two integrated forms
// 4.1. binary node
// 4.2. binary calls
// 5. binary operators */ between a integrated form and a constant
//
/*
let:
a(u,v) = int_domain expr(u,v) dx
The integrals are evaluated over each element K of the domain
by using a quadrature formulae given by iopt
expr(u,v) is a bilinear expression with respect to the
trial and test functions u and v
The trial function u is replaced by each of the basis function of
the corresponding finite element space Xh: (phi_j), j=0..dim(Xh)-1
The test function v is replaced by each of the basis function of
the corresponding finite element space Yh: (psi_i), i=0..dim(Yh)-1
The integrals over the domain omega is the sum of integrals over K.
The integrals over K are transformed on the reference element with
the piola transformation:
F : hat_K ---> K
hat_x |--> x = F(hat_x)
exemples:
1) expr(v) = u*v
int_K phi_j(x)*psi_i(x) dx
= int_{hat_K} hat_phi_j(hat_x)*hat_psi_i(hat_x) det(DF(hat_x)) d hat_x
= sum_q hat_phi_j(hat_xq)*hat_psi_i(hat_xq) det(DF(hat_xq)) hat_wq
The value(q,i,j) = (hat_phi_j(hat_xq)*hat_psi_i(hat_xq))
refers to basis values on the reference element.
There are evaluated on time for all over the reference element hat_K
and for the given quadrature formulae by:
expr.initialize (omega, quad);
This expression is represented by the 'test' class (see test.h)
3) expr(v) = dot(grad(u),grad(v)) dx
The 'grad' node returns
value(q,i) = trans(inv(DF(hat_wq))*grad_phi_i(hat_xq) that is vector-valued
The grad_phi values are obtained by a grad_value(q,i) method on the 'test' class.
The 'dot' performs on the fly the product
value(q,i,j) = dot (value1(q,i), value2(q,j))
This approch generalizes for an expression tree.
*/
#include "rheolef/form_expr_variational.h"
#include "rheolef/init_expr_quadrature.h"
namespace rheolef {
// -------------------------------------------------------------------
// 1. concept
// -------------------------------------------------------------------
namespace details {
// Define a trait type for detecting form expression valid arguments
template<class T> struct is_form_expr_quadrature_arg: std::false_type {};
template<class T> struct is_form_expr_quadrature_on_side_arg: std::false_type {};
} // namespace details
// ---------------------------------------------------------------------------
// 2. terminals
// ---------------------------------------------------------------------------
// 2.1. integration on one element K
// ---------------------------------------------------------------------------
namespace details {
template<class Expr>
class form_expr_quadrature_on_element {
public:
// typedefs:
typedef geo_element::size_type size_type;
typedef typename Expr::memory_type memory_type;
typedef typename Expr::value_type result_hint;
typedef typename Expr::value_type value_type;
typedef typename scalar_traits<value_type>::type scalar_type;
typedef typename float_traits<value_type>::type float_type;
typedef space_basic<float_type,memory_type> space_type;
typedef geo_basic <float_type,memory_type> geo_type;
typedef typename Expr::vf_tag_type vf_tag_type;
typedef typename details::dual_vf_tag<vf_tag_type>::type
vf_dual_tag_type;
typedef form_expr_quadrature_on_element<Expr> self_type;
typedef form_expr_quadrature_on_element<typename Expr::dual_self_type>
dual_self_type;
typedef typename Expr::maybe_symmetric::type maybe_symmetric;
static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<value_type>::value;
// alocators:
template<class Sfinae = typename std::enable_if<is_form_expr_v2_variational_arg<Expr>::value, Expr>::type>
form_expr_quadrature_on_element (const Expr& expr);
// modifiers:
void initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt);
void initialize (const band_basic<float_type,memory_type>& gh, const integrate_option& iopt);
// accessors:
const space_type& get_trial_space() const { return _expr.get_trial_space(); }
const space_type& get_test_space() const { return _expr.get_test_space(); }
size_type n_derivative() const { return _expr.n_derivative(); }
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& ak) const;
template<class Value>
bool valued_check() const {
typedef Value A1;
if (! is_undeterminated<A1>::value) return _expr.template valued_check<A1>();
return true;
}
protected:
// data:
Expr _expr;
mutable piola_on_pointset<float_type> _pops;
// working variables:
mutable Eigen::Tensor<float_type,3> _value_i;
};
template<class Expr> struct is_form_expr_quadrature_arg <form_expr_quadrature_on_element<Expr> > : std::true_type {};
// ---------------------------------------------------------------------------
// inlined
// ---------------------------------------------------------------------------
template<class Expr>
template<class Sfinae>
inline
form_expr_quadrature_on_element<Expr>::form_expr_quadrature_on_element (const Expr& expr)
: _expr(expr),
_pops(),
_value_i()
{
}
template<class Expr>
void
form_expr_quadrature_on_element<Expr>::initialize (
const geo_basic<float_type,memory_type>& omega_K,
const integrate_option& iopt)
{
integrate_option new_iopt = expr_quadrature_init_iopt (omega_K, get_trial_space(), get_test_space(), n_derivative(), iopt);
quadrature<float_type> quad = expr_quadrature_init_quad<float_type> (new_iopt);
_pops.initialize (omega_K.get_piola_basis(), quad, new_iopt);
_expr.initialize (_pops, new_iopt);
}
template<class Expr>
void
form_expr_quadrature_on_element<Expr>::initialize (
const band_basic<float_type,memory_type>& gh,
const integrate_option& iopt)
{
integrate_option new_iopt = expr_quadrature_init_iopt (gh.band(), get_trial_space(), get_test_space(), n_derivative(), iopt);
quadrature<float_type> quad = expr_quadrature_init_quad<float_type> (new_iopt);
_pops.initialize (gh.band().get_piola_basis(), quad, new_iopt);
_expr.initialize (gh, _pops, new_iopt);
}
template<class Expr>
template<class Value>
void
form_expr_quadrature_on_element <Expr>::evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& ak) const
{
const Eigen::Matrix<float_type,Eigen::Dynamic,1>& w = _pops.get_weight (omega_K, K);
_expr.evaluate (omega_K, K, _value_i);
// blas3: a_jk = sum_i phi_jk(xi)*w(xi) TODO: DVT_EIGEN_BLAS2
size_t ni = _value_i.dimension(0);
size_t nj = _value_i.dimension(1);
size_t nk = _value_i.dimension(2);
ak.resize (nj, nk);
for (size_t j = 0; j < nj; ++j) {
for (size_t k = 0; k < nk; ++k) {
Value sum = 0;
for (size_t i = 0; i < ni; ++i) {
sum += w[i] * _value_i(i,j,k);
}
ak(j,k) = sum;
}}
}
} // namespace details
// ---------------------------------------------------------------------------
// 2.2. integration on element boundary partial K
// ---------------------------------------------------------------------------
namespace details {
template<class Expr>
class form_expr_quadrature_on_sides {
public:
// typedefs:
typedef geo_element::size_type size_type;
typedef typename Expr::memory_type memory_type;
typedef typename Expr::value_type result_hint;
typedef typename Expr::value_type value_type;
typedef typename scalar_traits<value_type>::type scalar_type;
typedef typename float_traits<value_type>::type float_type;
typedef space_basic<float_type,memory_type> space_type;
typedef geo_basic <float_type,memory_type> geo_type;
typedef typename Expr::vf_tag_type vf_tag_type;
typedef typename details::dual_vf_tag<vf_tag_type>::type
vf_dual_tag_type;
typedef form_expr_quadrature_on_element<Expr> self_type;
typedef form_expr_quadrature_on_element<typename Expr::dual_self_type>
dual_self_type;
typedef typename Expr::maybe_symmetric::type maybe_symmetric;
static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<value_type>::value;
// alocators:
template<class Sfinae = typename std::enable_if<is_form_expr_v2_variational_arg<Expr>::value, Expr>::type>
form_expr_quadrature_on_sides (const Expr& expr);
// accessors:
const space_type& get_trial_space() const { return _expr.get_trial_space(); }
const space_type& get_test_space() const { return _expr.get_test_space(); }
size_type n_derivative() const { return _expr.n_derivative(); }
// mutable modifiers:
void initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt);
void initialize (const band_basic<float_type,memory_type>& gh, const integrate_option& iopt);
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& ak) const;
template<class Value>
bool valued_check() const {
typedef Value A1;
if (! is_undeterminated<A1>::value) return _expr.template valued_check<A1>();
return true;
}
protected:
// data:
mutable Expr _expr;
mutable piola_on_pointset<float_type> _pops;
mutable bool _ignore_sys_coord;
// working variables:
mutable Eigen::Tensor<float_type,3> _value_i;
mutable std::vector<size_type> _dis_inod_S;
mutable tensor_basic<float_type> _DF;
};
template<class Expr> struct is_form_expr_quadrature_arg <form_expr_quadrature_on_sides<Expr> > : std::true_type {};
template<class Expr> struct is_form_expr_quadrature_on_side_arg <form_expr_quadrature_on_sides<Expr> > : std::true_type {};
// ---------------------------------------------------------------------------
// inlined
// ---------------------------------------------------------------------------
template<class Expr>
template<class Sfinae>
inline
form_expr_quadrature_on_sides<Expr>::form_expr_quadrature_on_sides (const Expr& expr)
: _expr(expr),
_pops(),
_ignore_sys_coord(false),
_value_i(),
_dis_inod_S(),
_DF()
{
}
template<class Expr>
void
form_expr_quadrature_on_sides<Expr>::initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt)
{
_ignore_sys_coord = iopt.ignore_sys_coord;
integrate_option new_iopt = expr_quadrature_init_iopt (omega_K, get_trial_space(), get_test_space(), _expr.n_derivative(), iopt);
quadrature<float_type> quad = expr_quadrature_init_quad<float_type> (new_iopt);
new_iopt._is_inside_on_local_sides = true; // propagate it recursively in the whole expression
_pops.initialize (omega_K.get_piola_basis(), quad, new_iopt);
_expr.initialize (_pops, new_iopt);
}
template<class Expr>
void
form_expr_quadrature_on_sides<Expr>::initialize (const band_basic<float_type,memory_type>& gh, const integrate_option& iopt)
{
_ignore_sys_coord = iopt.ignore_sys_coord;
integrate_option new_iopt = expr_quadrature_init_iopt (gh.band(), get_trial_space(), get_test_space(), n_derivative(), iopt);
quadrature<float_type> quad = expr_quadrature_init_quad<float_type> (new_iopt);
new_iopt._is_inside_on_local_sides = true; // propagate it recursively in the whole expression
_pops.initialize (gh.band().get_piola_basis(), quad, new_iopt);
_expr.initialize (gh, _pops, new_iopt);
fatal_macro("on_local_sides: banded-level set not yet supported, sorry");
}
template<class Expr>
template<class Value>
void
form_expr_quadrature_on_sides<Expr>::evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
{
size_type sid_dim = K.dimension()-1;
size_type nyi = get_test_space().get_constitution().assembly_loc_ndof (omega_K, K);
size_type nxj = get_trial_space().get_constitution().assembly_loc_ndof (omega_K, K);
for (size_type isid = 0, nsid = K.n_subgeo(sid_dim); isid < nsid; ++isid) {
size_type dis_isid = (K.dimension() == 1) ? K[isid] : (K.dimension() == 2) ? K.edge(isid) : K.face(isid);
const geo_element& S = omega_K.dis_get_geo_element (sid_dim, dis_isid);
side_information_type sid;
K.get_side_informations (S, sid);
_expr.evaluate_on_side (omega_K, K, sid, _value_i);
const Eigen::Matrix<float_type,Eigen::Dynamic,1>& w = _pops.get_weight (omega_K, S);
// blas3: a_jk += sum_i phi_jk(xi)*w(xi) TODO: DVT_EIGEN_BLAS2
size_t ni = _value_i.dimension(0);
size_t nj = _value_i.dimension(1);
size_t nk = _value_i.dimension(2);
if (isid == 0) {
value = Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>::Zero(nj, nk);
}
for (size_t j = 0; j < nj; ++j) {
for (size_t k = 0; k < nk; ++k) {
Value sum = 0;
for (size_t i = 0; i < ni; ++i) {
sum += w[i] * _value_i(i,j,k);
}
value(j,k) += sum;
}}
}
}
} // namespace details
template<class Expr>
inline
typename
std::enable_if<
details::is_form_expr_v2_variational_arg<Expr>::value
,details::form_expr_quadrature_on_sides<Expr>
>::type
on_local_sides (const Expr& expr)
{
return details::form_expr_quadrature_on_sides<Expr>(expr);
}
// ---------------------------------------------------------------------------
// 3. unary function
// example: -(u*v), 2*(u*v), (u*v)/2
// ---------------------------------------------------------------------------
// 3.1. unary node
// ---------------------------------------------------------------------------
namespace details {
template<class UnaryFunction, class Expr>
class form_expr_quadrature_unary {
public:
// typedefs:
typedef geo_element::size_type size_type;
typedef typename Expr::memory_type memory_type;
typedef typename details::generic_unary_traits<UnaryFunction>::template result_hint<
typename Expr::value_type>::type result_hint;
typedef typename details::generic_unary_traits<UnaryFunction>::template hint<
typename Expr::value_type
,result_hint>::result_type value_type;
typedef typename scalar_traits<value_type>::type scalar_type;
typedef typename float_traits<value_type>::type float_type;
typedef space_basic<float_type,memory_type> space_type;
typedef geo_basic <float_type,memory_type> geo_type;
typedef typename Expr::vf_tag_type vf_tag_type;
typedef typename details::dual_vf_tag<vf_tag_type>::type
vf_dual_tag_type;
typedef form_expr_quadrature_unary<UnaryFunction,Expr> self_type;
typedef form_expr_quadrature_unary<UnaryFunction, typename Expr::dual_self_type>
dual_self_type;
typedef typename Expr::maybe_symmetric::type maybe_symmetric;
static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<value_type>::value;
// alocators:
template<class Sfinae = typename std::enable_if<is_form_expr_quadrature_arg<Expr>::value, Expr>::type>
form_expr_quadrature_unary (const UnaryFunction& f, const Expr& expr)
: _f(f), _expr(expr) {}
// accessors:
const space_type& get_trial_space() const { return _expr.get_trial_space(); }
const space_type& get_test_space() const { return _expr.get_test_space(); }
size_type n_derivative() const { return _expr.n_derivative(); }
// mutable modifiers:
void initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt) {
return _expr.initialize (omega_K, iopt); }
void initialize (const band_basic<float_type,memory_type>& gh, const integrate_option& iopt) {
return _expr.initialize (gh, iopt); }
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
{
typedef Value A1; // Value is float_type in general: elementary matrix
_expr.evaluate (omega_K, K, value);
for (size_type i = 0, ni = value.rows(); i < ni; ++i) {
for (size_type j = 0, nj = value.cols(); j < nj; ++j) {
value(i,j) = _f (value(i,j));
}}
}
template<class Value>
bool valued_check() const {
typedef Value A1;
if (! is_undeterminated<A1>::value) return _expr.template valued_check<A1>();
return true;
}
protected:
// data:
UnaryFunction _f;
Expr _expr;
};
template<class F, class Expr> struct is_form_expr_quadrature_arg <form_expr_quadrature_unary<F,Expr> > : std::true_type {};
} // namespace details
// ---------------------------------------------------------------------------
// 3.2. unary calls
// ---------------------------------------------------------------------------
#define _RHEOLEF_make_form_expr_quadrature_unary(FUNCTION,FUNCTOR) \
template<class Expr> \
inline \
typename \
std::enable_if< \
details::is_form_expr_quadrature_arg<Expr>::value \
,details::form_expr_quadrature_unary< \
FUNCTOR \
,Expr \
> \
>::type \
FUNCTION (const Expr& expr) \
{ \
return details::form_expr_quadrature_unary <FUNCTOR,Expr> (FUNCTOR(), expr); \
}
_RHEOLEF_make_form_expr_quadrature_unary (operator+, details::unary_plus)
_RHEOLEF_make_form_expr_quadrature_unary (operator-, details::negate)
#undef _RHEOLEF_make_form_expr_quadrature_unary
// ---------------------------------------------------------------------------
// 4. binary operators +- between two integrated forms
// ---------------------------------------------------------------------------
// 4.1. binary node
// ---------------------------------------------------------------------------
// example: operator+ between two forms as in
// (u*v) + on_local_sides(u*v)
namespace details {
template<class BinaryFunction, class Expr1, class Expr2>
class form_expr_quadrature_binary {
public:
// typedefs:
typedef geo_element::size_type size_type;
typedef typename promote_memory<typename Expr1::memory_type,typename Expr2::memory_type>::type
memory_type;
typedef typename details::generic_binary_traits<BinaryFunction>::template result_hint<
typename Expr1::value_type
,typename Expr2::value_type>::type result_hint;
typedef typename details::generic_binary_traits<BinaryFunction>::template hint<
typename Expr1::value_type
,typename Expr2::value_type
,result_hint>::result_type value_type;
typedef typename scalar_traits<value_type>::type scalar_type;
typedef typename float_traits<value_type>::type float_type;
typedef space_basic<float_type,memory_type> space_type; // TODO: deduce from Exprs
typedef geo_basic <float_type,memory_type> geo_type;
typedef typename details::bf_vf_tag<BinaryFunction,
typename Expr1::vf_tag_type,
typename Expr2::vf_tag_type>::type vf_tag_type;
typedef typename details::dual_vf_tag<vf_tag_type>::type
vf_dual_tag_type;
typedef form_expr_quadrature_binary<BinaryFunction,Expr1,Expr2> self_type;
typedef form_expr_quadrature_binary<BinaryFunction,typename Expr1::dual_self_type,
typename Expr2::dual_self_type>
dual_self_type;
typedef typename and_type<typename Expr1::maybe_symmetric::type,
typename Expr2::maybe_symmetric::type>::type
maybe_symmetric;
static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<value_type>::value;
// alocators:
#ifdef TODO
template<class Sfinae
= typename std::enable_if<
is_form_expr_quadrature_arg<Expr1>::value && is_form_expr_quadrature_arg<Expr2>::value
,Expr1
>::type
>
#endif // TODO
form_expr_quadrature_binary (const BinaryFunction& f,
const Expr1& expr1,
const Expr2& expr2)
: _f(f), _expr1(expr1), _expr2(expr2) {}
// accessors:
const space_type& get_trial_space() const { return _expr1.get_trial_space(); }
const space_type& get_test_space() const { return _expr1.get_test_space(); }
size_type n_derivative() const { return std::min(_expr1.n_derivative(), _expr2.n_derivative()); }
// mutable modifiers:
void initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt) {
integrate_option new_iopt = expr_quadrature_init_iopt (omega_K, get_trial_space(), get_test_space(), n_derivative(), iopt);
_expr1.initialize (omega_K, new_iopt);
_expr2.initialize (omega_K, new_iopt);
}
void initialize (const band_basic<float_type,memory_type>& gh, const integrate_option& iopt) {
integrate_option new_iopt = expr_quadrature_init_iopt (gh.band(), get_trial_space(), get_test_space(), n_derivative(), iopt);
_expr1.initialize (gh, new_iopt);
_expr2.initialize (gh, new_iopt);
}
template<class Value>
void evaluate (
const geo_basic<float_type,memory_type>& omega_K,
const geo_element& K,
Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
{
// Value is float_type in general: elementary matrix
// for f=operator+ => sum of two elementary matrix of the same type
// TODO: otherwise Value and 2 could be obtained from the hint<> helper
typedef Value A1;
typedef Value A2;
Eigen::Matrix<A2,Eigen::Dynamic,Eigen::Dynamic> value2 (value.cols(), value.cols());
_expr1.evaluate (omega_K, K, value);
_expr2.evaluate (omega_K, K, value2);
for (size_type i = 0, ni = value.rows(); i < ni; ++i) {
for (size_type j = 0, nj = value.cols(); j < nj; ++j) {
value(i,j) = _f (value(i,j), value2(i,j));
}}
}
template<class Value>
bool valued_check() const {
typedef Value A1;
typedef Value A2;
bool status = true;
if (! is_undeterminated<A1>::value) status &= _expr1.template valued_check<A1>();
if (! is_undeterminated<A2>::value) status &= _expr2.template valued_check<A2>();
return status;
}
protected:
// data:
BinaryFunction _f;
Expr1 _expr1;
Expr2 _expr2;
};
template<class F, class Expr1, class Expr2> struct is_form_expr_quadrature_arg <form_expr_quadrature_binary<F,Expr1,Expr2> > : std::true_type {};
} // namespace details
// ---------------------------------------------------------------------------
// 4.2. binary calls
// ---------------------------------------------------------------------------
// expr_quad := expr_quad +- expr_quad
// expr_quad := expr_var +- expr_quad
// expr_quad := expr_quad +- expr_var
#define _RHEOLEF_form_expr_quadrature_binary(FUNCTION,FUNCTOR) \
template <class Expr1, class Expr2> \
inline \
typename \
std::enable_if< \
details::is_form_expr_quadrature_arg <Expr1>::value \
&& details::is_form_expr_quadrature_arg <Expr2>::value \
,details::form_expr_quadrature_binary< \
FUNCTOR \
,Expr1 \
,Expr2 \
> \
>::type \
FUNCTION (const Expr1& expr1, const Expr2& expr2) \
{ \
return details::form_expr_quadrature_binary \
<FUNCTOR, Expr1, Expr2> \
(FUNCTOR(), expr1, expr2); \
} \
template <class Expr1, class ExprVar2> \
inline \
typename \
std::enable_if< \
details::is_form_expr_quadrature_arg <Expr1>::value \
&& details::is_form_expr_v2_variational_arg <ExprVar2>::value \
,details::form_expr_quadrature_binary< \
FUNCTOR \
,Expr1 \
,details::form_expr_quadrature_on_element<ExprVar2> \
> \
>::type \
FUNCTION (const Expr1& expr1, const ExprVar2& expr_var2) \
{ \
using Expr2 = details::form_expr_quadrature_on_element<ExprVar2>; \
return details::form_expr_quadrature_binary \
<FUNCTOR, Expr1, Expr2> \
(FUNCTOR(), expr1, Expr2(expr_var2)); \
} \
template <class ExprVar1, class Expr2> \
inline \
typename \
std::enable_if< \
details::is_form_expr_v2_variational_arg <ExprVar1>::value \
&& details::is_form_expr_quadrature_arg <Expr2>::value \
,details::form_expr_quadrature_binary< \
FUNCTOR \
,details::form_expr_quadrature_on_element<ExprVar1> \
,Expr2 \
> \
>::type \
FUNCTION (const ExprVar1& expr_var1, const Expr2& expr2) \
{ \
using Expr1 = details::form_expr_quadrature_on_element<ExprVar1>; \
return details::form_expr_quadrature_binary \
<FUNCTOR, Expr1, Expr2> \
(FUNCTOR(), Expr1(expr_var1), expr2); \
} \
_RHEOLEF_form_expr_quadrature_binary (operator+, details::plus)
_RHEOLEF_form_expr_quadrature_binary (operator-, details::minus)
#undef _RHEOLEF_form_expr_quadrature_binary
// ---------------------------------------------------------------------------
// 5. binary operators */ between a integrated form and a constant
// ---------------------------------------------------------------------------
// expr_quad := k*expr_quad
// expr_quad := expr_quad*k
// expr_quad := expr_quad/k
namespace details {
template<class Expr1, class Expr2, class Sfinae = void>
struct is_form_expr_quadrature_binary_multiplies_divides_constant_left : std::false_type {};
template<class Expr1, class Expr2>
struct is_form_expr_quadrature_binary_multiplies_divides_constant_left <
Expr1
,Expr2
,typename
std::enable_if<
is_rheolef_arithmetic <Expr1>::value
&& is_form_expr_quadrature_arg<Expr2>::value
>::type
>
: std::true_type
{};
template<class Expr1, class Expr2>
struct is_form_expr_quadrature_binary_multiplies_divides_constant_right
: is_form_expr_quadrature_binary_multiplies_divides_constant_left <Expr2,Expr1> {};
} // namespace details
#define _RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_left(FUNCTION,FUNCTOR) \
template<class Expr1, class Expr2> \
inline \
typename \
std::enable_if< \
details::is_form_expr_quadrature_binary_multiplies_divides_constant_left <Expr1,Expr2>::value \
,details::form_expr_quadrature_unary< \
details::binder_first <FUNCTOR, Expr1> \
,Expr2 /* vf */ \
> \
>::type \
FUNCTION (const Expr1& expr1, const Expr2& expr2) \
{ \
return details::form_expr_quadrature_unary \
<details::binder_first <FUNCTOR,Expr1>, Expr2> \
(details::binder_first <FUNCTOR,Expr1> (FUNCTOR(), expr1), expr2); \
}
#define _RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_right(FUNCTION,FUNCTOR) \
template<class Expr1, class Expr2> \
inline \
typename \
std::enable_if< \
details::is_form_expr_quadrature_binary_multiplies_divides_constant_right <Expr1,Expr2>::value \
,details::form_expr_quadrature_unary< \
details::binder_second <FUNCTOR, Expr2> \
,Expr1 /* vf */ \
> \
>::type \
FUNCTION (const Expr1& expr1, const Expr2& expr2) \
{ \
return details::form_expr_quadrature_unary \
<details::binder_second <FUNCTOR,Expr2>, Expr1> \
(details::binder_second <FUNCTOR,Expr2> (FUNCTOR(), expr2), expr1); \
}
#define _RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant(FUNCTION,FUNCTOR) \
_RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_left (FUNCTION,FUNCTOR) \
_RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_right (FUNCTION,FUNCTOR)
_RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant (operator*, details::multiplies)
_RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_right (operator/, details::divides)
#undef _RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_right
#undef _RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_left
#undef _RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant
#ifdef TODO
#endif // TODO
} // namespace rheolef
#endif // _RHEOLEF_FORM_EXPR_QUADRATURE_H
gh
field gh(Float epsilon, Float t, const field &uh, const test &v)
Definition burgers_diffusion_operators.icc:37
rheolef::band_basic
Definition band.h:95
rheolef::details::form_expr_quadrature_binary
Definition form_expr_quadrature.h:507
rheolef::details::form_expr_quadrature_binary::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition form_expr_quadrature.h:572
rheolef::details::form_expr_quadrature_binary::initialize
void initialize(const band_basic< float_type, memory_type > &gh, const integrate_option &iopt)
Definition form_expr_quadrature.h:566
rheolef::details::form_expr_quadrature_binary::geo_type
geo_basic< float_type, memory_type > geo_type
Definition form_expr_quadrature.h:524
rheolef::details::form_expr_quadrature_binary::_expr1
Expr1 _expr1
Definition form_expr_quadrature.h:602
rheolef::details::form_expr_quadrature_binary::valued_check
bool valued_check() const
Definition form_expr_quadrature.h:591
rheolef::details::form_expr_quadrature_binary::_expr2
Expr2 _expr2
Definition form_expr_quadrature.h:603
rheolef::details::form_expr_quadrature_binary::get_test_space
const space_type & get_test_space() const
Definition form_expr_quadrature.h:557
rheolef::details::form_expr_quadrature_binary::maybe_symmetric
and_type< typenameExpr1::maybe_symmetric::type, typenameExpr2::maybe_symmetric::type >::type maybe_symmetric
Definition form_expr_quadrature.h:536
rheolef::details::form_expr_quadrature_binary::form_expr_quadrature_binary
form_expr_quadrature_binary(const BinaryFunction &f, const Expr1 &expr1, const Expr2 &expr2)
Definition form_expr_quadrature.h:549
rheolef::details::form_expr_quadrature_binary::space_type
space_basic< float_type, memory_type > space_type
Definition form_expr_quadrature.h:523
rheolef::details::form_expr_quadrature_binary::result_hint
details::generic_binary_traits< BinaryFunction >::template result_hint< typenameExpr1::value_type, typenameExpr2::value_type >::type result_hint
Definition form_expr_quadrature.h:516
rheolef::details::form_expr_quadrature_binary::initialize
void initialize(const geo_basic< float_type, memory_type > &omega_K, const integrate_option &iopt)
Definition form_expr_quadrature.h:561
rheolef::details::form_expr_quadrature_binary::self_type
form_expr_quadrature_binary< BinaryFunction, Expr1, Expr2 > self_type
Definition form_expr_quadrature.h:530
rheolef::details::form_expr_quadrature_binary::vf_tag_type
details::bf_vf_tag< BinaryFunction, typenameExpr1::vf_tag_type, typenameExpr2::vf_tag_type >::type vf_tag_type
Definition form_expr_quadrature.h:527
rheolef::details::form_expr_quadrature_binary::dual_self_type
form_expr_quadrature_binary< BinaryFunction, typename Expr1::dual_self_type, typename Expr2::dual_self_type > dual_self_type
Definition form_expr_quadrature.h:533
rheolef::details::form_expr_quadrature_binary::valued_hint
static const space_constant::valued_type valued_hint
Definition form_expr_quadrature.h:538
rheolef::details::form_expr_quadrature_binary::n_derivative
size_type n_derivative() const
Definition form_expr_quadrature.h:558
rheolef::details::form_expr_quadrature_binary::vf_dual_tag_type
details::dual_vf_tag< vf_tag_type >::type vf_dual_tag_type
Definition form_expr_quadrature.h:529
rheolef::details::form_expr_quadrature_binary::_f
BinaryFunction _f
Definition form_expr_quadrature.h:601
rheolef::details::form_expr_quadrature_binary::scalar_type
scalar_traits< value_type >::type scalar_type
Definition form_expr_quadrature.h:521
rheolef::details::form_expr_quadrature_binary::value_type
details::generic_binary_traits< BinaryFunction >::template hint< typenameExpr1::value_type, typenameExpr2::value_type, result_hint >::result_type value_type
Definition form_expr_quadrature.h:520
rheolef::details::form_expr_quadrature_binary::memory_type
promote_memory< typenameExpr1::memory_type, typenameExpr2::memory_type >::type memory_type
Definition form_expr_quadrature.h:513
rheolef::details::form_expr_quadrature_binary::get_trial_space
const space_type & get_trial_space() const
Definition form_expr_quadrature.h:556
rheolef::details::form_expr_quadrature_binary::float_type
float_traits< value_type >::type float_type
Definition form_expr_quadrature.h:522
rheolef::details::form_expr_quadrature_binary::size_type
geo_element::size_type size_type
Definition form_expr_quadrature.h:511
rheolef::details::form_expr_quadrature_on_element
Definition form_expr_quadrature.h:113
rheolef::details::form_expr_quadrature_on_element::geo_type
geo_basic< float_type, memory_type > geo_type
Definition form_expr_quadrature.h:124
rheolef::details::form_expr_quadrature_on_element::valued_check
bool valued_check() const
Definition form_expr_quadrature.h:158
rheolef::details::form_expr_quadrature_on_element::get_test_space
const space_type & get_test_space() const
Definition form_expr_quadrature.h:148
rheolef::details::form_expr_quadrature_on_element::space_type
space_basic< float_type, memory_type > space_type
Definition form_expr_quadrature.h:123
rheolef::details::form_expr_quadrature_on_element::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &ak) const
Definition form_expr_quadrature.h:210
rheolef::details::form_expr_quadrature_on_element::form_expr_quadrature_on_element
form_expr_quadrature_on_element(const Expr &expr)
Definition form_expr_quadrature.h:179
rheolef::details::form_expr_quadrature_on_element::initialize
void initialize(const geo_basic< float_type, memory_type > &omega_K, const integrate_option &iopt)
Definition form_expr_quadrature.h:187
rheolef::details::form_expr_quadrature_on_element::maybe_symmetric
Expr::maybe_symmetric::type maybe_symmetric
Definition form_expr_quadrature.h:131
rheolef::details::form_expr_quadrature_on_element::valued_hint
static const space_constant::valued_type valued_hint
Definition form_expr_quadrature.h:133
rheolef::details::form_expr_quadrature_on_element::n_derivative
size_type n_derivative() const
Definition form_expr_quadrature.h:149
rheolef::details::form_expr_quadrature_on_element::vf_dual_tag_type
details::dual_vf_tag< vf_tag_type >::type vf_dual_tag_type
Definition form_expr_quadrature.h:127
rheolef::details::form_expr_quadrature_on_element::_expr
Expr _expr
Definition form_expr_quadrature.h:165
rheolef::details::form_expr_quadrature_on_element::self_type
form_expr_quadrature_on_element< Expr > self_type
Definition form_expr_quadrature.h:128
rheolef::details::form_expr_quadrature_on_element::scalar_type
scalar_traits< value_type >::type scalar_type
Definition form_expr_quadrature.h:121
rheolef::details::form_expr_quadrature_on_element::value_type
Expr::value_type value_type
Definition form_expr_quadrature.h:120
rheolef::details::form_expr_quadrature_on_element::memory_type
Expr::memory_type memory_type
Definition form_expr_quadrature.h:118
rheolef::details::form_expr_quadrature_on_element::dual_self_type
form_expr_quadrature_on_element< typename Expr::dual_self_type > dual_self_type
Definition form_expr_quadrature.h:130
rheolef::details::form_expr_quadrature_on_element::get_trial_space
const space_type & get_trial_space() const
Definition form_expr_quadrature.h:147
rheolef::details::form_expr_quadrature_on_element::result_hint
Expr::value_type result_hint
Definition form_expr_quadrature.h:119
rheolef::details::form_expr_quadrature_on_element::_pops
piola_on_pointset< float_type > _pops
Definition form_expr_quadrature.h:166
rheolef::details::form_expr_quadrature_on_element::_value_i
Eigen::Tensor< float_type, 3 > _value_i
Definition form_expr_quadrature.h:169
rheolef::details::form_expr_quadrature_on_element::vf_tag_type
Expr::vf_tag_type vf_tag_type
Definition form_expr_quadrature.h:125
rheolef::details::form_expr_quadrature_on_element::float_type
float_traits< value_type >::type float_type
Definition form_expr_quadrature.h:122
rheolef::details::form_expr_quadrature_on_element::size_type
geo_element::size_type size_type
Definition form_expr_quadrature.h:117
rheolef::details::form_expr_quadrature_on_sides
Definition form_expr_quadrature.h:241
rheolef::details::form_expr_quadrature_on_sides::geo_type
geo_basic< float_type, memory_type > geo_type
Definition form_expr_quadrature.h:252
rheolef::details::form_expr_quadrature_on_sides::_ignore_sys_coord
bool _ignore_sys_coord
Definition form_expr_quadrature.h:295
rheolef::details::form_expr_quadrature_on_sides::valued_check
bool valued_check() const
Definition form_expr_quadrature.h:286
rheolef::details::form_expr_quadrature_on_sides::get_test_space
const space_type & get_test_space() const
Definition form_expr_quadrature.h:271
rheolef::details::form_expr_quadrature_on_sides::space_type
space_basic< float_type, memory_type > space_type
Definition form_expr_quadrature.h:251
rheolef::details::form_expr_quadrature_on_sides::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &ak) const
Definition form_expr_quadrature.h:345
rheolef::details::form_expr_quadrature_on_sides::initialize
void initialize(const geo_basic< float_type, memory_type > &omega_K, const integrate_option &iopt)
Definition form_expr_quadrature.h:321
rheolef::details::form_expr_quadrature_on_sides::_dis_inod_S
std::vector< size_type > _dis_inod_S
Definition form_expr_quadrature.h:298
rheolef::details::form_expr_quadrature_on_sides::maybe_symmetric
Expr::maybe_symmetric::type maybe_symmetric
Definition form_expr_quadrature.h:259
rheolef::details::form_expr_quadrature_on_sides::valued_hint
static const space_constant::valued_type valued_hint
Definition form_expr_quadrature.h:261
rheolef::details::form_expr_quadrature_on_sides::n_derivative
size_type n_derivative() const
Definition form_expr_quadrature.h:272
rheolef::details::form_expr_quadrature_on_sides::vf_dual_tag_type
details::dual_vf_tag< vf_tag_type >::type vf_dual_tag_type
Definition form_expr_quadrature.h:255
rheolef::details::form_expr_quadrature_on_sides::_expr
Expr _expr
Definition form_expr_quadrature.h:293
rheolef::details::form_expr_quadrature_on_sides::form_expr_quadrature_on_sides
form_expr_quadrature_on_sides(const Expr &expr)
Definition form_expr_quadrature.h:310
rheolef::details::form_expr_quadrature_on_sides::_DF
tensor_basic< float_type > _DF
Definition form_expr_quadrature.h:299
rheolef::details::form_expr_quadrature_on_sides::self_type
form_expr_quadrature_on_element< Expr > self_type
Definition form_expr_quadrature.h:256
rheolef::details::form_expr_quadrature_on_sides::scalar_type
scalar_traits< value_type >::type scalar_type
Definition form_expr_quadrature.h:249
rheolef::details::form_expr_quadrature_on_sides::value_type
Expr::value_type value_type
Definition form_expr_quadrature.h:248
rheolef::details::form_expr_quadrature_on_sides::memory_type
Expr::memory_type memory_type
Definition form_expr_quadrature.h:246
rheolef::details::form_expr_quadrature_on_sides::dual_self_type
form_expr_quadrature_on_element< typename Expr::dual_self_type > dual_self_type
Definition form_expr_quadrature.h:258
rheolef::details::form_expr_quadrature_on_sides::get_trial_space
const space_type & get_trial_space() const
Definition form_expr_quadrature.h:270
rheolef::details::form_expr_quadrature_on_sides::result_hint
Expr::value_type result_hint
Definition form_expr_quadrature.h:247
rheolef::details::form_expr_quadrature_on_sides::_pops
piola_on_pointset< float_type > _pops
Definition form_expr_quadrature.h:294
rheolef::details::form_expr_quadrature_on_sides::_value_i
Eigen::Tensor< float_type, 3 > _value_i
Definition form_expr_quadrature.h:297
rheolef::details::form_expr_quadrature_on_sides::vf_tag_type
Expr::vf_tag_type vf_tag_type
Definition form_expr_quadrature.h:253
rheolef::details::form_expr_quadrature_on_sides::float_type
float_traits< value_type >::type float_type
Definition form_expr_quadrature.h:250
rheolef::details::form_expr_quadrature_on_sides::size_type
geo_element::size_type size_type
Definition form_expr_quadrature.h:245
rheolef::details::form_expr_quadrature_unary
Definition form_expr_quadrature.h:401
rheolef::details::form_expr_quadrature_unary::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition form_expr_quadrature.h:446
rheolef::details::form_expr_quadrature_unary::initialize
void initialize(const band_basic< float_type, memory_type > &gh, const integrate_option &iopt)
Definition form_expr_quadrature.h:442
rheolef::details::form_expr_quadrature_unary::geo_type
geo_basic< float_type, memory_type > geo_type
Definition form_expr_quadrature.h:415
rheolef::details::form_expr_quadrature_unary::valued_check
bool valued_check() const
Definition form_expr_quadrature.h:459
rheolef::details::form_expr_quadrature_unary::get_test_space
const space_type & get_test_space() const
Definition form_expr_quadrature.h:435
rheolef::details::form_expr_quadrature_unary::_f
UnaryFunction _f
Definition form_expr_quadrature.h:466
rheolef::details::form_expr_quadrature_unary::space_type
space_basic< float_type, memory_type > space_type
Definition form_expr_quadrature.h:414
rheolef::details::form_expr_quadrature_unary::value_type
details::generic_unary_traits< UnaryFunction >::template hint< typenameExpr::value_type, result_hint >::result_type value_type
Definition form_expr_quadrature.h:411
rheolef::details::form_expr_quadrature_unary::form_expr_quadrature_unary
form_expr_quadrature_unary(const UnaryFunction &f, const Expr &expr)
Definition form_expr_quadrature.h:429
rheolef::details::form_expr_quadrature_unary::initialize
void initialize(const geo_basic< float_type, memory_type > &omega_K, const integrate_option &iopt)
Definition form_expr_quadrature.h:440
rheolef::details::form_expr_quadrature_unary::maybe_symmetric
Expr::maybe_symmetric::type maybe_symmetric
Definition form_expr_quadrature.h:422
rheolef::details::form_expr_quadrature_unary::result_hint
details::generic_unary_traits< UnaryFunction >::template result_hint< typenameExpr::value_type >::type result_hint
Definition form_expr_quadrature.h:408
rheolef::details::form_expr_quadrature_unary::valued_hint
static const space_constant::valued_type valued_hint
Definition form_expr_quadrature.h:424
rheolef::details::form_expr_quadrature_unary::n_derivative
size_type n_derivative() const
Definition form_expr_quadrature.h:436
rheolef::details::form_expr_quadrature_unary::vf_dual_tag_type
details::dual_vf_tag< vf_tag_type >::type vf_dual_tag_type
Definition form_expr_quadrature.h:418
rheolef::details::form_expr_quadrature_unary::self_type
form_expr_quadrature_unary< UnaryFunction, Expr > self_type
Definition form_expr_quadrature.h:419
rheolef::details::form_expr_quadrature_unary::_expr
Expr _expr
Definition form_expr_quadrature.h:467
rheolef::details::form_expr_quadrature_unary::scalar_type
scalar_traits< value_type >::type scalar_type
Definition form_expr_quadrature.h:412
rheolef::details::form_expr_quadrature_unary::memory_type
Expr::memory_type memory_type
Definition form_expr_quadrature.h:406
rheolef::details::form_expr_quadrature_unary::dual_self_type
form_expr_quadrature_unary< UnaryFunction, typename Expr::dual_self_type > dual_self_type
Definition form_expr_quadrature.h:421
rheolef::details::form_expr_quadrature_unary::get_trial_space
const space_type & get_trial_space() const
Definition form_expr_quadrature.h:434
rheolef::details::form_expr_quadrature_unary::vf_tag_type
Expr::vf_tag_type vf_tag_type
Definition form_expr_quadrature.h:416
rheolef::details::form_expr_quadrature_unary::float_type
float_traits< value_type >::type float_type
Definition form_expr_quadrature.h:413
rheolef::details::form_expr_quadrature_unary::size_type
geo_element::size_type size_type
Definition form_expr_quadrature.h:405
rheolef::geo_basic
generic mesh with rerefence counting
Definition geo.h:1089
rheolef::geo_element
see the geo_element page for the full documentation
Definition geo_element.h:102
rheolef::geo_element::edge
size_type edge(size_type i) const
Definition geo_element.h:209
rheolef::geo_element::face
size_type face(size_type i) const
Definition geo_element.h:210
rheolef::geo_element::size_type
reference_element::size_type size_type
Definition geo_element.h:125
rheolef::geo_element::dimension
size_type dimension() const
Definition geo_element.h:167
rheolef::geo_element::get_side_informations
orientation_type get_side_informations(const geo_element &S, size_type &loc_isid, size_type &shift) const
Definition geo_element.cc:185
rheolef::geo_element::n_subgeo
size_type n_subgeo(size_type subgeo_dim) const
Definition geo_element.h:212
rheolef::integrate_option
see the integrate_option page for the full documentation
Definition integrate_option.h:125
rheolef::integrate_option::_is_inside_on_local_sides
bool _is_inside_on_local_sides
Definition integrate_option.h:180
rheolef::integrate_option::ignore_sys_coord
bool ignore_sys_coord
Definition integrate_option.h:168
rheolef::piola_on_pointset
Definition piola_on_pointset.h:142
rheolef::quadrature
Definition quadrature.h:186
rheolef::space_basic
the finite element space
Definition space.h:382
rheolef::tensor_basic
Definition tensor.h:90
fatal_macro
#define fatal_macro(message)
Definition dis_macros.h:33
_RHEOLEF_form_expr_quadrature_binary
#define _RHEOLEF_form_expr_quadrature_binary(FUNCTION, FUNCTOR)
Definition form_expr_quadrature.h:616
_RHEOLEF_make_form_expr_quadrature_unary
#define _RHEOLEF_make_form_expr_quadrature_unary(FUNCTION, FUNCTOR)
Definition form_expr_quadrature.h:476
_RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_right
#define _RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant_right(FUNCTION, FUNCTOR)
Definition form_expr_quadrature.h:728
_RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant
#define _RHEOLEF_make_form_expr_quadrature_binary_operator_multiplies_divides_constant(FUNCTION, FUNCTOR)
Definition form_expr_quadrature.h:746
rheolef::details::expr_quadrature_init_iopt
integrate_option expr_quadrature_init_iopt(const geo_basic< T, M > &omega_K, const space_basic< T, M > &X, size_t n_derivative, const integrate_option &iopt)
Definition init_expr_quadrature.h:36
rheolef::space_constant::valued_type
valued_type
Definition space_constant.h:133
rheolef
This file is part of Rheolef.
Definition compiler_eigen.h:39
rheolef::on_local_sides
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value, details::field_expr_quadrature_on_sides< Expr > >::type on_local_sides(const Expr &expr)
on_local_sides(expr): see the expression page for the full documentation
Definition field_expr_quadrature.h:323
std
STL namespace.
f
Definition cavity_dg.h:29
rheolef::details::and_type
Definition field_expr_utilities.h:77
rheolef::details::bf_vf_tag
Definition field_expr_variational_tag.h:74
rheolef::details::divides
Definition expression.h:1272
rheolef::details::generic_binary_traits
Definition expression.h:407
rheolef::details::generic_unary_traits
Definition expression.h:188
rheolef::details::is_form_expr_quadrature_arg
Definition form_expr_quadrature.h:101
rheolef::details::is_form_expr_quadrature_binary_multiplies_divides_constant_left
Definition form_expr_quadrature.h:689
rheolef::details::is_form_expr_quadrature_binary_multiplies_divides_constant_right
Definition form_expr_quadrature.h:706
rheolef::details::is_form_expr_quadrature_on_side_arg
Definition form_expr_quadrature.h:102
rheolef::details::is_form_expr_v2_variational_arg
Definition form_expr_variational.h:58
rheolef::details::minus
Definition expression.h:544
rheolef::details::multiplies
Definition expression.h:746
rheolef::details::negate
Definition expression.h:231
rheolef::details::plus
Definition expression.h:457
rheolef::details::unary_plus
Definition expression.h:209
rheolef::details::vf_tag_nonlinear
Definition field_expr_variational_tag.h:49
rheolef::float_traits::type
T type
Definition Float.h:94
rheolef::is_undeterminated
Definition undeterminated.h:39
rheolef::scalar_traits::type
T type
Definition point.h:323
rheolef::side_information_type
Definition reference_element_face_transformation.h:37
rheolef::space_constant::valued_tag_traits
Definition space_constant.h:159
rheolef::undefined_memory_model
Definition communicator.h:61