def create_upper_leg():
l1, l2 = 50, 80
pts = [(0, 0), (0, height / 2), (l1, height / 2 - 5), (l2, 0)]
upper_leg_hole = (l2 - 10, 0)
upper_leg = (
cq.Workplane()
.polyline(pts)
.mirrorX()
.pushPoints([upper_leg_hole])
.circle(diam / 2 + tol)
.extrude(thickness)
.edges("|Z and (not <X)")
.fillet(4)
)
axle = (
cq.Workplane("XZ", origin=(0, height / 2 + thickness + tol, thickness / 2))
.circle(diam / 2)
.extrude(2 * (height / 2 + thickness + tol))
)
upper_leg = upper_leg.union(axle)
# tag mating points
upper_leg.faces(">Z").edges(cq.NearestToPointSelector(upper_leg_hole)).tag("top")
upper_leg.faces("<Z").edges(cq.NearestToPointSelector(upper_leg_hole)).tag("bottom")
return upper_leg
def make_ball_reactor_seg(outputs=['stp', 'neutronics', 'svg', 'stl', 'html']):
my_reactor = paramak.SegmentedBlanketBallReactor(
inner_bore_radial_thickness=5,
inboard_tf_leg_radial_thickness=25,
center_column_shield_radial_thickness=45,
divertor_radial_thickness=150,
inner_plasma_gap_radial_thickness=50,
plasma_radial_thickness=300,
outer_plasma_gap_radial_thickness=50,
firstwall_radial_thickness=15,
blanket_radial_thickness=50,
blanket_rear_wall_radial_thickness=30,
elongation=2,
triangularity=0.55,
number_of_tf_coils=16,
rotation_angle=180,
pf_coil_radial_thicknesses=[50, 50, 50, 50],
pf_coil_vertical_thicknesses=[50, 50, 50, 50],
pf_coil_to_rear_blanket_radial_gap=50,
pf_coil_to_tf_coil_radial_gap=50,
outboard_tf_coil_radial_thickness=100,
outboard_tf_coil_poloidal_thickness=50,
gap_between_blankets=30,
number_of_blanket_segments=15,
blanket_fillet_radius=15,
)
# finds the correct edges to fillet
x_coord = my_reactor.major_radius
front_face = my_reactor._blanket.solid.faces(
cq.NearestToPointSelector((x_coord, 0, 0)))
front_edge = front_face.edges(cq.NearestToPointSelector((x_coord, 0, 0)))
front_edge_length = front_edge.val().Length()
my_reactor._blanket.solid = my_reactor._blanket.solid.edges(
paramak.EdgeLengthSelector(front_edge_length)).fillet(
my_reactor.blanket_fillet_radius)
# cuts away the breeder zone
my_reactor._blanket.solid = my_reactor._blanket.solid.cut(
my_reactor._blanket.solid)
my_reactor._blanket.export_stp('firstwall_with_fillet.stp')
if 'stp' in outputs:
my_reactor.export_stp(output_folder='SegmentedBlanketBallReactor')
if 'neutronics' in outputs:
my_reactor.export_neutronics_description(
'SegmentedBlanketBallReactor/manifest.json')
if 'svg' in outputs:
my_reactor.export_svg('SegmentedBlanketBallReactor/reactor.svg')
if 'stl' in outputs:
my_reactor.export_stl(output_folder='SegmentedBlanketBallReactor')
if 'html' in outputs:
my_reactor.export_html('SegmentedBlanketBallReactor/reactor.html')
def create_base(rotate=False):
x1, x2 = 0.63, 0.87
base_holes = {
"right_back": (-x1 * length, -x1 * width),
"right_middle": (0, -x2 * width),
"right_front": (x1 * length, -x1 * width),
"left_back": (-x1 * length, x1 * width),
"left_middle": (0, x2 * width),
"left_front": (x1 * length, x1 * width),
}
stand_holes = {
"front_stand": (0.75 * length, 0),
"back_stand": (-0.8 * length, 0)
}
workplane = cq.Workplane()
if rotate:
workplane = workplane.transformed(rotate=(30, 45, 60))
base = (workplane.ellipseArc(
length, width, 25, -25, startAtCurrent=False).close().pushPoints(
list(base_holes.values())).circle(diam / 2 + tol).moveTo(
*stand_holes["back_stand"]).rect(
thickness + 2 * tol, width / 2 +
2 * tol).moveTo(*stand_holes["front_stand"]).rect(
thickness + 2 * tol,
width / 2 + 2 * tol).extrude(thickness))
base
# tag mating points
if rotate:
l_coord = lambda vec2d: workplane.plane.toWorldCoords(vec2d).toTuple()
l_nps = lambda vec2d: cq.NearestToPointSelector(l_coord(vec2d))
base.faces(f"<{l_coord((0,0,1))}").tag("bottom")
base.faces(f">{l_coord((0,0,1))}").tag("top")
for name, hole in base_holes.items():
base.faces(f"<{l_coord((0,0,1))}").edges(l_nps(hole)).tag(name)
for name, hole in stand_holes.items():
base.faces(f"<{l_coord((0,0,1))}").wires(l_nps(hole)).tag(name)
else:
base.faces("<Z").tag("bottom")
base.faces(">Z").tag("top")
for name, hole in base_holes.items():
base.faces("<Z").wires(cq.NearestToPointSelector(hole)).tag(name)
for name, hole in stand_holes.items():
base.faces("<Z").wires(cq.NearestToPointSelector(hole)).tag(name)
return base
def _make_blankets_layers(self):
super()._make_blankets_layers()
azimuth_placement_angles = np.linspace(
0, 360, self.number_of_blanket_segments, endpoint=False)
thin_cutter = paramak.BlanketCutterStar(
distance=self.gap_between_blankets,
azimuth_placement_angle=azimuth_placement_angles)
thick_cutter = paramak.BlanketCutterStar(
distance=self.gap_between_blankets +
2 * self.firstwall_radial_thickness,
azimuth_placement_angle=azimuth_placement_angles)
self._blanket.cut = [self._center_column_cutter, thick_cutter]
if self.blanket_fillet_radius != 0:
# tried firstwall start radius here already
x = self.major_radius + 1
front_face_b = self._blanket.solid.faces(
cq.NearestToPointSelector((0, x, 0)))
front_edge_b = front_face_b.edges(
cq.NearestToPointSelector((0, x, 0)))
front_edge_length_b = front_edge_b.val().Length()
self._blanket.solid = self._blanket.solid.edges(
paramak.EdgeLengthSelector(front_edge_length_b)).fillet(
self.blanket_fillet_radius)
self._firstwall.thickness += self.blanket_radial_thickness
self._firstwall.cut = [
self._center_column_cutter,
thin_cutter,
self._blanket]
# TODO this segfaults at the moment but works as an opperation on the
# reactor after construction in jupyter
# tried different x values and (0, x, 0)
# noticed that it much quicker as a post process so perhaps some
# unwanted looping is happening
# if self.blanket_fillet_radius != 0:
# x = self.major_radius # tried firstwall start radius here already
# front_face = \
# self._firstwall.solid.faces(
# cq.NearestToPointSelector((x, 0, 0)))
# print('found front face')
# front_edge = front_face.edges(
# cq.NearestToPointSelector((x, 0, 0)))
# print('found front edge')
# front_edge_length = front_edge.val().Length()
# print('found front edge length', front_edge_length)
# self._firstwall.solid = self._firstwall.solid.edges(
# paramak.EdgeLengthSelector(front_edge_length)).fillet(self.blanket_fillet_radius)
# print('finished')
return [self._firstwall, self._blanket, self._blanket_rear_wall]
def make(self):
corner_protection = 16
s1 = self.leg_s1
s2 = self.leg_s2
s3 = self.leg_s3
s4 = self.leg_s4
x0 = self.cx + self.ins_l / 2.0 + corner_protection
x1 = self.cx - self.ins_l / 2.0 + corner_protection
x2 = x1 - 25
x3 = 100
x4 = 80
x5 = x3 - 55
y0 = self.height
y2 = self.height_1 - self.shelf_t + self.ins_d
y1 = y2 - 12
y3 = y2 - self.ins_d
y5 = self.height_2 - self.ins_d
y4 = y5 + self.ins_d
y6 = y5 + 12
y7 = y0 - 30
m = cq.Workplane("XZ", origin = (-corner_protection, self.leg_t / 2, -self.height)).moveTo(0, y0).lineTo(x4, y0).sagittaArc((x2, y1), s1) \
.lineTo(x1, y1).lineTo(x1, y2).lineTo(x0, y2).lineTo(x0, y3).sagittaArc((x0, y4), s2) \
.lineTo(x0, y5).lineTo(x1, y5).lineTo(x1, y6).lineTo(x2, y6).sagittaArc((x3, 0), s3) \
.lineTo(x5, 0).sagittaArc((0, y7), s4) \
.close().extrude(self.leg_t)
m = m.edges("|Y").edges(
cq.NearestToPointSelector(
(0 - corner_protection, 0, y7 - self.height))).fillet(100)
m = m.edges("|Y").edges(
cq.NearestToPointSelector(
(x2 - corner_protection, 0, y1 - self.height))).fillet(20)
m = m.edges("|Y").edges(
cq.NearestToPointSelector(
(x1 - corner_protection, 0, y1 - self.height))).fillet(8)
m = m.edges("|Y").edges(
cq.NearestToPointSelector(
(x1 - corner_protection, 0, y6 - self.height))).fillet(8)
m = m.edges("|Y").edges(
cq.NearestToPointSelector(
(x2 - corner_protection, 0, y6 - self.height))).fillet(20)
m = m.edges("%CIRCLE").fillet(7)
hole = cq.Workplane(
"XY",
origin=(self.cx, 0, -self.height)).circle(4).extrude(self.height)
m = m.cut(hole)
return m
def cslot(length=100):
out = (cq.Workplane().tag("base").box(
dims.outer.x, dims.base_depth, length,
centered=(True, False, False)).workplaneFromTagged("base").center(
dims.outer.x / 2 - dims.base_depth / 2,
0).box(dims.base_depth,
dims.outer.y,
length,
centered=(True, False,
False)).workplaneFromTagged("base").center(
-dims.outer.x / 2 + dims.base_depth / 2,
0).box(dims.base_depth,
dims.outer.y,
length,
centered=(True, False,
False)).tag("unslotted"))
points = []
for idx in range(4):
points.append((
-dims.outer.x / 2 + dims.base_depth / 2 +
idx * dims.base_depth # x
,
0 # y
,
0 # rotation
))
for side in [-1, 1]:
for idx in range(2):
points.append(
(side * dims.outer.x / 2,
dims.base_depth / 2 + idx * dims.base_depth, 180 - 90 * side))
for xval, yval, rot in points:
out = out.cut(cq.Workplane().center(xval, yval).tag("centered").hLine(
9.16 / 2).polarLine(4, 45 + 90).hLineTo(0).mirrorY(
).extrude(length).workplaneFromTagged("centered").center(
0, 1.8 + 1.5 / 2).rect(
11,
1.5, centered=True).extrude(length).workplaneFromTagged(
"centered").center(0, 1.8 + 4.3 / 2).rect(
6.5, 4.3,
centered=True).extrude(length).edges("|Z").edges(
cq.NearestToPointSelector(
(xval + 6.5 / 2, yval + 1.8 + 1.5,
0))).chamfer(2).edges("|Z").edges(
cq.NearestToPointSelector(
(xval - 6.5 / 2, yval + 1.8 + 1.5,
0))).chamfer(2).rotate(
(xval, yval, 0),
(xval, yval, 1), rot))
return out
def make_link(length, width=2, height=1):
link = (cq.Workplane("YZ").rect(length + 4, width + 2).pushPoints(
((-length / 2, 0),
(length / 2, 0))).circle(1).extrude(height).edges("|X").fillet(1.99))
link.faces(">X").wires(cq.NearestToPointSelector(
(0, length / 2))).tag("mate")
return link
def create_lower_leg():
w, l1, l2 = 15, 20, 120
pts = [(0, 0), (l1, w), (l2, 0)]
lower_leg_hole = (l1 - 10, 0)
lower_leg = (cq.Workplane().polyline(pts).mirrorX().pushPoints([
lower_leg_hole
]).circle(diam / 2 + tol).extrude(thickness).edges("|Z").fillet(5))
# tag mating points
lower_leg.faces(">Z").edges(
cq.NearestToPointSelector(lower_leg_hole)).tag("top"),
lower_leg.faces("<Z").edges(
cq.NearestToPointSelector(lower_leg_hole)).tag("bottom")
return lower_leg
cq.exporters.export(box.rotate((0, 0, 0), (0, 1, 0), -90), "box.stl")
cq.exporters.export(box.rotate((0, 0, 0), (0, 1, 0), -90), "box.step")
show_object(box)
if GEARS:
g = gear.spur(mod,teeth,bore,width,helixAngle)\
.rotate((0,0,0),(0,1,0),90).translate((-l/2,0,0))
vpts = [(-l / 2, od / 2 + d2), (0, od / 2 - d2), (l / 2, od / 2 + d2)]
apts = [(-l / 2, od / 2 - d2), (0, od / 2 + d2), (l / 2, od / 2 - d2)]
a = WP().polyline(vpts).close()
b = WP().polyline(apts).close()
a = a.revolve(360,(0,0,0),(1,0,0)).edges("%circle")\
.edges(cq.NearestToPointSelector((0,od/2,0))).fillet(2)\
w = (2.5**2 - 1.9**2)**0.5
b = b.revolve(360,(0,0,0),(1,0,0)).edges("%circle")\
.edges(cq.NearestToPointSelector((0,od/2,0))).fillet(3)
a = g.cut(a)
b = g.union(b)
b = b.cut(WP("YZ").circle(10 / 2).extrude(l, both=True))
a = a.cut(
WP("YZ").moveTo(1.9, -w).threePointArc(
(-2.5, 0), (1.9, w)).close().extrude(l, both=True))
b = b.translate((0, od, 0))
"back",
back.faces("<Z", tag="unslotted").val(),
"bracket",
bracket_module.bracket.faces(">Z").val(),
"Axis",
)
clamp = clamp_module.clamp.rotate((0, 0, 0), (0, 0, 1), 180)
assy.add(clamp, name="clamp")
assy.constrain("bracket@faces@<Y", "clamp@faces@>Y", "Plane")
assy.constrain("bracket@faces@<Z", "clamp@faces@>Z", "Axis")
spindle = spindle_module.spindle
assy.add(spindle, name="spindle", color=cq.Color(0.9, 0.7, 0.8))
spindle_lower_face = (spindle.faces(
cq.NearestToPointSelector(
(0, 0, dims.spindle.body.length / 2))).edges("<Z").val())
clamp_lower_face = clamp.faces("<Z").edges("%CIRCLE").val()
assy.constrain(
"clamp",
clamp_lower_face,
"spindle",
spindle_lower_face.translate((0, 0, dims.spindle.body.clamp_end_offset)),
"Plane",
)
vac_brack = vac_brack_module.bracket
assy.add(vac_brack, name="vac_brack", color=cq.Color(0.2, 0.2, 0.2, 0.8))
backpoint2 = back.faces("<Z", tag="unslotted").edges("<Y").vertices(">X").val()
vac_brack_point = vac_brack.faces("<Z").edges(">Y").vertices(">X").val()
assy.constrain("back", backpoint2, "vac_brack", vac_brack_point, "Point")
assy.constrain("back?unslotted@faces@<Z", "vac_brack@faces@>Z", "Axis")
disk = cq.Workplane().circle(r_disk + 2 * nr).extrude(thickness)
nipple = cq.Workplane().circle(nr).extrude(thickness)
disk = disk.cut(nipple).union(nipple.translate((r_disk, 0, thickness)))
pivot_base = cq.Workplane().circle(2 * nr).extrude(thickness)
base = (cq.Workplane().rect(
6 * nr + dist_pivot, 6 * nr).extrude(thickness).translate(
(dist_pivot / 2, 0,
0)).union(nipple.translate(
(dist_pivot, 0,
thickness))).union(pivot_base.translate(
(0, 0,
thickness))).union(nipple.translate(
(0, 0, 2 * thickness))).edges("|Z").fillet(3))
base.faces(">Z[-2]").wires(cq.NearestToPointSelector(
(dist_pivot + r_disk, 0))).tag("mate")
slot = (cq.Workplane().rect(2 * r_disk, 2 * nr).extrude(thickness).union(
nipple.translate(
(-r_disk, 0, 0))).union(nipple.translate(
(r_disk - 1e-9, 0, 0))).translate((dist_pivot, 0, 0)))
arm = (cq.Workplane().rect(
4 * nr + (r_disk + dist_pivot),
4 * nr).extrude(thickness).edges("|Z").fillet(3).translate(
((r_disk + dist_pivot) / 2, 0, 0)).cut(nipple).cut(slot))
arm.faces(">Z").wires(cq.NearestToPointSelector((0, 0))).tag("mate")
def create_disk_arm():
L = lambda *args: cq.Location(cq.Vector(*args))
dims.brace.width + dims.chimney.mountface.width, both=True))
cutters.append(
cq.Workplane('YZ').moveTo(
dims.brace.mount_face[1], dims.chimney.mountface.height).lineTo(
-dims.bracket.thick,
dims.brace.profile1[2] + dims.chimney.mountface.height).hLineTo(
dims.brace.mount_face[1]).close().extrude(
dims.brace.width + dims.chimney.mountface.width,
both=True))
for cutter in cutters:
brace = brace.cut(cutter)
del cutter
cutters = []
brace = (brace.tag('mountbase').edges("|Z").edges(
cq.NearestToPointSelector(
(dims.brace.profile1[0] - dims.chimney.mountface.width / 2,
-dims.bracket.thick, dims.brace.profile1[1] +
dims.chimney.mountface.height / 2))).fillet(10).edges("|Z").edges(
">(1, 1, 0)").fillet(10 + dims.bracket.thick).faces(
">Y[1]", tag='mountbase').workplane(
centerOption='ProjectedOrigin',
origin=(0, 0, dims.brace.profile1[2] +
dims.chimney.mountface.height /
2)).tag('bolt plane').pushPoints([
(-30, 0), (30, 0)
]).cboreHole(dims.vac_brack.hole.diam,
dims.vac_brack.hole.cbore_diam,
dims.vac_brack.hole.cbore_depth))
for sign in [-1, 1]:
brace = (brace.faces(
"<Y", tag="mountbase").workplane(centerOption='CenterOfMass').moveTo(
sign *
dims.clamp.upper[1],
dims.clamp.dims[2],
centered=(True, False,
True)).
workplaneFromTagged('lower').center(0, dims.clamp.upper[1]).vLine(
-1) # having some trouble with this shape not fusing with the base
# shape and messing up the hole later
.hLine(dims.clamp.shoulder.outer_x).vLine(1).lineTo(
dims.clamp.shoulder.inner_x,
dims.clamp.shoulder.delta_y).hLineTo(0).mirrorY().extrude(
dims.clamp.dims[2] / 2, both=True))
edges = []
for side in [-1, 1]:
for y0 in [
0, dims.clamp.lower[1], dims.clamp.lower[1] + dims.clamp.upper[1]
]:
edges.append(
clamp.edges("|Z").edges(
cq.NearestToPointSelector(
(side * dims.clamp.dims[0] / 2, y0, 0))).val())
clamp = (clamp.newObject(edges).chamfer(
dims.clamp.lower[0] / 2 - dims.clamp.upper[0] / 2 -
1e-3).workplaneFromTagged('base').workplane(
offset=dims.clamp.dims[2] / 2 +
1).center(dims.clamp.hole.pos[0], dims.clamp.hole.pos[1]).hole(
dims.clamp.hole.diam, clean=False).faces("<Y").workplane().rect(
*dims.clamp.bolt.spacing).vertices().hole(9.3))
obj = cq.Workplane().box(1, 1, 1).val()
from cadquery import Workplane as WP
import cadquery as cq
from math import sin , cos, pi
pts = []
np = 9
n = np*2
for p in range(n):
if p %2:
r= 100
else:
r=30
pts.append((r*cos(2*pi/n*p),r*sin(2*pi/n*p)))
a = WP().polyline(pts).close().extrude(5)
for p in range(n):
f = 10
if p %2: f = 4
a = a.edges("|Z").edges(cq.NearestToPointSelector(pts[p])).fillet(f)
