concepts.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 <concepts>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <dune/functions/functionspacebases/basistags.hh>
#include <dune/functions/functionspacebases/lagrangebasis.hh>
 
#include <Eigen/Dense>
#include <Eigen/Sparse>
 
#include "ikarus/assembler/dirichletbcenforcement.hh"
#include <ikarus/utils/traits.hh>
 
namespace Eigen {
template <typename Derived>
struct EigenBase;
}
 
namespace Ikarus {
template <auto stressIndexPair, typename MaterialImpl>
struct VanishingStress;
 
template <typename Derived>
auto transpose(const Eigen::EigenBase<Derived>& A);
namespace Concepts {
 
  template <typename Basis>
  concept FlatInterLeavedBasis = requires {
    std::is_same_v<typename Basis::PreBasis::IndexMergingStrategy, Dune::Functions::BasisFactory::FlatInterleaved>;
  };
 
  namespace Impl {
    template <template <typename, int, typename> class U, typename T>
    struct LagrangeNodeHelper : std::false_type
    {
    };
    template <template <typename, int, typename> class U, typename GV, int k, typename R>
    struct LagrangeNodeHelper<U, U<GV, k, R>> : std::true_type
    {
    };
 
    template <template <typename, int, typename> class U, typename T, int k>
    struct LagrangeNodeHelperOfOrder : std::false_type
    {
    };
    template <template <typename, int, typename> class U, typename GV, int k, typename R>
    struct LagrangeNodeHelperOfOrder<U, U<GV, k, R>, k> : std::true_type
    {
    };
  } // namespace Impl
 
  template <typename N>
  concept LagrangeNode = Impl::LagrangeNodeHelper<Dune::Functions::LagrangeNode, N>::value;
 
  template <typename N, int order>
  concept LagrangeNodeOfOrder = Impl::LagrangeNodeHelperOfOrder<Dune::Functions::LagrangeNode, N, order>::value;
 
  template <typename B>
  concept FlatLexicographicBasis = requires {
    std::is_same_v<typename B::PreBasis::IndexMergingStrategy, Dune::Functions::BasisFactory::FlatLexicographic>;
  };
 
  template <typename B>
  concept FlatIndexBasis = FlatLexicographicBasis<B> or FlatInterLeavedBasis<B>;
 
  template <typename Basis>
  concept BlockedInterLeavedBasis = requires {
    std::is_same_v<typename Basis::PreBasis::IndexMergingStrategy, Dune::Functions::BasisFactory::BlockedInterleaved>;
  };
 
  template <typename B>
  concept BlockedLexicographicBasis = requires {
    std::is_same_v<typename B::PreBasis::IndexMergingStrategy, Dune::Functions::BasisFactory::BlockedLexicographic>;
  };
 
  template <typename DLB>
  concept DuneLocalBasis = requires(DLB& duneLocalBasis) {
    typename DLB::Traits::RangeType;
    typename DLB::Traits::JacobianType;
    DLB::Traits::dimDomain;
    typename DLB::Traits::DomainType;
 
    typename DLB::Traits::DomainFieldType;
    typename DLB::Traits::RangeFieldType;
 
    duneLocalBasis.evaluateFunction(std::declval<typename DLB::Traits::DomainType>(),
                                    std::declval<std::vector<typename DLB::Traits::RangeType>&>());
    duneLocalBasis.evaluateJacobian(std::declval<typename DLB::Traits::DomainType>(),
                                    std::declval<std::vector<typename DLB::Traits::JacobianType>&>());
  };
 
  template <typename B>
  concept BlockedIndexBasis = BlockedLexicographicBasis<B> or BlockedInterLeavedBasis<B>;
 
  template <typename PF, typename NLO, typename SA>
  concept PathFollowingStrategy = requires(PF pft, NLO nop, SA args) {
    { pft(args) } -> std::same_as<void>;
    { pft.initialPrediction(nop, args) } -> std::same_as<void>;
    { pft.intermediatePrediction(nop, args) } -> std::same_as<void>;
  };
 
  template <typename ASS, typename NLSI, typename SA, typename NonLinearOperator>
  concept AdaptiveStepSizingStrategy = requires(ASS adaptiveStepSizing, NLSI info, SA args, NonLinearOperator nop) {
    { adaptiveStepSizing(info, args, nop) } -> std::same_as<void>;
    { adaptiveStepSizing.targetIterations() } -> std::same_as<int>;
    { adaptiveStepSizing.setTargetIterations(std::declval<int>()) } -> std::same_as<void>;
  };
 
  template <typename LS, typename M, typename V>
  concept LinearSolverCheck = requires(LS& linearSolver, M& A, V& vec) {
    linearSolver.analyzePattern(A);
    linearSolver.factorize(A);
    linearSolver.solve(vec, vec);
  };
 
  template <typename NLS>
  concept NonLinearSolverCheckForPathFollowing = requires {
    std::tuple_size<typename NLS::NonLinearOperator::ParameterValues>::value == 2;
    not(std::is_same_v<typename NLS::NonLinearOperator::ValueType, double> and
        ((traits::isSpecializationTypeAndNonTypes<Eigen::Matrix,
                                                  typename NLS::NonLinearOperator::DerivativeType>::value) or
         (traits::isSpecializationTypeNonTypeAndType<Eigen::SparseMatrix,
                                                     typename NLS::NonLinearOperator::DerivativeType>::value)));
  };
 
  template <typename L, typename R>
  concept MultiplyAble = requires(L x, R y) { x* y; };
 
  template <typename L, typename R>
  concept AddAble = requires(L x, R y) { x + y; };
 
  template <typename L, typename R>
  concept SubstractAble = requires(L x, R y) { x - y; };
 
  template <typename L, typename R>
  concept MultiplyAssignAble = requires(L x, R y) { x *= y; };
 
  template <typename L, typename R>
  concept DivideAssignAble = requires(L x, R y) { x /= y; };
 
  template <typename L, typename R>
  concept AddAssignAble = requires(L x, R y) { x += y; };
 
  template <typename L, typename R>
  concept SubstractAssignAble = requires(L x, R y) { x -= y; };
 
  template <typename L, typename R>
  concept DivideAble = requires(L x, R y) { x / y; };
 
  template <typename L>
  concept NegateAble = requires(L x) { -x; };
 
  template <typename L>
  concept TransposeAble = requires(L x) { transpose(x); };
 
  template <typename Op, typename... Args>
  concept IsFunctorWithArgs = requires(Op op, Args... args) { op(args...); };
 
  template <typename V>
  concept EigenVector = static_cast<bool>(V::IsVectorAtCompileTime);
 
  template <typename M>
  concept EigenMatrix = traits::isSpecializationTypeAndNonTypes<Eigen::Matrix, M>::value;
 
#define MAKE_EIGEN_FIXED_VECTOR_CONCEPT(Size) \
  template <typename V>                       \
  concept EigenVector##Size =                 \
      static_cast<bool>(V::IsVectorAtCompileTime) and static_cast<bool>(V::SizeAtCompileTime == Size);
 
  MAKE_EIGEN_FIXED_VECTOR_CONCEPT(1)
  MAKE_EIGEN_FIXED_VECTOR_CONCEPT(2)
  MAKE_EIGEN_FIXED_VECTOR_CONCEPT(3)
  MAKE_EIGEN_FIXED_VECTOR_CONCEPT(4)
  MAKE_EIGEN_FIXED_VECTOR_CONCEPT(5)
  MAKE_EIGEN_FIXED_VECTOR_CONCEPT(6)
 
#define MAKE_EIGEN_FIXED_MATRIX_CONCEPT(Size1, Size2)                                                           \
  template <typename M>                                                                                         \
  concept EigenMatrix##Size1##Size2 = static_cast<bool>(std::remove_cvref_t<M>::RowsAtCompileTime == Size1) and \
                                      static_cast<bool>(std::remove_cvref_t<M>::ColsAtCompileTime == Size2);
 
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(1, 1)
 
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(1, 2)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(2, 2)
 
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(1, 3)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(2, 3)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(3, 2)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(3, 3)
 
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(1, 4)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(2, 4)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(3, 4)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(4, 2)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(4, 3)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(4, 4)
 
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(1, 5)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(2, 5)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(3, 5)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(4, 5)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(5, 2)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(5, 3)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(5, 4)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(5, 5)
 
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(1, 6)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(2, 6)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(3, 6)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(4, 6)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(5, 6)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(6, 2)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(6, 3)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(6, 4)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(6, 5)
  MAKE_EIGEN_FIXED_MATRIX_CONCEPT(6, 6)
 
#define MAKE_EIGEN_FIXED_MATRIX_OR_VOIGT_CONCEPT(Size1, Size2) \
  template <typename M>                                        \
  concept EigenMatrixOrVoigtNotation##Size1 = EigenMatrix##Size1##Size1<M> or EigenVector##Size2<M>;
 
  MAKE_EIGEN_FIXED_MATRIX_OR_VOIGT_CONCEPT(1, 1)
  MAKE_EIGEN_FIXED_MATRIX_OR_VOIGT_CONCEPT(2, 3)
  MAKE_EIGEN_FIXED_MATRIX_OR_VOIGT_CONCEPT(3, 6)
 
  namespace Impl {
    template <template <typename...> class MaterialToCheck, typename Material>
    consteval bool isMaterial() {
      if constexpr (traits::isSpecialization<MaterialToCheck, Material>::value)
        return true;
 
      if constexpr (traits::isSpecializationNonTypeAndTypes<VanishingStress, Material>::value) {
        if constexpr (traits::isSpecialization<MaterialToCheck, typename Material::Underlying>::value) {
          return true;
        } else {
          return false;
        }
      } else
        return false;
    }
  } // namespace Impl
  template <template <typename...> class MaterialToCheck, typename Material>
  concept IsMaterial = Impl::isMaterial<MaterialToCheck, Material>();
 
  namespace Impl {
    template <typename T>
    concept ResultType = requires(T t) {
      typename T::type;                             // The nested type 'type'
      typename T::Vectorizer;                       // The nested type 'Vectorizer'
      typename T::Matricizer;                       // The nested type 'Matricizer'
      { toString(t) } -> std::same_as<std::string>; // The toString function
    };
  } // namespace Impl
 
  template <template <typename, int, int> typename RT>
  concept ResultType =
      Impl::ResultType<RT<double, 1, 1>> or Impl::ResultType<RT<double, 1, 2>> or Impl::ResultType<RT<double, 1, 3>> or
      Impl::ResultType<RT<double, 2, 3>> or Impl::ResultType<RT<double, 3, 3>>;
 
  template <typename T>
  concept FlatAssembler = requires(T t, const typename T::FERequirement& req,
                                   typename T::AffordanceCollectionType affordance, DBCOption dbcOption) {
    { t.scalar(req, affordance.scalarAffordance()) } -> std::convertible_to<const double&>;
    { t.scalar() } -> std::convertible_to<const double&>;
 
    { t.vector(req, affordance.vectorAffordance(), dbcOption) } -> std::convertible_to<const Eigen::VectorXd&>;
    { t.vector(dbcOption) } -> std::convertible_to<const Eigen::VectorXd&>;
    { t.vector() } -> std::convertible_to<const Eigen::VectorXd&>;
 
    { t.matrix(req, affordance.matrixAffordance(), dbcOption) };
    { t.matrix(dbcOption) };
    { t.matrix() };
 
    { t.requirement() } -> std::convertible_to<typename T::FERequirement&>;
    { t.affordanceCollection() } -> std::convertible_to<typename T::AffordanceCollectionType>;
    { t.dBCOption() } -> std::convertible_to<DBCOption>;
 
    { t.bind(req, affordance, dbcOption) } -> std::same_as<void>;
    { t.bind(req) } -> std::same_as<void>;
    { t.bind(affordance) } -> std::same_as<void>;
    { t.bind(dbcOption) } -> std::same_as<void>;
 
    { t.bound() } -> std::convertible_to<bool>;
    { t.boundToRequirement() } -> std::convertible_to<bool>;
    { t.boundToAffordanceCollection() } -> std::convertible_to<bool>;
    { t.boundToDBCOption() } -> std::convertible_to<bool>;
    { t.estimateOfConnectivity() } -> std::convertible_to<size_t>;
 
    { t.createFullVector(std::declval<Eigen::Ref<const Eigen::VectorXd>>()) } -> std::convertible_to<Eigen::VectorXd>;
    { t.constraintsBelow(std::declval<size_t>()) } -> std::convertible_to<size_t>;
    { t.isConstrained(std::declval<size_t>()) } -> std::convertible_to<bool>;
    { t.size() } -> std::convertible_to<size_t>;
    { t.reducedSize() } -> std::convertible_to<size_t>;
  };
 
} // namespace Concepts
} // namespace Ikarus