h2lib 13.2.201__py3-none-win_amd64.whl → 13.2.701__py3-none-win_amd64.whl

h2lib/_h2lib.py

@@ -7,11 +7,12 @@ import sys
 from multiclass_interface.multiprocess_interface import MultiProcessClassInterface, ProcessClass
 import numpy as np
 from pathlib import Path
+from h2lib.distributed_sections import H2Lib_DistributedSections
 
 _ERROR_CODES = {
     1: ValueError("WRONG_NUMBER_OF_COLUMNS"),
     2: ValueError("MAIN_BODY_NOT_FOUND"),
-    3: RuntimeError("NOT_IMPLEMENTED_ERROR"),
+    3: NotImplementedError(),
     4: RuntimeError("STRUCTURE_IS_CONFIDENTIAL"),
     5: IndexError("BODY_DOES_NOT_EXIST"),
     6: IndexError("ELEMENT_DOES_NOT_EXIST"),
@@ -30,12 +31,7 @@ _ERROR_CODES = {
 }
 
 
-def H2Lib(suppress_output=False, subprocess=True, cwd='.'):
-    H2 = [H2LibThread, H2LibProcess][subprocess]
-    return H2(suppress_output=suppress_output, cwd=cwd)
-
-
-class H2LibThread(H2LibSignatures, DLLWrapper):
+class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
     _model_path = '.'
     _aero_sections_data_shape = {}
 
@@ -170,6 +166,14 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         self.time = np.round(H2LibSignatures.step(self, restype=np.float64)[1], 6)
         return self.time
 
+    def predict(self):  # pragma: no cover
+        """Temporary functions to reproduce results from old cpl coupling"""
+        self.get_lib_function('step_predict_hawc2')()
+
+    def correct(self):  # pragma: no cover
+        """Temporary functions to reproduce results from old cpl coupling"""
+        self.get_lib_function('step_correct_hawc2')()
+
     def run(self, time):
         self.time = np.round(H2LibSignatures.run(self, np.float64(time), restype=np.float64)[1], 6)
         return self.time
@@ -697,6 +701,57 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         assert np.all(np.isfinite(uvw)), "uvw passed to h2lib.set_windfield contains nan or inf"
         return H2LibSignatures.set_windfield(self, uvw, np.float64(box_offset_x), np.float64(time))
 
+    def set_c2_def(
+        self, main_body_name, c2_def, twist_in_deg=True, check_length=True
+    ):
+        """
+        Set c2_def, which defines the centerline of the specified main body.
+
+        Parameters
+        ----------
+        main_body_name : str
+            Name of main body that must be updated.
+        c2_def : (:, 4) ndarray
+            New c2_def. It is an array with at least 2 rows and 4 columns for x, y, z and twist.
+            The number of rows, i.e. sections, must match the ones in the original c2_def.
+        twist_in_deg : bool, optional
+            `True` if the twist (last column in c2_def) is given in [deg].
+            `False` if it is given in [rad]. The default is `True`.
+        check_length : bool, optional
+            `True` if the new beam length needs to be checked, `False` otherwise. The default is `False`.
+
+        Raises
+        ------
+        ValueError
+            Can be due to:
+                - MAIN_BODY_NOT_FOUND: none of the main bodies is called `main_body_name`.
+                - TOO_FEW_SECTIONS_IN_C2DEF: `c2_def` must have at least 2 sections, i.e. rows.
+                - BEAM_TOO_SHORT: the minimum beam length is 1.0e-7.
+                - DIFFERENT_NSEC: this command does not allow to add or remove sections,
+                                  therefore `c2_def` must have the same number of sections as in the HAWC2 model.
+        NotImplementedError
+            Only the c2_def node distribution is supported.
+
+        Returns
+        -------
+        None.
+
+        """
+        error_code = -1
+        error_code = H2LibSignatures.set_c2_def(
+            self,
+            main_body_name,
+            np.asfortranarray(c2_def.astype(np.float64)),
+            c2_def.shape[0],
+            bool(twist_in_deg),
+            bool(check_length),
+            error_code,
+            check_stop=False,
+        )[0][-1]
+
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+
     # ===================================================================================================================
     # H2rotor
     # ===================================================================================================================
@@ -928,6 +983,100 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             raise _ERROR_CODES[error_code]
         return amat
 
+    def body_output_mass(self, ibdy):
+        """
+        Compute body mass properties. Wrapper of HAWC2 command `new_htc_structure / body_output_file_name`.
+
+        Parameters
+        ----------
+        ibdy : int
+            Body index, starting from 0.
+
+        Raises
+        ------
+        RuntimeError
+            If the structure is confidential.
+        IndexError
+            If the body does not exist.
+
+        Returns
+        -------
+        body_mass : float
+            Body mass [kg].
+        body_inertia : (6,) ndarray
+            Body inertia [Ixx, Iyy, Izz, Ixy, Ixz, Iyz] in [kg*m^2].
+        cog_global_frame : (3,) ndarray
+            Body center of gravity in the global frame [m].
+        cog_body_frame : (3,) ndarray
+            Body center of gravity in the body frame [m].
+        """
+        body_mass = 0.0
+        body_inertia = np.zeros((6,), order="F")
+        cog_global_frame = np.zeros((3,), order="F")
+        cog_body_frame = np.zeros((3,), order="F")
+        error_code = -1
+
+        _, body_mass, body_inertia, cog_global_frame, cog_body_frame, error_code = (
+            H2LibSignatures.body_output_mass(
+                self,
+                ibdy + 1,
+                body_mass,
+                body_inertia,
+                cog_global_frame,
+                cog_body_frame,
+                error_code,
+                check_stop=False,
+            )[0]
+        )
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+        return body_mass, body_inertia, cog_global_frame, cog_body_frame
+
+    def body_output_element(self, ibdy, ielem):
+        """
+        Compute element matrices. Wrapper of HAWC2 command `new_htc_structure / element_matrix_output`.
+
+        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
+        -------
+        mass : (12, 12) ndarray of float
+            Mass matrix.
+        stiffness : (12, 12) ndarray of float
+            Mass matrix.
+        damping : (12, 12) ndarray of float
+            Mass matrix.
+        """
+        mass = np.zeros((12, 12), dtype=np.float64, order="F")
+        stiffness = np.zeros_like(mass)
+        damping = np.zeros_like(mass)
+        error_code = -1
+        _, _, mass, stiffness, damping, error_code = H2LibSignatures.body_output_element(
+            self,
+            ibdy + 1,
+            ielem + 1,
+            mass,
+            stiffness,
+            damping,
+            error_code,
+            check_stop=False,
+        )[0]
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+        return mass, stiffness, damping
+
     def get_system_matrices(self, n_tdofs, n_rdofs):
         """
         Get the system structural matrices computed during the system_eigenanalysis.
@@ -973,6 +1122,20 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             raise _ERROR_CODES[error_code]
         return M, C, K, R
 
+    def get_no_mainbodies(self):
+        return H2LibSignatures.get_number_of_mainbodies(self, restype=np.int64)[1]
+
+    def get_mainbody_name_dict(self):
+        s = " " * 256
+        return {H2LibSignatures.get_mainbody_name(self, mainbody_nr=int(i), mainbody_name=s)[0][1].strip(): i
+                for i in np.arange(self.get_no_mainbodies()) + 1}
+
+    def get_mainbody_position_orientation(self, mainbody_nr, mainbody_coo_nr=0):
+        mbdy_pos = np.zeros(3, dtype=np.float64, order="F")
+        mbdy_tbg = np.zeros((3, 3), dtype=np.float64, order="F")
+        return H2Lib_DistributedSections.get_mainbody_position_orientation(
+            self, int(mainbody_nr), mbdy_pos, mbdy_tbg, int(mainbody_coo_nr))[0][1:-1]
+
 
 @contextmanager
 def set_LD_LIBRARY_PATH():
@@ -997,6 +1160,11 @@ class H2LibProcess(ProcessClass, H2LibThread):
             self(suppress_output=suppress_output, filename=filename, cwd=cwd)
 
 
+def H2Lib(suppress_output=False, subprocess=True, cwd='.', filename=None) -> H2LibThread:
+    H2 = [H2LibThread, H2LibProcess][subprocess]
+    return H2(suppress_output=suppress_output, cwd=cwd, filename=filename)
+
+
 def MultiH2Lib(N, filename=None, cwd='.', suppress_output=False):
 
     if not hasattr(suppress_output, '__len__'):

h2lib/_version.py

@@ -1,4 +1,4 @@
 # This file is autogenerated and should not be modified manually
-__version__ = '13.2.201'
-h2lib_version = '13.2.201'
-hawc2_version = '13.2.2+2-g5cd9228'
+__version__ = '13.2.701'
+h2lib_version = '13.2.701'
+hawc2_version = '13.2.7+4-gb779ee7'

h2lib/distributed_sections.py

@@ -0,0 +1,131 @@
+from h2lib.h2lib_signatures import H2LibSignatures
+import numpy as np
+from enum import Enum
+
+
+class DistributedSections():
+    def __init__(self, name, link_type, link_id, nsec):
+        self.name = name
+        assert isinstance(link_type, LinkType)
+        self.link_type = link_type
+        self.link_id = link_id
+        self.nsec = nsec
+
+
+class LinkType(Enum):
+    BODY = 0  # Distributed sections added via add_distributed_sections
+    BLADE = 1  # Aerodyninamic sections of rotor=1.
+    AERODRAG = 2  # Aerodrag sections
+    HYDRO = 3  # Hydroload sections
+    SOIL = 4  # soil sections
+
+
+class H2Lib_DistributedSections(H2LibSignatures):
+    """Distributed sections are sections distributed along a mainbody in HAWC2.
+    These sections follows the structure and the position and orientation of the sections can be obtained by
+    get_distributed_section_position_orientation.
+
+    Furthermore, forces and moments can be set on the sections via set_distributed_section_force_and_moment
+
+    Distributed sections are used inside HAWC2 for aerodynamic loads, aerodrag, hydro, and soil.
+    A reference/link object to these sections can be obtained by get_distributed_sections
+
+    Moreover, custom distributed sections can be added by add_distributed_sections. Remember to call
+    initialize_distributed_sections between the last add_distributed_sections and the first usage.
+    """
+
+    def add_distributed_sections(self, mainbody_name, section_relative_position):
+        """Add custom distributed sections along a mainbody.
+
+        Note, that initialize_distributed_sections (see below) must be called after the last call to
+        add_distributed_sections and before first call to get_distributed_sections,
+        get_distributed_section_position_orientation and set_distributed_section_force_and_moment
+        """
+        mbdy_name_dict = self.get_mainbody_name_dict()
+        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(
+            self,
+            mainbody_nr=int(mbdy_nr),
+            nsec=nsec,
+            sec_rel_pos=np.asfortranarray(section_relative_position, dtype=float),
+            link_id=0)[0][-1]
+        return DistributedSections(mainbody_name, LinkType.BODY, link_id, nsec)
+
+    def initialize_distributed_sections(self):
+        """Initialize distributed sections added by add_distributed_sections.
+
+        Note, that this method must be called after the last call to
+        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)
+
+    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).
+
+        To obtain the aerodynamic load sections at blade 3 (only rotor=1 can be accessed):
+        h2.get_distributed_sections(LinkType.BLADE, 3)
+
+        Parameters
+        ----------
+        link_type : LinkType
+            Specifies the link type. See enum LinkType
+        link_id : integer
+            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(
+            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):
+        """
+        Parameters
+        ----------
+        ds : DistributedSections
+
+        Returns
+        -------
+        sec_pos : array(nsec,3)
+        sec_ori : array(nsec,3,3)
+            Orientation of section in specified coordinates.
+            For mainbody_coo_nr=0, default, the orientation is in global coordinates, i.e. Tsg
+        """
+        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]
+
+    def set_distributed_section_force_and_moment(self, ds: DistributedSections, sec_frc, sec_mom):
+        """Set forces and moments at distributed sections
+
+        Parameters
+        ----------
+        ds : DistributedSections object
+            object returned by add_distributed_sections or get_distributed_sections
+        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)
+        """
+        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_g=sec_frc, mom_g=sec_mom)
+
+    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"""
+        fx, fy, fz, mx, my, mz = [np.asfortranarray(v, dtype=np.float64) for v in [fx, fy, fz, mx, my, mz]]
+        self.get_lib_function('set_fsi_loads_hawc2')(fx, fy, fz, mx, my, mz)

h2lib/h2lib_signatures.py

@@ -4,6 +4,14 @@ from h2lib.dll_wrapper import DLLWrapper
 
 
 class H2LibSignatures():
+    def add_distributed_sections(self, mainbody_nr, nsec, sec_rel_pos, link_id, check_stop=True):
+        '''subroutine add_distributed_sections(mainbody_nr, nsec, sec_rel_pos, link_id) bind(C, name="add_distributed_sections")
+      integer*8, intent(in) :: mainbody_nr, nsec
+      integer*8, intent(out) :: link_id
+      real(c_double), intent(in) :: sec_rel_pos(nsec)
+    end subroutine'''
+        return self.get_lib_function('add_distributed_sections')(mainbody_nr, nsec, sec_rel_pos, link_id, check_stop=check_stop)
+
     def add_sensor(self, sensor_line, index_start, index_stop, check_stop=True):
         '''subroutine add_sensor(sensor_line, index_start, index_stop) bind(C, name="add_sensor")
       integer*8 :: index_start, index_stop
@@ -11,6 +19,28 @@ class H2LibSignatures():
     end subroutine'''
         return self.get_lib_function('add_sensor')(sensor_line, index_start, index_stop, check_stop=check_stop)
 
+    def body_output_element(self, ibdy, ielem, mass, stiffness, damping, error_code, check_stop=True):
+        '''subroutine body_output_element(ibdy, ielem, mass, stiffness, damping, error_code) &
+    integer(kind=4), intent(in) :: ibdy
+    integer(kind=4), intent(in) :: ielem
+    real(kind=c_double), dimension(12, 12), intent(out) :: mass
+    real(kind=c_double), dimension(12, 12), intent(out) :: stiffness
+    real(kind=c_double), dimension(12, 12), intent(out) :: damping
+    integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('body_output_element')(ibdy, ielem, mass, stiffness, damping, error_code, check_stop=check_stop)
+
+    def body_output_mass(self, ibdy, body_mass, body_inertia, cog_global_frame, cog_body_frame, error_code, check_stop=True):
+        '''subroutine body_output_mass(ibdy, body_mass, body_inertia, cog_global_frame, cog_body_frame, error_code) &
+    integer(kind=4), intent(in) :: ibdy
+    real(kind=c_double), intent(out) :: body_mass
+    real(kind=c_double), intent(out) :: body_inertia(6)
+    real(kind=c_double), intent(out) :: cog_global_frame(3)
+    real(kind=c_double), intent(out) :: cog_body_frame(3)
+    integer(kind=8), intent(out) :: error_code
+end subroutine'''
+        return self.get_lib_function('body_output_mass')(ibdy, body_mass, body_inertia, cog_global_frame, cog_body_frame, error_code, check_stop=check_stop)
+
     def check_convergence(self, bconv, resq, resg, resd, check_stop=True):
         '''subroutine check_convergence(bconv, resq, resg, resd) bind(C, name='check_convergence')
       logical(kind=c_bool), intent(out) :: bconv
@@ -20,8 +50,7 @@ class H2LibSignatures():
     end subroutine'''
         return self.get_lib_function('check_convergence')(bconv, resq, resg, resd, check_stop=check_stop)
 
-    def do_system_eigenanalysis(self, include_damping, n_modes, natural_frequencies,
-                                damping_ratios, error_code, check_stop=True):
+    def do_system_eigenanalysis(self, include_damping, n_modes, natural_frequencies, damping_ratios, error_code, check_stop=True):
         '''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
@@ -29,8 +58,7 @@ 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, check_stop=check_stop)
+        return self.get_lib_function('do_system_eigenanalysis')(include_damping, n_modes, natural_frequencies, damping_ratios, error_code, check_stop=check_stop)
 
     def echo_version(self, check_stop=True):
         '''subroutine echo_version() BIND(C, NAME='echo_version')
@@ -136,6 +164,21 @@ end subroutine'''
  end function'''
         return self.get_lib_function('get_diameter')(rotor, restype=restype, check_stop=check_stop)
 
+    def get_distributed_section_position_orientation(self, link_type, link_id, nsec, sec_pos, sec_ori, mainbody_coo_nr, check_stop=True):
+        '''subroutine get_distributed_section_position_orientation(link_type, link_id, nsec, sec_pos, sec_ori, mainbody_coo_nr) bind(C, name="get_distributed_section_position_orientation")
+      integer*8, intent(in) ::  link_type, link_id, nsec, mainbody_coo_nr
+      real(c_double), intent(out) :: sec_pos(nsec,3)
+      real(c_double), intent(out) :: sec_ori(nsec,3,3)
+    end subroutine'''
+        return self.get_lib_function('get_distributed_section_position_orientation')(link_type, link_id, nsec, sec_pos, sec_ori, mainbody_coo_nr, check_stop=check_stop)
+
+    def get_distributed_sections(self, link_type, link_id, mainbody_nr, nsec, check_stop=True):
+        '''subroutine get_distributed_sections(link_type, link_id, mainbody_nr, nsec) bind(C, name="get_distributed_sections")
+      integer*8, intent(in) :: link_type, link_id
+      integer*8, intent(out) :: nsec, mainbody_nr
+    end subroutine'''
+        return self.get_lib_function('get_distributed_sections')(link_type, link_id, mainbody_nr, nsec, check_stop=check_stop)
+
     def get_induction_axisymmetric(self, rotor, induction, check_stop=True):
         '''subroutine get_induction_axisymmetric(rotor, induction) bind(C, name="get_induction_axisymmetric")
     integer*8, intent(in)        :: rotor
@@ -158,6 +201,21 @@ end subroutine'''
   end subroutine'''
         return self.get_lib_function('get_induction_rotoravg')(rotor, induction, check_stop=check_stop)
 
+    def get_mainbody_name(self, mainbody_nr, mainbody_name, check_stop=True):
+        '''subroutine get_mainbody_name(mainbody_nr, mainbody_name) bind(C, name="get_mainbody_name")
+      integer*8 :: mainbody_nr
+      character(kind=c_char, len=1), intent(inout)      :: mainbody_name(256)
+    end subroutine'''
+        return self.get_lib_function('get_mainbody_name')(mainbody_nr, mainbody_name, check_stop=check_stop)
+
+    def get_mainbody_position_orientation(self, mainbody_nr, mbdy_pos, mbdy_ori, mainbody_coo_nr, check_stop=True):
+        '''subroutine get_mainbody_position_orientation(mainbody_nr, mbdy_pos, mbdy_ori, mainbody_coo_nr) bind(C, name="get_mainbody_position_orientation")
+      integer*8, intent(in) :: mainbody_nr, mainbody_coo_nr
+      real(c_double), intent(out) :: mbdy_pos(3)
+      real(c_double), intent(out) :: mbdy_ori(3,3)
+    end subroutine'''
+        return self.get_lib_function('get_mainbody_position_orientation')(mainbody_nr, mbdy_pos, mbdy_ori, mainbody_coo_nr, check_stop=check_stop)
+
     def get_nSections(self, rotor, blade, restype, check_stop=True):
         '''function get_nSections(rotor, blade) bind(C, name="get_nSections")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_nSections
@@ -187,8 +245,7 @@ end subroutine'''
     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, check_stop=check_stop)
+        return self.get_lib_function('get_number_of_bodies_and_constraints')(nbdy, ncst, error_code, check_stop=check_stop)
 
     def get_number_of_elements(self, nbdy, nelem, error_code, check_stop=True):
         '''subroutine get_number_of_elements(nbdy, nelem, error_code) &
@@ -198,6 +255,13 @@ end subroutine'''
 end subroutine'''
         return self.get_lib_function('get_number_of_elements')(nbdy, nelem, error_code, check_stop=check_stop)
 
+    def get_number_of_mainbodies(self, restype, check_stop=True):
+        '''function get_number_of_mainbodies() bind(C, name="get_number_of_mainbodies")
+      !DEC$ ATTRIBUTES DLLEXPORT :: get_number_of_mainbodies
+      integer*8 :: get_number_of_mainbodies
+    end function'''
+        return self.get_lib_function('get_number_of_mainbodies')(restype=restype, check_stop=check_stop)
+
     def get_rotor_avg_wsp(self, coo, rotor, wsp, check_stop=True):
         '''subroutine get_rotor_avg_wsp(coo, rotor, wsp) bind(C, name="get_rotor_avg_wsp")
     integer*8, intent(in) :: rotor
@@ -253,8 +317,7 @@ end subroutine'''
 end subroutine'''
         return self.get_lib_function('get_stop_message')(stop_message, check_stop=check_stop)
 
-    def get_system_eigval_eigvec_with_damping(self, n_modes, ny, eigenvalues,
-                                              eigenvectors, error_code, check_stop=True):
+    def get_system_eigval_eigvec_with_damping(self, n_modes, ny, eigenvalues, eigenvectors, error_code, check_stop=True):
         '''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
@@ -262,11 +325,9 @@ 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, check_stop=check_stop)
+        return self.get_lib_function('get_system_eigval_eigvec_with_damping')(n_modes, ny, eigenvalues, eigenvectors, error_code, check_stop=check_stop)
 
-    def get_system_eigval_eigvec_without_damping(
-            self, n_modes, ny, eigenvalues, eigenvectors, error_code, check_stop=True):
+    def get_system_eigval_eigvec_without_damping(self, n_modes, ny, eigenvalues, eigenvectors, error_code, check_stop=True):
         '''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
@@ -274,8 +335,7 @@ 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, check_stop=check_stop)
+        return self.get_lib_function('get_system_eigval_eigvec_without_damping')(n_modes, ny, eigenvalues, eigenvectors, error_code, check_stop=check_stop)
 
     def get_system_matrices(self, n_tdofs, n_rdofs, M, C, K, R, error_code, check_stop=True):
         '''subroutine get_system_matrices(n_tdofs, n_rdofs, M, C, K, R, error_code) &
@@ -287,8 +347,7 @@ 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, check_stop=check_stop)
+        return self.get_lib_function('get_system_matrices')(n_tdofs, n_rdofs, M, C, K, R, error_code, check_stop=check_stop)
 
     def get_time(self, time, check_stop=True):
         '''subroutine
@@ -305,8 +364,7 @@ subroutine'''
     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, check_stop=check_stop)
+        return self.get_lib_function('get_timoshenko_location')(ibdy, ielem, l, r1, r12, tes, error_code, check_stop=check_stop)
 
     def get_version(self, s, check_stop=True):
         '''subroutine get_version(s) BIND(C, NAME='get_version')
@@ -326,8 +384,7 @@ end subroutine'''
     integer*8, intent(in) :: tiploss_method
     REAL(c_double), intent(in) :: tiploss2_shen_c2, tiploss2_shen_h
   end subroutine'''
-        return self.get_lib_function('init_AD')(rotor, tiploss_method, tiploss2_shen_c2,
-                                                tiploss2_shen_h, check_stop=check_stop)
+        return self.get_lib_function('init_AD')(rotor, tiploss_method, tiploss2_shen_c2, tiploss2_shen_h, check_stop=check_stop)
 
     def init_AL(self, rotor, epsilon_smearing, check_stop=True):
         '''subroutine init_AL(rotor, epsilon_smearing) bind(C, name="init_AL")
@@ -341,8 +398,21 @@ end subroutine'''
       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, check_stop=check_stop)
+        return self.get_lib_function('init_windfield')(Nxyz, dxyz, box_offset_yz, transport_speed, check_stop=check_stop)
+
+    def initialize_distributed_sections(self, check_stop=True):
+        '''subroutine initialize_distributed_sections() bind(C, name="initialize_distributed_sections")
+      !DEC$ ATTRIBUTES DLLEXPORT :: initialize_distributed_sections
+      type (TBodyLink), pointer :: bodylink
+      type (Tseclink),dimension(:),pointer   :: seclinks
+      Type (Tbaselink) :: baselink
+      type (body_type),dimension(:),pointer  :: b_vec
+      type (TBodySectionLink), pointer :: bsl
+      Type (Tmain_body_input),pointer :: mbdy
+      integer :: nnodes
+      integer :: i
+    end subroutine'''
+        return self.get_lib_function('initialize_distributed_sections')(check_stop=check_stop)
 
     def linearize(self, n_tdofs, n_rdofs, check_stop=True):
         '''subroutine linearize(n_tdofs, n_rdofs) bind(C, name="linearize")
@@ -409,32 +479,51 @@ end subroutine'''
   end subroutine'''
         return self.get_lib_function('set_aerosections_windspeed')(rotor, uvw, check_stop=check_stop)
 
-    def set_orientation_base(self, main_body_name,
-                             n_rows, mbdy_eulerang_table, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1,
-                             error_code, check_stop=True):
-        '''subroutine set_orientation_base(main_body_name,  &
+    def set_c2_def(self, main_body_name, c2_def, nsec, twist_in_deg, check_length, error_code, check_stop=True):
+        '''subroutine set_c2_def(main_body_name, c2_def, nsec, twist_in_deg, check_length, error_code) &
+character(kind=c_char, len=1), dimension(256),     intent(in   ) :: main_body_name  ! Defined as an array of length 1 characters because of bind.
+real(kind=c_double),           dimension(nsec, 4), intent(in   ) :: c2_def
+integer(kind=4),                                   intent(in   ) :: nsec
+logical(kind=c_bool),                              intent(in   ) :: twist_in_deg
+logical(kind=c_bool),                              intent(in   ) :: check_length
+integer(kind=8),                                   intent(  out) :: error_code
+character(kind=c_char, len=256) :: mbdy_name  ! Same as main_body_name, but as string instead of an array of characters.
+type(Tmain_body_input), pointer :: main_body  ! The main body whose c2_def we want to update.
+type(Tc2def_input), pointer :: c2def_input  ! The c2_def of main_body.
+end subroutine'''
+        return self.get_lib_function('set_c2_def')(main_body_name, c2_def, nsec, twist_in_deg, check_length, error_code, check_stop=check_stop)
+
+    def set_distributed_section_force_and_moment(self, link_type, link_id, nsec, frc_g, mom_g, check_stop=True):
+        '''subroutine set_distributed_section_force_and_moment(link_type, link_id, nsec, frc_g, mom_g) bind(C, name="set_distributed_section_force_and_moment")
+      integer*8, intent(in) ::  link_type, link_id, nsec
+      real(c_double), intent(in) :: frc_g(nsec,3), mom_g(nsec,3)
+    end subroutine'''
+        return self.get_lib_function('set_distributed_section_force_and_moment')(link_type, link_id, nsec, frc_g, mom_g, check_stop=check_stop)
+
+    def set_orientation_base(self, main_body_name, n_rows, mbdy_eulerang_table, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1, error_code, check_stop=True):
+        '''subroutine set_orientation_base(main_body_name, n_rows, mbdy_eulerang_table, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1, error_code) &
 character(kind=c_char, len=1), dimension(256), intent(in) :: main_body_name
+integer(kind=4), intent(in) :: n_rows
 real(kind=c_double), dimension(n_rows, 3),   intent(in) :: mbdy_eulerang_table
 logical(c_bool), intent(in) :: angles_in_deg
 logical(c_bool), intent(in) :: reset_orientation
 real(kind=c_double), dimension(4),   intent(in) :: mbdy_ini_rotvec_d1
+integer(kind=8), intent(out) :: error_code  ! Error code.
 end subroutine'''
-        return self.get_lib_function('set_orientation_base')(main_body_name,
-                                                             n_rows, mbdy_eulerang_table, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1,
-                                                             error_code, check_stop=check_stop)
-
-    def set_orientation_relative(self, main_body_1_name, node_1, main_body_2_name, node_2,
-                                 n_rows, mbdy2_eulerang_table, angles_in_deg,
-                                 reset_orientation,
-                                 mbdy2_ini_rotvec_d1,
-                                 error_code, check_stop=True):
-        '''subroutine set_orientation_relative(main_body_1_name, node_1, main_body_2_name, node_2,  &
+        return self.get_lib_function('set_orientation_base')(main_body_name, n_rows, mbdy_eulerang_table, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1, error_code, check_stop=check_stop)
+
+    def set_orientation_relative(self, main_body_1_name, node_1, main_body_2_name, node_2, n_rows, mbdy2_eulerang_table, angles_in_deg, reset_orientation, mbdy2_ini_rotvec_d1, error_code, check_stop=True):
+        '''subroutine set_orientation_relative(main_body_1_name, node_1, main_body_2_name, node_2, n_rows, mbdy2_eulerang_table, angles_in_deg, reset_orientation, mbdy2_ini_rotvec_d1, error_code) &
 character(kind=c_char, len=1),   dimension(256),       intent(in   ) :: main_body_1_name  ! Defined as an array of length 1 characters because of bind.
 character(kind=c_char, len=1),   dimension(256),       intent(in   ) :: main_body_2_name  ! Defined as an array of length 1 characters because of bind.
 integer(kind=8),                                       intent(in   ) :: node_1
 integer(kind=8),                                       intent(in   ) :: node_2
+integer(kind=4),                                       intent(in   ) :: n_rows
 real(kind=c_double),             dimension(n_rows, 3), intent(in   ) :: mbdy2_eulerang_table
 logical(c_bool),                                       intent(in   ) :: angles_in_deg
+logical(c_bool),                                       intent(in   ) :: reset_orientation
+real(kind=c_double),             dimension(4),         intent(in   ) :: mbdy2_ini_rotvec_d1  ! Initial angular velocity direction and magnitude.
+integer(kind=8),                                       intent(  out) :: error_code
 character(kind=c_char, len=256) :: mbdy_1_name  ! Same as main_body_1_name, but as string instead of an array of characters.
 character(kind=c_char, len=256) :: mbdy_2_name  ! Same as main_body_2_name, but as string instead of an array of characters.
 type(Tmain_body_input), pointer :: main_body_1  ! The main body pointer associated to main_body_1_name.
@@ -442,11 +531,7 @@ type(Tmain_body_input), pointer :: main_body_2  ! The main body pointer associat
 integer(kind=4) :: node_1_local, node_2_local     ! Internal copy of node_1 and node_2.
 real*8, dimension(3) :: eulerang                ! Euler angles associated to 1 row of mbdy2_eulerang_table.
 end subroutine'''
-        return self.get_lib_function('set_orientation_relative')(main_body_1_name, node_1, main_body_2_name, node_2,
-                                                                 n_rows, mbdy2_eulerang_table, angles_in_deg,
-                                                                 reset_orientation,
-                                                                 mbdy2_ini_rotvec_d1,
-                                                                 error_code, check_stop=check_stop)
+        return self.get_lib_function('set_orientation_relative')(main_body_1_name, node_1, main_body_2_name, node_2, n_rows, mbdy2_eulerang_table, angles_in_deg, reset_orientation, mbdy2_ini_rotvec_d1, error_code, check_stop=check_stop)
 
     def set_variable_sensor_value(self, id, value, check_stop=True):
         '''subroutine set_variable_sensor_value(id, value) bind(C, name="set_variable_sensor_value")

{h2lib-13.2.201.dist-info → h2lib-13.2.701.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: h2lib
-Version: 13.2.201
-Summary: Python interface to HAWC2 (13.2.2+2-g5cd9228)
+Version: 13.2.701
+Summary: Python interface to HAWC2 (13.2.7+4-gb779ee7)
 Download-URL: 
 Author: Mads M. Pedersen, S.G.Horcas and N.G.Ramos
 Author-email: mmpe@dtu.dk

h2lib-13.2.701.dist-info/RECORD

@@ -0,0 +1,11 @@
+h2lib/HAWC2Lib.dll,sha256=UhEa8wYrBfkZ3f-6MQDeNOTP9ncDIkWpfj8zJ1skSfA,30628864
+h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
+h2lib/_h2lib.py,sha256=mA4W91BbSO2edvHzsrroVbRD_pW4axwGlwxBE9nDnkQ,45730
+h2lib/_version.py,sha256=JiP-kg_iCUO5g8WQvSp95pNuU7r-swyVJphX5dw60eU,157
+h2lib/distributed_sections.py,sha256=VhcYr94se4Zq8PaHg_6z6r7YjwSvbEQoxPiA25HYXBg,6233
+h2lib/dll_wrapper.py,sha256=O_lGZ_w3FirjEn4FIE5OeZz30nwpufJB5sflVzf4Cc4,13446
+h2lib/h2lib_signatures.py,sha256=P-9iysIIwgi18qBEUXj5X_-YFS7xt5Em4NSwfgrfDVE,36509
+h2lib-13.2.701.dist-info/METADATA,sha256=evKD9QTQXimcV0tk8B3kJq5i2PrXJX89n9yjtMYwOIY,860
+h2lib-13.2.701.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+h2lib-13.2.701.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
+h2lib-13.2.701.dist-info/RECORD,,

h2lib-13.2.201.dist-info/RECORD

@@ -1,10 +0,0 @@
-h2lib/HAWC2Lib.dll,sha256=M6SWeBpQ32Phv7Bcj0LQhmiJdnXwWNwoNSPKtk_mpLc,30980096
-h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
-h2lib/_h2lib.py,sha256=Nxtz01N-AcMX-OZYS2-QRjuGDBVVKWopBHcxAHfjR7s,39553
-h2lib/_version.py,sha256=wfBRDfXJqowsNUL3qywY9qWaPyrqBIh3pXkfxk1s-vw,157
-h2lib/dll_wrapper.py,sha256=O_lGZ_w3FirjEn4FIE5OeZz30nwpufJB5sflVzf4Cc4,13446
-h2lib/h2lib_signatures.py,sha256=gHHPZ9vjwQwRA8Vb8V2gOuYBL6mZz9r_pcu7_EtzVoE,29637
-h2lib-13.2.201.dist-info/METADATA,sha256=YYuUvTlE3pDY7aS7STdo14Y4c-wMj1fI0Wv85hV0AzY,860
-h2lib-13.2.201.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
-h2lib-13.2.201.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
-h2lib-13.2.201.dist-info/RECORD,,