147 create an integrate debug function which could generate mtest files on integration errors

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

@@ -107,10 +107,14 @@ MGIS_C_EXPORT mgis_status mgis_bv_free_behaviour_integration_options(
  * \param[in,out] d: behaviour data
  * \param[in,out] b: behaviour
  */
-
 MGIS_C_EXPORT mgis_status mgis_bv_integrate(int* const,
                                             mgis_bv_BehaviourDataView* const,
                                             const mgis_bv_Behaviour* const);
+//! \brief debugging version
+MGIS_C_EXPORT mgis_status
+mgis_bv_integrate_debug(int* const,
+                        mgis_bv_BehaviourDataView* const,
+                        const mgis_bv_Behaviour* const);
 /*!
  * \brief integrate the behaviour. The returned value has the following
  * meaning:
@@ -130,6 +134,9 @@ MGIS_C_EXPORT mgis_status mgis_bv_integrate(int* const,
 MGIS_C_EXPORT mgis_status mgis_bv_integrate_2(int* const,
 					      mgis_bv_BehaviourData* const,
 					      const mgis_bv_Behaviour* const);
+//! \brief debugging version
+MGIS_C_EXPORT mgis_status mgis_bv_integrate_debug_2(
+    int* const, mgis_bv_BehaviourData* const, const mgis_bv_Behaviour* const);
 /*!
  * \brief integrate the behaviour for a range of integration points. The
  * returned value has the following meaning:
@@ -152,6 +159,14 @@ mgis_bv_integrate_material_data_manager_part(int* const,
                                              const mgis_real,
                                              const mgis_size_type,
                                              const mgis_size_type);
+//! \brief debugging version
+MGIS_C_EXPORT mgis_status
+mgis_bv_integrate_debug_material_data_manager_part(int* const,
+                                             mgis_bv_MaterialDataManager* const,
+                                             const mgis_bv_IntegrationType,
+                                             const mgis_real,
+                                             const mgis_size_type,
+                                             const mgis_size_type);
 /*!
  * \brief integrate the behaviour for a range of integration points. The
  * returned value has the following meaning:
@@ -172,14 +187,29 @@ mgis_bv_integrate_material_data_manager(int* const,
                                         mgis_bv_MaterialDataManager* const,
                                         const mgis_bv_IntegrationType,
                                         const mgis_real);
+//! \brief debugging version
+MGIS_C_EXPORT mgis_status mgis_bv_integrate_debug_material_data_manager(
+    int* const,
+    mgis_ThreadPool* const,
+    mgis_bv_MaterialDataManager* const,
+    const mgis_bv_IntegrationType,
+    const mgis_real);
 
 MGIS_C_EXPORT mgis_status
 mgis_bv_integrate_material_data_manager_with_options(int* const,
                                                      mgis_ThreadPool* const,
                                                      mgis_bv_MaterialDataManager* const,
                                                      mgis_bv_BehaviourIntegrationOptions* const,
                                                      const mgis_real);
-
+//! \brief debugging version
+MGIS_C_EXPORT mgis_status
+mgis_bv_integrate_debug_material_data_manager_with_options(
+    int* const,
+    mgis_ThreadPool* const,
+    mgis_bv_MaterialDataManager* const,
+    mgis_bv_BehaviourIntegrationOptions* const,
+    const mgis_real);
+
 #ifdef __cplusplus
 }
 #endif /*  __cplusplus */

bindings/c/src/Integrate.cxx

@@ -115,13 +115,31 @@ mgis_status mgis_bv_integrate(int* const r,
   return mgis_report_success();
 }  // end of mgis_bv_integrate
 
+mgis_status mgis_bv_integrate_debug(int* const r,
+                                    mgis_bv_BehaviourDataView* const d,
+                                    const mgis_bv_Behaviour* const b) {
+  *r = mgis::behaviour::integrate_debug(*d, *b);
+  if ((*r != 1) && (*r != 0)) {
+    return mgis_report_failure("behaviour integration failed");
+  }
+  return mgis_report_success();
+}  // end of mgis_bv_integrate
+
 mgis_status mgis_bv_integrate_2(int* const r,
                                 mgis_bv_BehaviourData* const d,
                                 const mgis_bv_Behaviour* const b) {
   auto v = mgis::behaviour::make_view(*d);
   auto s = mgis_bv_integrate(r, &v, b);
   return s;
-}  // end of mgis_bv_integrate2
+}  // end of mgis_bv_integrate_2
+
+mgis_status mgis_bv_integrate_debug_2(int* const r,
+                                      mgis_bv_BehaviourData* const d,
+                                      const mgis_bv_Behaviour* const b) {
+  auto v = mgis::behaviour::make_view(*d);
+  auto s = mgis_bv_integrate_debug(r, &v, b);
+  return s;
+}  // end of mgis_bv_integrate_debug_2
 
 mgis_status mgis_bv_integrate_material_data_manager(
     int* const r,
@@ -141,6 +159,25 @@ mgis_status mgis_bv_integrate_material_data_manager(
   return mgis_report_success();
 }  // end of mgis_bv_integrate_material_data_manager
 
+mgis_status mgis_bv_integrate_debug_material_data_manager(
+    int* const r,
+    mgis_ThreadPool* const p,
+    mgis_bv_MaterialDataManager* const m,
+    const mgis_bv_IntegrationType i,
+    const mgis_real dt) {
+  *r = -1;
+  try {
+    *r =
+        mgis::behaviour::integrate_debug(*p, *m, convertIntegrationType(i), dt);
+    if ((*r != 1) && (*r != 0)) {
+      return mgis_report_failure("behaviour integration failed");
+    }
+  } catch (...) {
+    return mgis_handle_cxx_exception();
+  }
+  return mgis_report_success();
+}  // end of mgis_bv_integrate_debug_material_data_manager
+
 mgis_status mgis_bv_integrate_material_data_manager_with_options(
     int* const r,
     mgis_ThreadPool* const p,
@@ -159,6 +196,24 @@ mgis_status mgis_bv_integrate_material_data_manager_with_options(
   return mgis_report_success();
 }  // end of mgis_bv_integrate_material_data_manager_with_options
 
+mgis_status mgis_bv_integrate_debug_material_data_manager_with_options(
+    int* const r,
+    mgis_ThreadPool* const p,
+    mgis_bv_MaterialDataManager* const m,
+    mgis_bv_BehaviourIntegrationOptions* const o,
+    const mgis_real dt) {
+  *r = -1;
+  try {
+    *r = mgis::behaviour::integrate_debug(*p, *m, *o, dt).exit_status;
+    if ((*r != 1) && (*r != 0)) {
+      return mgis_report_failure("behaviour integration failed");
+    }
+  } catch (...) {
+    return mgis_handle_cxx_exception();
+  }
+  return mgis_report_success();
+}  // end of mgis_bv_integrate_debug_material_data_manager_with_options
+
 mgis_status mgis_bv_integrate_material_data_manager_part(
     int* const r,
     mgis_bv_MaterialDataManager* const m,
@@ -178,4 +233,24 @@ mgis_status mgis_bv_integrate_material_data_manager_part(
   return mgis_report_success();
 }  // end of mgis_bv_integrate_material_data_manager_part
 
+mgis_status mgis_bv_integrate_debug_material_data_manager_part(
+    int* const r,
+    mgis_bv_MaterialDataManager* const m,
+    const mgis_bv_IntegrationType i,
+    const mgis_real dt,
+    const mgis_size_type b,
+    const mgis_size_type e) {
+  *r = -1;
+  try {
+    *r = mgis::behaviour::integrate_debug(*m, convertIntegrationType(i), dt, b,
+                                          e);
+    if ((*r != 1) && (*r != 0)) {
+      return mgis_report_failure("behaviour integration failed");
+    }
+  } catch (...) {
+    return mgis_handle_cxx_exception();
+  }
+  return mgis_report_success();
+}  // end of mgis_bv_integrate_debug_material_data_manager_part
+
 }  // end of extern "C"

bindings/fortran/src/mgis_behaviour.f90

@@ -3718,6 +3718,28 @@ end function integrate_wrapper
     type(mgis_status) :: s
     s = integrate_wrapper(r, d%ptr, b%ptr)
   end function integrate
+  ! integrate_debug
+  function integrate_debug(r, d, b) result(s)
+    use mgis, only: mgis_status
+    implicit none
+    interface
+       function integrate_debug_wrapper(r, d, b) &
+            bind(c,name = 'mgis_bv_integrate_debug_2') result(s)
+         use, intrinsic :: iso_c_binding, only: c_ptr, c_int
+         use mgis, only: mgis_status
+         implicit none
+         integer(kind=c_int), intent(out) :: r
+         type(c_ptr), intent(in),value :: d
+         type(c_ptr), intent(in),value :: b
+         type(mgis_status) :: s
+       end function integrate_debug_wrapper
+    end interface
+    integer, intent(out) :: r
+    type(BehaviourData), intent(in) :: d
+    type(Behaviour),     intent(in) :: b
+    type(mgis_status) :: s
+    s = integrate_debug_wrapper(r, d%ptr, b%ptr)
+  end function integrate_debug
   ! 
   function integrate_material_data_manager(r, p, m, i, dt) result(s)
     use, intrinsic :: iso_c_binding, only: c_size_t
@@ -3748,6 +3770,35 @@ end function integrate_material_data_manager_wrapper
     s = integrate_material_data_manager_wrapper(r, p%ptr, m%ptr, i, dt)
   end function integrate_material_data_manager
   ! 
+  function integrate_debug_material_data_manager(r, p, m, i, dt) result(s)
+    use, intrinsic :: iso_c_binding, only: c_size_t
+    use mgis_fortran_utilities, only: convert_to_c_index
+    use mgis, only: ThreadPool, mgis_status, report_failure
+    implicit none
+    interface
+       function integrate_debug_material_data_manager_wrapper(r, p, m, i, dt) &
+            bind(c,name = 'mgis_bv_integrate_debug_material_data_manager') &
+            result(s)
+         use, intrinsic :: iso_c_binding, only: c_ptr, c_int, c_double
+         use mgis, only: mgis_status
+         implicit none
+         integer(kind=c_int), intent(out) :: r
+         type(c_ptr), intent(in),value :: p
+         type(c_ptr), intent(in),value :: m
+         integer,     intent(in),value :: i
+         real(kind = c_double), intent(in),value :: dt
+         type(mgis_status) :: s
+       end function integrate_debug_material_data_manager_wrapper
+    end interface
+    integer, intent(out) :: r
+    type(ThreadPool),          intent(in) :: p
+    type(MaterialDataManager), intent(in) :: m
+    integer,                   intent(in) :: i
+    real(kind = 8),            intent(in) :: dt
+    type(mgis_status) :: s
+    s = integrate_debug_material_data_manager_wrapper(r, p%ptr, m%ptr, i, dt)
+  end function integrate_debug_material_data_manager
+  ! 
   function integrate_material_data_manager_with_options(r, p, m, i, dt) result(s)
    use, intrinsic :: iso_c_binding, only: c_size_t
    use mgis_fortran_utilities, only: convert_to_c_index
@@ -3776,6 +3827,35 @@ end function integrate_material_data_manager_with_options_wrapper
    type(mgis_status) :: s
    s = integrate_material_data_manager_with_options_wrapper(r, p%ptr, m%ptr, i%ptr, dt)
   end function integrate_material_data_manager_with_options
+  ! 
+  function integrate_debug_material_data_manager_with_options(r, p, m, i, dt) result(s)
+   use, intrinsic :: iso_c_binding, only: c_size_t
+   use mgis_fortran_utilities, only: convert_to_c_index
+   use mgis, only: ThreadPool, mgis_status, report_failure
+   implicit none
+   interface
+      function integrate_debug_material_data_manager_with_options_wrapper(r, p, m, i, dt) &
+           bind(c,name = 'mgis_bv_integrate_debug_material_data_manager_with_options') &
+           result(s)
+        use, intrinsic :: iso_c_binding, only: c_ptr, c_int, c_double
+        use mgis, only: mgis_status
+        implicit none
+        integer(kind=c_int), intent(out) :: r
+        type(c_ptr), intent(in),value :: p
+        type(c_ptr), intent(in),value :: m
+        type(c_ptr), intent(in),value :: i
+        real(kind = c_double), intent(in),value :: dt
+        type(mgis_status) :: s
+      end function integrate_debug_material_data_manager_with_options_wrapper
+   end interface
+   integer,                           intent(out) :: r
+   type(ThreadPool),                  intent(in) :: p
+   type(MaterialDataManager),         intent(in) :: m
+   type(BehaviourIntegrationOptions), intent(in) :: i
+   real(kind = 8), intent(in) :: dt
+   type(mgis_status) :: s
+   s = integrate_debug_material_data_manager_with_options_wrapper(r, p%ptr, m%ptr, i%ptr, dt)
+  end function integrate_debug_material_data_manager_with_options
   !
   function integrate_material_data_manager_part(r, m, i, dt, ni, ne) result(s)
     use, intrinsic :: iso_c_binding, only: c_size_t
@@ -3818,4 +3898,46 @@ end function integrate_material_data_manager_part_wrapper
     nec = nec + 1
     s = integrate_material_data_manager_part_wrapper(r, m%ptr, i, dt, nic, nec)
   end function integrate_material_data_manager_part
+  !
+  function integrate_debug_material_data_manager_part(r, m, i, dt, ni, ne) result(s)
+    use, intrinsic :: iso_c_binding, only: c_size_t
+    use mgis_fortran_utilities, only: convert_to_c_index
+    use mgis, only: mgis_status, report_failure
+    implicit none
+    interface
+       function integrate_debug_material_data_manager_part_wrapper(r, m, i, dt, ni, ne) &
+            bind(c,name = 'mgis_bv_integrate_debug_material_data_manager_part') &
+            result(s)
+         use, intrinsic :: iso_c_binding, only: c_ptr, c_size_t, c_int, c_double
+         use mgis, only: mgis_status
+         implicit none
+         integer(kind=c_int), intent(out) :: r
+         type(c_ptr), intent(in),value :: m
+         integer,     intent(in),value :: i
+         real(kind = c_double), intent(in),value :: dt
+         integer(kind = c_size_t), intent(in),value :: ni
+         integer(kind = c_size_t), intent(in),value :: ne
+         type(mgis_status) :: s
+       end function integrate_debug_material_data_manager_part_wrapper
+    end interface
+    integer, intent(out) :: r
+    type(MaterialDataManager), intent(in) :: m
+    integer,     intent(in),value :: i
+    real(kind = 8),            intent(in) :: dt
+    integer :: ni
+    integer :: ne
+    type(mgis_status) :: s
+    integer(kind=c_size_t) :: nic
+    integer(kind=c_size_t) :: nec
+    if(.not. convert_to_c_index(nic, ni)) then
+       s = report_failure("invalid index")
+       return
+    end if
+    if(.not. convert_to_c_index(nec, ne)) then
+       s = report_failure("invalid index")
+       return
+    end if
+    nec = nec + 1
+    s = integrate_debug_material_data_manager_part_wrapper(r, m%ptr, i, dt, nic, nec)
+  end function integrate_debug_material_data_manager_part
 end module  mgis_behaviour

bindings/julia/src/Integrate.cxx

@@ -24,7 +24,14 @@ static int integrateBehaviourData1(mgis::behaviour::BehaviourData& d,
   auto v = mgis::behaviour::make_view(d);
   const auto s = mgis::behaviour::integrate(v, b);
   return s;
-}  // end of integrateBehaviourData
+}  // end of integrateBehaviourData1
+
+static int integrateDebugBehaviourData1(mgis::behaviour::BehaviourData& d,
+					const mgis::behaviour::Behaviour& b) {
+  auto v = mgis::behaviour::make_view(d);
+  const auto s = mgis::behaviour::integrate_debug(v, b);
+  return s;
+}  // end of integrateDebugBehaviourData
 
 void declareIntegrate(jlcxx::Module& m) {
   using mgis::behaviour::IntegrationType;
@@ -65,6 +72,9 @@ void declareIntegrate(jlcxx::Module& m) {
   int (*integrate_ptr1)(mgis::behaviour::BehaviourDataView&,
                         const mgis::behaviour::Behaviour&) =
       mgis::behaviour::integrate;
+  int (*integrate_debug_ptr1)(mgis::behaviour::BehaviourDataView&,
+			      const mgis::behaviour::Behaviour&) =
+      mgis::behaviour::integrate_debug;
   //   int (*integrate_ptr2)(mgis::behaviour::MaterialDataManager&,
   //                         const IntegrationType, const mgis::real,
   //                         const mgis::size_type, const mgis::size_type) =
@@ -76,6 +86,8 @@ void declareIntegrate(jlcxx::Module& m) {
 
   m.method("integrate", &integrateBehaviourData1);
   m.method("integrate", integrate_ptr1);
+  m.method("integrate_debug", &integrateDebugBehaviourData1);
+  m.method("integrate_debug", integrate_debug_ptr1);
   //   boost::python::def("integrate", integrate_ptr2);
   //   boost::python::def("integrate", integrate_ptr3);
 }  // end of declareIntegrate