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 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 wradFieldRotate(self, pivot_origin, pivot_vector, rot_magnitude): '''trying to write a rotation function # u' = quq* #u is point #q is quaternion representation of rotation angle ( sin (th/2)i, sin(th/2)j, sin (th/2)k, cos (th/2))''' q = R.from_quat([ pivot_vector[0] * np.sin(rot_magnitude / 2.0), pivot_vector[1] * np.sin(rot_magnitude / 2.0), pivot_vector[2] * np.sin(rot_magnitude / 2.0), np.cos(rot_magnitude / 2.0) ]) #rotate magnetisation vector self.magnetisation = q.apply(self.magnetisation) self.material.M = self.magnetisation.tolist() self.material = wrdm.wradMatLin(self.material.ksi, self.material.M) rd.MatApl(self.radobj, self.material.radobj) # rotate colour q = R.from_quat([ pivot_vector[0] * np.sin(rot_magnitude / 2.0), pivot_vector[1] * np.sin(rot_magnitude / 2.0), pivot_vector[2] * np.sin(rot_magnitude / 2.0), np.cos(rot_magnitude / 2.0), ]) tmpcol = [(4 * x - 2) for x in self.colour] tmpcol = q.apply(tmpcol) self.colour = [(2 + x) / 4.0 for x in tmpcol] rd.ObjDrwAtr(self.radobj, self.colour, self.linethickness)
def draw(radia_object): if radia_object is None: return False _rad.ObjDrwAtr(radia_object, [0, 0.5, 1], 0.001) _rad.ObjDrwOpenGL(radia_object) return True
def wradObjDrwAtr(self, colour='default', linethickness=2): if colour == 'default': self.set_default_colour = True colour = [(2 + y) / 4.0 for y in self.material.M] else: self.set_default_colour = False self.colour = colour self.linethickness = linethickness rd.ObjDrwAtr(self.radobj, self.colour, self.linethickness)
def sp8(pos, per, gap, gapx, phase, lxc, lzc, colc, lxs, lzs, cols, airgap, br, nper): """ create "Spring8" undulator """ wc = [lxc, per/4 - airgap, lzc] px = 0 pz = gap/2 + lzc/2 g1 = undparts(pos + [px, -phase/2, pz], wc, wc, nper, per, br, 1) rad.ObjDrwAtr(g1, colc) g2 = undparts(pos + [px, -phase/2, -pz], wc, wc, nper, per, -br, -1) rad.ObjDrwAtr(g2, colc) wc = [lxs, per/4 - airgap, lzs] px = lxc/2 + gapx + lxs/2 pz = gap/2 + lzs/2 g3 = undparts(pos + [px, phase/2, pz], wc, wc, nper, per, br, 1) rad.ObjDrwAtr(g3, cols) g4 = undparts(pos + [px, phase/2, -pz], wc, wc, nper, per, br, -1) rad.ObjDrwAtr(g4, cols) g5 = undparts(pos + [-px, phase/2, pz], wc, wc, nper, per, -br, 1) rad.ObjDrwAtr(g5, cols) g6 = undparts(pos + [-px, phase/2, -pz], wc, wc, nper, per, -br, -1) rad.ObjDrwAtr(g6, cols) g = rad.ObjCnt([g1, g2, g3, g4, g5, g6]) return g
def undparts(po, wv, wh, nnp, per, br, si, axe=0.): """ create Pure Permanent Magnet """ g = rad.ObjCnt([]) p = po - [0, nnp*per/2, 0] for i in range(0,4*nnp + 1): if i == 0 or i == 4*nnp: s = 0.5 else: s = 1. if i%2 == 0: w = wv else: w = wh t = -(i - 1)*np.pi/2*si m = np.array([np.sin(axe)*np.sin(t), np.cos(t), np.cos(axe)*np.sin(t)])*br*s ma = rad.ObjRecMag(p, w, m) rad.ObjAddToCnt(g, [ma]) p = p + [0, per/4, 0] rad.ObjDrwAtr(g, [0, 0, 1]) return g
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 wradFieldInvert(self): '''trying to write a field inversion function''' for i in range(len(self.magnetisation)): u = -self.magnetisation[i] self.magnetisation[i] = u self.material.M = self.magnetisation fieldinvert = rd.TrfInv(self.radobj) rd.TrfOrnt(self.radobj, fieldinvert) #invert the colour tmp = np.zeros(3) #reflect colour tmpcol = [(4 * x - 2) for x in self.colour] tmpcol[0] = -tmpcol[0] tmpcol[1] = -tmpcol[1] tmpcol[2] = -tmpcol[2] self.colour = [(2 + x) / 4.0 for x in tmpcol] rd.ObjDrwAtr(self.radobj, self.colour, self.linethickness)
def wradRotate(self, pivot_origin, pivot_vector, rot_magnitude): '''trying to write a rotation function # u' = quq* #u is point #q is quaternion representation of rotation angle ( sin (th/2)i, sin(th/2)j, sin (th/2)k, cos (th/2))''' q = R.from_quat([ pivot_vector[0] * np.sin(rot_magnitude / 2.0), pivot_vector[1] * np.sin(rot_magnitude / 2.0), pivot_vector[2] * np.sin(rot_magnitude / 2.0), np.cos(rot_magnitude / 2.0) ]) #rotate vertices for i in range(len(self.vertices)): u = self.vertices[i] - pivot_origin self.vertices[i] = q.apply(u) #rotate magnetisation vector self.magnetisation = (q.apply(self.magnetisation)).tolist() self.material.M = self.magnetisation # rotate colour q = R.from_quat([ pivot_vector[0] * np.sin(rot_magnitude / 2.0), pivot_vector[1] * np.sin(rot_magnitude / 2.0), pivot_vector[2] * np.sin(rot_magnitude / 2.0), np.cos(rot_magnitude / 2.0), ]) tmpcol = [(4 * x - 2) for x in self.colour] tmpcol = q.apply(tmpcol) self.colour = [(2 + x) / 4.0 for x in tmpcol] rd.ObjDrwAtr(self.radobj, self.colour, self.linethickness) #rotate radia object rota = rd.TrfRot(pivot_origin, pivot_vector, rot_magnitude) rd.TrfOrnt(self.radobj, rota)
def make_dipole(pole_dimensions, center, length, current=-10000, trimesh_mode=0, triangle_min_size=TRIANGLE_MIN_SIZE, triangle_max_size=TRIANGLE_MAX_SIZE, longitudinal_divisions=4): """ Construct a complete H-dipole made of iron. :param pole_dimensions: (dict) Parameters describing geometry of pole piece. See `_create_point_table`. :param center: (float) Center point of dipole in x (longitudinal center for beam frame). :param length: (float) Length of the dipole in x :param current: (float) Current carried by dipole coils (default: -10000) :param trimesh_mode: (int) If 0 (default) then the pole piece is divisioned into polygons based on point ordering from coordinate list. If != 0 then a Triangular mesh is automatically generated. :param longitudinal_divisions: (int) Number of slices to divide up the dipole into along the x-axis (default: 4) :return: """ # coil_factor increases coil size slightly to accommodate sharp corners of pole piece coil_length_factor = 1.005 coil_height_factor = 3. / 4. coil_or_factor = 0.85 # Geometry for the poles table_quadrant_one = _create_point_table(**pole_dimensions) top_coodinates = _get_all_points_top(table_quadrant_one) bottom_coordinates = _get_all_points_bottom(top_coodinates) top_pole = create_pole(top_coodinates, center, length, mode=trimesh_mode, triangle_min_size=triangle_min_size, triangle_max_size=triangle_max_size) bottom_pole = create_pole(bottom_coordinates, center, length, mode=trimesh_mode, triangle_min_size=triangle_min_size, triangle_max_size=triangle_max_size) # Material for the poles (uses Iron) ironmat = rad.MatSatIsoFrm([20000, 2], [0.1, 2], [0.1, 2]) rad.MatApl(top_pole, ironmat) rad.MatApl(bottom_pole, ironmat) # Coils coil_outer_radius = pole_dimensions['pole_separation'] * coil_or_factor top_coil = make_racetrack_coil( center=[ 0, 0.0, pole_dimensions['gap_height'] + pole_dimensions['pole_height'] / 2. ], radii=[0.1, coil_outer_radius], sizes=[ length * coil_length_factor, pole_dimensions['pole_width'] * 2 * coil_length_factor, pole_dimensions['pole_height'] * coil_height_factor ], current=current) bottom_coil = make_racetrack_coil(center=[ 0, 0.0, -1. * (pole_dimensions['gap_height'] + pole_dimensions['pole_height'] / 2.) ], radii=[0.1, coil_outer_radius], sizes=[ length * coil_length_factor, pole_dimensions['pole_width'] * 2 * coil_length_factor, pole_dimensions['pole_height'] * coil_height_factor ], current=current) # Visualization rad.ObjDrwAtr(top_pole, [0, 0.4, 0.8]) rad.ObjDrwAtr(bottom_pole, [0, 0.4, 0.8]) rad.ObjDrwAtr(top_coil, [0.2, 0.9, 0.6]) rad.ObjDrwAtr(bottom_coil, [0.2, 0.9, 0.6]) # Element Division rad.ObjDivMag(top_pole, [longitudinal_divisions, 1, 1]) rad.ObjDivMag(bottom_pole, [longitudinal_divisions, 1, 1]) return rad.ObjCnt([top_pole, bottom_pole, top_coil, bottom_coil])
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 MagnetArray(_per, _nper, _po, _w, _si, _type, _cx, _cz, _br, _mu, _ndiv, _bs1, _s1, _bs2, _s2, _bs3, _s3, _bs2dz=0, _qp_ind_mag=None, _qp_dz=0): u = rad.ObjCnt([]) Le = _bs1+_s1+_bs2+_s2+_bs3+_s3 Lc = (_nper+0.25)*_per p = [_po[0],_po[1]-(Lc/2+Le),_po[2]] #po-{0,(Lc/2+Le),0} nMagTot = 4*_nper+7 iMagCen = int(nMagTot/2.) #0-based index of the central magnet #print('iMagCen =', iMagCen) #DEBUG QP_IsDef = False; QP_DispIsConst = True nQP_Disp = 0 if(_qp_ind_mag is not None): if(isinstance(_qp_ind_mag, list) or isinstance(_qp_ind_mag, array)): nQP_Disp = len(_qp_ind_mag) if(nQP_Disp > 0): QP_IsDef = True if(isinstance(_qp_dz, list) or isinstance(_qp_dz, array)): QP_DispIsConst = False elif(_qp_dz==0): QP_IsDef = False for i in range(nMagTot): wc = copy(_w) if(i==0): p[1] += _bs1/2 wc[1] = _bs1 elif(i==1): p[1] += _bs1/2+_s1+_bs2/2 wc[1] = _bs2 elif(i==2): p[1] += _bs2/2+_s2+_bs3/2 wc[1] = _bs3 elif(i==3): p[1] += _bs3/2+_s3+_per/8 elif((i>3) and (i<4*_nper+4)): p[1] += _per/4 elif(i==4*_nper+4): p[1] += _per/8+_s3+_bs3/2 wc[1] = _bs3 elif(i==4*_nper+5): p[1] += _bs3/2+_s2+_bs2/2 wc[1] = _bs2 elif(i==4*_nper+6): p[1] += _bs2/2+_s1+_bs1/2 wc[1] = _bs1 pc = copy(p) if((i==1) or (i==4*_nper+5)): if(_si==1): pc[2] += _bs2dz else: pc[2] -= _bs2dz if(QP_IsDef): for iQP in range(nQP_Disp): if(i == _qp_ind_mag[iQP] + iMagCen): qpdz = _qp_dz if(not QP_DispIsConst): qpdz = _qp_dz[iQP] pc[2] += qpdz #print('Abs. Ind. of Mag. to be Displaced:', i) #DEBUG break t = -i*pi/2*_si mcol = [0.0,cos(t),sin(t)] m = [mcol[0],mcol[1]*_br,mcol[2]*_br] ma = MagnetBlock(pc, wc, _cx, _cz, _type, _ndiv, m) mcol = [0.27, 0.9*abs(mcol[1]), 0.9*abs(mcol[2])] rad.ObjDrwAtr(ma, mcol, 0.0001) rad.ObjAddToCnt(u, [ma]) mat = rad.MatLin(_mu, abs(_br)) rad.MatApl(u, mat) return u
def Yoke(): p0 = [58.527, 294.236] p1 = [0, 294.236] p2 = [0, 229] p3 = [35.75, 229] p4 = [35.75, 98] p5 = [17.5, 79.75] p6 = [17.5, 78.268] p9 = [78.268, 17.5] p10 = [79.75, 17.5] p11 = [98, 32.75] p12 = [229, 35.75] p13 = [229, 0] p14 = [294.236, 0] p15 = [294.236, 58.827] poly1 = [p0, p1, p2, p3, p4, p5, p6] poly4 = [p9, p10, p11, p12, p13, p14, p15] #Hyperbolic h = 54 #OC: checking reduced segmentation of the pole tip #nStep=21 nStep = 11 xmin = 23.2126 xmax = h / math.sqrt(2) xstep = (xmax - xmin) / (nStep - 1) ymin = xmin ymax = xmax ystep = xstep xlist = [] ylist = [] poly2 = [] poly3 = [] for i in range(nStep): x = xmin + i * xstep y = h * h / x / 2 poly2.append([x, y]) i += 1 for i in range(nStep): y = ymax - i * ystep x = h * h / y / 2 poly3.append([x, y]) i += 1 #OC del poly3[0] #OCTEST #print(poly1) #print(' ') #print(poly2) #print(' ') #print(poly3) #print(' ') #print(poly4) poly = poly1 + poly2 + poly3 + poly4 #2D geometry #Triangularization newlist = [] for i in range(len(poly)): newlist.append([1, 1]) i += 1 poly3D = rad.ObjMltExtTri(100, 200, poly, newlist, 'z', [0, 0, 0], 'ki->Numb,TriAngMin->30,TriAreaMax->1000') #chamfer cham_y = 6.7 + h cham_ang = 30 / 180 * math.pi pch = [cham_y / math.sqrt(2), cham_y / math.sqrt(2), 200] vch = [-1, -1, math.sqrt(2) * math.tan(cham_ang)] poly3D = rad.ObjCutMag(poly3D, pch, vch, "Frame->Lab")[0] rad.ObjDivMag(poly3D, [[1, 1], [1, 1], [5, 0.2]], 'pln', [[1, 0, 0], [0, 1, 0], [0, 0, 1]], "Frame->LabTot") rad.ObjDrwAtr(poly3D, [1, 1, 0], 0.001) return poly3D
slicePgn.append( [_r * cos(phi) * cosTheta, _r * sin(phi) * cosTheta]) phi += dPhi allSlicePgns.append([slicePgn, z]) z += dz allSlicePgns.append([[[0., 0.]], _r]) return rad.ObjMltExtPgn(allSlicePgns, _M) #*********************************Entry point if __name__ == "__main__": #Build the Geometry aSpherMag = SphericalVolume(1, 15, 15, [1, 0, 0]) #Apply Color to it rad.ObjDrwAtr(aSpherMag, [0, 0.5, 0.8]) #Display the Geometry in 3D Viewer rad.ObjDrwOpenGL(aSpherMag) #Calculate Magnetic Field print('Field in the Center = ', rad.Fld(aSpherMag, 'b', [0, 0, 0])) #Horizontal Field vs Longitudinal Position yMin = -0.99 yMax = 0.99 ny = 301 yStep = (yMax - yMin) / (ny - 1) BxVsY = rad.Fld(aSpherMag, 'bx', [[0, yMin + i * yStep, 0] for i in range(ny)])
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 wradReflect(self, reflection_origin, reflection_vector): '''trying to write a reflection function # u' = quq #u is point #q is quaternion representation of rotation angle ( sin (th/2)i, sin(th/2)j, sin (th/2)k, cos (th/2))''' r = reflection_vector / np.linalg.norm( reflection_vector) #ai + bj + ck tmp = np.zeros(3) #reflect vertices for i in range(len(self.vertices)): u = self.vertices[i] - reflection_origin # xi + yj + zk #i x(-a^2 + b^2 + c^2) -2aby -2acz #j y(-b^2 + a^2 + c^2) -2abx -2bcz #k z(-c^2 + a^2 + b^2) -2acx -2bcy tmp[0] = u[0] * (-r[0]**2 + r[1]**2 + r[2]**2) - 2 * r[0] * (r[1] * u[1] + r[2] * u[2]) tmp[1] = u[1] * (-r[1]**2 + r[0]**2 + r[2]**2) - 2 * r[1] * (r[0] * u[0] + r[2] * u[2]) tmp[2] = u[2] * (-r[2]**2 + r[0]**2 + r[1]**2) - 2 * r[2] * (r[0] * u[0] + r[1] * u[1]) self.vertices[i] = tmp #reflect magnetisation vector u = self.magnetisation tmp[0] = u[0] * (-r[0]**2 + r[1]**2 + r[2]**2) - 2 * r[0] * (r[1] * u[1] + r[2] * u[2]) tmp[1] = u[1] * (-r[1]**2 + r[0]**2 + r[2]**2) - 2 * r[1] * (r[0] * u[0] + r[2] * u[2]) tmp[2] = u[2] * (-r[2]**2 + r[0]**2 + r[1]**2) - 2 * r[2] * (r[0] * u[0] + r[1] * u[1]) self.magnetisation = tmp self.material.M = self.magnetisation #is colour applied at this level? #reflect the colour r = reflection_vector / np.linalg.norm( reflection_vector) #ai + bj + ck tmp = np.zeros(3) #reflect colour tmpcol = [(4 * x - 2) for x in self.colour] u = tmpcol # xi + yj + zk #i x(-a^2 + b^2 + c^2) -2aby -2acz #j y(-b^2 + a^2 + c^2) -2abx -2bcz #k z(-c^2 + a^2 + b^2) -2acx -2bcy tmp[0] = u[0] * (-r[0]**2 + r[1]**2 + r[2]**2) - 2 * r[0] * (r[1] * u[1] + r[2] * u[2]) tmp[1] = u[1] * (-r[1]**2 + r[0]**2 + r[2]**2) - 2 * r[1] * (r[0] * u[0] + r[2] * u[2]) tmp[2] = u[2] * (-r[2]**2 + r[0]**2 + r[1]**2) - 2 * r[2] * (r[0] * u[0] + r[1] * u[1]) tmpcol = tmp self.colour = [(2 + x) / 4.0 for x in tmpcol] rd.ObjDrwAtr(self.radobj, self.colour, self.linethickness) #reflect radia object refl = rd.TrfPlSym(reflection_origin, reflection_vector) rd.TrfOrnt(self.radobj, refl)
def apply_color(g_id, color): radia.ObjDrwAtr(g_id, color)
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