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(ScalarAffordances,
            noAffordance,
            mechanicalPotentialEnergy,
            microMagneticPotentialEnergy
      );
 
  MAKE_ENUM(VectorAffordances,
            noAffordance,
            forces,
            microMagneticForces
      );
 
  MAKE_ENUM(MatrixAffordances,
            noAffordance,
            stiffness,
            materialstiffness,
            geometricstiffness,
            stiffnessdiffBucklingVector,
            microMagneticHessian,
            mass
      );
 
  MAKE_ENUM(FEParameter,
            noParameter,
            loadfactor,
            time
      );
 
  MAKE_ENUM(FESolutions,
            noSolution,
            displacement,
            velocity,
            director,
            magnetizationAndVectorPotential
      );
 
// clang-format on
 
struct AffordanceCollectionImpl
{
  ScalarAffordances scalarAffordances{ScalarAffordances::noAffordance};
  VectorAffordances vectorAffordances{VectorAffordances::noAffordance};
  MatrixAffordances matrixAffordances{MatrixAffordances::noAffordance};
};
 
template <typename T>
concept FEAffordance = std::is_same_v<std::remove_cvref_t<T>, ScalarAffordances> or
                       std::is_same_v<std::remove_cvref_t<T>, VectorAffordances> or
                       std::is_same_v<std::remove_cvref_t<T>, MatrixAffordances> or
                       std::is_same_v<std::remove_cvref_t<T>, AffordanceCollectionImpl>;
 
inline constexpr VectorAffordances forces = VectorAffordances::forces;
 
inline constexpr MatrixAffordances stiffness                   = MatrixAffordances::stiffness;
inline constexpr MatrixAffordances stiffnessdiffBucklingVector = MatrixAffordances::stiffnessdiffBucklingVector;
inline constexpr MatrixAffordances mass                        = MatrixAffordances::mass;
 
inline constexpr ScalarAffordances potentialEnergy = ScalarAffordances::mechanicalPotentialEnergy;
 
namespace AffordanceCollections {
  inline constexpr AffordanceCollectionImpl elastoStatics = {ScalarAffordances::mechanicalPotentialEnergy,
                                                             VectorAffordances::forces, MatrixAffordances::stiffness};
}
 
namespace Impl {
  template <typename T>
  struct DeduceRawVectorType
  {
    static_assert(!std::is_same<T, T>::value, "You should end up in the provided specializations");
  };
 
  template <typename T>
  struct DeduceRawVectorType<std::reference_wrapper<T>>
  {
    using Type = T;
  };
 
  template <typename T>
  struct DeduceRawVectorType<Eigen::Ref<T>>
  {
    using Type = Eigen::Ref<T>;
  };
} // namespace Impl
 
template <typename SV = std::reference_wrapper<Eigen::VectorXd>, typename PM = std::reference_wrapper<double>>
class FERequirements
{
public:
  using SolutionVectorType    = SV;
  using SolutionVectorTypeRaw = typename Impl::DeduceRawVectorType<std::remove_cvref_t<SV>>::Type;
  using ParameterType         = PM;
  using ParameterTypeRaw      = typename PM::type;
 
  template <FEAffordance Affordance>
  FERequirements& addAffordance(Affordance&& affordance) {
    if constexpr (std::is_same_v<std::remove_cvref_t<Affordance>, ScalarAffordances>)
      affordances_.scalarAffordances = affordance;
    else if constexpr (std::is_same_v<std::remove_cvref_t<Affordance>, VectorAffordances>)
      affordances_.vectorAffordances = affordance;
    else if constexpr (std::is_same_v<std::remove_cvref_t<Affordance>, MatrixAffordances>)
      affordances_.matrixAffordances = affordance;
    else if constexpr (std::is_same_v<std::remove_cvref_t<Affordance>, AffordanceCollectionImpl>)
      affordances_ = affordance;
    return *this;
  }
 
  FERequirements& insertParameter(const FEParameter& key, ParameterTypeRaw& val) {
    parameter_.insert_or_assign(key, val);
    return *this;
  }
 
  FERequirements& insertGlobalSolution(const FESolutions& key, SolutionVectorTypeRaw& sol) {
    sols_.insert_or_assign(key, sol);
    return *this;
  }
 
  const SolutionVectorTypeRaw& getGlobalSolution(const FESolutions& key) const {
    try {
      if constexpr (std::is_same_v<SolutionVectorType, std::reference_wrapper<Eigen::VectorXd>>)
        return sols_.at(key).get();
      else
        return sols_.at(key);
    } catch (std::out_of_range& oor) {
      DUNE_THROW(Dune::RangeError, std::string("Out of Range error: ") + std::string(oor.what()) +
                                       " in getGlobalSolution with key" + toString(key));
      abort();
    }
  }
 
  const ParameterTypeRaw& getParameter(FEParameter&& key) const {
    try {
      return parameter_.at(key).get();
    } catch (std::out_of_range& oor) {
      DUNE_THROW(Dune::RangeError, std::string("Out of Range error: ") + std::string(oor.what()) +
                                       " in getParameter with key" + toString(key));
      abort();
    }
  }
 
  template <FEAffordance Affordance>
  bool hasAffordance(Affordance&& affordance) const {
    if constexpr (std::is_same_v<std::remove_cvref_t<Affordance>, ScalarAffordances>)
      return affordances_.scalarAffordances == affordance;
    else if constexpr (std::is_same_v<std::remove_cvref_t<Affordance>, VectorAffordances>)
      return affordances_.vectorAffordances == affordance;
    else if constexpr (std::is_same_v<std::remove_cvref_t<Affordance>, MatrixAffordances>)
      return affordances_.matrixAffordances == affordance;
    else if constexpr (std::is_same_v<std::remove_cvref_t<Affordance>, AffordanceCollectionImpl>)
      return affordances_ == affordance;
  }
 
private:
  std::map<FESolutions, SolutionVectorType> sols_;
  std::map<FEParameter, ParameterType> parameter_;
  AffordanceCollectionImpl affordances_;
};
 
template <typename SV = std::reference_wrapper<Eigen::VectorXd>, typename PM = std::reference_wrapper<double>>
class [[deprecated(
    "FErequirements is deprecaded and will be removed after v0.5. Use FERequirements instead.")]] FErequirements
    : public FERequirements<SV, PM>
{
  using Base = FERequirements<SV, PM>;
 
public:
  FErequirements() = default;
  FErequirements(Base&& base)
      : Base(std::forward<Base>(base)) {}
  FErequirements(const Base& base)
      : Base(base) {}
  FErequirements& operator=(const Base& base) {
    Base::operator=(base);
    return *this;
  }
  FErequirements& operator=(Base&& base) {
    Base::operator=(std::forward<Base>(base));
    return *this;
  }
};
 
} // namespace Ikarus