solution_transfer.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2018 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_solution_transfer_h
#define dealii_solution_transfer_h


/*----------------------------   solutiontransfer.h     ----------------------*/


#include <deal.II/base/config.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/lac/vector.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/dofs/dof_handler.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;
};


DEAL_II_NAMESPACE_CLOSE


/*----------------------------   solutiontransfer.h     ---------------------------*/
#endif
/*----------------------------   solutiontransfer.h     ---------------------------*/