solution_transfer.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 1999 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.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/observer_pointer.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>, int spacedim = dim>
class SolutionTransfer
{
public:
  SolutionTransfer(const DoFHandler<dim, spacedim> &dof_handler,
                   const bool                       average_values = false);
 
  ~SolutionTransfer() = default;
 
  void
  prepare_for_coarsening_and_refinement(
    const std::vector<const VectorType *> &all_in);
 
  void
  prepare_for_coarsening_and_refinement(const std::vector<VectorType> &all_in);
 
  void
  prepare_for_coarsening_and_refinement(const VectorType &in);
 
  void
  interpolate(std::vector<VectorType *> &all_out);
 
  void
  interpolate(std::vector<VectorType> &all_out);
 
  void
  interpolate(VectorType &out);
 
  void
  prepare_for_serialization(const VectorType &in);
 
  void
  prepare_for_serialization(const std::vector<const VectorType *> &all_in);
 
  void
  deserialize(VectorType &in);
 
 
  void
  deserialize(std::vector<VectorType *> &all_in);
 
  DEAL_II_DEPRECATED_EARLY void
  clear();
 
private:
  ObserverPointer<const DoFHandler<dim, spacedim>,
                  SolutionTransfer<dim, VectorType, spacedim>>
    dof_handler;
 
  const bool average_values;
 
  std::vector<const VectorType *> input_vectors;
 
  unsigned int handle;
 
  std::vector<char>
  pack_callback(
    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
    const CellStatus                                            status);
 
  void
  unpack_callback(
    const typename Triangulation<dim, spacedim>::cell_iterator     &cell,
    const CellStatus                                                status,
    const boost::iterator_range<std::vector<char>::const_iterator> &data_range,
    std::vector<VectorType *>                                      &all_out,
    VectorType                                                     &valence);
 
 
  void
  register_data_attach();
};
 
 
 
namespace Legacy
{
  template <int dim, typename VectorType = Vector<double>, int spacedim = dim>
  class SolutionTransfer
  {
  public:
    SolutionTransfer(const DoFHandler<dim, spacedim> &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:
    ObserverPointer<const DoFHandler<dim, spacedim>,
                    SolutionTransfer<dim, VectorType, spacedim>>
      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
 
DEAL_II_NAMESPACE_CLOSE
 
#endif