deal.II version GIT relicensing-6834-g5b78e6bcdf 2026-10-01 11:20:01+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
elasticity.h
Go to the documentation of this file.
1// -----------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
4// Copyright (C) 2010 - 2024 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Detailed license information governing the source code and contributions
9// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
10//
11// -----------------------------------------------------------------------------
12
13#ifndef dealii_integrators_elasticity_h
14#define dealii_integrators_elasticity_h
15
16
17#include <deal.II/base/config.h>
18
19#include <deal.II/base/exceptions.h>
20#include <deal.II/base/quadrature.h>
21
22#include <deal.II/fe/fe_values.h>
23#include <deal.II/fe/mapping.h>
24
25#include <deal.II/lac/full_matrix.h>
26
27#include <deal.II/meshworker/dof_info.h>
28
29DEAL_II_NAMESPACE_OPEN
30
31namespace LocalIntegrators
32{
38 namespace Elasticity
39 {
46 template <int dim>
47 DEAL_II_DEPRECATED inline void
48 cell_matrix(FullMatrix<double> &M,
49 const FEValuesBase<dim> &fe,
50 const double factor = 1.)
51 {
52 const unsigned int n_dofs = fe.dofs_per_cell;
53
54 AssertDimension(fe.get_fe().n_components(), dim);
55 AssertDimension(M.m(), n_dofs);
56 AssertDimension(M.n(), n_dofs);
57
58 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
59 {
60 const double dx = factor * fe.JxW(k);
61 for (unsigned int i = 0; i < n_dofs; ++i)
62 for (unsigned int j = 0; j < n_dofs; ++j)
63 for (unsigned int d1 = 0; d1 < dim; ++d1)
64 for (unsigned int d2 = 0; d2 < dim; ++d2)
65 M(i, j) += dx * .25 *
66 (fe.shape_grad_component(j, k, d1)[d2] +
67 fe.shape_grad_component(j, k, d2)[d1]) *
68 (fe.shape_grad_component(i, k, d1)[d2] +
69 fe.shape_grad_component(i, k, d2)[d1]);
70 }
71 }
72
73
79 template <int dim, typename number>
80 DEAL_II_DEPRECATED inline void
81 cell_residual(Vector<number> &result,
82 const FEValuesBase<dim> &fe,
83 const ArrayView<const std::vector<Tensor<1, dim>>> &input,
84 double factor = 1.)
85 {
86 const unsigned int nq = fe.n_quadrature_points;
87 const unsigned int n_dofs = fe.dofs_per_cell;
88 AssertDimension(fe.get_fe().n_components(), dim);
89
90 AssertVectorVectorDimension(input, dim, fe.n_quadrature_points);
91 Assert(result.size() == n_dofs,
92 ExcDimensionMismatch(result.size(), n_dofs));
93
94 for (unsigned int k = 0; k < nq; ++k)
95 {
96 const double dx = factor * fe.JxW(k);
97 for (unsigned int i = 0; i < n_dofs; ++i)
98 for (unsigned int d1 = 0; d1 < dim; ++d1)
99 for (unsigned int d2 = 0; d2 < dim; ++d2)
100 {
101 result(i) += dx * .25 *
102 (input[d1][k][d2] + input[d2][k][d1]) *
103 (fe.shape_grad_component(i, k, d1)[d2] +
104 fe.shape_grad_component(i, k, d2)[d1]);
105 }
106 }
107 }
108
109
118 template <int dim>
119 DEAL_II_DEPRECATED inline void
120 nitsche_matrix(FullMatrix<double> &M,
121 const FEValuesBase<dim> &fe,
122 double penalty,
123 double factor = 1.)
124 {
125 const unsigned int n_dofs = fe.dofs_per_cell;
126
127 AssertDimension(fe.get_fe().n_components(), dim);
128 AssertDimension(M.m(), n_dofs);
129 AssertDimension(M.n(), n_dofs);
130
131 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
132 {
133 const double dx = factor * fe.JxW(k);
134 const Tensor<1, dim> n = fe.normal_vector(k);
135 for (unsigned int i = 0; i < n_dofs; ++i)
136 for (unsigned int j = 0; j < n_dofs; ++j)
137 for (unsigned int d1 = 0; d1 < dim; ++d1)
138 {
139 const double u = fe.shape_value_component(j, k, d1);
140 const double v = fe.shape_value_component(i, k, d1);
141 M(i, j) += dx * 2. * penalty * u * v;
142 for (unsigned int d2 = 0; d2 < dim; ++d2)
143 {
144 // v . nabla u n
145 M(i, j) -= .5 * dx *
146 fe.shape_grad_component(j, k, d1)[d2] * n[d2] *
147 v;
148 // v (nabla u)^T n
149 M(i, j) -= .5 * dx *
150 fe.shape_grad_component(j, k, d2)[d1] * n[d2] *
151 v;
152 // u nabla v n
153 M(i, j) -= .5 * dx *
154 fe.shape_grad_component(i, k, d1)[d2] * n[d2] *
155 u;
156 // u (nabla v)^T n
157 M(i, j) -= .5 * dx *
158 fe.shape_grad_component(i, k, d2)[d1] * n[d2] *
159 u;
160 }
161 }
162 }
163 }
164
173 template <int dim>
174 DEAL_II_DEPRECATED inline void
175 nitsche_tangential_matrix(FullMatrix<double> &M,
176 const FEValuesBase<dim> &fe,
177 double penalty,
178 double factor = 1.)
179 {
180 const unsigned int n_dofs = fe.dofs_per_cell;
181
182 AssertDimension(fe.get_fe().n_components(), dim);
183 AssertDimension(M.m(), n_dofs);
184 AssertDimension(M.n(), n_dofs);
185
186 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
187 {
188 const double dx = factor * fe.JxW(k);
189 const Tensor<1, dim> n = fe.normal_vector(k);
190 for (unsigned int i = 0; i < n_dofs; ++i)
191 for (unsigned int j = 0; j < n_dofs; ++j)
192 {
193 double udotn = 0.;
194 double vdotn = 0.;
195 double ngradun = 0.;
196 double ngradvn = 0.;
197
198 for (unsigned int d = 0; d < dim; ++d)
199 {
200 udotn += n[d] * fe.shape_value_component(j, k, d);
201 vdotn += n[d] * fe.shape_value_component(i, k, d);
202 ngradun += n * fe.shape_grad_component(j, k, d) * n[d];
203 ngradvn += n * fe.shape_grad_component(i, k, d) * n[d];
204 }
205 for (unsigned int d1 = 0; d1 < dim; ++d1)
206 {
207 const double u =
208 fe.shape_value_component(j, k, d1) - udotn * n[d1];
209 const double v =
210 fe.shape_value_component(i, k, d1) - vdotn * n[d1];
211 M(i, j) += dx * 2. * penalty * u * v;
212 // Correct the gradients below and subtract normal component
213 M(i, j) += dx * (ngradun * v + ngradvn * u);
214 for (unsigned int d2 = 0; d2 < dim; ++d2)
215 {
216 // v . nabla u n
217 M(i, j) -= .5 * dx *
218 fe.shape_grad_component(j, k, d1)[d2] *
219 n[d2] * v;
220 // v (nabla u)^T n
221 M(i, j) -= .5 * dx *
222 fe.shape_grad_component(j, k, d2)[d1] *
223 n[d2] * v;
224 // u nabla v n
225 M(i, j) -= .5 * dx *
226 fe.shape_grad_component(i, k, d1)[d2] *
227 n[d2] * u;
228 // u (nabla v)^T n
229 M(i, j) -= .5 * dx *
230 fe.shape_grad_component(i, k, d2)[d1] *
231 n[d2] * u;
232 }
233 }
234 }
235 }
236 }
237
252 template <int dim, typename number>
253 DEAL_II_DEPRECATED void
254 nitsche_residual(Vector<number> &result,
255 const FEValuesBase<dim> &fe,
256 const ArrayView<const std::vector<double>> &input,
257 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
258 const ArrayView<const std::vector<double>> &data,
259 double penalty,
260 double factor = 1.)
261 {
262 const unsigned int n_dofs = fe.dofs_per_cell;
263 AssertVectorVectorDimension(input, dim, fe.n_quadrature_points);
264 AssertVectorVectorDimension(Dinput, dim, fe.n_quadrature_points);
265 AssertVectorVectorDimension(data, dim, fe.n_quadrature_points);
266
267 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
268 {
269 const double dx = factor * fe.JxW(k);
270 const Tensor<1, dim> n = fe.normal_vector(k);
271 for (unsigned int i = 0; i < n_dofs; ++i)
272 for (unsigned int d1 = 0; d1 < dim; ++d1)
273 {
274 const double u = input[d1][k];
275 const double v = fe.shape_value_component(i, k, d1);
276 const double g = data[d1][k];
277 result(i) += dx * 2. * penalty * (u - g) * v;
278
279 for (unsigned int d2 = 0; d2 < dim; ++d2)
280 {
281 // v . nabla u n
282 result(i) -= .5 * dx * v * Dinput[d1][k][d2] * n[d2];
283 // v . (nabla u)^T n
284 result(i) -= .5 * dx * v * Dinput[d2][k][d1] * n[d2];
285 // u nabla v n
286 result(i) -= .5 * dx * (u - g) *
287 fe.shape_grad_component(i, k, d1)[d2] * n[d2];
288 // u (nabla v)^T n
289 result(i) -= .5 * dx * (u - g) *
290 fe.shape_grad_component(i, k, d2)[d1] * n[d2];
291 }
292 }
293 }
294 }
295
304 template <int dim, typename number>
305 DEAL_II_DEPRECATED inline void
306 nitsche_tangential_residual(
307 Vector<number> &result,
308 const FEValuesBase<dim> &fe,
309 const ArrayView<const std::vector<double>> &input,
310 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
311 const ArrayView<const std::vector<double>> &data,
312 double penalty,
313 double factor = 1.)
314 {
315 const unsigned int n_dofs = fe.dofs_per_cell;
316 AssertVectorVectorDimension(input, dim, fe.n_quadrature_points);
317 AssertVectorVectorDimension(Dinput, dim, fe.n_quadrature_points);
318 AssertVectorVectorDimension(data, dim, fe.n_quadrature_points);
319
320 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
321 {
322 const double dx = factor * fe.JxW(k);
323 const Tensor<1, dim> n = fe.normal_vector(k);
324 for (unsigned int i = 0; i < n_dofs; ++i)
325 {
326 double udotn = 0.;
327 double gdotn = 0.;
328 double vdotn = 0.;
329 double ngradun = 0.;
330 double ngradvn = 0.;
331
332 for (unsigned int d = 0; d < dim; ++d)
333 {
334 udotn += n[d] * input[d][k];
335 gdotn += n[d] * data[d][k];
336 vdotn += n[d] * fe.shape_value_component(i, k, d);
337 ngradun += n * Dinput[d][k] * n[d];
338 ngradvn += n * fe.shape_grad_component(i, k, d) * n[d];
339 }
340 for (unsigned int d1 = 0; d1 < dim; ++d1)
341 {
342 const double u = input[d1][k] - udotn * n[d1];
343 const double v =
344 fe.shape_value_component(i, k, d1) - vdotn * n[d1];
345 const double g = data[d1][k] - gdotn * n[d1];
346 result(i) += dx * 2. * penalty * (u - g) * v;
347 // Correct the gradients below and subtract normal component
348 result(i) += dx * (ngradun * v + ngradvn * (u - g));
349 for (unsigned int d2 = 0; d2 < dim; ++d2)
350 {
351 // v . nabla u n
352 result(i) -= .5 * dx * Dinput[d1][k][d2] * n[d2] * v;
353 // v (nabla u)^T n
354 result(i) -= .5 * dx * Dinput[d2][k][d1] * n[d2] * v;
355 // u nabla v n
356 result(i) -= .5 * dx * (u - g) *
357 fe.shape_grad_component(i, k, d1)[d2] *
358 n[d2];
359 // u (nabla v)^T n
360 result(i) -= .5 * dx * (u - g) *
361 fe.shape_grad_component(i, k, d2)[d1] *
362 n[d2];
363 }
364 }
365 }
366 }
367 }
368
382 template <int dim, typename number>
383 DEAL_II_DEPRECATED void
384 nitsche_residual_homogeneous(
385 Vector<number> &result,
386 const FEValuesBase<dim> &fe,
387 const ArrayView<const std::vector<double>> &input,
388 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
389 double penalty,
390 double factor = 1.)
391 {
392 const unsigned int n_dofs = fe.dofs_per_cell;
393 AssertVectorVectorDimension(input, dim, fe.n_quadrature_points);
394 AssertVectorVectorDimension(Dinput, dim, fe.n_quadrature_points);
395
396 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
397 {
398 const double dx = factor * fe.JxW(k);
399 const Tensor<1, dim> n = fe.normal_vector(k);
400 for (unsigned int i = 0; i < n_dofs; ++i)
401 for (unsigned int d1 = 0; d1 < dim; ++d1)
402 {
403 const double u = input[d1][k];
404 const double v = fe.shape_value_component(i, k, d1);
405 result(i) += dx * 2. * penalty * u * v;
406
407 for (unsigned int d2 = 0; d2 < dim; ++d2)
408 {
409 // v . nabla u n
410 result(i) -= .5 * dx * v * Dinput[d1][k][d2] * n[d2];
411 // v . (nabla u)^T n
412 result(i) -= .5 * dx * v * Dinput[d2][k][d1] * n[d2];
413 // u nabla v n
414 result(i) -= .5 * dx * u *
415 fe.shape_grad_component(i, k, d1)[d2] * n[d2];
416 // u (nabla v)^T n
417 result(i) -= .5 * dx * u *
418 fe.shape_grad_component(i, k, d2)[d1] * n[d2];
419 }
420 }
421 }
422 }
423
427 template <int dim>
428 DEAL_II_DEPRECATED inline void
429 ip_matrix(FullMatrix<double> &M11,
430 FullMatrix<double> &M12,
431 FullMatrix<double> &M21,
432 FullMatrix<double> &M22,
433 const FEValuesBase<dim> &fe1,
434 const FEValuesBase<dim> &fe2,
435 const double pen,
436 const double int_factor = 1.,
437 const double ext_factor = -1.)
438 {
439 const unsigned int n_dofs = fe1.dofs_per_cell;
440
441 AssertDimension(fe1.get_fe().n_components(), dim);
442 AssertDimension(fe2.get_fe().n_components(), dim);
443 AssertDimension(M11.m(), n_dofs);
444 AssertDimension(M11.n(), n_dofs);
445 AssertDimension(M12.m(), n_dofs);
446 AssertDimension(M12.n(), n_dofs);
447 AssertDimension(M21.m(), n_dofs);
448 AssertDimension(M21.n(), n_dofs);
449 AssertDimension(M22.m(), n_dofs);
450 AssertDimension(M22.n(), n_dofs);
451
452 const double nu1 = int_factor;
453 const double nu2 = (ext_factor < 0) ? int_factor : ext_factor;
454 const double penalty = .5 * pen * (nu1 + nu2);
455
456 for (unsigned int k = 0; k < fe1.n_quadrature_points; ++k)
457 {
458 const double dx = fe1.JxW(k);
459 const Tensor<1, dim> n = fe1.normal_vector(k);
460 for (unsigned int i = 0; i < n_dofs; ++i)
461 for (unsigned int j = 0; j < n_dofs; ++j)
462 for (unsigned int d1 = 0; d1 < dim; ++d1)
463 {
464 const double u1 = fe1.shape_value_component(j, k, d1);
465 const double u2 = fe2.shape_value_component(j, k, d1);
466 const double v1 = fe1.shape_value_component(i, k, d1);
467 const double v2 = fe2.shape_value_component(i, k, d1);
468
469 M11(i, j) += dx * penalty * u1 * v1;
470 M12(i, j) -= dx * penalty * u2 * v1;
471 M21(i, j) -= dx * penalty * u1 * v2;
472 M22(i, j) += dx * penalty * u2 * v2;
473
474 for (unsigned int d2 = 0; d2 < dim; ++d2)
475 {
476 // v . nabla u n
477 M11(i, j) -= .25 * dx * nu1 *
478 fe1.shape_grad_component(j, k, d1)[d2] *
479 n[d2] * v1;
480 M12(i, j) -= .25 * dx * nu2 *
481 fe2.shape_grad_component(j, k, d1)[d2] *
482 n[d2] * v1;
483 M21(i, j) += .25 * dx * nu1 *
484 fe1.shape_grad_component(j, k, d1)[d2] *
485 n[d2] * v2;
486 M22(i, j) += .25 * dx * nu2 *
487 fe2.shape_grad_component(j, k, d1)[d2] *
488 n[d2] * v2;
489 // v (nabla u)^T n
490 M11(i, j) -= .25 * dx * nu1 *
491 fe1.shape_grad_component(j, k, d2)[d1] *
492 n[d2] * v1;
493 M12(i, j) -= .25 * dx * nu2 *
494 fe2.shape_grad_component(j, k, d2)[d1] *
495 n[d2] * v1;
496 M21(i, j) += .25 * dx * nu1 *
497 fe1.shape_grad_component(j, k, d2)[d1] *
498 n[d2] * v2;
499 M22(i, j) += .25 * dx * nu2 *
500 fe2.shape_grad_component(j, k, d2)[d1] *
501 n[d2] * v2;
502 // u nabla v n
503 M11(i, j) -= .25 * dx * nu1 *
504 fe1.shape_grad_component(i, k, d1)[d2] *
505 n[d2] * u1;
506 M12(i, j) += .25 * dx * nu1 *
507 fe1.shape_grad_component(i, k, d1)[d2] *
508 n[d2] * u2;
509 M21(i, j) -= .25 * dx * nu2 *
510 fe2.shape_grad_component(i, k, d1)[d2] *
511 n[d2] * u1;
512 M22(i, j) += .25 * dx * nu2 *
513 fe2.shape_grad_component(i, k, d1)[d2] *
514 n[d2] * u2;
515 // u (nabla v)^T n
516 M11(i, j) -= .25 * dx * nu1 *
517 fe1.shape_grad_component(i, k, d2)[d1] *
518 n[d2] * u1;
519 M12(i, j) += .25 * dx * nu1 *
520 fe1.shape_grad_component(i, k, d2)[d1] *
521 n[d2] * u2;
522 M21(i, j) -= .25 * dx * nu2 *
523 fe2.shape_grad_component(i, k, d2)[d1] *
524 n[d2] * u1;
525 M22(i, j) += .25 * dx * nu2 *
526 fe2.shape_grad_component(i, k, d2)[d1] *
527 n[d2] * u2;
528 }
529 }
530 }
531 }
535 template <int dim, typename number>
536 DEAL_II_DEPRECATED void
537 ip_residual(Vector<number> &result1,
538 Vector<number> &result2,
539 const FEValuesBase<dim> &fe1,
540 const FEValuesBase<dim> &fe2,
541 const ArrayView<const std::vector<double>> &input1,
542 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput1,
543 const ArrayView<const std::vector<double>> &input2,
544 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput2,
545 double pen,
546 double int_factor = 1.,
547 double ext_factor = -1.)
548 {
549 const unsigned int n1 = fe1.dofs_per_cell;
550
551 AssertDimension(fe1.get_fe().n_components(), dim);
552 AssertDimension(fe2.get_fe().n_components(), dim);
553 AssertVectorVectorDimension(input1, dim, fe1.n_quadrature_points);
554 AssertVectorVectorDimension(Dinput1, dim, fe1.n_quadrature_points);
555 AssertVectorVectorDimension(input2, dim, fe2.n_quadrature_points);
556 AssertVectorVectorDimension(Dinput2, dim, fe2.n_quadrature_points);
557
558 const double nu1 = int_factor;
559 const double nu2 = (ext_factor < 0) ? int_factor : ext_factor;
560 const double penalty = .5 * pen * (nu1 + nu2);
561
562
563 for (unsigned int k = 0; k < fe1.n_quadrature_points; ++k)
564 {
565 const double dx = fe1.JxW(k);
566 const Tensor<1, dim> n = fe1.normal_vector(k);
567
568 for (unsigned int i = 0; i < n1; ++i)
569 for (unsigned int d1 = 0; d1 < dim; ++d1)
570 {
571 const double v1 = fe1.shape_value_component(i, k, d1);
572 const double v2 = fe2.shape_value_component(i, k, d1);
573 const double u1 = input1[d1][k];
574 const double u2 = input2[d1][k];
575
576 result1(i) += dx * penalty * u1 * v1;
577 result1(i) -= dx * penalty * u2 * v1;
578 result2(i) -= dx * penalty * u1 * v2;
579 result2(i) += dx * penalty * u2 * v2;
580
581 for (unsigned int d2 = 0; d2 < dim; ++d2)
582 {
583 // v . nabla u n
584 result1(i) -=
585 .25 * dx *
586 (nu1 * Dinput1[d1][k][d2] + nu2 * Dinput2[d1][k][d2]) *
587 n[d2] * v1;
588 result2(i) +=
589 .25 * dx *
590 (nu1 * Dinput1[d1][k][d2] + nu2 * Dinput2[d1][k][d2]) *
591 n[d2] * v2;
592 // v . (nabla u)^T n
593 result1(i) -=
594 .25 * dx *
595 (nu1 * Dinput1[d2][k][d1] + nu2 * Dinput2[d2][k][d1]) *
596 n[d2] * v1;
597 result2(i) +=
598 .25 * dx *
599 (nu1 * Dinput1[d2][k][d1] + nu2 * Dinput2[d2][k][d1]) *
600 n[d2] * v2;
601 // u nabla v n
602 result1(i) -= .25 * dx * nu1 *
603 fe1.shape_grad_component(i, k, d1)[d2] *
604 n[d2] * (u1 - u2);
605 result2(i) -= .25 * dx * nu2 *
606 fe2.shape_grad_component(i, k, d1)[d2] *
607 n[d2] * (u1 - u2);
608 // u (nabla v)^T n
609 result1(i) -= .25 * dx * nu1 *
610 fe1.shape_grad_component(i, k, d2)[d1] *
611 n[d2] * (u1 - u2);
612 result2(i) -= .25 * dx * nu2 *
613 fe2.shape_grad_component(i, k, d2)[d1] *
614 n[d2] * (u1 - u2);
615 }
616 }
617 }
618 }
619 } // namespace Elasticity
620} // namespace LocalIntegrators
621
622DEAL_II_NAMESPACE_CLOSE
623
624#endif
FEValuesBase::dofs_per_cell
const unsigned int dofs_per_cell
Definition fe_values_base.h:192
FEValuesBase::normal_vector
const Tensor< 1, spacedim > & normal_vector(const unsigned int q_point) const
FEValuesBase::shape_value_component
double shape_value_component(const unsigned int i, const unsigned int q_point, const unsigned int component) const
FEValuesBase::n_quadrature_points
const unsigned int n_quadrature_points
Definition fe_values_base.h:174
FEValuesBase::shape_grad_component
Tensor< 1, spacedim > shape_grad_component(const unsigned int i, const unsigned int q_point, const unsigned int component) const
FEValuesBase::get_fe
const FiniteElement< dim, spacedim > & get_fe() const
FEValuesBase::JxW
double JxW(const unsigned int q_point) const
FiniteElementData::n_components
unsigned int n_components() const
FullMatrix::n
size_type n() const
FullMatrix::m
size_type m() const
Vector::size
virtual size_type size() const override
DEAL_II_DEPRECATED
#define DEAL_II_DEPRECATED
Definition config.h:294
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:38
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:39
fe_values.h
full_matrix.h
v1
const unsigned int v1
Definition grid_tools_topology.cc:648
Assert
#define Assert(cond, exc)
Definition exception_macros.h:543
AssertVectorVectorDimension
#define AssertVectorVectorDimension(VEC, DIM1, DIM2)
Definition exception_macros.h:873
AssertDimension
#define AssertDimension(dim1, dim2)
Definition exception_macros.h:829
StandardExceptions::ExcDimensionMismatch
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
dof_info.h
data
std::vector< index_type > data
Definition mpi.cc:734
LocalIntegrators::Elasticity::nitsche_tangential_matrix
void nitsche_tangential_matrix(FullMatrix< double > &M, const FEValuesBase< dim > &fe, double penalty, double factor=1.)
Definition elasticity.h:175
LocalIntegrators::Elasticity::ip_matrix
void ip_matrix(FullMatrix< double > &M11, FullMatrix< double > &M12, FullMatrix< double > &M21, FullMatrix< double > &M22, const FEValuesBase< dim > &fe1, const FEValuesBase< dim > &fe2, const double pen, const double int_factor=1., const double ext_factor=-1.)
Definition elasticity.h:429
LocalIntegrators::Elasticity::nitsche_residual
void nitsche_residual(Vector< number > &result, const FEValuesBase< dim > &fe, const ArrayView< const std::vector< double > > &input, const ArrayView< const std::vector< Tensor< 1, dim > > > &Dinput, const ArrayView< const std::vector< double > > &data, double penalty, double factor=1.)
Definition elasticity.h:254
LocalIntegrators::Elasticity::nitsche_residual_homogeneous
void nitsche_residual_homogeneous(Vector< number > &result, const FEValuesBase< dim > &fe, const ArrayView< const std::vector< double > > &input, const ArrayView< const std::vector< Tensor< 1, dim > > > &Dinput, double penalty, double factor=1.)
Definition elasticity.h:384
LocalIntegrators::Elasticity::ip_residual
void ip_residual(Vector< number > &result1, Vector< number > &result2, const FEValuesBase< dim > &fe1, const FEValuesBase< dim > &fe2, const ArrayView< const std::vector< double > > &input1, const ArrayView< const std::vector< Tensor< 1, dim > > > &Dinput1, const ArrayView< const std::vector< double > > &input2, const ArrayView< const std::vector< Tensor< 1, dim > > > &Dinput2, double pen, double int_factor=1., double ext_factor=-1.)
Definition elasticity.h:537
LocalIntegrators::Elasticity::nitsche_tangential_residual
void nitsche_tangential_residual(Vector< number > &result, const FEValuesBase< dim > &fe, const ArrayView< const std::vector< double > > &input, const ArrayView< const std::vector< Tensor< 1, dim > > > &Dinput, const ArrayView< const std::vector< double > > &data, double penalty, double factor=1.)
Definition elasticity.h:306
LocalIntegrators::Elasticity::nitsche_matrix
void nitsche_matrix(FullMatrix< double > &M, const FEValuesBase< dim > &fe, double penalty, double factor=1.)
Definition elasticity.h:120
LocalIntegrators::Elasticity::cell_residual
void cell_residual(Vector< number > &result, const FEValuesBase< dim > &fe, const ArrayView< const std::vector< Tensor< 1, dim > > > &input, double factor=1.)
Definition elasticity.h:81
LocalIntegrators::Elasticity::cell_matrix
void cell_matrix(FullMatrix< double > &M, const FEValuesBase< dim > &fe, const double factor=1.)
Definition elasticity.h:48
LocalIntegrators
Library of integrals over cells and faces.
Definition advection.h:32
Generated by doxygen 1.9.8