MAST3
Multidisciplinary-design Adaptation and Sensitivity Toolkit (MAST)
fe_derivative_evaluation.hpp
Go to the documentation of this file.
1 /*
2 * MAST: Multidisciplinary-design Adaptation and Sensitivity Toolkit
3 * Copyright (C) 2013-2020 Manav Bhatia and MAST authors
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19 
20 #ifndef __mast_fe_derivative_evaluation_h__
21 #define __mast_fe_derivative_evaluation_h__
22 
23 // MAST includes
24 #include <mast/base/mast_data_types.h>
25 #include <mast/base/exceptions.hpp>
26 
27 
28 namespace MAST {
29 namespace FEBasis {
30 namespace Evaluation {
31 
32 template <typename NodalScalarType,
33  uint_t ElemDim,
34  uint_t SpatialDim,
35  typename FEBasisType,
36  typename ContextType>
37 inline void
38 compute_xyz(const ContextType& c,
39  const FEBasisType& fe_basis,
40  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& node_coord,
41  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& xyz) {
42 
43  uint_t
44  nq = fe_basis.n_q_points(),
45  n_nodes = c.n_nodes();
46 
47  node_coord = Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>::Zero(SpatialDim, n_nodes);
48  xyz = Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>::Zero(SpatialDim, nq);
49 
50  // get the nodal locations
51  for (uint_t i=0; i<n_nodes; i++)
52  for (uint_t j=0; j<SpatialDim; j++)
53  node_coord(j, i) = c.nodal_coord(i, j);
54 
55  // quadrature point coordinates
56  for (uint_t i=0; i<nq; i++)
57  for (uint_t k=0; k<n_nodes; k++)
58  for (uint_t j=0; j<SpatialDim; j++)
59  xyz(j, i) += fe_basis.phi(i, k) * node_coord(j, k);
60 }
61 
62 
63 
64 template <typename NodalScalarType,
65  uint_t ElemDim,
66  uint_t SpatialDim,
67  typename FEBasisType,
68  typename ContextType>
69 inline void
70 compute_Jac(const ContextType& c,
71  const FEBasisType& fe_basis,
72  const Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& node_coord,
73  Eigen::Matrix<NodalScalarType, SpatialDim*ElemDim, Eigen::Dynamic>& dx_dxi) {
74 
75  uint_t
76  nq = fe_basis.n_q_points(),
77  n_nodes = c.n_nodes();
78 
79  dx_dxi = Eigen::Matrix<NodalScalarType, SpatialDim*ElemDim, Eigen::Dynamic>::Zero(SpatialDim*ElemDim, nq);
80 
81  // quadrature point spatial coordinate derivatives dx/dxi
82  for (uint_t i=0; i<nq; i++) {
83 
84  Eigen::Map<typename Eigen::Matrix<NodalScalarType, SpatialDim, ElemDim>>
85  dxdxi(dx_dxi.col(i).data(), SpatialDim, ElemDim);
86 
87  for (uint_t l=0; l<n_nodes; l++)
88  for (uint_t j=0; j<SpatialDim; j++)
89  for (uint_t k=0; k<ElemDim; k++)
90  dxdxi(j, k) += fe_basis.dphi_dxi(i, l, k) * node_coord(j, l);
91  }
92 
93 }
94 
95 
96 template <typename NodalScalarType,
97  uint_t ElemDim,
98  uint_t SpatialDim>
99 inline void
100 compute_detJ(const Eigen::Matrix<NodalScalarType, SpatialDim*ElemDim, Eigen::Dynamic>& dx_dxi,
101  Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>& detJ) {
102 
103  uint_t
104  nq = dx_dxi.cols();
105 
106  detJ = Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>::Zero(nq);
107 
108  for (uint_t i=0; i<nq; i++) {
109 
110  Eigen::Map<const typename Eigen::Matrix<NodalScalarType, SpatialDim, ElemDim>>
111  dxdxi(dx_dxi.col(i).data(), SpatialDim, ElemDim);
112 
113  // determinant of dx_dxi
114  detJ(i) = dxdxi.determinant();
115  }
116 }
117 
118 
119 
120 template <typename NodalScalarType,
121  uint_t ElemDim,
122  uint_t SpatialDim,
123  typename ContextType>
124 inline
125 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 1, void>::type
126 compute_detJ_side
127 (const ContextType& c,
128  const uint_t s,
129  const Eigen::Matrix<NodalScalarType, ElemDim*SpatialDim, Eigen::Dynamic>& dx_dxi,
130  Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>& detJ) {
131 
132  Assert1(dx_dxi.cols() == 1, dx_dxi.cols(), "Only one quadrature point on side of 1D element");
133  detJ = Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>::Ones(1);
134 }
135 
136 
137 
138 inline uint_t quad_side_Jac_col(uint_t s) {
139 
140  // identify row of the Jacobian matrix that will be used to compute
141  // the size
142  switch (s) {
143  case 0:
144  case 2:
145  return 0; // (dx/dxi, dy/dxi)
146  break;
147 
148  case 1:
149  case 3:
150  return 1; // (dx/deta, dy/deta)
151  break;
152 
153  default:
154  Error(false, "Invalid side number for quad");
155  }
156 
157  // should not get here
158  return -1;
159 }
160 
161 
162 
163 inline void hex_side_Jac_cols(const uint_t s,
164  uint_t &c1,
165  uint_t &c2) {
166 
167  /*
168  * HEX8: 7 6
169  * o--------z
170  * /: /| zeta
171  * / : / | ^ eta (into page)
172  * 4 / : 5 / | | /
173  * o--------o | |/
174  * | o....|...o 2 o---> xi
175  * | .3 | /
176  * | . | /
177  * |. |/
178  * o--------o
179  * 0 1
180  *
181  * libMesh side numbering:
182  * {0, 3, 2, 1}, // Side 0
183  * {0, 1, 5, 4}, // Side 1
184  * {1, 2, 6, 5}, // Side 2
185  * {2, 3, 7, 6}, // Side 3
186  * {3, 0, 4, 7}, // Side 4
187  * {4, 5, 6, 7} // Side 5
188  */
189 
190  // identify row of the Jacobian matrix that will be used to compute
191  // the size
192  switch (s) {
193 
194  case 0: {
195  c1 = 1; // { dx/deta, dy/deta, dz/deta}
196  c2 = 0; // { dx/xi, dy/xi, dz/xi}
197  }
198  break;
199 
200  case 1: {
201  c1 = 0; // { dx/xi, dy/xi, dz/xi}
202  c2 = 2; // {dx/dzeta, dy/dzeta, dz/dzeta}
203  }
204  break;
205 
206  case 2: {
207  c1 = 1; // { dx/deta, dy/deta, dz/deta}
208  c2 = 2; // {dx/dzeta, dy/dzeta, dz/dzeta}
209  }
210  break;
211 
212  case 3: {
213  c1 = 2; // {dx/dzeta, dy/dzeta, dz/dzeta}
214  c2 = 0; // { dx/xi, dy/xi, dz/xi}
215  }
216  break;
217 
218  case 4: {
219  c1 = 2; // {dx/dzeta, dy/dzeta, dz/dzeta}
220  c2 = 1; // { dx/deta, dy/deta, dz/deta}
221  }
222  break;
223 
224  case 5: {
225  c1 = 0; // { dx/deta, dy/deta, dz/deta}
226  c2 = 1; // { dx/xi, dy/xi, dz/xi}
227  }
228  break;
229 
230  default:
231  Error(false, "Invalid side number for hex");
232  }
233 }
234 
235 
236 
237 template <typename NodalScalarType,
238  uint_t ElemDim,
239  uint_t SpatialDim,
240  typename ContextType>
241 inline
242 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 2, void>::type
243 compute_detJ_side_quad
244 (const ContextType& c,
245  const uint_t s,
246  const Eigen::Matrix<NodalScalarType, ElemDim*SpatialDim, Eigen::Dynamic>& dx_dxi,
247  Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>& detJ) {
248 
249  Assert0(c.elem_is_quad(), "Element must be a quadrilateral");
250 
251  uint_t
252  nq = dx_dxi.cols(),
253  col = MAST::FEBasis::Evaluation::quad_side_Jac_col(s);
254 
255  detJ = Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>::Zero(nq);
256 
257  for (uint_t i=0; i<nq; i++) {
258 
259  Eigen::Map<const typename Eigen::Matrix<NodalScalarType, 2, 2>>
260  dxdxi(dx_dxi.col(i).data(), SpatialDim, ElemDim);
261 
262  // determinant of dx_dxi
263  detJ(i) = dxdxi.col(col).norm();
264  }
265 }
266 
267 
268 
269 template <typename NodalScalarType,
270  uint_t ElemDim,
271  uint_t SpatialDim,
272  typename ContextType>
273 inline
274 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 3, void>::type
275 compute_detJ_side_hex
276 (const ContextType& c,
277  const uint_t s,
278  const Eigen::Matrix<NodalScalarType, ElemDim*SpatialDim, Eigen::Dynamic>& dx_dxi,
279  Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>& detJ) {
280 
281  Assert0(c.elem_is_hex(), "Element must be a hex");
282 
283  uint_t
284  nq = dx_dxi.cols(),
285  c1 = -1,
286  c2 = -1;
287 
288  MAST::FEBasis::Evaluation::hex_side_Jac_cols(s, c1, c2);
289 
290  detJ = Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>::Zero(nq);
291 
292  for (uint_t i=0; i<nq; i++) {
293 
294  Eigen::Map<const typename Eigen::Matrix<NodalScalarType, 3, 3>>
295  dxdxi(dx_dxi.col(i).data(), SpatialDim, ElemDim);
296 
297  // determinant of dx_dxi
298  detJ(i) = dxdxi.col(c1).cross(dxdxi.col(c2)).norm();
299  }
300 }
301 
302 
303 
304 template <typename NodalScalarType,
305  uint_t ElemDim,
306  uint_t SpatialDim,
307  typename ContextType>
308 inline
309 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 2, void>::type
310 compute_detJ_side
311  (const ContextType& c,
312  const uint_t s,
313  const Eigen::Matrix<NodalScalarType, ElemDim*SpatialDim, Eigen::Dynamic>& dx_dxi,
314  Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>& detJ) {
315 
316  if (c.elem_is_quad())
317  compute_detJ_side_quad<NodalScalarType, ElemDim, SpatialDim, ContextType>(c, s, dx_dxi, detJ);
318  else
319  Error(false, "Not implemented for element type.");
320  }
321 
322 
323 
324 template <typename NodalScalarType,
325  uint_t ElemDim,
326  uint_t SpatialDim,
327  typename ContextType>
328 inline
329 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 3, void>::type
330 compute_detJ_side
331  (const ContextType& c,
332  const uint_t s,
333  const Eigen::Matrix<NodalScalarType, ElemDim*SpatialDim, Eigen::Dynamic>& dx_dxi,
334  Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>& detJ) {
335 
336  if (c.elem_is_hex())
337  compute_detJ_side_hex<NodalScalarType, ElemDim, SpatialDim, ContextType>(c, s, dx_dxi, detJ);
338  else
339  Error(false, "Not implemented for element type.");
340  }
341 
342 
343 
344 
345 template <typename NodalScalarType,
346  uint_t ElemDim,
347  uint_t SpatialDim,
348  typename ContextType>
349 inline
350 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 1, void>::type
351 compute_side_tangent_and_normal
352  (const ContextType& c,
353  const uint_t s,
354  const Eigen::Matrix<NodalScalarType, SpatialDim*ElemDim, Eigen::Dynamic>& dx_dxi,
355  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& tangent,
356  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& normal) {
357 
358  // side of 1D is a 0-d element, so shoudl have a single point
359  Assert1(dx_dxi.cols() == 1, dx_dxi.cols(), "Only one quadrature point on side of 1D element");
360 
361  normal = Eigen::Matrix<NodalScalarType, 1, Eigen::Dynamic>::Zero(1, 1);
362  tangent = Eigen::Matrix<NodalScalarType, 1, Eigen::Dynamic>::Zero(1, 1);
363 
364  // left side normal is -1 and right side normal is +1
365  normal(0, 0) = s==0?-1.:1.;
366 }
367 
368 
369 
370 template <typename NodalScalarType,
371  uint_t ElemDim,
372  uint_t SpatialDim,
373  typename ContextType>
374 inline
375 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 2, void>::type
376 compute_quad_side_tangent_and_normal
377 (const ContextType& c,
378  const uint_t s,
379  const Eigen::Matrix<NodalScalarType, ElemDim*SpatialDim, Eigen::Dynamic>& dx_dxi,
380  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& tangent,
381  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& normal) {
382 
383  Assert0(c.elem_is_quad(), "Element must be a quadrilateral");
384 
385  uint_t
386  nq = dx_dxi.cols(),
387  col = MAST::FEBasis::Evaluation::quad_side_Jac_col(s);
388 
389  tangent = Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>::Zero(SpatialDim, nq);
390  normal = Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>::Zero(SpatialDim, nq);
391 
392  // for bottom and right edges, the tangent is d{x, y}/dxi and d{x, y}/deta.
393  // for top and left edges, the tangent is -d{x, y}/dxi and -d{x, y}/deta.
394  real_t
395  v = s>1?-1.:1;
396 
397  Eigen::Matrix<NodalScalarType, 2, 1>
398  dx = Eigen::Matrix<NodalScalarType, 2, 1>::Zero(2);
399 
400  for (uint_t i=0; i<nq; i++) {
401 
402  Eigen::Map<const typename Eigen::Matrix<NodalScalarType, 2, 2>>
403  dxdxi(dx_dxi.col(i).data(), 2, 2);
404 
405  // tangent
406  dx = v * dxdxi.col(col);
407  dx /= dx.norm();
408  tangent.col(i) = dx;
409 
410  // normal is tangent cross k_hat
411  // dn = | i j k | = i ty - j tx
412  // | tx ty 0 |
413  // | 0 0 1 |
414  normal(0, i) = dx(1);
415  normal(1, i) = -dx(0);
416  }
417 }
418 
419 
420 
421 
422 template <typename NodalScalarType,
423  uint_t ElemDim,
424  uint_t SpatialDim,
425  typename ContextType>
426 inline
427 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 3, void>::type
428 compute_hex_side_tangent_and_normal
429 (const ContextType& c,
430  const uint_t s,
431  const Eigen::Matrix<NodalScalarType, ElemDim*SpatialDim, Eigen::Dynamic>& dx_dxi,
432  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& tangent,
433  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& normal) {
434 
435  Assert0(c.elem_is_hex(), "Element must be a hexagon");
436 
437  uint_t
438  nq = dx_dxi.cols(),
439  c1 = -1,
440  c2 = -1;
441 
442  MAST::FEBasis::Evaluation::hex_side_Jac_cols(s, c1, c2);
443 
444  tangent = Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>::Zero(SpatialDim, nq);
445  normal = Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>::Zero(SpatialDim, nq);
446 
447  Eigen::Matrix<NodalScalarType, 3, 1>
448  dx = Eigen::Matrix<NodalScalarType, 3, 1>::Zero(3);
449 
450  for (uint_t i=0; i<nq; i++) {
451 
452  Eigen::Map<const typename Eigen::Matrix<NodalScalarType, 3, 3>>
453  dxdxi(dx_dxi.col(i).data(), 3, 3);
454 
455  // normal is dx1 x dx2
456  // dn = | i j k |
457  // | dx1 dy1 dz1 |
458  // | dx2 dy2 dz2 |
459  normal.col(i) = dxdxi.col(c1).cross(dxdxi.col(c2));
460  normal.col(i) /= normal.col(i).norm();
461  }
462 }
463 
464 
465 
466 template <typename NodalScalarType,
467  uint_t ElemDim,
468  uint_t SpatialDim,
469  typename ContextType>
470 inline
471 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 2, void>::type
472 compute_side_tangent_and_normal
473  (const ContextType& c,
474  const uint_t s,
475  const Eigen::Matrix<NodalScalarType, SpatialDim*ElemDim, Eigen::Dynamic>& dx_dxi,
476  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& tangent,
477  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& normal) {
478 
479  if (c.elem_is_quad())
480  MAST::FEBasis::Evaluation::compute_quad_side_tangent_and_normal
481  <NodalScalarType, ElemDim, SpatialDim, ContextType>
482  (c, s, dx_dxi, tangent, normal);
483  else
484  Error(false, "Not implemented for element type.");
485 }
486 
487 
488 
489 
490 template <typename NodalScalarType,
491  uint_t ElemDim,
492  uint_t SpatialDim,
493  typename ContextType>
494 inline
495 typename std::enable_if<ElemDim == SpatialDim && ElemDim == 3, void>::type
496 compute_side_tangent_and_normal
497  (const ContextType& c,
498  const uint_t s,
499  const Eigen::Matrix<NodalScalarType, SpatialDim*ElemDim, Eigen::Dynamic>& dx_dxi,
500  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& tangent,
501  Eigen::Matrix<NodalScalarType, SpatialDim, Eigen::Dynamic>& normal) {
502 
503  if (c.elem_is_hex())
504  MAST::FEBasis::Evaluation::compute_hex_side_tangent_and_normal
505  <NodalScalarType, ElemDim, SpatialDim, ContextType>
506  (c, s, dx_dxi, tangent, normal);
507  else
508  Error(false, "Not implemented for element type.");
509 }
510 
511 
512 
513 template <typename NodalScalarType,
514  uint_t ElemDim,
515  uint_t SpatialDim,
516  typename FEBasisType,
517  typename ContextType>
518 inline void
519 compute_detJxW(const FEBasisType& fe_basis,
520  const Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>& detJ,
521  Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>& detJxW) {
522 
523  Assert2(fe_basis.n_q_points() == detJ.rows(),
524  fe_basis.n_q_points(), detJ.rows(),
525  "Incompatible number of quadrature points of detJ and FEBasis.");
526 
527  uint_t
528  nq = detJ.rows();
529 
530  detJxW = Eigen::Matrix<NodalScalarType, Eigen::Dynamic, 1>::Zero(nq);
531 
532  for (uint_t i=0; i<nq; i++) {
533 
534  // determinant times weight
535  detJxW(i) = detJ(i) * fe_basis.qp_weight(i);
536  }
537 }
538 
539 
540 
541 
542 template <typename NodalScalarType,
543  uint_t ElemDim,
544  uint_t SpatialDim>
545 inline
546 typename std::enable_if<ElemDim == SpatialDim, void>::type
547 compute_Jac_inv
548  (const Eigen::Matrix<NodalScalarType, ElemDim*ElemDim, Eigen::Dynamic>& dx_dxi,
549  Eigen::Matrix<NodalScalarType, ElemDim*ElemDim, Eigen::Dynamic>& dxi_dx) {
550 
551  uint_t
552  nq = dx_dxi.cols();
553 
554  dxi_dx = Eigen::Matrix<NodalScalarType, ElemDim*ElemDim, Eigen::Dynamic>::Zero(ElemDim*ElemDim, nq);
555 
556  for (uint_t i=0; i<nq; i++) {
557 
558  // quadrature point spatial coordinate derivatives dx/dxi
559  Eigen::Map<const typename Eigen::Matrix<NodalScalarType, ElemDim, ElemDim>>
560  dxdxi(dx_dxi.col(i).data(), ElemDim, ElemDim);
561  Eigen::Map<typename Eigen::Matrix<NodalScalarType, ElemDim, ElemDim>>
562  dxidx(dxi_dx.col(i).data(), ElemDim, ElemDim);
563 
564  // compute dx/dxi
565  dxidx = dxdxi.inverse();
566  }
567 }
568 
569 
570 
571 
572 template <typename NodalScalarType,
573  uint_t ElemDim,
574  uint_t SpatialDim,
575  typename FEBasisType>
576 inline void
577 compute_dphi_dx
578 (const FEBasisType& fe_basis,
579  const Eigen::Matrix<NodalScalarType, ElemDim*SpatialDim, Eigen::Dynamic>& dxi_dx,
580  Eigen::Matrix<NodalScalarType, Eigen::Dynamic, Eigen::Dynamic>& dphi_dx) {
581 
582  uint_t
583  nq = fe_basis.n_q_points(),
584  n_basis = fe_basis.n_basis();
585 
586  Assert2(dxi_dx.cols() == nq,
587  dxi_dx.cols(), nq,
588  "Incompatible quadrature points in FEBasis and dxi_dx.");
589  Assert2(dxi_dx.rows() == ElemDim*SpatialDim,
590  dxi_dx.rows(), ElemDim*SpatialDim,
591  "Incompatible rows in dxi_dx.");
592 
593  dphi_dx = Eigen::Matrix<NodalScalarType, Eigen::Dynamic, Eigen::Dynamic>::Zero(SpatialDim*n_basis, nq);
594 
595  for (uint_t i=0; i<nq; i++) {
596 
597  // quadrature point spatial coordinate derivatives dx/dxi
598  Eigen::Map<const typename Eigen::Matrix<NodalScalarType, ElemDim, SpatialDim>>
599  dxidx (dxi_dx.col(i).data(), ElemDim, SpatialDim);
600  Eigen::Map<typename Eigen::Matrix<NodalScalarType, Eigen::Dynamic, SpatialDim>>
601  dphidx(dphi_dx.col(i).data(), n_basis, SpatialDim);
602 
603  for (uint_t l=0; l<n_basis; l++)
604  for (uint_t j=0; j<SpatialDim; j++)
605  for (uint_t k=0; k<ElemDim; k++)
606  dphidx(l, j) += fe_basis.dphi_dxi(i, l, k) * dxidx(k, j);
607  }
608 }
609 
610 
611 } // Evaluation
612 } // FEBasis
613 } // MAST
614 
615 #endif // __mast_fe_derivative_evaluation_h__
Error
#define Error(cond, msg)
Definition: exceptions.hpp:166
MAST::FEBasis::Evaluation::compute_Jac
void compute_Jac(const ContextType &c, const FEBasisType &fe_basis, const Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &node_coord, Eigen::Matrix< NodalScalarType, SpatialDim *ElemDim, Eigen::Dynamic > &dx_dxi)
Definition: fe_derivative_evaluation.hpp:70
MAST::FEBasis::Evaluation::hex_side_Jac_cols
void hex_side_Jac_cols(const uint_t s, uint_t &c1, uint_t &c2)
Definition: fe_derivative_evaluation.hpp:163
Assert1
#define Assert1(cond, v1, msg)
Definition: exceptions.hpp:143
MAST::FEBasis::Evaluation::compute_quad_side_tangent_and_normal
std::enable_if< ElemDim==SpatialDim &&ElemDim==2, void >::type compute_quad_side_tangent_and_normal(const ContextType &c, const uint_t s, const Eigen::Matrix< NodalScalarType, ElemDim *SpatialDim, Eigen::Dynamic > &dx_dxi, Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &tangent, Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &normal)
Definition: fe_derivative_evaluation.hpp:377
MAST::FEBasis::Evaluation::compute_detJ_side
std::enable_if< ElemDim==SpatialDim &&ElemDim==1, void >::type compute_detJ_side(const ContextType &c, const uint_t s, const Eigen::Matrix< NodalScalarType, ElemDim *SpatialDim, Eigen::Dynamic > &dx_dxi, Eigen::Matrix< NodalScalarType, Eigen::Dynamic, 1 > &detJ)
Definition: fe_derivative_evaluation.hpp:127
mast_data_types.h
MAST::FEBasis::Evaluation::compute_dphi_dx
void compute_dphi_dx(const FEBasisType &fe_basis, const Eigen::Matrix< NodalScalarType, ElemDim *SpatialDim, Eigen::Dynamic > &dxi_dx, Eigen::Matrix< NodalScalarType, Eigen::Dynamic, Eigen::Dynamic > &dphi_dx)
Definition: fe_derivative_evaluation.hpp:578
MAST::FEBasis::Evaluation::compute_side_tangent_and_normal
std::enable_if< ElemDim==SpatialDim &&ElemDim==1, void >::type compute_side_tangent_and_normal(const ContextType &c, const uint_t s, const Eigen::Matrix< NodalScalarType, SpatialDim *ElemDim, Eigen::Dynamic > &dx_dxi, Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &tangent, Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &normal)
Definition: fe_derivative_evaluation.hpp:352
MAST::FEBasis::Evaluation::compute_hex_side_tangent_and_normal
std::enable_if< ElemDim==SpatialDim &&ElemDim==3, void >::type compute_hex_side_tangent_and_normal(const ContextType &c, const uint_t s, const Eigen::Matrix< NodalScalarType, ElemDim *SpatialDim, Eigen::Dynamic > &dx_dxi, Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &tangent, Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &normal)
Definition: fe_derivative_evaluation.hpp:429
Assert0
#define Assert0(cond, msg)
Definition: exceptions.hpp:134
MAST::FEBasis::Evaluation::compute_Jac_inv
std::enable_if< ElemDim==SpatialDim, void >::type compute_Jac_inv(const Eigen::Matrix< NodalScalarType, ElemDim *ElemDim, Eigen::Dynamic > &dx_dxi, Eigen::Matrix< NodalScalarType, ElemDim *ElemDim, Eigen::Dynamic > &dxi_dx)
Definition: fe_derivative_evaluation.hpp:548
uint_t
unsigned int uint_t
Definition: mast_data_types.h:43
Assert2
#define Assert2(cond, v1, v2, msg)
Definition: exceptions.hpp:152
MAST::FEBasis::Evaluation::compute_detJ
void compute_detJ(const Eigen::Matrix< NodalScalarType, SpatialDim *ElemDim, Eigen::Dynamic > &dx_dxi, Eigen::Matrix< NodalScalarType, Eigen::Dynamic, 1 > &detJ)
Definition: fe_derivative_evaluation.hpp:100
MAST::FEBasis::Evaluation::compute_detJxW
void compute_detJxW(const FEBasisType &fe_basis, const Eigen::Matrix< NodalScalarType, Eigen::Dynamic, 1 > &detJ, Eigen::Matrix< NodalScalarType, Eigen::Dynamic, 1 > &detJxW)
Definition: fe_derivative_evaluation.hpp:519
MAST::FEBasis::Evaluation::compute_xyz
void compute_xyz(const ContextType &c, const FEBasisType &fe_basis, Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &node_coord, Eigen::Matrix< NodalScalarType, SpatialDim, Eigen::Dynamic > &xyz)
Definition: fe_derivative_evaluation.hpp:38
MAST::FEBasis::Evaluation::compute_detJ_side_quad
std::enable_if< ElemDim==SpatialDim &&ElemDim==2, void >::type compute_detJ_side_quad(const ContextType &c, const uint_t s, const Eigen::Matrix< NodalScalarType, ElemDim *SpatialDim, Eigen::Dynamic > &dx_dxi, Eigen::Matrix< NodalScalarType, Eigen::Dynamic, 1 > &detJ)
Definition: fe_derivative_evaluation.hpp:244
real_t
double real_t
Definition: mast_data_types.h:42
MAST::FEBasis::Evaluation::compute_detJ_side_hex
std::enable_if< ElemDim==SpatialDim &&ElemDim==3, void >::type compute_detJ_side_hex(const ContextType &c, const uint_t s, const Eigen::Matrix< NodalScalarType, ElemDim *SpatialDim, Eigen::Dynamic > &dx_dxi, Eigen::Matrix< NodalScalarType, Eigen::Dynamic, 1 > &detJ)
Definition: fe_derivative_evaluation.hpp:276