material.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/vectorization.h>
 
#include <meltpooldg/core/material_data.hpp>
#include <meltpooldg/heat/apparent_capacity.hpp>
#include <meltpooldg/utilities/fe_integrator.hpp>
 
#include <vector>
 
namespace MeltPoolDG
{
  template <typename value_type, typename number>
  struct MaterialParameterValues
  {
    MaterialParameterValues(const number thermal_conductivity_in                = 0.0,
                            const number specific_heat_capacity_in              = 0.0,
                            const number density_in                             = 0.0,
                            const number dynamic_viscosity_in                   = 0.0,
                            const number volume_specific_heat_capacity_in       = 0.0,
                            const number d_thermal_conductivity_d_T_in          = 0.0,
                            const number d_specific_heat_capacity_d_T_in        = 0.0,
                            const number d_density_d_T_in                       = 0.0,
                            const number d_volume_specific_heat_capacity_d_T_in = 0.0,
                            const number gas_fraction_in                        = 0.0,
                            const number liquid_fraction_in                     = 0.0,
                            const number solid_fraction_in                      = 0.0);
 
    template <typename material_phase_data_struct>
    MaterialParameterValues(const material_phase_data_struct &data);
 
    value_type thermal_conductivity;
    value_type specific_heat_capacity;
    value_type density;
    value_type dynamic_viscosity;
    value_type volume_specific_heat_capacity;
    value_type d_thermal_conductivity_d_T;
    value_type d_specific_heat_capacity_d_T;
    value_type d_density_d_T;
    value_type d_volume_specific_heat_capacity_d_T;
    value_type gas_fraction;
    value_type liquid_fraction;
    value_type solid_fraction;
  };
 
  enum class MaterialTypes
  {
    gas,
    liquid,
    gas_liquid,
    gas_liquid_consistent_with_evaporation,
    liquid_solid,
    gas_liquid_solid,
    gas_liquid_solid_consistent_with_evaporation
  };
 
  MaterialTypes
  determine_material_type(const bool do_two_phase,
                          const bool do_solidification,
                          const bool do_evaporation);
 
  namespace MaterialUpdateFlags
  {
    enum MaterialUpdateFlags
    {
      none                                = 0,
      thermal_conductivity                = 1 << 0,
      specific_heat_capacity              = 1 << 1,
      density                             = 1 << 2,
      dynamic_viscosity                   = 1 << 3,
      volume_specific_heat_capacity       = 1 << 4,
      d_thermal_conductivity_d_T          = 1 << 5,
      d_specific_heat_capacity_d_T        = 1 << 6,
      d_density_d_T                       = 1 << 7,
      d_volume_specific_heat_capacity_d_T = 1 << 8,
      phase_fractions                     = 1 << 9
    };
 
    inline MaterialUpdateFlags
    operator|(const MaterialUpdateFlags f1, const MaterialUpdateFlags f2);
 
    inline MaterialUpdateFlags &
    operator|=(MaterialUpdateFlags &f1, const MaterialUpdateFlags f2);
 
 
    inline MaterialUpdateFlags
    operator&(const MaterialUpdateFlags f1, const MaterialUpdateFlags f2);
 
    inline MaterialUpdateFlags &
    operator&=(MaterialUpdateFlags &f1, const MaterialUpdateFlags f2);
 
  } // namespace MaterialUpdateFlags
 
  template <typename number>
  class Material
  {
  public:
    enum FieldType
    {
      none,
      temperature,
      level_set
    };
 
    Material(const MaterialData<number> &material_data, const MaterialTypes material_type);
 
    const MaterialData<number> &
    get_data() const;
 
    template <typename value_type>
    inline MaterialParameterValues<value_type, number>
    compute_parameters(const MaterialUpdateFlags::MaterialUpdateFlags &flags) const;
 
    template <typename value_type>
    inline MaterialParameterValues<value_type, number>
    compute_parameters(const value_type                               &v,
                       const MaterialUpdateFlags::MaterialUpdateFlags &flags) const;
 
    template <typename value_type>
    inline MaterialParameterValues<value_type, number>
    compute_parameters(const value_type                               &level_set_heaviside,
                       const value_type                               &temperature,
                       const MaterialUpdateFlags::MaterialUpdateFlags &flags) const;
 
    template <typename value_type, int dim>
    inline MaterialParameterValues<value_type, number>
    compute_parameters(const FECellIntegrator<dim, 1, number>         &level_set_heaviside_val,
                       const FECellIntegrator<dim, 1, number>         &temperature_val,
                       const MaterialUpdateFlags::MaterialUpdateFlags &flags,
                       const unsigned int                              q_index) const;
 
    template <typename value_type, int dim>
    inline MaterialParameterValues<value_type, number>
    compute_parameters(const FECellIntegrator<dim, 1, number>              &level_set_heaviside_val,
                       const std::vector<FECellIntegrator<dim, 1, number>> &temperature_val,
                       const MaterialUpdateFlags::MaterialUpdateFlags      &flags,
                       const unsigned int                                   q_index) const;
 
    bool
    has_dependency(const FieldType &field_type) const;
 
  private:
    template <typename value_type>
    inline MaterialParameterValues<value_type, number>
    compute_parameters_internal(const value_type                               &v1,
                                const value_type                               &v2,
                                const MaterialUpdateFlags::MaterialUpdateFlags &flags) const;
 
    template <typename value_type>
    inline value_type
    compute_two_phase_fluid_property(const value_type &level_set_heaviside,
                                     const value_type &gas_value,
                                     const value_type &liquid_solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_two_phase_fluid_density_consistent_with_evaporation(
      const value_type &level_set_heaviside,
      const value_type &gas_density,
      const value_type &liquid_solid_density) const;
 
    template <typename value_type>
    inline value_type
    compute_solid_liquid_phases_property(const value_type &temperature_dependent_solid_fraction,
                                         const value_type &liquid_value,
                                         const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_temperature_derivative_of_solid_liquid_phases_property(
      const value_type &temperature_dependent_solid_fraction,
      const value_type &liquid_value,
      const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_solid_liquid_gas_phases_property(const value_type &level_set_heaviside,
                                             const value_type &temperature_dependent_solid_fraction,
                                             const value_type &gas_value,
                                             const value_type &liquid_value,
                                             const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_solid_liquid_gas_phases_density_consistent_with_evaporation(
      const value_type &level_set_heaviside,
      const value_type &temperature_dependent_solid_fraction,
      const value_type &gas_value,
      const value_type &liquid_value,
      const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_temperature_derivative_of_solid_liquid_gas_property(
      const value_type &level_set_heaviside,
      const value_type &temperature_dependent_solid_fraction,
      const value_type &liquid_value,
      const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_solid_liquid_phases_specific_heat_capacity(
      const value_type &temperature_dependent_solid_fraction,
      const value_type &liquid_value,
      const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_solid_liquid_gas_phases_specific_heat_capacity(
      const value_type &level_set_heaviside,
      const value_type &temperature_dependent_solid_fraction,
      const value_type &gas_value,
      const value_type &liquid_value,
      const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_temperature_derivative_of_solid_liquid_specific_heat_capacity(
      const value_type &temperature_dependent_solid_fraction,
      const value_type &liquid_value,
      const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_temperature_derivative_of_solid_liquid_gas_specific_heat_capacity(
      const value_type &level_set_heaviside,
      const value_type &temperature_dependent_solid_fraction,
      const value_type &liquid_value,
      const value_type &solid_value) const;
 
    template <typename value_type>
    inline value_type
    compute_temperature_derivative_of_solid_liquid_gas_density_consistent_with_evaporation(
      const value_type &level_set_heaviside,
      const value_type &temperature_dependent_solid_fraction,
      const value_type &gas_value,
      const value_type &liquid_value,
      const value_type &solid_value) const;
 
    inline number
    compute_temperature_dependent_solid_fraction(const number temperature) const;
 
    inline dealii::VectorizedArray<number>
    compute_temperature_dependent_solid_fraction(
      const dealii::VectorizedArray<number> &temperature) const;
 
    struct MaterialParameterValuesContainer
    {
      template <typename material_phase_data_struct>
      MaterialParameterValuesContainer(const material_phase_data_struct data);
 
      const MaterialParameterValues<number, number>                          scalar_parameters;
      const MaterialParameterValues<dealii::VectorizedArray<number>, number> vectorized_parameters;
 
      constexpr operator const MaterialParameterValues<number, number> &() const;
 
      constexpr
      operator const MaterialParameterValues<dealii::VectorizedArray<number>, number> &() const;
    };
 
    const MaterialData<number> &data;
 
    MaterialParameterValuesContainer gas;
    MaterialParameterValuesContainer liquid;
    MaterialParameterValuesContainer solid;
 
    const MaterialTypes material_type;
 
    const number inv_mushy_interval;
 
    std::unique_ptr<Heat::ApparentCapacity<number>> apparent_capacity = nullptr;
  };
 
 
  /*----------------- Template constructors -----------------*/
 
 
  template <typename value_type, typename number>
  MaterialParameterValues<value_type, number>::MaterialParameterValues(
    const number thermal_conductivity_in,
    const number specific_heat_capacity_in,
    const number density_in,
    const number dynamic_viscosity_in,
    const number volume_specific_heat_capacity_in,
    const number d_thermal_conductivity_d_T_in,
    const number d_specific_heat_capacity_d_T_in,
    const number d_density_d_T_in,
    const number d_volume_specific_heat_capacity_d_T_in,
    const number gas_fraction_in,
    const number liquid_fraction_in,
    const number solid_fraction_in)
    : thermal_conductivity(thermal_conductivity_in)
    , specific_heat_capacity(specific_heat_capacity_in)
    , density(density_in)
    , dynamic_viscosity(dynamic_viscosity_in)
    , volume_specific_heat_capacity(volume_specific_heat_capacity_in)
    , d_thermal_conductivity_d_T(d_thermal_conductivity_d_T_in)
    , d_specific_heat_capacity_d_T(d_specific_heat_capacity_d_T_in)
    , d_density_d_T(d_density_d_T_in)
    , d_volume_specific_heat_capacity_d_T(d_volume_specific_heat_capacity_d_T_in)
    , gas_fraction(gas_fraction_in)
    , liquid_fraction(liquid_fraction_in)
    , solid_fraction(solid_fraction_in)
  {}
 
 
 
  template <typename value_type, typename number>
  template <typename material_phase_data_struct>
  MaterialParameterValues<value_type, number>::MaterialParameterValues(
    const material_phase_data_struct &data)
    : thermal_conductivity(data.thermal_conductivity)
    , specific_heat_capacity(data.specific_heat_capacity)
    , density(data.density)
    , dynamic_viscosity(data.dynamic_viscosity)
    , volume_specific_heat_capacity(data.density * data.specific_heat_capacity)
    , d_thermal_conductivity_d_T(0.0)
    , d_specific_heat_capacity_d_T(0.0)
    , d_density_d_T(0.0)
    , d_volume_specific_heat_capacity_d_T(0.0)
    , gas_fraction(1.0)
    , liquid_fraction(0.0)
    , solid_fraction(0.0)
  {}
 
 
 
  template <typename number>
  Material<number>::Material(const MaterialData<number> &material_data,
                             const MaterialTypes         material_type)
    : data(material_data)
    , gas(data.gas)
    , liquid(data.liquid)
    , solid(data.solid)
    , material_type(material_type)
    , inv_mushy_interval(material_type == MaterialTypes::liquid_solid ||
                             material_type == MaterialTypes::gas_liquid_solid ||
                             material_type ==
                               MaterialTypes::gas_liquid_solid_consistent_with_evaporation ?
                           1.0 / (data.liquidus_temperature - data.solidus_temperature) :
                           0.0)
  {
    if (material_data.latent_heat_of_fusion > 0)
      apparent_capacity = std::make_unique<Heat::ApparentCapacity<number>>(material_data);
  }
 
 
 
  template <typename number>
  template <typename material_phase_data_struct>
  Material<number>::MaterialParameterValuesContainer::MaterialParameterValuesContainer(
    const material_phase_data_struct data)
    : scalar_parameters(data)
    , vectorized_parameters(data)
  {}
} // namespace MeltPoolDG