h2lib 13.1.505__py3-none-win_amd64.whl → 13.1.901__py3-none-win_amd64.whl

h2lib/_h2lib.py

@@ -6,6 +6,27 @@ import sys
 
 from multiclass_interface.multiprocess_interface import MultiProcessClassInterface, ProcessClass
 import numpy as np
+from pathlib import Path
+
+_ERROR_CODES = {
+    1: ValueError("WRONG_NUMBER_OF_COLUMNS"),
+    2: ValueError("MAIN_BODY_NOT_FOUND"),
+    3: RuntimeError("NOT_IMPLEMENTED_ERROR"),
+    4: RuntimeError("STRUCTURE_IS_CONFIDENTIAL"),
+    5: IndexError("BODY_DOES_NOT_EXIST"),
+    6: IndexError("ELEMENT_DOES_NOT_EXIST"),
+    7: ValueError("WRONG_NUMBER_OF_BODIES"),
+    100: RuntimeError("STATIC_SOLVER_DID_NOT_CONVERGE"),
+    101: RuntimeError("STATIC_SOLVER_NOT_INITIALIZED"),
+    300: ValueError("TOO_FEW_SECTIONS_IN_C2DEF"),
+    301: ValueError("BEAM_TOO_SHORT"),
+    302: ValueError("DIFFERENT_NSEC"),
+    700: RuntimeError("SYSTEM_NOT_LINEARIZED"),
+    701: RuntimeError("SYSTEM_EIGENANALYSIS_NOT_DONE"),
+    702: ValueError("TOO_MANY_MODES_REQUESTED"),
+    703: ValueError("WRONG_TOTAL_DOF"),
+    704: ValueError("WRONG_REDUCED_DOF")
+}
 
 
 def H2Lib(suppress_output=False, subprocess=True):
@@ -26,9 +47,11 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         # doubles the speed of single instances and 2N of N instances on linux
         os.environ['MKL_THREADING_LAYER'] = 'sequential'
         filename = os.path.abspath(filename)
-        library_bin = os.path.abspath(os.path.join(os.path.dirname(sys.executable), '../Library/bin'))
-        if os.path.isdir(library_bin):  # pragma: no cover
-            os.add_dll_directory(library_bin)
+        p = Path(np.__file__).parents
+        for i in range(2, 4):
+            if (p[i] / 'Library/bin').exists():
+                os.add_dll_directory(p[i] / 'Library/bin')
+                break
         DLLWrapper.__init__(self, filename, cwd=cwd, cdecl=True)
         self.suppress_output = suppress_output
         self._initialized = False
@@ -98,6 +121,213 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         self.time = np.round(H2LibSignatures.run(self, np.float64(time), restype=np.float64)[1], 6)
         return self.time
 
+    def linearize(self):
+        """
+        Linearize the system, as done by the system eigen-analysis.
+
+        Returns
+        -------
+        n_tdofs : int
+            Total number of degrees of freedom in the system.
+        n_rdofs : int
+            Number of degrees of freedom in the reduced order system.
+
+        """
+        n_tdofs = -1
+        n_rdofs = -1
+        res = H2LibSignatures.linearize(self, n_tdofs, n_rdofs)[0]
+        return res
+
+    def do_system_eigenanalysis(self, n_modes, include_damping=True):
+        """
+        Do the system eigen-analysis.
+
+        Parameters
+        ----------
+        n_modes : int
+            Number of modes to output.
+        include_damping : bool, optional
+            `True` to include damping, `False` otherwise. The default is `True`.
+
+        Raises
+        ------
+        RuntimeError
+            Call `linearize` first.
+        ValueError
+            If too many modes are requested.
+
+        Returns
+        -------
+        natural_frequencies : (n_modes,) ndarray
+            Natural frequencies, in Hz.
+        damping_ratios : (n_modes,) ndarray
+            Damping ratios (nondimensional).
+            Only returned if `include_damping=True`.
+
+        """
+        natural_frequencies = np.zeros((n_modes,), dtype=np.float64, order="F")
+        damping_ratios = np.zeros((n_modes,), dtype=np.float64, order="F")
+        error_code = -1
+
+        _, _, natural_frequencies, damping_ratios, error_code = (
+            H2LibSignatures.do_system_eigenanalysis(
+                self,
+                include_damping,
+                n_modes,
+                natural_frequencies,
+                damping_ratios,
+                error_code,
+            )[0]
+        )
+
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+
+        if include_damping:
+            return natural_frequencies, damping_ratios
+        else:
+            return natural_frequencies
+
+    def get_system_eigenvalues_and_eigenvectors(
+        self, n_modes, n_rdofs, include_damping=True
+    ):
+        """
+        Get the system eigenvalues and eigenvectors from system_eigenanalysis.
+
+        This function must be called after `do_system_eigenanalysis`, with the same value of `include_damping`.
+
+        Parameters
+        ----------
+        n_modes : int
+            Number of modes to output.
+        n_rdofs : int
+            Number of degrees of freedom in the reduced order system.
+            As returned by `linearize`.
+        include_damping : bool, optional
+            `True` to include damping, `False` otherwise. The default is `True`.
+
+        Raises
+        ------
+        RuntimeError
+            If the structure is confidential or if `linearize` and `do_system_eigenanalysis` have not been called first.
+        ValueError
+            Either `n_modes` or `n_rdofs` is wrong.
+
+        Returns
+        -------
+        eigenvalues : (n_modes,) ndarray
+            Eigenvalues. Real array without damping and complex array otherwise.
+        eigenvectors : (n_modes, ny)
+            Eigenvectors. Real array without damping and complex array otherwise.
+            Only returned if the structure is not confidential.
+
+        """
+        if include_damping:
+            ny = 2 * n_rdofs
+            dtype = np.complex128
+            f = H2LibSignatures.get_system_eigval_eigvec_with_damping
+        else:
+            ny = n_rdofs
+            dtype = np.float64
+            f = H2LibSignatures.get_system_eigval_eigvec_without_damping
+
+        error_code = -1
+        eigenvalues = np.zeros((n_modes,), dtype=dtype, order="F")
+        eigenvectors = np.zeros((n_modes, ny), dtype=dtype, order="F")
+
+        _, _, eigenvalues, eigenvectors, error_code = f(
+            self, n_modes, ny, eigenvalues, eigenvectors, error_code
+        )[0]
+
+        if error_code > 0:
+            if error_code == 4:
+                # The structure is confidential.
+                # The eigenvectors have not been returned by the Fortran code.
+                return eigenvalues
+            else:
+                raise _ERROR_CODES[error_code]
+
+        return eigenvalues, eigenvectors
+
+    def solver_static_init(self):
+        """
+        Initialize the static solver.
+
+        Returns
+        -------
+        None.
+
+        """
+        H2LibSignatures.solver_static_init(self)
+
+    def solver_static_update(self):
+        """
+        Update the static solver.
+
+        Raises
+        ------
+        RuntimeError
+            If the static solver has not been initialized. Call `solver_static_init()` first.
+
+        Returns
+        -------
+        None.
+
+        """
+        error_code = -1
+        error_code = H2LibSignatures.solver_static_update(self, error_code)[0][0]
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+
+    def solver_static_solve(self):
+        """
+        Compute the static solution.
+
+        Raises
+        ------
+        RuntimeError
+            If the static solver has not been initialized. Call `solver_static_init()` first.
+
+        Returns
+        -------
+        None.
+
+        """
+        error_code = -1
+        error_code = H2LibSignatures.solver_static_solve(self, error_code)[0][0]
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+
+    def solver_static_delete(self):
+        """
+        Delete the static solver.
+
+        Returns
+        -------
+        None.
+
+        """
+        H2LibSignatures.solver_static_delete(self)
+
+    def solver_static_run(self):
+        """
+        Run the complete static solver algorithm.
+
+        Raises
+        ------
+        RuntimeError
+            If the static solver has not converged.
+
+        Returns
+        -------
+        None.
+
+        """
+        error_code = -1
+        error_code = H2LibSignatures.solver_static_run(self, error_code)[0][0]
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+
     def add_sensor(self, sensor_line):
         """Add sensor to hawc2. The sensor will be accessible from h2lib but will not show up in the output file of HAWC2
         Note, that some sensors consist of multiple HAWC2 sensors, e.g. "wind free_wind" which has a Vx, Vy and Vz sensors
@@ -146,6 +376,76 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
     def set_variable_sensor_value(self, id, value):
         return H2LibSignatures.set_variable_sensor_value(self, id, np.float64(value))
 
+    def set_orientation_base(
+        self,
+        main_body_name,
+        mbdy_eulerang_table=None,
+        angles_in_deg=True,
+        reset_orientation=False,
+        mbdy_ini_rotvec_d1=None,
+    ):
+        """
+        Set an orientation / base command.
+
+        Function equivalent to the HAWC2 command orientation / base.
+        For further details see the HAWC2 documentation.
+        We assume that this base is already present in the htc file,
+        and therefore modify it here instead of creating a new one.
+
+        Parameters
+        ----------
+        main_body_name : str
+            Main body name. Same as HAWC2 `mbdy` parameter.
+        mbdy_eulerang_table : (:, 3) ndarray, optional
+            A sequence of Euler angles, one per row.
+            Equivalent to HAWC2 command `mbdy_eulerang`.
+            A 1D array with 3 elements will be interpreted as 1 row.
+            This table is additive with respect to the orientation / base command in the htc file,
+            unless the flag `reset_orientation` is used.
+            The default is `[0, 0, 0]`, which means that the base is coincident with the global frame.
+        angles_in_deg : bool, optional
+            `True` if the angles in `mbdy_eulerang_table` are provided in degrees.
+            `False` if they are in radians.
+            The default is `True`.
+        reset_orientation : bool, optional,
+            If `True` this function will reset the orientation to the global frame
+            before applying `mbdy_eulerang_table`. The default is `False`.
+        mbdy_ini_rotvec_d1 : (4) ndarray, optional
+            Angular velocity. First 3 elements for the direction and last for the magnitude.
+            Equivalent to HAWC2 command `mbdy_ini_rotvec_d1`.
+            The default is 0 speed.
+
+        Raises
+        ------
+        ValueError
+            If the orientation / base command cannot be found.
+
+        Returns
+        -------
+        None.
+
+        """
+        if mbdy_eulerang_table is None:
+            mbdy_eulerang_table = np.zeros((1, 3), dtype=np.float64, order="F")
+        if mbdy_ini_rotvec_d1 is None:
+            mbdy_ini_rotvec_d1 = np.zeros((4,), dtype=np.float64, order="F")
+        # 1D arrays are converted to 2D with 1 row.
+        mbdy_eulerang_table = np.atleast_2d(mbdy_eulerang_table)
+        error_code = -1
+        error_code = H2LibSignatures.set_orientation_base(
+            self,
+            main_body_name,
+            np.asfortranarray(mbdy_eulerang_table.astype(np.float64)),
+            mbdy_eulerang_table.shape[0],
+            angles_in_deg,
+            reset_orientation,
+            np.asfortranarray(mbdy_ini_rotvec_d1.astype(np.float64)),
+            error_code,
+        )[0][-1]
+
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+
     def init_windfield(self, Nxyz, dxyz, box_offset_yz, transport_speed):
         """Initialize wind field which afterwards can be set using set_windfield
 
@@ -302,26 +602,6 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         vx, vy, vz = self.get_rotor_avg_wsp(1, rotor)
         return [vy, vx, -vz]
 
-    def init_static_solver(self):
-        """
-        Initialize the static solver.
-
-        Raises
-        ------
-        RuntimeError
-            If the static solver has already been initialized.
-
-        Returns
-        -------
-        None.
-
-        """
-        error_code = H2LibSignatures.init_static_solver(self, restype=np.int64)[1]
-        if error_code > 0:
-            if error_code == 102:
-                raise RuntimeError("STATIC_SOLVER_ALREADY_INITIALIZED")
-            raise RuntimeError(error_code)  # pragma: no cover
-
     def get_number_of_bodies_and_constraints(self):
         """
         Get number of bodies and constraints.
@@ -352,9 +632,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             0
         ]
         if error_code > 0:
-            if error_code == 4:
-                raise RuntimeError("STRUCTURE_IS_CONFIDENTIAL")
-            raise RuntimeError(error_code)  # pragma: no cover
+            raise _ERROR_CODES[error_code]
         return nbdy, ncst
 
     def get_number_of_elements(self):
@@ -380,15 +658,9 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             self, nbdy, nelem, error_code
         )[0]
 
-        if error_code > 0:
-            if error_code == 4:  # pragma: no cover
-                # This cannot happen because if the structure is confidential we will
-                # get this error from get_number_of_bodies_and_constraints().
-                raise RuntimeError("STRUCTURE_IS_CONFIDENTIAL")  # pragma: no cover
-            elif error_code == 7:  # pragma: no cover
-                # This cannot happen because we call get_number_of_bodies_and_constraints().
-                raise ValueError("WRONG_NUMBER_OF_BODIES")  # pragma: no cover
-            raise RuntimeError(error_code)  # pragma: no cover
+        if error_code > 0:  # pragma: no cover
+            # This cannot happen because exceptions are raised by get_number_of_bodies_and_constraints().
+            raise _ERROR_CODES[error_code]  # pragma: no cover
         return nelem
 
     def get_timoshenko_location(self, ibdy, ielem):
@@ -441,14 +713,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             0
         ]
         if error_code > 0:
-            if error_code == 4:
-                raise RuntimeError("STRUCTURE_IS_CONFIDENTIAL")
-            elif error_code == 5:
-                raise IndexError("BODY_DOES_NOT_EXIST")
-            elif error_code == 6:
-                raise IndexError("ELEMENT_DOES_NOT_EXIST")
-            raise RuntimeError(error_code)  # pragma: no cover
-
+            raise _ERROR_CODES[error_code]
         return l, r1, r12, tes
 
     def get_body_rotation_tensor(self, ibdy):
@@ -479,14 +744,55 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             self, ibdy + 1, amat, error_code
         )[0]
         if error_code > 0:
-            if error_code == 4:
-                raise RuntimeError("STRUCTURE_IS_CONFIDENTIAL")
-            elif error_code == 5:
-                raise IndexError("BODY_DOES_NOT_EXIST")
-            raise RuntimeError(error_code)  # pragma: no cover
-
+            raise _ERROR_CODES[error_code]
         return amat
 
+    def get_system_matrices(self, n_tdofs, n_rdofs):
+        """
+        Get the system structural matrices computed during the system_eigenanalysis.
+
+        This function must be called after `linearize()`.
+
+        Parameters
+        ----------
+        n_tdofs : int
+            Total number of degrees of freedom in the system.
+        n_rdofs : int
+            Number of degrees of freedom in the reduced order system.
+
+        Raises
+        ------
+        RuntimeError
+            If the linearizetion has not been done or the structure is confidential.
+        ValueError
+            If the total or reduced number of degrees of freedom is wrong.
+
+        Returns
+        -------
+        M : (n_rdofs, n_rdofs) ndarray
+            Mass matrix.
+        C : (n_rdofs, n_rdofs) ndarray
+            Damping matrix.
+        K : (n_rdofs, n_rdofs) ndarray
+            Stiffness matrix.
+        R : (n_tdofs, n_rdofs) ndarray
+            Transformation between reduced and all DOFs.
+
+        """
+        M = np.zeros((n_rdofs, n_rdofs), dtype=np.float64, order="F")
+        C = np.zeros((n_rdofs, n_rdofs), dtype=np.float64, order="F")
+        K = np.zeros((n_rdofs, n_rdofs), dtype=np.float64, order="F")
+        R = np.zeros((n_tdofs, n_rdofs), dtype=np.float64, order="F")
+        error_code = -1
+
+        _, _, M, C, K, R, error_code = H2LibSignatures.get_system_matrices(
+            self, n_tdofs, n_rdofs, M, C, K, R, error_code
+        )[0]
+
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+        return M, C, K, R
+
 
 @contextmanager
 def set_LD_LIBRARY_PATH():

h2lib/_version.py

@@ -1,4 +1,4 @@
 # This file is autogenerated and should not be modified manually
-__version__ = '13.1.505'
-h2lib_version = '13.1.505'
-hawc2_version = '13.1.5+4-g20eca1a'
+__version__ = '13.1.901'
+h2lib_version = '13.1.901'
+hawc2_version = '13.1.9+5-g2026dd7'

h2lib/dll_wrapper.py

@@ -6,7 +6,7 @@ import platform
 import os
 import ctypes
 from _ctypes import POINTER
-from ctypes import c_int, c_double, c_char, c_char_p, c_long, c_longlong
+from ctypes import c_int, c_double, c_char, c_char_p, c_long, c_longlong, Structure
 from contextlib import contextmanager
 import tempfile
 try:
@@ -22,6 +22,24 @@ c_long_p = POINTER(ctypes.c_longlong)
 c_double_p = POINTER(ctypes.c_double)
 c_float_p = POINTER(ctypes.c_float)
 
+
+# Add support for complex numbers to ctypes.
+# This solution is copied from: https://stackoverflow.com/a/65743183/3676517
+class c_double_complex(Structure):
+    """complex is a c structure
+    https://docs.python.org/3/library/ctypes.html#module-ctypes suggests
+    to use ctypes.Structure to pass structures (and, therefore, complex)
+    """
+
+    _fields_ = [("real", c_double), ("imag", c_double)]
+
+    @property
+    def value(self):
+        return self.real + 1j * self.imag  # fields declared above
+
+
+c_double_complex_p = POINTER(c_double_complex)
+
 in_use = []
 
 
@@ -109,6 +127,8 @@ def wrap(self, f, *args, **kwargs):
                 c_args.append(arg.ctypes.data_as(c_double_p))
             elif arg.dtype == np.float32:
                 c_args.append(arg.ctypes.data_as(c_float_p))
+            elif arg.dtype == np.complex128:
+                c_args.append(arg.ctypes.data_as(c_double_complex_p))
             else:
                 raise NotImplementedError(arg.dtype)
 

h2lib/h2lib_signatures.py

@@ -6,11 +6,21 @@ from h2lib.dll_wrapper import DLLWrapper
 class H2LibSignatures():
     def add_sensor(self, sensor_line, index_start, index_stop):
         '''subroutine add_sensor(sensor_line, index_start, index_stop) bind(C, name="add_sensor")
-      integer*8 :: index_start, index_stop, i
+      integer*8 :: index_start, index_stop
       character(kind=c_char, len=1), intent(in)       :: sensor_line(1024)
     end subroutine'''
         return self.get_lib_function('add_sensor')(sensor_line, index_start, index_stop)
 
+    def do_system_eigenanalysis(self, include_damping, n_modes, natural_frequencies, damping_ratios, error_code):
+        '''subroutine do_system_eigenanalysis(include_damping, n_modes, natural_frequencies, damping_ratios, error_code) &
+logical(kind=c_bool), intent(in) :: include_damping
+integer(kind=4), intent(in) :: n_modes
+real(kind=c_double), dimension(n_modes), intent(out) :: natural_frequencies
+real(kind=c_double), dimension(n_modes), intent(out) :: damping_ratios
+integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('do_system_eigenanalysis')(include_damping, n_modes, natural_frequencies, damping_ratios, error_code)
+
     def echo_version(self, ):
         '''subroutine echo_version() BIND(C, NAME='echo_version')
     !DEC$ ATTRIBUTES DLLEXPORT :: echo_version
@@ -218,6 +228,38 @@ end subroutine'''
     end subroutine'''
         return self.get_lib_function('get_sensor_values')(ids, values, n)
 
+    def get_system_eigval_eigvec_with_damping(self, n_modes, ny, eigenvalues, eigenvectors, error_code):
+        '''subroutine get_system_eigval_eigvec_with_damping(n_modes, ny, eigenvalues, eigenvectors, error_code) &
+integer(kind=4), intent(in) :: n_modes
+integer(kind=4), intent(in) :: ny
+complex(kind=c_double_complex), dimension(n_modes), intent(out) :: eigenvalues
+complex(kind=c_double_complex), dimension(ny, n_modes), intent(out) :: eigenvectors
+integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('get_system_eigval_eigvec_with_damping')(n_modes, ny, eigenvalues, eigenvectors, error_code)
+
+    def get_system_eigval_eigvec_without_damping(self, n_modes, ny, eigenvalues, eigenvectors, error_code):
+        '''subroutine get_system_eigval_eigvec_without_damping(n_modes, ny, eigenvalues, eigenvectors, error_code) &
+integer(kind=4), intent(in) :: n_modes
+integer(kind=4), intent(in) :: ny
+real(kind=c_double), dimension(n_modes), intent(out) :: eigenvalues
+real(kind=c_double), dimension(ny, n_modes), intent(out) :: eigenvectors
+integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('get_system_eigval_eigvec_without_damping')(n_modes, ny, eigenvalues, eigenvectors, error_code)
+
+    def get_system_matrices(self, n_tdofs, n_rdofs, M, C, K, R, error_code):
+        '''subroutine get_system_matrices(n_tdofs, n_rdofs, M, C, K, R, error_code) &
+integer(kind=4), intent(in) :: n_tdofs
+integer(kind=4), intent(in) :: n_rdofs
+real(kind=c_double), dimension(n_rdofs, n_rdofs), intent(out) :: M
+real(kind=c_double), dimension(n_rdofs, n_rdofs), intent(out) :: C
+real(kind=c_double), dimension(n_rdofs, n_rdofs), intent(out) :: K
+real(kind=c_double), dimension(n_tdofs, n_rdofs), intent(out) :: R
+integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('get_system_matrices')(n_tdofs, n_rdofs, M, C, K, R, error_code)
+
     def get_time(self, time):
         '''subroutine
 subroutine'''
@@ -247,12 +289,6 @@ end subroutine'''
     end subroutine'''
         return self.get_lib_function('init')()
 
-    def init_static_solver(self, restype):
-        '''function init_static_solver() result(error_code) &
-    !DEC$ ATTRIBUTES DLLEXPORT :: init_static_solver
-end function'''
-        return self.get_lib_function('init_static_solver')(restype=restype)
-
     def init_windfield(self, Nxyz, dxyz, box_offset_yz, transport_speed):
         '''subroutine init_windfield(Nxyz, dxyz, box_offset_yz, transport_speed) bind(C, name="init_windfield")
       integer*8, dimension(3), intent(in) :: Nxyz
@@ -260,6 +296,13 @@ end function'''
     end subroutine'''
         return self.get_lib_function('init_windfield')(Nxyz, dxyz, box_offset_yz, transport_speed)
 
+    def linearize(self, n_tdofs, n_rdofs):
+        '''subroutine linearize(n_tdofs, n_rdofs) bind(C, name="linearize")
+integer(kind=8), intent(out) :: n_tdofs
+integer(kind=8), intent(out) :: n_rdofs
+end subroutine'''
+        return self.get_lib_function('linearize')(n_tdofs, n_rdofs)
+
     def loop(self, N, restype):
         '''function loop(N) bind(C, Name='loop')
     !DEC$ ATTRIBUTES DLLEXPORT :: loop
@@ -312,6 +355,20 @@ end function'''
   end subroutine'''
         return self.get_lib_function('set_aerosections_windspeed')(rotor, uvw)
 
+    def set_orientation_base(self, main_body_name,
+                             mbdy_eulerang_table, n_rows, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1,
+                             error_code):
+        '''subroutine set_orientation_base(main_body_name,&
+character(kind=c_char, len=1), dimension(256), intent(in) :: main_body_name
+integer(kind=4), intent(in) :: n_rows
+logical, intent(in) :: angles_in_deg
+logical, intent(in) :: reset_orientation
+real(kind=c_double), dimension(4),   intent(in) :: mbdy_ini_rotvec_d1
+end subroutine'''
+        return self.get_lib_function('set_orientation_base')(main_body_name,
+                                                             mbdy_eulerang_table, n_rows, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1,
+                                                             error_code)
+
     def set_variable_sensor_value(self, id, value):
         '''subroutine set_variable_sensor_value(id, value) bind(C, name="set_variable_sensor_value")
       integer*8, intent(in) :: id
@@ -326,6 +383,36 @@ end function'''
     end subroutine'''
         return self.get_lib_function('set_windfield')(uvw, box_offset_x, time)
 
+    def solver_static_delete(self, ):
+        '''subroutine solver_static_delete() &
+    !DEC$ ATTRIBUTES DLLEXPORT :: solver_static_delete
+end subroutine'''
+        return self.get_lib_function('solver_static_delete')()
+
+    def solver_static_init(self, ):
+        '''subroutine solver_static_init() &
+    !DEC$ ATTRIBUTES DLLEXPORT :: solver_static_init
+end subroutine'''
+        return self.get_lib_function('solver_static_init')()
+
+    def solver_static_run(self, error_code):
+        '''subroutine solver_static_run(error_code) bind(C, name="solver_static_run")
+    integer(8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('solver_static_run')(error_code)
+
+    def solver_static_solve(self, error_code):
+        '''subroutine solver_static_solve(error_code) &
+    integer*8, intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('solver_static_solve')(error_code)
+
+    def solver_static_update(self, error_code):
+        '''subroutine solver_static_update(error_code) &
+    integer*8, intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('solver_static_update')(error_code)
+
     def sqr2(self, val):
         '''subroutine sqr2(val) BIND(C, NAME='sqr2')
   integer, intent(inout) :: val
@@ -362,5 +449,9 @@ end function'''
     def write_output(self, ):
         '''subroutine write_output() bind(C, name="write_output")
       !DEC$ ATTRIBUTES DLLEXPORT :: write_output
+      logical                       :: firstcall
+      integer        :: nr, dummy=1
+      character*10 :: status = 'close';
+      Type (Toutvar) :: ov_dummy
     end subroutine'''
         return self.get_lib_function('write_output')()

{h2lib-13.1.505.dist-info → h2lib-13.1.901.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: h2lib
-Version: 13.1.505
-Summary: Python interface to HAWC2 (13.1.5+4-g20eca1a)
+Version: 13.1.901
+Summary: Python interface to HAWC2 (13.1.9+5-g2026dd7)
 Download-URL: 
 Author: Mads M. Pedersen, S.G.Horcas and N.G.Ramos
 Author-email: mmpe@dtu.dk

h2lib-13.1.901.dist-info/RECORD

@@ -0,0 +1,10 @@
+h2lib/HAWC2Lib.dll,sha256=sIZhsbsubvdSV1FYMFwm3o182LX443SmME3ak8QwLWM,30803968
+h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
+h2lib/_h2lib.py,sha256=povKoDnyzYF2xET29CxkBYKSYJc5yRjn7J4Xdw8qTow,30363
+h2lib/_version.py,sha256=36To1Vn7m9W0-ewELpaoXNd4wDAXEYhnaDUyBw5QI-k,157
+h2lib/dll_wrapper.py,sha256=CfuRfDPEmmfYlEGKUmiXiuMhNiMcf24ripPHgqd8CiE,12761
+h2lib/h2lib_signatures.py,sha256=BknUitXekKaOH9reEHDnBPN-ThAHFeHnfdD41UlJ8Y8,21780
+h2lib-13.1.901.dist-info/METADATA,sha256=IEbAB9rC-p8IT1nmtagD7xSRUhaY0l7vAZNYqeZg5_U,738
+h2lib-13.1.901.dist-info/WHEEL,sha256=62QJgqtUFevqILau0n0UncooEMoOyVCKVQitJpcuCig,101
+h2lib-13.1.901.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
+h2lib-13.1.901.dist-info/RECORD,,

{h2lib-13.1.505.dist-info → h2lib-13.1.901.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64
 

h2lib-13.1.505.dist-info/RECORD

@@ -1,10 +0,0 @@
-h2lib/HAWC2Lib.dll,sha256=IGuHPScAOZ_H6Mar3pcaZkYvWdZ1-8-s3JoJj2hNQcQ,30576128
-h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
-h2lib/_h2lib.py,sha256=itCf0sXkdYekNLg9fFu_zi9n_pCV660SvbRoD8clPDk,20558
-h2lib/_version.py,sha256=-tWFhe0RjnHTZr6S5BuRysb-EOM4i5jWwSA5k18ne1E,157
-h2lib/dll_wrapper.py,sha256=RC5_gJ1cwHXVfUaSvmsatyQrvks-aZJFAiXrG4B-FEI,12061
-h2lib/h2lib_signatures.py,sha256=j0TL8Zv6kX18F28X5cdzTlwQd1ZKiyg_zVBRqdOCPhY,16858
-h2lib-13.1.505.dist-info/METADATA,sha256=sd7TmknyNYz91Xig6ZUbYZFT6WymETsemf0x-dX9kTo,738
-h2lib-13.1.505.dist-info/WHEEL,sha256=3vidnDuZ-QSnHIxLhNbI1gIM-KgyEcMHuZuv1mWPd_Q,101
-h2lib-13.1.505.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
-h2lib-13.1.505.dist-info/RECORD,,