Debian Codegraph @

include/deal.II/integrators/grad_div.h

raw
1 // ------------------------------------------------------------------------
2 //
3 // SPDX-License-Identifier: LGPL-2.1-or-later
4 // Copyright (C) 2016 - 2024 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // Part of the source code is dual licensed under Apache-2.0 WITH
9 // LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10 // governing the source code and code contributions can be found in
11 // LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12 //
13 // ------------------------------------------------------------------------
14
15 #ifndef dealii_integrators_grad_div_h
16 #define dealii_integrators_grad_div_h
17
18
19 #include <deal.II/base/config.h>
20
21 #include <deal.II/base/exceptions.h>
22 #include <deal.II/base/quadrature.h>
23
24 #include <deal.II/fe/fe_values.h>
25 #include <deal.II/fe/mapping.h>
26
27 #include <deal.II/lac/full_matrix.h>
28
29 #include <deal.II/meshworker/dof_info.h>
30
31 DEAL_II_NAMESPACE_OPEN
32
33 namespace LocalIntegrators
34 {
35 /**
36 * Local integrators related to the grad-div operator and its boundary
37 * traces
38 *
39 * @ingroup Integrators
40 */
41 namespace GradDiv
42 {
43 /**
44 * The weak form of the grad-div operator penalizing volume changes
45 * @f[
46 * \int_Z \nabla\cdot u \nabla \cdot v \,dx
47 * @f]
48 */
49 template <int dim>
50 DEAL_II_DEPRECATED void
51 cell_matrix(FullMatrix<double> &M,
52 const FEValuesBase<dim> &fe,
53 double factor = 1.)
54 {
55 const unsigned int n_dofs = fe.dofs_per_cell;
56
57 AssertDimension(fe.get_fe().n_components(), dim);
58 AssertDimension(M.m(), n_dofs);
59 AssertDimension(M.n(), n_dofs);
60
61 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
62 {
63 const double dx = factor * fe.JxW(k);
64 for (unsigned int i = 0; i < n_dofs; ++i)
65 for (unsigned int j = 0; j < n_dofs; ++j)
66 {
67 const double divu =
68 fe[FEValuesExtractors::Vector(0)].divergence(j, k);
69 const double divv =
70 fe[FEValuesExtractors::Vector(0)].divergence(i, k);
71
72 M(i, j) += dx * divu * divv;
73 }
74 }
75 }
76
77 /**
78 * The weak form of the grad-div residual
79 * @f[
80 * \int_Z \nabla\cdot u \nabla \cdot v \,dx
81 * @f]
82 */
83 template <int dim, typename number>
84 DEAL_II_DEPRECATED void
85 cell_residual(Vector<number> &result,
86 const FEValuesBase<dim> &fetest,
87 const ArrayView<const std::vector<Tensor<1, dim>>> &input,
88 const double factor = 1.)
89 {
90 const unsigned int n_dofs = fetest.dofs_per_cell;
91
92 AssertDimension(fetest.get_fe().n_components(), dim);
93 AssertVectorVectorDimension(input, dim, fetest.n_quadrature_points);
94
95 for (unsigned int k = 0; k < fetest.n_quadrature_points; ++k)
96 {
97 const double dx = factor * fetest.JxW(k);
98 for (unsigned int i = 0; i < n_dofs; ++i)
99 {
100 const double divv =
101 fetest[FEValuesExtractors::Vector(0)].divergence(i, k);
102 double du = 0.;
103 for (unsigned int d = 0; d < dim; ++d)
104 du += input[d][k][d];
105
106 result(i) += dx * du * divv;
107 }
108 }
109 }
110
111 /**
112 * The matrix for the weak boundary condition of Nitsche type for linear
113 * elasticity:
114 * @f[
115 * \int_F \Bigl(\gamma (u \cdot n)(v \cdot n) - \nabla\cdot u
116 * v\cdot n - u \cdot n \nabla \cdot v \Bigr)\;ds.
117 * @f]
118 */
119 template <int dim>
120 DEAL_II_DEPRECATED inline void
121 nitsche_matrix(FullMatrix<double> &M,
122 const FEValuesBase<dim> &fe,
123 double penalty,
124 double factor = 1.)
125 {
126 const unsigned int n_dofs = fe.dofs_per_cell;
127
128 AssertDimension(fe.get_fe().n_components(), dim);
129 AssertDimension(M.m(), n_dofs);
130 AssertDimension(M.n(), n_dofs);
131
132 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
133 {
134 const double dx = factor * fe.JxW(k);
135 const Tensor<1, dim> n = fe.normal_vector(k);
136 for (unsigned int i = 0; i < n_dofs; ++i)
137 for (unsigned int j = 0; j < n_dofs; ++j)
138 {
139 const double divu =
140 fe[FEValuesExtractors::Vector(0)].divergence(j, k);
141 const double divv =
142 fe[FEValuesExtractors::Vector(0)].divergence(i, k);
143 double un = 0., vn = 0.;
144 for (unsigned int d = 0; d < dim; ++d)
145 {
146 un += fe.shape_value_component(j, k, d) * n[d];
147 vn += fe.shape_value_component(i, k, d) * n[d];
148 }
149
150 M(i, j) += dx * 2. * penalty * un * vn;
151 M(i, j) -= dx * (divu * vn + divv * un);
152 }
153 }
154 }
155
156 /**
157 * Weak boundary condition for the Laplace operator by Nitsche, vector
158 * valued version, namely on the face <i>F</i> the vector
159 * @f[
160 * \int_F \Bigl(\gamma (\mathbf u \cdot \mathbf n- \mathbf g \cdot
161 * \mathbf n) (\mathbf v \cdot \mathbf n)
162 * - \nabla \cdot \mathbf u (\mathbf v \cdot \mathbf n)
163 * - (\mathbf u-\mathbf g) \cdot \mathbf n \nabla \cdot v\Bigr)\;ds.
164 * @f]
165 *
166 * Here, <i>u</i> is the finite element function whose values and gradient
167 * are given in the arguments <tt>input</tt> and <tt>Dinput</tt>,
168 * respectively. <i>g</i> is the inhomogeneous boundary value in the
169 * argument <tt>data</tt>. $\gamma$ is the usual penalty parameter.
170 */
171 template <int dim>
172 DEAL_II_DEPRECATED void
173 nitsche_residual(Vector<double> &result,
174 const FEValuesBase<dim> &fe,
175 const ArrayView<const std::vector<double>> &input,
176 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput,
177 const ArrayView<const std::vector<double>> &data,
178 double penalty,
179 double factor = 1.)
180 {
181 const unsigned int n_dofs = fe.dofs_per_cell;
182 AssertDimension(fe.get_fe().n_components(), dim);
183 AssertVectorVectorDimension(input, dim, fe.n_quadrature_points);
184 AssertVectorVectorDimension(Dinput, dim, fe.n_quadrature_points);
185 AssertVectorVectorDimension(data, dim, fe.n_quadrature_points);
186
187 for (unsigned int k = 0; k < fe.n_quadrature_points; ++k)
188 {
189 const double dx = factor * fe.JxW(k);
190 const Tensor<1, dim> n = fe.normal_vector(k);
191
192 double umgn = 0.;
193 double divu = 0.;
194 for (unsigned int d = 0; d < dim; ++d)
195 {
196 umgn += (input[d][k] - data[d][k]) * n[d];
197 divu += Dinput[d][k][d];
198 }
199
200 for (unsigned int i = 0; i < n_dofs; ++i)
201 {
202 double vn = 0.;
203 const double divv =
204 fe[FEValuesExtractors::Vector(0)].divergence(i, k);
205 for (unsigned int d = 0; d < dim; ++d)
206 vn += fe.shape_value_component(i, k, d) * n[d];
207
208 result(i) +=
209 dx * (2. * penalty * umgn * vn - divv * umgn - divu * vn);
210 }
211 }
212 }
213
214 /**
215 * The interior penalty flux for the grad-div operator. See
216 * ip_residual() for details.
217 */
218 template <int dim>
219 DEAL_II_DEPRECATED void
220 ip_matrix(FullMatrix<double> &M11,
221 FullMatrix<double> &M12,
222 FullMatrix<double> &M21,
223 FullMatrix<double> &M22,
224 const FEValuesBase<dim> &fe1,
225 const FEValuesBase<dim> &fe2,
226 double penalty,
227 double factor1 = 1.,
228 double factor2 = -1.)
229 {
230 const unsigned int n_dofs = fe1.dofs_per_cell;
231 AssertDimension(M11.n(), n_dofs);
232 AssertDimension(M11.m(), n_dofs);
233 AssertDimension(M12.n(), n_dofs);
234 AssertDimension(M12.m(), n_dofs);
235 AssertDimension(M21.n(), n_dofs);
236 AssertDimension(M21.m(), n_dofs);
237 AssertDimension(M22.n(), n_dofs);
238 AssertDimension(M22.m(), n_dofs);
239
240 const double fi = factor1;
241 const double fe = (factor2 < 0) ? factor1 : factor2;
242 const double f = .5 * (fi + fe);
243
244 for (unsigned int k = 0; k < fe1.n_quadrature_points; ++k)
245 {
246 const double dx = fe1.JxW(k);
247 const Tensor<1, dim> n = fe1.normal_vector(k);
248 for (unsigned int i = 0; i < n_dofs; ++i)
249 for (unsigned int j = 0; j < n_dofs; ++j)
250 {
251 double uni = 0.;
252 double une = 0.;
253 double vni = 0.;
254 double vne = 0.;
255 const double divui =
256 fe1[FEValuesExtractors::Vector(0)].divergence(j, k);
257 const double divue =
258 fe2[FEValuesExtractors::Vector(0)].divergence(j, k);
259 const double divvi =
260 fe1[FEValuesExtractors::Vector(0)].divergence(i, k);
261 const double divve =
262 fe2[FEValuesExtractors::Vector(0)].divergence(i, k);
263
264 for (unsigned int d = 0; d < dim; ++d)
265 {
266 uni += fe1.shape_value_component(j, k, d) * n[d];
267 une += fe2.shape_value_component(j, k, d) * n[d];
268 vni += fe1.shape_value_component(i, k, d) * n[d];
269 vne += fe2.shape_value_component(i, k, d) * n[d];
270 }
271 M11(i, j) +=
272 dx * (-.5 * fi * divvi * uni - .5 * fi * divui * vni +
273 f * penalty * uni * vni);
274 M12(i, j) +=
275 dx * (.5 * fi * divvi * une - .5 * fe * divue * vni -
276 f * penalty * vni * une);
277 M21(i, j) +=
278 dx * (-.5 * fe * divve * uni + .5 * fi * divui * vne -
279 f * penalty * uni * vne);
280 M22(i, j) +=
281 dx * (.5 * fe * divve * une + .5 * fe * divue * vne +
282 f * penalty * une * vne);
283 }
284 }
285 }
286
287 /**
288 * Grad-div residual term for the symmetric interior penalty method:
289 * @f[
290 * \int_F \Bigl( \gamma [\mathbf u \cdot\mathbf n]
291 * \cdot[\mathbf v \cdot \mathbf n]
292 * - \{\nabla \cdot \mathbf u\}[\mathbf v\cdot \mathbf n]
293 * - [\mathbf u\times \mathbf n]\{\nabla\cdot \mathbf v\} \Bigr) \; ds.
294 * @f]
295 *
296 * See for instance Hansbo and Larson, 2002
297 */
298 template <int dim>
299 DEAL_II_DEPRECATED void
300 ip_residual(Vector<double> &result1,
301 Vector<double> &result2,
302 const FEValuesBase<dim> &fe1,
303 const FEValuesBase<dim> &fe2,
304 const ArrayView<const std::vector<double>> &input1,
305 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput1,
306 const ArrayView<const std::vector<double>> &input2,
307 const ArrayView<const std::vector<Tensor<1, dim>>> &Dinput2,
308 double pen,
309 double int_factor = 1.,
310 double ext_factor = -1.)
311 {
312 const unsigned int n1 = fe1.dofs_per_cell;
313
314 AssertDimension(fe1.get_fe().n_components(), dim);
315 AssertVectorVectorDimension(input1, dim, fe1.n_quadrature_points);
316 AssertVectorVectorDimension(Dinput1, dim, fe1.n_quadrature_points);
317 AssertVectorVectorDimension(input2, dim, fe2.n_quadrature_points);
318 AssertVectorVectorDimension(Dinput2, dim, fe2.n_quadrature_points);
319
320 const double fi = int_factor;
321 const double fe = (ext_factor < 0) ? int_factor : ext_factor;
322 const double penalty = .5 * pen * (fi + fe);
323
324
325 for (unsigned int k = 0; k < fe1.n_quadrature_points; ++k)
326 {
327 const double dx = fe1.JxW(k);
328 const Tensor<1, dim> n = fe1.normal_vector(k);
329 double uni = 0.;
330 double une = 0.;
331 double divui = 0.;
332 double divue = 0.;
333 for (unsigned int d = 0; d < dim; ++d)
334 {
335 uni += input1[d][k] * n[d];
336 une += input2[d][k] * n[d];
337 divui += Dinput1[d][k][d];
338 divue += Dinput2[d][k][d];
339 }
340
341 for (unsigned int i = 0; i < n1; ++i)
342 {
343 double vni = 0.;
344 double vne = 0.;
345 const double divvi =
346 fe1[FEValuesExtractors::Vector(0)].divergence(i, k);
347 const double divve =
348 fe2[FEValuesExtractors::Vector(0)].divergence(i, k);
349 for (unsigned int d = 0; d < dim; ++d)
350 {
351 vni += fe1.shape_value_component(i, k, d) * n[d];
352 vne += fe2.shape_value_component(i, k, d) * n[d];
353 }
354
355 result1(i) += dx * (-.5 * fi * divvi * uni -
356 .5 * fi * divui * vni + penalty * uni * vni);
357 result1(i) += dx * (.5 * fi * divvi * une -
358 .5 * fe * divue * vni - penalty * vni * une);
359 result2(i) += dx * (-.5 * fe * divve * uni +
360 .5 * fi * divui * vne - penalty * uni * vne);
361 result2(i) += dx * (.5 * fe * divve * une +
362 .5 * fe * divue * vne + penalty * une * vne);
363 }
364 }
365 }
366 } // namespace GradDiv
367 } // namespace LocalIntegrators
368
369 DEAL_II_NAMESPACE_CLOSE
370
371
372 #endif