ferequirements.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 <iosfwd>
#include <map>
#include <set>
#include <vector>
 
#include <dune/common/exceptions.hh>
 
#include <Eigen/Core>
 
#include <ikarus/finiteelements/feresulttypes.hh>
#include <ikarus/utils/makeenum.hh>
 
namespace Ikarus {
// clang-format off
 
// cppcheck-suppress MAKE_ENUM
 MAKE_ENUM(ScalarAffordance,
            noAffordance,
            mechanicalPotentialEnergy,
            microMagneticPotentialEnergy
      );
 
  MAKE_ENUM(VectorAffordance,
            noAffordance,
            forces,
            microMagneticForces
      );
 
  MAKE_ENUM(MatrixAffordance,
            noAffordance,
            stiffness,
            materialstiffness,
            geometricstiffness,
            stiffnessdiffBucklingVector,
            microMagneticHessian,
            mass
      );
 
  MAKE_ENUM(FEParameter,
            noParameter,
            loadfactor,
            time
      );
 
  MAKE_ENUM(FESolutions,
            noSolution,
            displacement,
            velocity,
            director,
            magnetizationAndVectorPotential
      );
 
// clang-format on
 
template <typename T>
concept FEAffordance = std::is_same_v<std::remove_cvref_t<T>, ScalarAffordance> or
                       std::is_same_v<std::remove_cvref_t<T>, VectorAffordance> or
                       std::is_same_v<std::remove_cvref_t<T>, MatrixAffordance>;
 
template <FEAffordance... Affordances>
requires(sizeof...(Affordances) <= 3)
struct AffordanceCollection : public std::tuple<Affordances...>
{
  using Base = std::tuple<Affordances...>;
 
  AffordanceCollection() = default;
  constexpr AffordanceCollection(Affordances... affordances)
      : Base(affordances...) {}
 
  static constexpr bool hasScalarAffordance = traits::hasType<ScalarAffordance, std::tuple<Affordances...>>::value;
  static constexpr bool hasVectorAffordance = traits::hasType<VectorAffordance, std::tuple<Affordances...>>::value;
  static constexpr bool hasMatrixAffordance = traits::hasType<MatrixAffordance, std::tuple<Affordances...>>::value;
  template <FEAffordance Affordance>
  constexpr bool hasAffordance(Affordance&& affordances) const {
    using AffordanceRaw = std::remove_cvref_t<Affordance>;
    if constexpr (std::is_same_v<AffordanceRaw, AffordanceCollection>)
      return affordances == *this;
    else {
      if constexpr (std::is_same_v<AffordanceRaw, ScalarAffordance>) {
        if constexpr (hasScalarAffordance)
          return affordances == std::get<ScalarAffordance>(*this);
        else
          return false;
      }
      if constexpr (std::is_same_v<AffordanceRaw, VectorAffordance>) {
        if constexpr (hasVectorAffordance)
          return affordances == std::get<VectorAffordance>(*this);
        else
          return false;
      }
      if constexpr (std::is_same_v<AffordanceRaw, MatrixAffordance>) {
        if constexpr (hasMatrixAffordance)
          return affordances == std::get<MatrixAffordance>(*this);
        else
          return false;
      }
    }
    return false;
  }
 
  auto scalarAffordance() const
  requires hasScalarAffordance
  {
    return std::get<ScalarAffordance>(*this);
  }
  auto vectorAffordance() const
  requires hasVectorAffordance
  {
    return std::get<VectorAffordance>(*this);
  }
  auto matrixAffordance() const
  requires hasMatrixAffordance
  {
    return std::get<MatrixAffordance>(*this);
  }
};
 
inline constexpr VectorAffordance forces = VectorAffordance::forces;
 
inline constexpr MatrixAffordance stiffness                   = MatrixAffordance::stiffness;
inline constexpr MatrixAffordance stiffnessdiffBucklingVector = MatrixAffordance::stiffnessdiffBucklingVector;
inline constexpr MatrixAffordance mass                        = MatrixAffordance::mass;
inline constexpr ScalarAffordance potentialEnergy             = ScalarAffordance::mechanicalPotentialEnergy;
 
auto vectorAffordance(MatrixAffordance affordanceM) {
  if (affordanceM == MatrixAffordance::stiffness)
    return VectorAffordance::forces;
  else if (affordanceM == MatrixAffordance::microMagneticHessian)
    return VectorAffordance::microMagneticForces;
  else
    return VectorAffordance::noAffordance;
}
 
auto scalarAffordance(MatrixAffordance affordanceM) {
  if (affordanceM == MatrixAffordance::stiffness)
    return ScalarAffordance::mechanicalPotentialEnergy;
  else if (affordanceM == MatrixAffordance::microMagneticHessian)
    return ScalarAffordance::microMagneticPotentialEnergy;
  else
    return ScalarAffordance::noAffordance;
}
 
auto scalarAffordance(VectorAffordance affordanceV) {
  if (affordanceV == VectorAffordance::forces)
    return ScalarAffordance::mechanicalPotentialEnergy;
  else if (affordanceV == VectorAffordance::microMagneticForces)
    return ScalarAffordance::microMagneticPotentialEnergy;
  else
    return ScalarAffordance::noAffordance;
}
 
namespace AffordanceCollections {
  inline constexpr AffordanceCollection elastoStatics(ScalarAffordance::mechanicalPotentialEnergy,
                                                      VectorAffordance::forces, MatrixAffordance::stiffness);
}
 
namespace Impl {
  template <typename T>
  struct DeduceTypes
  {
    using InputType       = T&;
    using StorageType     = std::reference_wrapper<T>;
    using ReturnType      = T&;
    using ConstReturnType = const T&;
  };
 
  template <typename T>
  struct DeduceTypes<std::reference_wrapper<T>>
  {
    using InputType       = T&;
    using StorageType     = std::reference_wrapper<T>;
    using ReturnType      = T&;
    using ConstReturnType = const T&;
  };
 
  template <typename T>
  struct DeduceTypes<Eigen::Ref<T>>
  {
    using InputType   = Eigen::Ref<T>&;
    using StorageType = Eigen::Ref<T>;
 
    using ReturnType      = Eigen::Ref<T>&;
    using ConstReturnType = const Eigen::Ref<T>&;
  };
} // namespace Impl
 
template <FESolutions sol, FEParameter para, typename SV = Eigen::VectorXd, typename PM = double>
class FERequirements
{
public:
  static constexpr FESolutions globalSolutionTag = sol;
  static constexpr FEParameter parameterTag      = para;
 
private:
  using SVHelper                  = Impl::DeduceTypes<std::remove_cvref_t<SV>>;
  using PMHelper                  = Impl::DeduceTypes<std::remove_cvref_t<PM>>;
  using SolutionVectorReturnType  = SVHelper::ReturnType;
  using ParameterReturnType       = PMHelper::ReturnType;
  using SolutionVectorStorageType = SVHelper::StorageType;
  using ParameterStorageType      = PMHelper::StorageType;
  using SolutionVectorInputType   = SVHelper::InputType;
  using ParameterInputType        = PMHelper::InputType;
 
public:
  using SolutionVectorType = SV;
  using ParameterType      = PM;
 
  FERequirements() = default;
  FERequirements(SolutionVectorInputType solVec, ParameterInputType parameter)
      : sol_{solVec},
        parameter_{parameter} {}
 
  FERequirements& insertParameter(ParameterInputType val) {
    parameter_ = val;
    return *this;
  }
 
  FERequirements& insertGlobalSolution(SolutionVectorInputType solVec) {
    sol_ = solVec;
    return *this;
  }
 
  SolutionVectorReturnType globalSolution() { return sol_.value(); }
 
  SVHelper::ConstReturnType globalSolution() const { return sol_.value(); }
 
  PMHelper::ConstReturnType parameter() const {
    return parameter_.value();
    ;
  }
 
  ParameterReturnType parameter() { return parameter_.value(); }
 
  bool populated() const { return sol_.has_value() and parameter_.has_value(); }
 
private:
  std::optional<SolutionVectorStorageType> sol_;
  std::optional<ParameterStorageType> parameter_;
};
 
template <FESolutions sol, FEParameter para, bool wrapWithRef = false, typename SV = Eigen::VectorXd,
          typename PM = double>
struct FERequirementsFactory
{
private:
  using typeEigen = std::conditional_t<wrapWithRef and Ikarus::Concepts::EigenMatrix<SV>, Eigen::Ref<SV>, SV>;
 
public:
  using type = FERequirements<sol, para, typeEigen, PM>;
};
 
} // namespace Ikarus