svk.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2025 The Ikarus Developers ikarus@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
// 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/utils/tensorutils.hh>
 
namespace Ikarus::Materials {
 
template <typename ST>
struct StVenantKirchhoffT : public Material<StVenantKirchhoffT<ST>>
{
  using ScalarType         = ST;
  static constexpr int dim = 3;
  using StrainMatrix       = Eigen::Matrix<ScalarType, dim, dim>;
  using StressMatrix       = StrainMatrix;
  using MaterialTensor     = Eigen::TensorFixedSize<ScalarType, Eigen::Sizes<dim, dim, dim, dim>>;
 
  using MaterialParameters = LamesFirstParameterAndShearModulus;
 
  static constexpr auto strainTag              = StrainTags::greenLagrangian;
  static constexpr auto stressTag              = StressTags::PK2;
  static constexpr auto tangentModuliTag       = TangentModuliTags::Material;
  static constexpr bool energyAcceptsVoigt     = true;
  static constexpr bool stressToVoigt          = true;
  static constexpr bool stressAcceptsVoigt     = true;
  static constexpr bool moduliToVoigt          = true;
  static constexpr bool moduliAcceptsVoigt     = true;
  static constexpr double derivativeFactorImpl = 1;
 
  [[nodiscard]] constexpr static std::string nameImpl() { return "StVenantKirchhoff"; }
 
  explicit StVenantKirchhoffT(const MaterialParameters& mpt)
      : materialParameter_{mpt} {}
 
  MaterialParameters materialParametersImpl() const { return materialParameter_; }
 
  template <typename Derived>
  ScalarType storedEnergyImpl(const Eigen::MatrixBase<Derived>& E) const {
    static_assert(Concepts::EigenMatrixOrVoigtNotation3<Derived>);
    if constexpr (Concepts::EigenVector<Derived>) {
      const ScalarType traceE = E.template segment<3>(0).sum();
      const ScalarType squaredNorm =
          E.template segment<3>(0).squaredNorm() + E.template segment<3>(3).squaredNorm() / ScalarType(2.0);
      return materialParameter_.lambda / ScalarType(2.0) * traceE * traceE + materialParameter_.mu * squaredNorm;
    } else {
      const auto traceE = E.trace();
      return materialParameter_.lambda / ScalarType(2.0) * traceE * traceE + materialParameter_.mu * E.squaredNorm();
    }
  }
 
  template <bool voigt, typename Derived>
  auto stressesImpl(const Eigen::MatrixBase<Derived>& E) const {
    static_assert(Concepts::EigenMatrixOrVoigtNotation3<decltype(E.eval())>);
    const auto& Ed = E.derived();
    if constexpr (!voigt) {
      if constexpr (Concepts::EigenVector<Derived>) {
        static_assert(Concepts::EigenVector6<Derived>);
        StressMatrix S;
        const ScalarType traceE = Ed.template segment<3>(0).sum();
        S.diagonal().array() =
            materialParameter_.lambda * traceE + 2 * materialParameter_.mu * Ed.template segment<3>(0).array();
        S(1, 2) = S(2, 1) = materialParameter_.mu * Ed(3);
        S(0, 2) = S(2, 0) = materialParameter_.mu * Ed(4);
        S(0, 1) = S(1, 0) = materialParameter_.mu * Ed(5); // no two since E voigt has 2* on off-diagonal terms
        return S;
      } else {
        static_assert(Concepts::EigenMatrix33<Derived>);
        return (materialParameter_.lambda * Ed.trace() * StrainMatrix::Identity() + 2 * materialParameter_.mu * Ed)
            .eval();
      }
    } else {
      if constexpr (Concepts::EigenVector<Derived>) {
        static_assert(Concepts::EigenVector6<Derived>);
        Eigen::Matrix<ScalarType, 6, 1> S;
        const ScalarType traceE          = Ed.template segment<3>(0).sum();
        S.template segment<3>(0).array() = traceE * materialParameter_.lambda;
        S.template segment<3>(0) += materialParameter_.mu * 2 * Ed.template segment<3>(0);
        S.template segment<3>(3) =
            materialParameter_.mu * Ed.template segment<3>(3); // no two since E voigt has 2* on off-diagonal terms
        return S;
      } else {
        Eigen::Matrix<ScalarType, 6, 1> S;
        S.template segment<3>(0).array() = Ed.trace() * materialParameter_.lambda;
        S.template segment<3>(0) += 2 * materialParameter_.mu * Ed.diagonal();
        S(3) = 2 * materialParameter_.mu * Ed(1, 2);
        S(4) = 2 * materialParameter_.mu * Ed(0, 2);
        S(5) = 2 * materialParameter_.mu * Ed(0, 1);
        return S;
      }
    }
  }
 
  template <bool voigt, typename Derived>
  auto tangentModuliImpl(const Eigen::MatrixBase<Derived>& /* E */) const {
    static_assert(Concepts::EigenMatrixOrVoigtNotation3<Derived>);
    if constexpr (!voigt) {
      MaterialTensor moduli;
      moduli = materialParameter_.lambda * identityFourthOrder() +
               2 * materialParameter_.mu * symmetricIdentityFourthOrder();
      return moduli;
    } else {
      Eigen::Matrix<ScalarType, 6, 6> moduli;
      moduli.setZero();
      moduli.template block<3, 3>(0, 0).array() = materialParameter_.lambda;
      moduli.template block<3, 3>(0, 0).diagonal().array() += 2 * materialParameter_.mu;
      moduli.template block<3, 3>(3, 3).diagonal().array() = materialParameter_.mu;
      return moduli;
    }
  }
 
  template <typename ScalarTypeOther>
  auto rebind() const {
    return StVenantKirchhoffT<ScalarTypeOther>(materialParameter_);
  }
 
  template <typename Derived>
  auto materialInversionImpl(const Eigen::MatrixBase<Derived>& Sraw) const {
    auto tangentModulus = tangentModuliImpl<true>(Eigen::Matrix3<ScalarType>::Zero());
    auto D              = tangentModulus.inverse().eval();
    auto S              = Impl::maybeToVoigt(Sraw, false);
    auto E              = (D * S).eval();
    return std::make_pair(D, E);
  }
 
private:
  MaterialParameters materialParameter_;
};
 
using StVenantKirchhoff = StVenantKirchhoffT<double>;
 
} // namespace Ikarus::Materials