Merge pull request #167 from thelfer/166-function-make-check-a-free-function

thelfer · web-flow · commit c95859bc06ca · 2025-09-08T22:29:50.000+02:00
Fix Issue #166
diff --git a/include/MGIS/Function/Algorithms.ixx b/include/MGIS/Function/Algorithms.ixx
@@ -259,7 +259,7 @@ namespace mgis::function {
       return ctx.registerErrorMessage("unmatched number of components");
     }
     //
-    if (!e.check(ctx)) {
+    if (!check(ctx, e)) {
       return false;
     }
     allocateWorkspace(e);
@@ -284,7 +284,7 @@ namespace mgis::function {
       return ctx.registerErrorMessage("non scalar evaluator");
     }
     //
-    if (!e.check(ctx)) {
+    if (!check(ctx, e)) {
       return false;
     }
     allocateWorkspace(e);
diff --git a/include/MGIS/Function/BinaryOperationEvaluatorBase.hxx b/include/MGIS/Function/BinaryOperationEvaluatorBase.hxx
@@ -120,6 +120,15 @@ namespace mgis::function {
       const BinaryOperationEvaluatorBase<Child,
                                          FirstEvaluatorType,
                                          SecondEvaluatorType>&);
+  //! \brief perform consistency checks
+  template <typename Child,
+            EvaluatorConcept FirstEvaluatorType,
+            EvaluatorConcept SecondEvaluatorType>
+  constexpr bool check(
+      AbstractErrorHandler&,
+      const BinaryOperationEvaluatorBase<Child,
+                                         FirstEvaluatorType,
+                                         SecondEvaluatorType>&);
   //! \brief allocate internal workspace
   template <typename Child,
             EvaluatorConcept FirstEvaluatorType,
diff --git a/include/MGIS/Function/BinaryOperationEvaluatorBase.ixx b/include/MGIS/Function/BinaryOperationEvaluatorBase.ixx
@@ -58,10 +58,10 @@ namespace mgis::function {
                              this->second_evaluator)) {
       return false;
     }
-    if (!this->first_evaluator.check(ctx)) {
+    if (!internals::disambiguateCheck(ctx, this->first_evaluator)) {
       return false;
     }
-    if (!this->second_evaluator.check(ctx)) {
+    if (!internals::disambiguateCheck(ctx, this->second_evaluator)) {
       return false;
     }
     return true;
@@ -169,6 +169,17 @@ namespace mgis::function {
     return e.getSpace();
   }  // end of getSpace
 
+  template <typename Child,
+            EvaluatorConcept FirstEvaluatorType,
+            EvaluatorConcept SecondEvaluatorType>
+  constexpr bool check(
+      AbstractErrorHandler& eh,
+      const BinaryOperationEvaluatorBase<Child,
+                                         FirstEvaluatorType,
+                                         SecondEvaluatorType>& e) {
+    return e.check(eh);
+  }  // end of check
+
   template <typename Child,
             EvaluatorConcept FirstEvaluatorType,
             EvaluatorConcept SecondEvaluatorType>
diff --git a/include/MGIS/Function/EvaluatorConcept.hxx b/include/MGIS/Function/EvaluatorConcept.hxx
@@ -153,6 +153,8 @@ namespace mgis::function {
     allocateWorkspace(e);
   } && requires(const EvaluatorType& e) {
     { getNumberOfComponents(e) } -> std::same_as<mgis::size_type>;
+  } && requires(const EvaluatorType& e, AbstractErrorHandler& eh) {
+    { check(eh, e) } -> std::same_as<bool>;
   } &&((internals::EvaluatorResultQuery<EvaluatorType>::b1) ||
        (internals::EvaluatorResultQuery<EvaluatorType>::b2) ||
        (internals::EvaluatorResultQuery<EvaluatorType>::b3) ||
@@ -233,6 +235,12 @@ namespace mgis::function {
      * the allocateWorkspace function
      */
     template <EvaluatorConcept EvaluatorType>
+    constexpr bool disambiguateCheck(AbstractErrorHandler&, const EvaluatorType&);
+    /*!
+     * This helper function allows to disambiguate the call to
+     * the allocateWorkspace function
+     */
+    template <EvaluatorConcept EvaluatorType>
     constexpr void disambiguateAllocateWorkspace(const EvaluatorType&);
     /*!
      * This helper function allows to disambiguate the call to
diff --git a/include/MGIS/Function/EvaluatorConcept.ixx b/include/MGIS/Function/EvaluatorConcept.ixx
@@ -15,6 +15,11 @@ namespace mgis::function::internals {
     return getSpace(e);
   }
 
+  template <EvaluatorConcept EvaluatorType>
+  constexpr bool disambiguateCheck(AbstractErrorHandler& ctx, const EvaluatorType& e){
+    return check(ctx, e);
+  }
+  
   template <EvaluatorConcept EvaluatorType>
   constexpr void disambiguateAllocateWorkspace(EvaluatorType& e) {
     allocateWorkspace(e);
diff --git a/include/MGIS/Function/EvaluatorModifierBase.hxx b/include/MGIS/Function/EvaluatorModifierBase.hxx
@@ -77,6 +77,10 @@ namespace mgis::function {
   template <typename Child, EvaluatorConcept EvaluatorType>
   constexpr decltype(auto) getSpace(
       const EvaluatorModifierBase<Child, EvaluatorType>&);
+  //! \brief perform consistency checks
+  template <typename Child, EvaluatorConcept EvaluatorType>
+  constexpr bool check(AbstractErrorHandler&,
+                       const EvaluatorModifierBase<Child, EvaluatorType>&);
   //! \brief allocate internal workspace
   template <typename Child, EvaluatorConcept EvaluatorType>
   constexpr void allocateWorkspace(
diff --git a/include/MGIS/Function/EvaluatorModifierBase.ixx b/include/MGIS/Function/EvaluatorModifierBase.ixx
@@ -26,7 +26,7 @@ namespace mgis::function {
   template <typename Child, EvaluatorConcept EvaluatorType>
   constexpr bool EvaluatorModifierBase<Child, EvaluatorType>::check(
       AbstractErrorHandler& ctx) const {
-    return this->evaluator.check(ctx);
+    return internals::disambiguateCheck(ctx, this->evaluator);
   }  // end of check
 
   template <typename Child, EvaluatorConcept EvaluatorType>
@@ -81,6 +81,12 @@ namespace mgis::function {
     return e.getSpace();
   }
 
+  template <typename Child, EvaluatorConcept EvaluatorType>
+  constexpr bool check(AbstractErrorHandler& eh,
+                       const EvaluatorModifierBase<Child, EvaluatorType>& e) {
+    return e.check(eh);
+  }  // end of check
+
   template <typename Child, EvaluatorConcept EvaluatorType>
   constexpr void allocateWorkspace(
       EvaluatorModifierBase<Child, EvaluatorType>& e) {
diff --git a/include/MGIS/Function/FixedSizeModifier.hxx b/include/MGIS/Function/FixedSizeModifier.hxx
@@ -106,7 +106,10 @@ namespace mgis::function {
 
   template <EvaluatorConcept EvaluatorType, size_type N>
   decltype(auto) getSpace(const FixedSizeModifier<EvaluatorType, N>&);
-
+  //! \brief perform consistency checks
+  template <EvaluatorConcept EvaluatorType, size_type N>
+  constexpr bool check(AbstractErrorHandler&,
+                       const FixedSizeModifier<EvaluatorType, N>&);
   //! \brief allocate internal workspace
   template <EvaluatorConcept EvaluatorType, size_type N>
   constexpr void allocateWorkspace(FixedSizeModifier<EvaluatorType, N>&);
diff --git a/include/MGIS/Function/FixedSizeModifier.ixx b/include/MGIS/Function/FixedSizeModifier.ixx
@@ -184,6 +184,12 @@ namespace mgis::function {
     return e.getSpace();
   }  // end of getSpace
 
+  template <EvaluatorConcept EvaluatorType, size_type N>
+  constexpr bool check(AbstractErrorHandler& eh,
+                       const FixedSizeModifier<EvaluatorType, N>& e){
+    return e.check(eh);
+  } // end of check
+
   template <EvaluatorConcept EvaluatorType, size_type N>
   constexpr void allocateWorkspace(FixedSizeModifier<EvaluatorType, N>& e) {
     return e.allocateWorkspace();
diff --git a/include/MGIS/Function/FixedSizeView.hxx b/include/MGIS/Function/FixedSizeView.hxx
@@ -145,7 +145,10 @@ namespace mgis::function {
 
   template <FunctionConcept FunctionType, size_type N>
   constexpr decltype(auto) getSpace(const FixedSizeView<FunctionType, N>&);
-
+  //! \brief perform consistency checks
+  template <FunctionConcept FunctionType, size_type N>
+  constexpr bool check(AbstractErrorHandler&,
+                       const FixedSizeView<FunctionType, N>&);
   //! \brief allocate internal workspace
   template <FunctionConcept FunctionType, size_type N>
   constexpr void allocateWorkspace(FixedSizeView<FunctionType, N>&) noexcept;
diff --git a/include/MGIS/Function/FixedSizeView.ixx b/include/MGIS/Function/FixedSizeView.ixx
@@ -290,6 +290,12 @@ namespace mgis::function {
     return v.getSpace();
   }  // end of getSpace
 
+  template <FunctionConcept FunctionType, size_type N>
+  constexpr bool check(AbstractErrorHandler& eh,
+                       const FixedSizeView<FunctionType, N>& v) {
+    return v.check(eh);
+  }  // end of check
+
   template <FunctionConcept FunctionType, size_type N>
   constexpr void allocateWorkspace(FixedSizeView<FunctionType, N>&) noexcept {
   }  // end of allocateWorkspace
diff --git a/include/MGIS/Function/Function.hxx b/include/MGIS/Function/Function.hxx
@@ -448,8 +448,6 @@ namespace mgis::function {
     constexpr FunctionView(const FunctionView&) = default;
     //! \return the underlying quadrature space
     constexpr const Space& getSpace() const noexcept;
-    //! \brief a noop function to match the EvaluatorConcept concept
-    constexpr bool check(AbstractErrorHandler&) const;
     /*!
      * \return the data associated with an integration point
      * \param[in] o: offset associated with the integration point
@@ -548,6 +546,14 @@ namespace mgis::function {
             bool is_mutable>
   constexpr void allocateWorkspace(
       FunctionView<Space, layout, is_mutable>&) noexcept;
+
+  //! \brief a noop function to match the EvaluatorConcept concept
+  template <FunctionalSpaceConcept Space,
+            FunctionDataLayoutDescription layout,
+            bool is_mutable>
+  constexpr bool check(AbstractErrorHandler&,
+                       const FunctionView<Space, layout, is_mutable>&) noexcept;
+
   /*!
    * \return the number of components of a view
    * \param[in] v: view
@@ -678,13 +684,6 @@ namespace mgis::function {
                         std::initializer_list<real>) noexcept;
     //! \brief destructor
     constexpr ~Function();
-
-   protected:
-    /*
-     * This function is made protected to avoid Function from being treated
-     * as an evaluator
-     */
-    using FunctionView<Space, {.data_size = N, .data_stride = N}, true>::check;
   };
 
   // class template deduction guide
@@ -716,7 +715,11 @@ namespace mgis::function {
   //! \brief deleted function so that Function does not match the
   //! EvaluatorConcept
   template <FunctionalSpaceConcept Space, size_type N>
-  constexpr void allocateWorkspace(const Function<Space, N>&) noexcept = delete;
+   void check(AbstractErrorHandler&, const Function<Space, N>&) = delete;
+  //! \brief deleted function so that Function does not match the
+  //! EvaluatorConcept
+  template <FunctionalSpaceConcept Space, size_type N>
+  void allocateWorkspace(const Function<Space, N>&) = delete;
 
 }  // namespace mgis::function
 
diff --git a/include/MGIS/Function/Function.ixx b/include/MGIS/Function/Function.ixx
@@ -479,16 +479,6 @@ namespace mgis::function {
     return this->space;
   }  // end of getSpace
 
-  template <FunctionalSpaceConcept Space,
-            FunctionDataLayoutDescription layout,
-            bool is_mutable>
-  requires(LinearElementSpaceConcept<Space> ||
-           LinearQuadratureSpaceConcept<Space>)  //
-      constexpr bool FunctionView<Space, layout, is_mutable>::check(
-          AbstractErrorHandler&) const {
-    return true;
-  }  // end of allocateWorkspace
-
   template <FunctionalSpaceConcept Space,
             FunctionDataLayoutDescription layout,
             bool is_mutable>
@@ -616,6 +606,15 @@ namespace mgis::function {
     return this->values;
   }
 
+  template <FunctionalSpaceConcept Space,
+            FunctionDataLayoutDescription layout,
+            bool is_mutable>
+  constexpr bool check(
+      AbstractErrorHandler&,
+      const FunctionView<Space, layout, is_mutable>&) noexcept {
+    return true;
+  }  // end of check
+
   template <FunctionalSpaceConcept Space,
             FunctionDataLayoutDescription layout,
             bool is_mutable>
diff --git a/include/MGIS/Function/Mechanics.ixx b/include/MGIS/Function/Mechanics.ixx
@@ -50,8 +50,10 @@ namespace mgis::function::internals {
       return ((checkMatchingSpaces(ctx, this->K, this->F0)) &&
               (checkMatchingSpaces(ctx, this->K, this->F1)) &&
               (checkMatchingSpaces(ctx, this->K, this->s)) &&
-              (this->K.check(ctx)) && (this->F0.check(ctx)) &&
-              (this->F1.check(ctx)) && (this->s.check(ctx)));
+              (internals::disambiguateCheck(ctx, this->K)) &&
+	      (internals::disambiguateCheck(ctx, this->F0)) &&
+	      (internals::disambiguateCheck(ctx, this->F1)) &&
+	      (internals::disambiguateCheck(ctx, this->s)));
     }
 
     //! \brief allocate internal workspace
@@ -143,6 +145,25 @@ namespace mgis::function::internals {
     CauchyStressEvaluatorType s;
   };
 
+  template <unsigned short N,
+            FiniteStrainStiffnessKind ResultFlag,
+            FiniteStrainStiffnessKind SourceFlag,
+            FourthOrderTensorEvaluatorConcept StiffnessEvaluator,
+            TensorEvaluatorConcept DeformationGradientEvaluatorType0,
+            TensorEvaluatorConcept DeformationGradientEvaluatorType1,
+            StensorEvaluatorConcept CauchyStressEvaluatorType>
+  constexpr bool check(
+      AbstractErrorHandler& eh,
+      const ConvertFiniteStrainStiffnessEvaluator<N,
+                                                  ResultFlag,
+                                                  SourceFlag,
+                                                  StiffnessEvaluator,
+                                                  DeformationGradientEvaluatorType0,
+                                                  DeformationGradientEvaluatorType1,
+                                                  CauchyStressEvaluatorType>& e) {
+    return e.check(eh);
+  }  // end of check
+
   template <unsigned short N,
             FiniteStrainStiffnessKind ResultFlag,
             FiniteStrainStiffnessKind SourceFlag,
diff --git a/include/MGIS/Function/Tensors/TensorView.hxx b/include/MGIS/Function/Tensors/TensorView.hxx
@@ -136,6 +136,10 @@ namespace mgis::function {
   template <FunctionConcept FunctionType, TensorConcept TensorType>
   constexpr decltype(auto) getSpace(
       const TensorView<FunctionType, TensorType>&);
+    //! \brief perform consistency checks
+  template <FunctionConcept FunctionType, TensorConcept TensorType>
+  constexpr bool check(AbstractErrorHandler&,
+                       const TensorView<FunctionType, TensorType>&);
   //! \brief allocate internal workspace
   template <FunctionConcept FunctionType, TensorConcept TensorType>
   constexpr void allocateWorkspace(
diff --git a/include/MGIS/Function/Tensors/TensorView.ixx b/include/MGIS/Function/Tensors/TensorView.ixx
@@ -202,6 +202,12 @@ namespace mgis::function {
     return t.getSpace();
   }
 
+  template <FunctionConcept FunctionType, TensorConcept TensorType>
+  constexpr bool check(AbstractErrorHandler& eh,
+                       const TensorView<FunctionType, TensorType>& v) {
+    return v.check(eh);
+  }  // end of check
+
   template <FunctionConcept FunctionType, TensorConcept TensorType>
   constexpr void allocateWorkspace(
       TensorView<FunctionType, TensorType>&) noexcept {

Original file line number	Diff line number	Diff line change
`@@ -259,7 +259,7 @@ namespace mgis::function {`
`259`	`259`	`return ctx.registerErrorMessage("unmatched number of components");`
`260`	`260`	`}`
`261`	`261`	`//`
`262`		`- if (!e.check(ctx)) {`
	`262`	`+ if (!check(ctx, e)) {`
`263`	`263`	`return false;`
`264`	`264`	`}`
`265`	`265`	`allocateWorkspace(e);`
`@@ -284,7 +284,7 @@ namespace mgis::function {`
`284`	`284`	`return ctx.registerErrorMessage("non scalar evaluator");`
`285`	`285`	`}`
`286`	`286`	`//`
`287`		`- if (!e.check(ctx)) {`
	`287`	`+ if (!check(ctx, e)) {`
`288`	`288`	`return false;`
`289`	`289`	`}`
`290`	`290`	`allocateWorkspace(e);`