def build_geometry(self):
"""Compute the curve (Line) needed to plot the Slot.
The ending point of a curve is the starting point of the next curve in
the list
Parameters
----------
self : SlotW16
A SlotW16 object
Returns
-------
curve_list: llist
A list of 4 Segment and 5 Arc
"""
Rbo = self.get_Rbo()
[Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8, Z9, Z10] = self._comp_point_coordinate()
# Creation of curve
curve_list = list()
curve_list.append(Segment(Z1, Z2))
curve_list.append(Arc1(Z2, Z3, -Rbo + self.H0, is_trigo_direction=False))
curve_list.append(Arc1(Z3, Z4, -self.R1, is_trigo_direction=False))
curve_list.append(Segment(Z4, Z5))
curve_list.append(
Arc1(Z5, Z6, Rbo - self.H0 - self.H2, is_trigo_direction=True))
curve_list.append(Segment(Z6, Z7))
curve_list.append(Arc1(Z7, Z8, -self.R1, is_trigo_direction=False))
curve_list.append(Arc1(Z8, Z9, -Rbo + self.H0, is_trigo_direction=False))
curve_list.append(Segment(Z9, Z10))
return curve_list
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 : SlotW25
A SlotW25 object
Returns
-------
curve_list: list
A list of 4 Segment and 3 Arc
"""
[Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8] = self._comp_point_coordinate()
# Creation of curve
curve_list = list()
curve_list.append(Segment(Z8, Z7))
curve_list.append(Arc1(Z7, Z6, -abs(Z2), is_trigo_direction=False))
curve_list.append(Segment(Z6, Z5))
curve_list.append(Arc1(Z5, Z4, abs(Z5)))
curve_list.append(Segment(Z4, Z3))
curve_list.append(Arc1(Z3, Z2, -abs(Z2), is_trigo_direction=False))
curve_list.append(Segment(Z2, Z1))
return curve_list
def build_geometry(self):
"""Compute the curve (Line) needed to plot the object.
The ending point of a curve is the starting point of the next curve in
the list
Parameters
----------
self : SlotW28
A SlotW28 object
Returns
-------
curve_list: list
A list of 4 Segment and 3 Arc1
"""
[Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8, rot_sign] = self._comp_point_coordinate()
# Creation of curve
curve_list = list()
curve_list.append(Segment(Z1, Z2))
curve_list.append(Arc1(Z2, Z3, rot_sign * self.R1, self.is_outwards()))
curve_list.append(Segment(Z3, Z4))
curve_list.append(Arc3(Z4, Z5, self.is_outwards()))
curve_list.append(Segment(Z5, Z6))
curve_list.append(Arc1(Z6, Z7, rot_sign * self.R1, self.is_outwards()))
curve_list.append(Segment(Z7, Z8))
return curve_list
def get_lines(self):
"""return the list of lines that delimits the PolarArc
Parameters
----------
self : PolarArc
a PolarArc object
Returns
-------
line_list: list
List of line need to draw the slot (2 Segment + 2 Arc1)
"""
# check if the PolarArc is correct
self.check()
Z_ref = self.point_ref
center = Z_ref * exp(-1j * angle(Z_ref))
H = self.height
A = self.angle
# the points of the PolarArc
Z2 = (center - (H / 2)) * exp(1j * (-(A / 2))) * exp(1j * angle(Z_ref))
Z3 = (center + (H / 2)) * exp(1j * (-(A / 2))) * exp(1j * angle(Z_ref))
Z4 = (center + (H / 2)) * exp(1j * (A / 2)) * exp(1j * angle(Z_ref))
Z1 = (center - (H / 2)) * exp(1j * (A / 2)) * exp(1j * angle(Z_ref))
# Lines that delimit the PolarArc
line1 = Arc1(Z1, Z2, -abs(Z1))
line2 = Segment(Z2, Z3)
line3 = Arc1(Z3, Z4, abs(Z3))
line4 = Segment(Z4, Z1)
return [line1, line2, line3, line4]
def build_geometry(self):
"""Compute the curve (Line) needed to plot the Slot.
The ending point of a curve is the starting point of the next curve in
the list
Parameters
----------
self : SlotW60
A SlotW60 object
Returns
-------
curve_list: list
A list of 8 Segment and 2 Arc1
"""
[Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8, Z9, Z10, Z11] = self._comp_point_coordinate()
# Creation of curve
curve_list = list()
curve_list.append(Arc1(Z1, Z2, self.R1))
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(Arc1(Z10, Z11, self.R1))
return curve_list
def build_geometry(self, alpha=0, delta=0, is_simplified=False):
"""Compute the curve (Arc) needed to plot the Hole.
The ending point of a curve is the starting point of the next curve in the
list
Parameters
----------
self : HoleM54
A HoleM54 object
alpha : float
Angle to rotate the slot (Default value = 0) [rad]
delta : complex
Complex to translate the slot (Default value = 0)
is_simplified : bool
True to avoid line superposition
Returns
-------
surf_list : list
List of Air Surface on the slot
"""
Rbo = self.get_Rbo()
# Compute point coordinates
Zc0 = Rbo - self.H0 + self.R1
Z1 = (self.R1 * exp(1j * (-pi + self.W0 / 2))) + Zc0
Z2 = (self.R1 * exp(1j * (pi - self.W0 / 2))) + Zc0
Z4 = ((self.R1 + self.H1) * exp(1j * (-pi + self.W0 / 2))) + Zc0
Z3 = ((self.R1 + self.H1) * exp(1j * (pi - self.W0 / 2))) + Zc0
Zref = Rbo - self.H0 - self.H1 / 2
surf_list = list()
curve_list = list()
curve_list.append(Arc1(begin=Z1, end=Z2, radius=-self.R1, is_trigo_direction=False))
curve_list.append(Arc3(begin=Z2, end=Z3, is_trigo_direction=True))
curve_list.append(Arc1(begin=Z3, end=Z4, radius=self.R1 + self.H1))
curve_list.append(Arc3(begin=Z4, end=Z1, is_trigo_direction=True))
if self.get_is_stator(): # check if the slot is on the stator
st = "_Stator"
else:
st = "_Rotor"
surf_list.append(
SurfLine(line_list=curve_list, label="Hole" + st + "_R0_T0_S0", point_ref=Zref)
)
# Apply the transformations
for surf in surf_list:
surf.rotate(alpha)
surf.translate(delta)
return surf_list
def build_geometry(self):
"""Compute the curve (Line) needed to plot the object.
The ending point of a curve is the starting point of the next curve in
the list
Parameters
----------
self : SlotW23
A SlotW23 object
Returns
-------
curve_list: list
A list of 6 Segment and 1 Arc
"""
[Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8] = self._comp_point_coordinate()
Zc = 0
# Creation of curve
curve_list = list()
curve_list.append(Segment(Z1, Z2))
curve_list.append(Segment(Z2, Z3))
curve_list.append(Segment(Z3, Z4))
curve_list.append(Arc1(Z4, Z5, abs(Z5)))
curve_list.append(Segment(Z5, Z6))
curve_list.append(Segment(Z6, Z7))
curve_list.append(Segment(Z7, Z8))
return curve_list
def build_geometry(self):
"""Compute the curve (Line) needed to plot the object.
The ending point of a curve is the starting point of the next curve in
the list
Parameters
----------
self : Slot19
A Slot19 object
Returns
-------
curve_list: list
A list of 2 Segment and 1 Arc
"""
[Z1, Z2, Z3, Z4] = self._comp_point_coordinate()
# Creation of curve
curve_list = list()
curve_list.append(Segment(Z1, Z2))
if self.W1 > 0:
curve_list.append(Arc1(Z2, Z3, abs(Z3)))
curve_list.append(Segment(Z3, Z4))
return curve_list
def test_get_middle(self, test_dict):
"""Check that you can compute the arc middle
"""
arc = Arc1(
begin=test_dict["begin"],
end=test_dict["end"],
radius=test_dict["radius"],
is_trigo_direction=test_dict["is_trigo"],
)
# Check center
Zc = arc.get_center()
msg = (
"Wrong center: return " + str(Zc) + ", expected " + str(test_dict["center"])
)
self.assertAlmostEqual(abs(Zc - test_dict["center"]), 0, msg=msg)
# Check middle
result = arc.get_middle()
msg = (
"Wrong middle: return "
+ str(result)
+ ", expected "
+ str(test_dict["expect"])
)
self.assertAlmostEqual(
abs(result - test_dict["expect"]), 0, delta=1e-6, msg=msg
)
def test_dicretize(self, test_dict):
"""Check that you can discretize an arc1
"""
arc = Arc1(
test_dict["begin"],
test_dict["end"],
test_dict["Radius"],
is_trigo_direction=test_dict["is_trigo"],
)
# Check center
Zc = arc.get_center()
msg = (
"Wrong center: return " + str(Zc) + ", expected " + str(test_dict["center"])
)
self.assertAlmostEqual(abs(Zc - test_dict["center"]), 0, msg=msg)
# Check discretize
result = arc.discretize(test_dict["nb_point"])
self.assertEqual(result.size, test_dict["result"].size)
for ii in range(0, result.size):
a = result[ii]
b = test_dict["result"][ii]
msg = (
"Wrong point["
+ str(ii)
+ "]: return "
+ str(a)
+ ", expected "
+ str(b)
)
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA, msg=msg)
def get_bore_line(self, alpha1, alpha2, label=""):
"""
Parameters
----------
self : Lamination
a Lamination object
alpha1 : float
Startinf angle [rad]
alpha2 : float
Ending angle [rad]
label : str
the label of the bore line
Returns
-------
bore_line : list
list of bore line
"""
if alpha1 == alpha2:
return []
else:
Rbo = self.get_Rbo()
Z1 = Rbo * exp(1j * alpha1)
Z2 = Rbo * exp(1j * alpha2)
return [Arc1(begin=Z1, end=Z2, radius=Rbo, label=label)]
def test_get_center(self):
"""Check that the can compute the center of the arc1
"""
arc = Arc1(begin=1, end=1 * exp(1j * pi / 2), radius=1)
result = arc.get_center()
expect = 0
self.assertAlmostEqual(abs(result - expect), 0)
arc = Arc1(begin=2 * exp(1j * 3 * pi / 4), end=2 * exp(1j * pi / 4), radius=-2)
result = arc.get_center()
expect = 0
self.assertAlmostEqual(abs(result - expect), 0)
arc = Arc1(begin=2, end=3, radius=-0.5)
result = arc.get_center()
expect = 2.5
self.assertAlmostEqual(abs(result - expect), 0, delta=1e-3)
def test_comp_length(self, test_dict):
"""Check that you the length return by comp_length is correct
"""
arc = Arc1(test_dict["begin"], test_dict["end"], test_dict["Radius"])
a = float(arc.comp_length())
b = float(test_dict["length"])
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA)
def test_get_angle(self, test_dict):
"""Check that the arc1 computed angle is correct
"""
arc = Arc1(begin=test_dict["begin"],
end=test_dict["end"],
radius=test_dict["radius"])
result = arc.get_angle(test_dict["is_deg"])
self.assertAlmostEqual(result, test_dict["exp_angle"])
def build_geometry(self):
"""Compute the curve (Line) needed to plot the object.
The ending point of a curve is the starting point of the next curve
in the list
Parameters
----------
self : SlotW11
A SlotW11 object
Returns
-------
curve_list: list
A list of 7 Segment and 2 Arc1
"""
[Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8, Z9, Z10,
rot_sign] = self._comp_point_coordinate()
# Creation of curve
curve_list = list()
curve_list.append(Segment(Z1, Z2))
curve_list.append(Segment(Z2, Z3))
curve_list.append(Segment(Z3, Z4))
if self.R1 * 2 < self.W2:
curve_list.append(
Arc1(Z4,
Z5,
rot_sign * self.R1,
is_trigo_direction=self.is_outwards()))
curve_list.append(Segment(Z5, Z6))
curve_list.append(
Arc1(Z6,
Z7,
rot_sign * self.R1,
is_trigo_direction=self.is_outwards()))
else:
curve_list.append(Arc3(Z4, Z7, self.is_outwards()))
curve_list.append(Segment(Z7, Z8))
curve_list.append(Segment(Z8, Z9))
curve_list.append(Segment(Z9, Z10))
return curve_list
def test_plot_schematics(self):
"""Check that the schematics is correct
"""
begin = 1 + 1j
end = 3 + 2j
R = 2.5
# Creating the 4 arcs
arc_1 = Arc1(begin=begin, end=end, radius=R, is_trigo_direction=True)
arc_2 = Arc1(begin=begin, end=end, radius=-R, is_trigo_direction=True)
arc_3 = Arc1(begin=begin, end=end, radius=R, is_trigo_direction=False)
arc_4 = Arc1(begin=begin, end=end, radius=-R, is_trigo_direction=False)
plt.close("all")
fig, axes = plt.subplots()
axes.set_title("Arc1 Schematics")
# adding the 4 arcs
Z = arc_1.discretize(100)
plt.plot(Z.real, Z.imag, "b")
Z = arc_2.discretize(100)
plt.plot(Z.real, Z.imag, "y")
Z = arc_3.discretize(100)
plt.plot(Z.real, Z.imag, "r")
Z = arc_4.discretize(100)
plt.plot(Z.real, Z.imag, "g")
# Adding the center
Zc = arc_1.get_center()
plt.plot(Zc.real, Zc.imag, "rx")
plt.text(Zc.real, Zc.imag, "R > 0")
Zc = arc_2.get_center()
plt.plot(Zc.real, Zc.imag, "rx")
plt.text(Zc.real, Zc.imag, "R < 0")
# Adding begin and end
plt.text(begin.real, begin.imag, "begin")
plt.text(end.real, end.imag, "end")
# Adding legend
plt.legend(
["R > 0, trigo", "R < 0, trigo", "R > 0, not trigo", "R < 0, not trigo"]
)
plt.axis("equal")
plt.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "Arc1_schematics.png"))
def test_get_middle(self, test_dict):
"""Check that you can compute the arc middle
"""
arc = Arc1(begin=test_dict["begin"],
end=test_dict["end"],
radius=test_dict["radius"])
result = arc.get_middle()
self.assertAlmostEqual(abs(result - test_dict["expect"]),
0,
delta=1e-6)
def test_translate(self, test_dict):
"""Check that you can translate the arc1
"""
arc = Arc1(
begin=test_dict["begin"], end=test_dict["end"], radius=test_dict["radius"]
)
expect_radius = arc.radius
arc.translate(test_dict["delta"])
self.assertAlmostEqual(abs(arc.begin - test_dict["exp_begin"]), 0, delta=1e-6)
self.assertAlmostEqual(abs(arc.end - test_dict["exp_end"]), 0, delta=1e-6)
self.assertAlmostEqual(abs(arc.radius - expect_radius), 0)
def test_dicretize(self, test_dict):
"""Check that you can discretize an arc1
"""
arc = Arc1(test_dict["begin"], test_dict["end"], test_dict["Radius"])
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 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_build_geometry_out(self):
"""check that curve_list is correct (outwards magnet)"""
lam = LamSlotMag(
Rint=40e-3,
Rext=90e-3,
is_internal=False,
is_stator=False,
L1=0.45,
Nrvd=1,
Wrvd=0.05,
)
magnet = [MagnetType11(Wmag=pi / 10, Hmag=0.2)]
lam.slot = SlotMPolar(Zs=8, W0=pi / 10, H0=0.2, magnet=magnet)
test_obj = lam.slot.magnet[0]
Z1 = (40e-3 + 0.2) * exp(-1j * pi / 10 / 2)
Z2 = (40e-3 + 0.2) * exp(1j * pi / 10 / 2)
Z = abs(Z1)
Z3 = (Z - 0.2) * exp(1j * angle(Z1))
Z4 = (Z - 0.2) * exp(1j * angle(Z2))
# # Creation of curve
curve_list = list()
curve_list.append(Segment(Z1, Z3))
curve_list.append(Arc1(Z3, Z4, abs(Z3)))
curve_list.append(Segment(Z4, Z2))
curve_list.append(Arc1(Z2, Z1, -abs(Z2)))
surface = test_obj.build_geometry()
result = surface[0].get_lines()
for i in range(0, len(result)):
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)
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 get_surface_tooth(self):
"""Returns the surface delimiting the tooth (including yoke part)
Parameters
----------
self : Slot
A Slot object
Returns
-------
surface: SurfLine
A SurfLine object representing the slot
"""
if self.parent is not None:
Ryoke = self.parent.get_Ryoke()
else:
raise ParentMissingError("Error: The slot is not inside a Lamination")
curve_list = list()
# tooth lines
top_list = self.build_geometry_half_tooth(is_top=True)
bot_list = self.build_geometry_half_tooth(is_top=False)
# Yoke lines
Z1 = Ryoke * exp(1j * pi / self.Zs)
Z2 = Ryoke * exp(-1j * pi / self.Zs)
curve_list.append(
Segment(top_list[-1].get_end(), Z1, label="Tooth_Yoke_Side"))
if Ryoke > 0:
curve_list.append(
Arc1(
begin=Z1,
end=Z2,
radius=-Ryoke,
is_trigo_direction=False,
label="Tooth_Yoke_Arc",
))
curve_list.append(
Segment(Z2, bot_list[0].get_begin(), label="Tooth_Yoke_Side"))
# Second half of the tooth
curve_list.extend(bot_list)
curve_list.extend(top_list)
return SurfLine(line_list=curve_list, label="Tooth")
def test_get_angle(self, test_dict):
"""Check that the arc1 computed angle is correct
"""
arc = Arc1(
begin=test_dict["begin"],
end=test_dict["end"],
radius=test_dict["radius"],
is_trigo_direction=test_dict["is_trigo"],
)
# Check center
Zc = arc.get_center()
msg = (
"Wrong center: return " + str(Zc) + ", expected " + str(test_dict["center"])
)
self.assertAlmostEqual(abs(Zc - test_dict["center"]), 0, msg=msg)
# Check angle
result = arc.get_angle(test_dict["is_deg"])
self.assertAlmostEqual(result, test_dict["exp_angle"])
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 build_geometry(self, sym=1, alpha=0, delta=0):
"""Build the geometry of the shaft
Parameters
----------
self : Shaft
Shaft Object
sym : int
Symmetry factor (1= full machine, 2= half of the machine...)
alpha : float
Angle for rotation [rad]
delta : complex
Complex value for translation
Returns
-------
surf_list : list
list of surfaces needed to draw the lamination
"""
surf_list = list()
if sym == 1:
surf_list.append(
Circle(radius=self.Drsh / 2, label="Shaft", center=0, point_ref=0))
else:
begin = self.Drsh / 2
end = begin * exp(1j * 2 * pi / sym)
surface = SurfLine(
line_list=[
Segment(0, begin),
Arc1(begin, end, self.Drsh / 2),
Segment(end, 0),
],
label="Shaft",
point_ref=0,
)
surf_list.append(surface)
for surf in surf_list:
surf.rotate(alpha)
surf.translate(delta)
return surf_list
def test_comp_length(self, test_dict):
"""Check that you the length return by comp_length is correct
"""
arc = Arc1(
begin=test_dict["begin"],
end=test_dict["end"],
radius=test_dict["Radius"],
is_trigo_direction=test_dict["is_trigo"],
)
# Check center
Zc = arc.get_center()
msg = (
"Wrong center: return " + str(Zc) + ", expected " + str(test_dict["center"])
)
self.assertAlmostEqual(abs(Zc - test_dict["center"]), 0, msg=msg)
# Check length
a = float(arc.comp_length())
b = float(test_dict["length"])
msg = "Wrong length: returned " + str(a) + ", expected " + str(b)
self.assertAlmostEqual((a - b) / a, 0, delta=DELTA, msg=msg)
def get_surface(self):
"""Returns the surface delimiting the slot
Parameters
----------
self : Slot
A Slot object
Returns
-------
surface: SurfLine
A SurfLine object representing the slot
"""
Rbo = self.get_Rbo()
curve_list = self.build_geometry()
Zbegin = curve_list[-1].get_end()
Zend = curve_list[0].get_begin()
curve_list.append(Arc1(Zbegin, Zend, -Rbo))
return SurfLine(line_list=curve_list, label="Slot")
def test_split_half(self, test_dict):
"""Check that the arc1 split is correct
"""
arc = Arc1(
begin=test_dict["begin"],
end=test_dict["end"],
radius=test_dict["radius"],
is_trigo_direction=test_dict["is_trigo"],
)
# Check center
Zc = arc.get_center()
msg = (
"Wrong center: return " + str(Zc) + ", expected " + str(test_dict["center"])
)
self.assertAlmostEqual(abs(Zc - test_dict["center"]), 0, msg=msg)
# Check split
arc.split_half(is_begin=test_dict["is_begin"])
self.assertAlmostEqual(arc.begin, test_dict["N_begin"])
self.assertAlmostEqual(arc.end, test_dict["N_end"])
self.assertAlmostEqual(arc.radius, test_dict["N_radius"])
self.assertAlmostEqual(arc.is_trigo_direction, test_dict["is_trigo"])
def get_bore_line(self, label=""):
"""Return the bore line description
Parameters
----------
self : BoreFlower
A BoreFlower object
Returns
-------
bore_list : list
List of bore lines
"""
if self.parent is not None:
Rbo = self.parent.get_Rbo()
else:
raise ParentMissingError("Error: The slot is not inside a Lamination")
# Compute the shape
(alpha_lim, z_top_left,
z_top_right) = comp_flower_arc(2 * pi / self.N, self.Rarc, Rbo)
# Create the lines
bore_list = list()
for ii in range(self.N):
bore_list.append(
Arc1(
begin=z_top_right * exp(1j * (2 * pi / self.N *
(ii - 1) + self.alpha)),
end=z_top_left * exp(1j * (2 * pi / self.N *
(ii - 1) + self.alpha)),
radius=self.Rarc,
is_trigo_direction=True,
label=label,
))
return bore_list
