5#include <deal.II/base/quadrature_lib.h>
8#include <deal.II/lac/dynamic_sparsity_pattern.h>
9#include <deal.II/lac/vector.h>
12#include <deal.II/grid/grid_tools.h>
15#include <deal.II/dofs/dof_accessor.h>
16#include <deal.II/dofs/dof_handler.h>
19#include <deal.II/lac/trilinos_parallel_block_vector.h>
20#include <deal.II/lac/trilinos_vector.h>
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>
39template <
int dim,
typename VectorType>
40std::pair<double, double>
42 const Mapping<dim> &mapping,
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)
49 FESystem<dim, dim> fe = dof_handler.get_fe();
50 FEValues<dim> fe_values(mapping,
52 cell_quadrature_formula,
53 update_values | update_quadrature_points |
54 update_JxW_values | update_gradients |
56 FEFaceValues<dim> fe_face_values(fe,
57 face_quadrature_formula,
58 update_values | update_quadrature_points |
59 update_normal_vectors | update_JxW_values);
61 const FEValuesExtractors::Vector velocities(0);
62 const FEValuesExtractors::Scalar
pressure(dim);
64 const unsigned int face_n_q_points = face_quadrature_formula.size();
66 std::vector<Tensor<1, dim>> velocity_values(face_n_q_points);
67 std::vector<double> pressure_values(face_n_q_points);
69 double static_pressure_outlet_boundary = 0.;
70 double static_pressure_inlet_boundary = 0.;
71 double static_pressure_drop = 0.;
73 double dynamic_pressure_outlet_boundary = 0.;
74 double dynamic_pressure_inlet_boundary = 0.;
75 double dynamic_pressure_drop = 0.;
77 double outlet_surface = 0.;
78 double inlet_surface = 0.;
80 double temp_surface = 0.;
81 double temp_static_pressure_at_boundary = 0.;
82 double temp_dynamic_pressure_at_boundary = 0.;
84 for (
const auto &cell : dof_handler.active_cell_iterators())
86 if (cell->is_locally_owned())
88 for (
unsigned int face_id = 0;
89 face_id < GeometryInfo<dim>::faces_per_cell;
92 if (cell->face(face_id)->at_boundary())
94 unsigned int boundary_id = cell->face(face_id)->boundary_id();
95 if (boundary_id != inlet_boundary_id &&
96 boundary_id != outlet_boundary_id)
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,
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++)
108 temp_surface += fe_face_values.JxW(q);
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] *
118 if (boundary_id == inlet_boundary_id)
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;
126 if (boundary_id == outlet_boundary_id)
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;
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);
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);
150 inlet_surface = Utilities::MPI::sum(inlet_surface, mpi_communicator);
151 outlet_surface = Utilities::MPI::sum(outlet_surface, mpi_communicator);
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;
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;
167 return {static_pressure_drop, static_pressure_drop + dynamic_pressure_drop};
170template std::pair<double, double>
172 const DoFHandler<2> &dof_handler,
173 const Mapping<2> &mapping,
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);
180template std::pair<double, double>
182 const DoFHandler<3> &dof_handler,
183 const Mapping<3> &mapping,
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);
190template std::pair<double, double>
192 const DoFHandler<2> &dof_handler,
193 const Mapping<2> &mapping,
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);
200template std::pair<double, double>
202 const DoFHandler<3> &dof_handler,
203 const Mapping<3> &mapping,
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);
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);
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);
232template <
int dim,
typename VectorType>
236 const double time_step,
237 const Quadrature<dim> &quadrature_formula,
238 const Mapping<dim> &mapping)
240 FESystem<dim, dim> fe = dof_handler.get_fe();
241 FEValues<dim> fe_values(mapping,
244 update_values | update_quadrature_points |
247 const FEValuesExtractors::Vector velocities(0);
248 const unsigned int n_q_points = quadrature_formula.size();
251 std::vector<Tensor<1, dim>> present_velocity_values(n_q_points);
257 const unsigned int degree = fe.degree;
262 for (
const auto &cell : dof_handler.active_cell_iterators())
264 if (cell->is_locally_owned())
266 fe_values.reinit(cell);
269 double cell_measure =
273 fe_values[velocities].get_function_values(evaluation_point,
274 present_velocity_values);
275 for (
unsigned int q = 0; q < n_q_points; ++q)
277 const double localCFL =
278 present_velocity_values[q].norm() / h * time_step;
279 CFL = std::max(CFL, localCFL);
283 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
284 CFL = Utilities::MPI::max(CFL, mpi_communicator);
291 const double time_step,
292 const Quadrature<2> &quadrature_formula,
293 const Mapping<2> &mapping);
298 const double time_step,
299 const Quadrature<3> &quadrature_formula,
300 const Mapping<3> &mapping);
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);
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);
322 const DoFHandler<2> &dof_handler,
324 const double time_step,
325 const Quadrature<2> &quadrature_formula,
326 const Mapping<2> &mapping);
330 const DoFHandler<3> &dof_handler,
332 const double time_step,
333 const Quadrature<3> &quadrature_formula,
334 const Mapping<3> &mapping);
337template <
int dim,
typename VectorType>
341 const Quadrature<dim> &quadrature_formula,
342 const Mapping<dim> &mapping)
344 const FESystem<dim, dim> fe = dof_handler.get_fe();
345 FEValues<dim> fe_values(mapping,
348 update_values | update_gradients |
349 update_quadrature_points | update_JxW_values);
351 const FEValuesExtractors::Vector velocities(0);
353 const unsigned int n_q_points = quadrature_formula.size();
355 std::vector<Tensor<2, dim>> present_velocity_gradients(n_q_points);
357 double domain_volume =
358 GridTools::volume(dof_handler.get_triangulation(), mapping);
360 for (
const auto &cell : dof_handler.active_cell_iterators())
362 if (cell->is_locally_owned())
364 fe_values.reinit(cell);
366 fe_values[velocities].get_function_gradients(
367 evaluation_point, present_velocity_gradients);
369 for (
unsigned int q = 0; q < n_q_points; q++)
373 double ux_y = present_velocity_gradients[q][0][1];
374 double uy_x = present_velocity_gradients[q][1][0];
378 en += 0.5 * (uy_x - ux_y) * (uy_x - ux_y) * fe_values.JxW(q) /
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) /
389 en += 0.5 * (ux_z - uz_x) * (ux_z - uz_x) * fe_values.JxW(q) /
391 en += 0.5 * (uy_x - ux_y) * (uy_x - ux_y) * fe_values.JxW(q) /
397 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
398 en = Utilities::MPI::sum(en, mpi_communicator);
404 const DoFHandler<2> &dof_handler,
406 const Quadrature<2> &quadrature_formula,
407 const Mapping<2> &mapping);
411 const DoFHandler<3> &dof_handler,
413 const Quadrature<3> &quadrature_formula,
414 const Mapping<3> &mapping);
418 const DoFHandler<2> &dof_handler,
420 const Quadrature<2> &quadrature_formula,
421 const Mapping<2> &mapping);
425 const DoFHandler<3> &dof_handler,
427 const Quadrature<3> &quadrature_formula,
428 const Mapping<3> &mapping);
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);
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);
446template <
int dim,
typename VectorType>
450 const Quadrature<dim> &quadrature_formula,
451 const Mapping<dim> &mapping)
453 const FESystem<dim, dim> fe = dof_handler.get_fe();
454 FEValues<dim> fe_values(mapping,
457 update_values | update_gradients | update_JxW_values);
459 const FEValuesExtractors::Vector velocities(0);
460 const FEValuesExtractors::Scalar
pressure(dim);
462 const unsigned int n_q_points = quadrature_formula.size();
464 std::vector<Tensor<1, dim>>
velocity(n_q_points);
465 std::vector<Tensor<1, dim>> pressure_gradients(n_q_points);
467 double pressure_power = 0.0;
469 for (
const auto &cell : dof_handler.active_cell_iterators())
471 if (cell->is_locally_owned())
473 fe_values.reinit(cell);
475 fe_values[
pressure].get_function_gradients(evaluation_point,
478 fe_values[velocities].get_function_values(evaluation_point,
velocity);
480 for (
unsigned int q = 0; q < n_q_points; q++)
483 velocity[q] * pressure_gradients[q] * fe_values.JxW(q);
488 pressure_power /= GridTools::volume(dof_handler.get_triangulation(), mapping);
490 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
491 pressure_power = Utilities::MPI::sum(pressure_power, mpi_communicator);
493 return pressure_power;
498 const DoFHandler<2> &dof_handler,
500 const Quadrature<2> &quadrature_formula,
501 const Mapping<2> &mapping);
505 const DoFHandler<3> &dof_handler,
507 const Quadrature<3> &quadrature_formula,
508 const Mapping<3> &mapping);
512 const DoFHandler<2> &dof_handler,
514 const Quadrature<2> &quadrature_formula,
515 const Mapping<2> &mapping);
519 const DoFHandler<3> &dof_handler,
521 const Quadrature<3> &quadrature_formula,
522 const Mapping<3> &mapping);
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);
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);
541template <
int dim,
typename VectorType>
544 const DoFHandler<dim> &dof_handler,
546 const Quadrature<dim> &quadrature_formula,
547 const Mapping<dim> &mapping,
550 const FESystem<dim, dim> fe = dof_handler.get_fe();
551 FEValues<dim> fe_values(mapping,
554 update_gradients | update_JxW_values);
556 const FEValuesExtractors::Vector
velocity(0);
558 const unsigned int n_q_points = quadrature_formula.size();
560 std::vector<Tensor<2, dim>> velocity_gradients(n_q_points);
562 const auto rheological_model = properties_manager.
get_rheology();
564 double viscous_dissipation = 0;
566 for (
const auto &cell : dof_handler.active_cell_iterators())
568 if (cell->is_locally_owned())
570 fe_values.reinit(cell);
572 fe_values[
velocity].get_function_gradients(evaluation_point,
575 for (
unsigned int q = 0; q < n_q_points; q++)
578 velocity_gradients[q] + transpose(velocity_gradients[q]);
580 const double shear_rate_magnitude =
583 std::map<field, double> field_values;
586 const double kinematic_viscosity =
587 rheological_model->value(field_values);
590 viscous_dissipation +=
591 kinematic_viscosity *
592 scalar_product(
shear_rate, transpose(velocity_gradients[q])) *
598 viscous_dissipation /=
599 GridTools::volume(dof_handler.get_triangulation(), mapping);
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;
609 const DoFHandler<2> &dof_handler,
611 const Quadrature<2> &quadrature_formula,
612 const Mapping<2> &mapping,
617 const DoFHandler<3> &dof_handler,
619 const Quadrature<3> &quadrature_formula,
620 const Mapping<3> &mapping,
625 const DoFHandler<2> &dof_handler,
627 const Quadrature<2> &quadrature_formula,
628 const Mapping<2> &mapping,
633 const DoFHandler<3> &dof_handler,
635 const Quadrature<3> &quadrature_formula,
636 const Mapping<3> &mapping,
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,
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,
658template <
int dim,
typename VectorType>
662 const Quadrature<dim> &quadrature_formula,
663 const Mapping<dim> &mapping)
665 const FESystem<dim, dim> fe = dof_handler.get_fe();
666 FEValues<dim> fe_values(mapping,
669 update_values | update_quadrature_points |
672 const FEValuesExtractors::Vector velocities(0);
673 const unsigned int n_q_points = quadrature_formula.size();
675 std::vector<Tensor<1, dim>> local_velocity_values(n_q_points);
676 double domain_volume =
677 GridTools::volume(dof_handler.get_triangulation(), mapping);
683 for (
const auto &cell : dof_handler.active_cell_iterators())
685 if (cell->is_locally_owned())
687 fe_values.reinit(cell);
688 fe_values[velocities].get_function_values(evaluation_point,
689 local_velocity_values);
691 for (
unsigned int q = 0; q < n_q_points; q++)
693 double ux_sim = local_velocity_values[q][0];
694 double uy_sim = local_velocity_values[q][1];
696 KEU += 0.5 * ((ux_sim) * (ux_sim)*fe_values.JxW(q));
697 KEU += 0.5 * ((uy_sim) * (uy_sim)*fe_values.JxW(q));
700 double uz_sim = local_velocity_values[q][2];
701 KEU += 0.5 * ((uz_sim) * (uz_sim)*fe_values.JxW(q));
706 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
707 KEU = Utilities::MPI::sum(KEU / domain_volume, mpi_communicator);
713 const DoFHandler<2> &dof_handler,
715 const Quadrature<2> &quadrature_formula,
716 const Mapping<2> &mapping);
720 const DoFHandler<3> &dof_handler,
722 const Quadrature<3> &quadrature_formula,
723 const Mapping<3> &mapping);
727 const DoFHandler<2> &dof_handler,
729 const Quadrature<2> &quadrature_formula,
730 const Mapping<2> &mapping);
734 const DoFHandler<3> &dof_handler,
736 const Quadrature<3> &quadrature_formula,
737 const Mapping<3> &mapping);
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);
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);
755template <
int dim,
typename VectorType>
758 const DoFHandler<dim> &dof_handler,
760 const Quadrature<dim> &quadrature_formula,
761 const Mapping<dim> &mapping,
764 double integral_viscosity_x_shear_rate = 0;
765 double integral_shear_rate = 0;
766 double shear_rate_magnitude;
768 double kinematic_viscosity;
769 const auto rheological_model = properties_manager.
get_rheology();
771 const FESystem<dim, dim> fe = dof_handler.get_fe();
772 FEValues<dim> fe_values(mapping,
775 update_gradients | update_JxW_values);
777 const FEValuesExtractors::Vector
velocity(0);
779 const unsigned int n_q_points = quadrature_formula.size();
781 std::vector<Tensor<2, dim>> velocity_gradients(n_q_points);
783 for (
const auto &cell : dof_handler.active_cell_iterators())
785 if (cell->is_locally_owned())
787 fe_values.reinit(cell);
789 fe_values[
velocity].get_function_gradients(evaluation_point,
792 for (
unsigned int q = 0; q < n_q_points; q++)
795 velocity_gradients[q] + transpose(velocity_gradients[q]);
797 double shear_rate_x_velocity_gradient = 0;
798 for (
int i = 0; i < dim; ++i)
800 for (
int j = 0; j < dim; ++j)
802 shear_rate_x_velocity_gradient +=
803 shear_rate[i][j] * velocity_gradients[q][j][i];
809 std::map<field, double> field_values;
812 kinematic_viscosity = rheological_model->value(field_values);
814 integral_viscosity_x_shear_rate +=
815 kinematic_viscosity * shear_rate_x_velocity_gradient *
817 integral_shear_rate +=
818 shear_rate_x_velocity_gradient * fe_values.JxW(q);
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;
832 const DoFHandler<2> &dof_handler,
834 const Quadrature<2> &quadrature_formula,
835 const Mapping<2> &mapping,
840 const DoFHandler<3> &dof_handler,
842 const Quadrature<3> &quadrature_formula,
843 const Mapping<3> &mapping,
848 const DoFHandler<2> &dof_handler,
850 const Quadrature<2> &quadrature_formula,
851 const Mapping<2> &mapping,
856 const DoFHandler<3> &dof_handler,
858 const Quadrature<3> &quadrature_formula,
859 const Mapping<3> &mapping,
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,
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,
880template <
int dim,
typename VectorType>
881std::vector<std::map<types::boundary_id, Tensor<1, dim>>>
886 &boundary_conditions,
887 const Quadrature<dim - 1> &face_quadrature_formula,
888 const Mapping<dim> &mapping)
890 const FESystem<dim, dim> fe = dof_handler.get_fe();
893 double kinematic_viscosity;
894 const auto rheological_model = properties_manager.
get_rheology();
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;
904 Tensor<2, dim> fluid_stress;
905 Tensor<2, dim> fluid_viscous_stress;
906 Tensor<2, dim> fluid_pressure;
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;
912 FEFaceValues<dim> fe_face_values(mapping,
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();
920 for (
const auto &cell : dof_handler.active_cell_iterators())
922 if (cell->is_locally_owned())
924 if (cell->at_boundary())
926 for (
const auto face : cell->face_indices())
928 if (cell->face(face)->at_boundary())
930 const auto boundary_id = cell->face(face)->boundary_id();
932 fe_face_values.reinit(cell, face);
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++)
942 normal_vector = -fe_face_values.normal_vector(q);
943 for (
int d = 0; d < dim; ++d)
945 fluid_pressure[d][d] = pressure_values[q];
948 transpose(velocity_gradients[q]);
950 const double shear_rate_magnitude =
953 std::map<field, double> field_values;
955 shear_rate_magnitude;
957 kinematic_viscosity =
958 rheological_model->value(field_values);
959 fluid_viscous_stress =
961 fluid_stress = -fluid_viscous_stress - fluid_pressure;
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 *
971 fe_face_values.JxW(q);
979 for (
auto const &[
id, type] : boundary_conditions.
type)
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);
987 std::vector<std::map<types::boundary_id, Tensor<1, dim>>> forces{
988 force_map, viscous_force_map, pressure_force_map};
992template std::vector<std::map<types::boundary_id, Tensor<1, 2>>>
994 const DoFHandler<2> &dof_handler,
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,
1007 &boundary_conditions,
1008 const Quadrature<2> &face_quadrature_formula,
1009 const Mapping<3> &mapping);
1011template std::vector<std::map<types::boundary_id, Tensor<1, 2>>>
1013 const DoFHandler<2> &dof_handler,
1017 &boundary_conditions,
1018 const Quadrature<1> &face_quadrature_formula,
1019 const Mapping<2> &mapping);
1021template std::vector<std::map<types::boundary_id, Tensor<1, 3>>>
1023 const DoFHandler<3> &dof_handler,
1027 &boundary_conditions,
1028 const Quadrature<2> &face_quadrature_formula,
1029 const Mapping<3> &mapping);
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,
1038 &boundary_conditions,
1039 const Quadrature<1> &face_quadrature_formula,
1040 const Mapping<2> &mapping);
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,
1048 &boundary_conditions,
1049 const Quadrature<2> &face_quadrature_formula,
1050 const Mapping<3> &mapping);
1053template <
int dim,
typename VectorType>
1054std::map<types::boundary_id, Tensor<1, 3>>
1059 &boundary_conditions,
1060 const Quadrature<dim - 1> &face_quadrature_formula,
1061 const Mapping<dim> &mapping)
1063 const FESystem<dim, dim> fe = dof_handler.get_fe();
1066 double kinematic_viscosity;
1067 const auto rheological_model = properties_manager.
get_rheology();
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;
1077 Tensor<2, dim> fluid_stress;
1078 Tensor<2, dim> fluid_pressure;
1081 std::map<types::boundary_id, Tensor<1, 3>> torque_map;
1083 FEFaceValues<dim> fe_face_values(mapping,
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();
1091 for (
const auto &cell : dof_handler.active_cell_iterators())
1093 if (cell->is_locally_owned())
1095 for (
const auto face : cell->face_indices())
1097 if (cell->face(face)->at_boundary())
1099 fe_face_values.reinit(cell, face);
1100 unsigned int boundary_id = cell->face(face)->boundary_id();
1102 Point<dim> center_of_rotation =
1104 ->center_of_rotation;
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,
1113 for (
unsigned int q = 0; q < n_q_points; q++)
1115 normal_vector = -fe_face_values.normal_vector(q);
1116 for (
int d = 0; d < dim; ++d)
1118 fluid_pressure[d][d] = pressure_values[q];
1121 transpose(velocity_gradients[q]);
1122 const double shear_rate_magnitude =
1125 std::map<field, double> field_values;
1128 kinematic_viscosity =
1129 rheological_model->value(field_values);
1132 kinematic_viscosity *
shear_rate - fluid_pressure;
1134 fluid_stress * normal_vector * fe_face_values.JxW(q);
1136 auto distance = q_points[q] - center_of_rotation;
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];
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];
1158 for (
auto const &[
id, type] : boundary_conditions.
type)
1160 torque_map[id] = Utilities::MPI::sum(torque_map[
id], mpi_communicator);
1166template std::map<types::boundary_id, Tensor<1, 3>>
1168 const DoFHandler<2> &dof_handler,
1172 &boundary_conditions,
1173 const Quadrature<1> &face_quadrature_formula,
1174 const Mapping<2> &mapping);
1176template std::map<types::boundary_id, Tensor<1, 3>>
1178 const DoFHandler<3> &dof_handler,
1182 &boundary_conditions,
1183 const Quadrature<2> &face_quadrature_formula,
1184 const Mapping<3> &mapping);
1186template std::map<types::boundary_id, Tensor<1, 3>>
1188 const DoFHandler<2> &dof_handler,
1192 &boundary_conditions,
1193 const Quadrature<1> &face_quadrature_formula,
1194 const Mapping<2> &mapping);
1196template std::map<types::boundary_id, Tensor<1, 3>>
1198 const DoFHandler<3> &dof_handler,
1202 &boundary_conditions,
1203 const Quadrature<2> &face_quadrature_formula,
1204 const Mapping<3> &mapping);
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,
1213 &boundary_conditions,
1214 const Quadrature<1> &face_quadrature_formula,
1215 const Mapping<2> &mapping);
1217template std::map<types::boundary_id, Tensor<1, 3>>
1219 const DoFHandler<3> &dof_handler,
1220 const LinearAlgebra::distributed::Vector<double> &evaluation_point,
1223 &boundary_conditions,
1224 const Quadrature<2> &face_quadrature_formula,
1225 const Mapping<3> &mapping);
1231template <
int dim,
typename VectorType>
1232std::pair<double, double>
1235 const Function<dim> *exact_solution,
1236 const Quadrature<dim> &quadrature_formula,
1237 const Mapping<dim> &mapping)
1239 const FESystem<dim, dim> fe = dof_handler.get_fe();
1240 FEValues<dim> fe_values(mapping,
1243 update_values | update_gradients |
1244 update_quadrature_points | update_JxW_values);
1246 const FEValuesExtractors::Vector velocities(0);
1247 const FEValuesExtractors::Scalar
pressure(dim);
1248 const unsigned int n_q_points = quadrature_formula.size();
1250 std::vector<Vector<double>> q_exactSol(n_q_points, Vector<double>(dim + 1));
1252 std::vector<Tensor<1, dim>> local_velocity_values(n_q_points);
1253 std::vector<double> local_pressure_values(n_q_points);
1255 double pressure_integral = 0;
1256 double exact_pressure_integral = 0;
1259 for (
const auto &cell : dof_handler.active_cell_iterators())
1261 if (cell->is_locally_owned())
1263 fe_values.reinit(cell);
1265 fe_values[
pressure].get_function_values(evaluation_point,
1266 local_pressure_values);
1268 exact_solution->vector_value_list(fe_values.get_quadrature_points(),
1271 for (
unsigned int q = 0; q < n_q_points; q++)
1273 pressure_integral += local_pressure_values[q] * fe_values.JxW(q);
1274 exact_pressure_integral += q_exactSol[q][dim] * fe_values.JxW(q);
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);
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;
1291 double l2errorU = 0.;
1292 double l2errorP = 0.;
1294 for (
const auto &cell : dof_handler.active_cell_iterators())
1296 if (cell->is_locally_owned())
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);
1305 exact_solution->vector_value_list(fe_values.get_quadrature_points(),
1308 for (
unsigned int q = 0; q < n_q_points; q++)
1312 double ux_sim = local_velocity_values[q][0];
1313 double ux_exact = q_exactSol[q][0];
1315 double uy_sim = local_velocity_values[q][1];
1316 double uy_exact = q_exactSol[q][1];
1319 (ux_sim - ux_exact) * (ux_sim - ux_exact) * fe_values.JxW(q);
1321 (uy_sim - uy_exact) * (uy_sim - uy_exact) * fe_values.JxW(q);
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) *
1331 double p_sim = local_pressure_values[q] - average_pressure;
1332 double p_exact = q_exactSol[q][dim] - average_exact_pressure;
1334 (p_sim - p_exact) * (p_sim - p_exact) * fe_values.JxW(q);
1338 l2errorU = Utilities::MPI::sum(l2errorU, mpi_communicator);
1339 l2errorP = Utilities::MPI::sum(l2errorP, mpi_communicator);
1341 return std::make_pair(std::sqrt(l2errorU), std::sqrt(l2errorP));
1344template std::pair<double, double>
1347 const Function<2> *l_exact_solution,
1348 const Quadrature<2> &quadrature_formula,
1349 const Mapping<2> &mapping);
1351template std::pair<double, double>
1354 const Function<3> *l_exact_solution,
1355 const Quadrature<3> &quadrature_formula,
1356 const Mapping<3> &mapping);
1358template std::pair<double, double>
1361 const Function<2> *l_exact_solution,
1362 const Quadrature<2> &quadrature_formula,
1363 const Mapping<2> &mapping);
1365template std::pair<double, double>
1368 const Function<3> *l_exact_solution,
1369 const Quadrature<3> &quadrature_formula,
1370 const Mapping<3> &mapping);
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);
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);
1390template <
int dim,
typename VectorType>
1391std::pair<double, double>
1394 const unsigned int &boundary_id,
1395 const Quadrature<dim - 1> &face_quadrature_formula,
1396 const Mapping<dim> &mapping)
1398 const FESystem<dim, dim> fe = dof_handler.get_fe();
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;
1405 FEFaceValues<dim> fe_face_values(mapping,
1407 face_quadrature_formula,
1408 update_values | update_quadrature_points |
1409 update_JxW_values | update_normal_vectors);
1411 double flow_rate = 0;
1415 for (
const auto &cell : dof_handler.active_cell_iterators())
1417 if (cell->is_locally_owned() && cell->at_boundary())
1419 for (
unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell;
1422 if (cell->face(face)->at_boundary())
1424 fe_face_values.reinit(cell, face);
1425 if (cell->face(face)->boundary_id() == boundary_id)
1427 for (
unsigned int q = 0; q < n_q_points; q++)
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);
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);
1446 return std::make_pair(flow_rate, area);
1449template std::pair<double, double>
1452 const unsigned int &boundary_id,
1453 const Quadrature<1> &face_quadrature_formula,
1454 const Mapping<2> &mapping);
1456template std::pair<double, double>
1459 const unsigned int &boundary_id,
1460 const Quadrature<2> &face_quadrature_formula,
1461 const Mapping<3> &mapping);
1463template std::pair<double, double>
1466 const unsigned int &boundary_id,
1467 const Quadrature<1> &face_quadrature_formula,
1468 const Mapping<2> &mapping);
1470template std::pair<double, double>
1473 const unsigned int &boundary_id,
1474 const Quadrature<2> &face_quadrature_formula,
1475 const Mapping<3> &mapping);
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);
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);
1495template <
int dim,
typename VectorType>
1499 const unsigned int &boundary_id,
1500 const Quadrature<dim - 1> &face_quadrature_formula,
1501 const Mapping<dim> &mapping)
1503 std::pair<double, double> flow_rate_and_area =
1507 face_quadrature_formula,
1513 return -flow_rate_and_area.first / flow_rate_and_area.second;
1519 const unsigned int &boundary_id,
1520 const Quadrature<1> &face_quadrature_formula,
1521 const Mapping<2> &mapping);
1526 const unsigned int &boundary_id,
1527 const Quadrature<2> &face_quadrature_formula,
1528 const Mapping<3> &mapping);
1533 const unsigned int &boundary_id,
1534 const Quadrature<1> &face_quadrature_formula,
1535 const Mapping<2> &mapping);
1540 const unsigned int &boundary_id,
1541 const Quadrature<2> &face_quadrature_formula,
1542 const Mapping<3> &mapping);
1544#ifndef LETHE_USE_LDV
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);
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);
1562template <
int dim,
typename VectorType>
1565 const DoFHandler<dim> &void_fraction_dof_handler,
1567 const VectorType &present_void_fraction_solution,
1568 const unsigned int &flow_direction,
1569 const Quadrature<dim> &quadrature_formula,
1570 const Mapping<dim> &mapping)
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);
1579 FEValues<dim> fe_values(mapping,
1582 update_values | update_quadrature_points |
1586 const FESystem<dim, dim> fe_void_fraction =
1587 void_fraction_dof_handler.get_fe();
1589 std::vector<double> void_fraction_values(n_q_points);
1591 FEValues<dim> fe_vf_values(mapping,
1594 update_values | update_quadrature_points);
1597 double average_velocity = 0;
1600 for (
const auto &cell : dof_handler.active_cell_iterators())
1602 if (cell->is_locally_owned())
1604 fe_values.reinit(cell);
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);
1610 for (
unsigned int q = 0; q < n_q_points; q++)
1614 present_void_fraction_solution, void_fraction_values);
1618 volume += void_fraction_values[q] * fe_values.JxW(q);
1622 fe_values[velocities].get_function_values(present_solution,
1624 average_velocity += void_fraction_values[q] *
1625 velocity_values[q][flow_direction] *
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);
1636 average_velocity /= volume;
1638 return average_velocity;
1643 const DoFHandler<2> &dof_handler,
1644 const DoFHandler<2> &void_fraction_dof_handler,
1647 const unsigned int &flow_direction,
1648 const Quadrature<2> &quadrature_formula,
1649 const Mapping<2> &mapping);
1653 const DoFHandler<3> &dof_handler,
1654 const DoFHandler<3> &void_fraction_dof_handler,
1657 const unsigned int &flow_direction,
1658 const Quadrature<3> &quadrature_formula,
1659 const Mapping<3> &mapping);
1661#ifndef LETHE_USE_LDV
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);
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);
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...
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)...
@ velocity
Velocity vector field from fluid dynamics.
@ pressure
Pressure scalar field from fluid dynamics.
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
dealii::TrilinosWrappers::MPI::BlockVector GlobalBlockVectorType