Fix Issue #54

Author: thelfer

bindings/c/include/MGIS/Behaviour/Behaviour.h

@@ -707,6 +707,20 @@ MGIS_C_EXPORT mgis_status mgis_bv_behaviour_get_lower_physical_bound(
  */
 MGIS_C_EXPORT mgis_status mgis_bv_behaviour_get_upper_physical_bound(
     long double* const, const mgis_bv_Behaviour* const, const char* const);
+/*!
+ * \brief return if the behaviour computes the stored energy
+ * \param[out] v: returned value
+ * \param[in] b: behaviour
+ */
+MGIS_C_EXPORT mgis_status mgis_bv_behaviour_computes_stored_energy(
+      int* const, const mgis_bv_Behaviour* const );
+/*!
+ * \brief return if the behaviour computes the dissipated energy
+ * \param[out] v: returned value
+ * \param[in] b: behaviour
+ */
+MGIS_C_EXPORT mgis_status mgis_bv_behaviour_computes_dissipated_energy(
+    int* const, const mgis_bv_Behaviour* const);
 /*!
  * \brief free the memory associated with the given behaviour.
  * \param[in,out] b: behaviour

bindings/c/src/Behaviour.cxx

@@ -990,6 +990,24 @@ mgis_bv_finite_strain_behaviour_options_set_tangent_operator_by_string(
     return mgis_report_success();
   }  // end of mgis_bv_behaviour_get_upper_physical_bound
 
+  mgis_status mgis_bv_behaviour_computes_stored_energy(
+      int* const v, const mgis_bv_Behaviour* const b) {
+    if ((b == nullptr) || (v == nullptr)) {
+      return mgis_report_failure("invalid argument");
+    }
+    *v = static_cast<int>(b->computesStoredEnergy);
+    return mgis_report_success();
+  }  // end of mgis_bv_behaviour_computes_stored_energy
+
+  mgis_status mgis_bv_behaviour_computes_dissipated_energy(
+      int* const v, const mgis_bv_Behaviour* const b) {
+    if ((b == nullptr) || (v == nullptr)) {
+      return mgis_report_failure("invalid argument");
+    }
+    *v = static_cast<int>(b->computesDissipatedEnergy);
+    return mgis_report_success();
+  }  // end of mgis_bv_behaviour_computes_dissipated_energy
+
   mgis_status mgis_bv_free_behaviour(mgis_bv_Behaviour * *b) {
     try {
       delete *b;

bindings/fortran/src/mgis_behaviour.f95

@@ -1355,6 +1355,71 @@ end function behaviour_get_external_state_variable_type_wrapper
     s = behaviour_get_external_state_variable_type_wrapper(t, b%ptr, nc)
   end function behaviour_get_external_state_variable_type
   !
+  function behaviour_computes_stored_energy(v, b) result(s)
+    use, intrinsic :: ieee_arithmetic, only: ieee_value, ieee_quiet_nan
+    use, intrinsic :: iso_c_binding, only: c_int
+    use mgis_fortran_utilities
+    use mgis, only: mgis_status, MGIS_SUCCESS
+    implicit none
+    interface
+       function behaviour_computes_stored_energy_wrapper(v, b) &
+            bind(c,name='mgis_bv_behaviour_computes_stored_energy') result(s)
+         use, intrinsic :: iso_c_binding, only: c_ptr, c_int
+         use mgis, only: mgis_status
+         integer(kind=c_int), intent(out) :: v
+         type(c_ptr), intent(in), value :: b
+         type(mgis_status) :: s
+       end function behaviour_computes_stored_energy_wrapper
+    end interface
+    logical, intent(out) :: v
+    type(Behaviour), intent(in) :: b
+    type(mgis_status) :: s
+    integer(kind=c_int) :: vc
+    s = behaviour_computes_stored_energy_wrapper(vc, b%ptr)
+    if( s % exit_status .eq. MGIS_SUCCESS) then
+       if (vc .eq. 1) then
+          v = .TRUE.
+       else
+          v = .FALSE.
+       end if
+    else
+       v = .FALSE.     
+    end if
+  end function behaviour_computes_stored_energy
+  !
+  function behaviour_computes_dissipated_energy(v, b) result(s)
+    use, intrinsic :: ieee_arithmetic, only: ieee_value, ieee_quiet_nan
+    use, intrinsic :: iso_c_binding, only: c_int
+    use mgis_fortran_utilities
+    use mgis, only: mgis_status, MGIS_SUCCESS
+    implicit none
+    interface
+       function behaviour_computes_dissipated_energy_wrapper(v, b) &
+            bind(c,name='mgis_bv_behaviour_computes_dissipated_energy') &
+            result(s)
+         use, intrinsic :: iso_c_binding, only: c_ptr, c_int
+         use mgis, only: mgis_status
+         integer(kind=c_int), intent(out) :: v
+         type(c_ptr), intent(in), value :: b
+         type(mgis_status) :: s
+       end function behaviour_computes_dissipated_energy_wrapper
+    end interface
+    logical, intent(out) :: v
+    type(Behaviour), intent(in) :: b
+    type(mgis_status) :: s
+    integer(kind=c_int) :: vc
+    s = behaviour_computes_dissipated_energy_wrapper(vc, b%ptr)
+    if( s % exit_status .eq. MGIS_SUCCESS) then
+       if (vc .eq. 1) then
+          v = .TRUE.
+       else
+          v = .FALSE.
+       end if
+    else
+       v = .FALSE.     
+    end if
+  end function behaviour_computes_dissipated_energy
+  !
   function behaviour_has_bounds(r, b, n) result(s)
     use, intrinsic :: iso_c_binding, only: c_int
     use mgis_fortran_utilities

bindings/python/mgis/fenics/nonlinear_material.py

@@ -154,5 +154,5 @@ def get_tangent_block_names(self):
         return [(t[0].name, t[1].name) for t in self.behaviour.tangent_operator_blocks]
 
     def get_tangent_block_sizes(self):
-        return [tuple([mgis_bv.getVariableSize(tt, self.hypothesis) for tt in t]) \
+        return [tuple([mgis_bv.getVariableSize(tt, self.hypothesis) for tt in t])
                 for t in self.behaviour.tangent_operator_blocks]

bindings/python/src/Behaviour.cxx

@@ -354,6 +354,12 @@ void declareBehaviour() {
                     "version of TFEL used to generate the behaviour")
       .add_property("btype", &Behaviour::btype,
                     "return the type of the behaviour")
+      .def_readonly(
+          "computesStoredEnergy", &Behaviour::computesStoredEnergy,
+          "a boolean stating if the behaviour computes the stored energy")
+      .def_readonly(
+          "computesDissipatedEnergy", &Behaviour::computesDissipatedEnergy,
+          "a boolean stating if the behaviour computes the dissipated energy")
       .def("getBehaviourType", &Behaviour_getType,
            "return the type of the behaviour")
       .add_property("kinematic", &Behaviour::kinematic,

bindings/python/src/MaterialStateManager.cxx

@@ -69,11 +69,21 @@ static boost::python::object MaterialStateManager_getInternalStateVariables(
 
 static boost::python::object MaterialStateManager_getStoredEnergies(
     mgis::behaviour::MaterialStateManager& s) {
+  if (!s.b.computesStoredEnergy) {
+    mgis::raise(
+        "MaterialStateManager_getStoredEnergies: "
+        "the stored energy is not computed by the behaviour");
+  }
   return mgis::python::wrapInNumPyArray(s.stored_energies);
 }  // end of MaterialStateManager_getStoredEnergy
 
 static boost::python::object MaterialStateManager_getDissipatedEnergies(
     mgis::behaviour::MaterialStateManager& s) {
+  if (!s.b.computesDissipatedEnergy) {
+    mgis::raise(
+        "MaterialStateManager_getDissipatedEnergies: "
+        "the dissipated energy is not computed by the behaviour");
+  }
   return mgis::python::wrapInNumPyArray(s.dissipated_energies);
 }  // end of MaterialStateManager_getDissipatedEnergy
 

docs/web/release-notes-1.2.md

@@ -21,6 +21,12 @@ bibliography: bibliography.bib
 Version 1.2 of `MFrontGenericInterfaceSupport` is compatible with the
 Version 3.4 of `TFEL/MFront`.
 
+# Known incompatibilities
+
+The `stored_energies` and `dissipated_energies` are now automatically
+allocated only of the behaviours by the `MaterialStateManager` class
+only if the behaviours is able to compute them.
+
 # New functionalities
 
 ## Orthotropic behaviours
@@ -121,6 +127,24 @@ module:
 
 # Issues solved
 
+## Issues #54: Inform the calling code about `@DissipatedEnergy` and/or `@InternalEnergy`
+
+The `Behaviour` class now exposes two new boolean data members:
+
+- `computesStoredEnergy`: if true, the behaviour computes the stored energy
+- `computesDissipatedEnergy`: if false, the behaviour computes the dissipated energy
+
+In the `C` bindings, the `mgis_bv_behaviour_computes_stored_energy`  and `mgis_bv_behaviour_computes_dissipated_energy` functions are now available.
+
+In the `fortran` bindings, the functions `behaviour_computes_stored_energy` and `behaviour_computes_dissipated_energy` are now available in the `mgis_behaviour` module.
+
+In the `python` bindings, the `Behaviour` class now exposes two read only properties: `computesStoredEnergy` and `computesDissipatedEnergy`.
+
+The `MaterialDataManager` constructor now only allocates the memory associated with the stored and disspated energies only if the behaviour computes those energies.
+
+For details, see <https://github.com/thelfer/MFrontGenericInterfaceSupport/issues/54>
+
+
 ## Issue #33: Function for checking if the behaviour is a Finite Strain one
 
 The `mgis::behaviour::isStandardFiniteStrainBehaviour` has been added to

include/MGIS/Behaviour/Behaviour.hxx

@@ -118,26 +118,40 @@ namespace mgis {
         FINITESTRAINKINEMATIC_F_CAUCHY,
         FINITESTRAINKINEMATIC_ETO_PK1
       } kinematic;
-      //! behaviour symmetry
+      //! \brief behaviour symmetry
       Symmetry symmetry;
-      //! gradients
+      //! \brief gradients
       std::vector<Variable> gradients;
-      //! thermodynamic forces associated to gradients
+      //! \brief thermodynamic forces associated to gradients
       std::vector<Variable> thermodynamic_forces;
-      //! material properties
+      //! \brief material properties
       std::vector<Variable> mps;
-      //! internal state variables
+      //! \brief internal state variables
       std::vector<Variable> isvs;
-      //! external state variables
+      //! \brief external state variables
       std::vector<Variable> esvs;
-      //! tangent operator blocks
+      //! \brief tangent operator blocks
       std::vector<std::pair<Variable, Variable>> to_blocks;
-      //! real parameters
+      //! \brief real parameters
       std::vector<std::string> params;
-      //! integer parameters
+      //! \brief integer parameters
       std::vector<std::string> iparams;
-      //! unsigned short parameters
+      //! \brief unsigned short parameters
       std::vector<std::string> usparams;
+      /*!
+       * \brief this boolean is true if the behaviour computes the
+       * energy stored by the material per unit of volume in the reference
+       * configuration. The physical meaning of this
+       * energy depends on the behaviour considered.
+       */
+      bool computesStoredEnergy;
+      /*!
+       * \brief this boolean is true if the behaviour computes the
+       * energy dissipated by the material per unit of volume in the 
+       * reference configuration. The physical meaning of this
+       * energy depends on the behaviour considered.
+       */
+      bool computesDissipatedEnergy;
       /*!
        * \brief behaviour options
        *

include/MGIS/Behaviour/MaterialDataManager.hxx

@@ -109,7 +109,6 @@ namespace mgis {
       MaterialDataManager& operator=(MaterialDataManager&&) = delete;
       //! copy assignement
       MaterialDataManager& operator=(const MaterialDataManager&) = delete;
-
     };  // end of struct MaterialDataManager
 
     /*!

include/MGIS/Behaviour/MaterialStateManager.hxx

@@ -42,7 +42,7 @@ namespace mgis {
       /*!
        * \brief view to an externally allocated memory used to store the
        * gradients. If empty, the material state manager will
-       * initialize the required memory internally. 
+       * initialize the required memory internally.
        */
       mgis::span<mgis::real> gradients;
       /*!
@@ -60,13 +60,23 @@ namespace mgis {
       /*!
        * \brief view to an externally allocated memory used to store the stored
        * energies. If empty, the material state manager will initialize the
-       * required memory internally.
+       * required memory internally, if the behaviour computes the stored
+       * energy.
+       *
+       * \note for backward compatibililty, the user may allocate memory for the
+       * stored energies even if the behaviour don't compute the stored
+       * energy.
        */
       mgis::span<mgis::real> stored_energies;
       /*!
        * \brief view to an externally allocated memory used to store the
        * dissipated energies. If empty, the material state manager will
-       * initialize the required memory internally.
+       * initialize the required memory internally, if the behaviour computes
+       * the dissipated energy.
+       *
+       * \note for backward compatibililty, the user may allocate memory for the
+       * dissipated energies even if the behaviour don't compute the dissipated
+       * energy.
        */
       mgis::span<mgis::real> dissipated_energies;
     };  // end of MaterialStateManagerInitializer
@@ -93,10 +103,10 @@ namespace mgis {
         LOCAL_STORAGE,    //! \brief use `std::vector` to store the data
         EXTERNAL_STORAGE  //! \brief use `mgis::span`  to store the data
       };                  // end of StorageMode
-      /*!
-       * \param[in] behaviour: behaviour
-       * \param[in] s: number of integration points
-       */
+                          /*!
+                           * \param[in] behaviour: behaviour
+                           * \param[in] s: number of integration points
+                           */
       MaterialStateManager(const Behaviour&, const size_type);
       /*!
        * \param[in] behaviour: behaviour