h2lib-tests 13.1.506__py3-none-any.whl → 13.1.1701__py3-none-any.whl

h2lib_tests/test_h2lib.py

@@ -328,3 +328,26 @@ def test_fail():
         # , match=re.escape('H2LibThread process died before or while executing fail(...)')):
         with pytest.raises(Exception):
             h2.fail('MyError')
+
+
+def test_dont_stop(capfd):
+    # This test is the same as test_error(), but instead we disable stop.
+    model_path = tfp + "minimal/"
+    htc = HTCFile(model_path + 'htc/minimal_mann_turb.htc')
+    htc.wind.scale_time_start = 200
+    htc.wind.turb_format = 1
+    htc.wind.mann.dont_scale = 0
+    htc.set_name('tmp')
+    htc.save()
+
+    with H2Lib() as h2:
+        h2.stop_on_error(False)
+        h2.init('htc/tmp.htc', model_path)
+        out, err = capfd.readouterr()
+        assert "*** ERROR *** Turbulence scale_time_start >= simulation length" in out
+
+    with MultiH2Lib(2) as h2:
+        h2.stop_on_error(False)
+        h2.init('htc/tmp.htc', model_path)
+        out, err = capfd.readouterr()
+        assert "*** ERROR *** Turbulence scale_time_start >= simulation length" in out

h2lib_tests/test_h2rotor.py

@@ -4,10 +4,11 @@ from numpy import testing as npt
 import pytest
 from wetb.gtsdf import gtsdf
 
-from h2lib_tests.dtu10mw import DTU10MW
+from h2lib_tests.dtu10mw import DTU10MW, DTU10MWRotor, DTU10MWSimple
 from h2lib_tests.test_files import tfp
 import matplotlib.pyplot as plt
 import numpy as np
+from wetb.hawc2.at_time_file import AtTimeFile
 
 
 def get_h2(htc_path='htc/DTU_10MW_RWT.htc'):
@@ -115,7 +116,7 @@ def test_rotor_avg_windspeed():
 
 def test_aerosections():
     plot = False
-    h2 = get_h2()
+    h2 = get_h2(htc_path='htc/DTU_10MW_RWT_no_aerodrag.htc')
     # blade 1, global coo, r>30
     pos_ids = [h2.add_sensor(f'aero position 3 1 {xyz} 30')[0] for xyz in [1, 2, 3]]
     wsp_ids = [h2.add_sensor(f'aero windspeed 3 1 {xyz} 30')[0] for xyz in [1, 2, 3]]
@@ -173,6 +174,111 @@ def test_aerosections():
     h2.close()
 
 
+def test_compare_aerosection_coupling():
+    """Compare simulations with 1) htc wind and 2) similar wind set to aerodynamic sections
+
+    - yaw=20, tilt=10, cone=5
+    - two blades (to check that xyz/uvw are not mixed up with number of blades)
+    - stiff structure, fixed rotor speed and pitch
+    - linear shear and no turb
+    - aero_calc=1, induction=0, tiploss=0, dynstall=2
+    - aerodrag turned off (requires wind speed at aerodrag sections, not implemented yet)
+    """
+    dtu10 = DTU10MWSimple(rotor_speed=.6, pitch=0, nbodies=1)
+    dtu10.set_stiff()
+
+    dtu10.set_wind(8, tint=0, turb_format=0, shear=(4, .01))
+    dtu10.set_tilt_cone_yaw(tilt=10, cone=5, yaw=20)
+    # remove third blade
+    dtu10.aero.nblades = 2
+    dtu10.aero.link__3.delete()
+
+    dtu10.aerodrag.delete()
+
+    T = 20
+    dtu10.set_time(0, T)
+    dtu10.set_aero(aero_calc=1, induction=0, tiploss=0, dynstall=2)
+
+    for coo in [3, 4]:
+        for xyz in [1, 2, 3]:
+            dtu10.output.add_sensor('aero', 'windspeed', [coo, 1, xyz, 72, 1])
+    for coo in [3]:
+        for xyz in [1, 2, 3]:
+            dtu10.output.add_sensor('aero', 'position', [coo, 1, xyz, 72, 1])
+
+    # At time sensors
+    at = dtu10.add_section(f'output_at_time aero {T}')
+    at.filename = "tmp1_at"
+    for sensor in ['vrel', 'alfa', 'alfadot', 'cl', 'cd', 'cm', 'lift', 'drag', 'moment', 'ct_local', 'cq_local', 'tiploss_f',
+                   'chord', 'inflow_angle', 'dcldalfa', 'dcddalfa', 'twist']:
+        at.add_sensor('', sensor, [1])
+
+    for sensor in ['inipos']:
+        for xyz in [1, 2, 3]:
+            at.add_sensor('', sensor, [1, xyz])
+    for sensor in ['secforce', 'secmoment', 'int_moment', 'int_force', 'position', 'velocity', 'acceleration', 'induc',
+                   'windspeed']:
+        for coo in [1, 2, 3, 4]:
+            for xyz in [1, 2, 3]:
+                at.add_sensor('', sensor, [1, xyz, coo])
+
+    dtu10.set_name('tmp1')
+    dtu10.save()
+    with H2Lib(suppress_output=True) as h2:
+        h2.init(dtu10.filename, dtu10.modelpath)
+        h2.run(T)
+
+    dtu10.wind.wsp = 20  # ensure htc wind speed is different and induction is large in case it by mistake is not turned off
+    at.filename = "tmp2_at"
+    dtu10.set_name('tmp2')
+    dtu10.save()
+
+    with H2Lib(suppress_output=True) as h2:
+        h2.init(dtu10.filename, dtu10.modelpath)
+        last_pos_gl_xyz = np.array(h2.get_aerosections_position(), order='F')
+        while h2.time < T:
+            pos_gl_xyz = np.array(h2.get_aerosections_position(), order='F')
+            uvw = np.asfortranarray(pos_gl_xyz * 0)
+            dpos_gl_xyz = (pos_gl_xyz - last_pos_gl_xyz)
+            next_pos_gl_xyz = pos_gl_xyz + dpos_gl_xyz
+            uvw[:, :, 0] = (-next_pos_gl_xyz[:, :, 2] - 119) * .01 + 8
+            last_pos_gl_xyz = pos_gl_xyz.copy()
+            h2.set_aerosections_windspeed(uvw)
+            h2.step()
+
+    time, data1, info = gtsdf.load(tfp + 'DTU_10_MW/res/tmp1.hdf5')
+    time, data2, info = gtsdf.load(tfp + 'DTU_10_MW/res/tmp2.hdf5')
+    # exclude first time step where position extrapolation is not active
+    for n, c1, c2 in zip(info['attribute_names'], data1[1:].T, data2[1:].T):
+        if n not in ['WSP gl. coo.,Vx', 'WSP gl. coo.,Vy', 'WSP gl. coo.,Vz']:  # nan
+            max_rel_err = np.abs(c2 - c1).max() / np.maximum(np.abs(c2).max(), 1)
+            try:
+                assert max_rel_err < 0.00001, n
+            except BaseException:
+                if 0:
+                    plt.title(n)
+                    plt.plot(c1)
+                    plt.plot(c2)
+                    plt.plot((c1 - c2))
+                    plt.show()
+                raise
+
+    at1 = AtTimeFile(tfp + 'DTU_10_MW/tmp1_at.dat')
+    at2 = AtTimeFile(tfp + 'DTU_10_MW/tmp2_at.dat')
+    for n, c1, c2 in zip(at1.attribute_names, at1.data.T, at2.data.T):
+        npt.assert_allclose(c2, c1, atol=1e-6, rtol=0.0001, err_msg=n)
+        try:
+            assert max_rel_err < 0.00001, n
+        except BaseException:
+            if 1:
+                plt.title(n)
+                plt.plot(c1)
+                plt.plot(c2)
+                plt.plot(c1 - c2)
+                plt.show()
+            raise
+
+
 def test_iea15MW():
     with H2Lib(suppress_output=True) as h2:
         h2.read_input(htc_path='htc/IEA_15MW_RWT_Onshore.htc', model_path=tfp + 'IEA-15-240-RWT-Onshore')

h2lib_tests/test_lin.py

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+"""
+Test the system-eigenanalysis.
+
+@author: ricriv
+"""
+
+# Here we are relying on the default behavior of pytest, which is to execute
+# the tests in the same order that they are specified.
+# If one day this will not be the case anymore, we can enforce the order by
+# using the solution proposed at: https://stackoverflow.com/a/77793427/3676517
+
+import pytest
+
+import numpy as np
+from numpy import testing as npt
+
+from h2lib._h2lib import H2Lib
+from h2lib_tests.test_files import tfp
+
+
+def test_system_not_linearized_1(h2_dtu_10mw_only_blade):
+    with pytest.raises(RuntimeError, match="SYSTEM_NOT_LINEARIZED"):
+        h2_dtu_10mw_only_blade.do_system_eigenanalysis(2)
+
+
+def test_system_not_linearized_2(h2_dtu_10mw_only_blade):
+    with pytest.raises(RuntimeError, match="SYSTEM_NOT_LINEARIZED"):
+        h2_dtu_10mw_only_blade.get_system_eigenvalues_and_eigenvectors(2, 2)
+
+
+def test_system_not_linearized_3(h2_dtu_10mw_only_blade):
+    with pytest.raises(RuntimeError, match="SYSTEM_NOT_LINEARIZED"):
+        h2_dtu_10mw_only_blade.get_system_matrices(312, 156)
+
+
+def test_linearize(h2_dtu_10mw_only_blade):
+    n_tdofs, n_rdofs = h2_dtu_10mw_only_blade.linearize()
+    assert n_rdofs == 26 * 6  # = number of nodes * 6
+    assert n_tdofs == 26 * 6 * 2  # times 2 because of speed.
+
+
+def test_too_many_modes(h2_dtu_10mw_only_blade):
+    with pytest.raises(ValueError, match="TOO_MANY_MODES_REQUESTED"):
+        h2_dtu_10mw_only_blade.do_system_eigenanalysis(n_modes=1000)
+
+
+def test_sys_eig_not_done(h2_dtu_10mw_only_blade):
+    with pytest.raises(RuntimeError, match="SYSTEM_EIGENANALYSIS_NOT_DONE"):
+        h2_dtu_10mw_only_blade.get_system_eigenvalues_and_eigenvectors(2, 2)
+
+
+def test_sys_eig_no_damping(h2_dtu_10mw_only_blade):
+    natural_frequencies = h2_dtu_10mw_only_blade.do_system_eigenanalysis(
+        n_modes=4, include_damping=False
+    )
+    # Test against: result at the time of writing.
+    npt.assert_allclose(
+        natural_frequencies,
+        np.array([0.610409, 0.930466, 1.739094, 2.761632]),
+        rtol=1e-6,
+    )
+
+
+def test_sys_eig_no_damping_wrong_n_modes(h2_dtu_10mw_only_blade):
+    with pytest.raises(ValueError, match="TOO_MANY_MODES_REQUESTED"):
+        h2_dtu_10mw_only_blade.get_system_eigenvalues_and_eigenvectors(
+            1000, 156
+        )
+
+
+def test_sys_eig_no_damping_wrong_ny(h2_dtu_10mw_only_blade):
+    with pytest.raises(ValueError, match="WRONG_REDUCED_DOF"):
+        h2_dtu_10mw_only_blade.get_system_eigenvalues_and_eigenvectors(4, 2)
+
+
+def test_sys_eig_no_damping_eigv(h2_dtu_10mw_only_blade):
+    n_modes = 4
+    n_rdofs = 156
+    eig_val, eig_vec = (
+        h2_dtu_10mw_only_blade.get_system_eigenvalues_and_eigenvectors(
+            n_modes, n_rdofs, include_damping=False
+        )
+    )
+    assert eig_val.size == n_modes
+    assert eig_vec.shape == (n_modes, n_rdofs)
+    assert eig_val.dtype == np.float64
+    assert eig_vec.dtype == np.float64
+    npt.assert_allclose(
+        eig_val,
+        np.array([3.83531, 5.846293, 10.927047, 17.351849]),
+    )
+
+
+def test_sys_eig_with_damping(h2_dtu_10mw_only_blade):
+    freq, damp = h2_dtu_10mw_only_blade.do_system_eigenanalysis(
+        n_modes=4, include_damping=True
+    )
+    # Test against: result at the time of writing.
+    npt.assert_allclose(
+        freq, np.array([0.610409, 0.930468, 1.739098, 2.761702]), rtol=1e-6
+    )
+    npt.assert_allclose(
+        damp, np.array([0.004826, 0.004758, 0.013395, 0.014194]), atol=1e-6
+    )
+
+
+def test_sys_eig_with_damping_eigv(h2_dtu_10mw_only_blade):
+    n_modes = 4
+    n_rdofs = 156
+    eig_val, eig_vec = (
+        h2_dtu_10mw_only_blade.get_system_eigenvalues_and_eigenvectors(
+            n_modes, n_rdofs, include_damping=True
+        )
+    )
+    assert eig_val.size == n_modes
+    assert eig_vec.shape == (n_modes, 2 * n_rdofs)
+    assert eig_val.dtype == np.complex128
+    assert eig_vec.dtype == np.complex128
+    npt.assert_allclose(
+        eig_val,
+        np.array(
+            [
+                -0.01851 - 3.835266j,
+                -0.027817 - 5.846237j,
+                -0.146367 - 10.926094j,
+                -0.246296 - 17.350536j,
+            ]
+        ),
+        atol=1e-6,
+    )
+
+
+def test_get_system_matrices_wrong_nt(h2_dtu_10mw_only_blade):
+    with pytest.raises(ValueError, match="WRONG_TOTAL_DOF"):
+        h2_dtu_10mw_only_blade.get_system_matrices(300, 156)
+
+
+def test_get_system_matrices_wrong_nr(h2_dtu_10mw_only_blade):
+    with pytest.raises(ValueError, match="WRONG_REDUCED_DOF"):
+        h2_dtu_10mw_only_blade.get_system_matrices(312, 150)
+
+
+def test_get_system_matrices(h2_dtu_10mw_only_blade):
+    n_rdofs = 26 * 6
+    n_tdofs = 2 * n_rdofs
+    M, C, K, R = h2_dtu_10mw_only_blade.get_system_matrices(n_tdofs, n_rdofs)
+    assert M.shape == (n_rdofs, n_rdofs)
+    assert C.shape == (n_rdofs, n_rdofs)
+    assert K.shape == (n_rdofs, n_rdofs)
+    assert R.shape == (n_tdofs, n_rdofs)
+
+
+def test_sys_eig_encrypted(h2_dtu_10mw_only_tower_encrypted):
+    n_tdofs, n_rdofs = h2_dtu_10mw_only_tower_encrypted.linearize()
+    n_modes = 4
+    freq, damp = h2_dtu_10mw_only_tower_encrypted.do_system_eigenanalysis(
+        n_modes=n_modes, include_damping=True
+    )
+    eig_val = h2_dtu_10mw_only_tower_encrypted.get_system_eigenvalues_and_eigenvectors(
+        n_modes=n_modes, n_rdofs=n_rdofs, include_damping=True
+    )
+    npt.assert_allclose(
+        freq,
+        np.array([0.770592, 0.770592, 3.449993, 3.449993]),
+        rtol=1e-6,
+    )
+
+    npt.assert_allclose(
+        damp,
+        np.array([0.010006, 0.010006, 0.044675, 0.044675]),
+        atol=1e-6,
+    )
+    npt.assert_allclose(
+        eig_val,
+        np.array(
+            [
+                -0.048444 - 4.84153j,
+                -0.048444 - 4.84153j,
+                -0.968409 - 21.6553j,
+                -0.968409 - 21.6553j,
+            ]
+        ),
+        atol=1e-6,
+    )
+
+
+def test_test_get_system_matrices_encrypted(h2_dtu_10mw_only_tower_encrypted):
+    n_tdofs, n_rdofs = h2_dtu_10mw_only_tower_encrypted.linearize()
+    with pytest.raises(RuntimeError, match="STRUCTURE_IS_CONFIDENTIAL"):
+        h2_dtu_10mw_only_tower_encrypted.get_system_matrices(n_tdofs, n_rdofs)

h2lib_tests/test_mpi.py

@@ -110,7 +110,7 @@ def ellipsys_mpi_dummy_workflow():
 
     with MultiH2Lib(N, suppress_output=True) as h2:
         el = Ellipsys()
-        htc = HTCFile(tfp + 'DTU_10_MW/htc/DTU_10MW_RWT.htc')
+        htc = HTCFile(tfp + 'DTU_10_MW/htc/DTU_10MW_RWT_no_aerodrag.htc')
         for i in range(N):
             htc.set_name(f'wt{i}')
             htc.save()

h2lib_tests/test_static_solver.py

@@ -18,31 +18,6 @@ from numpy import testing as npt
 from h2lib._h2lib import H2Lib
 from h2lib_tests.test_files import tfp
 
-from .test_write_htc import (
-    write_dtu10mw_only_blade,
-    write_dtu10mw_only_blade_low_max_iter,
-)
-
-
-@pytest.fixture(scope="module")
-def h2_dtu_10mw_only_blade(write_dtu10mw_only_blade):
-    h2 = H2Lib(suppress_output=True)
-    model_path = f"{tfp}DTU_10_MW/"
-    htc_path = "htc/DTU_10MW_RWT_only_blade.htc"
-    h2.init(htc_path=htc_path, model_path=model_path)
-    yield h2
-    h2.close()
-
-
-@pytest.fixture(scope="module")
-def h2_dtu10mw_only_blade_low_max_iter(write_dtu10mw_only_blade_low_max_iter):
-    h2 = H2Lib(suppress_output=True)
-    model_path = f"{tfp}DTU_10_MW/"
-    htc_path = "htc/DTU_10MW_RWT_only_blade_low_max_iter.htc"
-    h2.init(htc_path=htc_path, model_path=model_path)
-    yield h2
-    h2.close()
-
 
 def test_solver_static_update_no_init(h2_dtu_10mw_only_blade):
     with pytest.raises(RuntimeError, match="STATIC_SOLVER_NOT_INITIALIZED"):
@@ -77,7 +52,13 @@ def test_solver_static_delete(h2_dtu_10mw_only_blade):
     h2_dtu_10mw_only_blade.solver_static_delete()
 
 
-def test_static_solver_run(h2_dtu_10mw_only_blade):
+def test_static_solver_run_fail(h2_dtu10mw_only_blade_low_max_iter):
+    with pytest.raises(RuntimeError, match="STATIC_SOLVER_DID_NOT_CONVERGE"):
+        h2_dtu10mw_only_blade_low_max_iter.solver_static_run()
+
+
+def test_static_solver_run_1(h2_dtu_10mw_only_blade):
+    # Use gravity to deflect the clamped blade.
     # Add a sensor for the blade root moment, in this case only due to gravity.
     id = h2_dtu_10mw_only_blade.add_sensor("mbdy momentvec blade1 1 1 blade1")
 
@@ -93,6 +74,52 @@ def test_static_solver_run(h2_dtu_10mw_only_blade):
     )
 
 
-def test_static_solver_run_fail(h2_dtu10mw_only_blade_low_max_iter):
-    with pytest.raises(RuntimeError, match="STATIC_SOLVER_DID_NOT_CONVERGE"):
-        h2_dtu10mw_only_blade_low_max_iter.solver_static_run()
+def test_static_solver_run_2(h2_dtu_10mw_only_blade_rotate_base):
+    # Apply centrifugal loading with the base command.
+    # Add a sensor for the blade root force, in this case only due to centrifugal force.
+    id = h2_dtu_10mw_only_blade_rotate_base.add_sensor("mbdy forcevec blade1 1 1 blade1")
+
+    # Run the static solver.
+    h2_dtu_10mw_only_blade_rotate_base.solver_static_run()
+
+    # Do 1 step to get the output.
+    h2_dtu_10mw_only_blade_rotate_base.step()
+    val = h2_dtu_10mw_only_blade_rotate_base.get_sensor_values(id)
+    # Test against: result at the time of writing.
+    npt.assert_allclose(
+        val, np.array([10879.129998, 383.43168, 989.68145])
+    )
+
+
+def test_static_solver_run_3(h2_dtu_10mw_only_blade_rotate_relative):
+    # Apply centrifugal loading with the relative command.
+    # Add a sensor for the blade root force, in this case only due to centrifugal force.
+    id = h2_dtu_10mw_only_blade_rotate_relative.add_sensor("mbdy forcevec blade1 1 1 blade1")
+
+    # Run the static solver.
+    h2_dtu_10mw_only_blade_rotate_relative.solver_static_run()
+
+    # Do 1 step to get the output.
+    h2_dtu_10mw_only_blade_rotate_relative.step()
+    val = h2_dtu_10mw_only_blade_rotate_relative.get_sensor_values(id)
+    # Test against: result at the time of writing.
+    npt.assert_allclose(
+        val, np.array([10879.083576, 383.430039, 989.67935])
+    )
+
+
+def test_static_solver_run_4(h2_dtu_10mw_only_blade_rotate_bearing3):
+    # Apply centrifugal loading with the bearing3 command.
+    # Add a sensor for the blade root moment, in this case only due to centrifugal force.
+    id = h2_dtu_10mw_only_blade_rotate_bearing3.add_sensor("mbdy momentvec blade1 1 1 blade1")
+
+    # Run the static solver.
+    h2_dtu_10mw_only_blade_rotate_bearing3.solver_static_run()
+
+    # Do 1 step to get the output.
+    h2_dtu_10mw_only_blade_rotate_bearing3.step()
+    val = h2_dtu_10mw_only_blade_rotate_bearing3.get_sensor_values(id)
+    # Test against: result at the time of writing.
+    npt.assert_allclose(
+        val, np.array([-3094.986918, 115414.095937, 325.296806])
+    )