Rheolef  7.1
an efficient C++ finite element environment
field.h
Go to the documentation of this file.
1 # ifndef _RHEOLEF_FIELD_H
2 # define _RHEOLEF_FIELD_H
3 //
4 // This file is part of Rheolef.
5 //
6 // Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
7 //
8 // Rheolef is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
12 //
13 // Rheolef is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17 //
18 // You should have received a copy of the GNU General Public License
19 // along with Rheolef; if not, write to the Free Software
20 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 //
22 // =========================================================================
23 // AUTHOR: Pierre.Saramito@imag.fr
24 // DATE: 23 february 2011
25 
26 namespace rheolef {
192 } // namespace rheolef
193 
194 #include "rheolef/linalg.h"
195 #include "rheolef/space.h"
196 #include "rheolef/undeterminated.h"
197 #include "rheolef/misc_algo.h" // copy_n
198 #include "rheolef/quadrature.h"
199 #include "rheolef/integrate_option.h"
200 
201 namespace rheolef {
202 
203 // forward declaration:
204 template <class T, class M> class field_indirect;
205 template <class T, class M> class field_indirect_const;
206 template <class T, class M> class field_component;
207 template <class T, class M> class field_component_const;
208 template <class T, class M> class band_basic;
209 namespace details {
210 template <class T, class M> class field_concat_value;
211 } // namespace details
212 
213 namespace details {
214 
215 // Define a trait type for constants
216 template <class Value>
218 : or_type<
219  is_rheolef_arithmetic<Value>
220  ,is_point<Value>
221  ,is_tensor<Value>
222  ,is_tensor3<Value>
223  ,is_tensor4<Value>
224  >
225 {};
226 
227 // Define traits for field_expressions:
228 template <class Expr> struct is_field;
229 template<class T, class Sfinae = void> struct is_field_expr_affine_homogeneous: std::false_type {};
230 
231 } // namespace details
232 
233 // [verbatim_field_basic]
234 template <class T, class M = rheo_default_memory_model>
235 class field_basic {
236 public :
237 // typedefs:
238 
239  using size_type = std::size_t;
240  using memory_type = M;
241  using value_type = T; // TODO: run-time dependent
242  using result_type = T; // TODO: run-time dependent
243  // using value_type = undeterminated_basic<T>; // TODO
244  using scalar_type = T;
250  class iterator;
251  class const_iterator;
252 
253 // allocator/deallocator:
254 
256 
257  explicit field_basic (
258  const space_type& V,
259  const T& init_value = std::numeric_limits<T>::max());
260 
261  void resize (
262  const space_type& V,
263  const T& init_value = std::numeric_limits<T>::max());
264 
265  // expressions:
266  template <class Expr, class Sfinae =
267  typename std::enable_if<
270  field_basic (const Expr& expr);
271 
272  // initializer list (c++ 2011):
273  field_basic (const std::initializer_list<details::field_concat_value<T,M> >& init_list);
274 
275 // assignments:
276 
278 
279  template <class Value>
280  typename std::enable_if<
283  >::type
284  operator= (const Value& value);
285 
286 
287  template <class Expr>
288  typename std::enable_if<
293  operator= (const Expr&);
294 
295  // initializer list (c++ 2011):
296  field_basic<T,M>& operator= (const std::initializer_list<details::field_concat_value<T,M> >& init_list);
297 
298 // accessors:
299 
300  const space_type& get_space() const { return _V; }
301  const geo_type& get_geo() const { return _V.get_geo(); }
302  std::string name() const { return _V.name(); }
303  std::string get_approx() const { return _V.get_approx(); }
304  valued_type valued_tag() const { return _V.valued_tag(); }
305  const std::string& valued() const { return _V.valued(); }
306  bool have_homogeneous_space (space_basic<T,M>& Xh) const { Xh = get_space(); return true; }
307 
308 // accessors & modifiers to unknown & blocked parts:
309 
310  const vec<T,M>& u() const { return _u; }
311  const vec<T,M>& b() const { return _b; }
314 
315 // accessors to extremas:
316 
317  T min() const;
318  T max() const;
319  T max_abs() const;
320  T min_abs() const;
321 
322 // accessors by domains:
323 
326  field_indirect<T,M> operator[] (std::string dom_name);
327  field_indirect_const<T,M> operator[] (std::string dom_name) const;
328 
329 // accessors by components:
330 
331  size_type size() const { return _V.size(); }
336 
337 // accessors by degrees-of-freedom (dof):
338 
339  const distributor& ownership() const { return get_space().ownership(); }
340  const communicator& comm() const { return ownership().comm(); }
341  size_type ndof() const { return ownership().size(); }
342  size_type dis_ndof() const { return ownership().dis_size(); }
343  T& dof (size_type idof);
344  const T& dof (size_type idof) const;
345  const T& dis_dof (size_type dis_idof) const;
346  // write access to non-local dis_idof changes to others procs
348 
349  iterator begin_dof();
350  iterator end_dof();
353 
354 // input/output:
355 
356  idiststream& get (idiststream& ips);
357  odiststream& put (odiststream& ops) const;
358  odiststream& put_field (odiststream& ops) const;
359 
360 // evaluate uh(x) where x is given locally as hat_x in K:
361 
362  T dis_evaluate (const point_basic<T>& x, size_type i_comp = 0) const;
363  T operator() (const point_basic<T>& x) const { return dis_evaluate (x,0); }
365 
366 // [verbatim_field_basic]
367 // internals:
368  int constraint_process_rank() const { return u().constraint_process_rank(); }
369 public:
370 
371  // evaluate uh(x) where x is given locally as hat_x in K:
372  // requiers to call field::dis_dof_upgrade() before.
373  T evaluate (const geo_element& K, const point_basic<T>& hat_xq, size_type i_comp = 0) const;
374 
375  // propagate changed values shared at partition boundaries to others procs
376  void dis_dof_update() const;
377 
378  // new interface
379  template <class Expr>
380  void assembly_internal (
381  const geo_basic<T,M>& dom,
382  const geo_basic<T,M>& band,
383  const band_basic<T,M>& gh,
384  const Expr& expr,
385  const integrate_option& qopt,
386  bool is_on_band);
387  template <class Expr>
388  void assembly (
389  const geo_basic<T,M>& dom,
390  const Expr& expr,
391  const integrate_option& iopt);
392  template <class Expr>
393  void assembly (
394  const band_basic<T,M>& gh,
395  const Expr& expr,
396  const integrate_option& iopt);
397 
398 protected:
401 
402 // data:
404  mutable vec<T,M> _u;
405  mutable vec<T,M> _b;
408 // [verbatim_field_basic_cont]
409 };
410 // [verbatim_field_basic_cont]
411 template <class T, class M>
413 
414 template <class T, class M>
416 
417 // [verbatim_field]
420 // [verbatim_field]
422 
423 // =================================================================================
424 // field::iterator
425 // =================================================================================
426 template <class T, class M>
428 protected:
429  typedef typename vec<T,M>::iterator data_t; // random acess
430  typedef typename disarray<space_pair_type,M>::const_iterator iter_t; // forward access
431 public:
432 
433 // typedefs:
434 
435  typedef std::forward_iterator_tag iterator_category; // TODO: not fully random yet
436  typedef typename vec<T,M>::size_type size_type;
437  typedef T value_type;
438  typedef T& reference;
439  typedef T* pointer;
440  typedef std::ptrdiff_t difference_type;
441 
442 // allocators:
443 
445  : _blk_dis_iub_iter(),
446  _blk_dis_iub_incr(1),
447  _u(),
448  _b(),
449  _first_iu(0),
450  _first_ib(0)
451  {}
452  iterator (iter_t blk_dis_iub_iter, data_t u, data_t b, size_type first_iu, size_type first_ib)
453  : _blk_dis_iub_iter(blk_dis_iub_iter),
454  _blk_dis_iub_incr(1),
455  _u(u),
456  _b(b),
457  _first_iu(first_iu),
458  _first_ib(first_ib)
459  {}
460  iterator (iter_t blk_dis_iub_iter, size_type blk_dis_iub_incr, data_t u, data_t b, size_type first_iu, size_type first_ib)
461  : _blk_dis_iub_iter(blk_dis_iub_iter),
462  _blk_dis_iub_incr(blk_dis_iub_incr),
463  _u(u),
464  _b(b),
465  _first_iu(first_iu),
466  _first_ib(first_ib)
467  {}
468 
469  void set_increment (size_type incr) { _blk_dis_iub_incr = incr; }
470 
471 // accessors & modifiers:
472 
474  bool blk = (*_blk_dis_iub_iter).is_blocked();
475  size_type dis_iub = (*_blk_dis_iub_iter).dis_iub();
476  size_type iub = (!blk) ? dis_iub - _first_iu : dis_iub - _first_ib;
477  return (!blk) ? _u[iub] : _b[iub];
478  }
479  iterator& operator++ () { _blk_dis_iub_iter += _blk_dis_iub_incr; return *this; }
480  iterator operator++ (int) { iterator tmp = *this; operator++(); return *this; }
481  iterator& operator+= (difference_type n) { _blk_dis_iub_iter += n*_blk_dis_iub_incr; return *this; }
482  iterator operator+ (difference_type n) const { iterator tmp = *this; return tmp += n; }
483  reference operator[] (size_type n) const { return *(*this + n); }
484 
485 // comparators:
486 
487  bool operator== (const iterator& j) const { return _blk_dis_iub_iter == j._blk_dis_iub_iter; }
488  bool operator!= (const iterator& j) const { return ! operator== (j); }
489 //protected:
490  friend class const_iterator;
491 // data:
496  size_type _first_iu, _first_ib;
497 };
498 template <class T, class M>
499 inline
502 {
503  dis_dof_indexes_requires_update();
504  return iterator (_V.data()._idof2blk_dis_iub.begin(), _u.begin(), _b.begin(), _u.ownership().first_index(), _b.ownership().first_index());
505 }
506 template <class T, class M>
507 inline
510 {
511  dis_dof_indexes_requires_update();
512  return iterator (_V.data()._idof2blk_dis_iub.end(), _u.begin(), _b.begin(), _u.ownership().first_index(), _b.ownership().first_index());
513 }
514 // =================================================================================
515 // field::const_iterator
516 // =================================================================================
517 template <class T, class M>
519 protected:
522 public:
523 
524 // typedefs:
525 
526  typedef std::forward_iterator_tag iterator_category;
527  typedef typename vec<T,M>::size_type size_type;
528  typedef T value_type;
529  typedef const T& reference;
530  typedef const T* pointer;
531  typedef std::ptrdiff_t difference_type;
532 
533 // allocators:
534 
536  : _blk_dis_iub_iter(),
537  _blk_dis_iub_incr(1),
538  _u(),
539  _b(),
540  _first_iu(0),
541  _first_ib(0)
542  {}
543  const_iterator (iter_t blk_dis_iub_iter, data_t u, data_t b, size_type first_iu, size_type first_ib)
544  : _blk_dis_iub_iter(blk_dis_iub_iter),
545  _blk_dis_iub_incr(1),
546  _u(u), _b(b),
547  _first_iu(first_iu),
548  _first_ib(first_ib)
549  {}
551  : _blk_dis_iub_iter(i._blk_dis_iub_iter),
552  _blk_dis_iub_incr(i._blk_dis_iub_incr),
553  _u(i._u),
554  _b(i._b),
555  _first_iu(i._first_iu),
556  _first_ib(i._first_ib)
557  {}
558 
559  void set_increment (size_type incr) { _blk_dis_iub_incr = incr; }
560 
561 // accessors & modifiers:
562 
564  bool blk = (*_blk_dis_iub_iter).is_blocked();
565  size_type dis_iub = (*_blk_dis_iub_iter).dis_iub();
566  size_type iub = (!blk) ? dis_iub - _first_iu : dis_iub - _first_ib;
567  return (!blk) ? _u[iub] : _b[iub];
568  }
569  const_iterator& operator++ () { _blk_dis_iub_iter += _blk_dis_iub_incr; return *this; }
570  const_iterator operator++ (int) { const_iterator tmp = *this; operator++(); return *this; }
571  const_iterator& operator+= (difference_type n) { _blk_dis_iub_iter += n*_blk_dis_iub_incr; return *this; }
573  reference operator[] (size_type n) const { return *(*this + n); }
574 
575 // comparators:
576 
577  bool operator== (const const_iterator& j) const { return _blk_dis_iub_iter == j._blk_dis_iub_iter; }
578  bool operator!= (const const_iterator& j) const { return ! operator== (j); }
579 //protected:
580 // data:
585  size_type _first_iu, _first_ib;
586 };
587 template <class T, class M>
588 inline
591 {
592  dis_dof_indexes_requires_update();
593  return const_iterator (_V.data()._idof2blk_dis_iub.begin(), _u.begin(), _b.begin(), _u.ownership().first_index(), _b.ownership().first_index());
594 }
595 template <class T, class M>
596 inline
599 {
600  dis_dof_indexes_requires_update();
601  return const_iterator (_V.data()._idof2blk_dis_iub.end(), _u.begin(), _b.begin(), _u.ownership().first_index(), _b.ownership().first_index());
602 }
603 // =================================================================================
604 // field: inlined
605 // =================================================================================
606 template <class T, class M>
607 inline
609  : _V(),
610  _u(),
611  _b(),
612  _dis_dof_indexes_requires_update(true),
613  _dis_dof_assembly_requires_update(false)
614 {
615 }
616 template <class T, class M>
617 inline
620 {
621  _V.operator= (x._V);
622  _u.operator= (x._u);
623  _b.operator= (x._b);
624  _dis_dof_indexes_requires_update = x._dis_dof_indexes_requires_update;
625  _dis_dof_assembly_requires_update = x._dis_dof_assembly_requires_update;
626  return *this;
627 }
628 template <class T, class M>
629 void
631 {
632  _dis_dof_indexes_requires_update = true;
633 }
634 template <class T, class M>
635 void
637 {
638  _dis_dof_assembly_requires_update = true;
639 }
640 // TODO: DVT_EXPR_CTE_VEC : value as point or tensor
641 template<class T, class M>
642 template <class Value>
643 inline
644 typename std::enable_if<
645  details::is_rheolef_arithmetic<Value>::value
647 >::type
649 {
650  check_macro (name() != "", "field=constant : uninitialized field in affectation");
651  std::fill (begin_dof(), end_dof(), value);
652  dis_dof_indexes_requires_update();
653  return *this;
654 }
655 template <class T, class M>
656 inline
657 T&
659 {
660  dis_dof_indexes_requires_update();
661  bool blk = _V.is_blocked (idof);
662  size_type dis_iub = _V.dis_iub (idof);
663  if (!blk) {
664  size_type iub = dis_iub - _u.ownership().first_index();
665  return _u [iub];
666  } else {
667  size_type iub = dis_iub - _b.ownership().first_index();
668  return _b [iub];
669  }
670 }
671 template <class T, class M>
672 inline
673 const T&
675 {
676  bool blk = _V.is_blocked (idof);
677  size_type dis_iub = _V.dis_iub (idof);
678  return (!blk) ? _u.dis_at(dis_iub) : _b.dis_at(dis_iub);
679 }
680 template <class T, class M>
681 inline
682 T
684 {
685  T val = std::numeric_limits<T>::max();
686  for (const_iterator iter = begin_dof(), last = end_dof(); iter != last; iter++) {
687  val = std::min(val, *iter);
688  }
689 #ifdef _RHEOLEF_HAVE_MPI
691  val = mpi::all_reduce (comm(), val, mpi::minimum<T>());
692  }
693 #endif // _RHEOLEF_HAVE_MPI
694  return val;
695 }
696 template <class T, class M>
697 inline
698 T
700 {
701  T val = std::numeric_limits<T>::min();
702  for (const_iterator iter = begin_dof(), last = end_dof(); iter != last; iter++) {
703  val = std::max(val, *iter);
704  }
705 #ifdef _RHEOLEF_HAVE_MPI
707  val = mpi::all_reduce (comm(), val, mpi::maximum<T>());
708  }
709 #endif // _RHEOLEF_HAVE_MPI
710  return val;
711 }
712 template <class T, class M>
713 inline
714 T
716 {
717  T val = std::numeric_limits<T>::max();
718  for (const_iterator iter = begin_dof(), last = end_dof(); iter != last; iter++) {
719  val = std::min(val, abs(*iter));
720  }
721 #ifdef _RHEOLEF_HAVE_MPI
723  val = mpi::all_reduce (comm(), val, mpi::minimum<T>());
724  }
725 #endif // _RHEOLEF_HAVE_MPI
726  return val;
727 }
728 template <class T, class M>
729 inline
730 T
732 {
733  T val = 0;
734  for (const_iterator iter = begin_dof(), last = end_dof(); iter != last; iter++) {
735  val = std::max(val, abs(*iter));
736  }
737 #ifdef _RHEOLEF_HAVE_MPI
739  val = mpi::all_reduce (comm(), val, mpi::maximum<T>());
740  }
741 #endif // _RHEOLEF_HAVE_MPI
742  return val;
743 }
744 template <class T, class M>
745 inline
746 idiststream&
747 operator >> (idiststream& ips, field_basic<T,M>& uh)
748 {
749  return uh.get (ips);
750 }
751 template <class T, class M>
752 inline
755 {
756  return uh.put (ops);
757 }
758 
759 }// namespace rheolef
760 # endif /* _RHEOLEF_FIELD_H */
rheolef::field_basic::end_dof
const_iterator end_dof() const
Definition: field.h:598
mkgeo_ball.n
int n
Definition: mkgeo_ball.sh:150
rheolef::geo_basic
generic mesh with rerefence counting
Definition: geo.h:1089
rheolef::field_basic::const_iterator::difference_type
std::ptrdiff_t difference_type
Definition: field.h:531
rheolef::field_basic::iterator
Definition: field.h:427
rheolef::field_basic::get_space
const space_type & get_space() const
Definition: field.h:300
rheolef::operator!=
bool operator!=(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition: heap_allocator.h:172
rheolef::field_basic::get_approx
std::string get_approx() const
Definition: field.h:303
rheolef::field_basic::iterator::size_type
vec< T, M >::size_type size_type
Definition: field.h:436
rheolef::operator+=
std::enable_if< details::is_rheolef_arithmetic< U >::value,ad3_basic< T > & >::type operator+=(ad3_basic< T > &a, const U &b)
Definition: ad3.h:286
rheolef::field_basic::ownership
const distributor & ownership() const
Definition: field.h:339
rheolef::field_basic::assembly
void assembly(const geo_basic< T, M > &dom, const Expr &expr, const integrate_option &iopt)
Definition: field_vf_assembly.h:170
rheolef::field_basic::end_dof
iterator end_dof()
Definition: field.h:509
rheolef::begin_dof
const_iterator begin_dof() const
Definition: field_expr_recursive.h:569
rheolef::field_basic::iterator::iter_t
disarray< space_pair_type, M >::const_iterator iter_t
Definition: field.h:430
gh
field gh(Float epsilon, Float t, const field &uh, const test &v)
Definition: burgers_diffusion_operators.icc:37
rheolef::field_basic::const_iterator::const_iterator
const_iterator(iter_t blk_dis_iub_iter, data_t u, data_t b, size_type first_iu, size_type first_ib)
Definition: field.h:543
mkgeo_ball.expr
expr
Definition: mkgeo_ball.sh:361
rheolef::point_basic
Definition: point.h:87
rheolef::details::or_type
Definition: field_expr_utilities.h:58
rheolef::field_basic::dis_vector_evaluate
point_basic< T > dis_vector_evaluate(const point_basic< T > &x) const
Definition: field.cc:490
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
rheolef::field_basic::comm
const communicator & comm() const
Definition: field.h:340
rheolef::distributor::comm
const communicator_type & comm() const
Definition: distributor.h:145
rheolef::vec::const_iterator
base::const_iterator const_iterator
Definition: vec.h:92
rheolef::field_basic::const_iterator::size_type
vec< T, M >::size_type size_type
Definition: field.h:527
rheolef::field_basic::begin_dof
const_iterator begin_dof() const
Definition: field.h:590
rheolef::field
field_basic< Float > field
see the field page for the full documentation
Definition: field.h:419
rheolef::field_basic::iterator::_u
data_t _u
Definition: field.h:494
rheolef::details::is_field_expr_affine_homogeneous
Definition: field.h:229
rheolef::operator*
csr< T, sequential > operator*(const T &lambda, const csr< T, sequential > &a)
Definition: csr.h:437
rheolef::value
rheolef::std value
rheolef::field_component_const
Definition: field_component.h:143
rheolef::field_basic::evaluate
T evaluate(const geo_element &K, const point_basic< T > &hat_xq, size_type i_comp=0) const
Definition: field.cc:435
rheolef::field_basic::_dis_dof_indexes_requires_update
bool _dis_dof_indexes_requires_update
Definition: field.h:406
rheolef::field_basic< T, rheo_default_memory_model >::float_type
typename float_traits< T >::type float_type
Definition: field.h:245
rheolef::field_basic::iterator::iterator
iterator(iter_t blk_dis_iub_iter, size_type blk_dis_iub_incr, data_t u, data_t b, size_type first_iu, size_type first_ib)
Definition: field.h:460
rheolef::field_basic::iterator::iterator
iterator()
Definition: field.h:444
rheolef::field_basic::const_iterator::reference
const T & reference
Definition: field.h:529
rheolef::field_basic::ndof
size_type ndof() const
Definition: field.h:341
rheolef::space_basic< float_type, rheo_default_memory_model >
rheolef::distributor
see the distributor page for the full documentation
Definition: distributor.h:62
band
see the band page for the full documentation
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::field_basic::name
std::string name() const
Definition: field.h:302
rheolef::field_basic::min_abs
T min_abs() const
Definition: field.h:715
rheolef::field_basic::iterator::difference_type
std::ptrdiff_t difference_type
Definition: field.h:440
rheolef::space_constant::valued_type
valued_type
Definition: space_constant.h:135
rheolef::space_numbering::dis_idof
void dis_idof(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_idof_tab)
Definition: space_numbering.cc:187
rheolef::field_basic::const_iterator::set_increment
void set_increment(size_type incr)
Definition: field.h:559
rheolef::field_indirect_const
Definition: field_indirect.h:266
rheolef::field_basic< T, rheo_default_memory_model >::result_type
T result_type
Definition: field.h:242
rheolef::vec
see the vec page for the full documentation
Definition: vec.h:79
rheolef::field_basic::dis_dof
const T & dis_dof(size_type dis_idof) const
Definition: field.cc:376
rheolef::field_basic::iterator::set_increment
void set_increment(size_type incr)
Definition: field.h:469
rheolef::field_basic::u
const vec< T, M > & u() const
Definition: field.h:310
rheolef::is_distributed
Definition: distributed.h:36
rheolef::operator==
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition: heap_allocator.h:167
rheolef::field_basic::field_basic
field_basic()
Definition: field.h:608
rheolef::field_basic::dis_dof_entry
dis_reference dis_dof_entry(size_type dis_idof)
Definition: field.cc:397
rheolef::field_basic::iterator::_blk_dis_iub_iter
iter_t _blk_dis_iub_iter
Definition: field.h:492
rheolef::field_basic< T, rheo_default_memory_model >::value_type
T value_type
Definition: field.h:241
rheolef::field_basic::get_geo
const geo_type & get_geo() const
Definition: field.h:301
rheolef::field_basic::resize
void resize(const space_type &V, const T &init_value=std::numeric_limits< T >::max())
Definition: field.cc:48
rheolef::integrate_option
see the integrate_option page for the full documentation
Definition: integrate_option.h:125
rheolef::field_basic::const_iterator::value_type
T value_type
Definition: field.h:528
rheolef::field_basic::const_iterator::operator++
const_iterator operator++(int)
Definition: field.h:570
rheolef::field_basic::_V
space_type _V
Definition: field.h:403
rheolef::field_indirect
Definition: field_indirect.h:39
rheolef::field_basic::set_u
vec< T, M > & set_u()
Definition: field.h:312
rheolef::vec::iterator
base::iterator iterator
Definition: vec.h:91
rheolef::field_basic::dof
const T & dof(size_type idof) const
Definition: field.h:674
rheolef::field_basic::set_b
vec< T, M > & set_b()
Definition: field.h:313
rheolef::field_basic::iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: field.h:435
rheolef::field_basic::iterator::iterator
iterator(iter_t blk_dis_iub_iter, data_t u, data_t b, size_type first_iu, size_type first_ib)
Definition: field.h:452
rheolef::field_basic::dis_dof_update
void dis_dof_update() const
Definition: field.cc:410
rheolef::field_basic::iterator::value_type
T value_type
Definition: field.h:437
rheolef::field_basic::valued_tag
valued_type valued_tag() const
Definition: field.h:304
rheolef::field_basic::min
T min() const
Definition: field.h:683
rheolef::field_basic::dis_dof_assembly_requires_update
void dis_dof_assembly_requires_update() const
Definition: field.h:636
rheolef::type
rheolef::std type
rheolef::field_basic::max
T max() const
Definition: field.h:699
rheolef::field_basic
Definition: field.h:235
rheolef::field_basic::dof
T & dof(size_type idof)
Definition: field.h:658
rheolef::field_basic::_b
vec< T, M > _b
Definition: field.h:405
rheolef::field_basic< T, rheo_default_memory_model >::scalar_type
T scalar_type
Definition: field.h:244
rheolef::field_basic::const_iterator::const_iterator
const_iterator(iterator i)
Definition: field.h:550
rheolef::field_component
Definition: field_component.h:61
rheolef::field_basic::const_iterator::_u
data_t _u
Definition: field.h:583
rheolef::details::is_field_expr_v2_constant
Definition: field.h:225
rheolef::field_basic::iterator::pointer
T * pointer
Definition: field.h:439
rheolef::field_basic::constraint_process_rank
int constraint_process_rank() const
Definition: field.h:368
rheolef::field_basic::iterator::reference
T & reference
Definition: field.h:438
rheolef::operator>>
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
rheolef::field_basic::const_iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: field.h:526
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::float_traits::type
T type
Definition: Float.h:94
rheolef::distributor::dis_size
size_type dis_size() const
global and local sizes
Definition: distributor.h:207
u
Definition: leveque.h:25
rheolef::field_basic::const_iterator::data_t
vec< T, M >::const_iterator data_t
Definition: field.h:520
rheolef::field_basic::iterator::data_t
vec< T, M >::iterator data_t
Definition: field.h:429
rheolef::field_basic::put_field
odiststream & put_field(odiststream &ops) const
Definition: field.cc:302
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
rheolef::field_basic::const_iterator::_blk_dis_iub_iter
iter_t _blk_dis_iub_iter
Definition: field.h:581
rheolef::disarray
see the disarray page for the full documentation
Definition: disarray.h:459
rheolef::details::field_concat_value
Definition: field_concat.h:33
rheolef::field_basic::dis_ndof
size_type dis_ndof() const
Definition: field.h:342
rheolef::field_basic::valued
const std::string & valued() const
Definition: field.h:305
rheolef::field_basic::const_iterator::iter_t
disarray< space_pair_type, M >::const_iterator iter_t
Definition: field.h:521
rheolef::const_iterator
Definition: field_expr_recursive.h:552
rheolef::field_basic::_u
vec< T, M > _u
Definition: field.h:404
rheolef::field_basic::have_homogeneous_space
bool have_homogeneous_space(space_basic< T, M > &Xh) const
Definition: field.h:306
rheolef::operator+
std::enable_if< details::is_rheolef_arithmetic< U >::value,ad3_basic< T >>::type operator+(const U &a, const ad3_basic< T > &b)
Definition: ad3.h:222
rheolef::field_basic::assembly_internal
void assembly_internal(const geo_basic< T, M > &dom, const geo_basic< T, M > &band, const band_basic< T, M > &gh, const Expr &expr, const integrate_option &qopt, bool is_on_band)
Definition: field_vf_assembly.h:95
rheolef::field_basic::const_iterator::_blk_dis_iub_incr
size_type _blk_dis_iub_incr
Definition: field.h:582
rheolef::field_sequential
field_basic< Float, sequential > field_sequential
Definition: field.h:421
rheolef::field_basic::iterator::operator++
iterator operator++(int)
Definition: field.h:480
rheolef::field_basic::b
const vec< T, M > & b() const
Definition: field.h:311
rheolef::details::is_rheolef_arithmetic
Definition: Float.h:150
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::field_basic::iterator::_blk_dis_iub_incr
size_type _blk_dis_iub_incr
Definition: field.h:493
rheolef::field_basic::begin_dof
iterator begin_dof()
Definition: field.h:501
rheolef::field_basic::operator()
field_component< T, M > operator()(size_type i_comp, size_type j_comp)
Definition: field.cc:508
rheolef::field_basic::iterator::_b
data_t _b
Definition: field.h:495
rheolef::field_basic::operator[]
field_indirect< T, M > operator[](const geo_basic< T, M > &dom)
Definition: field_indirect.h:158
rheolef::field_basic::const_iterator::const_iterator
const_iterator()
Definition: field.h:535
rheolef::field_basic< T, rheo_default_memory_model >::memory_type
rheo_default_memory_model memory_type
Definition: field.h:240
rheolef::field_basic::dis_evaluate
T dis_evaluate(const point_basic< T > &x, size_type i_comp=0) const
Definition: field.cc:460
rheolef::field_basic::dis_dof_indexes_requires_update
void dis_dof_indexes_requires_update() const
Definition: field.h:630
rheolef::field_basic::operator=
field_basic< T, M > & operator=(const field_basic< T, M > &)
Definition: field.h:619
rheolef::field_basic::size
size_type size() const
Definition: field.h:331
rheolef::field_basic::const_iterator::_first_iu
size_type _first_iu
Definition: field.h:585
mkgeo_ball.tmp
tmp
Definition: mkgeo_ball.sh:380
rheolef::field_basic::const_iterator::_b
data_t _b
Definition: field.h:584
rheolef::field_basic::const_iterator::pointer
const T * pointer
Definition: field.h:530
rheolef::operator<<
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition: catchmark.h:99
rheolef::field_basic::put
odiststream & put(odiststream &ops) const
Definition: field.cc:366
rheolef::field_basic::const_iterator
Definition: field.h:518
rheolef::field_basic::_dis_dof_assembly_requires_update
bool _dis_dof_assembly_requires_update
Definition: field.h:407
rheolef::field_basic::max_abs
T max_abs() const
Definition: field.h:731
rheolef::field_basic::get
idiststream & get(idiststream &ips)
Definition: field.cc:121
rheolef::field_basic::iterator::_first_iu
size_type _first_iu
Definition: field.h:496
rheolef::vec::size_type
base::size_type size_type
Definition: vec.h:86
mkgeo_contraction.name
string name
Definition: mkgeo_contraction.sh:133
M
Expr1::memory_type M
Definition: vec_expr_v2.h:416
rheolef::distributor::size
size_type size(size_type iproc) const
Definition: distributor.h:163
rheolef::field_basic< T, rheo_default_memory_model >::size_type
std::size_t size_type
Definition: field.h:239
rheolef::field_basic< T, rheo_default_memory_model >::dis_reference
typename vec< T, rheo_default_memory_model >::dis_reference dis_reference
Definition: field.h:249
rheolef::details::is_field
Definition: field_expr_terminal.h:61
T
Expr1::float_type T
Definition: field_expr.h:261