thermo_mechanics_system.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/differentiable_numerics/solid_mechanics_system.hpp"
#include "smith/differentiable_numerics/thermal_system.hpp"
 
namespace smith {
 
namespace detail {
 
template <typename MaterialType, typename StateType, typename GradUType, typename GradVType, typename ThetaType,
          typename GradThetaType, typename... ParamTypes>
auto evaluateCoupledThermoMechanicsMaterial(const MaterialType& material, const TimeInfo& t_info, StateType& state,
                                            const GradUType& grad_u, const GradVType& grad_v, ThetaType theta,
                                            const GradThetaType& grad_theta, ParamTypes&&... params)
{
  return material(t_info, state, grad_u, grad_v, theta, grad_theta, std::forward<ParamTypes>(params)...);
}
 
template <typename MaterialType>
struct CoupledSolidThermoMechanicsMaterialAdapter {
  using State = typename MaterialType::State;
 
  MaterialType material;  
  double density;         
 
  template <typename StateType, typename GradUType, typename GradVType, typename TemperatureType,
            typename TemperatureDotType, typename... ParamTypes>
  auto operator()(const TimeInfo& t_info, StateType& state, GradUType grad_u, GradVType grad_v,
                  TemperatureType temperature, TemperatureDotType /*temperature_dot*/, ParamTypes&&... params) const
  {
    auto [pk, C_v, s0, q0] =
        evaluateCoupledThermoMechanicsMaterial(material, t_info, state, grad_u, grad_v, get<VALUE>(temperature),
                                               get<DERIVATIVE>(temperature), std::forward<ParamTypes>(params)...);
    return pk;
  }
};
 
}  // namespace detail
 
template <int dim, int disp_order_, int temp_order_, typename DispRule, typename TempRule, typename SolidCoupling,
          typename ThermalCoupling, typename MaterialType>
void setCoupledThermoMechanicsMaterial(
    std::shared_ptr<SolidMechanicsSystem<dim, disp_order_, DispRule, SolidCoupling>> solid,
    std::shared_ptr<ThermalSystem<dim, temp_order_, TempRule, ThermalCoupling>> thermal, const MaterialType& material,
    const std::string& domain_name)
{
  auto solid_material = detail::CoupledSolidThermoMechanicsMaterialAdapter<MaterialType>{material, material.density};
 
  solid->setMaterial(solid_material, domain_name);
 
  thermal->setMaterialAndHeatSource(
      [=](const TimeInfo& t_info, auto temperature, auto grad_temperature, auto u, auto v, auto /*a*/, auto... params) {
        typename MaterialType::State state{};
        auto [pk, C_v, s0, q0] = detail::evaluateCoupledThermoMechanicsMaterial(
            material, t_info, state, get<DERIVATIVE>(u), get<DERIVATIVE>(v), temperature, grad_temperature, params...);
        // Material's s0 sits on the LHS (residual = C_v*T_dot + s0 - q·∇v); negate to fit the
        // physical-heat-source convention used by setMaterialAndHeatSource.
        return smith::tuple{C_v, q0, -s0};
      },
      domain_name);
}
 
}  // namespace smith