Rework canProvideResultType() (#312)

ikarus/finiteelements/feresulttypes.hh

@@ -252,4 +252,34 @@ auto toString() {
 template <template <typename, int, int> class RT1, template <typename, int, int> class RT2>
 constexpr bool isSameResultType = std::is_same_v<Impl::DummyRT<RT1>, Impl::DummyRT<RT2>>;
 
+namespace Impl {
+  template <typename T, typename Tuple>
+  struct hasType;
+
+  template <typename T, typename... Us>
+  struct hasType<T, std::tuple<Us...>> : std::disjunction<std::is_same<T, Us>...>
+  {
+  };
+} // namespace Impl
+
+/**
+ * \brief Base class for element definitions that provides common functionality for ResultTypes
+ *
+ * \tparam ResultTypes supported ResultTypes
+ */
+template <template <typename, int, int> typename... ResultTypes>
+struct ResultTypeBase
+{
+  /**
+   * \brief Returns whether a ResultType is provided by the element
+   * \tparam RT requested ResultType
+   */
+  template <template <typename, int, int> typename RT>
+  static consteval bool supportsResultType() {
+    return Impl::hasType<decltype(makeRT<RT>()), SupportedResultTypes>::value;
+  }
+
+  using SupportedResultTypes = std::tuple<decltype(makeRT<ResultTypes>())...>;
+};
+
 } // namespace Ikarus

ikarus/finiteelements/mechanics/enhancedassumedstrains.hh

@@ -57,8 +57,6 @@ public:
   using GridView  = typename Traits::GridView;
   using Pre       = EnhancedAssumedStrainsPre;
 
-  using SupportedResultTypes = std::tuple<decltype(makeRT<ResultTypes::linearStress>())>;
-
   /**
    * \brief Constructor for Enhanced Assumed Strains elements.
    * \param pre The pre finite element

ikarus/finiteelements/mechanics/kirchhoffloveshell.hh

@@ -14,6 +14,7 @@
 
 #include <ikarus/finiteelements/fehelper.hh>
 #include <ikarus/finiteelements/ferequirements.hh>
+#include <ikarus/finiteelements/feresulttypes.hh>
 #include <ikarus/finiteelements/mechanics/loads.hh>
 #include <ikarus/finiteelements/mechanics/membranestrains.hh>
 #include <ikarus/finiteelements/physicshelper.hh>
@@ -46,7 +47,7 @@ struct KirchhoffLoveShellPre
  * \tparam FE Type of the finite element.
  */
 template <typename PreFE, typename FE>
-class KirchhoffLoveShell
+class KirchhoffLoveShell : public ResultTypeBase<>
 {
 public:
   using Traits       = PreFE::Traits;
@@ -152,18 +153,6 @@ public:
   [[nodiscard]] size_t numberOfNodes() const { return numberOfNodes_; }
   [[nodiscard]] int order() const { return order_; }
 
-  /**
-   * \brief Returns whether an element can provide a requested result. Can be used in constant expressions
-   * \tparam RT The type representing the requested result.
-   * \return boolean indicating if a requested result can be provided
-   */
-  template <template <typename, int, int> class RT>
-  static consteval bool canProvideResultType() {
-    return false;
-  }
-
-  using SupportedResultTypes = std::tuple<>;
-
   /**
    * \brief Calculates a requested result at a specific local position.
    *
@@ -174,7 +163,7 @@ public:
    * \tparam RT The type representing the requested result.
    */
   template <template <typename, int, int> class RT>
-  requires(canProvideResultType<RT>())
+  requires(supportsResultType<RT>())
   auto calculateAtImpl([[maybe_unused]] const Requirement& req,
                        [[maybe_unused]] const Dune::FieldVector<double, Traits::mydim>& local)
       -> ResultWrapper<RT<double, myDim, worldDim>, ResultShape::Vector> {

ikarus/finiteelements/mechanics/linearelastic.hh

@@ -20,6 +20,7 @@
 
   #include <ikarus/finiteelements/fehelper.hh>
   #include <ikarus/finiteelements/ferequirements.hh>
+  #include <ikarus/finiteelements/feresulttypes.hh>
   #include <ikarus/finiteelements/mechanics/materials.hh>
   #include <ikarus/finiteelements/physicshelper.hh>
 
@@ -48,7 +49,7 @@ struct LinearElasticPre
  * \tparam FE The type of the finite element.
  */
 template <typename PreFE, typename FE>
-class LinearElastic
+class LinearElastic : public ResultTypeBase<ResultTypes::linearStress>
 {
 public:
   using Traits       = PreFE::Traits;
@@ -154,13 +155,6 @@ public:
   [[nodiscard]] size_t numberOfNodes() const { return numberOfNodes_; }
   [[nodiscard]] int order() const { return order_; }
 
-  using SupportedResultTypes = std::tuple<decltype(makeRT<ResultTypes::linearStress>())>;
-
-  template <template <typename, int, int> class RT>
-  static consteval bool canProvideResultType() {
-    return isSameResultType<RT, ResultTypes::linearStress>;
-  }
-
 public:
   /**
    * \brief Calculates a requested result at a specific local position.
@@ -173,7 +167,7 @@ public:
    * \tparam RT The type representing the requested result.
    */
   template <template <typename, int, int> class RT>
-  requires(canProvideResultType<RT>())
+  requires(supportsResultType<RT>())
   auto calculateAtImpl(const Requirement& req, const Dune::FieldVector<double, Traits::mydim>& local,
                        Dune::PriorityTag<1>) const {
     using RTWrapper = ResultWrapper<RT<typename Traits::ctype, myDim, Traits::worlddim>, ResultShape::Vector>;

ikarus/finiteelements/mechanics/nonlinearelastic.hh

@@ -57,7 +57,7 @@ struct NonLinearElasticPre
  * \tparam PRE The type of the non-linear elastic pre finite element.
  */
 template <typename PreFE, typename FE, typename PRE>
-class NonLinearElastic
+class NonLinearElastic : public ResultTypeBase<ResultTypes::PK2Stress>
 {
 public:
   using Traits    = PreFE::Traits;
@@ -201,14 +201,6 @@ public:
   [[nodiscard]] size_t numberOfNodes() const { return numberOfNodes_; }
   [[nodiscard]] int order() const { return order_; }
 
-  using SupportedResultTypes = std::tuple<decltype(makeRT<ResultTypes::PK2Stress>())>;
-
-private:
-  template <template <typename, int, int> class RT>
-  static consteval bool canProvideResultType() {
-    return isSameResultType<RT, ResultTypes::PK2Stress>;
-  }
-
 public:
   /**
    * \brief Calculates a requested result at a specific local position.
@@ -220,7 +212,7 @@ public:
    * \tparam RT The type representing the requested result.
    */
   template <template <typename, int, int> class RT>
-  requires(canProvideResultType<RT>())
+  requires(supportsResultType<RT>())
   auto calculateAtImpl(const Requirement& req, const Dune::FieldVector<double, Traits::mydim>& local,
                        Dune::PriorityTag<1>) const {
     using namespace Dune::DerivativeDirections;

ikarus/finiteelements/mechanics/truss.hh

@@ -43,6 +43,7 @@ struct TrussPre
  */
 template <typename PreFE, typename FE>
 class Truss
+    : public ResultTypeBase<ResultTypes::cauchyAxialForce, ResultTypes::PK2AxialForce, ResultTypes::linearAxialForce>
 {
 public:
   using Traits       = PreFE::Traits;
@@ -156,17 +157,6 @@ public:
     return kin;
   }
 
-  using SupportedResultTypes =
-      std::tuple<decltype(makeRT<ResultTypes::cauchyAxialForce>()), decltype(makeRT<ResultTypes::PK2AxialForce>()),
-                 decltype(makeRT<ResultTypes::linearAxialForce>())>;
-
-private:
-  template <template <typename, int, int> class RT>
-  static consteval bool canProvideResultType() {
-    return isSameResultType<RT, ResultTypes::cauchyAxialForce> or isSameResultType<RT, ResultTypes::PK2AxialForce> or
-           isSameResultType<RT, ResultTypes::linearAxialForce>;
-  }
-
 public:
   /**
    * \brief Calculates a requested result at a specific local position.
@@ -179,7 +169,7 @@ public:
    * \tparam RT The type representing the requested result.
    */
   template <template <typename, int, int> class RT>
-  requires(canProvideResultType<RT>())
+  requires(supportsResultType<RT>())
   auto calculateAtImpl(const Requirement& req, [[maybe_unused]] const Dune::FieldVector<double, Traits::mydim>& local,
                        Dune::PriorityTag<0>) const {
     using RTWrapper                            = ResultWrapper<RT<double, myDim, myDim>, ResultShape::Vector>;

tests/src/testfeelement.hh

@@ -9,6 +9,7 @@
 #include <dune/fufem/boundarypatch.hh>
 
 #include <ikarus/assembler/simpleassemblers.hh>
+#include "ikarus/finiteelements/feresulttypes.hh"
 #include <ikarus/finiteelements/fefactory.hh>
 #include <ikarus/finiteelements/ferequirements.hh>
 #include <ikarus/finiteelements/mechanics/loads.hh>
@@ -107,6 +108,14 @@ auto testFEElement(const PreBasis& preBasis, const std::string& elementName, con
       << "The element is \n"
       << Dune::className<FEType>();
 
+  t.check(FEType::template supportsResultType<ResultTypes::linearStress>() == true)
+      << "Element should support result type LinearStress, but doesn't"
+      << "\nThe supported types are " << Dune::className<typename FEType::SupportedResultTypes>() << "\n";
+
+  t.check(FEType::template supportsResultType<ResultTypes::PK2Stress>() == false)
+      << "Element should not support result type PK2Stress, but does"
+      << "\nThe supported types are " << Dune::className<typename FEType::SupportedResultTypes>() << "\n";
+
   sparseAssembler->bind(requirements, Ikarus::AffordanceCollections::elastoStatics);
   auto nonLinOp = Ikarus::NonLinearOperatorFactory::op(sparseAssembler);