thermal_material.hpp

Go to the documentation of this file.

// Copyright (c) Lawrence Livermore National Security, LLC and
// other Smith Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include "smith/numerics/functional/functional.hpp"
 
namespace smith::heat_transfer {
 
struct LinearIsotropicConductor {
  LinearIsotropicConductor(double density = 1.0, double specific_heat_capacity = 1.0, double conductivity = 1.0)
      : density_(density), specific_heat_capacity_(specific_heat_capacity), conductivity_(conductivity)
  {
    SLIC_ERROR_ROOT_IF(conductivity_ < 0.0,
                       "Conductivity must be positive in the linear isotropic conductor material model.");
 
    SLIC_ERROR_ROOT_IF(density_ < 0.0, "Density must be positive in the linear isotropic conductor material model.");
 
    SLIC_ERROR_ROOT_IF(specific_heat_capacity_ < 0.0,
                       "Specific heat capacity must be positive in the linear isotropic conductor material model.");
  }
 
  template <typename T1, typename T2, typename T3>
  SMITH_HOST_DEVICE auto operator()(const T1& /* x */, const T2& /* temperature */,
                                    const T3& temperature_gradient) const
  {
    return smith::tuple{density_ * specific_heat_capacity_, -1.0 * conductivity_ * temperature_gradient};
  }
 
 private:
  double density_;
 
  double specific_heat_capacity_;
 
  double conductivity_;
};
 
struct IsotropicConductorWithLinearConductivityVsTemperature {
  IsotropicConductorWithLinearConductivityVsTemperature(double density = 1.0, double specific_heat_capacity = 1.0,
                                                        double reference_conductivity = 1.0,
                                                        double d_conductivity_d_temperature = 0.0)
      : density_(density),
        specific_heat_capacity_(specific_heat_capacity),
        reference_conductivity_(reference_conductivity),
        d_conductivity_d_temperature_(d_conductivity_d_temperature)
  {
    SLIC_ERROR_ROOT_IF(density_ < 0.0, "Density must be positive in the linear isotropic conductor material model.");
    SLIC_ERROR_ROOT_IF(specific_heat_capacity_ < 0.0,
                       "Specific heat capacity must be positive in the linear isotropic conductor material model.");
  }
 
  template <typename T1, typename T2, typename T3>
  SMITH_HOST_DEVICE auto operator()(const T1& /* x */, const T2& temperature, const T3& temperature_gradient) const
  {
    const auto currentConductivity = reference_conductivity_ + d_conductivity_d_temperature_ * temperature;
#if defined(SMITH_USE_CUDA) || defined(SMITH_USE_HIP)
    assert(smith::get_value(currentConductivity) >= 0.0);
#else
    SLIC_ERROR_ROOT_IF(
        smith::get_value(currentConductivity) < 0.0,
        "Conductivity in the IsotropicConductorWithLinearConductivityVsTemperature model has gone negative.");
#endif
    return smith::tuple{density_ * specific_heat_capacity_, -1.0 * currentConductivity * temperature_gradient};
  }
 
 private:
  double density_;
 
  double specific_heat_capacity_;
 
  double reference_conductivity_;
 
  double d_conductivity_d_temperature_;
};
 
template <int dim>
struct LinearConductor {
  LinearConductor(double density = 1.0, double specific_heat_capacity = 1.0,
                  tensor<double, dim, dim> conductivity = Identity<dim>())
      : density_(density), specific_heat_capacity_(specific_heat_capacity), conductivity_(conductivity)
  {
    SLIC_ERROR_ROOT_IF(density_ < 0.0, "Density must be positive in the linear conductor material model.");
 
    SLIC_ERROR_ROOT_IF(specific_heat_capacity_ < 0.0,
                       "Specific heat capacity must be positive in the linear conductor material model.");
 
    SLIC_ERROR_ROOT_IF(!is_symmetric_and_positive_definite(conductivity_),
                       "Conductivity tensor must be symmetric and positive definite.");
  }
 
  template <typename T1, typename T2, typename T3>
  SMITH_HOST_DEVICE auto operator()(const T1& /* x */, const T2& /* temperature */,
                                    const T3& temperature_gradient) const
  {
    return smith::tuple{density_ * specific_heat_capacity_, -1.0 * conductivity_ * temperature_gradient};
  }
 
 private:
  double density_;
 
  double specific_heat_capacity_;
 
  tensor<double, dim, dim> conductivity_;
};
 
struct ConstantSource {
  double source_ = 0.0;
 
  template <typename T1, typename T2, typename T3>
  SMITH_HOST_DEVICE auto operator()(const T1& /* x */, const double /* time */, const T2& /* temperature */,
                                    const T3& /* temperature_gradient */) const
  {
    return source_;
  }
};
 
struct ConstantFlux {
  double flux_ = 0.0;
 
  template <typename T1, typename T2, typename T3>
  SMITH_HOST_DEVICE auto operator()(const T1& /* x */, const T2& /* normal */, const double /* time */,
                                    const T3& /* temperature */) const
  {
    return flux_;
  }
};
 
}  // namespace smith::heat_transfer