def BuildGeometry():
#Current Densities in A/mm^2
j1 = 128
j2 = 256
#Coil Presentation Parameters
n1 = 3
n2 = 6
c2 = [1, 0, 0]
c1 = [0, 1, 1]
thcn = 0.001
#Create 5 Coils
Rt1 = rad.ObjRaceTrk([0., 0., 38.], [9.5, 24.5], [120., 0.], 36, n1, j1)
rad.ObjDrwAtr(Rt1, c1, thcn)
Rt3 = rad.ObjRaceTrk([0., 0., 76.], [10., 25.], [90., 0.], 24, n1, j1)
rad.ObjDrwAtr(Rt3, c1, thcn)
Rt2 = rad.ObjRaceTrk([0., 0., 38.], [24.5, 55.5], [120., 0.], 36, n1, j2)
rad.ObjDrwAtr(Rt2, c2, thcn)
Rt4 = rad.ObjRaceTrk([0., 0., 76.], [25., 55.], [90., 0.], 24, n1, j2)
rad.ObjDrwAtr(Rt4, c2, thcn)
Rt5 = rad.ObjRaceTrk([0., 0., 60.], [150., 166.3], [0., 0.], 39, n2, -j2)
rad.ObjDrwAtr(Rt5, c2, thcn)
Grp = rad.ObjCnt([Rt1, Rt2, Rt3, Rt4, Rt5])
#Define Mirror Coils
rad.TrfZerPara(Grp, [0, 0, 0], [0, 0, 1])
return Grp
def wiggler_example():
# current densities in A / mm^2
j1 = 128
j2 = 256
# number of arc segments
n1 = 3
n2 = 6
# create 5 racetrack coils above the mid-plane:
# lower inside, lower outside, upper inside, upper outside, and circular
# radia.ObjRaceTrk[ctr:[x,y,z], rad:[r1,r2], lstr:[lx,ly], ht, nseg, j]
rt1 = radia.ObjRaceTrk([0., 0., 38.], [9.5, 24.5], [120., 0.], 36, n1, j1)
rt2 = radia.ObjRaceTrk([0., 0., 38.], [24.5, 55.5], [120., 0.], 36, n1, j2)
rt3 = radia.ObjRaceTrk([0., 0., 76.], [10.0, 25.0], [90., 0.], 24, n1, j1)
rt4 = radia.ObjRaceTrk([0., 0., 76.], [25.0, 55.0], [90., 0.], 24, n1, j2)
rt5 = radia.ObjRaceTrk([0., 0., 60.], [150.0, 166.3], [0., 0.], 39, n2, -j2)
c1 = [0.0,1.0,1.0] # blue/green
c2 = [1.0,0.4,0.0] # orange-red
thcn = 0.001
radia.ObjDrwAtr(rt1, c1, thcn)
radia.ObjDrwAtr(rt2, c2, thcn)
radia.ObjDrwAtr(rt3, c1, thcn)
radia.ObjDrwAtr(rt4, c2, thcn)
radia.ObjDrwAtr(rt5, c2, thcn)
# assemble into a group
geom = radia.ObjCnt([rt1, rt2, rt3, rt4, rt5])
# and reflect in the (x,y) plane [plane through (0,0,0) with normal (0,0,1)]
radia.TrfZerPara(geom, [0, 0, 0], [0, 0, 1])
return geom
def make_racetrack_coil(center, radii, sizes, segments=15, current=1):
"""
Create coil for H-dipole. Coil runs in the XY plane.
:param center: (list) Center of the coil in [x, y, z].
:param radii: (list) Inner and outer edges for the coil.
:param sizes: (list) Straight sections lengths in X and Y; coil height in Z.
:param segments: (int) Number of segments for coil corners (default: 15).
:param current: (float) Current carried by the coil (default: 1).
:return: Radia object representing the coil
"""
return rad.ObjRaceTrk(center, radii, sizes[:2], sizes[2], segments,
current, 'man', 'z')
mag03 = rad.ObjArcPgnMag([0,5], 'z', [[2,0],[2,10],[10,10],[10,5]], [0,0.5], 5, 'nosym', [0,0,1])
mag04 = rad.ObjMltExtPgn([[[[-10,-10],[-15,-5],[-5,5],[5,5],[10,-15]], -15], [[[-5,-5],[-7.5,-2.5],[-2.5,2.5],[2.5,2.5],[5,-7.5]], -7]], [0,0,1])
mag05 = rad.ObjMltExtRtg([[[0,0,12],[5,10]], [[5,10,20],[15,5]]], [0,0,1])
mag06 = rad.ObjMltExtTri(25, 8, [[0,-15],[-15,0],[0,15],[15,0]], [[5,1],[5,2],[5,3],[5,1]], 'z', [0,0,1], 'ki->Numb,TriAngMin->20,TriAreaMax->10')
mag07 = rad.ObjCylMag([0,20,0], 5, 10, 21, 'z', [0,0,1])
mag08 = rad.ObjRecCur([-15,0,0], [5,7,15], [0.5,0.5,1.])
mag09 = rad.ObjArcCur([0,0,-5], [10,13], [0,2.5], 10, 15, 1.7, 'man', 'z')
mag10 = rad.ObjRaceTrk([0,0,0], [27,28], [1,2.5], 5, 15, 1.7, 'man', 'z')
mag11 = rad.ObjFlmCur([[-10,-30,-10],[30,-30,-10],[30,25,25],[-30,25,25],[-30,-30,-10]], 10.2)
magBkg = rad.ObjBckg([1,2,3])
mag = rad.ObjCnt([mag00, mag01, mag02, mag03, mag04, mag05, mag06, mag07, mag08, mag09])
print('Container Content:', rad.ObjCntStuf(mag))
print('Container Size:', rad.ObjCntSize(mag))
rad.ObjAddToCnt(mag, [mag10, mag11])
cnt02 = rad.ObjCnt([mag00, mag])
mat = rad.MatLin([1.01, 1.2], [0, 0, 1.3])
#mat = rad.MatStd('NdFeB', 1.2)
rad.MatApl(mag01, mat)
def geom(circ):
eps = 0
ironcolor = [0, 0.5, 1]
coilcolor = [1, 0, 0]
ironmat = radia.MatSatIsoFrm([20000, 2], [0.1, 2], [0.1, 2])
# Pole faces
lx1 = thick / 2
ly1 = width
lz1 = 20
l1 = [lx1, ly1, lz1]
k1 = [[thick / 4. - chamfer / 2., 0, gap / 2.],
[thick / 2. - chamfer, ly1 - 2. * chamfer]]
k2 = [[thick / 4., 0., gap / 2. + chamfer], [thick / 2., ly1]]
k3 = [[thick / 4., 0., gap / 2. + lz1], [thick / 2, ly1]]
g1 = radia.ObjMltExtRtg([k1, k2, k3])
radia.ObjDivMag(g1, n1)
radia.ObjDrwAtr(g1, ironcolor)
# Vertical segment on top of pole faces
lx2 = thick / 2
ly2 = ly1
lz2 = 30
l2 = [lx2, ly2, lz2]
p2 = [thick / 4, 0, lz1 + gap / 2 + lz2 / 2 + 1 * eps]
g2 = radia.ObjRecMag(p2, l2)
radia.ObjDivMag(g2, n2)
radia.ObjDrwAtr(g2, ironcolor)
# Corner
lx3 = thick / 2
ly3 = ly2
lz3 = ly2 * 1.25
l3 = [lx3, ly3, lz3]
p3 = [thick / 4, 0, lz1 + gap / 2 + lz2 + lz3 / 2 + 2 * eps]
g3 = radia.ObjRecMag(p3, l3)
typ = [
[p3[0], p3[1] + ly3 / 2, p3[2] - lz3 / 2],
[1, 0, 0],
[p3[0], p3[1] - ly3 / 2, p3[2] - lz3 / 2],
lz3 / ly3
]
if circ == 1:
radia.ObjDivMag(g3, [nbr, nbp, n3[1]], 'cyl', typ)
else:
radia.ObjDivMag(g3, n3)
radia.ObjDrwAtr(g3, ironcolor)
# Horizontal segment between the corners
lx4 = thick / 2
ly4 = 80
lz4 = lz3
l4 = [lx4, ly4, lz4]
p4 = [thick / 4, ly3 / 2 + eps + ly4 / 2, p3[2]]
g4 = radia.ObjRecMag(p4, l4)
radia.ObjDivMag(g4, n4)
radia.ObjDrwAtr(g4, ironcolor)
# The other corner
lx5 = thick / 2
ly5 = lz4 * 1.25
lz5 = lz4
l5 = [lx5, ly5, lz5]
p5 = [thick / 4, p4[1] + eps + (ly4 + ly5) / 2, p4[2]]
g5 = radia.ObjRecMag(p5, l5)
typ = [
[p5[0], p5[1] - ly5 / 2, p5[2] - lz5 / 2],
[1, 0, 0],
[p5[0], p5[1] + ly5 / 2, p5[2] - lz5 / 2],
lz5 / ly5
]
if circ == 1:
radia.ObjDivMag(g5, [nbr, nbp, n5[0]], 'cyl', typ)
else:
radia.ObjDivMag(g5, n5)
radia.ObjDrwAtr(g5, ironcolor)
# Vertical segment inside the coil
lx6 = thick / 2
ly6 = ly5
lz6 = gap / 2 + lz1 + lz2
l6 = [lx6, ly6, lz6]
p6 = [thick / 4, p5[1], p5[2] - (lz6 + lz5) / 2 - eps]
g6 = radia.ObjRecMag(p6, l6)
radia.ObjDivMag(g6, n6)
radia.ObjDrwAtr(g6, ironcolor)
# Generation of the coil
r_min = 5
r_max = 40
h = 2 * lz6 - 5
cur_dens = current / h / (r_max - r_min)
pc = [0, p6[1], 0]
coil = radia.ObjRaceTrk(pc, [r_min, r_max], [thick, ly6], h, 3, cur_dens)
radia.ObjDrwAtr(coil, coilcolor)
# Make container and set the colors
g = radia.ObjCnt([g1, g2, g3, g4, g5, g6])
radia.ObjDrwAtr(g, ironcolor)
radia.MatApl(g, ironmat)
t = radia.ObjCnt([g, coil])
# Define the symmetries
radia.TrfZerPerp(g, [0, 0, 0], [1, 0, 0])
radia.TrfZerPara(g, [0, 0, 0], [0, 0, 1])
return t
def build(self):
"""Create a quadrupole with the given geometry."""
if self.solve_state < SolveState.SHAPES:
self.define_shapes()
rad.UtiDelAll()
origin = [0, 0, 0]
nx = [1, 0, 0]
ny = [0, 1, 0]
nz = [0, 0, 1]
tip_mesh = round(self.min_mesh)
pole_mesh = round(self.min_mesh * self.pole_mult)
yoke_mesh = round(self.min_mesh * self.yoke_mult)
length = self.length
# Subdivide the pole tip cylindrically. The axis is where the edge of the tapered pole meets the Y-axis.
points = rotate45(self.tip_points)
x2, y2 = points[-2] # top right of pole
x3, y3 = points[-3] # bottom right of pole
m = (y2 - y3) / (x2 - x3)
c = y2 - m * x2
pole_tip = rad.ObjThckPgn(length / 2, length, points, "z")
# Slice off the chamfer (note the indexing at the end here - selects the pole not the cut-off piece)
pole_tip = rad.ObjCutMag(pole_tip, [length - self.chamfer, 0, self.r], [1, 0, -1])[0]
n_div = max(1, round(math.sqrt((x2 - x3) ** 2 + (y2 - y3) ** 2) / pole_mesh))
# We have to specify the q values here (second element of each sublist in the subdivision argument)
# otherwise weird things happen
mesh = [[n_div, 4], [tip_mesh / 3, 1], [tip_mesh, 1]]
div_opts = 'Frame->Lab;kxkykz->Size'
# rad.ObjDivMag(pole_tip, [[tip_mesh, 1], [tip_mesh, 1], [tip_mesh, 3]], div_opts)
rad.ObjDivMag(pole_tip, mesh, "cyl", [[[0, c, 0], nz], nx, 1], div_opts)
rad.TrfOrnt(pole_tip, rad.TrfRot(origin, nz, -math.pi / 4))
pole = rad.ObjThckPgn(length / 2, length, rotate45(self.pole_points), "z")
rad.ObjDivMag(pole, [pole_mesh, ] * 3, div_opts)
rad.TrfOrnt(pole, rad.TrfRot(origin, nz, -math.pi / 4))
# Need to split yoke since Radia can't build concave blocks
points = rotate45(self.yoke_points[:2] + self.yoke_points[-2:])
# yoke1 is the part that joins the pole to the yoke
# Subdivide this cylindrically since the flux goes around a corner here
# The axis is the second point (x1, y1)
x1, y1 = points[1]
yoke1 = rad.ObjThckPgn(length / 2, length, points, "z")
cyl_div = [[[x1, y1, 0], nz], [self.width, self.width, 0], 1]
# The first (kr) argument, corresponding to radial subdivision,
# in rad.ObjDivMag cuts by number not size even though kxkykz->Size is specified.
# So we have to fudge this. It seems to require a larger number to give the right number of subdivisions.
n_div = max(1, round(2 * self.width / yoke_mesh))
rad.ObjDivMag(yoke1, [n_div, yoke_mesh, yoke_mesh], "cyl", cyl_div, div_opts)
rad.TrfOrnt(yoke1, rad.TrfRot(origin, nz, -math.pi / 4))
# For the second part of the yoke, we use cylindrical subdivision again. But the axis is not on the corner;
# instead we calculate the point where the two lines converge (xc, yc).
points = self.yoke_points[1:3] + self.yoke_points[-3:-1]
x0, y0 = points[0]
x1, y1 = points[1]
x2, y2 = points[2]
x3, y3 = points[3]
m1 = (y3 - y0) / (x3 - x0)
m2 = (y2 - y1) / (x2 - x1)
c1 = y0 - m1 * x0
c2 = y1 - m2 * x1
xc = (c2 - c1) / (m1 - m2)
yc = m1 * xc + c1
yoke2 = rad.ObjThckPgn(length / 2, length, points, 'z')
cyl_div = [[[xc, yc, 0], nz], [x3 - xc, y3 - yc, 0], 1]
n_div = max(1, round(0.7 * n_div)) # this is a bit of a fudge
rad.ObjDivMag(yoke2, [n_div, yoke_mesh, yoke_mesh], "cyl", cyl_div, div_opts)
yoke3 = rad.ObjThckPgn(length / 2, length, self.yoke_points[2:6], "z")
rad.ObjDivMag(yoke3, [yoke_mesh, ] * 3, div_opts)
steel = rad.ObjCnt([pole_tip, pole, yoke1, yoke2, yoke3])
rad.ObjDrwAtr(steel, [0, 0, 1], 0.001) # blue steel
rad.TrfOrnt(steel, rad.TrfRot(origin, ny, -math.pi / 2))
rad.ObjDrwOpenGL(steel)
rad.TrfOrnt(steel, rad.TrfRot(origin, ny, math.pi / 2))
# rad.TrfMlt(steel, rad.TrfPlSym([0, 0, 0], [1, -1, 0]), 2) # reflect along X=Y line to create a quadrant
rad.TrfZerPerp(steel, origin, [1, -1, 0])
rad.TrfZerPerp(steel, origin, nz)
steel_material = rad.MatSatIsoFrm([2000, 2], [0.1, 2], [0.1, 2])
steel_material = rad.MatStd('Steel42')
steel_material = rad.MatSatIsoFrm([959.703184, 1.41019852], [33.9916543, 0.5389669], [1.39161186, 0.64144324])
rad.MatApl(steel, steel_material)
coil = rad.ObjRaceTrk(origin, [5, 5 + self.coil_width],
[self.coil_x * 2 - self.r, length * 2], self.coil_height, 4, self.current_density)
rad.TrfOrnt(coil, rad.TrfRot(origin, nx, -math.pi / 2))
rad.TrfOrnt(coil, rad.TrfTrsl([0, self.r + self.taper_height + self.coil_height / 2, 0]))
rad.TrfOrnt(coil, rad.TrfRot(origin, nz, -math.pi / 4))
rad.ObjDrwAtr(coil, [1, 0, 0], 0.001) # red coil
quad = rad.ObjCnt([steel, coil])
rad.TrfZerPara(quad, origin, nx)
rad.TrfZerPara(quad, origin, ny)
# rad.ObjDrwOpenGL(quad)
self.radia_object = quad
self.solve_state = SolveState.BUILT
def Geom():
#Pole faces
rap = 0.5
ct = [0, 0, 0]
z0 = gap / 2
y0 = width / 2
amax = hyp * asinh(y0 / z0)
dz = z0 * (cosh(amax) - 1)
aStep = amax / np
na = int(amax * (1 + 2 / np) / aStep) + 1
qq = [[(z0 * sinh(ia * aStep / hyp)), (z0 * cosh(ia * aStep))]
for ia in range(na)]
hh = qq[np][1] + height * rap - dz
qq[np + 1] = [qq[np][0], hh]
qq[np + 2] = [0, hh]
g1 = rad.ObjThckPgn(thick / 4, thick / 2, qq)
rad.ObjDivMag(g1, n1)
#Vertical segment on top of pole faces
g2 = rad.ObjRecMag(
[thick / 4, width / 4, gap / 2 + height * (1 / 2 + rap / 2)],
[thick / 2, width / 2, height * (1 - rap)])
rad.ObjDivMag(g2, n2)
#Corner
gg = rad.ObjCnt([g1, g2])
gp = rad.ObjCutMag(gg, [thick / 2 - chamfer - gap / 2, 0, 0],
[1, 0, -1])[0]
g3 = rad.ObjRecMag([thick / 4, width / 4, gap / 2 + height + depth / 2],
[thick / 2, width / 2, depth])
cy = [[[0, width / 2, gap / 2 + height], [1, 0, 0]],
[0, 0, gap / 2 + height], 2 * depth / width]
rad.ObjDivMag(g3, [nr3, np3, nx], 'cyl', cy)
#Horizontal segment between the corners
tan_n = tan(2 * pi / 2 / Nn)
length = tan_n * (height + gap / 2) - width / 2
g4 = rad.ObjRecMag(
[thick / 4, width / 2 + length / 2, gap / 2 + height + depth / 2],
[thick / 2, length, depth])
rad.ObjDivMag(g4, n4)
#The other corner
posy = width / 2 + length
posz = posy / tan_n
g5 = rad.ObjThckPgn(thick / 4, thick / 2,
[[posy, posz], [posy, posz + depth],
[posy + depth * tan_n, posz + depth]])
cy = [[[0, posy, posz], [1, 0, 0]], [0, posy, posz + depth], 1]
rad.ObjDivMag(g5, [nr5, np5, nx], 'cyl', cy)
#Generation of the coil
Rmax = Rmin - width / 2 + gap / 2 + offset - 2
coil1 = rad.ObjRaceTrk([0, 0, gap / 2 + height / 2 + offset / 2],
[Rmin, Rmax], [thick, width - 2 * Rmin],
height - offset, 3, CurDens)
rad.ObjDrwAtr(coil1, coilcolor)
hh = (height - offset) / 2
coil2 = rad.ObjRaceTrk([0, 0, gap / 2 + height - hh / 2],
[Rmax, Rmax + hh * 0.8], [thick, width - 2 * Rmin],
hh, 3, CurDens)
rad.ObjDrwAtr(coil2, coilcolor)
#Make container, set the colors and define symmetries
g = rad.ObjCnt([gp, g3, g4, g5])
rad.ObjDrwAtr(g, ironcolor)
gd = rad.ObjCnt([g])
rad.TrfZerPerp(gd, ct, [1, 0, 0])
rad.TrfZerPerp(gd, ct, [0, 1, 0])
t = rad.ObjCnt([gd, coil1, coil2])
rad.TrfZerPara(t, ct, [0, cos(pi / Nn), sin(pi / Nn)])
rad.TrfMlt(t, rad.TrfRot(ct, [1, 0, 0], 4 * pi / Nn), int(round(Nn / 2)))
rad.MatApl(g, ironmat)
rad.TrfOrnt(t, rad.TrfRot([0, 0, 0], [1, 0, 0], pi / Nn))
return t