h2lib 13.0.604__cp38-cp38-win_amd64.whl → 13.0.705__cp38-cp38-win_amd64.whl

h2lib/_h2lib.py

@@ -1,42 +1,34 @@
-import os
-import numpy as np
+from contextlib import contextmanager
 from h2lib.dll_wrapper import DLLWrapper
 from h2lib.h2lib_signatures import H2LibSignatures
-from h2lib.utils import MultiProcessInterface, ProcessClass
-from contextlib import contextmanager
-
+import os
+import sys
 
-@contextmanager
-def set_LD_LIBRARY_PATH():
-    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
+from multiclass_interface.multiprocess_interface import MultiProcessClassInterface, ProcessClass
+import numpy as np
 
 
 def H2Lib(suppress_output=False, subprocess=True):
-    if subprocess:
-        with set_LD_LIBRARY_PATH():
-            return H2LibProcess(suppress_output=suppress_output)
-    else:
-        return H2LibThread(suppress_output=suppress_output)
+    H2 = [H2LibThread, H2LibProcess][subprocess]
+    return H2(suppress_output=suppress_output)
 
 
 class H2LibThread(H2LibSignatures, DLLWrapper):
     _model_path = '.'
     _aero_sections_data_shape = {}
 
-    def __init__(self, filename=None, cwd='.', suppress_output=True):
+    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
@@ -46,23 +38,32 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
     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 __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
 
     def close(self):
         if self._initialized:
             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]
+        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),
@@ -97,17 +98,49 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         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 += ";"
-        return H2LibSignatures.add_sensor(self, sensor_line, restype=np.int64)[1]
+        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_value(self, id):
-        return H2LibSignatures.get_sensor_value(self, id, restype=np.float64)[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))
@@ -175,7 +208,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         """
         if time is None:
             time = self.get_time()
-        return H2LibSignatures.set_windfield(self, np.asarray(uvw, dtype=np.float64),
+        return H2LibSignatures.set_windfield(self, np.asarray(uvw, dtype=np.float32),
                                              np.float64(box_offset_x), np.float64(time))
 
     # ===================================================================================================================
@@ -199,12 +232,12 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         return H2LibSignatures.get_diameter(self, rotor + 1, restype=np.float64)[1]
 
     def aero_sections_data_shape(self, rotor):
-        if not rotor in self._aero_sections_data_shape:
+        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)
+        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):
@@ -212,12 +245,12 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
 
     def get_aerosections_forces(self, rotor=0):
         shape = self.aero_sections_data_shape(rotor)
-        Fxyz = np.zeros(shape, dtype=np.float64)
+        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)
+        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):
@@ -228,11 +261,12 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         """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), np.zeros(nrad, dtype=np.float64))[0][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)
+        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):
@@ -240,6 +274,10 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         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:]
@@ -262,15 +300,47 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         return [vy, vx, -vz]
 
 
-class H2LibProcess(ProcessClass, H2LibThread):
-    def __init__(self, suppress_output):
-        ProcessClass.__init__(self, cls=H2LibThread, cls_attrs=set(dir(H2LibThread)) - set(dir(ProcessClass)))
-        self(suppress_output=suppress_output)
+@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 MultiH2Lib(MultiProcessInterface, H2LibThread):
-    def __init__(self, N, filename=None, cwd='.', suppress_output=False):
-        if not hasattr(suppress_output, '__len__'):
-            suppress_output = [suppress_output] * N
+class H2LibProcess(ProcessClass, H2LibThread):
+    def __init__(self, suppress_output, filename=None, cwd='.'):
         with set_LD_LIBRARY_PATH():
-            MultiProcessInterface.__init__(self, H2LibThread, [(filename, cwd, suppress_output[i]) for i in range(N)])
+            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.size > 1:  # 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

@@ -1,4 +1,4 @@
 # This file is autogenerated and should not be modified manually
-__version__ = '13.0.604'
-h2lib_version = '13.0.604'
-hawc2_version = '13.0.6+5-g438f4c5'
+__version__ = '13.0.705'
+h2lib_version = '13.0.705'
+hawc2_version = '13.0.9'

h2lib/dll_wrapper.py

@@ -6,9 +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
-import tempfile
-import shutil
+from ctypes import c_int, c_double, c_char, c_char_p, c_long, c_longlong
 from contextlib import contextmanager
 try:
     from ctypes import windll
@@ -21,6 +19,7 @@ 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 = []
 
@@ -70,17 +69,88 @@ def cwd(f):
     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(sys.stdout), SuppressStream(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.')
-        in_use.append(os.path.abspath(self.filename))
         self.cwd = cwd
         self.cdecl = cdecl
         self.fortran = fortran
         self.suppress_output = False
         self.open()
+        in_use.append(os.path.abspath(self.filename))
         atexit.register(self.close)
 
     @staticmethod
@@ -124,9 +194,10 @@ class DLLWrapper(object):
     def open(self):
         assert os.path.isfile(self.filename), os.path.abspath(self.filename)
         if self.cdecl:
-            if tuple(map(int, platform.python_version().split('.'))) < (3, 8):
+            try:
+                # python < (3, 8) and > 3.10?:
                 self.lib = ct.CDLL(self.filename)
-            else:
+            except BaseException:
                 self.lib = ct.CDLL(self.filename, winmode=ctypes.DEFAULT_MODE)
         else:
             self.lib = windll.LoadLibrary(self.filename)
@@ -148,82 +219,17 @@ class DLLWrapper(object):
 #         self.close()
 #         return False
 
-    def __getattribute__(self, name):
-        try:
-            return object.__getattribute__(self, name)
-        except AttributeError:
-            if name == 'lib':
-                raise Exception("DLL not loaded. Run using: 'with dll: ...'")
-            return self.get_lib_function(name)
+    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))
-
-        def wrap(*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:
-                        args[i] = np.asfortranarray(args[i])
-                    else:
-                        args[i] = np.ascontiguousarray(args[i])
-            for arg in args:
-                if isinstance(arg, int):
-                    c_args.append(c_int_p(c_int(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))
-                    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(sys.stdout), SuppressStream(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
-        return wrap
+        return lambda *args, **kwargs: wrap(self, f, *args, **kwargs)
 
     def version(self, function_name='get_version'):
         try:
@@ -309,7 +315,7 @@ class Type2DllWrapper(DLLWrapper):
         arg2 = np.zeros(n2, dtype=ct.c_double, order='F')
 
         f(arg1, arg2)
-        return(arg2)
+        return arg2
 
     def init(self):
         n1, n2 = self.arraysizes_init