state_views_mixins.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/exception_macros.h>
#include <deal.II/base/exceptions.h>
 
#include <meltpooldg/utilities/concepts.hpp>
 
#include <optional>
#include <type_traits>
 
namespace MeltPoolDG::SpeciesTransport
{
  template <int n_start_index, int n_species, typename ValueType, typename Derived>
  struct DofValueMixin
  {
    using value_type = std::conditional_t<std::is_const_v<std::remove_reference_t<ValueType>>,
                                          std::add_const_t<typename ValueType::value_type>,
                                          typename ValueType::value_type>;
 
 
    value_type &
    partial_density(const unsigned species_component) const
    {
      AssertIndexRange(species_component, n_species);
      if (species_component < n_species - 1)
        {
          return value()[n_start_index + species_component];
        }
      else
        return last_species_partial_density();
    }
 
    typename ValueType::value_type
    mass_fraction(const unsigned species_component) const
    {
      AssertIndexRange(species_component, n_species);
      if (species_component < n_species - 1)
        return value()[n_start_index + species_component] / derived().density();
      else
        return last_species_mass_fraction();
    }
 
  private:
    ValueType &
    value() const
    {
      return static_cast<const Derived &>(*this).value();
    }
 
    const Derived &
    derived() const
    {
      return static_cast<const Derived &>(*this);
    }
 
    typename ValueType::value_type
    last_species_mass_fraction() const
    {
      if (last_species_cache.mass_fraction.has_value())
        return last_species_cache.mass_fraction.value();
      else
        {
          last_species_cache.mass_fraction = typename ValueType::value_type(1.);
          for (unsigned int i = 0; i < n_species - 1; ++i)
            {
              last_species_cache.mass_fraction.value() -= mass_fraction(i);
            }
          return last_species_cache.mass_fraction.value();
        }
    }
 
    value_type &
    last_species_partial_density() const
    {
      if (last_species_cache.partial_density.has_value())
        return last_species_cache.partial_density.value();
      else
        {
          last_species_cache.partial_density = derived().density() * last_species_mass_fraction();
          return last_species_cache.partial_density.value();
        }
    }
 
    struct
    {
      mutable std::optional<typename ValueType::value_type> mass_fraction;
      mutable std::optional<typename ValueType::value_type> partial_density;
    } last_species_cache;
  };
 
  template <int n_species, typename ValueType, typename Derived>
  struct DerivedPartialValueMixin
  {
    using value_type = std::conditional_t<std::is_const_v<std::remove_reference_t<ValueType>>,
                                          std::add_const_t<typename ValueType::value_type>,
                                          typename ValueType::value_type>;
 
    typename ValueType::value_type
    partial_pressure(const unsigned species_component) const
    {
      return derived().mole_fraction(species_component) * derived().pressure();
    }
 
    typename ValueType::value_type
    partial_inner_energy(const unsigned species_component) const
    {
      return derived().specific_inner_energy() * derived().mass_fraction(species_component);
    }
 
  private:
    ValueType &
    value() const
    {
      return static_cast<const Derived &>(*this).value();
    }
 
    const Derived &
    derived() const
    {
      return static_cast<const Derived &>(*this);
    }
  };
 
  template <int n_start_index,
            int n_species,
            typename ValueType,
            typename GradientType,
            typename Derived>
  struct GradientValueMixin
  {
    using value_type = std::conditional_t<std::is_const_v<std::remove_reference_t<ValueType>>,
                                          std::add_const_t<typename ValueType::value_type>,
                                          typename ValueType::value_type>;
 
    using gradient_type = std::conditional_t<std::is_const_v<std::remove_reference_t<GradientType>>,
                                             std::add_const_t<typename GradientType::value_type>,
                                             typename GradientType::value_type>;
 
    gradient_type &
    grad_partial_density(const unsigned species_component) const
    {
      AssertIndexRange(species_component, n_species);
      if (species_component < n_species - 1)
        return gradient_value()[n_start_index + species_component];
      else
        return last_species_grad_partial_density();
    }
 
    typename GradientType::value_type
    grad_mass_fraction(const unsigned species_component) const
    {
      AssertIndexRange(species_component, n_species);
 
      if (species_component < n_species - 1)
        return (gradient_value()[n_start_index + species_component] -
                derived().grad_density() * derived().mass_fraction(species_component)) /
               derived().density();
      else
        return last_species_grad_mass_fraction();
    }
 
  private:
    ValueType &
    value() const
    {
      return static_cast<const Derived &>(*this).value();
    }
 
    GradientType &
    gradient_value() const
    {
      return static_cast<const Derived &>(*this).gradient_value();
    }
 
    const Derived &
    derived() const
    {
      return static_cast<const Derived &>(*this);
    }
 
    gradient_type &
    last_species_grad_mass_fraction() const
    {
      if (last_species_cache.mass_fraction.has_value())
        return last_species_cache.mass_fraction.value();
      else
        {
          last_species_cache.mass_fraction = typename GradientType::value_type();
          for (unsigned int i = 0; i < n_species - 1; ++i)
            {
              last_species_cache.mass_fraction.value() -= grad_mass_fraction(i);
            }
          return last_species_cache.mass_fraction.value();
        }
    }
 
    typename GradientType::value_type &
    last_species_grad_partial_density() const
    {
      if (last_species_cache.partial_density.has_value())
        return last_species_cache.partial_density.value();
      else
        {
          last_species_cache.partial_density =
            derived().grad_density() * derived().mass_fraction(n_species - 1) +
            derived().density() * derived().grad_mass_fraction(n_species - 1);
          return last_species_cache.partial_density.value();
        }
    }
 
    struct
    {
      mutable std::optional<typename GradientType::value_type> mass_fraction;
      mutable std::optional<typename GradientType::value_type> partial_density;
    } last_species_cache;
  };
 
  template <int n_start_index, int n_species, typename Derived>
  struct FluxMixin
  {
    decltype(auto)
    partial_density_flux(const unsigned species_component) const
    {
      AssertIndexRange(species_component, n_species - 1);
      return get_value()[n_start_index + species_component];
    }
 
  private:
    decltype(auto)
    get_value() const
    {
      return static_cast<const Derived &>(*this).value();
    }
  };
} // namespace MeltPoolDG::SpeciesTransport