h2lib 13.1.506__py3-none-win_amd64.whl → 13.1.1701__py3-none-win_amd64.whl

h2lib/_h2lib.py

@@ -6,6 +6,28 @@ 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"),
+    500: ValueError("RELATIVE_ROTATION_NOT_FOUND"),
+    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 +48,9 @@ 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)
+        for f in [sys.base_prefix, sys.prefix]:
+            if os.path.isdir(os.path.join(f, 'Library/bin')):
+                os.add_dll_directory(os.path.join(f, 'Library/bin'))
         DLLWrapper.__init__(self, filename, cwd=cwd, cdecl=True)
         self.suppress_output = suppress_output
         self._initialized = False
@@ -66,6 +88,23 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         s = " " * 255
         return H2LibSignatures.get_version(self, s)[0][0].strip()
 
+    def stop_on_error(self, flag):
+        """
+        Control if HAWC2 will terminate the execution upon encountering an error. The default HAWC2 behavior is to stop.
+
+        Parameters
+        ----------
+        flag : bool
+            If set to `True` an error will cause HAWC2 to terminate the execution with status code 1.
+            If set to `False` HAWC2 will still print a log message but not stop.
+
+        Returns
+        -------
+        None.
+
+        """
+        H2LibSignatures.stop_on_error(self, bool(flag))
+
     def get_wind_speed(self, pos_g):
         return self.get_lib_function('get_wind_speed')(np.asarray(pos_g, dtype=np.float64),
                                                        np.asarray([0, 0, 0], dtype=np.float64))[0][1]
@@ -98,6 +137,134 @@ 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.
@@ -126,9 +293,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         error_code = -1
         error_code = H2LibSignatures.solver_static_update(self, error_code)[0][0]
         if error_code > 0:
-            if error_code == 101:
-                raise RuntimeError("STATIC_SOLVER_NOT_INITIALIZED")
-            raise RuntimeError(error_code)  # pragma: no cover
+            raise _ERROR_CODES[error_code]
 
     def solver_static_solve(self):
         """
@@ -147,9 +312,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         error_code = -1
         error_code = H2LibSignatures.solver_static_solve(self, error_code)[0][0]
         if error_code > 0:
-            if error_code == 101:
-                raise RuntimeError("STATIC_SOLVER_NOT_INITIALIZED")
-            raise RuntimeError(error_code)  # pragma: no cover
+            raise _ERROR_CODES[error_code]
 
     def solver_static_delete(self):
         """
@@ -179,9 +342,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         error_code = -1
         error_code = H2LibSignatures.solver_static_run(self, error_code)[0][0]
         if error_code > 0:
-            if error_code == 100:
-                raise RuntimeError("STATIC_SOLVER_DID_NOT_CONVERGE")
-            raise RuntimeError(error_code)  # pragma: no cover
+            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
@@ -231,6 +392,167 @@ 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,
+        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 orientation is already present in the htc file,
+        and therefore modify it here instead of creating a new one.
+
+        Parameters
+        ----------
+        main_body : 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 no rotation is applied.
+        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,
+            mbdy_eulerang_table.shape[0],
+            np.asfortranarray(mbdy_eulerang_table.astype(np.float64)),
+            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 set_orientation_relative(
+        self,
+        main_body_1,
+        node_1,
+        main_body_2,
+        node_2,
+        mbdy2_eulerang_table=None,
+        angles_in_deg=True,
+        reset_orientation=False,
+        mbdy2_ini_rotvec_d1=None,
+    ):
+        """
+        Set an `orientation` / `relative` command.
+
+        Function equivalent to the HAWC2 command `orientation` / `relative`.
+        For further details see the HAWC2 documentation.
+        We assume that this relative orientation is already present in the htc file,
+        and therefore modify it here instead of creating a new one.
+
+        Parameters
+        ----------
+        main_body_1 : str
+            Main body name to which the next main body is attached.
+        node_1 : int, str
+            Node number of `main_body_1` that is used for connection, starting from 0.
+            `"last"` can be specified which ensures that the last node on the main_body
+            is used, and `-1` refers to the origin of the main body coordinate system.
+        main_body_2 : str
+            Main_body name of the `main_body` that is positioned
+            in space by the relative command.
+        node_2 : int, str
+            Node number of `main_body_2` that is used for connection, starting from 0.
+            `"last"` can be specified which ensures that the last node on the main_body
+            is used, and `-1` refers to the origin of the main body coordinate system.
+        mbdy2_eulerang_table : : (:, 3) ndarray, optional
+            A sequence of Euler angles, one per row.
+            Equivalent to HAWC2 command `mbdy2_eulerang`.
+            A 1D array with 3 elements will be interpreted as 1 row.
+            This table is additive with respect to the orientation / relative command in the htc file,
+            unless the flag `reset_orientation` is used.
+            The default is `[0, 0, 0]`, which means that no rotation is applied.
+        angles_in_deg : bool, optional
+            `True` if the angles in `mbdy2_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 no rotation
+            before applying `mbdy2_eulerang_table`. The default is `False`.
+        mbdy2_ini_rotvec_d1 : (4) ndarray, optional
+            Angular velocity. First 3 elements for the direction and last for the magnitude.
+            Equivalent to HAWC2 command `mbdy2_ini_rotvec_d1`.
+            The default is 0 speed.
+
+        Raises
+        ------
+        ValueError
+            If the `orientation` / `relative` command cannot be found,
+            or if the main bodies do not exist.
+
+        Returns
+        -------
+        None.
+
+        """
+        if mbdy2_eulerang_table is None:
+            mbdy2_eulerang_table = np.zeros((1, 3), dtype=np.float64, order="F")
+        if mbdy2_ini_rotvec_d1 is None:
+            mbdy2_ini_rotvec_d1 = np.zeros((4,), dtype=np.float64, order="F")
+        # 1D arrays are converted to 2D with 1 row.
+        mbdy2_eulerang_table = np.atleast_2d(mbdy2_eulerang_table)
+        # Convert node_1 and 2 to int.
+        if node_1 == "last":
+            node_1 = -2
+        if node_2 == "last":
+            node_2 = -2
+        error_code = -1
+        error_code = H2LibSignatures.set_orientation_relative(
+            self,
+            main_body_1,
+            node_1 + 1,
+            main_body_2,
+            node_2 + 1,
+            mbdy2_eulerang_table.shape[0],
+            np.asfortranarray(mbdy2_eulerang_table.astype(np.float64)),
+            bool(angles_in_deg),
+            reset_orientation,
+            np.asfortranarray(mbdy2_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
 
@@ -325,10 +647,12 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         return self._aero_sections_data_shape[rotor]
 
     def get_aerosections_position(self, rotor=0):
+        """Global xyz position of aero sections. Shape=(#blades, #sections, 3)"""
         position = np.zeros(self.aero_sections_data_shape(rotor), dtype=np.float64, order='F')
         return H2LibSignatures.get_aerosections_position(self, rotor + 1, position)[0][1]
 
     def set_aerosections_windspeed(self, uvw, rotor=0):
+        """Update wind speed at aero sections. uvw shape=(#blades, #sections, 3)"""
         return H2LibSignatures.set_aerosections_windspeed(self, rotor + 1, np.asarray(uvw, np.float64))
 
     def get_aerosections_forces(self, rotor=0):
@@ -417,9 +741,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):
@@ -445,15 +767,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):
@@ -506,14 +822,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):
@@ -544,14 +853,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.506'
-h2lib_version = '13.1.506'
-hawc2_version = '13.1.8'
+__version__ = '13.1.1701'
+h2lib_version = '13.1.1701'
+hawc2_version = '13.1.17'

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

@@ -11,6 +11,16 @@ class H2LibSignatures():
     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'''
@@ -254,6 +296,13 @@ end subroutine'''
     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
@@ -306,6 +355,45 @@ end subroutine'''
   end subroutine'''
         return self.get_lib_function('set_aerosections_windspeed')(rotor, uvw)
 
+    def set_orientation_base(self, main_body_name,
+                             n_rows, mbdy_eulerang_table, 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
+real(kind=c_double), dimension(n_rows, 3),   intent(in) :: mbdy_eulerang_table
+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,
+                                                             n_rows, mbdy_eulerang_table, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1,
+                                                             error_code)
+
+    def set_orientation_relative(self, main_body_1_name, node_1, main_body_2_name, node_2,
+                                 n_rows, mbdy2_eulerang_table, angles_in_deg,
+                                 reset_orientation,
+                                 mbdy2_ini_rotvec_d1,
+                                 error_code):
+        '''subroutine set_orientation_relative(main_body_1_name, node_1, main_body_2_name, node_2,  &
+character(kind=c_char, len=1),   dimension(256),       intent(in   ) :: main_body_1_name  ! Defined as an array of length 1 characters because of bind.
+character(kind=c_char, len=1),   dimension(256),       intent(in   ) :: main_body_2_name  ! Defined as an array of length 1 characters because of bind.
+integer(kind=8),                                       intent(in   ) :: node_1
+integer(kind=8),                                       intent(in   ) :: node_2
+real(kind=c_double),             dimension(n_rows, 3), intent(in   ) :: mbdy2_eulerang_table
+logical,                                               intent(in   ) :: angles_in_deg
+character(kind=c_char, len=256) :: mbdy_1_name  ! Same as main_body_1_name, but as string instead of an array of characters.
+character(kind=c_char, len=256) :: mbdy_2_name  ! Same as main_body_2_name, but as string instead of an array of characters.
+type(Tmain_body_input), pointer :: main_body_1  ! The main body pointer associated to main_body_1_name.
+type(Tmain_body_input), pointer :: main_body_2  ! The main body pointer associated to main_body_1_name.
+integer(kind=4) :: node_1_local, node_2_local     ! Internal copy of node_1 and node_2.
+real*8, dimension(3) :: eulerang                ! Euler angles associated to 1 row of mbdy2_eulerang_table.
+end subroutine'''
+        return self.get_lib_function('set_orientation_relative')(main_body_1_name, node_1, main_body_2_name, node_2,
+                                                                 n_rows, mbdy2_eulerang_table, angles_in_deg,
+                                                                 reset_orientation,
+                                                                 mbdy2_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
@@ -363,6 +451,12 @@ end subroutine'''
     end function'''
         return self.get_lib_function('step')(restype=restype)
 
+    def stop_on_error(self, flag):
+        '''subroutine stop_on_error(flag) bind(C, name="stop_on_error")
+      logical, intent(in) :: flag
+    end subroutine'''
+        return self.get_lib_function('stop_on_error')(flag)
+
     def test_hdf5(self, ):
         '''subroutine test_hdf5() BIND(C, NAME='test_hdf5')
   !DEC$ ATTRIBUTES DLLEXPORT :: test_hdf5

{h2lib-13.1.506.dist-info → h2lib-13.1.1701.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: h2lib
-Version: 13.1.506
-Summary: Python interface to HAWC2 (13.1.8)
+Version: 13.1.1701
+Summary: Python interface to HAWC2 (13.1.17)
 Download-URL: 
 Author: Mads M. Pedersen, S.G.Horcas and N.G.Ramos
 Author-email: mmpe@dtu.dk
@@ -11,11 +11,10 @@ Project-URL: Documentation, https://hawc2.pages.windenergy.dtu.dk/HAWC2Lib/
 Project-URL: Source, https://gitlab.windenergy.dtu.dk/HAWC2/HAWC2Lib
 Project-URL: Tracker, https://gitlab.windenergy.dtu.dk/HAWC2/HAWC2Lib/-/issues
 Requires-Dist: numpy
-Requires-Dist: intel-fortran-rt ==2021.3.0
-Requires-Dist: mkl ==2021.3.0
-Requires-Dist: multiclass-interface >=1.5
-Provides-Extra: mpi
-Requires-Dist: mpi4py ; extra == 'mpi'
+Requires-Dist: intel-fortran-rt==2021.3.0
+Requires-Dist: mkl==2021.3.0
+Requires-Dist: multiclass_interface>=1.5
 Provides-Extra: test
-Requires-Dist: h2lib-tests ; extra == 'test'
-
+Requires-Dist: h2lib_tests; extra == "test"
+Provides-Extra: mpi
+Requires-Dist: mpi4py; extra == "mpi"

h2lib-13.1.1701.dist-info/RECORD

@@ -0,0 +1,10 @@
+h2lib/HAWC2Lib.dll,sha256=2f3ye1UAvxStkuQdfZ45KsPuWatlk6OKQIRGFRM-qD4,30801920
+h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
+h2lib/_h2lib.py,sha256=oCWMTpkui3KIxuZrQcyecBAv-KBKx0exTf3UC1WTJzc,35053
+h2lib/_version.py,sha256=aoq7oNXs_pDNUhj3g7OPtlrQRPyElXusqp2iqfeyvps,149
+h2lib/dll_wrapper.py,sha256=CfuRfDPEmmfYlEGKUmiXiuMhNiMcf24ripPHgqd8CiE,12761
+h2lib/h2lib_signatures.py,sha256=1CuaSNfaTgnbhqcSaehQGNVHhKpvLFwgs2UucKWVQJE,24289
+h2lib-13.1.1701.dist-info/METADATA,sha256=LiH31EtB7-lMnREX8IcRQ3Sj1V7F5HhJJ8W_yEjiF7s,722
+h2lib-13.1.1701.dist-info/WHEEL,sha256=pWXrJbnZSH-J-PhYmKs2XNn4DHCPNBYq965vsBJBFvA,101
+h2lib-13.1.1701.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
+h2lib-13.1.1701.dist-info/RECORD,,

{h2lib-13.1.506.dist-info → h2lib-13.1.1701.dist-info}/WHEEL

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

h2lib-13.1.506.dist-info/RECORD

@@ -1,10 +0,0 @@
-h2lib/HAWC2Lib.dll,sha256=_ECzaJeq1hmHTNyfA2oiyBf5qZKkeyepyF4Y8cyKLyc,30728192
-h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
-h2lib/_h2lib.py,sha256=AVZODCr2c-NEosVTeqjZNU206MpnAVpmn_t3PolwjqM,22203
-h2lib/_version.py,sha256=rV968fg9Lfv32R9TQD6ussF8dTsA74ZCbW8VTanCuus,146
-h2lib/dll_wrapper.py,sha256=RC5_gJ1cwHXVfUaSvmsatyQrvks-aZJFAiXrG4B-FEI,12061
-h2lib/h2lib_signatures.py,sha256=mqAqgg93ZEiglibECu8yDk-hy3MU8XDfAeXg-aokLk8,17961
-h2lib-13.1.506.dist-info/METADATA,sha256=D3B2YjuywPU_q7nHchHr-2t5b2xOAU471mbaBI1j5UY,727
-h2lib-13.1.506.dist-info/WHEEL,sha256=3vidnDuZ-QSnHIxLhNbI1gIM-KgyEcMHuZuv1mWPd_Q,101
-h2lib-13.1.506.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
-h2lib-13.1.506.dist-info/RECORD,,