Rheolef  7.1
an efficient C++ finite element environment
field_indirect.h
Go to the documentation of this file.
1 # ifndef _RHEOLEF_FIELD_INDIRECT_H
2 # define _RHEOLEF_FIELD_INDIRECT_H
3 
24 #include "rheolef/field.h"
25 
26 namespace rheolef {
27 
28 // forward:
29 template <class T, class M>
30 class field_indirect_const;
31 
32 // =================================================================================
33 // field_indirect
34 // as for:
35 // uh["left"] = value
36 // uh["left"] = gh
37 // =================================================================================
38 template <class T, class M = rheo_default_memory_model>
40 public:
41 // typedefs
42 
44  typedef T value_type;
45  typedef M memory_type;
48  class iterator;
49  class const_iterator;
50 
51 // allocators:
52 
54  : _V(uh.get_space()),
55  _W(),
56  _dom(dom),
57  _indirect(),
58  _val(uh.begin_dof())
59  {
60  if (! (_V.get_basis().option().is_restricted_to_sides()
61  && _V.get_geo().map_dimension() == _dom.map_dimension() + 1)) {
62  _W = space_basic<T,M> (dom, _V.get_basis().name());
63  } else {
64  // restricted on a subdomain: e.g. Pkd[sides](square) => Pkd(square[interface])
65  // i.e. the basis should remove the "sides" option
66  size_type k = _V.get_basis().degree();
67  _W = space_basic<T,M> (dom, "P"+itos(k)+"d", _V.valued());
68 #ifdef TODO
69  // TODO: more general, by skipping "sides" in option basis: how to do that?
70  // something as: basis b2 = b; bopt=b.opt(); bopt.set_restr(false); b2.reset(bopt);
71  // space (omega,b2.name());
72  basis b = _V.get_basis();
73  basis_option bopt = b.option();
74  bopt.set_restricted_to_sides (false);
75  b.reset (bopt);
76  _W = space_basic<T,M> (dom, b.name()); // TODO: a cstor space(dom,basis) ?
77  // => fatal(../../include/rheolef/smart_pointer.h,330): no_copy functor called (illegal copy)
78 #endif // TODO
79  }
80  _indirect = disarray<size_type,M> (_V.build_indirect_array (_W, dom));
81  }
82 
84 
86 
87  template <class Expr,
88  class Sfinae
89  = typename std::enable_if<
92  >::type>
93  field_indirect<T,M>& operator= (const Expr&);
94 
95  // explicit copy cstor (avoid simple copy of the proxy; see nfem/ptst/field_comp_assign_tst.cc )
97  return this -> template operator=<field_indirect<T,M> > (expr);
98  }
99 
100 // accessors:
101 
102  const distributor& ownership() const { return _indirect.ownership(); }
103  const communicator& comm() const { return ownership().comm(); }
104  size_type ndof() const { return ownership().size(); }
105  size_type dis_ndof() const { return ownership().dis_size(); }
106  std::string name() const;
107  const space_basic<T,M>& get_space() const { return _W; }
108  bool have_homogeneous_space (space_basic<T,M>& Xh) const { Xh = get_space(); return true; }
109  T& dof (size_type idof) { return _val [_indirect [idof]]; }
110  const T& dof (size_type idof) const { return _val [_indirect [idof]]; }
111 
112  iterator begin_dof();
113  iterator end_dof();
114  const_iterator begin_dof() const;
116 protected:
117  friend class field_basic<T,M>;
118  friend class field_indirect_const<T,M>;
119  static std::string _name_internal (const space_basic<T,M>& V, const geo_basic<T,M>& dom);
120 // data:
125  typename field_basic<T,M>::iterator _val; // iterator = reference on an external variable uh
126  // => cstor is protected : prevent copy outside the field class
127 };
128 template<class T, class M>
129 inline
132 {
133  std::fill (begin_dof(), end_dof(), alpha);
134  return *this;
135 }
136 template<class T, class M>
137 inline
138 std::string
140 {
141  return _name_internal (_V, _dom);
142 }
143 template<class T, class M>
144 std::string
146  const space_basic<T,M>& V,
147  const geo_basic<T,M>& dom)
148 {
149  // e.g. "P1(square[left]", an unique signature for field_expr<Expr> size-like checks
150  std::string dom_name = (dom.variant() != geo_abstract_base_rep<T>::geo_domain) ?
151  V.get_geo().name() + "[" + dom.name() + "]" :
152  dom.name();
153  return V.get_basis().name() + "{" + dom_name + "}";
154 }
155 template<class T, class M>
156 inline
159 {
160  dis_dof_indexes_requires_update();
161  return field_indirect<T,M> (*this, dom);
162 }
163 template<class T, class M>
164 inline
166 field_basic<T,M>::operator[] (std::string dom_name)
167 {
168  dis_dof_indexes_requires_update();
169  return operator[] (get_space().get_geo().operator[] (dom_name));
170 }
171 // =================================================================================
172 // field_indirect::iterator
173 // =================================================================================
174 template <class T, class M>
176 public:
177 // typedef:
178  typedef std::forward_iterator_tag iterator_category; // TODO: not fully random yet
179  typedef typename vec<T,M>::size_type size_type;
180  typedef T value_type;
181  typedef T& reference;
182  typedef T* pointer;
183  typedef std::ptrdiff_t difference_type;
184 // allocator:
186  : _idof_iter(idof_iter), _val(val) {}
187 
188 // accessors & modifiers:
189  T& operator* () { return _val [*_idof_iter]; }
190  const T& operator* () const { return _val [*_idof_iter]; }
191  iterator& operator++() { ++_idof_iter; return *this; }
192 
193 // comparators:
194 
195  bool operator== (const iterator& j) const { return _idof_iter == j._idof_iter; }
196  bool operator!= (const iterator& j) const { return ! operator== (j); }
197 protected:
198 // data:
201 };
202 template<class T, class M>
203 inline
206 {
207  return iterator (_indirect.begin(), _val);
208 }
209 template<class T, class M>
210 inline
213 {
214  return iterator (_indirect.end(), _val);
215 }
216 // =================================================================================
217 // field_indirect::const_iterator
218 // =================================================================================
219 template <class T, class M>
221 public:
222 // typedef:
223  typedef std::forward_iterator_tag iterator_category; // TODO: not fully random yet
224  typedef typename vec<T,M>::size_type size_type;
225  typedef T value_type;
226  typedef const T& reference;
227  typedef const T* pointer;
228  typedef std::ptrdiff_t difference_type;
229 // allocator:
231  : _idof_iter(idof_iter), _val(val) {}
232 
233 // accessors & modifiers:
234  const T& operator* () const { return _val [*_idof_iter]; }
235  const_iterator& operator++() { ++_idof_iter; return *this; }
236 
237 // comparators:
238 
239  bool operator== (const const_iterator& j) const { return _idof_iter == j._idof_iter; }
240  bool operator!= (const const_iterator& j) const { return ! operator== (j); }
241 protected:
242 // data:
245 };
246 template<class T, class M>
247 inline
250 {
251  return const_iterator (_indirect.begin(), _val);
252 }
253 template<class T, class M>
254 inline
257 {
258  return const_iterator (_indirect.end(), _val);
259 }
260 // =================================================================================
261 // field_indirect_const
262 // as for:
263 // gh = uh["left"]
264 // =================================================================================
265 template <class T, class M = rheo_default_memory_model>
267 public:
268 //protected:
269 
270 // typedefs:
271 
273  typedef T scalar_type;
274  typedef T value_type; // TODO: run-time dependent
275  typedef M memory_type;
276  class const_iterator;
277 
278 // allocators:
279 
281  : _V(uh.get_space()),
282  _W(dom, _V.get_basis().name()),
283  _dom(dom),
284  _indirect(_V.build_indirect_array (_W, dom)),
285  _val(uh.begin_dof())
286  {}
287 
289  : _V(gh._V),
290  _W(gh._W),
291  _dom(gh._dom),
293  _val(gh._val)
294  {}
295 
296 // accessors:
297 //protected:
298 
299  const distributor& ownership() const { return _indirect.ownership(); }
300  const communicator& comm() const { return ownership().comm(); }
301  size_type ndof() const { return ownership().size(); }
302  size_type dis_ndof() const { return ownership().dis_size(); }
303  std::string name() const;
304  space_basic<T,M> get_space() const { return _W; }
305  bool have_homogeneous_space (space_basic<T,M>& Xh) const { Xh = get_space(); return true; }
306 
307  const T& dof(size_type idof) const { return _val [_indirect [idof]]; }
308 
309  const_iterator begin_dof() const;
311  friend class field_basic<T,M>;
312 protected:
317  typename field_basic<T,M>::const_iterator _val; // iterator = reference on an external variable uh
318  // thus cstor is protected to prevent copy outside the field class
319 };
320 template<class T, class M>
321 inline
322 std::string
324 {
326 }
327 template<class T, class M>
328 inline
331 {
332  return field_indirect_const<T,M> (*this, dom);
333 }
334 template<class T, class M>
335 inline
337 field_basic<T,M>::operator[] (std::string dom_name) const
338 {
339  return operator[] (get_space().get_geo().operator[] (dom_name));
340 }
341 // =================================================================================
342 // field_indirect_const::const_iterator
343 // =================================================================================
344 template <class T, class M>
346 public:
347 // typedefs:
348 
349  typedef std::forward_iterator_tag iterator_category; // TODO: not fully random yet
350  typedef typename vec<T,M>::size_type size_type;
351  typedef T value_type;
352  typedef const T& reference;
353  typedef const T* pointer;
354  typedef std::ptrdiff_t difference_type;
355 
356 // allocator:
358  : _idof_iter(idof_iter), _val(val) {}
359 
360 // accessors & modifiers:
361  const T& operator* () const { return _val [*_idof_iter]; }
362  const_iterator& operator++() { ++_idof_iter; return *this; }
363 
364 // comparators:
365 
366  bool operator== (const const_iterator& j) const { return _idof_iter == j._idof_iter; }
367  bool operator!= (const const_iterator& j) const { return ! operator== (j); }
368 protected:
369 // data:
372 };
373 template<class T, class M>
374 inline
377 {
378  return const_iterator (_indirect.begin(), _val);
379 }
380 template<class T, class M>
381 inline
384 {
385  return const_iterator (_indirect.end(), _val);
386 }
387 // =================================================================================
388 // io
389 // =================================================================================
390 template <class T, class M>
391 inline
394 {
395  field_basic<T,M> tmp = uh;
396  return tmp.put (ops);
397 }
398 template <class T, class M>
399 inline
402 {
403  field_basic<T,M> tmp = uh;
404  return tmp.put (ops);
405 }
406 
407 }// namespace rheolef
408 # endif /* _RHEOLEF_FIELD_INDIRECT_H */
rheolef::field_indirect_const::const_iterator::_val
field_basic< T, M >::const_iterator _val
Definition: field_indirect.h:371
rheolef::field_indirect_const::begin_dof
const_iterator begin_dof() const
Definition: field_indirect.h:376
rheolef::field_indirect::const_iterator::operator++
const_iterator & operator++()
Definition: field_indirect.h:235
rheolef::field_indirect_const::const_iterator::const_iterator
const_iterator(typename disarray< size_type, M >::const_iterator idof_iter, typename field_basic< T, M >::const_iterator val)
Definition: field_indirect.h:357
rheolef::geo_basic
generic mesh with rerefence counting
Definition: geo.h:1089
rheolef::field_basic::iterator
Definition: field.h:427
rheolef::field_indirect::ndof
size_type ndof() const
Definition: field_indirect.h:104
rheolef::operator!=
bool operator!=(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition: heap_allocator.h:172
rheolef::field_indirect::iterator
Definition: field_indirect.h:175
rheolef::field_indirect::_W
space_basic< T, M > _W
Definition: field_indirect.h:122
rheolef::field_indirect_const::ndof
size_type ndof() const
Definition: field_indirect.h:301
rheolef::begin_dof
const_iterator begin_dof() const
Definition: field_expr_recursive.h:569
gh
field gh(Float epsilon, Float t, const field &uh, const test &v)
Definition: burgers_diffusion_operators.icc:37
bdf::alpha
Float alpha[pmax+1][pmax+1]
Definition: bdf.icc:28
mkgeo_ball.expr
expr
Definition: mkgeo_ball.sh:361
rheolef::field_indirect_const::memory_type
M memory_type
Definition: field_indirect.h:275
rheolef::field_indirect::end_dof
iterator end_dof()
Definition: field_indirect.h:212
rheolef::distributor::comm
const communicator_type & comm() const
Definition: distributor.h:145
rheolef::field_indirect::dof
const T & dof(size_type idof) const
Definition: field_indirect.h:110
rheolef::field_indirect::iterator::_idof_iter
disarray< size_type, M >::const_iterator _idof_iter
Definition: field_indirect.h:199
mkgeo_ball.b
int b
Definition: mkgeo_ball.sh:152
rheolef::field_indirect_const::ownership
const distributor & ownership() const
Definition: field_indirect.h:299
rheolef::field_indirect::_indirect
disarray< size_type, M > _indirect
Definition: field_indirect.h:124
rheolef::field_indirect_const::dof
const T & dof(size_type idof) const
Definition: field_indirect.h:307
rheolef::field_indirect::const_iterator
Definition: field_indirect.h:220
rheolef::details::is_field_expr_affine_homogeneous
Definition: field.h:229
rheolef::field_indirect::have_homogeneous_space
bool have_homogeneous_space(space_basic< T, M > &Xh) const
Definition: field_indirect.h:108
rheolef::field_indirect::const_iterator::_idof_iter
disarray< size_type, M >::const_iterator _idof_iter
Definition: field_indirect.h:243
rheolef::operator*
csr< T, sequential > operator*(const T &lambda, const csr< T, sequential > &a)
Definition: csr.h:437
rheolef::field_indirect::scalar_type
scalar_traits< value_type >::type scalar_type
Definition: field_indirect.h:46
rheolef::field_indirect_const::_W
space_basic< T, M > _W
Definition: field_indirect.h:314
rheolef::field_indirect_const::const_iterator::size_type
vec< T, M >::size_type size_type
Definition: field_indirect.h:350
rheolef::space_basic
the finite element space
Definition: space.h:352
rheolef::distributor
see the distributor page for the full documentation
Definition: distributor.h:62
rheolef::basis_option::set_restricted_to_sides
void set_restricted_to_sides(bool r=true)
Definition: basis_option.h:281
rheolef::field_indirect_const::end_dof
const_iterator end_dof() const
Definition: field_indirect.h:383
rheolef::field_indirect_const::_dom
geo_basic< T, M > _dom
Definition: field_indirect.h:315
rheolef::field_indirect::memory_type
M memory_type
Definition: field_indirect.h:45
rheolef::field_indirect_const::const_iterator::_idof_iter
disarray< size_type, M >::const_iterator _idof_iter
Definition: field_indirect.h:370
rheolef::field_indirect::_val
field_basic< T, M >::iterator _val
Definition: field_indirect.h:125
rheolef::basis_option
see the basis_option page for the full documentation
Definition: basis_option.h:93
rheolef::field_indirect::iterator::size_type
vec< T, M >::size_type size_type
Definition: field_indirect.h:179
rheolef::field_indirect_const
Definition: field_indirect.h:266
rheolef::field_indirect_const::_val
field_basic< T, M >::const_iterator _val
Definition: field_indirect.h:317
rheolef::field_indirect::const_iterator::difference_type
std::ptrdiff_t difference_type
Definition: field_indirect.h:228
rheolef::field_indirect::iterator::reference
T & reference
Definition: field_indirect.h:181
rheolef::field_indirect::field_indirect
field_indirect(field_basic< T, M > &uh, const geo_basic< T, M > &dom)
Definition: field_indirect.h:53
rheolef::operator==
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition: heap_allocator.h:167
rheolef::field_indirect::comm
const communicator & comm() const
Definition: field_indirect.h:103
rheolef::field_indirect_const::value_type
T value_type
Definition: field_indirect.h:274
rheolef::geo_abstract_base_rep
abstract base interface class
Definition: geo.h:248
rheolef::field_indirect::value_type
T value_type
Definition: field_indirect.h:44
rheolef::field_indirect::iterator::value_type
T value_type
Definition: field_indirect.h:180
rheolef::field_indirect::const_iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: field_indirect.h:223
rheolef::field_indirect
Definition: field_indirect.h:39
rheolef::field_indirect_const::const_iterator
Definition: field_indirect.h:345
rheolef::field_indirect_const::get_space
space_basic< T, M > get_space() const
Definition: field_indirect.h:304
basis
see the basis page for the full documentation
rheolef::field_indirect::_dom
geo_basic< T, M > _dom
Definition: field_indirect.h:123
rheolef::field_indirect_const::name
std::string name() const
Definition: field_indirect.h:323
rheolef::field_indirect::const_iterator::const_iterator
const_iterator(typename disarray< size_type, M >::const_iterator idof_iter, typename field_basic< T, M >::const_iterator val)
Definition: field_indirect.h:230
rheolef::field_indirect_const::const_iterator::operator++
const_iterator & operator++()
Definition: field_indirect.h:362
rheolef::field_indirect::iterator::_val
field_basic< T, M >::iterator _val
Definition: field_indirect.h:200
rheolef::field_indirect_const::const_iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: field_indirect.h:349
rheolef::type
rheolef::std type
rheolef::field_basic
Definition: field.h:235
rheolef::field_indirect_const::field_indirect_const
field_indirect_const(field_indirect< T, M > gh)
Definition: field_indirect.h:288
rheolef::field_indirect_const::have_homogeneous_space
bool have_homogeneous_space(space_basic< T, M > &Xh) const
Definition: field_indirect.h:305
rheolef::field_component
Definition: field_component.h:61
rheolef::field_indirect::get_space
const space_basic< T, M > & get_space() const
Definition: field_indirect.h:107
rheolef::details::is_field_expr_v2_constant
Definition: field.h:225
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::float_traits::type
T type
Definition: Float.h:94
rheolef::distributor::dis_size
size_type dis_size() const
global and local sizes
Definition: distributor.h:207
rheolef::field_indirect::iterator::iterator
iterator(typename disarray< size_type, M >::const_iterator idof_iter, typename field_basic< T, M >::iterator val)
Definition: field_indirect.h:185
rheolef::field_indirect::size_type
field_basic< T, M >::size_type size_type
Definition: field_indirect.h:43
rheolef::field_indirect::const_iterator::reference
const T & reference
Definition: field_indirect.h:226
rheolef::field_indirect_const::const_iterator::pointer
const T * pointer
Definition: field_indirect.h:353
rheolef::field_indirect::dof
T & dof(size_type idof)
Definition: field_indirect.h:109
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
rheolef::field_indirect::iterator::difference_type
std::ptrdiff_t difference_type
Definition: field_indirect.h:183
rheolef::field_indirect::const_iterator::value_type
T value_type
Definition: field_indirect.h:225
rheolef::disarray< size_type, M >
rheolef::field_indirect_const::const_iterator::difference_type
std::ptrdiff_t difference_type
Definition: field_indirect.h:354
rheolef::field_indirect::operator=
field_indirect< T, M > & operator=(const T &alpha)
Definition: field_indirect.h:131
rheolef::field_indirect::const_iterator::pointer
const T * pointer
Definition: field_indirect.h:227
rheolef::scalar_traits::type
T type
Definition: point.h:324
rheolef::const_iterator
Definition: field_expr_recursive.h:552
rheolef::field_indirect::iterator::operator++
iterator & operator++()
Definition: field_indirect.h:191
rheolef::field_indirect::const_iterator::size_type
vec< T, M >::size_type size_type
Definition: field_indirect.h:224
rheolef::field_indirect_const::const_iterator::reference
const T & reference
Definition: field_indirect.h:352
rheolef::field_indirect_const::const_iterator::value_type
T value_type
Definition: field_indirect.h:351
rheolef::field_indirect::iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: field_indirect.h:178
rheolef::field_indirect_const::size_type
field_basic< T, M >::size_type size_type
Definition: field_indirect.h:272
rheolef::field_basic::operator[]
field_indirect< T, M > operator[](const geo_basic< T, M > &dom)
Definition: field_indirect.h:158
rheolef::field_indirect_const::_V
space_basic< T, M > _V
Definition: field_indirect.h:313
get_geo
void get_geo(istream &in, my_geo &omega)
Definition: field2gmsh_pos.cc:126
rheolef::field_indirect_const::scalar_type
T scalar_type
Definition: field_indirect.h:273
rheolef::field_indirect::name
std::string name() const
Definition: field_indirect.h:139
rheolef::field_indirect_const::_indirect
disarray< size_type, M > _indirect
Definition: field_indirect.h:316
rheolef::field_indirect_const::field_indirect_const
field_indirect_const(const field_basic< T, M > &uh, const geo_basic< T, M > &dom)
Definition: field_indirect.h:280
rheolef::field_indirect::begin_dof
iterator begin_dof()
Definition: field_indirect.h:205
rheolef::field_indirect::dis_ndof
size_type dis_ndof() const
Definition: field_indirect.h:105
rheolef::itos
std::string itos(std::string::size_type i)
itos: see the rheostream page for the full documentation
mkgeo_ball.tmp
tmp
Definition: mkgeo_ball.sh:380
rheolef::operator<<
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition: catchmark.h:99
rheolef::field_basic::const_iterator
Definition: field.h:518
rheolef::field_indirect_const::comm
const communicator & comm() const
Definition: field_indirect.h:300
rheolef::field_indirect::const_iterator::_val
field_basic< T, M >::const_iterator _val
Definition: field_indirect.h:244
rheolef::field_indirect::ownership
const distributor & ownership() const
Definition: field_indirect.h:102
rheolef::vec::size_type
base::size_type size_type
Definition: vec.h:86
rheolef::field_indirect::_V
space_basic< T, M > _V
Definition: field_indirect.h:121
rheolef::field_indirect::float_type
float_traits< scalar_type >::type float_type
Definition: field_indirect.h:47
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_indirect_const::dis_ndof
size_type dis_ndof() const
Definition: field_indirect.h:302
rheolef::field_indirect::iterator::pointer
T * pointer
Definition: field_indirect.h:182
rheolef::field_basic::size_type
std::size_t size_type
Definition: field.h:239
T
Expr1::float_type T
Definition: field_expr.h:261
rheolef::field_indirect::_name_internal
static std::string _name_internal(const space_basic< T, M > &V, const geo_basic< T, M > &dom)
Definition: field_indirect.h:145