Follow-up to #15706.
#include <locale>
#include <string>
-// This is the only include file that is new: It introduces the
-// parallel::distributed::SolutionTransfer equivalent of the
-// SolutionTransfer class to take a solution from on mesh to the next
-// one upon mesh refinement, but in the case of parallel distributed
-// triangulations:
-#include <deal.II/distributed/solution_transfer.h>
-
// The following classes are used in parallel distributed computations and
// have all already been introduced in step-40:
#include <deal.II/base/index_set.h>
void
BoussinesqFlowProblem<dim>::refine_mesh(const unsigned int max_grid_level)
{
- parallel::distributed::SolutionTransfer<dim, TrilinosWrappers::MPI::Vector>
- temperature_trans(temperature_dof_handler);
- parallel::distributed::SolutionTransfer<dim,
- TrilinosWrappers::MPI::BlockVector>
- stokes_trans(stokes_dof_handler);
+ SolutionTransfer<dim, TrilinosWrappers::MPI::Vector> temperature_trans(
+ temperature_dof_handler);
+ SolutionTransfer<dim, TrilinosWrappers::MPI::BlockVector> stokes_trans(
+ stokes_dof_handler);
{
TimerOutput::Scope timer_section(computing_timer,
cell->clear_refine_flag();
// With all flags marked as necessary, we can then tell the
- // parallel::distributed::SolutionTransfer objects to get ready to
- // transfer data from one mesh to the next, which they will do when
- // notified by
+ // SolutionTransfer objects to get ready to transfer data from one mesh to
+ // the next, which they will do when notified by
// Triangulation as part of the @p execute_coarsening_and_refinement() call.
// The syntax is similar to the non-%parallel solution transfer (with the
// exception that here a pointer to the vector entries is enough). The
#include <deal.II/distributed/tria.h>
#include <deal.II/distributed/grid_refinement.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_renumbering.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/error_estimator.h>
#include <deal.II/numerics/fe_field_function.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <fstream>
#include <iostream>
triangulation.prepare_coarsening_and_refinement();
- parallel::distributed::SolutionTransfer<dim, TrilinosWrappers::MPI::Vector>
- solution_transfer(dof_handler);
+ SolutionTransfer<dim, TrilinosWrappers::MPI::Vector> solution_transfer(
+ dof_handler);
if (transfer_solution)
solution_transfer.prepare_for_coarsening_and_refinement(solution);
// cells whose center is within a radius of 11, and then refine once more
// for a radius 6. This simple ad hoc refinement could be done better by
// adapting the mesh to the solution using error estimators during the time
- // stepping as done in other example programs, and using
- // parallel::distributed::SolutionTransfer to transfer the solution to the
- // new mesh.
+ // stepping as done in other example programs, and using SolutionTransfer to
+ // transfer the solution to the new mesh.
template <int dim>
void SineGordonProblem<dim>::make_grid_and_dofs()
{
#include <deal.II/base/utilities.h>
#include <deal.II/distributed/grid_refinement.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/error_estimator.h>
#include <deal.II/numerics/vector_tools.h>
+#include <deal.II/numerics/solution_transfer.h>
// These are the only new include files with regard to step-60. In this
// tutorial, the non-matching coupling between the solid and the fluid is
cell->clear_coarsen_flag();
}
- parallel::distributed::SolutionTransfer<spacedim, LA::MPI::BlockVector>
- transfer(fluid_dh);
+ SolutionTransfer<spacedim, LA::MPI::BlockVector> transfer(fluid_dh);
fluid_tria.prepare_coarsening_and_refinement();
transfer.prepare_for_coarsening_and_refinement(locally_relevant_solution);
#include <deal.II/lac/sparsity_tools.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/distributed/grid_refinement.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/grid_out.h>
#include <deal.II/dofs/dof_handler.h>
const std::vector<PETScWrappers::MPI::Vector> &all_in,
std::vector<PETScWrappers::MPI::Vector> &all_out)
{
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- solution_trans(dof_handler);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> solution_trans(
+ dof_handler);
std::vector<PETScWrappers::MPI::Vector> all_in_ghosted(all_in.size());
std::vector<const PETScWrappers::MPI::Vector *> all_in_ghosted_ptr(
#include <deal.II/base/utilities.h>
#include <deal.II/distributed/grid_refinement.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
#include <fstream>
// To be sure, use two SolutionTransfer objects, because the second one
// will get a large offset
- parallel::distributed::SolutionTransfer<dim, VectorType> system_trans(
- dof_handler);
- parallel::distributed::SolutionTransfer<dim, VectorType> trans2(
- dof_handler);
+ SolutionTransfer<dim, VectorType> system_trans(dof_handler);
+ SolutionTransfer<dim, VectorType> trans2(dof_handler);
system_trans.prepare_for_serialization(x_system);
trans2.prepare_for_serialization(y);
triangulation.coarsen_global(99);
triangulation.load("restart.mesh");
- parallel::distributed::SolutionTransfer<dim, VectorType> system_trans(
- dof_handler);
- parallel::distributed::SolutionTransfer<dim, VectorType> trans2(
- dof_handler);
+ SolutionTransfer<dim, VectorType> system_trans(dof_handler);
+ SolutionTransfer<dim, VectorType> trans2(dof_handler);
system_trans.deserialize(x_system);
trans2.deserialize(y);
#include <deal.II/base/utilities.h>
#include <deal.II/distributed/grid_refinement.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
#include <fstream>
// To be sure, use two SolutionTransfer objects, because the second one
// will get a large offset
- parallel::distributed::SolutionTransfer<dim, VectorType> system_trans(
- dof_handler);
- parallel::distributed::SolutionTransfer<dim, VectorType> trans2(
- dof_handler);
+ SolutionTransfer<dim, VectorType> system_trans(dof_handler);
+ SolutionTransfer<dim, VectorType> trans2(dof_handler);
dof_handler.prepare_for_serialization_of_active_fe_indices();
triangulation.coarsen_global(99);
triangulation.load("restart.mesh");
- parallel::distributed::SolutionTransfer<dim, VectorType> system_trans(
- dof_handler);
- parallel::distributed::SolutionTransfer<dim, VectorType> trans2(
- dof_handler);
+ SolutionTransfer<dim, VectorType> system_trans(dof_handler);
+ SolutionTransfer<dim, VectorType> trans2(dof_handler);
dof_handler.deserialize_active_fe_indices();
system_trans.deserialize(x_system);
#include <deal.II/base/tensor.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/numerics/solution_transfer.h>
+
#include "../tests.h"
static const FE_Q<dim> fe(2);
dofh.distribute_dofs(fe);
- parallel::distributed::SolutionTransfer<dim, Vector<double>> soltrans(dofh);
+ SolutionTransfer<dim, Vector<double>> soltrans(dofh);
for (typename Triangulation<dim>::active_cell_iterator cell =
tr.begin_active();
#include <deal.II/base/function.h>
#include <deal.II/base/tensor.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
#include "../tests.h"
static const FE_Q<dim> fe(1);
dofh.distribute_dofs(fe);
- parallel::distributed::SolutionTransfer<dim, Vector<double>> soltrans(dofh);
+ SolutionTransfer<dim, Vector<double>> soltrans(dofh);
for (typename Triangulation<dim>::active_cell_iterator cell =
tr.begin_active();
#include <deal.II/base/function.h>
#include <deal.II/base/tensor.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
#include "../tests.h"
static const FE_Q<dim> fe(1);
dofh.distribute_dofs(fe);
- parallel::distributed::SolutionTransfer<dim, Vector<double>> soltrans(dofh);
+ SolutionTransfer<dim, Vector<double>> soltrans(dofh);
for (int i = 0; i < 4; ++i)
{
#include <deal.II/base/tensor.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/numerics/solution_transfer.h>
+
#include "../tests.h"
#include "coarse_grid_common.h"
static const FE_Q<dim> fe(2);
dofh.distribute_dofs(fe);
- parallel::distributed::SolutionTransfer<dim, Vector<double>> soltrans(dofh);
- parallel::distributed::SolutionTransfer<dim, Vector<double>> soltrans2(dofh);
+ SolutionTransfer<dim, Vector<double>> soltrans(dofh);
+ SolutionTransfer<dim, Vector<double>> soltrans2(dofh);
for (typename Triangulation<dim>::active_cell_iterator cell =
tr.begin_active();
// Test distributed solution transfer with fullydistributed triangulations.
#include <deal.II/distributed/fully_distributed_tria.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
#include "../grid/tests.h"
"solution_transfer_" + std::to_string(dim) + "d_out";
{
- parallel::distributed::SolutionTransfer<dim, VectorType> solution_transfer(
- dof_handler);
+ SolutionTransfer<dim, VectorType> solution_transfer(dof_handler);
solution_transfer.prepare_for_serialization(vector);
triangulation.save(filename);
triangulation.load(filename);
dof_handler.distribute_dofs(FE_Q<dim>(2));
- parallel::distributed::SolutionTransfer<dim, VectorType> solution_transfer(
- dof_handler);
+ SolutionTransfer<dim, VectorType> solution_transfer(dof_handler);
solution_transfer.deserialize(vector_loaded);
vector_loaded.update_ghost_values();
#include <deal.II/base/function.h>
#include <deal.II/base/tensor.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/lac/trilinos_vector.h>
#include <deal.II/numerics/data_out.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
#include "../tests.h"
- parallel::distributed::SolutionTransfer<dim,
- TrilinosWrappers::MPI::Vector>
- trans(dofh);
+ SolutionTransfer<dim, TrilinosWrappers::MPI::Vector> trans(dofh);
tr.prepare_coarsening_and_refinement();
#include <deal.II/base/function.h>
#include <deal.II/base/tensor.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/lac/trilinos_parallel_block_vector.h>
#include <deal.II/numerics/data_out.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
#include "../tests.h"
}
}
- parallel::distributed::SolutionTransfer<dim,
- TrilinosWrappers::MPI::Vector>
- trans(dofh);
+ SolutionTransfer<dim, TrilinosWrappers::MPI::Vector> trans(dofh);
tr.prepare_coarsening_and_refinement();
#include <deal.II/base/tensor.h>
#include <deal.II/base/utilities.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/numerics/solution_transfer.h>
+
#include "../tests.h"
locally_relevant_dofs,
MPI_COMM_WORLD);
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans(dh);
for (unsigned int i = 0; i < locally_owned_dofs.n_elements(); ++i)
{
DoFTools::extract_locally_relevant_dofs(dh);
PETScWrappers::MPI::Vector solution(locally_owned_dofs, MPI_COMM_WORLD);
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans(dh);
solution = 2;
soltrans.deserialize(solution);
#include <deal.II/base/tensor.h>
#include <deal.II/base/utilities.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/numerics/solution_transfer.h>
+
#include "../tests.h"
locally_relevant_dofs,
MPI_COMM_WORLD);
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans(dh);
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans2(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans2(dh);
for (unsigned int i = 0; i < locally_owned_dofs.n_elements(); ++i)
{
PETScWrappers::MPI::Vector solution(locally_owned_dofs, MPI_COMM_WORLD);
PETScWrappers::MPI::Vector solution2(locally_owned_dofs, MPI_COMM_WORLD);
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans(dh);
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans2(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans2(dh);
solution = 2;
soltrans.deserialize(solution);
soltrans2.deserialize(solution2);
#include <deal.II/base/tensor.h>
#include <deal.II/base/utilities.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/numerics/solution_transfer.h>
+
#include "../tests.h"
locally_relevant_dofs,
com_small);
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans(dh);
for (unsigned int i = 0; i < locally_owned_dofs.n_elements(); ++i)
{
PETScWrappers::MPI::Vector solution(locally_owned_dofs, com_all);
solution = PetscScalar();
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans(dh);
soltrans.deserialize(solution);
for (unsigned int i = 0; i < locally_owned_dofs.n_elements(); ++i)
#include <deal.II/base/tensor.h>
#include <deal.II/base/utilities.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/numerics/solution_transfer.h>
+
#include "../tests.h"
locally_relevant_dofs,
com_small);
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans(dh);
for (unsigned int i = 0; i < locally_owned_dofs.n_elements(); ++i)
{
PETScWrappers::MPI::Vector solution(locally_owned_dofs, com_all);
solution = PetscScalar();
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- soltrans(dh);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> soltrans(dh);
soltrans.deserialize(solution);
#include <deal.II/base/function.h>
#include <deal.II/base/tensor.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/lac/petsc_vector.h>
#include <deal.II/numerics/data_out.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
#include "../tests.h"
locally_relevant_dofs,
MPI_COMM_WORLD);
- parallel::distributed::SolutionTransfer<2, PETScWrappers::MPI::Vector>
- soltrans(dh);
+ SolutionTransfer<2, PETScWrappers::MPI::Vector> soltrans(dh);
tria.set_all_refine_flags();
tria.prepare_coarsening_and_refinement();
// This tests is based on mpi/feindices_transfer.cc
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/trilinos_vector.h>
+#include <deal.II/numerics/solution_transfer.h>
+
#include "../tests.h"
// ----- transfer -----
- parallel::distributed::SolutionTransfer<dim, TrilinosWrappers::MPI::Vector>
- soltrans(dh);
+ SolutionTransfer<dim, TrilinosWrappers::MPI::Vector> soltrans(dh);
soltrans.prepare_for_coarsening_and_refinement(old_solution);
tria.execute_coarsening_and_refinement();
-// Test parallel::distributed::SolutionTransfer for FE_Nothing
+// Test parallel distributed SolutionTransfer for FE_Nothing
// (see also https://github.com/dealii/dealii/issues/10570).
#include <deal.II/base/function.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/numerics/solution_transfer.h>
+
#include <iostream>
#include <vector>
for (unsigned int i = 0; i < solution.size(); ++i)
solution(i) = i;
- parallel::distributed::
- SolutionTransfer<dim, LinearAlgebra::distributed::Vector<double>>
- soltrans(dof_handler);
+ SolutionTransfer<dim, LinearAlgebra::distributed::Vector<double>> soltrans(
+ dof_handler);
for (const auto &cell : tria.active_cell_iterators())
cell->set_refine_flag();
#include <deal.II/base/utilities.h>
#include <deal.II/distributed/grid_refinement.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/solution_transfer.h>
#include <deal.II/numerics/vector_tools.h>
// These are the only new include files with regard to step-60. In this
cell->clear_coarsen_flag();
}
- parallel::distributed::SolutionTransfer<spacedim, LA::MPI::BlockVector>
- transfer(fluid_dh);
+ SolutionTransfer<spacedim, LA::MPI::BlockVector> transfer(fluid_dh);
fluid_tria.prepare_coarsening_and_refinement();
transfer.prepare_for_coarsening_and_refinement(locally_relevant_solution);
#include <deal.II/base/conditional_ostream.h>
#include <deal.II/distributed/grid_refinement.h>
-#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/grid/grid_tools.h>
triangulation.prepare_coarsening_and_refinement();
- parallel::distributed::SolutionTransfer<dim, PETScWrappers::MPI::Vector>
- solution_transfer(dof_handler);
+ SolutionTransfer<dim, PETScWrappers::MPI::Vector> solution_transfer(
+ dof_handler);
PETScWrappers::MPI::Vector current_solution_tmp(locally_relevant_solution);
solution_transfer.prepare_for_coarsening_and_refinement(