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
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)]) #Plot the Results uti_plot1d( BxVsY, [yMin, yMax, ny],
rad.FldInt(g, 'inf', 'ibz', [xMin + ix * xStep, -300., zc], [xMin + ix * xStep, 300., zc]) for ix in range(nx) ] return BzVsY, [yMin, yMax, ny], IBzVsX, [xMin, xMax, nx] #*********************************Entry point if __name__ == "__main__": #Build the Geometry g = BuildGeometry() print('SCW Geometry Index:', g) #Display the Geometry in 3D Viewer rad.ObjDrwOpenGL(g) #Calculate Magnetic Field BzVsY, MeshY, IBzVsX, MeshX = CalcField(g) print('Field in Center:', BzVsY[0], 'T') print('Field Integral in Center:', IBzVsX[0], 'T.mm') #Plot the Results uti_plot.uti_plot1d( BzVsY, MeshY, ['Longitudinal Position [mm]', 'Bz [T]', 'Vertical Magnetic Field']) uti_plot.uti_plot1d(IBzVsX, MeshX, [ 'Horizontal Position [mm]', 'Integral of Bz [T.mm]', 'Vertical Magnetic Field Integral' ])
#ll = per/2 - lp[1] ll = 0.5 * per - lp[1] #Magnet Parameters lm = [65, ll, 45] nm = [1, 3, 1] cm = [0, 1, 1] #Magnetic Materials mp, mm = Materials() #Build the Structure und, pole, magnet = Und(lp, mp, np, cp, lm, mm, nm, cm, gap, gapOffset, numPer) #Show the Structure in 3D Viewer rad.ObjDrwOpenGL(und) #Solve the Magnetization Problem t0 = time.time() res = rad.Solve(und, 0.0003, 1000) print('Solved for Magnetization in', round(time.time() - t0, 2), 's') print('Relaxation Results:', res) print('Peak Magnetic Field:', round(rad.Fld(und, 'bz', [0, 0, 0]), 5), 'T') #Calculate Magnetic Field BzVsY, MeshY = CalcField(und, per, numPer) #Extracting Characteristics of Magnetic Materials MeshH_Pole = [-0.002, 0.002, 201] M_Pole = GetMagnMaterCompMvsH(MeshH_Pole, pole, 'x', 'x') MeshH_Mag = [-1, 1, 201]
_lp=lp, _ch_p=chPole, _np=np, _np_tip=npTip, _mp=mp, _cp=cp, _lm=lm, _ch_m_xz=chMagXZ, _ch_m_yz=chMagYZ, _ch_m_yz_r=chMagYZrat, _nm=nm, _mm=mm, _cm=cm) #Display the Geometry if (rank <= 0): rad.ObjDrwOpenGL(grp) #Construct Interaction Matrix t0 = time.time() IM = rad.RlxPre(grp) if (rank <= 0): print('Interaction Matrix was set up in:', round(time.time() - t0, 2), 's') #Perform the Relaxation t0 = time.time() res = rad.RlxAuto(IM, 0.001, 5000) if (rank <= 0): print('Relaxation took:', round(time.time() - t0, 2), 's') print('Relaxation Results:', res)
if __name__ == '__main__': test_hyper_params = parameters.model_parameters( Mova=0, periods=8, periodlength=65, nominal_fmagnet_dimensions=[30.0, 0.0, 30.0], M=1.3, #nominal_cmagnet_dimensions = [10.0,0.0,15.0], nominal_vcmagnet_dimensions=[7.5, 0.0, 12.5], nominal_hcmagnet_dimensions=[7.5, 0.0, 15.0], compappleseparation=15, apple_clampcut=5.0, comp_magnet_chamfer=[3.0, 0.0, 3.0], magnets_per_period=4, gap=10, rowshift=0, shiftmode='circular', rowtorowgap=1.0, ) id_10eV = id.compensatedAPPLEv2(test_hyper_params) # case1 = af.CaseSolution(id_10eV) case1.calculate_B_field() print(case1.bmax) rd.ObjDrwOpenGL(id_10eV.cont.radobj) plt.plot(case1.bfield[:, 0], case1.bfield[:, 1], case1.bfield[:, 3]) plt.show() print(1)
periods=10, periodlength=15, block_subdivision=[1, 1, 1], nominal_fmagnet_dimensions=[15.0, 0.0, 15.0], nominal_cmagnet_dimensions=[10.0, 0.0, 7.5], compappleseparation=7.5, apple_clampcut=3.0, comp_magnet_chamfer=[3.0, 0.0, 3.0], magnets_per_period=4, gap=2, rowshift=0, shiftmode='circular') a = compensatedAPPLEv2(testparams) #draw object rd.ObjDrwOpenGL(a.cont.radobj) #solve object a.cont.wradSolve() #calculate field at a point aa = rd.Fld(a.cont.radobj, 'bxbybz', [0, 0, 10]) #define line start and end points linestart = [0, -60, 0] lineend = [0, 60, 0] #calculate field on a line bb = rd.FldLst(a.cont.radobj, 'bxbybz', linestart, lineend, int(1 + (lineend[1] - linestart[1]) / 0.1), 'arg', linestart[1])
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) print('Magn. Material index:', mat, ' appled to object:', mag01) mag00a = rad.ObjFullMag([10,0,40],[12,18,5],[0,0,1],[2,2,2],cnt02,mat,[0.5,0,0]) rad.ObjDrwOpenGL(cnt02) data_cnt = rad.ObjDrwVTK(cnt02) print(data_cnt) objAfterCut = rad.ObjCutMag(mag00a,[10,0,40],[1,1,1]) #,'Frame->Lab') print('Indexes of objects after cutting:', objAfterCut) #rad.ObjDrwOpenGL(objAfterCut[0]) print(rad.UtiDmp(mag01, 'asc')) print(rad.UtiDmp(mat, 'asc')) #print(rad.UtiDmp(107, 'asc')) magDpl = rad.ObjDpl(mag, 'FreeSym->False')
e = appleComplete(AII) f = compensatedAppleComplete(AII) #comp upper beam # f = compUpperBeam(AII) # rd.ObjDrwOpenGL(f.radobj) #comp lower beam #rota = rd.TrfRot([0,0,0],[1,1,1],np.pi/7.0) # rd.ObjDrwOpenGL(c.radobj) # rd.ObjDrwOpenGL(d.radobj) # rd.ObjDrwOpenGL(e.radobj) rd.ObjDrwOpenGL(f.radobj) #EXAMPLES OF TRANSFORMATIONS #b.wradRotate([0,0,0],[1,0,0],np.pi) #b.wradTranslate([10,20,30]) #b.wradReflect([0,0,0], [4,1,1]) #Lower APPLE BEAM #my apple model print(AII.origin) print(b.objectlist) #rd.ObjDrwOpenGL(a.radobj) #rd.ObjDrwOpenGL(b.radobj)
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
trf03 = rad.TrfTrsl([30,10,0]) trf04 = rad.TrfInv() trf05 = rad.TrfCmbL(trf01, trf04) trf06 = rad.TrfCmbR(trf01, trf04) #rad.TrfMlt(mag01, trf03, 3) rad.TrfOrnt(mag01, trf06) #rad.ObjDrwOpenGL(mag01) dmp = rad.UtiDmp([mag01, trf02], 'bin') #print(dmp) elemsRest = rad.UtiDmpPrs(dmp) print('Indexes of restored elements:', elemsRest) rad.ObjDrwOpenGL(elemsRest[0]) print(rad.UtiDmp(elemsRest[0], 'asc')) print(rad.UtiDmp(elemsRest[1], 'asc')) #rad.UtiDel(elemsRest[0]) #print(rad.UtiDmp(elemsRest[0], 'asc')) print(rad.UtiDmp(trf03, 'asc')) rad.UtiDelAll() print(rad.UtiDmp(trf03, 'asc')) #cutMag = rad.ObjCutMag(mag, [0,0,50], [0,0,1], "Frame->Lab") #print('Obj. indexes after magnet cut:', cutMag)
self.name = name if __name__ == '__main__': mymodelparams = parameters.model_parameters(magnets_per_period = 6, periods = 1) a = HalbachArray(mymodelparams) b = HalbachTermination_APPLE(mymodelparams) c = MagnetRow(a,b) a.cont.wradSolve(0.001, 1000) print('{}{}'.format(a.cont.radobj,b)) # rd.ObjDrwOpenGL(a.cont.radobj) rd.ObjDrwOpenGL(b.cont.radobj) rd.ObjDrwOpenGL(c.cont.radobj) z = 17.5; x1 = 15.25; x2 = 0; ymax = 400; nump = 2001 Bz1 = rd.FldLst(a.cont.radobj, 'bz', [x1,-ymax,z], [x1,ymax,z], nump, 'arg', 0) Bz2 = rd.FldLst(a.cont.radobj, 'bz', [x2,-ymax,z], [x2,ymax,z], nump, 'arg',0 ) Bx1 = rd.FldLst(a.cont.radobj, 'bx', [x1,-ymax,z], [x1,ymax,z], nump, 'arg', 0) Bx2 = rd.FldLst(a.cont.radobj, 'bx', [x2,-ymax,z], [x2,ymax,z], nump, 'arg',0 ) Bz1 = np.array(Bz1) Bz2 = np.array(Bz2)
n1 = [nx, 3, 2] #pole faces n2 = [nx, 2, 2] #small vertical arm n3 = [nx, 2, 2] n4 = [nx, 2, 2] #horizontal arm n5 = [nx, 2, 2] n6 = [nx, 2, 2] #inside the coil #Build the geometry t0 = time() rad.UtiDelAll() ironmat = rad.MatSatIsoFrm([20000, 2], [0.1, 2], [0.1, 2]) t = Geom(1) size = rad.ObjDegFre(t) #Display the geometry rad.ObjDrwOpenGL(t) #Solve the geometry t1 = time() res = rad.Solve(t, 0.0001, 1500) t2 = time() #Print the results b0 = rad.Fld(t, 'Bz', [0, 0, 0]) bampere = (-4 * pi * current / gap) / 10000 r = b0 / bampere print( 'Solving results for the segmentation by elliptical cylinders in the corners:' ) print('Mag_Max H_Max N_Iter =', round(res[1], 5), 'T ', round(res[2], 5),