h2lib 13.1.506__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,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 +277,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 +296,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 +326,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 +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
 
@@ -417,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):
@@ -445,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):
@@ -506,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):
@@ -544,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.506'
-h2lib_version = '13.1.506'
-hawc2_version = '13.1.8'
+__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

@@ -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,20 @@ end subroutine'''
   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

{h2lib-13.1.506.dist-info → h2lib-13.1.901.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.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.506.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.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,,