state_views.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/tensor.h>
#include <deal.II/base/vectorization.h>
 
#include <meltpooldg/compressible_flow/data_types.hpp>
#include <meltpooldg/compressible_flow/equation_of_state.hpp>
#include <meltpooldg/compressible_flow/material.hpp>
#include <meltpooldg/compressible_flow/material_views_mixins.hpp>
#include <meltpooldg/compressible_flow/operation_data.hpp>
#include <meltpooldg/compressible_flow/state_views_mixins.hpp>
 
#include <type_traits>
 
namespace MeltPoolDG::CompressibleFlow
{
  template <int dim, typename number>
  struct MaterialView : public MaterialMixin<MaterialView<dim, number>>
  {
    using state_type = std::any;
 
    MaterialView(const MaterialPhaseData<number> &material_data)
      : material_data(material_data)
    {}
 
    const MaterialPhaseData<number> &
    material() const
    {
      return material_data;
    }
 
  private:
    const MaterialPhaseData<number> &material_data;
  };
 
  template <int dim, IsConservedStateCompatible<dim> StateType>
  struct DofValueView
    : public DofValueMixin<dim, typename StateType::value_type, DofValueView<dim, StateType>>
  {
    using state_type = std::remove_cvref_t<StateType>;
 
    DofValueView(StateType &state)
      : flow_state(&state)
    {}
 
    operator DofValueView<dim, const StateType>()
    {
      return DofValueView<dim, const StateType>(*flow_state);
    }
 
    StateType &
    value() const
    {
      return *flow_state;
    }
 
  private:
    mutable StateType *flow_state;
  };
 
  template <int dim, IsConservedGradientCompatible<dim> StateType>
  struct DofGradientView : public DofGradientMixin<dim,
                                                   typename StateType::value_type::value_type,
                                                   DofGradientView<dim, StateType>>
  {
    DofGradientView(StateType &state)
      : flow_state(&state)
    {}
 
    operator DofGradientView<dim, const StateType>()
    {
      return DofGradientView<dim, const StateType>(*flow_state);
    }
 
    StateType &
    gradient_value() const
    {
      return *flow_state;
    }
 
  private:
    mutable StateType *flow_state;
  };
 
  template <int dim, typename number, IsConservedStateCompatible<dim> Value>
  struct DofStateView
    : public Flow::EOSValueMixin<dim, typename Value::value_type, DofStateView<dim, number, Value>>,
      public DofValueMixin<dim, typename Value::value_type, DofStateView<dim, number, Value>>,
      public MaterialMixin<DofStateView<dim, number, Value>>
  {
    using state_type = std::remove_cvref_t<Value>;
 
    DofStateView(Value &value_state, const MaterialPhaseData<number> &material_data)
      : flow_state(&value_state)
      , material_data(material_data)
    {}
 
    operator DofStateView<dim, number, const Value>()
    {
      return DofStateView<dim, number, const Value>(*flow_state, material_data);
    }
 
    EquationOfState
    eos_type() const
    {
      return material_data.eos_type;
    }
 
    Value &
    value() const
    {
      return *flow_state;
    }
 
    const MaterialPhaseData<number> &
    material() const
    {
      return material_data;
    }
 
  private:
    mutable Value                   *flow_state;
    const MaterialPhaseData<number> &material_data;
  };
 
  template <int dim,
            typename number,
            IsConservedStateCompatible<dim>    Value,
            IsConservedGradientCompatible<dim> Gradient>
  struct DofValueAndGradientStateView
    : public DofValueMixin<dim,
                           typename Value::value_type,
                           DofValueAndGradientStateView<dim, number, Value, Gradient>>,
      public DofGradientMixin<dim,
                              typename Gradient::value_type::value_type,
                              DofValueAndGradientStateView<dim, number, Value, Gradient>>,
      public Flow::EOSValueMixin<dim,
                                 typename Value::value_type,
                                 DofValueAndGradientStateView<dim, number, Value, Gradient>>,
      public Flow::EOSGradientMixin<dim,
                                    DofValueAndGradientStateView<dim, number, Value, Gradient>>,
      public MaterialMixin<DofValueAndGradientStateView<dim, number, Value, Gradient>>
  {
    using state_type    = std::remove_cvref_t<Value>;
    using gradient_type = std::remove_cvref_t<Gradient>;
 
    DofValueAndGradientStateView(Value                           &value_state,
                                 Gradient                        &gradient_state,
                                 const MaterialPhaseData<number> &material_data)
      : flow_state(&value_state)
      , flow_gradient_state(&gradient_state)
      , material_data(material_data)
    {}
 
    operator DofValueAndGradientStateView<dim, number, const Value, const Gradient>()
    {
      return DofValueAndGradientStateView<dim, number, const Value, const Gradient>(
        *flow_state, *flow_gradient_state, material_data);
    }
 
    Value &
    value() const
    {
      return *flow_state;
    }
 
    Gradient &
    gradient_value() const
    {
      return *flow_gradient_state;
    }
 
    EquationOfState
    eos_type() const
    {
      return material_data.eos_type;
    }
 
    const MaterialPhaseData<number> &
    material() const
    {
      return material_data;
    }
 
  private:
    mutable Value                   *flow_state;
    mutable Gradient                *flow_gradient_state;
    const MaterialPhaseData<number> &material_data;
  };
 
  template <int dim, typename FluxType>
  struct FluxView : public FluxMixin<dim, FluxView<dim, FluxType>>
  {
    explicit FluxView(FluxType &flux_in)
      : flux(&flux_in)
    {}
 
    operator FluxView<dim, const FluxType>()
    {
      return FluxView<dim, const FluxType>(*flux);
    }
 
    FluxType &
    value() const
    {
      return *flux;
    }
 
  private:
    mutable FluxType *flux;
  };
} // namespace MeltPoolDG::CompressibleFlow