15#include <deal.II/base/work_stream.h>
17#include <deal.II/dofs/dof_renumbering.h>
18#include <deal.II/dofs/dof_tools.h>
20#include <deal.II/fe/component_mask.h>
22#include <deal.II/grid/grid_tools.h>
24#include <deal.II/lac/full_matrix.h>
26#include <deal.II/numerics/vector_tools.h>
49 ExcMessage(
"SDIRK time-stepping methods are not supported by the block "
50 "fluid dynamics solver. Use a BDF method instead."));
65 .get_reference_temperature()));
73 .get_reference_temperature()));
82 this->simulation_parameters.physical_properties_manager
83 .density_is_constant())
103 PhaseChangePermeabilityModelRequiresTemperature());
107 .get_phase_change_parameters_vector(),
108 this->simulation_parameters.velocity_sources
109 .enable_darcy_multiply_by_density));
113 .permeability_model ==
115 carman_kozeny_phase_change)
118 PhaseChangePermeabilityModelRequiresTemperature());
122 .fluid_with_phase_change,
123 this->simulation_parameters.velocity_sources
124 .carman_kozeny_permeability_area,
125 this->simulation_parameters.velocity_sources
126 .carman_kozeny_tolerance,
127 this->simulation_parameters.physical_properties_manager
128 .get_phase_change_parameters_vector()));
132 .density_is_constant())
171 PhaseChangePermeabilityModelRequiresTemperature());
175 .get_physical_properties_parameters()
177 .phase_change_parameters));
181 .permeability_model ==
183 carman_kozeny_phase_change)
186 PhaseChangePermeabilityModelRequiresTemperature());
190 .carman_kozeny_permeability_area[0],
191 this->simulation_parameters.velocity_sources
192 .carman_kozeny_tolerance[0],
193 this->simulation_parameters.physical_properties_manager
194 .get_physical_properties_parameters()
196 .phase_change_parameters.T_liquidus,
198 this->simulation_parameters.physical_properties_manager
199 .get_physical_properties_parameters()
201 .phase_change_parameters.T_solidus));
216 .use_default_stabilization ==
true) ||
217 this->simulation_parameters.stabilization.stabilization ==
224 throw std::runtime_error(
225 "Using the GD solver with a stabilization other than the grad_div "
226 "stabilization will lead to an unstable block solver that is unable to converge");
257 *this->cell_quadrature,
259 *this->face_quadrature);
263 const DoFHandler<dim> &dof_handler_cls =
265 scratch_data.enable_cls(
266 dof_handler_cls.get_fe(),
267 *this->cell_quadrature,
269 this->simulation_parameters.multiphysics.cls_parameters.phase_filter);
275 this->dof_handler->end(),
281 this->cell_quadrature->size()));
304 const typename DoFHandler<dim>::active_cell_iterator &cell,
309 if (!cell->is_locally_owned())
317 this->forcing_function,
318 this->flow_control.get_beta(),
319 this->simulation_parameters.stabilization.pressure_scaling_factor);
322 const DoFHandler<dim> &dof_handler_cls =
324 typename DoFHandler<dim>::active_cell_iterator phase_cell(
339 const DoFHandler<dim> &dof_handler_ht =
342 *this->cell_quadrature,
352 assembler->assemble_matrix(scratch_data, copy_data);
368 constraints_used.distribute_local_to_global(copy_data.
local_matrix,
388 *this->cell_quadrature,
390 *this->face_quadrature);
394 const DoFHandler<dim> &dof_handler_cls =
396 scratch_data.enable_cls(
397 dof_handler_cls.get_fe(),
398 *this->cell_quadrature,
400 this->simulation_parameters.multiphysics.cls_parameters.phase_filter);
405 const DoFHandler<dim> &dof_handler_ht =
407 scratch_data.enable_heat_transfer(dof_handler_ht.get_fe(),
408 *this->cell_quadrature,
415 this->dof_handler->end(),
421 this->cell_quadrature->size()));
423 this->
system_rhs.compress(VectorOperation::add);
449 "This linear solver does not support this preconditioner. Only <ilu> and <amg> preconditioners are supported."));
455 const typename DoFHandler<dim>::active_cell_iterator &cell,
460 if (!cell->is_locally_owned())
468 this->forcing_function,
469 this->flow_control.get_beta(),
470 this->simulation_parameters.stabilization.pressure_scaling_factor);
474 const DoFHandler<dim> &dof_handler_cls =
476 typename DoFHandler<dim>::active_cell_iterator phase_cell(
491 const DoFHandler<dim> &dof_handler_ht =
494 typename DoFHandler<dim>::active_cell_iterator temperature_cell(
510 assembler->assemble_rhs(scratch_data, copy_data);
528 constraints_used.distribute_local_to_global(copy_data.
local_rhs,
542 FEValues<dim> fe_values(*this->
mapping,
545 update_values | update_quadrature_points |
547 const unsigned int dofs_per_cell = this->
fe->dofs_per_cell;
549 FullMatrix<double> local_matrix(dofs_per_cell, dofs_per_cell);
550 Vector<double> local_rhs(dofs_per_cell);
551 std::vector<Vector<double>> initial_velocity(n_q_points,
552 Vector<double>(dim + 1));
553 std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
554 const FEValuesExtractors::Vector velocities(0);
555 const FEValuesExtractors::Scalar
pressure(dim);
557 Tensor<1, dim> rhs_initial_velocity_pressure;
558 double rhs_initial_pressure;
560 std::vector<Tensor<1, dim>> phi_u(dofs_per_cell);
561 std::vector<double> phi_p(dofs_per_cell);
563 for (
const auto &cell : this->
dof_handler->active_cell_iterators())
565 if (cell->is_locally_owned())
567 fe_values.reinit(cell);
571 fe_values.get_quadrature_points(), initial_velocity);
572 for (
unsigned int q = 0; q < n_q_points; ++q)
574 for (
unsigned int k = 0; k < dofs_per_cell; ++k)
576 phi_p[k] = fe_values[
pressure].value(k, q);
577 phi_u[k] = fe_values[velocities].value(k, q);
581 for (
int i = 0; i < dim; ++i)
583 const unsigned int component_i =
584 this->
fe->system_to_component_index(i).first;
585 rhs_initial_velocity_pressure[i] =
586 initial_velocity[q](component_i);
588 rhs_initial_pressure = initial_velocity[q](dim);
590 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
593 for (
unsigned int j = 0; j < dofs_per_cell; ++j)
595 local_matrix(i, j) +=
596 (phi_u[j] * phi_u[i]) * fe_values.JxW(q);
597 local_matrix(i, j) +=
598 (phi_p[j] * phi_p[i]) * fe_values.JxW(q);
600 local_rhs(i) += (phi_u[i] * rhs_initial_velocity_pressure +
601 phi_p[i] * rhs_initial_pressure) *
606 cell->get_dof_indices(local_dof_indices);
632 std::vector<unsigned int> block_component(dim + 1, 0);
633 block_component[dim] = 1;
634 DoFRenumbering::component_wise(*this->
dof_handler, block_component);
640 DoFTools::count_dofs_per_fe_block(*this->
dof_handler, block_component);
647 this->
dof_handler->locally_owned_dofs().get_view(0, dof_u);
649 this->
dof_handler->locally_owned_dofs().get_view(dof_u, dof_u + dof_p);
651 IndexSet locally_relevant_dofs_acquisition;
652 locally_relevant_dofs_acquisition =
653 DoFTools::extract_locally_relevant_dofs(*this->
dof_handler);
656 locally_relevant_dofs_acquisition.get_view(0, dof_u);
658 locally_relevant_dofs_acquisition.get_view(dof_u, dof_u + dof_p);
665 for (
auto const &[
id, type] :
676 "The following boundary conditions are not supported by the lethe-fluid-block application: pressure, function weak, partial slip and outlet."));
722 for (
auto &solution : this->
sdirk_vectors.previous_k_j_solutions)
740 Table<2, DoFTools::Coupling> coupling(dim + 1, dim + 1);
741 for (
int c = 0; c < dim + 1; ++c)
742 for (
int d = 0; d < dim + 1; ++d)
743 if (!((c == dim) && (d == dim)))
744 coupling[c][d] = DoFTools::always;
746 coupling[c][d] = DoFTools::always;
748 DoFTools::make_sparsity_pattern(*this->
dof_handler,
753 Utilities::MPI::this_mpi_process(
766 "Time-averaging velocities and calculating reynolds "
767 "stresses are currently unavailable for mesh "
776 double global_volume =
779 this->
pcout <<
" Number of active cells: "
781 <<
" Number of degrees of freedom: "
783 this->
pcout <<
" Volume of triangulation: " << global_volume
792 this->previous_solutions);
815 this->
pcout <<
"************************" << std::endl;
816 this->
pcout <<
"---> Simulation Restart " << std::endl;
817 this->
pcout <<
"************************" << std::endl;
820 else if (initial_condition_type ==
828 else if (initial_condition_type ==
835 else if (initial_condition_type ==
839 std::shared_ptr<RheologicalModel> original_viscosity_model =
843 std::shared_ptr<Newtonian> temporary_rheology =
844 std::make_shared<Newtonian>(
853 const auto original_assembly_method =
865 original_viscosity_model);
869 throw std::runtime_error(
"GDNS - Initial condition could not be set");
877 const double absolute_residual =
880 const double relative_residual =
892 "This linear solver is not allowed. Only <gmres> linear solver is allowed."));
905 const unsigned int ilu_fill =
908 const double ilu_atol =
911 const double ilu_rtol =
916 std::make_shared<TrilinosWrappers::PreconditionILU>();
918 std::make_shared<TrilinosWrappers::PreconditionILU>();
920 TrilinosWrappers::PreconditionILU::AdditionalData preconditionerOptions(
921 ilu_fill, ilu_atol, ilu_rtol, 0);
923 preconditionerOptions);
926 preconditionerOptions);
931 .get_kinematic_viscosity_scale(),
950 std::vector<std::vector<bool>> velocity_constant_modes;
951 FEValuesExtractors::Vector velocities(0);
953 ComponentMask velocity_components = this->
fe->component_mask(velocities);
954 velocity_constant_modes =
955 DoFTools::extract_constant_modes(*this->
dof_handler, velocity_components);
958 std::vector<std::vector<bool>> pressure_constant_modes;
959 FEValuesExtractors::Scalar
pressure(dim);
960 ComponentMask pressure_components = this->
fe->component_mask(
pressure);
961 pressure_constant_modes =
962 DoFTools::extract_constant_modes(*this->
dof_handler, pressure_components);
965 const bool elliptic_velocity =
false;
966 bool higher_order_elements =
false;
967 if (this->
fe->degree > 1)
968 higher_order_elements =
true;
969 const unsigned int n_cycles =
975 const double aggregation_threshold =
977 .amg_aggregation_threshold;
978 const unsigned int smoother_sweeps =
980 .amg_smoother_sweeps;
981 const unsigned int smoother_overlap =
983 .amg_smoother_overlap;
984 const bool output_details =
false;
985 const char *smoother_type =
"Chebyshev";
986 const char *coarse_type =
"Amesos-KLU";
989 std::make_shared<TrilinosWrappers::PreconditionAMG>();
991 std::make_shared<TrilinosWrappers::PreconditionAMG>();
993 TrilinosWrappers::PreconditionAMG::AdditionalData
994 velocity_preconditioner_options(elliptic_velocity,
995 higher_order_elements,
998 aggregation_threshold,
999 velocity_constant_modes,
1006 Teuchos::ParameterList velocity_parameter_ml;
1007 std::unique_ptr<Epetra_MultiVector> velocity_distributed_constant_modes;
1008 velocity_preconditioner_options.set_parameters(
1009 velocity_parameter_ml,
1010 velocity_distributed_constant_modes,
1013 velocity_parameter_ml);
1017 const bool elliptic_pressure =
true;
1018 higher_order_elements =
false;
1020 higher_order_elements =
true;
1021 TrilinosWrappers::PreconditionAMG::AdditionalData
1022 pressure_preconditioner_options(elliptic_pressure,
1023 higher_order_elements,
1026 aggregation_threshold,
1027 pressure_constant_modes,
1033 Teuchos::ParameterList pressure_parameter_ml;
1034 std::unique_ptr<Epetra_MultiVector> pressure_distributed_constant_modes;
1035 velocity_preconditioner_options.set_parameters(
1036 pressure_parameter_ml,
1037 pressure_distributed_constant_modes,
1040 pressure_parameter_ml);
1052 .get_kinematic_viscosity_scale(),
1065 const double relative_residual)
1067 const AffineConstraints<double> &
zero_constraints = this->zero_constraints;
1069 const double current_residual = this->
system_rhs.l2_norm() / rescale_metric;
1070 const double linear_solver_tolerance =
1071 std::max(relative_residual * current_residual, absolute_residual);
1075 this->
pcout <<
" -Tolerance of iterative solver is : "
1076 << linear_solver_tolerance << std::endl;
1078 const double non_rescaled_linear_solver_tolerance =
1079 linear_solver_tolerance * rescale_metric;
1087 non_rescaled_linear_solver_tolerance,
1091 SolverFGMRES<GlobalBlockVectorType> solver(solver_control);
1116 this->simulation_parameters.linear_solver
1121 "This linear solver does not support this preconditioner. Only <ilu> and <amg> preconditioners are supported."));
1126 this->
pcout <<
" -Iterative solver took : "
1127 << solver_control.last_step()
1128 <<
" steps to reach a residual norm of "
1129 << solver_control.last_value() / rescale_metric
1140 double relative_residual)
1145 this->nonzero_constraints;
1147 const double current_residual = this->
system_rhs.l2_norm() / rescale_metric;
1148 const double linear_solver_tolerance =
1149 std::max(relative_residual * current_residual, absolute_residual);
1153 this->
pcout <<
" -Tolerance of iterative solver is : "
1154 << linear_solver_tolerance << std::endl;
1156 const double non_rescaled_linear_solver_tolerance =
1157 linear_solver_tolerance * rescale_metric;
1165 non_rescaled_linear_solver_tolerance,
1168 SolverFGMRES<GlobalBlockVectorType> solver(solver_control);
1169 TrilinosWrappers::PreconditionILU pmass_preconditioner;
1174 const unsigned int ilu_fill =
1177 const double ilu_atol =
1180 const double ilu_rtol =
1183 TrilinosWrappers::PreconditionILU::AdditionalData preconditionerOptions(
1184 ilu_fill, ilu_atol, ilu_rtol, 0);
1189 preconditioner(
system_matrix, pmass_preconditioner, solver_control);
1192 completely_distributed_solution,
1199 this->
pcout <<
" -Iterative solver took : " << solver_control.last_step()
1200 <<
" steps " << std::endl;
1214 auto &previous_k_j_solutions = this->
sdirk_vectors.previous_k_j_solutions;
1215 auto &sum_over_previous_stages = this->
sdirk_vectors.sum_over_previous_stages;
1216 auto &local_sum_over_previous_stages =
1218 auto &locally_owned_for_calculation =
1229 const double a_ii = stage_data.
a_ij[stage];
1233 local_sum_over_previous_stages = 0;
1240 for (
unsigned int p = 0; p < stage; ++p)
1242 locally_owned_for_calculation = previous_k_j_solutions[p];
1243 local_sum_over_previous_stages.add(stage_data.
a_ij[p] / a_ii,
1244 locally_owned_for_calculation);
1248 sum_over_previous_stages = local_sum_over_previous_stages;
1262 auto &local_sum_over_previous_stages =
1264 auto &locally_owned_for_calculation =
1266 auto &previous_k_j_solutions = this->
sdirk_vectors.previous_k_j_solutions;
1268 auto &local_sum_bi_ki = this->
sdirk_vectors.local_sum_bi_ki;
1272 const double a_ii = stage_data.
a_ij[stage];
1289 const double b_i = stage_data.
b_i;
1291 sum_bi_ki = local_sum_bi_ki;
1303 auto &local_sum_bi_ki = this->
sdirk_vectors.local_sum_bi_ki;
1306 local_sum_bi_ki = sum_bi_ki;
1323 this->simulation_parameters.manifolds_parameters,
1324 this->simulation_parameters.restart_parameters.restart,
1325 this->simulation_parameters.boundary_conditions.periodic_boundaries);
1331 this->simulation_parameters.restart_parameters.restart);
1344 for (
unsigned int i = 0;
Class that assembles the core of the Navier-Stokes equation. According to the following weak form: ...
virtual void multi_stage_postresolution(unsigned int stage, Parameters::SimulationControl::TimeSteppingMethod method, double time_step) override
Calculate from Update .
void solve_linear_system() override
void set_solution_vector(double value)
std::vector< types::global_dof_index > dofs_per_block
void assemble_L2_projection()
void multi_stage_preresolution(unsigned int stage, Parameters::SimulationControl::TimeSteppingMethod method) override
Update the sum_over_previous_stages variable to use it in the solver.
std::shared_ptr< TrilinosWrappers::PreconditionAMG > velocity_amg_preconditioner
virtual void update_multiphysics_time_average_solution() override
Update the average velocity field solution in the multiphysics interface.
std::shared_ptr< BlockSchurPreconditioner< TrilinosWrappers::PreconditionAMG > > system_amg_preconditioner
TrilinosWrappers::SparseMatrix pressure_mass_matrix
void assemble_local_system_matrix(const typename DoFHandler< dim >::active_cell_iterator &cell, NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data)
Assemble the local matrix for a given cell.
std::shared_ptr< BlockSchurPreconditioner< TrilinosWrappers::PreconditionILU > > system_ilu_preconditioner
void solve_L2_system(double relative_residual, double minimum_residual)
void copy_local_matrix_to_global_matrix(const StabilizedMethodsTensorCopyData< dim > ©_data)
Copy local cell information to global matrix.
void assemble_system_rhs() override
Assemble the rhs associated with the solver.
virtual void update_multi_stage_solution(double time_step) override
void copy_local_rhs_to_global_rhs(const StabilizedMethodsTensorCopyData< dim > ©_data)
Copy local cell rhs information to global rhs.
std::shared_ptr< TrilinosWrappers::PreconditionAMG > pressure_amg_preconditioner
TrilinosWrappers::BlockSparsityPattern sparsity_pattern
void setup_assemblers()
sets up the vector of assembler functions
virtual void set_initial_condition_fd(Parameters::FluidDynamicsInitialConditionType initial_condition_type, bool restart=false) override
Sets the initial condition for the solver.
std::shared_ptr< TrilinosWrappers::PreconditionILU > velocity_ilu_preconditioner
void solve_system_GMRES(const double relative_residual, const double minimum_residual)
FluidDynamicsBlock(SimulationParameters< dim > &nsparam)
void setup_preconditioner() override
Set up preconditioner. Not used for this solver but needed for other physics solvers.
TrilinosWrappers::BlockSparseMatrix system_matrix
void assemble_system_matrix() override
Assembles the matrix associated with the solver.
virtual void setup_dofs_fd() override
Initialize the dofs for fluid dynamics.
void assemble_local_system_rhs(const typename DoFHandler< dim >::active_cell_iterator &cell, NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > ©_data)
Assemble the local rhs for a given cell.
std::shared_ptr< TrilinosWrappers::PreconditionILU > pressure_ilu_preconditioner
Class that assembles the core of the Navier-Stokes equation with free surface using CLS modeling....
Class that assembles the transient time arising from BDF time integration for the Navier Stokes equat...
Class that assembles the coriolis and the centrifugal if a simulation is carried out in a rotating fr...
Assembles the transient time arising from BDF time integration for the Navier-Stokes equation with fr...
Assembles the core of the Navier-Stokes equation with free surface using CLS modeling....
void box_refine_mesh(const bool restart)
std::shared_ptr< FESystem< dim > > fe
std::shared_ptr< Quadrature< dim > > cell_quadrature
double get_residual_rescale_metric() const override
AffineConstraints< double > nonzero_constraints
virtual void set_initial_condition(const Parameters::FluidDynamicsInitialConditionType initial_condition_type, const bool restart=false)
const unsigned int pressure_fem_degree
MPI_Comm mpi_communicator
std::vector< IndexSet > locally_owned_dofs
void define_zero_constraints()
SDIRKVectors sdirk_vectors
void rescale_pressure_dofs_in_newton_update()
std::shared_ptr< GlobalBlockVectorType > present_solution
GlobalBlockVectorType system_rhs
GlobalBlockVectorType newton_update
virtual void refine_mesh()
void define_non_zero_constraints()
virtual void finish_time_step()
virtual void dynamic_flow_control()
SimulationParameters< dim > simulation_parameters
TimerOutput computing_timer
std::shared_ptr< std::vector< GlobalBlockVectorType > > previous_solutions
GlobalBlockVectorType evaluation_point
std::shared_ptr< Function< dim > > forcing_function
std::shared_ptr< SimulationControl > simulation_control
GlobalBlockVectorType local_evaluation_point
std::vector< std::shared_ptr< NavierStokesAssemblerBase< dim > > > assemblers
std::shared_ptr< MultiphysicsInterface< dim > > multiphysics
NavierStokesBase(SimulationParameters< dim > &nsparam, const FluidDynamicsFormulation fluid_dynamics_formulation=FluidDynamicsFormulation::standard)
AffineConstraints< double > zero_constraints
std::shared_ptr< AverageVelocities< dim, GlobalBlockVectorType, std::vector< IndexSet > > > average_velocities
virtual void setup_dofs()
std::shared_ptr< Mapping< dim > > mapping
std::vector< IndexSet > locally_relevant_dofs
std::shared_ptr< DoFHandler< dim > > dof_handler
std::shared_ptr< parallel::DistributedTriangulationBase< dim > > triangulation
virtual void postprocess(bool first_iteration)
Class that stores the information required by the assembly procedure for a Navier-Stokes equation....
void calculate_physical_properties()
Calculates the physical properties. This function calculates the physical properties that may be requ...
void reinit(const typename DoFHandler< dim >::active_cell_iterator &cell, const VectorType ¤t_solution, const std::vector< VectorType > &previous_solutions, const VectorType &sum_over_previous_stages, const std::shared_ptr< Function< dim > > &forcing_function, const Tensor< 1, dim > &beta_force, const double pressure_scaling_factor)
Reinitializes the content of the scratch.
void reinit_heat_transfer(const typename DoFHandler< dim >::active_cell_iterator &cell, const VectorType ¤t_solution, const std::vector< VectorType > &previous_solutions)
Reinitialize the content of the scratch for the heat transfer auxiliary physic.
void enable_heat_transfer(const FiniteElement< dim > &fe, const Quadrature< dim > &quadrature, const Mapping< dim > &mapping)
enable_heat_transfer Enables the collection of the heat transfer data (Temperature field) by the scra...
void reinit_cls(const typename DoFHandler< dim >::active_cell_iterator &cell, const VectorType ¤t_solution, const VectorType ¤t_filtered_solution, const std::vector< VectorType > &previous_solutions)
Reinitialize the content of the scratch for the cls.
Assembler of the non-linear Carman-Kozeny permeability model for simulations with phase change.
Assembler of the non-linear Carman-Kozeny permeability model for CLS simulations with phase change.
Class that assembles a phase change Darcy forcing term. This term adds to the right hand-side of the...
Assembles a phase change Darcy forcing term for a CLS two-fluid simulation. The term is added to the...
void solve_governing_system()
Solve the global system of equations according to a given strategy, either linear or not.
std::vector< double > a_ij
Class responsible for storing the information calculated using the assembly of stabilized Tensor<1,...
FullMatrix< double > local_matrix
Vector< double > local_rhs
void reset()
Resets the cell_matrix, cell_rhs, strong_residual and strong_jacobian to zero.
std::vector< types::global_dof_index > local_dof_indices
Assembles the thermal buoyancy source term for CLS simulations. This assembler includes density expli...
Class that assembles a thermal buoyancy forcing term using the Boussinesq approximation....
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.
@ pressure
Pressure scalar field from fluid dynamics.
@ fluid_dynamics
Fluid Dynamics (Velocity,Pressure).
@ heat_transfer
Heat transfer (Temperature).
FluidDynamicsInitialConditionType
void read_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_surfaces, CheckpointControl &checkpoint_controller)
Read a DEM simulation checkpoint, allowing the simulation to restart from where it stopped.
SDIRKTable sdirk_table(const Parameters::SimulationControl::TimeSteppingMethod method)
Construct the Butcher tableau (A, b, c) for a given SDIRK method.
@ amg
Algebraic Multigrid.
@ ilu
Incomplete LU Factorization.
Structure representing a Butcher tableau for a SDIRK method.
bool time_stepping_is_bdf(const Parameters::SimulationControl::TimeSteppingMethod method)
Determines if the time integration method is within the bdf family.
bool time_stepping_is_sdirk(const Parameters::SimulationControl::TimeSteppingMethod method)
Determines if the time integration method is within the sdirk family.
dealii::TrilinosWrappers::MPI::BlockVector GlobalBlockVectorType