Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
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
24namespace rheolef {
25
26// ----------------------------------------------------------------------------
27// initializers
28// ----------------------------------------------------------------------------
29template<class T>
30void
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:
47template <class T, class M, class Value, details::differentiate_option::type Diff>
48struct 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,
53 const details::differentiate_option& gopt,
54 Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value)
55 {
56 fatal_macro("unexpected call");
57 }
58};
59template <class T, class M, class Value, details::differentiate_option::type Diff>
60struct 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
76template<class T>
77template<class M, class Value>
78void
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}
104template <class T, class M, class Value>
105struct 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};
117template <class T, class M, class Value>
118struct 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:
136template<class T, class M, class Value, class GradValue>
137static
138void
139grad_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}
166template<class T, class M>
167static
168void
169grad_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}
180template <class T, class M, class GradValue>
181struct 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};
198template <class T, class M>
199struct 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};
210template <class T, class M, class GradValue>
211struct 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};
229template <class T, class M>
230struct 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:
247template<class T, class M, class Value, class GradValue>
248static
249void
250div_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:
263template <class T, class M>
264void
265div_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}
280template <class T, class M, class Value>
281struct 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};
296template <class T, class M, class Value>
297struct 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:
318template<class T, class M, class Value>
319static
320void
321curl_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
332template <class T, class M>
333void
334curl_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
354template <class T, class M>
355void
356curl_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}
423template <class T, class M, class Value>
424struct 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};
435template <class T, class M, class Value>
436struct 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// ----------------------------------------------------------------------------
451template <class T>
452template <class M, class Value, details::differentiate_option::type Diff>
453void
455 const geo_basic<T,M>& omega_K,
456 const geo_element& K,
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}
463template <class T>
464template <class M, class Value, details::differentiate_option::type Diff>
465void
467 const geo_basic<T,M>& omega_K,
468 const geo_element& K,
469 const side_information_type& sid,
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) \
480template class fem_on_pointset_rep<T>; \
481
482#define _RHEOLEF_instanciation_value(T,M,Value,Diff) \
483template 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; \
488template 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
#define _RHEOLEF_instanciation(T, M, A)
Definition asr.cc:223
field::size_type size_type
Definition branch.cc:430
see the Float page for the full documentation
basis_on_pointset< T > _bops
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
reference_element::size_type size_type
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
void initialize(const basis_basic< T > &fem_basis, const piola_on_pointset< T > &pops)
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
piola_on_pointset< T > _pops
generic mesh with rerefence counting
Definition geo.h:1089
see the geo_element page for the full documentation
const quadrature< T > & get_quadrature() const
const basis_basic< T > & get_nodal_basis() const
see the reference_element page for the full documentation
#define fatal_macro(message)
Definition dis_macros.h:33
#define _RHEOLEF_instanciation_evaluate(T, M)
Expr1::float_type T
Definition field_expr.h:230
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
const std::string & valued_name(valued_type valued_tag)
This file is part of Rheolef.
U tr(const tensor_basic< U > &a, size_t d=3)
Definition cavity_dg.h:25
undeterminated_basic< typename scalar_traits< T >::type > type
point_basic< typename scalar_traits< T >::type > type
Definition leveque.h:25
Expr1::memory_type M