mixin.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
 
#pragma once
 
#include <dune/common/tuplevector.hh>
 
#include <ikarus/finiteelements/fetraits.hh>
#include <ikarus/finiteelements/mechanics/assumedstress.hh>
#include <ikarus/finiteelements/mechanics/enhancedassumedstrains.hh>
#include <ikarus/utils/broadcaster/broadcastermessages.hh>
#include <ikarus/utils/functionhelper.hh>
#include <ikarus/utils/listener/listener.hh>
 
namespace Ikarus {
template <typename PreFE, template <typename, typename> class... Skills>
struct FEMixin : public Listener, Skills<PreFE, typename PreFE::template FE<Skills...>>...
{
  explicit FEMixin(typename Skills<PreFE, typename PreFE::template FE<Skills...>>::Pre&&... skillsArgs)
      : Skills<PreFE, typename PreFE::template FE<Skills...>>(
            std::forward<typename Skills<PreFE, typename PreFE::template FE<Skills...>>::Pre>(skillsArgs))... {}
 
  template <template <typename, typename> class Skill>
  static consteval bool hasSkill() {
    return Ikarus::traits::hasType<Skill<PreFE, typename PreFE::template FE<Skills...>>,
                                   std::tuple<Skills<PreFE, typename PreFE::template FE<Skills...>>...>>::value;
  }
 
private:
  template <typename T>
  consteval static auto computeSupportedResultTypes() {
    if constexpr (requires { typename T::SupportedResultTypes; })
      return typename T::SupportedResultTypes();
    else
      return std::tuple();
  }
 
public:
  using SupportedResultTypes =
      decltype(std::tuple_cat(computeSupportedResultTypes<Skills<PreFE, typename PreFE::template FE<Skills...>>>()...));
 
  template <bool, typename = void>
  struct RequirementType;
 
  template <typename T>
  struct RequirementType<false, T>
  {
    using type = FERequirements<FESolutions::noSolution, FEParameter::noParameter>;
  };
 
  template <typename T>
  struct RequirementType<true, T>
  {
    using type = std::common_type_t<typename Skills<PreFE, typename PreFE::template FE<Skills...>>::Requirement...>;
  };
 
private:
  static constexpr bool requirementDetected =
      Dune::Std::is_detected_v<std::common_type_t,
                               typename Skills<PreFE, typename PreFE::template FE<Skills...>>::Requirement...>;
  static_assert(requirementDetected or sizeof...(Skills) == 0, "The skills must have a common fe requirement type.");
 
public:
  using Traits                  = PreFE::Traits;
  using Requirement             = RequirementType<requirementDetected>::type;
  using LocalView               = typename Traits::LocalView;
  static constexpr int worldDim = Traits::worlddim;
 
private:
  template <typename ES>
  static constexpr bool hasEASImpl = hasSkill<EnhancedAssumedStrainsPre<ES>::template Skill>();
  template <typename PS>
  static constexpr bool hasASImpl = hasSkill<AssumedStressPre<PS>::template Skill>();
 
public:
  static constexpr bool hasEAS() {
    return hasEASImpl<EAS::LinearStrain> or hasEASImpl<EAS::GreenLagrangeStrain> or
           hasEASImpl<EAS::DisplacementGradient> or hasEASImpl<EAS::DisplacementGradientTransposed>;
  }
  static constexpr bool hasAssumedStress() { return hasASImpl<PS::LinearStress> or hasASImpl<PS::PK2Stress>; }
  static constexpr bool isMixed() { return hasAssumedStress() or hasEAS(); }
 
  static auto createRequirement() { return Requirement(); }
 
  friend auto calculateScalar(const FEMixin& self, const Requirement& req, ScalarAffordance affordance) {
    return self.template calculateScalarImpl<double>(req, affordance);
  }
 
  friend void calculateVector(const FEMixin& self, const Requirement& req, VectorAffordance affordance,
                              typename Traits::template VectorType<> force) {
    self.template calculateVectorImpl<double>(req, affordance, force);
  }
 
  friend void calculateMatrix(const FEMixin& self, const Requirement& req, MatrixAffordance affordance,
                              typename Traits::template MatrixType<> K) {
    self.template calculateMatrixImpl<double>(req, affordance, K);
  }
 
  using Skills<PreFE, typename PreFE::template FE<Skills...>>::calculateAtImpl...;
 
  template <template <typename, int, int> class RT>
  requires requires(FEMixin m, const Requirement& req, const Dune::FieldVector<double, Traits::mydim>& local) {
    m.template calculateAtImpl<RT>(req, local, Dune::PriorityTag<10>());
  }
  auto calculateAt(const Requirement& req, const Dune::FieldVector<double, Traits::mydim>& local) const {
    return this->template calculateAtImpl<RT>(req, local, Dune::PriorityTag<10>());
  }
 
private:
  template <typename Sk>
  auto invokeBind() {
    if constexpr (requires { this->Sk::bindImpl(); })
      Sk::bindImpl();
  }
 
  static constexpr bool implementsCalculateScalarImpl =
      (requires(FEMixin m, const Requirement& par, ScalarAffordance affordance,
                const std::optional<std::reference_wrapper<const Eigen::VectorX<double>>>& dx) {
        m.Skills<PreFE, typename PreFE::template FE<Skills...>>::calculateScalarImpl(par, affordance, dx);
      } ||
       ...);
 
public:
  void bind() { (invokeBind<Skills<PreFE, typename PreFE::template FE<Skills...>>>(), ...); }
 
  template <typename ScalarType = double>
  requires implementsCalculateScalarImpl
  auto calculateScalarImpl(
      const Requirement& par, ScalarAffordance affordance,
      const std::optional<std::reference_wrapper<const Eigen::VectorX<ScalarType>>>& dx = std::nullopt) const {
    return (Skills<PreFE, typename PreFE::template FE<Skills...>>::template calculateScalarImpl<ScalarType>(
                par, affordance, dx) +
            ... + ScalarType{0});
  }
 
private:
  static constexpr bool implementsCalculateVectorImpl =
      (requires(FEMixin m, const Requirement& par, VectorAffordance affordance,
                typename Traits::template VectorType<double> force,
                const std::optional<std::reference_wrapper<const Eigen::VectorX<double>>>& dx) {
        m.Skills<PreFE, typename PreFE::template FE<Skills...>>::calculateVectorImpl(par, affordance, force, dx);
      } ||
       ...);
 
public:
  template <typename ScalarType>
  requires implementsCalculateVectorImpl
  void calculateVectorImpl(
      const Requirement& par, VectorAffordance affordance, typename Traits::template VectorType<ScalarType> force,
      const std::optional<std::reference_wrapper<const Eigen::VectorX<ScalarType>>>& dx = std::nullopt) const {
    (Skills<PreFE, typename PreFE::template FE<Skills...>>::template calculateVectorImpl<ScalarType>(par, affordance,
                                                                                                     force, dx),
     ...);
  }
 
private:
  static constexpr bool implementsCalculateMatrixImpl =
      (requires(FEMixin m, const Requirement& par, MatrixAffordance affordance,
                typename Traits::template MatrixType<double> K,
                const std::optional<std::reference_wrapper<const Eigen::VectorX<double>>>& dx) {
        m.Skills<PreFE, typename PreFE::template FE<Skills...>>::calculateMatrixImpl(par, affordance, K, dx);
      } ||
       ...);
 
public:
  template <typename ScalarType>
  requires implementsCalculateMatrixImpl
  void calculateMatrixImpl(
      const Requirement& par, MatrixAffordance affordance, typename Traits::template MatrixType<ScalarType> K,
      const std::optional<std::reference_wrapper<const Eigen::VectorX<ScalarType>>>& dx = std::nullopt) const {
    (Skills<PreFE, typename PreFE::template FE<Skills...>>::template calculateMatrixImpl<ScalarType>(par, affordance, K,
                                                                                                     dx),
     ...);
  }
 
private:
  template <typename Sk>
  auto invokeUpdateState(const Requirement& par,
                         const std::remove_reference_t<typename Traits::template VectorType<>>& correction) {
    if constexpr (requires { Sk::updateStateImpl(par, correction); })
      Sk::updateStateImpl(par, correction);
  }
 
public:
  void updateState(const Requirement& par,
                   const std::remove_reference_t<typename Traits::template VectorType<>>& correction) {
    (invokeUpdateState<Skills<PreFE, typename PreFE::template FE<Skills...>>>(par, correction), ...);
  }
 
private:
  template <typename Sk, typename BC, typename MT>
  auto invokeSubscribeTo(BC& bc) {
    // For Clang-16: we need the this-> otherwise the code in the if clause will never be called. For Gcc-12.2: with
    // the this-> it throws a compiler error in certain cases
#if defined(__clang__)
    if constexpr (requires { this->Sk::template subscribeToImpl<MT>(bc); }) {
#else
    if constexpr (requires { Sk::template subscribeToImpl<MT>(bc); }) {
#endif
      Sk::template subscribeToImpl<MT>(bc);
    }
  }
 
public:
  template <typename MT, typename BC>
  auto subscribeTo(BC& bc) {
    (invokeSubscribeTo<Skills<PreFE, typename PreFE::template FE<Skills...>>, traits::MaybeDereferencedType<BC>, MT>(
         utils::maybeDeref(bc)),
     ...);
    return *this;
  }
 
protected:
  const auto& underlying() const { return static_cast<const typename PreFE::template FE<Skills...>&>(*this); }
  auto& underlying() { return static_cast<typename PreFE::template FE<Skills...>&>(*this); }
};
 
template <typename... ARGS>
struct Skills
{
  using Args = std::tuple<ARGS...>;
  Args args;
};
 
template <typename... Args>
auto skills(const Args&... args) {
  return Skills<std::remove_cvref_t<Args>...>{std::forward_as_tuple(std::remove_cvref_t<Args>(args)...)};
}
 
template <typename... Args1, typename... Args2>
auto merge(const Skills<Args1...>& sk1, const Skills<Args2...>& sk2) {
  return Skills<std::remove_cvref_t<Args1>..., std::remove_cvref_t<Args2>...>{std::tuple_cat(sk1.args, sk2.args)};
}
 
} // namespace Ikarus