h2lib 13.1.502__py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

h2lib/__init__.py

@@ -0,0 +1,15 @@
+import sys
+import os
+from ._h2lib import H2Lib, MultiH2Lib
+from ._version import __version__, h2lib_version, hawc2_version
+# try:
+# from ._version import __version__
+# if __version__ == 'unknown':
+#     f = os.path.abspath(os.path.dirname(__file__) + '/../../update_version.py')
+#     if os.path.isfile(f):
+#         os.system(f'{sys.executable} {f}')
+#     import importlib
+#     importlib.reload(_version)
+#     from ._version import __version__, h2lib_version, hawc2_version
+# except BaseException:
+#     pass

h2lib/_h2lib.py

@@ -0,0 +1,534 @@
+from contextlib import contextmanager
+from h2lib.dll_wrapper import DLLWrapper
+from h2lib.h2lib_signatures import H2LibSignatures
+import os
+import sys
+
+from multiclass_interface.multiprocess_interface import MultiProcessClassInterface, ProcessClass
+import numpy as np
+
+
+def H2Lib(suppress_output=False, subprocess=True):
+    H2 = [H2LibThread, H2LibProcess][subprocess]
+    return H2(suppress_output=suppress_output)
+
+
+class H2LibThread(H2LibSignatures, DLLWrapper):
+    _model_path = '.'
+    _aero_sections_data_shape = {}
+
+    def __init__(self, suppress_output=True, filename=None, cwd='.'):
+        if filename is None:
+            if os.name == 'nt':
+                filename = os.path.dirname(__file__) + '/HAWC2Lib.dll'
+            else:
+                filename = os.path.dirname(__file__) + '/HAWC2Lib.so'  # pragma: no cover
+        # 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)
+        DLLWrapper.__init__(self, filename, cwd=cwd, cdecl=True)
+        self.suppress_output = suppress_output
+        self._initialized = False
+        self.time = 0
+
+    @property
+    def model_path(self):
+        return self._model_path
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        if self._initialized:
+            self.write_output()
+            self.finalize()
+        DLLWrapper.close(self)
+        return "closed h2lib"
+
+    def getState(self):
+        return H2LibSignatures.getState(self, restype=np.int32)[1]
+
+    def work(self, time):
+        """Return number of loops"""
+        return H2LibSignatures.work(self, np.float64(time), restype=np.int64)[1]
+
+    def loop(self, N):
+        """Return time to compute N loops"""
+        return H2LibSignatures.loop(self, int(N), restype=np.float64)[1]
+
+    def get_version(self):
+        s = " " * 255
+        return H2LibSignatures.get_version(self, s)[0][0].strip()
+
+    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]
+
+    def get_uvw(self, pos_g):
+        vx, vy, vz = self.get_wind_speed(pos_g)
+        return [vy, vx, -vz]
+
+    def get_time(self):
+        return np.round(H2LibSignatures.get_time(self, time=0.)[0][0], 6)
+
+    def read_input(self, htc_path='htc/input_hawc.htc', model_path='.'):
+        self._model_path = model_path
+        self.cwd = self.model_path
+        return H2LibSignatures.read_input(self, htc_path)
+
+    def init(self, htc_path=None, model_path='.'):
+        assert not hasattr(self, '_init_result'), "init called twice"
+        if htc_path is not None:
+            self.read_input(htc_path, model_path)
+        r = H2LibSignatures.init(self)
+        self._initialized = True
+        return r
+
+    def step(self):
+        self.time = np.round(H2LibSignatures.step(self, restype=np.float64)[1], 6)
+        return self.time
+
+    def run(self, time):
+        self.time = np.round(H2LibSignatures.run(self, np.float64(time), restype=np.float64)[1], 6)
+        return self.time
+
+    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
+
+        Parameters
+        ----------
+        Sensor_line : str
+            Sensor line as used in the output sections in HAWC2. See How2Hawc2
+
+        Returns
+        -------
+        index_lst : list
+            List of sensor index(es). These index(es) can be used to call get_sensor_info or get_sensor_values
+        """
+        if ";" not in sensor_line:
+            sensor_line += ";"
+        index_start, index_stop = 0, 0
+        index_start, index_stop = H2LibSignatures.add_sensor(self, sensor_line.lower(), index_start, index_stop)[0][1:]
+        return tuple(range(index_start, index_stop + 1))
+
+    def get_sensor_info(self, id):
+        "return name, unit, description"
+        if isinstance(id, tuple):
+            return [self.get_sensor_info(i) for i in id]
+        return [s[:-1].strip()  # remove null termination
+                for s in H2LibSignatures.get_sensor_info(self, id, name=" " * 30, unit=" " * 10, desc=" " * 512)[0][1:]]
+
+    def get_sensor_values(self, id_lst):
+        """Get sensor values from HAWC2
+
+        Parameters
+        ----------
+        id_lst : array_like or int
+            list of sensor ids
+
+        Returns
+        -------
+        values : array_like or float
+        """
+        if isinstance(id_lst, int):
+            return self.get_sensor_values([id_lst])[0]
+        values = np.zeros(len(id_lst), dtype=np.float64)
+        id_lst = np.array(id_lst, dtype=np.int64)
+        return H2LibSignatures.get_sensor_values(self, id_lst, values, len(id_lst))[0][1]
+
+    def set_variable_sensor_value(self, id, value):
+        return H2LibSignatures.set_variable_sensor_value(self, id, np.float64(value))
+
+    def init_windfield(self, Nxyz, dxyz, box_offset_yz, transport_speed):
+        """Initialize wind field which afterwards can be set using set_windfield
+
+
+        x: direction of wind
+        y: horizontal to the left when looking along x
+        z: vertical up
+
+        Parameters
+        ----------
+        Nxyz : (int, int, int)
+            Number of points in wind field
+        dxyz : (float, float, float)
+            Distance between wind field points
+        box_offset_yz : (float, float)
+            Box offset in y and z, relative to hawc2 origo. Note this is in met coordinates as described above
+            To set a wind field of size 200x80x80, such that the center is located at hawc2 coordinate (0,0,-70),
+            box_offset_yz must be (-40,30)
+            Note that the wind field size is (Nxyz)-1*dxyz
+        transport_speed : float
+            Box transport speed
+
+        Notes
+        -----
+        The wind field will be transported in the hawc2 global y-direction with the transport speed,
+        In HAWC2:
+        - shear format is set to 0 (which also means that the mean wind (transport speed) is not added)
+        - turbformat is set to 1 (mann), but the buffer should be filled manually via set_windfield
+        - center_pos0 is set such that the lower right corner (when looking along global y) is located at box_offset_yz
+        - windfield_rotations is set to (0,0,0), i.e. the wind is aligned with y, and w points up (opposite global z)
+        - scaling is disabled
+        - the buffer is interpolated in the standard way, i.e. it is mirrored in the lateral and vertical direction and
+          repeated in the longitudinal direction
+
+        """
+        return H2LibSignatures.init_windfield(self, np.array(Nxyz, dtype=np.int64), np.array(dxyz, dtype=np.float64),
+                                              np.array(box_offset_yz, dtype=np.float64), np.float64(transport_speed))
+
+    def set_windfield(self, uvw, box_offset_x, time=None):
+        """Set wind field, must be called after init_windfield and init
+
+        Parameters
+        ----------
+        uvw : array_like, dims=(3,Nx,Ny,Nz)
+            wind field components including mean wind speed, shear etc.
+        box_offset_x : float
+            Offset in x direction at the <time>
+            To set a wind field of size 200x80x80, such that the front plane (largest x) is located
+            at hawc2 coordinate (0,20,-70), i.e. 20m downstream of origo, set box_offset_x=-180
+            Note that the wind field size is (Nxyz)-1*dxyz
+            Note also that the end plane (x=0) will be located in -180 and repeated in 20+dx
+        time : float, optional
+            Time at which the the last plane (x=0) is at x=box_offset_x
+            If None, default, time is set to the current time in HAWC2
+
+        Notes
+        -----
+        uvw must be scaled in advance to the right turbulence level
+        and should contain mean wind, shear, gusts, direction change etc.
+        and uvw(:,1) is the back plane of the turbulence box, while uvw(:,Nx) is the front plane
+        """
+        if time is None:
+            time = self.get_time()
+        uvw = np.asarray(uvw, dtype=np.float32)
+        assert np.all(np.isfinite(uvw)), "uvw passed to h2lib.set_windfield contains nan or inf"
+        return H2LibSignatures.set_windfield(self, np.asarray(uvw, dtype=np.float32),
+                                             np.float64(box_offset_x), np.float64(time))
+
+    # ===================================================================================================================
+    # H2rotor
+    # ===================================================================================================================
+
+    def get_rotor_dims(self):
+        return [[self.get_nSections(r, b) for b in range(self.get_nblades(r))]
+                for r in range(self.get_nrotors())]
+
+    def get_nrotors(self):
+        return H2LibSignatures.get_nrotors(self, restype=np.int64)[1]
+
+    def get_nblades(self, rotor=0):
+        return H2LibSignatures.get_nblades(self, rotor + 1, restype=np.int64)[1]
+
+    def get_nSections(self, rotor=0, blade=0):
+        return H2LibSignatures.get_nSections(self, rotor + 1, blade + 1, restype=np.int64)[1]
+
+    def get_diameter(self, rotor=0):
+        return H2LibSignatures.get_diameter(self, rotor + 1, restype=np.float64)[1]
+
+    def aero_sections_data_shape(self, rotor):
+        if rotor not in self._aero_sections_data_shape:
+            self._aero_sections_data_shape[rotor] = (self.get_nblades(rotor), self.get_nSections(rotor), 3)
+        return self._aero_sections_data_shape[rotor]
+
+    def get_aerosections_position(self, rotor=0):
+        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):
+        return H2LibSignatures.set_aerosections_windspeed(self, rotor + 1, np.asarray(uvw, np.float64))
+
+    def get_aerosections_forces(self, rotor=0):
+        shape = self.aero_sections_data_shape(rotor)
+        Fxyz = np.zeros(shape, dtype=np.float64, order='F')
+        return H2LibSignatures.get_aerosections_forces(self, rotor + 1, Fxyz)[0][1]
+
+    def get_aerosections_moments(self, rotor=0):
+        shape = self.aero_sections_data_shape(rotor)
+        Mxyz = np.zeros(shape, dtype=np.float64, order='F')
+        return H2LibSignatures.get_aerosections_moments(self, rotor + 1, Mxyz)[0][1]
+
+    def get_bem_grid_dim(self, rotor=0):
+        """returns (nazi, nrad)"""
+        return H2LibSignatures.get_bem_grid_dim(self, rotor + 1, 0, 0)[0][1:]
+
+    def get_bem_grid(self, rotor=0):
+        """returns azi, rad"""
+        nazi, nrad = self.get_bem_grid_dim(rotor)
+        return H2LibSignatures.get_bem_grid(self, rotor + 1,
+                                            np.zeros(nazi, dtype=np.float64, order='F'),
+                                            np.zeros(nrad, dtype=np.float64, order='F'))[0][1:]
+
+    def get_induction_polargrid(self, rotor=0):
+        nazi, nrad = self.get_bem_grid_dim(rotor)
+        induction = np.zeros((nazi, nrad), dtype=np.float64, order='F')
+        return H2LibSignatures.get_induction_polargrid(self, rotor + 1, induction)[0][1]
+
+    def get_induction_axisymmetric(self, rotor=0):
+        nrad = self.get_bem_grid_dim(rotor)[1]
+        induction = np.zeros(nrad, dtype=np.float64)
+        return H2LibSignatures.get_induction_axisymmetric(self, rotor + 1, induction)[0][1]
+
+    def get_induction_rotoravg(self, rotor=0):
+        induction = np.float64(0)
+        return H2LibSignatures.get_induction_rotoravg(self, rotor + 1, induction)[0][1]
+
+    def get_rotor_orientation(self, rotor=0, deg=False):
+        """return yaw, tilt, azi(of first blade) in rad(default) or deg"""
+        r = H2LibSignatures.get_rotor_orientation(self, rotor=rotor + 1, yaw=0., tilt=0., azi=0.)[0][1:]
+        if deg:
+            return np.rad2deg(r)
+        else:
+            return r
+
+    def get_rotor_position(self, rotor=0):
+        return H2LibSignatures.get_rotor_position(self, rotor=rotor + 1, position=np.zeros(3, dtype=np.float64))[0][1]
+
+    def get_rotor_avg_wsp(self, coo=1, rotor=0):
+        """Returns the rotor averaged wind speed in global(coo=1, default) or rotor(coo=2) coordinates."""
+        assert self.time > 0
+        wsp = np.zeros(3, dtype=np.float64)
+        return H2LibSignatures.get_rotor_avg_wsp(self, coo=coo, rotor=rotor + 1, wsp=wsp)[0][2]
+
+    def get_rotor_avg_uvw(self, rotor=0):
+        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.
+
+        Raises
+        ------
+        RuntimeError
+            If the structure is confidential.
+
+        Returns
+        -------
+        nbdy : int
+            Number of bodies.
+        ncst : int
+            Number of constraints.
+
+        """
+        nbdy = -1
+        ncst = -1
+        error_code = -1
+        (
+            nbdy,
+            ncst,
+            error_code,
+        ) = H2LibSignatures.get_number_of_bodies_and_constraints(
+            self, nbdy, ncst, error_code
+        )[
+            0
+        ]
+        if error_code > 0:
+            if error_code == 4:
+                raise RuntimeError("STRUCTURE_IS_CONFIDENTIAL")
+            raise RuntimeError(error_code)  # pragma: no cover
+        return nbdy, ncst
+
+    def get_number_of_elements(self):
+        """
+        Get the number of elements for each body.
+
+        Raises
+        ------
+        RuntimeError
+            If the structure is confidential.
+
+        Returns
+        -------
+        nelem : (nbdy) ndarray, int
+            Number of elements for each body.
+
+        """
+        nbdy, _ = self.get_number_of_bodies_and_constraints()
+
+        nelem = np.zeros((nbdy, ), dtype=np.int64, order="F")
+        error_code = -1
+        _, nelem, error_code = H2LibSignatures.get_number_of_elements(
+            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
+        return nelem
+
+    def get_timoshenko_location(self, ibdy, ielem):
+        """
+        Get the location and orientation of an element.
+
+        Parameters
+        ----------
+        ibdy : int
+            Body index, starting from 0.
+        ielem : int
+            Element index, starting from 0.
+
+        Raises
+        ------
+        RuntimeError
+            If the structure is confidential.
+        IndexError
+            If the body or the element do not exist.
+
+        Returns
+        -------
+        l : float
+            Element length.
+        r1 : (3) ndarray
+            Location of node 1.
+        r12 : (3) ndarray
+            Vector from node 1 to node 2.
+        tes : (3, 3) ndarray
+            Transformation matrix describing orientation.
+
+        """
+
+        l = 0.0
+        r1 = np.zeros((3), order="F")
+        r12 = np.zeros((3), order="F")
+        tes = np.zeros((3, 3), order="F")
+        error_code = -1
+        (
+            _,
+            _,
+            l,
+            r1,
+            r12,
+            tes,
+            error_code,
+        ) = H2LibSignatures.get_timoshenko_location(
+            self, ibdy + 1, ielem + 1, l, r1, r12, tes, 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")
+            elif error_code == 6:
+                raise IndexError("ELEMENT_DOES_NOT_EXIST")
+            raise RuntimeError(error_code)  # pragma: no cover
+
+        return l, r1, r12, tes
+
+    def get_body_rotation_tensor(self, ibdy):
+        """
+        Get the rotation tensor of the requested body, that transforms from local to global base.
+
+        Parameters
+        ----------
+        ibdy : int
+            Body index, starting from 0.
+
+        Raises
+        ------
+        RuntimeError
+            If the structure is confidential.
+        IndexError
+            If the body does not exist.
+
+        Returns
+        -------
+        amat : (3, 3) ndarray
+            Rotation tensor.
+
+        """
+        amat = np.zeros((3, 3), order="F")
+        error_code = -1
+        _, amat, error_code = H2LibSignatures.get_body_rotation_tensor(
+            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
+
+        return amat
+
+
+@contextmanager
+def set_LD_LIBRARY_PATH():
+    _file__ = np.__file__
+    old = os.environ.get('LD_LIBRARY_PATH', "")
+
+    if '/lib/' in _file__:  # pragma: no cover  (only on linux)
+        lib_path = _file__[:_file__.index("/lib/") + 5]
+        os.environ['LD_LIBRARY_PATH'] = f'{lib_path}:{old}'
+
+    try:
+        yield
+    finally:
+        os.environ['LD_LIBRARY_PATH'] = old
+
+
+class H2LibProcess(ProcessClass, H2LibThread):
+    def __init__(self, suppress_output, filename=None, cwd='.'):
+        with set_LD_LIBRARY_PATH():
+            ProcessClass.__init__(self, cls=H2LibThread, cls_attrs=set(dir(H2LibThread)) - set(dir(ProcessClass)))
+            self(suppress_output=suppress_output, filename=filename, cwd=cwd)
+
+
+def MultiH2Lib(N, filename=None, cwd='.', suppress_output=False):
+
+    if not hasattr(suppress_output, '__len__'):
+        suppress_output = [suppress_output] * N
+    args = [(suppress_output[i], filename, cwd) for i in range(N)]
+
+    with set_LD_LIBRARY_PATH():
+        from multiclass_interface import mpi_interface
+        if mpi_interface.mpi:  # pragma: no cover
+            # try:
+            #     with H2LibThread(filename):
+            #         pass
+            #     # LD_LIBRARY_PATH is set. Run H2LibThread directly in mpi processes
+            #     cls = H2LibThread
+            # except OSError:
+            #     # Set LD_LIBRARY_PATH in mpi workers and run H2LibThread from the workers via ProcessClass
+            #     cls = H2LibProcess
+            from multiclass_interface.mpi_interface import MPIClassInterface
+            cls = H2LibProcess
+            return MPIClassInterface(cls, args)
+        else:
+            return MultiProcessClassInterface(H2LibThread, args)

h2lib/_version.py

@@ -0,0 +1,4 @@
+# This file is autogenerated and should not be modified manually
+__version__ = '13.1.502'
+h2lib_version = '13.1.502'
+hawc2_version = '13.1.5+4-g20eca1a'

h2lib/dll_wrapper.py

@@ -0,0 +1,329 @@
+import numpy as np
+from numpy.ctypeslib import ndpointer
+import ctypes as ct
+import _ctypes
+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 contextlib import contextmanager
+import tempfile
+try:
+    from ctypes import windll
+except ImportError:
+    pass
+import sys
+from pathlib import Path
+import atexit
+c_int_p = POINTER(ctypes.c_long)
+c_long_p = POINTER(ctypes.c_longlong)
+
+c_double_p = POINTER(ctypes.c_double)
+c_float_p = POINTER(ctypes.c_float)
+
+in_use = []
+
+
+class SuppressStream(object):
+
+    def __init__(self, suppressed_output_file, stream=sys.stderr):
+        self.orig_stream_fileno = stream.fileno()
+        self.stream = stream
+        self.suppressed_output_file = suppressed_output_file
+
+    def __enter__(self):
+        # save stream file descriptor
+        self.orig_stream_dup = os.dup(self.orig_stream_fileno)
+        self.stream.flush()
+        os.dup2(self.suppressed_output_file.fileno(), self.orig_stream_fileno)
+
+    def __exit__(self, type, value, traceback):
+        os.dup2(self.orig_stream_dup, self.orig_stream_fileno)
+        os.close(self.orig_stream_dup)
+
+
+def suppress_output(f):
+    def wrap(*args, **kwargs):
+        if 'verbose' not in kwargs or not kwargs.pop('verbose'):
+            with SuppressStream(sys.stdout), SuppressStream(sys.stderr):
+                f(*args, **kwargs)
+        else:
+            f(*args, **kwargs)
+    return wrap
+
+
+@contextmanager
+def chdir(path):
+    oldpwd = os.getcwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(oldpwd)
+
+
+def cwd(f):
+    def wrap(self, *args, **kwargs):
+        with chdir(self.model_path):
+            f(self, *args, **kwargs)
+    return wrap
+
+
+def wrap(self, f, *args, **kwargs):
+    c_args = []
+    args = list(args)
+    for i, arg in enumerate(args):
+        if isinstance(arg, (list, tuple)):
+            if all([isinstance(e, int) for e in arg]):
+                # default to int64 which is default on linux but not windows
+                args[i] = np.array(arg, dtype=np.int64)
+            else:
+                args[i] = np.array(arg)
+        if isinstance(args[i], np.ndarray):
+
+            if self.fortran:
+                if not args[i].flags.f_contiguous:
+                    sys.stderr.write(f'argument {i} for {f.__name__} not f_contiguous\n')
+            else:
+                if not args[i].flags.c_contiguous:
+                    sys.stderr.write(f'argument {i} for {f.__name__} not c_contiguous\n')
+
+            args[i] = np.require(args[i], requirements=['C', 'F'][self.fortran])
+
+    for arg in args:
+        if isinstance(arg, int):
+            c_args.append(c_long_p(c_longlong(arg)))
+        elif isinstance(arg, float):
+            c_args.append(c_double_p(c_double(arg)))
+        elif isinstance(arg, str):
+            c_args.append(c_char_p(arg.encode('cp1252')))
+            # c_args.append(c_int_p(c_int(len(arg))))
+
+        elif isinstance(arg, np.ndarray):
+            if arg.dtype in [np.int32]:
+                c_args.append(arg.ctypes.data_as(c_int_p))
+            elif arg.dtype in [np.int64]:
+                c_args.append(arg.ctypes.data_as(c_long_p))
+            elif arg.dtype == np.float64:
+                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))
+            else:
+                raise NotImplementedError(arg.dtype)
+
+        else:
+            # raise NotImplementedError(arg.__class__.__name__)
+            c_args.append(arg)
+    if 'restype' in kwargs:
+        restype = kwargs['restype']
+        if hasattr(restype, 'dtype'):
+            restype = np.ctypeslib.as_ctypes_type(restype)
+        f.restype = restype
+    with chdir(self.cwd):
+        if self.suppress_output:
+            with SuppressStream(self.suppressed_output_file, sys.stdout), SuppressStream(self.suppressed_output_file, sys.stderr):
+                res = f(*c_args)
+        else:
+            res = f(*c_args)
+    ret_args = []
+    for arg in args:
+        c_arg = c_args.pop(0)
+        if isinstance(arg, (int, float)):
+            ret_args.append(c_arg.contents.value)
+        elif isinstance(arg, (str)):
+            ret_args.append(c_arg.value.decode('cp1252'))
+            # c_args.pop(0)
+        elif isinstance(arg, np.ndarray):
+            ret_args.append(arg)
+        else:
+            raise NotImplementedError(arg.__class__.__name__)
+    return ret_args, res
+
+
+class DLLWrapper(object):
+    def __init__(self, filename, cwd='.', cdecl=True, fortran=True):
+        self.filename = str(filename)
+        if os.path.abspath(self.filename) in in_use:
+            raise Exception(f'{os.path.abspath(self.filename)} already in use in current process.')
+        self.cwd = cwd
+        self.cdecl = cdecl
+        self.fortran = fortran
+        self.suppress_output = False
+        self.suppressed_output_file = tempfile.TemporaryFile('w')
+        self.open()
+        in_use.append(os.path.abspath(self.filename))
+        atexit.register(self.close)
+
+    @staticmethod
+    def find_dll(path, name):
+        p = Path(path)
+
+#         if sys.platform == "win32":
+#             prefixes = ['']
+#             if sys.maxsize > 2**32:
+#                 suffixes = ['.dll', '_64.dll']
+#             else:
+#                 suffixes = ['.dll']
+#         elif sys.platform == 'linux':
+#             prefixes = ['lib','']
+#             suffixes = ['.so']
+#         else:
+#             raise NotImplementedError()
+
+        dll_lst = []
+        file_patterns = ['*%s*.dll' % name, '*%s*.so' % name]
+        for fp in file_patterns:
+            dll_lst.extend(list(p.glob("**/" + fp)))
+
+        def use_first(dll_lst):
+            f = str(dll_lst[0])
+            print("Using ", os.path.abspath(f))
+            return DLLWrapper(f)
+
+        if len(dll_lst) == 1:
+            return use_first(dll_lst)
+        elif len(dll_lst) > 1:
+            # check if excluding dlls in hawc2-binary, i.e. "hawc2-<platform>" results in one dll
+            dll_lst2 = [d for d in dll_lst if not str(d).startswith('hawc2-')]
+            if len(dll_lst2) == 1:
+                return use_first(dll_lst2)
+            raise FileExistsError("Multiple dlls found:\n" + "\n".join([str(p) for p in dll_lst]))
+        else:
+            raise FileNotFoundError("No " + " or ".join(file_patterns) +
+                                    " files found in " + os.path.abspath(p.absolute()))
+
+    def open(self):
+        assert os.path.isfile(self.filename), os.path.abspath(self.filename)
+        if self.cdecl:
+            try:
+                # python < (3, 8) and > 3.10?:
+                self.lib = ct.CDLL(self.filename)
+            except BaseException:
+                self.lib = ct.CDLL(self.filename, winmode=ctypes.DEFAULT_MODE)
+        else:
+            self.lib = windll.LoadLibrary(self.filename)
+
+    def close(self):
+        if "FreeLibrary" in dir(_ctypes):
+            _ctypes.FreeLibrary(self.lib._handle)
+        else:
+            _ctypes.dlclose(self.lib._handle)
+        del self.lib
+        self.suppressed_output_file.close()
+        atexit.unregister(self.close)
+        in_use.remove(os.path.abspath(self.filename))
+
+#     def __enter__(self):
+#         self.open()
+#         return self
+#
+#     def __exit__(self, type, value, traceback):
+#         self.close()
+#         return False
+
+    def __getattr__(self, name):
+        if name == 'lib':
+            raise Exception("DLL not loaded. Run using: 'with dll: ...'")
+        return self.get_lib_function(name)
+
+    def get_lib_function(self, name):
+        try:
+            f = getattr(self.lib, name)
+        except AttributeError as e:
+            raise AttributeError("Attribute '%s' not found in dll ('%s')" % (name, self.filename))
+        return lambda *args, **kwargs: wrap(self, f, *args, **kwargs)
+
+    def version(self, function_name='get_version'):
+        try:
+            f = getattr(self.lib, function_name)
+            f.argtypes = [c_char_p, c_long]
+            s = "".ljust(255)
+            arg = c_char_p(s.encode('utf-8'))
+            f(arg, len(s))
+            return arg.value.decode().strip()
+        except AttributeError:
+            if function_name == 'get_version':
+                return self.version('version')
+
+    def getFileProperties(self):
+        if sys.platform != "win32":
+            raise OSError("Only supported for Windows")
+        import win32api
+        fname = self.filename
+
+        # ==============================================================================
+        """
+        Read all properties of the given file return them as a dictionary.
+        """
+        propNames = ('Comments', 'InternalName', 'ProductName',
+                     'CompanyName', 'LegalCopyright', 'ProductVersion',
+                     'FileDescription', 'LegalTrademarks', 'PrivateBuild',
+                     'FileVersion', 'OriginalFilename', 'SpecialBuild')
+
+        props = {'FixedFileInfo': None, 'StringFileInfo': None, 'FileVersion': None}
+
+        try:
+            # backslash as parm returns dictionary of numeric info corresponding to VS_FIXEDFILEINFO struc
+            fixedInfo = win32api.GetFileVersionInfo(fname, '\\')
+            props['FixedFileInfo'] = fixedInfo
+            props['FileVersion'] = "%d.%d.%d.%d" % (fixedInfo['FileVersionMS'] / 65536,
+                                                    fixedInfo['FileVersionMS'] % 65536, fixedInfo['FileVersionLS'] / 65536,
+                                                    fixedInfo['FileVersionLS'] % 65536)
+
+            # \VarFileInfo\Translation returns list of available (language, codepage)
+            # pairs that can be used to retreive string info. We are using only the first pair.
+            lang, codepage = win32api.GetFileVersionInfo(fname, '\\VarFileInfo\\Translation')[0]
+
+            # any other must be of the form \StringfileInfo\%04X%04X\parm_name, middle
+            # two are language/codepage pair returned from above
+
+            strInfo = {}
+            for propName in propNames:
+                strInfoPath = u'\\StringFileInfo\\%04X%04X\\%s' % (lang, codepage, propName)
+                # print str_info
+                strInfo[propName] = win32api.GetFileVersionInfo(fname, strInfoPath)
+
+            props['StringFileInfo'] = strInfo
+        except BaseException:
+            pass
+
+        return props
+
+
+class Type2DllWrapper(DLLWrapper):
+    def __init__(self, filename, dll_subroutine_init, dll_subroutine_update,
+                 arraysizes_init, arraysizes_update,
+                 init_array):
+        super().__init__(filename)
+        self.dll_subroutine_init = dll_subroutine_init
+        self.dll_subroutine_update = dll_subroutine_update
+        self.arraysizes_init = arraysizes_init
+        self.arraysizes_update = arraysizes_update
+        self.init_array = init_array
+
+    def open(self):
+        DLLWrapper.open(self)
+        self.init()
+
+    def call(self, name, array, n1, n2):
+        f = getattr(self.lib, name)
+        f.argtypes = [ndpointer(shape=n1, dtype=ct.c_double, flags='FORTRAN'),
+                      ndpointer(shape=n2, dtype=ct.c_double, flags='FORTRAN')]
+        f.restype = None
+
+        pad_array = np.zeros(n1)
+        pad_array[:len(array)] = array
+        arg1 = np.array(pad_array, dtype=ct.c_double, order='F')
+        arg2 = np.zeros(n2, dtype=ct.c_double, order='F')
+
+        f(arg1, arg2)
+        return arg2
+
+    def init(self):
+        n1, n2 = self.arraysizes_init
+        return self.call(self.dll_subroutine_init, self.init_array, n1, n2)
+
+    def update(self, array):
+        n1, n2 = self.arraysizes_update
+        return self.call(self.dll_subroutine_update, array, n1, n2)

h2lib/h2lib_signatures.py

@@ -0,0 +1,366 @@
+# noqa
+
+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
+      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 echo_version(self, ):
+        '''subroutine echo_version() BIND(C, NAME='echo_version')
+    !DEC$ ATTRIBUTES DLLEXPORT :: echo_version
+    !GCC$ ATTRIBUTES DLLEXPORT :: echo_version
+    type (tbuildinfo)   :: b
+end subroutine'''
+        return self.get_lib_function('echo_version')()
+
+    def extern_write_log(self, c_msg, n, dll_name, error, warning):
+        '''subroutine extern_write_log(c_msg, n, dll_name, error, warning) bind(C, name="extern_write_log")
+            integer, intent(in) :: n
+            character(kind=c_char, len=1), intent(in) :: c_msg(n)
+            character(kind=c_char), intent(in) :: dll_name(50)
+            logical(kind=c_bool), intent(in), optional :: error, warning
+    character(kind=c_char, len=1), intent(in) :: c_msg(n_msg)
+    integer, intent(in) :: n_msg
+    character(kind=c_char), intent(in) :: dll_name(50)
+    character(len=50) :: n
+    logical(kind=c_bool), intent(in), optional :: error, warning
+end subroutine'''
+        return self.get_lib_function('extern_write_log')(c_msg, n, dll_name, error, warning)
+
+    def fail(self, str_arr):  # pragma: no cover
+        '''subroutine fail(str_arr) bind(C, name='fail')
+    character(kind=c_char, len=1), intent(inout)       :: str_arr(255)
+  end subroutine'''
+        return self.get_lib_function('fail')(str_arr)
+
+    def finalize(self, ):
+        '''SUBROUTINE finalize() bind(C, name="finalize")
+!DEC$ ATTRIBUTES DLLEXPORT :: finalize
+  integer:: i
+  real*4:: T2
+END SUBROUTINE'''
+        return self.get_lib_function('finalize')()
+
+    def getSquare(self, val, restype):
+        '''function getSquare(val) result(valSquared) BIND(C, NAME='getSquare')
+  !DEC$ ATTRIBUTES DLLEXPORT :: getSquare
+        real(RK), intent(in) :: val
+        real(RK)             :: valSquared
+    end function'''
+        return self.get_lib_function('getSquare')(val, restype=restype)
+
+    def getState(self, restype):
+        '''function getState() result(val) BIND(C, NAME='getState')
+  !DEC$ ATTRIBUTES DLLEXPORT :: getState
+        integer             :: val
+    end function'''
+        return self.get_lib_function('getState')(restype=restype)
+
+    def get_aerosections_forces(self, rotor, Fxyz):
+        '''subroutine get_aerosections_forces(rotor, Fxyz) bind(C, name='get_aerosections_forces')
+    integer*8, intent(in) :: rotor
+    real(c_double),intent(out)::Fxyz(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
+  end subroutine'''
+        return self.get_lib_function('get_aerosections_forces')(rotor, Fxyz)
+
+    def get_aerosections_moments(self, rotor, Mxyz):
+        '''subroutine get_aerosections_moments(rotor, Mxyz) bind(C, name='get_aerosections_moments')
+    integer*8, intent(in) :: rotor
+    real(c_double),intent(out):: Mxyz(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
+  end subroutine'''
+        return self.get_lib_function('get_aerosections_moments')(rotor, Mxyz)
+
+    def get_aerosections_position(self, rotor, position):
+        '''subroutine get_aerosections_position(rotor, position) bind(C, name="get_aerosections_position")
+    integer*8, intent(in) :: rotor
+    real(c_double),intent(out)   :: position(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
+  end subroutine'''
+        return self.get_lib_function('get_aerosections_position')(rotor, position)
+
+    def get_bem_grid(self, rotor, azi, rad):
+        '''subroutine get_bem_grid(rotor, azi, rad) bind(C, name="get_bem_grid")
+    integer*8, intent(in)               :: rotor
+    real(c_double), intent(out)       :: azi(rotors_gl%rotor(rotor)%dyn_induc%bem%nazi)
+    real(c_double), intent(out)       :: rad(rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
+  end subroutine'''
+        return self.get_lib_function('get_bem_grid')(rotor, azi, rad)
+
+    def get_bem_grid_dim(self, rotor, nazi, nrad):
+        '''subroutine get_bem_grid_dim(rotor, nazi, nrad) bind(C, name="get_bem_grid_dim")
+    integer*8, intent(in)               :: rotor
+    integer*8, intent(out)              :: nazi, nrad
+  end subroutine'''
+        return self.get_lib_function('get_bem_grid_dim')(rotor, nazi, nrad)
+
+    def get_body_rotation_tensor(self, ibdy, amat, error_code):
+        '''subroutine get_body_rotation_tensor(ibdy, amat, error_code) &
+    integer(kind=8), intent(in) :: ibdy
+    real(kind=c_double), dimension(3, 3), intent(out) :: amat
+    integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('get_body_rotation_tensor')(ibdy, amat, error_code)
+
+    def get_diameter(self, rotor, restype):
+        '''function get_diameter(rotor) bind(C, name="get_diameter")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_diameter
+    integer*8, intent(in) :: rotor
+    Type (Taerorotor),pointer :: rotor_p
+    real(c_double)  :: get_diameter
+ end function'''
+        return self.get_lib_function('get_diameter')(rotor, restype=restype)
+
+    def get_induction_axisymmetric(self, rotor, induction):
+        '''subroutine get_induction_axisymmetric(rotor, induction) bind(C, name="get_induction_axisymmetric")
+    integer*8, intent(in)        :: rotor
+    real(c_double),intent(out)   :: induction(rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
+  end subroutine'''
+        return self.get_lib_function('get_induction_axisymmetric')(rotor, induction)
+
+    def get_induction_polargrid(self, rotor, induction):
+        '''subroutine get_induction_polargrid(rotor, induction) bind(C, name="get_induction_polargrid")
+      integer*8, intent(in)        :: rotor
+      real(c_double),intent(out)   :: induction(rotors_gl%rotor(rotor)%dyn_induc%bem%nazi, rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
+  end subroutine'''
+        return self.get_lib_function('get_induction_polargrid')(rotor, induction)
+
+    def get_induction_rotoravg(self, rotor, induction):
+        '''subroutine get_induction_rotoravg(rotor, induction) bind(C, name="get_induction_rotoravg")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_induction_rotoravg
+    integer*8, intent(in)        :: rotor
+    real(c_double), intent(out) :: induction
+  end subroutine'''
+        return self.get_lib_function('get_induction_rotoravg')(rotor, induction)
+
+    def get_nSections(self, rotor, blade, restype):
+        '''function get_nSections(rotor, blade) bind(C, name="get_nSections")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_nSections
+    integer*8, intent(in) :: rotor, blade
+    integer*8             :: get_nSections
+  end function'''
+        return self.get_lib_function('get_nSections')(rotor, blade, restype=restype)
+
+    def get_nblades(self, rotor, restype):
+        '''function get_nblades(rotor) bind(C, name="get_nblades")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_nblades
+    integer*8, intent(in) ::  rotor
+    integer*8             :: get_nblades
+  end function'''
+        return self.get_lib_function('get_nblades')(rotor, restype=restype)
+
+    def get_nrotors(self, restype):
+        '''function get_nrotors() bind(C, name="get_nrotors")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_nrotors
+    integer*8 :: get_nrotors
+  end function'''
+        return self.get_lib_function('get_nrotors')(restype=restype)
+
+    def get_number_of_bodies_and_constraints(self, nbdy, ncst, error_code):
+        '''subroutine get_number_of_bodies_and_constraints(nbdy, ncst, error_code) &
+    integer(kind=8), intent(out) :: nbdy
+    integer(kind=8), intent(out) :: ncst
+    integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('get_number_of_bodies_and_constraints')(nbdy, ncst, error_code)
+
+    def get_number_of_elements(self, nbdy, nelem, error_code):
+        '''subroutine get_number_of_elements(nbdy, nelem, error_code) &
+    integer(kind=8), intent(in) :: nbdy
+    integer(kind=8), dimension(nbdy), intent(out) :: nelem
+    integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('get_number_of_elements')(nbdy, nelem, error_code)
+
+    def get_rotor_avg_wsp(self, coo, rotor, wsp):
+        '''subroutine get_rotor_avg_wsp(coo, rotor, wsp) bind(C, name="get_rotor_avg_wsp")
+    integer*8, intent(in) :: rotor
+    integer*8, intent(in) :: coo ! 1: global, 2: rotor
+    real(c_double), dimension(3):: wsp
+  end subroutine'''
+        return self.get_lib_function('get_rotor_avg_wsp')(coo, rotor, wsp)
+
+    def get_rotor_orientation(self, rotor, yaw, tilt, azi):
+        '''subroutine get_rotor_orientation(rotor, yaw, tilt, azi) bind(C, name="get_rotor_orientation")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_rotor_orientation
+    integer*8, intent(in) :: rotor
+    real(c_double), intent(out) :: yaw, tilt, azi
+  end subroutine'''
+        return self.get_lib_function('get_rotor_orientation')(rotor, yaw, tilt, azi)
+
+    def get_rotor_position(self, rotor, position):
+        '''subroutine get_rotor_position(rotor, position) bind(C, name="get_rotor_position")
+    !DEC$ ATTRIBUTES DLLEXPORT :: get_rotor_position
+    integer*8, intent(in) :: rotor
+    real(c_double), dimension(3), intent(out) ::  position
+  !DEC$ ATTRIBUTES DLLEXPORT :: get_rotor_avg_wsp
+    integer*8, intent(in) :: rotor
+    integer*8, intent(in) :: coo ! 1: global, 2: rotor
+  end subroutine'''
+        return self.get_lib_function('get_rotor_position')(rotor, position)
+
+    def get_sensor_info(self, id, name, unit, desc):
+        '''subroutine get_sensor_info(id, name, unit, desc) bind(C, name="get_sensor_info")
+      integer*8, intent(in) :: id
+      character(kind=c_char, len=1), intent(out)       :: name(30), unit(10), desc(512)
+    end subroutine'''
+        return self.get_lib_function('get_sensor_info')(id, name, unit, desc)
+
+    def get_sensor_values(self, ids, values, n):
+        '''subroutine get_sensor_values(ids, values, n) bind(C, name="get_sensor_values")
+      integer*8, intent(in) :: n
+      integer*8, intent(in) :: ids(n)
+      real(c_double), intent(out)        :: values(n)
+    end subroutine'''
+        return self.get_lib_function('get_sensor_values')(ids, values, n)
+
+    def get_time(self, time):
+        '''subroutine
+subroutine'''
+        return self.get_lib_function('get_time')(time)
+
+    def get_timoshenko_location(self, ibdy, ielem, l, r1, r12, tes, error_code):
+        '''subroutine get_timoshenko_location(ibdy, ielem, l, r1, r12, tes, error_code) &
+    integer(kind=8), intent(in) :: ibdy
+    integer(kind=8), intent(in) :: ielem
+    real(kind=c_double), intent(out) :: l
+    real(kind=c_double), dimension(3), intent(out) :: r1
+    real(kind=c_double), dimension(3), intent(out) :: r12
+    real(kind=c_double), dimension(3,3), intent(out) :: tes
+    integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('get_timoshenko_location')(ibdy, ielem, l, r1, r12, tes, error_code)
+
+    def get_version(self, s):
+        '''subroutine get_version(s) BIND(C, NAME='get_version')
+                character(kind=c_char, len=1), intent(inout)  :: s(255)
+            end subroutine'''
+        return self.get_lib_function('get_version')(s)
+
+    def init(self, ):
+        '''subroutine init() bind(C, name="init")
+     !DEC$ ATTRIBUTES DLLEXPORT :: init
+    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
+      real*8              :: transport_speed
+    end subroutine'''
+        return self.get_lib_function('init_windfield')(Nxyz, dxyz, box_offset_yz, transport_speed)
+
+    def loop(self, N, restype):
+        '''function loop(N) bind(C, Name='loop')
+    !DEC$ ATTRIBUTES DLLEXPORT :: loop
+    integer*8, intent(in) :: N
+    real(c_double) :: loop,a
+    integer*8 :: i, j
+  end function'''
+        return self.get_lib_function('loop')(N, restype=restype)
+
+    def myfunction(self, int, dbl, restype):
+        '''function myfunction(int, dbl) bind(C, name='myfunction')
+      !DEC$ ATTRIBUTES DLLEXPORT :: myfunction
+      integer*8, intent(in) :: int
+      real(c_double), intent(in) :: dbl
+      real(c_double) :: myfunction
+    end function'''
+        return self.get_lib_function('myfunction')(int, dbl, restype=restype)
+
+    def mysubroutine(self, str_arr, dbl_arr):
+        '''subroutine mysubroutine(str_arr, dbl_arr) bind(C, name='mysubroutine')
+      character(kind=c_char, len=1), intent(inout)       :: str_arr(20)
+      real(c_double), intent(inout), dimension(2) :: dbl_arr
+    end subroutine'''
+        return self.get_lib_function('mysubroutine')(str_arr, dbl_arr)
+
+    def read_input(self, htc_path):
+        '''subroutine read_input(htc_path) bind(C, name="read_input")
+      character(kind=c_char, len=1), intent(in)       :: htc_path(1024)
+    end subroutine'''
+        return self.get_lib_function('read_input')(htc_path)
+
+    def run(self, time, restype):
+        '''function run(time) bind(C, name='run')
+      !DEC$ ATTRIBUTES DLLEXPORT :: run
+      real(c_double), intent(in) :: time
+      real(c_double) :: run, eps
+    end function'''
+        return self.get_lib_function('run')(time, restype=restype)
+
+    def setState(self, val):
+        '''subroutine setState(val) BIND(C, NAME='setState')
+  integer, intent(in) :: val
+ end subroutine'''
+        return self.get_lib_function('setState')(val)
+
+    def set_aerosections_windspeed(self, rotor, uvw):
+        '''subroutine set_aerosections_windspeed(rotor, uvw) bind(C, name="set_aerosections_windspeed")
+    integer*8, intent(in) :: rotor
+    real(c_double),intent(in)   :: uvw(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
+  end subroutine'''
+        return self.get_lib_function('set_aerosections_windspeed')(rotor, uvw)
+
+    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
+      real(c_double)        :: value
+    end subroutine'''
+        return self.get_lib_function('set_variable_sensor_value')(id, value)
+
+    def set_windfield(self, uvw, box_offset_x, time):
+        '''subroutine set_windfield(uvw, box_offset_x, time) bind(C, name="set_windfield")
+      real*4, intent(in) :: uvw(3, gwsd%TMOD%buffer_points_x,gwsd%TMOD%buffer_points_y,gwsd%TMOD%buffer_points_z)
+      real*8, intent(in):: box_offset_x, time
+    end subroutine'''
+        return self.get_lib_function('set_windfield')(uvw, box_offset_x, time)
+
+    def sqr2(self, val):
+        '''subroutine sqr2(val) BIND(C, NAME='sqr2')
+  integer, intent(inout) :: val
+ end subroutine'''
+        return self.get_lib_function('sqr2')(val)
+
+    def step(self, restype):
+        '''function step() bind(C, name='step')
+      !DEC$ ATTRIBUTES DLLEXPORT :: step
+      real(c_double) :: step
+    end function'''
+        return self.get_lib_function('step')(restype=restype)
+
+    def test_hdf5(self, ):
+        '''subroutine test_hdf5() BIND(C, NAME='test_hdf5')
+  !DEC$ ATTRIBUTES DLLEXPORT :: test_hdf5
+  INTEGER     ::   hdferr ! Error flag
+  CHARACTER(9) :: filename = 'test.hdf5'
+  INTEGER(HID_T) :: file_id       ! File identifier
+  INTEGER(HID_T) :: H5_Create_file,H5_Open_file      ! File identifier
+  type(c_ptr) :: x
+ end subroutine'''
+        return self.get_lib_function('test_hdf5')()
+
+    def work(self, time, restype):
+        '''function work(time) bind(C, Name='work')
+    !DEC$ ATTRIBUTES DLLEXPORT :: work
+    real(c_double), intent(in) :: time
+    real*4 :: start_time, t
+    integer*8 :: N, work
+  end function'''
+        return self.get_lib_function('work')(time, restype=restype)
+
+    def write_output(self, ):
+        '''subroutine write_output() bind(C, name="write_output")
+      !DEC$ ATTRIBUTES DLLEXPORT :: write_output
+    end subroutine'''
+        return self.get_lib_function('write_output')()

h2lib-13.1.502.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: h2lib
+Version: 13.1.502
+Summary: Python interface to HAWC2 (13.1.5+4-g20eca1a)
+Download-URL: 
+Author: Mads M. Pedersen, S.G.Horcas and N.G.Ramos
+Author-email: mmpe@dtu.dk
+Maintainer: 
+Maintainer-email: 
+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'
+Provides-Extra: test
+Requires-Dist: h2lib-tests ; extra == 'test'
+

h2lib-13.1.502.dist-info/RECORD

@@ -0,0 +1,10 @@
+h2lib/HAWC2Lib.so,sha256=ZOO_WZAenl4I1XmuG5zjQ7_NVaEHlalo_zJJ1MrGvqU,37991032
+h2lib/__init__.py,sha256=YyJWPF22nu9ZoxkrE3ghngT9n_hl-HiAEflnZ_Ay8Q4,513
+h2lib/_h2lib.py,sha256=ad2d83NMwmLYQbx6C95CZrcDpZAJWc83ul2eHtYcZ8I,20024
+h2lib/_version.py,sha256=DnjpfNE4USjsrcXL_S34wybMKe5H_kI6B_qIN9y4ssE,153
+h2lib/dll_wrapper.py,sha256=lCxinGa1KDId8kDOJIDolA_c_FrN8Pw2hdouNyxbydk,11732
+h2lib/h2lib_signatures.py,sha256=FyD6a1lbVZOKhBuY3VWM75j_Vs4HwVDIML_k63Pau4A,16492
+h2lib-13.1.502.dist-info/METADATA,sha256=7_9jjwsoaaBSfEmRoADbD_Ys09UqWQsaUD2XoPdMp5Y,717
+h2lib-13.1.502.dist-info/WHEEL,sha256=i5OLz_nY6LYJdhup5CNR0jiQepm8jaO24sNeH6xy2cs,105
+h2lib-13.1.502.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
+h2lib-13.1.502.dist-info/RECORD,,

h2lib-13.1.502.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-linux_x86_64
+

h2lib-13.1.502.dist-info/top_level.txt

@@ -0,0 +1 @@
+h2lib