4#include <deal.II/base/config.h>
8#include <deal.II/base/exceptions.h>
9#include <deal.II/base/mpi_noncontiguous_partitioner.templates.h>
11#include <deal.II/fe/fe_nothing.h>
16 InterfaceRadiusTolerance,
18 <<
"The computed radius of the rotor mesh has a variation of " << arg1
19 <<
" along the interface boundary, which exceeds the prescribed tolerance.");
27 AssertThrow(dim != 1, ExcInternalError());
32 const double tolerance = 1e-8 * delta_0;
42 if constexpr (dim == 1)
52 if constexpr (dim == 3)
56 return n_total_subdivisions;
58 return 2 * n_total_subdivisions;
65 if constexpr (dim == 1)
75std::vector<unsigned int>
77 const bool is_inner)
const
79 if constexpr (dim == 1)
80 return std::vector<unsigned int>{0};
83 const auto [type, id_in_plane, id_out_plane] =
88 std::vector<unsigned int> indices;
90 const unsigned int index = id_in_plane;
100 std::vector<unsigned int> indices;
102 for (
unsigned int q = 0; q < 2; ++q)
105 const unsigned int index =
110 indices.emplace_back(index + 2 *
n_subdivisions[0] * id_out_plane);
117 std::vector<unsigned int> indices;
119 for (
unsigned int q = 0; q < 2; ++q)
122 const unsigned int index = id_in_plane * 2 + q;
126 indices.emplace_back(index + 2 *
n_subdivisions[0] * id_out_plane);
137 if constexpr (dim == 1)
147 if constexpr (dim == 1)
154std::vector<Point<dim>>
156 const bool is_inner)
const
158 if constexpr (dim == 1)
159 return std::vector<Point<dim>>{face_center};
162 const auto [type, id_in_plane, id_out_plane] =
168 double delta_1 = 1.0;
170 if constexpr (dim == 3)
175 std::vector<Point<dim>> points;
183 if constexpr (dim == 3)
187 points.emplace_back(x);
207 double rad_0, rad_1, rad_2;
215 rad_0 = id_in_plane * delta_0;
216 rad_1 = id_in_plane * delta_0 + rot_min;
217 rad_2 = (id_in_plane + 1) * delta_0;
221 rad_0 = id_in_plane * delta_0 + rot_min;
222 rad_1 = (id_in_plane + 1) * delta_0;
223 rad_2 = (id_in_plane + 1) * delta_0 + rot_min;
226 std::vector<Point<dim>> points;
235 if constexpr (dim == 3)
239 points.emplace_back(x);
249 if constexpr (dim == 3)
253 points.emplace_back(x);
261std::vector<Point<std::max(1, dim - 1)>>
263 const bool is_inner)
const
266 return std::vector<Point<std::max(1, dim - 1)>>{
267 Point<std::max(1, dim - 1)>()};
270 const auto [type, _, __] =
get_config(face_center, is_inner);
276 std::vector<Point<std::max(1, dim - 1)>> points;
292 double rad_0, rad_1, rad_2;
307 rad_1 = 1.0 - rot_min;
311 std::vector<Point<std::max(1, dim - 1)>> points;
317 const double x = rad_0 +
quadrature.point(q)[0] * (rad_1 - rad_0);
320 points.emplace_back(x);
322 points.emplace_back(x,
quadrature.point(q)[1]);
328 const double x = rad_1 +
quadrature.point(q)[0] * (rad_2 - rad_1);
331 points.emplace_back(x);
333 points.emplace_back(x,
quadrature.point(q)[1]);
343 const bool is_inner)
const
346 return std::vector<double>{1.0};
349 const auto [type, id_in_plane, id_out_plane] =
353 double delta_1 = 1.0;
360 std::vector<double> weights;
382 double rad_0, rad_1, rad_2;
389 rad_0 = id_in_plane * delta_0;
390 rad_1 = id_in_plane * delta_0 + rot_min;
391 rad_2 = (id_in_plane + 1) * delta_0;
395 rad_0 = id_in_plane * delta_0 + rot_min;
396 rad_1 = (id_in_plane + 1) * delta_0;
397 rad_2 = (id_in_plane + 1) * delta_0 + rot_min;
402 std::vector<double> weights;
408 (rad_1 - rad_0) * delta_1);
413 (rad_2 - rad_1) * delta_1);
420std::vector<Tensor<1, dim, double>>
422 const bool is_inner)
const
425 const auto points =
get_points(face_center, is_inner);
427 std::vector<Tensor<1, dim, double>> result;
429 result.reserve(points.size());
431 for (
const auto &point : points)
438std::tuple<unsigned int, unsigned int, unsigned int>
440 const bool is_inner)
const
442 const auto angle_cell_center =
to_1D(face_center);
447 const double rot_min =
450 AssertThrow(rot_min <= delta_0, ExcInternalError());
453 const double segment = (angle_cell_center - delta_0 / 2) / delta_0;
455 const double segment_rot =
456 (angle_cell_center - delta_0 / 2 - rot_min) / delta_0;
458 unsigned int id_out_plane = 0;
460 if constexpr (dim == 3)
464 auto upper_height_iterator =
467 face_center[this->rotation_axis_direction]);
471 std::distance(
stage_heights.begin(), upper_height_iterator) - 1;
477 return {0,
static_cast<unsigned int>(std::round(segment)), id_out_plane};
485 static_cast<unsigned int>(std::round(segment)),
490 (
static_cast<unsigned int>(std::round(segment_rot)) +
500std::vector<unsigned int>
505 unsigned int n_subdivisions_local = 0;
507 unsigned int n_subdivisions_plane_local = 0;
511 const unsigned int rotation_axis_direction =
516 double coord_ref_local = std::numeric_limits<double>::max();
518 if constexpr (dim == 3)
524 for (
const auto &cell : triangulation.active_cell_iterators())
526 if (cell->is_locally_owned())
528 for (
const auto face_no : cell->face_indices())
530 const auto face = cell->face(face_no);
532 if (face->at_boundary() &&
533 face->boundary_id() ==
536 std::min(coord_ref_local,
537 cell->center()[rotation_axis_direction]);
544 const double coord_ref =
545 Utilities::MPI::min(coord_ref_local, triangulation.get_mpi_communicator());
548 for (
const auto &cell : triangulation.active_cell_iterators())
550 if (cell->is_locally_owned())
552 for (
const auto face_no : cell->face_indices())
554 const auto face = cell->face(face_no);
556 if (face->at_boundary())
558 if (face->boundary_id() ==
561 n_subdivisions_local++;
565 if constexpr (dim == 3)
569 if (std::abs(cell->center()[rotation_axis_direction] -
570 coord_ref) < radius_tolerance)
571 n_subdivisions_plane_local++;
574 n_subdivisions_plane_local++;
582 const unsigned int n_subdivisions =
583 Utilities::MPI::sum(n_subdivisions_local,
584 triangulation.get_mpi_communicator());
587 const unsigned int n_subdivisions_plane =
588 Utilities::MPI::sum(n_subdivisions_plane_local,
589 triangulation.get_mpi_communicator());
591 return {n_subdivisions_plane, n_subdivisions / n_subdivisions_plane};
595std::tuple<std::vector<double>,
double>
597 const Triangulation<dim> &triangulation,
598 const Mapping<dim> &mapping,
604 double radius_min = std::numeric_limits<double>::max();
605 double radius_max = 0;
607 double pre_rotation_min = std::numeric_limits<double>::max();
610 const unsigned int rotation_axis_direction =
613 Tensor<1, dim> rotation_axis;
614 if constexpr (dim == 3)
615 rotation_axis[rotation_axis_direction] = 1.0;
619 double vertex_min = std::numeric_limits<double>::max();
620 double vertex_max = std::numeric_limits<double>::lowest();
623 for (
const auto &cell : triangulation.active_cell_iterators())
625 if (cell->is_locally_owned())
627 for (
const auto face_no : cell->face_indices())
629 const auto face = cell->face(face_no);
631 if (face->at_boundary())
633 if (face->boundary_id() ==
636 const auto vertices = mapping.get_vertices(cell, face_no);
638 for (
unsigned int vertex_index = 0;
639 vertex_index < face->n_vertices();
642 const auto v = vertices[vertex_index];
643 double radius_current =
650 if constexpr (dim == 3)
652 vertex_min = std::min(vertex_min,
653 v[rotation_axis_direction]);
654 vertex_max = std::max(vertex_max,
655 v[rotation_axis_direction]);
664 radius_min = std::min(radius_min, radius_current);
665 radius_max = std::max(radius_max, radius_current);
670 else if (face->boundary_id() ==
673 const auto vertices = mapping.get_vertices(cell, face_no);
675 for (
unsigned int vertex_index = 0;
676 vertex_index < face->n_vertices();
679 const auto v = vertices[vertex_index];
681 pre_rotation_min = std::min(
685 rotation_axis_direction));
695 Utilities::MPI::min(radius_min, triangulation.get_mpi_communicator());
697 Utilities::MPI::max(radius_max, triangulation.get_mpi_communicator());
700 Utilities::MPI::min(pre_rotation_min, triangulation.get_mpi_communicator());
703 Utilities::MPI::min(vertex_min, triangulation.get_mpi_communicator());
705 Utilities::MPI::max(vertex_max, triangulation.get_mpi_communicator());
708 const auto radius_diff = std::abs(radius_max - radius_min);
711 AssertThrow(radius_diff < radius_tolerance,
712 InterfaceRadiusTolerance(radius_diff));
715 const double radius = radius_min;
717 const double length_rot_axis = dim == 3 ? vertex_max - vertex_min : 0;
719 return {{radius, length_rot_axis}, pre_rotation_min};
723std::pair<double, double>
725 const Triangulation<dim> &triangulation,
726 const Mapping<dim> &mapping,
731 double coord_min = std::numeric_limits<double>::max();
732 double coord_max = 0;
734 for (
const auto &cell : triangulation.active_cell_iterators())
736 if (cell->is_locally_owned())
738 for (
const auto face_no : cell->face_indices())
740 const auto face = cell->face(face_no);
742 if (face->at_boundary())
744 if (face->boundary_id() ==
747 const auto vertices = mapping.get_vertices(cell, face_no);
749 for (
unsigned int vertex_index = 0;
750 vertex_index < face->n_vertices();
753 const auto v = vertices[vertex_index];
754 coord_min = std::min(coord_min, v[1]);
755 coord_max = std::max(coord_max, v[1]);
765 Utilities::MPI::min(coord_min, triangulation.get_mpi_communicator());
767 Utilities::MPI::max(coord_max, triangulation.get_mpi_communicator());
769 return {coord_min, coord_max};
777 const int oversampling_factor =
780 for (
unsigned int i = 1; i <= 10; ++i)
781 if (quadrature == QGauss<dim>(i))
782 return QGauss<dim>(i * oversampling_factor);
784 AssertThrow(
false, ExcNotImplemented());
794 if constexpr (dim == 3)
797 const unsigned int rotation_axis_direction =
801 std::vector<double> stage_heights_local;
804 double minimum_face_diameter_local = std::numeric_limits<double>::max();
808 for (
const auto &cell : triangulation.active_cell_iterators())
810 if (cell->is_locally_owned())
812 for (
const auto face_no : cell->face_indices())
814 const auto face = cell->face(face_no);
819 if (face->at_boundary() &&
820 face->boundary_id() ==
823 minimum_face_diameter_local =
824 std::min(minimum_face_diameter_local, face->diameter());
826 for (
const auto vertex_no : face->vertex_indices())
827 stage_heights_local.push_back(
828 face->vertex(vertex_no)[rotation_axis_direction]);
834 double minimum_face_diameter =
835 Utilities::MPI::min(minimum_face_diameter_local,
836 triangulation.get_mpi_communicator());
840 const auto stage_heights_all =
841 Utilities::MPI::all_gather(triangulation.get_mpi_communicator(),
842 stage_heights_local);
843 std::vector<double> stage_heights;
844 for (
const auto &heights_per_process : stage_heights_all)
845 stage_heights.insert(stage_heights.end(),
846 heights_per_process.begin(),
847 heights_per_process.end());
850 const double height_tolerance = minimum_face_diameter * 1e-8;
853 std::ranges::sort(stage_heights);
855 std::ranges::unique(stage_heights,
856 [height_tolerance](
const double a,
const double b) {
857 return std::abs(a - b) <= height_tolerance;
859 stage_heights.erase(result.begin(), result.end());
861 return stage_heights;
871 const ConditionalOStream &pcout)
873 unsigned int n_mortar_cells = 0;
876 for (
const auto &cell : triangulation.active_cell_iterators())
877 if (cell->is_locally_owned())
878 for (
const auto face_no : cell->face_indices())
880 const auto face = cell->face(face_no);
882 if (face->at_boundary() &&
889 const auto [n_mortar_cells_sum,
895 Utilities::MPI::min_max_avg(n_mortar_cells,
896 triangulation.get_mpi_communicator());
898 const unsigned int n_proc =
899 Utilities::MPI::n_mpi_processes(triangulation.get_mpi_communicator());
902 const double ideal_work = n_mortar_cells_sum /
static_cast<double>(n_proc);
905 const double workload_imbalance = n_mortar_cells_max / ideal_work;
907 pcout <<
"Workload imbalance: " << workload_imbalance << std::endl;
908 pcout << std::defaultfloat;
909 pcout <<
"Number of cells per process - Min.: " << n_mortar_cells_min
911 pcout <<
" Max.: " << n_mortar_cells_max
913 pcout << std::scientific;
939Tensor<1, dim, double>
943 if constexpr (dim == 3)
946 return radial / radial.norm();
955 return Point<dim>(0.5,
968Tensor<1, dim, double>
971 return Point<dim>(1.0, 0.0);
975template <
int dim,
typename Number>
979 const AffineConstraints<Number> &constraints,
982 const unsigned int bid_m,
983 const unsigned int bid_p,
984 const double sip_factor)
996 data.penalty_factor =
1000 const unsigned int n_sub_cells =
mortar_manager->get_n_total_mortars();
1002 std::vector<types::global_dof_index> is_local_cell;
1003 std::vector<types::global_dof_index> is_ghost_cell;
1006 std::vector<double> vec_local_cells(n_sub_cells * 2, 0.0);
1007 std::vector<double> vec_ghost_cells(n_sub_cells * 2, 0.0);
1010 for (
const auto &cell :
dof_handler.active_cell_iterators())
1011 if (cell->is_locally_owned())
1012 for (
const auto face_no : cell->face_indices())
1013 if ((cell->face(face_no)->boundary_id() ==
bid_m) ||
1014 (cell->face(face_no)->boundary_id() ==
bid_p))
1016 const auto face = cell->face(face_no);
1022 center, cell->face(face_no)->boundary_id() ==
bid_m);
1029 for (
unsigned int ii = 0; ii < indices.size(); ++ii)
1031 const unsigned int i = indices[ii];
1032 unsigned int id_local = 0, id_ghost = 0;
1034 if (face->boundary_id() ==
bid_m)
1037 id_ghost = i + n_sub_cells;
1039 else if (face->boundary_id() ==
bid_p)
1041 id_local = i + n_sub_cells;
1046 vec_local_cells[id_local] += 1.0;
1047 vec_ghost_cells[id_ghost] += 1.0;
1049 is_local_cell.emplace_back(id_local);
1050 is_ghost_cell.emplace_back(id_ghost);
1052 for (
const auto l_dof : local_dofs)
1057 const auto weights =
1059 cell->face(face_no)->boundary_id() ==
1061 data.all_weights.insert(
data.all_weights.end(),
1066 if constexpr (dim == 3)
1070 cell->face(face_no)->boundary_id() ==
bid_m);
1071 std::vector<Point<dim, Number>> points_ref(points.size());
1072 mapping.transform_points_real_to_unit_cell(cell,
1079 std::vector<Point<dim - 1>> quad;
1081 for (
const auto &p : points_ref)
1083 Point<dim - 1> temp;
1086 const unsigned int axis = face_no / 2;
1091 for (
int t = 0; t < dim - 1; ++t)
1092 temp[t] = p[(axis + 1 + t) % dim];
1094 quad.emplace_back(temp);
1097 FEFaceValues<dim> fe_face_values(
mapping,
1100 update_normal_vectors);
1102 fe_face_values.reinit(cell, face_no);
1104 data.all_normals.insert(
1105 data.all_normals.end(),
1106 fe_face_values.get_normal_vectors().begin(),
1107 fe_face_values.get_normal_vectors().end());
1113 cell->face(face_no)->boundary_id() ==
bid_m);
1116 if (face->boundary_id() ==
bid_p)
1117 for (
auto &normal : normals)
1119 data.all_normals.insert(
data.all_normals.end(),
1123 if constexpr (dim == 1)
1127 else if (face_no == 1)
1130 AssertThrow(
false, ExcNotImplemented());
1132 else if constexpr (dim == 2)
1136 cell->face(face_no)->boundary_id() ==
bid_m);
1141 (face->vertex(0)[0] * face->vertex(1)[1] -
1142 face->vertex(0)[1] * face->vertex(1)[0]) < 0.0;
1147 for (
auto &p : points)
1150 if (face_no / 2 == 0)
1152 for (
auto &p : points)
1155 else if (face_no / 2 == 1)
1157 for (
auto &p : points)
1162 AssertThrow(
false, ExcNotImplemented());
1165 else if constexpr (dim == 3)
1167 AssertThrow(
false, ExcNotImplemented());
1170 AssertThrow(
false, ExcNotImplemented());
1177 for (
unsigned int i = 0; i <
mortar_manager->get_n_points(); ++i)
1178 data.all_penalty_parameter.emplace_back(penalty_parameter);
1182 Utilities::MPI::sum(vec_local_cells,
1185 Utilities::MPI::sum(vec_ghost_cells,
1189 std::set<unsigned int> vec_local_cells_0;
1190 std::set<unsigned int> vec_local_cells_2;
1192 if (Utilities::MPI::this_mpi_process(
dof_handler.get_mpi_communicator()) == 0)
1194 for (
unsigned int i = 0; i < vec_local_cells.size(); ++i)
1196 if (vec_local_cells[i] == 0)
1197 vec_local_cells_0.insert(i);
1198 if (vec_local_cells[i] > 1)
1199 vec_local_cells_2.insert(i);
1202 std::set<unsigned int> vec_ghost_cells_0;
1203 std::set<unsigned int> vec_ghost_cells_2;
1205 for (
unsigned int i = 0; i < vec_ghost_cells.size(); ++i)
1207 if (vec_ghost_cells[i] == 0)
1208 vec_ghost_cells_0.insert(i);
1209 if (vec_ghost_cells[i] > 1)
1210 vec_ghost_cells_2.insert(i);
1213 if (!(vec_local_cells_0.empty() && vec_local_cells_2.empty() &&
1214 vec_ghost_cells_0.empty() && vec_ghost_cells_2.empty()))
1216 std::cout <<
"CouplingOperator mortar matching failed:" << std::endl;
1218 if (!vec_local_cells_0.empty())
1220 std::cout <<
" - some local cells are not owned: ";
1221 for (
const auto &i : vec_local_cells_0)
1222 std::cout << i <<
" ";
1223 std::cout << std::endl;
1225 if (!vec_local_cells_2.empty())
1227 std::cout <<
" - some local cells are owned multiple times: ";
1228 for (
const auto &i : vec_local_cells_2)
1229 std::cout << i <<
" ";
1230 std::cout << std::endl;
1232 if (!vec_ghost_cells_0.empty())
1234 std::cout <<
" - some ghost cells are not owned: ";
1235 for (
const auto &i : vec_ghost_cells_0)
1236 std::cout << i <<
" ";
1237 std::cout << std::endl;
1239 if (!vec_ghost_cells_2.empty())
1241 std::cout <<
" - some ghost cells are owned multiple times: ";
1242 for (
const auto &i : vec_ghost_cells_2)
1243 std::cout << i <<
" ";
1244 std::cout << std::endl;
1249 AssertThrow(
false, ExcInternalError());
1260 const unsigned n_q_points =
1262 std::vector<Number> all_penalty_parameter_ghost(
1263 data.all_penalty_parameter.size());
1264 partitioner.export_to_ghosted_array<Number, 0>(
data.all_penalty_parameter,
1265 all_penalty_parameter_ghost,
1267 for (
unsigned int i = 0; i <
data.all_penalty_parameter.size(); ++i)
1268 data.all_penalty_parameter[i] =
1269 std::max(
data.all_penalty_parameter[i], all_penalty_parameter_ghost[i]);
1273 partitioner.export_to_ghosted_array<types::global_dof_index, 0>(
1277 auto locally_owned_dofs = constraints.get_locally_owned_indices();
1278 auto constraints_to_make_consistent = constraints.get_local_lines();
1281 for (
unsigned int i = 0; i <
dof_indices.size(); ++i)
1283 constraints_to_make_consistent.add_index(
dof_indices[i]);
1288 constraints_to_make_consistent);
1291 AffineConstraints<Number>::MergeConflictBehavior::no_conflicts_allowed,
1296 constraints_to_make_consistent,
1306template <
int dim,
typename Number>
1307const AffineConstraints<Number> &
1313template <
int dim,
typename Number>
1316 const Number factor)
1318 return factor * (degree + 1.0) * (degree + 1.0);
1321template <
int dim,
typename Number>
1324 const typename Triangulation<dim>::cell_iterator &cell)
const
1326 const unsigned int degree =
dof_handler.get_fe().degree;
1328 FE_Nothing<dim> fe_nothing;
1330 dealii::QGauss<dim> quadrature(degree + 1);
1331 dealii::FEValues<dim> fe_values(
mapping,
1334 dealii::update_JxW_values);
1336 dealii::QGauss<dim - 1> face_quadrature(degree + 1);
1337 dealii::FEFaceValues<dim> fe_face_values(
mapping,
1340 dealii::update_JxW_values);
1342 fe_values.reinit(cell);
1345 for (
unsigned int q = 0; q < quadrature.size(); ++q)
1346 volume += fe_values.JxW(q);
1348 Number surface_area = 0;
1349 for (
const auto f : cell->face_indices())
1351 fe_face_values.reinit(cell, f);
1353 const Number factor =
1354 (cell->at_boundary(f) && !cell->has_periodic_neighbor(f) &&
1355 (cell->face(f)->boundary_id() !=
bid_m &&
1356 cell->face(f)->boundary_id() !=
bid_p)) ?
1360 for (
unsigned int q = 0; q < face_quadrature.size(); ++q)
1361 surface_area += fe_face_values.JxW(q) * factor;
1364 return surface_area / volume;
1367template <
int dim,
typename Number>
1370 const typename Triangulation<dim>::cell_iterator &cell,
1371 const typename Triangulation<dim>::face_iterator &face)
const
1373 return mapping.transform_unit_to_real_cell(
1374 cell, MappingQ1<dim>().transform_real_to_unit_cell(cell, face->center()));
1377template <
int dim,
typename Number>
1378std::vector<types::global_dof_index>
1380 const typename DoFHandler<dim>::active_cell_iterator &cell)
const
1382 std::vector<types::global_dof_index> local_dofs_all(
1384 cell->get_dof_indices(local_dofs_all);
1394template <
int dim,
typename Number>
1395template <
typename VectorType>
1402 if constexpr (std::is_same_v<VectorType, TrilinosWrappers::MPI::Vector>)
1405 this->partitioner_extended->get_mpi_communicator());
1411 if constexpr (std::is_same_v<VectorType, TrilinosWrappers::MPI::Vector>)
1412 src_internal.reinit(this->partitioner_extended->locally_owned_range(),
1413 this->partitioner_extended->ghost_indices(),
1414 this->partitioner_extended->get_mpi_communicator());
1418 src_internal.update_ghost_values();
1421 unsigned int ptr_q = 0;
1423 Vector<Number> buffer;
1425 std::vector<Number> all_values_local(
data.all_normals.size() *
q_data_size);
1426 std::vector<Number> all_values_ghost(
data.all_normals.size() *
q_data_size);
1428 for (
const auto &cell :
dof_handler.active_cell_iterators())
1429 if (cell->is_locally_owned())
1430 for (
const auto &face : cell->face_iterators())
1431 if ((face->boundary_id() ==
bid_m) || (face->boundary_id() ==
bid_p))
1439 ArrayView<
const Point<dim, Number>>(
all_points_ref.data() + ptr_q,
1446 for (
unsigned int i = 0; i < local_dofs.size(); ++i)
1447 buffer[i] = src_internal[local_dofs[i]];
1453 all_values_local.data() +
1456 ptr_q += n_q_points;
1460 const unsigned n_q_points =
1463 ArrayView<const Number>(
reinterpret_cast<Number *
>(all_values_local.data()),
1464 all_values_local.size()),
1465 ArrayView<Number>(
reinterpret_cast<Number *
>(all_values_ghost.data()),
1466 all_values_ghost.size()),
1471 for (
const auto &cell :
dof_handler.active_cell_iterators())
1472 if (cell->is_locally_owned())
1473 for (
const auto &face : cell->face_iterators())
1474 if ((face->boundary_id() ==
bid_m) || (face->boundary_id() ==
bid_p))
1478 const unsigned int total_n_q_points =
1483 ArrayView<
const Point<dim, Number>>(
all_points_ref.data() + ptr_q,
1491 all_values_local.data() +
1493 all_values_ghost.data() +
1501 ptr_q += total_n_q_points;
1504 dst_internal.compress(VectorOperation::add);
1505 dst.add(1.0, dst_internal);
1508template <
int dim,
typename Number>
1509template <
typename VectorType>
1515 if constexpr (std::is_same_v<VectorType, TrilinosWrappers::MPI::Vector>)
1517 diagonal_internal.reinit(
1519 this->partitioner_extended->get_mpi_communicator());
1524 unsigned int ptr_q = 0;
1526 Vector<Number> buffer, diagonal_local;
1527 std::vector<Number> all_values_local, all_values_ghost;
1529 for (
const auto &cell :
dof_handler.active_cell_iterators())
1530 if (cell->is_locally_owned())
1531 for (
const auto &face : cell->face_iterators())
1532 if ((face->boundary_id() ==
bid_m) || (face->boundary_id() ==
bid_p))
1540 ArrayView<
const Point<dim, Number>>(
all_points_ref.data() + ptr_q,
1545 all_values_local.resize(n_q_points *
q_data_size);
1546 all_values_ghost.resize(n_q_points *
q_data_size);
1552 buffer[j] =
static_cast<Number
>(i == j);
1556 data, buffer, ptr_q, 1, all_values_local.data());
1566 all_values_local.data(),
1567 all_values_ghost.data());
1569 diagonal_local[i] = buffer[i];
1577 ptr_q += n_q_points;
1580 diagonal_internal.compress(VectorOperation::add);
1581 diagonal.add(1.0, diagonal_internal);
1584template <
int dim,
typename Number>
1587 SparsityPatternBase &dsp)
const
1591 std::vector<types::global_dof_index> a(
dof_indices.begin() + i,
1603template <
int dim,
typename Number>
1606 TrilinosWrappers::SparseMatrix &system_matrix)
const
1608 std::vector<Number> all_values_local(
data.all_normals.size() *
1610 std::vector<Number> all_values_ghost(
data.all_normals.size() *
1613 unsigned int ptr_q = 0;
1615 Vector<Number> buffer;
1618 for (
const auto &cell :
dof_handler.active_cell_iterators())
1619 if (cell->is_locally_owned())
1620 for (
const auto &face : cell->face_iterators())
1621 if ((face->boundary_id() ==
bid_m) || (face->boundary_id() ==
bid_p))
1631 ArrayView<
const Point<dim, Number>>(
all_points_ref.data() + ptr_q,
1641 buffer[j] =
static_cast<Number
>(i == j);
1648 all_values_local.data() +
1653 ptr_q += n_q_points;
1656 const unsigned n_q_points =
1661 ArrayView<const Number>(
reinterpret_cast<Number *
>(all_values_local.data()),
1662 all_values_local.size()),
1663 ArrayView<Number>(
reinterpret_cast<Number *
>(all_values_ghost.data()),
1664 all_values_ghost.size()),
1669 unsigned int ptr_dofs = 0;
1672 for (
const auto &cell :
dof_handler.active_cell_iterators())
1673 if (cell->is_locally_owned())
1674 for (
const auto &face : cell->face_iterators())
1675 if ((face->boundary_id() ==
bid_m) || (face->boundary_id() ==
bid_p))
1682 for (
unsigned int m = 0; m < n_mortars; ++m)
1685 ArrayView<
const Point<dim, Number>>(
1690 for (
unsigned int b = 0; b < 2; ++b)
1707 all_values_local.data() +
1717 all_values_ghost.data() +
1722 cell_matrix[j][i] = buffer[j];
1727 std::vector<types::global_dof_index> local_dof_indices(
1734 cell_matrix, local_dof_indices, system_matrix);
1738 std::vector<types::global_dof_index>
1747 local_dof_indices_ghost,
1754 ptr_q += n_q_points;
1758 AssertDimension(ptr_q,
data.all_normals.size());
1764template <
int dim,
int n_components,
typename Number>
1767 const DoFHandler<dim> &dof_handler,
1768 const unsigned int first_selected_component)
1769 :
fe_sub(dof_handler.get_fe().base_element(
1770 dof_handler.get_fe()
1771 .component_to_base_index(first_selected_component)
1774 ,
phi_m(mapping,
fe_sub, update_values | update_gradients)
1776 for (
unsigned int i = 0; i < dof_handler.get_fe().n_dofs_per_cell(); ++i)
1777 if ((first_selected_component <=
1778 dof_handler.get_fe().system_to_component_index(i).first) &&
1779 (dof_handler.get_fe().system_to_component_index(i).first <
1780 first_selected_component + n_components))
1784template <
int dim,
int n_components,
typename Number>
1788 return n_components * 2;
1791template <
int dim,
int n_components,
typename Number>
1792const std::vector<unsigned int> &
1799template <
int dim,
int n_components,
typename Number>
1802 const typename Triangulation<dim>::cell_iterator &cell,
1803 const ArrayView<
const Point<dim, Number>> &points)
const
1805 this->
phi_m.reinit(cell, points);
1808template <
int dim,
int n_components,
typename Number>
1812 const Vector<Number> &buffer,
1813 const unsigned int ptr_q,
1814 const unsigned int q_stride,
1815 Number *all_values_m)
const
1817 this->
phi_m.evaluate(buffer,
1818 EvaluationFlags::values | EvaluationFlags::gradients);
1820 for (
const auto q : this->
phi_m.quadrature_point_indices())
1824 const unsigned int q_index = ptr_q + q;
1828 const auto value_m = this->
phi_m.get_value(q);
1829 const auto gradient_m =
contract(this->
phi_m.get_gradient(q), normal);
1835 buffer_m.
write(value_m);
1836 buffer_m.
write(gradient_m);
1840template <
int dim,
int n_components,
typename Number>
1844 Vector<Number> &buffer,
1845 const unsigned int ptr_q,
1846 const unsigned int q_stride,
1847 Number *all_values_m,
1848 Number *all_values_p)
const
1850 for (
const auto q : this->
phi_m.quadrature_point_indices())
1852 const unsigned int q_index = ptr_q + q;
1858 const auto value_m = buffer_m.template read<value_type>();
1859 const auto value_p = buffer_p.template read<value_type>();
1860 const auto normal_gradient_m = buffer_m.template read<value_type>();
1861 const auto normal_gradient_p = buffer_p.template read<value_type>();
1871 const auto value_jump =
outer((value_m - value_p), normal);
1876 const auto gradient_normal_avg =
1877 (normal_gradient_m - normal_gradient_p) * 0.5;
1883 this->
phi_m.submit_gradient(-value_jump * 0.5 * JxW, q);
1886 this->
phi_m.submit_value(
1887 (
contract(value_jump, normal) * sigma - gradient_normal_avg) * JxW, q);
1890 this->
phi_m.test_and_sum(buffer,
1891 EvaluationFlags::values |
1892 EvaluationFlags::gradients);
1898template <
int dim,
typename Number>
1901 const DoFHandler<dim> &dof_handler,
1903 :
fe_sub_u(dof_handler.get_fe().base_element(
1904 dof_handler.get_fe().component_to_base_index(0).first),
1906 ,
fe_sub_p(dof_handler.get_fe().base_element(
1907 dof_handler.get_fe().component_to_base_index(dim).first),
1913 for (
unsigned int i = 0; i < dof_handler.get_fe().n_dofs_per_cell(); ++i)
1914 if (dof_handler.get_fe().system_to_component_index(i).first < dim)
1917 for (
unsigned int i = 0; i < dof_handler.get_fe().n_dofs_per_cell(); ++i)
1918 if (dof_handler.get_fe().system_to_component_index(i).first == dim)
1921 AssertDimension(dof_handler.get_fe().n_dofs_per_cell(),
1925template <
int dim,
typename Number>
1932template <
int dim,
typename Number>
1933const std::vector<unsigned int> &
1940template <
int dim,
typename Number>
1943 const typename Triangulation<dim>::cell_iterator &cell,
1944 const ArrayView<
const Point<dim, Number>> &points)
const
1946 this->
phi_u_m.reinit(cell, points);
1947 this->
phi_p_m.reinit(cell, points);
1950template <
int dim,
typename Number>
1954 const Vector<Number> &buffer,
1955 const unsigned int ptr_q,
1956 const unsigned int q_stride,
1957 Number *all_values_m)
const
1959 AssertDimension(buffer.size(),
1962 ArrayView<const Number> buffer_u(buffer.data() + 0,
1964 ArrayView<const Number> buffer_p(buffer.data() +
fe_sub_u.n_dofs_per_cell(),
1967 this->
phi_u_m.evaluate(buffer_u,
1968 EvaluationFlags::values | EvaluationFlags::gradients);
1969 this->
phi_p_m.evaluate(buffer_p, EvaluationFlags::values);
1971 for (
const auto q : this->
phi_u_m.quadrature_point_indices())
1975 const unsigned int q_index = ptr_q + q;
1980 const auto u_value = this->
phi_u_m.get_value(q);
1981 const auto u_grad_normal =
1983 const auto p_value_normal = this->
phi_p_m.get_value(q) * normal;
1990 buffer_m.
write(u_value);
1991 buffer_m.
write(u_grad_normal);
1992 buffer_m.
write(p_value_normal);
1996template <
int dim,
typename Number>
2000 Vector<Number> &buffer,
2001 const unsigned int ptr_q,
2002 const unsigned int q_stride,
2003 Number *all_values_m,
2004 Number *all_values_p)
const
2006 for (
const auto q : this->
phi_u_m.quadrature_point_indices())
2008 const unsigned int q_index = ptr_q + q;
2015 const auto u_value_m = buffer_m.template read<u_value_type>();
2016 const auto u_value_p = buffer_p.template read<u_value_type>();
2017 const auto u_grad_normal_m = buffer_m.template read<u_value_type>();
2018 const auto u_grad_normal_p = buffer_p.template read<u_value_type>();
2019 const auto p_value_normal_m = buffer_m.template read<u_value_type>();
2020 const auto p_value_normal_p = buffer_p.template read<u_value_type>();
2027 const auto u_value_jump = u_value_m - u_value_p;
2033 const auto u_grad_avg = (u_grad_normal_m - u_grad_normal_p) * 0.5;
2036 const auto p_value_avg = (p_value_normal_m - p_value_normal_p) * 0.5;
2038 typename FEPointIntegratorU::value_type u_grad_result = {};
2039 typename FEPointIntegratorU::value_type u_value_result = {};
2040 typename FEPointIntegratorP::value_type p_value_result = {};
2047 u_grad_result -= u_value_jump;
2051 u_value_result += sigma * this->kinematic_viscosity * u_value_jump;
2055 u_value_result += p_value_avg;
2059 p_value_result -= 0.5 *
contract(u_value_jump, normal);
2063 this->kinematic_viscosity * 0.5 * JxW,
2065 phi_u_m.submit_value(u_value_result * JxW, q);
2066 phi_p_m.submit_value(p_value_result * JxW, q);
2069 AssertDimension(buffer.size(),
2072 ArrayView<Number> buffer_u(buffer.data() + 0,
fe_sub_u.n_dofs_per_cell());
2073 ArrayView<Number> buffer_p(buffer.data() +
fe_sub_u.n_dofs_per_cell(),
2076 this->
phi_u_m.test_and_sum(buffer_u,
2077 EvaluationFlags::values |
2078 EvaluationFlags::gradients);
2079 this->
phi_p_m.test_and_sum(buffer_p, EvaluationFlags::values);
2102 LinearAlgebra::distributed::Vector<double> &,
2103 const LinearAlgebra::distributed::Vector<double> &)
const;
2106 LinearAlgebra::distributed::Vector<double> &,
2107 const LinearAlgebra::distributed::Vector<double> &)
const;
2110 LinearAlgebra::distributed::Vector<double> &,
2111 const LinearAlgebra::distributed::Vector<double> &)
const;
2115 TrilinosWrappers::MPI::Vector &,
2116 const TrilinosWrappers::MPI::Vector &)
const;
2119 TrilinosWrappers::MPI::Vector &,
2120 const TrilinosWrappers::MPI::Vector &)
const;
2123 TrilinosWrappers::MPI::Vector &,
2124 const TrilinosWrappers::MPI::Vector &)
const;
2128 LinearAlgebra::distributed::Vector<float> &,
2129 const LinearAlgebra::distributed::Vector<float> &)
const;
2133 LinearAlgebra::distributed::Vector<float> &,
2134 const LinearAlgebra::distributed::Vector<float> &)
const;
2138 LinearAlgebra::distributed::Vector<double> &)
const;
2141 LinearAlgebra::distributed::Vector<double> &)
const;
2144 LinearAlgebra::distributed::Vector<double> &)
const;
2148 LinearAlgebra::distributed::Vector<float> &)
const;
2151 LinearAlgebra::distributed::Vector<float> &)
const;
2165template std::vector<unsigned int>
2167 const Triangulation<2> &triangulation,
2170template std::vector<unsigned int>
2172 const Triangulation<3> &triangulation,
2175template std::tuple<std::vector<double>,
double>
2177 const Triangulation<2> &triangulation,
2178 const Mapping<2> &mapping,
2181template std::tuple<std::vector<double>,
double>
2183 const Triangulation<3> &triangulation,
2184 const Mapping<3> &mapping,
2187template std::pair<double, double>
2189 const Triangulation<2> &triangulation,
2190 const Mapping<2> &mapping,
2193template std::pair<double, double>
2195 const Triangulation<3> &triangulation,
2196 const Mapping<3> &mapping,
2199template Quadrature<2>
2203template Quadrature<3>
2207template std::vector<double>
2211template std::vector<double>
2218 const ConditionalOStream &pcout);
2223 const ConditionalOStream &pcout);
Create a temporary vector where mortar evaluation data is stored before being passed to the system ma...
Base class for coupling evaluation routines.
Base class for the Coupling Operator Base.
std::shared_ptr< CouplingEvaluationBase< dim, Number > > evaluator
CouplingEvaluationData< dim, Number > data
CouplingOperator(const Mapping< dim > &mapping, const DoFHandler< dim > &dof_handler, const AffineConstraints< Number > &constraints, const std::shared_ptr< CouplingEvaluationBase< dim, Number > > &evaluator, const std::shared_ptr< MortarManagerBase< dim > > &mortar_manager, const unsigned int bid_m, const unsigned int bid_p, const double sip_factor)
Mortar coupling operator constructor.
void add_diagonal_entries(VectorType &diagonal) const
Add mortar coupling terms in diagonal entries.
const DoFHandler< dim > & dof_handler
DoFHandler associated to the triangulation.
const AffineConstraints< Number > & get_affine_constraints() const
Return object containing problem constraints.
static Number compute_penalty_factor(const unsigned int degree, const Number factor)
Compute penalty factor used in weak imposition of coupling at the rotor-stator interface.
std::vector< types::global_dof_index > dof_indices
unsigned int q_data_size
Number of data points per quadrature point.
void vmult_add(VectorType &dst, const VectorType &src) const
Add matrix-vector multiplication.
std::shared_ptr< const Utilities::MPI::Partitioner > partitioner_extended
const Mapping< dim > & mapping
Mapping associated to the domain.
void add_system_matrix_entries(TrilinosWrappers::SparseMatrix &system_matrix) const
Add mortar coupling terms in the system matrix.
std::vector< types::global_dof_index > dof_indices_ghost
AffineConstraints< Number > constraints_extended
Constraints extended according to mortar entries.
Point< dim > get_face_center(const typename Triangulation< dim >::cell_iterator &cell, const typename Triangulation< dim >::face_iterator &face) const
Returns the point corresponding to the cell center.
void add_sparsity_pattern_entries(SparsityPatternBase &dsp) const
Add mortar coupling terms in the sparsity pattern.
std::shared_ptr< MortarManagerBase< dim > > mortar_manager
std::vector< types::global_dof_index > get_dof_indices(const typename DoFHandler< dim >::active_cell_iterator &cell) const
Returns dof indices.
Utilities::MPI::NoncontiguousPartitioner partitioner
Number compute_penalty_parameter(const typename Triangulation< dim >::cell_iterator &cell) const
Compute penalty parameter in a cell.
std::vector< Point< dim, Number > > all_points_ref
std::vector< unsigned int > relevant_dof_indices
List of relevant DoF indices per cell.
unsigned int n_dofs_per_cell
Number of DoFs per cell.
Base class for the mortar manager.
const unsigned int n_quadrature_points
Number of quadrature points per cell.
virtual double to_1D(const Point< dim > &point) const =0
Convert quadrature point in real space to angle (in radians).
unsigned int get_n_mortars() const
Returns the number of mortar cells connecting rotor-stator regular cells at the interface 1 = rotor-s...
std::vector< Point< std::max(1, dim - 1)> > get_points_ref(const Point< dim > &face_center, const bool is_inner) const
Returns the coordinates of the quadrature points at both sides of the interface in the reference spac...
bool is_mesh_aligned() const
Verify if cells of the inner and outer domains are aligned.
const unsigned int rotation_axis_direction
Direction of the rotation axis (x=0, y=1, z=2).
virtual Tensor< 1, dim, double > get_normal(const Point< dim > &point) const =0
Return the normal for a given quadrature point.
const double rotation_angle
Rotation angle for the inner domain.
const std::vector< double > stage_heights
std::vector< unsigned int > n_subdivisions
Number of cells at the interface between inner and outer domains.
unsigned int get_n_points() const
Returns the number of quadrature points at the mortar cells connected to a given cell.
std::vector< double > get_weights(const Point< dim > &face_center, const bool is_inner) const
Returns the weights of the quadrature points at both sides of the interface.
std::tuple< unsigned int, unsigned int, unsigned int > get_config(const Point< dim > &face_center, const bool is_inner) const
Returns the mesh alignment type and cell index.
Quadrature< std::max(1, dim - 1)> quadrature
Mortar quadrature.
std::vector< double > interface_dimensions
std::vector< Point< dim > > get_points(const Point< dim > &face_center, const bool is_inner) const
Returns the coordinates of the quadrature points at both sides of the interface in the real space.
std::vector< Tensor< 1, dim, double > > get_normals(const Point< dim > &face_center, const bool is_inner) const
Returns the normal vector for the quadrature points.
std::vector< unsigned int > get_mortar_indices(const Point< dim > &face_center, const bool is_inner) const
Returns the indices of all mortars at both sides of the interface.
virtual Point< dim > from_1D(const double angle_rad) const =0
Convert angle (in radians) to quadrature point in real space.
unsigned int get_n_total_points() const
Returns the total number of quadrature points at all mortar cells.
unsigned int get_n_total_mortars() const
Returns the total number of mortars.
Mortar manager class for circular interface.
Point< dim > from_1D(const double angle_rad) const override
Convert angle (in radians) to quadrature point in real space.
const Point< dim > center_of_rotation
Center of rotation of the inner domain.
double to_1D(const Point< dim > &point) const override
Convert quadrature point in real space to angle (in radians).
const double pre_rotation_angle
Tensor< 1, dim, double > get_normal(const Point< dim > &point) const override
Return the normal for a given quadrature point.
Mortar manager class for linear interface.
double to_1D(const Point< dim > &point) const override
Convert quadrature point in real space to angle (in radians).
double coord_min
Minimum y coordinate of interface nodes.
Tensor< 1, dim, double > get_normal(const Point< dim > &) const override
Return the normal for a given quadrature point.
Point< dim > from_1D(const double angle_rad) const override
Convert angle (in radians) to quadrature point in real space.
double coord_max
Maximum y coordinate of interface nodes.
void local_reinit(const typename Triangulation< dim >::cell_iterator &cell, const ArrayView< const Point< dim, Number > > &points) const override
Set up mapping information.
const FESystem< dim > fe_sub_u
NavierStokesCouplingEvaluationSIPG(const Mapping< dim > &mapping, const DoFHandler< dim > &dof_handler, const double kinematic_viscosity)
Class constructor.
const std::vector< unsigned int > & get_relevant_dof_indices() const override
Return relevant dof indices.
const FESystem< dim > fe_sub_p
void local_integrate(const CouplingEvaluationData< dim, Number > &data, Vector< Number > &buffer, const unsigned int ptr_q, const unsigned int q_stride, Number *all_values_m, Number *all_values_p) const override
Perform integral of mortar elements at the rotor-stator interface.
FEPointIntegratorU phi_u_m
Interface to the evaluation of mortar coupling interpolated solution.
unsigned int data_size() const override
FEPointIntegratorP phi_p_m
void local_evaluate(const CouplingEvaluationData< dim, Number > &data, const Vector< Number > &buffer, const unsigned int ptr_q, const unsigned int q_stride, Number *all_values_local) const override
Evaluate values and gradients at the coupling entries.
const double kinematic_viscosity
Kinematic viscosity.
std::vector< unsigned int > relevant_dof_indices
Relevant dof indices.
void local_integrate(const CouplingEvaluationData< dim, Number > &data, Vector< Number > &buffer, const unsigned int ptr_q, const unsigned int q_stride, Number *all_value_m, Number *all_value_p) const override
Perform integral of mortar elements at the rotor-stator interface.
std::vector< unsigned int > relevant_dof_indices
Relevant dof indices.
const std::vector< unsigned int > & get_relevant_dof_indices() const override
Return relevant dof indices.
void local_reinit(const typename Triangulation< dim >::cell_iterator &cell, const ArrayView< const Point< dim, Number > > &points) const override
Set up mapping information.
unsigned int data_size() const override
ScalarCouplingEvaluationSIPG(const Mapping< dim > &mapping, const DoFHandler< dim > &dof_handler, const unsigned int first_selected_component=0)
const FESystem< dim > fe_sub
FEPointIntegrator phi_m
Interface to the evaluation of mortar coupling interpolated solution.
void local_evaluate(const CouplingEvaluationData< dim, Number > &data, const Vector< Number > &buffer, const unsigned int ptr_q, const unsigned int q_stride, Number *all_value_m) const override
Evaluate values and gradients at the coupling entries.
double point_to_angle(const Point< dim > &point, const Point< dim > ¢er_of_rotation=Point< dim >(), const unsigned int rotation_axis_direction=2)
Converts point to angle (in radians) based on rotation axis.
Point< dim > radius_to_point(const double radius, const double angle_rad, const Point< dim > ¢er_of_rotation=Point< dim >(), const unsigned int rotation_axis_direction=2)
Converts radius to point in cartesian coordinates based on rotation axis.
template std::tuple< std::vector< double >, double > compute_interface_dimensions_circular< 3 >(const Triangulation< 3 > &triangulation, const Mapping< 3 > &mapping, const Parameters::Mortar< 3 > &mortar_parameters)
template std::pair< double, double > compute_interface_dimensions_linear< 2 >(const Triangulation< 2 > &triangulation, const Mapping< 2 > &mapping, const Parameters::Mortar< 2 > &mortar_parameters)
std::vector< unsigned int > compute_number_interface_cells(const Triangulation< dim > &triangulation, const Parameters::Mortar< dim > &mortar_parameters)
Compute the number of cells located at the mortar interface.
DeclException1(InterfaceRadiusTolerance, double,<< "The computed radius of the rotor mesh has a variation of "<< arg1<< " along the interface boundary, which exceeds the prescribed tolerance.")
template std::pair< double, double > compute_interface_dimensions_linear< 3 >(const Triangulation< 3 > &triangulation, const Mapping< 3 > &mapping, const Parameters::Mortar< 3 > &mortar_parameters)
template std::vector< double > compute_stage_heights< 3 >(const Triangulation< 3 > &triangulation, const Parameters::Mortar< 3 > &mortar_parameters)
template std::vector< unsigned int > compute_number_interface_cells< 2 >(const Triangulation< 2 > &triangulation, const Parameters::Mortar< 2 > &mortar_parameters)
std::pair< double, double > compute_interface_dimensions_linear(const Triangulation< dim > &triangulation, const Mapping< dim > &mapping, const Parameters::Mortar< dim > &mortar_parameters)
Compute linear mortar interface dimensions.
std::vector< double > compute_stage_heights(const Triangulation< dim > &triangulation, const Parameters::Mortar< dim > &mortar_parameters)
Compute the stage heights in the direction of the rotation axis at the mortar interface....
template std::vector< double > compute_stage_heights< 2 >(const Triangulation< 2 > &triangulation, const Parameters::Mortar< 2 > &mortar_parameters)
template std::vector< unsigned int > compute_number_interface_cells< 3 >(const Triangulation< 3 > &triangulation, const Parameters::Mortar< 3 > &mortar_parameters)
void mortar_workload_imbalance(const Triangulation< dim > &triangulation, const Parameters::Mortar< dim > &mortar_parameters, const ConditionalOStream &pcout)
Compute workload imbalance of mortar cells.
std::tuple< std::vector< double >, double > compute_interface_dimensions_circular(const Triangulation< dim > &triangulation, const Mapping< dim > &mapping, const Parameters::Mortar< dim > &mortar_parameters)
Compute circular mortar interface dimensions and the rotor mesh pre-rotation angle.
Quadrature< dim > construct_quadrature(const Quadrature< dim > &quadrature, const Parameters::Mortar< dim > &mortar_parameters)
Construct oversampled quadrature.
template std::tuple< std::vector< double >, double > compute_interface_dimensions_circular< 2 >(const Triangulation< 2 > &triangulation, const Mapping< 2 > &mapping, const Parameters::Mortar< 2 > &mortar_parameters)
Tensor< 1, dim, Number > outer(const Number &value, const Tensor< 1, dim, Number > &normal)
Compute outer product.
Number contract(const Tensor< 1, dim, Number > &grad, const Tensor< 1, dim, Number > &normal)
Compute inner product.
std::vector< Tensor< 1, dim, Number > > all_normals
Number penalty_factor
Penalty factor (akin to penalty factor in SIPG).
std::vector< Number > all_weights
Weights of quadrature points.
std::vector< Number > all_penalty_parameter
Penalty parameter in symmetric interior penalty Galerkin (SIPG) method.
Mortar - Defines parameters used to construct mortar elements.
Point< dim > center_of_rotation
Center of rotation of the rotor domain.
unsigned int stator_boundary_id
Boundary ID # of the stator at the rotor-stator interface.
unsigned int rotor_boundary_id
Boundary ID # of the rotor at the rotor-stator interface.
unsigned int rotation_axis_direction
Rotation axis direction.
unsigned int oversampling_factor
Oversampling factor for quadrature points.
double radius_tolerance
Tolerance used for rotor-stator interface radius computation.
GlobalVectorType VectorType