#include <deal.II/distributed/solution_transfer.h>

Public Member Functions
	SolutionTransfer (const DoFHandlerType &dof)

	~SolutionTransfer ()

void	prepare_for_coarsening_and_refinement (const std::vector< const VectorType *> &all_in)

void	prepare_for_coarsening_and_refinement (const VectorType &in)

void	interpolate (std::vector< VectorType *> &all_out)

void	interpolate (VectorType &out)

unsigned int	get_data_size () const

void	prepare_serialization (const VectorType &in)

void	prepare_serialization (const std::vector< const VectorType *> &all_in)

void	deserialize (VectorType &in)

void	deserialize (std::vector< VectorType *> &all_in)

Private Member Functions
void	pack_callback (const typename Triangulation< dim, DoFHandlerType::space_dimension >::cell_iterator &cell, const typename Triangulation< dim, DoFHandlerType::space_dimension >::CellStatus status, void *data)

void	unpack_callback (const typename Triangulation< dim, DoFHandlerType::space_dimension >::cell_iterator &cell, const typename Triangulation< dim, DoFHandlerType::space_dimension >::CellStatus status, const void data, std::vector< VectorType > &all_out)

Private Attributes
SmartPointer< const DoFHandlerType, SolutionTransfer< dim, VectorType, DoFHandlerType > >	dof_handler

std::vector< const VectorType * >	input_vectors

unsigned int	offset

Detailed Description

template<int dim, typename VectorType, typename DoFHandlerType = DoFHandler<dim>>
class parallel::distributed::SolutionTransfer< dim, VectorType, DoFHandlerType >

Transfers a discrete FE function (like a solution vector) by interpolation while refining and/or coarsening a distributed grid and handles the necessary communication.

Note: It is important to note, that if you use more than one SolutionTransfer object at the same time, that the calls to prepare_*() and interpolate()/deserialize() need to be in the same order.

Note on ghost elements

In a parallel computation PETSc or Trilinos vector may contain ghost elements or not. For reading in information with prepare_for_coarsening_and_refinement() or prepare_serialization() you need to supply vectors with ghost elements, so that all locally_active elements can be read. On the other hand, ghosted vectors are generally not writable, so for calls to interpolate() or deserialize() you need to supply distributed vectors without ghost elements.

Transferring a solution

Here VectorType is your favorite vector type, e.g. PETScWrappers::MPI::Vector, TrilinosWrappers::MPI::Vector, or corresponding blockvectors.

SolutionTransfer<dim, VectorType> soltrans(dof_handler);
                                  // flag some cells for refinement
                                  // and coarsening, e.g.
GridRefinement::refine_and_coarsen_fixed_fraction(
tria, error_indicators, 0.3, 0.05);
                                  // prepare the triangulation,
tria.prepare_coarsening_and_refinement();
                                  // prepare the SolutionTransfer object
                                  // for coarsening and refinement and give
                                  // the solution vector that we intend to
                                  // interpolate later,
soltrans.prepare_for_coarsening_and_refinement(solution);
                                  // actually execute the refinement,
tria.execute_coarsening_and_refinement ();
                                  // redistribute dofs,
dof_handler.distribute_dofs (fe);
                                  // and interpolate the solution
VectorType interpolated_solution;
//create VectorType in the right size here
soltrans.interpolate(interpolated_solution);

Use for Serialization

This class can be used to serialize and later deserialize a distributed mesh with solution vectors to a file. If you use more than one DoFHandler and therefore more than one SolutionTransfer object, they need to be serialized and deserialized in the same order.

If vector has the locally relevant DoFs, serialization works as follows: *

parallel::distributed::SolutionTransfer<dim,VectorType> sol_trans(dof_handler);
sol_trans.prepare_serialization (vector);
triangulation.save(filename);

For deserialization the vector needs to be a distributed vector (without ghost elements):

//[create coarse mesh...]
triangulation.load(filename);
parallel::distributed::SolutionTransfer<dim,VectorType> sol_trans(dof_handler);
sol_trans.deserialize (distributed_vector);

Interaction with hanging nodes

In essence, this class implements the same steps as does SolutionTransfer (though the implementation is entirely separate). Consequently, the same issue with hanging nodes and coarsening can happen with this class as happens with SolutionTransfer. See there for an extended discussion.

Author: Timo Heister, 2009-2011

Definition at line 116 of file solution_transfer.h.