def arc(r0, R, e, n, phi0, phi): e1 = e / np.sqrt(np.sum(e * e)) # normalize en = n / np.sqrt(np.sum(n * n)) # normalize ip = np.argmax(phi > phi0) # find end index e2 = np.cross(en, e1) cp = np.cos(np.radians(phi[:ip])) sp = np.sin(np.radians(phi[:ip])) # r = cp*e1+sp*e2 r = np.zeros((3, ip)) r[0, :] = r0[0] + R * (cp * e1[0] + sp * e2[0]) r[1, :] = r0[1] + R * (cp * e1[1] + sp * e2[1]) r[2, :] = r0[2] + R * (cp * e1[2] + sp * e2[2]) return r
def drawArc(self, centerxy, startxy, endxy): v1 = np.array([startxy[0] - centerxy[0], startxy[1] - centerxy[1]]) v2 = np.array([endxy[0] - centerxy[0], endxy[1] - centerxy[1]]) cos夹角 = (v1[0] * v2[0] + v1[1] * v2[1]) / (np.sqrt(v1.dot(v1)) * np.sqrt(v2.dot(v2))) angle_between = np.arccos(cos夹角) radius = np.sqrt(v1.dot(v1)) angle_start = np.arctan2(v1[1], v1[0]) angle_end = angle_start + angle_between self.ctx.move_to(startxy[0], startxy[1]) self.ctx.arc(centerxy[0], centerxy[1], radius, angle_start, angle_end) # self.ctx.arc_negative(centerxy[0], centerxy[1], radius, angle_start, angle_end) return []
def gauss(x, p, mode='eval'): """Gaussian defined by amplitide Function: :math:`f(x) = k + m*x + p_2 \exp\left(\\frac{-(x - p_0)^2}{2p_1^2}\\right)` """ try: if mode == 'eval': cent=p[0];wid=p[1];amp=p[2];const=p[3];slope=p[4] #out = const + amp * np.exp(-1.0 * (x - cent)**2 / (2 * wid**2)) #Inserted the 0.5* because we want FWHM out, not HWHM #out = const + slope*x + amp * np.exp(-1.0 * (x - cent)**2 / (2 * (0.5*wid)**2)) conversion =2.0*np.sqrt(2.0*np.log(2)) #Hutchings et al. Introduction to the characterisation of residual stress by neutron diffraction.2005. Page 159 #conversion = 2.0 out = const + slope*x + amp * np.exp(-1.0 * (x - cent)**2 / (2 * (wid/conversion)**2)) elif mode == 'params': out = ['cent', 'sigma', 'amp', 'const', 'slope'] elif mode == 'name': out = "Gaussian" elif mode == 'guess': g = fitfuncs.peakguess(x, p) out = [g[0], g[1] / (4 * np.log(2)), g[3], g[4], g[5]] else: out = [] except: out = [0,0,0,0,0] return out
def ltfree(lK, Rg, alpha, beta, delta, omegat): ltx = np.cos(alpha) * np.cos(np.radians(omegat) + delta) + np.cos( beta) * lK - np.cos(np.radians(omegat)) * Rg lty = np.sin(np.radians(omegat) + delta) - np.sin(np.radians(omegat)) * Rg ltz = -np.sin(alpha) * np.cos(np.radians(omegat) + delta) + np.sin(beta) * lK return np.sqrt(ltx * ltx + lty * lty + ltz * ltz)
def cosgammag(lK, Rg, beta, delta, omegat): alpha = 0.5*np.pi-beta cb = np.cos(beta) sb = np.sin(beta) cot = np.cos(np.radians(omegat)) sot = np.sin(np.radians(omegat)) cotd = np.cos(np.radians(omegat)+delta) sotd = np.sin(np.radians(omegat)+delta) ltx = np.cos(alpha)*cotd + cb*lK - cot*Rg lty = sotd - sot*Rg ltz = -np.sin(alpha)*cotd + sb*lK Rwx = cot*Rg Rwy = sot*Rg Rwz = 0 lt = np.sqrt(ltx*ltx+lty*lty+ltz*ltz) return (Rwx*lty-Rwy*ltx)/(lt*Rg)
def vt(lK, Rg, beta, delta, omegat): alpha = 0.5*np.pi-beta cb = np.cos(beta) sb = np.sin(beta) ca = np.cos(alpha) sa = np.sin(alpha) cot = np.cos(np.radians(omegat)) sot = np.sin(np.radians(omegat)) cotd = np.cos(np.radians(omegat)+delta) sotd = np.sin(np.radians(omegat)+delta) ltx = ca*cotd + cb*lK - cot*Rg lty = sotd - sot*Rg ltz = -sa*cotd + sb*lK lt = np.sqrt(ltx*ltx+lty*lty+ltz*ltz) dltxdt = -ca*sotd + sot*Rg dltydt = cotd - cot*Rg dltzdt = sa*sotd return (ltx*dltxdt+lty*dltydt+ltz*dltzdt)/lt
def cosgammak(lK, Rg, beta, delta, omegat): alpha = 0.5*np.pi-beta cb = np.cos(beta) sb = np.sin(beta) ca = np.cos(alpha) sa = np.sin(alpha) cot = np.cos(np.radians(omegat)) sot = np.sin(np.radians(omegat)) cotd = np.cos(np.radians(omegat)+delta) sotd = np.sin(np.radians(omegat)+delta) Rax = ca*cotd Ray = sotd Raz = -sa*cotd ltx = Rax + cb*lK - cot*Rg lty = Ray - sot*Rg ltz = Raz + sb*lK lt = np.sqrt(ltx*ltx+lty*lty+ltz*ltz) return (sa*(Ray*ltz-Raz*lty) + ca*(Rax*lty-Ray*ltx))/lt
def gammak2(lK, Rg, beta, delta, omegat): alpha = 0.5 * np.pi - beta cb = np.cos(beta) sb = np.sin(beta) cot = np.cos(np.radians(omegat)) sot = np.sin(np.radians(omegat)) cotd = np.cos(np.radians(omegat) + delta) sotd = np.sin(np.radians(omegat) + delta) cotdt = np.cos(np.radians(omegat + 90) + delta) sotdt = np.sin(np.radians(omegat + 90) + delta) ltx = np.cos(alpha) * cotd + cb * lK - cot * Rg lty = sotd - sot * Rg ltz = -np.sin(alpha) * cotd + sb * lK eyrx = np.cos(alpha) * cotdt eyry = sotdt eyrz = -np.sin(alpha) * cotdt lt = np.sqrt(ltx * ltx + lty * lty + ltz * ltz) return np.degrees(np.arccos((eyrx * ltx + eyry * lty + eyrz * ltz) / lt))
def FitRange(self,rngnum=-1): rngtbl=self.ui.range_tbl start = rngnum end = rngnum +1 if (rngnum == -1): start = 0 end = len(self.rangeList) self.CalcBG() wedisconnected = False try: rngtbl.cellChanged.disconnect() #otherwise this function might be called recursively wedisconnected = True except: True for i in range(start, end): rng = self.rangeList[i] #xdata = rng.line.get_xdata(True) #ydata = rng.line.get_ydata(True) xdata = self.scanman.datasrc.x[rng.start:rng.stop] ydata = self.scanman.datasrc.y[rng.start:rng.stop] #xdata_smooth = np.linspace(xdata[0],xdata[-1],100) xwidth = xdata[1:]-xdata[:-1] if ((len(xdata) < 4) or (len(ydata) < 4)): continue #break out if the range was chosen wrong if (min(ydata) == max(ydata)): #No difference in values detected - cannto fit peak gparams = [0.0]*5 stdev = [0.0]*4 fitted = ydata True else: #Try to fit the data gparams = gauss(xdata, ydata, 'guess') gparamsfix = [0]*len(gparams) gparams[4] = 0.0 #slope gparamsfix[4] = 1 if (rng.position_fix): gparams[0] = rng.position gparamsfix[0] = 1 if (rng.fwhm_fix): gparams[1] = rng.fwhm gparamsfix[1] = 1 if (rng.intensity_fix): gparams[2] = rng.intensity gparamsfix[2] = 1 if (rng.background_fix): #gparams[3] = rng.background #gparamsfix[3] = 1 gparams[3] = rng.bgndfitparms[1] gparamsfix[3] = 1 gparams[4] = rng.bgndfitparms[0] gparamsfix[4] = 1 fitob = fit.fit(x=xdata, y=ydata, guess=gparams, ifix=gparamsfix ,quiet=True, funcs=[gauss], r2min=-100000, optimizer='mpfit') if ((min(gparams) == max(gparams)) and min(gparams)==0): #Could not find any possible peak fitted = ydata stdev = gparams rng.r2 = 0 rng.niter = 0 rng.time = 0 else: fitob.go(interactive=False) gparams=fitob.result rng.bgndfitparms[1] = gparams[3] rng.bgndfitparms[0] = gparams[4] stdev=fitob.stdev fitted = gauss(xdata,gparams) #fitted_smooth= gauss(xdata_smooth,gparams) rng.chi2 = fitob.chi2 rng.r2 = fitob.r2 rng.niter = fitob._niter rng.time = fitob._lastRunTime #rng.fittedline.set_data(rng.line.get_xdata(True), fitted) #rng.diffline.set_data(rng.line.get_xdata(True), rng.line.get_ydata(True) - fitted) rng.fittedline.set_data(xdata, fitted) #rng.fittedline.set_data(xdata_smooth, fitted_smooth) rng.diffline.set_data(xdata, ydata - fitted) rng.position = gparams[0] rng.fwhm = gparams[1] rng.intensity = gparams[2] rng.background = gparams[3] rng.position_stdev = stdev[0] rng.fwhm_stdev = stdev[1] rng.intensity_stdev = stdev[2] if (self.bgmode=="Single fixed" or self.bgmode=="All fixed" or self.bgmode=="Auto"): rng.background_stdev = stdev[3] #Determine if the calculated fits are valid rng.position_valid = True rng.fwhm_valid = True if (rng.fwhm <= 0) or (rng.fwhm_stdev/rng.fwhm >= 0.2) or (rng.fwhm_stdev == 0 and rng.fwhm_fix==False): rng.fwhm_valid = False rng.position_valid = False if (rng.intensity <= 0) or (rng.intensity_stdev/rng.intensity >= 0.3) or (rng.intensity_stdev == 0 and rng.intensity_fix==False): rng.intensity_valid = False rng.position_valid = False else: rng.intensity_valid = True #if (rng.intensity == False): rng.position_valid = False if (rng.background != 0): if (rng.intensity / rng.background < 1.1): rng.position_valid = False if (rng.position < xdata.min()) or (rng.position > xdata.max()): rng.position_valid = False ybgnd = fitfuncs.linear(xdata, rng.bgndfitparms,"eval") rng.intensity_sum = np.sum(fitted-ybgnd) rng.intensity_area = np.sum(abs((fitted-ybgnd)[:-1]*xwidth)) rng.counts = np.sum(ydata) #cmnerrterm = np.sqrt(2.0*rng.position_stdev*rng.position_stdev/rng.position/rng.position)*1e6 if self.scanman.axistype == "d-spacing": #rng.errustrain = np.sqrt(2.0*rng.position_stdev*rng.position_stdev/rng.position/rng.position)/rng.position*1e6 rng.errustrain = np.sqrt(2.0)*rng.position_stdev/rng.position*1e6 #elif self.scanman.axistype =="Angle": #pos = np.sin(np.deg2rad(rng.position/2.0)) #err = np.sin(np.deg2rad(rng.position_stdev/2.0)) #rng.errustrain = np.sqrt(2.0*err*err/pos/pos)/pos*1e6 else: rng.errustrain=0.0 rngtbl.item(self.position_row, i*2).setForeground(qt.QBrush(qt.QColor('Black' if rng.position_valid else 'Red'))) rngtbl.item(self.position_row, i*2).setText("{0:.4f}".format(rng.position)) rngtbl.item(self.position_row, i*2 + 1).setText("{0:.3e}".format(rng.position_stdev)) rngtbl.item(self.fwhm_row, i*2).setForeground(qt.QBrush(qt.QColor('Black' if rng.fwhm_valid else 'Red'))) rngtbl.item(self.fwhm_row, i*2).setText("{0:.4f}".format(rng.fwhm)) rngtbl.item(self.fwhm_row, i*2 + 1).setText("{0:.3e}".format(rng.fwhm_stdev)) rngtbl.item(self.intensity_row, i*2).setForeground(qt.QBrush(qt.QColor('Black' if rng.intensity_valid else 'Red'))) rngtbl.item(self.intensity_row, i*2).setText("{0:.4f}".format(rng.intensity)) rngtbl.item(self.intensity_row, i*2 + 1).setText("{0:.3e}".format(rng.intensity_stdev)) rngtbl.item(self.background_row, i*2).setText("{0:.4f}".format(rng.background)) rngtbl.item(self.background_row, i*2 + 1).setText("{0:.3e}".format(rng.background_stdev)) rngtbl.item(self.chi2_row, i*2).setText("{0:.3e}".format(rng.chi2)) rngtbl.item(self.r2_row, i*2).setText("{0:.4f}".format(rng.r2)) rngtbl.item(self.niter_row, i*2).setText("{0:.4f}".format(rng.niter)) rngtbl.item(self.time_row, i*2).setText("{0:.4f}".format(rng.time)) rngtbl.item(self.intensity_sum_row, i*2).setText("{0:.4f}".format(rng.intensity_sum)) rngtbl.item(self.intensity_area_row, i*2).setText("{0:.4f}".format(rng.intensity_area)) rngtbl.item(self.counts_row, i*2).setText("{0:.4f}".format(rng.counts)) rngtbl.item(self.errustrain_row, i*2).setText("{0:.4f}".format(rng.errustrain)) #self.scanman.ui.graph.draw() ymin = y = 0.0 ymax = x = 0.0 for rng in self.rangeList: if (len(rng.diffline._y) > 0): y = min(rng.diffline.get_ydata(True)) if (y < ymin): ymin = y y = max(rng.diffline.get_ydata(True)) if (y > ymax): ymax = y ybuf = (ymax - ymin) * 0.1 if ybuf == 0: ybuf = 1.0 self.scanman.ui.diffgraph.figure.axes[0].set_ylim(ymin - ybuf, ymax + ybuf) #self.scanman.ui.diffgraph.draw() if (wedisconnected): rngtbl.cellChanged.connect(self.CellValueChanged) #Reconnect the signal self.fittedsignal.emit() #To call any listeners True #************************************************************************************** #if __name__ == '__main__': # app = qt.QApplication(sys.argv) # window=FitDEF() # window.show() # sys.exit(app.exec_())
def zcopt(CL, G): # return 4./27.*CL*G**2 return 4. / 27. * CL * (1 + G**2) / G * np.sqrt(1 + G**2)
pred_ci.iloc[:, 0], pred_ci.iloc[:, 1], color='k', alpha=.2) ax.set_xlabel('Date') ax.set_ylabel('infected') plt.legend() # plt.savefig('./Figures/decemberPrediction.png', bbox_inches = 'tight' ) plt.show() # y_predicted = prediction.predicted_mean y_real = df['2020-10-01'] mse = ((y_predicted - y_real)**2).mean() print('The Mean Squared Error of our forecasts is {}'.format(round(mse, 2))) print('The Root Mean Squared Error of our forecasts is {}'.format( round(np.sqrt(mse), 2))) # future prediction # future = results.get_forecast(steps=100) # pred_ci = future.conf_int() # # ax = df.plot(label='observed', figsize=(14,7)) # future.predicted_mean.plot(ax=ax,label= 'forecast') # ax.fill_between(pred_ci.index, pred_ci.iloc[:,0], pred_ci.iloc[:,1], color='k', alpha=.25) # ax.set_xlabel('Date') # ax.set_ylabel('Infected') # # plt.legend() # plt.show()
def draw_spmsm(self, acm_variant): # Rotor Core list_regions_1 = acm_variant.rotorCore.draw(self, bool_draw_whole_model=True) # self.bMirror = False # self.iRotateCopy = acm_variant.rotorCore.p*2 # region1 = self.prepareSection(list_regions_1) # Shaft # list_regions = acm_variant.shaft.draw(self) # self.bMirror = False # self.iRotateCopy = 1 # region0 = self.prepareSection(list_regions) # Rotor Magnet list_regions = acm_variant.rotorMagnet.draw(self, bool_draw_whole_model=True) # self.bMirror = False # self.iRotateCopy = acm_variant.rotorMagnet.notched_rotor.p*2 # region2 = self.prepareSection(list_regions, bRotateMerge=False, color=color_rgb_B) # Sleeve # list_regions = acm_variant.sleeve.draw(self) # self.bMirror = False # self.iRotateCopy = acm_variant.rotorMagnet.notched_rotor.p*2 # regionS = self.prepareSection(list_regions) # Stator Core list_regions = acm_variant.stator_core.draw(self, bool_draw_whole_model=True) # self.bMirror = True # self.iRotateCopy = acm_variant.stator_core.Q # region3 = self.prepareSection(list_regions) # Stator Winding # list_regions = acm_variant.coils.draw(self, bool_draw_whole_model=True) # self.bMirror = False # self.iRotateCopy = acm_variant.coils.stator_core.Q # region4 = self.prepareSection(list_regions) self.apply_stroke() self.save() if False: # 根据绕组的形状去计算可以放铜导线的面积,然后根据电流密度计算定子电流 EX = acm_variant.template.d['EX'] CurrentAmp_in_the_slot = acm_variant.coils.mm2_slot_area * EX[ 'WindingFill'] * EX['Js'] * 1e-6 * np.sqrt(2) #/2.2*2.8 CurrentAmp_per_conductor = CurrentAmp_in_the_slot / EX['DriveW_zQ'] CurrentAmp_per_phase = CurrentAmp_per_conductor * EX[ 'wily'].number_parallel_branch # 跟几层绕组根本没关系!除以zQ的时候,就已经变成每根导体的电流了。 # Maybe there is a bug here... regarding the excitation for suspension winding... variant_DriveW_CurrentAmp = CurrentAmp_per_phase # this current amp value is for non-bearingless motor variant_BeariW_CurrentAmp = CurrentAmp_per_conductor * 1 # number_parallel_branch is 1 for suspension winding EX['CurrentAmp_per_phase'] = CurrentAmp_per_phase EX['DriveW_CurrentAmp'] = acm_variant.template.fea_config_dict[ 'TORQUE_CURRENT_RATIO'] * variant_DriveW_CurrentAmp EX['BeariW_CurrentAmp'] = acm_variant.template.fea_config_dict[ 'SUSPENSION_CURRENT_RATIO'] * variant_DriveW_CurrentAmp slot_current_utilizing_ratio = ( EX['DriveW_CurrentAmp'] + EX['BeariW_CurrentAmp']) / EX['CurrentAmp_per_phase'] # print('[FEMM_SlidingMesh.py]---Heads up! slot_current_utilizing_ratio is', slot_current_utilizing_ratio, ' (PS: =1 means it is combined winding)') return True
def zetar(CL, G, f): # return CL*f*(np.sqrt(1+G**2*(1-f)**2)-f)**2/np.sqrt(1+G**2) # was wrong return CL * f * (np.sqrt(1 + G**2 * (1 - f**2)) - f)**2 / (G * np.sqrt(1 + G**2))
def zetar(CL, G, f): return CL*(f/np.sqrt(1 + G**2))*(np.sqrt(1 + (1/G**2) - f**2) - (f/G))**2
def zetar(CL, G, f): return CL*f*(np.sqrt(1+G**2*(1-f)**2)-f)**2/np.sqrt(1+G**2)
def zetac(CL, G, f): # return CL*G**2*f*(1-f)**2 # was wrong return CL * f * (1 - f)**2 * (1 + G**2) / G * np.sqrt(1 + G**2)
def redraw_cross_section_outline_with_pyx(tool_tikz, no_repeat_stator, no_repeat_rotor, mm_rotor_outer_radius, mm_air_gap_length, mm_rotor_outer_steel_radius, mm_rotor_inner_radius): # PyX tool_tikz.c = pyx.canvas.canvas( ) # clear the canvas because we want to redraw 90 deg with the data tool_tikz.track_path print('Index | Path data') p_stator = None #pyx.path.path() p_rotor = None #pyx.path.path() for index, path in enumerate( tool_tikz.track_path ): # track_path is passed by reference and is changed by mirror # Failed to fill the closed path, because there is no arc-like path available. # p = pyx.path.line(4, 0, 5, 0) << pyx.path.line(5, 0, 5, 1) << pyx.path.line(5, 1, 4, 1) # p.append(path.closepath()) # tool_tikz.c.stroke(p) # tool_tikz.c.stroke(path.rect(0, 0, 1, 1), [pyx.style.linewidth.Thick, # pyx.color.rgb.red, # pyx.deco.filled([pyx.color.rgb.green])]) path_mirror = deepcopy(path) # for mirror copy (along x-axis) path_mirror[1] = path[1] * -1 path_mirror[3] = path[3] * -1 # for mirror copy (along y-axis) # path_mirror[0] = path[0]*-1 # path_mirror[2] = path[2]*-1 bool_exclude_path = False # rotate path and plot if is_at_stator(path, mm_rotor_outer_radius, mm_air_gap_length): Q = no_repeat_stator else: Q = no_repeat_rotor * 2 EPS = 1e-6 if is_at_stator(path, mm_rotor_outer_radius, mm_air_gap_length): # 按照Eric的要求,把不必要的线给删了。 if abs(path[1] + path[3]) < EPS: # 镜像对称线 bool_exclude_path = True if abs(path[0] - path[2]) + np.cos( 2 * np.pi / Q / 2) < EPS: # 旋转对称线(特别情况,tan(90°) = ∞ bool_exclude_path = True else: if abs( abs((path[1] - path[3]) / (path[0] - path[2])) - abs(np.tan(2 * np.pi / Q / 2))) < EPS: # 旋转对称线 bool_exclude_path = True if not is_at_stator(path, mm_rotor_outer_radius, mm_air_gap_length): # 按照Eric的要求,把不必要的线给删了。 if (abs(np.sqrt(path[0]**2+path[1]**2) - mm_rotor_inner_radius)<EPS or abs(np.sqrt(path[2]**2+path[3]**2) - mm_rotor_inner_radius)<EPS) \ and (len(path)==4): # 转子铁芯内径到外径的直线(len(path)==4) bool_exclude_path = True # # 特别的是,画永磁体的时候,边界要闭合哦。 # if abs(np.sqrt(path[0]**2+path[1]**2) - mm_rotor_outer_steel_radius) < EPS or abs(np.sqrt(path[2]**2+path[3]**2) - mm_rotor_outer_steel_radius) < EPS: # bool_exclude_path = False # A trick that makes sure models with different outer diameters have the same scale. # tool_tikz.draw_arc([125,0], [-125,0], relangle=sign*180, untrack=True) tool_tikz.c.fill( pyx.path.circle(0, 0, 125), [pyx.color.transparency(1)] ) # use this if THICK is used. <- Warn: Transparency not available in PostScript, proprietary ghostscript extension code inserted. (save as eps format) # tool_tikz.c.fill(pyx.path.circle(0, 0, 125), [pyx.color.rgb.white]) # use this if THICK is used. <- this will over-write everthing... how to change zorder? _ = 2 * np.pi / Q if True: # full model for counter in range(Q): # 转子:旋转复制 if not is_at_stator(path, mm_rotor_outer_radius, mm_air_gap_length): path[0], path[1] = rotate(_, path[0], path[1]) path[2], path[3] = rotate(_, path[2], path[3]) 路径 = tool_tikz.pyx_draw_path( path, sign=1, bool_exclude_path=bool_exclude_path, bool_stroke=True) if 路径 is not None: if p_rotor is None: p_rotor = 路径 else: p_rotor = p_rotor << 路径 # 定子:镜像+旋转复制 if is_at_stator(path, mm_rotor_outer_radius, mm_air_gap_length): path[0], path[1] = rotate(_, path[0], path[1]) path[2], path[3] = rotate(_, path[2], path[3]) 路径 = tool_tikz.pyx_draw_path( path, sign=1, bool_exclude_path=bool_exclude_path, bool_stroke=True) # print(index, '\t|', ',\t'.join(['%g'%(el) for el in path])) if 路径 is not None: if p_stator is None: p_stator = 路径 else: p_stator = p_stator << 路径 path_mirror[0], path_mirror[1] = rotate( _, path_mirror[0], path_mirror[1]) path_mirror[2], path_mirror[3] = rotate( _, path_mirror[2], path_mirror[3]) 路径 = tool_tikz.pyx_draw_path( path_mirror, sign=-1, bool_exclude_path=bool_exclude_path, bool_stroke=True) if 路径 is not None: if p_stator is None: p_stator = 路径 else: p_stator = p_stator << 路径 # break else: # backup # 转子:旋转复制 if not is_at_stator(path, mm_rotor_outer_radius, mm_air_gap_length): path[0], path[1] = rotate(0.5 * np.pi - 0.5 * 0.5 * _, path[0], path[1]) path[2], path[3] = rotate(0.5 * np.pi - 0.5 * 0.5 * _, path[2], path[3]) pyx_draw_path(tool_tikz, path, sign=1, bool_exclude_path=bool_exclude_path) # print(index, '\t|', ',\t'.join(['%g'%(el) for el in path])) # path[0], path[1] = rotate(0.5*np.pi - 0*0.5*_, path[0], path[1]) # path[2], path[3] = rotate(0.5*np.pi - 0*0.5*_, path[2], path[3]) # pyx_draw_path(tool_tikz, path, sign=1, bool_exclude_path=bool_exclude_path) # 定子:镜像+旋转复制 if is_at_stator(path, mm_rotor_outer_radius, mm_air_gap_length): path[0], path[1] = rotate(0.5 * np.pi - 0.5 * _, path[0], path[1]) path[2], path[3] = rotate(0.5 * np.pi - 0.5 * _, path[2], path[3]) pyx_draw_path(tool_tikz, path, sign=1, bool_exclude_path=bool_exclude_path) # print(index, '\t|', ',\t'.join(['%g'%(el) for el in path])) path_mirror[0], path_mirror[1] = rotate( 0.5 * np.pi - 0.5 * _, path_mirror[0], path_mirror[1]) path_mirror[2], path_mirror[3] = rotate( 0.5 * np.pi - 0.5 * _, path_mirror[2], path_mirror[3]) pyx_draw_path(tool_tikz, path_mirror, sign=-1, bool_exclude_path=bool_exclude_path) # 注意,所有 tack_path 中的 path 都已经转动了90度了! # for mirror copy (along y-axis) path[0] *= -1 path[2] *= -1 pyx_draw_path(tool_tikz, path, sign=-1, bool_exclude_path=bool_exclude_path) path_mirror[0] *= -1 path_mirror[2] *= -1 pyx_draw_path(tool_tikz, path_mirror, sign=1, bool_exclude_path=bool_exclude_path)
def is_at_stator(path, mm_rotor_outer_radius, mm_air_gap_length): return np.sqrt(path[0]**2 + path[1]**2 ) > mm_rotor_outer_radius + 0.5 * mm_air_gap_length
from pylab import sum, np from scipy.special.orthogonal import p_roots def gauss(f, n, a, b): [x, w] = p_roots(n + 1) G = 0.5 * (b - a) * sum(w * f(0.5 * (b - a) * x + 0.5 * (b + a))) return G print(gauss(lambda x: x/(np.sqrt((x**2)+2)), 50, 0.8, 2)) # 0.8246820618559857
def dzrdf(f, CL, G): r = np.sqrt(1 + G**2 * (1 - f**2)) # return CL*(f-r)*(2*f*(G**2*(1-f)+r)+(f-r)*r)/(np.sqrt(G**2+1)*r) # this is still wrong! return CL / (G * np.sqrt(1 + G**2)) * (r - f) * (r - 3 * f - 2 * G**2 * f**2 / r)
def draw(self, drawer, bool_draw_whole_model=False): drawer.getSketch(self.name, self.color) alpha_st = self.deg_alpha_st * np.pi / 180 alpha_so = -self.deg_alpha_so * np.pi / 180 r_si = self.mm_r_si d_so = self.mm_d_so d_sp = self.mm_d_sp d_st = self.mm_d_st d_sy = self.mm_d_sy w_st = self.mm_w_st r_st = self.mm_r_st r_sf = self.mm_r_sf r_sb = self.mm_r_sb Q = self.Q alpha_slot_span = 360 / Q * np.pi / 180 P1 = [r_si, 0] P2 = [r_si * cos(alpha_st * 0.5), r_si * -sin(alpha_st * 0.5)] P3_temp = [d_so * cos(alpha_st * 0.5), d_so * -sin(alpha_st * 0.5)] P3_local_rotate = [ cos(alpha_so) * P3_temp[0] + sin(alpha_so) * P3_temp[1], -sin(alpha_so) * P3_temp[0] + cos(alpha_so) * P3_temp[1] ] P3 = [P3_local_rotate[0] + P2[0], P3_local_rotate[1] + P2[1]] 三角形的底 = r_si + d_sp 三角形的高 = w_st * 0.5 三角形的角度 = arctan(三角形的高 / 三角形的底) P4 = [三角形的底 * cos(三角形的角度), 三角形的底 * -sin(三角形的角度)] P5 = [P4[0] + d_st, P4[1]] # Option 1 # 6 [94.01649113009418, -25.191642873516543] 97.33303383272235 # Radius_InnerStatorYoke = r_si+d_sp+d_st # print('Radius_InnerStatorYoke #1:', Radius_InnerStatorYoke) # Option 2 Radius_InnerStatorYoke = np.sqrt(P5[0]**2 + P5[1]**2) # print('Radius_InnerStatorYoke #2:', Radius_InnerStatorYoke) P6 = [ Radius_InnerStatorYoke * cos(alpha_slot_span * 0.5), Radius_InnerStatorYoke * -sin(alpha_slot_span * 0.5) ] P7 = [(r_si + d_sp + d_st + d_sy) * cos(alpha_slot_span * 0.5), (r_si + d_sp + d_st + d_sy) * -sin(alpha_slot_span * 0.5)] P8 = [r_si + d_sp + d_st + d_sy, 0] list_segments = [] if bool_draw_whole_model: P2_Mirror = [P2[0], -P2[1]] # = iPark(P2, alpha_st) P3_Mirror = [P3[0], -P3[1]] P4_Mirror = [P4[0], -P4[1]] P5_Mirror = [P5[0], -P5[1]] def iPark(P, theta): return [ P[0] * np.cos(theta) + P[1] * -np.sin(theta), P[0] * np.sin(theta) + P[1] * np.cos(theta) ] def draw_fraction(list_segments, P2, P3, P4, P5, P2_Mirror, P3_Mirror, P4_Mirror, P5_Mirror): P5_Rotate = iPark(P5, alpha_slot_span) list_segments += drawer.drawArc([0, 0], P2, P2_Mirror) list_segments += drawer.drawLine(P2, P3) list_segments += drawer.drawLine(P2_Mirror, P3_Mirror) list_segments += drawer.drawLine(P3, P4) list_segments += drawer.drawLine(P3_Mirror, P4_Mirror) list_segments += drawer.drawLine(P4, P5) list_segments += drawer.drawLine(P4_Mirror, P5_Mirror) list_segments += drawer.drawArc([0, 0], P5_Mirror, P5_Rotate) for i in range(Q): draw_fraction( list_segments, iPark(P2, i * alpha_slot_span), iPark(P3, i * alpha_slot_span), iPark(P4, i * alpha_slot_span), iPark(P5, i * alpha_slot_span), iPark(P2_Mirror, i * alpha_slot_span), iPark(P3_Mirror, i * alpha_slot_span), iPark(P4_Mirror, i * alpha_slot_span), iPark(P5_Mirror, i * alpha_slot_span), ) # raise # draw a circle (this is officially suggested) list_segments += drawer.drawArc([0, 0], P8, [-P8[0], P8[1]]) list_segments += drawer.drawArc([0, 0], [-P8[0], P8[1]], P8) else: list_segments += drawer.drawArc([0, 0], P2, P1) list_segments += drawer.drawLine(P2, P3) list_segments += drawer.drawLine(P3, P4) list_segments += drawer.drawLine(P4, P5) list_segments += drawer.drawArc([0, 0], P6, P5) list_segments += drawer.drawLine(P6, P7) list_segments += drawer.drawArc([0, 0], P7, P8) list_segments += drawer.drawLine(P8, P1) # DEBUG # for ind, point in enumerate([P1, P2, P3, P4, P5, P6, P7, P8]): # print(ind+1, point, np.sqrt(point[0]**2+point[1]**2)) self.innerCoord = (0.5 * (P1[0] + P5[0]), 0.5 * (P1[1] + P5[1])) # return [list_segments] return { 'innerCoord': self.innerCoord, 'list_regions': [list_segments], 'mirrorAxis': [(P8[0] + 5, P8[1]), (P8[0] + 15, P8[1])] }
def is_at_stator(im, path): return np.sqrt(path[0]**2 + path[1]**2 ) > im.Radius_OuterRotor + 0.5 * im.Length_AirGap
def draw(self, drawer): drawer.getSketch(self.name, self.color) alpha_st = self.deg_alpha_st * np.pi / 180 alpha_so = -self.deg_alpha_so * np.pi / 180 r_si = self.mm_r_si d_so = self.mm_d_so d_sp = self.mm_d_sp d_st = self.mm_d_st d_sy = self.mm_d_sy w_st = self.mm_w_st r_st = self.mm_r_st r_sf = self.mm_r_sf r_sb = self.mm_r_sb Q = self.Q alpha_slot_span = 360 / Q * np.pi / 180 P1 = [r_si, 0] P2 = [r_si * cos(alpha_st * 0.5), r_si * -sin(alpha_st * 0.5)] P3_temp = [d_so * cos(alpha_st * 0.5), d_so * -sin(alpha_st * 0.5)] P3_local_rotate = [ cos(alpha_so) * P3_temp[0] + sin(alpha_so) * P3_temp[1], -sin(alpha_so) * P3_temp[0] + cos(alpha_so) * P3_temp[1] ] P3 = [P3_local_rotate[0] + P2[0], P3_local_rotate[1] + P2[1]] 三角形的底 = r_si + d_sp 三角形的高 = w_st * 0.5 三角形的角度 = arctan(三角形的高 / 三角形的底) P4 = [三角形的底 * cos(三角形的角度), 三角形的底 * -sin(三角形的角度)] P5 = [P4[0] + d_st, P4[1]] # Option 1 # 6 [94.01649113009418, -25.191642873516543] 97.33303383272235 # Radius_InnerStatorYoke = r_si+d_sp+d_st # print('Radius_InnerStatorYoke #1:', Radius_InnerStatorYoke) # Option 2 Radius_InnerStatorYoke = np.sqrt(P5[0]**2 + P5[1]**2) # print('Radius_InnerStatorYoke #2:', Radius_InnerStatorYoke) P6 = [ Radius_InnerStatorYoke * cos(alpha_slot_span * 0.5), Radius_InnerStatorYoke * -sin(alpha_slot_span * 0.5) ] P7 = [(r_si + d_sp + d_st + d_sy) * cos(alpha_slot_span * 0.5), (r_si + d_sp + d_st + d_sy) * -sin(alpha_slot_span * 0.5)] P8 = [r_si + d_sp + d_st + d_sy, 0] list_segments = [] list_segments += drawer.drawArc([0, 0], P2, P1) list_segments += drawer.drawLine(P2, P3) list_segments += drawer.drawLine(P3, P4) list_segments += drawer.drawLine(P4, P5) list_segments += drawer.drawArc([0, 0], P6, P5) # print(P4, P5) # print(P6, P5) list_segments += drawer.drawLine(P6, P7) # l, vA = drawer.drawArc([0,0], P6, P5, returnVertexName=True) # list_segments += l # l, vB = drawer.drawLine(P6, P7, returnVertexName=True) # list_segments += l # drawer.addConstraintCocentricity(vA[0], vB[0]) # raise list_segments += drawer.drawArc([0, 0], P7, P8) list_segments += drawer.drawLine(P8, P1) # DEBUG # for ind, point in enumerate([P1, P2, P3, P4, P5, P6, P7, P8]): # print(ind+1, point, np.sqrt(point[0]**2+point[1]**2)) innerCoord = (0.5 * (P1[0] + P5[0]), 0.5 * (P1[1] + P5[1])) # return [list_segments] return { 'innerCoord': innerCoord, 'list_regions': [list_segments], 'mirrorAxis': [(P8[0] + 5, P8[1]), (P8[0] + 15, P8[1])] }
def dzrdf(f, CL, G): r= np.sqrt(G**2*(1-f)**2+1) return CL*(f-r)*(2*f*(G**2*(1-f)+r)+(f-r)*r)/(np.sqrt(G**2+1)*r)
Ma = Pnom / omega S = np.pi * (Rko * Rko - Rk * Rk) alpha = np.radians(60) # Initial value betas = np.radians(0) # Initial value a, b, c, d = Marzmean(lKRk, RgRk, alpha, betas, beta, delta) alpha = a betas = b MaRF = c MgRF = d Fakz = Ma / (MaRF * Rk) sa = np.sin(alpha) ca = np.cos(alpha) sb = np.sin(betas) cb = np.cos(betas) L = Fakz * np.sqrt(sb * sb * sa * sa + ca * ca) D = Fakz * cb * sa LoD = L / D CL = 2 * L / (rho * S * vw * vw) CD = 2 * D / (rho * S * vw * vw) CM = 2 * Ma / (rho * Rko * S * vw * vw) Cp = lam * CM aeff = np.arccos(cb * ca) Ftrxam = Ftrxminmax(lKRk, RgRk, alpha, betas, beta, delta) Ftryam = Ftryminmax(lKRk, RgRk, alpha, betas, beta, delta) h = np.sin(beta) * lK - sa * Rko print "Pnom : ", Pnom print "lK/Rk : ", lKRk print "Rg/Rk : ", RgRk