state_views_multi_species.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/state_views_mixins.hpp>
#include <meltpooldg/species_transport/effective_material_mixin.hpp>
#include <meltpooldg/species_transport/state_views_mixins.hpp>
 
namespace MeltPoolDG::CompressibleFlow
{
  template <int dim, int n_species, IsConservedStateCompatible<dim> StateType>
  struct MultiSpeciesDofValueView
    : public DofValueMixin<dim,
                           typename StateType::value_type,
                           MultiSpeciesDofValueView<dim, n_species, StateType>>,
      public SpeciesTransport::DofValueMixin<n_conserved_variables<dim>,
                                             n_species,
                                             StateType,
                                             MultiSpeciesDofValueView<dim, n_species, StateType>>
  {
    using state_type = std::remove_cvref_t<StateType>;
 
    MultiSpeciesDofValueView(StateType &state)
      : flow_state(&state)
    {}
 
    operator MultiSpeciesDofValueView<dim, n_species, const StateType>()
    {
      return MultiSpeciesDofValueView<dim, n_species, const StateType>(*flow_state);
    }
 
    StateType &
    value() const
    {
      return *flow_state;
    }
 
  private:
    mutable StateType *flow_state;
  };
 
  template <int dim, int n_species, typename number, IsConservedStateCompatible<dim> Value>
  struct MultiSpeciesDofStateView
    : public Flow::EOSValueMixin<dim,
                                 typename Value::value_type,
                                 MultiSpeciesDofStateView<dim, n_species, number, Value>>,
      public DofValueMixin<dim,
                           typename Value::value_type,
                           MultiSpeciesDofStateView<dim, n_species, number, Value>>,
      public SpeciesTransport::DofValueMixin<
        n_conserved_variables<dim>,
        n_species,
        Value,
        MultiSpeciesDofStateView<dim, n_species, number, Value>>,
      public MultiSpeciesMaterialMixin<n_species,
                                       number,
                                       typename Value::value_type,
                                       MultiSpeciesDofStateView<dim, n_species, number, Value>>,
      public SpeciesTransport::DerivedPartialValueMixin<
        n_species,
        Value,
        MultiSpeciesDofStateView<dim, n_species, number, Value>>
  {
    using state_type = std::remove_cvref_t<Value>;
 
    // Only ideal gas is supported for multi-species flow
    static constexpr std::array<EquationOfState, 1> supported_eos = {{EquationOfState::ideal_gas}};
 
    MultiSpeciesDofStateView(Value &value_state, const MaterialPhaseData<number> &material_data)
      : flow_state(&value_state)
      , material_data(material_data)
    {}
 
    operator MultiSpeciesDofStateView<dim, n_species, number, const Value>()
    {
      return MultiSpeciesDofStateView<dim, n_species, 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,
            int n_species,
            typename number,
            IsConservedStateCompatible<dim>    Value,
            IsConservedGradientCompatible<dim> Gradient>
  struct MultiSpeciesDofValueAndGradientStateView
    : public DofValueMixin<
        dim,
        typename Value::value_type,
        MultiSpeciesDofValueAndGradientStateView<dim, n_species, number, Value, Gradient>>,
      public DofGradientMixin<
        dim,
        typename Gradient::value_type::value_type,
        MultiSpeciesDofValueAndGradientStateView<dim, n_species, number, Value, Gradient>>,
      public SpeciesTransport::DofValueMixin<
        n_conserved_variables<dim>,
        n_species,
        Value,
        MultiSpeciesDofValueAndGradientStateView<dim, n_species, number, Value, Gradient>>,
      public SpeciesTransport::GradientValueMixin<
        n_conserved_variables<dim>,
        n_species,
        Value,
        Gradient,
        MultiSpeciesDofValueAndGradientStateView<dim, n_species, number, Value, Gradient>>,
      public Flow::EOSValueMixin<
        dim,
        typename Value::value_type,
        MultiSpeciesDofValueAndGradientStateView<dim, n_species, number, Value, Gradient>>,
      public Flow::EOSGradientMixin<
        dim,
        MultiSpeciesDofValueAndGradientStateView<dim, n_species, number, Value, Gradient>>,
      public MultiSpeciesMaterialMixin<
        n_species,
        number,
        typename Value::value_type,
        MultiSpeciesDofValueAndGradientStateView<dim, n_species, number, Value, Gradient>>,
      public SpeciesTransport::DerivedPartialValueMixin<
        n_species,
        Value,
        MultiSpeciesDofValueAndGradientStateView<dim, n_species, number, Value, Gradient>>
  {
    using state_type    = std::remove_cvref_t<Value>;
    using gradient_type = std::remove_cvref_t<Gradient>;
 
    // Only ideal gas is supported for multi-species flow
    static constexpr std::array<EquationOfState, 1> supported_eos = {{EquationOfState::ideal_gas}};
 
    MultiSpeciesDofValueAndGradientStateView(Value                           &value_state,
                                             Gradient                        &gradient_state,
                                             const MaterialPhaseData<number> &material_data)
      : flow_state(&value_state)
      , flow_gradient_state(&gradient_state)
      , material_data(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:
    Value                           *flow_state;
    Gradient                        *flow_gradient_state;
    const MaterialPhaseData<number> &material_data;
  };
 
  template <int dim, int n_species, typename FluxTypeIn>
  struct MultiSpeciesFluxView
    : public FluxMixin<dim, MultiSpeciesFluxView<dim, n_species, FluxTypeIn>>,
      public SpeciesTransport::FluxMixin<n_conserved_variables<dim>,
                                         n_species,
                                         MultiSpeciesFluxView<dim, n_species, FluxTypeIn>>
  {
    using FluxType = FluxTypeIn;
 
    explicit MultiSpeciesFluxView(FluxType &flux_in)
      : flux(&flux_in)
    {}
 
    operator MultiSpeciesFluxView<dim, n_species, const FluxType>()
    {
      return MultiSpeciesFluxView<dim, n_species, const FluxType>(*flux);
    }
 
    FluxType &
    value() const
    {
      return *flux;
    }
 
  private:
    mutable FluxType *flux;
  };
} // namespace MeltPoolDG::CompressibleFlow