materialconversions.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2026 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
#include "tags.hh"
 
#include <Eigen/Core>
 
#include <ikarus/finiteelements/mechanics/materials/materialhelpers.hh>
#include <ikarus/utils/tensorutils.hh>
 
namespace Ikarus {
 
template <TangentModuliTags tag, typename Derived, typename ST>
Eigen::TensorFixedSize<ST, Eigen::Sizes<3, 3, 3, 3>> createTwoPointMaterialTensor(
    const Eigen::TensorFixedSize<ST, Eigen::Sizes<3, 3, 3, 3>>& C, const Eigen::MatrixBase<Derived>& sPK2,
    const Eigen::MatrixBase<Derived>& F) {
  static_assert(Concepts::EigenMatrix33<Derived>);
  if constexpr (tag == TangentModuliTags::Material) {
    const auto& S                    = sPK2.derived();
    const Eigen::Matrix<ST, 3, 3> Id = Eigen::Matrix<ST, 3, 3>::Identity();
    constexpr int dim                = 3;
    Eigen::TensorFixedSize<ST, Eigen::Sizes<dim, dim, dim, dim>> A;
    A.setZero();
    for (const auto i : Dune::range(dim))
      for (const auto J : Dune::range(dim))
        for (const auto k : Dune::range(dim))
          for (const auto L : Dune::range(dim)) {
            A(i, J, k, L) += Id(i, k) * S(J, L);
            for (const auto I : Dune::range(dim))
              for (const auto K : Dune::range(dim))
                A(i, J, k, L) += C(I, J, K, L) * F(i, I) * F(k, K);
          }
    return A;
  } else if constexpr (tag == TangentModuliTags::TwoPoint) {
    return C;
  } else if constexpr (tag == TangentModuliTags::Spatial) {
    static_assert(Dune::AlwaysFalse<ST>::value,
                  "Transformation from spatial to two-point material tensor is not implemented.");
  }
}
 
template <TangentModuliTags from, TangentModuliTags to, typename DerivedS, typename DerivedF, typename ST>
auto transformTangentModuli(const Eigen::TensorFixedSize<ST, Eigen::Sizes<3, 3, 3, 3>>& C,
                            const Eigen::MatrixBase<DerivedS>& sRaw, const Eigen::MatrixBase<DerivedF>& F) {
  static_assert(Concepts::EigenMatrix33<DerivedF>);
 
  const auto S = Impl::maybeFromVoigt(sRaw.derived(), false);
 
  if constexpr (from == to)
    return C;
  else if constexpr (to == TangentModuliTags::TwoPoint)
    return createTwoPointMaterialTensor<from>(C, S, F);
  else
    static_assert(Dune::AlwaysFalse<ST>::value, "Transformation only to two-point material tensor is implemented.");
}
} // namespace Ikarus