solid_mechanics_with_internal_vars_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/state_variable_system.hpp"
 
namespace smith {
 
namespace detail {
 
template <typename MaterialType, typename AlphaType, typename AlphaDotType, typename DerivType, typename... ParamTypes>
auto evaluateCoupledInternalVariableMaterial(const MaterialType& material, const TimeInfo& t_info, AlphaType alpha,
                                             AlphaDotType alpha_dot, DerivType deriv_u, ParamTypes&&... params)
{
  if constexpr (requires { material(t_info, alpha, alpha_dot, deriv_u, std::forward<ParamTypes>(params)...); }) {
    return material(t_info, alpha, alpha_dot, deriv_u, std::forward<ParamTypes>(params)...);
  } else {
    return material(alpha, alpha_dot, deriv_u, std::forward<ParamTypes>(params)...);
  }
}
 
template <typename MaterialType, typename StateType, typename GradUType, typename GradVType, typename AlphaType,
          typename... ParamTypes>
auto evaluateSolidInternalVariableMaterial(const MaterialType& material, const TimeInfo& t_info, StateType& state,
                                           const GradUType& grad_u, const GradVType& grad_v, AlphaType alpha,
                                           ParamTypes&&... params)
{
  return material(t_info, state, grad_u, grad_v, alpha, std::forward<ParamTypes>(params)...);
}
 
template <typename MaterialType>
struct CoupledSolidInternalVariableMaterialAdapter {
  using State = typename MaterialType::State;
 
  MaterialType material;  
  double density;         
 
  template <typename StateType, typename GradUType, typename GradVType, typename AlphaType, typename AlphaDotType,
            typename... ParamTypes>
  auto operator()(const TimeInfo& t_info, StateType& state, GradUType grad_u, GradVType grad_v, AlphaType alpha,
                  AlphaDotType /*alpha_dot*/, ParamTypes&&... params) const
  {
    return evaluateSolidInternalVariableMaterial(material, t_info, state, grad_u, grad_v, get<VALUE>(alpha),
                                                 std::forward<ParamTypes>(params)...);
  }
};
 
}  // namespace detail
 
template <int dim, int disp_order, typename DispRule, typename SolidCoupling, typename StateSpace, typename StateRule,
          typename StateCoupling, typename MaterialType>
void setCoupledSolidMechanicsInternalVariableMaterial(
    std::shared_ptr<SolidMechanicsSystem<dim, disp_order, DispRule, SolidCoupling>> solid,
    std::shared_ptr<InternalVariableSystem<dim, StateSpace, StateRule, StateCoupling>> /*internal_variables*/,
    const MaterialType& material, const std::string& domain_name)
{
  auto solid_material = detail::CoupledSolidInternalVariableMaterialAdapter<MaterialType>{material, material.density};
 
  solid->setMaterial(solid_material, domain_name);
}
 
template <int dim, typename StateSpace, typename StateRule, typename StateCoupling, int disp_order, typename DispRule,
          typename SolidCoupling, typename MaterialType>
void setCoupledInternalVariableMaterial(
    std::shared_ptr<InternalVariableSystem<dim, StateSpace, StateRule, StateCoupling>> internal_variables,
    std::shared_ptr<SolidMechanicsSystem<dim, disp_order, DispRule, SolidCoupling>> /*solid*/,
    const MaterialType& material, const std::string& domain_name)
{
  internal_variables->addEvolution(
      domain_name, [=](auto t_info, auto alpha, auto alpha_dot, auto u, auto /*v*/, auto /*a*/, auto... params) {
        return detail::evaluateCoupledInternalVariableMaterial(material, t_info, alpha, alpha_dot, get<DERIVATIVE>(u),
                                                               params...);
      });
}
 
template <int dim, int disp_order, typename DispRule, typename SolidCoupling, typename StateSpace, typename StateRule,
          typename StateCoupling, typename MaterialType>
void setCoupledSolidMechanicsInternalVarsMaterial(
    std::shared_ptr<SolidMechanicsSystem<dim, disp_order, DispRule, SolidCoupling>> solid,
    std::shared_ptr<InternalVariableSystem<dim, StateSpace, StateRule, StateCoupling>> state,
    const MaterialType& material, const std::string& domain_name)
{
  setCoupledSolidMechanicsInternalVariableMaterial(solid, state, material, domain_name);
}
 
}  // namespace smith