blatzko.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/interface.hh>
#include <ikarus/finiteelements/mechanics/materials/materialhelpers.hh>
#include <ikarus/finiteelements/mechanics/materials/tags.hh>
#include <ikarus/utils/tensorutils.hh>
 
namespace Ikarus::Materials {
 
template <typename ST_>
struct BlatzKoT
{
  using ScalarType = ST_;
 
  template <typename ST = ScalarType>
  using PrincipalStretches = Eigen::Vector<ST, 3>;
 
  static constexpr int dim         = 3;
  static constexpr auto stretchTag = PrincipalStretchTags::total;
 
  template <typename ST = ScalarType>
  using FirstDerivative = Eigen::Vector<ST, dim>;
  template <typename ST = ScalarType>
  using SecondDerivative = Eigen::Matrix<ST, dim, dim>;
 
  using MaterialParameters = double;
 
  [[nodiscard]] constexpr static std::string name() noexcept { return "BlatzKo"; }
 
  explicit BlatzKoT(MaterialParameters mu)
      : mu_{mu} {}
 
  MaterialParameters materialParametersImpl() const { return mu_; }
 
  template <typename ST>
  ST storedEnergyImpl(const PrincipalStretches<ST>& lambda) const {
    return mu_ / 2 * (lambda.cwiseInverse().squaredNorm() + 2 * lambda.prod() - 5);
  }
 
  template <typename ST>
  FirstDerivative<ST> firstDerivativeImpl(const PrincipalStretches<ST>& lambda) const {
    auto dWdLambda = FirstDerivative<ST>::Zero().eval();
    const ST J     = Impl::determinantFromPrincipalValues(lambda);
 
    return mu_ * (-lambda.cwisePow(3).cwiseInverse() + (J * lambda.cwiseInverse()));
  }
 
  template <typename ST>
  SecondDerivative<ST> secondDerivativeImpl(const PrincipalStretches<ST>& lambda) const {
    auto dS    = SecondDerivative<ST>::Zero().eval();
    const ST J = Impl::determinantFromPrincipalValues(lambda);
 
    auto lam      = lambda.array();
    dS            = J / (lambda * lambda.transpose()).array();
    dS.diagonal() = lam.square().inverse() * (lam.square().inverse() - J) + (3.0 / lam.pow(4));
    dS.array() *= mu_;
 
    return dS;
  }
 
  template <typename STO>
  auto rebind() const {
    return BlatzKoT<STO>(mu_);
  }
 
private:
  MaterialParameters mu_;
 
  inline static constexpr auto dimensionRange() { return Dune::range(dim); }
};
 
using BlatzKo = BlatzKoT<double>;
 
} // namespace Ikarus::Materials