gent.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 <ikarus/finiteelements/mechanics/materials/hyperelastic/deviatoric/deviatoricinvariants.hh>
#include <ikarus/finiteelements/mechanics/materials/materialhelpers.hh>
#include <ikarus/finiteelements/mechanics/materials/tags.hh>
#include <ikarus/utils/tensorutils.hh>
 
namespace Ikarus {
 
struct GentMatParameters
{
  double mu; 
  double Jm; 
};
} // namespace Ikarus
 
namespace Ikarus::Materials {
 
template <typename ST_>
struct GentT
{
  static constexpr int dim = 3;
  using ScalarType         = ST_;
 
  template <typename ST = ScalarType>
  using PrincipalStretches = Eigen::Vector<ST, 3>;
 
  template <typename ST = ScalarType>
  using Invariants = PrincipalStretches<ST>;
 
  template <typename ST = ScalarType>
  using FirstDerivative = Eigen::Vector<ST, dim>;
  template <typename ST = ScalarType>
  using SecondDerivative = Eigen::Matrix<ST, dim, dim>;
 
  using MaterialParameters = GentMatParameters;
 
  static constexpr auto stretchTag = PrincipalStretchTags::deviatoric;
 
  [[nodiscard]] constexpr static std::string name() noexcept { return "Gent"; }
 
  explicit GentT(const MaterialParameters& matPar)
      : matPar_{matPar} {}
 
  MaterialParameters materialParametersImpl() const { return matPar_; }
 
  template <typename ST = ScalarType>
  ST storedEnergyImpl(const PrincipalStretches<ST>& lambda) const {
    const Invariants<ST>& invariants = Impl::invariants(lambda);
    const auto& devInvariants        = DeviatoricInvariants<PrincipalStretches<ST>>(lambda);
    const auto W1                    = devInvariants.value()[0];
    checkJm(W1);
    return -(matPar_.mu / 2.0) * matPar_.Jm * log(1.0 - ((W1 - 3.0) / matPar_.Jm));
  }
 
  template <typename ST = ScalarType>
  FirstDerivative<ST> firstDerivativeImpl(const PrincipalStretches<ST>& lambda) const {
    const Invariants<ST>& invariants = Impl::invariants(lambda);
    const auto& devInvariants        = DeviatoricInvariants<PrincipalStretches<ST>>(lambda);
    const auto W1                    = devInvariants.value()[0];
    const auto& dW1dLambda           = devInvariants.firstDerivative().first;
    const auto mu                    = matPar_.mu;
    const auto Jm                    = matPar_.Jm;
    checkJm(W1);
 
    FirstDerivative<ST> dWdLambda = (mu * dW1dLambda * Jm) / (2.0 * (Jm - W1) + 6.0);
 
    return dWdLambda;
  }
 
  template <typename ST = ScalarType>
  SecondDerivative<ST> secondDerivativeImpl(const PrincipalStretches<ST>& lambda) const {
    const Invariants<ST>& invariants = Impl::invariants(lambda);
    auto dS                          = SecondDerivative<ST>::Zero().eval();
 
    const auto& devInvariants = DeviatoricInvariants<PrincipalStretches<ST>>(lambda);
    const auto W1             = devInvariants.value()[0];
    const auto& dW1dLambda    = devInvariants.firstDerivative().first;
    const auto& ddW1dLambda   = devInvariants.secondDerivative().first;
    const auto mu             = matPar_.mu;
    const auto Jm             = matPar_.Jm;
    checkJm(W1);
 
    for (const auto i : dimensionRange())
      for (const auto j : dimensionRange()) {
        auto factor1 = 1.0 - ((W1 - 3.0) / Jm);
        dS(i, j) += (mu / (2.0 * factor1)) * (ddW1dLambda(i, j) + (dW1dLambda[i] * dW1dLambda[j] / (factor1 * Jm)));
        if (i == j)
          dS(i, j) -= (mu / (2.0 * lambda[i] * factor1)) * dW1dLambda[i];
      }
 
    return dS;
  }
 
  template <typename STO>
  auto rebind() const {
    return GentT<STO>(matPar_);
  }
 
private:
  MaterialParameters matPar_;
 
  inline static constexpr auto dimensionRange() { return Dune::range(dim); }
 
  void checkJm(ScalarType W1) const {
    if (Dune::FloatCmp::le(matPar_.Jm, static_cast<double>(W1) - 3.0, 1e-14))
      DUNE_THROW(Dune::InvalidStateException, "The material parameter Jm should be greater than (W1 - 3)");
  }
};
 
using Gent = GentT<double>;
 
} // namespace Ikarus::Materials