solution_transfer.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2020 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_solution_transfer_h
#  define dealii_solution_transfer_h
 
 
/*----------------------------   solutiontransfer.h     ----------------------*/
 
 
#  include <deal.II/base/config.h>
 
#  include <deal.II/base/exceptions.h>
#  include <deal.II/base/smartpointer.h>
 
#  include <deal.II/dofs/dof_handler.h>
 
#  include <deal.II/lac/vector.h>
 
#  include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
template <int dim,
          typename VectorType     = Vector<double>,
          typename DoFHandlerType = DoFHandler<dim>>
class SolutionTransfer
{
#  ifndef DEAL_II_MSVC
  static_assert(dim == DoFHandlerType::dimension,
                "The dimension explicitly provided as a template "
                "argument, and the dimension of the DoFHandlerType "
                "template argument must match.");
#  endif
public:
  SolutionTransfer(const DoFHandlerType &dof);
 
  ~SolutionTransfer();
 
  void
  clear();
 
  void
  prepare_for_pure_refinement();
 
  void
  prepare_for_coarsening_and_refinement(const std::vector<VectorType> &all_in);
 
  void
  prepare_for_coarsening_and_refinement(const VectorType &in);
 
  void
  refine_interpolate(const VectorType &in, VectorType &out) const;
 
  void
  interpolate(const std::vector<VectorType> &all_in,
              std::vector<VectorType> &      all_out) const;
 
  void
  interpolate(const VectorType &in, VectorType &out) const;
 
  std::size_t
  memory_consumption() const;
 
  DeclExceptionMsg(ExcNotPrepared,
                   "You are attempting an operation for which this object is "
                   "not prepared. This may be because you either did not call "
                   "one of the prepare_*() functions at all, or because you "
                   "called the wrong one for the operation you are currently "
                   "attempting.");
 
  DeclExceptionMsg(
    ExcAlreadyPrepForRef,
    "You are attempting to call one of the prepare_*() functions "
    "of this object to prepare it for an operation for which it "
    "is already prepared. Specifically, the object was "
    "previously prepared for pure refinement.");
 
  DeclExceptionMsg(
    ExcAlreadyPrepForCoarseAndRef,
    "You are attempting to call one of the prepare_*() functions "
    "of this object to prepare it for an operation for which it "
    "is already prepared. Specifically, the object was "
    "previously prepared for both coarsening and refinement.");
 
private:
  SmartPointer<const DoFHandlerType,
               SolutionTransfer<dim, VectorType, DoFHandlerType>>
    dof_handler;
 
  types::global_dof_index n_dofs_old;
 
  enum PreparationState
  {
    none,
    pure_refinement,
    coarsening_and_refinement
  };
 
  PreparationState prepared_for;
 
 
  std::vector<std::vector<types::global_dof_index>> indices_on_cell;
 
  struct Pointerstruct
  {
    Pointerstruct()
      : indices_ptr(nullptr)
      , dof_values_ptr(nullptr)
      , active_fe_index(0)
    {}
    Pointerstruct(std::vector<types::global_dof_index> *indices_ptr_in,
                  const unsigned int                    active_fe_index_in = 0)
      : indices_ptr(indices_ptr_in)
      , dof_values_ptr(nullptr)
      , active_fe_index(active_fe_index_in)
    {}
    Pointerstruct(
      std::vector<Vector<typename VectorType::value_type>> *dof_values_ptr_in,
      const unsigned int active_fe_index_in = 0)
      : indices_ptr(nullptr)
      , dof_values_ptr(dof_values_ptr_in)
      , active_fe_index(active_fe_index_in)
    {}
    std::size_t
    memory_consumption() const;
 
    std::vector<types::global_dof_index> *                indices_ptr;
    std::vector<Vector<typename VectorType::value_type>> *dof_values_ptr;
    unsigned int                                          active_fe_index;
  };
 
  std::map<std::pair<unsigned int, unsigned int>, Pointerstruct> cell_map;
 
  std::vector<std::vector<Vector<typename VectorType::value_type>>>
    dof_values_on_cell;
};
 
namespace Legacy
{
  template <int dim,
            typename VectorType     = Vector<double>,
            typename DoFHandlerType = DoFHandler<dim>>
  using SolutionTransfer =
    ::SolutionTransfer<dim, VectorType, DoFHandlerType>;
} // namespace Legacy
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // dealii_solutiontransfer_h
/*---------------------------- solutiontransfer.h ---------------------------*/