Rheolef  7.1
an efficient C++ finite element environment
fem_on_pointset.cc
Go to the documentation of this file.
1 //
21 #include "rheolef/fem_on_pointset.h"
22 #include "rheolef/piola_util.h"
23 
24 namespace rheolef {
25 
26 // ----------------------------------------------------------------------------
27 // initializers
28 // ----------------------------------------------------------------------------
29 template<class T>
30 void
32  const basis_basic<T>& fem_basis,
33  const piola_on_pointset<T>& pops)
34 {
35  _pops = pops;
36  if (pops.has_quadrature()) {
37  _bops.set (pops.get_quadrature(), fem_basis);
38  } else {
39  _bops.set (pops.get_nodal_basis(), fem_basis);
40  }
41 }
42 // ----------------------------------------------------------------------------
43 // internal: general evaluators
44 // ----------------------------------------------------------------------------
45 // partial specialization of member class functions are not allowed,
46 // do, use a class-function with partial specialization:
47 template <class T, class M, class Value, details::differentiate_option::type Diff>
48 struct evaluate_internal {
49  void operator() (
50  const fem_on_pointset_rep<T>& obj,
51  const geo_basic<T,M>& omega_K,
52  const geo_element& K,
54  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value)
55  {
56  fatal_macro("unexpected call");
57  }
58 };
59 template <class T, class M, class Value, details::differentiate_option::type Diff>
60 struct evaluate_on_side_internal {
61  void operator() (
62  const fem_on_pointset_rep<T>& obj,
63  const geo_basic<T,M>& omega_K,
64  const geo_element& K,
65  const side_information_type& sid,
66  const details::differentiate_option& gopt,
67  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value)
68  {
69  fatal_macro("unexpected call");
70  }
71 };
72 // ----------------------------------------------------------------------------
73 // evaluators
74 // ----------------------------------------------------------------------------
75 // post-evaluation: apply a Piola transformation, e.g. for RTk
76 template<class T>
77 template<class M, class Value>
78 void
80  const geo_basic<T,M>& omega_K,
81  const geo_element& K,
82  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& hat_phij_xi,
83  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
84 {
85  const piola_fem<T>& pf = _bops.get_basis().get_piola_fem();
86  if (! pf.transform_need_piola()) {
87  // e.g. Pk element: do not need transformation
88  value = hat_phij_xi;
89  return;
90  }
91  // e.g. RTk element: need a specific Piola transformation
92  const Eigen::Matrix<piola<T>,Eigen::Dynamic,1>& piola = _pops.get_piola (omega_K, K);
93  size_type loc_nnod = hat_phij_xi.rows();
94  size_type loc_ndof = hat_phij_xi.cols();
95  value.resize (loc_nnod, loc_ndof);
96  for (size_type loc_inod = 0; loc_inod < loc_nnod; ++loc_inod) {
97  for (size_type loc_jdof = 0; loc_jdof < loc_ndof; ++loc_jdof) {
98  const Value& hat_u = hat_phij_xi (loc_inod, loc_jdof);
99  Value& u = value (loc_inod, loc_jdof);
100  pf.transform (piola[loc_inod], hat_u, u);
101  }
102  }
103 }
104 template <class T, class M, class Value>
105 struct evaluate_internal<T,M,Value,details::differentiate_option::none> {
106  void operator() (
107  const fem_on_pointset_rep<T>& obj,
108  const geo_basic<T,M>& omega_K,
109  const geo_element& K,
110  const details::differentiate_option& gopt,
111  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
112  {
113  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& hat_phij_xi = obj._bops.template evaluate<Value> (K);
114  obj._evaluate_post_piola (omega_K, K, hat_phij_xi, value);
115  }
116 };
117 template <class T, class M, class Value>
118 struct evaluate_on_side_internal<T,M,Value,details::differentiate_option::none> {
119  void operator() (
120  const fem_on_pointset_rep<T>& obj,
121  const geo_basic<T,M>& omega_K,
122  const geo_element& K,
123  const side_information_type& sid,
124  const details::differentiate_option& gopt,
125  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
126  {
127  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& hat_phij_xi = obj._bops.template evaluate_on_side<Value> (K, sid);
128  obj._evaluate_post_piola (omega_K, K, hat_phij_xi, value);
129  }
130 };
131 // ----------------------------------------------------------------------------
132 // grad-evaluators
133 // ----------------------------------------------------------------------------
134 // partial specialization of member class functions are not allowed,
135 // do, use a full function specialization:
136 template<class T, class M, class Value, class GradValue>
137 static
138 void
139 grad_evaluate_post_piola (
140  const fem_on_pointset_rep<T>& obj,
141  const geo_basic<T,M>& omega_K,
142  const geo_element& K,
143  const details::differentiate_option& gopt,
144  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>&
145  hat_phij_xi,
146  const Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic>&
147  hat_grad_phij_xi,
148  Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic>& value)
149 {
151  reference_element hat_K = K;
152  const Eigen::Matrix<piola<T>,Eigen::Dynamic,1>& piola = obj._pops.get_piola (omega_K, K);
153  const piola_fem<T>& pf = obj._bops.get_basis().get_piola_fem();
154  size_type loc_nnod = hat_grad_phij_xi.rows();
155  size_type loc_ndof = hat_grad_phij_xi.cols();
156  value.resize (loc_nnod,loc_ndof);
157  for (size_type loc_inod = 0; loc_inod < loc_nnod; ++loc_inod) {
158  for (size_type loc_jdof = 0; loc_jdof < loc_ndof; ++loc_jdof) {
159  const Value& hat_u = hat_phij_xi (loc_inod, loc_jdof);
160  const GradValue& hat_grad_u = hat_grad_phij_xi (loc_inod, loc_jdof);
161  GradValue& grad_u = value (loc_inod, loc_jdof);
162  pf.grad_transform (piola[loc_inod], hat_u, hat_grad_u, gopt, grad_u);
163  }
164  }
165 }
166 template<class T, class M>
167 static
168 void
169 grad_evaluate_post_piola (
170  const fem_on_pointset_rep<T>& obj,
171  const geo_basic<T,M>& omega_K,
172  const geo_element& K,
173  const details::differentiate_option& gopt,
174  const Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic>&
175  hat_grad_phij_xi,
176  Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic>& value)
177 {
178  fatal_macro("grad_evaluate: undefined scalar-valued grad");
179 }
180 template <class T, class M, class GradValue>
181 struct evaluate_internal<T,M,GradValue,details::differentiate_option::gradient> {
182  void operator() (
183  const fem_on_pointset_rep<T>& obj,
184  const geo_basic<T,M>& omega_K,
185  const geo_element& K,
186  const details::differentiate_option& gopt,
187  Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic>& value)
188  {
189  reference_element hat_K = K;
190  typedef typename space_constant::rank_down<GradValue>::type Value;
191  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>&
192  hat_phij_xi = obj._bops.template evaluate<Value> (hat_K);
193  const Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic>&
194  hat_grad_phij_xi = obj._bops.template grad_evaluate<GradValue> (hat_K);
195  grad_evaluate_post_piola (obj, omega_K, K, gopt, hat_phij_xi, hat_grad_phij_xi, value);
196  }
197 };
198 template <class T, class M>
199 struct evaluate_internal<T,M,T,details::differentiate_option::gradient> {
200  void operator() (
201  const fem_on_pointset_rep<T>& obj,
202  const geo_basic<T,M>& omega_K,
203  const geo_element& K,
204  const details::differentiate_option& gopt,
205  Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic>& value)
206  {
207  fatal_macro ("undefined scalar-valued grad");
208  }
209 };
210 template <class T, class M, class GradValue>
211 struct evaluate_on_side_internal<T,M,GradValue,details::differentiate_option::gradient> {
212  void operator() (
213  const fem_on_pointset_rep<T>& obj,
214  const geo_basic<T,M>& omega_K,
215  const geo_element& K,
216  const side_information_type& sid,
217  const details::differentiate_option& gopt,
218  Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic>& value)
219  {
220  reference_element hat_K = K;
221  typedef typename space_constant::rank_down<GradValue>::type Value;
222  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>&
223  hat_phij_xi = obj._bops.template evaluate_on_side<Value> (hat_K,sid);
224  const Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic>&
225  hat_grad_phij_xi = obj._bops.template grad_evaluate_on_side<GradValue> (hat_K, sid);
226  grad_evaluate_post_piola (obj, omega_K, K, gopt, hat_phij_xi, hat_grad_phij_xi, value);
227  }
228 };
229 template <class T, class M>
230 struct evaluate_on_side_internal<T,M,T,details::differentiate_option::gradient> {
231  void operator() (
232  const fem_on_pointset_rep<T>& obj,
233  const geo_basic<T,M>& omega_K,
234  const geo_element& K,
235  const side_information_type& sid,
236  const details::differentiate_option& gopt,
237  Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic>& value)
238  {
239  fatal_macro("grad_evaluate_on_side: undefined scalar-valued grad");
240  }
241 };
242 // ----------------------------------------------------------------------------
243 // div evaluator
244 // ----------------------------------------------------------------------------
245 // partial specialization of member class functions are not allowed,
246 // do, use a full function specialization:
247 template<class T, class M, class Value, class GradValue>
248 static
249 void
250 div_evaluate_internal (
251  const fem_on_pointset_rep<T>& obj,
252  const geo_basic<T,M>& omega_K,
253  const geo_element& K,
254  const details::differentiate_option& gopt,
255  const Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic>& grad_value,
256  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value)
257 {
258  // TODO: vector-valued div: from a tensor3 grad of a tensor2: div(sigma) -> vector
260  <<"-valued div operator");
261 }
262 // scalar-valued div:
263 template <class T, class M>
264 void
265 div_evaluate_internal (
266  const fem_on_pointset_rep<T>& obj,
267  const geo_basic<T,M>& omega_K,
268  const geo_element& K,
269  const details::differentiate_option& gopt,
270  const Eigen::Matrix<tensor_basic<T>,Eigen::Dynamic,Eigen::Dynamic>& grad_value,
271  Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic>& value)
272 {
274  value.resize (grad_value.rows(), grad_value.cols());
275  for (size_type loc_inod = 0, loc_nnod = value.rows(); loc_inod < loc_nnod; ++loc_inod) {
276  for (size_type loc_jdof = 0, loc_ndof = value.cols(); loc_jdof < loc_ndof; ++loc_jdof) {
277  value (loc_inod,loc_jdof) = tr (grad_value(loc_inod,loc_jdof));
278  }}
279 }
280 template <class T, class M, class Value>
281 struct evaluate_internal<T,M,Value,details::differentiate_option::divergence> {
282  void operator() (
283  const fem_on_pointset_rep<T>& obj,
284  const geo_basic<T,M>& omega_K,
285  const geo_element& K,
286  const details::differentiate_option& gopt,
287  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
288  {
289  typedef typename space_constant::rank_up<Value>::type UpValue;
290  typedef typename space_constant::rank_up<UpValue>::type GradValue;
291  Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic> grad_value;
292  obj.template evaluate<M,GradValue,details::differentiate_option::gradient> (omega_K, K, gopt, grad_value);
293  div_evaluate_internal (obj, omega_K, K, gopt, grad_value, value);
294  }
295 };
296 template <class T, class M, class Value>
297 struct evaluate_on_side_internal<T,M,Value,details::differentiate_option::divergence> {
298  void operator() (
299  const fem_on_pointset_rep<T>& obj,
300  const geo_basic<T,M>& omega_K,
301  const geo_element& K,
302  const side_information_type& sid,
303  const details::differentiate_option& gopt,
304  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
305  {
306  typedef typename space_constant::rank_up<Value>::type UpValue;
307  typedef typename space_constant::rank_up<UpValue>::type GradValue;
308  Eigen::Matrix<GradValue,Eigen::Dynamic,Eigen::Dynamic> grad_value;
309  obj.template evaluate_on_side<M,GradValue,details::differentiate_option::gradient> (omega_K, K, sid, gopt, grad_value);
310  div_evaluate_internal (obj, omega_K, K, gopt, grad_value, value);
311  }
312 };
313 // ----------------------------------------------------------------------------
314 // curl evaluator
315 // ----------------------------------------------------------------------------
316 // partial specialization of member class functions are not allowed,
317 // do, use a full function specialization:
318 template<class T, class M, class Value>
319 static
320 void
321 curl_evaluate_internal (
322  const fem_on_pointset_rep<T>& obj,
323  const geo_basic<T,M>& omega_K,
324  const geo_element& K,
325  const details::differentiate_option& gopt,
326  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value)
327 {
329  <<"-valued curl operator");
330 }
331 // scalar-valued curl: for 2D geometry
332 template <class T, class M>
333 void
334 curl_evaluate_internal (
335  const fem_on_pointset_rep<T>& obj,
336  const geo_basic<T,M>& omega_K,
337  const geo_element& K,
338  const details::differentiate_option& gopt,
339  Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic>& value)
340 {
342  Eigen::Matrix<tensor_basic<T>,Eigen::Dynamic,Eigen::Dynamic> value_grad;
343  obj.template evaluate<M,tensor_basic<T>,details::differentiate_option::gradient> (omega_K, K, gopt, value_grad);
344  value.resize (value_grad.rows(), value_grad.cols());
345  for (size_type loc_inod = 0, loc_nnod = value.rows(); loc_inod < loc_nnod; ++loc_inod) {
346  for (size_type loc_jdof = 0, loc_ndof = value.cols(); loc_jdof < loc_ndof; ++loc_jdof) {
347  const tensor_basic<T>& g = value_grad (loc_inod,loc_jdof);
348  value (loc_inod,loc_jdof) = g(1,0) - g(0,1);
349  }}
350 }
351 // vector-valued curl:
352 // for 3D geometry and when argument is vector-valued
353 // & for 2D geometry and when argument is scalar-valued
354 template <class T, class M>
355 void
356 curl_evaluate_internal (
357  const fem_on_pointset_rep<T>& obj,
358  const geo_basic<T,M>& omega_K,
359  const geo_element& K,
360  const details::differentiate_option& gopt,
361  Eigen::Matrix<point_basic<T>,Eigen::Dynamic,Eigen::Dynamic>& value)
362 {
364  size_type d = omega_K.dimension();
365  check_macro (d >= 2, "curl: unexpected dimension d="<<d<<" for mesh \""<<omega_K.name()<<"\"");
366  if (d == 2) {
367  // argument is scalar-valued:
368  // curl(w) = [dw/dx1 ; - dw/dx0] = [g1; -g0] when g=grad(v)=dw/dxi is a vector
369  Eigen::Matrix<point_basic<T>,Eigen::Dynamic,Eigen::Dynamic> value_grad;
370  obj.template evaluate<M,point_basic<T>,details::differentiate_option::gradient> (omega_K, K, gopt, value_grad);
371  value.resize (value_grad.rows(), value_grad.cols());
372  for (size_type loc_inod = 0, loc_nnod = value.rows(); loc_inod < loc_nnod; ++loc_inod) {
373  for (size_type loc_jdof = 0, loc_ndof = value.cols(); loc_jdof < loc_ndof; ++loc_jdof) {
374  const point_basic<T>& g = value_grad (loc_inod,loc_jdof);
375  point_basic<T>& c = value (loc_inod,loc_jdof);
376  c[0] = g[1];
377  c[1] = -g[0];
378  }}
379  space_constant::coordinate_type sys_coord = omega_K.coordinate_system();
380  if (! obj._pops.ignore_sys_coord() && sys_coord != space_constant::cartesian && ! gopt.batchelor_curl) {
381  // v = [vz,vr] = curl(w) = [dw/dr + w/r ; - dw/dz] : add w/r to the z-component
382  // => add the specific vz += wr/r term in the axi case
383  // Batchelor curl: do not perform this add
384  size_type i_comp_r = (sys_coord == space_constant::axisymmetric_rz) ? 0 : 1;
385  size_type i_comp_z = (sys_coord == space_constant::axisymmetric_rz) ? 1 : 0;
386  size_type i_comp_theta = 2;
387  reference_element hat_K = K;
388  // TODO: BUG_PIOLA_RT_AXI for non-Pk basis that requires Piola : use obj.evaluate (omega_K, K, value_w); instead
389  const Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic>&
390  hat_phij_xi = obj._bops.template evaluate<T> (hat_K);
391  const Eigen::Matrix<piola<T>,Eigen::Dynamic,1>& piola = obj._pops.get_piola (omega_K, K);
392  size_type loc_nnod = value.rows();
393  size_type loc_ndof = value.cols();
394  for (size_type loc_inod = 0; loc_inod < loc_nnod; ++loc_inod) {
395  T r = piola[loc_inod].F[i_comp_r];
396  check_macro (1+abs(r) != 1, "curl(): singular axisymmetric (1/r) weight (HINT: avoid interpolate() or change quadrature formulae)");
397  // pb: r==0 when using gauss_lobatto, e.g. for the characteristic method
398  for (size_type loc_jdof = 0; loc_jdof < loc_ndof; ++loc_jdof) {
399  const T& w = hat_phij_xi (loc_inod,loc_jdof);
400  point_basic<T>& v = value(loc_inod,loc_jdof);
401  v [i_comp_z] += w/r;
402  }
403  }
404  }
405  } else { // d == 3
406  // d=3: arg is vector:
407  // [dw2/dx1 -dw1/dx2] [ g21 - g12 ]
408  // curl(w) = [dw0/dx2 -dw2/dx0] = [ g02 - g20 ] when g=grad(w)=dwi/dxj is a tensor
409  // [dw1/dx0 -dw0/dx1] [ g10 - g01 ]
410  Eigen::Matrix<tensor_basic<T>,Eigen::Dynamic,Eigen::Dynamic> value_grad;
411  obj.template evaluate<M,tensor_basic<T>,details::differentiate_option::gradient> (omega_K, K, gopt, value_grad);
412  value.resize (value_grad.rows(), value_grad.cols());
413  for (size_type loc_inod = 0, loc_nnod = value.rows(); loc_inod < loc_nnod; ++loc_inod) {
414  for (size_type loc_jdof = 0, loc_ndof = value.cols(); loc_jdof < loc_ndof; ++loc_jdof) {
415  const tensor_basic<T>& g = value_grad (loc_inod,loc_jdof);
416  point_basic<T>& c = value (loc_inod,loc_jdof);
417  c[0] = g(2,1) - g(1,2);
418  c[1] = g(0,2) - g(2,0);
419  c[2] = g(1,0) - g(0,1);
420  }}
421  }
422 }
423 template <class T, class M, class Value>
424 struct evaluate_internal<T,M,Value,details::differentiate_option::curl> {
425  void operator() (
426  const fem_on_pointset_rep<T>& obj,
427  const geo_basic<T,M>& omega_K,
428  const geo_element& K,
429  const details::differentiate_option& gopt,
430  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
431  {
432  curl_evaluate_internal (obj, omega_K, K, gopt, value);
433  }
434 };
435 template <class T, class M, class Value>
436 struct evaluate_on_side_internal<T,M,Value,details::differentiate_option::curl> {
437  void operator() (
438  const fem_on_pointset_rep<T>& obj,
439  const geo_basic<T,M>& omega_K,
440  const geo_element& K,
441  const side_information_type& sid,
442  const details::differentiate_option& gopt,
443  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
444  {
445  fatal_macro("evaluate curl on side: not yet");
446  }
447 };
448 // ----------------------------------------------------------------------------
449 // main call to evaluators
450 // ----------------------------------------------------------------------------
451 template <class T>
452 template <class M, class Value, details::differentiate_option::type Diff>
453 void
455  const geo_basic<T,M>& omega_K,
456  const geo_element& K,
457  const details::differentiate_option& gopt,
458  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
459 {
460  evaluate_internal<T,M,Value,Diff> eval;
461  eval (*this, omega_K, K, gopt, value);
462 }
463 template <class T>
464 template <class M, class Value, details::differentiate_option::type Diff>
465 void
467  const geo_basic<T,M>& omega_K,
468  const geo_element& K,
469  const side_information_type& sid,
470  const details::differentiate_option& gopt,
471  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
472 {
473  evaluate_on_side_internal<T,M,Value,Diff> eval;
474  eval (*this, omega_K, K, sid, gopt, value);
475 }
476 // ----------------------------------------------------------------------------
477 // instanciation in library
478 // ----------------------------------------------------------------------------
479 #define _RHEOLEF_instanciation(T) \
480 template class fem_on_pointset_rep<T>; \
481 
482 #define _RHEOLEF_instanciation_value(T,M,Value,Diff) \
483 template void fem_on_pointset_rep<T>::evaluate<M,Value,Diff> ( \
484  const geo_basic<T,M>& omega_K, \
485  const geo_element& K, \
486  const details::differentiate_option& gopt, \
487  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const; \
488 template void fem_on_pointset_rep<T>::evaluate_on_side<M,Value,Diff> ( \
489  const geo_basic<T,M>& omega_K, \
490  const geo_element& K, \
491  const side_information_type& sid, \
492  const details::differentiate_option& gopt, \
493  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const; \
494 
495 #define _RHEOLEF_instanciation_values(T,M,Diff) \
496 _RHEOLEF_instanciation_value(T,M,T,Diff) \
497 _RHEOLEF_instanciation_value(T,M,point_basic<T>,Diff) \
498 _RHEOLEF_instanciation_value(T,M,tensor_basic<T>,Diff) \
499 _RHEOLEF_instanciation_value(T,M,tensor3_basic<T>,Diff) \
500 _RHEOLEF_instanciation_value(T,M,tensor4_basic<T>,Diff) \
501 
502 #define _RHEOLEF_instanciation_evaluate(T,M) \
503 _RHEOLEF_instanciation_values(T,M,details::differentiate_option::none) \
504 _RHEOLEF_instanciation_values(T,M,details::differentiate_option::gradient) \
505 _RHEOLEF_instanciation_values(T,M,details::differentiate_option::divergence) \
506 _RHEOLEF_instanciation_values(T,M,details::differentiate_option::curl) \
507 
510 #ifdef _RHEOLEF_HAVE_MPI
512 #endif // _RHEOLEF_HAVE_MPI
513 
514 } // namespace rheolef
g
u_exact g
Definition: burgers_diffusion_exact.h:33
rheolef::geo_basic
generic mesh with rerefence counting
Definition: geo.h:1089
rheolef::point_basic
Definition: point.h:87
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_constant::valued_tag_traits::value
static const valued_type value
Definition: space_constant.h:161
rheolef::piola::F
point_basic< T > F
Definition: piola.h:79
rheolef::piola_on_pointset::get_nodal_basis
const basis_basic< T > & get_nodal_basis() const
Definition: piola_on_pointset.h:231
rheolef::_RHEOLEF_instanciation
_RHEOLEF_instanciation(Float, sequential, std::allocator< Float >) _RHEOLEF_instanciation(Float
rheolef::sequential
Definition: distributed.h:28
rheolef::space_constant::cartesian
@ cartesian
Definition: space_constant.h:122
rheolef::value
rheolef::std value
rheolef::tensor_basic
Definition: tensor.h:90
mkgeo_ball.d
int d
Definition: mkgeo_ball.sh:154
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::piola_on_pointset::get_quadrature
const quadrature< T > & get_quadrature() const
Definition: piola_on_pointset.h:224
rheolef::space_constant::axisymmetric_rz
@ axisymmetric_rz
Definition: space_constant.h:123
rheolef::space_constant::rank_down::type
undeterminated_basic< typename scalar_traits< T >::type > type
Definition: space_constant.h:180
rheolef::fem_on_pointset_rep::_evaluate_post_piola
void _evaluate_post_piola(const geo_basic< T, M > &omega_K, const geo_element &K, const Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &hat_phij_xi, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: fem_on_pointset.cc:79
rheolef::side_information_type
Definition: reference_element_face_transformation.h:37
rheolef::basis_basic
Definition: basis.h:532
rheolef::reference_element
see the reference_element page for the full documentation
Definition: reference_element.h:66
rheolef::distributed
Definition: distributed.h:88
rheolef::details::differentiate_option
Definition: piola.h:41
fatal_macro
#define fatal_macro(message)
Definition: dis_macros.h:33
rheolef::space_constant::rank_up::type
point_basic< typename scalar_traits< T >::type > type
Definition: space_constant.h:186
rheolef::piola_on_pointset
Definition: piola_on_pointset.h:142
rheolef::space_constant::valued_name
const std::string & valued_name(valued_type valued_tag)
Definition: space_constant.cc:43
rheolef::details::differentiate_option::gradient
@ gradient
Definition: piola.h:44
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
u
Definition: leveque.h:25
rheolef::curl
std::enable_if< details::is_field_convertible< Expr >::value,details::field_expr_v2_nonlinear_terminal_field< typename Expr::scalar_type,typename Expr::memory_type,details::differentiate_option::curl >>::type curl(const Expr &expr)
curl(uh): see the expression page for the full documentation
Definition: field_expr_terminal.h:1089
Float
see the Float page for the full documentation
rheolef::fem_on_pointset_rep
Definition: fem_on_pointset.h:43
mkgeo_grid.sys_coord
string sys_coord
Definition: mkgeo_grid.sh:171
rheolef::fem_on_pointset_rep::evaluate_on_side
void evaluate_on_side(const geo_basic< T, M > &omega_K, const geo_element &K, const side_information_type &sid, const details::differentiate_option &gopt, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: fem_on_pointset.cc:466
rheolef::fem_on_pointset_rep::size_type
reference_element::size_type size_type
Definition: fem_on_pointset.h:45
g
Definition: cavity_dg.h:25
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::fem_on_pointset_rep::evaluate
void evaluate(const geo_basic< T, M > &omega_K, const geo_element &K, const details::differentiate_option &gopt, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: fem_on_pointset.cc:454
rheolef::fem_on_pointset_rep::_pops
piola_on_pointset< T > _pops
Definition: fem_on_pointset.h:90
rheolef::piola_on_pointset::has_quadrature
bool has_quadrature() const
Definition: piola_on_pointset.h:217
rheolef::space_constant::coordinate_type
coordinate_type
Definition: space_constant.h:121
rheolef::fem_on_pointset_rep::initialize
void initialize(const basis_basic< T > &fem_basis, const piola_on_pointset< T > &pops)
Definition: fem_on_pointset.cc:31
grad_u
Definition: combustion_exact.icc:34
M
Expr1::memory_type M
Definition: vec_expr_v2.h:416
mkgeo_ball.c
int c
Definition: mkgeo_ball.sh:153
rheolef::fem_on_pointset_rep::_bops
basis_on_pointset< T > _bops
Definition: fem_on_pointset.h:89
_RHEOLEF_instanciation_evaluate
#define _RHEOLEF_instanciation_evaluate(T, M)
Definition: fem_on_pointset.cc:502
T
Expr1::float_type T
Definition: field_expr.h:261
rheolef::tr
U tr(const tensor_basic< U > &a, size_t d=3)
rheolef::piola
Definition: piola.h:67