def split_half(self, is_begin=True):
"""Cut the line in half (modify the object Arc3 => Arc2)
Parameters
----------
self : Arc3
An Arc3 object
is_begin : bool
True to keep the part begin=>middle, False for the part middle=>end
Returns
-------
"""
if self.is_trigo_direction:
sign = 1
else:
sign = -1
if is_begin:
arc = Arc2(begin=self.begin,
center=self.get_center(),
angle=sign * pi / 2)
else:
arc = Arc2(begin=self.get_middle(),
center=self.get_center(),
angle=sign * pi / 2)
# Change the object type from Arc3 => Arc2
self.__class__ = Arc2
self.__dict__.update(arc.__dict__)
def test_comp_radius(self):
"""Check that the radius is correct
"""
test_obj = Arc2(1, 0, pi / 2)
result = test_obj.comp_radius()
self.assertAlmostEqual(result, 1)
test_obj = Arc2(2 * exp(1j * 3 * pi / 4), 0, -pi / 2)
result = test_obj.comp_radius()
self.assertAlmostEqual(result, 2)
def build_geometry(self):
"""Compute the curve (Segment) needed to plot the object.
The ending point of a curve is the starting point of the next curve in
the list
Parameters
----------
self : SlotW22
A SlotW22 object
Returns
-------
curve_list: llist
A list of 5 Segment and 3 Arc2
"""
Rbo = self.get_Rbo()
# comp point coordinate (in complex)
Z1 = Rbo * exp(-1j * self.W0 / 2)
if self.is_outwards():
R1 = Rbo + self.H0
R2 = Rbo + self.H0 + self.H2
else: # inward slot
R1 = Rbo - self.H0
R2 = Rbo - self.H0 - self.H2
Z2 = R1 * exp(-1j * self.W0 / 2.0)
Z3 = R1 * exp(-1j * self.W2 / 2.0)
Z4 = R2 * exp(-1j * self.W2 / 2.0)
# symetry
Z5 = Z4.conjugate()
Z6 = Z3.conjugate()
Z7 = Z2.conjugate()
Z8 = Z1.conjugate()
Zc = 0
# Creation of curve
curve_list = list()
if self.H0 > 0:
curve_list.append(Segment(Z1, Z2))
if self.W2 != self.W0:
curve_list.append(Arc2(Z2, Zc, -(self.W2 - self.W0) / 2))
curve_list.append(Segment(Z3, Z4))
curve_list.append(Arc2(Z4, Zc, self.W2))
curve_list.append(Segment(Z5, Z6))
if self.W2 != self.W0:
curve_list.append(Arc2(Z6, Zc, -(self.W2 - self.W0) / 2))
if self.H0 > 0:
curve_list.append(Segment(Z7, Z8))
return curve_list
def test_build_geometry(self):
"""check that curve_list is correct"""
test_obj = SlotW22(W0=pi / 10, H0=0.1, W2=pi / 5, H2=0.1)
lam = LamSlot(is_internal=False, slot=test_obj, Rint=1)
Z1 = cos(pi / 20) + 1j * sin(pi / 20)
Z2 = 1.1 * (cos(pi / 20) + 1j * sin(pi / 20))
Z3 = 1.1 * (cos(pi / 10) + 1j * sin(pi / 10))
Z4 = 1.2 * (cos(pi / 10) + 1j * sin(pi / 10))
Z5 = 1.2 * (cos(pi / 10) - 1j * sin(pi / 10))
Z6 = 1.1 * (cos(pi / 10) - 1j * sin(pi / 10))
Z7 = 1.1 * (cos(pi / 20) - 1j * sin(pi / 20))
Z8 = cos(pi / 20) - 1j * sin(pi / 20)
[Z8, Z7, Z6, Z5, Z4, Z3, Z2, Z1] = [Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8]
# Creation of curve
curve_list = list()
Zc = 0 # center
curve_list.append(Segment(Z1, Z2))
curve_list.append(Arc2(Z2, Zc, -pi / 20))
curve_list.append(Segment(Z3, Z4))
curve_list.append(Arc2(Z4, Zc, pi / 5))
curve_list.append(Segment(Z5, Z6))
curve_list.append(Arc2(Z6, Zc, -pi / 20))
curve_list.append(Segment(Z7, Z8))
result = test_obj.build_geometry()
self.assertEqual(len(result), len(curve_list))
for i in range(0, len(result)):
if isinstance(result[i], Segment):
a = result[i].begin
b = curve_list[i].begin
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
a = result[i].end
b = curve_list[i].end
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
else: # Arc2
a = result[i].begin
b = curve_list[i].begin
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
a = result[i].center
b = curve_list[i].center
self.assertAlmostEqual(a, b)
a = result[i].angle
b = curve_list[i].angle
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
def build_geometry(self):
"""Compute the curve needed to plot the object.
The ending point of a curve is the starting point of the next curve in
the list
Parameters
----------
self : SlotW24
A SlotW24 object
Returns
-------
curve_list: list
A list of 2 Segment and 1 Arc
"""
(alpha_0, alpha_2) = self.comp_alphas()
[Z1, Z2, Z3, Z4] = self._comp_point_coordinate()
Zc = 0
# Creation of curve
curve_list = list()
curve_list.append(Segment(Z1, Z2))
curve_list.append(Arc2(Z2, Zc, alpha_2))
curve_list.append(Segment(Z3, Z4))
return curve_list
def test_comp_length(self, test_dict):
"""Check that you the length return by comp_length is correct
"""
arc = Arc2(test_dict["begin"], test_dict["center"], test_dict["angle"])
a = float(arc.comp_length())
b = float(test_dict["length"])
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
def test_get_end(self):
"""Check that the end is correct
"""
test_obj = Arc2(1, 0, pi / 2)
result = test_obj.get_end()
self.assertEqual(result, 1 * exp(1j * pi / 2))
test_obj = Arc2(0, 1, -pi / 2)
result = test_obj.get_end()
a = abs(result)
b = 1.414213
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
a = angle(result)
b = pi / 4
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
def test_get_angle(self, test_dict):
"""Check that the arc2 computed angle is correct
"""
arc = Arc2(
begin=test_dict["begin"],
center=test_dict["center"],
angle=test_dict["angle"],
)
result = arc.get_angle(test_dict["is_deg"])
self.assertAlmostEqual(result, test_dict["exp_angle"])
def test_get_middle(self, test_dict):
"""Check that the middle is computed correctly
"""
arc = Arc2(
begin=test_dict["begin"],
center=test_dict["center"],
angle=test_dict["angle"],
)
result = arc.get_middle()
self.assertAlmostEqual(abs(result - test_dict["expect"]), 0, delta=1e-3)
def build_geometry(self):
"""Compute the curve (Line) needed to plot the Slot.
The ending point of a curve is always the starting point of the next
curve in the list
Parameters
----------
self : SlotMPolar
A SlotMPolar object
Returns
-------
curve_list: list
A list of 2 Segment and 1 Arc1
"""
Rbo = self.get_Rbo()
alpha = self.comp_angle_opening()
alpha_mag = self.comp_angle_opening_magnet()
# Point coordinate for a slot center on Ox
Z1 = Rbo * exp(-1j * alpha_mag / 2)
Z2 = Rbo * exp(1j * alpha_mag / 2)
if self.is_outwards():
Rbot = Rbo + self.H0
else:
Rbot = Rbo - self.H0
Z3 = Rbot * exp(-1j * alpha_mag / 2)
Z4 = Rbot * exp(1j * alpha_mag / 2)
# Curve list of a single slot
curve_list = list()
if self.H0 > 0:
curve_list.append(Segment(Z1, Z3))
curve_list.append(Arc1(Z3, Z4, Rbot))
if self.H0 > 0:
curve_list.append(Segment(Z4, Z2))
# Complete curve list for all the slots (for one pole)
slot_list = list()
for ii in range(len(self.magnet)):
# Compute angle of the middle of the slot
beta = -alpha / 2 + alpha_mag / 2 + ii * (self.W3 + alpha_mag)
# Duplicate and rotate the slot + bore for each slot
for line in curve_list:
new_line = type(line)(init_dict=line.as_dict())
new_line.rotate(beta)
slot_list.append(new_line)
if ii != len(self.magnet) - 1: # Add the W3 except for the last slot
slot_list.append(Arc2(slot_list[-1].get_end(), 0, self.W3))
return slot_list
def test_split_half(self, test_dict):
"""Check that the arc2 split is correct
"""
arc = Arc2(
begin=test_dict["begin"],
center=test_dict["center"],
angle=test_dict["angle"],
)
arc.split_half(is_begin=test_dict["is_begin"])
self.assertAlmostEqual(arc.begin, test_dict["N_begin"])
self.assertAlmostEqual(arc.center, test_dict["N_center"])
self.assertAlmostEqual(arc.angle, test_dict["N_angle"])
def test_dicretize(self, test_dict):
"""Check that you can discretize an arc2
"""
arc = Arc2(test_dict["begin"], test_dict["center"], test_dict["angle"])
result = arc.discretize(test_dict["nb_point"])
self.assertEqual(result.size, test_dict["result"].size)
for i in range(0, result.size):
a = result[i]
b = test_dict["result"][i]
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
def test_translate(self, test_dict):
"""Check that you can translate the arc2
"""
arc = Arc2(
begin=test_dict["begin"],
center=test_dict["center"],
angle=test_dict["angle"],
)
expect_angle = arc.angle
arc.translate(test_dict["delta"])
self.assertAlmostEqual(abs(test_dict["exp_begin"] - arc.begin), 0)
self.assertAlmostEqual(abs(expect_angle - arc.angle), 0)
self.assertAlmostEqual(abs(test_dict["exp_center"] - arc.center), 0)
def test_translate(self):
"""Check that you can rotate the surface
"""
line1 = Arc1(begin=1, end=1j, radius=1)
line2 = Arc2(begin=1, center=0, angle=pi / 2)
line3 = Segment(begin=1j, end=0)
surface = SurfLine(line_list=[line1, line2, line3],
label="test",
point_ref=0)
surface.translate(1j)
self.assertAlmostEqual(abs(line1.begin - 1j), 1)
self.assertAlmostEqual(line1.end, 2j)
self.assertAlmostEqual(abs(line2.begin - 1j), 1)
self.assertAlmostEqual(abs(line2.center - 1j), 0)
self.assertAlmostEqual(abs(line3.begin - 2j), 0)
self.assertAlmostEqual(line3.end, 1j)
def test_comp_length(self):
"""Check that you can compute the length of the Surface
"""
line1 = Arc1(begin=1, end=1j, radius=1)
line1.comp_length = MagicMock(return_value=1)
line2 = Arc2(begin=1, center=0, angle=pi / 2)
line2.comp_length = MagicMock(return_value=1)
line3 = Segment(begin=1j, end=0)
line3.comp_length = MagicMock(return_value=1)
surface = SurfLine(line_list=[line1, line2, line3],
label="test",
point_ref=0)
length = surface.comp_length()
line1.comp_length.assert_called_once()
line2.comp_length.assert_called_once()
line3.comp_length.assert_called_once()
self.assertAlmostEqual(abs(length - 3), 0)
def test_comp_length_Point_error(self):
"""Check that comp_length can detect a one point arc2
"""
arc = Arc2(0, 0, 2)
with self.assertRaises(PointArc2Error):
arc.comp_length()
def test_check_Point(self):
"""Check that you can detect a one point arc"""
arc = Arc2(0, 0, 1)
with self.assertRaises(PointArc2Error):
arc.check()
], # Expected intersection points
"Zs_top": [
Arc1(
begin=-1j + 3 * exp(1j * pi / 4),
end=-1j + 3 * exp(1j * 3 * pi / 4),
radius=3,
is_trigo_direction=True,
)
], # Expected result for slip is_top
"Zs_bot": [], # Expected result for slip not is_top
}
)
# 14) Arc2, 1 Intersection
split_test.append(
{
"arc": Arc2(begin=1j, center=0, angle=pi), # Arc to split
"Z1": -3, # First point of cutting line
"Z2": 1, # Second point of cutting line
"center": 0, # Center of the arc (should not be changed by the split)
"Zi": [-1], # Expected intersection points
"Zs_top": [
Arc1(begin=1j, end=-1, radius=1, is_trigo_direction=True)
], # Expected result for slip is_top
"Zs_bot": [
Arc1(begin=-1, end=-1j, radius=1, is_trigo_direction=True)
], # Expected result for slip not is_top
}
)
# 15) Case 14 with angle = -angle
split_test.append(
{
def test_check_Angle(self):
"""Check that you can detect null angle"""
arc = Arc2(0, 1, 0)
with self.assertRaises(AngleArc2Error):
arc.check()
def test_get_center(self):
"""Check that the center is returned correctly
"""
test_obj = Arc2(1, 1 + 1j, pi)
result = test_obj.get_center()
self.assertEqual(result, 1 + 1j)
def build_geometry_wind(self,
Nrad,
Ntan,
is_simplified=False,
alpha=0,
delta=0):
"""Split the slot winding area in several zone
Parameters
----------
self : SlotW23
A SlotW23 object
Nrad : int
Number of radial layer
Ntan : int
Number of tangentiel layer
is_simplified : bool
boolean to specify if coincident lines are considered as one or different lines (Default value = False)
alpha : float
Angle for rotation (Default value = 0) [rad]
delta : Complex
complex for translation (Default value = 0)
Returns
-------
surf_list:
List of surface delimiting the winding zone
"""
if self.get_is_stator(): # check if the slot is on the stator
st = "S"
else:
st = "R"
[Z8, Z7, Z6, Z5, Z4, Z3, Z2, Z1] = self._comp_point_coordinate()
X = linspace(Z6, Z5, Nrad + 1)
# Nrad+1 and Ntan+1 because 3 points => 2 zones
Z = zeros((Nrad + 1, Ntan + 1), dtype=complex)
for ii in range(Nrad + 1):
Z[ii][:] = linspace(X[ii], X[ii].conjugate(), Ntan + 1)
# The bottom and top are Arc and not a line
Z[0][:] = abs(Z6) * exp(1j * linspace(angle(Z6), angle(Z3), Ntan + 1))
Z[Nrad][:] = abs(Z5) * exp(1j * linspace(angle(Z5), angle(Z4), Ntan + 1))
assert abs(Z[0][0] - Z6) < 1e-6
assert abs(Z[Nrad][0] - Z5) < 1e-6
assert abs(Z[0][Ntan] - Z3) < 1e-6
assert abs(Z[Nrad][Ntan] - Z4) < 1e-6
Zc = 0 # Center of the machine
# We go thought the zone by Rad then Tan, starting by (0,0)
surf_list = list()
for jj in range(Ntan): # jj from 0 to Ntan-1
for ii in range(Nrad): # ii from 0 to Nrad-1
Z1 = Z[ii][jj]
Z2 = Z[ii][jj + 1]
Z3 = Z[ii + 1][jj + 1]
Z4 = Z[ii + 1][jj]
point_ref = (Z1 + Z2 + Z3 + Z4) / 4
# With one zone the order would be [Z6,Z3,Z4,Z5]
if is_simplified: # No doubling Line allowed
curve_list = list()
if ii == 0:
curve_list.append(Segment(Z1, Z2))
if jj != Ntan - 1:
curve_list.append(Segment(Z2, Z3))
if ii != Nrad - 1:
curve_list.append(Segment(Z3, Z4))
surface = SurfLine(
line_list=curve_list,
label="Wind" + st + "_R" + str(ii) + "_T" + str(jj) +
"_S0",
point_ref=point_ref,
)
surf_list.append(surface)
else:
curve_list = list()
curve_list.append(Segment(Z1, Z2))
curve_list.append(Segment(Z2, Z3))
if ii == Nrad - 1: # Top zone
curve_list.append(Arc2(Z3, Zc, angle(Z4) - angle(Z3)))
else:
curve_list.append(Segment(Z3, Z4))
curve_list.append(Segment(Z4, Z1))
surface = SurfLine(
line_list=curve_list,
label="Wind" + st + "_R" + str(ii) + "_T" + str(jj) +
"_S0",
point_ref=point_ref,
)
surf_list.append(surface)
for surf in surf_list:
surf.rotate(alpha)
surf.translate(delta)
return surf_list
def test_discretize_Nb_Type_error(self):
"""Check that discretize can detect a wrong arg
"""
arc = Arc2(0, 1, 1)
with self.assertRaises(NbPointArc2DError):
arc.discretize("test")
def test_discretize_Angle_error(self):
"""Check that discretize can detect a null angle arc2
"""
arc = Arc2(0, 1, 0)
with self.assertRaises(AngleArc2Error):
arc.discretize(5)
def test_discretize_Point_error(self):
"""Check that dicretize can detect a one point arc2
"""
arc = Arc2(0, 0, 2)
with self.assertRaises(PointArc2Error):
arc.discretize(5)
def test_comp_length_angle_error(self):
"""Check that comp_length can detect a null angle arc2
"""
arc = Arc2(0, 1, 0)
with self.assertRaises(AngleArc2Error):
arc.comp_length()
def build_geometry(self):
"""Compute the curve (Line) needed to plot the Slot.
The ending point of a curve is always the starting point of the next curve
in the list
Parameters
----------
self : SlotMFlat2
A SlotMFlat2 object
Returns
-------
curve_list: list
A list of 7 Segments for each slot + W3 arc
"""
Rbo = self.get_Rbo()
alpha = self.comp_angle_opening()
alpha_slot = self.comp_angle_opening_magnet()
alpha_mag = self.comp_angle_magnet()
# Point coordinate for a slot center on Ox
Z1 = Rbo * exp(-1j * alpha_slot / 2)
Z8 = Rbo * exp(1j * alpha_slot / 2)
R1 = self.comp_W0m() / (2 * sin(alpha_mag / 2))
Z3 = R1 * exp(-1j * alpha_mag / 2)
Z6 = R1 * exp(1j * alpha_mag / 2)
if self.is_outwards():
Z2 = Z1 + self.H1
Z7 = Z8 + self.H1
Z4 = Z3 + self.H0
Z5 = Z6 + self.H0
else:
Z2 = Z1 - self.H1
Z7 = Z8 - self.H1
Z4 = Z3 - self.H0
Z5 = Z6 - self.H0
# Curve list of a single slot
curve_list = list()
if self.H1 > 0:
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))
if self.H1 > 0:
curve_list.append(Segment(Z7, Z8))
# Copied from SlotMFlat. Probably not working for more than one Magnet
# Complete curve list for all the slots (for one pole)
slot_list = list()
for ii in range(len(self.magnet)):
# Compute angle of the middle of the slot
beta = -alpha / 2 + alpha_slot / 2 + ii * (self.W3 + alpha_slot)
# Duplicate and rotate the slot + bore for each slot
for line in curve_list:
new_line = type(line)(init_dict=line.as_dict())
new_line.rotate(beta)
slot_list.append(new_line)
if ii != len(self.magnet) - 1: # Add the W3 except for the last slot
slot_list.append(Arc2(slot_list[-1].get_end(), 0, self.W3))
return slot_list
