Merge pull request #516 from thelfer/496-tfel-math-add-better-support…

…-class-template-argument-deduction-ctad

496 tfel math add better support class template argument deduction ctad

docs/web/bibliography.bib

@@ -1,3 +1,16 @@
+@thesis{loiseau_formulation_2023,
+	title = {Formulation de l'endommagement anisotrope des matériaux et stuctures quasi-fragiles basée sur la simulation discrète de la fissuration {\textbar} Theses.fr},
+	url = {https://theses.fr/s253804},
+	abstract = {Les matériaux quasi-fragiles, couramment utilisés pour les structures du génie civil, ont tendance à se dégrader lorsqu'ils sont soumis à des chargements mécaniques. Cette dégradation induit une perte de propriété mécanique et peut induire une anisotropie du comportement qui dépend de la direction du chargement. La prédiction de cette dégradation et de son impact sur le matériau est un enjeu important pour garantir l'intégrité des structures et la sécurité des usagers. Cette problématique est au cœur de ce travail qui vise à formuler un modèle d'endommagement anisotrope (macroscopique) pour les matériaux quasi-fragiles en 2D. Pour ce faire, une base de donnée de tenseurs d'élasticité est générée par essais "virtuels''. Un élément d'aire (mésoscopique) du matériau est représentée par un modèle discret beam-particle fournissant une description explicite de la micro-fissuration. L'évolution du tenseur d'élasticité effectif de l'élément est mesurée pour différents chargements (dont certains multiaxiaux et non proportionnels). L'analyse des tenseurs par le calcul des distances aux classes de symétrie montre qu'une variable tensorielle d'ordre au moins deux est nécessaire pour décrire la micro-fissuration. Afin de faciliter la construction du modèle d'état, une formule de reconstruction du tenseur d'élasticité par ses covariants ainsi qu'une variable d'endommagement sous-jacente, toutes deux issues de travaux précédents, sont rappelées. En se basant sur ces outils ainsi que sur la base de donnée générée, un modèle du tenseur d'élasticité effectif en fonction de la variable d'endommagement, i.e. un modèle d'état, est proposé puis évalué. Concernant la modélisation de l'évolution, la fonction critère de l'élément d'aire est déterminée puis calibrée par essais "virtuels''. Enfin, après une analyse de l'évolution de l'endommagement dans la base de donnée, un modèle (préliminaire) non-standard de l'évolution de l'endommagement est proposé.},
+	institution = {université Paris-Saclay},
+	type = {thesis},
+	author = {Loiseau, Flavien},
+	urldate = {2024-05-06},
+	date = {2023-12-12},
+	langid = {french},
+	file = {Snapshot:/home/th202608/.zotero/zotero/vzpzva46.default/zotero/storage/63DPQ8RF/s253804.html:text/html},
+}
+
 @article{mohanan_intergranular_2024,
 	title = {Intergranular stress and plastic strain formation during laser scanning of additively manufactured stainless steel: An experimentally-driven thermomechanical simulation study},
 	issn = {2589-1529},
@@ -31,6 +44,20 @@ @article{scherer_tensile_2024
 	file = {ScienceDirect Snapshot:/home/th202608/.zotero/zotero/vzpzva46.default/zotero/storage/D7U4PBQV/S0921509324004027.html:text/html},
 }
 
+@thesis{thuillet_modelisation_2023,
+	title = {Modélisation de lois de comportement pour le micro-formage de tôles ultra-fines},
+	rights = {Licence Etalab},
+	url = {https://theses.fr/2023LORIS655},
+	abstract = {La miniaturisation fait maintenant partie intégrante des problématiques actuelles de notre société. Afin de combler l'attente des industries demandeuses de plus en plus de composants de petites tailles, tout en respectant des délais de fabrication courts, les procédés par déformation plastique se sont révélés être les plus efficaces. Pour éviter de nombreux tests expérimentaux la simulation de ces procédés est une alternative importante. L'objectif de cette thèse vise à la définition d'une loi de comportement dédiée aux tôles ultra-fines d'alliages cuivreux présents dans les industries et en particulier l'horlogerie. Une campagne expérimentale est ainsi menée dans le but d'observer le comportement de tôles en cuivre de 0,25 mm d'épaisseur et d'un alliage de cuivre béryllium de 0,20 mm d'épaisseur. La caractérisation microstructurale permet de valider le cadre des tôles ultra-fines grâce à l'étude du nombre et de la taille des grains dans l'épaisseur. Les tests expérimentaux mettent quant à eux en avant le comportement isotrope du cuivre, le {CuBe} possède pour sa part un comportement anisotrope et une prédominance d'écrouissage cinématique. En relation avec les observations expérimentales, deux modèles utilisant une loi élastoviscoplastique sont proposés et comparés, un dans le cadre de la plasticité associée et l'autre employant la plasticité non-associée. Ces modèles prennent notamment en compte un écrouissage mixte. Les paramètres matériaux sont ensuite identifiés à l'aide d'un algorithme de minimisation. Les différentes analyses sur les méthodes de simulations et d'identification indiquent que le modèle de plasticité non-associée est le plus adapté. Des simulations et identifications sur des éléments de volume représentatifs sont suffisantes dans notre cas. Enfin différents procédés de mise en forme sont étudiés et simulés grâce à l'implémentation de la loi de comportement proposée dans un code de calcul par la méthode des éléments finis. Ils mettent en évidence le développement du modèle proposé permettant de prendre en compte un écrouissage mixte. Ce modèle peut donc être utilisé pour la simulation de procédés de mise en forme de tôles ultra-fines d'alliages cuivreux de petites dimensions sous sollicitations complexes},
+	institution = {Lorient},
+	type = {These de doctorat},
+	author = {Thuillet, Stéphanie},
+	editora = {Manach, Pierre Yves and Richard, Fabrice and Thibaud, Sébastien},
+	editoratype = {collaborator},
+	urldate = {2024-05-03},
+	date = {2023-03-03},
+	keywords = {673, Alliages -- Plasticité, Alliages cuivreux, Copper alloys, Déformations (mécanique) -- Modèles mathématiques, Écrouissage mixte, Micro forming process, Micro-formage incrémental, Mixed hardening, Non-associated plasticity, Plasticité non-associée, Travail de la tôle -- Modèles mathématiques},
+}
 
 @article{wang_modelling_2023,
 	title = {Modelling of the elastoplastic behaviour of the bio-cemented soils using an extended Modified Cam Clay model},

docs/web/publications.md

@@ -21,6 +21,8 @@ nocite: |
     @lorenzo_exploring_2024
     @simo_novel_2024
     @singh_irradiation_2024
+    @loiseau_formulation_2023
+	@thuillet_modelisation_2023
     @wang_modelling_2023
     @fokam_implementation_2023
     @bacquaert_standard_2023

docs/web/release-notes-4.1.2.md

@@ -23,6 +23,10 @@ eqnPrefixTemplate: "($$i$$)"
 
 For more details, see <https://github.com/thelfer/tfel/issues/548.
 
+## Issue 541: [tfel-math] support for quantities in `computePushForwardDerivative` and `convertSecondPiolaKirchhoffStressDerivativeToFirstPiolaKirchoffStressDerivative`
+
+For more details, see <https://github.com/thelfer/tfel/issues/540.
+
 ## Issue 540: Allow behaviour to call models with more than one output
 
 For more details, see <https://github.com/thelfer/tfel/issues/540.

docs/web/signorini.md

@@ -118,7 +118,7 @@ where \(K\) is the bulk modulus.
 The Signorini behaviour mostly refers to the following choice of
 \(W^{i}\):
 \[
-W^{i}= C_{10}\,\paren{\bar{I}_{1}-3}+2\,C_{20}\,\paren{\bar{I}_{1}-3}^{2}+C_{01}\,\paren{\bar{I}_{2}-3}
+W^{i}= C_{10}\,\paren{\bar{I}_{1}-3}+C_{20}\,\paren{\bar{I}_{1}-3}^{2}+C_{01}\,\paren{\bar{I}_{2}-3}
 \]
 
 The general expression of the second Piola-Kirchhoff stress is:

include/CMakeLists.txt

@@ -265,7 +265,6 @@ install_header(TFEL/Math/Tensor tensorResultType.hxx)
 install_header(TFEL/Math/Tensor TensorConcept.hxx)
 install_header(TFEL/Math/Tensor TensorConcept.ixx)
 install_header(TFEL/Math/Tensor TensorConceptIO.hxx)
-install_header(TFEL/Math/Tensor TensorSizeToDime.hxx)
 install_header(TFEL/Math/Tensor TensorConceptOperations.hxx)
 install_header(TFEL/Math/Tensor TensorConceptOperations.ixx)
 install_header(TFEL/Math/Tensor TensorProduct.hxx)
@@ -294,7 +293,6 @@ install_header(TFEL/Math/Stensor stensor.ixx)
 install_header(TFEL/Math/Stensor StensorConceptOperations.hxx)
 install_header(TFEL/Math/Stensor StensorConceptOperations.ixx)
 install_header(TFEL/Math/Stensor StensorProduct.hxx)
-install_header(TFEL/Math/Stensor StensorSizeToDime.hxx)
 install_header(TFEL/Math/Stensor stensorResultType.hxx)
 install_header(TFEL/Math/Stensor DecompositionInPositiveAndNegativeParts.hxx)
 install_header(TFEL/Math/Stensor DecompositionInPositiveAndNegativeParts.ixx)

include/TFEL/Config/TFELTypes.hxx

@@ -21,8 +21,6 @@
 #include "TFEL/Math/Forward/stensor.hxx"
 #include "TFEL/Math/Forward/t2tost2.hxx"
 #include "TFEL/Math/Forward/st2tost2.hxx"
-#include "TFEL/Math/Stensor/StensorSizeToDime.hxx"
-#include "TFEL/Math/Tensor/TensorSizeToDime.hxx"
 #include "TFEL/Config/Internals/TFELTypesInternals.hxx"
 
 namespace tfel::config {

include/TFEL/Math/Array/FixedSizeArrayDerivative.hxx

@@ -81,7 +81,9 @@ namespace tfel::math {
    * \tparam Array2Tag: tag of variable
    * \tparam ArrayDerivativeType: type of the array derivative
    */
-  template <typename Array1Tag, typename Array2Tag, typename ArrayDerivativeType>
+  template <typename Array1Tag,
+            typename Array2Tag,
+            typename ArrayDerivativeType>
   struct ConceptRebind<FixedSizeArrayDerivativeTag<Array1Tag, Array2Tag>,
                        ArrayDerivativeType> {
     //! \brief a simple alias

include/TFEL/Math/Forward/stensor.hxx

@@ -42,6 +42,54 @@ namespace tfel::math {
     static constexpr unsigned short dime = N;
   };  // end of MathObjectTraits
 
+  /*!
+   * \class StensorDimeToSize
+   * \brief Metafunction which returns the number of components of
+   * an stensor given the spatial dimension used.
+   * The correspondance between these two numbers is given by the
+   * following table:
+   *
+   * | Spatial Dimension | Number of components  |
+   * | :---------------: | :-------------------: |
+   * | 1                 | 3                     |
+   * | 2                 | 4                     |
+   * | 3                 | 6                     |
+   *
+   * \tparam N : the spatial dimension.
+   */
+  template <unsigned short N>
+  requires((N == 1u) || (N == 2u) || (N == 3u)) struct StensorDimeToSize {
+    static constexpr auto value = []() constexpr -> unsigned short {
+      constexpr unsigned short values[4] = {0u, 3u, 4u, 6u};
+      return values[N];
+    }
+    ();
+  };
+
+  /*!
+   * \class StensorSizeToDime
+   * \brief Metafunction which returns the spatial dimension given
+   * the number of components of a stensor.
+   * \param N, the number of components of an stensor
+   * \param value, the spatial dimension.
+   */
+  template <unsigned short N>
+  requires((N == 3u) || (N == 4u) || (N == 6u)) struct StensorSizeToDime {
+    static constexpr auto value = []() constexpr -> unsigned short {
+      constexpr unsigned short values[7] = {0u, 0u, 0u, 1u, 2u, 0u, 3u};
+      return values[N];
+    }
+    ();
+  };
+
+  /*!
+   * \brief a small helper function around `StensorDimeToSize`
+   */
+  template <unsigned short N>
+  TFEL_HOST_DEVICE constexpr unsigned short getStensorSize() {
+    return StensorDimeToSize<N>::value;
+  }  // end of getStensorSize
+
 }  // end of namespace tfel::math
 
 #endif /* LIB_TFEL_MATH_FORWARD_STENSOR_HXX */

include/TFEL/Math/Forward/tensor.hxx

@@ -41,6 +41,47 @@ namespace tfel::math {
     static constexpr unsigned short dime = N;
   };
 
+  /*!
+   * \class TensorDimeToSize
+   * \brief Metafunction which returns the number of components of
+   * an tensor given the spatial dimension used.
+   * The mapping between these two numbers is given by the
+   * following table:
+   *
+   * | Spatial Dimension | Number of components  |
+   * | :---------------: | :-------------------: |
+   * | 1                 | 3                     |
+   * | 2                 | 5                     |
+   * | 3                 | 9                     |
+   *
+   * \tparam N, the spatial dimension.
+   */
+  template <unsigned short N>
+  requires((N == 1u) || (N == 2u) || (N == 3u)) struct TensorDimeToSize {
+    static constexpr auto value = []() constexpr -> unsigned short {
+      constexpr unsigned short values[4] = {0u, 3u, 5u, 9u};
+      return values[N];
+    }
+    ();
+  };
+
+  /*!
+   * \class TensorSizeToDime
+   * \brief Metafunction which returns the spatial dimension given
+   * the number of components of a tensor.
+   * \param N, the number of components of an tensor
+   * \param value, the spatial dimension.
+   */
+  template <unsigned short N>
+  requires((N == 3u) || (N == 5u) || (N == 9u)) struct TensorSizeToDime {
+    static constexpr auto value = []() constexpr -> unsigned short {
+      constexpr unsigned short values[10] = {0u, 0u, 0u, 1u, 0u,  //
+                                             2u, 0u, 0u, 0u, 3u};
+      return values[N];
+    }
+    ();
+  };
+
 }  // end of namespace tfel::math
 
 #endif /* LIB_TFEL_MATH_FORWARD_TENSOR_HXX */

include/TFEL/Math/Matrix/matrix.ixx

@@ -14,6 +14,8 @@
 #ifndef LIB_TFEL_MATH_MATRIX_IXX
 #define LIB_TFEL_MATH_MATRIX_IXX
 
+#include"TFEL/Raise.hxx"
+
 namespace tfel::math {
 
   template <typename ValueType>
@@ -23,6 +25,36 @@ namespace tfel::math {
     this->resize(r, c, v);
   }  // end of matrix
 
+  template <typename ValueType>
+  matrix<ValueType>::matrix(
+      const std::initializer_list<std::initializer_list<ValueType>>& values) {
+    this->operator=(values);
+  }
+
+  template <typename ValueType>
+  template <typename ValueType2>
+  matrix<ValueType>& matrix<ValueType>::operator=(
+      const std::initializer_list<std::initializer_list<ValueType2>>&
+          values) requires(isAssignableTo<ValueType2, ValueType2>()) {
+    const auto nc = values.begin()->size();
+    for (const auto row : values) {
+      if (row.size() != nc) {
+        raise<std::invalid_argument>("all rows must have the same size");
+      }
+    }
+    this->resize(values.size(), nc);
+    auto i = typename matrix::size_type{};
+    for (const auto row : values) {
+      auto j = typename matrix::size_type{};
+      for (const auto v : row) {
+        this->operator()(i, j) = v;
+        ++j;
+      }
+      ++i;
+    }
+    return *this;
+  }  // end of matrix
+
   template <typename ValueType>
   void matrix<ValueType>::resize(const typename matrix::size_type r,
                                  const typename matrix::size_type c,

include/TFEL/Math/Matrix/tmatrix.ixx

@@ -266,6 +266,21 @@ namespace tfel::math::internals {
 
 namespace tfel::math {
 
+  template <unsigned short N, unsigned short M, typename ValueType>
+  template <std::size_t... d>
+  TFEL_HOST_DEVICE constexpr tmatrix<N, M, ValueType>::tmatrix(
+      ValueType const (&... arrays)[d])  //
+      requires((sizeof...(d) == N) && ((d == M) && ...)) {
+    auto init_row = [this](const typename tmatrix::size_type i,
+                           ValueType const(&values)[M]) {
+      for (typename tmatrix::size_type j = 0u; j < M; ++j) {
+        this->operator()(i, j) = values[j];
+      }
+    };
+    auto i = typename tmatrix::size_type{};
+    (init_row(i++, arrays), ...);
+  }  // end of tmatrix
+
   template <unsigned short N, unsigned short M, typename T>
   TFEL_HOST_DEVICE constexpr unsigned short tmatrix<N, M, T>::getNbCols()
       const {

include/TFEL/Math/ST2toST2/ST2toST2Concept.ixx

@@ -14,7 +14,6 @@
 #define LIB_TFEL_MATH_ST2TOST2_CONCEPT_IXX 1
 
 #include "TFEL/Math/General/Abs.hxx"
-#include "TFEL/Math/Stensor/StensorSizeToDime.hxx"
 #include "TFEL/Math/LU/LUDecomp.hxx"
 #include "TFEL/Math/LU/TinyPermutation.hxx"
 #include "TFEL/Math/ST2toST2/ST2toST2TransposeExpr.hxx"

include/TFEL/Math/ST2toST2/st2tost2.ixx

@@ -29,6 +29,24 @@
 
 namespace tfel::math {
 
+  template <unsigned short N, typename ValueType>
+  template <std::size_t... d>
+  TFEL_HOST_DEVICE constexpr st2tost2<N, ValueType>::st2tost2(
+      ValueType const (&... arrays)[d])  //
+      requires((sizeof...(d) == StensorDimeToSize<N>::value) &&
+               ((d == StensorDimeToSize<N>::value) && ...)) {
+    auto init_row = [this](
+                        const typename st2tost2::size_type i,
+                        ValueType const(&values)[StensorDimeToSize<N>::value]) {
+      for (typename st2tost2::size_type j = 0u; j < StensorDimeToSize<N>::value;
+           ++j) {
+        this->operator()(i, j) = values[j];
+      }
+    };
+    auto i = typename st2tost2::size_type{};
+    (init_row(i++, arrays), ...);
+  }  // end of st2tost2
+
   template <unsigned short N, typename T>
   template <StensorConcept StensorType>
   TFEL_HOST_DEVICE constexpr auto

include/TFEL/Math/ST2toT2/ST2toT2Concept.ixx

@@ -14,9 +14,6 @@
 #ifndef LIB_TFEL_MATH_ST2TOT2_CONCEPT_IXX
 #define LIB_TFEL_MATH_ST2TOT2_CONCEPT_IXX 1
 
-#include "TFEL/Math/Tensor/TensorSizeToDime.hxx"
-#include "TFEL/Math/Stensor/StensorSizeToDime.hxx"
-
 namespace tfel::math {
 
   TFEL_HOST_DEVICE constexpr auto abs(const ST2toT2Concept auto& t) noexcept {

include/TFEL/Math/ST2toT2/st2tot2.ixx

@@ -69,6 +69,24 @@ namespace tfel::math {
     return Expr<st2tot2<N, T>, StensorProductRightDerivativeExpr<N>>(a, C);
   }
 
+  template <unsigned short N, typename ValueType>
+  template <std::size_t... d>
+  TFEL_HOST_DEVICE constexpr st2tot2<N, ValueType>::st2tot2(
+      ValueType const (&... arrays)[d])  //
+      requires((sizeof...(d) == TensorDimeToSize<N>::value) &&
+               ((d == StensorDimeToSize<N>::value) && ...)) {
+    auto init_row = [this](
+                        const typename st2tot2::size_type i,
+                        ValueType const(&values)[StensorDimeToSize<N>::value]) {
+      for (typename st2tot2::size_type j = 0u; j < StensorDimeToSize<N>::value;
+           ++j) {
+        this->operator()(i, j) = values[j];
+      }
+    };
+    auto i = typename st2tot2::size_type{};
+    (init_row(i++, arrays), ...);
+  }  // end of st2tot2
+
   template <unsigned short N, typename T>
   TFEL_HOST_DEVICE constexpr void st2tot2<N, T>::import(
       const base_type<T>* const src) noexcept {

include/TFEL/Math/Stensor/Internals/HarariEigenSolver.ixx

@@ -32,8 +32,8 @@ namespace tfel::math::internals {
                                                       const real D,
                                                       const real E,
                                                       const real F) {
-    constexpr auto sqrt3 = Cste<real>::sqrt3; 
-    constexpr auto one   = real{1};
+    constexpr auto sqrt3 = Cste<real>::sqrt3;
+    constexpr auto one = real{1};
     constexpr const auto one_third = one / 3;
     constexpr auto eye = tmatrix<3u, 3u, real>::Id();
     constexpr const auto eps = std::numeric_limits<real>::min();

include/TFEL/Math/Stensor/Internals/StensorComputeEigenVectors.hxx

@@ -283,12 +283,14 @@ namespace tfel::math::internals {
                     tfel::math::rotation_matrix<T>& vec,
                     const bool b) {
       StensorComputeEigenValues<3u>::exe(s, vp(0), vp(1), vp(2), b);
-      vp = {vp(0),vp(1),vp(2)};
-      return computeEigenVectors<T>(s, vp,  vec);
+      vp = {vp(0), vp(1), vp(2)};
+      return computeEigenVectors<T>(s, vp, vec);
     }
 
     template <typename T>
-    static bool computeEigenVectors(const T* const s, const tfel::math::tvector<3u, T>& vp, tfel::math::rotation_matrix<T>& vec) {
+    static bool computeEigenVectors(const T* const s,
+                                    const tfel::math::tvector<3u, T>& vp,
+                                    tfel::math::rotation_matrix<T>& vec) {
       using namespace std;
       using tfel::math::tvector;
       static_assert(tfel::typetraits::IsFundamentalNumericType<T>::cond);

include/TFEL/Math/Stensor/Internals/StensorEigenSolver.hxx

@@ -136,7 +136,6 @@ namespace tfel::math::internals {
                                                     const bool) {
       auto sm = StensorEigenSolverBase<3u, NumType>::as_base_matrix(v);
       auto vp = tvector<3u, real>{};
-      auto m = tmatrix<3u, 3u, real>{};
       HarariEigensolver3x3<real>::computeEigenValues(
           vp, sm(0, 0), sm(1, 1), sm(2, 2), sm(0, 1), sm(0, 2), sm(1, 2));
       vp0 = NumType(vp[0]);

include/TFEL/Math/Stensor/StensorConcept.ixx

@@ -14,7 +14,6 @@
 
 #include "TFEL/Math/power.hxx"
 #include "TFEL/Math/General/Abs.hxx"
-#include "TFEL/Math/Stensor/StensorSizeToDime.hxx"
 
 namespace tfel::math {
 

include/TFEL/Math/Stensor/StensorConceptIO.hxx

@@ -15,6 +15,7 @@
 #define LIB_TFEL_MATH_STENSORCONCEPTIO_HXX
 
 #include <ostream>
+#include "TFEL/Math/Forward/stensor.hxx"
 #include "TFEL/Math/Stensor/StensorConcept.hxx"
 
 namespace tfel::math {