solution_transfer.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception or LGPL-2.1-or-later
// Copyright (C) 2020 - 2026 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.h>
 
#include "mpi_ensemble.h"
#include "observer_pointer.h"
#include "offline_data.h"
#include "state_vector.h"
 
#include <deal.II/base/parameter_acceptor.h>
 
namespace ryujin
{
  template <typename Description, int dim, typename Number = double>
  class SolutionTransfer final : public dealii::ParameterAcceptor
  {
  public:
 
    using HyperbolicSystem = typename Description::HyperbolicSystem;
    using ParabolicSystem = typename Description::ParabolicSystem;
 
    using View = typename HyperbolicSystem::template View<dim, Number>;
 
    using Limiter = typename Description::template Limiter<Number>;
 
    using LimiterView = typename Limiter::template View<dim, Number>;
 
    static constexpr auto problem_dimension = View::problem_dimension;
 
    using state_type = typename View::state_type;
 
    static constexpr unsigned int n_bounds = LimiterView::n_bounds;
 
    using Bounds = typename LimiterView::Bounds;
 
    using StateVector = typename View::StateVector;
    using HyperbolicVector = typename View::HyperbolicVector;
 
 
 
    SolutionTransfer(const MPIEnsemble &mpi_ensemble,
                     const OfflineData<dim, Number> &offline_data,
                     const HyperbolicSystem &hyperbolic_system,
                     const ParabolicSystem &parabolic_system,
                     const std::string &subsection = "/SolutionTransfer");
 
    ~SolutionTransfer() override = default;
 
 
 
    void prepare_projection(const StateVector &old_state_vector);
 
    void project(StateVector &new_state_vector);
 
 
 
    unsigned int get_handle() const
    {
      Assert(
          handle_ != dealii::numbers::invalid_unsigned_int,
          dealii::ExcMessage("Invalid handle: Cannot retrieve a valid "
                             "handle. get_handle() can only be called after a "
                             "call to prepare_projection(), or set_handle()."));
      return handle_;
    }
 
    void set_handle(unsigned int handle)
    {
      Assert(
          handle_ == dealii::numbers::invalid_unsigned_int,
          dealii::ExcMessage("Invalid state: Cannot set handle because we "
                             "already have a valid handle due to a prior call "
                             "to prepare_projection(), or set_handle()."));
      handle_ = handle;
    }
 
    void reset_handle()
    {
      handle_ = dealii::numbers::invalid_unsigned_int;
    }
 
  private:
 
 
    Limiter limiter_;
 
 
 
    const MPIEnsemble &mpi_ensemble_;
 
    dealii::ObserverPointer<const OfflineData<dim, Number>> offline_data_;
    dealii::ObserverPointer<const HyperbolicSystem> hyperbolic_system_;
    dealii::ObserverPointer<const ParabolicSystem> parabolic_system_;
 
    unsigned int handle_;
 
 
 
    state_type read_tensor(const HyperbolicVector &U,
                           const dealii::types::global_dof_index global_i);
 
    void add_tensor(HyperbolicVector &U,
                    const state_type &U_i,
                    const dealii::types::global_dof_index global_i);
 
  };
} // namespace ryujin