field.h
Go to the documentation of this file.
# ifndef _RHEOLEF_FIELD_H
# define _RHEOLEF_FIELD_H
//
// This file is part of Rheolef.
//
// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
//
// Rheolef is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Rheolef is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rheolef; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// =========================================================================
// AUTHOR: Pierre.Saramito@imag.fr
// DATE: 23 february 2011
namespace rheolef {
} // namespace rheolef
#include "rheolef/linalg.h"
#include "rheolef/space.h"
#include "rheolef/undeterminated.h"
#include "rheolef/misc_algo.h" // copy_n
#include "rheolef/quadrature.h"
#include "rheolef/integrate_option.h"
namespace rheolef {
// forward declaration:
template <class T, class M> class field_indirect;
template <class T, class M> class field_indirect_const;
template <class T, class M> class field_component;
template <class T, class M> class field_component_const;
template <class T, class M> class band_basic;
namespace details {
template <class T, class M> class field_concat_value;
} // namespace details
namespace details {
// Define a trait type for constants
template <class Value>
struct is_field_expr_v2_constant
: or_type<
is_rheolef_arithmetic<Value>
,is_point<Value>
,is_tensor<Value>
,is_tensor3<Value>
,is_tensor4<Value>
>
{};
// Define traits for field_expressions:
template <class Expr> struct is_field;
template<class T, class Sfinae = void> struct is_field_expr_affine_homogeneous: std::false_type {};
} // namespace details
// [verbatim_field_basic]
template <class T, class M = rheo_default_memory_model>
class field_basic {
public :
// typedefs:
using size_type = std::size_t;
using memory_type = M;
using value_type = T; // TODO: run-time dependent
using result_type = T; // TODO: run-time dependent
// using value_type = undeterminated_basic<T>; // TODO
using scalar_type = T;
using float_type = typename float_traits<T>::type;
using valued_type = space_constant::valued_type;
using geo_type = geo_basic <float_type,M>;
using space_type = space_basic<float_type,M>;
using dis_reference = typename vec<T,M>::dis_reference;
class iterator;
class const_iterator;
// allocator/deallocator:
field_basic();
explicit field_basic (
const space_type& V,
const T& init_value = std::numeric_limits<T>::max());
void resize (
const space_type& V,
const T& init_value = std::numeric_limits<T>::max());
// expressions:
template <class Expr, class Sfinae =
typename std::enable_if<
details::is_field_expr_affine_homogeneous<Expr>::value
&& ! details::is_field<Expr>::value>::type>
field_basic (const Expr& expr);
// initializer list (c++ 2011):
field_basic (const std::initializer_list<details::field_concat_value<T,M> >& init_list);
// assignments:
field_basic<T,M>& operator= (const field_basic<T,M>&);
template <class Value>
typename std::enable_if<
details::is_rheolef_arithmetic<Value>::value
,field_basic<T,M>&
>::type
operator= (const Value& value);
template <class Expr>
typename std::enable_if<
details::is_field_expr_affine_homogeneous<Expr>::value
&& ! details::is_field_expr_v2_constant <Expr>::value
&& ! details::is_field <Expr>::value
,field_basic<T, M>&>::type
operator= (const Expr&);
// initializer list (c++ 2011):
field_basic<T,M>& operator= (const std::initializer_list<details::field_concat_value<T,M> >& init_list);
// accessors:
const space_type& get_space() const { return _V; }
const geo_type& get_geo() const { return _V.get_geo(); }
std::string name() const { return _V.name(); }
std::string get_approx() const { return _V.get_approx(); }
valued_type valued_tag() const { return _V.valued_tag(); }
const std::string& valued() const { return _V.valued(); }
bool have_homogeneous_space (space_basic<T,M>& Xh) const { Xh = get_space(); return true; }
// accessors & modifiers to unknown & blocked parts:
const vec<T,M>& u() const { return _u; }
const vec<T,M>& b() const { return _b; }
vec<T,M>& set_u() { dis_dof_indexes_requires_update(); return _u; }
vec<T,M>& set_b() { dis_dof_indexes_requires_update(); return _b; }
// accessors to extremas:
T min() const;
T max() const;
T max_abs() const;
T min_abs() const;
// accessors by domains:
field_indirect<T,M> operator[] (const geo_basic<T,M>& dom);
field_indirect_const<T,M> operator[] (const geo_basic<T,M>& dom) const;
field_indirect<T,M> operator[] (std::string dom_name);
field_indirect_const<T,M> operator[] (std::string dom_name) const;
// accessors by components:
size_type size() const { return _V.size(); }
field_component<T,M> operator[] (size_type i_comp);
field_component_const<T,M> operator[] (size_type i_comp) const;
field_component<T,M> operator() (size_type i_comp, size_type j_comp);
field_component_const<T,M> operator() (size_type i_comp, size_type j_comp) const;
// accessors by degrees-of-freedom (dof):
const distributor& ownership() const { return get_space().ownership(); }
const communicator& comm() const { return ownership().comm(); }
size_type ndof() const { return ownership().size(); }
size_type dis_ndof() const { return ownership().dis_size(); }
T& dof (size_type idof);
const T& dof (size_type idof) const;
const T& dis_dof (size_type dis_idof) const;
// write access to non-local dis_idof changes to others procs
dis_reference dis_dof_entry (size_type dis_idof);
iterator begin_dof();
iterator end_dof();
const_iterator begin_dof() const;
const_iterator end_dof() const;
// input/output:
idiststream& get (idiststream& ips);
odiststream& put (odiststream& ops) const;
odiststream& put_field (odiststream& ops) const;
// evaluate uh(x) where x is given locally as hat_x in K:
T dis_evaluate (const point_basic<T>& x, size_type i_comp = 0) const;
T operator() (const point_basic<T>& x) const { return dis_evaluate (x,0); }
point_basic<T> dis_vector_evaluate (const point_basic<T>& x) const;
// [verbatim_field_basic]
// internals:
int constraint_process_rank() const { return u().constraint_process_rank(); }
public:
// evaluate uh(x) where x is given locally as hat_x in K:
// requiers to call field::dis_dof_upgrade() before.
T evaluate (const geo_element& K, const point_basic<T>& hat_xq, size_type i_comp = 0) const;
// propagate changed values shared at partition boundaries to others procs
void dis_dof_update() const;
// new interface
template <class Expr>
void assembly_internal (
const geo_basic<T,M>& dom,
const geo_basic<T,M>& band,
const band_basic<T,M>& gh,
const Expr& expr,
const integrate_option& qopt,
bool is_on_band);
template <class Expr>
void assembly (
const geo_basic<T,M>& dom,
const Expr& expr,
const integrate_option& iopt);
template <class Expr>
void assembly (
const band_basic<T,M>& gh,
const Expr& expr,
const integrate_option& iopt);
protected:
void dis_dof_indexes_requires_update() const;
void dis_dof_assembly_requires_update() const;
// data:
space_type _V;
mutable vec<T,M> _u;
mutable vec<T,M> _b;
mutable bool _dis_dof_indexes_requires_update;
mutable bool _dis_dof_assembly_requires_update;
// [verbatim_field_basic_cont]
};
// [verbatim_field_basic_cont]
template <class T, class M>
idiststream& operator >> (odiststream& ips, field_basic<T,M>& u);
template <class T, class M>
odiststream& operator << (odiststream& ops, const field_basic<T,M>& uh);
// [verbatim_field]
typedef field_basic<Float> field;
// [verbatim_field]
typedef field_basic<Float,sequential> field_sequential;
// =================================================================================
// field::iterator
// =================================================================================
template <class T, class M>
class field_basic<T,M>::iterator {
protected:
typedef typename vec<T,M>::iterator data_t; // random acess
typedef typename disarray<space_pair_type,M>::const_iterator iter_t; // forward access
public:
// typedefs:
typedef std::forward_iterator_tag iterator_category; // TODO: not fully random yet
typedef typename vec<T,M>::size_type size_type;
typedef T value_type;
typedef T& reference;
typedef T* pointer;
typedef std::ptrdiff_t difference_type;
// allocators:
iterator ()
: _blk_dis_iub_iter(),
_blk_dis_iub_incr(1),
_u(),
_b(),
_first_iu(0),
_first_ib(0)
{}
iterator (iter_t blk_dis_iub_iter, data_t u, data_t b, size_type first_iu, size_type first_ib)
: _blk_dis_iub_iter(blk_dis_iub_iter),
_blk_dis_iub_incr(1),
_u(u),
_b(b),
_first_iu(first_iu),
_first_ib(first_ib)
{}
iterator (iter_t blk_dis_iub_iter, size_type blk_dis_iub_incr, data_t u, data_t b, size_type first_iu, size_type first_ib)
: _blk_dis_iub_iter(blk_dis_iub_iter),
_blk_dis_iub_incr(blk_dis_iub_incr),
_u(u),
_b(b),
_first_iu(first_iu),
_first_ib(first_ib)
{}
void set_increment (size_type incr) { _blk_dis_iub_incr = incr; }
// accessors & modifiers:
reference operator* () const {
bool blk = (*_blk_dis_iub_iter).is_blocked();
size_type dis_iub = (*_blk_dis_iub_iter).dis_iub();
size_type iub = (!blk) ? dis_iub - _first_iu : dis_iub - _first_ib;
return (!blk) ? _u[iub] : _b[iub];
}
iterator& operator++ () { _blk_dis_iub_iter += _blk_dis_iub_incr; return *this; }
iterator operator++ (int) { iterator tmp = *this; operator++(); return *this; }
iterator& operator+= (difference_type n) { _blk_dis_iub_iter += n*_blk_dis_iub_incr; return *this; }
iterator operator+ (difference_type n) const { iterator tmp = *this; return tmp += n; }
reference operator[] (size_type n) const { return *(*this + n); }
// comparators:
bool operator== (const iterator& j) const { return _blk_dis_iub_iter == j._blk_dis_iub_iter; }
bool operator!= (const iterator& j) const { return ! operator== (j); }
//protected:
friend class const_iterator;
// data:
iter_t _blk_dis_iub_iter;
size_type _blk_dis_iub_incr;
data_t _u;
data_t _b;
size_type _first_iu, _first_ib;
};
template <class T, class M>
inline
typename field_basic<T,M>::iterator
field_basic<T,M>::begin_dof ()
{
dis_dof_indexes_requires_update();
return iterator (_V.data()._idof2blk_dis_iub.begin(), _u.begin(), _b.begin(), _u.ownership().first_index(), _b.ownership().first_index());
}
template <class T, class M>
inline
typename field_basic<T,M>::iterator
field_basic<T,M>::end_dof ()
{
dis_dof_indexes_requires_update();
return iterator (_V.data()._idof2blk_dis_iub.end(), _u.begin(), _b.begin(), _u.ownership().first_index(), _b.ownership().first_index());
}
// =================================================================================
// field::const_iterator
// =================================================================================
template <class T, class M>
class field_basic<T,M>::const_iterator {
protected:
typedef typename vec<T,M>::const_iterator data_t;
typedef typename disarray<space_pair_type,M>::const_iterator iter_t;
public:
// typedefs:
typedef std::forward_iterator_tag iterator_category;
typedef typename vec<T,M>::size_type size_type;
typedef T value_type;
typedef const T& reference;
typedef const T* pointer;
typedef std::ptrdiff_t difference_type;
// allocators:
const_iterator ()
: _blk_dis_iub_iter(),
_blk_dis_iub_incr(1),
_u(),
_b(),
_first_iu(0),
_first_ib(0)
{}
const_iterator (iter_t blk_dis_iub_iter, data_t u, data_t b, size_type first_iu, size_type first_ib)
: _blk_dis_iub_iter(blk_dis_iub_iter),
_blk_dis_iub_incr(1),
_u(u), _b(b),
_first_iu(first_iu),
_first_ib(first_ib)
{}
const_iterator (iterator i)
: _blk_dis_iub_iter(i._blk_dis_iub_iter),
_blk_dis_iub_incr(i._blk_dis_iub_incr),
_u(i._u),
_b(i._b),
_first_iu(i._first_iu),
_first_ib(i._first_ib)
{}
void set_increment (size_type incr) { _blk_dis_iub_incr = incr; }
// accessors & modifiers:
reference operator* () const {
bool blk = (*_blk_dis_iub_iter).is_blocked();
size_type dis_iub = (*_blk_dis_iub_iter).dis_iub();
size_type iub = (!blk) ? dis_iub - _first_iu : dis_iub - _first_ib;
return (!blk) ? _u[iub] : _b[iub];
}
const_iterator& operator++ () { _blk_dis_iub_iter += _blk_dis_iub_incr; return *this; }
const_iterator operator++ (int) { const_iterator tmp = *this; operator++(); return *this; }
const_iterator& operator+= (difference_type n) { _blk_dis_iub_iter += n*_blk_dis_iub_incr; return *this; }
const_iterator operator+ (difference_type n) const { const_iterator tmp = *this; return tmp += n; }
reference operator[] (size_type n) const { return *(*this + n); }
// comparators:
bool operator== (const const_iterator& j) const { return _blk_dis_iub_iter == j._blk_dis_iub_iter; }
bool operator!= (const const_iterator& j) const { return ! operator== (j); }
//protected:
// data:
iter_t _blk_dis_iub_iter;
size_type _blk_dis_iub_incr;
data_t _u;
data_t _b;
size_type _first_iu, _first_ib;
};
template <class T, class M>
inline
typename field_basic<T,M>::const_iterator
field_basic<T,M>::begin_dof () const
{
dis_dof_indexes_requires_update();
return const_iterator (_V.data()._idof2blk_dis_iub.begin(), _u.begin(), _b.begin(), _u.ownership().first_index(), _b.ownership().first_index());
}
template <class T, class M>
inline
typename field_basic<T,M>::const_iterator
field_basic<T,M>::end_dof () const
{
dis_dof_indexes_requires_update();
return const_iterator (_V.data()._idof2blk_dis_iub.end(), _u.begin(), _b.begin(), _u.ownership().first_index(), _b.ownership().first_index());
}
// =================================================================================
// field: inlined
// =================================================================================
template <class T, class M>
inline
field_basic<T,M>::field_basic ()
: _V(),
_u(),
_b(),
_dis_dof_indexes_requires_update(true),
_dis_dof_assembly_requires_update(false)
{
}
template <class T, class M>
inline
field_basic<T,M>&
field_basic<T,M>::operator= (const field_basic<T,M>& x)
{
_V.operator= (x._V);
_u.operator= (x._u);
_b.operator= (x._b);
_dis_dof_indexes_requires_update = x._dis_dof_indexes_requires_update;
_dis_dof_assembly_requires_update = x._dis_dof_assembly_requires_update;
return *this;
}
template <class T, class M>
void
field_basic<T,M>::dis_dof_indexes_requires_update() const
{
_dis_dof_indexes_requires_update = true;
}
template <class T, class M>
void
field_basic<T,M>::dis_dof_assembly_requires_update() const
{
_dis_dof_assembly_requires_update = true;
}
// TODO: DVT_EXPR_CTE_VEC : value as point or tensor
template<class T, class M>
template <class Value>
inline
typename std::enable_if<
details::is_rheolef_arithmetic<Value>::value
,field_basic<T,M>&
>::type
field_basic<T,M>::operator= (const Value& value)
{
check_macro (name() != "", "field=constant : uninitialized field in affectation");
std::fill (begin_dof(), end_dof(), value);
dis_dof_indexes_requires_update();
return *this;
}
template <class T, class M>
inline
T&
field_basic<T,M>::dof (size_type idof)
{
dis_dof_indexes_requires_update();
bool blk = _V.is_blocked (idof);
size_type dis_iub = _V.dis_iub (idof);
if (!blk) {
size_type iub = dis_iub - _u.ownership().first_index();
return _u [iub];
} else {
size_type iub = dis_iub - _b.ownership().first_index();
return _b [iub];
}
}
template <class T, class M>
inline
const T&
field_basic<T,M>::dof (size_type idof) const
{
bool blk = _V.is_blocked (idof);
size_type dis_iub = _V.dis_iub (idof);
return (!blk) ? _u.dis_at(dis_iub) : _b.dis_at(dis_iub);
}
template <class T, class M>
inline
T
field_basic<T,M>::min () const
{
T val = std::numeric_limits<T>::max();
for (const_iterator iter = begin_dof(), last = end_dof(); iter != last; iter++) {
val = std::min(val, *iter);
}
#ifdef _RHEOLEF_HAVE_MPI
if (is_distributed<M>::value) {
val = mpi::all_reduce (comm(), val, mpi::minimum<T>());
}
#endif // _RHEOLEF_HAVE_MPI
return val;
}
template <class T, class M>
inline
T
field_basic<T,M>::max () const
{
T val = std::numeric_limits<T>::min();
for (const_iterator iter = begin_dof(), last = end_dof(); iter != last; iter++) {
val = std::max(val, *iter);
}
#ifdef _RHEOLEF_HAVE_MPI
if (is_distributed<M>::value) {
val = mpi::all_reduce (comm(), val, mpi::maximum<T>());
}
#endif // _RHEOLEF_HAVE_MPI
return val;
}
template <class T, class M>
inline
T
field_basic<T,M>::min_abs () const
{
T val = std::numeric_limits<T>::max();
for (const_iterator iter = begin_dof(), last = end_dof(); iter != last; iter++) {
val = std::min(val, abs(*iter));
}
#ifdef _RHEOLEF_HAVE_MPI
if (is_distributed<M>::value) {
val = mpi::all_reduce (comm(), val, mpi::minimum<T>());
}
#endif // _RHEOLEF_HAVE_MPI
return val;
}
template <class T, class M>
inline
T
field_basic<T,M>::max_abs () const
{
T val = 0;
for (const_iterator iter = begin_dof(), last = end_dof(); iter != last; iter++) {
val = std::max(val, abs(*iter));
}
#ifdef _RHEOLEF_HAVE_MPI
if (is_distributed<M>::value) {
val = mpi::all_reduce (comm(), val, mpi::maximum<T>());
}
#endif // _RHEOLEF_HAVE_MPI
return val;
}
template <class T, class M>
inline
idiststream&
operator >> (idiststream& ips, field_basic<T,M>& uh)
{
return uh.get (ips);
}
template <class T, class M>
inline
odiststream&
operator << (odiststream& ops, const field_basic<T,M>& uh)
{
return uh.put (ops);
}
}// namespace rheolef
# endif /* _RHEOLEF_FIELD_H */
rheolef::geo_basic
generic mesh with rerefence counting
Definition: domain_indirect.h:64
rheolef::field_basic::const_iterator::difference_type
std::ptrdiff_t difference_type
Definition: field.h:531
rheolef::field_basic::iterator
Definition: field.h:427
rheolef::field_basic::get_space
const space_type & get_space() const
Definition: field.h:300
rheolef::operator!=
bool operator!=(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition: heap_allocator.h:172
rheolef::field_basic::get_approx
std::string get_approx() const
Definition: field.h:303
rheolef::field_basic::iterator::size_type
vec< T, M >::size_type size_type
Definition: field.h:436
rheolef::operator+=
std::enable_if< details::is_rheolef_arithmetic< U >::value,ad3_basic< T > & >::type operator+=(ad3_basic< T > &a, const U &b)
Definition: ad3.h:286
rheolef::field_basic::ownership
const distributor & ownership() const
Definition: field.h:339
rheolef::field_basic::assembly
void assembly(const geo_basic< T, M > &dom, const Expr &expr, const integrate_option &iopt)
Definition: field_vf_assembly.h:170
rheolef::begin_dof
const_iterator begin_dof() const
Definition: field_expr_recursive.h:569
rheolef::field_basic::iterator::iter_t
disarray< space_pair_type, M >::const_iterator iter_t
Definition: field.h:430
gh
field gh(Float epsilon, Float t, const field &uh, const test &v)
Definition: burgers_diffusion_operators.icc:37
rheolef::field_basic::const_iterator::const_iterator
const_iterator(iter_t blk_dis_iub_iter, data_t u, data_t b, size_type first_iu, size_type first_ib)
Definition: field.h:543
mkgeo_ball.expr
expr
Definition: mkgeo_ball.sh:361
rheolef::point_basic
Definition: point.h:87
rheolef::details::or_type
Definition: field_expr_utilities.h:58
rheolef::field_basic::dis_vector_evaluate
point_basic< T > dis_vector_evaluate(const point_basic< T > &x) const
Definition: field.cc:490
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::field_basic::comm
const communicator & comm() const
Definition: field.h:340
rheolef::distributor::comm
const communicator_type & comm() const
Definition: distributor.h:145
rheolef::vec::const_iterator
base::const_iterator const_iterator
Definition: vec.h:92
rheolef::field_basic::const_iterator::size_type
vec< T, M >::size_type size_type
Definition: field.h:527
rheolef::field
field_basic< Float > field
see the field page for the full documentation
Definition: field.h:419
rheolef::field_basic::iterator::_u
data_t _u
Definition: field.h:494
rheolef::details::is_field_expr_affine_homogeneous
Definition: field.h:229
rheolef::operator*
csr< T, sequential > operator*(const T &lambda, const csr< T, sequential > &a)
Definition: csr.h:437
rheolef::value
rheolef::std value
rheolef::field_component_const
Definition: field.h:207
rheolef::field_basic::evaluate
T evaluate(const geo_element &K, const point_basic< T > &hat_xq, size_type i_comp=0) const
Definition: field.cc:435
rheolef::field_basic::_dis_dof_indexes_requires_update
bool _dis_dof_indexes_requires_update
Definition: field.h:406
rheolef::field_basic< T, rheo_default_memory_model >::float_type
typename float_traits< T >::type float_type
Definition: field.h:245
rheolef::field_basic::iterator::iterator
iterator(iter_t blk_dis_iub_iter, size_type blk_dis_iub_incr, data_t u, data_t b, size_type first_iu, size_type first_ib)
Definition: field.h:460
rheolef::field_basic::iterator::iterator
iterator()
Definition: field.h:444
rheolef::field_basic::ndof
size_type ndof() const
Definition: field.h:341
rheolef::space_basic< float_type, rheo_default_memory_model >
rheolef::distributor
see the distributor page for the full documentation
Definition: distributor.h:62
band
see the band page for the full documentation
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::field_basic::name
std::string name() const
Definition: field.h:302
rheolef::field_basic::min_abs
T min_abs() const
Definition: field.h:715
rheolef::field_basic::iterator::difference_type
std::ptrdiff_t difference_type
Definition: field.h:440
rheolef::space_constant::valued_type
valued_type
Definition: space_constant.h:135
rheolef::space_numbering::dis_idof
void dis_idof(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_idof_tab)
Definition: space_numbering.cc:187
rheolef::field_basic::const_iterator::set_increment
void set_increment(size_type incr)
Definition: field.h:559
rheolef::field_indirect_const
Definition: field.h:205
rheolef::field_basic< T, rheo_default_memory_model >::result_type
T result_type
Definition: field.h:242
rheolef::vec
see the vec page for the full documentation
Definition: vec.h:79
rheolef::field_basic::dis_dof
const T & dis_dof(size_type dis_idof) const
Definition: field.cc:376
rheolef::field_basic::iterator::set_increment
void set_increment(size_type incr)
Definition: field.h:469
rheolef::field_basic::u
const vec< T, M > & u() const
Definition: field.h:310
rheolef::is_distributed
Definition: distributed.h:36
rheolef::operator==
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition: heap_allocator.h:167
rheolef::field_basic::field_basic
field_basic()
Definition: field.h:608
rheolef::field_basic::dis_dof_entry
dis_reference dis_dof_entry(size_type dis_idof)
Definition: field.cc:397
rheolef::field_basic::iterator::_blk_dis_iub_iter
iter_t _blk_dis_iub_iter
Definition: field.h:492
rheolef::field_basic< T, rheo_default_memory_model >::value_type
T value_type
Definition: field.h:241
rheolef::field_basic::get_geo
const geo_type & get_geo() const
Definition: field.h:301
rheolef::field_basic::resize
void resize(const space_type &V, const T &init_value=std::numeric_limits< T >::max())
Definition: field.cc:48
rheolef::integrate_option
see the integrate_option page for the full documentation
Definition: integrate_option.h:125
rheolef::field_basic::const_iterator::value_type
T value_type
Definition: field.h:528
rheolef::field_basic::const_iterator::operator++
const_iterator operator++(int)
Definition: field.h:570
rheolef::field_basic::_V
space_type _V
Definition: field.h:403
rheolef::field_indirect
Definition: field.h:204
rheolef::field_basic::set_u
vec< T, M > & set_u()
Definition: field.h:312
rheolef::vec::iterator
base::iterator iterator
Definition: vec.h:91
rheolef::field_basic::set_b
vec< T, M > & set_b()
Definition: field.h:313
rheolef::field_basic::iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: field.h:435
rheolef::field_basic::iterator::iterator
iterator(iter_t blk_dis_iub_iter, data_t u, data_t b, size_type first_iu, size_type first_ib)
Definition: field.h:452
rheolef::field_basic::dis_dof_update
void dis_dof_update() const
Definition: field.cc:410
rheolef::operator>>
idiststream & operator>>(idiststream &ips, field_basic< T, M > &uh)
Definition: field.h:747
rheolef::field_basic::iterator::value_type
T value_type
Definition: field.h:437
rheolef::field_basic::valued_tag
valued_type valued_tag() const
Definition: field.h:304
rheolef::field_basic::min
T min() const
Definition: field.h:683
rheolef::field_basic::dis_dof_assembly_requires_update
void dis_dof_assembly_requires_update() const
Definition: field.h:636
operator<<
ostream & operator<<(ostream &os, const tiny_element &K)
Definition: tiny_element.cc:27
rheolef::type
rheolef::std type
rheolef::field_basic::max
T max() const
Definition: field.h:699
rheolef::field_basic
Definition: field_expr_utilities.h:38
rheolef::field_basic::dof
T & dof(size_type idof)
Definition: field.h:658
rheolef::field_basic::end_dof
iterator end_dof()
Definition: field.h:509
rheolef::field_basic::_b
vec< T, M > _b
Definition: field.h:405
rheolef::field_basic< T, rheo_default_memory_model >::scalar_type
T scalar_type
Definition: field.h:244
rheolef::field_basic::begin_dof
iterator begin_dof()
Definition: field.h:501
rheolef::field_basic::const_iterator::const_iterator
const_iterator(iterator i)
Definition: field.h:550
rheolef::field_component
Definition: field.h:206
rheolef::field_basic::const_iterator::_u
data_t _u
Definition: field.h:583
rheolef::details::is_field_expr_v2_constant
Definition: field.h:217
rheolef::field_basic::iterator::pointer
T * pointer
Definition: field.h:439
rheolef::field_basic::constraint_process_rank
int constraint_process_rank() const
Definition: field.h:368
rheolef::field_basic::iterator::reference
T & reference
Definition: field.h:438
rheolef::operator>>
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
rheolef::band_basic
Definition: band.h:95
rheolef::field_basic::const_iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: field.h:526
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::float_traits::type
T type
Definition: Float.h:94
rheolef::distributor::dis_size
size_type dis_size() const
global and local sizes
Definition: distributor.h:207
rheolef::field_basic::const_iterator::reference
const typedef T & reference
Definition: field.h:529
rheolef::details::max_abs
T max_abs(const T &x)
Definition: keller_details.h:47
u
Definition: leveque.h:25
rheolef::field_basic::const_iterator::data_t
vec< T, M >::const_iterator data_t
Definition: field.h:520
rheolef::field_basic::iterator::data_t
vec< T, M >::iterator data_t
Definition: field.h:429
rheolef::field_basic::put_field
odiststream & put_field(odiststream &ops) const
Definition: field.cc:302
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
rheolef::field_basic::const_iterator::pointer
const typedef T * pointer
Definition: field.h:530
rheolef::field_basic::const_iterator::_blk_dis_iub_iter
iter_t _blk_dis_iub_iter
Definition: field.h:581
rheolef::disarray
see the disarray page for the full documentation
Definition: disarray.h:459
rheolef::details::field_concat_value
Definition: field.h:210
rheolef::field_basic::dis_ndof
size_type dis_ndof() const
Definition: field.h:342
rheolef::field_basic::valued
const std::string & valued() const
Definition: field.h:305
rheolef::field_basic::const_iterator::iter_t
disarray< space_pair_type, M >::const_iterator iter_t
Definition: field.h:521
rheolef::const_iterator
Definition: field_expr_recursive.h:552
rheolef::field_basic::_u
vec< T, M > _u
Definition: field.h:404
rheolef::field_basic::have_homogeneous_space
bool have_homogeneous_space(space_basic< T, M > &Xh) const
Definition: field.h:306
rheolef::operator+
std::enable_if< details::is_rheolef_arithmetic< U >::value,ad3_basic< T >>::type operator+(const U &a, const ad3_basic< T > &b)
Definition: ad3.h:222
rheolef::field_basic::assembly_internal
void assembly_internal(const geo_basic< T, M > &dom, const geo_basic< T, M > &band, const band_basic< T, M > &gh, const Expr &expr, const integrate_option &qopt, bool is_on_band)
Definition: field_vf_assembly.h:95
rheolef::field_basic::const_iterator::_blk_dis_iub_incr
size_type _blk_dis_iub_incr
Definition: field.h:582
mkgeo_ball.n
n
Definition: mkgeo_ball.sh:150
rheolef::field_sequential
field_basic< Float, sequential > field_sequential
Definition: field.h:421
rheolef::field_basic::iterator::operator++
iterator operator++(int)
Definition: field.h:480
rheolef::field_basic::b
const vec< T, M > & b() const
Definition: field.h:311
rheolef::details::is_rheolef_arithmetic
Definition: Float.h:150
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::field_basic::iterator::_blk_dis_iub_incr
size_type _blk_dis_iub_incr
Definition: field.h:493
rheolef::field_basic::operator()
field_component< T, M > operator()(size_type i_comp, size_type j_comp)
Definition: field.cc:508
rheolef::field_basic::iterator::_b
data_t _b
Definition: field.h:495
rheolef::field_basic::operator[]
field_indirect< T, M > operator[](const geo_basic< T, M > &dom)
Definition: field_indirect.h:158
rheolef::field_basic::const_iterator::const_iterator
const_iterator()
Definition: field.h:535
rheolef::field_basic< T, rheo_default_memory_model >::memory_type
rheo_default_memory_model memory_type
Definition: field.h:240
rheolef::field_basic::dis_evaluate
T dis_evaluate(const point_basic< T > &x, size_type i_comp=0) const
Definition: field.cc:460
rheolef::field_basic::dis_dof_indexes_requires_update
void dis_dof_indexes_requires_update() const
Definition: field.h:630
rheolef::field_basic::operator=
field_basic< T, M > & operator=(const field_basic< T, M > &)
Definition: field.h:619
rheolef::field_basic::size
size_type size() const
Definition: field.h:331
rheolef::field_basic::const_iterator::_first_iu
size_type _first_iu
Definition: field.h:585
mkgeo_ball.tmp
tmp
Definition: mkgeo_ball.sh:380
rheolef::field_basic::const_iterator::_b
data_t _b
Definition: field.h:584
rheolef::operator<<
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition: catchmark.h:99
rheolef::field_basic::put
odiststream & put(odiststream &ops) const
Definition: field.cc:366
rheolef::field_basic::const_iterator
Definition: field.h:518
rheolef::field_basic::_dis_dof_assembly_requires_update
bool _dis_dof_assembly_requires_update
Definition: field.h:407
rheolef::field_basic::max_abs
T max_abs() const
Definition: field.h:731
rheolef::field_basic::get
idiststream & get(idiststream &ips)
Definition: field.cc:121
rheolef::field_basic::iterator::_first_iu
size_type _first_iu
Definition: field.h:496
rheolef::vec::size_type
base::size_type size_type
Definition: vec.h:86
mkgeo_contraction.name
name
Definition: mkgeo_contraction.sh:133
M
Expr1::memory_type M
Definition: vec_expr_v2.h:385
rheolef::distributor::size
size_type size(size_type iproc) const
Definition: distributor.h:163
rheolef::field_basic< T, rheo_default_memory_model >::size_type
std::size_t size_type
Definition: field.h:239
rheolef::field_basic< T, rheo_default_memory_model >::dis_reference
typename vec< T, rheo_default_memory_model >::dis_reference dis_reference
Definition: field.h:249
rheolef::details::is_field
Definition: field.h:228
T
Expr1::float_type T
Definition: field_expr.h:218