# -*- coding: utf-8 -*-
import pytest
from pyleecan.Classes.Segment import Segment
from pyleecan.Classes.SlotW29 import SlotW29
from numpy import ndarray, arcsin, exp
from pyleecan.Classes.LamSlot import LamSlot
from pyleecan.Classes.Slot import Slot
# For AlmostEqual
DELTA = 1e-4
slotW29_test = list()
# Internal Slot
lam = LamSlot(is_internal=True, Rext=0.1325)
lam.slot = SlotW29(H0=1e-3, H1=1.5e-3, H2=30e-3, W0=12e-3, W1=14e-3, W2=20e-3)
slotW29_test.append(
{
"test_obj": lam,
"S_exp": 6.340874e-4,
"Ao": 0.10004,
"Aw": 0.174118,
"SW_exp": 6e-4,
"H_exp": 3.26359e-2,
}
)
# External Slot
lam = LamSlot(is_internal=False, Rint=0.1325)
lam.slot = SlotW29(H0=1e-3, H1=1.5e-3, H2=30e-3, W0=12e-3, W1=14e-3, W2=20e-3)
slotW29_test.append(
{
"test_obj": lam,
"S_exp": 6.31912e-4,
"Ao": 0.10004,
"Aw": 0.133185,
"SW_exp": 6e-4,
"H_exp": 3.2667e-2,
}
)
[docs]class Test_SlotW29_meth(object):
"""pytest for SlotW29 methods"""
[docs] @pytest.mark.parametrize("test_dict", slotW29_test)
def test_schematics(self, test_dict):
"""Check that the schematics is correct"""
test_obj = test_dict["test_obj"]
point_dict = test_obj.slot._comp_point_coordinate()
# Check width
assert abs(point_dict["Z1"] - point_dict["Z12"]) == pytest.approx(
test_obj.slot.W0
)
assert abs(point_dict["Z2"] - point_dict["Z11"]) == pytest.approx(
test_obj.slot.W0
)
assert abs(point_dict["Z3"] - point_dict["Z10"]) == pytest.approx(
test_obj.slot.W1
)
assert abs(point_dict["Z4"] - point_dict["Z9"]) == pytest.approx(
test_obj.slot.W1
)
assert abs(point_dict["Z5"] - point_dict["Z8"]) == pytest.approx(
test_obj.slot.W2
)
assert abs(point_dict["Z6"] - point_dict["Z7"]) == pytest.approx(
test_obj.slot.W2
)
# Check height
assert abs(point_dict["Z1"] - point_dict["Z2"]) == pytest.approx(
test_obj.slot.H0
)
assert abs(point_dict["Z3"] - point_dict["Z4"]) == pytest.approx(
test_obj.slot.H1
)
assert abs(point_dict["Z5"] - point_dict["Z6"]) == pytest.approx(
test_obj.slot.H2
)
assert abs(point_dict["Z12"] - point_dict["Z11"]) == pytest.approx(
test_obj.slot.H0
)
assert abs(point_dict["Z10"] - point_dict["Z9"]) == pytest.approx(
test_obj.slot.H1
)
assert abs(point_dict["Z7"] - point_dict["Z8"]) == pytest.approx(
test_obj.slot.H2
)
[docs] @pytest.mark.parametrize("test_dict", slotW29_test)
def test_build_geometry_active(self, test_dict):
"""Check that the computation of the average angle is correct"""
test_obj = test_dict["test_obj"]
surf_list = test_obj.slot.build_geometry_active(Nrad=3, Ntan=2)
# Check label
assert surf_list[0].label == "Wind_Stator_R0_T0_S0"
assert surf_list[1].label == "Wind_Stator_R1_T0_S0"
assert surf_list[2].label == "Wind_Stator_R2_T0_S0"
assert surf_list[3].label == "Wind_Stator_R0_T1_S0"
assert surf_list[4].label == "Wind_Stator_R1_T1_S0"
assert surf_list[5].label == "Wind_Stator_R2_T1_S0"
# Check tangential position
assert surf_list[0].point_ref.imag < 0
assert surf_list[1].point_ref.imag < 0
assert surf_list[2].point_ref.imag < 0
assert surf_list[3].point_ref.imag > 0
assert surf_list[4].point_ref.imag > 0
assert surf_list[5].point_ref.imag > 0
# Check radial position
if test_obj.is_internal:
# Tan=0
assert surf_list[0].point_ref.real > surf_list[1].point_ref.real
assert surf_list[1].point_ref.real > surf_list[2].point_ref.real
# Tan=1
assert surf_list[3].point_ref.real > surf_list[4].point_ref.real
assert surf_list[4].point_ref.real > surf_list[5].point_ref.real
else:
# Tan=0
assert surf_list[0].point_ref.real < surf_list[1].point_ref.real
assert surf_list[1].point_ref.real < surf_list[2].point_ref.real
# Tan=1
assert surf_list[3].point_ref.real < surf_list[4].point_ref.real
assert surf_list[4].point_ref.real < surf_list[5].point_ref.real
[docs] @pytest.mark.parametrize("test_dict", slotW29_test)
def test_comp_surface(self, test_dict):
"""Check that the computation of the surface is correct"""
test_obj = test_dict["test_obj"]
result = test_obj.slot.comp_surface()
a = result
b = test_dict["S_exp"]
msg = "Return " + str(a) + " expected " + str(b)
assert abs((a - b) / a - 0) < DELTA, msg
# Check that the analytical method returns the same result as the numerical one
b = Slot.comp_surface(test_obj.slot)
msg = "Return " + str(a) + " expected " + str(b)
assert abs((a - b) / a - 0) < DELTA, msg
[docs] @pytest.mark.parametrize("test_dict", slotW29_test)
def test_comp_surface_active(self, test_dict):
"""Check that the computation of the winding surface is correct"""
test_obj = test_dict["test_obj"]
result = test_obj.slot.comp_surface_active()
a = result
b = test_dict["SW_exp"]
msg = "Return " + str(a) + " expected " + str(b)
assert abs((a - b) / a - 0) < DELTA, msg
# Check that the analytical method returns the same result as the numerical one
b = Slot.comp_surface_active(test_obj.slot)
msg = "Return " + str(a) + " expected " + str(b)
assert abs((a - b) / a - 0) < DELTA, msg
[docs] @pytest.mark.parametrize("test_dict", slotW29_test)
def test_comp_height(self, test_dict):
"""Check that the computation of the height is correct"""
test_obj = test_dict["test_obj"]
result = test_obj.slot.comp_height()
a = result
b = test_dict["H_exp"]
msg = "Return " + str(a) + " expected " + str(b)
assert abs((a - b) / a - 0) < DELTA, msg
# Check that the analytical method returns the same result as the numerical one
b = Slot.comp_height(test_obj.slot)
msg = "Return " + str(a) + " expected " + str(b)
assert abs((a - b) / a - 0) < DELTA, msg
[docs] @pytest.mark.parametrize("test_dict", slotW29_test)
def test_comp_angle_opening(self, test_dict):
"""Check that the computation of the average opening angle iscorrect"""
test_obj = test_dict["test_obj"]
a = test_obj.slot.comp_angle_opening()
assert a == 2 * arcsin(test_obj.slot.W0 / (2 * 0.1325))
# Check that the analytical method returns the same result as the numerical one
b = Slot.comp_angle_opening(test_obj.slot)
msg = "Return " + str(a) + " expected " + str(b)
assert abs((a - b) / a - 0) < DELTA, msg
[docs] @pytest.mark.parametrize("test_dict", slotW29_test)
def test_comp_angle_active_eq(self, test_dict):
"""Check that the computation of the average angle is correct"""
test_obj = test_dict["test_obj"]
result = test_obj.slot.comp_angle_active_eq()
a = result
b = test_dict["Aw"]
msg = "Return " + str(a) + " expected " + str(b)
assert abs((a - b) / a - 0) < DELTA, msg
[docs] def test_build_geometry(self):
"""check that curve_list is correct"""
test_obj = LamSlot(is_internal=False, Rint=1)
test_obj.slot = SlotW29(W0=0.2, H0=0.1, W1=0.4, H1=0.1, H2=0.6, W2=0.6)
# Rbo=1
Z1 = exp(1j * float(arcsin(0.1)))
Z2 = Z1 + 0.1
Z3 = Z1 + 0.1 + 0.1j
Z4 = Z1 + 0.2 + 0.1j
Z5 = Z1 + 0.2 + 0.2j
Z6 = Z1 + 0.8 + 0.2j
Z7 = Z1 + 0.8 - 0.4j
Z8 = Z1 + 0.2 - 0.4j
Z9 = Z1 + 0.2 - 0.3j
Z10 = Z1 + 0.1 - 0.3j
Z11 = Z1 + 0.1 - 0.2j
Z12 = Z1 - 0.2j
[Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8, Z9, Z10, Z11, Z12] = [
Z12,
Z11,
Z10,
Z9,
Z8,
Z7,
Z6,
Z5,
Z4,
Z3,
Z2,
Z1,
]
curve_list = list()
curve_list.append(Segment(Z1, Z2))
curve_list.append(Segment(Z2, Z3))
curve_list.append(Segment(Z3, Z4))
curve_list.append(Segment(Z4, Z5))
curve_list.append(Segment(Z5, Z6))
curve_list.append(Segment(Z6, Z7))
curve_list.append(Segment(Z7, Z8))
curve_list.append(Segment(Z8, Z9))
curve_list.append(Segment(Z9, Z10))
curve_list.append(Segment(Z10, Z11))
curve_list.append(Segment(Z11, Z12))
result = test_obj.slot.build_geometry()
assert len(result) == len(curve_list)
for i in range(0, len(result)):
a = result[i].begin
b = curve_list[i].begin
assert abs((a - b) / a - 0) < DELTA, (
"Wrong build_geo (for begin point "
+ str(i)
+ " returned "
+ str(a)
+ ", expected "
+ str(b)
+ ")"
)
a = result[i].end
b = curve_list[i].end
assert abs((a - b) / a - 0) < DELTA, (
"Wrong build_geo (for end point "
+ str(i)
+ " returned "
+ str(a)
+ ", expected "
+ str(b)
+ ")"
)
[docs] def test_get_surface_active(self):
"""Check that the get_surface_active works when stator = false"""
lam = LamSlot(is_internal=True, Rext=0.1325, is_stator=False)
lam.slot = SlotW29(H0=1e-3, H1=1.5e-3, H2=30e-3, W0=12e-3, W1=14e-3, W2=20e-3)
result = lam.slot.get_surface_active()
assert result.label == "Wind_Rotor_R0_T0_S0"
assert len(result.get_lines()) == 6
