data.hh

Go to the documentation of this file.

#pragma once
 
// external libraries
#include <deal.II/base/function.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/vector.h>
#include <deal.II/numerics/vector_tools.h>
 
// DiFfRG
#include <DiFfRG/common/utils.hh>
#include <DiFfRG/discretization/common/abstract_data.hh>
 
namespace DiFfRG
{
  using namespace dealii;
 
  namespace internal
  {
    template <uint dim, typename NumberType> class FunctionFromLambda : public Function<dim, NumberType>
    {
      using FUN = std::function<void(const Point<dim> &, Vector<NumberType> &)>;
 
    public:
      FunctionFromLambda(FUN &&fun_, uint components) : Function<dim, NumberType>(components), fun(std::move(fun_)) {}
      virtual void vector_value(const Point<dim> &p, Vector<NumberType> &values) const override { fun(p, values); }
 
    private:
      FUN fun;
    };
  } // namespace internal
 
  template <typename NT = double> class FlowingVariables : public AbstractFlowingVariables<NT>
  {
  public:
    using NumberType = NT;
 
    FlowingVariables() {}
 
    template <typename Model> void interpolate(const Model &model)
    {
      std::vector<uint> block_structure{0};
      block_structure.push_back(Model::Components::count_variables());
      m_data = (block_structure);
      if (m_data.n_blocks() > 1) model.initial_condition_variables(m_data.block(1));
    }
 
    virtual BlockVector<NumberType> &data() override { return m_data; }
    virtual const BlockVector<NumberType> &data() const override { return m_data; }
 
    virtual Vector<NumberType> &spatial_data() override { return m_data.block(0); }
    virtual const Vector<NumberType> &spatial_data() const override { return m_data.block(0); }
 
    virtual Vector<NumberType> &variable_data() override { return m_data.block(1); }
    virtual const Vector<NumberType> &variable_data() const override { return m_data.block(1); }
 
  private:
    BlockVector<NumberType> m_data;
  };
 
  namespace FE
  {
    template <typename Discretization>
    class FlowingVariables : public AbstractFlowingVariables<typename Discretization::NumberType>
    {
    public:
      using NumberType = typename Discretization::NumberType;
      using Components = typename Discretization::Components;
      static constexpr uint dim = Discretization::dim;
 
      FlowingVariables(const Discretization &discretization)
          : discretization(discretization), dof_handler(discretization.get_dof_handler())
      {
      }
 
      template <typename Model> void interpolate(const Model &model)
      {
        auto block_structure = discretization.get_block_structure();
        m_data = (block_structure);
 
        if constexpr (Model::Components::count_fe_functions() > 0) {
          auto interpolating_function = [&model](const auto &p, auto &values) { model.initial_condition(p, values); };
          internal::FunctionFromLambda<dim, NumberType> initial_condition_function(std::move(interpolating_function),
                                                                                   dof_handler.get_fe().n_components());
          VectorTools::interpolate(dof_handler, initial_condition_function, m_data.block(0));
        }
        if (m_data.n_blocks() > 1) model.initial_condition_variables(m_data.block(1));
      }
 
      virtual BlockVector<NumberType> &data() override { return m_data; }
      virtual const BlockVector<NumberType> &data() const override { return m_data; }
 
      virtual Vector<NumberType> &spatial_data() override { return m_data.block(0); }
      virtual const Vector<NumberType> &spatial_data() const override { return m_data.block(0); }
 
      virtual Vector<NumberType> &variable_data() override { return m_data.block(1); }
      virtual const Vector<NumberType> &variable_data() const override { return m_data.block(1); }
 
    private:
      const Discretization &discretization;
      const DoFHandler<dim> &dof_handler;
      BlockVector<NumberType> m_data;
    };
  } // namespace FE
 
  namespace FV
  {
    template <typename Discretization>
    using FlowingVariables = DiFfRG::FE::FlowingVariables<Discretization>;
  } // namespace FV
 
} // namespace DiFfRG