rheolef  7.0
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
rheolef Namespace Reference

irheostream, orheostream - large data streams More...

Namespaces

 algo
 
 custom_cgal
 
 details
 
 edge
 
 element_constant
 
 hexahedron
 
 io
 
 prism
 
 quadrangle
 
 space_constant
 
 tetrahedron
 
 triangle
 

Classes

class  __branch_header
 
class  __const_branch_finalize
 
class  __const_branch_header
 
class  __iobranch
 
class  __obranch
 
struct  _disarray_get_element_type
 
struct  _disarray_get_element_type< geo_element >
 
struct  _disarray_put_element_type
 
struct  _disarray_put_element_type< geo_element >
 
struct  _disarray_put_matlab_type
 
struct  _point_get
 
struct  _point_put
 
struct  _round_point_put
 
struct  abtb_schur_complement
 
struct  abtbc_schur_complement
 
struct  adapt_option
 adapt - mesh adaptation More...
 
struct  always_true
 
class  apply_iterator
 
class  asr
 asr - associative sparse matrix More...
 
class  band_basic
 band - compute the band around a level set More...
 
struct  base_geo_node_t
 
class  binary_compose
 
struct  bound_type
 
class  branch_basic
 branch - a parameter-dependent sequence of field More...
 
class  catchmark
 catchmark - iostream manipulator More...
 
struct  ceiler_type
 
class  characteristic_basic
 characteristic - the Lagrange-Galerkin method implemented More...
 
class  characteristic_on_quadrature
 
struct  characteristic_on_quadrature_rep
 
class  characteristic_rep
 
struct  communicator
 
struct  continuation_option
 continuation_option - send options to the continuation algorithm More...
 
class  csr
 csr - compressed sparse row matrix More...
 
class  csr< T, sequential >
 
class  csr_concat
 
class  csr_concat_line
 
class  csr_concat_value
 
class  csr_rep
 
class  csr_rep< T, sequential >
 
class  curved_ball_H
 
class  curved_ball_q
 
class  curved_ball_t
 
class  curved_ball_T
 
struct  default_set_op
 
struct  default_set_op< pair_set< T, A > >
 
class  dia
 dia - diagonal matrix More...
 
class  disarray
 disarray - container in distributed environment More...
 
class  disarray< T, sequential, A >
 
class  disarray_rep
 
class  disarray_rep< T, sequential, A >
 
struct  disarray_store
 
struct  disarray_store< OutputRandomIterator, SetOp, Size, std::false_type >
 
struct  disarray_store< OutputRandomIterator, SetOp, Size, std::true_type >
 
class  distributor
 distributor - data distribution table More...
 
class  domain_indirect_base_rep
 
class  domain_indirect_basic
 domain_indirect - a named part of a finite element mesh More...
 
class  domain_indirect_basic< sequential >
 
class  domain_indirect_rep
 
class  domain_indirect_rep< sequential >
 
class  dummy_iterator
 
class  environment
 
struct  environment_option_type
 
struct  evaluate_internal
 
struct  evaluate_internal< This, Result, Result, Arg1, Arg2 >
 
struct  evaluate_switch
 
struct  evaluate_switch< This, Result, Arg1, Arg1Tag, Arg2, space_constant::last_valued >
 
struct  evaluate_switch< This, Result, Arg1, space_constant::last_valued, Arg2, Arg2Tag >
 
struct  evaluate_switch< This, Result, Arg1, space_constant::last_valued, Arg2, space_constant::last_valued >
 
class  eye_rep
 eye - the identity matrix More...
 
class  fdinbuf
 
class  fdistream
 
class  fdostream
 
class  fdoutbuf
 
class  field_basic
 field - piecewise polynomial finite element field More...
 
class  field_component
 
class  field_component_const
 
struct  field_concat
 
class  field_concat_value
 
struct  field_functor
 field_functor - a functor wrapper suitable for field expressions (obsolete) More...
 
class  field_indirect
 
class  field_indirect_const
 
class  field_o_characteristic
 
struct  field_put
 
struct  field_put< T, sequential >
 
struct  first_op
 
class  FlexLexer
 
struct  float_traits
 
struct  float_traits< point_basic< T > >
 
struct  float_traits< std::complex< T > >
 
struct  float_traits< tensor3_basic< T > >
 
struct  float_traits< tensor4_basic< T > >
 
struct  float_traits< tensor_basic< T > >
 
struct  float_traits< undeterminated_basic< T > >
 
struct  floorer_type
 
class  form_basic
 form - representation of a finite element bilinear form More...
 
struct  form_concat
 
class  form_concat_line
 
class  form_concat_value
 
class  geo_abstract_base_rep
 
class  geo_abstract_rep
 
class  geo_abstract_rep< T, sequential >
 
class  geo_base_rep
 
class  geo_basic
 
class  geo_basic< T, sequential >
 
struct  geo_cgal_traits
 
struct  geo_cgal_traits< T, 1 >
 
struct  geo_cgal_traits< T, 2 >
 
struct  geo_cgal_traits< T, 3 >
 
class  geo_domain_indirect_base_rep
 
class  geo_domain_indirect_rep
 
class  geo_domain_indirect_rep< T, sequential >
 
class  geo_domain_rep
 geo_domain - a named part of a finite element mesh that behaves as a mesh More...
 
class  geo_element
 geo_element - element of a mesh More...
 
class  geo_element_auto
 
class  geo_element_hack
 
class  geo_element_indirect
 
struct  geo_element_permuted_put
 
struct  geo_header
 
struct  geo_iterator
 
class  geo_locate
 
class  geo_locate_abstract_rep
 
class  geo_nearest
 
class  geo_nearest_abstract_rep
 
class  geo_rep
 
class  geo_rep< T, sequential >
 
struct  geo_size
 
class  geo_trace_ray_boundary
 
class  geo_trace_ray_boundary_abstract_rep
 
struct  get_first
 
struct  get_second
 
class  hack_array
 hack_array - container in distributed environment More...
 
class  hack_array< T, sequential, A >
 
struct  hack_array_iterator
 
class  hack_array_seq_rep
 
class  heap_object
 
struct  id
 
struct  id_pt_minimum
 
struct  id_pt_t
 
class  index_iterator
 
struct  integrate_option
 integrate_option - send options to the integrate function More...
 
class  inv_piola
 
class  iofem
 
class  iorheo
 
class  iorheobase_memory_handler
 
class  iorheomanip1
 
class  ipstream
 
class  irheomanip1
 
class  irheostream
 
struct  is_container
 
struct  is_container< pair_set< T, A > >
 
struct  is_dia_t
 
struct  is_distributed
 
struct  is_distributed< sequential >
 
struct  is_field_expr_v2_nonlinear_arg< field_expr_v2_nonlinear_node_binary< F, Expr1, Expr2 > >
 
struct  is_sequential
 
struct  is_sequential< sequential >
 
struct  is_undeterminated
 
struct  is_undeterminated< undeterminated_basic< T > >
 
class  keller
 
class  keller< Problem, std::false_type >
 
class  keller< Problem, std::true_type >
 
struct  KeyValueType
 
class  ldlt_seq_builtin
 
struct  level_set_option
 level_set - compute a level set from a function More...
 
struct  limiter_option_type
 
struct  MeshType
 
struct  msg_right_permutation_set_default
 
struct  newton_identity_preconditioner
 
class  numbering
 numbering - global degree of freedom numbering More...
 
class  numbering_rep
 
class  odiststream
 idiststream, odiststream - distributed interface for large data streams More...
 
class  opstream
 
class  orheomanip1
 
class  orheostream
 
struct  pair_identity
 
class  pair_set
 pair_set - a set of (index,value) pair More...
 
struct  pair_set_add_op
 
class  point_basic
 point - vertex of a mesh More...
 
struct  promote
 
struct  promote< char, char >
 
struct  promote< char, double >
 
struct  promote< char, float >
 
struct  promote< char, int >
 
struct  promote< char, long >
 
struct  promote< char, long double >
 
struct  promote< char, short int >
 
struct  promote< char, short unsigned int >
 
struct  promote< char, unsigned char >
 
struct  promote< char, unsigned int >
 
struct  promote< char, unsigned long >
 
struct  promote< double, char >
 
struct  promote< double, double >
 
struct  promote< double, float >
 
struct  promote< double, int >
 
struct  promote< double, long >
 
struct  promote< double, long double >
 
struct  promote< double, short int >
 
struct  promote< double, short unsigned int >
 
struct  promote< double, unsigned char >
 
struct  promote< double, unsigned int >
 
struct  promote< double, unsigned long >
 
struct  promote< float, char >
 
struct  promote< float, double >
 
struct  promote< float, float >
 
struct  promote< float, int >
 
struct  promote< float, long >
 
struct  promote< float, long double >
 
struct  promote< float, short int >
 
struct  promote< float, short unsigned int >
 
struct  promote< float, unsigned char >
 
struct  promote< float, unsigned int >
 
struct  promote< float, unsigned long >
 
struct  promote< int, char >
 
struct  promote< int, double >
 
struct  promote< int, float >
 
struct  promote< int, int >
 
struct  promote< int, long >
 
struct  promote< int, long double >
 
struct  promote< int, short int >
 
struct  promote< int, short unsigned int >
 
struct  promote< int, unsigned char >
 
struct  promote< int, unsigned int >
 
struct  promote< int, unsigned long >
 
struct  promote< long double, char >
 
struct  promote< long double, double >
 
struct  promote< long double, float >
 
struct  promote< long double, int >
 
struct  promote< long double, long >
 
struct  promote< long double, long double >
 
struct  promote< long double, short int >
 
struct  promote< long double, short unsigned int >
 
struct  promote< long double, unsigned char >
 
struct  promote< long double, unsigned int >
 
struct  promote< long double, unsigned long >
 
struct  promote< long, char >
 
struct  promote< long, double >
 
struct  promote< long, float >
 
struct  promote< long, int >
 
struct  promote< long, long >
 
struct  promote< long, long double >
 
struct  promote< long, short int >
 
struct  promote< long, short unsigned int >
 
struct  promote< long, unsigned char >
 
struct  promote< long, unsigned int >
 
struct  promote< long, unsigned long >
 
struct  promote< short int, char >
 
struct  promote< short int, double >
 
struct  promote< short int, float >
 
struct  promote< short int, int >
 
struct  promote< short int, long >
 
struct  promote< short int, short int >
 
struct  promote< short int, short unsigned int >
 
struct  promote< short int, unsigned char >
 
struct  promote< short int, unsigned int >
 
struct  promote< short int, unsigned long >
 
struct  promote< short unsigned int, char >
 
struct  promote< short unsigned int, double >
 
struct  promote< short unsigned int, float >
 
struct  promote< short unsigned int, int >
 
struct  promote< short unsigned int, long >
 
struct  promote< short unsigned int, long double >
 
struct  promote< short unsigned int, short int >
 
struct  promote< short unsigned int, short unsigned int >
 
struct  promote< short unsigned int, unsigned char >
 
struct  promote< short unsigned int, unsigned int >
 
struct  promote< short unsigned int, unsigned long >
 
struct  promote< T1, undeterminated_basic< T2 > >
 
struct  promote< undeterminated_basic< T1 >, T2 >
 
struct  promote< undeterminated_basic< T1 >, undeterminated_basic< T2 > >
 
struct  promote< unsigned char, char >
 
struct  promote< unsigned char, double >
 
struct  promote< unsigned char, float >
 
struct  promote< unsigned char, int >
 
struct  promote< unsigned char, long >
 
struct  promote< unsigned char, long double >
 
struct  promote< unsigned char, short int >
 
struct  promote< unsigned char, short unsigned int >
 
struct  promote< unsigned char, unsigned char >
 
struct  promote< unsigned char, unsigned int >
 
struct  promote< unsigned char, unsigned long >
 
struct  promote< unsigned int, char >
 
struct  promote< unsigned int, double >
 
struct  promote< unsigned int, float >
 
struct  promote< unsigned int, int >
 
struct  promote< unsigned int, long >
 
struct  promote< unsigned int, long double >
 
struct  promote< unsigned int, short int >
 
struct  promote< unsigned int, short unsigned int >
 
struct  promote< unsigned int, unsigned char >
 
struct  promote< unsigned int, unsigned int >
 
struct  promote< unsigned int, unsigned long >
 
struct  promote< unsigned long, char >
 
struct  promote< unsigned long, double >
 
struct  promote< unsigned long, float >
 
struct  promote< unsigned long, int >
 
struct  promote< unsigned long, long >
 
struct  promote< unsigned long, long double >
 
struct  promote< unsigned long, short int >
 
struct  promote< unsigned long, short unsigned int >
 
struct  promote< unsigned long, unsigned char >
 
struct  promote< unsigned long, unsigned int >
 
struct  promote< unsigned long, unsigned long >
 
struct  promote_memory
 
struct  promote_memory< sequential, sequential >
 
struct  promote_memory< sequential, undefined_memory_model >
 
struct  promote_memory< undefined_memory_model, sequential >
 
struct  promote_not_specialized_for_this_case
 
struct  pt2_minimum
 
struct  pt2_t
 
class  quadrature
 
class  quadrature_on_geo
 
class  quadrature_option
 quadrature_option - send options to the integrate function More...
 
class  quadrature_rep
 
class  quadruplet
 
class  reference_element
 reference_element - reference element More...
 
class  reference_element_e
 
class  reference_element_H
 
class  reference_element_p
 
class  reference_element_P
 
class  reference_element_q
 
class  reference_element_T
 
class  reference_element_t
 
struct  rounder_type
 
struct  scalar_traits
 helper for point_basic<T> & tensor_basic<T>: get basic T type More...
 
struct  scalar_traits< point_basic< T > >
 
struct  scalar_traits< tensor3_basic< T > >
 
struct  scalar_traits< tensor4_basic< T > >
 
struct  scalar_traits< tensor_basic< T > >
 
struct  scalar_traits< undeterminated_basic< T > >
 
struct  second_op
 
struct  select1st
 
struct  select2nd
 
struct  sequential
 
struct  set_add_op
 
struct  set_op
 
struct  side_information_type
 
class  smart_pointer
 
class  smart_pointer_base
 
class  smart_pointer_clone
 
class  smart_pointer_nocopy
 
class  solver_abstract_rep
 
class  solver_abtb_basic
 solver_abtb – direct or iterative solver interface for mixed linear systems More...
 
class  solver_basic
 solver - direct or interative solver interface More...
 
class  solver_ldlt_builtin_rep
 
class  solver_no_trilinos_ifpack_rep
 
class  solver_option
 
class  solver_rep
 
class  solver_wrapper_rep
 
class  space_act
 
class  space_base_rep
 
class  space_basic
 space – piecewise polynomial finite element space More...
 
class  space_basic< T, sequential >
 
class  space_component
 
class  space_component_const
 
class  space_constitution
 
class  space_constitution_rep
 
class  space_mult_list
 
struct  space_mult_list_rep
 
struct  space_pair_type
 
class  space_rep
 
class  space_rep< T, sequential >
 
class  space_scalar_constitution
 
class  space_scalar_constitution_rep
 
class  stack_allocator
 
class  std
 
class  tensor3_basic
 
class  tensor4_basic
 
class  tensor_basic
 
class  test_basic
 
class  test_rep
 test, trial - symbolic arguments in variational expressions More...
 
class  tiny_element
 
class  tiny_matrix
 
class  tiny_vector
 
struct  to_solve
 
struct  tree_type
 
class  unary_compose
 
struct  undefined_memory_model
 
struct  undeterminated_basic
 
class  vec
 vec - vector in distributed environment More...
 
class  vec_concat
 
class  vec_concat_value
 
class  vec_range
 
class  vec_range_const
 
struct  vec_trans
 
struct  Vector
 
class  vector_of_iterator
 
struct  vector_rep
 
struct  vector_vec_trans
 
struct  VectorOfIterators
 
struct  weighted_point
 quadrature - quadrature formulae on the reference lement More...
 
struct  yy_buffer_state
 
struct  yy_trans_info
 
union  yyalloc
 
class  yyFlexLexer
 
union  YYSTYPE
 

Typedefs

typedef double Float
 
template<class T >
using heap_allocator = std::allocator< T >
 
typedef solver_basic< Floatsolver
 
typedef solver_abtb_basic< Float, rheo_default_memory_modelsolver_abtb
 
using solver_option_type = solver_option
 
typedef point_basic< Floatpoint
 
using quadrature_option_type = quadrature_option
 
typedef tensor_basic< Floattensor
 
typedef tensor3_basic< Floattensor3
 
typedef tensor4_basic< Floattensor4
 
using adapt_option_type = adapt_option
 
typedef band_basic< Floatband
 
typedef branch_basic< Floatbranch
 
typedef characteristic_basic< Floatcharacteristic
 
using continuation_option_type = continuation_option
 
typedef domain_indirect_basic< rheo_default_memory_modeldomain_indirect
 
typedef field_basic< Floatfield
 
typedef field_basic< Float, sequentialfield_sequential
 
typedef details::generic_binary_traits< BinaryFunction >::template result_hint< typename Expr1::result_type, typename Expr2::result_type >::type result_type
 
typedef result_type value_type
 
typedef scalar_traits< value_type >::type scalar_type
 
typedef float_traits< value_type >::type float_type
 
typedef Expr1::memory_type memory_type
 
typedef form_basic< Float, rheo_default_memory_modelform
 
typedef geo_basic< Float, rheo_default_memory_modelgeo
 geo - the default mesh class More...
 
typedef geo domain
 geo_domain_indirect_rep - a named part of a finite element mesh More...
 
typedef int my_idxtype
 
typedef my_idxtype idxtype
 
typedef struct KeyValueType KeyValueType
 
using form_option_type = integrate_option
 
typedef geo_element_auto< heap_allocator< geo_element::size_type > > element_type
 
using level_set_option_type = level_set_option
 
typedef space_basic< Floatspace
 
typedef std::list< tree_typelist_type
 
typedef size_t size_type
 
typedef union YYSTYPE YYSTYPE
 
typedef unsigned char yytype_uint8
 
typedef signed char yytype_int8
 
typedef unsigned short int yytype_uint16
 
typedef short int yytype_int16
 
typedef signed char flex_int8_t
 
typedef short int flex_int16_t
 
typedef int flex_int32_t
 
typedef unsigned char flex_uint8_t
 
typedef unsigned short int flex_uint16_t
 
typedef unsigned int flex_uint32_t
 
typedef struct yy_buffer_stateYY_BUFFER_STATE
 
typedef size_t yy_size_t
 
typedef unsigned char YY_CHAR
 
typedef int yy_state_type
 
typedef test_basic< Float, rheo_default_memory_model, details::vf_tag_01test
 
typedef test_basic< Float, rheo_default_memory_model, details::vf_tag_10trial
 

Enumerations

enum  yytokentype {
  IDENTIFIER = 258,
  SCALAR = 259,
  VECTOR = 260,
  TENSOR = 261,
  UNSYMMETRIC_TENSOR = 262,
  TENSOR4 = 263,
  EQUISPACED = 264,
  WARBURTON = 265,
  FEKETE = 266
}
 

Functions

static double sqr (const double &x)
 
std::istream & operator>> (std::istream &is, const catchmark &m)
 
std::ostream & operator<< (std::ostream &os, const catchmark &m)
 
template<typename InputPairIterator , typename OutputPairIterator , typename UnaryOperation >
OutputPairIterator pair_transform_second (InputPairIterator first, InputPairIterator last, OutputPairIterator result, UnaryOperation unary_op)
 
template<class T1 , class T2 >
std::ostream & operator<< (std::ostream &out, const std::pair< T1, T2 > &x)
 
std::string indent (std::string str, const std::string &indent=" ")
 
std::string typeid_name (const char *name, bool do_indent)
 typename_macro, pretty_typename_macro - type demangler and pretty printer More...
 
std::string get_tmpdir ()
 
string ftos (const Float &x)
 
bool has_suffix (const string &name, const string &suffix)
 
string delete_suffix (const string &name, const string &suffix)
 
bool has_any_suffix (const string &name)
 
string delete_any_suffix (const string &name)
 
string get_basename (const string &name)
 
string get_dirname (const string &name)
 
static string get_dir_from_path (const string &path, unsigned int &i_pos)
 
static void init_rheo_path ()
 
void append_dir_to_rheo_path (const string &dir)
 
void prepend_dir_to_rheo_path (const string &dir)
 
static bool have_name_in_dir (const string &dir, const string &name, string &full_path)
 
string get_full_name_from_rheo_path (const string &rootname, const string &suffix)
 
bool is_float (const string &s)
 
Float to_float (const string &s)
 
std::string itos (std::string::size_type i)
 
bool scatch (std::istream &in, const std::string &ch, bool full_match=true)
 
bool file_exists (const std::string &filename)
 
template<class T >
rounder_type< T > rounder (const T &prec)
 
template<class T >
floorer_type< T > floorer (const T &prec)
 
template<class T >
ceiler_type< T > ceiler (const T &prec)
 
template<typename T1 >
bool operator== (const stack_allocator< T1 > &lhs, const stack_allocator< T1 > &rhs) throw ()
 
template<typename T1 >
bool operator!= (const stack_allocator< T1 > &lhs, const stack_allocator< T1 > &rhs) throw ()
 
template<class T >
bool invert (const ublas::matrix< T > &input, ublas::matrix< T > &inverse)
 
template<class T >
boost::numeric::ublas::matrix< T > invert (const boost::numeric::ublas::matrix< T > &m, bool &is_singular)
 
template<class matrix_T >
double determinant (ublas::matrix_expression< matrix_T > const &mat_r)
 
template<class T >
std::ostream & operator<< (std::ostream &out, const ublas::vector< T > &b)
 
template<class T >
std::ostream & operator<< (std::ostream &out, const ublas::matrix< T > &A)
 
template<class T >
bool invert_3x3 (const ublas::matrix< T > &A, ublas::matrix< T > &result)
 
template<class Range1 , class Range2 >
static void mr_set (ublas::matrix< Float > &m, Range1 r1, Range2 r2, const ublas::matrix< Float > &m_expr)
 
void read_mm_header (idiststream &)
 
template<class T , class M , class A >
idiststream & operator>> (idiststream &s, asr< T, M, A > &x)
 
template<class T , class M , class A >
odiststreamoperator<< (odiststream &s, const asr< T, M, A > &x)
 
template<class InputPtrIterator , class Predicate , class Operation , class OutputPtrIterator , class OutputDataIterator >
OutputPtrIterator asr_to_csr (InputPtrIterator iter_ptr_a, InputPtrIterator last_ptr_a, Predicate pred, Operation op, OutputPtrIterator iter_ptr_b, OutputDataIterator iter_data_b)
 asr_to_csr – sequential sparse matrix convertion More...
 
template<class InputPtrIterator , class Predicate , class Set >
Set::value_type asr_to_csr_dist_logical (InputPtrIterator iter_ptr_a, InputPtrIterator last_ptr_a, Predicate is_dia, Set &colext)
 asr_to_csr_dist_logical – sparse matrix convertion More...
 
template<class Matrix , class Vector , class Vector2 , class Preconditioner >
int cg (const Matrix &A, Vector &x, const Vector2 &Mb, const Preconditioner &M, const solver_option &sopt=solver_option())
 cg – conjugate gradient algorithm. More...
 
template<class T , class M >
csr< T, Mdiag (const vec< T, M > &d)
 
template<class T >
csr< T, sequentialoperator* (const T &lambda, const csr< T, sequential > &a)
 
template<class T >
csr< T, sequentialoperator- (const csr< T, sequential > &a)
 
template<class T >
csr< T, sequentialtrans (const csr< T, sequential > &a)
 
template<class T , class M , class Function >
endcode csr< T, Mapply (Function f, const csr< T, M > &a)
 
template<class T , class M , class Function >
csr< T, Mapply (T(*f)(const T &), const csr< T, M > &a)
 
template<class T , class M >
endcode csr< T, Mdiag (const vec< T, M > &)
 
template<class T , class M >
idiststream & operator>> (idiststream &s, csr< T, M > &x)
 
template<class T , class M >
odiststreamoperator<< (odiststream &s, const csr< T, M > &x)
 
template<class T , class M >
vec_trans< T, Mtrans (const vec< T, M > &w)
 
template<class T , class M >
vector_vec_trans< T, Mtrans (const std::vector< vec< T, M > > &w)
 
template<class InputIterator1 , class InputIterator3 , class SetOperator , class RandomAccessMutableIterator >
void csr_cumul_trans_mult (InputIterator1 ia, InputIterator1 last_ia, InputIterator3 x, SetOperator set_op, RandomAccessMutableIterator y)
 
template<class T >
csr_rep< T, sequential >::size_type csr_csr_mult_size (const csr_rep< T, sequential > &a, const csr_rep< T, sequential > &b)
 
template<class T >
static void csr_csr_mult (const csr_rep< T, sequential > &a, const csr_rep< T, sequential > &b, csr_rep< T, sequential > &c)
 
template<class InputPtrIterator , class InputDataIterator , class UnaryOperation , class OutputPtrIterator >
OutputPtrIterator csr_to_asr (InputPtrIterator iter_ptr_a, InputPtrIterator last_ptr_a, InputDataIterator iter_data_a, UnaryOperation op, OutputPtrIterator iter_ptr_b)
 csr_to_asr – sequential sparse matrix convertion More...
 
template<class T , class M >
dia< T, Moperator/ (const T &lambda, const dia< T, M > &d)
 
template<class T , class M >
vec< T, Moperator* (const dia< T, M > &d, const vec< T, M > &x)
 
template<class T , class M >
dia< T, Mdiag (const csr< T, M > &a) @endcode
 diag - get diagonal part of a matrix More...
 
template<class InputIterator , class Size >
std::iterator_traits< InputIterator >::value_type dis_accumulate (InputIterator first, Size n, const distributor::communicator_type &comm, sequential)
 dis_accumulate - distributed accumulate algorithm More...
 
template<class InputIterator , class Size >
std::iterator_traits< InputIterator >::value_type dis_accumulate (InputIterator first, Size n, const distributor::communicator_type &comm)
 
double seq_wall_time ()
 dis_cpu_time, dis_wall_time, seq_cpu_time, seq_walltime – Time in seconds since an arbitrary time in the past. More...
 
double seq_cpu_time ()
 
double dis_wall_time ()
 
double dis_cpu_time ()
 
template<class InputIterator1 , class InputIterator2 , class Size >
promote< typename std::iterator_traits< InputIterator1 >::value_type, typename std::iterator_traits< InputIterator2 >::value_type >::type dis_inner_product (InputIterator1 first1, InputIterator2 first2, Size n, const distributor::communicator_type &comm, sequential)
 dis_inner_product - distributed inner product algorithm More...
 
template<class InputIterator1 , class InputIterator2 , class Size >
promote< typename std::iterator_traits< InputIterator1 >::value_type, typename std::iterator_traits< InputIterator2 >::value_type >::type dis_inner_product (InputIterator1 first1, InputIterator2 first2, Size n, const distributor::communicator_type &comm)
 
size_t seq_peak_memory_usage ()
 Returns the peak (maximum so far) resident set size (physical memory use) measured in bytes, or zero if the value cannot be determined on this OS. More...
 
size_t seq_memory_usage ()
 dis_memory_usage, seq_memory_usage – physical memory in use More...
 
size_t memory_size ()
 
size_t dis_memory_usage ()
 
size_t dis_peak_memory_usage ()
 
template<class T , class A >
idiststream & operator>> (idiststream &ips, disarray< T, sequential, A > &x)
 
template<class T , class A >
odiststreamoperator<< (odiststream &ops, const disarray< T, sequential, A > &x)
 
template<class OutputRandomIterator , class SetOp , class Size , class IsContainer >
disarray_store< OutputRandomIterator, SetOp, Size, IsContainer > disarray_make_store (OutputRandomIterator x, SetOp op, Size, IsContainer)
 
idiststream din (cin)
 
bool dis_scatch (idiststream &ips, const communicator &comm, std::string ch)
 
int dis_system (const std::string &command, const communicator &comm)
 
bool dis_file_exists (const std::string &filename, const communicator &comm)
 
template<class T >
odiststreamoperator<< (odiststream &s, T x)
 
bool dis_scatch (idiststream &ips, std::string ch)
 
idiststream & operator>> (idiststream &ids, const catchmark &m)
 
odiststreamoperator<< (odiststream &ods, const catchmark &m)
 
template<class _Operation1 , class _Operation2 >
unary_compose< _Operation1, _Operation2 > compose1 (const _Operation1 &__fn1, const _Operation2 &__fn2)
 
template<class _Operation1 , class _Operation2 , class _Operation3 >
binary_compose< _Operation1, _Operation2, _Operation3 > compose2 (const _Operation1 &__fn1, const _Operation2 &__fn2, const _Operation3 &__fn3)
 
template<class Iterator >
std::iterator_traits< Iterator >::pointer get_pointer_from_iterator (Iterator iter)
 
template<class T >
std::iterator_traits< T * >::pointer get_pointer_from_iterator (T *iter)
 
template<class Matrix , class Vector , class Preconditioner , class SmallMatrix , class SmallVector >
int gmres (const Matrix &A, Vector &x, const Vector &b, const Preconditioner &M, SmallMatrix &H, const SmallVector &, const solver_option &sopt=solver_option())
 
template<typename T >
void ldlt_seq_builtin_ordering (const csr_rep< T, sequential > &a, std::valarray< size_t > &perm)
 
template<typename T >
bool ldlt_seq_builtin_numeric (const csr_rep< T, sequential > &A, const std::valarray< size_t > &perm, const std::valarray< size_t > &iperm, const std::valarray< size_t > &parent, vec< T, sequential > &D, csr_rep< T, sequential > &L, std::valarray< size_t > &L_nnz, std::valarray< size_t > &mark, std::valarray< size_t > &pattern, vec< T, sequential > &Y)
 
template<typename T >
void ldlt_seq_builtin_symbolic (const csr_rep< T, sequential > &A, const std::valarray< size_t > &perm, const std::valarray< size_t > &iperm, std::valarray< size_t > &parent, std::valarray< size_t > &L_nnz, std::valarray< size_t > &mark)
 
template<typename T >
odiststreamoperator<< (odiststream &s, const ldlt_seq_builtin< T > &c)
 
template<class RandomIterator >
bool load_chunk (std::istream &s, RandomIterator iter, RandomIterator last)
 
template<class RandomIterator , class GetFunction >
bool load_chunk (std::istream &s, RandomIterator iter, RandomIterator last, GetFunction get_element)
 
template<class Matrix , class Vector , class Preconditioner >
int minres (const Matrix &A, Vector &x, const Vector &Mb, const Preconditioner &M, const solver_option &sopt=solver_option())
 minres – conjugate gradient algorithm. More...
 
template<class Matrix , class Vector , class Solver , class Preconditioner >
int uzawa_abtbc (const Matrix &A, const Matrix &B, const Matrix &C, Vector &u, Vector &p, const Vector &Mf, const Vector &Mg, const Preconditioner &S1, const Solver &inner_solver_A, const Float &rho, const solver_option &sopt=solver_option())
 
template<class Matrix , class Vector , class Solver , class Preconditioner , class Real >
int uzawa_abtb (const Matrix &A, const Matrix &B, Vector &u, Vector &p, const Vector &Mf, const Vector &Mg, const Preconditioner &S1, const Solver &inner_solver_A, const Real &rho, const solver_option &sopt=solver_option())
 
template<class Matrix , class Vector , class VectorExpr1 , class VectorExpr2 , class Solver , class Preconditioner >
int cg_abtbc (const Matrix &A, const Matrix &B, const Matrix &C, Vector &u, Vector &p, const VectorExpr1 &Mf, const VectorExpr2 &Mg, const Preconditioner &S1, const Solver &inner_solver_A, const solver_option &sopt=solver_option())
 cg_abtb, cg_abtbc, minres_abtb, minres_abtbc – solvers for mixed linear problems More...
 
template<class Matrix , class Vector , class VectorExpr1 , class VectorExpr2 , class Solver , class Preconditioner >
int cg_abtb (const Matrix &A, const Matrix &B, Vector &u, Vector &p, const VectorExpr1 &Mf, const VectorExpr2 &Mg, const Preconditioner &S1, const Solver &inner_solver_A, const solver_option &sopt=solver_option())
 
template<class Matrix , class Vector , class Solver , class Preconditioner >
int minres_abtbc (const Matrix &A, const Matrix &B, const Matrix &C, Vector &u, Vector &p, const Vector &Mf, const Vector &Mg, const Preconditioner &S1, const Solver &inner_solver_A, const solver_option &sopt=solver_option())
 
template<class Matrix , class Vector , class Solver , class Preconditioner >
int minres_abtb (const Matrix &A, const Matrix &B, Vector &u, Vector &p, const Vector &Mf, const Vector &Mg, const Preconditioner &S1, const Solver &inner_solver_A, const solver_option &sopt=solver_option())
 
template<class Stash , class Message , class InputIterator >
Stash::size_type mpi_assembly_begin (const Stash &stash, InputIterator first_stash_idx, InputIterator last_stash_idx, const distributor &ownership, Message &receive, Message &send)
 mpi_assembly_begin – for array or matrix More...
 
template<class Container , class Message , class Size >
Size mpi_assembly_end (Message &receive, Message &send, Size receive_max_size, Container x)
 msg_assembly_end – array or matrix assembly More...
 
template<class InputIterator , class Message , class Tag , class Comm >
void mpi_scatter_begin_global (InputIterator x, Message &from, Message &to, Tag tag, Comm comm)
 mpi_scatter_begin – gather/scatter initialize More...
 
template<class InputIterator , class OutputIterator , class SetOp , class Message >
void mpi_scatter_begin_local (InputIterator x, OutputIterator y, Message &from, Message &to, SetOp op)
 
template<class InputIterator , class OutputIterator , class Message >
void mpi_scatter_begin_local (InputIterator x, OutputIterator y, Message &from, Message &to, set_op< typename Message::value_type, typename Message::value_type > op)
 
template<class InputIterator , class OutputIterator , class Message , class SetOp , class Tag , class Comm >
void mpi_scatter_begin (InputIterator x, OutputIterator y, Message &from, Message &to, SetOp op, Tag tag, Comm comm)
 
template<class InputIterator , class OutputIterator , class Message , class SetOp , class Tag , class Comm >
void mpi_scatter_end (InputIterator x, OutputIterator y, Message &from, Message &to, SetOp op, Tag tag, Comm comm)
 mpi_scatter_end – gather/scatter finalize More...
 
template<class Message , class Size , class SizeRandomIterator1 , class SizeRandomIterator2 , class SizeRandomIterator3 , class Tag >
void mpi_scatter_init (Size nidx, SizeRandomIterator1 idx, Size nidy, SizeRandomIterator2 idy, Size idy_maxval, SizeRandomIterator3 ownership, Tag tag, const distributor::communicator_type &comm, Message &from, Message &to)
 
template<class InputIterator , class InputSet , class OutputMap >
void mpi_scatter_map (const distributor &ownership, InputIterator local_data, const InputSet &ext_idx_set, OutputMap &ext_idx_map) @endcode
 mpi_scatter_map – gather/scatter and build map More...
 
template<class InputIterator1 , class InputIterator2 , class InputRandomIterator , class SetOp , class OutputRandomIterator >
void msg_both_permutation_apply (InputIterator1 px, InputIterator1 last_px, InputRandomIterator x, SetOp set_op, InputIterator2 py, OutputRandomIterator y)
 msg_both_permutation_apply – sequentail apply More...
 
template<class InputIterator1 , class InputIterator2 , class InputRandomIterator , class Proc , class Size , class MutableRandomIterator , class OutputIterator >
void msg_from_context_indices (InputIterator1 owner, InputIterator1 last_owner, InputIterator2 idy, InputRandomIterator proc2from_proc, Proc my_proc, Size idy_maxval, MutableRandomIterator ptr, OutputIterator from_idx)
 msg_from_context_indices – gather More...
 
template<class InputIterator1 , class OutputIterator1 , class OutputIterator2 , class OutputIterator3 >
void msg_from_context_pattern (InputIterator1 msg_size, InputIterator1 last_msg_size, OutputIterator1 from_proc, OutputIterator2 from_ptr, OutputIterator3 proc2from_proc)
 msg_from_context – gather More...
 
template<class InputIterator1 , class InputIterator2 , class SetOp , class OutputRandomIterator >
void msg_left_permutation_apply (InputIterator1 x, SetOp op, InputIterator2 py, InputIterator2 last_py, OutputRandomIterator y)
 msg_left_permutation_apply – sequentail apply More...
 
template<class InputIterator1 , class InputIterator2 , class Size , class OutputIterator1 , class OutputIterator2 >
void msg_local_context (InputIterator1 idx, InputIterator1 last_idx, InputIterator2 idy, Size idy_maxval, Size istart, Size ilast, OutputIterator1 to_loc_idx, OutputIterator1 last_to_loc_idx, OutputIterator2 from_loc_idy)
 msg_local_context – receive pattern More...
 
template<class InputIterator1 , class InputIterator2 >
bool msg_local_optimize (InputIterator1 to_loc_idx, InputIterator1 last_to_loc_idx, InputIterator2 from_loc_idy)
 msg_local_optimize – local scatter optimize More...
 
template<class InputIterator , class InputRandomIterator , class OutputIterator , class SetOp >
OutputIterator msg_right_permutation_apply (InputIterator perm, InputIterator last_perm, const InputRandomIterator &x, OutputIterator y, SetOp set_op)
 msg_right_permutation_apply – sequentail apply More...
 
template<class InputIterator , class InputRandomIterator , class OutputIterator >
OutputIterator msg_right_permutation_apply (InputIterator perm, InputIterator last_perm, const InputRandomIterator &x, OutputIterator y)
 
template<class RandomIterator , class SizeRandomIterator , class Size >
void quick_sort_with_permutation (RandomIterator v, SizeRandomIterator p, Size start, Size end)
 
template<class RandomIterator , class SizeRandomIterator , class Size >
void bubble_sort_with_permutation (RandomIterator v, SizeRandomIterator p, Size n)
 
template<class RandomIterator , class SizeRandomIterator , class Size >
void sort_with_permutation (RandomIterator v, SizeRandomIterator p, Size n)
 
template<class InputIterator1 , class InputRandomIterator2 , class InputRandomIterator3 , class InputRandomIterator4 , class Size , class OutputIterator1 , class OutputIterator2 , class OutputIterator3 >
void msg_to_context (InputIterator1 perm, InputIterator1 last_perm, InputRandomIterator2 r_iproc, InputRandomIterator3 r_size, InputRandomIterator4 r_idx, Size receive_max_size, Size istart, OutputIterator1 to_proc, OutputIterator2 to_ptr, OutputIterator3 to_idx)
 msg_to_context – receive pattern More...
 
template<class Iterator , class Operator >
apply_iterator< Iterator, Operator > make_apply_iterator (Iterator i, Operator op)
 
template<class InputIterator , class OutputIterator >
OutputIterator msg_pair_copy (InputIterator input, InputIterator last, OutputIterator result)
 
template<class T , class A >
std::istream & operator>> (std::istream &is, pair_set< T, A > &a)
 
template<class T , class A >
std::ostream & operator<< (std::ostream &os, const pair_set< T, A > &b)
 
template<class T , class M >
solver_basic< T, Mldlt (const csr< T, M > &a, const solver_option &opt=solver_option())
 
template<class T , class M >
solver_basic< T, Mlu (const csr< T, M > &a, const solver_option &opt=solver_option())
 
template<class T , class M = rheo_default_memory_model>
solver_basic< T, Meye_basic ()
 
solver_basic< Floateye ()
 
template<class T , class M >
solver_basic< T, Mic0 (const csr< T, M > &a, const solver_option &opt=solver_option())
 
template<class T , class M >
solver_basic< T, Milu0 (const csr< T, M > &a, const solver_option &opt=solver_option())
 
template<class T , class M >
solver_basic< T, Mldlt_seq (const csr< T, M > &a, const solver_option &opt=solver_option())
 
template<class T , class M >
solver_basic< T, Mlu_seq (const csr< T, M > &a, const solver_option &opt=solver_option())
 
template<class T , class M >
static csr< T, M >::size_type nnz_upper_strict (const csr< T, M > &a)
 
template<class T , class M >
static void extract_upper (const csr< T, M > &a, csr< T, M > &u)
 
template<class T , class M >
static void inplace_ic0 (csr< T, M > &u)
 
template<class T , class M >
static void inplace_csc_lower_diag_solve (const csr< T, M > &a, vec< T, M > &x_vec)
 
template<class T , class M >
static void inplace_csr_upper_diag_solve (const csr< T, M > &a, vec< T, M > &x_vec, const vec< T, M > &b_vec)
 
template<class Matrix , class Vector , class Preconditioner , class Real2 >
int uzawa (const Matrix &A, Vector &x, const Vector &Mb, const Preconditioner &M, const Real2 &rho, const solver_option &sopt=solver_option())
 uzawa – Uzawa algorithm. More...
 
template<class T >
idiststream & operator>> (idiststream &ips, vec< T, sequential > &x)
 
template<class T , class M >
odiststreamoperator<< (odiststream &ods, const vec< T, M > &x)
 
template<class T , class M >
norm2 (const vec< T, M > &x)
 
template<class T , class M >
norm (const vec< T, M > &x)
 
 _RHEOLEF_vec_expr_v2_unary_operator (+, details::generic_unary_plus<>) _RHEOLEF_vec_expr_v2_unary_operator(-
 
 _RHEOLEF_vec_expr_v2_binary_operator (+, details::generic_plus<>) _RHEOLEF_vec_expr_v2_binary_operator(-
 
template<class Expr1 , class Expr2 >
details::generic_minus std::enable_if<(details::is_rheolef_arithmetic< Expr1 >::value &&details::is_vec_expr_v2_arg< Expr2 >::value)||(details::is_vec_expr_v2_arg< Expr1 >::value &&details::is_rheolef_arithmetic< Expr2 >::value), typename details::vec_expr_v2_binary_traits< details::generic_multiplies<>, Expr1, Expr2 >::type >::type operator* (const Expr1 &expr1, const Expr2 &expr2)
 
template<class Expr1 , class Expr2 >
std::enable_if<(details::is_vec_expr_v2_arg< Expr1 >::value &&details::is_rheolef_arithmetic< Expr2 >::value), typename details::vec_expr_v2_binary_traits< details::generic_divides<>, Expr1, Expr2 >::type >::type operator/ (const Expr1 &expr1, const Expr2 &expr2)
 
 _RHEOLEF_vec_expr_v2_op_assign (+=, details::plus_assign) _RHEOLEF_vec_expr_v2_op_assign(-
 
 _RHEOLEF_vec_expr_v2_op_assign_constant (+=, details::plus_assign) _RHEOLEF_vec_expr_v2_op_assign_constant(-
 
details::minus_assign _RHEOLEF_vec_expr_v2_op_assign_constant details::multiplies_assign _RHEOLEF_vec_expr_v2_op_assign_constant (/=, details::divides_assign) template< class Expr1
 
rheolef::std enable_if ::type dot const Expr1 expr1, const Expr2 expr2 dot (const Expr1 &expr1, const Expr2 &expr2)
 
template<class T >
pythag (T a, T b)
 
template<class T >
SIGN (T a, T b)
 
template<class Iterator1 , class Iterator2 , class Size >
void tqli (Iterator1 d, Iterator2 e, Size n)
 
std::istream & operator>> (std::istream &is, geo_element_indirect &x)
 
std::ostream & operator<< (std::ostream &os, const geo_element_indirect &x)
 
template<class T , class M >
bool point_belongs_to_e (const disarray< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
 
template<class T , class M >
bool point_belongs_to_t (const disarray< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
 
template<class T , class M >
bool point_belongs_to_q (const disarray< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
 
template<class T , class M >
bool point_belongs_to_T (const disarray< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
 
template<class T , class M >
bool point_belongs_to_H (const disarray< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
 
template<class T , class M >
bool point_belongs_to_P (const disarray< point_basic< T >, M > &node, const geo_element &K, const point_basic< T > &x)
 
char skip_blancs_and_tabs (istream &is)
 
istream & operator>> (istream &is, geo_element &K)
 
ostream & operator<< (ostream &os, const geo_element &K)
 
template<class T , class A >
idiststream & operator>> (idiststream &ips, hack_array< T, sequential, A > &x)
 
template<class T , class A >
odiststreamoperator<< (odiststream &ops, const hack_array< T, sequential, A > &x)
 
template<class T , class U >
std::enable_if< details::is_rheolef_arithmetic< U >::value,point_basic< T >>::type operator* (const U &a, const point_basic< T > &u)
 
template<class T >
point_basic< T > vect (const point_basic< T > &v, const point_basic< T > &w)
 
template<class T >
dot (const point_basic< T > &x, const point_basic< T > &y)
 
template<class T >
norm2 (const point_basic< T > &x)
 
template<class T >
norm (const point_basic< T > &x)
 
template<class T >
dist2 (const point_basic< T > &x, const point_basic< T > &y)
 
template<class T >
dist (const point_basic< T > &x, const point_basic< T > &y)
 
template<class T >
dist_infty (const point_basic< T > &x, const point_basic< T > &y)
 
template<class T >
vect2d (const point_basic< T > &v, const point_basic< T > &w)
 
template<class T >
mixt (const point_basic< T > &u, const point_basic< T > &v, const point_basic< T > &w)
 
template<class T >
int sign_orient2d (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c)
 
template<class T >
int sign_orient3d (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c, const point_basic< T > &d)
 
template<class T >
orient2d (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c)
 
template<class T >
orient3d (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c, const point_basic< T > &d)
 
template<class T >
std::string ptos (const point_basic< T > &x, int d=3)
 
template<class T , size_t d>
bool lexicographically_less (const point_basic< T > &a, const point_basic< T > &b)
 
template<class T >
std::istream & operator>> (std::istream &s, point_basic< T > &p)
 
template<class T >
std::ostream & operator<< (std::ostream &s, const point_basic< T > &p)
 
 def_point_function (sqr) def_point_function(sqrt) def_point_function(log) def_point_function(log10) def_point_function(exp) template< class T1
 
class T2 inline point_basic< T1 > operator/ (const T2 &a, const point_basic< T1 > &x)
 
template<class T >
static T inexact_orient2d (const point_basic< T > &x, const point_basic< T > &a, const point_basic< T > &b)
 
template<class T >
static T inexact_orient3d (const point_basic< T > &x, const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c)
 
static quadrature_option::family_type family_name2type (string name)
 
template<class T >
ostream & operator<< (ostream &out, const quadrature_on_geo< T > &x)
 
template<class T >
ostream & operator<< (ostream &out, const quadrature_rep< T > &x)
 
template<class T >
endcode std::ostream & operator<< (std::ostream &os, const quadrature< T > &q)
 
Float measure (reference_element hat_K)
 
template<class T >
point_basic< T > reference_element_face_transformation (reference_element tilde_K, const side_information_type &sid, const point_basic< T > &hat_x)
 
template<class T >
static T hypot2 (const T &x, const T &y)
 
template<class T >
static void tred2 (tensor_basic< T > &V, point_basic< T > &d, point_basic< T > &e)
 
template<class T >
static void tql2 (tensor_basic< T > &V, point_basic< T > &d, point_basic< T > &e)
 
template<class T >
void eigen_decomposition (const tensor_basic< T > &A, tensor_basic< T > &V, point_basic< T > &d)
 
template<class T >
static tensor_basic< T > exp2d (const tensor_basic< T > &chi)
 
template<class T >
tensor_basic< T > exp (const tensor_basic< T > &a, size_t d)
 
template<class T >
const T MIN (const T &a, const T &b)
 
template<class T >
const T MAX (const T &a, const T &b)
 
template<class T >
const T SIGN (const T &a, const T &b)
 
template<class T >
const T SQR (const T a)
 
template<class T >
pythag (const T &a, const T &b)
 
template<class Matrix1 , class Matrix2 , class Vector , class T , class Size >
void svdcmp (Matrix1 &a, Vector &w, Matrix2 &v, Size anrow, Size ancol, T dummy)
 
template<class T >
point_basic< T > operator* (const point_basic< T > &x, const tensor_basic< T > &a)
 
template<class T >
tensor_basic< T > trans (const tensor_basic< T > &a, size_t d)
 
template<class T >
tensor_basic< T > inv (const tensor_basic< T > &a, size_t d)
 
template<class T >
void prod (const tensor_basic< T > &a, const tensor_basic< T > &b, tensor_basic< T > &result, size_t di, size_t dj, size_t dk)
 
template<class T >
ddot (const tensor_basic< T > &a, const tensor_basic< T > &b)
 
template<class T >
void cumul_otimes (tensor_basic< T > &t, const point_basic< T > &a, const point_basic< T > &b, size_t na, size_t nb)
 
template<class T >
bool invert_3x3 (const tensor_basic< T > &A, tensor_basic< T > &result)
 
template<class T >
static point_basic< T > eig3x3 (const tensor_basic< T > &a, tensor_basic< T > &q)
 
template<class T >
static point_basic< T > eig2x2 (const tensor_basic< T > &a, tensor_basic< T > &q)
 
template<class U >
point_basic< U > operator* (const point_basic< U > &yt, const tensor_basic< U > &a)
 
template<class U >
tensor_basic< U > trans (const tensor_basic< U > &a, size_t d=3)
 
template<class U >
void prod (const tensor_basic< U > &a, const tensor_basic< U > &b, tensor_basic< U > &result, size_t di=3, size_t dj=3, size_t dk=3)
 
template<class U >
tr (const tensor_basic< U > &a, size_t d=3)
 
template<class U >
ddot (const tensor_basic< U > &, const tensor_basic< U > &)
 
template<class U >
tensor_basic< U > otimes (const point_basic< U > &u, const point_basic< U > &v, size_t d=3)
 
template<class U >
tensor_basic< U > inv (const tensor_basic< U > &a, size_t d=3)
 
template<class U >
tensor_basic< U > diag (const point_basic< U > &d)
 
template<class U >
point_basic< U > diag (const tensor_basic< U > &a)
 
template<class U >
determinant (const tensor_basic< U > &A, size_t d=3)
 
template<class U >
bool invert_3x3 (const tensor_basic< U > &A, tensor_basic< U > &result)
 
template<class T >
std::istream & operator>> (std::istream &in, tensor_basic< T > &a)
 
template<class T >
std::ostream & operator<< (std::ostream &out, const tensor_basic< T > &a)
 
template<class T >
void cumul_otimes (tensor_basic< T > &t, const point_basic< T > &a, const point_basic< T > &b, size_t na=3)
 
template<class T , class U >
std::enable_if< details::is_rheolef_arithmetic< U >::value,tensor_basic< T >>::type operator* (const U &k, const tensor_basic< T > &a)
 
template<class T >
tensor_basic< T > otimes (const point_basic< T > &u, const point_basic< T > &v, size_t d)
 
template<class T >
determinant (const tensor_basic< T > &A, size_t d)
 
template<class T >
tensor_basic< T > diag (const point_basic< T > &d)
 
template<class T >
point_basic< T > diag (const tensor_basic< T > &a)
 
template<class T >
tr (const tensor_basic< T > &a, size_t d)
 
template<class T >
norm2 (const tensor_basic< T > &a)
 
template<class T >
dist2 (const tensor_basic< T > &a, const tensor_basic< T > &b)
 
template<class U >
norm (const tensor_basic< U > &a)
 
template<class U >
dist (const tensor_basic< U > &a, const tensor_basic< U > &b)
 
template<class T >
dddot (const tensor3_basic< T > &a, const tensor3_basic< T > &b)
 
template<class T , class U >
std::enable_if< details::is_rheolef_arithmetic< U >::value,tensor3_basic< T >>::type operator* (const U &k, const tensor3_basic< T > &a)
 
template<class U >
dddot (const tensor3_basic< U > &, const tensor3_basic< U > &)
 
template<class T >
norm2 (const tensor3_basic< T > &a)
 
template<class T >
dist2 (const tensor3_basic< T > &a, const tensor3_basic< T > &b)
 
template<class U >
norm (const tensor3_basic< U > &a)
 
template<class U >
dist (const tensor3_basic< U > &a, const tensor3_basic< U > &b)
 
template<class T >
std::istream & operator>> (std::istream &in, tensor3_basic< T > &a)
 
template<class T >
std::ostream & operator<< (std::ostream &out, const tensor3_basic< T > &a)
 
template<class T >
tensor4_basic< T > dexp (const tensor_basic< T > &chi, size_t dim)
 
template<class T >
tensor_basic< T > ddot (const tensor4_basic< T > &a, const tensor_basic< T > &x)
 
template<class T >
tensor_basic< T > ddot (const tensor_basic< T > &y, const tensor4_basic< T > &a)
 
template<class T >
norm2 (const tensor4_basic< T > &a)
 
template<class T >
norm (const tensor4_basic< T > &a)
 
template<class T , class U >
std::enable_if< details::is_rheolef_arithmetic< U >::value,tensor4_basic< T >>::type operator* (const U &k, const tensor4_basic< T > &a)
 
template<class T >
std::ostream & operator<< (std::ostream &out, const tensor4_basic< T > &a)
 
template<class T >
void lu (tiny_matrix< T > &a, tiny_vector< size_t > &piv)
 
template<class T >
void solve (tiny_matrix< T > &a, tiny_vector< size_t > &piv, const tiny_vector< T > &b, tiny_vector< T > &x)
 
template<class T >
void invert (tiny_matrix< T > &a, tiny_matrix< T > &inv_a)
 
template<class T >
void put (std::ostream &out, std::string name, const tiny_matrix< T > &a)
 
template<class T >
void trans (const tiny_matrix< T > &a, tiny_matrix< T > &b)
 
template<class T >
tiny_matrix< T > operator* (const tiny_matrix< T > &a, const tiny_matrix< T > &b)
 
template<class T >
tiny_vector< T > operator* (const tiny_matrix< T > &a, const tiny_vector< T > &u)
 
template<class T , class M >
geo_basic< T, Madapt_gmsh (const field_basic< T, M > &uh, const adapt_option &opts)
 
template<class T , class M >
geo_basic< T, Madapt_bamg (const field_basic< T, M > &uh, const adapt_option &opts)
 
template<class T , class M >
field_basic< T, Mproj (const field_basic< T, M > &uh, const std::string &approx="P1")
 
template<class T , class M >
field_basic< T, Msmooth (const field_basic< T, M > &uh, size_t n=1)
 
template<class T , class M >
field_basic< T, Mhessian (const field_basic< T, M > &uh)
 
template<class T , class M >
field_basic< T, Mhessian_criterion (const field_basic< T, M > &uh0, const adapt_option &opts)
 
template<class T , class M >
geo_basic< T, Madapt (const field_basic< T, M > &uh, const adapt_option &opts)
 
std::string bamgcad_catch_name (idiststream &bamg_in)
 
template<class T , class M >
geo_basic< T, Mlevel_set_internal (const field_basic< T, M > &, const level_set_option &, std::vector< size_t > &, disarray< size_t, M > &)
 
template<class T >
static bool band_is_zero (const T &x)
 
template<class T , class M >
static geo_element::size_type build_vertex_connex_component (const geo_basic< T, M > &band, const std::vector< geo_element::size_type > &zero_iv_list, const std::vector< geo_element::size_type > &isolated_ie_list)
 
template<class T >
void put_header (odiststream &out, const branch_basic< T, sequential > &b)
 
template<class T , class M >
idiststream & operator>> (idiststream &in, branch_basic< T, M > &b)
 
template<class T >
void put_event (odiststream &out, const branch_basic< T, sequential > &b)
 
template<class T , class M >
odiststreamoperator<< (odiststream &out, const branch_basic< T, M > &b)
 
template<class T >
void put_finalize (odiststream &out, const branch_basic< T, sequential > &b)
 
template<class T , class M >
odiststreamoperator<< (odiststream &os, __iobranch< T, M > m)
 
template<class T , class M >
idiststream & operator>> (idiststream &is, __iobranch< T, M > m)
 
template<class T >
void put_header_gnuplot (odiststream &ops, const branch_basic< T, sequential > &b)
 
template<class T >
void put_event_gnuplot (odiststream &ops, const branch_basic< T, sequential > &b)
 
template<class T >
void put_finalize_gnuplot (odiststream &ops, const branch_basic< T, sequential > &b)
 
template void put_header_gnuplot (odiststream &, const branch_basic< Float, sequential > &)
 
template void put_event_gnuplot (odiststream &, const branch_basic< Float, sequential > &)
 
template void put_finalize_gnuplot (odiststream &, const branch_basic< Float, sequential > &)
 
template<class T >
odiststreamfield_put_vtk (odiststream &, const field_basic< T, sequential > &, std::string, bool)
 
template<class T >
void put_header_paraview (odiststream &out, const branch_basic< T, sequential > &)
 
template<class T >
void put_event_paraview (odiststream &ods, const branch_basic< T, sequential > &b)
 
template<class T >
void put_finalize_paraview (odiststream &out, const branch_basic< T, sequential > &b)
 
template void put_header_paraview (odiststream &, const branch_basic< Float, sequential > &)
 
template void put_event_paraview (odiststream &, const branch_basic< Float, sequential > &)
 
template void put_finalize_paraview (odiststream &, const branch_basic< Float, sequential > &)
 
template<class Function , class... Exprs>
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)
 
template<class Problem >
void continuation (Problem &F, typename Problem::value_type &uh, odiststream *p_out, odiststream *p_err, const continuation_option &opts=continuation_option()) @endcode
 
template<class Problem >
void continuation (keller< Problem > &F, typename keller< Problem >::value_type &uh, odiststream *p_out, odiststream *p_err, const continuation_option &opts=continuation_option())
 
template<class Problem , class Preconditioner , class Field , class Real , class Size >
int damped_newton (const Problem &P, const Preconditioner &T, Field &u, Real &tol, Size &max_iter, odiststream *p_derr=0)
 
template<class Problem , class Field , class Real , class Size >
int damped_newton (const Problem &F, Field &u, Real &tol, Size &max_iter, odiststream *p_derr=0) @endcode
 damped_newton – damped Newton nonlinear algorithm More...
 
template<class T >
domain_indirect_basic< sequentialbuild_union (const geo_basic< T, sequential > &omega, const domain_indirect_basic< sequential > &a, const domain_indirect_basic< sequential > &b)
 
void build_set_that_contains_S (const geo_element &S, const std::vector< index_set > &ball, index_set &contains_S)
 
template<class T , class M >
static void get_field_recursive (idiststream &ids, vec< T, M > &u_io, const space_constitution< T, M > &constit, distributor::size_type &comp_start_dis_idof, distributor::size_type &comp_start_ios_idof, bool read_header=false)
 
template<class T , class M >
static void put_field_recursive (odiststream &ods, const field_basic< T, M > &uh, const space_constitution< T, M > &constit, distributor::size_type &comp_start_idof, distributor::size_type &comp_start_dis_idof, bool write_header=false)
 
template<class T >
odiststreamvisu_gnuplot (odiststream &, const field_basic< T, sequential > &)
 
template<class T >
odiststreamvisu_vtk_mayavi (odiststream &, const field_basic< T, sequential > &)
 
template<class T >
odiststreamvisu_vtk_paraview (odiststream &, const field_basic< T, sequential > &)
 
template<class T >
odiststreamfield_put_gmsh (odiststream &, const field_basic< T, sequential > &)
 
template<class T >
odiststreamfield_put_gmsh_pos (odiststream &, const field_basic< T, sequential > &)
 
template<class T >
odiststreamfield_put_bamg_bb (odiststream &, const field_basic< T, sequential > &)
 
template<class T , class M >
idiststream & operator>> (odiststream &ips, field_basic< T, M > &u)
 
template<class T , class M >
odiststreamoperator<< (odiststream &ops, const field_basic< T, M > &uh)
 
template<class T , class M >
idiststream & operator>> (idiststream &ips, field_basic< T, M > &uh)
 
template<class T , class M >
odiststreamoperator<< (odiststream &ods, const field_component< T, M > &uh_comp)
 
template<class T , class M >
odiststreamoperator<< (odiststream &ods, const field_component_const< T, M > &uh_comp)
 
template<class T , class M >
field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q)
 
template<class T , class M >
point_basic< T > vector_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q)
 
template<class T , class M >
tensor_basic< T > tensor_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q)
 
template<class T , class M >
field_component_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof_tab, size_t q, size_t i_comp)
 
template<class T , class M >
void general_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q, T &value)
 
template<class T , class M >
void general_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q, point_basic< T > &value)
 
template<class T , class M >
void general_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q, tensor_basic< T > &value)
 
template<class T , class M >
void general_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q, tensor3_basic< T > &value)
 
template<class T , class M >
void general_field_evaluate (const field_basic< T, M > &uh, const basis_on_pointset< T > &bops, reference_element hat_K, const std::vector< size_t > &dis_idof, size_t q, tensor4_basic< T > &value)
 
 _RHEOLEF_field_expr_v2_unary_operator (+, details::unary_plus) _RHEOLEF_field_expr_v2_unary_operator(-
 
 _RHEOLEF_field_expr_v2_binary_operator (+, details::plus) _RHEOLEF_field_expr_v2_binary_operator(-
 
template<class Expr1 , class Expr2 >
details::minus std::enable_if<(details::is_field_expr_v2_constant< Expr1 >::value &&details::is_field_expr_v2_linear_arg< Expr2 >::value)||(details::is_field_expr_v2_linear_arg< Expr1 >::value &&details::is_field_expr_v2_constant< Expr2 >::value),typename details::field_expr_v2_binary_traits< details::multiplies, Expr1, Expr2 >::type >::type operator* (const Expr1 &expr1, const Expr2 &expr2)
 
template<class Expr1 , class Expr2 >
std::enable_if<(details::is_field_expr_v2_linear_arg< Expr1 >::value &&details::is_field_expr_v2_constant< Expr2 >::value),typename details::field_expr_v2_binary_traits< details::divides, Expr1, Expr2 >::type >::type operator/ (const Expr1 &expr1, const Expr2 &expr2)
 
 _RHEOLEF_field_expr_v2_op_assign (+=, details::plus_assign) _RHEOLEF_field_expr_v2_op_assign(-
 
 _RHEOLEF_field_expr_v2_op_assign_constant (+=, details::plus_assign) _RHEOLEF_field_expr_v2_op_assign_constant(-
 
details::minus_assign _RHEOLEF_field_expr_v2_op_assign_constant details::multiplies_assign _RHEOLEF_field_expr_v2_op_assign_constant (/=, details::divides_assign) template< class Expr1
 
rheolef::std enable_if ::type dual const Expr1 expr1, const Expr2 expr2 dual (const Expr1 &expr1, const Expr2 &expr2)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value &&! details::is_field< Expr >::value,form_basic< typename Expr::value_type, typename Expr::memory_type >>::type diag (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value &&! details::is_field< Expr >::value,odiststream & >::type operator<< (odiststream &ops, const Expr &expr)
 
 _RHEOLEF_make_field_expr_v2_nonlinear_unary_operator (operator+, details::unary_plus) _RHEOLEF_make_field_expr_v2_nonlinear_unary_operator(operator-
 
details::negate _RHEOLEF_make_field_expr_v2_nonlinear_unary_function (cos) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(sin) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(tan) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(acos) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(asin) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(atan) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(cosh) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(sinh) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(tanh) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(exp) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(log) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(log10) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(sqrt) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(abs) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(fabs) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(floor) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(ceil) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(sqr) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(norm) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(norm2) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(tr) _RHEOLEF_make_field_expr_v2_nonlinear_unary_function(trans) template< class Function
 
 field_expr_v2_nonlinear_node_binary (const BinaryFunction &f, const Expr1 &expr1, const Expr2 &expr2)
 
space_constant::valued_type valued_tag () const
 
bool initialize (const geo_basic< float_type, memory_type > &omega, const quadrature< float_type > &hat_x) const
 
bool initialize (const space_basic< float_type, memory_type > &Xh) const
 
template<class Result , class Arg1 , class Arg2 >
void evaluate_internal2 (const geo_element &K, std::vector< Result > &value) const
 
template<class Result , class Arg1 , class Arg2 >
void evaluate_call (const geo_element &K, std::vector< Result > &value) const
 
template<class Result >
bool evaluate (const geo_element &K, std::vector< Result > &value) const
 
template<class Result >
bool valued_check () const
 
 _RHEOLEF_make_field_expr_v2_nonlinear_binary_operator_plus_minus (operator+, details::plus) _RHEOLEF_make_field_expr_v2_nonlinear_binary_operator_plus_minus(operator-
 
 _RHEOLEF_make_field_expr_v2_nonlinear_binary_operator_constant (operator+, details::plus) _RHEOLEF_make_field_expr_v2_nonlinear_binary_operator_constant(operator-
 
 _RHEOLEF_make_field_expr_v2_nonlinear_binary_general (operator*, details::multiplies, details::is_field_expr_v2_nonlinear_binary_operator_multiplies) _RHEOLEF_make_field_expr_v2_nonlinear_binary_operator_constant(operator*
 
 _RHEOLEF_make_field_expr_v2_nonlinear_binary_general (operator/, details::divides, details::is_field_expr_v2_nonlinear_binary_operator_divides) namespace details
 
 _RHEOLEF_make_field_expr_v2_nonlinear_binary_operator_constant_divides (operator/, details::divides) namespace details
 
 _RHEOLEF_make_field_expr_v2_nonlinear_binary_function (atan2) _RHEOLEF_make_field_expr_v2_nonlinear_binary_function(pow) _RHEOLEF_make_field_expr_v2_nonlinear_binary_function(fmod) _RHEOLEF_make_field_expr_v2_nonlinear_binary_function(min) _RHEOLEF_make_field_expr_v2_nonlinear_binary_function(max) _RHEOLEF_make_field_expr_v2_nonlinear_binary_function(dot) _RHEOLEF_make_field_expr_v2_nonlinear_binary_function(ddot) template< class Function
 
rheolef::std enable_if ::type compose const Function f, const Expr1 expr1, const Expr2 expr2 compose (const Function &f, const Expr1 &expr1, const Expr2 &expr2)
 
template<class T >
details::field_expr_v2_nonlinear_terminal_function< details::normal_pseudo_function< T > > normal_basic ()
 
details::field_expr_v2_nonlinear_terminal_function< details::normal_pseudo_function< Float > > normal ()
 
template<class T >
details::field_expr_v2_nonlinear_terminal_function< details::h_local_pseudo_function< T > > h_local_basic ()
 
details::field_expr_v2_nonlinear_terminal_function< details::h_local_pseudo_function< Float > > h_local ()
 
template<class T >
details::field_expr_v2_nonlinear_terminal_function< details::penalty_pseudo_function< T > > penalty_basic ()
 
details::field_expr_v2_nonlinear_terminal_function< details::penalty_pseudo_function< Float > > penalty ()
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_grad< typename Expr::scalar_type,typename Expr::memory_type >>::type grad (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_grad< typename Expr::scalar_type,typename Expr::memory_type >>::type grad_s (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_grad< typename Expr::scalar_type,typename Expr::memory_type >>::type grad_h (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_grad< typename Expr::scalar_type,typename Expr::memory_type >>::type D (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_grad< typename Expr::scalar_type,typename Expr::memory_type >>::type Ds (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_grad< typename Expr::scalar_type,typename Expr::memory_type >>::type Dh (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_div< typename Expr::scalar_type,typename Expr::memory_type >>::type div (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_div< typename Expr::scalar_type,typename Expr::memory_type >>::type div_s (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_div< typename Expr::scalar_type,typename Expr::memory_type >>::type div_h (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,details::field_expr_v2_nonlinear_terminal_field_curl< typename Expr::scalar_type,typename Expr::memory_type >>::type curl (const Expr &expr)
 
 _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg (jump, 1, -1) _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg(average
 
 _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg (inner, 1, 0) _RHEOLEF_make_field_expr_v2_nonlinear_terminal_field_dg(outer
 
template<class T , class M >
details::field_expr_v2_nonlinear_terminal_field_o_characteristic< T, Mcompose (const field_basic< T, M > &uh, const characteristic_basic< T, M > &X)
 
 _RHEOLEF_make_field_expr_v2_variational_unary_operator (operator+, details::unary_plus) _RHEOLEF_make_field_expr_v2_variational_unary_operator(operator-
 
details::negate _RHEOLEF_make_field_expr_v2_variational_unary_operator (tr, details::tr_) _RHEOLEF_make_field_expr_v2_variational_unary_operator(trans
 
 _RHEOLEF_make_field_expr_v2_variational_binary_operator_plus_minus (operator+, details::plus) _RHEOLEF_make_field_expr_v2_variational_binary_operator_plus_minus(operator-
 
 _RHEOLEF_make_field_expr_v2_variational_binary_operator_multiplies_divides (operator*, details::multiplies) _RHEOLEF_make_field_expr_v2_variational_binary_operator_multiplies_divides_right(operator/
 
details::divides _RHEOLEF_make_field_expr_v2_variational_binary_operator_multiplies_divides (dot, details::dot_) _RHEOLEF_make_field_expr_v2_variational_binary_operator_multiplies_divides(ddot
 
 _RHEOLEF_make_field_expr_v2_variational_binary_operator_multiplies_divides_constant (operator*, details::multiplies) _RHEOLEF_make_field_expr_v2_variational_binary_operator_multiplies_divides_constant_right(operator/
 
details::divides _RHEOLEF_make_field_expr_v2_variational_binary_operator_multiplies_divides_constant (dot, details::dot_) _RHEOLEF_make_field_expr_v2_variational_binary_operator_multiplies_divides_constant(ddot
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_grad< Expr >>::type grad (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_grad< Expr >>::type grad_s (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_grad< Expr >>::type grad_h (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_grad< Expr >>::type D (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_grad< Expr >>::type Ds (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_grad< Expr >>::type Dh (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_div< Expr >>::type div (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_div< Expr >>::type div_s (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_div< Expr >>::type div_h (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_curl< Expr >>::type curl (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,details::field_expr_v2_variational_curl< Expr >>::type bcurl (const Expr &expr)
 
 _RHEOLEF_make_field_expr_v2_variational_dg (jump, 1, -1) _RHEOLEF_make_field_expr_v2_variational_dg(average
 
 _RHEOLEF_make_field_expr_v2_variational_dg (inner, 1, 0) _RHEOLEF_make_field_expr_v2_variational_dg(outer
 
template<class T , class M >
odiststreamoperator<< (odiststream &ops, const field_indirect< T, M > &uh)
 
template<class T , class M >
odiststreamoperator<< (odiststream &ops, const field_indirect_const< T, M > &uh)
 
template odiststreamfield_put_bamg_bb< Float > (odiststream &, const field_basic< Float, sequential > &)
 
template<class T >
odiststreamgeo_put_gmsh (odiststream &ods, const geo_basic< T, sequential > &)
 
template<class T >
odiststreamfield_put_gmsh (odiststream &ods, const field_basic< T, sequential > &uh, std::string name)
 
template odiststreamfield_put_gmsh< Float > (odiststream &, const field_basic< Float, sequential > &, std::string)
 
template odiststreamfield_put_gmsh< Float > (odiststream &, const field_basic< Float, sequential > &)
 
template<class T >
odiststreamfield_put_gmsh_pos (odiststream &ods, const field_basic< T, sequential > &uh, std::string name)
 
template odiststreamfield_put_gmsh_pos< Float > (odiststream &, const field_basic< Float, sequential > &, std::string)
 
template odiststreamfield_put_gmsh_pos< Float > (odiststream &, const field_basic< Float, sequential > &)
 
template<class T >
odiststreamgeo_put_vtk (odiststream &ods, const geo_basic< T, sequential > &omega, const numbering< T, sequential > &my_numb, const disarray< point_basic< T >, sequential > &my_node, bool append_data)
 
template<class T >
odiststreamgeo_put_vtk (odiststream &ods, const geo_basic< T, sequential > &omega, size_t my_order, const disarray< point_basic< T >, sequential > &my_node, bool append_data)
 
template<class T >
static field_basic< T, sequentialinterpolate_scalar (const space_basic< T, sequential > &Vh, const field_basic< T, sequential > &uh)
 
template<class T >
static field_basic< T, sequentialinterpolate (const space_basic< T, sequential > &Vh, const field_basic< T, sequential > &uh)
 
template<class T >
odiststreamput_vtk_scalar_values (odiststream &ods, const field_basic< T, sequential > &uh, std::string name, bool put_header)
 
template<class T >
odiststreamput_vtk_vector_values (odiststream &ods, const field_basic< T, sequential > &uh, std::string name, bool put_header)
 
template<class T >
odiststreamput_vtk_tensor_values (odiststream &ods, const field_basic< T, sequential > &tau_h, std::string name, bool put_header)
 
template<class T >
odiststreamfield_put_vtk (odiststream &ods, const field_basic< T, sequential > &uh)
 
template odiststreamfield_put_vtk< Float > (odiststream &, const field_basic< Float, sequential > &, std::string, bool)
 
template odiststreamfield_put_vtk< Float > (odiststream &, const field_basic< Float, sequential > &)
 
template<class T >
odiststreamvisu_gnuplot (odiststream &ops, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put_edge (std::ostream &gdat, const geo_element &E, const geo_basic< T, sequential > &omega, const field_basic< T, sequential > &uh, const basis_on_pointset< T > &geo_on_pointset, const basis_on_pointset< T > &field_on_pointset, size_t my_order, bound_type< T > &bbox)
 
template<class T >
static void put_triangle (std::ostream &gdat, const geo_element &F, const geo_basic< T, sequential > &omega, const field_basic< T, sequential > &uh, const basis_on_pointset< T > &geo_on_pointset, const basis_on_pointset< T > &field_on_pointset, size_t my_order, bound_type< T > &bbox)
 
template<class T >
static void put_quadrangle (std::ostream &gdat, const geo_element &F, const geo_basic< T, sequential > &omega, const field_basic< T, sequential > &uh, const basis_on_pointset< T > &b)
 
template<class T >
void put (std::ostream &gdat, const geo_element &K, const geo_basic< T, sequential > &omega, const field_basic< T, sequential > &uh, const basis_on_pointset< T > &geo_on_pointset, const basis_on_pointset< T > &field_on_pointset, size_t my_order, bound_type< T > &bbox)
 
template<class T >
odiststreamvisu_gnuplot_scalar (odiststream &ods, const field_basic< T, sequential > &uh)
 
template<class T >
odiststreamvisu_gnuplot_vector (odiststream &ods, const field_basic< T, sequential > &uh)
 
template<class T >
static std::string python (const point_basic< T > &x, size_t d=3)
 
template<class T >
idiststream & geo_get_vtk (idiststream &, geo_basic< T, sequential > &)
 
template<class T >
field_basic< T, sequentialplane_cut (const field_basic< T, sequential > &uh, const point_basic< T > &origin, const point_basic< T > &normal)
 
template odiststreamvisu_vtk_mayavi< Float > (odiststream &, const field_basic< Float, sequential > &)
 
template field_basic< Float, sequentialplane_cut (const field_basic< Float, sequential > &, const point_basic< Float > &, const point_basic< Float > &)
 
template<class T >
static std::string python (const point_basic< T > &x, size_t d=3)
 
template<class T >
field_basic< T, sequentialparaview_plane_cut (const field_basic< T, sequential > &uh, const point_basic< T > &origin, const point_basic< T > &normal)
 
template<class T >
geo_basic< T, sequentialparaview_isosurface (const field_basic< T, sequential > &uh)
 
template odiststreamvisu_vtk_paraview< Float > (odiststream &, const field_basic< Float, sequential > &)
 
template field_basic< Float, sequentialparaview_plane_cut (const field_basic< Float, sequential > &, const point_basic< Float > &, const point_basic< Float > &)
 
template geo_basic< Float, sequentialparaview_isosurface (const field_basic< Float, sequential > &)
 
template<class T >
std::valarray< field_basic< T > > operator* (const T &a, const std::valarray< field_basic< T > > &xh)
 
template<class T , class M >
void assembly_dis_idof (const space_basic< T, M > &X, const geo_basic< T, M > &dom, const geo_element &bgd_K, std::vector< geo_element::size_type > &dis_idx)
 
template<class T , class M >
form_basic< T, Mtrans (const form_basic< T, M > &a)
 
template<class T , class Permutation1 , class Permutation2 >
static void merge (asr< T, sequential > &a, const csr< T, sequential > &m, Permutation1 dis_im2dis_idof, Permutation2 dis_jm2dis_jdof)
 
template<class T , class M >
form_basic< T, Mdiag (const field_basic< T, M > &dh)
 
template<class T , class M >
field_basic< T, Mdiag (const form_basic< T, M > &a)
 
template<class T , class M >
form_basic< T, Moperator* (const T &lambda, const form_basic< T, M > &a)
 
template<class T , class M >
form_basic< T, Moperator- (const form_basic< T, M > &a)
 
 _RHEOLEF_make_form_expr_v2_variational_unary (operator+, details::unary_plus) _RHEOLEF_make_form_expr_v2_variational_unary(operator-
 
 _RHEOLEF_form_expr_v2_variational_binary (operator+, details::plus) _RHEOLEF_form_expr_v2_variational_binary(operator-
 
 _RHEOLEF_form_expr_v2_variational_binary_field (operator*, details::multiplies) _RHEOLEF_form_expr_v2_variational_binary_field(dot
 
details::dot_ _RHEOLEF_form_expr_v2_variational_binary_field (ddot, details::ddot_) namespace details
 
 _RHEOLEF_make_form_expr_v2_variational_binary_operator_multiplies_divides (operator*, details::multiplies) _RHEOLEF_make_form_expr_v2_variational_binary_operator_multiplies_divides_right(operator/
 
details::divides _RHEOLEF_make_form_expr_v2_variational_binary_operator_multiplies_divides (dot, details::dot_) _RHEOLEF_make_form_expr_v2_variational_binary_operator_multiplies_divides(ddot
 
 _RHEOLEF_make_form_expr_v2_variational_binary_operator_multiplies_divides_constant (operator*, details::multiplies) _RHEOLEF_make_form_expr_v2_variational_binary_operator_multiplies_divides_constant_right(operator/
 
details::divides _RHEOLEF_make_form_expr_v2_variational_binary_operator_multiplies_divides_constant (dot, details::dot_) _RHEOLEF_make_form_expr_v2_variational_binary_operator_multiplies_divides_constant(ddot
 
 _RHEOLEF_form_mult_field_var (field_component) _RHEOLEF_form_mult_field_var(field_component_const) _RHEOLEF_form_mult_field_var(field_indirect) _RHEOLEF_form_mult_field_var(field_indirect_const) template< class T
 
template<class T >
bool is_symmetric (ublas::matrix< T > &m, const T &tol)
 
template<class T >
void local_lump (ublas::matrix< T > &m)
 
template<class T >
void local_invert (ublas::matrix< T > &m, bool is_diag)
 
template<class T , class M , class WeightFunction >
bool form_named_init (form_basic< T, M > &a, const geo_basic< T, M > &dom, const std::string &name, bool has_weight, WeightFunction w, const quadrature_option &qopt)
 
template<class R , class... Args>
std::function< R(Args...)> functor (R(*f)(Args...))
 
static bool is_domain (const std::string &name, std::string &bgd_name, std::string &dom_name)
 
template<class T , class M >
geo_basic< T, Mgeo_load (const std::string &name)
 geo - finite element mesh More...
 
template<class T , class M >
geo_basic< T, Mcompact (const geo_basic< T, M > &gamma)
 
 _RHEOLEF_save (sequential) _RHEOLEF_set_name(sequential) _RHEOLEF_set_serial_number(sequential) _RHEOLEF_reset_order(sequential) _RHEOLEF_set_nodes(sequential) _RHEOLEF_set_coordinate_system(sequential) _RHEOLEF_set_dimension(sequential) _RHEOLEF_build_by_subdividing(sequential) _RHEOLEF_build_from_data(sequential) _RHEOLEF_reset_order(sequential) template< class T
 
template<class T , class M >
void boundary_guard (const geo_basic< T, M > &omega)
 
template<class T , class M >
void internal_sides_guard (const geo_basic< T, M > &omega)
 
template<class T , class M >
void sides_guard (const geo_basic< T, M > &omega)
 
template<class T , class M >
void geo_build_by_subdividing (geo_rep< T, M > &new_omega, const geo_basic< T, M > &old_omega, typename geo_rep< T, M >::size_type k)
 
template<class T , class M >
idiststream & operator>> (idiststream &ips, geo_basic< T, M > &omega)
 
template<class T , class M >
odiststreamoperator<< (odiststream &ops, const geo_basic< T, M > &omega)
 
 _RHEOLEF_geo_domain_cstor (sequential) _RHEOLEF_instanciation(Float
 
idiststream & operator>> (idiststream &ips, geo_header &h)
 
odiststreamoperator<< (odiststream &ops, const geo_header &h)
 
template<class T , class M >
void compute_bbox (const geo_base_rep< T, M > &omega, const geo_element &K, point_basic< T > &xmin, point_basic< T > &xmax)
 
template<class T , class M >
static void add_ball_externals (const geo_base_rep< T, M > &omega, const disarray< index_set, M > &ball)
 
template<class T >
static void add_ball_externals (const geo_base_rep< T, sequential > &omega, const disarray< index_set, sequential > &ball)
 
void geo_partition_scotch (my_idxtype *elmdist, my_idxtype *eptr, std::vector< my_idxtype > &eind, my_idxtype *elmwgt, int *ncon, int *ncommonnodes, int *nparts, float *tpwgts, float *ubvec, int *edgecut, my_idxtype *part, const mpi::communicator &comm)
 
template<class Size , class RandomIOIterator >
static void init_csr_ptr (Size n, const RandomIOIterator &aptr)
 
template<class Size , class RandomIOIterator >
static void shift_csr_ptr (Size n, const RandomIOIterator &aptr)
 
int idxamin (int n, const std::vector< my_idxtype > &x)
 
int idxamax (int n, const std::vector< my_idxtype > &x)
 
template<class T >
static T meas_t (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c)
 
template<class T >
static T meas_T (const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c, const point_basic< T > &d)
 
template<class T >
static void meas_P (const point_basic< T > &a0, const point_basic< T > &a1, const point_basic< T > &a2, const point_basic< T > &a3, const point_basic< T > &a4, const point_basic< T > &a5, T &meas1, T &meas2, T &meas3)
 
template<class T >
static bool check_element (const geo_element &K, const disarray< point_basic< T >, sequential > &p, bool verbose=false)
 
template<class T >
idiststream & geo_get_bamg (idiststream &ips, geo_basic< T, sequential > &omega)
 
template<class A >
static void bamg_load_element (std::istream &is, size_t variant, geo_element_auto< A > &K)
 
template<class T , class A >
static void build_domains (size_t dom_dim, const disarray< geo_element_auto< A >, sequential, A > &elt, const disarray< size_t, sequential, A > &elt_bamg_dom_id, const std::vector< std::string > &dom_name, const geo_basic< T, sequential > &omega, vector< index_set > *ball)
 
template<class T , class A >
static void build_vertex_domains (const disarray< size_t, sequential, A > &edg_bdr_bamg_dom_id, const disarray< size_t, sequential, A > &vert_bamg_dom_id, const std::vector< std::string > &dom_name, const geo_basic< T, sequential > &omega, vector< index_set > *ball)
 
template idiststream & geo_get_bamg< Float > (idiststream &, geo_basic< Float, sequential > &)
 
template idiststream & geo_get_vtk< Float > (idiststream &, geo_basic< Float, sequential > &)
 
template<class T >
odiststreamvisu_vtk_mayavi (odiststream &, const geo_basic< T, sequential > &)
 
template<class T >
odiststreamvisu_vtk_paraview (odiststream &, const geo_basic< T, sequential > &)
 
template<class T >
odiststreamgeo_put_bamg (odiststream &, const geo_basic< T, sequential > &)
 
template<class T >
static void put_edge (ostream &bamg, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put_triangle (ostream &bamg, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put (ostream &bamg, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega, const disarray< point_basic< Float >, sequential > &my_node)
 
template<class T >
odiststreamgeo_put_bamg (odiststream &ops, const geo_basic< T, sequential > &omega, const numbering< T, sequential > &my_numb, const disarray< point_basic< T >, sequential > &my_node)
 
template odiststreamgeo_put_bamg< Float > (odiststream &, const geo_basic< Float, sequential > &, const numbering< Float, sequential > &, const disarray< point_basic< Float >, sequential > &)
 
template odiststreamgeo_put_bamg< Float > (odiststream &, const geo_basic< Float, sequential > &)
 
template<class T >
static void put_edge (ostream &gmsh, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put_triangle (ostream &gmsh, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put (ostream &gmsh, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega, const disarray< point_basic< Float >, sequential > &my_node)
 
template<class T >
odiststreamgeo_put_gmsh (odiststream &ops, const geo_basic< T, sequential > &omega, const numbering< T, sequential > &my_numb, const disarray< point_basic< T >, sequential > &my_node)
 
template odiststreamgeo_put_gmsh< Float > (odiststream &, const geo_basic< Float, sequential > &, const numbering< Float, sequential > &, const disarray< point_basic< Float >, sequential > &)
 
template odiststreamgeo_put_gmsh< Float > (odiststream &, const geo_basic< Float, sequential > &)
 
template<class T >
static void put_edge (ostream &vtk, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put_triangle (ostream &vtk, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put_quadrangle (ostream &vtk, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put_tetrahedron (ostream &vtk, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
static void raw_put_prism (ostream &vtk, size_t i000, size_t i100, size_t i010, size_t i001, size_t i101, size_t i011)
 
template<class T >
static void put_prism (ostream &vtk, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega, const disarray< point_basic< Float >, sequential > &my_node)
 
template<class T >
static void put_hexahedron (ostream &vtk, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put (ostream &vtk, const geo_element &K, const numbering< T, sequential > &my_numb, const geo_basic< T, sequential > &omega, const disarray< point_basic< Float >, sequential > &my_node)
 
template<class T >
odiststreamgeo_put_vtk (odiststream &ops, const geo_basic< T, sequential > &omega, size_t my_order, const disarray< point_basic< T >, sequential > &my_node)
 
template<class T >
odiststreamgeo_put_vtk (odiststream &ops, const geo_basic< T, sequential > &omega, bool append_data)
 
template<class T >
odiststreamgeo_put_vtk (odiststream &ops, const geo_basic< T, sequential > &omega)
 
template odiststreamgeo_put_vtk< Float > (odiststream &, const geo_basic< Float, sequential > &, const numbering< Float, sequential > &, const disarray< point_basic< Float >, sequential > &, bool)
 
template odiststreamgeo_put_vtk< Float > (odiststream &, const geo_basic< Float, sequential > &, size_t, const disarray< point_basic< Float >, sequential > &, bool)
 
template odiststreamgeo_put_vtk< Float > (odiststream &, const geo_basic< Float, sequential > &, size_t, const disarray< point_basic< Float >, sequential > &)
 
template odiststreamgeo_put_vtk< Float > (odiststream &, const geo_basic< Float, sequential > &)
 
template<class T >
static void put_vertex (std::ostream &gdat, const geo_element &P, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put_edge (std::ostream &gdat, const geo_element &E, const geo_basic< T, sequential > &omega, const basis_on_pointset< T > &pointset, size_t subdivide)
 
template<class T >
static void put_2d_face (std::ostream &gdat, const geo_element &F, const geo_basic< T, sequential > &omega, const basis_on_pointset< T > &pointset, size_t subdivide)
 
template<class T >
static void put_3d_face (std::ostream &gdat, const geo_element &F, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put_face (std::ostream &gdat, const geo_element &F, const geo_basic< T, sequential > &omega, const basis_on_pointset< T > &pointset, size_t subdivide)
 
template<class T >
static void put_volume (std::ostream &gdat, const geo_element &K, const geo_basic< T, sequential > &omega)
 
template<class T >
static void put (std::ostream &gdat, const geo_element &K, const geo_basic< T, sequential > &omega, const basis_on_pointset< T > &pointset, size_t subdivide)
 
template odiststreamvisu_gnuplot (odiststream &ops, const geo_basic< Float, sequential > &omega)
 
template<class T >
static std::string python (const point_basic< T > &x, size_t d=3)
 
template odiststreamvisu_vtk_mayavi< Float > (odiststream &, const geo_basic< Float, sequential > &)
 
template<class T >
static std::string python (const point_basic< T > &x, size_t d=3)
 
template odiststreamvisu_vtk_paraview< Float > (odiststream &, const geo_basic< Float, sequential > &)
 
template<class M >
static void build_edge (const std::vector< size_t > &new_dis_inod, size_t nsub, hack_array< geo_element_hack, M > &ge, size_t &ie)
 
template<class M >
static void build_triangle (const std::vector< size_t > &new_dis_inod, size_t nsub, std::array< hack_array< geo_element_hack, M >, reference_element::max_variant > &ge, std::array< size_t, reference_element::max_variant > &count_by_variant)
 
template<class M >
static void build_element (const reference_element &hat_K, const std::vector< size_t > &new_dis_inod, size_t nsub, std::array< hack_array< geo_element_hack, M >, reference_element::max_variant > &ge, std::array< size_t, reference_element::max_variant > &count_by_variant)
 
 _RHEOLEF_geo_build_by_subdividing (sequential) _RHEOLEF_instanciate(Float
 
template<class T , class M , class Expr , class Result = typename details::field_expr_v2_nonlinear_terminal_wrapper_traits<Expr>::type::value_type>
std::enable_if< details::is_field_expr_v2_nonlinear_arg< Expr >::value &&! is_undeterminated< Result >::value, Result >::type integrate (const geo_basic< T, M > &omega, const Expr &expr, const quadrature_option &qopt, Result dummy=Result())
 integrate - integrate a function or an expression More...
 
template<class T , class M >
integrate (const geo_basic< T, M > &omega, quadrature_option &&qopt=quadrature_option())
 
template<class T , class M , class Expr >
std::enable_if< details::is_field_expr_v2_nonlinear_arg< Expr >::value &&is_undeterminated< typename details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr >::type::value_type >::value, typename scalar_traits< typename details::field_expr_v2_nonlinear_terminal_wrapper_traits< Expr >::type::value_type >::type >::type integrate (const geo_basic< T, M > &omega, const Expr &expr, const quadrature_option &qopt)
 
template<class T , class M , class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,field_basic< T, M >>::type integrate (const geo_basic< T, M > &domain, const Expr &expr, const quadrature_option &qopt=quadrature_option())
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,field_basic< typename Expr::scalar_type, typename Expr::memory_type >>::type integrate (const Expr &expr, const quadrature_option &qopt=quadrature_option())
 
template<class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,field_basic< typename Expr::scalar_type, typename Expr::memory_type >>::type integrate (const std::string &domname, const Expr &expr, const quadrature_option &qopt=quadrature_option())
 
template<class T , class M , class Expr >
std::enable_if< details::is_form_expr_v2_variational_arg< Expr >::value,form_basic< typename Expr::scalar_type, typename Expr::memory_type >>::type integrate (const geo_basic< T, M > &domain, const Expr &expr, const integrate_option &fopt=integrate_option())
 
template<class Expr >
std::enable_if< details::is_form_expr_v2_variational_arg< Expr >::value,form_basic< typename Expr::scalar_type, typename Expr::memory_type >>::type integrate (const Expr &expr, const integrate_option &fopt=integrate_option())
 
template<class Expr >
std::enable_if< details::is_form_expr_v2_variational_arg< Expr >::value,form_basic< typename Expr::scalar_type, typename Expr::memory_type >>::type integrate (const std::string &domname, const Expr &expr, const integrate_option &fopt=integrate_option())
 
template<class T , class M , class Expr >
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value,field_basic< typename Expr::scalar_type, typename Expr::memory_type >>::type integrate (const band_basic< T, M > &gh, const Expr &expr, const quadrature_option &qopt=quadrature_option())
 
template<class T , class M , class Expr >
std::enable_if< details::is_form_expr_v2_variational_arg< Expr >::value,form_basic< typename Expr::scalar_type, typename Expr::memory_type >>::type integrate (const band_basic< T, M > &gh, const Expr &expr, const integrate_option &fopt=integrate_option())
 
template<class T , class M >
field_basic< T, Minterpolate (const space_basic< T, M > &V2h, const field_basic< T, M > &u1h)
 
template<class T , class M , class Expr >
std::enable_if< details::is_field_expr_v2_nonlinear_arg< Expr >::value &&! details::is_field_expr_v2_linear_arg< Expr >::value &&! details::is_field_function< Expr >::value,field_basic< T, M >>::type interpolate (const space_basic< T, M > &Xh, const Expr &expr)
 interpolate - Lagrange interpolation of a function More...
 
template<class T , class M , class Expr >
std::enable_if< details::is_field_function< Expr >::value,field_basic< T, M >>::type interpolate (const space_basic< T, M > &Xh, const Expr &expr)
 
template<class T , class M , class Expr >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value &&! details::is_field< Expr >::value,field_basic< T, M >>::type interpolate (const space_basic< T, M > &Xh, const Expr &expr)
 
 o_scalar (field_sequential, topography) o_scalar(point
 
origin o_scalar (point, normal) o_scalar(point_basic< size_t >
 
static size_t edge_t_iloc (size_t l, size_t m)
 
static size_t edge_T_iloc (size_t l, size_t m)
 
static size_t face_T_iloc (size_t l, size_t m, size_t n)
 
template<class T >
static bool is_zero (const T &x)
 
template<class T >
static bool have_same_sign (const T &x, const T &y)
 
template<class T >
static bool have_opposite_sign (const T &x, const T &y)
 
template<class T >
static bool belongs_to_band_t (const std::vector< T > &f)
 
template<class T >
static size_t isolated_vertex_t (const std::vector< T > &f)
 
template<class T >
static void subcompute_matrix_t (const std::vector< point_basic< T > > &x, const std::vector< T > &f, std::vector< size_t > &j, point_basic< T > &a, point_basic< T > &b, T &S)
 
template<class T >
static bool belongs_to_band_T (const std::vector< T > &f)
 
template<class T >
bool intersection_is_quadrilateral_T (const std::vector< T > &f, quadruplet &q)
 
template<class T >
static size_t isolated_vertex_T (const std::vector< T > &f)
 
template<class T >
static void subcompute_matrix_triangle_T (const std::vector< point_basic< T > > &x, const std::vector< T > &f, std::vector< size_t > &j, point_basic< T > &a, point_basic< T > &b, point_basic< T > &c, T &aire)
 
template<class T >
static void subcompute_matrix_quadrilateral_T (const std::vector< point_basic< T > > &x, const std::vector< T > &f, const quadruplet &q, point_basic< T > &a, point_basic< T > &b, point_basic< T > &c, point_basic< T > &d, T &aire_Q)
 
template<class T , class M >
void gamma_list2disarray (const std::list< point_basic< T > > &gamma_node_list, std::array< std::list< std::pair< element_type, size_t > >, reference_element::max_variant > gamma_side_list, const communicator &comm, size_t d, disarray< point_basic< T >, M > &gamma_node, std::array< disarray< element_type, M >, reference_element::max_variant > &gamma_side, disarray< size_t, M > &sid_ie2bnd_ie)
 
template<class T , class M >
geo_basic< T, Mlevel_set (const field_basic< T, M > &fh, const level_set_option &opt)
 
template<class T , class M >
field_basic< T, Mlimiter (const field_basic< T, M > &uh, const T &bar_g_S, const limiter_option_type &opt)
 
template<class Problem , class Preconditioner , class Field , class Real >
int newton_backtrack (const Problem &P, const Preconditioner &T, const Field &u_old, Float Tu_old, Field &delta_u, Real slope, Real norm_delta_u_max, Field &u, Field &Fu, Real &Tu, Real &lambda, odiststream *p_derr=0)
 
template<class Problem , class Field >
int newton (const Problem &P, Field &uh, Float &tol, size_t &max_iter, odiststream *p_derr=0)
 newton – Newton nonlinear algorithm More...
 
template<class T , class M >
point_basic< T > piola_transformation (const geo_basic< T, M > &omega, const basis_on_pointset< T > &piola_on_pointset, reference_element hat_K, const std::vector< size_t > &dis_inod, size_t q)
 
template<class T , class M >
void jacobian_piola_transformation (const geo_basic< T, M > &omega, const basis_on_pointset< T > &piola_on_pointset, reference_element hat_K, const std::vector< size_t > &dis_inod, const point_basic< T > &hat_x, tensor_basic< T > &DF)
 
template<class T , class M >
void jacobian_piola_transformation (const geo_basic< T, M > &omega, const basis_on_pointset< T > &piola_on_pointset, reference_element hat_K, const std::vector< size_t > &dis_inod, size_t q, tensor_basic< T > &DF)
 
template<class T >
det_jacobian_piola_transformation (const tensor_basic< T > &DF, size_t d, size_t map_d)
 
template<class T , class M >
point_basic< T > normal_from_piola_transformation (const geo_basic< T, M > &omega, const geo_element &S, const tensor_basic< T > &DF, size_t d)
 
template<class T >
tensor_basic< T > pseudo_inverse_jacobian_piola_transformation (const tensor_basic< T > &DF, size_t d, size_t map_d)
 
template<class T >
weight_coordinate_system (space_constant::coordinate_type sys_coord, const point_basic< T > &xq)
 
template<class T , class M >
weight_coordinate_system (const geo_basic< T, M > &omega, const basis_on_pointset< T > &piola_table, const geo_element &K, const std::vector< size_t > &dis_inod, size_t q)
 
template<class T >
void map_projector (const tensor_basic< T > &DF, size_t d, size_t map_d, tensor_basic< T > &P)
 
template<class T >
static point_basic< T > inv_piola_e (const point_basic< T > &x, const point_basic< T > &a, const point_basic< T > &b)
 
template<class T >
static point_basic< T > inv_piola_t (const point_basic< T > &x, const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c)
 
template<class T >
static point_basic< T > inv_piola_T (const point_basic< T > &x, const point_basic< T > &a, const point_basic< T > &b, const point_basic< T > &c, const point_basic< T > &d)
 
template<class T , class M >
point_basic< T > inverse_piola_transformation (const geo_basic< T, M > &omega, const reference_element &hat_K, const std::vector< size_t > &dis_inod, const point_basic< T > &x)
 
 _RHEOLEF_instanciation1 (Float) _RHEOLEF_instanciation2(Float
 
template<class T , class M >
void jacobian_piola_transformation (const geo_basic< T, M > &omega, reference_element hat_K, const std::vector< size_t > &dis_inod, const point_basic< T > &hat_x, tensor_basic< T > &DF)
 
template<class T , class M , class Function >
field_basic< T, Mriesz (const space_basic< T, M > &Xh, const Function &f, const quadrature_option &qopt=quadrature_option()) @endcode
 riesz - approximate a Riesz representer More...
 
template<class T , class M , class Function >
field_basic< T, Mriesz (const space_basic< T, M > &Xh, const Function &f, const geo_basic< T, M > &dom, const quadrature_option &qopt=quadrature_option()) @endcode
 
template<class T , class M , class Function >
field_basic< T, Mriesz (const space_basic< T, M > &Xh, const Function &f, std::string dom_name, const quadrature_option &qopt=quadrature_option()) @endcode
 
template<class T , class M , class Function >
field_basic< T, Mriesz (const space_basic< T, M > &Xh, const Function &f, const band_basic< T, M > &gh, const quadrature_option &qopt=quadrature_option()) @endcode
 
template<class Expr , class T2 >
std::enable_if< details::is_field_expr_v2_linear_arg< Expr >::value,field_basic< typename Expr::scalar_type,typename Expr::memory_type >>::type round (const Expr &expr, const T2 &prec)
 
template<class T , class M >
std::ostream & put (std::ostream &os, const space_constitution< T, M > &constit, size_t level=0)
 
template<class T , class M >
std::ostream & operator<< (std::ostream &os, const space_constitution< T, M > &constit)
 
template std::ostream & operator<< (std::ostream &, const space_constitution< Float, sequential > &)
 
template<class T , class M >
idiststream & operator>> (idiststream &, space_constitution< T, M > &)
 
int space_constitution_lex ()
 
void space_constitution_error (const char *msg)
 
int space_constitution_wrap ()
 
static const std::string & symbol (size_t i)
 
static size_t insert (const std::string &str)
 
int space_constitution_parse (void)
 
static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 
int yyparse (void)
 
void * space_constitution_alloc (yy_size_t)
 
void * space_constitution_realloc (void *, yy_size_t)
 
void space_constitution_free (void *)
 
 if (!(yy_init))
 
void tree_dump (const tree_type &x, std::ostream &out, size_t level=0)
 
static void space_constitution_get_pass_1_2 (idiststream &ids)
 
template<class T , class M >
static space_constitution< T, Mbuild_from_tree (const tree_type &x)
 
template idiststream & operator>> (idiststream &, space_constitution< Float, sequential > &)
 
template<class T , class M >
space_mult_list< T, Moperator* (const space_basic< T, M > &X, const space_basic< T, M > &Y)
 
template<class T , class M >
const space_mult_list< T, M > & operator* (const space_mult_list< T, M > &Xm, const space_basic< T, M > &Y)
 
template<class T , class M >
space_mult_list< T, M > & operator*= (space_mult_list< T, M > &Xm, const space_basic< T, M > &Y)
 
template<class T , class M >
const space_mult_list< T, M > & operator* (const space_basic< T, M > &X, const space_mult_list< T, M > &Ym)
 
template<class T , class M >
space_mult_list< T, Mpow (const space_basic< T, M > &X, size_t n)
 

Variables

static iorheo::force_initialization dummy
 
static const char * rheo_path_name = "RHEOPATH"
 
static const char * default_rheo_path = "."
 
static char * rheo_path = 0
 
static const bool dont_gzip = false
 
odiststream dout (cout)
 
odiststream dlog (clog)
 
odiststream derr (cerr)
 
rheolef::std Expr1
 
rheolef::std value
 
static const char * static_family_name [quadrature_option::max_family+1]
 
static const Float hat_K_measure [reference_element::max_variant]
 
const reference_element::size_type geo_element_T_fac2edg_idx [4][3]
 
const reference_element::size_type geo_element_P_fac2edg_idx [5][4]
 
const reference_element::size_type geo_element_H_fac2edg_idx [6][4]
 
const int geo_element_T_fac2edg_orient [4][3]
 
const int geo_element_P_fac2edg_orient [5][4]
 
const int geo_element_H_fac2edg_orient [6][4]
 
const unsigned int tiny_size_max = 32
 
static Float band_epsilon = 100*std::numeric_limits<Float>::epsilon()
 
rheolef::std BinaryFunction
 
static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<result_type>::value
 
BinaryFunction _f
 
Expr1 _expr1
 
Expr2 _expr2
 
rheolef::std Function
 
rheolef::std functor_type
 
rheolef::std type
 
static const char * label_variant []
 
static Float level_set_epsilon = 100*std::numeric_limits<Float>::epsilon()
 
static tree_typeresult_ptr
 
static size_type space_constitution_line_no = 1
 
static size_type space_constitution_n_error = 0
 
static std::vector< std::string > symbol_table
 
YYSTYPE space_constitution_lval
 
static const yytype_uint8 yytranslate []
 
static const yytype_int8 yypact []
 
static const yytype_uint8 yydefact []
 
static const yytype_int8 yypgoto []
 
static const yytype_int8 yydefgoto []
 
static const yytype_int8 yytable []
 
static const yytype_int8 yycheck []
 
static const yytype_uint8 yystos []
 
static const yytype_uint8 yyr1 []
 
static const yytype_uint8 yyr2 []
 
int yychar
 
YYSTYPE yylval
 
int yynerrs
 
int yyleng
 
static yyconst flex_int16_t yy_accept [68]
 
static yyconst YY_CHAR yy_ec [256]
 
static yyconst YY_CHAR yy_meta [28]
 
static yyconst flex_uint16_t yy_base [70]
 
static yyconst flex_int16_t yy_def [70]
 
static yyconst flex_uint16_t yy_nxt [110]
 
static yyconst flex_int16_t yy_chk [110]
 
 YY_DECL
 The main scanner function which does all the work. More...
 
char * yy_cp
 
char * yy_bp
 
int yy_act
 
static std::set< size_t > empty_set
 

Detailed Description

irheostream, orheostream - large data streams

limiter - discontinuous Galerkin slope limiter

iofem - input and output finite element manipulators

functor - a function wrapper suitable for field expressions

continuation – continuation algorithm for nonlinear problems

compose - a n-ary function with n fields

tensor4 - a fouth order tensor

tensor3 - a third order tensor

tensor - a N*N tensor, N=1,2,3

geo_element - element of a mesh

mpi_scatter_init – gather/scatter initialize

gmres – generalized minimum residual method

environment - rheolef initialization

Returns the size of physical memory (RAM) in bytes.

Returns the current resident set size (physical memory use) measured in bytes, or zero if the value cannot be determined on this OS.

Vector - STL vector<T> with reference counting

smart_pointer, smart_pointer_clone - reference counted safe pointer with true copy semantic

ABSTRACT

This class provides a stream interface for large data management. File decompresion is assumed using gzip and a recursive search in a directory list is provided for input.

orheostream foo("NAME", "suffix");

is like

ofstream foo("NAME.suffix").

However, if NAME does not end with `.suffix', then `.suffix' is automatically added. By default, compression is performed on the fly with gzip, adding an additional `.gz' suffix. The flush action is nicely handled in compression mode:

foo.flush();

This feature allows intermediate results to be available during long computations. The compression can be deactivated while opening a file by an optional argument:

orheostream foo("NAME", "suffix", io::nogz);

An existing compressed file can be reopen in append mode: new results will be appended at the end of an existing file:

orheostream foo("NAME", "suffix", io::app);

Conversely,

irheostream foo("NAME","suffix");

is like

ifstream foo("NAME.suffix").

However, we look at a search path environment variable RHEOPATH in order to find NAME while suffix is assumed. Moreover, gzip compressed files, ending with the `.gz' suffix is assumed, and decompression is done.

Finally, a set of useful functions are provided.

The following code:

irheostream is("results", "data");

will recursively look for a `results[.data[.gz]]' file in the directory mentioned by the RHEOPATH environment variable.

For instance, if you insert in our ".cshrc" something like:

setenv RHEOPATH ".:/home/dupont:/usr/local/math/demo"

the process will study the current directory `.', then, if neither `square.data.gz' nor `square.data' exits, it scan all subdirectory of the current directory. Then, if file is not founded, it start recusively in `/home/dupond' and then in `/usr/local/math/demo'.

File decompression is performed by using the gzip command, and data are pipe-lined directly in memory.

If the file start with `.' as `./square' or with a `/' as `/home/oscar/square', no search occurs and RHEOPATH environment variable is not used.

Also, if the environment variable RHEOPATH is not set, the default value is the current directory `.'.

For output stream:

orheostream os("newresults", "data");

file compression is assumed, and "newresults.data.gz" will be created.

File loading and storing are mentioned by a message, either:

! load "./results.data.gz"

or:

! file "./newresults.data.gz" created.

on the clog stream. By adding the following:

clog << noverbose;

you turn off these messages (see iorheo ialgorithm).

Here is a convenient way to implement a true copy semantic, by using shallow copies and reference counting, in order to minimise memory copies. This concept is generally related to the smart pointer method for managing memory.

The true semantic copy is defined as follows: if an object A is assigned to B, such as A = B, every further modification on A or B does not modify the other.

Notice that this class differs from the boost::shared_ptr class that implements safe pointers without the true copy semantic.

CLONE VARIANT

The smart_pointer_clone variant uses a T* T::clone() const member function instead of the usual T::T() copy constructor for obtaining a true copy of the data. This variant is motivated as follows: when using hierarchies of derived classes (also known as polymorphic classes), the usual copy is not possible because c++ copy constructors cannot be virtual, so you cannot make a copy this way. This is a well-known problem with C++'s implementation of polymorphism.

We uses a solution to the non-virtual copy constructor problem which is suggested by Ellis and Stroustrup in "The Annotated LRM". The solution is to require the T class to provide a virtual clone method for every class which makes a copy using new and the correct copy constructor, returning the result as a pointer to the superclass T. Each subclass of T overloads this function with its own variant which copies its own type. Thus the copy operation is now virtual and furthermore is localised to the individual subclass.

NOCOPY VARIANT

This variant of the smart pointer is designed for use on objects that cannot (or must not) be copied. An example would be when managing an object that contains, say, a file handle. It is essential that this not be copied because then you get the problem of deciding which copy is responsible for closing the file. To avoid the problem, wrap the file handle in a class and then manage a unique instance of it using a smart_pointer_nocopy. This ensures that the file handle cannot be copied and is closed when the last alias is destroyed.

The interface to the nocopy variant is the same as smart_pointer but with all operations that perform copying forbidden. In fact, because all three variants are instances of a common superclass, the forbidden methods do exist but will cause an error and exit if they are called.

The following modifiers cannot be used because they use copying of the pointed-to object and will thereore cause an error:

T* operator-> ();
T* pointer ();
T& data ();

EFERENCES

[1] A. Geron and F. Tawbi,
Pour mieux developer avec C++ : design pattern, STL, RTTI et smart pointers,
InterEditions, 1999. Page 118.
[2] STLplus, http://stlplus.sourceforge.net/stlplus3/docs/smart_ptr.html
for the clone and nocopy variants.

The class implement a reference counting wrapper for the STL vector<T> container class, with shallow copies. See also: The standard template library, by Alexander Stephanov and Meng Lee.

This class provides the full vector<T> interface specification an could be used instead of vector<T>.

NOTE

The write accessors

T& operator[](size_type)

as in v[i] may checks the reference count for each access. For a loop, a better usage is:

Vector<T>::iterator i = v.begin();
Vector<T>::iterator last = v.end();
while (i != last) { ...}

and the reference count check step occurs only two time, when accessing via begin() and end().

Thus, in order to encourage users to do it, we declare private theses member functions. A synonym of operator[] is at.

SYNOPSIS

This class is mainly used to initialize the MPI library: it should be called juste after the main(argc,argv) declaration as in:

#include "rheolef.h"
using namespace rheolef;
int main(int argc, char**argv) {
environment rheolef (argc, argv);
...
}

An optional third argument of the environment constructor allows one to set the MPI thread feature. By default, its value is MPI_THREAD_SINGLE, as defined in mpi.h. Other possible values are related to MPI multi-threaded, see the MPI documentation for more details.

SYNOPSIS

template <class Matrix, class Vector, class Preconditioner,
class SmallMatrix, class SmallVector, class Real, class Size>
int gmres (const Matrix &A, Vector &x, const Vector &b, const Preconditioner &M,
SmallMatrix &H, const SmallVector& dummy,
const solver_option& sopt);

EXAMPLE

The simplest call to gmres has the folling form:

solver_option sopt;
sopt.tol = 1e-7;
sopt.max_iter = 100;
size_t m = sopt.krylov_dimension;
boost::numeric::ublas::matrix<T> H(m+1,m+1);
vec<T,sequential> dummy(m,0.0);
int status = gmres (a, x, b, ic0(a), H, dummy, sopt);

gmres solves the unsymmetric linear system Ax = b using the generalized minimum residual method.

The return value indicates convergence within max_iter (input) iterations (0), or no convergence within max_iter iterations (1). Upon successful return, output arguments have the following values:

x

approximate solution to Ax = b

sopt.n_iter

the number of iterations performed before the tolerance was reached

sopt.residue
the residual after the final iteration

See also the solver_option. In addition, M specifies a preconditioner, H specifies a matrix to hold the coefficients of the upper Hessenberg matrix constructed by the gmres iterations, m specifies the number of iterations for each restart.

gmres requires two matrices as input, A and H. The matrix A, which will typically be a sparse matrix) corresponds to the matrix in the linear system Ax=b. The matrix H, which will be typically a dense matrix, corresponds to the upper Hessenberg matrix H that is constructed during the gmres iterations. Within gmres, H is used in a different way than A, so its class must supply different functionality. That is, A is only accessed though its matrix-vector and transpose-matrix-vector multiplication functions. On the other hand, gmres solves a dense upper triangular linear system of equations on H. Therefore, the class to which H belongs must provide H(i,j) operator for element access.

NOTE

It is important to remember that we use the convention that indices are 0-based. That is H(0,0) is the first component of the matrix H. Also, the type of the matrix must be compatible with the type of single vector entry. That is, operations such as H(i,j)*x(j) must be able to be carried out.

gmres is an iterative template routine.

gmres follows the algorithm described on p. 20 in Templates for the solution of linear systems: building blocks for iterative methods, 2nd Edition, R. Barrett, M. Berry, T. F. Chan, J. Demmel, J. Donato, J. Dongarra, V. Eijkhout, R. Pozo, C. Romine, H. Van der Vorst, SIAM, 1994, ftp.netlib.org/templates/templates.ps.

The present implementation is inspired from IML++ 1.2 iterative method library, http://math.nist.gov/iml++.

See also
solver_option.

Initialize communication for distributed to sequential scatter context.

COMPLEXITY

Time and memory complexity is O(nidx+nproc). For finite-element problems in d dimenion

| nidx ~ N^((d-1)/d)

where N is the number of degrees of freedom.

IMPLEMENTATION Inspirated from petsc-2.0/vpscat.c: VecScatterCreate_PtoS()

Defines geometrical elements and sides as a set of vertice and edge indexes. This element is obtained after a Piola transformation from a reference element (see reference_element). Indexes are related to arrays of edges and vertices. These arrays are included in the description of the mesh. Thus, this class is related of a given mesh instance (see geo).

EXAMPLE

This is the test of geo_element:

geo_element K;
K.set_name('t') ;
cout << "n_vertices: " << K.size() << endl
<< "n_edges : " << K.n_edges() << endl
<< "dimension : " << K.dimension() << endl << endl;
for(geo_element::size_type i = 0; i < K.size(); i++)
K[i] = i*10 ;
for(geo_element::size_type i = 0; i < K.n_edges(); i++)
K.set_edge(i, i*10+5) ;
cout << "vertices: local -> global" << endl;
for (geo_element::size_type vloc = 0; vloc < K.size(); vloc++)
cout << vloc << "-> " << K[vloc] << endl;
cout << endl
<< "edges: local -> global" << endl;
for (geo_element::size_type eloc = 0; eloc < K.n_edges(); eloc++) {
geo_element::size_type vloc1 = subgeo_local_vertex(1, eloc, 0);
geo_element::size_type vloc2 = subgeo_local_vertex(1, eloc, 1);
cout << eloc << "-> " << K.edge(eloc) << endl
<< "local_vertex_from_edge(" << eloc
<< ") -> (" << vloc1 << ", " << vloc2 << ")" << endl;
}
See also
geo, reference_element.

SYNOPSIS

The tensor class defines a 3*3 tensor, as the value of a tensorial valued field. Basic algebra with scalars, vectors of R^3 (i.e. the point class) and tensor objects are supported.

SYNOPSIS

The tensor3 class defines a fourth tensor where indices varie from zero to 2 (aka 3D physical space).

SYNOPSIS

The tensor4 class defines a fourth tensor where indices varie from zero to 2 (aka 3D physical space).

Compose a n-ary function f with n fields.

geo omega ("circle");
space Xh (omega, "P1");
field uh (Xh, 1.0);

The compose operator could be used in all non-linear expressions involved in either the interpolate or the integrate functions (see interpolate algorithm and integrate algorithm). The f function could be either a usual function or a functor.

CHARACTERISTIC

The compose function supports also the characteristic algorithm (see characteristic) used for convection.

characteristic X (-delta_t*uh);
test v (Xh);
field lh = integrate (compose(uh,X)*v);

IMPLEMENTATION

The n-arity bases on the variadic template feature of the 2011 c++ normalisation. When this feature is not available, only unary and binary functions are supported.

See also
characteristic.

This function applies a continuation algorithm for the resolution of the following problem:

F(lambda,u) = 0

where lambda is a parameter and u is the corresponding solution. The main idea is to follow a branch of solution u(lambda) when the parameter lambda varies. A simple call to the algorithm writes:

my_problem P;
field uh (Vh,0);
continuation (P, uh, &dout, &derr);

The continuation algorithm bases on the damped_newton (see damped_newton algorithm) and thus requirement for the my_problem class may contains methods for the evaluation of F (aka the residue) and its derivative:

class my_problem {
public:
typedef value_type;
typedef float_type;
string parameter_name() const;
float_type parameter() const;
void set_parameter (float_type lambda);
value_type residue (const value_type& uh) const;
void update_derivative (const value_type& uh) const;
csr<float_type> derivative (const value_type& uh) const;
value_type derivative_versus_parameter (const field& uh) const;
value_type derivative_solve (const value_type& mrh) const;
value_type derivative_trans_mult (const value_type& mrh) const;
bool stop (const value_type& xh) const;
idiststream& get (idiststream& is, value_type& uh);
odiststream& put (odiststream& os, const value_type& uh) const;
float_type space_norm (const value_type& uh) const;
float_type dual_space_norm (const value_type& mrh) const;
float_type space_dot (const value_type& xh, const value_type& yh) const;
float_type dual_space_dot (const value_type& mrh, const value_type& msh) const;
value_type massify (const value_type& uh) const;
value_type unmassify (const value_type& mrh) const;
};

See the example combustion.h in the user's documentation for more. The optional argument of type class continuation_option (see continuation_option) allows one to control some features of the algorithm.

See also
continuation_option.

A functor is a class-function, i.e. a class that defines the operator(): it can be used in place of an usual function. Moreover, functors can be used in Rheolef field expressions, mixed with fields (see field). For instance, assuming that uh is a field and u_ex is a functor:

Float err_l1 = integrate (omega, abs(uh - uh_ex), qopt);

where omega denotes a mesh (see geo) and qopt a quadrature formula (see quadrature_option). See also the integrate algorithm function. An usual function u_ex_f cannot always be mixed so nicely in expressions, due to c++ language rules. For instance, the following exprtession is valid:

Float err_l1 = integrate (omega, abs(uh - u_ex_f), qopt);

In some case, the compiler cannot build a field expression using usual functionsn e.g.

Float I = integrate (omega, 0.5*u_ex_f), qopt);

because 0.5*u_ex_f is a direct algebraic operation between usual functions and flmoating points, that is not defined in the c++ language. A way to circumvent this difficulty is to convert the usual function into a functor, as in:

Float I = integrate (omega, 0.5*functor(u_ex_f)), qopt);
See also
field, geo, quadrature_option.

This class implements some specific finite element manipulators. For a general presentation of stream manipulators, reports to class iostream.

VALUATED MANIPULATORS

origin
normal
set a cutting plane for visualizations and post-processing.
cout << cut << origin(point(0.5, 0.5, 0.5)) << normal(point(1,1,0) << uh;
topography
specifies the topography field when representing a bidimensionnal field in tridimensionnal elevation.
cout << topography(zh) << uh;
This manipulator takes an agument that specifies a scalar field value zh for the elevation, while uh is the scalar field to represent. Then, the z-elevation takes zh(x,y)+uh(x,y).

SYNOPSIS

field limiter (const field& uh, options...);

This function returns a slope limited field for any supplied discontinuous approximation.

geo omega ("square");
space Xh (omega, "P1d");
field uh (Xh);
...
field vh = limiter(uh);

This function is still in development as a prototype: it supports only d=1 dimension and k=0 or 1 polynomial degrees. Its generalization to 2D and 3D geometries and any polynomial degree is in development.

Typedef Documentation

◆ Float

typedef double rheolef::Float

Definition at line 160 of file compiler.h.

◆ heap_allocator

template<class T >
using rheolef::heap_allocator = typedef std::allocator<T>

Definition at line 42 of file heap_allocator.h.

◆ solver

Definition at line 172 of file solver.h.

◆ solver_abtb

Definition at line 90 of file solver_abtb.h.

◆ solver_option_type

Definition at line 161 of file solver_option.h.

◆ point

Definition at line 122 of file point.h.

◆ quadrature_option_type

Definition at line 68 of file quadrature_option.h.

◆ tensor

Definition at line 85 of file tensor.h.

◆ tensor3

Definition at line 55 of file tensor3.h.

◆ tensor4

Definition at line 61 of file tensor4.h.

◆ adapt_option_type

Definition at line 131 of file adapt.h.

◆ band

Definition at line 68 of file band.h.

◆ branch

Definition at line 179 of file branch.h.

◆ characteristic

Definition at line 142 of file characteristic.h.

◆ continuation_option_type

Definition at line 57 of file continuation_option.h.

◆ domain_indirect

Definition at line 270 of file domain_indirect.h.

◆ field

Definition at line 382 of file field.h.

◆ field_sequential

Definition at line 383 of file field.h.

◆ result_type

typedef details::generic_binary_traits<BinaryFunction>::template result_hint<typename Expr1::result_type,typename Expr2::result_type>::type rheolef::result_type

Definition at line 254 of file field_expr_v2_nonlinear.h.

◆ value_type

Definition at line 255 of file field_expr_v2_nonlinear.h.

◆ scalar_type

Definition at line 256 of file field_expr_v2_nonlinear.h.

◆ float_type

Definition at line 257 of file field_expr_v2_nonlinear.h.

◆ memory_type

typedef Expr1::memory_type rheolef::memory_type

Definition at line 258 of file field_expr_v2_nonlinear.h.

◆ form

Definition at line 230 of file form.h.

◆ geo

geo - the default mesh class

Definition at line 1341 of file geo.h.

◆ domain

geo_domain_indirect_rep - a named part of a finite element mesh

The geo_domain_indirect_rep class defines a container for a part of a finite element mesh. This describes the connectivity of edges or faces. This class is useful for boundary condition setting.

IMPLEMENTATION NOTE

The geo_domain_indirect_rep class is split into two parts. The first one is the domain_indirect class, that contains the main renumbering features: it acts as an indirection on a geo class(see geo). The second one is the geo class itself, named here the background geo. Thus, the geo_domain_indirect class develops a complete geo-like interface, via the geo_abstract_rep pure virtual class derivation, and can be used by the space class (see space).

The split between domain_indirect and geo_domain_indirect is necessary, because the geo class contains a list of domain_indirect. The geo class cannot contains a list of geo_domain_indirect classes, that refers to the geo class itself: a loop in reference counting leads to a blocking situation in the automatic deallocation.

See also
geo, space.

Definition at line 38 of file geo_domain_indirect.h.

◆ my_idxtype

typedef int rheolef::my_idxtype

Definition at line 8 of file geo_partition_scotch.h.

◆ idxtype

Definition at line 10 of file geo_partition_scotch.h.

◆ KeyValueType

Definition at line 64 of file geo_partition_scotch.h.

◆ form_option_type

Definition at line 63 of file integrate_option.h.

◆ element_type

Definition at line 284 of file level_set.cc.

◆ level_set_option_type

Definition at line 41 of file level_set.h.

◆ space

Definition at line 232 of file space.h.

◆ list_type

typedef std::list<tree_type> rheolef::list_type

Definition at line 28 of file space_constitution_get.cc.

◆ size_type

Definition at line 53 of file space_constitution_get.cc.

◆ YYSTYPE

typedef union YYSTYPE rheolef::YYSTYPE

Definition at line 137 of file space_constitution_get.cc.

◆ yytype_uint8

typedef unsigned char rheolef::yytype_uint8

Definition at line 160 of file space_constitution_get.cc.

◆ yytype_int8

typedef signed char rheolef::yytype_int8

Definition at line 166 of file space_constitution_get.cc.

◆ yytype_uint16

typedef unsigned short int rheolef::yytype_uint16

Definition at line 172 of file space_constitution_get.cc.

◆ yytype_int16

typedef short int rheolef::yytype_int16

Definition at line 178 of file space_constitution_get.cc.

◆ flex_int8_t

typedef signed char rheolef::flex_int8_t

Definition at line 55 of file space_constitution_get.cc.

◆ flex_int16_t

typedef short int rheolef::flex_int16_t

Definition at line 56 of file space_constitution_get.cc.

◆ flex_int32_t

typedef int rheolef::flex_int32_t

Definition at line 57 of file space_constitution_get.cc.

◆ flex_uint8_t

typedef unsigned char rheolef::flex_uint8_t

Definition at line 58 of file space_constitution_get.cc.

◆ flex_uint16_t

typedef unsigned short int rheolef::flex_uint16_t

Definition at line 59 of file space_constitution_get.cc.

◆ flex_uint32_t

typedef unsigned int rheolef::flex_uint32_t

Definition at line 60 of file space_constitution_get.cc.

◆ YY_BUFFER_STATE

Definition at line 162 of file space_constitution_get.cc.

◆ yy_size_t

typedef size_t rheolef::yy_size_t

Definition at line 167 of file space_constitution_get.cc.

◆ YY_CHAR

typedef unsigned char rheolef::YY_CHAR

Definition at line 307 of file space_constitution_get.cc.

◆ yy_state_type

Definition at line 329 of file space_constitution_get.cc.

◆ test

Definition at line 234 of file test.h.

◆ trial

Definition at line 235 of file test.h.

Enumeration Type Documentation

◆ yytokentype

Enumerator
IDENTIFIER 
SCALAR 
VECTOR 
TENSOR 
UNSYMMETRIC_TENSOR 
TENSOR4 
EQUISPACED 
WARBURTON 
FEKETE 

Definition at line 108 of file space_constitution_get.cc.

Function Documentation

◆ sqr()

static double rheolef::sqr ( const double &  x)
inlinestatic

Definition at line 203 of file compiler.h.

◆ operator>>() [1/21]

std::istream& rheolef::operator>> ( std::istream &  is,
const catchmark m 
)
inline

Definition at line 48 of file catchmark.h.

◆ operator<<() [1/34]

std::ostream& rheolef::operator<< ( std::ostream &  os,
const catchmark m 
)
inline

Definition at line 59 of file catchmark.h.

◆ pair_transform_second()

template<typename InputPairIterator , typename OutputPairIterator , typename UnaryOperation >
OutputPairIterator rheolef::pair_transform_second ( InputPairIterator  first,
InputPairIterator  last,
OutputPairIterator  result,
UnaryOperation  unary_op 
)

Definition at line 21 of file pair_util.h.

◆ operator<<() [2/34]

template<class T1 , class T2 >
std::ostream& rheolef::operator<< ( std::ostream &  out,
const std::pair< T1, T2 > &  x 
)

Definition at line 34 of file pair_util.h.

◆ indent()

std::string rheolef::indent ( std::string  str,
const std::string &  indent = "  " 
)

Definition at line 12 of file pretty_name.cc.

◆ typeid_name()

std::string rheolef::typeid_name ( const char *  name,
bool  do_indent 
)

typename_macro, pretty_typename_macro - type demangler and pretty printer

These preprocessor macro-definitions are useful when dealing with complex types as generated by imbricted template technics: they print in clear a complex type at run-time. typeid_name_macro obtains a human readable type in a std::tring form by calling the system typeid function and then a demangler. When this type is very long, pretty_name_macro prints also it in a multi-line form with a pretty indentation.

EXAMPLES

typedef map <size_t, double, less<size_t>, heap_allocator<pair<size_t,double> > > map_type;
cout << typeid_name_macro (map_type);

Definition at line 55 of file pretty_name.cc.

◆ get_tmpdir()

std::string rheolef::get_tmpdir ( )

Definition at line 35 of file rheostream.cc.

◆ ftos()

std::string rheolef::ftos ( const Float x)

Definition at line 40 of file rheostream.cc.

◆ has_suffix()

bool rheolef::has_suffix ( const string &  name,
const string &  suffix 
)

Definition at line 177 of file rheostream.cc.

◆ delete_suffix()

std::string rheolef::delete_suffix ( const string &  name,
const string &  suffix 
)

Definition at line 191 of file rheostream.cc.

◆ has_any_suffix()

bool rheolef::has_any_suffix ( const string &  name)

Definition at line 198 of file rheostream.cc.

◆ delete_any_suffix()

std::string rheolef::delete_any_suffix ( const string &  name)

Definition at line 208 of file rheostream.cc.

◆ get_basename()

std::string rheolef::get_basename ( const string &  name)

Definition at line 223 of file rheostream.cc.

◆ get_dirname()

std::string rheolef::get_dirname ( const string &  name)

Definition at line 232 of file rheostream.cc.

◆ get_dir_from_path()

static string rheolef::get_dir_from_path ( const string &  path,
unsigned int &  i_pos 
)
static

Definition at line 247 of file rheostream.cc.

◆ init_rheo_path()

static void rheolef::init_rheo_path ( )
static

Definition at line 274 of file rheostream.cc.

◆ append_dir_to_rheo_path()

void rheolef::append_dir_to_rheo_path ( const string &  dir)

Definition at line 287 of file rheostream.cc.

◆ prepend_dir_to_rheo_path()

void rheolef::prepend_dir_to_rheo_path ( const string &  dir)

Definition at line 296 of file rheostream.cc.

◆ have_name_in_dir()

static bool rheolef::have_name_in_dir ( const string &  dir,
const string &  name,
string &  full_path 
)
static

Definition at line 306 of file rheostream.cc.

◆ get_full_name_from_rheo_path()

std::string rheolef::get_full_name_from_rheo_path ( const string &  rootname,
const string &  suffix 
)

Definition at line 389 of file rheostream.cc.

◆ is_float()

bool rheolef::is_float ( const string &  s)

Definition at line 417 of file rheostream.cc.

◆ to_float()

Float rheolef::to_float ( const string &  s)

Definition at line 429 of file rheostream.cc.

◆ itos()

std::string rheolef::itos ( std::string::size_type  i)

◆ scatch()

bool rheolef::scatch ( std::istream &  in,
const std::string &  ch,
bool  full_match = true 
)

◆ file_exists()

bool rheolef::file_exists ( const std::string &  filename)

◆ rounder()

template<class T >
rounder_type<T> rheolef::rounder ( const T &  prec)

Definition at line 39 of file rounder.h.

◆ floorer()

template<class T >
floorer_type<T> rheolef::floorer ( const T &  prec)

Definition at line 40 of file rounder.h.

◆ ceiler()

template<class T >
ceiler_type<T> rheolef::ceiler ( const T &  prec)

Definition at line 41 of file rounder.h.

◆ operator==()

template<typename T1 >
bool rheolef::operator== ( const stack_allocator< T1 > &  lhs,
const stack_allocator< T1 > &  rhs 
)
throw (
)

◆ operator!=()

template<typename T1 >
bool rheolef::operator!= ( const stack_allocator< T1 > &  lhs,
const stack_allocator< T1 > &  rhs 
)
throw (
)

◆ invert() [1/3]

template<class T >
bool rheolef::invert ( const ublas::matrix< T > &  input,
ublas::matrix< T > &  inverse 
)

Definition at line 14 of file ublas-invert.h.

◆ invert() [2/3]

template<class T >
boost::numeric::ublas::matrix<T> rheolef::invert ( const boost::numeric::ublas::matrix< T > &  m,
bool &  is_singular 
)

Definition at line 31 of file ublas-invert.h.

◆ determinant() [1/3]

template<class matrix_T >
double rheolef::determinant ( ublas::matrix_expression< matrix_T > const &  mat_r)

Definition at line 39 of file ublas-invert.h.

◆ operator<<() [3/34]

template<class T >
std::ostream& rheolef::operator<< ( std::ostream &  out,
const ublas::vector< T > &  b 
)

Definition at line 11 of file ublas-io.h.

◆ operator<<() [4/34]

template<class T >
std::ostream& rheolef::operator<< ( std::ostream &  out,
const ublas::matrix< T > &  A 
)

Definition at line 23 of file ublas-io.h.

◆ invert_3x3() [1/3]

template<class T >
bool rheolef::invert_3x3 ( const ublas::matrix< T > &  A,
ublas::matrix< T > &  result 
)

Definition at line 14 of file ublas_invert_3x3.h.

◆ mr_set()

template<class Range1 , class Range2 >
static void rheolef::mr_set ( ublas::matrix< Float > &  m,
Range1  r1,
Range2  r2,
const ublas::matrix< Float > &  m_expr 
)
inlinestatic

Definition at line 12 of file ublas_matrix_range.h.

◆ read_mm_header()

void rheolef::read_mm_header ( idiststream &  ips)

Definition at line 9 of file mm_io.cc.

◆ operator>>() [2/21]

template<class T , class M , class A >
idiststream& rheolef::operator>> ( idiststream &  s,
asr< T, M, A > &  x 
)
inline

Definition at line 124 of file asr.h.

◆ operator<<() [5/34]

template<class T , class M , class A >
odiststream& rheolef::operator<< ( odiststream s,
const asr< T, M, A > &  x 
)
inline

Definition at line 131 of file asr.h.

◆ asr_to_csr()

template<class InputPtrIterator , class Predicate , class Operation , class OutputPtrIterator , class OutputDataIterator >
OutputPtrIterator rheolef::asr_to_csr ( InputPtrIterator  iter_ptr_a,
InputPtrIterator  last_ptr_a,
Predicate  pred,
Operation  op,
OutputPtrIterator  iter_ptr_b,
OutputDataIterator  iter_data_b 
)

asr_to_csr – sequential sparse matrix convertion

Convert sequential "asr" to sequential "csr" sparse matrix format.

ALGORITHM

asr_to_csr

"input": the sparse asr matrix, predicate and operator | ia(0:2*nrow+1), a(0:nnz-1), | pred(.), op(.) "output": the sparse csr matrix | ib(0:nrow-1), b(0:nnz-1) begin | ib(0) := q := 0 | for i := 0 to nrow-1 do | for p := ia(2*i) to ia(2*i+1)-1 do | if pred(a(p)) then | b(q) := op(a(p)) | q := q + 1 | endif | endfor | ib(i+1) := q | endfor end

COMPLEXITY

Time and memory complexity is O(nnz).

NOTE

The output arrays are supposed to be coorectly allocated, i.e. large enough.

Definition at line 51 of file asr_to_csr.h.

◆ asr_to_csr_dist_logical()

template<class InputPtrIterator , class Predicate , class Set >
Set::value_type rheolef::asr_to_csr_dist_logical ( InputPtrIterator  iter_ptr_a,
InputPtrIterator  last_ptr_a,
Predicate  is_dia,
Set &  colext 
)

asr_to_csr_dist_logical – sparse matrix convertion

Logical pass for the distributed "asr" to the distributed "csr" sparse matrix format conversion. Build the set of column indexes out of the current processor range, and return the size of this set.

ALGORITHM

asr_to_csr_dist_logical

"input": the sparse asr matrix | ia(0:2*nrow+1), a(0:nnz-1), is_dia(.) "output": the external column set | colext(0:ncolext-1) begin | for i := 0 to nrow-1 do | for p := ia(2*i) to ia(2*i+1)-1 do | if not is_dia(a(p)) then | colext(ncolext) := a(p) | ncolext := ncolext + 1 | endif | endfor | endfor end

NOTE

Practical implementation build the sorted set "colext" by using STL set.

The predicate "is_dia" returns true when the matrix entry has its column in the local column range of the processor.

COMPLEXITY

Time and memory complexity is O(nnz + ncolext*log(ncolext)).

Definition at line 54 of file asr_to_csr_dist_logical.h.

◆ cg()

template<class Matrix , class Vector , class Vector2 , class Preconditioner >
int rheolef::cg ( const Matrix &  A,
Vector x,
const Vector2 &  Mb,
const Preconditioner &  M,
const solver_option sopt = solver_option() 
)

cg – conjugate gradient algorithm.

SYNOPSIS

template <class Matrix, class Vector, class Preconditioner, class Real>
int cg (const Matrix &A, Vector &x, const Vector &b,
const solver_option& sopt = solver_option())

EXAMPLE

The simplest call to cg has the folling form:

solver_option sopt;
sopt.max_iter = 100;
sopt.tol = 1e-7;
int status = cg(a, x, b, eye(), sopt);

cg solves the symmetric positive definite linear system Ax=b using the conjugate gradient method. The return value indicates convergence within max_iter (input) iterations (0), or no convergence within max_iter iterations (1). Upon successful return, output arguments have the following values:

x

approximate solution to Ax = b

sopt.n_iter

the number of iterations performed before the tolerance was reached

sopt.residue
the residual after the final iteration

See also the solver_option.

NOTE

cg is an iterative template routine.

cg follows the algorithm described on p. 15 in

Templates for the solution of linear systems: building blocks for iterative methods, 2nd Edition, R. Barrett, M. Berry, T. F. Chan, J. Demmel, J. Donato, J. Dongarra, V. Eijkhout, R. Pozo, C. Romine, H. Van der Vorst, SIAM, 1994, ftp.netlib.org/templates/templates.ps.

The present implementation is inspired from IML++ 1.2 iterative method library, http://math.nist.gov/iml++.

See also
solver_option.

Definition at line 73 of file cg.h.

◆ diag() [1/10]

template<class T , class M >
csr<T,M> rheolef::diag ( const vec< T, M > &  d)

Definition at line 33 of file csr.cc.

◆ operator*() [1/17]

template<class T >
csr<T,sequential> rheolef::operator* ( const T &  lambda,
const csr< T, sequential > &  a 
)
inline

Definition at line 365 of file csr.h.

◆ operator-() [1/2]

template<class T >
csr<T,sequential> rheolef::operator- ( const csr< T, sequential > &  a)
inline

Definition at line 374 of file csr.h.

◆ trans() [1/7]

template<class T >
csr<T,sequential> rheolef::trans ( const csr< T, sequential > &  a)
inline

Definition at line 381 of file csr.h.

◆ apply() [1/2]

template<class T , class M , class Function >
endcode csr<T,M> rheolef::apply ( Function  f,
const csr< T, M > &  a 
)

Definition at line 515 of file csr.h.

◆ apply() [2/2]

template<class T , class M , class Function >
csr<T,M> rheolef::apply ( T(*)(const T &)  f,
const csr< T, M > &  a 
)

Definition at line 531 of file csr.h.

◆ diag() [2/10]

template<class T , class M >
endcode csr<T,M> rheolef::diag ( const vec< T, M > &  )

Definition at line 33 of file csr.cc.

◆ operator>>() [3/21]

template<class T , class M >
idiststream& rheolef::operator>> ( idiststream &  s,
csr< T, M > &  x 
)
inline

Definition at line 545 of file csr.h.

◆ operator<<() [6/34]

template<class T , class M >
odiststream& rheolef::operator<< ( odiststream s,
const csr< T, M > &  x 
)
inline

Definition at line 552 of file csr.h.

◆ trans() [2/7]

template<class T , class M >
vec_trans<T,M> rheolef::trans ( const vec< T, M > &  w)
inline

Definition at line 17 of file csr_concat.h.

◆ trans() [3/7]

template<class T , class M >
vector_vec_trans<T,M> rheolef::trans ( const std::vector< vec< T, M > > &  w)
inline

Definition at line 28 of file csr_concat.h.

◆ csr_cumul_trans_mult()

template<class InputIterator1 , class InputIterator3 , class SetOperator , class RandomAccessMutableIterator >
void rheolef::csr_cumul_trans_mult ( InputIterator1  ia,
InputIterator1  last_ia,
InputIterator3  x,
SetOperator  set_op,
RandomAccessMutableIterator  y 
)

Definition at line 37 of file csr_cumul_trans_mult.h.

◆ csr_csr_mult_size()

template<class T >
csr_rep<T,sequential>::size_type rheolef::csr_csr_mult_size ( const csr_rep< T, sequential > &  a,
const csr_rep< T, sequential > &  b 
)

Definition at line 343 of file csr_seq.cc.

◆ csr_csr_mult()

template<class T >
static void rheolef::csr_csr_mult ( const csr_rep< T, sequential > &  a,
const csr_rep< T, sequential > &  b,
csr_rep< T, sequential > &  c 
)
static

Definition at line 367 of file csr_seq.cc.

◆ csr_to_asr()

template<class InputPtrIterator , class InputDataIterator , class UnaryOperation , class OutputPtrIterator >
OutputPtrIterator rheolef::csr_to_asr ( InputPtrIterator  iter_ptr_a,
InputPtrIterator  last_ptr_a,
InputDataIterator  iter_data_a,
UnaryOperation  op,
OutputPtrIterator  iter_ptr_b 
)

csr_to_asr – sequential sparse matrix convertion

Convert sequential "csr" to sequential "asr" sparse matrix format.

ALGORITHM

csr_build_from_asr

"input": the sparse asr matrix | ia(0:nrow-1), a(0:nnz-1) | ib(0:2*nrow+1), op(.) "ouput": the sparse csr matrix | b(0:nnz-1) begin | q := 0 | for i := 0 to nrow-1 do | q := ib(2*i) | for p := ia(i) to ia(i+1)-1 do | b(q) := op(a(p)) | q := q + 1 | endfor | endfor end

COMPLEXITY

Time and memory complexity is O(nnz).

NOTE

The output arrays are supposed to be coorectly allocated, i.e. large enough.

The pointer array "ib" is taken as input parameter, since practical C++ "asr" implementation uses STL "map" for data storage. Thus "ib(.)" is an array of STL map, and this algorithm is only formal. METHODS:

Definition at line 53 of file csr_to_asr.h.

◆ operator/() [1/4]

template<class T , class M >
dia< T, M > rheolef::operator/ ( const T &  lambda,
const dia< T, M > &  d 
)
inline

Definition at line 118 of file dia.h.

◆ operator*() [2/17]

template<class T , class M >
vec< T, M > rheolef::operator* ( const dia< T, M > &  d,
const vec< T, M > &  x 
)
inline

Definition at line 125 of file dia.h.

◆ diag() [3/10]

template<class T , class M >
dia<T,M> rheolef::diag ( const csr< T, M > &  a)

diag - get diagonal part of a matrix

This function get the diagonal part of a matrix.

csr<Float> a;
dia<Float> d = diag(a);

TODO

Build a csr matrix from a diagonal one or from a vector:

dia<Float> d;
csr<Float> a = diag(d);
vec<Float> u;
csr<Float> b = diag(u);

Definition at line 28 of file diag.h.

◆ dis_accumulate() [1/2]

template<class InputIterator , class Size >
std::iterator_traits<InputIterator>::value_type rheolef::dis_accumulate ( InputIterator  first,
Size  n,
const distributor::communicator_type comm,
sequential   
)

dis_accumulate - distributed accumulate algorithm

STL-like accumulate for distributed containers environment.

SYNOPSIS

template<class InputIterator, class Size>
T dis_accumulate (InputIterator first, Size n);

EXAMPLE

A sample usage writes:

# include "rheolef/disarray.h"
# include "rheolef/dis_accumulate.h"
int main(int argc, char**argv) {
environment distributed (argc, argv);
unsigned int n = 100;
disarray<double> x(n, 2.0);
double sum = dis_accumulate(x.begin(),x.size(),x.comm());
dout << "dot(x,1) = " << sum << endl;
}

Definition at line 41 of file dis_accumulate.h.

◆ dis_accumulate() [2/2]

template<class InputIterator , class Size >
std::iterator_traits<InputIterator>::value_type rheolef::dis_accumulate ( InputIterator  first,
Size  n,
const distributor::communicator_type comm 
)
inline

Definition at line 73 of file dis_accumulate.h.

◆ seq_wall_time()

double rheolef::seq_wall_time ( )

dis_cpu_time, dis_wall_time, seq_cpu_time, seq_walltime – Time in seconds since an arbitrary time in the past.

SYNOPSIS

double dis_cpu_time();
double dis_wall_time();
double seq_cpu_time();
double seq_wall_time();

EXAMPLE

double t_start = dis_wall_time();
double t_end = dis_wall_time();
derr << "That took " << t_end - t_start << " seconds" << endl
double cpu_start = dis_cpu_time();
double cpu_end = dis_cpu_time();
derr << "That needs " << cpu_end - cpu_start << " CPU seconds" << endl

dis_wall_time returns a floating-point number of seconds, representing elapsed wall-clock time since some time in the past. The time in the past is guaranteed not to change during the life of the process. The user is responsible for converting large numbers of seconds to other units if they are preferred. This function is portable (it returns seconds, not ticks), it allows high resolution, and carries no unnecessary baggage. In a distributed environment, dis_wall_time clocks are synchronized: different nodes return the same time value at the same instant. seq_wall_time is similar but the time returned is local to the node that called them and clocks are not synchronized: in a distributed environment, different nodes can return different local times, at different instant when the call to seq_wall_time is reached.

seq_cpu_time is similar but returns the computing time per user for the current process. dis_cpu_time returns the accumulated CPU for all processed linked together via the default communicator.

Definition at line 14 of file dis_cpu_time.cc.

◆ seq_cpu_time()

double rheolef::seq_cpu_time ( )

Definition at line 56 of file dis_cpu_time.cc.

◆ dis_wall_time()

double rheolef::dis_wall_time ( )
inline

Definition at line 59 of file dis_cpu_time.h.

◆ dis_cpu_time()

double rheolef::dis_cpu_time ( )
inline

Definition at line 60 of file dis_cpu_time.h.

◆ dis_inner_product() [1/2]

template<class InputIterator1 , class InputIterator2 , class Size >
promote< typename std::iterator_traits<InputIterator1>::value_type, typename std::iterator_traits<InputIterator2>::value_type>::type rheolef::dis_inner_product ( InputIterator1  first1,
InputIterator2  first2,
Size  n,
const distributor::communicator_type comm,
sequential   
)

dis_inner_product - distributed inner product algorithm

STL-like inner product for distributed containers environment.

SYNOPSIS

template<class InputIterator1, class InputIterator2, class Size>
InputIterator1 first1, InputIterator2 first2,
Size n);

EXAMPLE

A sample usage writes:

# include "rheolef/disarray.h"
# include "rheolef/dis_inner_product.h"
int main(int argc, char**argv) {
environment distributed(argc, argv);
unsigned int n = 100;
disarray<double> x(n, 2.0);
double norme2_x = dis_inner_product(x.begin(),x.begin(),x.size(),x.comm());
dout << "dot(x,x) = " << norme2_x << endl;
}

IMPLEMENTATION NOTE

The std::inner_product(first1,first2,last1) function is similar but not used here. Use here both two "first" iterators and the size "n", since expression template approach generates iterators as expression tree and a comparison like "first1 != last1" becomes complex and requires a recursive inspection.

Definition at line 54 of file dis_inner_product.h.

◆ dis_inner_product() [2/2]

template<class InputIterator1 , class InputIterator2 , class Size >
promote< typename std::iterator_traits<InputIterator1>::value_type, typename std::iterator_traits<InputIterator2>::value_type>::type rheolef::dis_inner_product ( InputIterator1  first1,
InputIterator2  first2,
Size  n,
const distributor::communicator_type comm 
)
inline

Definition at line 94 of file dis_inner_product.h.

◆ seq_peak_memory_usage()

size_t rheolef::seq_peak_memory_usage ( )

Returns the peak (maximum so far) resident set size (physical memory use) measured in bytes, or zero if the value cannot be determined on this OS.

Definition at line 36 of file dis_memory_usage.cc.

◆ seq_memory_usage()

size_t rheolef::seq_memory_usage ( )

dis_memory_usage, seq_memory_usage – physical memory in use

SYNOPSIS

seq_memory_usage returns the current resident set size (physical memory use) measured in bytes, or zero if the value cannot be determined on this OS.

dis_memory_usage returns the accumulated memory usage for all processed linked together via the default communicator.

seq_peak_memory_usage returns the peak (maximum so far) resident set size (physical memory use) measured in bytes, or zero if the value cannot be determined on this OS.

dis_peak_memory_usage returns the accumulated peak memory usage for all processed linked together via the default communicator.

memory_size returns the size of physical memory (RAM) in bytes associated to the given process.

Definition at line 81 of file dis_memory_usage.cc.

◆ memory_size()

size_t rheolef::memory_size ( )

Definition at line 148 of file dis_memory_usage.cc.

◆ dis_memory_usage()

size_t rheolef::dis_memory_usage ( )

Definition at line 230 of file dis_memory_usage.cc.

◆ dis_peak_memory_usage()

size_t rheolef::dis_peak_memory_usage ( )

Definition at line 231 of file dis_memory_usage.cc.

◆ operator>>() [4/21]

template<class T , class A >
idiststream& rheolef::operator>> ( idiststream &  ips,
disarray< T, sequential, A > &  x 
)
inline

Definition at line 616 of file disarray.h.

◆ operator<<() [7/34]

template<class T , class A >
odiststream& rheolef::operator<< ( odiststream ops,
const disarray< T, sequential, A > &  x 
)
inline

Definition at line 623 of file disarray.h.

◆ disarray_make_store()

template<class OutputRandomIterator , class SetOp , class Size , class IsContainer >
disarray_store<OutputRandomIterator, SetOp, Size, IsContainer> rheolef::disarray_make_store ( OutputRandomIterator  x,
SetOp  op,
Size  ,
IsContainer   
)
inline

Definition at line 37 of file disarray_store.h.

◆ din()

idiststream rheolef::din ( cin  )

◆ dis_scatch() [1/2]

bool rheolef::dis_scatch ( idiststream &  ips,
const communicator comm,
std::string  ch 
)

Definition at line 13 of file diststream.cc.

◆ dis_system()

int rheolef::dis_system ( const std::string &  command,
const communicator comm 
)

Definition at line 170 of file diststream.cc.

◆ dis_file_exists()

bool rheolef::dis_file_exists ( const std::string &  filename,
const communicator comm 
)

Definition at line 189 of file diststream.cc.

◆ operator<<() [8/34]

template<class T >
odiststream& rheolef::operator<< ( odiststream s,
x 
)
inline

Definition at line 196 of file diststream.h.

◆ dis_scatch() [2/2]

bool rheolef::dis_scatch ( idiststream &  ips,
std::string  ch 
)
inline

Definition at line 334 of file diststream.h.

◆ operator>>() [5/21]

idiststream& rheolef::operator>> ( idiststream &  ids,
const catchmark m 
)
inline

Definition at line 340 of file diststream.h.

◆ operator<<() [9/34]

odiststream& rheolef::operator<< ( odiststream ods,
const catchmark m 
)
inline

Definition at line 353 of file diststream.h.

◆ compose1()

template<class _Operation1 , class _Operation2 >
unary_compose<_Operation1, _Operation2> rheolef::compose1 ( const _Operation1 &  __fn1,
const _Operation2 &  __fn2 
)
inline

Definition at line 24 of file functional_sgi_ext.h.

◆ compose2()

template<class _Operation1 , class _Operation2 , class _Operation3 >
binary_compose<_Operation1, _Operation2, _Operation3> rheolef::compose2 ( const _Operation1 &  __fn1,
const _Operation2 &  __fn2,
const _Operation3 &  __fn3 
)
inline

Definition at line 49 of file functional_sgi_ext.h.

◆ get_pointer_from_iterator() [1/2]

template<class Iterator >
std::iterator_traits<Iterator>::pointer rheolef::get_pointer_from_iterator ( Iterator  iter)

Definition at line 6 of file get_pointer_from_iterator.h.

◆ get_pointer_from_iterator() [2/2]

template<class T >
std::iterator_traits<T*>::pointer rheolef::get_pointer_from_iterator ( T *  iter)

Definition at line 11 of file get_pointer_from_iterator.h.

◆ gmres()

template<class Matrix , class Vector , class Preconditioner , class SmallMatrix , class SmallVector >
int rheolef::gmres ( const Matrix &  A,
Vector x,
const Vector b,
const Preconditioner &  M,
SmallMatrix &  H,
const SmallVector &  ,
const solver_option sopt = solver_option() 
)

Definition at line 138 of file gmres.h.

◆ ldlt_seq_builtin_ordering()

template<typename T >
void rheolef::ldlt_seq_builtin_ordering ( const csr_rep< T, sequential > &  a,
std::valarray< size_t > &  perm 
)
inline

Definition at line 8 of file ldlt_seq_builtin.cc.

◆ ldlt_seq_builtin_numeric()

template<typename T >
bool rheolef::ldlt_seq_builtin_numeric ( const csr_rep< T, sequential > &  A,
const std::valarray< size_t > &  perm,
const std::valarray< size_t > &  iperm,
const std::valarray< size_t > &  parent,
vec< T, sequential > &  D,
csr_rep< T, sequential > &  L,
std::valarray< size_t > &  L_nnz,
std::valarray< size_t > &  mark,
std::valarray< size_t > &  pattern,
vec< T, sequential > &  Y 
)

Definition at line 71 of file ldlt_seq_builtin.cc.

◆ ldlt_seq_builtin_symbolic()

template<typename T >
void rheolef::ldlt_seq_builtin_symbolic ( const csr_rep< T, sequential > &  A,
const std::valarray< size_t > &  perm,
const std::valarray< size_t > &  iperm,
std::valarray< size_t > &  parent,
std::valarray< size_t > &  L_nnz,
std::valarray< size_t > &  mark 
)

Definition at line 128 of file ldlt_seq_builtin.cc.

◆ operator<<() [10/34]

template<typename T >
odiststream& rheolef::operator<< ( odiststream s,
const ldlt_seq_builtin< T > &  c 
)

Definition at line 217 of file ldlt_seq_builtin.cc.

◆ load_chunk() [1/2]

template<class RandomIterator >
bool rheolef::load_chunk ( std::istream &  s,
RandomIterator  iter,
RandomIterator  last 
)
inline

Definition at line 7 of file load_chunk.h.

◆ load_chunk() [2/2]

template<class RandomIterator , class GetFunction >
bool rheolef::load_chunk ( std::istream &  s,
RandomIterator  iter,
RandomIterator  last,
GetFunction  get_element 
)
inline

Definition at line 16 of file load_chunk.h.

◆ minres()

template<class Matrix , class Vector , class Preconditioner >
int rheolef::minres ( const Matrix &  A,
Vector x,
const Vector Mb,
const Preconditioner &  M,
const solver_option sopt = solver_option() 
)

minres – conjugate gradient algorithm.

SYNOPSIS

template <class Matrix, class Vector, class Preconditioner, class Real>
int minres (const Matrix &A, Vector &x, const Vector &b, const Preconditioner &M,
const solver_option& sopt = solver_option);

EXAMPLE

The simplest call to minres has the folling form:

solver_option sopt;
sopt.max_iter = 100;
sopt.tol = 1e-7;
int status = minres (a, x, b, eye(), sopt);

minres solves the symmetric positive definite linear system Ax=b using the Conjugate Gradient method.

The return value indicates convergence within max_iter (input) iterations (0), or no convergence within max_iter iterations (1). Upon successful return, output arguments have the following values:

x

approximate solution to Ax = b

sopt.n_iter

the number of iterations performed before the tolerance was reached

sopt.residue
the residual after the final iteration

NOTE

minres follows the algorithm described in "Solution of sparse indefinite systems of linear equations", C. C. Paige and M. A. Saunders, SIAM J. Numer. Anal., 12(4), 1975. For more, see http://www.stanford.edu/group/SOL/software.html and also the PhD "Iterative methods for singular linear equations and least-squares problems", S.-C. T. Choi, Stanford University, 2006, http://www.stanford.edu/group/SOL/dissertations/sou-cheng-choi-thesis.pdf at page 60. The present implementation style is inspired from IML++ 1.2 iterative method library, http://math.nist.gov/iml++.

Definition at line 58 of file minres.h.

◆ uzawa_abtbc()

template<class Matrix , class Vector , class Solver , class Preconditioner >
int rheolef::uzawa_abtbc ( const Matrix &  A,
const Matrix &  B,
const Matrix &  C,
Vector u,
Vector p,
const Vector Mf,
const Vector Mg,
const Preconditioner &  S1,
const Solver &  inner_solver_A,
const Float rho,
const solver_option sopt = solver_option() 
)

Definition at line 30 of file mixed_solver.h.

◆ uzawa_abtb()

template<class Matrix , class Vector , class Solver , class Preconditioner , class Real >
int rheolef::uzawa_abtb ( const Matrix &  A,
const Matrix &  B,
Vector u,
Vector p,
const Vector Mf,
const Vector Mg,
const Preconditioner &  S1,
const Solver &  inner_solver_A,
const Real &  rho,
const solver_option sopt = solver_option() 
)

Definition at line 44 of file mixed_solver.h.

◆ cg_abtbc()

template<class Matrix , class Vector , class VectorExpr1 , class VectorExpr2 , class Solver , class Preconditioner >
int rheolef::cg_abtbc ( const Matrix &  A,
const Matrix &  B,
const Matrix &  C,
Vector u,
Vector p,
const VectorExpr1 &  Mf,
const VectorExpr2 &  Mg,
const Preconditioner &  S1,
const Solver &  inner_solver_A,
const solver_option sopt = solver_option() 
)

cg_abtb, cg_abtbc, minres_abtb, minres_abtbc – solvers for mixed linear problems

SYNOPSIS

template <class Matrix, class Vector, class Solver, class Preconditioner>
int cg_abtb (const Matrix& A, const Matrix& B, Vector& u, Vector& p,
const Vector& Mf, const Vector& Mg, const Preconditioner& S1,
const Solver& inner_solver_A, const solver_option& sopt = solver_option());
template <class Matrix, class Vector, class Solver, class Preconditioner>
int cg_abtbc (const Matrix& A, const Matrix& B, const Matrix& C, Vector& u, Vector& p,
const Vector& Mf, const Vector& Mg, const Preconditioner& S1,
const Solver& inner_solver_A, const solver_option& sopt = solver_option());

The synopsis is the same with the minres algorithm.

EXAMPLES

See the user's manual for practical examples for the nearly incompressible elasticity, the Stokes and the Navier-Stokes problems.

Preconditioned conjugate gradient algorithm on the pressure p applied to the stabilized stokes problem:

[ A B^T ] [ u ] [ Mf ]
[ ] [ ] = [ ]
[ B -C ] [ p ] [ Mg ]

where A is symmetric positive definite and C is symmetric positive and semi-definite. Such mixed linear problems appears for instance with the discretization of Stokes problems with stabilized P1-P1 element, or with nearly incompressible elasticity. Formally u = inv(A)*(Mf - B^T*p) and the reduced system writes for all non-singular matrix S1:

inv(S1)*(B*inv(A)*B^T)*p = inv(S1)*(B*inv(A)*Mf - Mg)

Uzawa or conjugate gradient algorithms are considered on the reduced problem. Here, S1 is some preconditioner for the Schur complement S=B*inv(A)*B^T. Both direct or iterative solvers for S1*q = t are supported. Application of inv(A) is performed via a call to a solver for systems such as A*v = b. This last system may be solved either by direct or iterative algorithms, thus, a general matrix solver class is submitted to the algorithm. For most applications, such as the Stokes problem, the mass matrix for the p variable is a good S1 preconditioner for the Schur complement. The stopping criteria is expressed using the S1 matrix, i.e. in L2 norm when this choice is considered. It is scaled by the L2 norm of the right-hand side of the reduced system, also in S1 norm.

Definition at line 119 of file mixed_solver.h.

◆ cg_abtb()

template<class Matrix , class Vector , class VectorExpr1 , class VectorExpr2 , class Solver , class Preconditioner >
int rheolef::cg_abtb ( const Matrix &  A,
const Matrix &  B,
Vector u,
Vector p,
const VectorExpr1 &  Mf,
const VectorExpr2 &  Mg,
const Preconditioner &  S1,
const Solver &  inner_solver_A,
const solver_option sopt = solver_option() 
)

Definition at line 133 of file mixed_solver.h.

◆ minres_abtbc()

template<class Matrix , class Vector , class Solver , class Preconditioner >
int rheolef::minres_abtbc ( const Matrix &  A,
const Matrix &  B,
const Matrix &  C,
Vector u,
Vector p,
const Vector Mf,
const Vector Mg,
const Preconditioner &  S1,
const Solver &  inner_solver_A,
const solver_option sopt = solver_option() 
)

Definition at line 146 of file mixed_solver.h.

◆ minres_abtb()

template<class Matrix , class Vector , class Solver , class Preconditioner >
int rheolef::minres_abtb ( const Matrix &  A,
const Matrix &  B,
Vector u,
Vector p,
const Vector Mf,
const Vector Mg,
const Preconditioner &  S1,
const Solver &  inner_solver_A,
const solver_option sopt = solver_option() 
)

Definition at line 159 of file mixed_solver.h.

◆ mpi_assembly_begin()

template<class Stash , class Message , class InputIterator >
Stash::size_type rheolef::mpi_assembly_begin ( const Stash &  stash,
InputIterator  first_stash_idx,
InputIterator  last_stash_idx,
const distributor ownership,
Message &  receive,
Message &  send 
)

mpi_assembly_begin – for array or matrix

Start a dense array or a sparse matrix assembly.

COMPLEXITY

Assume that stash has indexes in increasing order. cpu complexity : O(stash.size + nproc) memory complexity : O(stash.size + nproc) msg size complexity : O(stash.size + nproc)

When assembling a finite element matrix, the stash.size is at boundaries of the mesh partition, and stash.size = O(nrow^alpha), where alpha=(d-1)/d and d=2,3. Using nproc <= O(nrow^alpha) is performant.

NOTE

The stash may be sorted by increasing nows and column.

Inspirated from Petsc (petsc/src/vec/vec/impls/mpi/pdvec.c), here with a pre-sorted stash, thanks to the stl::map data structure.

Definition at line 37 of file mpi_assembly_begin.h.

◆ mpi_assembly_end()

template<class Container , class Message , class Size >
Size rheolef::mpi_assembly_end ( Message &  receive,
Message &  send,
Size  receive_max_size,
Container  x 
)

msg_assembly_end – array or matrix assembly

Finish a dense array or sparse matrix assembly.

COMPLEXITY

TO DO**

Definition at line 27 of file mpi_assembly_end.h.

◆ mpi_scatter_begin_global()

template<class InputIterator , class Message , class Tag , class Comm >
void rheolef::mpi_scatter_begin_global ( InputIterator  x,
Message &  from,
Message &  to,
Tag  tag,
Comm  comm 
)

mpi_scatter_begin – gather/scatter initialize

Begin communication for distributed to sequential scatter context.

COMPLEXITY

IMPLEMENTATION

Even though the next routines are written with distributed vectors, either x or y (but not both) may be sequential vectors, one for each processor.

from indices indicate where arriving stuff is stashed to indices indicate where departing stuff came from. the naming can be a little confusing.

Reverse scatter is obtained by swapping (to,from) in calls to scatter_begin and scatter_end. Reverse scatter is usefull for transpose matrix-vector multiply.

Scatter general operation is handled by a template "SetOp" type. The special case "SetOp=set_op" of an affectation is treated separatly, tacking care of local scatter affectation. Thus, the "mpi_scatter_begin" routine is splitted into "msg_scatter_begin_global" and "msg_scatter_begin_local" parts.

Definition at line 47 of file mpi_scatter_begin.h.

◆ mpi_scatter_begin_local() [1/2]

template<class InputIterator , class OutputIterator , class SetOp , class Message >
void rheolef::mpi_scatter_begin_local ( InputIterator  x,
OutputIterator  y,
Message &  from,
Message &  to,
SetOp  op 
)

Definition at line 94 of file mpi_scatter_begin.h.

◆ mpi_scatter_begin_local() [2/2]

template<class InputIterator , class OutputIterator , class Message >
void rheolef::mpi_scatter_begin_local ( InputIterator  x,
OutputIterator  y,
Message &  from,
Message &  to,
set_op< typename Message::value_type, typename Message::value_type >  op 
)

Definition at line 116 of file mpi_scatter_begin.h.

◆ mpi_scatter_begin()

template<class InputIterator , class OutputIterator , class Message , class SetOp , class Tag , class Comm >
void rheolef::mpi_scatter_begin ( InputIterator  x,
OutputIterator  y,
Message &  from,
Message &  to,
SetOp  op,
Tag  tag,
Comm  comm 
)
inline

Definition at line 164 of file mpi_scatter_begin.h.

◆ mpi_scatter_end()

template<class InputIterator , class OutputIterator , class Message , class SetOp , class Tag , class Comm >
void rheolef::mpi_scatter_end ( InputIterator  x,
OutputIterator  y,
Message &  from,
Message &  to,
SetOp  op,
Tag  tag,
Comm  comm 
)

mpi_scatter_end – gather/scatter finalize

Finishes communication for distributed to sequential scatter context.

Definition at line 30 of file mpi_scatter_end.h.

◆ mpi_scatter_init()

template<class Message , class Size , class SizeRandomIterator1 , class SizeRandomIterator2 , class SizeRandomIterator3 , class Tag >
void rheolef::mpi_scatter_init ( Size  nidx,
SizeRandomIterator1  idx,
Size  nidy,
SizeRandomIterator2  idy,
Size  idy_maxval,
SizeRandomIterator3  ownership,
Tag  tag,
const distributor::communicator_type comm,
Message &  from,
Message &  to 
)

Definition at line 45 of file mpi_scatter_init.h.

◆ mpi_scatter_map()

template<class InputIterator , class InputSet , class OutputMap >
void rheolef::mpi_scatter_map ( const distributor ownership,
InputIterator  local_data,
const InputSet &  ext_idx_set,
OutputMap &  ext_idx_map 
)

mpi_scatter_map – gather/scatter and build map

This is a high-level communication function for application to finite-element problems. The input is a stl::set of external degrees of freedom (e.g. vertices, edges, faces) referenced by localy managed elements and required by the local processor. These degrees of freedom are on the boundary of the mesh partition and are managed by a neighbour processor. The ouput is the same index set, but associated with the required values, in a stl::map associative container. The input also furnish an iterator to the locally managed data and the distributor associated to these data.

COMPLEXITY

Time, communication and memory complexity is O(nidx+nproc). For finite-element problems in d dimenion

nidx ~ N^((d-1)/d)

where N is the number of degrees of freedom (vertices or elements).

Definition at line 36 of file mpi_scatter_map.h.

◆ msg_both_permutation_apply()

template<class InputIterator1 , class InputIterator2 , class InputRandomIterator , class SetOp , class OutputRandomIterator >
void rheolef::msg_both_permutation_apply ( InputIterator1  px,
InputIterator1  last_px,
InputRandomIterator  x,
SetOp  set_op,
InputIterator2  py,
OutputRandomIterator  y 
)

msg_both_permutation_apply – sequentail apply

Applies permutations when copying an array.

ALGORITHM

msg_both_permutation_apply

"input": the length array | px(0:n-1), x(0:nx-1), py(0:n-1) "output": the pointer array and the total size | y(0:ny) begin | for i := 0 to n-1 do | y(py(i)) := x(px(i)) | endfor end

COMPLEXITY

Time and memory complexity is O(n).

Definition at line 37 of file msg_both_permutation_apply.h.

◆ msg_from_context_indices()

template<class InputIterator1 , class InputIterator2 , class InputRandomIterator , class Proc , class Size , class MutableRandomIterator , class OutputIterator >
void rheolef::msg_from_context_indices ( InputIterator1  owner,
InputIterator1  last_owner,
InputIterator2  idy,
InputRandomIterator  proc2from_proc,
Proc  my_proc,
Size  idy_maxval,
MutableRandomIterator  ptr,
OutputIterator  from_idx 
)

msg_from_context_indices – gather

Computes the receive compressed message pattern for gather and scatter. Suppose indexes are sorted by increasing order.

ALGORITHM

msg_from_context_indices

"input": the owner and indice arrays, the current process | owner(0:nidx-1), idy(0:nidx-1), | proc2from_proc(0:nproc-1), my_proc "input-output": the pointer array, used for accumulation | ptr(0:nidx) "output": the receive context (from) indice array | from_idx(0:nidx-1) begin | for k := 0 to nidx-1 do | iproc := owner(k) | if iproc <> my_proc then | i := proc2from_proc(iproc) | p := ptr(i) | ptr(i) := p + 1 | from_idx(p) := idy(k) | endif | endfor end

COMPLEXITY

Complexity is O(nidx).

TODO

Uses input iterators.

Definition at line 57 of file msg_from_context_indices.h.

◆ msg_from_context_pattern()

template<class InputIterator1 , class OutputIterator1 , class OutputIterator2 , class OutputIterator3 >
void rheolef::msg_from_context_pattern ( InputIterator1  msg_size,
InputIterator1  last_msg_size,
OutputIterator1  from_proc,
OutputIterator2  from_ptr,
OutputIterator3  proc2from_proc 
)

msg_from_context – gather

Computes the receive compressed message pattern for gather and scatter.

ALGORITHM

msg_from_context_pattern

"input": the ownership distribution and the indexes arrays | msg_size(0:nproc) "output": the receive context (from) and an auxilliary array proc2from_proc | from_proc(0:send_nproc-1), from_ptr(0:send_nproc), | proc2from_proc(0:nproc-1) begin | i := 0 | from_ptr(0) := 0 | for iproc := 0 to nproc-1 do | if msg_size(iproc) <> 0 then | from_proc(i) := iproc | from_ptr(i+1) := from_ptr(i) + msg_size(i) | proc2from_proc(iproc) := i | i := i+1 | endif | endfor end

NOTE

At the end of the algorithm, we have i = send_nproc.

COMPLEXITY

Complexity is O(nproc).

Definition at line 53 of file msg_from_context_pattern.h.

◆ msg_left_permutation_apply()

template<class InputIterator1 , class InputIterator2 , class SetOp , class OutputRandomIterator >
void rheolef::msg_left_permutation_apply ( InputIterator1  x,
SetOp  op,
InputIterator2  py,
InputIterator2  last_py,
OutputRandomIterator  y 
)

msg_left_permutation_apply – sequentail apply

Applies a left permutation to an array.

ALGORITHM

msg_left_permutation_apply

"input": the length array | x(0:nx-1), py(0:n-1) "output": the pointer array and the total size | y(0:n) begin | for i := 0 to n-1 do | y(py(i)) := x(i) | endfor end

COMPLEXITY

Time and memory complexity is O(n).

Definition at line 36 of file msg_left_permutation_apply.h.

◆ msg_local_context()

template<class InputIterator1 , class InputIterator2 , class Size , class OutputIterator1 , class OutputIterator2 >
void rheolef::msg_local_context ( InputIterator1  idx,
InputIterator1  last_idx,
InputIterator2  idy,
Size  idy_maxval,
Size  istart,
Size  ilast,
OutputIterator1  to_loc_idx,
OutputIterator1  last_to_loc_idx,
OutputIterator2  from_loc_idy 
)

msg_local_context – receive pattern

Computes the receive compresed message local pattern, i.e. the only part that does not requires communication. (see "msg_to_context"(5)).

ALGORITHM

msg_local_context

"input": the index sets and the local processor index range | idx(0:nidx-1), idy(0:nidx-1), istart, ilast "output": the send and receive local contexts (to, from) | to_loc_idx(0:n_local-1), from_loc_idy(0:n_local-1) begin | if n_local <> 0 then | iloc := 0 | for k := 0 to nidx-1 do | if idy(k) in (istart, ilast( then | to_loc_idx(iloc) := idy(k) - istart | from_loc_idy(iloc) := idy(k) | iloc := iloc + 1 | endif | endfor | endif end

COMPLEXITY

Memory and time complexity is O(receive_total_size).

Definition at line 51 of file msg_local_context.h.

◆ msg_local_optimize()

template<class InputIterator1 , class InputIterator2 >
bool rheolef::msg_local_optimize ( InputIterator1  to_loc_idx,
InputIterator1  last_to_loc_idx,
InputIterator2  from_loc_idy 
)

msg_local_optimize – local scatter optimize

Optimize local exchanges during gatter/scatter.

ALGORITHM

msg_local_optimize

"input": the send and receive local contexts (to, from) | to_loc_idx(0:n_local-1), from_loc_idy(0:n_local-1) "output": the boolean, true when optimization is possible | has_opt begin | if n_local = 0 then | has_opt := false | else | to_start := to_loc_idx(0) | from_start := from_loc_idy(0) | has_opt := true | i := 1 | while i < n_local and has_opt do | to_start := to_start + 1 | from_start := from_start + 1 | if to_loc_idx(i) <> to_start | or from_loc_idy(i) <> from_start then | has_opt := false | endif | i := i + 1 | endwhile | endif end

COMPLEXITY

Memory and time complexity is O(receive_total_size).

Definition at line 53 of file msg_local_optimize.h.

◆ msg_right_permutation_apply() [1/2]

template<class InputIterator , class InputRandomIterator , class OutputIterator , class SetOp >
OutputIterator rheolef::msg_right_permutation_apply ( InputIterator  perm,
InputIterator  last_perm,
const InputRandomIterator &  x,
OutputIterator  y,
SetOp  set_op 
)

msg_right_permutation_apply – sequentail apply

Applies a permutation to an array.

ALGORITHM

msg_right_permutation_apply

"input": the length array | perm(0:n-1), x(0:nx-1) "output": the pointer array and the total size | y(0:n) begin | for i := 0 to n-1 do | y(i) := x(perm(i)) | endfor end

COMPLEXITY

Time and memory complexity is O(n).

Definition at line 36 of file msg_right_permutation_apply.h.

◆ msg_right_permutation_apply() [2/2]

template<class InputIterator , class InputRandomIterator , class OutputIterator >
OutputIterator rheolef::msg_right_permutation_apply ( InputIterator  perm,
InputIterator  last_perm,
const InputRandomIterator &  x,
OutputIterator  y 
)
inline

Definition at line 65 of file msg_right_permutation_apply.h.

◆ quick_sort_with_permutation()

template<class RandomIterator , class SizeRandomIterator , class Size >
void rheolef::quick_sort_with_permutation ( RandomIterator  v,
SizeRandomIterator  p,
Size  start,
Size  end 
)

Definition at line 22 of file msg_sort_with_permutation.h.

◆ bubble_sort_with_permutation()

template<class RandomIterator , class SizeRandomIterator , class Size >
void rheolef::bubble_sort_with_permutation ( RandomIterator  v,
SizeRandomIterator  p,
Size  n 
)

Definition at line 54 of file msg_sort_with_permutation.h.

◆ sort_with_permutation()

template<class RandomIterator , class SizeRandomIterator , class Size >
void rheolef::sort_with_permutation ( RandomIterator  v,
SizeRandomIterator  p,
Size  n 
)

Definition at line 71 of file msg_sort_with_permutation.h.

◆ msg_to_context()

template<class InputIterator1 , class InputRandomIterator2 , class InputRandomIterator3 , class InputRandomIterator4 , class Size , class OutputIterator1 , class OutputIterator2 , class OutputIterator3 >
void rheolef::msg_to_context ( InputIterator1  perm,
InputIterator1  last_perm,
InputRandomIterator2  r_iproc,
InputRandomIterator3  r_size,
InputRandomIterator4  r_idx,
Size  receive_max_size,
Size  istart,
OutputIterator1  to_proc,
OutputIterator2  to_ptr,
OutputIterator3  to_idx 
)

msg_to_context – receive pattern

Computes the receive compresed message pattern for gather and scatter. The local message part is computed by a separate algorithm (see "msg_to_local_context"(5)).

ALGORITHM

msg_to_context

"input": the receive pattern and the permutation | perm(0:receive_nproc-1) | r_iproc(0:receive_nproc-1), r_size(0:receive_nproc-1), | r_idx(0:receive_nproc*receive_max_size-1) "output": the receive context (to) | to_proc(0:receive_nproc-1), to_ptr(0:receive_nproc), | to_idx(0:receive_total_size-1) begin | to_ptr(0) := 0 | for j := 0 to receive_nproc-1 do | j1 := perm(j) | to_proc(j) := r_iproc(j1) | to_ptr(j+1) := r_ptr(j) + rsize(j1) | for q := to_ptr(j) to to_tr(j+1)-1 do | to_idx(q) := r_idx(j1, q-to_ptr(j)) - istart | endfor | endfor end

COMPLEXITY

Memory and time complexity is O(receive_total_size).

Definition at line 57 of file msg_to_context.h.

◆ make_apply_iterator()

template<class Iterator , class Operator >
apply_iterator<Iterator,Operator> rheolef::make_apply_iterator ( Iterator  i,
Operator  op 
)
inline

Definition at line 102 of file msg_util.h.

◆ msg_pair_copy()

template<class InputIterator , class OutputIterator >
OutputIterator rheolef::msg_pair_copy ( InputIterator  input,
InputIterator  last,
OutputIterator  result 
)

Definition at line 108 of file msg_util.h.

◆ operator>>() [6/21]

template<class T , class A >
std::istream & rheolef::operator>> ( std::istream &  is,
pair_set< T, A > &  a 
)

Definition at line 170 of file pair_set.h.

◆ operator<<() [11/34]

template<class T , class A >
std::ostream & rheolef::operator<< ( std::ostream &  os,
const pair_set< T, A > &  b 
)

Definition at line 186 of file pair_set.h.

◆ ldlt()

template<class T , class M >
solver_basic< T, M > rheolef::ldlt ( const csr< T, M > &  a,
const solver_option opt = solver_option() 
)
inline

Definition at line 206 of file solver.h.

◆ lu() [1/2]

template<class T , class M >
solver_basic< T, M > rheolef::lu ( const csr< T, M > &  a,
const solver_option opt = solver_option() 
)
inline

Definition at line 197 of file solver.h.

◆ eye_basic()

template<class T , class M = rheo_default_memory_model>
solver_basic< T, M > rheolef::eye_basic ( )
inline

Definition at line 213 of file solver.h.

◆ eye()

solver_basic<Float> rheolef::eye ( )
inline

Definition at line 162 of file solver.h.

◆ ic0()

template<class T , class M >
solver_basic< T, M > rheolef::ic0 ( const csr< T, M > &  a,
const solver_option opt = solver_option() 
)
inline

Definition at line 231 of file solver.h.

◆ ilu0()

template<class T , class M >
solver_basic< T, M > rheolef::ilu0 ( const csr< T, M > &  a,
const solver_option opt = solver_option() 
)
inline

Definition at line 222 of file solver.h.

◆ ldlt_seq()

template<class T , class M >
solver_basic< T, M > rheolef::ldlt_seq ( const csr< T, M > &  a,
const solver_option opt = solver_option() 
)
inline

Definition at line 247 of file solver.h.

◆ lu_seq()

template<class T , class M >
solver_basic< T, M > rheolef::lu_seq ( const csr< T, M > &  a,
const solver_option opt = solver_option() 
)
inline

Definition at line 238 of file solver.h.

◆ nnz_upper_strict()

template<class T , class M >
static csr<T,M>::size_type rheolef::nnz_upper_strict ( const csr< T, M > &  a)
static

Definition at line 12 of file solver_no_trilinos_ifpack.cc.

◆ extract_upper()

template<class T , class M >
static void rheolef::extract_upper ( const csr< T, M > &  a,
csr< T, M > &  u 
)
static

Definition at line 28 of file solver_no_trilinos_ifpack.cc.

◆ inplace_ic0()

template<class T , class M >
static void rheolef::inplace_ic0 ( csr< T, M > &  u)
static

Definition at line 47 of file solver_no_trilinos_ifpack.cc.

◆ inplace_csc_lower_diag_solve()

template<class T , class M >
static void rheolef::inplace_csc_lower_diag_solve ( const csr< T, M > &  a,
vec< T, M > &  x_vec 
)
static

Definition at line 80 of file solver_no_trilinos_ifpack.cc.

◆ inplace_csr_upper_diag_solve()

template<class T , class M >
static void rheolef::inplace_csr_upper_diag_solve ( const csr< T, M > &  a,
vec< T, M > &  x_vec,
const vec< T, M > &  b_vec 
)
static

Definition at line 99 of file solver_no_trilinos_ifpack.cc.

◆ uzawa()

template<class Matrix , class Vector , class Preconditioner , class Real2 >
int rheolef::uzawa ( const Matrix &  A,
Vector x,
const Vector Mb,
const Preconditioner &  M,
const Real2 &  rho,
const solver_option sopt = solver_option() 
)

uzawa – Uzawa algorithm.

SYNOPSIS

template <class Matrix, class Vector, class Preconditioner, class Real>
int uzawa (const Matrix &A, Vector &x, const Vector &b, const Preconditioner &M,
const solver_option& sopt)

EXAMPLE

The simplest call to 'uzawa' has the folling form:

solver_option sopt;
sopt.max_iter = 100;
sopt.tol = 1e-7;
int status = uzawa(A, x, b, eye(), sopt);

uzawa solves the linear system A*x=b using the Uzawa method. The Uzawa method is a descent method in the direction opposite to the gradient, with a constant step length 'rho'. The convergence is assured when the step length 'rho' is small enough. If matrix A is symmetric positive definite, please uses 'cg' that computes automatically the optimal descdnt step length at each iteration. The return value indicates convergence within max_iter (input) iterations (0), or no convergence within max_iter iterations (1). Upon successful return, output arguments have the following values:

x

approximate solution to Ax = b

sopt.n_iter

the number of iterations performed before the tolerance was reached

sopt.residue
the residual after the final iteration

See also the solver_option.

See also
solver_option.

Definition at line 58 of file uzawa.h.

◆ operator>>() [7/21]

template<class T >
idiststream& rheolef::operator>> ( idiststream &  ips,
vec< T, sequential > &  x 
)
inline

Definition at line 294 of file vec.h.

◆ operator<<() [12/34]

template<class T , class M >
odiststream& rheolef::operator<< ( odiststream ods,
const vec< T, M > &  x 
)
inline

Definition at line 301 of file vec.h.

◆ norm2() [1/5]

template<class T , class M >
T rheolef::norm2 ( const vec< T, M > &  x)
inline

Definition at line 334 of file vec.h.

◆ norm() [1/5]

template<class T , class M >
T rheolef::norm ( const vec< T, M > &  x)
inline

Definition at line 341 of file vec.h.

◆ _RHEOLEF_vec_expr_v2_unary_operator()

rheolef::_RHEOLEF_vec_expr_v2_unary_operator ( ,
details::generic_unary_plus<>   
)

◆ _RHEOLEF_vec_expr_v2_binary_operator()

rheolef::_RHEOLEF_vec_expr_v2_binary_operator ( ,
details::generic_plus<>   
)

◆ operator*() [3/17]

template<class Expr1 , class Expr2 >
details::generic_minus std::enable_if< (details::is_rheolef_arithmetic<Expr1>::value && details::is_vec_expr_v2_arg<Expr2>::value) || (details::is_vec_expr_v2_arg<Expr1>::value && details::is_rheolef_arithmetic<Expr2>::value), typename details::vec_expr_v2_binary_traits< details::generic_multiplies<>, Expr1, Expr2 >::type>::type rheolef::operator* ( const Expr1 expr1,
const Expr2 &  expr2 
)
inline

Definition at line 224 of file vec_expr_v2.h.

◆ operator/() [2/4]

template<class Expr1 , class Expr2 >
std::enable_if< (details::is_vec_expr_v2_arg<Expr1>::value && details::is_rheolef_arithmetic<Expr2>::value), typename details::vec_expr_v2_binary_trai