interface.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2024 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <ikarus/finiteelements/mechanics/materials/strainconversions.hh>
#include <ikarus/finiteelements/mechanics/materials/tags.hh>
#include <ikarus/finiteelements/physicshelper.hh>
#include <ikarus/utils/concepts.hh>
#include <ikarus/utils/linearalgebrahelper.hh>
#include <ikarus/utils/traits.hh>
 
namespace Ikarus {
 
#ifndef DOXYGEN
  template <class MaterialImpl>
  struct Material;
 
  template <auto stressIndexPair, typename MaterialImpl>
  struct VanishingStress;
#endif
 
  template <typename Material, typename Strains>
  consteval bool hasCorrectSize() {
    if constexpr (Concepts::EigenVector6<Strains> or Concepts::EigenMatrix33<Strains>) return true;
    if constexpr (Material::isReduced and Concepts::EigenVector<Strains>) {
      return Strains::RowsAtCompileTime == Material::freeStrains;
    } else
      return false;
  }
 
  template <typename Material, typename Strains>
  concept CorrectStrainSize = hasCorrectSize<Material, Strains>();
 
  template <class MaterialImpl>
  struct Material {
    using MaterialImplType = MaterialImpl;  
 
    static constexpr bool isReduced = traits::isSpecializationNonTypeAndTypes<VanishingStress, MaterialImpl>::value;
 
    constexpr const MaterialImpl& impl() const { return static_cast<MaterialImpl const&>(*this); }
 
    constexpr MaterialImpl& impl() { return static_cast<MaterialImpl&>(*this); }
 
    [[nodiscard]] constexpr std::string name() const { return impl().nameImpl(); }
 
    template <StrainTags tag, typename Derived>
    requires CorrectStrainSize<MaterialImpl, Derived>
    [[nodiscard]] auto storedEnergy(const Eigen::MatrixBase<Derived>& Eraw) const {
      decltype(auto) Ev = enlargeIfReduced<Material>(Eraw);
      decltype(auto) E  = transformStrain<tag, MaterialImpl::strainTag>(Ev);
 
      if constexpr (Concepts::EigenVector<Derived>) {  // receiving vector means voigt notation
        if constexpr (MaterialImpl::energyAcceptsVoigt)
          return impl().storedEnergyImpl(toVoigt(E));
        else
          return impl().storedEnergyImpl(E);
      } else
        return impl().storedEnergyImpl(E);
    }
 
    template <StrainTags tag, bool voigt = true, typename Derived>
    requires CorrectStrainSize<MaterialImpl, Derived>
    [[nodiscard]] auto stresses(const Eigen::MatrixBase<Derived>& Eraw) const {
      decltype(auto) Ev = enlargeIfReduced<Material>(Eraw);
      decltype(auto) E  = transformStrain<tag, MaterialImpl::strainTag>(Ev);
      if constexpr (voigt and MaterialImpl::stressToVoigt == false)
        // user requests a Voigt shaped return but material is not able to. Therefore, we transform it here.
        return toVoigt(stressesMaybeTransformInputToVoigt<false>(E), false);
      else
        return stressesMaybeTransformInputToVoigt<voigt>(E);
    }
 
    template <StrainTags tag, bool voigt = true, typename Derived>
    requires CorrectStrainSize<MaterialImpl, Derived>
    [[nodiscard]] auto tangentModuli(const Eigen::MatrixBase<Derived>& Eraw) const {
      decltype(auto) Ev = enlargeIfReduced<Material>(Eraw);
      decltype(auto) E  = transformStrain<tag, MaterialImpl::strainTag>(Ev);
      if constexpr (voigt and MaterialImpl::moduliToVoigt == false)
        // user request a Voigt shaped return but material is not able to. Therefore, we transform it here.
        return toVoigt(tangentModuliMaybeTransformInputToVoigt<false>(E));
      else
        return tangentModuliMaybeTransformInputToVoigt<voigt>(E);
    }
 
    template <typename ScalarTypeOther>
    auto rebind() const {
      return impl().template rebind<ScalarTypeOther>();
    }
 
  private:
    template <bool voigt = true, typename Derived>
    auto stressesMaybeTransformInputToVoigt(const Eigen::MatrixBase<Derived>& E) const {
      if constexpr (Concepts::EigenVector<Derived>) {  // receiving vector means Voigt notation
        if constexpr (MaterialImpl::stressAcceptsVoigt)
          return impl().template stressesImpl<voigt>(E);
        else  // material is not able to accept Voigt shaped Input. Therefore, we transform it before.
          return impl().template stressesImpl<voigt>(fromVoigt(E.derived()));
      } else
        return impl().template stressesImpl<voigt>(E.derived());
    }
 
    template <bool voigt = true, typename Derived>
    auto tangentModuliMaybeTransformInputToVoigt(const Eigen::MatrixBase<Derived>& E) const {
      if constexpr (Concepts::EigenVector<Derived>) {  // receiving vector means voigt notation
        if constexpr (MaterialImpl::moduliAcceptsVoigt)
          return impl().template tangentModuliImpl<voigt>(E);
        else
          return impl().template tangentModuliImpl<voigt>(fromVoigt(E.derived()));
      } else
        return impl().template tangentModuliImpl<voigt>(E.derived());
    }
  };
 
}  // namespace Ikarus