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
laplace.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_laplace_h
14#define dealii_integrators_laplace_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 Laplace
39 {
47 template <int dim>
48 DEAL_II_DEPRECATED void
49 cell_matrix(FullMatrix<double> &M,
50 const FEValuesBase<dim> &fe,
51 const double factor = 1.)
52 {
53 const unsigned int n_dofs = fe.dofs_per_cell;
54 const unsigned int n_components = fe.get_fe().n_components();
55
56 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
57 {
58 const double dx = fe.JxW(k) * factor;
59 for (unsigned int i = 0; i < n_dofs; ++i)
60 {
61 double Mii = 0.0;
62 for (unsigned int d = 0; d < n_components; ++d)
63 Mii += dx * (fe.shape_grad_component(i, k, d) *
64 fe.shape_grad_component(i, k, d));
65
66 M(i, i) += Mii;
67
68 for (unsigned int j = i + 1; j < n_dofs; ++j)
69 {
70 double Mij = 0.0;
71 for (unsigned int d = 0; d < n_components; ++d)
72 Mij += dx * (fe.shape_grad_component(j, k, d) *
73 fe.shape_grad_component(i, k, d));
74
75 M(i, j) += Mij;
76 M(j, i) += Mij;
77 }
78 }
79 }
80 }
81
87 template <int dim>
88 DEAL_II_DEPRECATED inline void
89 cell_residual(Vector<double> &result,
90 const FEValuesBase<dim> &fe,
91 const std::vector<Tensor<1, dim>> &input,
92 double factor = 1.)
93 {
94 const unsigned int nq = fe.n_quadrature_points;
95 const unsigned int n_dofs = fe.dofs_per_cell;
96 Assert(input.size() == nq, ExcDimensionMismatch(input.size(), nq));
97 Assert(result.size() == n_dofs,
98 ExcDimensionMismatch(result.size(), n_dofs));
99
100 for (unsigned int k = 0; k < nq; ++k)
101 {
102 const double dx = factor * fe.JxW(k);
103 for (unsigned int i = 0; i < n_dofs; ++i)
104 result(i) += dx * (input[k] * fe.shape_grad(i, k));
105 }
106 }
107
108
114 template <int dim>
115 DEAL_II_DEPRECATED inline void
116 cell_residual(Vector<double> &result,
117 const FEValuesBase<dim> &fe,
118 const ArrayView<const std::vector<Tensor<1, dim>>> &input,
119 double factor = 1.)
120 {
121 const unsigned int nq = fe.n_quadrature_points;
122 const unsigned int n_dofs = fe.dofs_per_cell;
123 const unsigned int n_comp = fe.get_fe().n_components();
124
125 AssertVectorVectorDimension(input, n_comp, fe.n_quadrature_points);
126 Assert(result.size() == n_dofs,
127 ExcDimensionMismatch(result.size(), n_dofs));
128
129 for (unsigned int k = 0; k < nq; ++k)
130 {
131 const double dx = factor * fe.JxW(k);
132 for (unsigned int i = 0; i < n_dofs; ++i)
133 for (unsigned int d = 0; d < n_comp; ++d)
134 {
135 result(i) +=
136 dx * (input[d][k] * fe.shape_grad_component(i, k, d));
137 }
138 }
139 }
140
141
152 template <int dim>
153 DEAL_II_DEPRECATED void
154 nitsche_matrix(FullMatrix<double> &M,
155 const FEValuesBase<dim> &fe,
156 double penalty,
157 double factor = 1.)
158 {
159 const unsigned int n_dofs = fe.dofs_per_cell;
160 const unsigned int n_comp = fe.get_fe().n_components();
161
162 Assert(M.m() == n_dofs, ExcDimensionMismatch(M.m(), n_dofs));
163 Assert(M.n() == n_dofs, ExcDimensionMismatch(M.n(), n_dofs));
164
165 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
166 {
167 const double dx = fe.JxW(k) * factor;
168 const Tensor<1, dim> &n = fe.normal_vector(k);
169 for (unsigned int i = 0; i < n_dofs; ++i)
170 for (unsigned int j = 0; j < n_dofs; ++j)
171 for (unsigned int d = 0; d < n_comp; ++d)
172 M(i, j) += dx * (2. * fe.shape_value_component(i, k, d) *
173 penalty * fe.shape_value_component(j, k, d) -
174 (n * fe.shape_grad_component(i, k, d)) *
175 fe.shape_value_component(j, k, d) -
176 (n * fe.shape_grad_component(j, k, d)) *
177 fe.shape_value_component(i, k, d));
178 }
179 }
180
193 template <int dim>
194 DEAL_II_DEPRECATED void
195 nitsche_tangential_matrix(FullMatrix<double> &M,
196 const FEValuesBase<dim> &fe,
197 double penalty,
198 double factor = 1.)
199 {
200 const unsigned int n_dofs = fe.dofs_per_cell;
201 AssertDimension(fe.get_fe().n_components(), dim);
202 Assert(M.m() == n_dofs, ExcDimensionMismatch(M.m(), n_dofs));
203 Assert(M.n() == n_dofs, ExcDimensionMismatch(M.n(), n_dofs));
204
205 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
206 {
207 const double dx = fe.JxW(k) * factor;
208 const Tensor<1, dim> n = fe.normal_vector(k);
209 for (unsigned int i = 0; i < n_dofs; ++i)
210 for (unsigned int j = 0; j < n_dofs; ++j)
211 {
212 double udotn = 0.;
213 double vdotn = 0.;
214 double ngradun = 0.;
215 double ngradvn = 0.;
216
217 for (unsigned int d = 0; d < dim; ++d)
218 {
219 udotn += n[d] * fe.shape_value_component(j, k, d);
220 vdotn += n[d] * fe.shape_value_component(i, k, d);
221 ngradun += n * fe.shape_grad_component(j, k, d) * n[d];
222 ngradvn += n * fe.shape_grad_component(i, k, d) * n[d];
223 }
224
225 for (unsigned int d = 0; d < dim; ++d)
226 {
227 const double v_t =
228 fe.shape_value_component(i, k, d) - vdotn * n[d];
229 const double dnv_t =
230 n * fe.shape_grad_component(i, k, d) - ngradvn * n[d];
231 const double u_t =
232 fe.shape_value_component(j, k, d) - udotn * n[d];
233 const double dnu_t =
234 n * fe.shape_grad_component(j, k, d) - ngradun * n[d];
235
236 M(i, j) += dx * (2. * penalty * u_t * v_t - dnu_t * v_t -
237 dnv_t * u_t);
238 }
239 }
240 }
241 }
242
256 template <int dim>
257 DEAL_II_DEPRECATED void
258 nitsche_residual(Vector<double> &result,
259 const FEValuesBase<dim> &fe,
260 const std::vector<double> &input,
261 const std::vector<Tensor<1, dim>> &Dinput,
262 const std::vector<double> &data,
263 double penalty,
264 double factor = 1.)
265 {
266 const unsigned int n_dofs = fe.dofs_per_cell;
267 AssertDimension(input.size(), fe.n_quadrature_points);
268 AssertDimension(Dinput.size(), fe.n_quadrature_points);
269 AssertDimension(data.size(), fe.n_quadrature_points);
270
271 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
272 {
273 const double dx = factor * fe.JxW(k);
274 const Tensor<1, dim> n = fe.normal_vector(k);
275 for (unsigned int i = 0; i < n_dofs; ++i)
276 {
277 const double dnv = fe.shape_grad(i, k) * n;
278 const double dnu = Dinput[k] * n;
279 const double v = fe.shape_value(i, k);
280 const double u = input[k];
281 const double g = data[k];
282
283 result(i) +=
284 dx * (2. * penalty * (u - g) * v - dnv * (u - g) - dnu * v);
285 }
286 }
287 }
288
303 template <int dim>
304 DEAL_II_DEPRECATED void
305 nitsche_residual(Vector<double> &result,
306 const FEValuesBase<dim> &fe,
307 const ArrayView<const std::vector<double>> &input,
308 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
309 const ArrayView<const std::vector<double>> &data,
310 double penalty,
311 double factor = 1.)
312 {
313 const unsigned int n_dofs = fe.dofs_per_cell;
314 const unsigned int n_comp = fe.get_fe().n_components();
315 AssertVectorVectorDimension(input, n_comp, fe.n_quadrature_points);
316 AssertVectorVectorDimension(Dinput, n_comp, fe.n_quadrature_points);
317 AssertVectorVectorDimension(data, n_comp, fe.n_quadrature_points);
318
319 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
320 {
321 const double dx = factor * fe.JxW(k);
322 const Tensor<1, dim> n = fe.normal_vector(k);
323 for (unsigned int i = 0; i < n_dofs; ++i)
324 for (unsigned int d = 0; d < n_comp; ++d)
325 {
326 const double dnv = fe.shape_grad_component(i, k, d) * n;
327 const double dnu = Dinput[d][k] * n;
328 const double v = fe.shape_value_component(i, k, d);
329 const double u = input[d][k];
330 const double g = data[d][k];
331
332 result(i) +=
333 dx * (2. * penalty * (u - g) * v - dnv * (u - g) - dnu * v);
334 }
335 }
336 }
337
354 template <int dim>
355 DEAL_II_DEPRECATED void
356 ip_matrix(FullMatrix<double> &M11,
357 FullMatrix<double> &M12,
358 FullMatrix<double> &M21,
359 FullMatrix<double> &M22,
360 const FEValuesBase<dim> &fe1,
361 const FEValuesBase<dim> &fe2,
362 double penalty,
363 double factor1 = 1.,
364 double factor2 = -1.)
365 {
366 const unsigned int n_dofs = fe1.dofs_per_cell;
367 AssertDimension(M11.n(), n_dofs);
368 AssertDimension(M11.m(), n_dofs);
369 AssertDimension(M12.n(), n_dofs);
370 AssertDimension(M12.m(), n_dofs);
371 AssertDimension(M21.n(), n_dofs);
372 AssertDimension(M21.m(), n_dofs);
373 AssertDimension(M22.n(), n_dofs);
374 AssertDimension(M22.m(), n_dofs);
375
376 const double nui = factor1;
377 const double nue = (factor2 < 0) ? factor1 : factor2;
378 const double nu = .5 * (nui + nue);
379
380 for (unsigned int k = 0; k < fe1.n_quadrature_points; ++k)
381 {
382 const double dx = fe1.JxW(k);
383 const Tensor<1, dim> &n = fe1.normal_vector(k);
384 for (unsigned int d = 0; d < fe1.get_fe().n_components(); ++d)
385 {
386 for (unsigned int i = 0; i < n_dofs; ++i)
387 {
388 for (unsigned int j = 0; j < n_dofs; ++j)
389 {
390 const double vi = fe1.shape_value_component(i, k, d);
391 const double dnvi = n * fe1.shape_grad_component(i, k, d);
392 const double ve = fe2.shape_value_component(i, k, d);
393 const double dnve = n * fe2.shape_grad_component(i, k, d);
394 const double ui = fe1.shape_value_component(j, k, d);
395 const double dnui = n * fe1.shape_grad_component(j, k, d);
396 const double ue = fe2.shape_value_component(j, k, d);
397 const double dnue = n * fe2.shape_grad_component(j, k, d);
398 M11(i, j) +=
399 dx * (-.5 * nui * dnvi * ui - .5 * nui * dnui * vi +
400 nu * penalty * ui * vi);
401 M12(i, j) +=
402 dx * (.5 * nui * dnvi * ue - .5 * nue * dnue * vi -
403 nu * penalty * vi * ue);
404 M21(i, j) +=
405 dx * (-.5 * nue * dnve * ui + .5 * nui * dnui * ve -
406 nu * penalty * ui * ve);
407 M22(i, j) +=
408 dx * (.5 * nue * dnve * ue + .5 * nue * dnue * ve +
409 nu * penalty * ue * ve);
410 }
411 }
412 }
413 }
414 }
415
427 template <int dim>
428 DEAL_II_DEPRECATED void
429 ip_tangential_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 double penalty,
436 double factor1 = 1.,
437 double factor2 = -1.)
438 {
439 const unsigned int n_dofs = fe1.dofs_per_cell;
440 AssertDimension(fe1.get_fe().n_components(), dim);
441 AssertDimension(fe2.get_fe().n_components(), dim);
442 AssertDimension(M11.n(), n_dofs);
443 AssertDimension(M11.m(), n_dofs);
444 AssertDimension(M12.n(), n_dofs);
445 AssertDimension(M12.m(), n_dofs);
446 AssertDimension(M21.n(), n_dofs);
447 AssertDimension(M21.m(), n_dofs);
448 AssertDimension(M22.n(), n_dofs);
449 AssertDimension(M22.m(), n_dofs);
450
451 const double nui = factor1;
452 const double nue = (factor2 < 0) ? factor1 : factor2;
453 const double nu = .5 * (nui + nue);
454
455 for (unsigned int k = 0; k < fe1.n_quadrature_points; ++k)
456 {
457 const double dx = fe1.JxW(k);
458 const Tensor<1, dim> n = fe1.normal_vector(k);
459 for (unsigned int i = 0; i < n_dofs; ++i)
460 {
461 // We compute the tangential component by subtracting
462 // the normal component from the total. Thus, compute
463 // the normal component first
464 for (unsigned int j = 0; j < n_dofs; ++j)
465 {
466 double u1dotn = 0.;
467 double v1dotn = 0.;
468 double u2dotn = 0.;
469 double v2dotn = 0.;
470
471 double ngradu1n = 0.;
472 double ngradv1n = 0.;
473 double ngradu2n = 0.;
474 double ngradv2n = 0.;
475
476 for (unsigned int d = 0; d < dim; ++d)
477 {
478 u1dotn += n[d] * fe1.shape_value_component(j, k, d);
479 v1dotn += n[d] * fe1.shape_value_component(i, k, d);
480 u2dotn += n[d] * fe2.shape_value_component(j, k, d);
481 v2dotn += n[d] * fe2.shape_value_component(i, k, d);
482
483 ngradu1n += n * fe1.shape_grad_component(j, k, d) * n[d];
484 ngradv1n += n * fe1.shape_grad_component(i, k, d) * n[d];
485 ngradu2n += n * fe2.shape_grad_component(j, k, d) * n[d];
486 ngradv2n += n * fe2.shape_grad_component(i, k, d) * n[d];
487 }
488
489 // The following code is equal to ip_matrix() with
490 // the only exception that all variables introduced
491 // below denote tangential components.
492 for (unsigned int d = 0; d < dim; ++d)
493 {
494 const double vi =
495 fe1.shape_value_component(i, k, d) - v1dotn * n[d];
496 const double dnvi =
497 n * fe1.shape_grad_component(i, k, d) - ngradv1n * n[d];
498
499 const double ve =
500 fe2.shape_value_component(i, k, d) - v2dotn * n[d];
501 const double dnve =
502 n * fe2.shape_grad_component(i, k, d) - ngradv2n * n[d];
503
504 const double ui =
505 fe1.shape_value_component(j, k, d) - u1dotn * n[d];
506 const double dnui =
507 n * fe1.shape_grad_component(j, k, d) - ngradu1n * n[d];
508
509 const double ue =
510 fe2.shape_value_component(j, k, d) - u2dotn * n[d];
511 const double dnue =
512 n * fe2.shape_grad_component(j, k, d) - ngradu2n * n[d];
513
514 M11(i, j) +=
515 dx * (-.5 * nui * dnvi * ui - .5 * nui * dnui * vi +
516 nu * penalty * ui * vi);
517 M12(i, j) +=
518 dx * (.5 * nui * dnvi * ue - .5 * nue * dnue * vi -
519 nu * penalty * vi * ue);
520 M21(i, j) +=
521 dx * (-.5 * nue * dnve * ui + .5 * nui * dnui * ve -
522 nu * penalty * ui * ve);
523 M22(i, j) +=
524 dx * (.5 * nue * dnve * ue + .5 * nue * dnue * ve +
525 nu * penalty * ue * ve);
526 }
527 }
528 }
529 }
530 }
531
539 template <int dim>
540 DEAL_II_DEPRECATED void
541 ip_residual(Vector<double> &result1,
542 Vector<double> &result2,
543 const FEValuesBase<dim> &fe1,
544 const FEValuesBase<dim> &fe2,
545 const std::vector<double> &input1,
546 const std::vector<Tensor<1, dim>> &Dinput1,
547 const std::vector<double> &input2,
548 const std::vector<Tensor<1, dim>> &Dinput2,
549 double pen,
550 double int_factor = 1.,
551 double ext_factor = -1.)
552 {
553 Assert(fe1.get_fe().n_components() == 1,
554 ExcDimensionMismatch(fe1.get_fe().n_components(), 1));
555 Assert(fe2.get_fe().n_components() == 1,
556 ExcDimensionMismatch(fe2.get_fe().n_components(), 1));
557
558 const double nui = int_factor;
559 const double nue = (ext_factor < 0) ? int_factor : ext_factor;
560 const double penalty = .5 * pen * (nui + nue);
561
562 const unsigned int n_dofs = fe1.dofs_per_cell;
563
564 for (unsigned int k = 0; k < fe1.n_quadrature_points; ++k)
565 {
566 const double dx = fe1.JxW(k);
567 const Tensor<1, dim> n = fe1.normal_vector(k);
568
569 for (unsigned int i = 0; i < n_dofs; ++i)
570 {
571 const double vi = fe1.shape_value(i, k);
572 const Tensor<1, dim> &Dvi = fe1.shape_grad(i, k);
573 const double dnvi = Dvi * n;
574 const double ve = fe2.shape_value(i, k);
575 const Tensor<1, dim> &Dve = fe2.shape_grad(i, k);
576 const double dnve = Dve * n;
577
578 const double ui = input1[k];
579 const Tensor<1, dim> &Dui = Dinput1[k];
580 const double dnui = Dui * n;
581 const double ue = input2[k];
582 const Tensor<1, dim> &Due = Dinput2[k];
583 const double dnue = Due * n;
584
585 result1(i) += dx * (-.5 * nui * dnvi * ui - .5 * nui * dnui * vi +
586 penalty * ui * vi);
587 result1(i) += dx * (.5 * nui * dnvi * ue - .5 * nue * dnue * vi -
588 penalty * vi * ue);
589 result2(i) += dx * (-.5 * nue * dnve * ui + .5 * nui * dnui * ve -
590 penalty * ui * ve);
591 result2(i) += dx * (.5 * nue * dnve * ue + .5 * nue * dnue * ve +
592 penalty * ue * ve);
593 }
594 }
595 }
596
597
606 template <int dim>
607 DEAL_II_DEPRECATED void
608 ip_residual(Vector<double> &result1,
609 Vector<double> &result2,
610 const FEValuesBase<dim> &fe1,
611 const FEValuesBase<dim> &fe2,
612 const ArrayView<const std::vector<double>> &input1,
613 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput1,
614 const ArrayView<const std::vector<double>> &input2,
615 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput2,
616 double pen,
617 double int_factor = 1.,
618 double ext_factor = -1.)
619 {
620 const unsigned int n_comp = fe1.get_fe().n_components();
621 const unsigned int n1 = fe1.dofs_per_cell;
622
623 AssertVectorVectorDimension(input1, n_comp, fe1.n_quadrature_points);
624 AssertVectorVectorDimension(Dinput1, n_comp, fe1.n_quadrature_points);
625 AssertVectorVectorDimension(input2, n_comp, fe2.n_quadrature_points);
626 AssertVectorVectorDimension(Dinput2, n_comp, fe2.n_quadrature_points);
627
628 const double nui = int_factor;
629 const double nue = (ext_factor < 0) ? int_factor : ext_factor;
630 const double penalty = .5 * pen * (nui + nue);
631
632
633 for (unsigned int k = 0; k < fe1.n_quadrature_points; ++k)
634 {
635 const double dx = fe1.JxW(k);
636 const Tensor<1, dim> n = fe1.normal_vector(k);
637
638 for (unsigned int i = 0; i < n1; ++i)
639 for (unsigned int d = 0; d < n_comp; ++d)
640 {
641 const double vi = fe1.shape_value_component(i, k, d);
642 const Tensor<1, dim> &Dvi = fe1.shape_grad_component(i, k, d);
643 const double dnvi = Dvi * n;
644 const double ve = fe2.shape_value_component(i, k, d);
645 const Tensor<1, dim> &Dve = fe2.shape_grad_component(i, k, d);
646 const double dnve = Dve * n;
647
648 const double ui = input1[d][k];
649 const Tensor<1, dim> &Dui = Dinput1[d][k];
650 const double dnui = Dui * n;
651 const double ue = input2[d][k];
652 const Tensor<1, dim> &Due = Dinput2[d][k];
653 const double dnue = Due * n;
654
655 result1(i) += dx * (-.5 * nui * dnvi * ui -
656 .5 * nui * dnui * vi + penalty * ui * vi);
657 result1(i) += dx * (.5 * nui * dnvi * ue -
658 .5 * nue * dnue * vi - penalty * vi * ue);
659 result2(i) += dx * (-.5 * nue * dnve * ui +
660 .5 * nui * dnui * ve - penalty * ui * ve);
661 result2(i) += dx * (.5 * nue * dnve * ue +
662 .5 * nue * dnue * ve + penalty * ue * ve);
663 }
664 }
665 }
666
667
668
680 template <int dim, int spacedim, typename number>
681 DEAL_II_DEPRECATED double
682 compute_penalty(const MeshWorker::DoFInfo<dim, spacedim, number> &dinfo1,
683 const MeshWorker::DoFInfo<dim, spacedim, number> &dinfo2,
684 unsigned int deg1,
685 unsigned int deg2)
686 {
687 const unsigned int normal1 =
688 GeometryInfo<dim>::unit_normal_direction[dinfo1.face_number];
689 const unsigned int normal2 =
690 GeometryInfo<dim>::unit_normal_direction[dinfo2.face_number];
691 const unsigned int deg1sq = (deg1 == 0) ? 1 : deg1 * (deg1 + 1);
692 const unsigned int deg2sq = (deg2 == 0) ? 1 : deg2 * (deg2 + 1);
693
694 double penalty1 = deg1sq / dinfo1.cell->extent_in_direction(normal1);
695 double penalty2 = deg2sq / dinfo2.cell->extent_in_direction(normal2);
696 if (dinfo1.cell->has_children() ^ dinfo2.cell->has_children())
697 {
698 Assert(dinfo1.face == dinfo2.face, ExcInternalError());
699 Assert(dinfo1.face->has_children(), ExcInternalError());
700 penalty1 *= 2;
701 }
702 const double penalty = 0.5 * (penalty1 + penalty2);
703 return penalty;
704 }
705 } // namespace Laplace
706} // namespace LocalIntegrators
707
708
709DEAL_II_NAMESPACE_CLOSE
710
711#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::shape_grad
const Tensor< 1, spacedim > & shape_grad(const unsigned int i, const unsigned int q_point) const
FEValuesBase::get_fe
const FiniteElement< dim, spacedim > & get_fe() const
FEValuesBase::JxW
double JxW(const unsigned int q_point) const
FEValuesBase::shape_value
const double & shape_value(const unsigned int i, 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
MeshWorker::DoFInfo::face
Triangulation< dim, spacedim >::face_iterator face
The current face.
Definition dof_info.h:79
MeshWorker::DoFInfo::face_number
unsigned int face_number
Definition dof_info.h:87
MeshWorker::DoFInfo::cell
Triangulation< dim, spacedim >::cell_iterator cell
The current cell.
Definition dof_info.h:76
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
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::ExcInternalError
static ::ExceptionBase & ExcInternalError()
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::Laplace::ip_tangential_matrix
void ip_tangential_matrix(FullMatrix< double > &M11, FullMatrix< double > &M12, FullMatrix< double > &M21, FullMatrix< double > &M22, const FEValuesBase< dim > &fe1, const FEValuesBase< dim > &fe2, double penalty, double factor1=1., double factor2=-1.)
Definition laplace.h:429
LocalIntegrators::Laplace::cell_residual
void cell_residual(Vector< double > &result, const FEValuesBase< dim > &fe, const std::vector< Tensor< 1, dim > > &input, double factor=1.)
Definition laplace.h:89
LocalIntegrators::Laplace::cell_matrix
void cell_matrix(FullMatrix< double > &M, const FEValuesBase< dim > &fe, const double factor=1.)
Definition laplace.h:49
LocalIntegrators::Laplace::compute_penalty
double compute_penalty(const MeshWorker::DoFInfo< dim, spacedim, number > &dinfo1, const MeshWorker::DoFInfo< dim, spacedim, number > &dinfo2, unsigned int deg1, unsigned int deg2)
Definition laplace.h:682
LocalIntegrators::Laplace::nitsche_residual
void nitsche_residual(Vector< double > &result, const FEValuesBase< dim > &fe, const std::vector< double > &input, const std::vector< Tensor< 1, dim > > &Dinput, const std::vector< double > &data, double penalty, double factor=1.)
Definition laplace.h:258
LocalIntegrators::Laplace::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, double penalty, double factor1=1., double factor2=-1.)
Definition laplace.h:356
LocalIntegrators::Laplace::nitsche_tangential_matrix
void nitsche_tangential_matrix(FullMatrix< double > &M, const FEValuesBase< dim > &fe, double penalty, double factor=1.)
Definition laplace.h:195
LocalIntegrators::Laplace::ip_residual
void ip_residual(Vector< double > &result1, Vector< double > &result2, const FEValuesBase< dim > &fe1, const FEValuesBase< dim > &fe2, const std::vector< double > &input1, const std::vector< Tensor< 1, dim > > &Dinput1, const std::vector< double > &input2, const std::vector< Tensor< 1, dim > > &Dinput2, double pen, double int_factor=1., double ext_factor=-1.)
Definition laplace.h:541
LocalIntegrators::Laplace::nitsche_matrix
void nitsche_matrix(FullMatrix< double > &M, const FEValuesBase< dim > &fe, double penalty, double factor=1.)
Definition laplace.h:154
LocalIntegrators
Library of integrals over cells and faces.
Definition advection.h:32
Generated by doxygen 1.9.8