h2lib 13.2.702__py3-none-win_amd64.whl → 13.2.901__py3-none-win_amd64.whl

h2lib/distributed_sections.py

@@ -1,6 +1,7 @@
 from h2lib.h2lib_signatures import H2LibSignatures
 import numpy as np
 from enum import Enum
+import sys
 
 
 class DistributedSections():
@@ -45,9 +46,9 @@ class H2Lib_DistributedSections(H2LibSignatures):
         assert mainbody_name in mbdy_name_dict, f"'{mainbody_name}' does not exist. Valid names are {list(mbdy_name_dict.keys())}."
         mbdy_nr = mbdy_name_dict[mainbody_name]
         nsec = len(section_relative_position)
-        link_id = H2LibSignatures.add_distributed_sections(
+        link_id = H2LibSignatures._add_distributed_sections(
             self,
-            mainbody_nr=int(mbdy_nr),
+            mainbody_nr=mbdy_nr,
             nsec=nsec,
             sec_rel_pos=np.asfortranarray(section_relative_position, dtype=float),
             link_id=0)[0][-1]
@@ -60,11 +61,12 @@ class H2Lib_DistributedSections(H2LibSignatures):
         add_distributed_sections and before first call to get_distributed_sections,
         get_distributed_section_position_orientation and set_distributed_section_force_and_moment
         """
-        return H2LibSignatures.initialize_distributed_sections(self)
+        self.distributed_sections_initialized = True
+        return H2LibSignatures._initialize_distributed_sections(self)
 
     def get_distributed_sections(self, link_type: LinkType, link_id):
         """Return a DistributedSections link object (needed for get_distributed_section_position_orientation
-        and set_distributed_section_force_and_moment).
+        get_distributed_section_force_and_moment and set_distributed_section_force_and_moment).
 
         To obtain the aerodynamic load sections at blade 3 (only rotor=1 can be accessed):
         h2.get_distributed_sections(LinkType.BLADE, 3)
@@ -73,23 +75,35 @@ class H2Lib_DistributedSections(H2LibSignatures):
         ----------
         link_type : LinkType
             Specifies the link type. See enum LinkType
-        link_id : integer
+        link_id : int
             index of link. link_id=1 will reference the first added sections, e.g. blade1
         Returns
         -------
         DistributedSections object
         """
-        mbdy_nr, nsec = H2LibSignatures.get_distributed_sections(
+        if link_type == LinkType.BODY:
+            err_msg = "Call initialize_distributed_sections before get_distributed_sections(link_type=LinkType.BODY,...)"
+            assert getattr(self, 'distributed_sections_initialized', False) is True, err_msg
+        mbdy_nr, nsec = H2LibSignatures._get_distributed_sections(
             self, link_type.value, link_id, mainbody_nr=0, nsec=0)[0][2:]
         mbdy_name_dict = self.get_mainbody_name_dict()
         mbdy_name = {nr: name for name, nr in mbdy_name_dict.items()}[mbdy_nr]
         return DistributedSections(mbdy_name, link_type, link_id, nsec)
 
     def get_distributed_section_position_orientation(self, ds: DistributedSections, mainbody_coo_nr=0):
-        """
+        """Computes the position and orientation of a set of distributed sections.
+        Note, the distributed sections are located on the c2def (aeroload/blade sections have a twisted 1/4 chord offset
+        relative to c2def)
+
         Parameters
         ----------
         ds : DistributedSections
+            reference to distributed sections as returned from add_distributed_sections or get_distributed_sections
+        mainbody_coo_nr : int, optional
+            Specifies the coodinate system of the returned position and orientation.
+            If 0 (default), the output is in global coordinates
+            Otherwise the output is transformed to the coordinate system of the mainbody with the specified index.
+            The index can be obtained from get_mainbody_name_dict
 
         Returns
         -------
@@ -98,13 +112,16 @@ class H2Lib_DistributedSections(H2LibSignatures):
             Orientation of section in specified coordinates.
             For mainbody_coo_nr=0, default, the orientation is in global coordinates, i.e. Tsg
         """
+        if ds.link_type == LinkType.BODY:
+            err_msg = "Call initialize_distributed_sections before get_distributed_section_position_orientation"
+            assert getattr(self, 'distributed_sections_initialized', False) is True, err_msg
         sec_pos = np.zeros((ds.nsec, 3), dtype=np.float64, order="F")
         sec_ori = np.zeros((ds.nsec, 3, 3), dtype=np.float64, order="F")
-        return H2LibSignatures.get_distributed_section_position_orientation(
-            self, int(ds.link_type.value), int(ds.link_id), int(ds.nsec), sec_pos, sec_ori,
-            int(mainbody_coo_nr))[0][3:-1]
+        return H2LibSignatures._get_distributed_section_position_orientation(
+            self, ds.link_type.value, ds.link_id, ds.nsec, sec_pos, sec_ori,
+            mainbody_coo_nr)[0][3:-1]
 
-    def set_distributed_section_force_and_moment(self, ds: DistributedSections, sec_frc, sec_mom):
+    def set_distributed_section_force_and_moment(self, ds: DistributedSections, sec_frc, sec_mom, mainbody_coo_nr=0):
         """Set forces and moments at distributed sections
 
         Parameters
@@ -115,15 +132,51 @@ class H2Lib_DistributedSections(H2LibSignatures):
             Section forces pr. length [N/m] in global coordinates, shape=(nsec,3)
         sec_momc : array_like
             Section moments pr. length [Nm/m] in global coordinates, shape=(nsec,3)
+        mainbody_coo_nr : int, optional
+            Specifies the coodinate system of the provided forces and moments.
+            If 0 (default), the forces and moments are in global coordinates
+            Otherwise the index of the mainbody in which coordinate system, the forces and moments are provided
+            The index can be obtained from get_mainbody_name_dict
         """
+        if ds.link_type == LinkType.BODY:
+            err_msg = "Call initialize_distributed_sections before set_distributed_section_force_and_moment"
+            assert getattr(self, 'distributed_sections_initialized', False) is True, err_msg
         sec_frc = np.asfortranarray(sec_frc, dtype=np.float64)
         sec_mom = np.asfortranarray(sec_mom, dtype=np.float64)
         assert sec_frc.shape == (ds.nsec, 3)
         assert sec_mom.shape == (ds.nsec, 3)
+        return H2LibSignatures._set_distributed_section_force_and_moment(
+            self, link_type=int(ds.link_type.value), link_id=int(ds.link_id), nsec=int(ds.nsec),
+            frc=sec_frc, mom=sec_mom, mainbody_coo_nr=int(mainbody_coo_nr))
+
+    def get_distributed_section_force_and_moment(self, ds: DistributedSections, mainbody_coo_nr=0):
+        """Set forces and moments at distributed sections
 
-        return H2LibSignatures.set_distributed_section_force_and_moment(
+        Parameters
+        ----------
+        ds : DistributedSections object
+            object returned by add_distributed_sections or get_distributed_sections
+        mainbody_coo_nr : int, optional
+            Specifies the coodinate system of the provided forces and moments.
+            If 0 (default), the forces and moments are in global coordinates
+            Otherwise the index of the mainbody in which coordinate system, the forces and moments are provided
+            The index can be obtained from get_mainbody_name_dict
+
+        Returns
+        -------
+        sec_frc : array_like
+            Section forces pr. length [N/m] in global coordinates, shape=(nsec,3)
+        sec_momc : array_like
+            Section moments pr. length [Nm/m] in global coordinates, shape=(nsec,3)
+        """
+        if ds.link_type == LinkType.BODY:
+            err_msg = "Call initialize_distributed_sections before get_distributed_section_force_and_moment"
+            assert getattr(self, 'distributed_sections_initialized', False) is True, err_msg
+        sec_frc = np.zeros((ds.nsec, 3), order='F', dtype=np.float64)
+        sec_mom = np.zeros((ds.nsec, 3), order='F', dtype=np.float64)
+        return H2LibSignatures._get_distributed_section_force_and_moment(
             self, link_type=int(ds.link_type.value), link_id=int(ds.link_id), nsec=int(ds.nsec),
-            frc_g=sec_frc, mom_g=sec_mom)
+            frc=sec_frc, mom=sec_mom, mainbody_coo_nr=int(mainbody_coo_nr))[0][3:5]
 
     def set_fsi_loads_h2lib(self, fx, fy, fz, mx, my, mz):  # pragma: no cover
         """Temporary function needed to replicate results of the cpl coupling framework"""

h2lib/dll_wrapper.py

@@ -17,8 +17,9 @@ import sys
 from pathlib import Path
 import atexit
 
-c_int_p = POINTER(ctypes.c_long)
-c_long_p = POINTER(ctypes.c_longlong)
+c_int_p = POINTER(ctypes.c_int)
+c_long_p = POINTER(ctypes.c_long)
+c_longlong_p = POINTER(ctypes.c_longlong)
 c_double_p = POINTER(ctypes.c_double)
 c_float_p = POINTER(ctypes.c_float)
 c_bool_p = POINTER(ctypes.c_bool)
@@ -113,19 +114,21 @@ def wrap(self, f, *args, check_stop=True, **kwargs):
     for arg in args:
         if isinstance(arg, bool):
             c_args.append(c_bool_p(c_bool(arg)))
-        elif isinstance(arg, int):
-            c_args.append(c_long_p(c_longlong(arg)))
-        elif isinstance(arg, float):
+        elif isinstance(arg, np.int32):
+            c_args.append(c_long_p(c_long(arg)))
+        elif isinstance(arg, (int, np.int64)):
+            c_args.append(c_longlong_p(c_longlong(arg)))
+        elif isinstance(arg, (float, np.float64)):
             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))))
+            # c_args.append(c_long_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 in [np.int64]:
+                c_args.append(arg.ctypes.data_as(c_longlong_p))
             elif arg.dtype == np.float64:
                 c_args.append(arg.ctypes.data_as(c_double_p))
             elif arg.dtype == np.float32:
@@ -158,7 +161,7 @@ def wrap(self, f, *args, check_stop=True, **kwargs):
     ret_args = []
     for arg in args:
         c_arg = c_args.pop(0)
-        if isinstance(arg, (int, float, bool)):
+        if isinstance(arg, (int, float, bool, np.int64, np.float64)):
             ret_args.append(c_arg.contents.value)
         elif isinstance(arg, (str)):
             ret_args.append(c_arg.value.decode('cp1252'))
@@ -184,7 +187,7 @@ class DLLWrapper(object):
 
     def check_stop(self):
         stop_code = 0
-        cstop_code = c_long_p(c_longlong(stop_code))
+        cstop_code = c_longlong_p(c_longlong(stop_code))
         getattr(self.lib, 'get_stop_code')(cstop_code)
         if cstop_code.contents.value:
             stop_msg = (" " * 1024).encode('cp1252')