Reference documentation for deal.II version Git 2a81969 2017-11-21 09:22:35 +0100
Public Member Functions | Private Member Functions | Private Attributes | List of all members
parallel::distributed::SolutionTransfer< dim, VectorType, DoFHandlerType > Class Template Reference

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

Public Member Functions

 SolutionTransfer (const DoFHandlerType &dof)
 
 ~SolutionTransfer ()=default
 
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.

// flag some cells for refinement
// and coarsening, e.g.
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: *

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);
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 118 of file solution_transfer.h.

Constructor & Destructor Documentation

template<int dim, typename VectorType , typename DoFHandlerType >
SolutionTransfer< dim, VectorType, DoFHandlerType >::SolutionTransfer ( const DoFHandlerType &  dof)

Constructor, takes the current DoFHandler as argument.

Definition at line 47 of file solution_transfer.cc.

template<int dim, typename VectorType, typename DoFHandlerType = DoFHandler<dim>>
parallel::distributed::SolutionTransfer< dim, VectorType, DoFHandlerType >::~SolutionTransfer ( )
default

Destructor.

Member Function Documentation

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::prepare_for_coarsening_and_refinement ( const std::vector< const VectorType * > &  all_in)

Prepares the SolutionTransfer for coarsening and refinement. It stores the dof indices of each cell and stores the dof values of the vectors in all_in in each cell that'll be coarsened. all_in includes all vectors that are to be interpolated onto the new (refined and/or coarsened) grid.

Definition at line 62 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::prepare_for_coarsening_and_refinement ( const VectorType &  in)

Same as previous function but for only one discrete function to be interpolated.

Definition at line 99 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::interpolate ( std::vector< VectorType * > &  all_out)

Interpolate the data previously stored in this object before the mesh was refined or coarsened onto the current set of cells. Do so for each of the vectors provided to prepare_for_coarsening_and_refinement() and write the result into the given set of vectors.

Definition at line 152 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::interpolate ( VectorType &  out)

Same as the previous function. It interpolates only one function. It assumes the vectors having the right sizes (i.e. in.size()==n_dofs_old, out.size()==n_dofs_refined)

Multiple calling of this function is NOT allowed. Interpolating several functions can be performed in one step by using interpolate (all_in, all_out)

Definition at line 186 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
unsigned int SolutionTransfer< dim, VectorType, DoFHandlerType >::get_data_size ( ) const

Return the size in bytes that need to be stored per cell.

Definition at line 196 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::prepare_serialization ( const VectorType &  in)

Prepare the serialization of the given vector. The serialization is done by Triangulation::save(). The given vector needs all information on the locally active DoFs (it must be ghosted). See documentation of this class for more information.

Definition at line 109 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::prepare_serialization ( const std::vector< const VectorType * > &  all_in)

Same as the function above, only for a list of vectors.

Definition at line 120 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::deserialize ( VectorType &  in)

Execute the deserialization of the given vector. This needs to be done after calling Triangulation::load(). The given vector must be a fully distributed vector without ghost elements. See documentation of this class for more information.

Definition at line 129 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::deserialize ( std::vector< VectorType * > &  all_in)

Same as the function above, only for a list of vectors.

Definition at line 139 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::pack_callback ( const typename Triangulation< dim, DoFHandlerType::space_dimension >::cell_iterator &  cell,
const typename Triangulation< dim, DoFHandlerType::space_dimension >::CellStatus  status,
void *  data 
)
private

A callback function used to pack the data on the current mesh into objects that can later be retrieved after refinement, coarsening and repartitioning.

Definition at line 205 of file solution_transfer.cc.

template<int dim, typename VectorType , typename DoFHandlerType >
void SolutionTransfer< dim, VectorType, DoFHandlerType >::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

A callback function used to unpack the data on the current mesh that has been packed up previously on the mesh before refinement, coarsening and repartitioning.

Definition at line 229 of file solution_transfer.cc.

Member Data Documentation

template<int dim, typename VectorType, typename DoFHandlerType = DoFHandler<dim>>
SmartPointer<const DoFHandlerType,SolutionTransfer<dim,VectorType,DoFHandlerType> > parallel::distributed::SolutionTransfer< dim, VectorType, DoFHandlerType >::dof_handler
private

Pointer to the degree of freedom handler to work with.

Definition at line 211 of file solution_transfer.h.

template<int dim, typename VectorType, typename DoFHandlerType = DoFHandler<dim>>
std::vector<const VectorType *> parallel::distributed::SolutionTransfer< dim, VectorType, DoFHandlerType >::input_vectors
private

A vector that stores pointers to all the vectors we are supposed to copy over from the old to the new mesh.

Definition at line 217 of file solution_transfer.h.

template<int dim, typename VectorType, typename DoFHandlerType = DoFHandler<dim>>
unsigned int parallel::distributed::SolutionTransfer< dim, VectorType, DoFHandlerType >::offset
private

The offset that the Triangulation has assigned to this object starting at which we are allowed to write.

Definition at line 223 of file solution_transfer.h.


The documentation for this class was generated from the following files: