13#include <deal.II/base/multithread_info.h>
15#include <deal.II/numerics/fe_field_function.h>
17#include <deal.II/particles/data_out.h>
19#include <boost/archive/text_iarchive.hpp>
20#include <boost/archive/text_oarchive.hpp>
23template <
int dim,
int spacedim>
28 const unsigned int n_solids =
33 std::make_shared<std::vector<std::shared_ptr<SolidBase<dim, spacedim>>>>();
39 for (
unsigned int i_solid = 0; i_solid < n_solids; ++i_solid)
55template <
int dim,
int spacedim>
56template <
bool assemble_matrix>
60 TimerOutput::Scope t(this->
computing_timer,
"Nitsche assemble restriction");
64 RequiresConstantViscosity(
"assemble_nitsche_restriction"));
67 const double kinematic_viscosity =
69 .get_kinematic_viscosity_scale();
72 std::vector<double> time_steps_vector =
74 const double dt = time_steps_vector[0];
75 const double sdt = 1. / dt;
77 for (
unsigned int i_solid = 0; i_solid <
solids->size(); ++i_solid)
79 std::shared_ptr<Particles::ParticleHandler<spacedim>> &solid_ph =
80 (*solids)[i_solid]->get_solid_particle_handler();
83 const unsigned int dofs_per_cell = this->
fe->dofs_per_cell;
85 std::vector<types::global_dof_index> fluid_dof_indices(dofs_per_cell);
87 FullMatrix<double> local_matrix(dofs_per_cell, dofs_per_cell);
88 dealii::Vector<double> local_rhs(dofs_per_cell);
91 Function<spacedim> *solid_velocity =
92 (*solids)[i_solid]->get_solid_velocity();
101 auto particle = solid_ph->begin();
102 while (particle != solid_ph->end())
107 const auto &cell = particle->get_surrounding_cell();
109 this->velocity_fem_degree);
110 const double penalty_parameter =
111 1. / std::pow(h_cell * h_cell,
double(dim) /
double(spacedim));
112 const auto &dh_cell =
113 typename DoFHandler<spacedim>::cell_iterator(*cell,
115 dh_cell->get_dof_indices(fluid_dof_indices);
117 const auto pic = solid_ph->particles_in_cell(cell);
118 Assert(pic.begin() == particle, ExcInternalError());
119 for (
const auto &p : pic)
121 const ArrayView<const double> properties = p.get_properties();
124 const auto &ref_q = p.get_reference_location();
125 const auto &real_q = p.get_location();
126 const auto &JxW = properties[0];
128 for (
unsigned int k = 0; k < dofs_per_cell; ++k)
131 this->
fe->system_to_component_index(k).first;
132 if (comp_k < spacedim)
139 this->
fe->shape_value(k, ref_q);
143 const double u_mag =
velocity.norm();
149 1. / std::sqrt(std::pow(2. * u_mag / h_cell, 2) +
150 9 * std::pow(4 * kinematic_viscosity /
155 std::pow(sdt, 2) + std::pow(2. * u_mag / h_cell, 2) +
156 9 * std::pow(4 * kinematic_viscosity / (h_cell * h_cell),
159 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
162 this->
fe->system_to_component_index(i).first;
163 if (comp_i < spacedim)
167 for (
unsigned int j = 0; j < dofs_per_cell; ++j)
170 this->
fe->system_to_component_index(j).first;
171 if (comp_i == comp_j)
173 local_matrix(i, j) +=
174 penalty_parameter * beta *
175 this->
fe->shape_value(i, ref_q) *
176 this->
fe->shape_value(j, ref_q) * JxW;
181 local_matrix(i, j) +=
182 penalty_parameter * beta *
183 this->
fe->shape_value(j, ref_q) *
184 (this->
fe->shape_grad(i, ref_q) *
191 local_rhs(i) += -penalty_parameter * beta *
193 this->
fe->shape_value(i, ref_q) * JxW +
194 penalty_parameter * beta *
195 solid_velocity->value(real_q, comp_i) *
196 this->
fe->shape_value(i, ref_q) * JxW;
200 const double strong_residual =
201 -penalty_parameter * beta *
202 (solid_velocity->value(real_q, comp_i) -
205 const double test_function =
209 -tau * (strong_residual)*test_function * JxW;
213 const AffineConstraints<double> &constraints_used =
216 constraints_used.distribute_local_to_global(local_matrix,
221 particle = pic.end();
224 this->
system_rhs.compress(VectorOperation::add);
231 const unsigned int i_solid)
233 std::shared_ptr<Particles::ParticleHandler<3>> &solid_ph =
234 (*solids)[i_solid]->get_solid_particle_handler();
236 const unsigned int dofs_per_cell = this->
fe->dofs_per_cell;
238 std::vector<types::global_dof_index> fluid_dof_indices(dofs_per_cell);
240 Tensor<2, 3> velocity_gradient;
242 Tensor<1, 3> normal_vector;
243 Tensor<2, 3> fluid_stress;
244 Tensor<2, 3> fluid_pressure;
251 RequiresConstantViscosity(
"assemble_nitsche_restriction"));
253 const double kinematic_viscosity =
255 .get_kinematic_viscosity_scale();
258 auto particle = solid_ph->begin();
259 while (particle != solid_ph->end())
261 const auto &cell = particle->get_surrounding_cell();
262 const auto &dh_cell =
263 typename DoFHandler<3>::cell_iterator(*cell, &(*this->
dof_handler));
264 dh_cell->get_dof_indices(fluid_dof_indices);
266 const auto pic = solid_ph->particles_in_cell(cell);
267 Assert(pic.begin() == particle, ExcInternalError());
273 Functions::FEFieldFunction<3, GlobalVectorType> fe_field(
277 fe_field.set_active_cell(dh_cell);
279 for (
const auto &p : pic)
281 const ArrayView<const double> properties = p.get_properties();
283 velocity_gradient = 0;
285 const auto &q = p.get_location();
286 const auto &JxW = properties[0];
287 normal_vector[0] = -properties[1];
288 normal_vector[1] = -properties[2];
289 normal_vector[2] = -properties[3];
291 for (
int k = 0; k < 3; ++k)
293 velocity_gradient[k] = fe_field.gradient(q, k);
298 for (
int d = 0; d < 2; ++d)
303 fluid_stress = kinematic_viscosity *
304 (velocity_gradient + transpose(velocity_gradient)) -
306 force += fluid_stress * normal_vector * JxW;
309 particle = pic.end();
315template <
int dim,
int spacedim>
318 const unsigned int i_solid)
320 std::shared_ptr<Particles::ParticleHandler<dim, spacedim>> &solid_ph =
321 (*solids)[i_solid]->get_solid_particle_handler();
323 const unsigned int dofs_per_cell = this->
fe->dofs_per_cell;
325 std::vector<types::global_dof_index> fluid_dof_indices(dofs_per_cell);
331 Function<spacedim> *solid_velocity = (*solids)[i_solid]->get_solid_velocity();
332 Tensor<1, spacedim> force;
333 for (
int i = 0; i < spacedim; ++i)
337 auto particle = solid_ph->begin();
338 while (particle != solid_ph->end())
340 const auto &cell = particle->get_surrounding_cell();
343 const double penalty_parameter =
344 1. / std::pow(h_cell * h_cell,
double(dim) /
double(spacedim));
345 const auto &dh_cell =
346 typename DoFHandler<spacedim>::cell_iterator(*cell,
348 dh_cell->get_dof_indices(fluid_dof_indices);
350 const auto pic = solid_ph->particles_in_cell(cell);
351 Assert(pic.begin() == particle, ExcInternalError());
352 for (
const auto &p : pic)
354 const ArrayView<const double> properties = p.get_properties();
357 const auto &ref_q = p.get_reference_location();
358 const auto &real_q = p.get_location();
359 const auto &JxW = properties[0];
361 for (
unsigned int k = 0; k < dofs_per_cell; ++k)
363 const auto comp_k = this->
fe->system_to_component_index(k).first;
364 if (comp_k < spacedim)
370 this->
fe->shape_value(k, ref_q);
373 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
375 const auto comp_i = this->
fe->system_to_component_index(i).first;
376 if (comp_i < spacedim)
379 penalty_parameter * beta * this->
fe->shape_value(i, ref_q) *
381 (solid_velocity->value(real_q, comp_i) -
velocity[comp_i]);
385 particle = pic.end();
391template <
int dim,
int spacedim>
394 const unsigned int i_solid)
396 std::shared_ptr<Particles::ParticleHandler<spacedim>> &solid_ph =
397 (*solids)[i_solid]->get_solid_particle_handler();
399 const unsigned int dofs_per_cell = this->
fe->dofs_per_cell;
401 std::vector<types::global_dof_index> fluid_dof_indices(dofs_per_cell);
407 Function<spacedim> *solid_velocity = (*solids)[i_solid]->get_solid_velocity();
414 Point<spacedim> center_of_rotation =
416 ->center_of_rotation;
419 auto particle = solid_ph->begin();
420 while (particle != solid_ph->end())
422 const auto &cell = particle->get_surrounding_cell();
425 const double penalty_parameter =
426 1. / std::pow(h_cell * h_cell,
double(dim) /
double(spacedim));
427 const auto &dh_cell =
428 typename DoFHandler<spacedim>::cell_iterator(*cell,
430 dh_cell->get_dof_indices(fluid_dof_indices);
432 const auto pic = solid_ph->particles_in_cell(cell);
433 Assert(pic.begin() == particle, ExcInternalError());
434 for (
const auto &p : pic)
436 const ArrayView<const double> properties = p.get_properties();
438 Tensor<1, spacedim> force;
441 const auto &ref_q = p.get_reference_location();
442 const auto &real_q = p.get_location();
443 const auto &JxW = properties[0];
445 for (
unsigned int k = 0; k < dofs_per_cell; ++k)
447 const auto comp_k = this->
fe->system_to_component_index(k).first;
448 if (comp_k < spacedim)
454 this->
fe->shape_value(k, ref_q);
457 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
459 const auto comp_i = this->
fe->system_to_component_index(i).first;
460 if (comp_i < spacedim)
463 penalty_parameter * beta * this->
fe->shape_value(i, ref_q) *
465 (solid_velocity->value(real_q, comp_i) -
velocity[comp_i]);
469 auto distance = real_q - center_of_rotation;
475 torque[2] += distance[0] * force[1] - distance[1] * force[0];
479 torque[0] += distance[1] * force[2] - distance[2] * force[1];
480 torque[1] += distance[2] * force[0] - distance[0] * force[2];
481 torque[2] += distance[0] * force[1] - distance[1] * force[0];
484 particle = pic.end();
490template <
int dim,
int spacedim>
493 const unsigned int i_solid,
494 bool first_solid_forces)
496 TimerOutput::Scope t(this->
computing_timer,
"Calculate force on solid");
498 std::vector<Tensor<1, spacedim>> force;
499 std::vector<unsigned int> solid_indices;
502 solid_indices.emplace_back(i_solid);
506 this->this_mpi_process == 0)
508 std::string independent_column_names =
"Solid ID";
509 std::vector<std::string> dependent_column_names;
510 dependent_column_names.emplace_back(
"f_x");
511 dependent_column_names.emplace_back(
"f_y");
513 dependent_column_names.emplace_back(
"f_z");
517 independent_column_names,
519 dependent_column_names,
525 if (first_solid_forces)
527 std::cout << std::endl;
528 std::cout <<
"+------------------------------------------+"
530 std::cout <<
"| Force on solid summary |"
532 std::cout <<
"+------------------------------------------+"
535 table.write_text(std::cout);
565 std::string filename_force =
568 ->force_output_name +
569 "_" + Utilities::int_to_string(i_solid, 2) +
".dat";
570 std::ofstream output_force(filename_force.c_str());
575template <
int dim,
int spacedim>
578 const unsigned int i_solid,
579 bool first_solid_torques)
581 TimerOutput::Scope t(this->
computing_timer,
"Calculate torque on solid");
583 std::vector<Tensor<1, 3>> torque;
584 std::vector<unsigned int> solid_indices;
587 solid_indices.emplace_back(i_solid);
591 this->this_mpi_process == 0)
593 std::string independent_column_names =
"Solid ID";
594 std::vector<std::string> dependent_column_names;
595 dependent_column_names.emplace_back(
"T_x");
596 dependent_column_names.emplace_back(
"T_y");
597 dependent_column_names.emplace_back(
"T_z");
601 independent_column_names,
603 dependent_column_names,
609 if (first_solid_torques)
611 std::cout << std::endl;
612 std::cout <<
"+------------------------------------------+"
614 std::cout <<
"| Torque on solids summary |"
616 std::cout <<
"+------------------------------------------+"
619 table.write_text(std::cout);
648 std::string filename_torque =
651 ->torque_output_name +
652 "_" + Utilities::int_to_string(i_solid, 2) +
".dat";
653 std::ofstream output_torque(filename_torque.c_str());
659template <
int dim,
int spacedim>
667 this->simulation_parameters.manifolds_parameters,
668 this->simulation_parameters.restart_parameters.restart,
669 this->simulation_parameters.boundary_conditions.periodic_boundaries);
677 "Nitsche setup solid mesh and particles");
678 for (
unsigned int i_solid = 0; i_solid <
solids->size(); ++i_solid)
680 (*solids)[i_solid]->initial_setup();
689 if constexpr (dim == spacedim)
698 this->simulation_parameters.restart_parameters.restart);
709 for (
unsigned int i_solid = 0; i_solid <
solids->size(); ++i_solid)
712 ->enable_particles_motion)
716 const double time_step =
718 const double initial_time =
721 (*solids)[i_solid]->update_temperature_time(time_step);
722 (*solids)[i_solid]->integrate_velocity(time_step, initial_time);
723 (*solids)[i_solid]->move_solid_triangulation(time_step,
727 if constexpr (dim == spacedim)
742 bool first_solid_forces(
true);
743 bool first_solid_torques(
true);
745 for (
unsigned int i_solid = 0;
750 ->calculate_force_on_solid)
753 first_solid_forces =
false;
756 ->calculate_torque_on_solid)
763 first_solid_torques =
false;
777 for (
unsigned int i_solid = 0; i_solid <
solids->size(); ++i_solid)
779 (*solids)[i_solid]->print_particle_positions();
785template <
int dim,
int spacedim>
788 const unsigned int i_solid)
790 std::shared_ptr<Particles::ParticleHandler<spacedim>> &particle_handler =
791 (*solids)[i_solid]->get_solid_particle_handler();
792 Particles::DataOut<spacedim, spacedim> particles_out;
793 particles_out.build_patches(*particle_handler);
796 const std::string solution_name =
798 Utilities::int_to_string(i_solid, 2);
813template <
int dim,
int spacedim>
816 const unsigned int i_solid)
818 DataOut<dim, spacedim> data_out;
819 DoFHandler<dim, spacedim> &solid_dh =
820 (*solids)[i_solid]->get_solid_dof_handler();
821 data_out.attach_dof_handler(solid_dh);
823 DoFHandler<dim, spacedim> &displacement_dh =
824 (*solids)[i_solid]->get_displacement_dof_handler();
825 data_out.attach_dof_handler(displacement_dh);
827 std::vector<std::string> solution_names(spacedim,
"displacement");
828 std::vector<DataComponentInterpretation::DataComponentInterpretation>
829 data_component_interpretation(
830 spacedim, DataComponentInterpretation::component_is_part_of_vector);
832 (*solids)[i_solid]->get_displacement_vector();
834 data_out.add_data_vector(displacement_vector,
836 DataOut<dim, spacedim>::type_dof_data,
837 data_component_interpretation);
841 data_out.build_patches();
844 const std::string solution_name =
846 Utilities::int_to_string(i_solid, 2);
861template <
int dim,
int spacedim>
866 this->simulation_parameters.mesh_adaptation))
876 for (
const auto &solid : *
solids)
877 solid->get_solid_particle_handler()
878 ->prepare_for_coarsening_and_refinement();
890 for (
const auto &solid : *
solids)
891 solid->get_solid_particle_handler()
892 ->unpack_after_coarsening_and_refinement();
896template <
int dim,
int spacedim>
907template <
int dim,
int spacedim>
916template <
int dim,
int spacedim>
917std::vector<OutputStructTableHandler>
922 std::vector<OutputStructTableHandler> table_output_structs;
927 std::string suffix =
".checkpoint";
931 for (
unsigned int i_solid = 0;
936 ->calculate_force_on_solid)
938 table_output_structs.emplace_back(
942 ->force_output_name +
943 "_" + Utilities::int_to_string(i_solid, 2) + suffix);
946 ->calculate_torque_on_solid)
948 table_output_structs.emplace_back(
952 ->torque_output_name +
953 "_" + Utilities::int_to_string(i_solid, 2) + suffix);
956 return table_output_structs;
959template <
int dim,
int spacedim>
964 for (
unsigned int i_solid = 0; i_solid <
solids->size(); ++i_solid)
966 std::string filename =
969 Utilities::int_to_string(i_solid, 2);
988 for (
unsigned int i_solid = 0; i_solid <
solids->size(); ++i_solid)
991 prefix +
"_solid_particles_" +
992 Utilities::int_to_string(i_solid, 2));
994 prefix +
"_solid_triangulation_" +
995 Utilities::int_to_string(i_solid, 2));
1005 const std::vector<OutputStructTableHandler> &table_output_structs =
1010template <
int dim,
int spacedim>
1017 "Nitsche reload solid mesh and particles");
1023 for (
unsigned int i_solid = 0; i_solid <
solids->size(); ++i_solid)
1025 std::string prefix =
1028 Utilities::int_to_string(i_solid, 2);
1030 (*solids)[i_solid]->read_checkpoint(prefix);
1035 std::string prefix =
1038 for (
unsigned int i_solid = 0; i_solid <
solids->size(); ++i_solid)
1042 prefix +
"_solid_particles_" + Utilities::int_to_string(i_solid, 2));
1044 prefix +
"_solid_triangulation_" +
1045 Utilities::int_to_string(i_solid, 2));
1054 std::vector<OutputStructTableHandler> table_output_structs =
TrilinosWrappers::SparseMatrix system_matrix
virtual void assemble_system_matrix() override
Assembles the matrix associated with the solver.
virtual void assemble_system_rhs() override
Assemble the rhs associated with the solver.
FluidDynamicsMatrixBased(SimulationParameters< dim > &nsparam, const FluidDynamicsFormulation fluid_dynamics_formulation=FluidDynamicsFormulation::standard)
Construct the matrix-based Navier-Stokes solver.
FluidDynamicsNitsche(SimulationParameters< spacedim > &nsparam)
void output_solid_triangulation(const unsigned int i_solid)
Outputs a vtu file for each output frequency of the solid triangulation.
void assemble_nitsche_restriction()
Adds the nitsche restriction to the global matrix and global rhs on the cells surrounding the immerse...
void postprocess_solid_torques(const unsigned int i_solid, bool first_solid_torques)
Post-process for torques on solid after an iteration.
std::vector< PVDHandler > pvdhandler_solid_triangulation
std::vector< OutputStructTableHandler > gather_tables() override
Returns a vector of references to TableHandler objects that needs to be serialized/deserialized for a...
Tensor< 1, 3 > calculate_torque_on_solid()
Calculates the torque due to the fluid motion on the solid.
virtual void read_checkpoint() override
Read a gls_nitsche simulation checkpoint and initiate simulation restart.
void output_solid_particles(const unsigned int i_solid)
Outputs a vtu file for each output frequency of the particles.
std::vector< TableHandler > solid_forces_table
void assemble_matrix_and_rhs()
Same as in fluid_dynamics_matrix_based, but calls assemble_nitsche_restriction() when global matrix a...
Tensor< 1, spacedim > calculate_forces_on_solid(const unsigned int i_solid)
Calculates the force due to the fluid motion on the solid.
std::shared_ptr< std::vector< std::shared_ptr< SolidBase< dim, spacedim > > > > solids
virtual void solve() override
solve Solves the Navier-Stokes problem
Tensor< 1, 3 > calculate_torque_on_solid(const unsigned int i_solid)
Calculates the torque due to the fluid motion on the solid.
std::vector< PVDHandler > pvdhandler_solid_particles
virtual void refine_mesh() override
Allow the refinement of the mesh according to one of the 2 methods proposed. Overrides the regular me...
virtual void write_checkpoint() override
Write a gls_nitsche simulation checkpointing to allow for gls_nitsche simulation restart.
void postprocess_solid_forces(const unsigned int i_solid, bool first_solid_forces)
Post-process for forces on solid after an iteration.
void assemble_rhs()
Same as in fluid_dynamics_matrix_based, but calls assemble_nitsche_restriction() when rhs is assemble...
std::vector< TableHandler > solid_torques_table
std::shared_ptr< FESystem< dim > > fe
virtual void set_initial_condition(const Parameters::FluidDynamicsInitialConditionType initial_condition_type, const bool restart=false)
void refine_mesh_adaptive()
MPI_Comm mpi_communicator
virtual std::vector< OutputStructTableHandler > gather_tables()
Returns a vector of references to TableHandler objects that needs to be serialized/ deserialized for ...
GlobalVectorType system_rhs
virtual void read_checkpoint()
virtual void finish_time_step()
const unsigned int this_mpi_process
SimulationParameters< dim > simulation_parameters
TimerOutput computing_timer
GlobalVectorType evaluation_point
std::shared_ptr< SimulationControl > simulation_control
void refine_mesh_uniform()
std::shared_ptr< MultiphysicsInterface< dim > > multiphysics
AffineConstraints< double > zero_constraints
virtual void setup_dofs()
virtual void write_checkpoint()
std::shared_ptr< DoFHandler< dim > > dof_handler
std::shared_ptr< parallel::DistributedTriangulationBase< dim > > triangulation
virtual void postprocess(bool first_iteration)
TableHandler make_table_scalars_tensors(const std::vector< T > &independent_values, const std::string &independent_column_name, const std::vector< Tensor< 1, dim > > &dependent_vector, const std::vector< std::string > &dependent_column_names, const unsigned int display_precision, const bool display_scientific_notation=false)
Generate a table from a vector of scalars (independent variable) and a vector of Tensor<1,...
void serialize_tables_vector(const std::vector< OutputStructTableHandler > &table_output_structs, const MPI_Comm mpi_communicator)
Serializes all the TableHandler objects in table_output_structs.
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)...
void deserialize_tables_vector(std::vector< OutputStructTableHandler > &table_output_structs, const MPI_Comm mpi_communicator)
Deserializes all the TableHandler objects in table_output_structs.
void read_mesh_and_manifolds(parallel::DistributedTriangulationBase< dim, spacedim > &triangulation, const Parameters::Mesh< dim, spacedim > &mesh_parameters, const Parameters::Manifolds &manifolds_parameters, bool restart, const Parameters::PeriodicBoundaries &periodic_boundaries)
Completely sets up a mesh and its manifolds.
@ velocity
Velocity vector field from fluid dynamics.
@ pressure
Pressure scalar 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...
dealii::TrilinosWrappers::MPI::Vector GlobalVectorType
void write_checkpoint(TimerOutput &computing_timer, const DEMSolverParameters< dim > ¶meters, std::shared_ptr< SimulationControl > &simulation_control, PVDHandler &particles_pvdhandler, PVDHandler &grid_pvdhandler, parallel::distributed::Triangulation< dim > &triangulation, Particles::ParticleHandler< dim > &particle_handler, std::shared_ptr< Insertion< dim, PropertiesIndex > > &insertion_object, std::vector< std::shared_ptr< SerialSolid< dim - 1, dim > > > &solid_objects, const ConditionalOStream &pcout, MPI_Comm &mpi_communicator, const CheckpointControl &checkpoint_controller)
Write_checkpoint Write a DEM simulation checkpointing to allow for DEM simulation restart.