7#include <deal.II/base/bounding_box.h>
8#include <deal.II/base/point.h>
9#include <deal.II/base/quadrature_lib.h>
11#include <deal.II/distributed/fully_distributed_tria.h>
13#include <deal.II/dofs/dof_tools.h>
15#include <deal.II/fe/fe_simplex_p.h>
16#include <deal.II/fe/fe_system.h>
17#include <deal.II/fe/fe_values.h>
18#include <deal.II/fe/mapping.h>
20#include <deal.II/grid/filtered_iterator.h>
21#include <deal.II/grid/grid_generator.h>
22#include <deal.II/grid/grid_in.h>
23#include <deal.II/grid/grid_tools.h>
25#include <deal.II/numerics/solution_transfer.h>
26#include <deal.II/numerics/vector_tools.h>
28#include <deal.II/particles/data_out.h>
30#include <boost/archive/text_iarchive.hpp>
31#include <boost/archive/text_oarchive.hpp>
37template <
int dim,
int spacedim>
40 const std::shared_ptr<parallel::DistributedTriangulationBase<spacedim>>
52 if (
param->solid_mesh.simplex)
55 fe = std::make_shared<FE_SimplexP<dim, spacedim>>(1);
56 solid_mapping = std::make_shared<MappingFE<dim, spacedim>>(*fe);
58 std::make_shared<QGaussSimplex<dim>>(param->number_quadrature_points);
59 solid_tria = std::make_shared<
60 parallel::fullydistributed::Triangulation<dim, spacedim>>(
61 this->mpi_communicator);
64 std::make_shared<FESystem<dim, spacedim>>(FE_SimplexP<dim, spacedim>(1),
70 fe = std::make_shared<FE_Q<dim, spacedim>>(1);
71 solid_mapping = std::make_shared<MappingQGeneric<dim, spacedim>>(1);
73 std::make_shared<QGauss<dim>>(param->number_quadrature_points);
75 std::make_shared<parallel::distributed::Triangulation<dim, spacedim>>(
77 typename Triangulation<dim, spacedim>::MeshSmoothing(
78 Triangulation<dim, spacedim>::smoothing_on_refinement |
79 Triangulation<dim, spacedim>::smoothing_on_coarsening));
82 std::make_shared<FESystem<dim, spacedim>>(FE_Q<dim, spacedim>(1),
95template <
int dim,
int spacedim>
108template <
int dim,
int spacedim>
120 "gmsh mesh file of the solid object, given by "
121 "'subsection mesh' - 'set file name'");
123 if (
param->solid_mesh.simplex)
125 auto comm =
solid_tria->get_mpi_communicator();
126 std::string file_name =
param->solid_mesh.file_name;
128 auto construction_data = TriangulationDescription::Utilities::
129 create_description_from_triangulation_in_groups<dim, spacedim>(
130 [file_name](dealii::Triangulation<dim, spacedim> &basetria) {
131 GridIn<dim, spacedim> grid_in;
132 grid_in.attach_triangulation(basetria);
133 std::ifstream input_file(file_name);
135 grid_in.read_msh(input_file);
137 [](dealii::Triangulation<dim, spacedim> &basetria,
139 const unsigned int ) {
140 GridTools::partition_triangulation(
141 Utilities::MPI::n_mpi_processes(comm), basetria);
144 Utilities::MPI::n_mpi_processes(comm) ,
145 dealii::Triangulation<dim, spacedim>::none);
147 solid_tria->create_triangulation(construction_data);
151 GridIn<dim, spacedim> grid_in;
155 std::ifstream input_file(
param->solid_mesh.file_name);
156 grid_in.read_msh(input_file);
161 if (
param->solid_mesh.simplex)
165 Triangulation<dim, spacedim> temporary_quad_triangulation;
166 GridGenerator::generate_from_name_and_arguments(
167 temporary_quad_triangulation,
168 param->solid_mesh.grid_type,
169 param->solid_mesh.grid_arguments);
172 const int initial_refinement =
param->solid_mesh.initial_refinement;
173 temporary_quad_triangulation.refine_global(initial_refinement);
175 Triangulation<dim, spacedim> flat_temp_quad_triangulation;
176 GridGenerator::flatten_triangulation(temporary_quad_triangulation,
177 flat_temp_quad_triangulation);
179 Triangulation<dim, spacedim> temporary_tri_triangulation(
180 Triangulation<dim, spacedim>::limit_level_difference_at_vertices);
181 GridGenerator::convert_hypercube_to_simplex_mesh(
182 flat_temp_quad_triangulation, temporary_tri_triangulation);
184 GridTools::partition_triangulation_zorder(
185 Utilities::MPI::n_mpi_processes(
solid_tria->get_mpi_communicator()),
186 temporary_tri_triangulation);
187 GridTools::partition_multigrid_levels(temporary_tri_triangulation);
190 auto construction_data = TriangulationDescription::Utilities::
191 create_description_from_triangulation(
192 temporary_tri_triangulation,
194 TriangulationDescription::Settings::
195 construct_multigrid_hierarchy);
196 solid_tria->create_triangulation(construction_data);
200 GridGenerator::generate_from_name_and_arguments(
202 param->solid_mesh.grid_type,
203 param->solid_mesh.grid_arguments);
207 throw std::runtime_error(
208 "Unsupported mesh type - solid mesh will not be created");
212 param->solid_mesh.rotation_axis);
221 if (
param->solid_mesh.simplex)
233template <
int dim,
int spacedim>
237 [[maybe_unused]]
const Tensor<1, spacedim> &axis)
239 if constexpr (spacedim == 2)
245template <
int dim,
int spacedim>
252template <
int dim,
int spacedim>
266 ExcMessage(
"Cannot open snapshot mesh file or read the "
267 "solid triangulation stored there."));
274template <
int dim,
int spacedim>
278 unsigned int n_properties = (dim == 2 && spacedim == 3) ? 1 + spacedim : 1;
281 std::make_shared<Particles::ParticleHandler<spacedim>>();
287template <
int dim,
int spacedim>
294 std::vector<Point<spacedim>> quadrature_points_vec;
295 quadrature_points_vec.reserve(
quadrature->size() *
297 unsigned int n_properties = (dim == 2 && spacedim == 3) ? 1 + spacedim : 1;
299 std::vector<std::vector<double>> properties;
301 solid_tria->n_locally_owned_active_cells() * n_properties);
303 UpdateFlags update_flags = update_JxW_values | update_quadrature_points;
304 if (dim == 2 && spacedim == 3)
305 update_flags = update_flags | update_normal_vectors;
311 for (
const auto &cell :
solid_dh.active_cell_iterators())
312 if (cell->is_locally_owned())
315 const auto &points = fe_v.get_quadrature_points();
316 const auto &JxW = fe_v.get_JxW_values();
317 if (dim == 2 && spacedim == 3)
319 const auto &normal_vectors = fe_v.get_normal_vectors();
320 for (
unsigned int q = 0; q < points.size(); ++q)
322 quadrature_points_vec.emplace_back(points[q]);
323 std::vector<double> prop_i = {JxW[q],
324 normal_vectors[q][0],
325 normal_vectors[q][1]};
327 prop_i.push_back(normal_vectors[q][2]);
328 properties.emplace_back(prop_i);
333 for (
unsigned int q = 0; q < points.size(); ++q)
335 quadrature_points_vec.emplace_back(points[q]);
336 std::vector<double> prop_i = {JxW[q]};
337 properties.emplace_back(prop_i);
343 std::vector<std::vector<BoundingBox<spacedim>>> global_fluid_bounding_boxes;
346 std::vector<BoundingBox<spacedim>> all_boxes;
347 all_boxes.reserve(
fluid_tria->n_locally_owned_active_cells());
348 for (
const auto &cell :
fluid_tria->active_cell_iterators())
349 if (cell->is_locally_owned())
350 all_boxes.emplace_back(cell->bounding_box());
351 const auto tree = pack_rtree(all_boxes);
352 const auto local_boxes = extract_rtree_level(
353 tree, std::max(
int(log10(
fluid_tria->n_locally_owned_active_cells())), 1));
355 global_fluid_bounding_boxes =
360 global_fluid_bounding_boxes,
367template <
int dim,
int spacedim>
376 "checkpoint file of the solid particles, given by "
377 "'subsection restart' - 'set filename'");
378 std::ifstream input(filename_part.c_str());
381 std::getline(input, buffer);
382 std::istringstream iss(buffer);
383 boost::archive::text_iarchive ia(iss, boost::archive::no_header);
390template <
int dim,
int spacedim>
391DoFHandler<dim, spacedim> &
397template <
int dim,
int spacedim>
398DoFHandler<dim, spacedim> &
405template <
int dim,
int spacedim>
413template <
int dim,
int spacedim>
414std::shared_ptr<Particles::ParticleHandler<spacedim>> &
420template <
int dim,
int spacedim>
421std::shared_ptr<parallel::DistributedTriangulationBase<dim, spacedim>>
427template <
int dim,
int spacedim>
433template <
int dim,
int spacedim>
440template <
int dim,
int spacedim>
447template <
int dim,
int spacedim>
452 const unsigned int sub_particles_iterations =
param->particles_sub_iterations;
453 AssertThrow(sub_particles_iterations >= 1,
454 ExcMessage(
"Sub particles iterations must be 1 or larger"));
458 double sub_iteration_relaxation = 1. / sub_particles_iterations;
459 time_step = time_step * sub_iteration_relaxation;
466 for (
unsigned int it = 0; it < sub_particles_iterations; ++it)
485 Point<spacedim> particle_location = particle->get_location();
487 Tensor<1, spacedim> k1;
489 for (
int comp_i = 0; comp_i < spacedim; ++comp_i)
490 k1[comp_i] =
velocity->value(particle_location, comp_i);
492 Point<spacedim> p1 = particle_location + time_step / 2 * k1;
493 Tensor<1, spacedim> k2;
494 velocity->set_time(initial_time + time_step / 2);
495 for (
int comp_i = 0; comp_i < spacedim; ++comp_i)
496 k2[comp_i] =
velocity->value(p1, comp_i);
498 Point<spacedim> p2 = particle_location + time_step / 2 * k2;
499 Tensor<1, spacedim> k3;
500 for (
int comp_i = 0; comp_i < spacedim; ++comp_i)
501 k3[comp_i] =
velocity->value(p2, comp_i);
503 Point<spacedim> p3 = particle_location + time_step * k3;
504 Tensor<1, spacedim> k4;
505 velocity->set_time(initial_time + time_step);
506 for (
int comp_i = 0; comp_i < spacedim; ++comp_i)
507 k4[comp_i] =
velocity->value(p3, comp_i);
509 particle_location += time_step / 6 * (k1 + 2 * k2 + 2 * k3 + k4);
510 particle->set_location(particle_location);
513 initial_time += time_step;
521 std::cout <<
"Warning - Nitsche Particles have been lost"
523 std::cout <<
"Initial number of particles : "
525 std::cout <<
"Current number of particles : "
528 std::cout <<
"Try increasing the number of particles sub iterations"
534 if (
param->stop_particles_lost)
539 <<
"----------------------------------------------------"
542 <<
"Exception on processing: " << std::endl
543 <<
"Nitsche Particles have been lost" << std::endl
544 <<
"Aborting!" << std::endl
545 <<
"----------------------------------------------------"
553template <
int dim,
int spacedim>
556 const double initial_time)
562 const std::vector<bool> locally_owned_vertices =
563 GridTools::get_locally_owned_vertices(*this->
solid_tria);
564 std::vector<bool> vertex_moved(this->
solid_tria->n_vertices(),
false);
565 std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
570 if (cell->is_locally_owned())
572 for (
unsigned int vertex = 0;
573 vertex < cell->reference_cell().n_vertices();
589 const auto dof_index = cell->vertex_dof_index(vertex, 0);
590 Point<spacedim> &vertex_position = cell->vertex(vertex);
591 const unsigned global_vertex_no = cell->vertex_index(vertex);
592 if (vertex_moved[global_vertex_no] ||
593 !locally_owned_vertices[global_vertex_no])
596 Tensor<1, spacedim> k1;
598 for (
int comp_i = 0; comp_i < spacedim; ++comp_i)
599 k1[comp_i] =
velocity->value(vertex_position, comp_i);
601 Point<spacedim> p1 = vertex_position + time_step / 2 * k1;
602 Tensor<1, spacedim> k2;
603 velocity->set_time(initial_time + time_step / 2);
604 for (
int comp_i = 0; comp_i < spacedim; ++comp_i)
605 k2[comp_i] =
velocity->value(p1, comp_i);
607 Point<spacedim> p2 = vertex_position + time_step / 2 * k2;
608 Tensor<1, spacedim> k3;
609 for (
int comp_i = 0; comp_i < spacedim; ++comp_i)
610 k3[comp_i] =
velocity->value(p2, comp_i);
612 Point<spacedim> p3 = vertex_position + time_step * k3;
613 Tensor<1, spacedim> k4;
614 velocity->set_time(initial_time + time_step);
615 for (
int comp_i = 0; comp_i < spacedim; ++comp_i)
616 k4[comp_i] =
velocity->value(p3, comp_i);
618 auto vertex_displacement =
619 time_step / 6 * (k1 + 2 * k2 + 2 * k3 + k4);
621 vertex_position += vertex_displacement;
623 for (
int d = 0; d < spacedim; ++d)
627 vertex_moved[global_vertex_no] =
true;
631 this->
solid_tria->communicate_locally_moved_vertices(locally_owned_vertices);
635template <
int dim,
int spacedim>
640 std::set<unsigned int> dof_vertex_displaced;
641 std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
645 if (cell->is_locally_owned())
647 for (
unsigned int vertex = 0;
648 vertex < cell->reference_cell().n_vertices();
651 if (!dof_vertex_displaced.contains(cell->vertex_index(vertex)))
653 const auto dof_index = cell->vertex_dof_index(vertex, 0);
654 Point<spacedim> &vertex_position = cell->vertex(vertex);
656 for (
int d = 0; d < spacedim; ++d)
658 vertex_position[d] = vertex_position[d] +
662 dof_vertex_displaced.insert(cell->vertex_index(vertex));
669template <
int dim,
int spacedim>
673 std::map<int, Particles::ParticleIterator<spacedim>> local_particles;
678 local_particles.insert({particle->get_id(), particle});
681 for (
auto &iterator : local_particles)
683 unsigned int id = iterator.first;
684 auto particle = iterator.second;
685 auto particle_location = particle->get_location();
687 std::cout << std::fixed << std::setprecision(0) <<
id <<
" "
688 << std::setprecision(2) << particle_location << std::endl;
693template <
int dim,
int spacedim>
702 std::string prefix_particles = prefix +
"_particles";
703 std::ostringstream oss;
704 boost::archive::text_oarchive oa(oss, boost::archive::no_header);
708 std::string particle_filename = prefix +
".particles";
709 std::ofstream output(particle_filename.c_str());
710 output << oss.str() << std::endl;
717 SolutionTransfer<dim, GlobalVectorType, spacedim> system_trans_vectors(
720 std::vector<const GlobalVectorType *> sol_set_transfer;
724 system_trans_vectors.prepare_for_serialization(sol_set_transfer);
726 std::string triangulationName = prefix +
".triangulation";
727 this->
solid_tria.get()->save(prefix +
".triangulation");
730template <
int dim,
int spacedim>
738 if (!
param->solid_mesh.simplex)
742 const std::string filename = prefix +
".triangulation";
750 ExcMessage(
"Cannot open snapshot mesh file or read the "
751 "triangulation stored there."));
759 std::vector<GlobalVectorType *> x_system(1);
762 SolutionTransfer<dim, GlobalVectorType, spacedim> system_trans_vectors(
765 system_trans_vectors.deserialize(x_system);
771 if (!
param->solid_mesh.simplex)
775 std::string particle_filename = prefix +
".particles";
777 "checkpoint file of the solid particles, given by "
778 "'subsection restart' - 'set filename'");
779 std::ifstream input(particle_filename.c_str());
782 std::getline(input, buffer);
783 std::istringstream iss(buffer);
784 boost::archive::text_iarchive ia(iss, boost::archive::no_header);
801template <
int dim,
int spacedim>
Parameters for a single solid object used with the Nitsche immersed boundary method.
std::shared_ptr< Particles::ParticleHandler< spacedim > > & get_solid_particle_handler()
DoFHandler< dim, spacedim > solid_dh
DoFHandler< dim, spacedim > & get_solid_dof_handler()
std::shared_ptr< parallel::DistributedTriangulationBase< dim, spacedim > > solid_tria
void load_particles(const std::string &filename_part)
Loads a particle handler in the fluid triangulation domain that holds the particles of the solid acco...
DoFHandler< dim, spacedim > & get_displacement_dof_handler()
void move_solid_triangulation(double time_step, double initial_time)
Moves the vertices of the solid triangulation. This function uses an Runge-Kutta 4 explicit time inte...
void translate_grid(const Tensor< 1, spacedim > &translate)
Translate the grid. In spacedim=2, the third component is ignore.
const unsigned int this_mpi_process
void update_temperature_time(double time)
Updates the time in the function used to describe the solid temperature.
void load_triangulation(const std::string &filename_tria)
Loads a solid triangulation from a restart file.
std::shared_ptr< Quadrature< dim > > quadrature
void setup_triangulation(const bool restart)
Generates a solid triangulation from a dealii or gmsh mesh.
const unsigned int n_mpi_processes
GlobalVectorType displacement
GlobalVectorType & get_displacement_vector()
std::shared_ptr< Mapping< spacedim > > fluid_mapping
Function< spacedim > * temperature
void initial_setup()
Manages solid triangulation and particles setup.
std::shared_ptr< Particles::ParticleHandler< spacedim > > solid_particle_handler
std::shared_ptr< Parameters::NitscheObject< spacedim > > & param
void move_solid_triangulation_with_displacement()
Moves the dofs of the solid_triangulation by using the displacement vector. This is only use to move ...
DoFHandler< dim, spacedim > displacement_dh
std::shared_ptr< parallel::DistributedTriangulationBase< spacedim > > fluid_tria
SolidBase(std::shared_ptr< Parameters::NitscheObject< spacedim > > ¶m, const std::shared_ptr< parallel::DistributedTriangulationBase< spacedim > > &fluid_tria, const std::shared_ptr< Mapping< spacedim > > &fluid_mapping)
GlobalVectorType displacement_relevant
IndexSet locally_owned_dofs
std::shared_ptr< parallel::DistributedTriangulationBase< dim, spacedim > > get_solid_triangulation()
Function< spacedim > * get_solid_velocity()
void read_checkpoint(const std::string &prefix_name)
read solid base triangulation checkpoint
void setup_displacement()
Sets-up particles with particle handler, in the fluid triangulation domain that holds the particles o...
std::shared_ptr< FiniteElement< dim, spacedim > > fe
MPI_Comm mpi_communicator
std::shared_ptr< Mapping< dim, spacedim > > solid_mapping
Function< spacedim > * get_solid_temperature()
IndexSet locally_relevant_dofs
std::shared_ptr< FESystem< dim, spacedim > > displacement_fe
void setup_particles()
Sets-up particles with particle handler, in the fluid triangulation domain that holds the particles o...
Function< spacedim > * velocity
void write_checkpoint(const std::string &prefix_name)
write solid base triangulation checkpoint
void setup_particles_handler()
Creates a particle handler in the fluid triangulation domain.
unsigned int initial_number_of_particles
void integrate_velocity(double time_step, double initial_time)
Updates particle positions in solid_particle_handler by integrating velocity using an explicit Runge-...
void print_particle_positions()
prints the positions of the particles
void rotate_grid(const double angle, const Tensor< 1, spacedim > &axis)
Rotates the grid by a given angle around an axis.
void check_file_exists(const std::string &file_name, const std::string &file_description)
Verify that a file that Lethe must read exists and can be opened, and raise an error stated in the us...
dealii::TrilinosWrappers::MPI::Vector GlobalVectorType