ferequirements.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2025 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/basis.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 AffordanceCollections
 
template <FESolutions sol, FEParameter para, typename SV = Eigen::VectorXd, typename PM = double>
class FERequirements
{
public:
  using SolutionVectorType = SV; 
  using ParameterType      = PM; 
 
  FERequirements() = default;
 
  template <typename SV2 = SV, typename PM2 = PM>
  FERequirements(SV2&& solVec, PM2&& parameter)
      : sol_(std::make_unique<SV>(std::forward<SV2>(solVec))),
        parameter_(std::make_unique<PM>(std::forward<PM2>(parameter))) {}
 
  template <typename PB>
  FERequirements(const Ikarus::BasisHandler<PB>& basis)
      : sol_(std::make_unique<SV>(SV::Zero(basis.flat().size()))),
        parameter_(std::make_unique<PM>(0.0)) {}
 
  FERequirements(const FERequirements& other)
      : sol_(other.sol_ ? std::make_unique<SV>(*other.sol_) : nullptr),
        parameter_(other.parameter_ ? std::make_unique<PM>(*other.parameter_) : nullptr) {}
 
  FERequirements& operator=(const FERequirements& other) {
    if (this != &other) {
      sol_       = other.sol_ ? std::make_unique<SV>(*other.sol_) : nullptr;
      parameter_ = other.parameter_ ? std::make_unique<PM>(*other.parameter_) : nullptr;
    }
    return *this;
  }
 
  FERequirements& insertParameter(const PM& val) {
    parameter_ = std::make_unique<PM>(val);
    return *this;
  }
 
  template <typename SV2 = SolutionVectorType>
  FERequirements& insertGlobalSolution(SV2&& solVec) {
    sol_ = std::make_unique<SV>(std::forward<SV2>(solVec));
    return *this;
  }
 
  const SolutionVectorType& globalSolution() const {
    if (!sol_)
      DUNE_THROW(Dune::InvalidStateException, "Solution vector is not initialized.");
    return *sol_;
  }
 
  SV& globalSolution() {
    if (!sol_)
      DUNE_THROW(Dune::InvalidStateException, "Solution vector is not initialized.");
 
    return *sol_;
  }
 
  const PM& parameter() const {
    if (!parameter_)
      DUNE_THROW(Dune::InvalidStateException, "Parameter is not initialized.");
 
    return *parameter_;
  }
 
  PM& parameter() {
    if (!parameter_)
      DUNE_THROW(Dune::InvalidStateException, "Parameter is not initialized.");
 
    return *parameter_;
  }
 
  bool populated() const { return sol_ and parameter_; }
 
  template <typename T>
  SV& operator+=(const T& rhs) {
    if (!sol_)
      DUNE_THROW(Dune::InvalidStateException, "Solution vector is not initialized.");
    *sol_ += rhs;
    return *sol_;
  }
 
private:
  std::unique_ptr<SV> sol_;       
  std::unique_ptr<PM> parameter_; 
};
 
} // namespace Ikarus