def main(): n_pontos = 40 polos = 7 deg_mec = np.linspace(0, 360, n_pontos) deg_ele = deg_mec / polos a_flux = np.zeros(n_pontos) b_flux = np.zeros(n_pontos) c_flux = np.zeros(n_pontos) print(a_flux) for i in range(n_pontos): femm.mi_modifyboundprop("Sliding", 11, deg_ele[i]) femm.mi_analyse() femm.mi_loadsolution() a_flux[i] = femm.mo_getcircuitproperties("A")[2] b_flux[i] = femm.mo_getcircuitproperties("A")[2] c_flux[i] = femm.mo_getcircuitproperties("A")[2] flux_1n = np.zeros(n_pontos) for i in range(n_pontos): femm.mi_modifyboundprop("Sliding", 11, deg_ele[i]) femm.mi_analyse() femm.mi_loadsolution() femm.mo_selectblock(1.5, 8.6) flux_1n[i] = femm.mo_blockintegral(1) / femm.mo_blockintegral(5) femm.mo_clearblock() ap = 10e-3 * (10.86 + 10.96) * 1e-3 * np.pi / 14 bt = flux_1n / ap / 4
def computeL0(self): """Compute L0 Compute the bare inductance of the coil without projectile. """ self.deleteProjectile() femm.mi_refreshview() femm.mi_analyze() femm.mi_loadsolution() # print(femm.mo_getcircuitproperties("Bobine")) self.L0 = femm.mo_getcircuitproperties("Bobine")[2] / self._i0 self.resistance = femm.mo_getcircuitproperties("Bobine")[1] / self._i0 femm.mo_close() self.drawProjectile()
def comp_FEMM_Phi_wind(qs, Npcpp, is_stator, Lfemm, L1, sym, is_rescale_flux=True): """Compute the total fluxlinkage of the winding phases Parameters ---------- qs : int number of phases Npcpp : int number of parallel circuits per phase (maximum 2p) is_stator : bool true if windings are stator windings Lfemm : float lenght of FEMM model L1 : float actual lenght for rescaling fluxlinkage sym : int symmetry factor (ie. 1 = full machine, 2 = half machine ...) is_rescale_flux : bool True if rescaling should be applied Returns ------- Phi_wind : float fluxlinkage of the winding phases [Vs] """ Phi_wind = zeros((1, qs)) if is_stator: label = "Circs" else: label = "Circr" # For each phase/circuit for q in range(qs): PropCirc = mo_getcircuitproperties(label + str(q)) # rescaling to account for end winding flux if is_rescale_flux: Kphi = L1 / Lfemm else: Kphi = 1 # flux linkage of phase q in Wb=Vs=HA Phi_wind[0, q] = sym * PropCirc[2] * Kphi / Npcpp return Phi_wind
def calc_inductance(tg, currents, inductances=(None, None), **kwargs): ''' Setup of magneto-static problem in femm to calculate inductance and resistance of planar transformer. Args: tg (:obj:'TransformerGeometry'): tg contains all geometry information of the transformer. currents (list of float): currents in the primary and secondary side circuits on the form [I_prim, I_sec]. inductances (list of float): self-inductances of the primary and secondary side circuits on the form [L_prim, L_sec]. Used to calculate mutual inductance. Returns: (inductance, resistance): calculated self or mutual inductance and equivalent series resistance of either primary or secondary circuit. ''' etiquettes_dict = {} # Dictionary to store coordinates of nodes # initialitiation of the magneto-static problem boundary_radius = 2 * tg.radius_dielectric initial_setup(boundary_radius, currents, **kwargs) # draw geometry and add block labels add_conductors(tg, etiquettes_dict) add_pcbs(tg) add_isolation(tg) add_block_labels(tg, etiquettes_dict) # mi zoomnatural() # From manual: zooms to a “natural” view with sensible extents. femm.mi_zoomnatural() # Saving geometry file femm.mi_saveas('inductance_transformer.fem') # Meshing and analysis # From manual: Note that it is not necessary to run mesh before performing # an analysis, as mi_analyze() will make sure the mesh is up to date before # running an analysis. # mi analyze(flag) # From manual: runs fkern to solve the problem. The flag parameter controls # whether the fkern window is visible or minimized. For a visible window, # either specify no value for flag or specify 0. For a minimized window, # flag should be set to 1. femm.mi_analyze(1) # Post-processing femm.mi_loadsolution() # mo_seteditmode(mode) # From manual: Sets themode of the postprocessor to point, contour, or area # mode. Valid entries for mode are "point", "contour", and "area". femm.mo_seteditmode('area') # mo_blockintegral(type) # From manual: Calculate a block integral for the selected blocks # Type Definition # 0 A · J # 1 A # 2 Magnetic field energy # 3 Hysteresis and/or lamination losses # 4 Resistive losses # 5 Block cross-section area # 6 Total losses # 7 Total current # 8 Integral of Bx (or Br) over block # 9 Integral of By (or rBz) over block # 10 Block volume # ... # mo_getcircuitproperties("circuit") # From manual: Used primarily to obtain impedance information associated # with circuit properties. Properties are returned for the circuit property # named "circuit". Three values are returned by the function. In order, # these results are: # – current Current carried by the circuit # – volts Voltage drop across the circuit # – flux_re Circuit’s flux linkage # mo_groupselectblock(n) # From manual: Selects all the blocks that are labeled by block labels # that are members of group n. If no number is specified (i.e. # mo_groupselectblock() ), all blocks are selected. # Calculate the inductance of the circuit with non-zero current. If both # currents are given, we calculate the mutual inductance. L1, L2 = inductances if (currents[0] > 0) and (currents[1] == 0): circ = femm.mo_getcircuitproperties('phase_prim') resistance = circ[1].real inductance = abs(circ[2] / circ[0]) elif (currents[0] == 0) and (currents[1] > 0): circ = femm.mo_getcircuitproperties('phase_sec') resistance = circ[1].real inductance = abs(circ[2] / circ[0]) else: femm.mo_groupselectblock() # axisymmetric problem, integral is multiplied by 2 Wm = femm.mo_blockintegral(2) * 2 inductance = ((Wm - 0.5 * (L1 * currents[1]**2 + L2 * currents[0]**2)) / (currents[0] * currents[1])) resistance = 0 femm.mo_clearblock() if kwargs.get('close') is True: femm.closefemm() return (inductance, resistance)
# Now,analyze the problem and load the solution when the analysis is finished femm.mi_analyze() femm.mi_loadsolution() # If we were interested in the flux density at specific positions, # we could inquire at specific points directly: b0=femm.mo_getb(0,0); print('Flux density at the center of the bar is %g T' % b0[1]); b1=femm.mo_getb(0,50); print('Flux density at r=0,z=50 is %g T' % b1[1]); # The program will report the terminal properties of the circuit: # current, voltage, and flux linkage vals = femm.mo_getcircuitproperties('icoil'); # [i, v, \[Phi]] = MOGetCircuitProperties["icoil"] # If we were interested in inductance, it could be obtained by # dividing flux linkage by current L = 1000*vals[2]/vals[0]; print('The self-inductance of the coil is %g mH' % L); # Or we could, for example, plot the results along a line using zee=[] bee=[] for n in range(-100,101): b=femm.mo_getb(0,n); zee.append(n) bee.append(b[1]);
def computeMuImpact(self, mus=[5, 10, 50, 100, 500, 1000, 5000], error=0.1): """Compute the impact of Mu The model is NOT LINEAR in mu. It is hard to guess what would be the effect of an increased suceptibility and it may highly modify the response of the coil. However, for some configuration the error is low (typically a long coil and a small projectile). This function provides some help to know if we can consider the model linear in Mu. Simply provide a range of possible susceptibilities for your projectile, and an acceptable relative error. We do not check the whole linearity, but simply in two points selected empirically. Therefore some care should be taken regarding the output of this helper method. Keyword Arguments: mus {list} -- [description] (default: {[5, 10, 50, 100, 500, 1000, 5000]}) error {number} -- [description] (default: {0.1}) """ _mu = self.mu res = [] test_res = [] print("Coil " + self._seed + " mus") for mu in mus: self.mu = mu self.deleteProjectile() self.drawProjectile() femm.mi_clearselected() femm.mi_selectgroup(1) femm.mi_analyze() femm.mi_loadsolution() femm.mo_groupselectblock(1) res.append(femm.mo_getcircuitproperties("Bobine")[2] / self._i0) femm.mi_movetranslate2(0, self.Lb / 4, 4) femm.mi_analyze() femm.mi_loadsolution() femm.mo_groupselectblock(1) test_res.append( femm.mo_getcircuitproperties("Bobine")[2] / self._i0) self.mu = _mu success = True errors = [] for i in range(0, len(test_res)): errors.append( numpy.abs((res[i] / res[0]) / (test_res[i] / test_res[0]) - 1)) if errors[-1] > error: success = False # break if success: return { 'valid': True, 'mus': mus, 'mu_Lz_0': res, 'mu_Lz_1': test_res, 'errors': errors } else: return { 'valid': False, 'mus': mus, 'mu_Lz_0': res, 'mu_Lz_1': test_res, 'errors': errors }
for coil_origin in coil_origins: coil = Rectangle(coil_origin.x, coil_origin.y, Params.D4, Params.D3) coil.assign_material(Params.CoilMaterial, Params.Turns, 'Circuit') # Now, the finished input geometry can be displayed. femm.mi_zoomnatural() # We have to give the geometry a name before we can analyze it. femm.mi_saveas('feladat2.fem') move_vectors = [Point(0, 0)] # do it once without moving for previous, current in zip(Params.core_gap, Params.core_gap[1:]): move_vectors.append(Point(0, previous - current)) forces = {} for core_gap, move_vector in zip(Params.core_gap, move_vectors): bottom_part.move(move_vector.x, move_vector.y) femm.mi_analyze() femm.mi_loadsolution() bottom_part.select_block_for_anal() forces[core_gap] = femm.mo_blockintegral(19) # 19 means force (current, voltage, flux_linkage) = femm.mo_getcircuitproperties('Circuit') inductance = flux_linkage / current print( f'In case of {core_gap:.1f} cm gap, force is {forces[core_gap]:.2f} N; inductance is {inductance*1000:.2f} mH' ) femm.closefemm()
# Store vector potential at the element centroid for elements that are in PMs A[index, m] = femm.mo_geta(float(np.real(z[m])), float(np.imag(z[m]))) elif g[m] == GroupSummary['stator_iron_core'] \ or g[m] == GroupSummary['rotor_iron_core'] \ or g[m] == GroupSummary['coils']: # Element is on the stator or rotor iron or coils # Store flux density at the element centroid for these elements b_temp = femm.mo_getb(float(np.real(z[m])), float(np.imag(z[m]))) b[index, m] = b_temp[0] + 1j * b_temp[1] # Torque, force, fluxes torque = femm.mo_gapintegral('WholeModelSlidingBand', 0) forces = femm.mo_gapintegral('WholeModelSlidingBand', 1) energy = femm.mo_gapintegral('WholeModelSlidingBand', 2) cP_Uac = femm.mo_getcircuitproperties('U-GrpAC') cP_Vac = femm.mo_getcircuitproperties('V-GrpAC') cP_Wac = femm.mo_getcircuitproperties('W-GrpAC') cP_Ubd = femm.mo_getcircuitproperties('U-GrpBD') cP_Vbd = femm.mo_getcircuitproperties('V-GrpBD') cP_Wbd = femm.mo_getcircuitproperties('W-GrpBD') M[index, 0] = torque M[index, 1] = forces[0] M[index, 2] = forces[1] M[index, 3] = energy M[index, 4] = cP_Uac[0] M[index, 5] = cP_Vac[0] M[index, 6] = cP_Wac[0] M[index, 7] = cP_Ubd[0] M[index, 8] = cP_Vbd[0] M[index, 9] = cP_Wbd[0]