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

h2lib/_h2lib.py

@@ -22,6 +22,7 @@ _ERROR_CODES = {
     300: ValueError("TOO_FEW_SECTIONS_IN_C2DEF"),
     301: ValueError("BEAM_TOO_SHORT"),
     302: ValueError("DIFFERENT_NSEC"),
+    400: ValueError("ST_Z_NOT_CONTINUOUSLY_INCREASING"),
     500: ValueError("RELATIVE_ROTATION_NOT_FOUND"),
     700: RuntimeError("SYSTEM_NOT_LINEARIZED"),
     701: RuntimeError("SYSTEM_EIGENANALYSIS_NOT_DONE"),
@@ -65,25 +66,25 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
 
     def close(self):
         if self._initialized:
-            self.write_output()
-            self.finalize()
+            self._write_output()
+            self._finalize()
         DLLWrapper.close(self)
         return "closed h2lib"
 
     def getState(self):
-        return H2LibSignatures.getState(self, restype=np.int32)[1]
+        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]
+        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]
+        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()
+        return H2LibSignatures._get_version(self, s)[0][0].strip()
 
     def stop_on_error(self, flag):
         """
@@ -100,7 +101,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         None.
 
         """
-        H2LibSignatures.stop_on_error(self, bool(flag))
+        H2LibSignatures._stop_on_error(self, bool(flag))
 
     def get_wind_speed(self, pos_g):
         return self.get_lib_function('get_wind_speed')(np.asfortranarray(pos_g, dtype=np.float64),
@@ -111,18 +112,18 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         return [vy, vx, -vz]
 
     def get_time(self):
-        return np.round(H2LibSignatures.get_time(self, time=0.)[0][0], 6)
+        return np.round(H2LibSignatures._get_time(self, time=0.)[0][0], 6)
 
     def read_input(self, htc_path, model_path='.'):
         if htc_path is not None:
             self._model_path = model_path
             self.cwd = self.model_path
-            return H2LibSignatures.read_input(self, htc_path)
+            return H2LibSignatures._read_input(self, htc_path)
 
     def init(self, htc_path=None, model_path='.'):
         assert not self._initialized, "h2lib already initialized via init, init_AD or init_AL"
         self.read_input(htc_path, model_path)
-        r = H2LibSignatures.init(self)
+        r = H2LibSignatures._init(self)
         self._initialized = True
         return r
 
@@ -139,8 +140,8 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         """
         assert not self._initialized, "h2lib already initialized via init, init_AD or init_AL"
         self.read_input(htc_path, model_path)
-        r = H2LibSignatures.init_AD(self, rotor + 1, int(tiploss_method),
-                                    float(tiploss2_shen_c2), float(tiploss2_shen_h))
+        r = H2LibSignatures._init_AD(self, rotor + 1, int(tiploss_method),
+                                     float(tiploss2_shen_c2), float(tiploss2_shen_h))
         self._initialized = True
         return r
 
@@ -158,12 +159,12 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         """
         assert not self._initialized, "h2lib already initialized via init, init_AD or init_AL"
         self.read_input(htc_path, model_path)
-        r = H2LibSignatures.init_AL(self, rotor=rotor + 1, epsilon_smearing=float(epsilon_smearing))
+        r = H2LibSignatures._init_AL(self, rotor=rotor + 1, epsilon_smearing=float(epsilon_smearing))
         self._initialized = True
         return r
 
     def step(self):
-        self.time = np.round(H2LibSignatures.step(self, restype=np.float64)[1], 6)
+        self.time = np.round(H2LibSignatures._step(self, restype=np.float64)[1], 6)
         return self.time
 
     def predict(self):  # pragma: no cover
@@ -175,7 +176,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         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)
+        self.time = np.round(H2LibSignatures._run(self, np.float64(time), restype=np.float64)[1], 6)
         return self.time
 
     def check_convergence(self):
@@ -197,7 +198,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         resq = -1.0
         resg = -1.0
         resd = -1.0
-        bconv, resq, resg, resd = H2LibSignatures.check_convergence(self, bconv, resq, resg, resd)[0]
+        bconv, resq, resg, resd = H2LibSignatures._check_convergence(self, bconv, resq, resg, resd)[0]
         return bconv, resq, resg, resd
 
     def linearize(self):
@@ -214,7 +215,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         """
         n_tdofs = -1
         n_rdofs = -1
-        res = H2LibSignatures.linearize(self, n_tdofs, n_rdofs)[0]
+        res = H2LibSignatures._linearize(self, n_tdofs, n_rdofs)[0]
         return res
 
     def do_system_eigenanalysis(self, n_modes, include_damping=True):
@@ -249,7 +250,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         error_code = -1
 
         _, _, natural_frequencies, damping_ratios, error_code = (
-            H2LibSignatures.do_system_eigenanalysis(
+            H2LibSignatures._do_system_eigenanalysis(
                 self,
                 include_damping,
                 n_modes,
@@ -304,11 +305,11 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         if include_damping:
             ny = 2 * n_rdofs
             dtype = np.complex128
-            f = H2LibSignatures.get_system_eigval_eigvec_with_damping
+            f = H2LibSignatures._get_system_eigval_eigvec_with_damping
         else:
             ny = n_rdofs
             dtype = np.float64
-            f = H2LibSignatures.get_system_eigval_eigvec_without_damping
+            f = H2LibSignatures._get_system_eigval_eigvec_without_damping
 
         error_code = -1
         eigenvalues = np.zeros((n_modes,), dtype=dtype, order="F")
@@ -337,7 +338,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         None.
 
         """
-        H2LibSignatures.solver_static_init(self)
+        H2LibSignatures._solver_static_init(self)
 
     def solver_static_update(self):
         """
@@ -354,7 +355,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
 
         """
         error_code = -1
-        error_code = H2LibSignatures.solver_static_update(self, error_code)[0][0]
+        error_code = H2LibSignatures._solver_static_update(self, error_code)[0][0]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
 
@@ -373,7 +374,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
 
         """
         error_code = -1
-        error_code = H2LibSignatures.solver_static_solve(self, error_code)[0][0]
+        error_code = H2LibSignatures._solver_static_solve(self, error_code)[0][0]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
 
@@ -386,7 +387,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         None.
 
         """
-        H2LibSignatures.solver_static_delete(self)
+        H2LibSignatures._solver_static_delete(self)
 
     def solver_static_run(self, reset_structure=False):
         """
@@ -416,13 +417,13 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
 
         """
         error_code = -1
-        _, error_code = H2LibSignatures.solver_static_run(self, reset_structure, error_code, check_stop=False)[0]
+        _, error_code = H2LibSignatures._solver_static_run(self, reset_structure, error_code, check_stop=False)[0]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
 
     def structure_reset(self):
         """Reset the structure deflection and orientation."""
-        H2LibSignatures.structure_reset(self)
+        H2LibSignatures._structure_reset(self)
 
     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
@@ -441,7 +442,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         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:]
+        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):
@@ -449,7 +450,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         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:]]
+                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
@@ -467,10 +468,10 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
             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]
+        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))
+        return H2LibSignatures._set_variable_sensor_value(self, id, np.float64(value))
 
     def set_orientation_base(
         self,
@@ -528,7 +529,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         # 1D arrays are converted to 2D with 1 row.
         mbdy_eulerang_table = np.atleast_2d(mbdy_eulerang_table)
         error_code = -1
-        error_code = H2LibSignatures.set_orientation_base(
+        error_code = H2LibSignatures._set_orientation_base(
             self,
             main_body,
             mbdy_eulerang_table.shape[0],
@@ -618,7 +619,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         if node_2 == "last":
             node_2 = -2
         error_code = -1
-        error_code = H2LibSignatures.set_orientation_relative(
+        error_code = H2LibSignatures._set_orientation_relative(
             self,
             main_body_1,
             node_1 + 1,
@@ -669,8 +670,8 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
           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))
+        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
@@ -699,32 +700,39 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
             time = self.get_time()
         uvw = np.asfortranarray(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, uvw, np.float64(box_offset_x), np.float64(time))
+        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
+        self, main_body_nr, c2_def, twist_in_deg=True, check_length=True, update_structure=True
     ):
         """
-        Set c2_def, which defines the centerline of the specified main body.
+        Set `c2_def` or `cx_def` for 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.
+        main_body_nr : int
+            Number of main body that must be updated.
+            The mapping between main body name and number can be obtained with `get_mainbody_name_dict`.
+        c2_def : (:, 4) or (:, 5) ndarray
+            New c2_def/cx_def. It is an array with at least 2 rows and 4 columns for x, y, z and twist.
+            Optionally, the 5th column can be used for dx (default is 0.)
             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`.
+        update_structure : bool, optional
+            If `True` (default) triggers the recomputation of the element matrices, constraints and so on.
+            It is required for the changes to c2_def to take effect. If the user updates both c2_def/cx_def
+            and st, only 1 structure update is required.
 
         Raises
         ------
         ValueError
             Can be due to:
                 - MAIN_BODY_NOT_FOUND: none of the main bodies is called `main_body_name`.
+                - WRONG_NUMBER_OF_COLUMNS: cx_def must have 4 or 5 columns.
                 - 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,
@@ -738,13 +746,15 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
 
         """
         error_code = -1
-        error_code = H2LibSignatures.set_c2_def(
+        error_code = H2LibSignatures._set_cx_def(
             self,
-            main_body_name,
-            np.asfortranarray(c2_def.astype(np.float64)),
+            main_body_nr,
             c2_def.shape[0],
+            c2_def.shape[1],
+            np.asfortranarray(c2_def, dtype=np.float64),
             bool(twist_in_deg),
             bool(check_length),
+            bool(update_structure),
             error_code,
             check_stop=False,
         )[0][-1]
@@ -752,6 +762,55 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         if error_code > 0:
             raise _ERROR_CODES[error_code]
 
+    def set_st(
+        self, main_body_nr, st, update_structure=True
+    ):
+        """
+        Set STructural data for the specified main body.
+
+        Parameters
+        ----------
+        main_body_nr : int
+            Number of main body that must be updated.
+            The mapping between main body name and number can be obtained with `get_mainbody_name_dict`.
+        st : (:, :) ndarray
+            New ST. It is an array with an arbitrary number of rows and 19 or 30 columns.
+            Both the classical Timoshenko and the FPM model are supported.
+        update_structure : bool, optional
+            If `True` (default) triggers the recomputation of the element matrices, constraints and so on.
+            It is required for the changes to st to take effect. If the user updates both c2_def/cx_def
+            and st, only 1 structure update is required.
+
+        Raises
+        ------
+        ValueError
+            Can be due to:
+                - MAIN_BODY_NOT_FOUND: none of the main bodies is called `main_body_name`.
+                - WRONG_NUMBER_OF_COLUMNS: `st` must have 19 or 30 columns.
+                - ST_Z_NOT_CONTINUOUSLY_INCREASING: The z coordinate must always increase.
+        NotImplementedError
+            Only the c2_def node distribution is supported.
+
+        Returns
+        -------
+        None.
+
+        """
+        error_code = -1
+        error_code = H2LibSignatures._set_st(
+            self,
+            main_body_nr,
+            st.shape[0],
+            st.shape[1],
+            np.asfortranarray(st, dtype=np.float64),
+            bool(update_structure),
+            error_code,
+            check_stop=False,
+        )[0][-1]
+        self.initialize_distributed_sections()
+        if error_code > 0:
+            raise _ERROR_CODES[error_code]
+
     # ===================================================================================================================
     # H2rotor
     # ===================================================================================================================
@@ -761,16 +820,16 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
                 for r in range(self.get_nrotors())]
 
     def get_nrotors(self):
-        return H2LibSignatures.get_nrotors(self, restype=np.int64)[1]
+        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]
+        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]
+        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]
+        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:
@@ -780,63 +839,63 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
     def get_aerosections_position(self, rotor=0):
         """Global xyz position of aero sections. Shape=(#blades, #sections, 3)"""
         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]
+        return H2LibSignatures._get_aerosections_position(self, rotor + 1, position)[0][1]
 
     def set_aerosections_windspeed(self, uvw, rotor=0):
         """Update wind speed at aero sections. uvw shape=(#blades, #sections, 3)"""
-        return H2LibSignatures.set_aerosections_windspeed(self, rotor + 1, np.asfortranarray(uvw, np.float64))
+        return H2LibSignatures._set_aerosections_windspeed(self, rotor + 1, np.asfortranarray(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]
+        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]
+        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:]
+        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:]
+        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]
+        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]
+        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]
+        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:]
+        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]
+        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]
+        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)
@@ -866,7 +925,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
             nbdy,
             ncst,
             error_code,
-        ) = H2LibSignatures.get_number_of_bodies_and_constraints(
+        ) = H2LibSignatures._get_number_of_bodies_and_constraints(
             self, nbdy, ncst, error_code, check_stop=False
         )[
             0
@@ -894,7 +953,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
 
         nelem = np.zeros((nbdy, ), dtype=np.int64, order="F")
         error_code = -1
-        _, nelem, error_code = H2LibSignatures.get_number_of_elements(
+        _, nelem, error_code = H2LibSignatures._get_number_of_elements(
             self, nbdy, nelem, error_code, check_stop=False
         )[0]
 
@@ -947,7 +1006,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
             r12,
             tes,
             error_code,
-        ) = H2LibSignatures.get_timoshenko_location(
+        ) = H2LibSignatures._get_timoshenko_location(
             self, ibdy + 1, ielem + 1, l, r1, r12, tes, error_code, check_stop=False)[0]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
@@ -977,7 +1036,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         """
         amat = np.zeros((3, 3), order="F")
         error_code = -1
-        _, amat, error_code = H2LibSignatures.get_body_rotation_tensor(
+        _, amat, error_code = H2LibSignatures._get_body_rotation_tensor(
             self, ibdy + 1, amat, error_code, check_stop=False)[0]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
@@ -1017,7 +1076,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         error_code = -1
 
         _, body_mass, body_inertia, cog_global_frame, cog_body_frame, error_code = (
-            H2LibSignatures.body_output_mass(
+            H2LibSignatures._body_output_mass(
                 self,
                 ibdy + 1,
                 body_mass,
@@ -1063,7 +1122,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         stiffness = np.zeros_like(mass)
         damping = np.zeros_like(mass)
         error_code = -1
-        _, _, mass, stiffness, damping, error_code = H2LibSignatures.body_output_element(
+        _, _, mass, stiffness, damping, error_code = H2LibSignatures._body_output_element(
             self,
             ibdy + 1,
             ielem + 1,
@@ -1115,7 +1174,7 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         R = np.zeros((n_tdofs, n_rdofs), dtype=np.float64, order="F")
         error_code = -1
 
-        _, _, M, C, K, R, error_code = H2LibSignatures.get_system_matrices(
+        _, _, M, C, K, R, error_code = H2LibSignatures._get_system_matrices(
             self, n_tdofs, n_rdofs, M, C, K, R, error_code, check_stop=False)[0]
 
         if error_code > 0:
@@ -1123,19 +1182,48 @@ class H2LibThread(DLLWrapper, H2Lib_DistributedSections, H2LibSignatures):
         return M, C, K, R
 
     def get_no_mainbodies(self):
-        return H2LibSignatures.get_number_of_mainbodies(self, restype=np.int64)[1]
+        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}
+        return {H2LibSignatures._get_mainbody_name(self, mainbody_nr=int(i), mainbody_name=s)[0][1].strip(): i
+                for i in np.arange(1, 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(
+        return H2LibSignatures._get_mainbody_position_orientation(
             self, int(mainbody_nr), mbdy_pos, mbdy_tbg, int(mainbody_coo_nr))[0][1:-1]
 
+    def get_mainbody_nodes_state(self, mainbody_nr, state, mainbody_coo_nr=0):
+        """Return the state (pos, vel or acc) of mainbody nodes
+        Note, the state refers to the structural nodes at the elastic axis
+
+        Parameters
+        ----------
+        mainbody_nr : int
+            Index of mainbody (can be obtained from get_mainbody_name_dict())
+        state : {'pos','vel','acc'}
+            state type (position, velocity, acceleration) to compute
+        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
+        -------
+        state : array_like
+            state data shape=(no_nodes,3) containing the (x,y,z) position, velocity or acceleration of the nodes
+
+        """
+        state = ['pos', 'vel', 'acc'].index(state) + 1
+        nnodes = H2LibSignatures._get_mainbody_nnodes(self, int(mainbody_nr), restype=int)[1]
+        nodes_state = np.zeros((nnodes, 3), dtype=np.float64, order="F")
+        return H2LibSignatures._get_mainbody_nodes_state(
+            self, int(mainbody_nr), int(state), int(nnodes), int(mainbody_coo_nr), nodes_state)[0][-1]
+
 
 @contextmanager
 def set_LD_LIBRARY_PATH():

h2lib/_version.py

@@ -1,4 +1,4 @@
 # This file is autogenerated and should not be modified manually
-__version__ = '13.2.702'
-h2lib_version = '13.2.702'
-hawc2_version = '13.2.7+4-gb779ee7'
+__version__ = '13.2.901'
+h2lib_version = '13.2.901'
+hawc2_version = '13.2.9+4-gfd77867'