7#include <deal.II/dofs/dof_tools.h>
9#include <deal.II/grid/grid_tools.h>
11#include <deal.II/hp/fe_collection.h>
12#include <deal.II/hp/q_collection.h>
14#include <deal.II/non_matching/fe_values.h>
15#include <deal.II/non_matching/mesh_classifier.h>
16#include <deal.II/non_matching/quadrature_generator.h>
21 FEPointEvaluation<1, dim> &fe_point_evaluation,
22 const typename DoFHandler<dim>::active_cell_iterator &cell,
23 Vector<double> cell_dof_level_set_values,
25 const unsigned int n_quad_points)
27 const unsigned int n_dofs = cell_dof_level_set_values.size();
30 const BoundingBox<dim> unit_box = create_unit_bounding_box<dim>();
34 hp::QCollection<1> q_collection;
35 q_collection.push_back(QGauss<1>(n_quad_points));
37 NonMatching::QuadratureGenerator<dim> quadrature_generator =
38 NonMatching::QuadratureGenerator<dim>(q_collection);
40 for (
unsigned int j = 0; j < n_dofs; j++)
42 cell_dof_level_set_values[j] += corr;
46 quadrature_generator.generate(signed_distance_function, unit_box);
48 const Quadrature<dim> inside_quadrature =
49 quadrature_generator.get_inside_quadrature();
51 if (inside_quadrature.size() == 0)
54 fe_point_evaluation.reinit(cell, inside_quadrature.get_points());
56 double inside_cell_volume = 0.0;
57 for (
unsigned int q = 0; q < inside_quadrature.size(); q++)
61 inside_cell_volume += fe_point_evaluation.jacobian(q).determinant() *
62 inside_quadrature.weight(q);
65 return inside_cell_volume;
68template <
int dim,
typename VectorType>
69std::pair<double, double>
71 const DoFHandler<dim> &dof_handler,
72 const FiniteElement<dim> &fe,
73 const VectorType &level_set_vector_relevant_copy)
76 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
78 NonMatching::MeshClassifier<dim> mesh_classifier(
79 dof_handler, level_set_vector_relevant_copy);
80 mesh_classifier.reclassify();
82 const hp::FECollection<dim> fe_collection(fe);
84 const QGauss<1> quadrature_1D(fe.degree + 1);
86 NonMatching::RegionUpdateFlags region_update_flags;
87 region_update_flags.inside = update_JxW_values;
88 region_update_flags.surface = update_JxW_values;
90 NonMatching::FEValues<dim> non_matching_fe_values(
96 level_set_vector_relevant_copy);
100 for (
const auto &cell : dof_handler.active_cell_iterators())
102 if (cell->is_locally_owned())
104 non_matching_fe_values.reinit(cell);
106 const std::optional<FEValues<dim>> &inside_fe_values =
107 non_matching_fe_values.get_inside_fe_values();
109 if (inside_fe_values)
110 for (
const unsigned int q :
111 inside_fe_values->quadrature_point_indices())
113 volume += inside_fe_values->JxW(q);
116 const std::optional<NonMatching::FEImmersedSurfaceValues<dim>>
117 &surface_fe_values = non_matching_fe_values.get_surface_fe_values();
119 if (surface_fe_values)
120 for (
const unsigned int q :
121 surface_fe_values->quadrature_point_indices())
123 surface += surface_fe_values->JxW(q);
127 volume = Utilities::MPI::sum(volume, mpi_communicator);
128 surface = Utilities::MPI::sum(surface, mpi_communicator);
130 return {volume, surface};
133template std::pair<double, double>
135 const DoFHandler<2> &dof_handler,
136 const FiniteElement<2> &fe,
139template std::pair<double, double>
141 const DoFHandler<3> &dof_handler,
142 const FiniteElement<3> &fe,
145template <
int dim,
typename VectorType>
146std::pair<double, double>
148 const FiniteElement<dim> &fe,
150 const double iso_level)
153 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
155 VectorType level_set_vector_owned_copy(dof_handler.locally_owned_dofs(),
158 level_set_vector_owned_copy = level_set_vector;
160 level_set_vector_owned_copy.add(-iso_level);
163 dof_handler.locally_owned_dofs(),
164 DoFTools::extract_locally_relevant_dofs(dof_handler),
167 level_set_vector_relevant_copy = level_set_vector_owned_copy;
171 level_set_vector_relevant_copy);
174template std::pair<double, double>
176 const DoFHandler<2> &dof_handler,
177 const FiniteElement<2> &fe,
179 const double iso_level);
180template std::pair<double, double>
182 const DoFHandler<3> &dof_handler,
183 const FiniteElement<3> &fe,
185 const double iso_level);
187template <
int dim,
typename VectorType>
188std::pair<Point<dim>, Tensor<1, dim>>
190 const DoFHandler<dim> &dof_handler,
191 const FiniteElement<dim> &fe,
192 const VectorType &level_set_vector_relevant_copy,
193 const Mapping<dim> &mapping_velocity,
194 const DoFHandler<dim> &dof_handler_velocity,
195 const FiniteElement<dim> &fe_velocity,
199 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
201 NonMatching::MeshClassifier<dim> mesh_classifier(
202 dof_handler, level_set_vector_relevant_copy);
203 mesh_classifier.reclassify();
205 const hp::FECollection<dim> fe_collection(fe);
207 const QGauss<1> quadrature_1D(fe.degree + 1);
209 NonMatching::RegionUpdateFlags region_update_flags;
210 region_update_flags.inside =
211 update_JxW_values | update_quadrature_points | update_values;
213 NonMatching::FEValues<dim> non_matching_fe_values(
219 level_set_vector_relevant_copy);
223 Point<dim> barycenter;
224 Tensor<1, dim> barycenter_velocity;
226 Vector<double> cell_dof_values(fe_velocity.dofs_per_cell);
228 FEPointEvaluation<dim + 1, dim> fe_point_evaluation(mapping_velocity,
232 for (
const auto &cell : dof_handler.active_cell_iterators())
234 if (cell->is_locally_owned())
236 non_matching_fe_values.reinit(cell);
238 const std::optional<FEValues<dim>> &inside_fe_values =
239 non_matching_fe_values.get_inside_fe_values();
241 if (inside_fe_values)
243 std::vector<Point<dim>> quadrature_points =
244 inside_fe_values->get_quadrature_points();
246 std::vector<Point<dim>> quadrature_points_ref(
247 inside_fe_values->n_quadrature_points);
249 mapping_velocity.transform_points_real_to_unit_cell(
250 cell, quadrature_points, quadrature_points_ref);
252 typename DoFHandler<dim>::active_cell_iterator cell_fd(
253 &(dof_handler_velocity.get_triangulation()),
256 &dof_handler_velocity);
258 fe_point_evaluation.reinit(cell, quadrature_points_ref);
260 cell_fd->get_dof_values(velocity_vector,
261 cell_dof_values.begin(),
262 cell_dof_values.end());
264 fe_point_evaluation.evaluate(cell_dof_values,
265 EvaluationFlags::values);
267 for (
const unsigned int q :
268 inside_fe_values->quadrature_point_indices())
270 volume += inside_fe_values->JxW(q);
272 auto velocity_value = fe_point_evaluation.get_value(q);
274 for (
int i = 0; i < dim; i++)
277 quadrature_points[q][i] * inside_fe_values->JxW(q);
279 barycenter_velocity[i] +=
280 velocity_value[i] * inside_fe_values->JxW(q);
287 volume = Utilities::MPI::sum(volume, mpi_communicator);
288 for (
int i = 0; i < dim; i++)
291 Utilities::MPI::sum(barycenter[i], mpi_communicator) / (volume + 1e-16);
292 barycenter_velocity[i] =
293 Utilities::MPI::sum(barycenter_velocity[i], mpi_communicator) /
297 return {barycenter, barycenter_velocity};
300template std::pair<Point<2>, Tensor<1, 2>>
302 const DoFHandler<2> &dof_handler,
303 const FiniteElement<2> &fe,
305 const Mapping<2> &mapping_velocity,
306 const DoFHandler<2> &dof_handler_velocity,
307 const FiniteElement<2> &fe_velocity,
310template std::pair<Point<3>, Tensor<1, 3>>
312 const DoFHandler<3> &dof_handler,
313 const FiniteElement<3> &fe,
315 const Mapping<3> &mapping_velocity,
316 const DoFHandler<3> &dof_handler_velocity,
317 const FiniteElement<3> &fe_velocity,
321template <
int dim,
typename VectorType>
322std::pair<Point<dim>, Tensor<1, dim>>
324 const DoFHandler<dim> &dof_handler,
325 const FiniteElement<dim> &fe,
327 const Mapping<dim> &mapping_velocity,
328 const DoFHandler<dim> &dof_handler_velocity,
329 const FiniteElement<dim> &fe_velocity,
331 const double iso_level)
334 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
336 VectorType level_set_vector_owned_copy(dof_handler.locally_owned_dofs(),
339 level_set_vector_owned_copy = level_set_vector;
341 level_set_vector_owned_copy *= -1.0;
342 level_set_vector_owned_copy.add(iso_level);
345 dof_handler.locally_owned_dofs(),
346 DoFTools::extract_locally_relevant_dofs(dof_handler),
349 level_set_vector_relevant_copy = level_set_vector_owned_copy;
353 level_set_vector_relevant_copy,
355 dof_handler_velocity,
360template std::pair<Point<2>, Tensor<1, 2>>
362 const FiniteElement<2> &fe,
364 const Mapping<2> &mapping_velocity,
365 const DoFHandler<2> &dof_handler_velocity,
366 const FiniteElement<2> &fe_velocity,
368 const double iso_level);
370template std::pair<Point<3>, Tensor<1, 3>>
372 const FiniteElement<3> &fe,
374 const Mapping<3> &mapping_velocity,
375 const DoFHandler<3> &dof_handler_velocity,
376 const FiniteElement<3> &fe_velocity,
378 const double iso_level);
380template <
int dim,
typename VectorType>
383 const Mapping<dim> &mapping,
384 const DoFHandler<dim> &dof_handler,
385 const FiniteElement<dim> &fe,
387 const double iso_level,
388 std::map<types::global_cell_index, std::vector<Point<dim>>>
389 &interface_reconstruction_vertices,
390 std::map<types::global_cell_index, std::vector<CellData<dim - 1>>>
391 &interface_reconstruction_cells,
392 std::set<types::global_dof_index> &intersected_dofs)
394 GridTools::MarchingCubeAlgorithm<dim, VectorType> marching_cube(mapping,
398 const unsigned int dofs_per_cell = fe.n_dofs_per_cell();
400 for (
const auto &cell : dof_handler.active_cell_iterators())
402 if ((cell->is_locally_owned()) || (cell->is_ghost()))
404 std::vector<Point<dim>> surface_vertices;
405 std::vector<CellData<dim - 1>> surface_cells;
407 marching_cube.process_cell(
408 cell, level_set_vector, iso_level, surface_vertices, surface_cells);
411 if (surface_vertices.size() != 0)
413 const unsigned int cell_index = cell->global_active_cell_index();
416 interface_reconstruction_vertices[cell_index] = surface_vertices;
417 interface_reconstruction_cells[cell_index] = surface_cells;
419 if (cell->is_locally_owned())
421 std::vector<types::global_dof_index> dof_indices(
423 cell->get_dof_indices(dof_indices);
425 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
427 intersected_dofs.insert(dof_indices[i]);
437 const Mapping<2> &mapping,
438 const DoFHandler<2> &dof_handler,
439 const FiniteElement<2> &fe,
441 const double iso_level,
442 std::map<types::global_cell_index, std::vector<Point<2>>>
443 &interface_reconstruction_vertices,
444 std::map<types::global_cell_index, std::vector<CellData<1>>>
445 &interface_reconstruction_cells,
446 std::set<types::global_dof_index> &intersected_dofs);
450 const Mapping<3> &mapping,
451 const DoFHandler<3> &dof_handler,
452 const FiniteElement<3> &fe,
454 const double iso_level,
455 std::map<types::global_cell_index, std::vector<Point<3>>>
456 &interface_reconstruction_vertices,
457 std::map<types::global_cell_index, std::vector<CellData<2>>>
458 &interface_reconstruction_cells,
459 std::set<types::global_dof_index> &intersected_dofs);
463 const Mapping<2> &mapping,
464 const DoFHandler<2> &dof_handler,
465 const FiniteElement<2> &fe,
466 const Vector<double> &level_set_vector,
467 const double iso_level,
468 std::map<types::global_cell_index, std::vector<Point<2>>>
469 &interface_reconstruction_vertices,
470 std::map<types::global_cell_index, std::vector<CellData<1>>>
471 &interface_reconstruction_cells,
472 std::set<types::global_dof_index> &intersected_dofs);
476 const Mapping<3> &mapping,
477 const DoFHandler<3> &dof_handler,
478 const FiniteElement<3> &fe,
479 const Vector<double> &level_set_vector,
480 const double iso_level,
481 std::map<types::global_cell_index, std::vector<Point<3>>>
482 &interface_reconstruction_vertices,
483 std::map<types::global_cell_index, std::vector<CellData<2>>>
484 &interface_reconstruction_cells,
485 std::set<types::global_dof_index> &intersected_dofs);
488template <
int dim,
typename VectorType>
492 const MPI_Comm mpi_communicator =
dof_handler.get_mpi_communicator();
527template <
int dim,
typename VectorType>
531 const DoFHandler<dim> &background_dof_handler,
532 const VectorType &background_level_set_vector)
534 const MPI_Comm mpi_communicator =
dof_handler.get_mpi_communicator();
538 FETools::interpolate(background_dof_handler,
539 background_level_set_vector,
542 tmp_local_level_set);
544 tmp_local_level_set *=
scaling;
549template <
int dim,
typename VectorType>
600template <
int dim,
typename VectorType>
619template <
int dim,
typename VectorType>
623 const MPI_Comm mpi_communicator =
dof_handler.get_mpi_communicator();
639template <
int dim,
typename VectorType>
653template <
int dim,
typename VectorType>
667template <
int dim,
typename VectorType>
672 distance.compress(VectorOperation::min);
696template <
int dim,
typename VectorType>
707 std::map<types::global_dof_index, Point<dim>> dof_support_points =
713 const unsigned int cell_index = intersected_cell.first;
717 std::vector<Point<dim>> surface_vertices =
719 std::vector<CellData<dim - 1>> surface_cells = intersected_cell.second;
721 Triangulation<dim - 1, dim> surface_triangulation;
722 surface_triangulation.create_triangulation(surface_vertices,
731 const Point<dim> y = dof_support_points.at(intersected_dof);
737 for (
const auto &surface_cell :
738 surface_triangulation.active_cell_iterators())
741 unsigned int surface_cell_n_vertices = surface_cell->n_vertices();
742 std::vector<Point<dim>> surface_cell_vertices(
743 surface_cell_n_vertices);
744 for (
unsigned int p = 0; p < surface_cell_n_vertices; p++)
746 surface_cell_vertices[p] = surface_cell->vertex(p);
752 surface_cell_vertices, y);
756 std::min(std::abs(
distance(intersected_dof)), std::abs(D));
763template <
int dim,
typename VectorType>
775 const MPI_Comm mpi_communicator =
dof_handler.get_mpi_communicator();
781 const unsigned int dofs_per_cell =
fe->n_dofs_per_cell();
782 unsigned int faces_per_cell = 4;
783 if constexpr (dim == 3)
786 unsigned int n_opposite_dofs_per_faces = 2;
787 if constexpr (dim == 3)
788 n_opposite_dofs_per_faces = 4;
790 unsigned int n_dofs_per_faces = 2;
791 if constexpr (dim == 3)
792 n_dofs_per_faces = 4;
794 std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
795 std::vector<double> cell_dof_values(dofs_per_cell);
797 std::vector<unsigned int> face_opposite_dofs(n_opposite_dofs_per_faces);
798 std::vector<unsigned int> face_local_dofs(n_dofs_per_faces);
799 std::vector<double> face_local_dof_values(n_dofs_per_faces);
803 Tensor<1, dim> x_n_to_x_I_real;
804 Tensor<1, dim> correction;
805 Point<dim> x_n_p1_ref;
806 Point<dim - 1> ref_face_center_point = Point<dim - 1>();
807 ref_face_center_point(0) = 0.5;
808 if constexpr (dim == 3)
809 ref_face_center_point(1) = 0.5;
812 std::vector<Point<dim>> x_n_ref_vector(n_opposite_dofs_per_faces);
813 std::vector<Point<dim>> x_n_real_vector(n_opposite_dofs_per_faces);
814 Tensor<1, dim> distance_gradients;
817 DerivativeForm<1, dim, dim> cell_transformation_jacobian;
818 LAPACKFullMatrix<double> face_transformation_jacobian(dim, dim - 1);
821 LAPACKFullMatrix<double> jacobian_matrix(dim - 1, dim - 1);
822 jacobian_matrix.set_property(LAPACKSupport::general);
823 Vector<double> residual_n_vec(dim - 1);
824 std::vector<double> correction_norm(n_opposite_dofs_per_faces, 1.0);
827 std::vector<int> outside_check(n_opposite_dofs_per_faces);
830 std::map<types::global_dof_index, Point<dim>> dof_support_points =
834 FEPointEvaluation<1, dim> fe_point_evaluation(
835 *
mapping, *
fe, update_gradients | update_jacobians);
837 FEPointEvaluation<1, dim> fe_point_evaluation_values_only(*
mapping,
848 std::map<
unsigned int,
849 std::set<typename DoFHandler<dim>::active_cell_iterator>>
854 std::set<typename DoFHandler<dim>::active_cell_iterator> corona_cell;
855 for (
const auto &cell :
dof_handler.active_cell_iterators())
857 if (cell->is_locally_owned())
859 const unsigned int cell_index = cell->global_active_cell_index();
865 auto active_neighbors =
868 corona_cell.insert(active_neighbors.begin(),
869 active_neighbors.end());
881 pcout <<
"Solving signed distance of layer " << count << std::endl;
884 for (
const auto &cell :
dof_handler.active_cell_iterators())
886 if (cell->is_locally_owned())
889 cell_dof_values.begin(),
890 cell_dof_values.end());
894 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
900 corona_cell.insert(cell);
906 for (
const auto &cell : corona_cell)
908 if (cell->is_locally_owned())
910 const unsigned int cell_index = cell->global_active_cell_index();
918 cell->get_dof_indices(dof_indices);
920 cell_dof_values.begin(),
921 cell_dof_values.end());
924 for (
unsigned int j = 0; j < faces_per_cell; ++j)
929 for (
unsigned int i = 0; i < n_opposite_dofs_per_faces; ++i)
933 ref_face_center_point, j);
936 correction_norm[i] = 1.0;
937 outside_check[i] = 0;
940 for (
unsigned int i = 0; i < n_dofs_per_faces; ++i)
942 face_local_dof_values[i] =
943 cell_dof_values[face_local_dofs[i]];
946 constexpr double tol = 1e-9;
947 unsigned int newton_it = 0;
948 constexpr int newton_max_it = 100;
953 while (*std::ranges::max_element(correction_norm) > tol &&
954 newton_it < newton_max_it)
958 fe_point_evaluation.reinit(cell, x_n_ref_vector);
959 fe_point_evaluation.evaluate(cell_dof_values,
960 EvaluationFlags::gradients);
963 for (
unsigned int i = 0; i < n_opposite_dofs_per_faces;
966 if (correction_norm[i] < tol)
971 const unsigned int local_face_opposite_dof =
972 face_opposite_dofs[i];
974 dof_indices[local_face_opposite_dof]))
976 correction_norm[i] = 0;
980 x_I_real = dof_support_points.at(
981 dof_indices[local_face_opposite_dof]);
984 fe_point_evaluation.quadrature_point(i);
986 fe_point_evaluation.get_gradient(i);
987 cell_transformation_jacobian =
988 fe_point_evaluation.jacobian(i);
990 cell_transformation_jacobian,
992 face_transformation_jacobian);
994 x_n_to_x_I_real = x_I_real - x_n_real_vector[i];
1001 face_transformation_jacobian,
1002 face_local_dof_values,
1007 Tensor<1, dim - 1> residual_n;
1010 face_transformation_jacobian,
1015 residual_n.unroll(residual_n_vec.begin(),
1016 residual_n_vec.end());
1017 residual_n_vec *= -1.0;
1021 jacobian_matrix.compute_lu_factorization();
1022 jacobian_matrix.solve(residual_n_vec);
1023 jacobian_matrix.reinit(dim - 1, dim - 1);
1026 correction_norm[i] = residual_n_vec.l2_norm();
1036 x_n_p1_ref = x_n_ref_vector[i] + correction;
1040 double relaxation = 1.0;
1080 for (
int k = 0; k < dim; ++k)
1082 if (x_n_p1_ref[k] > 1.0 + tol ||
1083 x_n_p1_ref[k] < 0.0 - tol)
1091 if (correction[k] > tol)
1094 std::min((1.0 - x_n_ref_vector[i][k]) /
1095 (correction[k] + tol),
1098 else if (correction[k] < -tol)
1101 std::min((0.0 - x_n_ref_vector[i][k]) /
1102 (correction[k] + tol),
1110 outside_check[i] += 1;
1112 if (outside_check[i] > 3)
1114 correction_norm[i] = 0.0;
1119 x_n_ref_vector[i] + relaxation * correction;
1122 x_n_ref_vector[i] = x_n_p1_ref;
1128 fe_point_evaluation_values_only.reinit(cell, x_n_ref_vector);
1129 fe_point_evaluation_values_only.evaluate(
1130 cell_dof_values, EvaluationFlags::values);
1131 for (
unsigned int i = 0; i < n_opposite_dofs_per_faces; ++i)
1133 const unsigned int local_face_opposite_dof =
1134 face_opposite_dofs[i];
1136 x_I_real = dof_support_points.at(
1137 dof_indices[local_face_opposite_dof]);
1139 x_n_real_vector[i] =
1140 fe_point_evaluation_values_only.quadrature_point(i);
1141 x_n_to_x_I_real = x_I_real - x_n_real_vector[i];
1143 double distance_value_at_x_n =
1144 fe_point_evaluation_values_only.get_value(i);
1146 double approx_distance =
1148 distance_value_at_x_n);
1155 constexpr double distance_tol = 1e-8;
1156 if (
distance(dof_indices[local_face_opposite_dof]) >
1157 (approx_distance + distance_tol))
1160 distance(dof_indices[local_face_opposite_dof]) =
1171 change = Utilities::MPI::logical_or(change, mpi_communicator);
1180template <
int dim,
typename VectorType>
1205 for (
auto p : this->locally_active_dofs)
1211template <
int dim,
typename VectorType>
1216 FEPointEvaluation<1, dim> fe_point_evaluation(
1217 *
mapping, *
fe, update_jacobians | update_JxW_values);
1219 const unsigned int dofs_per_cell =
fe->n_dofs_per_cell();
1223 double n_cells_per_dofs_inv = 1.0 / 4.0;
1224 if constexpr (dim == 3)
1226 n_cells_per_dofs_inv = 1.0 / 8.0;
1232 for (
const auto &cell :
dof_handler.active_cell_iterators())
1234 if (cell->is_locally_owned())
1236 const unsigned int cell_index = cell->global_active_cell_index();
1258 Vector<double> cell_level_set_dof_values(dofs_per_cell);
1261 cell_level_set_dof_values.begin(),
1262 cell_level_set_dof_values.end());
1265 double targeted_cell_volume =
1268 cell_level_set_dof_values,
1273 Vector<double> cell_dof_values(dofs_per_cell);
1275 cell_dof_values.begin(),
1276 cell_dof_values.end());
1282 const double cell_volume = cell->measure();
1283 const double cell_size =
1290 double inside_cell_volume_nm1 = 0.0;
1291 double inside_cell_volume_n = 0.0;
1293 double delta_volume_nm1 = 0.0;
1294 double delta_volume_n = 0.0;
1296 double delta_volume_prime = 0.0;
1298 double eta_nm1 = 0.0;
1299 double eta_n = 1e-6 * cell_size;
1300 double eta_np1 = 0.0;
1303 inside_cell_volume_nm1 =
1309 delta_volume_nm1 = targeted_cell_volume - inside_cell_volume_nm1;
1313 const double initial_inside_cell_volume = inside_cell_volume_nm1;
1317 constexpr double tol = 1e-12;
1318 if (inside_cell_volume_nm1 < tol * cell_volume ||
1319 inside_cell_volume_nm1 > (cell_volume - tol * cell_volume))
1325 unsigned int secant_it = 0;
1326 unsigned int secant_max_it = 20;
1327 double secant_update = 1.0;
1330 while (abs(secant_update) > tol &&
1331 abs(delta_volume_nm1) > tol * initial_inside_cell_volume &&
1332 secant_it < secant_max_it)
1336 if (inside_cell_volume_nm1 < tol * cell_size ||
1337 inside_cell_volume_nm1 > (cell_size - tol * cell_size))
1344 inside_cell_volume_n =
1351 delta_volume_n = targeted_cell_volume - inside_cell_volume_n;
1353 delta_volume_prime =
1354 (delta_volume_n - delta_volume_nm1) / (eta_n - eta_nm1 + tol);
1356 secant_update = -delta_volume_n / (delta_volume_prime + tol);
1357 eta_np1 = eta_n + secant_update;
1361 inside_cell_volume_nm1 = inside_cell_volume_n;
1362 delta_volume_nm1 = delta_volume_n;
1366 if (secant_it >= secant_max_it)
1371 std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
1372 cell->get_dof_indices(dof_indices);
1376 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
1387template <
int dim,
typename VectorType>
1403 const MPI_Comm mpi_communicator =
dof_handler.get_mpi_communicator();
1408 double global_volume, surface;
1410 std::tie(global_volume, surface) =
1417 double global_volume_nm1 = 0.0;
1418 double global_volume_n = 0.0;
1420 double global_delta_volume_nm1 = 0.0;
1421 double global_delta_volume_n = 0.0;
1423 double global_delta_volume_prime = 0.0;
1436 LinearAlgebra::distributed::Vector<double> signed_distance_0(
1441 signed_distance_0.update_ghost_values();
1443 std::tie(global_volume_nm1, surface) =
1446 global_delta_volume_nm1 = global_volume - global_volume_nm1;
1449 C_n = 1e-6 * global_volume;
1452 const double global_volume_0 = global_volume_nm1;
1455 constexpr double tol = 1e-12;
1456 unsigned int secant_it = 0;
1457 constexpr unsigned int secant_max_it = 20;
1458 double secant_update = 1.0;
1461 while (abs(secant_update) > tol &&
1462 abs(global_delta_volume_nm1) > tol * global_volume_0 &&
1463 secant_it < secant_max_it)
1467 LinearAlgebra::distributed::Vector<double> signed_distance_n(
1470 signed_distance_n.update_ghost_values();
1472 std::tie(global_volume_n, surface) =
1475 global_delta_volume_n = global_volume - global_volume_n;
1477 global_delta_volume_prime =
1478 (global_delta_volume_n - global_delta_volume_nm1) / (C_n - C_nm1 + tol);
1481 -global_delta_volume_n / (global_delta_volume_prime + tol);
1483 C_np1 = C_n + secant_update;
1487 global_volume_nm1 = global_volume_n;
1488 global_delta_volume_nm1 = global_delta_volume_n;
1492 if (secant_it >= secant_max_it)
1497 unsigned int this_mpi_process(
1498 Utilities::MPI::this_mpi_process(mpi_communicator));
1499 if (this_mpi_process == 0)
1501 std::vector<std::string> column_names = {
1503 "Volume after redistanciation",
1504 "Remaining error on the volume"};
1506 TableHandler volume_conservation_table;
1507 volume_conservation_table.declare_column(column_names[0]);
1508 volume_conservation_table.add_value(column_names[0], global_volume);
1509 volume_conservation_table.set_scientific(column_names[0],
true);
1511 volume_conservation_table.declare_column(column_names[1]);
1512 volume_conservation_table.add_value(column_names[1], global_volume_n);
1513 volume_conservation_table.set_scientific(column_names[1],
true);
1515 volume_conservation_table.declare_column(column_names[2]);
1516 volume_conservation_table.add_value(column_names[2],
1517 global_delta_volume_n);
1518 volume_conservation_table.set_scientific(column_names[2],
true);
1520 volume_conservation_table.write_text(std::cout);
1537template <
int dim,
typename VectorType>
1541 const std::string &output_path,
1543 const unsigned int it)
1545 const MPI_Comm mpi_communicator =
dof_handler.get_mpi_communicator();
1551 reconstruction_data_out,
1560template <
int dim,
typename VectorType>
1563 const std::string &output_name,
1564 const std::string &output_path,
1566 const unsigned int it)
1568 const MPI_Comm mpi_communicator =
dof_handler.get_mpi_communicator();
1570 DataOut<dim> data_out;
1573 data_out.build_patches(*this->
mapping,
1575 DataOut<dim>::curved_inner_cells);
1586template <
int dim,
typename VectorType>
1587std::vector<OutputStruct<dim, GlobalVectorType>>
1590#ifndef LETHE_USE_LDV
1591 const MPI_Comm mpi_communicator =
dof_handler.get_mpi_communicator();
1603 std::vector<OutputStruct<dim, GlobalVectorType>> solution_output_structs;
1604 std::vector<std::string> solution_names(1,
"signed_distance");
1605 std::vector<DataComponentInterpretation::DataComponentInterpretation>
1606 solution_data_component_interpretation(
1607 1, DataComponentInterpretation::component_is_scalar);
1608 solution_output_structs.emplace_back(
1613 solution_data_component_interpretation);
1615 return solution_output_structs;
1621#ifndef LETHE_USE_LDV
1622template class InterfaceTools::
1623 SignedDistanceSolver<2, LinearAlgebra::distributed::Vector<double>>;
1624template class InterfaceTools::
1625 SignedDistanceSolver<3, LinearAlgebra::distributed::Vector<double>>;
1631template <
int dim,
typename VectorType>
1634 const DoFHandler<dim> &dof_handler,
1636 const double isovalue)
1639 const MPI_Comm mpi_communicator = dof_handler.get_mpi_communicator();
1641 bool isocontour_exists =
false;
1656 VectorType solution_vector_owned_copy(dof_handler.locally_owned_dofs(),
1658 solution_vector_owned_copy = solution_vector;
1661 solution_vector_owned_copy.add(-isovalue);
1665 dof_handler.locally_owned_dofs(),
1666 DoFTools::extract_locally_relevant_dofs(dof_handler),
1668 solution_vector_relevant_copy = solution_vector_owned_copy;
1671 NonMatching::MeshClassifier<dim> mesh_classifier(
1672 dof_handler, solution_vector_relevant_copy);
1673 mesh_classifier.reclassify();
1676 const hp::FECollection<dim> fe_collection(dof_handler.get_fe());
1677 const QGauss<1> quadrature_1D(dof_handler.get_fe().degree + 1);
1678 NonMatching::RegionUpdateFlags region_update_flags;
1679 region_update_flags.surface = update_quadrature_points;
1680 NonMatching::FEValues<dim> non_matching_fe_values(
1683 region_update_flags,
1686 solution_vector_relevant_copy);
1688 for (
const auto &cell : dof_handler.active_cell_iterators())
1690 if (cell->is_locally_owned())
1693 non_matching_fe_values.reinit(cell);
1694 const std::optional<NonMatching::FEImmersedSurfaceValues<dim>>
1695 &surface_fe_values = non_matching_fe_values.get_surface_fe_values();
1699 if (surface_fe_values)
1701 const auto &q_points = surface_fe_values->get_quadrature_points();
1702 if (q_points.size() > 0)
1703 isocontour_exists =
true;
1704 for (
const auto &p : q_points)
1710 if constexpr (dim == 3)
1712 isocontour_bounding_values
1714 std::min(isocontour_bounding_values
1717 isocontour_bounding_values
1719 std::max(isocontour_bounding_values
1729 x_min = Utilities::MPI::min(x_min, mpi_communicator);
1730 x_max = Utilities::MPI::max(x_max, mpi_communicator);
1731 y_min = Utilities::MPI::min(y_min, mpi_communicator);
1732 y_max = Utilities::MPI::max(y_max, mpi_communicator);
1733 if constexpr (dim == 3)
1735 isocontour_bounding_values.
bounding_values[BoundingCoordinates::z_min] =
1736 Utilities::MPI::min(isocontour_bounding_values
1737 .bounding_values[BoundingCoordinates::z_min],
1739 isocontour_bounding_values.
bounding_values[BoundingCoordinates::z_max] =
1740 Utilities::MPI::max(isocontour_bounding_values
1741 .bounding_values[BoundingCoordinates::z_max],
1745 Utilities::MPI::logical_or(isocontour_exists, mpi_communicator);
1747 return isocontour_bounding_values;
1752 const DoFHandler<2> &dof_handler,
1754 const double isovalue);
1758 const DoFHandler<3> &dof_handler,
1760 const double isovalue);
1762template <
int dim,
typename VectorType>
1767 std::pair<
unsigned int,
1769 dim>::IsocontourBoundingBoxes::Isocontour>>
1770 &ids_and_isocontours_per_variable,
1771 const DoFHandler<dim> &dof_handler,
1773 const double current_time,
1775 const ConditionalOStream &pcout,
1776 std::vector<TableHandler> &isocontour_bounding_values_tables)
1779 auto [begin, end] = ids_and_isocontours_per_variable.equal_range(variable);
1784 for (
auto it = begin; it != end; ++it, ++i)
1787 const unsigned int id = it->second.first;
1789 dim>::IsocontourBoundingBoxes::Isocontour &isocontour =
1796 isocontour.isovalue);
1800 const auto &bounding_coordinates_names =
1805 pcout <<
"Isocontour " <<
id <<
": " << isocontour.output_name
1808 for (
unsigned int j = 0; j < bounding_coordinates_names.size();
1811 pcout << bounding_coordinates_names[j] <<
": "
1818 const unsigned int table_precision = 6;
1819 TableHandler ¤t_table = isocontour_bounding_values_tables[i];
1821 current_table.add_value(
"time", current_time);
1822 current_table.set_scientific(
"time",
true);
1823 for (
unsigned int j = 0; j < bounding_coordinates_names.size(); ++j)
1825 current_table.add_value(
1826 bounding_coordinates_names[j],
1828 current_table.set_precision(bounding_coordinates_names[j],
1830 current_table.set_scientific(bounding_coordinates_names[j],
true);
1840 std::pair<
unsigned int,
1842 2>::IsocontourBoundingBoxes::Isocontour>>
1843 &ids_and_isocontours_per_variable,
1844 const DoFHandler<2> &dof_handler,
1846 const double current_time,
1848 const ConditionalOStream &pcout,
1849 std::vector<TableHandler> &isocontour_bounding_values_tables);
1855 std::pair<
unsigned int,
1857 3>::IsocontourBoundingBoxes::Isocontour>>
1858 &ids_and_isocontours_per_variable,
1859 const DoFHandler<3> &dof_handler,
1861 const double current_time,
1863 const ConditionalOStream &pcout,
1864 std::vector<TableHandler> &isocontour_bounding_values_tables);
1869 const MPI_Comm &mpi_communicator,
1870 const std::string &output_folder,
1873 std::pair<
unsigned int,
1875 dim>::IsocontourBoundingBoxes::Isocontour>>
1876 &ids_and_isocontours_per_variable,
1877 const std::vector<TableHandler> &isocontour_bounding_values_tables)
1879 if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
1883 ids_and_isocontours_per_variable.equal_range(variable);
1888 for (
auto it = begin; it != end; ++it, ++i)
1891 const std::string &isocontour_output_name =
1892 it->second.second.output_name;
1893 std::string filename =
1894 output_folder + isocontour_output_name +
".dat";
1895 std::ofstream output(filename.c_str());
1897 isocontour_bounding_values_tables[i].write_text(output);
1904 const MPI_Comm &mpi_communicator,
1905 const std::string &output_folder,
1908 std::pair<
unsigned int,
1910 2>::IsocontourBoundingBoxes::Isocontour>>
1911 &ids_and_isocontours_per_variable,
1912 const std::vector<TableHandler> &isocontour_bounding_values_tables);
1916 const MPI_Comm &mpi_communicator,
1917 const std::string &output_folder,
1920 std::pair<
unsigned int,
1922 3>::IsocontourBoundingBoxes::Isocontour>>
1923 &ids_and_isocontours_per_variable,
1924 const std::vector<TableHandler> &isocontour_bounding_values_tables);
Postprocessing - Defines the parameters for the post-processing. In Lethe, post-processing implies th...
void announce_string(const ConditionalOStream &pcout, const std::string &expression, const char delimiter='-')
Prints a string and then adds a line above and below made with dashes containing as many dashes as th...
constexpr int sgn(const T val) noexcept
Retrieve the sign of a value.
double compute_cell_diameter(const double cell_measure, const unsigned int fe_degree)
Computes equivalent cell diameter by comparing the area to a disk (2D) or the volume to a sphere (3D)...
Variable
Solution fields of the different physics that are used as an indicator for multiple purposes (e....
@ velocity
Velocity vector field from fluid dynamics.
void write_vtu_and_pvd(PVDHandler &pvd_handler, const DataOutInterface< dim, spacedim > &data_out, const std::string &folder, const std::string &file_prefix, const double time, const unsigned int iter, const unsigned int group_files, const MPI_Comm &mpi_communicator, const unsigned int digits=5)
Output the data out to "group_files" vtu files, with a pvtu file and a pvd to store the timing This f...
Struct containing information about the solution output. It is used to pass all the information requi...
GlobalVectorType VectorType
dealii::TrilinosWrappers::MPI::Vector GlobalVectorType
void convert_vector_dealii_to_trilinos(dealii::TrilinosWrappers::MPI::Vector &out, const dealii::LinearAlgebra::distributed::Vector< number > &in)
Helper function that allows to convert deal.II vectors to Trilinos vectors.