Rheolef  7.1
an efficient C++ finite element environment
field_component.h
Go to the documentation of this file.
1 #ifndef _RHEOLEF_FIELD_COMPONENT_H
2 #define _RHEOLEF_FIELD_COMPONENT_H
3 
24 /* TODO: when slip B.C. or Raviart-Thomas RT H(div) approx :
25  uh[0] values are computed on the fly in a temporary
26 
27 struct field_component {
28 // data:
29  field_basic<T,M>::iterator _start, _last;
30  const space_constit& _constit; // a ce niveau
31  field* _tmp_comp_ptr; // si necesite un temporaire
32 // actions:
33  field_component (field& uh, i_comp) {
34  constit = uh.get_space().get_constitution();
35  _constit = constit[i_comp]);
36  if (! constit.has_slip_bc() && ! constit.has_hdiv()) {
37  _tmp_comp_ptr = 0;
38  _star & _last : pointe dans le field uh
39  } else {
40  space Vi (_constit);
41  _tmp_comp_ptr = new field (Vi);
42  uh.compute_slip_comp (i_comp, *_tmp_comp_ptr);
43  _star & _last : pointe dans *_tmp_comp_ptr
44  }
45  }
46  ~field_component () {
47  if (_tmp_comp_ptr) delete _tmp_comp_ptr;
48  }
49 };
50 */
51 
52 #include "rheolef/field.h"
53 #include "rheolef/field_indirect.h"
54 
55 namespace rheolef {
56 
57 // =========================================================================
58 // field_component
59 // =========================================================================
60 template<class T, class M>
61 class field_component {
62 public:
63 
64 // typename:
65 
67  typedef T value_type;
68  typedef M memory_type;
73 
74 // allocators:
75 
76  field_component ();
79 
81 
82  template <class Expr,
83  class Sfinae
84  = typename std::enable_if<
87  >::type>
88  field_component<T,M>& operator= (const Expr&);
89 
90  // explicit copy cstor (avoid simple copy of the proxy; see nfem/ptst/field_comp_assign_tst.cc )
92  return this -> template operator=<field_component<T,M> > (expr);
93  }
94 
95 // high-level accessors & modifiers:
96 
98  field_indirect<T,M> operator[] (const std::string& dom_name);
99 
100 // recursive call:
101 
102  field_component<T,M> operator[] (size_t i_comp);
103 
104 // low-level accessors & modifiers:
105 
107  std::string name() const { return _constit.name(); }
108  geo_basic<T,M> get_geo() const { return _constit.get_geo(); }
110  bool have_homogeneous_space (space_basic<T,M>& Xh) const { Xh = get_space(); return true; }
111  const distributor& ownership() const { return _constit.ownership(); }
112  const communicator& comm() const { return ownership().comm(); }
113  size_type ndof() const { return ownership().size(); }
114  size_type dis_ndof() const { return ownership().dis_size(); }
115  T& dof (size_type idof) { return _start [idof]; }
116  const T& dof (size_type idof) const { return _start [idof]; }
117  iterator begin_dof() { return _start; }
118  iterator end_dof() { return _last; }
121 
122 // advanced usage:
124  friend class field_component_const<T,M>;
125  template<class Iterator>
126  static void initialize (
127  const space_constitution<T,M>& sup_constit,
128  size_type i_comp,
129  space_constitution<T,M>& constit,
130  Iterator& start,
131  Iterator& last);
132 protected:
133  static const size_type _unset = std::numeric_limits<size_type>::max();
134 // data:
138 };
139 // =========================================================================
140 // field_component_const
141 // =========================================================================
142 template<class T, class M>
143 class field_component_const {
144 public:
145 
146 // typename:
147 
149  typedef T value_type;
150  typedef M memory_type;
154 
155 // allocators:
156 
161  std::string name() const { return _constit.name(); }
162  const distributor& ownership() const { return _constit.ownership(); }
163  const communicator& comm() const { return ownership().comm(); }
164  geo_basic<T,M> get_geo() const { return _constit.get_geo(); }
166  bool have_homogeneous_space (space_basic<T,M>& Xh) const { Xh = get_space(); return true; }
167  size_type ndof() const { return ownership().size(); }
168  size_type dis_ndof() const { return ownership().dis_size(); }
169  const T& dof (size_type idof) const { return _start [idof]; }
172 
173 // advanced usage:
175 protected:
176  static const size_type _unset = std::numeric_limits<size_type>::max();
177 // data:
181 private:
182  field_component_const<T,M>& operator= (const field_component_const<T,M>& uh_comp);
183 };
184 // =========================================================================
185 // inlined
186 // =========================================================================
187 template<class T, class M>
188 inline
190  : _constit(),
191  _start(),
192  _last()
193 {
194 }
195 template<class T, class M>
196 inline
198  : _constit(),
199  _start(),
200  _last()
201 {
202 }
203 template<class T, class M>
204 template<class Iterator>
205 void
207  const space_constitution<T,M>& sup_constit,
208  size_type i_comp,
209  space_constitution<T,M>& constit,
210  Iterator& start,
211  Iterator& last)
212 {
213  if (sup_constit.is_hierarchical()) {
214  size_type n_comp = sup_constit.size();
215  check_macro (i_comp < n_comp,
216  "field component index "<<i_comp<<" is out of range [0:"<<n_comp<<"[");
217  size_type shift = 0;
218  for (size_type j_comp = 0; j_comp < i_comp; j_comp++) {
219  shift += sup_constit [j_comp].ndof();
220  }
221  constit = sup_constit [i_comp];
222  size_type sz = constit.ndof();
223  start += shift;
224  last += shift + sz;
225  } else {
226  size_type n_comp = sup_constit.get_basis().size();
227  check_macro (i_comp < n_comp,
228  "field component index "<<i_comp<<" is out of range [0:"<<n_comp<<"[");
229  constit = space_constitution<T,M>(sup_constit.get_geo(), sup_constit.get_basis()[i_comp].name());
230  start += i_comp;
231  last += i_comp + n_comp*constit.ndof();
232  start.set_increment (n_comp);
233  last.set_increment (n_comp);
234  }
235 }
236 template<class T, class M>
238  : _constit(),
239  _start(uh.begin_dof()),
240  _last(uh.begin_dof())
241 {
242  initialize (uh.get_space().get_constitution(), i_comp, _constit, _start, _last);
243 }
244 template<class T, class M>
246  : _constit(),
247  _start(uh.begin_dof()),
248  _last(uh.begin_dof())
249 {
250  field_component<T,M>::initialize (uh.get_space().get_constitution(), i_comp, _constit, _start, _last);
251 }
252 template<class T, class M>
254  : _constit(),
255  _start(uh._start),
256  _last(uh._last)
257 {
258  initialize (uh._constit, i_comp, _constit, _start, _last);
259 }
260 template<class T, class M>
261 inline
263  : _constit (uh_comp.get_constitution()),
264  _start(uh_comp.begin_dof()),
265  _last(uh_comp.end_dof())
266 {
267 }
268 template<class T, class M>
269 inline
272 {
273  // avoided at compile time: is private
274  fatal_macro ("try to assign const field in field[i_comp] = field[j_comp]");
275  return *this;
276 }
277 template<class T, class M>
278 inline
279 field_component_const<T,M>&
281 {
282  _constit = uh_comp.get_constitution();
283  _start = uh_comp.begin_dof();
284  _last = uh_comp.end_dof();
285  return *this;
286 }
287 template<class T, class M>
288 inline
291 {
292  _constit = uh_comp.get_constitution();
293  _start = uh_comp.begin_dof();
294  _last = uh_comp.end_dof();
295  return *this;
296 }
297 template<class T, class M>
298 inline
301 {
302  dis_dof_indexes_requires_update();
303  return field_component<T,M> (*this, i_comp);
304 }
305 template<class T, class M>
306 inline
309 {
310  return field_component<T,M> (*this, i_comp);
311 }
312 template<class T, class M>
313 inline
316 {
317  return field_component_const<T,M> (*this, i_comp);
318 }
319 template<class T, class M>
320 inline
323 {
324  std::fill (begin_dof(), end_dof(), alpha);
325  return *this;
326 }
327 #ifdef TODO
328 // TODO: as: field vh; din >> vh ; uh[i_comp] = vh;
329 template <class T, class M>
330 inline
331 idiststream& operator >> (odiststream& ids, field_basic<T,M>& u);
332 #endif // TODO
333 
334 template <class T, class M>
336 {
337  return ods << field_basic<T,M>(uh_comp);
338 }
339 template <class T, class M>
340 inline
342 {
343  return ods << field_basic<T,M>(uh_comp);
344 }
345 // =========================================================================
346 // uh[0]["boundary"] = alpha;
347 // => field_component & field_indirect together
348 // =========================================================================
349 template <class T, class M>
350 inline
352  : _V(uh_comp.get_space()),
353  _W(dom, _V.get_basis().name()),
354  _dom(dom),
355  _indirect(_V.build_indirect_array (_W, _dom.name())),
356  _val(uh_comp.begin_dof())
357 {
358 }
359 template <class T, class M>
360 inline
363 {
364  return field_indirect<T,M> (*this, dom);
365 }
366 template <class T, class M>
367 inline
369 field_component<T,M>::operator[] (const std::string& dom_name)
370 {
371  return field_indirect<T,M> (*this, get_geo().operator[](dom_name));
372 }
373 
374 } // namespace rheolef
375 #endif // _RHEOLEF_FIELD_COMPONENT_H
rheolef::field_component_const::get_constitution
const space_constitution< T, M > & get_constitution() const
Definition: field_component.h:160
rheolef::field_component::comm
const communicator & comm() const
Definition: field_component.h:112
rheolef::field_component::initialize
static void initialize(const space_constitution< T, M > &sup_constit, size_type i_comp, space_constitution< T, M > &constit, Iterator &start, Iterator &last)
Definition: field_component.h:206
rheolef::geo_basic< T, M >
rheolef::field_basic::iterator
Definition: field.h:427
rheolef::field_component::dis_ndof
size_type dis_ndof() const
Definition: field_component.h:114
rheolef::field_basic::get_space
const space_type & get_space() const
Definition: field.h:300
rheolef::field_component::_constit
space_constitution< T, M > _constit
Definition: field_component.h:135
rheolef::space_constitution::ndof
size_type ndof() const
Definition: space_constitution.h:412
rheolef::field_component::begin_dof
iterator begin_dof()
Definition: field_component.h:117
rheolef::begin_dof
const_iterator begin_dof() const
Definition: field_expr_recursive.h:569
bdf::alpha
Float alpha[pmax+1][pmax+1]
Definition: bdf.icc:28
mkgeo_ball.expr
expr
Definition: mkgeo_ball.sh:361
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::space_constitution::is_hierarchical
bool is_hierarchical() const
Definition: space_constitution.h:432
rheolef::distributor::comm
const communicator_type & comm() const
Definition: distributor.h:145
rheolef::field_component::ownership
const distributor & ownership() const
Definition: field_component.h:111
rheolef::field_component::float_type
float_traits< T >::type float_type
Definition: field_component.h:70
rheolef::field_component_const::size_type
field_basic< T, M >::size_type size_type
Definition: field_component.h:148
rheolef::details::is_field_expr_affine_homogeneous
Definition: field.h:229
rheolef::field_component_const::get_space
space_basic< T, M > get_space() const
Definition: field_component.h:165
rheolef::field_component::have_homogeneous_space
bool have_homogeneous_space(space_basic< T, M > &Xh) const
Definition: field_component.h:110
rheolef::field_component_const::comm
const communicator & comm() const
Definition: field_component.h:163
rheolef::field_component_const::have_homogeneous_space
bool have_homogeneous_space(space_basic< T, M > &Xh) const
Definition: field_component.h:166
rheolef::field_component_const
Definition: field.h:207
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::field_component::proxy_assign
field_component< T, M > & proxy_assign(field_component< T, M > &&uh_comp)
Definition: field_component.h:290
rheolef::field_component::scalar_type
scalar_traits< T >::type scalar_type
Definition: field_component.h:69
rheolef::field_component::_last
iterator _last
Definition: field_component.h:137
rheolef::field_component::dof
T & dof(size_type idof)
Definition: field_component.h:115
rheolef::field_component::size_type
field_basic< T, M >::size_type size_type
Definition: field_component.h:66
rheolef::field_component::dof
const T & dof(size_type idof) const
Definition: field_component.h:116
rheolef::field_component_const::dis_ndof
size_type dis_ndof() const
Definition: field_component.h:168
rheolef::field_component_const::const_iterator
field_basic< T, M >::const_iterator const_iterator
Definition: field_component.h:153
rheolef::field_component_const::_start
const_iterator _start
Definition: field_component.h:179
rheolef::space_constitution::get_basis
const basis_basic< T > & get_basis() const
Definition: space_constitution.h:418
rheolef::field_component::iterator
field_basic< T, M >::iterator iterator
Definition: field_component.h:71
rheolef::field_component_const::float_type
float_traits< T >::type float_type
Definition: field_component.h:152
rheolef::field_indirect::field_indirect
field_indirect(field_basic< T, M > &uh, const geo_basic< T, M > &dom)
Definition: field_indirect.h:53
rheolef::field_component_const::name
std::string name() const
Definition: field_component.h:161
rheolef::field_indirect
Definition: field.h:204
rheolef::field_component::get_geo
geo_basic< T, M > get_geo() const
Definition: field_component.h:108
rheolef::field_component::_start
iterator _start
Definition: field_component.h:136
rheolef::field_component_const::_unset
static const size_type _unset
Definition: field_component.h:176
rheolef::field_component::value_type
T value_type
Definition: field_component.h:67
rheolef::space_constitution::size
size_type size() const
Definition: space_constitution.h:455
rheolef::type
rheolef::std type
rheolef::field_basic
Definition: field_expr_utilities.h:38
rheolef::field_component::memory_type
M memory_type
Definition: field_component.h:68
rheolef::field_component::begin_dof
const_iterator begin_dof() const
Definition: field_component.h:119
rheolef::field_component_const::ndof
size_type ndof() const
Definition: field_component.h:167
rheolef::field_component
Definition: field.h:206
fatal_macro
#define fatal_macro(message)
Definition: dis_macros.h:33
rheolef::details::is_field_expr_v2_constant
Definition: field.h:217
rheolef::field_component_const::scalar_type
scalar_traits< T >::type scalar_type
Definition: field_component.h:151
rheolef::operator>>
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::float_traits::type
T type
Definition: Float.h:94
rheolef::field_component::end_dof
const_iterator end_dof() const
Definition: field_component.h:120
rheolef::distributor::dis_size
size_type dis_size() const
global and local sizes
Definition: distributor.h:207
rheolef::field_component_const::proxy_assign
field_component_const< T, M > & proxy_assign(const field_component_const< T, M > &uh_comp)
Definition: field_component.h:280
rheolef::field_component_const::ownership
const distributor & ownership() const
Definition: field_component.h:162
u
Definition: leveque.h:25
rheolef::space_constitution::get_geo
const geo_basic< T, M > & get_geo() const
Definition: space_constitution.h:416
rheolef::field_component_const::dof
const T & dof(size_type idof) const
Definition: field_component.h:169
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
rheolef::field_component_const::_last
const_iterator _last
Definition: field_component.h:180
rheolef::field_component_const::begin_dof
const_iterator begin_dof() const
Definition: field_component.h:170
rheolef::field_component::get_space
space_basic< T, M > get_space() const
Definition: field_component.h:109
rheolef::field_component::operator=
field_component< T, M > & operator=(const T &alpha)
Definition: field_component.h:322
rheolef::field_component::_unset
static const size_type _unset
Definition: field_component.h:133
rheolef::scalar_traits::type
T type
Definition: point.h:324
rheolef::field_component::operator[]
field_indirect< T, M > operator[](const geo_basic< T, M > &dom)
Definition: field_component.h:362
rheolef::field_component_const::field_component_const
field_component_const()
Definition: field_component.h:197
rheolef::field_component_const::value_type
T value_type
Definition: field_component.h:149
rheolef::field_component::ndof
size_type ndof() const
Definition: field_component.h:113
rheolef::field_basic::operator[]
field_indirect< T, M > operator[](const geo_basic< T, M > &dom)
Definition: field_indirect.h:158
get_geo
void get_geo(istream &in, my_geo &omega)
Definition: field2gmsh_pos.cc:126
rheolef::field_component_const::memory_type
M memory_type
Definition: field_component.h:150
rheolef::field_component::get_constitution
const space_constitution< T, M > & get_constitution() const
Definition: field_component.h:106
rheolef::field_component::name
std::string name() const
Definition: field_component.h:107
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_component::const_iterator
field_basic< T, M >::const_iterator const_iterator
Definition: field_component.h:72
rheolef::field_component_const::get_geo
geo_basic< T, M > get_geo() const
Definition: field_component.h:164
mkgeo_contraction.name
name
Definition: mkgeo_contraction.sh:133
rheolef::field_component::end_dof
iterator end_dof()
Definition: field_component.h:118
M
Expr1::memory_type M
Definition: vec_expr_v2.h:385
rheolef::distributor::size
size_type size(size_type iproc) const
Definition: distributor.h:163
rheolef::space_constitution
Definition: space_constitution.h:32
rheolef::field_basic::size_type
std::size_t size_type
Definition: field.h:239
rheolef::field_component_const::end_dof
const_iterator end_dof() const
Definition: field_component.h:171
rheolef::field_component::field_component
field_component()
Definition: field_component.h:189
T
Expr1::float_type T
Definition: field_expr.h:218
rheolef::field_component_const::_constit
space_constitution< T, M > _constit
Definition: field_component.h:178