18 const std::vector<double> &viscosity_vector =
21 const std::vector<double> &viscosity_for_stabilization_vector =
25 const auto &JxW_vec = scratch_data.
JxW;
26 const unsigned int n_q_points = scratch_data.
n_q_points;
27 const unsigned int n_dofs = scratch_data.
n_dofs;
36 std::vector<double> time_steps_vector =
38 const double dt = time_steps_vector[0];
39 const double sdt = 1. / dt;
45 for (
unsigned int q = 0; q < n_q_points; ++q)
48 const double kinematic_viscosity = viscosity_vector[q];
50 const Tensor<2, dim> &velocity_gradient =
52 const Tensor<1, dim> &velocity_laplacian =
54 const Tensor<1, dim> &advective_velocity =
57 const Tensor<1, dim> &pressure_gradient =
61 const Tensor<1, dim> &force = scratch_data.
force[q];
66 const double u_mag = std::max(advective_velocity.norm(), 1e-12);
69 const double JxW = JxW_vec[q];
79 u_mag, viscosity_for_stabilization_vector[q], h) :
81 u_mag, viscosity_for_stabilization_vector[q], h, sdt);
84 auto strong_residual = velocity_gradient * advective_velocity +
86 kinematic_viscosity * velocity_laplacian - force +
87 mass_source *
velocity + strong_residual_vec[q];
89 std::vector<Tensor<1, dim>> grad_phi_u_j_x_velocity(n_dofs);
90 std::vector<Tensor<1, dim>> velocity_gradient_x_phi_u_j(n_dofs);
95 for (
unsigned int j = 0; j < n_dofs; ++j)
97 const auto &phi_u_j = scratch_data.
phi_u[q][j];
98 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
101 const auto &grad_phi_p_j =
102 pressure_scaling_factor * scratch_data.
grad_phi_p[q][j];
104 strong_jacobian_vec[q][j] +=
105 (velocity_gradient * phi_u_j + grad_phi_u_j * advective_velocity +
106 grad_phi_p_j - kinematic_viscosity * laplacian_phi_u_j +
107 mass_source * phi_u_j);
110 grad_phi_u_j_x_velocity[j] = grad_phi_u_j * advective_velocity;
111 velocity_gradient_x_phi_u_j[j] = velocity_gradient * phi_u_j;
116 for (
unsigned int i = 0; i < n_dofs; ++i)
118 const int component_i = scratch_data.
components[i];
120 const auto &phi_u_i = scratch_data.
phi_u[q][i];
121 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
122 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
123 const auto &phi_p_i = scratch_data.
phi_p[q][i];
124 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
128 const auto grad_phi_u_i_x_velocity =
129 grad_phi_u_i * advective_velocity;
130 const auto strong_residual_x_grad_phi_u_i =
131 strong_residual * grad_phi_u_i;
133 for (
unsigned int j = 0; j < n_dofs; ++j)
135 const int component_j = scratch_data.
components[j];
137 const auto &phi_u_j = scratch_data.
phi_u[q][j];
139 const auto &phi_p_j =
140 pressure_scaling_factor * scratch_data.
phi_p[q][j];
142 const auto &strong_jac = strong_jacobian_vec[q][j];
144 double local_matrix_ij =
145 component_j == dim ? -div_phi_u_i * phi_p_j : 0;
146 if (component_i == dim)
148 const auto &div_phi_u_j = scratch_data.
div_phi_u[q][j];
150 local_matrix_ij += phi_p_i * div_phi_u_j;
153 local_matrix_ij += tau * (strong_jac * grad_phi_p_i);
156 if (component_i < dim && component_j < dim)
158 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
160 local_matrix_ij += velocity_gradient_x_phi_u_j[j] * phi_u_i +
161 grad_phi_u_j_x_velocity[j] * phi_u_i;
163 if (component_i == component_j)
166 kinematic_viscosity * (grad_phi_u_j[component_j] *
167 grad_phi_u_i[component_i]) +
168 mass_source * phi_u_j * phi_u_i;
171 if (component_i < dim)
180 tau * (strong_jac * grad_phi_u_i_x_velocity +
181 strong_residual_x_grad_phi_u_i * phi_u_j);
184 local_matrix_ij *= JxW;
185 local_matrix(i, j) += local_matrix_ij;
198 const std::vector<double> &viscosity_vector =
201 const std::vector<double> &viscosity_for_stabilization_vector =
205 const auto &JxW_vec = scratch_data.
JxW;
206 const unsigned int n_q_points = scratch_data.
n_q_points;
207 const unsigned int n_dofs = scratch_data.
n_dofs;
215 std::vector<double> time_steps_vector =
217 const double dt = time_steps_vector[0];
218 const double sdt = 1. / dt;
221 for (
unsigned int q = 0; q < n_q_points; ++q)
224 const double kinematic_viscosity = viscosity_vector[q];
229 const Tensor<2, dim> &velocity_gradient =
231 const Tensor<1, dim> &velocity_laplacian =
233 const Tensor<1, dim> &advective_velocity =
238 const Tensor<1, dim> &pressure_gradient =
242 const Tensor<1, dim> &force = scratch_data.
force[q];
246 const double u_mag = std::max(advective_velocity.norm(), 1e-12);
249 const double JxW = JxW_vec[q];
259 u_mag, viscosity_for_stabilization_vector[q], h) :
261 u_mag, viscosity_for_stabilization_vector[q], h, sdt);
266 auto strong_residual = velocity_gradient * advective_velocity +
268 kinematic_viscosity * velocity_laplacian - force +
269 mass_source *
velocity + strong_residual_vec[q];
272 for (
unsigned int i = 0; i < n_dofs; ++i)
274 const auto &phi_u_i = scratch_data.
phi_u[q][i];
275 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
276 const auto &phi_p_i = scratch_data.
phi_p[q][i];
277 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
278 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
280 double local_rhs_i = 0;
286 -kinematic_viscosity *
287 scalar_product(velocity_gradient, grad_phi_u_i) -
288 velocity_gradient * advective_velocity * phi_u_i +
289 pressure * div_phi_u_i + force * phi_u_i -
292 velocity_divergence * phi_p_i + mass_source * phi_p_i) *
296 local_rhs_i += -tau * (strong_residual * grad_phi_p_i) * JxW;
300 -tau * (strong_residual * (grad_phi_u_i * advective_velocity)) *
303 local_rhs(i) += local_rhs_i;
320 const std::vector<double> &viscosity_vector =
323 const std::vector<double> &viscosity_for_stabilization_vector =
327 const auto &JxW_vec = scratch_data.
JxW;
328 const unsigned int n_q_points = scratch_data.
n_q_points;
329 const unsigned int n_dofs = scratch_data.
n_dofs;
338 std::vector<double> time_steps_vector =
340 const double dt = time_steps_vector[0];
341 const double sdt = 1. / dt;
347 for (
unsigned int q = 0; q < n_q_points; ++q)
350 const double kinematic_viscosity = viscosity_vector[q];
352 const Tensor<2, dim> &velocity_gradient =
354 const Tensor<1, dim> &velocity_laplacian =
356 const Tensor<1, dim> &advective_velocity =
359 const Tensor<1, dim> &pressure_gradient =
363 const Tensor<1, dim> &force = scratch_data.
force[q];
368 const double u_mag = std::max(advective_velocity.norm(), 1e-12);
371 const double JxW = JxW_vec[q];
381 u_mag, viscosity_for_stabilization_vector[q], h) :
383 u_mag, viscosity_for_stabilization_vector[q], h, sdt);
386 const double tau_lsic = 0.5 * u_mag * h;
390 auto strong_residual = velocity_gradient * advective_velocity +
392 kinematic_viscosity * velocity_laplacian - force +
393 mass_source *
velocity + strong_residual_vec[q];
395 std::vector<Tensor<1, dim>> grad_phi_u_j_x_velocity(n_dofs);
396 std::vector<Tensor<1, dim>> velocity_gradient_x_phi_u_j(n_dofs);
401 for (
unsigned int j = 0; j < n_dofs; ++j)
403 const auto &phi_u_j = scratch_data.
phi_u[q][j];
404 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
407 const auto &grad_phi_p_j =
408 pressure_scaling_factor * scratch_data.
grad_phi_p[q][j];
410 strong_jacobian_vec[q][j] +=
411 (velocity_gradient * phi_u_j + grad_phi_u_j * advective_velocity +
412 grad_phi_p_j - kinematic_viscosity * laplacian_phi_u_j +
413 mass_source * phi_u_j);
416 grad_phi_u_j_x_velocity[j] = grad_phi_u_j * advective_velocity;
417 velocity_gradient_x_phi_u_j[j] = velocity_gradient * phi_u_j;
420 for (
unsigned int i = 0; i < n_dofs; ++i)
422 const int component_i = scratch_data.
components[i];
424 const auto &phi_u_i = scratch_data.
phi_u[q][i];
425 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
426 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
427 const auto &phi_p_i = scratch_data.
phi_p[q][i];
428 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
434 const auto grad_phi_u_i_x_velocity =
435 grad_phi_u_i * advective_velocity;
436 const auto strong_residual_x_grad_phi_u_i =
437 strong_residual * grad_phi_u_i;
439 for (
unsigned int j = 0; j < n_dofs; ++j)
441 const int component_j = scratch_data.
components[j];
443 const auto &phi_u_j = scratch_data.
phi_u[q][j];
445 const auto &phi_p_j =
446 pressure_scaling_factor * scratch_data.
phi_p[q][j];
448 const auto &strong_jac = strong_jacobian_vec[q][j];
450 double local_matrix_ij =
451 component_j == dim ? -div_phi_u_i * phi_p_j : 0;
452 if (component_i == dim)
454 const auto &div_phi_u_j = scratch_data.
div_phi_u[q][j];
455 local_matrix_ij += phi_p_i * div_phi_u_j;
458 local_matrix_ij += tau * (strong_jac * grad_phi_p_i);
461 if (component_i < dim && component_j < dim)
463 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
465 local_matrix_ij += velocity_gradient_x_phi_u_j[j] * phi_u_i +
466 grad_phi_u_j_x_velocity[j] * phi_u_i;
469 const auto &div_phi_u_j = scratch_data.
div_phi_u[q][j];
470 local_matrix_ij += tau_lsic * (div_phi_u_i * div_phi_u_j);
472 if (component_i == component_j)
475 kinematic_viscosity * (grad_phi_u_j[component_j] *
476 grad_phi_u_i[component_i]) +
477 mass_source * phi_u_j * phi_u_i;
480 if (component_i < dim)
489 (strong_jac * (grad_phi_u_i_x_velocity -
490 kinematic_viscosity * laplacian_phi_u_i) +
491 strong_residual_x_grad_phi_u_i * phi_u_j);
494 local_matrix_ij *= JxW;
495 local_matrix(i, j) += local_matrix_ij;
508 const std::vector<double> &viscosity_vector =
511 const std::vector<double> &viscosity_for_stabilization_vector =
515 const auto &JxW_vec = scratch_data.
JxW;
516 const unsigned int n_q_points = scratch_data.
n_q_points;
517 const unsigned int n_dofs = scratch_data.
n_dofs;
525 std::vector<double> time_steps_vector =
527 const double dt = time_steps_vector[0];
528 const double sdt = 1. / dt;
531 for (
unsigned int q = 0; q < n_q_points; ++q)
534 const double kinematic_viscosity = viscosity_vector[q];
539 const Tensor<2, dim> &velocity_gradient =
541 const Tensor<1, dim> &velocity_laplacian =
543 const Tensor<1, dim> &advective_velocity =
548 const Tensor<1, dim> &pressure_gradient =
552 const Tensor<1, dim> &force = scratch_data.
force[q];
556 const double u_mag = std::max(advective_velocity.norm(), 1e-12);
559 const double JxW = JxW_vec[q];
569 u_mag, viscosity_for_stabilization_vector[q], h) :
571 u_mag, viscosity_for_stabilization_vector[q], h, sdt);
575 const double tau_lsic = u_mag * h / 2;
579 auto strong_residual = velocity_gradient * advective_velocity +
581 kinematic_viscosity * velocity_laplacian - force +
582 mass_source *
velocity + strong_residual_vec[q];
585 for (
unsigned int i = 0; i < n_dofs; ++i)
587 const auto &phi_u_i = scratch_data.
phi_u[q][i];
588 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
589 const auto &phi_p_i = scratch_data.
phi_p[q][i];
590 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
591 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
595 double local_rhs_i = 0;
601 -kinematic_viscosity *
602 scalar_product(velocity_gradient, grad_phi_u_i) -
603 velocity_gradient * advective_velocity * phi_u_i +
604 pressure * div_phi_u_i + force * phi_u_i -
607 velocity_divergence * phi_p_i + mass_source * phi_p_i) *
611 local_rhs_i += -tau * (strong_residual * grad_phi_p_i) * JxW;
614 local_rhs_i += -tau_lsic * (div_phi_u_i * velocity_divergence) * JxW;
619 (strong_residual * (grad_phi_u_i * advective_velocity -
620 kinematic_viscosity * laplacian_phi_u_i)) *
623 local_rhs(i) += local_rhs_i;
640 const std::vector<double> &viscosity_vector =
643 const std::vector<double> &viscosity_for_stabilization_vector =
647 const auto &JxW_vec = scratch_data.
JxW;
648 const unsigned int n_q_points = scratch_data.
n_q_points;
649 const unsigned int n_dofs = scratch_data.
n_dofs;
658 std::vector<double> time_steps_vector =
660 const double dt = time_steps_vector[0];
661 const double sdt = 1. / dt;
667 for (
unsigned int q = 0; q < n_q_points; ++q)
670 const double kinematic_viscosity = viscosity_vector[q];
673 const Tensor<2, dim> &velocity_gradient =
675 const Tensor<1, dim> &velocity_laplacian =
677 const Tensor<3, dim> &velocity_hessian =
679 const Tensor<1, dim> &pressure_gradient =
681 const Tensor<1, dim> &advective_velocity =
686 velocity_gradient + transpose(velocity_gradient);
692 shear_rate_magnitude =
693 shear_rate_magnitude > 1e-12 ? shear_rate_magnitude : 1e-12;
696 const Tensor<1, dim> viscosity_gradient =
700 shear_rate_magnitude,
704 const Tensor<1, dim> force = scratch_data.
force[q];
709 const double u_mag = std::max(advective_velocity.norm(), 1e-12);
712 const double JxW = JxW_vec[q];
722 u_mag, viscosity_for_stabilization_vector[q], h) :
724 u_mag, viscosity_for_stabilization_vector[q], h, sdt);
727 auto strong_residual = velocity_gradient * advective_velocity +
730 kinematic_viscosity * velocity_laplacian - force +
731 mass_source *
velocity + strong_residual_vec[q];
733 std::vector<Tensor<1, dim>> grad_phi_u_j_x_velocity(n_dofs);
734 std::vector<Tensor<1, dim>> velocity_gradient_x_phi_u_j(n_dofs);
739 for (
unsigned int j = 0; j < n_dofs; ++j)
741 const auto &phi_u_j = scratch_data.
phi_u[q][j];
742 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
745 const auto &grad_phi_p_j =
746 pressure_scaling_factor * scratch_data.
grad_phi_p[q][j];
748 const auto &grad_phi_u_j_non_newtonian =
749 grad_phi_u_j + transpose(grad_phi_u_j);
751 strong_jacobian_vec[q][j] +=
752 (velocity_gradient * phi_u_j + grad_phi_u_j * advective_velocity +
753 grad_phi_p_j - kinematic_viscosity * laplacian_phi_u_j -
754 grad_phi_u_j_non_newtonian * viscosity_gradient +
755 mass_source * phi_u_j);
758 grad_phi_u_j_x_velocity[j] = grad_phi_u_j * advective_velocity;
759 velocity_gradient_x_phi_u_j[j] = velocity_gradient * phi_u_j;
762 shear_rate_magnitude =
763 shear_rate_magnitude > 1e-3 ? shear_rate_magnitude : 1e-3;
765 for (
unsigned int i = 0; i < n_dofs; ++i)
767 const auto &phi_u_i = scratch_data.
phi_u[q][i];
768 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
769 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
770 const auto &phi_p_i = scratch_data.
phi_p[q][i];
771 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
774 const auto grad_phi_u_i_x_velocity =
775 grad_phi_u_i * advective_velocity;
776 const auto strong_residual_x_grad_phi_u_i =
777 strong_residual * grad_phi_u_i;
779 for (
unsigned int j = 0; j < n_dofs; ++j)
781 const auto &phi_u_j = scratch_data.
phi_u[q][j];
782 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
783 const auto &div_phi_u_j = scratch_data.
div_phi_u[q][j];
785 const auto &grad_phi_u_j_non_newtonian =
786 grad_phi_u_j + transpose(grad_phi_u_j);
788 const auto &phi_p_j =
789 pressure_scaling_factor * scratch_data.
phi_p[q][j];
791 const auto &strong_jac = strong_jacobian_vec[q][j];
793 double local_matrix_ij =
794 kinematic_viscosity *
795 scalar_product(grad_phi_u_j_non_newtonian, grad_phi_u_i) +
797 shear_rate_magnitude *
798 scalar_product(grad_phi_u_j_non_newtonian,
shear_rate) *
800 velocity_gradient_x_phi_u_j[j] * phi_u_i +
801 grad_phi_u_j_x_velocity[j] * phi_u_i - div_phi_u_i * phi_p_j +
802 mass_source * phi_u_j * phi_u_i +
804 phi_p_i * div_phi_u_j;
807 local_matrix_ij += tau * (strong_jac * grad_phi_p_i);
817 tau * (strong_jac * grad_phi_u_i_x_velocity +
818 strong_residual_x_grad_phi_u_i * phi_u_j);
820 local_matrix_ij *= JxW;
821 local_matrix(i, j) += local_matrix_ij;
834 const std::vector<double> &viscosity_vector =
837 const std::vector<double> &viscosity_for_stabilization_vector =
841 const auto &JxW_vec = scratch_data.
JxW;
842 const unsigned int n_q_points = scratch_data.
n_q_points;
843 const unsigned int n_dofs = scratch_data.
n_dofs;
851 std::vector<double> time_steps_vector =
853 const double dt = time_steps_vector[0];
854 const double sdt = 1. / dt;
857 for (
unsigned int q = 0; q < n_q_points; ++q)
860 const double kinematic_viscosity = viscosity_vector[q];
865 const Tensor<2, dim> &velocity_gradient =
867 const Tensor<1, dim> &velocity_laplacian =
869 const Tensor<3, dim> &velocity_hessian =
871 const Tensor<1, dim> &advective_velocity =
876 velocity_gradient + transpose(velocity_gradient);
881 shear_rate_magnitude =
882 shear_rate_magnitude > 1e-12 ? shear_rate_magnitude : 1e-12;
885 const Tensor<1, dim> kinematic_viscosity_gradient =
889 shear_rate_magnitude,
894 const Tensor<1, dim> pressure_gradient =
898 const Tensor<1, dim> force = scratch_data.
force[q];
902 const double u_mag = std::max(advective_velocity.norm(), 1e-12);
905 const double JxW = JxW_vec[q];
915 u_mag, viscosity_for_stabilization_vector[q], h) :
917 u_mag, viscosity_for_stabilization_vector[q], h, sdt);
921 auto strong_residual = velocity_gradient * advective_velocity +
924 kinematic_viscosity * velocity_laplacian - force +
925 mass_source *
velocity + strong_residual_vec[q];
928 for (
unsigned int i = 0; i < n_dofs; ++i)
930 const auto &phi_u_i = scratch_data.
phi_u[q][i];
931 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
932 const auto &phi_p_i = scratch_data.
phi_p[q][i];
933 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
934 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
936 double local_rhs_i = 0;
942 -kinematic_viscosity * scalar_product(
shear_rate, grad_phi_u_i) -
943 velocity_gradient * advective_velocity * phi_u_i +
944 pressure * div_phi_u_i + force * phi_u_i -
947 velocity_divergence * phi_p_i + mass_source * phi_p_i) *
951 local_rhs_i += -tau * (strong_residual * grad_phi_p_i) * JxW;
957 -tau * (strong_residual * (grad_phi_u_i * advective_velocity)) *
960 local_rhs(i) += local_rhs_i;
976 const auto &JxW = scratch_data.
JxW;
977 const unsigned int n_q_points = scratch_data.
n_q_points;
978 const unsigned int n_dofs = scratch_data.
n_dofs;
989 Tensor<1, dim> omega_vector;
998 for (
unsigned int q = 0; q < n_q_points; ++q)
1001 const std::vector<Tensor<1, dim>>
velocity = {
1006 strong_residual[q] +=
1007 2 * omega_z * (-1.) * cross_product_2d(
velocity[0]);
1013 strong_residual[q] += centrifugal;
1017 strong_residual[q] += 2 * cross_product_3d(omega_vector,
velocity[0]);
1018 strong_residual[q] += cross_product_3d(
1023 for (
unsigned int j = 0; j < n_dofs; ++j)
1025 const auto &phi_u_j = scratch_data.
phi_u[q][j];
1027 strong_jacobian[q][j] +=
1028 2 * omega_z * (-1.) * cross_product_2d(phi_u_j);
1030 strong_jacobian[q][j] +=
1031 2 * cross_product_3d(omega_vector, phi_u_j);
1035 for (
unsigned int i = 0; i < n_dofs; ++i)
1037 const auto phi_u_i = scratch_data.
phi_u[q][i];
1038 for (
unsigned int j = 0; j < n_dofs; ++j)
1040 const auto &phi_u_j = scratch_data.
phi_u[q][j];
1043 local_matrix(i, j) += 2 * omega_z * (-1.) *
1044 cross_product_2d(phi_u_j) * phi_u_i *
1048 local_matrix(i, j) += 2 *
1049 cross_product_3d(omega_vector, phi_u_j) *
1063 const auto &JxW = scratch_data.
JxW;
1065 const unsigned int n_q_points = scratch_data.
n_q_points;
1066 const unsigned int n_dofs = scratch_data.
n_dofs;
1076 Tensor<1, dim> omega_vector;
1086 for (
unsigned int q = 0; q < n_q_points; ++q)
1089 const std::vector<Tensor<1, dim>>
velocity = {
1094 strong_residual[q] +=
1095 2 * omega_z * (-1.) * cross_product_2d(
velocity[0]);
1101 strong_residual[q] += centrifugal;
1105 strong_residual[q] += 2 * cross_product_3d(omega_vector,
velocity[0]);
1106 strong_residual[q] += cross_product_3d(
1111 for (
unsigned int i = 0; i < n_dofs; ++i)
1113 const auto phi_u_i = scratch_data.
phi_u[q][i];
1117 local_rhs(i) += -2 * omega_z * (-1.) *
1118 cross_product_2d(
velocity[0]) * phi_u_i * JxW[q];
1121 cross_product_2d(omega_z * (-1.) *
1122 cross_product_2d(quadrature_points[q]));
1123 local_rhs(i) += -centrifugal * phi_u_i * JxW[q];
1127 local_rhs(i) += -2 * cross_product_3d(omega_vector,
velocity[0]) *
1130 -cross_product_3d(omega_vector,
1131 cross_product_3d(omega_vector,
1132 quadrature_points[q])) *
1151 const auto &JxW = scratch_data.
JxW;
1152 const unsigned int n_q_points = scratch_data.
n_q_points;
1153 const unsigned int n_dofs = scratch_data.
n_dofs;
1163 const Vector<double> &bdf_coefs =
1166 std::vector<Tensor<1, dim>>
velocity(1 +
1170 for (
unsigned int q = 0; q < n_q_points; ++q)
1179 strong_residual[q] += bdf_coefs[p] *
velocity[p];
1182 for (
unsigned int j = 0; j < n_dofs; ++j)
1184 strong_jacobian[q][j] += bdf_coefs[0] * scratch_data.
phi_u[q][j];
1188 for (
unsigned int i = 0; i < n_dofs; ++i)
1190 const Tensor<1, dim> &phi_u_i = scratch_data.
phi_u[q][i];
1191 for (
unsigned int j = 0; j < n_dofs; ++j)
1193 const Tensor<1, dim> &phi_u_j = scratch_data.
phi_u[q][j];
1195 local_matrix(i, j) += phi_u_j * phi_u_i * bdf_coefs[0] * JxW[q];
1208 const auto &JxW = scratch_data.
JxW;
1209 const unsigned int n_q_points = scratch_data.
n_q_points;
1210 const unsigned int n_dofs = scratch_data.
n_dofs;
1219 const Vector<double> &bdf_coefs =
1222 std::vector<Tensor<1, dim>>
velocity(1 +
1226 for (
unsigned int q = 0; q < n_q_points; ++q)
1235 strong_residual[q] += (bdf_coefs[p] *
velocity[p]);
1239 for (
unsigned int i = 0; i < n_dofs; ++i)
1241 const auto phi_u_i = scratch_data.
phi_u[q][i];
1242 double local_rhs_i = 0;
1246 local_rhs_i -= bdf_coefs[p] * (
velocity[p] * phi_u_i);
1248 local_rhs(i) += local_rhs_i * JxW[q];
1263 const auto &JxW = scratch_data.
JxW;
1264 const unsigned int n_q_points = scratch_data.
n_q_points;
1265 const unsigned int n_dofs = scratch_data.
n_dofs;
1272 std::vector<double> time_steps_vector =
1274 const double h = time_steps_vector[0];
1279 std::vector<Tensor<1, dim>>
velocity(2);
1282 for (
unsigned int q = 0; q < n_q_points; ++q)
1287 strong_residual[q] +=
1291 for (
unsigned int j = 0; j < n_dofs; ++j)
1293 strong_jacobian[q][j] +=
1294 scratch_data.
phi_u[q][j] / (h * stage_data.
a_ij[0]);
1297 for (
unsigned int i = 0; i < n_dofs; ++i)
1299 const Tensor<1, dim> &phi_u_i = scratch_data.
phi_u[q][i];
1300 for (
unsigned int j = 0; j < n_dofs; ++j)
1302 const Tensor<1, dim> &phi_u_j = scratch_data.
phi_u[q][j];
1304 local_matrix(i, j) +=
1305 ((phi_u_j * phi_u_i) / (h * stage_data.
a_ij[0])) * JxW[q];
1318 const auto &JxW = scratch_data.
JxW;
1319 const unsigned int n_q_points = scratch_data.
n_q_points;
1320 const unsigned int n_dofs = scratch_data.
n_dofs;
1328 std::vector<double> time_steps_vector =
1330 const double h = time_steps_vector[0];
1332 std::vector<Tensor<1, dim>>
velocity(2);
1335 for (
unsigned int q = 0; q < n_q_points; ++q)
1340 strong_residual[q] +=
1344 for (
unsigned int i = 0; i < n_dofs; ++i)
1346 const auto phi_u_i = scratch_data.
phi_u[q][i];
1347 double local_rhs_i = 0;
1348 local_rhs_i -= (1 / (h * stage_data.
a_ij[0])) * phi_u_i *
1352 local_rhs(i) += local_rhs_i * JxW[q];
1367 const std::vector<double> &kinematic_viscosity =
1371 const auto &JxW_vec = scratch_data.
JxW;
1372 const unsigned int n_q_points = scratch_data.
n_q_points;
1373 const unsigned int n_dofs = scratch_data.
n_dofs;
1379 std::vector<Tensor<1, dim>> grad_phi_u_j_x_velocity(n_dofs);
1380 std::vector<Tensor<1, dim>> velocity_gradient_x_phi_u_j(n_dofs);
1386 for (
unsigned int q = 0; q < n_q_points; ++q)
1389 const Tensor<2, dim> &velocity_gradient =
1391 const Tensor<1, dim> &advective_velocity =
1395 const double JxW = JxW_vec[q];
1399 for (
unsigned int j = 0; j < n_dofs; ++j)
1401 const auto &phi_u_j = scratch_data.
phi_u[q][j];
1402 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
1405 grad_phi_u_j_x_velocity[j] = grad_phi_u_j * advective_velocity;
1406 velocity_gradient_x_phi_u_j[j] = velocity_gradient * phi_u_j;
1409 for (
unsigned int i = 0; i < n_dofs; ++i)
1411 const auto &phi_u_i = scratch_data.
phi_u[q][i];
1412 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
1413 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
1414 const auto &phi_p_i = scratch_data.
phi_p[q][i];
1416 for (
unsigned int j = 0; j < n_dofs; ++j)
1418 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
1419 const auto &div_phi_u_j = scratch_data.
div_phi_u[q][j];
1421 const auto &phi_p_j =
1422 pressure_scaling_factor * scratch_data.
phi_p[q][j];
1424 const auto &grad_phi_u_j_non_newtonian =
1425 grad_phi_u_j + transpose(grad_phi_u_j);
1427 double local_matrix_ij =
1428 kinematic_viscosity[q] *
1429 scalar_product(grad_phi_u_j_non_newtonian, grad_phi_u_i) +
1430 velocity_gradient_x_phi_u_j[j] * phi_u_i +
1431 grad_phi_u_j_x_velocity[j] * phi_u_i - div_phi_u_i * phi_p_j -
1433 phi_p_i * div_phi_u_j +
gamma * div_phi_u_j * div_phi_u_i +
1437 local_matrix_ij *= JxW;
1438 local_matrix(i, j) += local_matrix_ij;
1451 const std::vector<double> &kinematic_viscosity_vector =
1455 const auto &JxW_vec = scratch_data.
JxW;
1456 const unsigned int n_q_points = scratch_data.
n_q_points;
1457 const unsigned int n_dofs = scratch_data.
n_dofs;
1463 for (
unsigned int q = 0; q < n_q_points; ++q)
1466 const double kinematic_viscosity = kinematic_viscosity_vector[q];
1470 const Tensor<2, dim> &velocity_gradient =
1472 const Tensor<1, dim> &advective_velocity =
1477 velocity_gradient + transpose(velocity_gradient);
1483 const Tensor<1, dim> &force = scratch_data.
force[q];
1486 const double JxW = JxW_vec[q];
1489 for (
unsigned int i = 0; i < n_dofs; ++i)
1491 const auto phi_u_i = scratch_data.
phi_u[q][i];
1492 const auto grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
1493 const auto phi_p_i = scratch_data.
phi_p[q][i];
1494 const auto div_phi_u_i = scratch_data.
div_phi_u[q][i];
1496 double local_rhs_i = 0;
1502 -kinematic_viscosity * scalar_product(
shear_rate, grad_phi_u_i) -
1503 velocity_gradient * advective_velocity * phi_u_i +
1504 pressure * div_phi_u_i + force * phi_u_i +
1506 velocity_divergence * phi_p_i -
1507 gamma * velocity_divergence * div_phi_u_i) *
1510 local_rhs(i) += local_rhs_i;
1526 const std::vector<double> &kinematic_viscosity_vector =
1530 const auto &JxW_vec = scratch_data.
JxW;
1531 const unsigned int n_q_points = scratch_data.
n_q_points;
1532 const unsigned int n_dofs = scratch_data.
n_dofs;
1538 std::vector<Tensor<1, dim>> grad_phi_u_j_x_velocity(n_dofs);
1539 std::vector<Tensor<1, dim>> velocity_gradient_x_phi_u_j(n_dofs);
1545 for (
unsigned int q = 0; q < n_q_points; ++q)
1548 const double kinematic_viscosity = kinematic_viscosity_vector[q];
1551 const Tensor<2, dim> &velocity_gradient =
1553 const Tensor<1, dim> &advective_velocity =
1557 const double JxW = JxW_vec[q];
1561 for (
unsigned int j = 0; j < n_dofs; ++j)
1563 const auto &phi_u_j = scratch_data.
phi_u[q][j];
1564 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
1567 grad_phi_u_j_x_velocity[j] = grad_phi_u_j * advective_velocity;
1568 velocity_gradient_x_phi_u_j[j] = velocity_gradient * phi_u_j;
1571 for (
unsigned int i = 0; i < n_dofs; ++i)
1573 const auto &phi_u_i = scratch_data.
phi_u[q][i];
1574 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
1575 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
1576 const auto &phi_p_i = scratch_data.
phi_p[q][i];
1578 for (
unsigned int j = 0; j < n_dofs; ++j)
1580 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
1581 const auto &div_phi_u_j = scratch_data.
div_phi_u[q][j];
1583 const auto &phi_p_j =
1584 pressure_scaling_factor * scratch_data.
phi_p[q][j];
1586 double local_matrix_ij =
1587 kinematic_viscosity *
1588 scalar_product(grad_phi_u_j, grad_phi_u_i) +
1589 velocity_gradient_x_phi_u_j[j] * phi_u_i +
1590 grad_phi_u_j_x_velocity[j] * phi_u_i - div_phi_u_i * phi_p_j -
1592 phi_p_i * div_phi_u_j +
gamma * div_phi_u_j * div_phi_u_i +
1596 local_matrix_ij *= JxW;
1597 local_matrix(i, j) += local_matrix_ij;
1610 const std::vector<double> &kinematic_viscosity_vector =
1614 const auto &JxW_vec = scratch_data.
JxW;
1615 const unsigned int n_q_points = scratch_data.
n_q_points;
1616 const unsigned int n_dofs = scratch_data.
n_dofs;
1622 for (
unsigned int q = 0; q < n_q_points; ++q)
1625 const double kinematic_viscosity = kinematic_viscosity_vector[q];
1629 const Tensor<2, dim> &velocity_gradient =
1631 const Tensor<1, dim> &advective_velocity =
1638 const Tensor<1, dim> &force = scratch_data.
force[q];
1641 const double JxW = JxW_vec[q];
1644 for (
unsigned int i = 0; i < n_dofs; ++i)
1646 const auto &phi_u_i = scratch_data.
phi_u[q][i];
1647 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
1648 const auto &phi_p_i = scratch_data.
phi_p[q][i];
1649 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
1651 double local_rhs_i = 0;
1656 -kinematic_viscosity *
1657 scalar_product(velocity_gradient, grad_phi_u_i) -
1658 velocity_gradient * advective_velocity * phi_u_i +
1659 pressure * div_phi_u_i + force * phi_u_i +
1661 velocity_divergence * phi_p_i -
1662 gamma * velocity_divergence * div_phi_u_i) *
1665 local_rhs(i) += local_rhs_i;
1682 const auto &JxW_vec = scratch_data.
JxW;
1683 const unsigned int n_q_points = scratch_data.
n_q_points;
1684 const unsigned int n_dofs = scratch_data.
n_dofs;
1686 const double h = scratch_data.
cell_size;
1691 std::vector<double> time_steps_vector =
1695 for (
unsigned int q = 0; q < n_q_points; ++q)
1698 const double JxW = JxW_vec[q];
1700 for (
unsigned int i = 0; i < n_dofs; ++i)
1702 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
1703 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
1705 for (
unsigned int j = 0; j < n_dofs; ++j)
1707 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
1708 const auto &grad_phi_p_j = scratch_data.
grad_phi_p[q][j];
1714 double local_matrix_ij =
1715 kinematic_viscosity *
1716 scalar_product(grad_phi_u_j, grad_phi_u_i);
1719 local_matrix_ij += 1 / kinematic_viscosity * h *
1720 scalar_product(grad_phi_p_j, grad_phi_p_i);
1728 local_matrix_ij *= JxW;
1729 local_matrix(i, j) += local_matrix_ij;
1742 const auto &JxW_vec = scratch_data.
JxW;
1743 const unsigned int n_q_points = scratch_data.
n_q_points;
1744 const unsigned int n_dofs = scratch_data.
n_dofs;
1747 const double h = scratch_data.
cell_size;
1750 std::vector<double> time_steps_vector =
1754 for (
unsigned int q = 0; q < n_q_points; ++q)
1757 const Tensor<2, dim> &velocity_gradient =
1761 const Tensor<1, dim> &pressure_gradient =
1765 const double JxW = JxW_vec[q];
1769 for (
unsigned int i = 0; i < n_dofs; ++i)
1771 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
1772 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
1775 double local_rhs_i = 0;
1778 local_rhs_i += -kinematic_viscosity *
1779 scalar_product(velocity_gradient, grad_phi_u_i) * JxW;
1783 local_rhs_i += -1 / kinematic_viscosity * h *
1784 scalar_product(pressure_gradient, grad_phi_p_i) * JxW;
1788 local_rhs(i) += local_rhs_i;
1806 const unsigned int n_q_points = scratch_data.
n_q_points;
1810 for (
unsigned int q = 0; q < n_q_points; ++q)
1812 strong_residual[q] +=
1827 const auto &JxW_vec = scratch_data.
JxW;
1828 const unsigned int n_q_points = scratch_data.
n_q_points;
1829 const unsigned int n_dofs = scratch_data.
n_dofs;
1836 for (
unsigned int q = 0; q < n_q_points; ++q)
1839 const Tensor<1, dim> &force = scratch_data.
force[q];
1844 const double JxW = JxW_vec[q];
1849 strong_residual[q] += force * thermal_expansion *
1853 for (
unsigned int i = 0; i < n_dofs; ++i)
1855 const auto phi_u_i = scratch_data.
phi_u[q][i];
1857 local_rhs(i) -= force * thermal_expansion *
1874 const auto &JxW_vec = scratch_data.
JxW;
1875 const unsigned int n_q_points = scratch_data.
n_q_points;
1876 const unsigned int n_dofs = scratch_data.
n_dofs;
1886 for (
unsigned int q = 0; q < n_q_points; ++q)
1889 const double JxW = JxW_vec[q];
1891 double current_temperature = temperatures[q];
1895 const double liquid_fraction =
1897 std::max((current_temperature -
1902 double darcy_penalty =
1906 strong_residual[q] += darcy_penalty * velocities[q];
1908 for (
unsigned int j = 0; j < n_dofs; ++j)
1910 strong_jacobian[q][j] += darcy_penalty * scratch_data.
phi_u[q][j];
1913 for (
unsigned int i = 0; i < n_dofs; ++i)
1915 const auto &phi_u_i = scratch_data.
phi_u[q][i];
1916 for (
unsigned int j = 0; j < n_dofs; ++j)
1918 const auto &phi_u_j = scratch_data.
phi_u[q][j];
1919 local_matrix(i, j) += darcy_penalty * phi_u_i * phi_u_j * JxW;
1932 const auto &JxW_vec = scratch_data.
JxW;
1933 const unsigned int n_q_points = scratch_data.
n_q_points;
1934 const unsigned int n_dofs = scratch_data.
n_dofs;
1943 for (
unsigned int q = 0; q < n_q_points; ++q)
1946 const double JxW = JxW_vec[q];
1948 double current_temperature = temperatures[q];
1952 const double liquid_fraction =
1954 std::max((current_temperature -
1959 double darcy_penalty =
1963 strong_residual[q] += darcy_penalty * velocities[q];
1966 for (
unsigned int i = 0; i < n_dofs; ++i)
1968 const auto phi_u_i = scratch_data.
phi_u[q][i];
1971 local_rhs(i) -= darcy_penalty * velocities[q] * phi_u_i * JxW;
1986 const auto &JxW_vec = scratch_data.
JxW;
1987 const unsigned int n_q_points = scratch_data.
n_q_points;
1988 const unsigned int n_dofs = scratch_data.
n_dofs;
1998 for (
unsigned int q = 0; q < n_q_points; ++q)
2001 const double JxW = JxW_vec[q];
2005 double kinematic_viscosity = kinematic_viscosity_values[q];
2008 const double liquid_fraction =
2015 const double carman_kozeny_penalty_denominator_inv =
2020 const double carman_kozeny_penalty =
2022 Utilities::fixed_power<2>(1 - liquid_fraction) *
2023 carman_kozeny_penalty_denominator_inv;
2025 strong_residual[q] += carman_kozeny_penalty * velocities[q];
2027 for (
unsigned int j = 0; j < n_dofs; ++j)
2029 strong_jacobian[q][j] +=
2030 carman_kozeny_penalty * scratch_data.
phi_u[q][j];
2033 for (
unsigned int i = 0; i < n_dofs; ++i)
2035 const auto &phi_u_i = scratch_data.
phi_u[q][i];
2036 for (
unsigned int j = 0; j < n_dofs; ++j)
2038 const auto &phi_u_j = scratch_data.
phi_u[q][j];
2039 local_matrix(i, j) +=
2040 carman_kozeny_penalty * phi_u_i * phi_u_j * JxW;
2053 const auto &JxW_vec = scratch_data.
JxW;
2054 const unsigned int n_q_points = scratch_data.
n_q_points;
2055 const unsigned int n_dofs = scratch_data.
n_dofs;
2065 for (
unsigned int q = 0; q < n_q_points; ++q)
2068 const double JxW = JxW_vec[q];
2072 double kinematic_viscosity = kinematic_viscosity_values[q];
2075 const double liquid_fraction =
2082 const double carman_kozeny_penalty_denominator_inv =
2087 const double carman_kozeny_penalty =
2089 Utilities::fixed_power<2>(1 - liquid_fraction) *
2090 carman_kozeny_penalty_denominator_inv;
2092 strong_residual[q] += carman_kozeny_penalty * velocities[q];
2095 for (
unsigned int i = 0; i < n_dofs; ++i)
2097 const auto phi_u_i = scratch_data.
phi_u[q][i];
2100 local_rhs(i) -= carman_kozeny_penalty * velocities[q] * phi_u_i * JxW;
2123 Tensor<2, dim> identity;
2124 for (
int d = 0; d < dim; ++d)
2129 std::vector<std::vector<std::vector<Tensor<1, dim>>>> gn_j;
2130 gn_j = std::vector<std::vector<std::vector<Tensor<1, dim>>>>(
2133 std::vector<Tensor<1, dim>>(
2139 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2153 const double JxW = scratch_data.
face_JxW[f][q];
2154 for (
const unsigned int j :
2158 (-kinematic_viscosity *
2162 for (
const unsigned int i :
2165 for (
const unsigned int j :
2168 local_matrix[i][j] +=
2169 -scratch_data.
face_phi_u[f][q][i] * gn_j[f][q][j] *
2192 Tensor<2, dim> identity;
2193 for (
int d = 0; d < dim; ++d)
2197 std::vector<std::vector<double>> prescribed_pressure_values;
2198 prescribed_pressure_values = std::vector<std::vector<double>>(
2201 std::vector<std::vector<Tensor<1, dim>>> gn_bc =
2202 std::vector<std::vector<Tensor<1, dim>>>(scratch_data.
n_faces,
2203 std::vector<Tensor<1, dim>>(
2213 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2232 const double JxW = scratch_data.
face_JxW[f][q];
2233 prescribed_pressure_values[f][q] =
2237 (-prescribed_pressure_values[f][q] * identity -
2238 kinematic_viscosity *
2241 for (
const unsigned int i :
2245 -scratch_data.
face_phi_u[f][q][i] * (gn_bc[f][q]) * JxW;
2273 std::vector<std::vector<Tensor<1, dim>>> traction_vec_data =
2274 std::vector<std::vector<Tensor<1, dim>>>(scratch_data.
n_faces,
2275 std::vector<Tensor<1, dim>>(
2293 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2307 const double JxW = scratch_data.
face_JxW[f][q];
2310 traction_vec_data[f][q][0] =
2313 ->traction_fn.value(
2315 traction_vec_data[f][q][1] =
2318 ->traction_fn.value(
2320 if constexpr (dim == 3)
2321 traction_vec_data[f][q][2] =
2323 .navier_stokes_functions.at(boundary_id)
2324 ->traction_fn.value(
2327 for (
const unsigned int i :
2330 local_rhs(i) -= -scratch_data.
face_phi_u[f][q][i] *
2331 (traction_vec_data[f][q]) * JxW;
2354 Tensor<2, dim> identity;
2355 for (
int d = 0; d < dim; ++d)
2359 std::vector<std::vector<Tensor<1, dim>>> prescribed_velocity_values;
2360 prescribed_velocity_values =
2361 std::vector<std::vector<Tensor<1, dim>>>(scratch_data.
n_faces,
2362 std::vector<Tensor<1, dim>>(
2364 const FiniteElement<dim> &fe = scratch_data.
fe_face_values.get_fe();
2366 const double penalty_parameter =
2367 1. / std::pow(scratch_data.
cell_size, fe.degree + 1);
2371 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2387 const double JxW = scratch_data.
face_JxW[f][q];
2388 for (
const unsigned int i :
2391 const auto comp_i = fe.system_to_component_index(i).first;
2394 for (
const unsigned int j :
2398 fe.system_to_component_index(j).first;
2399 if (comp_i == comp_j)
2402 penalty_parameter * beta *
2406 double grad_phi_terms =
2407 ((kinematic_viscosity *
2412 double surface_stress_term =
2413 (kinematic_viscosity *
2418 local_matrix(i, j) += +beta_terms -
2420 surface_stress_term;
2444 Tensor<2, dim> identity;
2445 for (
int d = 0; d < dim; ++d)
2449 std::vector<std::vector<Tensor<1, dim>>> prescribed_velocity_values =
2450 std::vector<std::vector<Tensor<1, dim>>>(scratch_data.
n_faces,
2451 std::vector<Tensor<1, dim>>(
2454 const FiniteElement<dim> &fe = scratch_data.
fe_face_values.get_fe();
2456 const double penalty_parameter =
2457 1. / std::pow(scratch_data.
cell_size, fe.degree + 1);
2460 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2480 const double JxW = scratch_data.
face_JxW[f][q];
2481 for (
int d = 0; d < dim; ++d)
2483 prescribed_velocity_values[f][q][d] = function_v.
value(
2486 for (
const unsigned int i :
2489 const auto comp_i = fe.system_to_component_index(i).first;
2493 penalty_parameter * beta *
2495 prescribed_velocity_values[f][q][comp_i]) *
2496 scratch_data.
face_phi_u[f][q][i][comp_i] * JxW;
2497 double grad_phi_terms =
2498 ((kinematic_viscosity *
2500 prescribed_velocity_values[f][q])) *
2504 double surface_stress_term =
2505 (kinematic_viscosity *
2512 -beta_terms + grad_phi_terms + surface_stress_term;
2537 Tensor<2, dim> identity;
2538 for (
int d = 0; d < dim; ++d)
2542 std::vector<std::vector<Tensor<1, dim>>> prescribed_velocity_values;
2543 prescribed_velocity_values =
2544 std::vector<std::vector<Tensor<1, dim>>>(scratch_data.
n_faces,
2545 std::vector<Tensor<1, dim>>(
2547 const FiniteElement<dim> &fe = scratch_data.
fe_face_values.get_fe();
2549 const double penalty_parameter =
2550 1. / std::pow(scratch_data.
cell_size, fe.degree + 1);
2554 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2566 const double boundary_layer_thickness =
2568 const double beta_tangent =
2569 kinematic_viscosity / boundary_layer_thickness;
2574 const double JxW = scratch_data.
face_JxW[f][q];
2575 for (
const unsigned int i :
2578 const auto comp_i = fe.system_to_component_index(i).first;
2581 for (
const unsigned int j :
2585 fe.system_to_component_index(j).first;
2586 if (comp_i == comp_j)
2588 double beta_terms_normal =
2589 penalty_parameter * beta *
2595 double beta_terms_tangent =
2628 local_matrix(i, j) +=
2629 +beta_terms_normal +
2657 Tensor<2, dim> identity;
2658 for (
int d = 0; d < dim; ++d)
2662 std::vector<std::vector<Tensor<1, dim>>> prescribed_velocity_values =
2663 std::vector<std::vector<Tensor<1, dim>>>(scratch_data.
n_faces,
2664 std::vector<Tensor<1, dim>>(
2667 const FiniteElement<dim> &fe = scratch_data.
fe_face_values.get_fe();
2669 const double penalty_parameter =
2670 1. / std::pow(scratch_data.
cell_size, fe.degree + 1);
2673 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2686 const double boundary_layer_thickness =
2688 const double beta_tangent =
2689 kinematic_viscosity / boundary_layer_thickness;
2697 const double JxW = scratch_data.
face_JxW[f][q];
2698 for (
int d = 0; d < dim; ++d)
2700 prescribed_velocity_values[f][q][d] = function_v.
value(
2703 for (
const unsigned int i :
2706 const auto comp_i = fe.system_to_component_index(i).first;
2709 double beta_terms_normal =
2711 penalty_parameter * beta *
2715 prescribed_velocity_values[f][q][comp_i]) *
2716 scratch_data.
face_phi_u[f][q][i][comp_i] * JxW;
2717 double beta_terms_tangent =
2724 (prescribed_velocity_values[f][q][comp_i] -
2727 prescribed_velocity_values[f][q][comp_i]))) *
2728 scratch_data.
face_phi_u[f][q][i][comp_i] * JxW;
2750 -beta_terms_normal -
2773 const FiniteElement<dim> &fe = scratch_data.
fe_face_values.get_fe();
2775 const double penalty_parameter =
2776 1. / std::pow(scratch_data.
cell_size, fe.degree + 1);
2780 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2796 const double JxW = scratch_data.
face_JxW[f][q];
2797 for (
const unsigned int i :
2800 double normal_outflux =
2805 const auto comp_i = fe.system_to_component_index(i).first;
2808 for (
const unsigned int j :
2812 fe.system_to_component_index(j).first;
2813 if (comp_i == comp_j)
2816 penalty_parameter * beta * normal_outflux *
2821 local_matrix(i, j) += -beta_terms;
2841 const FiniteElement<dim> &fe = scratch_data.
fe_face_values.get_fe();
2843 const double penalty_parameter =
2844 1. / std::pow(scratch_data.
cell_size, fe.degree + 1);
2848 for (
unsigned int f = 0; f < scratch_data.
n_faces; ++f)
2864 const double JxW = scratch_data.
face_JxW[f][q];
2865 for (
const unsigned int i :
2871 double normal_outflux =
2876 const auto comp_i = fe.system_to_component_index(i).first;
2880 penalty_parameter * beta * normal_outflux *
2885 local_rhs(i) += +beta_terms;
unsigned int number_of_previous_solutions(const Parameters::SimulationControl::TimeSteppingMethod method)
Get the number of previous time steps for a specific BDF scheme.
Class that assembles the core of the Navier-Stokes equation. According to the following weak form: ...
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
This class implements a pressure boundary condition for the Navier-Stokes equations.
double value(const Point< dim > &point, unsigned int component) const override
Calculates the value of a Function-type fluid dynamics equations.
This class implements a boundary conditions for the fluid dynamics solver where the velocity componen...
double value(const Point< dim > &point, const unsigned int component) const override
Calculates the value of a Function-type fluid dynamics equations.
Class that assembles the transient time arising from BDF time integration for the Navier Stokes equat...
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
const std::shared_ptr< SimulationControl > simulation_control
Class that assembles the core of the Navier-Stokes equation. According to the following weak form: ...
const std::shared_ptr< SimulationControl > simulation_control
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
Class that assembles the core of the Navier-Stokes equation using a Rheological model to predict non-...
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
const std::shared_ptr< SimulationControl > simulation_control
Tensor< 1, dim > get_kinematic_viscosity_gradient(const Tensor< 2, dim > &velocity_gradient, const Tensor< 3, dim > &velocity_hessians, const double shear_rate_magnitude, const double grad_kinematic_viscosity_shear_rate) const
Calculates an approximation of the gradient of the kinematic viscosity.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
Class that assembles the transient term arising from SDIRK time integration for the Navier Stokes equ...
const std::shared_ptr< SimulationControl > simulation_control
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
Class that assembles the coriolis and the centrifugal if a simulation is carried out in a rotating fr...
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
Parameters::VelocitySource velocity_sources
Class that assembles a Poisson problem for all velocity components and pressure variables....
const std::shared_ptr< SimulationControl > simulation_control
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
Class that stores the information required by the assembly procedure for a Navier-Stokes equation....
Table< 2, Tensor< 1, dim > > face_normal
Table< 2, double > div_phi_u
std::vector< double > mass_source
std::vector< double > pressure_values
std::vector< Tensor< 1, dim > > sdirk_stage_sum
std::vector< Tensor< 1, dim > > force
Table< 2, double > face_JxW
double pressure_scaling_factor
SDIRKTable sdirk_table
SDIRK Butcher table with coefficients for the SDIRK time-stepping method.
Table< 3, Tensor< 2, dim > > face_grad_phi_u
std::vector< Tensor< 3, dim > > velocity_hessians
std::vector< std::vector< Tensor< 1, dim > > > previous_velocity_values
std::vector< unsigned int > components
std::vector< Tensor< 2, dim > > velocity_gradients
unsigned int n_faces_q_points
std::vector< Point< dim > > quadrature_points
Table< 2, Tensor< 1, dim > > phi_u
std::vector< Tensor< 1, dim > > advective_velocity
double kinematic_viscosity_scale
std::vector< double > kinematic_viscosity
std::vector< bool > is_boundary_face
std::vector< Tensor< 1, dim > > velocity_values
Table< 2, Tensor< 2, dim > > grad_phi_u
Table< 2, Tensor< 1, dim > > laplacian_phi_u
std::vector< std::vector< Tensor< 1, dim > > > face_velocity_values
Table< 3, Tensor< 1, dim > > face_phi_u
std::vector< double > temperature_values
std::vector< unsigned int > boundary_face_id
std::vector< double > kinematic_viscosity_for_stabilization
std::vector< double > velocity_divergences
std::vector< std::vector< Tensor< 2, dim > > > face_velocity_gradients
Table< 2, Tensor< 1, dim > > grad_phi_p
FEFaceValues< dim > fe_face_values
std::vector< double > grad_kinematic_viscosity_shear_rate
std::vector< std::vector< Point< dim > > > face_quadrature_points
std::vector< Tensor< 1, dim > > pressure_gradients
std::vector< double > thermal_expansion
std::vector< Tensor< 1, dim > > velocity_laplacians
Class that assembles a Neumann traction boundary condition. According to the following weak form: a...
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > & neumann_traction_boundary_condition
Class that assembles the weak formulation of an outlet boundary condition according to the following ...
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > & boundary_conditions
Class that assembles the core of the Navier-Stokes equation. According to the following weak form: ...
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
const std::shared_ptr< SimulationControl > simulation_control
Class that assembles the special case of partial slip condition using the weak formulation of a Diric...
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > & boundary_conditions
Assembler of the non-linear Carman-Kozeny permeability model for simulations with phase change.
const double carman_kozeny_permeability_area_inv
One over the permeability area of the pseudo-porous bed (solid phase).
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the right-hand side (rhs) of:
const double liquidus_temperature
Liquidus temperature.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assembles the matrix of:
const double solidus_temperature
Solidus temperature.
const double carman_kozeny_tolerance
Tolerance in the Carman-Kozeny source term that avoids division by zero.
Class that assembles a phase change Darcy forcing term. This term adds to the right hand-side of the...
const Parameters::PhaseChange phase_change_parameters
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix of:
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the weak form of:
Class that assembles a Neumann boundary condition. According to the following weak form: (p-mu*grad_u...
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > & pressure_boundary_conditions
std::vector< double > a_ij
Class responsible for storing the information calculated using the assembly of stabilized Tensor<1,...
FullMatrix< double > local_matrix
Vector< double > local_rhs
std::vector< Tensor< 1, dim > > strong_residual
std::vector< std::vector< Tensor< 1, dim > > > strong_jacobian
Class that assembles a thermal buoyancy forcing term using the Boussinesq approximation....
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the weak form of:
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Adds the buoyancy force to the strong residual used by the stabilization terms of the...
const double reference_temperature
Class that assembles the weak formulation of a Dirichlet boundary condition using the Nitsche method....
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_rhs Assembles the rhs
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
assemble_matrix Assembles the matrix
const BoundaryConditions::FluidDynamicsBoundaryConditions< dim > & boundary_conditions
@ velocity
Velocity vector field from fluid dynamics.
@ pressure
Pressure scalar field from fluid dynamics.
@ temperature
Temperature scalar field from heat transfer.
double calculate_shear_rate_magnitude(const Tensor< 2, dim > shear_rate)
Calculates the magnitude of the shear rate tensor given as input.
Simulation control classes for managing time-stepping and iteration control in Lethe.
double calculate_navier_stokes_gls_tau_transient(const double u_mag, const double kinematic_viscosity, const double h, const double sdt)
Calculate the stabilization parameter for the transient Navier-Stokes equations.
double calculate_navier_stokes_gls_tau_steady(const double u_mag, const double kinematic_viscosity, const double h)
Calculate the stabilization parameter for the Navier-Stokes equations in steady-state.