12#include <deal.II/base/tensor.h>
21 template <
typename CurlType>
23 extract_out_of_plane_vorticity(
const CurlType &curl)
25 if constexpr (std::is_arithmetic_v<std::decay_t<CurlType>>)
39 const std::vector<double> &viscosity_vector =
43 const auto &JxW_vec = scratch_data.
JxW;
44 const unsigned int n_q_points = scratch_data.
n_q_points;
45 const unsigned int n_dofs = scratch_data.
n_dofs;
54 std::vector<double> time_steps_vector =
56 const double dt = time_steps_vector[0];
57 const double sdt = 1. / dt;
60 for (
unsigned int q = 0; q < n_q_points; ++q)
63 const double kinematic_viscosity = viscosity_vector[q];
65 const Tensor<1, dim> previous_velocity =
67 const Tensor<2, dim> velocity_gradient =
69 const Tensor<1, dim> velocity_laplacian =
72 const Tensor<1, dim> pressure_gradient =
76 const Tensor<1, dim> void_fraction_gradients =
80 const Tensor<1, dim> force = scratch_data.
force[q];
86 if (
cfd_dem.implicit_stabilization)
87 u_mag = std::max(
velocity.norm(), 1e-12);
91 this->simulation_control->get_time_step())
92 u_mag = std::max(
velocity.norm(), 1e-12);
94 u_mag = std::max(previous_velocity.norm(), 1e-12);
102 const double JxW = JxW_vec[q];
124 + pressure_gradient -
126 kinematic_viscosity * velocity_laplacian -
130 const double pressure_scaling_factor =
135 for (
unsigned int j = 0; j < n_dofs; ++j)
137 const auto &phi_u_j = scratch_data.
phi_u[q][j];
138 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
141 const auto &grad_phi_p_j =
142 pressure_scaling_factor * scratch_data.
grad_phi_p[q][j];
144 strong_jacobian_vec[q][j] +=
148 mass_source * phi_u_j +
152 - kinematic_viscosity * laplacian_phi_u_j);
155 for (
unsigned int i = 0; i < n_dofs; ++i)
157 const int component_i = scratch_data.
components[i];
158 const auto &phi_u_i = scratch_data.
phi_u[q][i];
159 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
160 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
161 const auto &phi_p_i = scratch_data.
phi_p[q][i];
162 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
164 for (
unsigned int j = 0; j < n_dofs; ++j)
166 const int component_j = scratch_data.
components[j];
167 const auto &phi_u_j = scratch_data.
phi_u[q][j];
168 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
169 const auto &div_phi_u_j = scratch_data.
div_phi_u[q][j];
171 const auto &phi_p_j =
172 pressure_scaling_factor * scratch_data.
phi_p[q][j];
174 const auto &strong_jac = strong_jacobian_vec[q][j];
177 double local_matrix_ij =
178 component_j == dim ? -div_phi_u_i * phi_p_j : 0;
180 if (component_i == dim)
185 (phi_u_j * void_fraction_gradients));
188 local_matrix_ij += tau * (strong_jac * grad_phi_p_i);
191 if (component_i < dim && component_j < dim)
198 if (component_i == component_j)
202 kinematic_viscosity * (grad_phi_u_j[component_j] *
203 grad_phi_u_i[component_i])
205 + mass_source * phi_u_j * phi_u_i;
214 if (
SUPG && component_i < dim)
217 tau * (strong_jac * grad_phi_u_i *
velocity +
218 strong_residual * grad_phi_u_i * phi_u_j);
224 local_matrix_ij += gamma *
226 phi_u_j * void_fraction_gradients) *
230 local_matrix_ij *= JxW;
231 local_matrix(i, j) += local_matrix_ij;
244 const std::vector<double> &viscosity_vector =
248 const auto &JxW_vec = scratch_data.
JxW;
249 const unsigned int n_q_points = scratch_data.
n_q_points;
250 const unsigned int n_dofs = scratch_data.
n_dofs;
258 std::vector<double> time_steps_vector =
260 const double dt = time_steps_vector[0];
261 const double sdt = 1. / dt;
264 for (
unsigned int q = 0; q < n_q_points; ++q)
267 const double kinematic_viscosity = viscosity_vector[q];
271 const Tensor<1, dim> previous_velocity =
274 const Tensor<2, dim> velocity_gradient =
276 const Tensor<1, dim> velocity_laplacian =
281 const Tensor<1, dim> pressure_gradient =
286 const Tensor<1, dim> void_fraction_gradients =
290 const Tensor<1, dim> force = scratch_data.
force[q];
296 if (
cfd_dem.implicit_stabilization)
297 u_mag = std::max(
velocity.norm(), 1e-12);
301 this->simulation_control->get_time_step())
302 u_mag = std::max(
velocity.norm(), 1e-12);
304 u_mag = std::max(previous_velocity.norm(), 1e-12);
312 const double JxW = JxW_vec[q];
334 + pressure_gradient -
336 kinematic_viscosity * velocity_laplacian -
340 for (
unsigned int i = 0; i < n_dofs; ++i)
342 const int component_i = scratch_data.
components[i];
343 const auto phi_u_i = scratch_data.
phi_u[q][i];
344 const auto grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
345 const auto phi_p_i = scratch_data.
phi_p[q][i];
346 const auto grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
347 const auto div_phi_u_i = scratch_data.
div_phi_u[q][i];
349 double local_rhs_i = 0;
352 if (component_i < dim)
355 -kinematic_viscosity *
356 scalar_product(velocity_gradient, grad_phi_u_i) -
363 if (component_i == dim)
366 velocity * void_fraction_gradients - mass_source) *
370 local_rhs_i += -tau * (strong_residual * grad_phi_p_i);
373 if (
SUPG && component_i < dim)
376 -tau * (strong_residual * (grad_phi_u_i *
velocity));
382 local_rhs_i -= gamma *
384 velocity * void_fraction_gradients) *
388 local_rhs(i) += local_rhs_i * JxW;
403 const std::vector<double> &viscosity_vector =
407 const auto &JxW_vec = scratch_data.
JxW;
408 const unsigned int n_q_points = scratch_data.
n_q_points;
409 const unsigned int n_dofs = scratch_data.
n_dofs;
418 std::vector<double> time_steps_vector =
420 const double dt = time_steps_vector[0];
421 const double sdt = 1. / dt;
426 for (
unsigned int q = 0; q < n_q_points; ++q)
429 const double kinematic_viscosity = viscosity_vector[q];
433 const Tensor<1, dim> previous_velocity =
435 const Tensor<2, dim> velocity_gradient =
437 const Tensor<1, dim> velocity_laplacian =
439 const Tensor<1, dim> velocity_gradient_divergence =
442 const Tensor<1, dim> pressure_gradient =
446 const Tensor<1, dim> void_fraction_gradients =
450 const Tensor<1, dim> force = scratch_data.
force[q];
456 if (
cfd_dem.implicit_stabilization)
457 u_mag = std::max(
velocity.norm(), 1e-12);
461 this->simulation_control->get_time_step())
462 u_mag = std::max(
velocity.norm(), 1e-12);
464 u_mag = std::max(previous_velocity.norm(), 1e-12);
472 const double JxW = JxW_vec[q];
490 auto strong_residual =
500 -
void_fraction * kinematic_viscosity * velocity_gradient_divergence
505 const double pressure_scaling_factor =
510 for (
unsigned int j = 0; j < n_dofs; ++j)
512 const auto &phi_u_j = scratch_data.
phi_u[q][j];
513 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
515 const auto &gradient_divergence_phi_u_j =
518 const auto &grad_phi_p_j =
519 pressure_scaling_factor * scratch_data.
grad_phi_p[q][j];
521 strong_jacobian_vec[q][j] +=
525 + mass_source * phi_u_j
530 void_fraction * kinematic_viscosity * gradient_divergence_phi_u_j);
533 for (
unsigned int i = 0; i < n_dofs; ++i)
535 const int component_i = scratch_data.
components[i];
536 const auto &phi_u_i = scratch_data.
phi_u[q][i];
537 const auto &grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
538 const auto &div_phi_u_i = scratch_data.
div_phi_u[q][i];
539 const auto &phi_p_i = scratch_data.
phi_p[q][i];
540 const auto &grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
542 for (
unsigned int j = 0; j < n_dofs; ++j)
544 const int component_j = scratch_data.
components[j];
545 const auto &phi_u_j = scratch_data.
phi_u[q][j];
546 const auto &grad_phi_u_j = scratch_data.
grad_phi_u[q][j];
547 const auto &div_phi_u_j = scratch_data.
div_phi_u[q][j];
548 const auto &phi_p_j =
549 pressure_scaling_factor * scratch_data.
phi_p[q][j];
551 const auto &strong_jac = strong_jacobian_vec[q][j];
554 double local_matrix_ij =
556 phi_p_j * void_fraction_gradients * phi_u_i);
558 if (component_i == dim)
562 (phi_u_j * void_fraction_gradients));
565 local_matrix_ij += tau * (strong_jac * grad_phi_p_i);
568 if (component_i < dim && component_j < dim)
575 if (component_i == component_j)
578 (grad_phi_u_j[component_j] *
579 grad_phi_u_i[component_i]) +
580 kinematic_viscosity * grad_phi_u_j *
581 void_fraction_gradients * phi_u_i +
582 mass_source * phi_u_j * phi_u_i;
597 grad_phi_u_i[component_i][component_j] *
598 grad_phi_u_j[component_j][component_i] +
599 kinematic_viscosity *
600 grad_phi_u_j[component_j][component_i] *
601 void_fraction_gradients[component_j] *
602 phi_u_i[component_i];
610 if (
SUPG && component_i < dim)
613 tau * (strong_jac * grad_phi_u_i *
velocity +
614 strong_residual * grad_phi_u_i * phi_u_j);
620 local_matrix_ij += gamma *
622 phi_u_j * void_fraction_gradients) *
626 local_matrix_ij *= JxW;
627 local_matrix(i, j) += local_matrix_ij;
640 const std::vector<double> &viscosity_vector =
644 const auto &JxW_vec = scratch_data.
JxW;
645 const unsigned int n_q_points = scratch_data.
n_q_points;
646 const unsigned int n_dofs = scratch_data.
n_dofs;
654 std::vector<double> time_steps_vector =
656 const double dt = time_steps_vector[0];
657 const double sdt = 1. / dt;
660 for (
unsigned int q = 0; q < n_q_points; ++q)
663 const double kinematic_viscosity = viscosity_vector[q];
667 const Tensor<1, dim> previous_velocity =
670 const Tensor<2, dim> velocity_gradient =
672 const Tensor<1, dim> velocity_laplacian =
674 const Tensor<1, dim> velocity_gradient_divergence =
679 const Tensor<1, dim> pressure_gradient =
684 const Tensor<1, dim> void_fraction_gradients =
688 const Tensor<1, dim> force = scratch_data.
force[q];
694 if (
cfd_dem.implicit_stabilization)
695 u_mag = std::max(
velocity.norm(), 1e-12);
699 this->simulation_control->get_time_step())
700 u_mag = std::max(
velocity.norm(), 1e-12);
702 u_mag = std::max(previous_velocity.norm(), 1e-12);
710 const double JxW = JxW_vec[q];
728 auto strong_residual =
738 -
void_fraction * kinematic_viscosity * velocity_gradient_divergence
743 for (
unsigned int i = 0; i < n_dofs; ++i)
745 const int component_i = scratch_data.
components[i];
747 const auto phi_u_i = scratch_data.
phi_u[q][i];
748 const auto grad_phi_u_i = scratch_data.
grad_phi_u[q][i];
749 const auto phi_p_i = scratch_data.
phi_p[q][i];
750 const auto grad_phi_p_i = scratch_data.
grad_phi_p[q][i];
751 const auto div_phi_u_i = scratch_data.
div_phi_u[q][i];
754 double local_rhs_i = 0;
756 if (component_i < dim)
760 scalar_product(velocity_gradient, grad_phi_u_i) +
761 kinematic_viscosity * velocity_gradient *
762 void_fraction_gradients * phi_u_i) -
764 velocity_divergence +
765 kinematic_viscosity * velocity_divergence *
766 void_fraction_gradients * phi_u_i) -
772 pressure * void_fraction_gradients * phi_u_i) +
775 if (component_i == dim)
778 velocity * void_fraction_gradients - mass_source) *
782 local_rhs_i += -tau * (strong_residual * grad_phi_p_i);
788 -tau * (strong_residual * (grad_phi_u_i *
velocity));
794 local_rhs_i -= gamma *
796 velocity * void_fraction_gradients) *
801 local_rhs(i) += local_rhs_i;
816 const auto &JxW = scratch_data.
JxW;
817 const unsigned int n_q_points = scratch_data.
n_q_points;
818 const unsigned int n_dofs = scratch_data.
n_dofs;
828 const Vector<double> &bdf_coefs =
830 std::vector<Tensor<1, dim>>
velocity(1 +
834 for (
unsigned int q = 0; q < n_q_points; ++q)
848 for (
unsigned int j = 0; j < n_dofs; ++j)
850 strong_jacobian[q][j] +=
854 for (
unsigned int i = 0; i < n_dofs; ++i)
856 const Tensor<1, dim> &phi_u_i = scratch_data.
phi_u[q][i];
857 for (
unsigned int j = 0; j < n_dofs; ++j)
859 const Tensor<1, dim> &phi_u_j = scratch_data.
phi_u[q][j];
861 local_matrix(i, j) +=
875 const std::vector<double> &kinematic_viscosity =
880 const auto &JxW = scratch_data.
JxW;
881 const unsigned int n_q_points = scratch_data.
n_q_points;
882 const unsigned int n_dofs = scratch_data.
n_dofs;
891 const Vector<double> &bdf_coefs =
893 std::vector<Tensor<1, dim>>
velocity(1 +
898 for (
unsigned int q = 0; q < n_q_points; ++q)
915 if (
cfd_dem.implicit_stabilization)
916 u_mag = std::max(
velocity[0].norm(), 1e-12);
921 this->simulation_control->get_time_step())
922 u_mag = std::max(
velocity[0].norm(), 1e-12);
924 u_mag = std::max(
velocity[1].norm(), 1e-12);
931 for (
unsigned int i = 0; i < n_dofs; ++i)
933 const auto phi_u_i = scratch_data.
phi_u[q][i];
934 const auto div_phi_u_i = scratch_data.
div_phi_u[q][i];
935 double local_rhs_i = 0;
943 if (
cfd_dem.void_fraction_time_derivative ==
true)
945 local_rhs_i -= bdf_coefs[p] *
955 local_rhs(i) += local_rhs_i * JxW[q];
963template <
int dim,
typename PropertiesIndex>
972 RequiresConstantViscosity(
973 "VANSAssemblerDiFelice<dim>::calculate_particle_fluid_interactions"));
977 RequiresConstantDensity(
978 "VANSAssemblerDiFelice<dim>::calculate_particle_fluid_interactions"));
980 double cell_void_fraction = 0;
982 const auto &relative_velocity =
986 auto &beta_drag = scratch_data.
beta_drag;
990 auto &explicit_particle_volumetric_acceleration_on_fluid =
993 Tensor<1, dim> drag_force;
995 const auto pic = scratch_data.
pic;
1002 unsigned int i_particle = 0;
1005 for (
auto &particle : pic)
1007 auto particle_properties = particle.get_properties();
1009 cell_void_fraction =
1013 C_d = Utilities::fixed_power<2>((0.63 + 4.8 / sqrt(Re_p[i_particle]))) *
1014 pow(cell_void_fraction,
1015 2 - (3.7 - 0.65 * exp(-Utilities::fixed_power<2>(
1016 1.5 - log10(Re_p[i_particle])) *
1019 double momentum_transfer_coefficient =
1021 Utilities::fixed_power<2>(particle_properties[PropertiesIndex::dp]) /
1023 relative_velocity[i_particle].norm();
1028 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1029 momentum_transfer_coefficient;
1030 beta_drag += momentum_transfer_coefficient;
1034 explicit_particle_volumetric_acceleration_on_fluid -=
1035 momentum_transfer_coefficient * relative_velocity[i_particle] /
1037 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1041 drag_force = density[i_particle] * momentum_transfer_coefficient *
1042 relative_velocity[i_particle];
1044 for (
int d = 0; d < dim; ++d)
1046 particle_properties[PropertiesIndex::fem_drag_x + d] += drag_force[d];
1062template <
int dim,
typename PropertiesIndex>
1069 RequiresConstantViscosity(
1070 "VANSAssemblerRong<dim>::calculate_particle_fluid_interactions"));
1073 RequiresConstantDensity(
1074 "VANSAssemblerRong<dim>::calculate_particle_fluid_interactions"));
1076 double cell_void_fraction = 0;
1078 const auto &relative_velocity =
1082 auto &beta_drag = scratch_data.
beta_drag;
1086 auto &explicit_particle_volumetric_acceleration_on_fluid =
1089 Tensor<1, dim> drag_force;
1091 const auto pic = scratch_data.
pic;
1093 unsigned int i_particle = 0;
1096 for (
auto &particle : pic)
1098 auto particle_properties = particle.get_properties();
1100 cell_void_fraction =
1105 Utilities::fixed_power<2>((0.63 + 4.8 / sqrt(Re_p[i_particle]))) *
1106 pow(cell_void_fraction,
1108 (2.65 * (cell_void_fraction + 1) -
1109 (5.3 - (3.5 * cell_void_fraction)) *
1110 Utilities::fixed_power<2>(cell_void_fraction) *
1111 exp(-Utilities::fixed_power<2>(1.5 - log10(Re_p[i_particle])) *
1114 double momentum_transfer_coefficient =
1116 Utilities::fixed_power<2>(particle_properties[PropertiesIndex::dp]) *
1118 relative_velocity[i_particle].norm();
1123 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1124 momentum_transfer_coefficient;
1125 beta_drag += momentum_transfer_coefficient;
1129 explicit_particle_volumetric_acceleration_on_fluid -=
1130 momentum_transfer_coefficient * relative_velocity[i_particle] /
1132 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1135 drag_force = density[i_particle] * momentum_transfer_coefficient *
1136 relative_velocity[i_particle];
1138 for (
int d = 0; d < dim; ++d)
1140 particle_properties[PropertiesIndex::fem_drag_x + d] += drag_force[d];
1154template <
int dim,
typename PropertiesIndex>
1163 RequiresConstantViscosity(
1164 "VANSAssemblerDallavalle<dim>::calculate_particle_fluid_interactions"));
1168 RequiresConstantDensity(
1169 "VANSAssemblerDallavalle<dim>::calculate_particle_fluid_interactions"));
1172 const auto &relative_velocity =
1176 auto &beta_drag = scratch_data.
beta_drag;
1180 auto &explicit_particle_volumetric_acceleration_on_fluid =
1183 Tensor<1, dim> drag_force;
1185 const auto pic = scratch_data.
pic;
1187 unsigned int i_particle = 0;
1190 for (
auto &particle : pic)
1192 auto particle_properties = particle.get_properties();
1195 C_d = Utilities::fixed_power<2>(0.63 + 4.8 / sqrt(Re_p[i_particle]));
1197 double momentum_transfer_coefficient =
1199 Utilities::fixed_power<2>(particle_properties[PropertiesIndex::dp]) *
1201 relative_velocity[i_particle].norm();
1206 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1207 momentum_transfer_coefficient;
1208 beta_drag += momentum_transfer_coefficient;
1212 explicit_particle_volumetric_acceleration_on_fluid -=
1213 momentum_transfer_coefficient * relative_velocity[i_particle] /
1215 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1219 drag_force = density[i_particle] * momentum_transfer_coefficient *
1220 relative_velocity[i_particle];
1222 for (
int d = 0; d < dim; ++d)
1224 particle_properties[PropertiesIndex::fem_drag_x + d] += drag_force[d];
1244template <
int dim,
typename PropertiesIndex>
1253 RequiresConstantViscosity(
1254 "VANSAssemblerKochHill<dim>::calculate_particle_fluid_interactions"));
1258 RequiresConstantDensity(
1259 "VANSAssemblerKochHill<dim>::calculate_particle_fluid_interactions"));
1261 double cell_void_fraction = 0;
1262 const auto &relative_velocity =
1266 const auto &kinematic_viscosity =
1268 auto &beta_drag = scratch_data.
beta_drag;
1272 auto &explicit_particle_volumetric_acceleration_on_fluid =
1275 Tensor<1, dim> drag_force;
1277 const auto pic = scratch_data.
pic;
1279 unsigned int i_particle = 0;
1284 for (
auto &particle : pic)
1286 auto particle_properties = particle.get_properties();
1288 cell_void_fraction =
1292 if ((1 - cell_void_fraction) < 0.4)
1294 f0 = (1 + 3 * sqrt((1 - cell_void_fraction + DBL_MIN) / 2) +
1295 (135.0 / 64) * (1 - cell_void_fraction) *
1296 log(1 - cell_void_fraction + DBL_MIN) +
1297 16.14 * (1 - cell_void_fraction)) /
1298 (1 + 0.681 * (1 - cell_void_fraction) -
1299 8.48 * Utilities::fixed_power<2>(1 - cell_void_fraction) +
1300 8.16 * Utilities::fixed_power<3>(1 - cell_void_fraction));
1302 else if ((1 - cell_void_fraction) >= 0.4)
1304 f0 = 10 * (1 - cell_void_fraction) /
1305 Utilities::fixed_power<3>(cell_void_fraction);
1308 double f3 = 0.0673 + 0.212 * (1 - cell_void_fraction) +
1309 0.0232 / Utilities::fixed_power<5>(cell_void_fraction);
1311 double momentum_transfer_coefficient =
1312 ((18 * kinematic_viscosity[i_particle] *
1313 Utilities::fixed_power<2>(cell_void_fraction) *
1314 (1 - cell_void_fraction)) /
1315 Utilities::fixed_power<2>(particle_properties[PropertiesIndex::dp])) *
1316 (f0 + 0.5 * f3 * Re_p[i_particle]) *
1317 (M_PI * pow(particle_properties[PropertiesIndex::dp], dim) /
1319 (1 - cell_void_fraction + DBL_MIN);
1324 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1325 momentum_transfer_coefficient;
1326 beta_drag += momentum_transfer_coefficient;
1330 explicit_particle_volumetric_acceleration_on_fluid -=
1331 momentum_transfer_coefficient * relative_velocity[i_particle] /
1333 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1337 drag_force = density[i_particle] * momentum_transfer_coefficient *
1338 relative_velocity[i_particle];
1340 for (
int d = 0; d < dim; ++d)
1342 particle_properties[PropertiesIndex::fem_drag_x + d] += drag_force[d];
1358template <
int dim,
typename PropertiesIndex>
1367 RequiresConstantViscosity(
1368 "VANSAssemblerBeetstra<dim>::calculate_particle_fluid_interactions"));
1372 RequiresConstantDensity(
1373 "VANSAssemblerBeetstra<dim>::calculate_particle_fluid_interactions"));
1375 double cell_void_fraction = 0;
1377 const auto &relative_velocity =
1381 const auto &kinematic_viscosity =
1383 auto &beta_drag = scratch_data.
beta_drag;
1387 auto &explicit_particle_volumetric_acceleration_on_fluid =
1390 Tensor<1, dim> drag_force;
1392 const auto pic = scratch_data.
pic;
1394 unsigned int i_particle = 0;
1397 for (
auto &particle : pic)
1399 auto particle_properties = particle.get_properties();
1401 cell_void_fraction =
1405 F0 = 10 * (1 - cell_void_fraction) /
1406 Utilities::fixed_power<2>(cell_void_fraction) +
1407 Utilities::fixed_power<2>(cell_void_fraction) *
1408 (1 + 1.5 * sqrt((1 - cell_void_fraction + DBL_MIN))) +
1409 0.413 * (Re_p[i_particle]) /
1410 (24 * Utilities::fixed_power<2>(cell_void_fraction)) *
1411 ((1 / cell_void_fraction) +
1412 3 * (1 - cell_void_fraction) * cell_void_fraction +
1413 8.4 * pow((Re_p[i_particle]), -0.343)) /
1414 (1 + pow(10, 3 * (1 - cell_void_fraction)) *
1415 pow((Re_p[i_particle]),
1416 -(1 + 4 * (1 - cell_void_fraction)) * 0.5));
1418 double momentum_transfer_coefficient =
1419 F0 * 3 * M_PI * kinematic_viscosity[i_particle] * cell_void_fraction *
1420 particle_properties[PropertiesIndex::dp];
1425 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1426 momentum_transfer_coefficient;
1427 beta_drag += momentum_transfer_coefficient;
1431 explicit_particle_volumetric_acceleration_on_fluid -=
1432 momentum_transfer_coefficient * relative_velocity[i_particle] /
1434 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1438 drag_force = density[i_particle] * momentum_transfer_coefficient *
1439 relative_velocity[i_particle];
1441 for (
int d = 0; d < dim; ++d)
1443 particle_properties[PropertiesIndex::fem_drag_x + d] += drag_force[d];
1459template <
int dim,
typename PropertiesIndex>
1468 RequiresConstantViscosity(
1469 "VANSAssemblerGidaspow<dim>::calculate_particle_fluid_interactions"));
1473 RequiresConstantDensity(
1474 "VANSAssemblerGidaspow<dim>::calculate_particle_fluid_interactions"));
1476 double cell_void_fraction = 0;
1477 const auto &relative_velocity =
1481 const auto &kinematic_viscosity =
1483 auto &beta_drag = scratch_data.
beta_drag;
1487 auto &explicit_particle_volumetric_acceleration_on_fluid =
1491 Tensor<1, dim> drag_force;
1493 const auto pic = scratch_data.
pic;
1494 double momentum_transfer_coefficient = 0;
1496 unsigned int i_particle = 0;
1499 for (
auto &particle : pic)
1501 auto particle_properties = particle.get_properties();
1503 cell_void_fraction =
1507 double particle_density =
1508 particle_properties[PropertiesIndex::mass] /
1510 Utilities::fixed_power<dim>(particle_properties[PropertiesIndex::dp]) /
1513 if (cell_void_fraction > 0.8)
1515 momentum_transfer_coefficient =
1516 (18 * pow(cell_void_fraction, -3.65) *
1517 (1 + 0.15 * pow(Re_p[i_particle], 0.687))) *
1518 (particle_properties[PropertiesIndex::mass] *
1519 kinematic_viscosity[i_particle] /
1520 (Utilities::fixed_power<2, double>(
1521 particle_properties[PropertiesIndex::dp]) *
1527 momentum_transfer_coefficient =
1528 (150 * (1 - cell_void_fraction) /
1529 Utilities::fixed_power<2, double>(cell_void_fraction) +
1530 1.75 * Re_p[i_particle] /
1531 Utilities::fixed_power<2, double>(cell_void_fraction)) *
1532 (particle_properties[PropertiesIndex::mass] *
1533 kinematic_viscosity[i_particle] /
1534 (Utilities::fixed_power<2, double>(
1535 particle_properties[PropertiesIndex::dp]) *
1542 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1543 momentum_transfer_coefficient;
1544 beta_drag += momentum_transfer_coefficient;
1548 explicit_particle_volumetric_acceleration_on_fluid -=
1549 momentum_transfer_coefficient * relative_velocity[i_particle] /
1551 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1555 particle_properties[PropertiesIndex::momentum_transfer_coefficient] =
1556 momentum_transfer_coefficient;
1558 drag_force = density[i_particle] * momentum_transfer_coefficient *
1559 relative_velocity[i_particle];
1562 for (
int d = 0; d < dim; ++d)
1564 particle_properties[PropertiesIndex::fem_drag_x + d] += drag_force[d];
1580template <
int dim,
typename PropertiesIndex>
1589 RequiresConstantViscosity(
1590 "VANSAssemblerSaffmanMei<dim>::calculate_particle_fluid_interactions"));
1594 RequiresConstantDensity(
1595 "VANSAssemblerSaffmanMei<dim>::calculate_particle_fluid_interactions"));
1604 const auto &relative_velocity =
1608 const auto &kinematic_viscosity =
1611 auto &vorticity_2d =
1613 auto &vorticity_3d =
1615 auto &explicit_particle_volumetric_acceleration_on_fluid =
1618 Tensor<1, dim> lift_force;
1620 const auto pic = scratch_data.
pic;
1621 unsigned int i_particle = 0;
1623 if constexpr (dim == 2)
1625 for (
auto &particle : pic)
1627 auto particle_properties = particle.get_properties();
1631 const double vorticity_z =
1632 extract_out_of_plane_vorticity(vorticity_2d[i_particle]);
1635 alpha = 0.5 * particle_properties[PropertiesIndex::dp] /
1636 relative_velocity[i_particle].norm() *
1637 (std::abs(vorticity_z) + 1e-12);
1639 if (Re_p[i_particle] <= 40)
1640 C_s = (1 - 0.3314 * sqrt(alpha)) * exp(-0.1 * Re_p[i_particle]) +
1641 0.3314 * sqrt(alpha);
1642 else if (Re_p[i_particle] > 40)
1643 C_s = 0.0524 * sqrt(alpha * Re_p[i_particle]);
1649 C_s * 1.61 * particle_properties[PropertiesIndex::dp] *
1650 particle_properties[PropertiesIndex::dp] * density[i_particle] *
1651 sqrt(kinematic_viscosity[i_particle] + DBL_MIN) /
1652 sqrt(std::abs(vorticity_z) + 1e-12) *
1653 (relative_velocity[i_particle][1] * vorticity_z);
1656 C_s * 1.61 * particle_properties[PropertiesIndex::dp] *
1657 particle_properties[PropertiesIndex::dp] * density[i_particle] *
1658 sqrt(kinematic_viscosity[i_particle] + DBL_MIN) /
1659 sqrt(std::abs(vorticity_z) + 1e-12) *
1660 (-relative_velocity[i_particle][0] * vorticity_z);
1662 for (
int d = 0; d < dim; ++d)
1666 [PropertiesIndex::fem_force_two_way_coupling_x + d] +=
1670 explicit_particle_volumetric_acceleration_on_fluid[d] -=
1678 else if constexpr (dim == 3)
1680 for (
auto &particle : pic)
1682 auto particle_properties = particle.get_properties();
1685 alpha = 0.5 * particle_properties[PropertiesIndex::dp] /
1686 relative_velocity[i_particle].norm() *
1687 (vorticity_3d[i_particle].norm() + 1e-12);
1689 if (Re_p[i_particle] <= 40)
1690 C_s = (1 - 0.3314 * sqrt(alpha)) * exp(-0.1 * Re_p[i_particle]) +
1691 0.3314 * sqrt(alpha);
1692 else if (Re_p[i_particle] > 40)
1693 C_s = 0.0524 * sqrt(alpha * Re_p[i_particle]);
1696 Tensor<1, 3> vorticity = vorticity_3d[i_particle];
1699 C_s * 1.61 * particle_properties[PropertiesIndex::dp] *
1700 particle_properties[PropertiesIndex::dp] * density[i_particle] *
1701 sqrt(kinematic_viscosity[i_particle] + DBL_MIN) /
1702 sqrt(vorticity.norm() + 1e-12) *
1703 (cross_product_3d(relative_velocity[i_particle], vorticity));
1705 for (
int d = 0; d < dim; ++d)
1709 [PropertiesIndex::fem_force_two_way_coupling_x + d] +=
1713 explicit_particle_volumetric_acceleration_on_fluid[d] -=
1733template <
int dim,
typename PropertiesIndex>
1741 RequiresConstantDensity(
1742 "VANSAssemblerMagnus<dim>::calculate_particle_fluid_interactions"));
1748 const auto &relative_velocity =
1753 auto &explicit_particle_volumetric_acceleration_on_fluid =
1756 Tensor<1, dim> lift_force;
1758 const auto pic = scratch_data.
pic;
1759 unsigned int i_particle = 0;
1761 if constexpr (dim == 2)
1763 for (
auto &particle : pic)
1765 auto particle_properties = particle.get_properties();
1769 particle_properties[PropertiesIndex::omega_z] + 1e-15;
1771 double omega_norm = abs(omega_z);
1774 double spin_parameter = particle_properties[PropertiesIndex::dp] *
1776 (2.0 * relative_velocity[i_particle].norm());
1779 if (spin_parameter > 1.0 && spin_parameter < 6.0 &&
1780 Re_p[i_particle] > 10.0 && Re_p[i_particle] < 140.0)
1783 C_m = 0.45 + (2 * spin_parameter - 0.45) *
1784 exp(-0.075 * pow(spin_parameter, 0.4) *
1785 pow(Re_p[i_particle], 0.7));
1788 C_m = 2.0 * spin_parameter;
1792 0.5 * C_m * particle_properties[PropertiesIndex::dp] *
1793 density[i_particle] * relative_velocity[i_particle].norm() *
1794 (omega_z / omega_norm * relative_velocity[i_particle][1]);
1797 0.5 * C_m * particle_properties[PropertiesIndex::dp] *
1798 density[i_particle] * relative_velocity[i_particle].norm() *
1799 (omega_z / omega_norm * relative_velocity[i_particle][0]);
1801 for (
int d = 0; d < dim; ++d)
1805 [PropertiesIndex::fem_force_two_way_coupling_x + d] +=
1809 explicit_particle_volumetric_acceleration_on_fluid[d] -=
1817 else if constexpr (dim == 3)
1819 for (
auto &particle : pic)
1821 auto particle_properties = particle.get_properties();
1823 Tensor<1, dim> omega;
1825 for (
int d = 0; d < dim; ++d)
1828 particle_properties[PropertiesIndex::omega_x + d] + 1e-15;
1832 double spin_parameter = particle_properties[PropertiesIndex::dp] *
1834 (2.0 * relative_velocity[i_particle].norm());
1837 if (spin_parameter > 1.0 && spin_parameter < 6.0 &&
1838 Re_p[i_particle] > 10.0 && Re_p[i_particle] < 140.0)
1841 C_m = 0.45 + (2 * spin_parameter - 0.45) *
1842 exp(-0.075 * pow(spin_parameter, 0.4) *
1843 pow(Re_p[i_particle], 0.7));
1846 C_m = 2.0 * spin_parameter;
1848 Tensor<1, dim> rotational_vector = omega / omega.norm();
1851 lift_force = 0.125 * M_PI *
1852 Utilities::fixed_power<2>(
1853 particle_properties[PropertiesIndex::dp]) *
1854 C_m * density[i_particle] *
1855 relative_velocity[i_particle].norm() *
1856 (cross_product_3d(rotational_vector,
1857 relative_velocity[i_particle]));
1859 for (
int d = 0; d < dim; ++d)
1863 [PropertiesIndex::fem_force_two_way_coupling_x + d] +=
1867 explicit_particle_volumetric_acceleration_on_fluid[d] -=
1881template <
int dim,
typename PropertiesIndex>
1890 RequiresConstantViscosity(
1891 "VANSAssemblerViscousTorque<dim>::calculate_particle_fluid_interactions"));
1895 RequiresConstantDensity(
1896 "VANSAssemblerViscousTorque<dim>::calculate_particle_fluid_interactions"));
1899 const auto &kinematic_viscosity =
1901 const auto pic = scratch_data.
pic;
1903 unsigned int i_particle = 0;
1906 for (
auto &particle : pic)
1908 auto particle_properties = particle.get_properties();
1911 const double factor = M_PI *
1912 Utilities::fixed_power<3, double>(
1913 particle_properties[PropertiesIndex::dp]) *
1914 kinematic_viscosity[i_particle] *
1915 density[i_particle] * 0.5;
1917 for (
int d = 0; d < dim; d++)
1919 particle_properties[PropertiesIndex::fem_torque_x + d] -=
1920 factor * particle_properties[PropertiesIndex::omega_x + d];
1939template <
int dim,
typename PropertiesIndex>
1948 RequiresConstantViscosity(
1949 "VANSAssemblerVorticalTorque<dim>::calculate_particle_fluid_interactions"));
1953 RequiresConstantDensity(
1954 "VANSAssemblerVorticalTorque<dim>::calculate_particle_fluid_interactions"));
1957 const auto &kinematic_viscosity =
1960 auto &vorticity_3d =
1963 const auto pic = scratch_data.
pic;
1967 unsigned int i_particle = 0;
1970 for (
auto &particle : pic)
1972 auto particle_properties = particle.get_properties();
1975 const double factor = M_PI *
1976 Utilities::fixed_power<3, double>(
1977 particle_properties[PropertiesIndex::dp]) *
1978 kinematic_viscosity[i_particle] *
1979 density[i_particle] * 0.5;
1981 for (
int d = 0; d < dim; d++)
1984 particle_properties[PropertiesIndex::fem_torque_x + d] +=
1985 factor * vorticity_3d[i_particle][d];
2004template <
int dim,
typename PropertiesIndex>
2013 RequiresConstantDensity(
2014 "VANSAssemblerBuoyancy<dim>::calculate_particle_fluid_interactions"));
2016 const auto pic = scratch_data.
pic;
2017 Tensor<1, 3> buoyancy_force;
2021 unsigned int i_particle = 0;
2024 for (
auto &particle : pic)
2026 auto particle_properties = particle.get_properties();
2029 buoyancy_force = -
gravity * (4.0 / 3) * M_PI *
2030 Utilities::fixed_power<3>(
2031 (particle_properties[PropertiesIndex::dp] / 2.0));
2033 for (
int d = 0; d < dim; ++d)
2035 particle_properties[PropertiesIndex::fem_force_one_way_coupling_x +
2036 d] += buoyancy_force[d] * density[i_particle];
2049template <
int dim,
typename PropertiesIndex>
2058 RequiresConstantDensity(
2059 "VANSAssemblerPressureForce<dim>::calculate_particle_fluid_interactions"));
2061 const auto pic = scratch_data.
pic;
2062 auto &explicit_particle_volumetric_acceleration_on_fluid =
2064 auto pressure_gradients =
2066 Tensor<1, dim> pressure_force;
2068 unsigned int i_particle = 0;
2073 for (
auto &particle : pic)
2075 auto particle_properties = particle.get_properties();
2078 pressure_force = -(M_PI *
2079 Utilities::fixed_power<dim>(
2080 particle_properties[PropertiesIndex::dp]) /
2082 pressure_gradients[i_particle];
2084 for (
int d = 0; d < dim; ++d)
2093 [PropertiesIndex::fem_force_one_way_coupling_x + d] +=
2094 pressure_force[d] * density[i_particle];
2099 [PropertiesIndex::fem_force_two_way_coupling_x + d] +=
2100 pressure_force[d] * density[i_particle];
2101 explicit_particle_volumetric_acceleration_on_fluid[d] -=
2123template <
int dim,
typename PropertiesIndex>
2133 RequiresConstantViscosity(
2134 "VANSAssemblerShearForce<dim>::calculate_particle_fluid_interactions"));
2138 RequiresConstantDensity(
2139 "VANSAssemblerShearForce<dim>::calculate_particle_fluid_interactions"));
2141 const auto pic = scratch_data.
pic;
2142 auto &explicit_particle_volumetric_acceleration_on_fluid =
2144 auto &velocity_laplacians =
2146 Tensor<1, dim> shear_force;
2148 unsigned int i_particle = 0;
2151 const std::vector<double> &kinematic_viscosity =
2155 for (
auto &particle : pic)
2157 auto particle_properties = particle.get_properties();
2160 shear_force = -(M_PI *
2161 Utilities::fixed_power<dim>(
2162 particle_properties[PropertiesIndex::dp]) /
2164 kinematic_viscosity[i_particle] *
2165 velocity_laplacians[i_particle];
2167 for (
int d = 0; d < dim; ++d)
2177 [PropertiesIndex::fem_force_one_way_coupling_x + d] +=
2178 shear_force[d] * density[i_particle];
2183 [PropertiesIndex::fem_force_two_way_coupling_x + d] +=
2184 shear_force[d] * density[i_particle];
2185 explicit_particle_volumetric_acceleration_on_fluid[d] -=
2212 const auto &JxW_vec = scratch_data.
JxW;
2213 const unsigned int n_q_points = scratch_data.
n_q_points;
2214 const unsigned int n_dofs = scratch_data.
n_dofs;
2220 auto beta_drag = scratch_data.
beta_drag;
2221 auto &explicit_particle_volumetric_acceleration_on_fluid =
2223 const Tensor<1, dim> average_particles_velocity =
2227 for (
unsigned int q = 0; q < n_q_points; ++q)
2233 const double JxW = JxW_vec[q];
2237 strong_residual[q] -=
2239 (-beta_drag * (
velocity - average_particles_velocity)
2241 + explicit_particle_volumetric_acceleration_on_fluid);
2243 for (
unsigned int j = 0; j < n_dofs; ++j)
2245 const auto &phi_u_j = scratch_data.
phi_u[q][j];
2246 strong_jacobian[q][j] +=
2248 beta_drag * phi_u_j;
2251 for (
unsigned int i = 0; i < n_dofs; ++i)
2253 const auto &phi_u_i = scratch_data.
phi_u[q][i];
2255 for (
unsigned int j = 0; j < n_dofs; ++j)
2257 const auto &phi_u_j = scratch_data.
phi_u[q][j];
2259 local_matrix(i, j) +=
2260 beta_drag * phi_u_j * phi_u_i * JxW;
2273 const auto &JxW_vec = scratch_data.
JxW;
2274 const unsigned int n_q_points = scratch_data.
n_q_points;
2275 const unsigned int n_dofs = scratch_data.
n_dofs;
2280 auto beta_drag = scratch_data.
beta_drag;
2281 auto &explicit_particle_volumetric_acceleration_on_fluid =
2283 const Tensor<1, dim> average_particles_velocity =
2287 for (
unsigned int q = 0; q < n_q_points; ++q)
2293 const double JxW = JxW_vec[q];
2303 strong_residual[q] -=
2305 (-beta_drag * (
velocity - average_particles_velocity)
2307 + explicit_particle_volumetric_acceleration_on_fluid);
2310 for (
unsigned int i = 0; i < n_dofs; ++i)
2312 const auto phi_u_i = scratch_data.
phi_u[q][i];
2316 (-beta_drag * (
velocity - average_particles_velocity) +
2318 explicit_particle_volumetric_acceleration_on_fluid) *
2333 const auto &JxW_vec = scratch_data.
JxW;
2334 const unsigned int n_q_points = scratch_data.
n_q_points;
2335 const unsigned int n_dofs = scratch_data.
n_dofs;
2345 for (
unsigned int q = 0; q < n_q_points; ++q)
2347 const Tensor<1, dim> &two_way_coupling_force =
2349 const Tensor<1, dim> &fluid_drag =
2351 const double &beta_drag =
2353 const Tensor<1, dim> particles_velocity =
2358 const double JxW = JxW_vec[q];
2364 strong_residual[q] -=
2365 (fluid_drag - beta_drag * (
velocity - particles_velocity) +
2366 two_way_coupling_force);
2368 for (
unsigned int j = 0; j < n_dofs; ++j)
2370 const auto &phi_u_j = scratch_data.
phi_u[q][j];
2371 strong_jacobian[q][j] +=
2373 beta_drag * phi_u_j;
2376 for (
unsigned int i = 0; i < n_dofs; ++i)
2378 const auto &phi_u_i = scratch_data.
phi_u[q][i];
2380 for (
unsigned int j = 0; j < n_dofs; ++j)
2382 const auto &phi_u_j = scratch_data.
phi_u[q][j];
2384 local_matrix(i, j) +=
2385 beta_drag * phi_u_j * phi_u_i * JxW;
2398 const auto &JxW_vec = scratch_data.
JxW;
2399 const unsigned int n_q_points = scratch_data.
n_q_points;
2400 const unsigned int n_dofs = scratch_data.
n_dofs;
2409 for (
unsigned int q = 0; q < n_q_points; ++q)
2411 const Tensor<1, dim> &two_way_coupling_force =
2413 const Tensor<1, dim> &fluid_drag =
2415 const double &beta_drag =
2417 const Tensor<1, dim> particles_velocity =
2422 const double JxW = JxW_vec[q];
2428 strong_residual[q] -=
2429 (fluid_drag - beta_drag * (
velocity - particles_velocity) +
2430 two_way_coupling_force);
2433 for (
unsigned int i = 0; i < n_dofs; ++i)
2435 const auto phi_u_i = scratch_data.
phi_u[q][i];
2442 (fluid_drag - beta_drag * (
velocity - particles_velocity) +
2443 two_way_coupling_force) *
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 stores the information required by the assembly procedure for a Navier-Stokes equation....
Table< 2, double > div_phi_u
std::vector< double > mass_source
std::vector< double > pressure_values
std::vector< Tensor< 1, dim > > force
double pressure_scaling_factor
std::vector< velocity_curl_type_2d > fluid_velocity_curls_at_particle_location_2d
std::vector< Tensor< 1, dim > > void_fraction_gradient_values
std::vector< std::vector< Tensor< 1, dim > > > previous_velocity_values
Tensor< 1, dim > average_particle_velocity
std::vector< unsigned int > components
std::vector< double > cell_void_fraction
std::vector< Tensor< 2, dim > > velocity_gradients
std::vector< Tensor< 1, dim > > particle_two_way_coupling_force_values
std::vector< Tensor< 1, dim > > fluid_particle_relative_velocity_at_particle_location
std::vector< double > particle_momentum_transfer_coefficient_values
Table< 2, Tensor< 1, dim > > phi_u
std::vector< double > void_fraction_values
std::vector< Tensor< 1, dim > > particle_velocity_values
std::vector< double > kinematic_viscosity
std::vector< Tensor< 1, dim > > velocity_values
std::vector< double > Re_particle
Table< 2, Tensor< 2, dim > > grad_phi_u
std::vector< velocity_curl_type_3d > fluid_velocity_curls_at_particle_location_3d
Particles::ParticleHandler< dim >::particle_iterator_range pic
Table< 2, Tensor< 1, dim > > laplacian_phi_u
std::vector< std::vector< double > > previous_void_fraction_values
std::vector< Tensor< 1, dim > > velocity_gradient_divergence
std::vector< Tensor< 1, dim > > particle_drag_values
std::vector< Tensor< 1, dim > > fluid_velocity_laplacian_at_particle_location
std::vector< double > velocity_divergences
std::vector< double > density_at_particle_location
std::vector< double > kinematic_viscosity_at_particle_location
Table< 2, Tensor< 1, dim > > grad_phi_p
std::vector< Tensor< 1, dim > > pressure_gradients
Tensor< 1, dim > explicit_particle_volumetric_acceleration_on_fluid
std::vector< Tensor< 1, dim > > fluid_pressure_gradients_at_particle_location
Table< 2, Tensor< 1, dim > > gradient_divergence_phi_u
std::vector< Tensor< 1, dim > > velocity_laplacians
const PhysicalPropertiesManager properties_manager
bool density_is_constant() const
bool is_non_newtonian() const
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
Assembler for the transient term arising from BDF time integration for the VANS equations.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the matrix.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the right-hand side.
const std::shared_ptr< SimulationControl > simulation_control
Shared pointer to the simulation control object.
Assembler for the drag force using the Beetstra model.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Beetstra model....
Assembler for the buoyancy force on particles in the VANS equations.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the buoyancy force on particles.
const Tensor< 1, 3 > gravity
Gravity acceleration applied to the particles.
Assembler for the core of Model A of the Volume-Averaged Navier-Stokes (VANS) equations.
const bool SUPG
Flag indicating whether SUPG stabilization is used.
const std::shared_ptr< SimulationControl > simulation_control
Shared pointer to the simulation control object.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the right-hand side.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the matrix.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
Assembler for the core of Model B of the Volume-Averaged Navier-Stokes (VANS) equations.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
const std::shared_ptr< SimulationControl > simulation_control
Shared pointer to the simulation control object.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the matrix.
const bool SUPG
Flag indicating whether SUPG stabilization is used.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the right-hand side.
Assembler for the drag force using the Dallavalle model.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Dallavalle model.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
Assembler for the drag force using the Di Felice model.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Di Felice model.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
Assembler for the fluid-particle interactions (FPI) in the VANS equations when the forces are project...
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the right-hand side.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the matrix.
Assembler for the fluid-particle interactions (FPI) in the VANS equations, such as the drag force.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the matrix.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data) override
Assemble the right-hand side.
Assembler for the drag force using the Gidaspow model.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Gidaspow model.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
Assembler for the drag force using the Koch and Hill drag model.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Koch-Hill model.
Assembler for the lift force using the Magnus model.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the Magnus lift force on particles.
Assembler for the pressure force on particles.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the pressure force on particles.
Assembler for the drag force using the Rong model.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Rong model.
Assembler for the lift force using the Saffman-Mei model.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the Saffman-Mei lift force on particles.
Assembler for the shear force on particles.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the shear force on particles.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
Assembler for the viscous dissipative torque due to particle rotation as defined by Derksen (2004).
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the viscous torque dissipation on particles.
Assembler for the viscous dissipative torque due to fluid vorticity as defined by Derksen (2004).
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the vortical torque on particles.
@ velocity
Velocity vector field from fluid dynamics.
@ pressure
Pressure scalar field from fluid dynamics.
PropertiesIndex
Particle property indices for CFD-DEM multiphysics simulations.
PropertiesIndex
Particle property indices for CFD-DEM simulations.
@ modelA
Model A: volume-averaged continuity and momentum equations.
@ modelB
Model B: alternative VANS formulation.
@ semi_implicit
Semi-implicit drag coupling.
@ fully_implicit
Fully implicit drag coupling.
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.
Assemblers for the Volume-Averaged Navier-Stokes (VANS) equations.
double calculate_gamma(double velocity, double kinematic_viscosity, double, double c_star)
Calculate the grad-div stabilization constant for the VANS equations.