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 <ryujin/base/compile_time_options.h>
#include <ryujin/base/mpi_ensemble.h>
#include <ryujin/base/observer_pointer.h>
#include <ryujin/interface/discretization.h>
#include <ryujin/interface/offline_data.h>
#include <ryujin/interface/parabolic_system.h>
#include <ryujin/interface/solution_transfer.h>
#include <ryujin/linear_algebra/state_vector.h>
 
#include <deal.II/base/parameter_acceptor.h>
 
#include <utility>
#include <vector>
 
namespace ryujin
{
  template <typename HyperbolicDescription, int dim, typename Number = double>
  class SolutionTransfer final : public Interface::SolutionTransfer<dim, Number>
  {
  public:
 
    using HyperbolicSystem = typename HyperbolicDescription::HyperbolicSystem;
 
    using View = typename HyperbolicSystem::template View<dim, Number>;
 
    using Limiter = typename HyperbolicDescription::template Limiter<Number>;
 
    using LimiterView =
        decltype(std::declval<const Limiter &>().template view<dim, Number>());
 
    static constexpr auto problem_dimension = View::problem_dimension;
 
    static constexpr auto n_precomputed_values = View::n_precomputed_values;
 
    using state_type = typename View::state_type;
 
    static constexpr unsigned int n_bounds = LimiterView::n_bounds;
 
    using Bounds = typename LimiterView::Bounds;
 
 
 
    SolutionTransfer(const MPIEnsemble &mpi_ensemble,
                     Interface::Discretization<dim> &discretization, /*mutable*/
                     const Interface::OfflineData<dim, Number> &offline_data,
                     const HyperbolicSystem &hyperbolic_system,
                     const Interface::ParabolicSystem &parabolic_system,
                     const std::string &subsection = "/SolutionTransfer");
 
    ~SolutionTransfer() override = default;
 
 
 
    void
    prepare_projection(const StateVector<Number> &old_state_vector) override;
 
    void project(StateVector<Number> &new_state_vector) override;
 
  private:
 
 
    Limiter limiter_;
 
 
 
    const MPIEnsemble &mpi_ensemble_;
 
    dealii::ObserverPointer<Interface::Discretization<dim>> discretization_;
    dealii::ObserverPointer<const Interface::OfflineData<dim, Number>>
        offline_data_;
    dealii::ObserverPointer<const HyperbolicSystem> hyperbolic_system_;
    dealii::ObserverPointer<const Interface::ParabolicSystem> parabolic_system_;
 
 
 
    state_type read_tensor(const MultiComponentVector<Number> &U,
                           const dealii::types::global_dof_index global_i);
 
    void add_tensor(MultiComponentVector<Number> &U,
                    const state_type &U_i,
                    const dealii::types::global_dof_index global_i);
 
  };
} // namespace ryujin