finiteelements/mechanics/materials/hyperelastic/deviatoric/interface.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2025 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <dune/common/float_cmp.hh>
 
#include <ikarus/finiteelements/mechanics/materials/hyperelastic/concepts.hh>
#include <ikarus/utils/tensorutils.hh>
 
namespace Ikarus::Materials {
 
template <Concepts::DeviatoricFunction DF>
struct Deviatoric
{
  using ScalarType = typename DF::ScalarType;
 
  template <typename ST = ScalarType>
  using PrincipalStretches = typename DF::template PrincipalStretches<ST>;
  using MaterialParameters = typename DF::MaterialParameters;
 
  using DeviatoricFunction = DF;
 
  template <typename ST = ScalarType>
  using FirstDerivative = typename DF::template FirstDerivative<ST>;
  template <typename ST = ScalarType>
  using SecondDerivative = typename DF::template SecondDerivative<ST>;
 
  static constexpr int dim = 3;
 
  template <typename ST = ScalarType>
  using StressMatrix = Eigen::Vector<ST, dim>;
 
  template <typename ST = ScalarType>
  using MaterialTensor = Eigen::TensorFixedSize<ST, Eigen::Sizes<dim, dim, dim, dim>>;
 
  [[nodiscard]] constexpr static std::string name() noexcept { return "Deviatoric function: " + DF::name(); }
 
  Deviatoric(const DF df)
      : deviatoricFunction_{df} {}
 
  const MaterialParameters materialParameters() const { return deviatoricFunction_.materialParametersImpl(); }
 
  template <typename ST>
  ST storedEnergy(const PrincipalStretches<ST>& lambda) const {
    return deviatoricFunction_.storedEnergyImpl(lambda);
  };
 
  template <typename ST>
  StressMatrix<ST> stresses(const PrincipalStretches<ST>& lambda) const {
    auto dWdLambda = deviatoricFunction_.firstDerivativeImpl(lambda);
    return (dWdLambda.array() / lambda.array()).eval();
  }
 
  template <typename ST>
  MaterialTensor<ST> tangentModuli(const PrincipalStretches<ST>& lambda) const {
    auto S  = stresses(lambda);
    auto dS = deviatoricFunction_.secondDerivativeImpl(lambda);
 
    auto L = MaterialTensor<ST>{};
    L.setZero();
 
    for (const auto i : dimensionRange())
      for (const auto k : dimensionRange())
        L(i, i, k, k) = 1.0 / (lambda(i) * lambda(k)) * dS(i, k);
 
    Eigen::ArrayXd lambdaSquared = lambda.array().square();
    for (const auto i : dimensionRange())
      for (const auto k : dimensionRange())
        if (i != k) {
          if (Dune::FloatCmp::eq(lambda(i), lambda(k), 1e-8))
            L(i, k, i, k) = 0.5 * (L(i, i, i, i) - L(i, i, k, k));
          else
            L(i, k, i, k) += (S(i) - S(k)) / (lambdaSquared(i) - lambdaSquared(k));
        }
 
    return L;
  };
 
  template <typename STO>
  auto rebind() const {
    auto reboundDF = deviatoricFunction_.template rebind<STO>();
    return Deviatoric<decltype(reboundDF)>{reboundDF};
  }
 
private:
  DF deviatoricFunction_;
 
  inline static constexpr auto dimensionRange() { return Dune::range(dim); }
};
} // namespace Ikarus::Materials