h2lib-tests 13.1.3110__py3-none-any.whl → 13.2.701__py3-none-any.whl

h2lib_tests/conftest.py

@@ -1,6 +1,7 @@
-import pytest
 import numpy as np
+import pytest
 from wetb.hawc2.htc_file import HTCFile
+from wetb.hawc2.mainbody import MainBody
 from h2lib_tests.test_files import tfp
 from h2lib._h2lib import H2Lib
 
@@ -59,7 +60,9 @@ def write_dtu10mw_only_tower_encrypted(write_dtu10mw_only_tower):
     htc = write_dtu10mw_only_tower.copy()
     htc.set_name("DTU_10MW_RWT_only_tower_encrypted")
     # Only the tower is left.
-    htc.new_htc_structure.main_body.timoschenko_input.filename = "./data/DTU_10MW_RWT_Tower_st.dat.v3.enc"
+    htc.new_htc_structure.main_body.timoschenko_input.filename = (
+        "./data/DTU_10MW_RWT_Tower_st.dat.v3.enc"
+    )
     htc.save()
 
 
@@ -88,7 +91,9 @@ def write_dtu10mw_only_blade():
     htc.new_htc_structure.orientation.base.mbdy = "blade1"
     htc.new_htc_structure.orientation.base.inipos = [0.0, 0.0, 0.0]
     htc.new_htc_structure.orientation.base["mbdy_eulerang"] = [90.0, 0.0, 0.0]
-    htc.new_htc_structure.orientation.base.mbdy_eulerang.comments = "Blade span is horizontal."
+    htc.new_htc_structure.orientation.base.mbdy_eulerang.comments = (
+        "Blade span is horizontal."
+    )
 
     # Clamp the blade.
     htc.new_htc_structure.add_section("constraint")
@@ -128,6 +133,20 @@ def write_dtu10mw_only_blade_low_max_iter(write_dtu10mw_only_blade):
     return htc
 
 
+@pytest.fixture(scope="session")
+def write_dtu10mw_only_blade_1_body(write_dtu10mw_only_blade):
+    # Start from the write_dtu10mw_only_blade and then set the number of bodies to 1.
+    # This is to compute its mass properties.
+    htc = write_dtu10mw_only_blade.copy()
+    htc.set_name("DTU_10MW_RWT_only_blade_1_body")
+    htc.new_htc_structure.main_body__7.nbodies = 1
+    htc["wind"].delete()
+    htc["output"].delete()
+    htc.save()
+
+    return htc
+
+
 @pytest.fixture(scope="session")
 def write_dtu10mw_only_blade_rotate_base(write_dtu10mw_only_blade):
     # Start from the write_dtu10mw_only_blade and then make it rotate by using the base command.
@@ -137,12 +156,20 @@ def write_dtu10mw_only_blade_rotate_base(write_dtu10mw_only_blade):
     htc = write_dtu10mw_only_blade.copy()
     htc.set_name("DTU_10MW_RWT_only_blade_rotate_base")
     speed = 1.0  # [rad/s]
-    htc.new_htc_structure.orientation.base["mbdy_ini_rotvec_d1"] = [0.0, 1.0, 0.0, speed]
-    htc.new_htc_structure.orientation.base.mbdy_ini_rotvec_d1.comments = f"= {speed * 30.0 / np.pi:.2f} rpm"
+    htc.new_htc_structure.orientation.base["mbdy_ini_rotvec_d1"] = [
+        0.0,
+        1.0,
+        0.0,
+        speed,
+    ]
+    htc.new_htc_structure.orientation.base.mbdy_ini_rotvec_d1.comments = (
+        f"= {speed * 30.0 / np.pi:.2f} rpm"
+    )
     htc.new_htc_structure.main_body__7.gravity = 0.0
     htc["wind"].delete()
     htc["output"].delete()
     htc.save()
+    return htc
 
 
 @pytest.fixture(scope="session")
@@ -152,16 +179,17 @@ def write_dtu10mw_only_blade_rotate_relative():
     # Because of the fix1 constraint, the blade will not rotate after time 0.
     htc = HTCFile(tfp + "DTU_10_MW/htc/DTU_10MW_RWT.htc")
     htc.set_name("DTU_10MW_RWT_only_blade_rotate_relative")
-    for key1 in ("main_body",     # tower
-                 "main_body__2",  # towertop
-                 "main_body__3",  # shaft
-                 "main_body__5",  # hub2
-                 "main_body__6",  # hub3
-                 "main_body__8",  # blade2
-                 "main_body__9",  # blade3
-                 "orientation",
-                 "constraint",
-                 ):
+    for key1 in (
+        "main_body",  # tower
+        "main_body__2",  # towertop
+        "main_body__3",  # shaft
+        "main_body__5",  # hub2
+        "main_body__6",  # hub3
+        "main_body__8",  # blade2
+        "main_body__9",  # blade3
+        "orientation",
+        "constraint",
+    ):
         htc["new_htc_structure"][key1].delete()
     htc["wind"].delete()
     htc["aerodrag"].delete()
@@ -175,17 +203,32 @@ def write_dtu10mw_only_blade_rotate_relative():
     htc.new_htc_structure.orientation.base.mbdy = "hub1"
     htc.new_htc_structure.orientation.base.inipos = [0.0, 0.0, 0.0]
     htc.new_htc_structure.orientation.base["mbdy_eulerang"] = [180.0, 0.0, 0.0]
-    htc.new_htc_structure.orientation.base.mbdy_eulerang.comments = "Hub axis is up."
+    htc.new_htc_structure.orientation.base.mbdy_eulerang.comments = (
+        "Hub axis is up."
+    )
 
     # Set the blade horizontal.
     htc.new_htc_structure.orientation.add_section("relative")
     htc.new_htc_structure.orientation.relative.mbdy1 = "hub1  last"
     htc.new_htc_structure.orientation.relative.mbdy2 = "blade1  1"
-    htc.new_htc_structure.orientation.relative["mbdy2_eulerang"] = [-90.0, 0.0, 0.0]
-    htc.new_htc_structure.orientation.relative.mbdy2_eulerang.comments = "Blade span is horizontal."
+    htc.new_htc_structure.orientation.relative["mbdy2_eulerang"] = [
+        -90.0,
+        0.0,
+        0.0,
+    ]
+    htc.new_htc_structure.orientation.relative.mbdy2_eulerang.comments = (
+        "Blade span is horizontal."
+    )
     speed = 1.0  # [rad/s]
-    htc.new_htc_structure.orientation.relative["mbdy2_ini_rotvec_d1"] = [0.0, 1.0, 0.0, speed]
-    htc.new_htc_structure.orientation.relative.mbdy2_ini_rotvec_d1.comments = f"= {speed * 30.0 / np.pi:.2f} rpm"
+    htc.new_htc_structure.orientation.relative["mbdy2_ini_rotvec_d1"] = [
+        0.0,
+        1.0,
+        0.0,
+        speed,
+    ]
+    htc.new_htc_structure.orientation.relative.mbdy2_ini_rotvec_d1.comments = (
+        f"= {speed * 30.0 / np.pi:.2f} rpm"
+    )
 
     # Disable gravity.
     htc.new_htc_structure.main_body__7.gravity = 0.0
@@ -224,16 +267,17 @@ def write_dtu10mw_only_blade_rotate_bearing3():
     # The blade now rotates because of the bearing3 between the blade and hub.
     htc = HTCFile(tfp + "DTU_10_MW/htc/DTU_10MW_RWT.htc")
     htc.set_name("DTU_10MW_RWT_only_blade_rotate_bearing3")
-    for key1 in ("main_body",     # tower
-                 "main_body__2",  # towertop
-                 "main_body__3",  # shaft
-                 "main_body__5",  # hub2
-                 "main_body__6",  # hub3
-                 "main_body__8",  # blade2
-                 "main_body__9",  # blade3
-                 "orientation",
-                 "constraint",
-                 ):
+    for key1 in (
+        "main_body",  # tower
+        "main_body__2",  # towertop
+        "main_body__3",  # shaft
+        "main_body__5",  # hub2
+        "main_body__6",  # hub3
+        "main_body__8",  # blade2
+        "main_body__9",  # blade3
+        "orientation",
+        "constraint",
+    ):
         htc["new_htc_structure"][key1].delete()
     htc["wind"].delete()
     htc["aerodrag"].delete()
@@ -247,14 +291,22 @@ def write_dtu10mw_only_blade_rotate_bearing3():
     htc.new_htc_structure.orientation.base.mbdy = "hub1"
     htc.new_htc_structure.orientation.base.inipos = [0.0, 0.0, 0.0]
     htc.new_htc_structure.orientation.base["mbdy_eulerang"] = [180.0, 0.0, 0.0]
-    htc.new_htc_structure.orientation.base.mbdy_eulerang.comments = "Hub axis is up."
+    htc.new_htc_structure.orientation.base.mbdy_eulerang.comments = (
+        "Hub axis is up."
+    )
 
     # Set the blade horizontal.
     htc.new_htc_structure.orientation.add_section("relative")
     htc.new_htc_structure.orientation.relative.mbdy1 = "hub1  last"
     htc.new_htc_structure.orientation.relative.mbdy2 = "blade1  1"
-    htc.new_htc_structure.orientation.relative["mbdy2_eulerang"] = [-90.0, 0.0, 0.0]
-    htc.new_htc_structure.orientation.relative.mbdy2_eulerang.comments = "Blade span is horizontal."
+    htc.new_htc_structure.orientation.relative["mbdy2_eulerang"] = [
+        -90.0,
+        0.0,
+        0.0,
+    ]
+    htc.new_htc_structure.orientation.relative.mbdy2_eulerang.comments = (
+        "Blade span is horizontal."
+    )
 
     # Disable gravity.
     htc.new_htc_structure.main_body__7.gravity = 0.0
@@ -270,10 +322,17 @@ def write_dtu10mw_only_blade_rotate_bearing3():
     htc.new_htc_structure.constraint.bearing3.name = "bearing"
     htc.new_htc_structure.constraint.bearing3.mbdy1 = "hub1 last"
     htc.new_htc_structure.constraint.bearing3.mbdy2 = "blade1 1"
-    htc.new_htc_structure.constraint.bearing3.bearing_vector = [1, 0.0, 0.0, 1.0]
+    htc.new_htc_structure.constraint.bearing3.bearing_vector = [
+        1,
+        0.0,
+        0.0,
+        1.0,
+    ]
     speed = 1.0  # [rad/s]
     htc.new_htc_structure.constraint.bearing3.omegas = speed
-    htc.new_htc_structure.constraint.bearing3.omegas.comments = f"= {speed * 30.0 / np.pi:.2f} rpm"
+    htc.new_htc_structure.constraint.bearing3.omegas.comments = (
+        f"= {speed * 30.0 / np.pi:.2f} rpm"
+    )
 
     # Set as many bodies as elements.
     htc.new_htc_structure.main_body__7.nbodies = 26
@@ -291,6 +350,85 @@ def write_dtu10mw_only_blade_rotate_bearing3():
     return htc
 
 
+@pytest.fixture(scope="session")
+def write_dtu10mw_only_blade_uniform_node_distribution(
+    write_dtu10mw_only_blade,
+):
+    # Start from the write_dtu10mw_only_blade and then change the nodes distribution to uniform.
+    htc = write_dtu10mw_only_blade.copy()
+    htc.set_name("DTU_10MW_RWT_only_blade_uniform_node_distribution")
+    htc.new_htc_structure.main_body__7.nbodies = 10
+    htc.new_htc_structure.main_body__7.node_distribution = ["uniform", 11]
+    # Somehow the wind and output blocks are back.
+    htc["wind"].delete()
+    htc["output"].delete()
+    htc.save()
+    return htc
+
+
+@pytest.fixture(scope="session")
+def write_dtu10mw_only_blade_high_gravity(
+    write_dtu10mw_only_blade,
+):
+    # Start from the write_dtu10mw_only_blade and then increase the gravity loading.
+    htc = write_dtu10mw_only_blade.copy()
+    htc.set_name("DTU_10MW_RWT_only_blade_high_gravity")
+    htc.new_htc_structure.main_body__7.gravity = 100.0
+    mb = MainBody(htc, "blade1")
+    blade_c2def = mb.c2def
+    # Somehow the wind and output blocks are back.
+    htc["wind"].delete()
+    htc["output"].delete()
+    htc.save()
+    return htc, blade_c2def
+
+
+@pytest.fixture(scope="session")
+def write_dtu10mw_only_blade_high_gravity_1_body(
+    write_dtu10mw_only_blade_high_gravity,
+):
+    # Start from the write_dtu10mw_only_blade_high_gravity and then set 1 body.
+    htc_ori, _ = write_dtu10mw_only_blade_high_gravity
+    htc = htc_ori.copy()
+    htc.set_name("DTU_10MW_RWT_only_blade_high_gravity_1_body")
+    htc.new_htc_structure.main_body__7.nbodies = 1
+    mb = MainBody(htc, "blade1")
+    blade_c2def = mb.c2def
+    # Somehow the wind and output blocks are back.
+    htc["wind"].delete()
+    htc["output"].delete()
+    htc.save()
+    return htc, blade_c2def
+
+
+@pytest.fixture(scope="session")
+def write_dtu10mw_only_blade_high_gravity_deformed(
+    write_dtu10mw_only_blade,
+):
+    # Start from the write_dtu10mw_only_blade and then increase the gravity loading.
+    htc = write_dtu10mw_only_blade.copy()
+    htc.set_name("DTU_10MW_RWT_only_blade_high_gravity_deformed")
+    htc.new_htc_structure.main_body__7.gravity = 100.0
+    # Deform c2_def.
+    mb = MainBody(htc, "blade1")
+    blade_c2def = mb.c2def
+    blade_c2def[:, 0] *= 1.3
+    blade_c2def[:, 1] *= 0.8
+    blade_c2def[:, 2] *= 1.2
+    blade_c2def[:, 3] -= 3.42796
+    # Loop over the sec and set c2def.
+    i = 0
+    htc.new_htc_structure.main_body__7.c2_def.sec = f"{i + 1}  {blade_c2def[i, 0]:.14f}  {blade_c2def[i, 1]:.14f}  {blade_c2def[i, 2]:.14f}  {blade_c2def[i, 3]:.14f}"
+    for i in range(1, blade_c2def.shape[0]):
+        setattr(htc.new_htc_structure.main_body__7.c2_def, f"sec__{i + 1}", f"{i + 1}  {blade_c2def[i, 0]:.14f}  {blade_c2def[i, 1]:.14f}  {blade_c2def[i, 2]:.14f}  {blade_c2def[i, 3]:.14f}")
+
+    # Somehow the wind and output blocks are back.
+    htc["wind"].delete()
+    htc["output"].delete()
+    htc.save()
+    return htc, blade_c2def
+
+
 @pytest.fixture(scope="session")
 def h2_dtu_10mw_only_tower(write_dtu10mw_only_tower):
     h2 = H2Lib(suppress_output=True)
@@ -329,6 +467,9 @@ 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.add_sensor("mbdy forcevec blade1 1 1 blade1")  # 1, 2, 3
+    h2.add_sensor("mbdy momentvec blade1 1 1 blade1")  # 4, 5, 6
+    h2.add_sensor("mbdy statevec_new blade1 c2def global absolute 85.0 1.0 0.0 0.0")  # 7, 8, 9
     h2.init(htc_path=htc_path, model_path=model_path)
     h2.stop_on_error(False)
     yield h2
@@ -346,11 +487,24 @@ def h2_dtu10mw_only_blade_low_max_iter(write_dtu10mw_only_blade_low_max_iter):
     h2.close()
 
 
+@pytest.fixture(scope="session")
+def h2_dtu10mw_only_blade_1_body(write_dtu10mw_only_blade_1_body):
+    h2 = H2Lib(suppress_output=True)
+    model_path = f"{tfp}DTU_10_MW/"
+    htc_path = "htc/DTU_10MW_RWT_only_blade_1_body.htc"
+    h2.init(htc_path=htc_path, model_path=model_path)
+    h2.stop_on_error(False)
+    yield h2
+    h2.close()
+
+
 @pytest.fixture(scope="session")
 def h2_dtu_10mw_only_blade_rotate_base(write_dtu10mw_only_blade_rotate_base):
     h2 = H2Lib(suppress_output=True)
     model_path = f"{tfp}DTU_10_MW/"
     htc_path = "htc/DTU_10MW_RWT_only_blade_rotate_base.htc"
+    h2.add_sensor("mbdy forcevec blade1 1 1 blade1")  # 1, 2, 3
+    h2.add_sensor("mbdy momentvec blade1 1 1 blade1")  # 4, 5, 6
     h2.init(htc_path=htc_path, model_path=model_path)
     h2.stop_on_error(False)
     yield h2
@@ -358,10 +512,14 @@ def h2_dtu_10mw_only_blade_rotate_base(write_dtu10mw_only_blade_rotate_base):
 
 
 @pytest.fixture(scope="session")
-def h2_dtu_10mw_only_blade_rotate_relative(write_dtu10mw_only_blade_rotate_relative):
+def h2_dtu_10mw_only_blade_rotate_relative(
+    write_dtu10mw_only_blade_rotate_relative,
+):
     h2 = H2Lib(suppress_output=True)
     model_path = f"{tfp}DTU_10_MW/"
     htc_path = "htc/DTU_10MW_RWT_only_blade_rotate_relative.htc"
+    h2.add_sensor("mbdy forcevec blade1 1 1 blade1")  # 1, 2, 3
+    h2.add_sensor("mbdy momentvec blade1 1 1 blade1")  # 4, 5, 6
     h2.init(htc_path=htc_path, model_path=model_path)
     h2.stop_on_error(False)
     yield h2
@@ -369,10 +527,67 @@ def h2_dtu_10mw_only_blade_rotate_relative(write_dtu10mw_only_blade_rotate_relat
 
 
 @pytest.fixture(scope="session")
-def h2_dtu_10mw_only_blade_rotate_bearing3(write_dtu10mw_only_blade_rotate_bearing3):
+def h2_dtu_10mw_only_blade_rotate_bearing3(
+    write_dtu10mw_only_blade_rotate_bearing3,
+):
     h2 = H2Lib(suppress_output=True)
     model_path = f"{tfp}DTU_10_MW/"
     htc_path = "htc/DTU_10MW_RWT_only_blade_rotate_bearing3.htc"
+    h2.add_sensor("mbdy forcevec blade1 1 1 blade1")  # 1, 2, 3
+    h2.add_sensor("mbdy momentvec blade1 1 1 blade1")  # 4, 5, 6
+    h2.init(htc_path=htc_path, model_path=model_path)
+    h2.stop_on_error(False)
+    yield h2
+    h2.close()
+
+
+@pytest.fixture(scope="session")
+def h2_dtu_10mw_only_blade_uniform_node_distribution(
+    write_dtu10mw_only_blade_uniform_node_distribution,
+):
+    h2 = H2Lib(suppress_output=True)
+    model_path = f"{tfp}DTU_10_MW/"
+    htc_path = "htc/DTU_10MW_RWT_only_blade_uniform_node_distribution.htc"
+    h2.init(htc_path=htc_path, model_path=model_path)
+    h2.stop_on_error(False)
+    yield h2
+    h2.close()
+
+
+@pytest.fixture(scope="session")
+def h2_dtu10mw_only_blade_high_gravity(write_dtu10mw_only_blade_high_gravity):
+    h2 = H2Lib(suppress_output=True)
+    model_path = f"{tfp}DTU_10_MW/"
+    htc_path = "htc/DTU_10MW_RWT_only_blade_high_gravity.htc"
+    h2.add_sensor("mbdy statevec_new blade1 c2def global absolute 90.0 1.0 0.0 0.0")  # 1-6
+    h2.add_sensor("mbdy forcevec blade1 1 1 blade1")  # 7, 8, 9
+    h2.add_sensor("mbdy momentvec blade1 1 1 blade1")  # 10, 11, 12
+    h2.init(htc_path=htc_path, model_path=model_path)
+    h2.stop_on_error(False)
+    yield h2
+    h2.close()
+
+
+@pytest.fixture(scope="session")
+def h2_dtu10mw_only_blade_high_gravity_deformed(write_dtu10mw_only_blade_high_gravity_deformed):
+    h2 = H2Lib(suppress_output=True)
+    model_path = f"{tfp}DTU_10_MW/"
+    htc_path = "htc/DTU_10MW_RWT_only_blade_high_gravity_deformed.htc"
+    h2.add_sensor("mbdy statevec_new blade1 c2def global absolute 90.0 1.0 0.0 0.0")  # 1-6
+    h2.add_sensor("mbdy forcevec blade1 1 1 blade1")  # 7, 8, 9
+    h2.add_sensor("mbdy momentvec blade1 1 1 blade1")  # 10, 11, 12
+    h2.init(htc_path=htc_path, model_path=model_path)
+    h2.stop_on_error(False)
+    yield h2
+    h2.close()
+
+
+@pytest.fixture(scope="session")
+def h2_dtu10mw_only_blade_high_gravity_1_body(write_dtu10mw_only_blade_high_gravity_1_body):
+    h2 = H2Lib(suppress_output=True)
+    model_path = f"{tfp}DTU_10_MW/"
+    htc_path = "htc/DTU_10MW_RWT_only_blade_high_gravity_1_body.htc"
+    h2.add_sensor("mbdy statevec_new blade1 c2def global absolute 90.0 1.0 0.0 0.0")
     h2.init(htc_path=htc_path, model_path=model_path)
     h2.stop_on_error(False)
     yield h2

h2lib_tests/test_distributed_sections.py

@@ -0,0 +1,111 @@
+from h2lib_tests import tfp
+import pytest
+
+from h2lib._h2lib import H2LibThread, H2Lib
+from h2lib.distributed_sections import DistributedSections, LinkType
+import numpy as np
+from numpy import testing as npt
+import matplotlib.pyplot as plt
+
+
+def test_distributed_sections():
+    # apply force on tower and check deflected tower position
+    with H2Lib(suppress_output=0) as h2:
+        model_path = f"{tfp}DTU_10_MW/"
+        htc_path = f"{tfp}DTU_10_MW/htc/DTU_10MW_RWT.htc"
+        h2.init(htc_path=htc_path, model_path=model_path)
+
+        ax = plt.figure().add_subplot(projection='3d')
+        for i in [1, 2, 3]:
+            # ds = DistributedSections(name='', link_type=1, link_id=i, nsec=50)
+            ds = h2.get_distributed_sections(LinkType.BLADE, link_id=i)
+
+            sec_pos, sec_tsg = h2.get_distributed_section_position_orientation(ds, mainbody_coo_nr=0)
+            x, y, z = sec_pos.T
+            ax.plot(y, x, -z, label=ds.name)
+            for (x, y, z), tsg in zip(sec_pos, sec_tsg):
+                for (ex, ey, ez), c in zip(tsg.T * 10, 'rgb'):
+                    plt.plot([y, y + ey], [x, x + ex], [-z, -z - ez], c)
+        plt.legend()
+        plt.axis('equal')
+        if 0:
+            plt.show()
+        ds = h2.get_distributed_sections(LinkType.BLADE, link_id=2)
+        sec_pos, sec_tsg = h2.get_distributed_section_position_orientation(ds, mainbody_coo_nr=0)
+        npt.assert_array_almost_equal(sec_pos[40], [70.58938502, -16.98280589, -77.95555399], 6)
+        npt.assert_array_almost_equal(sec_tsg[40], [[0.49371347, 0.09098716, 0.86485163],
+                                                    [0.12164175, 0.97750846, -0.17228029],
+                                                    [-0.86107508, 0.19025917, 0.47154125]], 6)
+
+        with pytest.raises(AssertionError, match=r"'missing' does not exist. Valid names are \['tower',"):
+            h2.add_distributed_sections('missing', [0, .4, .8, 1])
+        mbdy_name_dict = h2.get_mainbody_name_dict()
+        mbdy_name_lst = list(mbdy_name_dict.keys())
+        ds_dict = {mbdy_name: h2.add_distributed_sections(mbdy_name, [0, .4, .8, 1])
+                   for mbdy_name in mbdy_name_lst}
+        h2.initialize_distributed_sections()
+        ds_dict['blade1_aero'] = h2.get_distributed_sections(LinkType.BLADE, 1)
+
+        ax = plt.figure().add_subplot(projection='3d')
+        for name, ds in ds_dict.items():
+            sec_pos, sec_tsg = h2.get_distributed_section_position_orientation(ds, mbdy_name_dict['hub2'])
+            x, y, z = sec_pos.T
+            ax.plot(y, x, -z, label=name)
+            for (x, y, z), tsg in zip(sec_pos, sec_tsg):
+                for (ex, ey, ez), c in zip(tsg.T * 10, 'rgb'):
+
+                    plt.plot([y, y + ey], [x, x + ex], [-z, -z - ez], c)
+
+        plt.axis('equal')
+        if 0:
+            plt.show()
+
+        # print(ds_lst[6].name, ds_lst[3].name)
+        # mb_pos, b1_mb_tbg, b1_sec_pos, sec_tsb = h2.get_distributed_section_position_orientation(ds_lst[6])
+        # hub_id = h2.get_mainbody_name_dict()['hub1']
+        # print(hub_id)
+        # print(h2.get_mainbody_position_orientation(hub_id))
+        # print(b1_sec_pos[[0, -1]])
+
+        sec_pos, sec_tsb = h2.get_distributed_section_position_orientation(ds_dict['blade1'])
+        # print(np.round(mb_pos + [mb_tbg@sp for sp in sec_pos], 1).tolist())
+
+        print(np.round(sec_pos, 1).tolist())
+        npt.assert_array_almost_equal(sec_pos, [[-0.0, -6.9, -121.8],
+                                                [0.8, -5.7, -156.4],
+                                                [0.4, -5.8, -190.9],
+                                                [0.1, -6.5, -208.2]], 1)
+
+        sec_pos, sec_tsb = h2.get_distributed_section_position_orientation(ds_dict['blade1_aero'])
+
+        idx = [0, 10, 20, 30, 40, 49]
+        print(np.round(sec_pos[idx], 2).tolist())
+        npt.assert_array_almost_equal(sec_pos[idx], [[1.3, -6.61, -121.78],
+                                                     [1.37, -6.27, -130.32],
+                                                     [2.33, -5.65, -152.69],
+                                                     [1.51, -5.61, -179.95],
+                                                     [0.86, -6.2, -201.24],
+                                                     [0.29, -6.53, -208.25]], 2)
+
+        frc = np.zeros((4, 3))
+        frc[:, 1] = 100000
+        h2.set_distributed_section_force_and_moment(ds_dict['tower'], sec_frc=frc, sec_mom=np.zeros((4, 3)))
+
+        h2.run(2)
+        for ds in ds_dict.values():
+            sec_pos, sec_tsb = h2.get_distributed_section_position_orientation(ds)
+            x, y, z = sec_pos.T
+            ax.plot(y, x, -z, '--', label=ds.name)
+        plt.legend()
+        plt.axis('scaled')
+        if 0:
+            plt.show()
+        plt.close('all')
+        np.set_printoptions(linewidth=200)
+        sec_pos, sec_tsb = h2.get_distributed_section_position_orientation(ds_dict['tower'])
+        # print(np.round(mb_pos + [mb_tbg@sp for sp in sec_pos], 1).tolist())
+
+        npt.assert_array_almost_equal(sec_pos, [[0.0, 0.0, 0.0],
+                                                [-0.0, 0.7, -46.2],
+                                                [-0.0, 2.4, -92.5],
+                                                [0.0, 3.5, -115.6]], 1)

h2lib_tests/test_ellipsys_couplings.py

@@ -55,7 +55,7 @@ def test_ellipsys_dummy_workflow_1wt():
             htc.set_name(f'wt{i}')
             htc.save()
 
-        h2.init_AD(htc_path=f'htc/wt0.htc', model_path=tfp + 'DTU_10_MW', tiploss_shen_c2=28)
+        h2.init_AD(htc_path=f'htc/wt0.htc', model_path=tfp + 'DTU_10_MW', tiploss2_shen_c2=28)
         wt_pos = np.array([0, 0, 0])
 
         while True:
@@ -80,7 +80,8 @@ def test_ellipsys_dummy_workflow():
             htc.set_name(f'wt{i}')
             htc.save()
 
-        h2.init_AD(htc_path=[f'htc/wt{i}.htc' for i in range(N)], model_path=tfp + 'DTU_10_MW', tiploss_shen_c2=28)
+        h2.init_AD(htc_path=[f'htc/wt{i}.htc' for i in range(N)], model_path=tfp + 'DTU_10_MW',
+                   tiploss2_shen_c2=28, tiploss2_shen_h=0.5)
         wt_pos = np.array([[0, 0, 0], [0, 500, 0], [0, 1000, 0], [0, 1500, 0]])
 
         while True:

h2lib_tests/test_files/DTU_10_MW/htc/DTU_10MW_RWT_only_tower.htc

@@ -0,0 +1,68 @@
+;DTU_10MW_RWT, version 9, 25-09-2017, mhha
+;
+  begin simulation;
+    time_stop	10.0;
+    solvertype	1;	(newmark)
+    on_no_convergence	continue;
+    convergence_limits	1000 1 1e-07;	
+;logfile ./log/DTU_10MW_RWT_ver09.log ;
+    log_deltat	1;
+    begin newmark;
+      deltat	0.01;
+    end newmark;
+  end simulation;
+;
+;----------------------------------------------------------------------------------------------------------------------------------------------------------------
+  begin new_htc_structure;
+;   beam_output_file_name  ./log/DTU_10MW_RWT_beam.dat;                    Optional - Calculated beam properties of the bodies are written to file
+;   body_output_file_name  ./log/DTU_10MW_RWT_body.dat;                    Optional - Body initial position and orientation are written to file
+;   body_eigenanalysis_file_name ./eig/DTU_10MW_RWT_body_eigen.dat;
+;   structure_eigenanalysis_file_name ./eig/DTU_10MW_RWT_strc_eigen.dat ;
+;-------------------------------------------------------------------------------------------------------------------------------
+;-------------------------------------------------------------------------------------------------------------------------------
+    begin main_body;	tower 115m
+      name	tower;
+      type	timoschenko;
+      nbodies	3;
+      node_distribution	c2_def;
+      damping_posdef	0 0 0 0.00412 0.00412 0.00045;	Mx My Mz Kx Ky Kz , M´s raises overall level, K´s raises high freguency level "tuned by Larh"
+      begin timoschenko_input;
+        filename	./data/DTU_10MW_RWT_Tower_st.dat;
+        set	1 1;
+      end timoschenko_input;
+      begin c2_def;	Definition of centerline (main_body coordinates)
+        nsec	11;
+        sec	1 0 0 0 0;	x,y,z,twist
+        sec	2 0 0 -11.5 0;
+        sec	3 0 0 -23 0;
+        sec	4 0 0 -34.5 0;
+        sec	5 0 0 -46 0;
+        sec	6 0 0 -57.5 0;
+        sec	7 0 0 -69 0;
+        sec	8 0 0 -80.5 0;
+        sec	9 0 0 -92 0;
+        sec	10 0 0 -103.5 0;
+        sec	11 0 0 -115.63 0;
+      end c2_def;
+    end main_body;
+;
+    begin orientation;
+      begin base;
+        body	tower;
+        inipos	0 0 0;	initial position of node 1
+        body_eulerang	0 0 0;
+      end base;
+;
+    end orientation;
+;-------------------------------------------------------------------------------------------------------------------------------
+    begin constraint;
+;
+      begin fix0;	fixed to ground in translation and rotation of node 1
+        body	tower;
+      end fix0;
+;
+    end constraint;
+;
+  end new_htc_structure;
+;----------------------------------------------------------------------------------------------------------------------------------------------------------------
+exit;

h2lib_tests/test_h2rotor.py

@@ -1,5 +1,5 @@
 import os
-from h2lib._h2lib import H2Lib, MultiH2Lib
+from h2lib._h2lib import H2Lib, MultiH2Lib, H2LibThread
 
 from numpy import testing as npt
 import pytest
@@ -40,7 +40,39 @@ def test_get_bem_grid(h2):
     azi, rad = h2.get_bem_grid()
 
     npt.assert_array_almost_equal(np.roll(np.linspace(-np.pi, np.pi, 17)[1:], 9), azi)
-    npt.assert_array_almost_equal([3.09929662, 11.4350243, 33.76886193, 60.8641887, 82.01217305], rad[::10])
+    npt.assert_array_almost_equal([3.09929662, 11.4350243, 33.76886193, 60.8641887, 82.01217305], rad[::10], 4)
+
+
+def test_mainbody_names(h2: H2LibThread):
+    assert h2.get_mainbody_name_dict() == {'tower': 1, 'towertop': 2, 'shaft': 3, 'hub1': 4, 'hub2': 5, 'hub3': 6,
+                                           'blade1': 7, 'blade2': 8, 'blade3': 9}
+
+
+def test_get_mainbody_position_orientation(h2: H2LibThread):
+    mainbody_coo_nr = 0
+    mb_dict = h2.get_mainbody_name_dict()
+    if 0:
+        ax = plt.figure().add_subplot(projection='3d')
+        for name, mainbody_nr in mb_dict.items():
+            pos, ori = h2.get_mainbody_position_orientation(mainbody_nr, mainbody_coo_nr)
+            ax.plot(*pos, 'o', label=name)
+            for (exyz), c in zip(ori, 'rgb'):
+                ax.plot(*np.array([pos, pos + exyz * 10]).T, color=c)
+        plt.axis('equal')
+        plt.legend()
+        plt.show()
+
+    pos, ori = h2.get_mainbody_position_orientation(mb_dict['blade2'], 0)
+    npt.assert_array_almost_equal(pos, [2.42817657, -7.31388712, -117.62523996], 6)
+    npt.assert_array_almost_equal(ori, [[0.49826649, 0.03782549, 0.86619844],
+                                        [0.07555272, 0.99335333, -0.08683861],
+                                        [-0.86372582, 0.10871241, 0.49209686]], 6)
+
+    pos, ori = h2.get_mainbody_position_orientation(mb_dict['hub2'], 0)
+    npt.assert_array_almost_equal(pos, [-2.42631565e-09, -7.07298239e+00, -1.18998544e+02], 6)
+    npt.assert_array_almost_equal(ori, [[0.49826698, 0.03781904, 0.86619844],
+                                        [0.07556557, 0.99335236, -0.0868386],
+                                        [-0.86372441, 0.10872359, 0.49209687]], 6)
 
 
 def test_induction(h2):

h2lib_tests/test_lin.py

@@ -83,10 +83,7 @@ def test_sys_eig_no_damping_eigv(h2_dtu_10mw_only_blade):
     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.835311, 5.846144, 10.92697, 17.353821]),
-    )
+    npt.assert_allclose(eig_val, [3.835311, 5.846144, 10.92697, 17.353821], atol=2e-6)
 
 
 def test_sys_eig_with_damping(h2_dtu_10mw_only_blade):
@@ -156,29 +153,18 @@ def test_sys_eig_encrypted(h2_dtu_10mw_only_tower_encrypted):
     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(freq, [0.770592, 0.770592, 3.449993, 3.449993], atol=1e-5)
 
     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,
-    )
+    npt.assert_allclose(eig_val, [-0.048444 - 4.84153j,
+                                  -0.048444 - 4.84153j,
+                                  -0.968409 - 21.6553j,
+                                  -0.968409 - 21.6553j], atol=1e-5,
+                        )
 
 
 def test_get_system_matrices_encrypted(h2_dtu_10mw_only_tower_encrypted):

h2lib_tests/test_static_solver.py

@@ -59,70 +59,59 @@ def test_static_solver_run_fail(h2_dtu10mw_only_blade_low_max_iter):
 
 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")
 
     # Run the static solver.
     h2_dtu_10mw_only_blade.solver_static_run(reset_structure=True)
 
-    # Do 1 step to get the output.
-    h2_dtu_10mw_only_blade.step()
-    val = h2_dtu_10mw_only_blade.get_sensor_values(id)
-    # Test against: initial_condition 2; followed by time simulaiton.
+    # Test against: initial_condition 2; followed by time simulation.
+    val = h2_dtu_10mw_only_blade.get_sensor_values((4, 5, 6))
     npt.assert_allclose(
-        val, np.array([-1.072136e04, -3.978756e-02, -4.066154e01]), rtol=1e-6
+        val, np.array([-1.071480e+04, -3.974322e-02, -4.064080e+01]), rtol=1e-6
     )
 
 
 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(reset_structure=True)
 
-    # 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.057846, 383.58397, 991.216685]))
+    val = h2_dtu_10mw_only_blade_rotate_base.get_sensor_values((1, 2, 3))
+    npt.assert_allclose(val, np.array([-5.02001147e+00, 1.87207970e-01, 1.09028022e+03]))
 
 
 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(reset_structure=True)
 
-    # 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.011239, 383.582323, 991.217846]))
+    val = h2_dtu_10mw_only_blade_rotate_relative.get_sensor_values((1, 2, 3))
+    npt.assert_allclose(val, np.array([-5.02001146e+00, 1.87207914e-01, 1.09028022e+03]))
 
 
 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(reset_structure=True)
 
-    # 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([-3097.095312, 115414.360165, 366.321024]))
+    # The static solver does not work with bearing3 and we get 0 load.
+    val = h2_dtu_10mw_only_blade_rotate_bearing3.get_sensor_values((4, 5, 6))
+    npt.assert_allclose(val, np.array([0., 0., 0.]))
+
+    # This is what happens by simulating for a long time.
+    # The simulation must be long because the rotor speed is applied impulsively
+    # and we get a very long initial transient.
+    # h2_dtu_10mw_only_blade_rotate_bearing3.run(500.0)
+    # npt.assert_allclose(h2_dtu_10mw_only_blade_rotate_bearing3.get_sensor_values(id),
+    #                     np.array([-757.65278331,    4.16512026,    6.05878323]))
+    # h2_dtu_10mw_only_blade_rotate_bearing3.run(1000.0)
+    # npt.assert_allclose(h2_dtu_10mw_only_blade_rotate_bearing3.get_sensor_values(id),
+    #                     np.array([-758.77170923,    4.31107218,    6.05914454]))
 
 
 def test_static_solver_run_no_reset(h2_dtu_10mw_only_blade):
@@ -160,34 +149,25 @@ def test_static_solver_run_with_reset(h2_dtu_10mw_only_blade):
     )
 
 
-def test_structure_reset():
-    # Apply centrifugal loading with the base command.
-    # We cannot use h2_dtu_10mw_only_blade_rotate_base because we need to add a sensor,
-    # and this must be done before init.
-
-    with H2Lib(suppress_output=True) as h2:
-        model_path = f"{tfp}DTU_10_MW/"
-        htc_path = "htc/DTU_10MW_RWT_only_blade_rotate_base.htc"
-        id = h2.add_sensor(
-            "mbdy statevec_new blade1 c2def global absolute 85.0 1.0 0.0 0.0"
-        )
-        h2.init(htc_path=htc_path, model_path=model_path)
-        h2.stop_on_error(False)
-
-        # Do 1 step to get the output. This is our reference.
-        h2.step()
-        val_desired = h2.get_sensor_values(id)
-
-        # Run static solver.
-        h2.solver_static_run(reset_structure=False)
-
-        # The deflection must have changed.
-        h2.step()
-        val_actual = h2.get_sensor_values(id)
-        npt.assert_raises(AssertionError, npt.assert_allclose, val_actual, val_desired)
-
-        # Reset the structure and check that we match the reference.
-        h2.structure_reset()
-        h2.step()
-        val_actual = h2.get_sensor_values(id)
-        npt.assert_allclose(val_actual, val_desired)
+def test_structure_reset(h2_dtu10mw_only_blade_high_gravity):
+    h2 = h2_dtu10mw_only_blade_high_gravity
+
+    id = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+    h2.step()
+    val_1 = h2.get_sensor_values(id)
+    h2.solver_static_run(reset_structure=True)
+    val_2 = h2.get_sensor_values(id)
+    h2.structure_reset()
+    h2.step()
+    val_3 = h2.get_sensor_values(id)
+
+    with npt.assert_raises(AssertionError):
+        npt.assert_allclose(val_1, val_2)
+    npt.assert_allclose(val_1, val_3)
+
+
+# %% Main.
+
+if __name__ == "__main__":
+    # pytest.main([__file__])
+    pytest.main([__file__, "-k test_structure_reset"])

h2lib_tests/test_topology_h2lib.py

@@ -108,6 +108,63 @@ def test_get_body_rotation_tensor_encrypted(h2_dtu_10mw_only_tower_encrypted):
         h2_dtu_10mw_only_tower_encrypted.get_body_rotation_tensor(ibdy=0)
 
 
+def test_body_output_mass_body_does_not_exist(h2_dtu_10mw_only_tower):
+    with pytest.raises(IndexError, match="BODY_DOES_NOT_EXIST"):
+        h2_dtu_10mw_only_tower.get_body_rotation_tensor(ibdy=1000)
+
+
+def test_body_output_mass_encrypted(h2_dtu_10mw_only_tower_encrypted):
+    with pytest.raises(RuntimeError, match="STRUCTURE_IS_CONFIDENTIAL"):
+        h2_dtu_10mw_only_tower_encrypted.body_output_mass(ibdy=0)
+
+
+def test_body_output_mass(h2_dtu10mw_only_blade_1_body):
+    body_mass, body_inertia, cog_global_frame, cog_body_frame = h2_dtu10mw_only_blade_1_body.body_output_mass(ibdy=0)
+
+    npt.assert_allclose(body_mass, 41715.74898702217)
+    npt.assert_allclose(
+        body_inertia,
+        np.array(
+            [
+                4.59166245e07,
+                4.59258429e07,
+                1.68059539e05,
+                -5.46069861e03,
+                -1.63069037e05,
+                -8.35539506e05,
+            ]
+        ),
+    )
+    npt.assert_allclose(
+        cog_global_frame, np.array([-0.12113986, -26.17867389, -0.3688314])
+    )
+    npt.assert_allclose(
+        cog_body_frame, np.array([-0.12113986, -0.3688314, 26.17867389])
+    )
+
+
+def test_body_output_element_body_does_not_exist(h2_dtu_10mw_only_tower):
+    with pytest.raises(IndexError, match="BODY_DOES_NOT_EXIST"):
+        h2_dtu_10mw_only_tower.body_output_element(ibdy=1000, ielem=0)
+
+
+def test_body_output_element_element_does_not_exist(h2_dtu_10mw_only_tower):
+    with pytest.raises(IndexError, match="ELEMENT_DOES_NOT_EXIST"):
+        h2_dtu_10mw_only_tower.body_output_element(ibdy=0, ielem=1000)
+
+
+def test_body_output_element_encrypted(h2_dtu_10mw_only_tower_encrypted):
+    with pytest.raises(RuntimeError, match="STRUCTURE_IS_CONFIDENTIAL"):
+        h2_dtu_10mw_only_tower_encrypted.body_output_element(ibdy=0, ielem=0)
+
+
+def test_body_output_element(h2_dtu10mw_only_blade_1_body):
+    mass, stiffness, damping = h2_dtu10mw_only_blade_1_body.body_output_element(ibdy=0, ielem=0)
+    assert mass.shape == (12, 12)
+    assert stiffness.shape == (12, 12)
+    assert damping.shape == (12, 12)
+
+
 def test_set_orientation_base_not_found(h2_dtu_10mw_only_tower):
     with pytest.raises(ValueError, match="MAIN_BODY_NOT_FOUND"):
         h2_dtu_10mw_only_tower.set_orientation_base(main_body="blade")
@@ -157,9 +214,6 @@ def test_set_orientation_base_without_reset_orientation(
 
 
 def test_set_orientation_base_speed(h2_dtu_10mw_only_blade):
-    # Add a sensor for the blade root force, in this case only due to centrifugal force.
-    id = h2_dtu_10mw_only_blade.add_sensor("mbdy forcevec blade1 1 1 blade1")
-
     # Set speed.
     h2_dtu_10mw_only_blade.set_orientation_base(
         main_body="blade1",
@@ -171,11 +225,11 @@ def test_set_orientation_base_speed(h2_dtu_10mw_only_blade):
 
     # Do 1 step to get the output.
     h2_dtu_10mw_only_blade.step()
-    val = h2_dtu_10mw_only_blade.get_sensor_values(id)
+    val = h2_dtu_10mw_only_blade.get_sensor_values((1, 2, 3))
 
     # Test against: result at the time of writing.
     # The result is close, but not identical, to test_static_solver_run_2.
-    npt.assert_allclose(val, np.array([10879.363636, 793.815211, 1034.923463]))
+    npt.assert_allclose(val, [10879.363449, 793.564425, 1034.896613])
 
     # Reset speed.
     h2_dtu_10mw_only_blade.set_orientation_base(
@@ -184,6 +238,241 @@ def test_set_orientation_base_speed(h2_dtu_10mw_only_blade):
     )
 
 
+def test_set_c2_def_main_body_not_found(h2_dtu_10mw_only_blade):
+    with pytest.raises(ValueError, match="MAIN_BODY_NOT_FOUND"):
+        h2_dtu_10mw_only_blade.set_c2_def(
+            "tower",
+            np.array([[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]]),
+        )
+
+
+def test_set_c2_def_too_few_sections(h2_dtu_10mw_only_blade):
+    with pytest.raises(ValueError, match="TOO_FEW_SECTIONS_IN_C2DEF"):
+        h2_dtu_10mw_only_blade.set_c2_def("blade1", np.zeros((1, 4)))
+
+
+def test_set_c2_def_different_nsec(h2_dtu_10mw_only_blade):
+    with pytest.raises(ValueError, match="DIFFERENT_NSEC"):
+        h2_dtu_10mw_only_blade.set_c2_def(
+            "blade1",
+            np.array([[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]]),
+        )
+
+
+def test_set_c2_def_uniform_node_distribution(
+    h2_dtu_10mw_only_blade_uniform_node_distribution,
+):
+    with pytest.raises(
+        NotImplementedError,
+    ):
+        h2_dtu_10mw_only_blade_uniform_node_distribution.set_c2_def(
+            "blade1", np.ones((27, 4), dtype=np.float64, order="F")
+        )
+
+
+def test_set_c2_def_beam_too_short(h2_dtu_10mw_only_blade):
+    c2def = np.zeros((27, 4), dtype=np.float64, order="F")
+    c2def[:, 2] = np.linspace(0.0, 1e-9, c2def.shape[0])
+    with pytest.raises(ValueError, match="BEAM_TOO_SHORT"):
+        h2_dtu_10mw_only_blade.set_c2_def("blade1", c2def)
+
+
+def test_set_c2_def_blade_static_back_to_original(
+    write_dtu10mw_only_blade_high_gravity,
+    h2_dtu10mw_only_blade_high_gravity,
+):
+    # This test will:
+    #  1. Take the DTU 10 MW blade subjected to high gravity loading.
+    #  2. Compute the static solution.
+    #  3. Change c2_def a few times and re-compute the static solution.
+    #  4. Revert it to the original one and check that the static solution matches the one from step 2.
+
+    # Get the clamped DTU 10 MW blade subjected to high gravity loading.
+    _, blade_c2def = write_dtu10mw_only_blade_high_gravity
+    h2 = h2_dtu10mw_only_blade_high_gravity
+
+    # Sensors 1 to 6 are the displacement and rotation of the blade tip.
+    #   h2.get_sensor_info(1)
+
+    # Run the static solver and get the blade tip position and rotation.
+    h2.solver_static_run(reset_structure=True)
+    blade_tip_desired = h2.get_sensor_values((1, 2, 3, 4, 5, 6))
+
+    # Change blade length and run the static solver.
+    c2def_new = blade_c2def.copy()
+    for factor in (0.6, 0.7, 0.8, 0.9, 1.1, 1.2, 1.3, 1.4):
+        c2def_new[:, 2] = factor * blade_c2def[:, 2]
+        h2.set_c2_def("blade1", c2def_new)
+        # Since we are smoothly changing c2_def, it makes sense to start the static solver from the last converged solution.
+        h2.solver_static_run(reset_structure=False)
+
+        # Get new blade displacement.
+        blade_tip_actual = h2.get_sensor_values((1, 2, 3, 4, 5, 6))
+
+        # Must differ from blade_tip_desired.
+        with npt.assert_raises(AssertionError):
+            npt.assert_allclose(blade_tip_actual, blade_tip_desired)
+
+    # Restore blade c2_def.
+    h2.set_c2_def("blade1", blade_c2def)
+    h2.solver_static_run(reset_structure=True)
+    blade_tip_actual = h2.get_sensor_values((1, 2, 3, 4, 5, 6))
+    npt.assert_allclose(blade_tip_actual, blade_tip_desired)
+
+
+def test_set_c2_def_blade_static_deformed(
+    write_dtu10mw_only_blade_high_gravity,
+    write_dtu10mw_only_blade_high_gravity_deformed,
+    h2_dtu10mw_only_blade_high_gravity,
+    h2_dtu10mw_only_blade_high_gravity_deformed,
+):
+    # Solve the static problem with the deformed blade loaded directly by HAWC2.
+    h2_dtu10mw_only_blade_high_gravity_deformed.solver_static_run(reset_structure=True)
+    blade_tip_desired = h2_dtu10mw_only_blade_high_gravity_deformed.get_sensor_values((1, 2, 3, 4, 5, 6))
+
+    # Set c2_def in the original blade, thus making it equivalent to the deformed one.
+    # Then, solve again the static problem.
+    _, c2def_deformed = write_dtu10mw_only_blade_high_gravity_deformed
+    h2_dtu10mw_only_blade_high_gravity.set_c2_def("blade1", c2def_deformed)
+    h2_dtu10mw_only_blade_high_gravity.solver_static_run(reset_structure=True)
+    blade_tip_actual = h2_dtu10mw_only_blade_high_gravity_deformed.get_sensor_values((1, 2, 3, 4, 5, 6))
+
+    npt.assert_allclose(blade_tip_actual, blade_tip_desired)
+
+    # Restore c2_def.
+    _, c2def_original = write_dtu10mw_only_blade_high_gravity
+    h2_dtu10mw_only_blade_high_gravity.set_c2_def("blade1", c2def_original)
+
+
+@pytest.mark.skip(reason="The system eigenanalysis cannot be called more than once.")
+def test_set_c2_def_blade_eig_back_to_original(
+    write_dtu10mw_only_blade_high_gravity,
+    h2_dtu10mw_only_blade_high_gravity,
+):
+    # Get the clamped DTU 10 MW blade.
+    # We use the fixture with high gravity because it also returns c2_def.
+    _, blade_c2def = write_dtu10mw_only_blade_high_gravity
+    h2 = h2_dtu10mw_only_blade_high_gravity
+
+    # Solve the eigenvalue problem.
+    h2.structure_reset()
+    h2.linearize()
+    natural_frequencies_desired, damping_ratios_desired = h2.do_system_eigenanalysis(n_modes=6, include_damping=True)
+
+    # Change blade length and solve again the eigenvalue problem
+    c2def_new = blade_c2def.copy()
+    for factor in (0.6, 0.7, 0.8, 0.9, 1.1, 1.2, 1.3, 1.4):
+        c2def_new[:, 2] = factor * blade_c2def[:, 2]
+        h2.set_c2_def("blade1", c2def_new)
+        h2.structure_reset()
+        h2.linearize()
+        natural_frequencies_actual, damping_ratios_actual = h2.do_system_eigenanalysis(n_modes=6, include_damping=True)
+
+        # Must differ from the desired ones.
+        with npt.assert_raises(AssertionError):
+            npt.assert_allclose(natural_frequencies_actual, natural_frequencies_desired)
+        with npt.assert_raises(AssertionError):
+            npt.assert_allclose(damping_ratios_actual, damping_ratios_desired)
+
+    # Restore blade c2_def.
+    h2.set_c2_def("blade1", blade_c2def)
+    h2.structure_reset()
+    h2.linearize()
+    natural_frequencies_actual, damping_ratios_actual = h2.do_system_eigenanalysis(n_modes=6, include_damping=True)
+    npt.assert_allclose(natural_frequencies_actual, natural_frequencies_desired)
+    npt.assert_allclose(damping_ratios_actual, damping_ratios_desired)
+
+
+def test_set_c2_def_blade_mass_back_to_original(
+    write_dtu10mw_only_blade_high_gravity_1_body,
+    h2_dtu10mw_only_blade_high_gravity_1_body,
+):
+    # Get the clamped DTU 10 MW blade.
+    # We use the fixture with high gravity because it also returns c2_def.
+    _, blade_c2def = write_dtu10mw_only_blade_high_gravity_1_body
+    h2 = h2_dtu10mw_only_blade_high_gravity_1_body
+
+    # Get the inertia properties.
+    h2.structure_reset()
+    inertia_desired = h2.body_output_mass(0)
+
+    # Change blade length and compute inertia properties.
+    c2def_new = blade_c2def.copy()
+    for factor in (0.6, 0.7, 0.8, 0.9, 1.1, 1.2, 1.3, 1.4):
+        c2def_new[:, 2] = factor * blade_c2def[:, 2]
+        h2.set_c2_def("blade1", c2def_new)
+        inertia_actual = h2.body_output_mass(0)
+
+        # Must differ from the desired ones.
+        for i in range(4):  # Loop over tuple of arrays.
+            with npt.assert_raises(AssertionError):
+                npt.assert_allclose(inertia_actual[i], inertia_desired[i])
+
+    # Restore blade c2_def.
+    h2.set_c2_def("blade1", blade_c2def)
+    inertia_actual = h2.body_output_mass(0)
+    for i in range(4):  # Loop over tuple of arrays.
+        npt.assert_allclose(inertia_actual[i], inertia_desired[i])
+
+
+def test_set_c2_def_blade_mass_deformed(
+    write_dtu10mw_only_blade_high_gravity,
+    write_dtu10mw_only_blade_high_gravity_deformed,
+    h2_dtu10mw_only_blade_high_gravity,
+    h2_dtu10mw_only_blade_high_gravity_deformed,
+):
+    # Revert blades to the undeflected configuration.
+    h2_dtu10mw_only_blade_high_gravity.structure_reset()
+    h2_dtu10mw_only_blade_high_gravity_deformed.structure_reset()
+
+    # Set c2_def in the original blade, thus making it equivalent to the deformed one.
+    _, c2def_deformed = write_dtu10mw_only_blade_high_gravity_deformed
+    h2_dtu10mw_only_blade_high_gravity.set_c2_def("blade1", c2def_deformed)
+
+    # Compare inertia properties for all bodies.
+    nbdy, _ = h2_dtu10mw_only_blade_high_gravity_deformed.get_number_of_bodies_and_constraints()
+    for i in range(nbdy):
+        inertia_desired = h2_dtu10mw_only_blade_high_gravity_deformed.body_output_mass(i)
+        inertia_actual = h2_dtu10mw_only_blade_high_gravity.body_output_mass(i)
+
+        for i in range(4):  # Loop over tuple of arrays.
+            npt.assert_allclose(inertia_actual[i], inertia_desired[i], rtol=1e-6)
+
+    # Restore c2_def.
+    _, c2def_original = write_dtu10mw_only_blade_high_gravity
+    h2_dtu10mw_only_blade_high_gravity.set_c2_def("blade1", c2def_original)
+
+
+def test_set_c2_def_blade_element_deformed(
+    write_dtu10mw_only_blade_high_gravity,
+    write_dtu10mw_only_blade_high_gravity_deformed,
+    h2_dtu10mw_only_blade_high_gravity,
+    h2_dtu10mw_only_blade_high_gravity_deformed,
+):
+    # Revert blades to the undeflected configuration.
+    h2_dtu10mw_only_blade_high_gravity.structure_reset()
+    h2_dtu10mw_only_blade_high_gravity_deformed.structure_reset()
+
+    # Set c2_def in the original blade, thus making it equivalent to the deformed one.
+    _, c2def_deformed = write_dtu10mw_only_blade_high_gravity_deformed
+    h2_dtu10mw_only_blade_high_gravity.set_c2_def("blade1", c2def_deformed)
+
+    # Compare element matrices for all bodies.
+    nelem = h2_dtu10mw_only_blade_high_gravity_deformed.get_number_of_elements()
+    for ibdy in range(nelem.size):
+        for ielem in range(nelem[ibdy]):
+            mat_desired = h2_dtu10mw_only_blade_high_gravity_deformed.body_output_element(ibdy, ielem)
+            mat_actual = h2_dtu10mw_only_blade_high_gravity.body_output_element(ibdy, ielem)
+
+            npt.assert_allclose(mat_actual[0], mat_desired[0], rtol=1e-10)  # mass
+            npt.assert_allclose(mat_actual[1], mat_desired[1], rtol=1e-10)  # stiffness
+            npt.assert_allclose(mat_actual[2], mat_desired[2], rtol=1e-10)  # damping
+
+    # Restore c2_def.
+    _, c2def_original = write_dtu10mw_only_blade_high_gravity
+    h2_dtu10mw_only_blade_high_gravity.set_c2_def("blade1", c2def_original)
+
+
 def test_set_orientation_relative_main_body_not_found(
     h2_dtu_10mw_only_blade_rotate_relative,
 ):
@@ -279,11 +568,6 @@ def test_set_orientation_relative_2(
 def test_set_orientation_relative_static(
     h2_dtu_10mw_only_blade_rotate_relative,
 ):
-    # Add a sensor for the blade root force.
-    id = h2_dtu_10mw_only_blade_rotate_relative.add_sensor(
-        "mbdy forcevec blade1 1 1 blade1"
-    )
-
     # Set arbitrary orientation and speed.
     h2_dtu_10mw_only_blade_rotate_relative.set_orientation_relative(
         main_body_1="hub1",
@@ -295,11 +579,13 @@ def test_set_orientation_relative_static(
         mbdy2_ini_rotvec_d1=[0.0, 1.0, 0.0, 0.8],
     )
     # Run static solver.
-    h2_dtu_10mw_only_blade_rotate_relative.solver_static_run(reset_structure=True)
+    h2_dtu_10mw_only_blade_rotate_relative.solver_static_run(
+        reset_structure=True
+    )
 
     # 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)
+    val = h2_dtu_10mw_only_blade_rotate_relative.get_sensor_values((1, 2, 3))
 
     # Test against: result at the time of writing.
     npt.assert_allclose(val, np.array([8702.206018, 306.728782, 640.051269]))
@@ -314,3 +600,10 @@ def test_set_orientation_relative_static(
         reset_orientation=True,
         mbdy2_ini_rotvec_d1=np.array([0.0, 1.0, 0.0, 1.0]),
     )
+
+
+# %% Main.
+
+if __name__ == "__main__":
+    # pytest.main([__file__])
+    pytest.main([__file__, "-k test_set_c2_def_blade_element_deformed"])

{h2lib_tests-13.1.3110.dist-info → h2lib_tests-13.2.701.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: h2lib-tests
-Version: 13.1.3110
-Summary: Tests and test_files for test h2lib (13.1.31+5-g08eea40)
+Version: 13.2.701
+Summary: Tests and test_files for test h2lib (13.2.7+4-gb779ee7)
 Download-URL: 
 Author: Mads M Pedersen
 Author-email: 

{h2lib_tests-13.1.3110.dist-info → h2lib_tests-13.2.701.dist-info}/RECORD

@@ -1,15 +1,16 @@
 h2lib_tests/__init__.py,sha256=VjSqfGg8BzdmSjfSFhJh4hZbYZ_cME7xp9EWFKHQphA,61
-h2lib_tests/conftest.py,sha256=DAxRUsOP7-3-JUTglMSuyr1qcsdrqeKEDerEtenL0lA,14753
+h2lib_tests/conftest.py,sha256=o9bkMEaB40rr_KSGovy1nuvq2Y09rKfQWxTcTGZ0MfY,21607
 h2lib_tests/dtu10mw.py,sha256=a7SXfyDwDQPastYKb5CgghOQcYfgO1eTwGrd-H3Enok,4374
 h2lib_tests/test_calc.py,sha256=VNLfr2J9R2Jy9xTbdZ9dfbQ4dCwr7H7nbZRI3yP69fQ,2152
-h2lib_tests/test_ellipsys_couplings.py,sha256=JLos66l_zNDBY6glxwqSfDa6p0Uko5aRKAckh2uoSSM,3302
+h2lib_tests/test_distributed_sections.py,sha256=JtguIddd2nmRyNsy2jqjPFB8E5cGpH2_IVErP1wGPPg,5432
+h2lib_tests/test_ellipsys_couplings.py,sha256=mfSTk1IamaKETU6Be8p8W9vA-yostWJl17m5sFlEK3Q,3345
 h2lib_tests/test_h2lib.py,sha256=LEV1n0Fwa1llQwIM06Mcqr07Y6WOn-j8mNxjzlCEOl0,14219
-h2lib_tests/test_h2rotor.py,sha256=4P5bUGvwYDl8Z9hVNP_SXKa79DWhsA-ptpp0v0rT9ow,11309
-h2lib_tests/test_lin.py,sha256=KujYIy9YXTo-uxi_umRWIWZwcHu0oH8GyeVgMcMCq0o,6383
+h2lib_tests/test_h2rotor.py,sha256=yAcG9RDD3uO4g4w8LJnJ3Md_bC-_mBn1--4KHwvlTRc,12963
+h2lib_tests/test_lin.py,sha256=yydbsMX44ym_MSqR1cbQkqil8qC4icSW_JccPSElGac,6292
 h2lib_tests/test_mpi.py,sha256=CTT160yc6uZFRr_QNFWxyOwJ-y0qHiIp8jPYs1MQpyg,7111
 h2lib_tests/test_multiprocessinterface.py,sha256=h2o4havtK6IuMXsplNjGUa3VxOnbpEYGxdrrAKQilj0,1470
-h2lib_tests/test_static_solver.py,sha256=ckzcBAuVge5V5tdrac4PPYxrH5TheNTUc3PKksbB89A,7426
-h2lib_tests/test_topology_h2lib.py,sha256=U1NOREhoJ9m7cYxb8sLsVuKSHRqjkEde6hoyl88IF4A,11486
+h2lib_tests/test_static_solver.py,sha256=IuUkKrEoz_EKLCmGQ94CLFgjKPvO20iVx4773JTKO-8,6503
+h2lib_tests/test_topology_h2lib.py,sha256=7ZfVjEUYBJacPcFCDi_Qb0LqW6W-0no_zTBUKbNcKQw,23858
 h2lib_tests/test_files/__init__.py,sha256=9e6ZUPb42e0wf2E1rutdcTM8hROcWFRVPXtZriU3ySw,50
 h2lib_tests/test_files/my_test_cls.py,sha256=7ZDsFkxrLfOY6q00U5Y-daxfuhATK-K5H04RP-VmQdE,850
 h2lib_tests/test_files/DTU_10_MW/control/dtu_we_controller.dll,sha256=C5T_CuAFtIuDgCXSYAoNu24yKPwj2nWOeORacJbLN9s,1134592
@@ -44,6 +45,7 @@ h2lib_tests/test_files/DTU_10_MW/htc/DTU_10MW_RWT.htc,sha256=gBDcGmlmm9UWpYE1fvq
 h2lib_tests/test_files/DTU_10_MW/htc/DTU_10MW_RWT_mann_turb.htc,sha256=-jFK-ra64GeY3fQrP8FxeZ25DkQMdS8yQ9sO78SS9G8,32006
 h2lib_tests/test_files/DTU_10_MW/htc/DTU_10MW_RWT_no_aerodrag.htc,sha256=ELZNcQWlUdOsfSFq9iryvolbYgu5sd241lTfnyD8cS4,31705
 h2lib_tests/test_files/DTU_10_MW/htc/DTU_10MW_RWT_no_output.htc,sha256=PxkaacH8iVp0ewk6x8fIjkITPUkiVar5bxZCWqZSoP4,25887
+h2lib_tests/test_files/DTU_10_MW/htc/DTU_10MW_RWT_only_tower.htc,sha256=xUOj-miknjkFyUz7plPaVqbU9RtYsI-BMLqQi7peV7Y,2744
 h2lib_tests/test_files/DTU_10_MW/htc/DTU_10MW_RWT_yaw_acturator.htc,sha256=WMxUTE_EJo39AjPfNm3zhjNkSyGli-qwcc0GRauTkw4,33790
 h2lib_tests/test_files/IEA-15-240-RWT/IEA_15MW_RWT_Blade_st_FPM.st,sha256=ytwFSx1cFSF25vZ8WZpYFiV2aL3DTvetPrR7oEqFYpc,16605
 h2lib_tests/test_files/IEA-15-240-RWT/IEA_15MW_RWT_Blade_st_noFPM.st,sha256=Pdb8rfJoV7zOAmbPn_xUyGgQk-xIjQ5fCZPRzsu9Q-M,20945
@@ -89,7 +91,7 @@ h2lib_tests/test_files/minimal/res/minimal_mann_turb.hdf5,sha256=Q3cs3bZyplZjBpo
 h2lib_tests/test_files/minimal/turb/hawc2_mann_l33.6_ae0.1000_g3.9_h0_512xd32xd16_2.000x3.00x4.00_s0001_u,sha256=byiorJmXDL6uKFbyfXthHTjJdm6ELvLR2lS202KrhRI,1048576
 h2lib_tests/test_files/minimal/turb/hawc2_mann_l33.6_ae0.1000_g3.9_h0_512xd32xd16_2.000x3.00x4.00_s0001_v,sha256=cxK5Rfgfm3gyJsEYi_KlmYY8DIIl_G0aizN2jt18Glc,1048576
 h2lib_tests/test_files/minimal/turb/hawc2_mann_l33.6_ae0.1000_g3.9_h0_512xd32xd16_2.000x3.00x4.00_s0001_w,sha256=xs61jAwhP3fIR1P5Oa8ovEt2baLoF8uCNs6pKIT8L4o,1048576
-h2lib_tests-13.1.3110.dist-info/METADATA,sha256=esLhRzsDvVKIahBKUL2MZfrRSBVBKWpvq4Cw8kyhHlw,419
-h2lib_tests-13.1.3110.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-h2lib_tests-13.1.3110.dist-info/top_level.txt,sha256=WufAL3LO35YJBhWg1AfgTjSld-6l_WuRkXAkNKczUrM,12
-h2lib_tests-13.1.3110.dist-info/RECORD,,
+h2lib_tests-13.2.701.dist-info/METADATA,sha256=-mXXeU5VEAY9tlTcDTGdIrr3YjPISLCZsZpFATvR-cg,417
+h2lib_tests-13.2.701.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+h2lib_tests-13.2.701.dist-info/top_level.txt,sha256=WufAL3LO35YJBhWg1AfgTjSld-6l_WuRkXAkNKczUrM,12
+h2lib_tests-13.2.701.dist-info/RECORD,,