def Und(lp, mp, np, cp, lm, mm, nm, cm, gap, gapOffset, numPer): zer = [0, 0, 0] Grp = rad.ObjCnt([]) #Principal Poles and Magnets #y = lp[1]/4; y = 0.25 * lp[1] #Pole = rad.ObjFullMag([lp[0]/4,y,-lp[2]/2-gap/2], [lp[0]/2,lp[1]/2,lp[2]], zer, np, Grp, mp, cp) Pole = rad.ObjFullMag([0.25 * lp[0], y, -0.5 * (lp[2] + gap)], [0.5 * lp[0], 0.5 * lp[1], lp[2]], zer, np, Grp, mp, cp) #y += lp[1]/4; y += 0.25 * lp[1] mDir = -1 for i in range(0, numPer): initM = [0, mDir, 0] mDir *= -1 #y += lm[1]/2 y += 0.5 * lm[1] #Magnet = rad.ObjFullMag([lm[0]/4,y,-lm[2]/2-gap/2-gapOffset], [lm[0]/2,lm[1],lm[2]], initM, nm, Grp, mm, cm) Magnet = rad.ObjFullMag( [0.25 * lm[0], y, -0.5 * (lm[2] + gap) - gapOffset], [0.5 * lm[0], lm[1], lm[2]], initM, nm, Grp, mm, cm) #y += (lm[1] + lp[1])/2 y += 0.5 * (lm[1] + lp[1]) #Pole = rad.ObjFullMag([lp[0]/4,y,-lp[2]/2-gap/2], [lp[0]/2,lp[1],lp[2]], zer, np, Grp, mp, cp) Pole = rad.ObjFullMag([0.25 * lp[0], y, -0.5 * (lp[2] + gap)], [0.5 * lp[0], lp[1], lp[2]], zer, np, Grp, mp, cp) #y += lp[1]/2 y += 0.5 * lp[1] initM = [0, mDir, 0] #y += lm[1]/4; y += 0.25 * lm[1] #Magnet = rad.ObjFullMag([lm[0]/4,y,-lm[2]/2-gap/2-gapOffset], [lm[0]/2,lm[1]/2,lm[2]], initM, nm, Grp, mm, cm) Magnet = rad.ObjFullMag( [0.25 * lm[0], y, -0.5 * (lm[2] + gap) - gapOffset], [0.5 * lm[0], 0.5 * lm[1], lm[2]], initM, nm, Grp, mm, cm) #Mirrors rad.TrfZerPerp(Grp, [0, 0, 0], [1, 0, 0]) rad.TrfZerPara(Grp, zer, [0, 0, 1]) rad.TrfZerPerp(Grp, zer, [0, 1, 0]) return Grp, Pole, Magnet
def _apply_symmetry(g_id, xform): plane = _split_comma_field(xform.symmetryPlane, 'float') point = _split_comma_field(xform.symmetryPoint, 'float') if xform.symmetryType == 'parallel': radia.TrfZerPara(g_id, point, plane) if xform.symmetryType == 'perpendicular': radia.TrfZerPerp(g_id, point, plane)
def _apply_symmetry(g_id, xform): xform = PKDict(xform) plane = sirepo.util.split_comma_delimited_string(xform.symmetryPlane, float) point = sirepo.util.split_comma_delimited_string(xform.symmetryPoint, float) if xform.symmetryType == 'parallel': radia.TrfZerPara(g_id, point, plane) if xform.symmetryType == 'perpendicular': radia.TrfZerPerp(g_id, point, plane)
def Coil(ex): excitation = ex A = 127 * 31.75 j = excitation / A Pi = math.pi coil1 = rad.ObjRecCur([17.875, 163.5, 0], [31.75, 127, 400], [0, 0, j]) coil2 = rad.ObjArcCur([53.75, 163.5, 200], [20, 51.75], [-Pi / 2, 0], 127, 5, j, 'man', 'y') coil3 = rad.ObjArcCur([53.75, 53.75, 235.875], [46.25, 173.25], [Pi / 4, Pi / 2], 31.75, 5, -j, 'man', 'z') rad.TrfZerPerp(coil2, [0, 0, 0], [0, 0, 1]) rad.TrfZerPerp(coil2, [0, 0, 0], [1, -1, 0]) rad.TrfZerPerp(coil3, [0, 0, 0], [0, 0, 1]) rad.TrfZerPerp(coil3, [0, 0, 0], [1, -1, 0]) rad.TrfZerPerp(coil1, [0, 0, 0], [1, -1, 0]) coil = rad.ObjCnt([coil1, coil2, coil3]) rad.ObjDrwAtr(coil, [1, 0, 0], 0.001) return coil
def Und(lp, mp, np, cp, lm, mm, nm, cm, gap, gapOffset, numPer): zer = [0, 0, 0] Grp = rad.ObjCnt([]) #Principal Poles and Magnets y = lp[1] / 4 Pole = rad.ObjFullMag([lp[0] / 4, y, -lp[2] / 2 - gap / 2], [lp[0] / 2, lp[1] / 2, lp[2]], zer, np, Grp, mp, cp) y += lp[1] / 4 mDir = -1 for i in range(0, numPer): initM = [0, mDir, 0] mDir *= -1 y += lm[1] / 2 Magnet = rad.ObjFullMag( [lm[0] / 4, y, -lm[2] / 2 - gap / 2 - gapOffset], [lm[0] / 2, lm[1], lm[2]], initM, nm, Grp, mm, cm) y += (lm[1] + lp[1]) / 2 Pole = rad.ObjFullMag([lp[0] / 4, y, -lp[2] / 2 - gap / 2], [lp[0] / 2, lp[1], lp[2]], zer, np, Grp, mp, cp) y += lp[1] / 2 initM = [0, mDir, 0] y += lm[1] / 4 Magnet = rad.ObjFullMag([lm[0] / 4, y, -lm[2] / 2 - gap / 2 - gapOffset], [lm[0] / 2, lm[1] / 2, lm[2]], initM, nm, Grp, mm, cm) #Mirrors rad.TrfZerPerp(Grp, [0, 0, 0], [1, 0, 0]) rad.TrfZerPara(Grp, zer, [0, 0, 1]) rad.TrfZerPerp(Grp, zer, [0, 1, 0]) return Grp, Pole, Magnet
def HybridUndCenPart(_gap, _gap_ofst, _nper, _air, _lp, _ch_p, _np, _np_tip, _mp, _cp, _lm, _ch_m_xz, _ch_m_yz, _ch_m_yz_r, _nm, _mm, _cm, _use_ex_sym=False): zer = [0, 0, 0] grp = rad.ObjCnt([]) y = _lp[1] / 4 initM = [0, -1, 0] pole = rad.ObjFullMag([_lp[0] / 4, y, -_lp[2] / 2 - _gap / 2 - _ch_p], [_lp[0] / 2, _lp[1] / 2, _lp[2]], zer, [_np[0], int(_np[1] / 2 + 0.5), _np[2]], grp, _mp, _cp) if (_ch_p > 0.): # Pole Tip poleTip = rad.ObjThckPgn( _lp[0] / 4, _lp[0] / 2, [[y - _lp[1] / 4, -_gap / 2 - _ch_p], [y - _lp[1] / 4, -_gap / 2], [y + _lp[1] / 4 - _ch_p, -_gap / 2], [y + _lp[1] / 4, -_gap / 2 - _ch_p]], zer) rad.ObjDivMag( poleTip, [_np_tip[0], int(_np_tip[1] / 2 + 0.5), _np_tip[2]]) rad.MatApl(poleTip, _mp) rad.ObjDrwAtr(poleTip, _cp) rad.ObjAddToCnt(grp, [poleTip]) y += _lp[1] / 4 + _air + _lm[1] / 2 for i in range(_nper): magnet = rad.ObjThckPgn( _lm[0] / 4, _lm[0] / 2, [[y + _lm[1] / 2 - _ch_m_yz_r * _ch_m_yz, -_gap / 2 - _gap_ofst], [y + _lm[1] / 2, -_gap / 2 - _gap_ofst - _ch_m_yz], [y + _lm[1] / 2, -_gap / 2 - _gap_ofst - _lm[2] + _ch_m_yz], [ y + _lm[1] / 2 - _ch_m_yz_r * _ch_m_yz, -_gap / 2 - _gap_ofst - _lm[2] ], [ y - _lm[1] / 2 + _ch_m_yz_r * _ch_m_yz, -_gap / 2 - _gap_ofst - _lm[2] ], [y - _lm[1] / 2, -_gap / 2 - _gap_ofst - _lm[2] + _ch_m_yz], [y - _lm[1] / 2, -_gap / 2 - _gap_ofst - _ch_m_yz], [y - _lm[1] / 2 + _ch_m_yz_r * _ch_m_yz, -_gap / 2 - _gap_ofst]], initM) # Cuting Magnet Corners magnet = rad.ObjCutMag( magnet, [_lm[0] / 2 - _ch_m_xz, 0, -_gap / 2 - _gap_ofst], [1, 0, 1])[0] magnet = rad.ObjCutMag( magnet, [_lm[0] / 2 - _ch_m_xz, 0, -_gap / 2 - _gap_ofst - _lm[2]], [1, 0, -1])[0] rad.ObjDivMag(magnet, _nm) rad.MatApl(magnet, _mm) rad.ObjDrwAtr(magnet, _cm) rad.ObjAddToCnt(grp, [magnet]) initM[1] *= -1 y += _lm[1] / 2 + _lp[1] / 2 + _air if (i < _nper - 1): pole = rad.ObjFullMag( [_lp[0] / 4, y, -_lp[2] / 2 - _gap / 2 - _ch_p], [_lp[0] / 2, _lp[1], _lp[2]], zer, _np, grp, _mp, _cp) if (_ch_p > 0.): # Pole Tip poleTip = rad.ObjThckPgn(_lp[0] / 4, _lp[0] / 2, [[y - _lp[1] / 2, -_gap / 2 - _ch_p], [y - _lp[1] / 2 + _ch_p, -_gap / 2], [y + _lp[1] / 2 - _ch_p, -_gap / 2], [y + _lp[1] / 2, -_gap / 2 - _ch_p]], zer) rad.ObjDivMag(poleTip, _np_tip) rad.MatApl(poleTip, _mp) rad.ObjDrwAtr(poleTip, _cp) rad.ObjAddToCnt(grp, [poleTip]) y += _lm[1] / 2 + _lp[1] / 2 + _air y -= _lp[1] / 4 pole = rad.ObjFullMag([_lp[0] / 4, y, -_lp[2] / 2 - _gap / 2 - _ch_p], [_lp[0] / 2, _lp[1] / 2, _lp[2]], zer, [_np[0], int(_np[1] / 2 + 0.5), _np[2]], grp, _mp, _cp) if (_ch_p > 0.): # Pole Tip poleTip = rad.ObjThckPgn( _lp[0] / 4, _lp[0] / 2, [[y - _lp[1] / 4, -_gap / 2 - _ch_p], [y - _lp[1] / 4 + _ch_p, -_gap / 2], [y + _lp[1] / 4, -_gap / 2], [y + _lp[1] / 4, -_gap / 2 - _ch_p]], zer) rad.ObjDivMag( poleTip, [_np_tip[0], int(_np_tip[1] / 2 + 0.5), _np_tip[2]]) rad.MatApl(poleTip, _mp) rad.ObjDrwAtr(poleTip, _cp) rad.ObjAddToCnt(grp, [poleTip]) # Symmetries if ( _use_ex_sym ): # Some "non-physical" mirroring (applicable for calculation of central field only) y += _lp[1] / 4 rad.TrfZerPerp(grp, [0, y, 0], [0, 1, 0]) # Mirror left-right rad.TrfZerPerp(grp, [0, 2 * y, 0], [0, 1, 0]) # #"Physical" symmetries (applicable also for calculation of total structure with terminations) # rad.TrfZerPerp(grp, zer, [0,1,0]) #Mirror left-right # #Mirror front-back # rad.TrfZerPerp(grp, zer, [1,0,0]) # #Mirror top-bottom # rad.TrfZerPara(grp, zer, [0,0,1]) return grp
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 undulator( pole_lengths, pole_props, pole_segs, block_lengths, block_props, block_segs, gap_height, gap_offset, num_periods ): """ create hybrid undulator magnet arguments: pole_lengths = [lpx, lpy, lpz] = dimensions of the iron poles (mm) pole_props = magnetic properties of the iron poles (M-H curve) pole_segs = segmentation of the iron poles block_lengths = [lmx, lmy, lmz] = dimensions of the magnet blocks (mm) block_props = magnetic properties of the magnet blocks (remanent magnetization) block_segs = segmentation of the magnet blocks gap_height = undulator gap (mm) gap_offset = vertical offset of the magnet blocks w/rt the poles (mm) numPer = number of full periods of the undulator magnetic field return: Radia representations of undulator group, poles, permanent magnets """ zero = [0, 0, 0] # colors c_pole = [1, 0, 1] c_block = [0, 1, 1] # full magnet will be assembled into this Radia group grp = radia.ObjCnt([]) # principal poles and magnet blocks in octant(+,+,–) # -- half pole y = pole_lengths[1] / 4 pole = radia.ObjFullMag( [pole_lengths[0] / 4, y, -pole_lengths[2] / 2 - gap_height / 2], [pole_lengths[0] / 2, pole_lengths[1] / 2, pole_lengths[2]], zero, pole_segs, grp, pole_props, c_pole ) y += pole_lengths[1] / 4 # -- magnet and pole pairs m_dir = -1 for i in range(num_periods): init_m = [0, m_dir, 0] m_dir *= -1 y += block_lengths[1] / 2 magnet = radia.ObjFullMag( [ block_lengths[0] / 4, y, -block_lengths[2] / 2 - gap_height / 2 - gap_offset ], [ block_lengths[0] / 2, block_lengths[1], block_lengths[2] ], init_m, block_segs, grp, block_props, c_block ) y += (block_lengths[1] + pole_lengths[1]) / 2 pole = radia.ObjFullMag( [pole_lengths[0] / 4, y, -pole_lengths[2] / 2 - gap_height / 2], [pole_lengths[0] / 2, pole_lengths[1], pole_lengths[2]], zero, pole_segs, grp, pole_props, c_pole ) y += pole_lengths[1] / 2 # -- end magnet block init_m = [0, m_dir, 0] y += block_lengths[1] / 4 magnet = radia.ObjFullMag( [ block_lengths[0] / 4, y, -block_lengths[2] / 2 - gap_height / 2 - gap_offset ], [ block_lengths[0] / 2, block_lengths[1] / 2, block_lengths[2] ], init_m, block_segs, grp, block_props, c_block) # use mirror symmetry to define the full undulator radia.TrfZerPerp(grp, zero, [1, 0, 0]) # reflect in the (y,z) plane radia.TrfZerPara(grp, zero, [0, 0, 1]) # reflect in the (x,y) plane radia.TrfZerPerp(grp, zero, [0, 1, 0]) # reflect in the (z,x) plane return grp, pole, magnet
#main mat = Material() yoke = Yoke() #rad.ObjDrwOpenGL(yoke) excitation = 4832.5 rad.MatApl(yoke, mat) coil = Coil(excitation) #rad.ObjDrwOpenGL(coil) rad.TrfZerPara(yoke, [0, 0, 0], [1, 0, 0]) rad.TrfZerPara(yoke, [0, 0, 0], [0, 1, 0]) rad.TrfZerPerp(yoke, [0, 0, 0], [0, 0, 1]) rad.TrfZerPara(coil, [0, 0, 0], [1, 0, 0]) rad.TrfZerPara(coil, [0, 0, 0], [0, 1, 0]) full = rad.ObjCnt([yoke, coil]) #rad.ObjDrwOpenGL(full) t0 = time.time() res = rad.Solve(full, 0.0001, 10000) # No workers should exit rad.Solve assert mpi4py.MPI.COMM_WORLD.Get_rank() == 0 #print('Solved for Magnetizations in', round(time.time() - t0, 2), 's') expect = [ 9.991124106723865e-05, 1.7586937018625115, 0.009296872940670615, 744.0
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 hybrid_undulator(lpx, lpy, lpz, pole_properties, pole_segmentation, pole_color, lmx, lmz, magnet_properties, magnet_segmentation, magnet_color, gap, offset, period, period_number): """ create hybrid undulator magnet arguments: pole_dimensions = [lpx, lpy, lpz] = dimensions of the iron poles / mm pole_properties = magnetic properties of the iron poles (M-H curve) pole_separation = segmentation of the iron poles pole_color = [r,g,b] = color for the iron poles magnet_dimensions = [lmx, lmy, lmz] = dimensions of the magnet blocks / mm magnet_properties = magnetic properties of the magnet blocks (remanent magnetization) magnet_segmentation = segmentation of the magnet blocks magnet_color = [r,g,b] = color for the magnet blocks gap = undulator gap / mm offset = vertical offset / mm of the magnet blocks w/rt the poles period = length of one undulator period / mm period_number = number of full periods of the undulator magnetic field return: Radia representations of undulator group, poles, permanent magnets """ pole_dimensions = [lpx, lpy, lpz] lmy = period / 2. - pole_dimensions[1] magnet_dimensions = [lmx, lmy, lmz] zer = [0, 0, 0] # full magnet will be assembled into this Radia group grp = rad.ObjCnt([]) # principal poles and magnet blocks in octant(+,+,–) # -- half pole y = pole_dimensions[1] / 4 pole = rad.ObjFullMag([pole_dimensions[0] / 4, y, -pole_dimensions[2] / 2 - gap / 2], [pole_dimensions[0] / 2, pole_dimensions[1] / 2, pole_dimensions[2]], zer, pole_segmentation, grp, pole_properties, pole_color) y += pole_dimensions[1] / 4 # -- magnet and pole pairs magnetization_dir = -1 for i in range(0, period_number): init_magnetization = [0, magnetization_dir, 0] magnetization_dir *= -1 y += magnet_dimensions[1] / 2 magnet = rad.ObjFullMag([magnet_dimensions[0] / 4, y, -magnet_dimensions[2] / 2 - gap / 2 - offset], [magnet_dimensions[0] / 2, magnet_dimensions[1], magnet_dimensions[2]], init_magnetization, magnet_segmentation, grp, magnet_properties, magnet_color) y += (magnet_dimensions[1] + pole_dimensions[1]) / 2 pole = rad.ObjFullMag([pole_dimensions[0] / 4, y, -pole_dimensions[2] / 2 - gap / 2], [pole_dimensions[0] / 2, pole_dimensions[1], pole_dimensions[2]], zer, pole_segmentation, grp, pole_properties, pole_color) y += pole_dimensions[1] / 2 # -- end magnet block init_magnetization = [0, magnetization_dir, 0] y += magnet_dimensions[1] / 4 magnet = rad.ObjFullMag([magnet_dimensions[0] / 4, y, -magnet_dimensions[2] / 2 - gap / 2 - offset], [magnet_dimensions[0] / 2, magnet_dimensions[1] / 2, magnet_dimensions[2]], init_magnetization, magnet_segmentation, grp, magnet_properties, magnet_color) # use mirror symmetry to define the full undulator rad.TrfZerPerp(grp, zer, [1, 0, 0]) # reflect in the (y,z) plane rad.TrfZerPara(grp, zer, [0, 0, 1]) # reflect in the (x,y) plane rad.TrfZerPerp(grp, zer, [0, 1, 0]) # reflect in the (z,x) plane return grp, pole, magnet
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