Fix Issue thelfer#95

Author: thelfer

docs/web/release-notes-2.1.md

@@ -184,8 +184,28 @@ auto outputs = allocatePostProcessingVariables(m, "PrincipalStrain");
 executePostProcessing(outputs, m, "PrincipalStrain");
 ~~~~
 
+## Utility function to extract the value of an internal state variable {#sec:mgis:2.1:extractInternalStateVariable}
+
+The `extractInternalStateVariable` function can now be used to extract
+the value of an internal state variable in a pre-allocated buffer.
+
+### Example of usage
+
+~~~~{.cxx}
+auto m = MaterialDataManager{b, 2u};
+...
+auto pr = std::vector<real>(2u);
+extractInternalStateVariable(pr, m.s1, "HydrostaticPressure");
+~~~~
+
 # Issues solved
 
+## Issue #95: Add an utility function to extract the value of an internal state variable
+
+This feature is described in Section @sec:mgis:2.1:extractInternalStateVariable.
+
+For more details, see <https://github.com/thelfer/MFrontGenericInterfaceSupport/issues/95>.
+
 ## Issue #83: Add support for extended variable types 
 
 This feature is described in depth in Section @sec:mgis:2.1:extended_types.

include/MGIS/Behaviour/MaterialStateManager.hxx

@@ -174,15 +174,14 @@ namespace mgis::behaviour {
     std::vector<mgis::real> stored_energies_values;
     //! \brief value of the dissipated energies, if hold internally
     std::vector<mgis::real> dissipated_energies_values;
-    //! move constructor
+    //! \brief move constructor
     MaterialStateManager(MaterialStateManager&&) = delete;
-    //! copy constructor
+    //! \brief copy constructor
     MaterialStateManager(const MaterialStateManager&) = delete;
-    //! move assignement
+    //! \brief move assignement
     MaterialStateManager& operator=(MaterialStateManager&&) = delete;
-    //! copy assignement
+    //! \brief copy assignement
     MaterialStateManager& operator=(const MaterialStateManager&) = delete;
-
   };  // end of struct MaterialStateManager
 
   /*!
@@ -269,8 +268,22 @@ namespace mgis::behaviour {
    * \param[out] o: output state
    * \param[out] i: input state
    */
-  MGIS_EXPORT void update_values(MaterialStateManager&,
-                                 const MaterialStateManager&);
+  MGIS_EXPORT void updateValues(MaterialStateManager&,
+                                const MaterialStateManager&);
+  /*!
+   * \brief extract an internal state variable
+   *
+   * \param[out] o: buffer in which the values of the given internal state
+   * variable is stored
+   * \param[in] s: material state manager
+   * \param[in] n: name of the internal state variables
+   *
+   * \note the output buffer must be allocated properly
+   */
+  MGIS_EXPORT void extractInternalStateVariable(
+      mgis::span<mgis::real>,
+      const mgis::behaviour::MaterialStateManager&,
+      const mgis::string_view);
 
 }  // end of namespace mgis::behaviour
 

src/MaterialDataManager.cxx

@@ -167,12 +167,12 @@ namespace mgis::behaviour {
 
   void update(MaterialDataManager& m) {
     std::fill(m.K.begin(), m.K.end(), real{0});
-    update_values(m.s0, m.s1);
+    updateValues(m.s0, m.s1);
   }  // end of update
 
   void revert(MaterialDataManager& m) {
     std::fill(m.K.begin(), m.K.end(), real{0});
-    update_values(m.s1, m.s0);
+    updateValues(m.s1, m.s0);
   }  // end of update
 
   std::vector<mgis::real> allocatePostProcessingVariables(

src/MaterialStateManager.cxx

@@ -261,11 +261,11 @@ namespace mgis::behaviour {
     return std::holds_alternative<real>(p->second);
   }  // end of isExternalStateVariableUniform
 
-  void update_values(MaterialStateManager& o, const MaterialStateManager& i) {
+  void updateValues(MaterialStateManager& o, const MaterialStateManager& i) {
     auto check_size = [](const mgis::size_type s1, const mgis::size_type s2) {
       if (s1 != s2) {
         mgis::raise(
-            "mgis::behaviour::update_values: "
+            "mgis::behaviour::updateValues: "
             "arrays' size does not match");
       }
     };  // end of check_size
@@ -323,7 +323,7 @@ namespace mgis::behaviour {
             if (std::find_if(b.mps.begin(), b.mps.end(), find_mp) ==
                 b.mps.end()) {
               mgis::raise(
-                  "mgis::behaviour::update_values: "
+                  "mgis::behaviour::updateValues: "
                   "material property '" +
                   mp.first +
                   "' defined in the material state manager is not defined "
@@ -333,7 +333,7 @@ namespace mgis::behaviour {
         };
     if (&i.b != &o.b) {
       mgis::raise(
-          "mgis::behaviour::update_values: the material state managers "
+          "mgis::behaviour::updateValues: the material state managers "
           "do not holds the same behaviour");
     }
     check_mps(o.b, i.material_properties);
@@ -365,6 +365,61 @@ namespace mgis::behaviour {
     for (const auto& ev : i.external_state_variables) {
       update_field_holder(o.external_state_variables[ev.first], ev.second);
     }
-  }  // end of update_values
+  }  // end of updateValues
+
+  namespace internals {
+
+    void extractScalarInternalStateVariable(
+        mgis::span<mgis::real> o,
+        const mgis::behaviour::MaterialStateManager& s,
+        const mgis::size_type offset) {
+      const auto stride = s.internal_state_variables_stride;
+      auto* const p = o.data();
+      const auto* const piv = s.internal_state_variables.data() + offset;
+      for (mgis::size_type i = 0; i != s.n; ++i) {
+        p[i] = piv[i * stride];
+      }
+    }  // end of extractScalarInternalStateVariable
+
+    void extractInternalStateVariable(
+        mgis::span<mgis::real> o,
+        const mgis::behaviour::MaterialStateManager& s,
+        const mgis::size_type nc,
+        const mgis::size_type offset) {
+      const auto stride = s.internal_state_variables_stride;
+      auto* p = o.data();
+      const auto* const piv = s.internal_state_variables.data() + offset;
+      for (mgis::size_type i = 0; i != s.n; ++i) {
+        const auto is = i * stride;
+        for (mgis::size_type j = 0; j != nc; ++j, ++p) {
+          *p = piv[is + j];
+        }
+      }
+    }  // end of extractScalarInternalStateVariable
+
+  }  // end of namespace internals
+
+  void extractInternalStateVariable(
+      mgis::span<mgis::real> o,
+      const mgis::behaviour::MaterialStateManager& s,
+      const mgis::string_view n) {
+    const auto& iv = mgis::behaviour::getVariable(s.b.isvs, n);
+    const auto nc = mgis::behaviour::getVariableSize(iv, s.b.hypothesis);
+    const auto offset =
+        mgis::behaviour::getVariableOffset(s.b.isvs, n, s.b.hypothesis);
+    // checking compatibility
+    if (o.size() != s.n * nc) {
+      mgis::raise(
+          "extractInternalStateVariable: "
+          "unmatched number of integration points");
+    }
+    if (nc == 1) {
+      mgis::behaviour::internals::extractScalarInternalStateVariable(o, s,
+                                                                     offset);
+    } else {
+      mgis::behaviour::internals::extractInternalStateVariable(o, s, nc,
+                                                               offset);
+    }
+  }  // end of extractInternalStateVariable
 
 }  // end of namespace mgis::behaviour