def initFemm(depth=50, sm=False, filename='test.fem'): femm.openfemm() femm.newdocument(0) femm.mi_probdef(0, 'millimeters', 'planar', 1.e-8, depth, 30) femm.mi_hidegrid() # femm.smartmesh(sm) femm.mi_saveas(filename)
def new(self, fname): fe.openfemm() fe.newdocument(0) fe.mi_saveas(fname) self.fname = fname #add air to problem by default air = mat.Material('Air') air.add()
def __init__(self): self.gap_width = None self.gap_height = None self.core_width = None self.inner_radius = None self.outer_radius = None self.core_radius = None femm.openfemm() femm.newdocument(0) femm.mi_probdef(0, 'millimeters', 'axi', 1.e-8, 0, 30)
def main(): fe.openfemm() fe.newdocument(0) rotor = PM_Rotor(dri=50, dm=10, dmp=3, alpha_m=60, p=2, OR=100) rotor.draw() rotor.set_materials('test', 'test') fe.mi_zoomnatural()
def creation_FEMM(self): """Méthode permettant de générer une simulation FEMM""" # Permet de lancer le logiciel FEMM. femm.openfemm() # Création d'un problème de magnétostatique ( = 0 ). femm.newdocument(0) # Définition du problème. Magnetostatique, Unités mètres, Problème plan, # Precision de 10^(-8), longueur active de 1m, angle de contraintes de 30deg femm.mi_probdef(0, 'meters', 'planar', 1e-8, 1, 30)
def __init__(self, bHide=False, meshsize=config.MESHSIZE, _i0=config.CURRENT, _id=None): """Initialize a FEMM solver Open FEMM and define the key elements of the magnetic problem. The problem is considered STATIC. All measurements are in MILLIMETERS here ! Keyword Arguments: bHide {bool} -- Either to show or hide the window. Hiding it provides a nice speed improvement (default: {False}) meshsize {number} -- Size of the mesh used for the finite elements. The smaller the more precise, but it comes with a computational cost (default: {1}) _i0 {number} -- Current used in computation. Any value should do, we use 100 to avoid working with very small floats (default: {100}) _id {number} -- Some id used to save the problem, if one requires to track and come back to the FEMM model (default: {None}) """ if _id is not None: self._seed = str(_id) else: self._seed = str(numpy.random.randint(10000)) self.meshsize = meshsize self.Lb = None self.Rbi = None self.Rbo = None self.phi = None self.rho = None self.n = None self.resistance = None self.Lp = None self.Rp = None self.m_vol_fer = None self.mu = None self.mass = None self.espace = None self.wire_type = None self._i0 = _i0 self.bHide = bHide femm.openfemm(bHide) femm.create(0) femm.mi_probdef(0, "millimeters", "axi", 1E-16) femm.mi_saveas("temp/temp" + self._seed + ".fem") femm.mi_addcircprop("Bobine", self._i0, 1) femm.mi_addmaterial("Air", 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0)
# The objective of this program is to find the capacitance # matrix associated with a set of four microstrip lines on # top of a dielectric substrate. We will consider lines # that are 20 um wide and 2 um thick, separated by a 4 um # distance. The traces are laying centered atop of a 20 um # by 200 um slab with a relative permeability of 4. The # slab rests on an infinite ground plane. We will consider # a 1m depth in the into-the-page direction. # # This program sets up the problem and solves two different # cases with different voltages applied to the conductors # Becuase of symmetry, this yields enough information to # deduce the 4x4 capacitance matrix # Start up and connect to FEMM femm.openfemm() # Create a new electrostatics problem femm.newdocument(1) # Draw the geometry femm.ei_probdef('micrometers', 'planar', 10**(-8), 10**6, 30) femm.ei_drawrectangle(2, 0, 22, 2) femm.ei_drawrectangle(2 + 24, 0, 22 + 24, 2) femm.ei_drawrectangle(-2, 0, -22, 2) femm.ei_drawrectangle(-2 - 24, 0, -22 - 24, 2) femm.ei_drawrectangle(-100, -20, 100, 0) femm.ei_drawline(-120, -20, 120, -20) femm.ei_drawarc(120, -20, -120, -20, 180, 2.5) femm.ei_drawarc(100, 100, 120, 100, 180, 2.5) femm.ei_drawline(100, 100, 120, 100)
def initial_setup(limite_externe, voltage_high, **kwargs): '''Start femm and setup problem definition and set boundary condition.''' if kwargs.get('hide') is True: femm.openfemm(1) femm.main_minimize() else: femm.openfemm() # newdocument(doctype) # From manual: Creates a new preprocessor document and opens up a new # preprocessor window. Specify doctype to be 0 for a magnetics problem, 1 # for an electrostatics problem, 2 for a heat flow problem, or 3 for a # current flow problem. An alternative syntax for this command is # create(doctype) femm.newdocument(1) # ei probdef(units,type,precision,(depth),(minangle)) # From manual: changes the problem definition. The units parameter # specifies the units used for measuring length in the problem domain. # Valid "units" entries are "inches", "millimeters", "centimeters", "mils", # "meters, and "micrometers". Set problemtype to "planar" for a 2-D planar # problem, or to "axi" for an axisymmetric problem. The precision parameter # dictates the precision required by the solver. For example, entering # 1.E-8 requires the RMS of the residual to be less than 10^-8. A fourth # parameter, representing the depth of the problem in the into-thepage # direction for 2-D planar problems, can also be specified for planar # problems. A sixth parameter represents the minimum angle constraint sent # to the mesh generator. if 'precision' in kwargs: precision = kwargs['precision'] else: precision = 1e-9 if 'min_angle' in kwargs: min_angle = kwargs['min_angle'] else: min_angle = 30 femm.ei_probdef('millimeters', 'axi', precision, 100, min_angle) # Circuit parameters # From manual: ei_addconductorprop("conductorname", Vc, qc, conductortype) # adds a new conductor property with name "conductorname" with either a # prescribed voltage or a prescribed total charge. Set the unused property # to zero. The conductortype parameter is 0 for prescribed charge and 1 for # prescribed voltage femm.ei_addconductorprop('high', voltage_high, 0, 1) femm.ei_addconductorprop('zero', 0, 0, 1) # Add materials properties used in the simulation # ei_addmaterial(’matname’, ex, ey, qv) # From manual: adds a new material with called ’matname’ with the material # properties: # ex Relative permittivity in the x- or r-direction. # ey Relative permittivity in the y- or z-direction. # qv Volume charge density in units of C/m3 femm.ei_addmaterial('air', 1, 1, 0) femm.ei_addmaterial('fr4', 4.4, 4.4, 0) femm.ei_addmaterial('polysterimide', 3.5, 3.5, 0) femm.ei_addmaterial('teflon', 2.1, 2.1, 0) femm.ei_addmaterial('silgel', 2.7, 2.7, 0) femm.ei_addmaterial('midel', 3.15, 3.15, 0) if 'material' in kwargs: for m in kwargs['material']: femm.ei_addmaterial(*m) # Boundary conditions # ei makeABC(n,R,x,y,bc) # From manual: creates a series of circular shells that emulate the # impedance of an unbounded domain (i.e. an Improvised Asymptotic Boundary # Condition). The n parameter contains the number of shells to be used # (should be between 1 and 10), R is the radius of the solution domain, and # (x,y) denotes the center of the solution domain. The bc parameter should # be specified as 0 for a Dirichlet outer edge or 1 for a Neumann outer # edge. If the function is called without all the parameters, the function # makes up reasonable values for the missing parameters. femm.ei_makeABC(7, limite_externe, 0, 0, 0)
# of a cylindrical coil with an axial length of 100 mm, an # inner radius of 50 mm, and an outer radius of 100 mm. The # coil has 200 turns and the coil current is 20 Amps. There is # an iron bar 80 mm long with a radius of 10 mm centered co- # axially with the coil. The objective of the analysis is to # determine the flux density at the center of the iron bar, # and to plot the field along the r=0 axis. This analysis # defines a nonlinear B-H curve for the iron and employs an # asymptotic boundary condition to approximate an "open" # boundary condition on the edge of the solution domain. import femm import matplotlib.pyplot as plt # The package must be initialized with the openfemm command. femm.openfemm(); # We need to create a new Magnetostatics document to work on. femm.newdocument(0); # Define the problem type. Magnetostatic; Units of mm; Axisymmetric; # Precision of 10^(-8) for the linear solver; a placeholder of 0 for # the depth dimension, and an angle constraint of 30 degrees femm.mi_probdef(0, 'millimeters', 'axi', 1.e-8, 0, 30); # Draw a rectangle for the steel bar on the axis; femm.mi_drawrectangle(0, -40, 10, 40); # Draw a rectangle for the coil; femm.mi_drawrectangle(50, -50, 100, 50);
# # dir_run = r'D:\femm42\PS_Qr36_NoEndRing_M15_17303l_DPNV\static-femm/' # dir_run = r'D:\femm42\PS_Qr32_NoEndRing_M19Gauge29_DPNV_1e3Hz\static-femm\sweeping/' id_solver = int(sys.argv[1]) number_of_instances = int(sys.argv[2]) dir_run = sys.argv[3] print('ParaSolve', id_solver) handle_torque = open(dir_run + "static_results_%d.txt" % (id_solver), 'a') # handle_stator_B_data = open(dir_run + "static_results_stator_B_data_%d.txt"%(id_solver), 'a') # use 'ab' for np.savetxt https://stackoverflow.com/questions/27786868/python3-numpy-appending-to-a-file-using-numpy-savetxt # handle_rotor_B_data = open(dir_run + "static_results_rotor_B_data_%d.txt"%(id_solver), 'a') fem_file_list = os.listdir(dir_run) fem_file_list = [f for f in fem_file_list if '.fem' in f] femm.openfemm(True) # bHide femm.callfemm_noeval('smartmesh(0)') # this is essential to reduce elements counts from >50000 to ~20000. print('mi_smartmesh is off') for i in range(id_solver, len(fem_file_list), number_of_instances): output_file_name = dir_run + fem_file_list[i][:-4] if not os.path.exists(output_file_name + '.ans'): tic = time() femm.opendocument(output_file_name + '.fem') # femm.callfemm_noeval('mi_smartmesh(0)') try: # femm.mi_createmesh() # [useless]
femm.mi_setgroup(group) femm.mi_selectsegment(c1_x + width / 2, c1_y) femm.mi_setgroup(group) femm.mi_selectsegment(c2_x, c2_y) femm.mi_setgroup(group) femm.mi_selectsegment(c2_x, c2_y + length / 2) femm.mi_setgroup(group) femm.mi_selectsegment(c3_x, c3_y) femm.mi_setgroup(group) femm.mi_selectsegment(c3_x - width / 2, c3_y) femm.mi_setgroup(group) #femm.mi_clearselected() femm.openfemm(0) femm.opendocument( "setup.fem") # Load a template that has all the required materials already # pre-loaded, i.e when calling 'femm.mi_setblockprop('NdFeB 52 MGOe'.." # This is how it knows where to get that property 'NdFeB 52 MGOe' femm.mi_saveas( "temporary.fem" ) # this changes the working file so that 'template.fem' is always whats in use # This is Wire Gauge Data from MWS industries # it may not line up exactly with the magnet wire in FEMM # so it is good to be aware of this # its 14 to 32 AWG AWG_list = np.linspace(14, 32, 32 - 14 + 1).tolist() OD_list = [ 0.06695, 0.05975, 0.0534, 0.0478, 0.04275, 0.0382, 0.03425, 0.0306,
def simulate(self): self.__updateDimensions() # open FEMM femm.openfemm() femm.main_maximize() # True Steady State # new Magnetostatics document femm.newdocument(0) # Define the problem type. Magnetostatic; Units of mm; 2D planar; # Precision of 10^(-8) for the linear solver; a placeholder of 0 for # the depth dimension, and an angle constraint of 30 degrees femm.mi_probdef(0, 'millimeters', 'planar', 1.e-8, 0, 30) # Import Materials femm.mi_getmaterial('Air') femm.mi_getmaterial(self.magnetType) femm.mi_getmaterial(self.windingType) # Draw geometry # Coil for coil in range(0, self.numStators): corner = Vector(coil * (self.coilLength + self.coilBufferLength), 0) femm.mi_drawrectangle(corner.x, corner.y, corner.x + self.coilLength, corner.y + self.pcbThickness) femm.mi_addblocklabel(corner.x + self.coilLength / 2, corner.y + self.pcbThickness / 2) femm.mi_selectlabel(corner.x + self.coilLength / 2, corner.y + self.pcbThickness / 2) femm.mi_setblockprop(self.windingType, 1, 0, '<None>', 0, 0, self.numWindings) # # Upper Rotor for magnet in range(0, self.numPoles): corner = Vector(magnet * (self.magnetLength + self.magnetBufferLength), self.pcbThickness + self.airGap) femm.mi_drawrectangle(corner.x, corner.y, corner.x + self.magnetLength, corner.y + self.rotorThickness) femm.mi_addblocklabel(corner.x + self.magnetLength / 2, corner.y + self.rotorThickness / 2) femm.mi_selectlabel(corner.x + self.magnetLength / 2, corner.y + self.rotorThickness / 2) if magnet % 2 == 0: femm.mi_setblockprop(self.magnetType, 1, 0, '<None>', 90, 0, 0) else: femm.mi_setblockprop(self.magnetType, 1, 0, '<None>', -90, 0, 0) if magnet == int(self.numPoles / 2): self.testPoint = Vector(corner.x, 0 + self.pcbThickness / 2) # Lower Rotor for magnet in range(0, self.numPoles): corner = Vector(magnet * (self.magnetLength + self.magnetBufferLength), -self.airGap) femm.mi_drawrectangle(corner.x, corner.y, corner.x + self.magnetLength, corner.y - self.rotorThickness) femm.mi_addblocklabel(corner.x + self.magnetLength / 2, corner.y - self.rotorThickness / 2) femm.mi_selectlabel(corner.x + self.magnetLength / 2, corner.y - self.rotorThickness / 2) if magnet % 2 == 0: femm.mi_setblockprop(self.magnetType, 1, 0, '<None>', 90, 0, 0) else: femm.mi_setblockprop(self.magnetType, 1, 0, '<None>', -90, 0, 0) # Define an "open" boundary condition using the built-in function: # Add air block label outside machine femm.mi_makeABC() airLabel = Vector((self.numStators / 2) * (self.coilLength + self.coilBufferLength), 5 * (self.rotorThickness + self.airGap)) femm.mi_addblocklabel(airLabel.x, airLabel.y) femm.mi_selectlabel(airLabel.x, airLabel.y) femm.mi_setblockprop('Air', 1, 0, '<None>', 0, 0, 0) # We have to give the geometry a name before we can analyze it. femm.mi_saveas('alternatorSim.fem') # Now,analyze the problem and load the solution when the analysis is finished femm.mi_analyze() femm.mi_loadsolution() # Now, the finished input geometry can be displayed. # femm.mo_zoom(self.testPoint.x - 2 * self.coilLength, self.testPoint.y - self.coilLength, # self.testPoint.x + 2 * self.coilLength, # self.testPoint.y + self.coilLength) # femm.mo_showdensityplot(1, 0, 1, 0, 'mag') self.fluxDensity = self.getFlux()
def draw_FEMM( output, is_mmfr, is_mmfs, sym, is_antiper, type_calc_leakage, is_remove_vent=False, is_remove_slotS=False, is_remove_slotR=False, type_BH_stator=0, type_BH_rotor=0, kgeo_fineness=1, kmesh_fineness=1, user_FEMM_dict={}, path_save="FEMM_model.fem", is_sliding_band=True, transform_list=[], rotor_dxf=None, stator_dxf=None, ): """Draws and assigns the property of the machine in FEMM Parameters ---------- output : Output Output object is_mmfr : bool 1 to compute the rotor magnetomotive force / rotor magnetic field is_mmfs : bool 1 to compute the stator magnetomotive force/stator magnetic field type_calc_leakage : int 0 no leakage calculation 1 calculation using single slot is_remove_vent : bool True to remove the ventilation ducts in FEMM (Default value = False) is_remove_slotS : bool True to solve without slot effect on the Stator (Default value = False) is_remove_slotR : bool True to solve without slot effect on the Rotor (Default value = False) type_BH_stator: int 2 Infinite permeability, 1 to use linear B(H) curve according to mur_lin, 0 to use the B(H) curve type_BH_rotor: bool 2 Infinite permeability, 1 to use linear B(H) curve according to mur_lin, 0 to use the B(H) curve kgeo_fineness : float global coefficient to adjust geometry fineness in FEMM (1: default ; > 1: finner ; < 1: less fine) kmesh_fineness : float global coefficient to adjust mesh fineness in FEMM (1: default ; > 1: finner ; < 1: less fine) sym : int the symmetry applied on the stator and the rotor (take into account antiperiodicity) is_antiper: bool To apply antiperiodicity boundary conditions rotor_dxf : DXFImport To use a dxf version of the rotor instead of build_geometry stator_dxf : DXFImport To use a dxf version of the stator instead of build_geometry Returns ------- FEMM_dict : dict Dictionnary containing the main parameters of FEMM (including circuits and materials) """ # Initialization from output for readibility BHs = output.geo.stator.BH_curve # Stator B(H) curve BHr = output.geo.rotor.BH_curve # Rotor B(H) curve Is = output.elec.Is # Stator currents waveforms Ir = output.elec.Ir # Rotor currents waveforms machine = output.simu.machine # Computing parameter (element size, arcspan...) needed to define the simulation FEMM_dict = comp_FEMM_dict(machine, kgeo_fineness, kmesh_fineness, type_calc_leakage) FEMM_dict.update(user_FEMM_dict) # Overwrite some values if needed # The package must be initialized with the openfemm command. try: femm.openfemm() except Exception as e: raise FEMMError( "ERROR: Unable to open FEMM, please check that FEMM is correctly installed\n" + str(e)) # We need to create a new Magnetostatics document to work on. femm.newdocument(0) # Minimize the main window for faster geometry creation. femm.main_minimize() # defining the problem femm.mi_probdef(0, "meters", FEMM_dict["pbtype"], FEMM_dict["precision"]) # Modifiy the machine to match the conditions machine = type(machine)(init_dict=machine.as_dict()) if is_remove_slotR: # Remove all slots on the rotor lam_dict = machine.rotor.as_dict() machine.rotor = Lamination(init_dict=lam_dict) if is_remove_slotS: # Remove all slots on the stator lam_dict = machine.stator.as_dict() machine.stator = Lamination(init_dict=lam_dict) if is_remove_vent: # Remove all ventilations machine.rotor.axial_vent = list() machine.stator.axial_vent = list() # Building geometry of the (modified) stator and the rotor surf_list = list() lam_list = machine.get_lam_list() lam_int = lam_list[0] lam_ext = lam_list[1] # Adding no_mesh for shaft if needed if lam_int.Rint > 0 and sym == 1: surf_list.append( Circle(point_ref=0, radius=lam_int.Rint, label="No_mesh")) # adding the Airgap surface if is_sliding_band: surf_list.extend( get_sliding_band(sym=sym, lam_int=lam_int, lam_ext=lam_ext)) else: surf_list.extend(get_airgap_surface(lam_int=lam_int, lam_ext=lam_ext)) # adding Both laminations surfaces (or import from DXF) if rotor_dxf is not None: femm.mi_readdxf(rotor_dxf.file_path) surf_list.extend(rotor_dxf.get_surfaces()) else: surf_list.extend(machine.rotor.build_geometry(sym=sym)) if stator_dxf is not None: femm.mi_readdxf(stator_dxf.file_path) surf_list.extend(stator_dxf.get_surfaces()) else: surf_list.extend(machine.stator.build_geometry(sym=sym)) # Applying user defined modifications for transfrom in transform_list: for surf in surf_list: if transfrom["label"] in surf.label and transfrom[ "type"] == "rotate": surf.rotate(transfrom["value"]) elif transfrom["label"] in surf.label and transfrom[ "type"] == "translate": surf.translate(transfrom["value"]) # Creation of all the materials and circuit in FEMM prop_dict, materials, circuits = create_FEMM_materials( machine, surf_list, Is, Ir, BHs, BHr, is_mmfs, is_mmfr, type_BH_stator, type_BH_rotor, is_eddies, j_t0=0, ) create_FEMM_boundary_conditions(sym=sym, is_antiper=is_antiper) # Draw and assign all the surfaces of the machine for surf in surf_list: label = surf.label # Get the correct element size and group according to the label surf.draw_FEMM( nodeprop="None", maxseg=FEMM_dict["arcspan"], # max span of arc element in degrees propname="None", FEMM_dict=FEMM_dict, hide=False, ) assign_FEMM_surface(surf, prop_dict[label], FEMM_dict, machine.rotor, machine.stator) # Apply BC for DXF import if rotor_dxf is not None: for BC in rotor_dxf.BC_list: if BC[1] is True: # Select Arc femm.mi_selectarcsegment(BC[0].real, BC[0].imag) femm.mi_setarcsegmentprop(FEMM_dict["arcspan"], BC[2], False, None) else: # Select Line femm.mi_selectsegment(BC[0].real, BC[0].imag) femm.mi_setsegmentprop(BC[2], None, None, False, None) femm.mi_clearselected() femm.mi_zoomnatural() # Zoom out femm.mi_probdef( FEMM_dict["freqpb"], "meters", FEMM_dict["pbtype"], FEMM_dict["precision"], FEMM_dict["Lfemm"], FEMM_dict["minangle"], FEMM_dict["acsolver"], ) femm.smartmesh(FEMM_dict["smart_mesh"]) femm.mi_saveas(path_save) # Save # femm.mi_close() FEMM_dict["materials"] = materials FEMM_dict["circuits"] = circuits return FEMM_dict
# if __name__ == '__main__': # DEBUG_MODE = True if DEBUG_MODE == False: number_of_instantces = int(sys.argv[1]) dir_femm_temp = sys.argv[2] stack_length = float(sys.argv[3]) VAREPSILON = 0.255 # difference between 1st and 2nd max torque slip frequencies else: #debug number_of_instantces = 5 dir_femm_temp = "D:/OneDrive - UW-Madison/c/csv_opti/run#114/femm_temp/" # modify as expected stack_length = 186.4005899999999940 VAREPSILON = 0.02 femm.openfemm(True) femm.opendocument(dir_femm_temp + 'femm_temp.fem') # here, the only variable for an individual is frequency, so pop = list of frequencies freq_begin = 1. # hz freq_end = freq_begin + number_of_instantces - 1. # 5 Hz list_torque = [] list_slipfreq = [] list_solver_id = [] list_done_id = [] count_loop = 0 while True: # freq_step can be negative! freq_step = (freq_end - freq_begin) / (number_of_instantces - 1)
def draw_FEMM( output, is_mmfr, is_mmfs, sym, is_antiper, type_calc_leakage, is_remove_vent=False, is_remove_slotS=False, is_remove_slotR=False, is_stator_linear_BH=False, is_rotor_linear_BH=False, kgeo_fineness=1, kmesh_fineness=1, user_FEMM_dict={}, path_save="FEMM_model.fem", is_sliding_band=True, ): """Draws and assigns the property of the machine in FEMM Parameters ---------- output : Output Output object is_mmfr : bool 1 to compute the rotor magnetomotive force / rotor magnetic field is_mmfs : bool 1 to compute the stator magnetomotive force/stator magnetic field type_calc_leakage : int 0 no leakage calculation 1 calculation using single slot is_remove_vent : bool True to remove the ventilation ducts in FEMM (Default value = False) is_remove_slotS : bool True to solve without slot effect on the Stator (Default value = False) is_remove_slotR : bool True to solve without slot effect on the Rotor (Default value = False) is_stator_linear_BH: bool 1 to use linear B(H) curve according to mur_lin, 0 to use the B(H) curve is_rotor_linear_BH: bool 1 to use linear B(H) curve according to mur_lin, 0 to use the B(H) curve kgeo_fineness : float global coefficient to adjust geometry fineness in FEMM (1: default ; > 1: finner ; < 1: less fine) kmesh_fineness : float global coefficient to adjust mesh fineness in FEMM (1: default ; > 1: finner ; < 1: less fine) sym : int the symmetry applied on the stator and the rotor (take into account antiperiodicity) is_antiper: bool To apply antiperiodicity boundary conditions Returns ------- FEMM_dict : dict Dictionnary containing the main parameters of FEMM (including circuits and materials) """ # Initialization from output for readibility BHs = output.geo.stator.BH_curve # Stator B(H) curve BHr = output.geo.rotor.BH_curve # Rotor B(H) curve Is = output.elec.Is # Stator currents waveforms Ir = output.elec.Ir # Rotor currents waveforms machine = output.simu.machine # Modifiy the machine to match the conditions machine = type(machine)(init_dict=machine.as_dict()) if is_remove_slotR: # Remove all slots on the rotor lam_dict = machine.rotor.as_dict() machine.rotor = Lamination(init_dict=lam_dict) if is_remove_slotS: # Remove all slots on the stator lam_dict = machine.stator.as_dict() machine.stator = Lamination(init_dict=lam_dict) if is_remove_vent: # Remove all ventilations machine.rotor.axial_vent = list() machine.stator.axial_vent = list() # Building geometry of the (modified) stator and the rotor surf_list = list() lam_ext = machine.get_lamination(is_internal=False) lam_int = machine.get_lamination(is_internal=True) # adding Internal Lamination surface surf_list.extend(lam_int.build_geometry(sym=sym)) # adding the Airgap surface if is_sliding_band: surf_list.extend( get_sliding_band( sym=sym, lam_int=output.simu.machine.get_lamination(True), lam_ext=output.simu.machine.get_lamination(False), ) ) else: surf_list.extend( get_airgap_surface( lam_int=output.simu.machine.get_lamination(True), lam_ext=output.simu.machine.get_lamination(False), ) ) # adding External Lamination surface surf_list.extend(lam_ext.build_geometry(sym=sym)) # Computing parameter (element size, arcspan...) needed to define the simulation FEMM_dict = comp_FEMM_dict( machine, kgeo_fineness, kmesh_fineness, type_calc_leakage ) FEMM_dict.update(user_FEMM_dict) # Overwrite some values if needed # The package must be initialized with the openfemm command. femm.openfemm() # We need to create a new Magnetostatics document to work on. femm.newdocument(0) # Minimize the main window for faster geometry creation. femm.main_minimize() # defining the problem femm.mi_probdef(0, "meters", FEMM_dict["pbtype"], FEMM_dict["precision"]) # Creation of all the materials and circuit in FEMM prop_dict, materials, circuits = create_FEMM_materials( machine, surf_list, Is, Ir, BHs, BHr, is_mmfs, is_mmfr, is_stator_linear_BH, is_rotor_linear_BH, is_eddies, j_t0=0, ) create_FEMM_boundary_conditions(sym=sym, is_antiper=is_antiper) # Draw and assign all the surfaces of the machine for surf in surf_list: label = surf.label # Get the correct element size and group according to the label mesh_dict = get_mesh_param(label, FEMM_dict) surf.draw_FEMM( nodeprop="None", maxseg=FEMM_dict["arcspan"], # max span of arc element in degrees propname="None", elementsize=mesh_dict["element_size"], automesh=mesh_dict["automesh"], hide=False, group=mesh_dict["group"], ) assign_FEMM_surface( surf, prop_dict[label], mesh_dict, machine.rotor, machine.stator ) femm.mi_zoomnatural() # Zoom out femm.mi_probdef( FEMM_dict["freqpb"], "meters", FEMM_dict["pbtype"], FEMM_dict["precision"], FEMM_dict["Lfemm"], FEMM_dict["minangle"], FEMM_dict["acsolver"], ) femm.smartmesh(FEMM_dict["smart_mesh"]) femm.mi_saveas(path_save) # Save # femm.mi_close() FEMM_dict["materials"] = materials FEMM_dict["circuits"] = circuits return FEMM_dict
# This program is inspired of pyfemm exemple demo2, although a lot simpler. # The problem consider an axisymmetric magnetostatic problem # of a 'N48' neodymium ring magnet with a height of 5mm, an # inner radius of 6 mm, and an outer radius of 15 mm. The objective of the analysis is to # determine the flux density at the center of the ring magnet, # and to plot the field along the r=0 axis. This analysis # uses Femm materials library for material properties and employs an # asymptotic boundary condition to approximate an "open" # boundary condition on the edge of the solution domain. import femm import matplotlib.pyplot as plt femm.openfemm() # create an instance of femm without GUI # problem definition femm.newdocument(0) # create new magnetic problem preprocessor document femm.mi_probdef( 0, 'millimeters', 'axi', 1.e-8, 0, 30 ) # Define the problem type. Magnetostatic; Units of mm; Axisymmetric; Precision of 10^(-8) for the linear solver; a placeholder of 0 for the depth dimension, and an angle constraint of 30 degrees # geometry definition femm.mi_drawrectangle(6, 0, 15, 5) # draw a rectangle for the ring magnet; # boundaries conditions femm.mi_makeABC() # simulate an open boundary condition # materials properties femm.mi_addblocklabel(1, 1) # air block (airbox) femm.mi_addblocklabel(10, 3) # ring block (neodymium)
def initial_setup(boundary, currents, **kwargs): '''Start femm and setup problem definition and set boundary condition.''' if kwargs.get('hide') is True: femm.openfemm(1) femm.main_minimize() else: femm.openfemm() # newdocument(doctype) # From manual: Creates a new preprocessor document and opens up a new # preprocessor window. Specify doctype to be 0 for a magnetics problem, 1 # for an electrostatics problem, 2 for a heat flow problem, or 3 for a # current flow problem. An alternative syntax for this command is # create(doctype) femm.newdocument(0) # ei probdef(units,type,precision,(depth),(minangle)) # From manual: changes the problem definition. The units parameter # specifies the units used for measuring length in the problem domain. # Valid "units" entries are "inches", "millimeters", "centimeters", "mils", # "meters, and "micrometers". Set problemtype to "planar" for a 2-D planar # problem, or to "axi" for an axisymmetric problem. The precision parameter # dictates the precision required by the solver. For example, entering # 1.E-8 requires the RMS of the residual to be less than 10^-8. A fourth # parameter, representing the depth of the problem in the into-thepage # direction for 2-D planar problems, can also be specified for planar # problems. A sixth parameter represents the minimum angle constraint sent # to the mesh generator. if 'frequency' in kwargs: freq = kwargs['frequency'] else: freq = 6.78e6 if 'precision' in kwargs: precision = kwargs['precision'] else: precision = 5e-9 if 'min_angle' in kwargs: min_angle = kwargs['min_angle'] else: min_angle = 30 femm.mi_probdef(freq, 'millimeters', 'axi', precision, 50, min_angle) # Circuit parameters # mi addcircprop("circuitname", i, circuittype) # From manual: adds a new circuit property with name "circuitname" with a # prescribed current, i. The circuittype parameter is 0 for a # parallel-connected circuit and 1 for a series-connected circuit. # The currents in the primary and secondary circuits are set I1, I2 = currents femm.mi_addcircprop('phase_prim', I1, 1) femm.mi_addcircprop('phase_sec', I2, 1) # Add materials properties used in the simulation # mi addmaterial("materialname", mu x, mu y, H c, J, Cduct, Lam d, # Phi hmax, lam fill, LamType, Phi hx, Phi hy,NStrands,WireD) # From manual: adds a newmaterial with called "materialname" with the # material properties: # – mu x Relative permeability in the x- or r-direction. # – mu y Relative permeability in the y- or z-direction. # – H c Permanent magnet coercivity in Amps/Meter. # – J Real Applied source current density in Amps/mm2. # – Cduct Electrical conductivity of the material in MS/m. # – Lam d Lamination thickness in millimeters. # – Phi hmax Hysteresis lag angle in degrees, used for nonlinear BH curves. # – Lam fill Fraction of the volume occupied per lamination that is # actually filled with iron (Note that this parameter defaults to 1 the # femm preprocessor dialog box because, by default, iron completely fills # the volume) # – Lamtype Set to # ? 0 – Not laminated or laminated in plane # ? 1 – laminated x or r # ? 2 – laminated y or z # ? 3 – Magnet wire # ? 4 – Plain stranded wire # ? 5 – Litz wire # ? 6 – Square wire # – Phi hx Hysteresis lag in degrees in the x-direction for linear problems # – Phi hy Hysteresis lag in degrees in the y-direction for linear problems # – NStrands Number of strands in the wire build. Should be 1 for Magnet or # Square wire. # – WireD Diameter of each wire constituent strand in millimeters. femm.mi_addmaterial('air', 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0) femm.mi_addmaterial('fr4', 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0) femm.mi_addmaterial('copper', 1, 1, 0, 0, 58, 0, 0, 0, 0, 0, 0) femm.mi_addmaterial('polysterimide', 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0) femm.mi_addmaterial('teflon', 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0) femm.mi_addmaterial('silgel', 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0) if 'material' in kwargs: for m in kwargs['material']: femm.mi_addmaterial(*m) # Boundary condition # ei makeABC(n,R,x,y,bc) # From manual: creates a series of circular shells that emulate the # impedance of an unbounded domain (i.e. an Improvised Asymptotic Boundary # Condition). The n parameter contains the number of shells to be used # (should be between 1 and 10), R is the radius of the solution domain, and # (x,y) denotes the center of the solution domain. The bc parameter should # be specified as 0 for a Dirichlet outer edge or 1 for a Neumann outer # edge. If the function is called without all the parameters, the function # makes up reasonable values for the missing parameters. femm.mi_makeABC(7, boundary, 0, 0, 0)
def open_previous(self, fname): fe.openfemm() fe.opendocument(fname) self.fname = fname