Lethe Open-Source Library version 1.2.0
Developer Guide
Loading...
Searching...
No Matches
postprocessing_cfd.cc
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) 2020-2026 The Lethe Authors
2// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
3
4// Base
5#include <deal.II/base/quadrature_lib.h>
6
7// Lac
8#include <deal.II/lac/dynamic_sparsity_pattern.h>
9#include <deal.II/lac/vector.h>
10
11// grid
12#include <deal.II/grid/grid_tools.h>
13
14// Dofs
15#include <deal.II/dofs/dof_accessor.h>
16#include <deal.II/dofs/dof_handler.h>
17
18// Lac - Trilinos includes
19#include <deal.II/lac/trilinos_parallel_block_vector.h>
20#include <deal.II/lac/trilinos_vector.h>
21
22// Fe
23#include <deal.II/fe/fe_q.h>
24#include <deal.II/fe/fe_system.h>
25#include <deal.II/fe/fe_values.h>
26#include <deal.II/fe/mapping_q.h>
27
28// Lethe includes
30#include <core/parameters.h>
32#include <core/vector.h>
33
35
36
37using namespace dealii;
38
39template <int dim, typename VectorType>
40std::pair<double, double>
41calculate_pressure_drop(const DoFHandler<dim> &dof_handler,
42 const Mapping<dim> &mapping,
43 const VectorType &evaluation_point,
44 const Quadrature<dim> &cell_quadrature_formula,
45 const Quadrature<dim - 1> &face_quadrature_formula,
46 const unsigned int inlet_boundary_id,
47 const unsigned int outlet_boundary_id)
48{
49 FESystem<dim, dim> fe = dof_handler.get_fe();
50 FEValues<dim> fe_values(mapping,
51 fe,
52 cell_quadrature_formula,
53 update_values | update_quadrature_points |
54 update_JxW_values | update_gradients |
55 update_hessians);
56 FEFaceValues<dim> fe_face_values(fe,
57 face_quadrature_formula,
58 update_values | update_quadrature_points |
59 update_normal_vectors | update_JxW_values);
60
61 const FEValuesExtractors::Vector velocities(0);
62 const FEValuesExtractors::Scalar pressure(dim);
63
64 const unsigned int face_n_q_points = face_quadrature_formula.size();
65
66 std::vector<Tensor<1, dim>> velocity_values(face_n_q_points);
67 std::vector<double> pressure_values(face_n_q_points);
68
69 double static_pressure_outlet_boundary = 0.;
70 double static_pressure_inlet_boundary = 0.;
71 double static_pressure_drop = 0.;
72
73 double dynamic_pressure_outlet_boundary = 0.;
74 double dynamic_pressure_inlet_boundary = 0.;
75 double dynamic_pressure_drop = 0.;
76
77 double outlet_surface = 0.;
78 double inlet_surface = 0.;
79
80 double temp_surface = 0.;
81 double temp_static_pressure_at_boundary = 0.;
82 double temp_dynamic_pressure_at_boundary = 0.;
83
84 for (const auto &cell : dof_handler.active_cell_iterators())
85 {
86 if (cell->is_locally_owned())
87 {
88 for (unsigned int face_id = 0;
89 face_id < GeometryInfo<dim>::faces_per_cell;
90 face_id++)
91 {
92 if (cell->face(face_id)->at_boundary())
93 {
94 unsigned int boundary_id = cell->face(face_id)->boundary_id();
95 if (boundary_id != inlet_boundary_id &&
96 boundary_id != outlet_boundary_id)
97 continue;
98 fe_face_values.reinit(cell, face_id);
99 fe_face_values[velocities].get_function_values(
100 evaluation_point, velocity_values);
101 fe_face_values[pressure].get_function_values(evaluation_point,
102 pressure_values);
103 temp_surface = 0.;
104 temp_static_pressure_at_boundary = 0.;
105 temp_dynamic_pressure_at_boundary = 0.;
106 for (unsigned int q = 0; q < face_n_q_points; q++)
107 {
108 temp_surface += fe_face_values.JxW(q);
109 // Integration of velocity^2 and
110 // pressure, since the pressure in Lethe has units of
111 // Length^2/Time^2
112 temp_static_pressure_at_boundary +=
113 fe_face_values.JxW(q) * pressure_values[q];
114 temp_dynamic_pressure_at_boundary +=
115 0.5 * fe_face_values.JxW(q) * velocity_values[q] *
116 velocity_values[q];
117 }
118 if (boundary_id == inlet_boundary_id)
119 {
120 inlet_surface += temp_surface;
121 dynamic_pressure_inlet_boundary +=
122 temp_dynamic_pressure_at_boundary;
123 static_pressure_inlet_boundary +=
124 temp_static_pressure_at_boundary;
125 }
126 if (boundary_id == outlet_boundary_id)
127 {
128 outlet_surface += temp_surface;
129 dynamic_pressure_outlet_boundary +=
130 temp_dynamic_pressure_at_boundary;
131 static_pressure_outlet_boundary +=
132 temp_static_pressure_at_boundary;
133 }
134 }
135 }
136 }
137 }
138
139 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
140 static_pressure_inlet_boundary =
141 Utilities::MPI::sum(static_pressure_inlet_boundary, mpi_communicator);
142 static_pressure_outlet_boundary =
143 Utilities::MPI::sum(static_pressure_outlet_boundary, mpi_communicator);
144
145 dynamic_pressure_inlet_boundary =
146 Utilities::MPI::sum(dynamic_pressure_inlet_boundary, mpi_communicator);
147 dynamic_pressure_outlet_boundary =
148 Utilities::MPI::sum(dynamic_pressure_outlet_boundary, mpi_communicator);
149
150 inlet_surface = Utilities::MPI::sum(inlet_surface, mpi_communicator);
151 outlet_surface = Utilities::MPI::sum(outlet_surface, mpi_communicator);
152
153 static_pressure_outlet_boundary =
154 static_pressure_outlet_boundary / outlet_surface;
155 static_pressure_inlet_boundary =
156 static_pressure_inlet_boundary / inlet_surface;
157 static_pressure_drop =
158 static_pressure_inlet_boundary - static_pressure_outlet_boundary;
159
160 dynamic_pressure_outlet_boundary =
161 dynamic_pressure_outlet_boundary / outlet_surface;
162 dynamic_pressure_inlet_boundary =
163 dynamic_pressure_inlet_boundary / inlet_surface;
164 dynamic_pressure_drop =
165 dynamic_pressure_inlet_boundary - dynamic_pressure_outlet_boundary;
166
167 return {static_pressure_drop, static_pressure_drop + dynamic_pressure_drop};
168}
169
170template std::pair<double, double>
172 const DoFHandler<2> &dof_handler,
173 const Mapping<2> &mapping,
174 const GlobalVectorType &evaluation_point,
175 const Quadrature<2> &cell_quadrature_formula,
176 const Quadrature<1> &face_quadrature_formula,
177 const unsigned int inlet_boundary_id,
178 const unsigned int outlet_boundary_id);
179
180template std::pair<double, double>
182 const DoFHandler<3> &dof_handler,
183 const Mapping<3> &mapping,
184 const GlobalVectorType &evaluation_point,
185 const Quadrature<3> &cell_quadrature_formula,
186 const Quadrature<2> &face_quadrature_formula,
187 const unsigned int inlet_boundary_id,
188 const unsigned int outlet_boundary_id);
189
190template std::pair<double, double>
192 const DoFHandler<2> &dof_handler,
193 const Mapping<2> &mapping,
194 const GlobalBlockVectorType &evaluation_point,
195 const Quadrature<2> &cell_quadrature_formula,
196 const Quadrature<1> &face_quadrature_formula,
197 const unsigned int inlet_boundary_id,
198 const unsigned int outlet_boundary_id);
199
200template std::pair<double, double>
202 const DoFHandler<3> &dof_handler,
203 const Mapping<3> &mapping,
204 const GlobalBlockVectorType &evaluation_point,
205 const Quadrature<3> &cell_quadrature_formula,
206 const Quadrature<2> &face_quadrature_formula,
207 const unsigned int inlet_boundary_id,
208 const unsigned int outlet_boundary_id);
209
210#ifndef LETHE_USE_LDV
211template std::pair<double, double>
213 const DoFHandler<2> &dof_handler,
214 const Mapping<2> &mapping,
215 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
216 const Quadrature<2> &cell_quadrature_formula,
217 const Quadrature<1> &face_quadrature_formula,
218 const unsigned int inlet_boundary_id,
219 const unsigned int outlet_boundary_id);
220
221template std::pair<double, double>
223 const DoFHandler<3> &dof_handler,
224 const Mapping<3> &mapping,
225 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
226 const Quadrature<3> &cell_quadrature_formula,
227 const Quadrature<2> &face_quadrature_formula,
228 const unsigned int inlet_boundary_id,
229 const unsigned int outlet_boundary_id);
230#endif
231
232template <int dim, typename VectorType>
233double
234calculate_CFL(const DoFHandler<dim> &dof_handler,
235 const VectorType &evaluation_point,
236 const double time_step,
237 const Quadrature<dim> &quadrature_formula,
238 const Mapping<dim> &mapping)
239{
240 FESystem<dim, dim> fe = dof_handler.get_fe();
241 FEValues<dim> fe_values(mapping,
242 fe,
243 quadrature_formula,
244 update_values | update_quadrature_points |
245 update_JxW_values);
246
247 const FEValuesExtractors::Vector velocities(0);
248 const unsigned int n_q_points = quadrature_formula.size();
249
250
251 std::vector<Tensor<1, dim>> present_velocity_values(n_q_points);
252
253 // Element size
254 double h;
255
256 // Element degree
257 const unsigned int degree = fe.degree;
258
259 // CFL
260 double CFL = 0;
261
262 for (const auto &cell : dof_handler.active_cell_iterators())
263 {
264 if (cell->is_locally_owned())
265 {
266 fe_values.reinit(cell);
267
268 // Compute cell diameter
269 double cell_measure =
270 compute_cell_measure_with_JxW(fe_values.get_JxW_values());
271 h = compute_cell_diameter<dim>(cell_measure, degree);
272
273 fe_values[velocities].get_function_values(evaluation_point,
274 present_velocity_values);
275 for (unsigned int q = 0; q < n_q_points; ++q)
276 {
277 const double localCFL =
278 present_velocity_values[q].norm() / h * time_step;
279 CFL = std::max(CFL, localCFL);
280 }
281 }
282 }
283 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
284 CFL = Utilities::MPI::max(CFL, mpi_communicator);
285 return (CFL);
286}
287
288template double
289calculate_CFL<2, GlobalVectorType>(const DoFHandler<2> &dof_handler,
290 const GlobalVectorType &evaluation_point,
291 const double time_step,
292 const Quadrature<2> &quadrature_formula,
293 const Mapping<2> &mapping);
294
295template double
296calculate_CFL<3, GlobalVectorType>(const DoFHandler<3> &dof_handler,
297 const GlobalVectorType &evaluation_point,
298 const double time_step,
299 const Quadrature<3> &quadrature_formula,
300 const Mapping<3> &mapping);
301
302#ifndef LETHE_USE_LDV
303template double
305 const DoFHandler<2> &dof_handler,
306 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
307 const double time_step,
308 const Quadrature<2> &quadrature_formula,
309 const Mapping<2> &mapping);
310
311template double
313 const DoFHandler<3> &dof_handler,
314 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
315 const double time_step,
316 const Quadrature<3> &quadrature_formula,
317 const Mapping<3> &mapping);
318#endif
319
320template double
322 const DoFHandler<2> &dof_handler,
323 const GlobalBlockVectorType &evaluation_point,
324 const double time_step,
325 const Quadrature<2> &quadrature_formula,
326 const Mapping<2> &mapping);
327
328template double
330 const DoFHandler<3> &dof_handler,
331 const GlobalBlockVectorType &evaluation_point,
332 const double time_step,
333 const Quadrature<3> &quadrature_formula,
334 const Mapping<3> &mapping);
335
336
337template <int dim, typename VectorType>
338double
339calculate_enstrophy(const DoFHandler<dim> &dof_handler,
340 const VectorType &evaluation_point,
341 const Quadrature<dim> &quadrature_formula,
342 const Mapping<dim> &mapping)
343{
344 const FESystem<dim, dim> fe = dof_handler.get_fe();
345 FEValues<dim> fe_values(mapping,
346 fe,
347 quadrature_formula,
348 update_values | update_gradients |
349 update_quadrature_points | update_JxW_values);
350
351 const FEValuesExtractors::Vector velocities(0);
352
353 const unsigned int n_q_points = quadrature_formula.size();
354
355 std::vector<Tensor<2, dim>> present_velocity_gradients(n_q_points);
356 double en = 0.0;
357 double domain_volume =
358 GridTools::volume(dof_handler.get_triangulation(), mapping);
359
360 for (const auto &cell : dof_handler.active_cell_iterators())
361 {
362 if (cell->is_locally_owned())
363 {
364 fe_values.reinit(cell);
365
366 fe_values[velocities].get_function_gradients(
367 evaluation_point, present_velocity_gradients);
368
369 for (unsigned int q = 0; q < n_q_points; q++)
370 {
371 // Find the values of gradient of ux and uy (the finite element
372 // solution) at the quadrature points
373 double ux_y = present_velocity_gradients[q][0][1];
374 double uy_x = present_velocity_gradients[q][1][0];
375
376 if (dim == 2)
377 {
378 en += 0.5 * (uy_x - ux_y) * (uy_x - ux_y) * fe_values.JxW(q) /
379 domain_volume;
380 }
381 else
382 {
383 double uz_y = present_velocity_gradients[q][2][1];
384 double uy_z = present_velocity_gradients[q][1][2];
385 double ux_z = present_velocity_gradients[q][0][2];
386 double uz_x = present_velocity_gradients[q][2][0];
387 en += 0.5 * (uz_y - uy_z) * (uz_y - uy_z) * fe_values.JxW(q) /
388 domain_volume;
389 en += 0.5 * (ux_z - uz_x) * (ux_z - uz_x) * fe_values.JxW(q) /
390 domain_volume;
391 en += 0.5 * (uy_x - ux_y) * (uy_x - ux_y) * fe_values.JxW(q) /
392 domain_volume;
393 }
394 }
395 }
396 }
397 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
398 en = Utilities::MPI::sum(en, mpi_communicator);
399 return (en);
400}
401
402template double
404 const DoFHandler<2> &dof_handler,
405 const GlobalVectorType &evaluation_point,
406 const Quadrature<2> &quadrature_formula,
407 const Mapping<2> &mapping);
408
409template double
411 const DoFHandler<3> &dof_handler,
412 const GlobalVectorType &evaluation_point,
413 const Quadrature<3> &quadrature_formula,
414 const Mapping<3> &mapping);
415
416template double
418 const DoFHandler<2> &dof_handler,
419 const GlobalBlockVectorType &evaluation_point,
420 const Quadrature<2> &quadrature_formula,
421 const Mapping<2> &mapping);
422
423template double
425 const DoFHandler<3> &dof_handler,
426 const GlobalBlockVectorType &evaluation_point,
427 const Quadrature<3> &quadrature_formula,
428 const Mapping<3> &mapping);
429
430#ifndef LETHE_USE_LDV
431template double
433 const DoFHandler<2> &dof_handler,
434 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
435 const Quadrature<2> &quadrature_formula,
436 const Mapping<2> &mapping);
437
438template double
440 const DoFHandler<3> &dof_handler,
441 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
442 const Quadrature<3> &quadrature_formula,
443 const Mapping<3> &mapping);
444#endif
445
446template <int dim, typename VectorType>
447double
448calculate_pressure_power(const DoFHandler<dim> &dof_handler,
449 const VectorType &evaluation_point,
450 const Quadrature<dim> &quadrature_formula,
451 const Mapping<dim> &mapping)
452{
453 const FESystem<dim, dim> fe = dof_handler.get_fe();
454 FEValues<dim> fe_values(mapping,
455 fe,
456 quadrature_formula,
457 update_values | update_gradients | update_JxW_values);
458
459 const FEValuesExtractors::Vector velocities(0);
460 const FEValuesExtractors::Scalar pressure(dim);
461
462 const unsigned int n_q_points = quadrature_formula.size();
463
464 std::vector<Tensor<1, dim>> velocity(n_q_points);
465 std::vector<Tensor<1, dim>> pressure_gradients(n_q_points);
466
467 double pressure_power = 0.0;
468
469 for (const auto &cell : dof_handler.active_cell_iterators())
470 {
471 if (cell->is_locally_owned())
472 {
473 fe_values.reinit(cell);
474
475 fe_values[pressure].get_function_gradients(evaluation_point,
476 pressure_gradients);
477
478 fe_values[velocities].get_function_values(evaluation_point, velocity);
479
480 for (unsigned int q = 0; q < n_q_points; q++)
481 {
482 pressure_power +=
483 velocity[q] * pressure_gradients[q] * fe_values.JxW(q);
484 }
485 }
486 }
487
488 pressure_power /= GridTools::volume(dof_handler.get_triangulation(), mapping);
489
490 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
491 pressure_power = Utilities::MPI::sum(pressure_power, mpi_communicator);
492
493 return pressure_power;
494}
495
496template double
498 const DoFHandler<2> &dof_handler,
499 const GlobalVectorType &evaluation_point,
500 const Quadrature<2> &quadrature_formula,
501 const Mapping<2> &mapping);
502
503template double
505 const DoFHandler<3> &dof_handler,
506 const GlobalVectorType &evaluation_point,
507 const Quadrature<3> &quadrature_formula,
508 const Mapping<3> &mapping);
509
510template double
512 const DoFHandler<2> &dof_handler,
513 const GlobalBlockVectorType &evaluation_point,
514 const Quadrature<2> &quadrature_formula,
515 const Mapping<2> &mapping);
516
517template double
519 const DoFHandler<3> &dof_handler,
520 const GlobalBlockVectorType &evaluation_point,
521 const Quadrature<3> &quadrature_formula,
522 const Mapping<3> &mapping);
523
524#ifndef LETHE_USE_LDV
525template double
527 const DoFHandler<2> &dof_handler,
528 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
529 const Quadrature<2> &quadrature_formula,
530 const Mapping<2> &mapping);
531
532template double
534 const DoFHandler<3> &dof_handler,
535 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
536 const Quadrature<3> &quadrature_formula,
537 const Mapping<3> &mapping);
538#endif
539
540
541template <int dim, typename VectorType>
542double
544 const DoFHandler<dim> &dof_handler,
545 const VectorType &evaluation_point,
546 const Quadrature<dim> &quadrature_formula,
547 const Mapping<dim> &mapping,
548 const PhysicalPropertiesManager &properties_manager)
549{
550 const FESystem<dim, dim> fe = dof_handler.get_fe();
551 FEValues<dim> fe_values(mapping,
552 fe,
553 quadrature_formula,
554 update_gradients | update_JxW_values);
555
556 const FEValuesExtractors::Vector velocity(0);
557
558 const unsigned int n_q_points = quadrature_formula.size();
559
560 std::vector<Tensor<2, dim>> velocity_gradients(n_q_points);
561
562 const auto rheological_model = properties_manager.get_rheology();
563
564 double viscous_dissipation = 0;
565
566 for (const auto &cell : dof_handler.active_cell_iterators())
567 {
568 if (cell->is_locally_owned())
569 {
570 fe_values.reinit(cell);
571
572 fe_values[velocity].get_function_gradients(evaluation_point,
573 velocity_gradients);
574
575 for (unsigned int q = 0; q < n_q_points; q++)
576 {
577 Tensor<2, dim> shear_rate =
578 velocity_gradients[q] + transpose(velocity_gradients[q]);
579
580 const double shear_rate_magnitude =
582
583 std::map<field, double> field_values;
584 field_values[field::shear_rate] = shear_rate_magnitude;
585
586 const double kinematic_viscosity =
587 rheological_model->value(field_values);
588
589 // Equation is t_ij djui (Eq 11.2-1 of BSL 2nd edition)
590 viscous_dissipation +=
591 kinematic_viscosity *
592 scalar_product(shear_rate, transpose(velocity_gradients[q])) *
593 fe_values.JxW(q);
594 }
595 }
596 }
597
598 viscous_dissipation /=
599 GridTools::volume(dof_handler.get_triangulation(), mapping);
600
601 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
602 viscous_dissipation =
603 Utilities::MPI::sum(viscous_dissipation, mpi_communicator);
604 return viscous_dissipation;
605}
606
607template double
609 const DoFHandler<2> &dof_handler,
610 const GlobalVectorType &evaluation_point,
611 const Quadrature<2> &quadrature_formula,
612 const Mapping<2> &mapping,
613 const PhysicalPropertiesManager &properties_manager);
614
615template double
617 const DoFHandler<3> &dof_handler,
618 const GlobalVectorType &evaluation_point,
619 const Quadrature<3> &quadrature_formula,
620 const Mapping<3> &mapping,
621 const PhysicalPropertiesManager &properties_manager);
622
623template double
625 const DoFHandler<2> &dof_handler,
626 const GlobalBlockVectorType &evaluation_point,
627 const Quadrature<2> &quadrature_formula,
628 const Mapping<2> &mapping,
629 const PhysicalPropertiesManager &properties_manager);
630
631template double
633 const DoFHandler<3> &dof_handler,
634 const GlobalBlockVectorType &evaluation_point,
635 const Quadrature<3> &quadrature_formula,
636 const Mapping<3> &mapping,
637 const PhysicalPropertiesManager &properties_manager);
638
639#ifndef LETHE_USE_LDV
640template double
642 const DoFHandler<2> &dof_handler,
643 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
644 const Quadrature<2> &quadrature_formula,
645 const Mapping<2> &mapping,
646 const PhysicalPropertiesManager &properties_manager);
647
648template double
650 const DoFHandler<3> &dof_handler,
651 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
652 const Quadrature<3> &quadrature_formula,
653 const Mapping<3> &mapping,
654 const PhysicalPropertiesManager &properties_manager);
655#endif
656
657
658template <int dim, typename VectorType>
659double
660calculate_kinetic_energy(const DoFHandler<dim> &dof_handler,
661 const VectorType &evaluation_point,
662 const Quadrature<dim> &quadrature_formula,
663 const Mapping<dim> &mapping)
664{
665 const FESystem<dim, dim> fe = dof_handler.get_fe();
666 FEValues<dim> fe_values(mapping,
667 fe,
668 quadrature_formula,
669 update_values | update_quadrature_points |
670 update_JxW_values);
671
672 const FEValuesExtractors::Vector velocities(0);
673 const unsigned int n_q_points = quadrature_formula.size();
674
675 std::vector<Tensor<1, dim>> local_velocity_values(n_q_points);
676 double domain_volume =
677 GridTools::volume(dof_handler.get_triangulation(), mapping);
678 // double domain_volume =
679 // GridTools::volume(dof_handler.get_triangulation(),*mapping);
680
681 double KEU = 0.0;
682
683 for (const auto &cell : dof_handler.active_cell_iterators())
684 {
685 if (cell->is_locally_owned())
686 {
687 fe_values.reinit(cell);
688 fe_values[velocities].get_function_values(evaluation_point,
689 local_velocity_values);
690
691 for (unsigned int q = 0; q < n_q_points; q++)
692 {
693 double ux_sim = local_velocity_values[q][0];
694 double uy_sim = local_velocity_values[q][1];
695
696 KEU += 0.5 * ((ux_sim) * (ux_sim)*fe_values.JxW(q));
697 KEU += 0.5 * ((uy_sim) * (uy_sim)*fe_values.JxW(q));
698 if (dim == 3)
699 {
700 double uz_sim = local_velocity_values[q][2];
701 KEU += 0.5 * ((uz_sim) * (uz_sim)*fe_values.JxW(q));
702 }
703 }
704 }
705 }
706 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
707 KEU = Utilities::MPI::sum(KEU / domain_volume, mpi_communicator);
708 return (KEU);
709}
710
711template double
713 const DoFHandler<2> &dof_handler,
714 const GlobalVectorType &evaluation_point,
715 const Quadrature<2> &quadrature_formula,
716 const Mapping<2> &mapping);
717
718template double
720 const DoFHandler<3> &dof_handler,
721 const GlobalVectorType &evaluation_point,
722 const Quadrature<3> &quadrature_formula,
723 const Mapping<3> &mapping);
724
725template double
727 const DoFHandler<2> &dof_handler,
728 const GlobalBlockVectorType &evaluation_point,
729 const Quadrature<2> &quadrature_formula,
730 const Mapping<2> &mapping);
731
732template double
734 const DoFHandler<3> &dof_handler,
735 const GlobalBlockVectorType &evaluation_point,
736 const Quadrature<3> &quadrature_formula,
737 const Mapping<3> &mapping);
738
739#ifndef LETHE_USE_LDV
740template double
742 const DoFHandler<2> &dof_handler,
743 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
744 const Quadrature<2> &quadrature_formula,
745 const Mapping<2> &mapping);
746
747template double
749 const DoFHandler<3> &dof_handler,
750 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
751 const Quadrature<3> &quadrature_formula,
752 const Mapping<3> &mapping);
753#endif
754
755template <int dim, typename VectorType>
756double
758 const DoFHandler<dim> &dof_handler,
759 const VectorType &evaluation_point,
760 const Quadrature<dim> &quadrature_formula,
761 const Mapping<dim> &mapping,
762 const PhysicalPropertiesManager &properties_manager)
763{
764 double integral_viscosity_x_shear_rate = 0;
765 double integral_shear_rate = 0;
766 double shear_rate_magnitude;
767 Tensor<2, dim> shear_rate;
768 double kinematic_viscosity;
769 const auto rheological_model = properties_manager.get_rheology();
770
771 const FESystem<dim, dim> fe = dof_handler.get_fe();
772 FEValues<dim> fe_values(mapping,
773 fe,
774 quadrature_formula,
775 update_gradients | update_JxW_values);
776
777 const FEValuesExtractors::Vector velocity(0);
778
779 const unsigned int n_q_points = quadrature_formula.size();
780
781 std::vector<Tensor<2, dim>> velocity_gradients(n_q_points);
782
783 for (const auto &cell : dof_handler.active_cell_iterators())
784 {
785 if (cell->is_locally_owned())
786 {
787 fe_values.reinit(cell);
788
789 fe_values[velocity].get_function_gradients(evaluation_point,
790 velocity_gradients);
791
792 for (unsigned int q = 0; q < n_q_points; q++)
793 {
794 shear_rate =
795 velocity_gradients[q] + transpose(velocity_gradients[q]);
796
797 double shear_rate_x_velocity_gradient = 0;
798 for (int i = 0; i < dim; ++i)
799 {
800 for (int j = 0; j < dim; ++j)
801 {
802 shear_rate_x_velocity_gradient +=
803 shear_rate[i][j] * velocity_gradients[q][j][i];
804 }
805 }
806
807 shear_rate_magnitude = calculate_shear_rate_magnitude(shear_rate);
808
809 std::map<field, double> field_values;
810 field_values[field::shear_rate] = shear_rate_magnitude;
811
812 kinematic_viscosity = rheological_model->value(field_values);
813
814 integral_viscosity_x_shear_rate +=
815 kinematic_viscosity * shear_rate_x_velocity_gradient *
816 fe_values.JxW(q);
817 integral_shear_rate +=
818 shear_rate_x_velocity_gradient * fe_values.JxW(q);
819 }
820 }
821 }
822 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
823 integral_viscosity_x_shear_rate =
824 Utilities::MPI::sum(integral_viscosity_x_shear_rate, mpi_communicator);
825 integral_shear_rate =
826 Utilities::MPI::sum(integral_shear_rate, mpi_communicator);
827 return integral_viscosity_x_shear_rate / integral_shear_rate;
828}
829
830template double
832 const DoFHandler<2> &dof_handler,
833 const GlobalVectorType &evaluation_point,
834 const Quadrature<2> &quadrature_formula,
835 const Mapping<2> &mapping,
836 const PhysicalPropertiesManager &properties_manager);
837
838template double
840 const DoFHandler<3> &dof_handler,
841 const GlobalVectorType &evaluation_point,
842 const Quadrature<3> &quadrature_formula,
843 const Mapping<3> &mapping,
844 const PhysicalPropertiesManager &properties_manager);
845
846template double
848 const DoFHandler<2> &dof_handler,
849 const GlobalBlockVectorType &evaluation_point,
850 const Quadrature<2> &quadrature_formula,
851 const Mapping<2> &mapping,
852 const PhysicalPropertiesManager &properties_manager);
853
854template double
856 const DoFHandler<3> &dof_handler,
857 const GlobalBlockVectorType &evaluation_point,
858 const Quadrature<3> &quadrature_formula,
859 const Mapping<3> &mapping,
860 const PhysicalPropertiesManager &properties_manager);
861
862#ifndef LETHE_USE_LDV
863template double
865 const DoFHandler<2> &dof_handler,
866 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
867 const Quadrature<2> &quadrature_formula,
868 const Mapping<2> &mapping,
869 const PhysicalPropertiesManager &properties_manager);
870
871template double
873 const DoFHandler<3> &dof_handler,
874 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
875 const Quadrature<3> &quadrature_formula,
876 const Mapping<3> &mapping,
877 const PhysicalPropertiesManager &properties_manager);
878#endif
879
880template <int dim, typename VectorType>
881std::vector<std::map<types::boundary_id, Tensor<1, dim>>>
882calculate_forces(const DoFHandler<dim> &dof_handler,
883 const VectorType &evaluation_point,
884 const PhysicalPropertiesManager &properties_manager,
886 &boundary_conditions,
887 const Quadrature<dim - 1> &face_quadrature_formula,
888 const Mapping<dim> &mapping)
889{
890 const FESystem<dim, dim> fe = dof_handler.get_fe();
891
892 // Rheological model for viscosity properties
893 double kinematic_viscosity;
894 const auto rheological_model = properties_manager.get_rheology();
895
896
897 const unsigned int n_q_points = face_quadrature_formula.size();
898 const FEValuesExtractors::Vector velocities(0);
899 const FEValuesExtractors::Scalar pressure(dim);
900 std::vector<double> pressure_values(n_q_points);
901 std::vector<Tensor<2, dim>> velocity_gradients(n_q_points);
902 Tensor<1, dim> normal_vector;
903 Tensor<2, dim> shear_rate;
904 Tensor<2, dim> fluid_stress;
905 Tensor<2, dim> fluid_viscous_stress;
906 Tensor<2, dim> fluid_pressure;
907
908 std::map<types::boundary_id, Tensor<1, dim>> viscous_force_map;
909 std::map<types::boundary_id, Tensor<1, dim>> pressure_force_map;
910 std::map<types::boundary_id, Tensor<1, dim>> force_map;
911
912 FEFaceValues<dim> fe_face_values(mapping,
913 fe,
914 face_quadrature_formula,
915 update_values | update_quadrature_points |
916 update_gradients | update_JxW_values |
917 update_normal_vectors);
918 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
919
920 for (const auto &cell : dof_handler.active_cell_iterators())
921 {
922 if (cell->is_locally_owned())
923 {
924 if (cell->at_boundary())
925 {
926 for (const auto face : cell->face_indices())
927 {
928 if (cell->face(face)->at_boundary())
929 {
930 const auto boundary_id = cell->face(face)->boundary_id();
931
932 fe_face_values.reinit(cell, face);
933
934 std::vector<Point<dim>> q_points =
935 fe_face_values.get_quadrature_points();
936 fe_face_values[velocities].get_function_gradients(
937 evaluation_point, velocity_gradients);
938 fe_face_values[pressure].get_function_values(
939 evaluation_point, pressure_values);
940 for (unsigned int q = 0; q < n_q_points; q++)
941 {
942 normal_vector = -fe_face_values.normal_vector(q);
943 for (int d = 0; d < dim; ++d)
944 {
945 fluid_pressure[d][d] = pressure_values[q];
946 }
947 shear_rate = velocity_gradients[q] +
948 transpose(velocity_gradients[q]);
949
950 const double shear_rate_magnitude =
952
953 std::map<field, double> field_values;
954 field_values[field::shear_rate] =
955 shear_rate_magnitude;
956
957 kinematic_viscosity =
958 rheological_model->value(field_values);
959 fluid_viscous_stress =
960 -kinematic_viscosity * shear_rate;
961 fluid_stress = -fluid_viscous_stress - fluid_pressure;
962
963 viscous_force_map[boundary_id] -=
964 fluid_viscous_stress * normal_vector *
965 fe_face_values.JxW(q);
966 pressure_force_map[boundary_id] -=
967 fluid_pressure * normal_vector *
968 fe_face_values.JxW(q);
969 force_map[boundary_id] += fluid_stress *
970 normal_vector *
971 fe_face_values.JxW(q);
972 }
973 }
974 }
975 }
976 }
977 }
978
979 for (auto const &[id, type] : boundary_conditions.type)
980 {
981 viscous_force_map[id] =
982 Utilities::MPI::sum(viscous_force_map[id], mpi_communicator);
983 pressure_force_map[id] =
984 Utilities::MPI::sum(pressure_force_map[id], mpi_communicator);
985 force_map[id] = Utilities::MPI::sum(force_map[id], mpi_communicator);
986 }
987 std::vector<std::map<types::boundary_id, Tensor<1, dim>>> forces{
988 force_map, viscous_force_map, pressure_force_map};
989 return forces;
990}
991
992template std::vector<std::map<types::boundary_id, Tensor<1, 2>>>
994 const DoFHandler<2> &dof_handler,
995 const GlobalVectorType &evaluation_point,
996 const PhysicalPropertiesManager &properties_manager,
998 &boundary_conditions,
999 const Quadrature<1> &face_quadrature_formula,
1000 const Mapping<2> &mapping);
1001template std::vector<std::map<types::boundary_id, Tensor<1, 3>>>
1003 const DoFHandler<3> &dof_handler,
1004 const GlobalVectorType &evaluation_point,
1005 const PhysicalPropertiesManager &properties_manager,
1007 &boundary_conditions,
1008 const Quadrature<2> &face_quadrature_formula,
1009 const Mapping<3> &mapping);
1010
1011template std::vector<std::map<types::boundary_id, Tensor<1, 2>>>
1013 const DoFHandler<2> &dof_handler,
1014 const GlobalBlockVectorType &evaluation_point,
1015 const PhysicalPropertiesManager &properties_manager,
1017 &boundary_conditions,
1018 const Quadrature<1> &face_quadrature_formula,
1019 const Mapping<2> &mapping);
1020
1021template std::vector<std::map<types::boundary_id, Tensor<1, 3>>>
1023 const DoFHandler<3> &dof_handler,
1024 const GlobalBlockVectorType &evaluation_point,
1025 const PhysicalPropertiesManager &properties_manager,
1027 &boundary_conditions,
1028 const Quadrature<2> &face_quadrature_formula,
1029 const Mapping<3> &mapping);
1030
1031#ifndef LETHE_USE_LDV
1032template std::vector<std::map<types::boundary_id, Tensor<1, 2>>>
1034 const DoFHandler<2> &dof_handler,
1035 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
1036 const PhysicalPropertiesManager &properties_manager,
1038 &boundary_conditions,
1039 const Quadrature<1> &face_quadrature_formula,
1040 const Mapping<2> &mapping);
1041
1042template std::vector<std::map<types::boundary_id, Tensor<1, 3>>>
1044 const DoFHandler<3> &dof_handler,
1045 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
1046 const PhysicalPropertiesManager &properties_manager,
1048 &boundary_conditions,
1049 const Quadrature<2> &face_quadrature_formula,
1050 const Mapping<3> &mapping);
1051#endif
1052
1053template <int dim, typename VectorType>
1054std::map<types::boundary_id, Tensor<1, 3>>
1055calculate_torques(const DoFHandler<dim> &dof_handler,
1056 const VectorType &evaluation_point,
1057 const PhysicalPropertiesManager &properties_manager,
1059 &boundary_conditions,
1060 const Quadrature<dim - 1> &face_quadrature_formula,
1061 const Mapping<dim> &mapping)
1062{
1063 const FESystem<dim, dim> fe = dof_handler.get_fe();
1064
1065 // Rheological model for viscosity properties
1066 double kinematic_viscosity;
1067 const auto rheological_model = properties_manager.get_rheology();
1068
1069
1070 const unsigned int n_q_points = face_quadrature_formula.size();
1071 const FEValuesExtractors::Vector velocities(0);
1072 const FEValuesExtractors::Scalar pressure(dim);
1073 std::vector<double> pressure_values(n_q_points);
1074 std::vector<Tensor<2, dim>> velocity_gradients(n_q_points);
1075 Tensor<1, dim> normal_vector;
1076 Tensor<2, dim> shear_rate;
1077 Tensor<2, dim> fluid_stress;
1078 Tensor<2, dim> fluid_pressure;
1079
1080
1081 std::map<types::boundary_id, Tensor<1, 3>> torque_map;
1082
1083 FEFaceValues<dim> fe_face_values(mapping,
1084 fe,
1085 face_quadrature_formula,
1086 update_values | update_quadrature_points |
1087 update_gradients | update_JxW_values |
1088 update_normal_vectors);
1089 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
1090
1091 for (const auto &cell : dof_handler.active_cell_iterators())
1092 {
1093 if (cell->is_locally_owned())
1094 {
1095 for (const auto face : cell->face_indices())
1096 {
1097 if (cell->face(face)->at_boundary())
1098 {
1099 fe_face_values.reinit(cell, face);
1100 unsigned int boundary_id = cell->face(face)->boundary_id();
1101
1102 Point<dim> center_of_rotation =
1103 boundary_conditions.navier_stokes_functions.at(boundary_id)
1104 ->center_of_rotation;
1105
1106 std::vector<Point<dim>> q_points =
1107 fe_face_values.get_quadrature_points();
1108 fe_face_values[velocities].get_function_gradients(
1109 evaluation_point, velocity_gradients);
1110 fe_face_values[pressure].get_function_values(evaluation_point,
1111 pressure_values);
1112
1113 for (unsigned int q = 0; q < n_q_points; q++)
1114 {
1115 normal_vector = -fe_face_values.normal_vector(q);
1116 for (int d = 0; d < dim; ++d)
1117 {
1118 fluid_pressure[d][d] = pressure_values[q];
1119 }
1120 shear_rate = velocity_gradients[q] +
1121 transpose(velocity_gradients[q]);
1122 const double shear_rate_magnitude =
1124
1125 std::map<field, double> field_values;
1126 field_values[field::shear_rate] = shear_rate_magnitude;
1127
1128 kinematic_viscosity =
1129 rheological_model->value(field_values);
1130
1131 fluid_stress =
1132 kinematic_viscosity * shear_rate - fluid_pressure;
1133 auto force =
1134 fluid_stress * normal_vector * fe_face_values.JxW(q);
1135
1136 auto distance = q_points[q] - center_of_rotation;
1137 if (dim == 2)
1138 {
1139 torque_map[boundary_id][0] = 0.;
1140 torque_map[boundary_id][1] = 0.;
1141 torque_map[boundary_id][2] +=
1142 distance[0] * force[1] - distance[1] * force[0];
1143 }
1144 else if (dim == 3)
1145 {
1146 torque_map[boundary_id][0] +=
1147 distance[1] * force[2] - distance[2] * force[1];
1148 torque_map[boundary_id][1] +=
1149 distance[2] * force[0] - distance[0] * force[2];
1150 torque_map[boundary_id][2] +=
1151 distance[0] * force[1] - distance[1] * force[0];
1152 }
1153 }
1154 }
1155 }
1156 }
1157 }
1158 for (auto const &[id, type] : boundary_conditions.type)
1159 {
1160 torque_map[id] = Utilities::MPI::sum(torque_map[id], mpi_communicator);
1161 }
1162
1163 return torque_map;
1164}
1165
1166template std::map<types::boundary_id, Tensor<1, 3>>
1168 const DoFHandler<2> &dof_handler,
1169 const GlobalVectorType &evaluation_point,
1170 const PhysicalPropertiesManager &properties_manager,
1172 &boundary_conditions,
1173 const Quadrature<1> &face_quadrature_formula,
1174 const Mapping<2> &mapping);
1175
1176template std::map<types::boundary_id, Tensor<1, 3>>
1178 const DoFHandler<3> &dof_handler,
1179 const GlobalVectorType &evaluation_point,
1180 const PhysicalPropertiesManager &properties_manager,
1182 &boundary_conditions,
1183 const Quadrature<2> &face_quadrature_formula,
1184 const Mapping<3> &mapping);
1185
1186template std::map<types::boundary_id, Tensor<1, 3>>
1188 const DoFHandler<2> &dof_handler,
1189 const GlobalBlockVectorType &evaluation_point,
1190 const PhysicalPropertiesManager &properties_manager,
1192 &boundary_conditions,
1193 const Quadrature<1> &face_quadrature_formula,
1194 const Mapping<2> &mapping);
1195
1196template std::map<types::boundary_id, Tensor<1, 3>>
1198 const DoFHandler<3> &dof_handler,
1199 const GlobalBlockVectorType &evaluation_point,
1200 const PhysicalPropertiesManager &properties_manager,
1202 &boundary_conditions,
1203 const Quadrature<2> &face_quadrature_formula,
1204 const Mapping<3> &mapping);
1205
1206#ifndef LETHE_USE_LDV
1207template std::map<types::boundary_id, Tensor<1, 3>>
1209 const DoFHandler<2> &dof_handler,
1210 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
1211 const PhysicalPropertiesManager &properties_manager,
1213 &boundary_conditions,
1214 const Quadrature<1> &face_quadrature_formula,
1215 const Mapping<2> &mapping);
1216
1217template std::map<types::boundary_id, Tensor<1, 3>>
1219 const DoFHandler<3> &dof_handler,
1220 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
1221 const PhysicalPropertiesManager &properties_manager,
1223 &boundary_conditions,
1224 const Quadrature<2> &face_quadrature_formula,
1225 const Mapping<3> &mapping);
1226#endif
1227
1228// Find the l2 norm of the error between the finite element sol'n and the exact
1229// sol'n for both the velocity and the pressure
1230// Mean pressure is removed from both the analytical and the simulation solution
1231template <int dim, typename VectorType>
1232std::pair<double, double>
1233calculate_L2_error(const DoFHandler<dim> &dof_handler,
1234 const VectorType &evaluation_point,
1235 const Function<dim> *exact_solution,
1236 const Quadrature<dim> &quadrature_formula,
1237 const Mapping<dim> &mapping)
1238{
1239 const FESystem<dim, dim> fe = dof_handler.get_fe();
1240 FEValues<dim> fe_values(mapping,
1241 fe,
1242 quadrature_formula,
1243 update_values | update_gradients |
1244 update_quadrature_points | update_JxW_values);
1245
1246 const FEValuesExtractors::Vector velocities(0);
1247 const FEValuesExtractors::Scalar pressure(dim);
1248 const unsigned int n_q_points = quadrature_formula.size();
1249
1250 std::vector<Vector<double>> q_exactSol(n_q_points, Vector<double>(dim + 1));
1251
1252 std::vector<Tensor<1, dim>> local_velocity_values(n_q_points);
1253 std::vector<double> local_pressure_values(n_q_points);
1254
1255 double pressure_integral = 0;
1256 double exact_pressure_integral = 0;
1257
1258 // loop over elements to calculate average pressure
1259 for (const auto &cell : dof_handler.active_cell_iterators())
1260 {
1261 if (cell->is_locally_owned())
1262 {
1263 fe_values.reinit(cell);
1264
1265 fe_values[pressure].get_function_values(evaluation_point,
1266 local_pressure_values);
1267 // Get the exact solution at all gauss points
1268 exact_solution->vector_value_list(fe_values.get_quadrature_points(),
1269 q_exactSol);
1270
1271 for (unsigned int q = 0; q < n_q_points; q++)
1272 {
1273 pressure_integral += local_pressure_values[q] * fe_values.JxW(q);
1274 exact_pressure_integral += q_exactSol[q][dim] * fe_values.JxW(q);
1275 }
1276 }
1277 }
1278 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
1279 pressure_integral = Utilities::MPI::sum(pressure_integral, mpi_communicator);
1280 exact_pressure_integral =
1281 Utilities::MPI::sum(exact_pressure_integral, mpi_communicator);
1282
1283 // double global_volume =
1284 // GridTools::volume(dof_handler.get_triangulation(),*mapping);
1285 double global_volume =
1286 GridTools::volume(dof_handler.get_triangulation(), mapping);
1287 double average_pressure = pressure_integral / global_volume;
1288 double average_exact_pressure = exact_pressure_integral / global_volume;
1289
1290
1291 double l2errorU = 0.;
1292 double l2errorP = 0.;
1293
1294 for (const auto &cell : dof_handler.active_cell_iterators())
1295 {
1296 if (cell->is_locally_owned())
1297 {
1298 fe_values.reinit(cell);
1299 fe_values[velocities].get_function_values(evaluation_point,
1300 local_velocity_values);
1301 fe_values[pressure].get_function_values(evaluation_point,
1302 local_pressure_values);
1303
1304 // Get the exact solution at all gauss points
1305 exact_solution->vector_value_list(fe_values.get_quadrature_points(),
1306 q_exactSol);
1307
1308 for (unsigned int q = 0; q < n_q_points; q++)
1309 {
1310 // Find the values of x and u_h (the finite element solution) at
1311 // the quadrature points
1312 double ux_sim = local_velocity_values[q][0];
1313 double ux_exact = q_exactSol[q][0];
1314
1315 double uy_sim = local_velocity_values[q][1];
1316 double uy_exact = q_exactSol[q][1];
1317
1318 l2errorU +=
1319 (ux_sim - ux_exact) * (ux_sim - ux_exact) * fe_values.JxW(q);
1320 l2errorU +=
1321 (uy_sim - uy_exact) * (uy_sim - uy_exact) * fe_values.JxW(q);
1322
1323 if (dim == 3)
1324 {
1325 double uz_sim = local_velocity_values[q][2];
1326 double uz_exact = q_exactSol[q][2];
1327 l2errorU += (uz_sim - uz_exact) * (uz_sim - uz_exact) *
1328 fe_values.JxW(q);
1329 }
1330
1331 double p_sim = local_pressure_values[q] - average_pressure;
1332 double p_exact = q_exactSol[q][dim] - average_exact_pressure;
1333 l2errorP +=
1334 (p_sim - p_exact) * (p_sim - p_exact) * fe_values.JxW(q);
1335 }
1336 }
1337 }
1338 l2errorU = Utilities::MPI::sum(l2errorU, mpi_communicator);
1339 l2errorP = Utilities::MPI::sum(l2errorP, mpi_communicator);
1340
1341 return std::make_pair(std::sqrt(l2errorU), std::sqrt(l2errorP));
1342}
1343
1344template std::pair<double, double>
1345calculate_L2_error(const DoFHandler<2> &dof_handler,
1346 const GlobalVectorType &present_solution,
1347 const Function<2> *l_exact_solution,
1348 const Quadrature<2> &quadrature_formula,
1349 const Mapping<2> &mapping);
1350
1351template std::pair<double, double>
1352calculate_L2_error(const DoFHandler<3> &dof_handler,
1353 const GlobalVectorType &present_solution,
1354 const Function<3> *l_exact_solution,
1355 const Quadrature<3> &quadrature_formula,
1356 const Mapping<3> &mapping);
1357
1358template std::pair<double, double>
1359calculate_L2_error(const DoFHandler<2> &dof_handler,
1360 const GlobalBlockVectorType &present_solution,
1361 const Function<2> *l_exact_solution,
1362 const Quadrature<2> &quadrature_formula,
1363 const Mapping<2> &mapping);
1364
1365template std::pair<double, double>
1366calculate_L2_error(const DoFHandler<3> &dof_handler,
1367 const GlobalBlockVectorType &present_solution,
1368 const Function<3> *l_exact_solution,
1369 const Quadrature<3> &quadrature_formula,
1370 const Mapping<3> &mapping);
1371
1372#ifndef LETHE_USE_LDV
1373template std::pair<double, double>
1375 const DoFHandler<2> &dof_handler,
1376 const LinearAlgebra::distributed::Vector<double> &present_solution,
1377 const Function<2> *l_exact_solution,
1378 const Quadrature<2> &quadrature_formula,
1379 const Mapping<2> &mapping);
1380
1381template std::pair<double, double>
1383 const DoFHandler<3> &dof_handler,
1384 const LinearAlgebra::distributed::Vector<double> &present_solution,
1385 const Function<3> *l_exact_solution,
1386 const Quadrature<3> &quadrature_formula,
1387 const Mapping<3> &mapping);
1388#endif
1389
1390template <int dim, typename VectorType>
1391std::pair<double, double>
1392calculate_flow_rate(const DoFHandler<dim> &dof_handler,
1393 const VectorType &present_solution,
1394 const unsigned int &boundary_id,
1395 const Quadrature<dim - 1> &face_quadrature_formula,
1396 const Mapping<dim> &mapping)
1397{
1398 const FESystem<dim, dim> fe = dof_handler.get_fe();
1399
1400 const unsigned int n_q_points = face_quadrature_formula.size();
1401 const FEValuesExtractors::Vector velocities(0);
1402 std::vector<Tensor<1, dim>> velocity_values(n_q_points);
1403 Tensor<1, dim> normal_vector;
1404
1405 FEFaceValues<dim> fe_face_values(mapping,
1406 fe,
1407 face_quadrature_formula,
1408 update_values | update_quadrature_points |
1409 update_JxW_values | update_normal_vectors);
1410
1411 double flow_rate = 0;
1412 double area = 0;
1413
1414 // Calculating area and volumetric flow rate at the boundary
1415 for (const auto &cell : dof_handler.active_cell_iterators())
1416 {
1417 if (cell->is_locally_owned() && cell->at_boundary())
1418 {
1419 for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell;
1420 face++)
1421 {
1422 if (cell->face(face)->at_boundary())
1423 {
1424 fe_face_values.reinit(cell, face);
1425 if (cell->face(face)->boundary_id() == boundary_id)
1426 {
1427 for (unsigned int q = 0; q < n_q_points; q++)
1428 {
1429 area += fe_face_values.JxW(q);
1430 normal_vector = fe_face_values.normal_vector(q);
1431 fe_face_values[velocities].get_function_values(
1432 present_solution, velocity_values);
1433 flow_rate += velocity_values[q] * normal_vector *
1434 fe_face_values.JxW(q);
1435 }
1436 }
1437 }
1438 }
1439 }
1440 }
1441
1442 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
1443 area = Utilities::MPI::sum(area, mpi_communicator);
1444 flow_rate = Utilities::MPI::sum(flow_rate, mpi_communicator);
1445
1446 return std::make_pair(flow_rate, area);
1447}
1448
1449template std::pair<double, double>
1450calculate_flow_rate(const DoFHandler<2> &dof_handler,
1451 const GlobalVectorType &present_solution,
1452 const unsigned int &boundary_id,
1453 const Quadrature<1> &face_quadrature_formula,
1454 const Mapping<2> &mapping);
1455
1456template std::pair<double, double>
1457calculate_flow_rate(const DoFHandler<3> &dof_handler,
1458 const GlobalVectorType &present_solution,
1459 const unsigned int &boundary_id,
1460 const Quadrature<2> &face_quadrature_formula,
1461 const Mapping<3> &mapping);
1462
1463template std::pair<double, double>
1464calculate_flow_rate(const DoFHandler<2> &dof_handler,
1465 const GlobalBlockVectorType &present_solution,
1466 const unsigned int &boundary_id,
1467 const Quadrature<1> &face_quadrature_formula,
1468 const Mapping<2> &mapping);
1469
1470template std::pair<double, double>
1471calculate_flow_rate(const DoFHandler<3> &dof_handler,
1472 const GlobalBlockVectorType &present_solution,
1473 const unsigned int &boundary_id,
1474 const Quadrature<2> &face_quadrature_formula,
1475 const Mapping<3> &mapping);
1476
1477#ifndef LETHE_USE_LDV
1478template std::pair<double, double>
1480 const DoFHandler<2> &dof_handler,
1481 const LinearAlgebra::distributed::Vector<double> &present_solution,
1482 const unsigned int &boundary_id,
1483 const Quadrature<1> &face_quadrature_formula,
1484 const Mapping<2> &mapping);
1485
1486template std::pair<double, double>
1488 const DoFHandler<3> &dof_handler,
1489 const LinearAlgebra::distributed::Vector<double> &present_solution,
1490 const unsigned int &boundary_id,
1491 const Quadrature<2> &face_quadrature_formula,
1492 const Mapping<3> &mapping);
1493#endif
1494
1495template <int dim, typename VectorType>
1496double
1497calculate_average_velocity(const DoFHandler<dim> &dof_handler,
1498 const VectorType &present_solution,
1499 const unsigned int &boundary_id,
1500 const Quadrature<dim - 1> &face_quadrature_formula,
1501 const Mapping<dim> &mapping)
1502{
1503 std::pair<double, double> flow_rate_and_area =
1504 calculate_flow_rate(dof_handler,
1505 present_solution,
1506 boundary_id,
1507 face_quadrature_formula,
1508 mapping);
1509
1510 // In dynamic flow control, the flow rate is negative if the velocity is
1511 // positive when calculated at inlet boundary because of the normal vector
1512 // direction. Hence, we need to invert the sign to get the average velocity.
1513 return -flow_rate_and_area.first / flow_rate_and_area.second;
1514}
1515
1516template double
1517calculate_average_velocity(const DoFHandler<2> &dof_handler,
1518 const GlobalVectorType &present_solution,
1519 const unsigned int &boundary_id,
1520 const Quadrature<1> &face_quadrature_formula,
1521 const Mapping<2> &mapping);
1522
1523template double
1524calculate_average_velocity(const DoFHandler<3> &dof_handler,
1525 const GlobalVectorType &present_solution,
1526 const unsigned int &boundary_id,
1527 const Quadrature<2> &face_quadrature_formula,
1528 const Mapping<3> &mapping);
1529
1530template double
1531calculate_average_velocity(const DoFHandler<2> &dof_handler,
1532 const GlobalBlockVectorType &present_solution,
1533 const unsigned int &boundary_id,
1534 const Quadrature<1> &face_quadrature_formula,
1535 const Mapping<2> &mapping);
1536
1537template double
1538calculate_average_velocity(const DoFHandler<3> &dof_handler,
1539 const GlobalBlockVectorType &present_solution,
1540 const unsigned int &boundary_id,
1541 const Quadrature<2> &face_quadrature_formula,
1542 const Mapping<3> &mapping);
1543
1544#ifndef LETHE_USE_LDV
1545template double
1547 const DoFHandler<2> &dof_handler,
1548 const LinearAlgebra::distributed::Vector<double> &present_solution,
1549 const unsigned int &boundary_id,
1550 const Quadrature<1> &face_quadrature_formula,
1551 const Mapping<2> &mapping);
1552
1553template double
1555 const DoFHandler<3> &dof_handler,
1556 const LinearAlgebra::distributed::Vector<double> &present_solution,
1557 const unsigned int &boundary_id,
1558 const Quadrature<2> &face_quadrature_formula,
1559 const Mapping<3> &mapping);
1560#endif
1561
1562template <int dim, typename VectorType>
1563double
1564calculate_average_velocity(const DoFHandler<dim> &dof_handler,
1565 const DoFHandler<dim> &void_fraction_dof_handler,
1566 const VectorType &present_solution,
1567 const VectorType &present_void_fraction_solution,
1568 const unsigned int &flow_direction,
1569 const Quadrature<dim> &quadrature_formula,
1570 const Mapping<dim> &mapping)
1571{
1572 // Set up for velocity fe values
1573 const auto &tria = dof_handler.get_triangulation();
1574 const FESystem<dim, dim> fe = dof_handler.get_fe();
1575 const unsigned int n_q_points = quadrature_formula.size();
1576 const FEValuesExtractors::Vector velocities(0);
1577 std::vector<Tensor<1, dim>> velocity_values(n_q_points);
1578
1579 FEValues<dim> fe_values(mapping,
1580 fe,
1581 quadrature_formula,
1582 update_values | update_quadrature_points |
1583 update_JxW_values);
1584
1585 // Set up for void fraction fe values
1586 const FESystem<dim, dim> fe_void_fraction =
1587 void_fraction_dof_handler.get_fe();
1588 const FEValuesExtractors::Scalar void_fraction(0);
1589 std::vector<double> void_fraction_values(n_q_points);
1590
1591 FEValues<dim> fe_vf_values(mapping,
1592 fe_void_fraction,
1593 quadrature_formula,
1594 update_values | update_quadrature_points);
1595
1596 // Initialize variables for summation
1597 double average_velocity = 0;
1598 double volume = 0;
1599
1600 for (const auto &cell : dof_handler.active_cell_iterators())
1601 {
1602 if (cell->is_locally_owned())
1603 {
1604 fe_values.reinit(cell);
1605
1606 typename DoFHandler<dim>::active_cell_iterator vf_cell(
1607 &tria, cell->level(), cell->index(), &void_fraction_dof_handler);
1608 fe_vf_values.reinit(vf_cell);
1609
1610 for (unsigned int q = 0; q < n_q_points; q++)
1611 {
1612 // Get the void fraction at the quadrature point
1613 fe_vf_values[void_fraction].get_function_values(
1614 present_void_fraction_solution, void_fraction_values);
1615
1616 // Add the area of the face on boundary
1617 // weighted by void fraction
1618 volume += void_fraction_values[q] * fe_values.JxW(q);
1619
1620 // Add the flow rate at the face on boundary weighted
1621 // by void fraction
1622 fe_values[velocities].get_function_values(present_solution,
1623 velocity_values);
1624 average_velocity += void_fraction_values[q] *
1625 velocity_values[q][flow_direction] *
1626 fe_values.JxW(q);
1627 }
1628 }
1629 }
1630
1631 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
1632 average_velocity = Utilities::MPI::sum(average_velocity, mpi_communicator);
1633 volume = Utilities::MPI::sum(volume, mpi_communicator);
1634
1635 // Calculate the average velocity
1636 average_velocity /= volume;
1637
1638 return average_velocity;
1639}
1640
1641template double
1643 const DoFHandler<2> &dof_handler,
1644 const DoFHandler<2> &void_fraction_dof_handler,
1645 const GlobalVectorType &present_solution,
1646 const GlobalVectorType &present_void_fraction_solution,
1647 const unsigned int &flow_direction,
1648 const Quadrature<2> &quadrature_formula,
1649 const Mapping<2> &mapping);
1650
1651template double
1653 const DoFHandler<3> &dof_handler,
1654 const DoFHandler<3> &void_fraction_dof_handler,
1655 const GlobalVectorType &present_solution,
1656 const GlobalVectorType &present_void_fraction_solution,
1657 const unsigned int &flow_direction,
1658 const Quadrature<3> &quadrature_formula,
1659 const Mapping<3> &mapping);
1660
1661#ifndef LETHE_USE_LDV
1662template double
1664 const DoFHandler<2> &dof_handler,
1665 const DoFHandler<2> &void_fraction_dof_handler,
1666 const LinearAlgebra::distributed::Vector<double> &present_solution,
1667 const LinearAlgebra::distributed::Vector<double>
1668 &present_void_fraction_solution,
1669 const unsigned int &flow_direction,
1670 const Quadrature<2> &quadrature_formula,
1671 const Mapping<2> &mapping);
1672
1673template double
1675 const DoFHandler<3> &dof_handler,
1676 const DoFHandler<3> &void_fraction_dof_handler,
1677 const LinearAlgebra::distributed::Vector<double> &present_solution,
1678 const LinearAlgebra::distributed::Vector<double>
1679 &present_void_fraction_solution,
1680 const unsigned int &flow_direction,
1681 const Quadrature<3> &quadrature_formula,
1682 const Mapping<3> &mapping);
1683#endif
std::map< types::boundary_id, BoundaryType > type
Map containing the boundary id and the boundary type.
This class manages the boundary conditions forhe fluid dynamics solver It introduces the boundary fun...
std::map< types::boundary_id, std::shared_ptr< NavierStokesBoundaryFunctions< dim > > > navier_stokes_functions
Class that manages the physical properties model which are required to calculate the various physical...
std::shared_ptr< RheologicalModel > get_rheology(const unsigned int fluid_id=0, const unsigned int material_id=0) const
double compute_cell_measure_with_JxW(const std::vector< double > &JxW_values)
Computes the area (2D) or volume (3D) of the cell by integrating 1 over the cell, by summing JxW valu...
Definition utilities.h:1017
double compute_cell_diameter(const double cell_measure, const unsigned int fe_degree)
Computes equivalent cell diameter by comparing the area to a disk (2D) or the volume to a sphere (3D)...
Definition utilities.h:989
@ velocity
Velocity vector field from fluid dynamics.
@ pressure
Pressure scalar field from fluid dynamics.
@ void_fraction
template double calculate_apparent_viscosity< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping, const PhysicalPropertiesManager &properties_manager)
template double calculate_CFL< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalVectorType &evaluation_point, const double time_step, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping)
template double calculate_viscous_dissipation< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping, const PhysicalPropertiesManager &properties_manager)
template double calculate_kinetic_energy< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping)
double calculate_pressure_power(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculate the average power done by pressure in the simulation domain. The average power is defined a...
template double calculate_pressure_power< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping)
std::pair< double, double > calculate_pressure_drop(const DoFHandler< dim > &dof_handler, const Mapping< dim > &mapping, const VectorType &evaluation_point, const Quadrature< dim > &cell_quadrature_formula, const Quadrature< dim - 1 > &face_quadrature_formula, const unsigned int inlet_boundary_id, const unsigned int outlet_boundary_id)
Calculate the pressure drop and total pressure drop between two boundaries. The pressure drop thus ca...
template double calculate_apparent_viscosity< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping, const PhysicalPropertiesManager &properties_manager)
template double calculate_kinetic_energy< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping)
template double calculate_viscous_dissipation< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping, const PhysicalPropertiesManager &properties_manager)
template double calculate_kinetic_energy< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping)
template double calculate_pressure_power< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping)
template std::map< types::boundary_id, Tensor< 1, 3 > > calculate_torques< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalVectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< 2 > &boundary_conditions, const Quadrature< 1 > &face_quadrature_formula, const Mapping< 2 > &mapping)
double calculate_apparent_viscosity(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping, const PhysicalPropertiesManager &properties_manager)
Calculates the apparent viscosity of the fluid for non Newtonian flows.
template double calculate_enstrophy< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping)
template double calculate_pressure_power< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping)
template double calculate_CFL< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const double time_step, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping)
template double calculate_enstrophy< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping)
template std::vector< std::map< types::boundary_id, Tensor< 1, 3 > > > calculate_forces< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< 3 > &boundary_conditions, const Quadrature< 2 > &face_quadrature_formula, const Mapping< 3 > &mapping)
template double calculate_CFL< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const double time_step, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping)
std::map< types::boundary_id, Tensor< 1, 3 > > calculate_torques(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > &boundary_conditions, const Quadrature< dim - 1 > &face_quadrature_formula, const Mapping< dim > &mapping)
Calculates the torques due to the fluid motion on every boundary conditions.
template std::map< types::boundary_id, Tensor< 1, 3 > > calculate_torques< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalVectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< 3 > &boundary_conditions, const Quadrature< 2 > &face_quadrature_formula, const Mapping< 3 > &mapping)
std::pair< double, double > calculate_flow_rate(const DoFHandler< dim > &dof_handler, const VectorType &present_solution, const unsigned int &boundary_id, const Quadrature< dim - 1 > &face_quadrature_formula, const Mapping< dim > &mapping)
calculate_flow_rate. This function calculates the volumetric flow rate at the selected boundary....
double calculate_kinetic_energy(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculate the average kinetic energy in the simulation domain.
template std::map< types::boundary_id, Tensor< 1, 3 > > calculate_torques< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< 2 > &boundary_conditions, const Quadrature< 1 > &face_quadrature_formula, const Mapping< 2 > &mapping)
template std::vector< std::map< types::boundary_id, Tensor< 1, 3 > > > calculate_forces< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalVectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< 3 > &boundary_conditions, const Quadrature< 2 > &face_quadrature_formula, const Mapping< 3 > &mapping)
double calculate_CFL(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const double time_step, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculate the CFL condition on the simulation domain.
template double calculate_viscous_dissipation< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping, const PhysicalPropertiesManager &properties_manager)
double calculate_average_velocity(const DoFHandler< dim > &dof_handler, const VectorType &present_solution, const unsigned int &boundary_id, const Quadrature< dim - 1 > &face_quadrature_formula, const Mapping< dim > &mapping)
calculate_average_velocity. This function calculates average velocity from the volumetric flow rate a...
template std::vector< std::map< types::boundary_id, Tensor< 1, 2 > > > calculate_forces< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< 2 > &boundary_conditions, const Quadrature< 1 > &face_quadrature_formula, const Mapping< 2 > &mapping)
template std::map< types::boundary_id, Tensor< 1, 3 > > calculate_torques< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< 3 > &boundary_conditions, const Quadrature< 2 > &face_quadrature_formula, const Mapping< 3 > &mapping)
template std::pair< double, double > calculate_pressure_drop< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const Mapping< 2 > &mapping, const GlobalVectorType &evaluation_point, const Quadrature< 2 > &cell_quadrature_formula, const Quadrature< 1 > &face_quadrature_formula, const unsigned int inlet_boundary_id, const unsigned int outlet_boundary_id)
template double calculate_enstrophy< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping)
template std::vector< std::map< types::boundary_id, Tensor< 1, 2 > > > calculate_forces< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalVectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< 2 > &boundary_conditions, const Quadrature< 1 > &face_quadrature_formula, const Mapping< 2 > &mapping)
std::pair< double, double > calculate_L2_error(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Function< dim > *exact_solution, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculates the L2 norm of the error on velocity and pressure.
std::vector< std::map< types::boundary_id, Tensor< 1, dim > > > calculate_forces(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > &boundary_conditions, const Quadrature< dim - 1 > &face_quadrature_formula, const Mapping< dim > &mapping)
Calculates the force due to the fluid motion on every boundary conditions.
template double calculate_enstrophy< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping)
template double calculate_kinetic_energy< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping)
template double calculate_apparent_viscosity< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping, const PhysicalPropertiesManager &properties_manager)
template double calculate_apparent_viscosity< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping, const PhysicalPropertiesManager &properties_manager)
template std::pair< double, double > calculate_pressure_drop< 3, GlobalBlockVectorType >(const DoFHandler< 3 > &dof_handler, const Mapping< 3 > &mapping, const GlobalBlockVectorType &evaluation_point, const Quadrature< 3 > &cell_quadrature_formula, const Quadrature< 2 > &face_quadrature_formula, const unsigned int inlet_boundary_id, const unsigned int outlet_boundary_id)
template double calculate_viscous_dissipation< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const GlobalVectorType &evaluation_point, const Quadrature< 3 > &quadrature_formula, const Mapping< 3 > &mapping, const PhysicalPropertiesManager &properties_manager)
template double calculate_pressure_power< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalBlockVectorType &evaluation_point, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping)
template double calculate_CFL< 2, GlobalVectorType >(const DoFHandler< 2 > &dof_handler, const GlobalVectorType &evaluation_point, const double time_step, const Quadrature< 2 > &quadrature_formula, const Mapping< 2 > &mapping)
template std::pair< double, double > calculate_pressure_drop< 3, GlobalVectorType >(const DoFHandler< 3 > &dof_handler, const Mapping< 3 > &mapping, const GlobalVectorType &evaluation_point, const Quadrature< 3 > &cell_quadrature_formula, const Quadrature< 2 > &face_quadrature_formula, const unsigned int inlet_boundary_id, const unsigned int outlet_boundary_id)
double calculate_enstrophy(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculate the average enstrophy in the simulation domain.
template std::pair< double, double > calculate_pressure_drop< 2, GlobalBlockVectorType >(const DoFHandler< 2 > &dof_handler, const Mapping< 2 > &mapping, const GlobalBlockVectorType &evaluation_point, const Quadrature< 2 > &cell_quadrature_formula, const Quadrature< 1 > &face_quadrature_formula, const unsigned int inlet_boundary_id, const unsigned int outlet_boundary_id)
double calculate_viscous_dissipation(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping, const PhysicalPropertiesManager &properties_manager)
Calculate the viscous dissipation of kinetic energy which is defined as ∫∇u.τdΩ/∫1dΩ
double calculate_pressure_power(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculate the average power done by pressure in the simulation domain. The average power is defined a...
std::pair< double, double > calculate_pressure_drop(const DoFHandler< dim > &dof_handler, const Mapping< dim > &mapping, const VectorType &evaluation_point, const Quadrature< dim > &cell_quadrature_formula, const Quadrature< dim - 1 > &face_quadrature_formula, const unsigned int inlet_boundary_id, const unsigned int outlet_boundary_id)
Calculate the pressure drop and total pressure drop between two boundaries. The pressure drop thus ca...
double calculate_apparent_viscosity(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping, const PhysicalPropertiesManager &properties_manager)
Calculates the apparent viscosity of the fluid for non Newtonian flows.
std::map< types::boundary_id, Tensor< 1, 3 > > calculate_torques(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > &boundary_conditions, const Quadrature< dim - 1 > &face_quadrature_formula, const Mapping< dim > &mapping)
Calculates the torques due to the fluid motion on every boundary conditions.
double calculate_kinetic_energy(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculate the average kinetic energy in the simulation domain.
double calculate_CFL(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const double time_step, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculate the CFL condition on the simulation domain.
std::vector< std::map< types::boundary_id, Tensor< 1, dim > > > calculate_forces(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const PhysicalPropertiesManager &properties_manager, const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > &boundary_conditions, const Quadrature< dim - 1 > &face_quadrature_formula, const Mapping< dim > &mapping)
Calculates the force due to the fluid motion on every boundary conditions.
double calculate_enstrophy(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping)
Calculate the average enstrophy in the simulation domain.
double calculate_viscous_dissipation(const DoFHandler< dim > &dof_handler, const VectorType &evaluation_point, const Quadrature< dim > &quadrature_formula, const Mapping< dim > &mapping, const PhysicalPropertiesManager &properties_manager)
Calculate the viscous dissipation of kinetic energy which is defined as ∫∇u.τdΩ/∫1dΩ
double calculate_shear_rate_magnitude(const Tensor< 2, dim > shear_rate)
Calculates the magnitude of the shear rate tensor given as input.
GlobalVectorType VectorType
dealii::TrilinosWrappers::MPI::Vector GlobalVectorType
Definition vector.h:17
dealii::TrilinosWrappers::MPI::BlockVector GlobalBlockVectorType
Definition vector.h:18