Pyleecan Simulation Framework

For complex or exotic topologies, you can define machines directly in Python by composing various lamination, slot, winding, and machine classes.

Key components include:

• Machine classes: e.g., MachineUD, MachineIPMSM.
• Lamination classes: e.g., LamSlotWind (for stators with windings), LamSlot (for rotors/stators without windings), LamHole (for rotors with magnet holes).
• Slot classes: e.g., SlotW11, SlotW22.
• Winding classes: e.g., WindingCW2LT, WindingDW1L.
• Conductor classes: e.g., CondType11.
• Shaft and Frame: Shaft and Frame classes.

from pyleecan.Classes.MachineUD import MachineUD
from pyleecan.Classes.LamSlotWind import LamSlotWind
from pyleecan.Classes.LamSlot import LamSlot
from pyleecan.Classes.WindingCW2LT import WindingCW2LT
from pyleecan.Classes.SlotW10 import SlotW10
from pyleecan.Classes.SlotW22 import SlotW22
from numpy import pi

machine = MachineUD()

# Example: Defining an outer stator
Rext = 170e-3
W1 = 30e-3
lam1 = LamSlotWind(Rext=Rext, Rint=Rext - W1, is_internal=False, is_stator=True)
lam1.slot = SlotW22(
    Zs=12, W0=2 * pi / 12 * 0.75, W2=2 * pi / 12 * 0.75, H0=0, H2=W1 * 0.65
)
lam1.winding = WindingCW2LT(qs=3, p=3)

machine.lam_list = [lam1]
machine.plot()

To run a simulation over a range of operating points (e.g., varying current angle $\Phi_0$ or $I_d/I_q$), use the VarLoadCurrent class. This creates a 'multi-simulation' that returns an XOutput object.

Steps:

1. Define a single simulation (Simu1) with an InputCurrent object.
2. Create a VarLoadCurrent object.
3. Define an OP_matrix where each row is an operating point. The columns depend on type_OP_matrix:
   • type_OP_matrix = 0: (N0, I0, Phi0)
   • type_OP_matrix = 1: (N0, Id, Iq)
4. Copy the original simulation and assign the var_simu property to the VarLoadCurrent instance.
5. Run the simulation.

XOutput Results: Results are stored in Xout.xoutput_dict. You can access specific results using Xout["key"].result (e.g., Xout["Phi0"].result).

from pyleecan.Classes.VarLoadCurrent import VarLoadCurrent

# 1. Setup VarLoadCurrent
varload = VarLoadCurrent(is_torque=True, is_reuse_femm_file=True)
varload.type_OP_matrix = 0 # Matrix format: N0, I0, Phi0

# 2. Create OP_matrix (example: 5 points)
import numpy as np
OP_matrix = np.zeros((5, 4))
OP_matrix[:, 0] = 2000 # N0
OP_matrix[:, 1] = 250 / np.sqrt(2) # I0
OP_matrix[:, 2] = np.linspace(60*np.pi/180, 180*np.pi/180, 5) # Phi0
OP_matrix[:, 3] = [79, 125, 160, 192, 237] # Reference torque

varload.OP_matrix = OP_matrix

# 3. Run multi-simulation
simu_vop = simu_op.copy()
simu_vop.var_simu = varload
Xout_vop = simu_vop.run()

# 4. Access results
print(Xout_vop["Phi0"].result)

To capture Finite Element (FE) results from a FEMM simulation into a Pyleecan MeshSolution object, set the is_get_mesh attribute to True on the magnetic module before running the simulation.

Once the simulation is complete, you can use the MeshSolution object to:

• Plot the mesh: out_femm.mag.meshsolution.plot_mesh()
• Extract specific groups: Use group_names (e.g., "stator" or ["airgap", "stator_windings"]) or intersection syntax (e.g., ["stator", "/", "airgap"]).
• Plot electromagnetic solutions: Use plot_contour(label="B") for field contours or plot_glyph(label="B") for vector/arrow plots.
• Extract field data: Use get_field(label='B') to retrieve the raw data arrays.

# Enable saving of FEMM mesh and results
simu_femm.mag.is_get_mesh = True

# Run simulation
out_femm = simu_femm.run()

# Plotting examples
out_femm.mag.meshsolution.plot_mesh(group_names="stator")
out_femm.mag.meshsolution.plot_contour(label="B")
out_femm.mag.meshsolution.plot_glyph(label="B", group_names="stator")

Pyleecan solves constrained global optimization problems by separating the problem definition from the solver. To perform an optimization, you must define an OptiProblem object which encapsulates:

1. A Reference Simulation: A base simulation object (e.g., Simu1) that serves as a template. Each optimization iteration copies this simulation and applies new design variable values.
2. Design Variables: Parameters to vary, defined via OptiDesignVarInterval (for continuous variables) or OptiDesignVarSet (for discrete variables).
3. Objective Functions: The metrics to minimize, defined using OptiObjective objects.
4. Constraints (Optional): Limits on the search space, defined using OptiConstraint objects.
5. Evaluation Function: A function (defaults to simu.run) that executes the simulation for a given set of variables and returns the results.

from pyleecan.Classes.OptiProblem import OptiProblem

# Problem creation
my_prob = OptiProblem(
    simu=simu_ref, 
    design_var=my_design_var, 
    obj_func=my_obj,
    constraint = my_constraint,
    eval_func = None # Defaults to simu.run
)

The Air-Gap Surface Force (AGSF) method computes equivalent magnetic pressure in the air-gap using the Maxwell Stress Tensor (MST). To resolve the conflict between numerical error in the middle of the air-gap and MST accuracy at the stator bore radius, Pyleecan provides an AGSF transfer law. This allows you to compute the AGSF at the stator bore radius based on the AGSF calculated in the middle of the air-gap.

To use this feature, configure a ForceMT object within your simulation and set the following parameters:

• is_agsf_transfer=True: Enables the transfer law.
• max_wavenumber_transfer: Sets the maximum wavenumber used for the transfer (e.g., 70 or 100).
• Rsbo_enforced_transfer: Specifies the target radius (stator bore radius) where the transferred force should be applied.

# Create a simulation instance with transfer enabled
simu_transfer = simu.copy()
simu_transfer.force.is_agsf_transfer = True
simu_transfer.force.max_wavenumber_transfer = 70

# When running, specify the target radius (e.g., stator bore radius)
simu_transfer.force.Rsbo_enforced_transfer = Rag

# Run the simulation
out_transfer = simu_transfer.run()