86 const DoFHandler<dim> &void_fraction_dof_handler,
87 const LinearAlgebra::distributed::Vector<double> &void_fraction_solution,
88 const LinearAlgebra::distributed::Vector<double>
89 &time_derivative_void_fraction_solution)
91 this->
timer.enter_subsection(
"operator::compute_void_fraction");
93 const unsigned int n_cells = this->
matrix_free.n_cell_batches();
102 FEValues<dim> fe_values(*(this->
matrix_free.get_mapping_info().mapping),
103 void_fraction_dof_handler.get_fe(),
104 this->matrix_free.get_quadrature(),
105 update_values | update_gradients);
107 std::vector<double> cell_void_fraction(fe_values.n_quadrature_points);
108 std::vector<double> cell_time_derivative_void_fraction(
109 fe_values.n_quadrature_points);
111 std::vector<Tensor<1, dim>> cell_void_fraction_gradient(
112 fe_values.n_quadrature_points);
122 const unsigned int mg_level = this->
matrix_free.get_mg_level();
123 const bool on_mg_level = mg_level != numbers::invalid_unsigned_int;
125 const unsigned int dofs_per_cell =
126 void_fraction_dof_handler.get_fe().n_dofs_per_cell();
127 Vector<double> local_void_fraction(dofs_per_cell);
128 Vector<double> local_time_derivative_void_fraction(dofs_per_cell);
129 std::vector<types::global_dof_index> level_dof_indices(dofs_per_cell);
131 for (
unsigned int cell = 0; cell < n_cells; ++cell)
134 lane < this->
matrix_free.n_active_entries_per_cell_batch(cell);
137 const auto tria_cell =
143 typename DoFHandler<dim>::level_cell_iterator dof_cell(
144 &tria_cell->get_triangulation(),
147 &void_fraction_dof_handler);
148 fe_values.reinit(dof_cell);
152 dof_cell->get_mg_dof_indices(level_dof_indices);
153 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
155 const auto idx = level_dof_indices[i];
156 local_void_fraction[i] = void_fraction_solution[idx];
157 local_time_derivative_void_fraction[i] =
158 time_derivative_void_fraction_solution[idx];
164 for (
const auto q : fe_values.quadrature_point_indices())
166 cell_void_fraction[q] = 0.;
167 cell_time_derivative_void_fraction[q] = 0.;
168 cell_void_fraction_gradient[q] = 0.;
169 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
171 const double phi = fe_values.shape_value(i, q);
172 const auto gphi = fe_values.shape_grad(i, q);
173 cell_void_fraction[q] += local_void_fraction[i] * phi;
174 cell_time_derivative_void_fraction[q] +=
175 local_time_derivative_void_fraction[i] * phi;
176 cell_void_fraction_gradient[q] +=
177 local_void_fraction[i] * gphi;
185 tria_cell->as_dof_handler_iterator(void_fraction_dof_handler));
187 fe_values.get_function_values(void_fraction_solution,
189 fe_values.get_function_values(
190 time_derivative_void_fraction_solution,
191 cell_time_derivative_void_fraction);
192 fe_values.get_function_gradients(void_fraction_solution,
193 cell_void_fraction_gradient);
196 for (
const auto q : fe_values.quadrature_point_indices())
198 for (
int c = 0; c < dim; ++c)
200 cell_void_fraction_gradient[q][c];
204 cell_time_derivative_void_fraction[q];
209 this->
timer.leave_subsection(
"operator::compute_void_fraction");
215 const DoFHandler<dim> &fp_force_dof_handler,
216 const LinearAlgebra::distributed::Vector<double> &fp_force_solution,
217 const DoFHandler<dim> &fp_drag_dof_handler,
218 const LinearAlgebra::distributed::Vector<double> &fp_drag_solution,
219 const DoFHandler<dim> &particle_velocity_dof_handler,
220 const LinearAlgebra::distributed::Vector<double> &particle_velocity_solution,
221 const DoFHandler<dim> &momentum_transfer_coefficient_dof_handler,
222 const LinearAlgebra::distributed::Vector<double>
223 &momentum_transfer_coefficient_solution)
225 this->
timer.enter_subsection(
"operator::compute_particle_fluid_forces");
247 "The matrix-free VANS operator does not support variable density. Simulation will abort"));
248 const double inv_density =
252 AssertIsFinite(inv_density);
254 const unsigned int n_cells = this->
matrix_free.n_cell_batches();
265 FEValues<dim> fe_values_force(*(this->
matrix_free.get_mapping_info().mapping),
266 fp_force_dof_handler.get_fe(),
267 this->matrix_free.get_quadrature(),
270 FEValues<dim> fe_values_drag(*(this->
matrix_free.get_mapping_info().mapping),
271 fp_drag_dof_handler.get_fe(),
272 this->matrix_free.get_quadrature(),
275 FEValues<dim> fe_values_particle_velocity(
277 particle_velocity_dof_handler.get_fe(),
278 this->matrix_free.get_quadrature(),
281 FEValues<dim> fe_values_momentum_transfer_coefficient(
283 momentum_transfer_coefficient_dof_handler.get_fe(),
284 this->matrix_free.get_quadrature(),
289 std::vector<Tensor<1, dim>> cell_fp_force(
290 fe_values_force.n_quadrature_points);
291 std::vector<Tensor<1, dim>> cell_fp_drag(fe_values_drag.n_quadrature_points);
292 std::vector<Tensor<1, dim>> cell_particle_velocity(
293 fe_values_particle_velocity.n_quadrature_points);
294 std::vector<double> cell_momentum_transfer_coefficient(
295 fe_values_force.n_quadrature_points, 0.);
298 constexpr FEValuesExtractors::Vector vector_index(0);
307 const unsigned int mg_level = this->
matrix_free.get_mg_level();
308 const bool on_mg_level = mg_level != numbers::invalid_unsigned_int;
311 Vector<double> local_fp_force(
312 fp_force_dof_handler.get_fe().n_dofs_per_cell());
313 Vector<double> local_fp_drag(fp_drag_dof_handler.get_fe().n_dofs_per_cell());
314 Vector<double> local_particle_velocity(
315 particle_velocity_dof_handler.get_fe().n_dofs_per_cell());
316 Vector<double> local_momentum_transfer_coefficient(
317 momentum_transfer_coefficient_dof_handler.get_fe().n_dofs_per_cell());
319 for (
unsigned int cell = 0; cell < n_cells; ++cell)
322 lane < this->
matrix_free.n_active_entries_per_cell_batch(cell);
325 const auto tria_cell =
336 const auto gather_and_eval_vector =
337 [&](FEValues<dim> &fev,
338 const DoFHandler<dim> &dh,
339 const LinearAlgebra::distributed::Vector<double> &vec,
340 Vector<double> &local,
341 std::vector<Tensor<1, dim>> &output) {
342 typename DoFHandler<dim>::level_cell_iterator dof_cell(
343 &tria_cell->get_triangulation(),
347 fev.reinit(dof_cell);
349 const unsigned int dpc = dh.get_fe().n_dofs_per_cell();
350 std::vector<types::global_dof_index> indices(dpc);
351 dof_cell->get_mg_dof_indices(indices);
352 for (
unsigned int i = 0; i < dpc; ++i)
353 local[i] = vec[indices[i]];
355 for (
const auto q : fev.quadrature_point_indices())
358 for (
unsigned int i = 0; i < dpc; ++i)
359 v += local[i] * fev[vector_index].value(i, q);
364 gather_and_eval_vector(fe_values_force,
365 fp_force_dof_handler,
372 gather_and_eval_vector(fe_values_drag,
381 gather_and_eval_vector(fe_values_particle_velocity,
382 particle_velocity_dof_handler,
383 particle_velocity_solution,
384 local_particle_velocity,
385 cell_particle_velocity);
389 typename DoFHandler<dim>::level_cell_iterator dof_cell_mtc(
390 &tria_cell->get_triangulation(),
393 &momentum_transfer_coefficient_dof_handler);
394 fe_values_momentum_transfer_coefficient.reinit(dof_cell_mtc);
396 const unsigned int mtc_dofs_per_cell =
397 momentum_transfer_coefficient_dof_handler.get_fe()
399 std::vector<types::global_dof_index> mtc_indices(
401 dof_cell_mtc->get_mg_dof_indices(mtc_indices);
402 for (
unsigned int i = 0; i < mtc_dofs_per_cell; ++i)
403 local_momentum_transfer_coefficient[i] =
404 momentum_transfer_coefficient_solution[mtc_indices[i]];
406 for (
const auto q : fe_values_momentum_transfer_coefficient
407 .quadrature_point_indices())
409 cell_momentum_transfer_coefficient[q] = 0.;
410 for (
unsigned int i = 0; i < mtc_dofs_per_cell; ++i)
411 cell_momentum_transfer_coefficient[q] +=
412 local_momentum_transfer_coefficient[i] *
413 fe_values_momentum_transfer_coefficient.shape_value(
422 fe_values_force.reinit(
423 tria_cell->as_dof_handler_iterator(fp_force_dof_handler));
425 fe_values_force[vector_index].get_function_values(
426 fp_force_solution, cell_fp_force);
432 fe_values_drag.reinit(
433 tria_cell->as_dof_handler_iterator(fp_drag_dof_handler));
435 fe_values_drag[vector_index].get_function_values(
436 fp_drag_solution, cell_fp_drag);
442 fe_values_particle_velocity.reinit(
443 tria_cell->as_dof_handler_iterator(
444 particle_velocity_dof_handler));
446 fe_values_particle_velocity[vector_index].get_function_values(
447 particle_velocity_solution, cell_particle_velocity);
450 fe_values_momentum_transfer_coefficient.reinit(
451 tria_cell->as_dof_handler_iterator(
452 momentum_transfer_coefficient_dof_handler));
454 fe_values_momentum_transfer_coefficient.get_function_values(
455 momentum_transfer_coefficient_solution,
456 cell_momentum_transfer_coefficient);
460 for (
const auto q : fe_values_force.quadrature_point_indices())
462 for (
int c = 0; c < dim; ++c)
469 -cell_fp_force[q][c] * inv_density;
471 -cell_fp_drag[q][c] * inv_density;
475 cell_particle_velocity[q][c];
482 cell_momentum_transfer_coefficient[q];
487 this->
timer.leave_subsection(
"operator::compute_particle_fluid_forces");
524 integrator.evaluate(EvaluationFlags::values | EvaluationFlags::gradients |
525 EvaluationFlags::hessians);
527 integrator.evaluate(EvaluationFlags::values | EvaluationFlags::gradients);
529 const unsigned int cell = integrator.get_current_cell_index();
532 VectorizedArray<number> cell_mask(1.0);
545 const double kinematic_viscosity =
549 const Vector<double> *bdf_coefs;
553 for (
const auto q : integrator.quadrature_point_indices())
559 Tensor<1, dim, VectorizedArray<number>> source_value;
566 auto beta_momentum_transfer =
571 source_value = pf_force_value + pf_drag_value;
574 VectorizedArray<number> mass_source = 0.;
586 typename FECellIntegrator::value_type value = integrator.get_value(q);
587 typename FECellIntegrator::gradient_type gradient =
588 integrator.get_gradient(q);
589 typename FECellIntegrator::gradient_type hessian_diagonal;
590 typename FECellIntegrator::hessian_type hessian;
598 hessian_diagonal = integrator.get_hessian_diagonal(q);
599 hessian = integrator.get_hessian(q);
603 typename FECellIntegrator::value_type value_result;
604 typename FECellIntegrator::gradient_type gradient_result;
605 typename FECellIntegrator::hessian_type hessian_result;
610 auto previous_hessian_diagonal =
615 for (
int d = 0; d < dim; ++d)
617 beta_momentum_transfer * (p_velocity[d] - previous_values[d]);
619 Tensor<1, dim + 1, VectorizedArray<number>> previous_time_derivatives;
621 previous_time_derivatives =
628 value_result[dim] = 0;
629 for (
int i = 0; i < dim; ++i)
634 gradient_result[i] = kinematic_viscosity * vf_value * gradient[i];
636 value_result[i] = -vf_gradient[i] * value[dim];
638 gradient_result[i][i] += -vf_value * value[dim];
640 value_result[dim] += vf_value * gradient[i][i];
642 value_result[dim] += vf_gradient[i] * value[i];
644 value_result[i] += beta_momentum_transfer * value[i];
646 value_result[i] += mass_source * value[i];
648 for (
int k = 0; k < dim; ++k)
652 vf_value * (gradient[i][k] * previous_values[k] +
653 previous_gradient[i][k] * value[k]);
655 gradient_result[i][k] +=
656 kinematic_viscosity * vf_value * gradient[k][i];
659 kinematic_viscosity * vf_gradient[k] * gradient[k][i];
662 kinematic_viscosity * vf_gradient[k] * gradient[i][k];
666 value_result[i] += vf_value * (*bdf_coefs)[0] * value[i];
670 for (
int i = 0; i < dim; ++i)
672 for (
int k = 0; k < dim; ++k)
675 gradient_result[dim][i] +=
677 (-kinematic_viscosity *
678 (hessian_diagonal[i][k] + hessian[k][k][i]) +
679 gradient[i][k] * previous_values[k] +
680 previous_gradient[i][k] * value[k]);
684 gradient_result[dim][i] +=
685 tau * vf_value * (*bdf_coefs)[0] * value[i];
688 gradient_result[dim][i] += tau * beta_momentum_transfer * value[i];
691 gradient_result[dim][i] += tau * mass_source * value[i];
694 gradient_result[dim] += tau * vf_value * gradient[dim];
700 for (
int i = 0; i < dim; ++i)
702 for (
int k = 0; k < dim; ++k)
704 gradient_result[i][i] +=
706 (vf_value * gradient[k][k] + value[k] * vf_gradient[k]);
712 for (
int i = 0; i < dim; ++i)
714 for (
int k = 0; k < dim; ++k)
717 for (
int l = 0; l < dim; ++l)
720 gradient_result[i][k] +=
721 tau * vf_value * previous_values[k] *
722 (gradient[i][l] * previous_values[l] +
723 previous_gradient[i][l] * value[l] -
724 kinematic_viscosity *
725 (hessian_diagonal[i][l] + hessian[l][l][i]));
728 gradient_result[i][k] +=
729 tau * vf_value * previous_values[k] * (gradient[dim][i]);
733 gradient_result[i][k] += tau * previous_values[k] * vf_value *
734 ((*bdf_coefs)[0] * value[i]);
737 gradient_result[i][k] +=
738 beta_momentum_transfer * value[i] * tau * previous_values[k];
741 gradient_result[i][k] +=
742 mass_source * value[i] * tau * previous_values[k];
745 for (
int l = 0; l < dim; ++l)
748 gradient_result[i][k] +=
749 tau * value[k] * vf_value *
750 (previous_gradient[i][l] * previous_values[l] -
751 kinematic_viscosity * previous_hessian_diagonal[i][l]);
754 gradient_result[i][k] += -tau * kinematic_viscosity *
755 vf_value * value[k] *
756 previous_hessian[l][l][i];
759 gradient_result[i][k] +=
761 (vf_value * previous_gradient[dim][i] - source_value[i]);
764 gradient_result[i][k] +=
765 tau * value[k] * mass_source * previous_values[i];
769 gradient_result[i][k] += tau * value[k] * vf_value *
770 ((*bdf_coefs)[0] * previous_values[i] +
771 previous_time_derivatives[i]);
777 gradient_result = gradient_result * cell_mask;
778 value_result = value_result * cell_mask;
780 hessian_result = hessian_result * cell_mask;
783 integrator.submit_gradient(gradient_result, q);
784 integrator.submit_value(value_result, q);
787 integrator.submit_hessian(hessian_result, q);
791 integrator.integrate(EvaluationFlags::values | EvaluationFlags::gradients |
792 EvaluationFlags::hessians);
794 integrator.integrate(EvaluationFlags::values | EvaluationFlags::gradients);
819 const std::pair<unsigned int, unsigned int> &range)
const
823 const double kinematic_viscosity =
826 for (
unsigned int cell = range.first; cell < range.second; ++cell)
828 integrator.reinit(cell);
829 integrator.read_dof_values_plain(src);
832 integrator.evaluate(EvaluationFlags::values |
833 EvaluationFlags::gradients |
834 EvaluationFlags::hessians);
836 integrator.evaluate(EvaluationFlags::values |
837 EvaluationFlags::gradients);
840 VectorizedArray<number> cell_mask(1.0);
855 const Vector<double> *bdf_coefs;
859 for (
const auto q : integrator.quadrature_point_indices())
866 auto beta_momentum_transfer =
870 Tensor<1, dim, VectorizedArray<number>> source_value =
871 pf_force_value + pf_drag_value;
876 auto vf_time_derivative =
880 VectorizedArray<number> mass_source = 0.;
892 typename FECellIntegrator::value_type value = integrator.get_value(q);
893 typename FECellIntegrator::gradient_type gradient =
894 integrator.get_gradient(q);
895 typename FECellIntegrator::gradient_type hessian_diagonal;
896 typename FECellIntegrator::hessian_type hessian;
899 for (
int d = 0; d < dim; ++d)
901 beta_momentum_transfer * (p_velocity[d] - value[d]);
907 hessian_diagonal = integrator.get_hessian_diagonal(q);
908 hessian = integrator.get_hessian(q);
912 Tensor<1, dim + 1, VectorizedArray<number>> previous_time_derivatives;
914 previous_time_derivatives =
921 typename FECellIntegrator::value_type value_result;
922 typename FECellIntegrator::gradient_type gradient_result;
923 typename FECellIntegrator::hessian_type hessian_result;
926 value_result[dim] = vf_time_derivative;
929 value_result[dim] -= mass_source;
932 for (
int i = 0; i < dim; ++i)
935 gradient_result[i] = kinematic_viscosity * vf_value * gradient[i];
938 gradient_result[i][i] += -vf_value * value[dim];
941 value_result[i] = -source_value[i];
944 value_result[i] += -vf_gradient[i] * value[dim];
947 value_result[i] += mass_source * value[i];
952 value_result[i] += vf_value * ((*bdf_coefs)[0] * value[i] +
953 previous_time_derivatives[i]);
957 value_result[dim] += vf_value * gradient[i][i];
959 value_result[dim] += value[i] * vf_gradient[i];
961 for (
int k = 0; k < dim; ++k)
965 kinematic_viscosity * gradient[i][k] * vf_gradient[k];
969 kinematic_viscosity * gradient[k][i] * vf_gradient[k];
972 gradient_result[i][k] +=
973 kinematic_viscosity * vf_value * gradient[k][i];
976 value_result[i] += vf_value * gradient[i][k] * value[k];
981 for (
int i = 0; i < dim; ++i)
983 for (
int k = 0; k < dim; ++k)
986 gradient_result[dim][i] +=
988 (-kinematic_viscosity *
989 (hessian_diagonal[i][k] + hessian[k][k][i]) +
990 gradient[i][k] * value[k]);
993 gradient_result[dim][i] += tau * (-source_value[i]);
996 gradient_result[dim][i] += tau * mass_source * value[i];
1000 gradient_result[dim][i] +=
1002 ((*bdf_coefs)[0] * value[i] + previous_time_derivatives[i]);
1005 gradient_result[dim] += tau * vf_value * gradient[dim];
1012 auto continuity_residual = vf_time_derivative - mass_source;
1013 for (
int k = 0; k < dim; ++k)
1014 continuity_residual +=
1015 vf_value * gradient[k][k] + value[k] * vf_gradient[k];
1017 for (
int i = 0; i < dim; ++i)
1018 gradient_result[i][i] +=
1023 for (
int i = 0; i < dim; ++i)
1025 for (
int k = 0; k < dim; ++k)
1027 for (
int l = 0; l < dim; ++l)
1030 gradient_result[i][k] +=
1031 -tau * kinematic_viscosity * vf_value * value[k] *
1032 (hessian_diagonal[i][l] + hessian[l][l][i]);
1035 gradient_result[i][k] +=
1036 tau * vf_value * value[k] * gradient[i][l] * value[l];
1039 gradient_result[i][k] +=
1041 (vf_value * gradient[dim][i] - source_value[i]);
1044 gradient_result[i][k] +=
1045 tau * value[k] * mass_source * value[i];
1049 gradient_result[i][k] += tau * value[k] * vf_value *
1050 ((*bdf_coefs)[0] * value[i] +
1051 previous_time_derivatives[i]);
1057 gradient_result = gradient_result * cell_mask;
1058 value_result = value_result * cell_mask;
1060 hessian_result = hessian_result * cell_mask;
1063 integrator.submit_gradient(gradient_result, q);
1064 integrator.submit_value(value_result, q);
1066 integrator.submit_hessian(hessian_result, q);
1070 integrator.integrate_scatter(EvaluationFlags::values |
1071 EvaluationFlags::gradients |
1072 EvaluationFlags::hessians,
1075 integrator.integrate_scatter(EvaluationFlags::values |
1076 EvaluationFlags::gradients,