motulator_bearingless.control

motulator_bearingless.control#

Force control of six-phase bearingless synchronous machines.

Two force control methods are implemented. In direct force control, the radial force and the torque are controlled directly by means of feedback linearization, based on a nonlinear electromagnetic model [1]. The force control law is designed in stator coordinates and augmented with a disturbance observer. The stator flux linkages of the two planes are estimated using a state observer in rotor coordinates. The rotor angle and the rotor speed are either measured or estimated by the observer. In current-based force control, the four-pole plane is controlled by a vector controller of motulator, and the radial force reference is converted to the current reference of the two-pole plane, which is current-controlled, in the same manner as the common and differential modes of multi-three-phase machines are controlled in motulator_multiphase. In both methods, the rotor displacement is measured, and it can be controlled by means of an outer levitation controller.

References

Classes#

`BearinglessControlSystem`	Base class of the bearingless control systems.
`BearinglessMagneticModel`	Base class for the machine parameters, as used by the control system.
`BearinglessSynchronousMachinePars`	Constant parameters of a six-phase bearingless synchronous machine.
`CurrentBasedForceControlSystem`	Current-based force control system for six-phase bearingless machine drives.
`CurrentBasedForceController`	Current-based radial force controller of the two-pole plane.
`DirectForceControlSystem`	Direct force control system for six-phase bearingless machine drives.
`DirectForceController`	Direct radial force and torque controller.
`DirectForceControllerCfg`	Direct force controller configuration.
`FluxObserver`	Flux observer in rotor coordinates.
`ForceDisturbanceObserver`	Disturbance observer for the radial force dynamics.
`LevitationController`	Rotor displacement controller.
`SaturatedBearinglessSynchronousMachinePars`	Parameters of a saturated bearingless synchronous machine.

Module Contents#

class motulator_bearingless.control.BearinglessControlSystem(speed_ctrl, levitation_ctrl)[source]#

Bases: motulator.common.control.ControlSystem[motulator_bearingless.model.BearinglessDrive, Measurements, Ref, Fbk]

Base class of the bearingless control systems.

This class implements the parts common to the bearingless control systems: the measurements, the modulators of the two sets, and the external references. The speed and torque references work as in the public VectorControlSystem. In the force-control mode, the radial force reference is given externally, and in the levitation-control mode, the levitation controller gives the force reference based on the displacement reference. Subclasses implement get_feedback, compute_output, and update. Gate blocking is not supported, since the multi-three-phase converter model does not support it.

Parameters:

speed_ctrl (SpeedController | PIController | None) – Speed controller. If None, torque-control mode is used.
levitation_ctrl (LevitationController | None) – Levitation controller. If None, force-control mode is used.

compute_standby_output(fbk)[source]#

Compute the controller output while the gates are blocked.

Parameters:: fbk (Fbk)
Return type:: Ref

get_command(ref)[source]#

Extract the sampling period and the duty ratios from the references.

Parameters:: ref (Ref)
Return type:: tuple[float, collections.abc.Sequence[float]]

get_measurement(mdl)[source]#

Sample the sensors, the speed and position sensors if the drive has them.

Parameters:: mdl (motulator_bearingless.model.BearinglessDrive)
Return type:: Measurements

set_displacement_ref(ref_fcn)[source]#

Set the external displacement reference for levitation-control mode.

Parameters:: ref_fcn (complex | Callable[[float], complex]) – Rotor displacement reference (m) in stator coordinates, constant or a function of time. Defaults to zero, i.e., a centric rotor.
Return type:: None

set_force_ref(ref_fcn)[source]#

Set the external radial force reference for force-control mode.

Parameters:: ref_fcn (complex | Callable[[float], complex]) – Radial force reference (N) in stator coordinates, constant or a function of time. Defaults to zero.
Return type:: None

set_speed_ref(ref_fcn)[source]#

Set the external speed reference for speed-control mode.

Parameters:: ref_fcn (float | Callable[[float], float]) – Speed reference (mechanical rad/s), constant or a function of time.
Return type:: None

set_torque_ref(ref_fcn)[source]#

Set the external torque reference for torque-control mode.

Parameters:: ref_fcn (float | Callable[[float], float]) – Torque reference (Nm), constant or a function of time.
Return type:: None

class motulator_bearingless.control.BearinglessMagneticModel[source]#

Bases: BaseBearinglessMachinePars, Protocol

Base class for the machine parameters, as used by the control system.

In addition to the machine model, the control system needs the flux map psi_s, the force map f_M, the incremental inductance matrix incr_ind_mat, and the sensitivities di_dq and df_dq to the displacement, all as functions of the currents and the displacement.

df_dq(i_s1, i_s2, q_M)[source]#

Force sensitivity d f_M/d q_M at constant flux, shape (…, 2, 2).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

di_dq(i_s1, i_s2, q_M)[source]#

Current sensitivity d i_s/d q_M at constant flux, shape (…, 4, 2).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

f_M(i_s1, i_s2, q_M)[source]#

Radial force (N) as a function of currents (A) and displacement (m).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

Any

incr_ind_mat(i_s1, i_s2, q_M)[source]#

Incremental inductance matrix (H), shape (…, 4, 4), d psi_s/d i_s.

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

psi_s(i_s1, i_s2, q_M)[source]#

Flux linkages (Vs) as functions of currents (A) and displacement (m).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

tuple[Any, Any]

class motulator_bearingless.control.BearinglessSynchronousMachinePars[source]#

Bases: BearinglessMagneticModel

Constant parameters of a six-phase bearingless synchronous machine.

The four-pole rotor produces the torque with the four-pole field (h = 2) and the radial force with the two-pole field (h = 1). Linear magnetics are assumed. The flux linkages are psi_s = L_s(q_M)*i_s, where the inductance matrix depends linearly on the rotor displacement via the radial force constants:

L_s = [[L_1*I, L_21.T], [L_21, diag(L_d, L_q)]]
L_21 = [[m_d*q_i, -m_d*q_j], [m_q*q_j, m_q*q_i]]

The corresponding radial force is f_M = 1.5*i_s.T*(dL_s/dq_M)*i_s, i.e.:

f_i = 3*(m_d*i_2d*i_1d + m_q*i_2q*i_1q)
f_j = 3*(m_q*i_2q*i_1d - m_d*i_2d*i_1q)

Parameters:

R_s (float) – Stator resistance (Ω).
L_1 (float) – Inductance (H) of the two-pole plane, isotropic for the four-pole rotor.
L_d (float) – d-axis inductance (H) of the four-pole plane.
L_q (float) – q-axis inductance (H) of the four-pole plane.
m_d (float) – d-axis radial force constant (H/m).
m_q (float) – q-axis radial force constant (H/m).

Notes

The negative stiffness (unbalanced magnetic pull proportional to the displacement) is a second-order effect of the displacement on the inductances, which is not included in this linear model.

df_dq(i_s1, i_s2, q_M)[source]#

Force sensitivity d f_M/d q_M at constant flux, shape (…, 2, 2).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

di_dq(i_s1, i_s2, q_M)[source]#

Current sensitivity d i_s/d q_M at constant flux, shape (…, 4, 2).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

f_M(i_s1, i_s2, q_M)[source]#

Radial force (N) as a function of currents (A) and displacement (m).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

Any

i_s(psi_s1, psi_s2, q_M, exp_j_theta_M=None)[source]#

Currents (A) and radial force (N) from flux linkages (Vs).

Parameters:

psi_s1 (Any)
psi_s2 (Any)
q_M (Any)
exp_j_theta_M (Any)

Return type:

tuple[Any, Any, Any]

incr_ind_mat(i_s1, i_s2, q_M)[source]#

Incremental inductance matrix (H), shape (…, 4, 4).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

ind_mat(q_M)[source]#

Inductance matrix (H), shape (…, 4, 4), at the displacement q_M.

Parameters:: q_M (Any)
Return type:: numpy.ndarray

psi_s(i_s1, i_s2, q_M)[source]#

Flux linkages (Vs) as functions of currents (A) and displacement (m).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

tuple[Any, Any]

class motulator_bearingless.control.CurrentBasedForceControlSystem(vector_ctrl, force_ctrl, speed_ctrl=None, levitation_ctrl=None)[source]#

Bases: BearinglessControlSystem[VectorReferences, motulator.drive.control.sm.ObserverOutputs]

Current-based force control system for six-phase bearingless machine drives.

The four-pole plane is controlled by a vector controller of motulator for synchronous machines, configured with the parameters of the equivalent three-phase machine, see fourpole_pars(). The feedback signals of the vector controller are the voltage of the four-pole plane and twice its current, i.e., the sum of the set currents, cf. the common mode of multi-three-phase machines in motulator_multiphase. The two-pole plane is controlled by the current-based force controller in the coordinates of the vector controller, cf. the differential mode. Both planes rotate at the same electrical angular speed in stator coordinates, so the angle advance k_comp*T_s*w_c of the voltage references is common to them, as in the public VectorControlSystem. The reference modes are described in BearinglessControlSystem.

The feedback and reference signals of the vector controller are logged in the signal groups fbk and ref, and those of the force control in the groups force_fbk and force_ref. In post-processing, the latter are merged into the former, and the four-pole flux linkage psi_s2 is added, so that the time series have the same layout as those of DirectForceControlSystem. The space vectors of both planes are in the coordinates of the vector controller.

Parameters:

vector_ctrl (VectorController) – Vector controller of the four-pole plane, configured with the parameters of the equivalent three-phase machine.
force_ctrl (CurrentBasedForceController) – Current-based force controller of the two-pole plane.
speed_ctrl (SpeedController | PIController | None, optional) – Speed controller. If None (default), torque-control mode is used.
levitation_ctrl (LevitationController | None, optional) – Levitation controller. If None (default), force-control mode is used.

compute_output(fbk)[source]#

Compute the controller output.

Parameters:: fbk (motulator.drive.control.sm.ObserverOutputs)
Return type:: VectorReferences

get_feedback(meas)[source]#

Get the feedback signals.

Parameters:: meas (Measurements)
Return type:: motulator.drive.control.sm.ObserverOutputs

post_process()[source]#

Extend the post-process method.

Return type:: motulator.common.control.TimeSeries

save(t, **signal_groups)[source]#

Extend the base class method by saving the force control signals.

Parameters:

t (float)
signal_groups (Any)

Return type:

None

update(ref, fbk)[source]#

Update the controller states.

Parameters:

ref (VectorReferences)
fbk (motulator.drive.control.sm.ObserverOutputs)

Return type:

None

class motulator_bearingless.control.CurrentBasedForceController(par, alpha_c=2 * pi * 200, alpha_i=None, i_s1_max=inf, T_s=None)[source]#

Current-based radial force controller of the two-pole plane.

The radial force reference is converted to the current reference of the two-pole plane, and the current is controlled by a complex-vector PI controller, in the same manner as the differential-mode currents of multi-three-phase machines are controlled in motulator_multiphase. The two-pole plane is modeled as a resistive-inductive circuit with the inductance L_1, and its current is controlled in the coordinates of the vector controller of the four-pole plane. In these coordinates, the force-producing current is constant in the steady state, and the radial force in stator coordinates is given by the linear force model [3]:

f_M_ab = 3*k*conj(i_s1)    k = m_d*i_s2d + 1j*m_q*i_s2q

where i_s2 is the current of the four-pole plane in rotor coordinates. The current reference is obtained by inverting this model, and the force estimate for the levitation control is computed from the measured currents. Magnetic saturation and the eccentricity effects on the inductances are not taken into account, cf. DirectForceController.

Parameters:

par (BearinglessSynchronousMachinePars) – Machine model parameter estimates.
alpha_c (float, optional) – Current-control bandwidth (rad/s), defaults to 2*pi*200.
alpha_i (float, optional) – Integral-action bandwidth (rad/s), defaults to alpha_c. Not used in the direct discrete-time design.
i_s1_max (float, optional) – Maximum current (A) of the two-pole plane, defaults to inf.
T_s (float, optional) – Sampling period (s). If given, the direct discrete-time design is used instead of the continuous-time design. The vector controller must then be a direct discrete-time design as well (k_comp = 0), since the angle advance of the voltage references is common to both planes, and its sampling period must equal this value.

compute_output(f_M_ab_ref, fbk)[source]#

Compute the current and voltage references of the two-pole plane.

Parameters:

f_M_ab_ref (complex)
fbk (ForceFeedbacks)

Return type:

ForceReferences

get_feedback(i_s1_ab, u_s1_ab, i_s2, theta_c, q_M_ab)[source]#

Get the feedback signals.

Parameters:

i_s1_ab (complex) – Two-pole current (A) in stator coordinates.
u_s1_ab (complex) – Realized two-pole voltage (V) in stator coordinates.
i_s2 (complex) – Four-pole current (A) in the coordinates of the vector controller.
theta_c (float) – Angle (rad) of the coordinates of the vector controller.
q_M_ab (complex) – Measured rotor displacement (m) in stator coordinates.

Return type:

ForceFeedbacks

update(T_s, ref, fbk, w_c)[source]#

Update the integral state using the realized or limited voltage.

Parameters:

T_s (float)
ref (ForceReferences)
fbk (ForceFeedbacks)
w_c (float)

Return type:

None

class motulator_bearingless.control.DirectForceControlSystem(force_ctrl, speed_ctrl=None, levitation_ctrl=None)[source]#

Bases: BearinglessControlSystem[References, Feedbacks]

Direct force control system for six-phase bearingless machine drives.

The reference modes are described in BearinglessControlSystem.

Parameters:

force_ctrl (DirectForceController) – Inner force and torque controller.
speed_ctrl (SpeedController | PIController | None, optional) – Speed controller. If None (default), torque-control mode is used.
levitation_ctrl (LevitationController | None, optional) – Levitation controller. If None (default), force-control mode is used.

compute_output(fbk)[source]#

Compute the controller output.

Parameters:: fbk (Feedbacks)
Return type:: References

get_feedback(meas)[source]#

Get the feedback signals.

Parameters:: meas (Measurements)
Return type:: Feedbacks

update(ref, fbk)[source]#

Update the controller states.

Parameters:

ref (References)
fbk (Feedbacks)

Return type:

None

class motulator_bearingless.control.DirectForceController(par, cfg)[source]#

Direct radial force and torque controller.

The voltage reference is u_s = R_s i_s + w_M J_M psi_s + e, where the control input e = [e_1, e_2] linearizes the force dynamics of the two-pole plane and the flux and torque dynamics of the four-pole plane [1]. The control laws neglect the effect of the four-pole input e_2 on the force and that of the two-pole input e_1 on the torque, i.e., the planes are assumed to be decoupled in the control design, while the machine model includes the couplings. The flux and torque references of the four-pole plane are based on the maximum-torque-per-ampere and maximum-torque-per-volt loci of the magnetic model, sliced at zero two-pole current and at a centric rotor. The two-pole plane loads the converter only slightly, so that the voltage limit is assigned to the four-pole plane.

Parameters:

par (BearinglessMagneticModel) – Machine model parameter estimates.
cfg (DirectForceControllerCfg) – Configuration.

compute_output(tau_M_ref, f_M_ab_ref, fbk)[source]#

Compute the references.

Parameters:

tau_M_ref (float)
f_M_ab_ref (complex)
fbk (Feedbacks)

Return type:

References

get_feedback(u_s1_ab, u_s2_ab, i_s1_ab, i_s2_ab, w_M, theta_M, q_M_ab)[source]#

Get the feedback signals.

Parameters:

u_s1_ab (complex)
u_s2_ab (complex)
i_s1_ab (complex)
i_s2_ab (complex)
w_M (float | None)
theta_M (float | None)
q_M_ab (complex)

Return type:

Feedbacks

update(ref, fbk)[source]#

Update the states.

Parameters:

ref (References)
fbk (Feedbacks)

Return type:

None

class motulator_bearingless.control.DirectForceControllerCfg[source]#

Direct force controller configuration.

Parameters:

i_s_max (float) – Maximum current (A) of the four-pole plane.
psi_s_min (float) – Minimum flux magnitude (Vs) of the four-pole plane, i.e., the bias flux for the force production.
psi_s_max (float, optional) – Maximum flux magnitude (Vs) of the four-pole plane, defaults to inf.
k_u (float, optional) – Voltage utilization factor of the field weakening, defaults to 0.95.
k_mtpv (float, optional) – Margin of the maximum-torque-per-volt limit, defaults to 0.9.
alpha_f (float, optional) – Force-control bandwidth (rad/s), defaults to 2*pi*300.
alpha_i (float, optional) – Integral-action bandwidth (rad/s) of the force control, i.e., the bandwidth of the force disturbance observer, defaults to 2*pi*30. The observer is disabled if the value is zero.
alpha_psi (float, optional) – Flux-control bandwidth (rad/s), defaults to 2*pi*200.
alpha_tau (float, optional) – Torque-control bandwidth (rad/s), defaults to 2*pi*200.
zeta (float, optional) – Damping ratio of the flux observer, defaults to 0.45.
sensorless (bool, optional) – If True, the rotor angle and the rotor speed are estimated, defaults to False.
alpha_o (float, optional) – Speed-estimation pole (rad/s) in the sensorless mode, defaults to 2*pi*100.
T_s (float, optional) – Sampling period (s), defaults to 125e-6.

class motulator_bearingless.control.FluxObserver(par, zeta=0.45, sensorless=False, alpha_o=2 * pi * 100)[source]#

Flux observer in rotor coordinates.

The stator flux linkages of both planes are estimated based on the voltage model, corrected by the flux map of the machine [1]. The observer gain of the two-pole plane places the estimation-error poles at the distance w_M from the origin with the damping ratio zeta. The gain of the four-pole plane projects the error signal onto the auxiliary flux linkage with the damping b = 2*zeta*|w_M|. The flux estimates are updated using the voltages of the ongoing sampling period. The voltage is constant in stator coordinates during the sampling period, so that its integral is exact for a constant speed of the coordinates, which avoids the coupling from the voltage transients to the position error signal. The resistive voltage drop and the correction are held constant in stator coordinates during the period.

In the sensorless mode, the rotor angle and the rotor speed are estimated using the component of the four-pole error signal perpendicular to the auxiliary flux linkage, as in the public observer for synchronous machines [2]. The projection in the four-pole observer gain decouples the flux estimation from the angle estimation.

Parameters:

par (BearinglessMagneticModel) – Machine model parameter estimates.
zeta (float, optional) – Damping ratio of the estimation-error dynamics, defaults to 0.45.
sensorless (bool, optional) – If True, the rotor angle and the rotor speed are estimated, defaults to False.
alpha_o (float, optional) – Speed-estimation pole (rad/s), defaults to 2*pi*100.

compute_output(u_s1_ab, u_s2_ab, i_s1_ab, i_s2_ab, w_M, theta_M, q_M_ab)[source]#

Compute the feedback signals in rotor coordinates.

In the sensorless mode, the measured rotor speed w_M and the measured rotor angle theta_M are replaced with their estimates.

Parameters:

u_s1_ab (complex)
u_s2_ab (complex)
i_s1_ab (complex)
i_s2_ab (complex)
w_M (float | None)
theta_M (float | None)
q_M_ab (complex)

Return type:

Feedbacks

update(T_s, fbk)[source]#

Update the flux estimates.

Parameters:

T_s (float)
fbk (Feedbacks)

Return type:

None

class motulator_bearingless.control.ForceDisturbanceObserver(alpha_i)[source]#

Disturbance observer for the radial force dynamics.

The force dynamics in stator coordinates are modeled as df_M_ab/dt = w + d, where w is the model-based part and the disturbance d is assumed to be constant in stator coordinates. The disturbance is estimated as dd/dt = alpha_i*(df_M_ab/dt - w - d). The force derivative is avoided by means of the state z = d - alpha_i*f_M_ab. Combined with the proportional control law, the observer provides the integral action, cf. the disturbance-observer structure of the 2DOF PI controller. If the realized voltage is used in w, the observer is free from windup.

Parameters:: alpha_i (float) – Observer bandwidth (rad/s).

compute_output(f_M_ab)[source]#

Compute the disturbance estimate (N/s) in stator coordinates.

Parameters:: f_M_ab (complex)
Return type:: complex

update(T_s, w, d)[source]#

Update the state.

Parameters:

T_s (float)
w (complex)
d (complex)

Return type:

None

class motulator_bearingless.control.LevitationController(m, alpha_q, alpha_o=None)[source]#

Rotor displacement controller.

The radial dynamics of the rotor in stator coordinates are modeled as m*dv_M_ab/dt = f_M_ab + f_ext_ab and dq_M_ab/dt = v_M_ab, where the external force f_ext_ab (e.g., gravity) is a constant disturbance. The displacement, the lateral velocity, and the external force are estimated by a disturbance observer from the measured displacement and the radial force estimate. The force reference is obtained from the state feedback law:

f_M_ab_ref = m*(alpha_q**2*(q_M_ab_ref - q_M_ab) - 2*alpha_q*v_M_ab) - f_ext_ab

which results in the double closed-loop pole at s = -alpha_q. The control law has no memory: the integral action is provided by the observer. Since the observer is driven by the radial force estimate, the dynamics and the limits of the inner force control loop do not cause windup.

Parameters:

m (float) – Rotor mass estimate (kg).
alpha_q (float) – Displacement-control bandwidth (rad/s).
alpha_o (float, optional) – Triple pole (rad/s) of the observer, defaults to 3*alpha_q.

compute_output(q_M_ab_ref)[source]#

Compute the radial force reference (N) in stator coordinates.

Parameters:: q_M_ab_ref (complex)
Return type:: complex

update(T_s, q_M_ab, f_M_ab)[source]#

Update the state estimates.

Parameters:

T_s (float)
q_M_ab (complex)
f_M_ab (complex)

Return type:

None

class motulator_bearingless.control.SaturatedBearinglessSynchronousMachinePars[source]#

Bases: BearinglessMagneticModel

Parameters of a saturated bearingless synchronous machine.

The class corresponds to motulator.drive.model.SaturatedSynchronousMachinePars. The saturation model is specified as a current map. Optionally, to be used only in control systems, a flux map can be provided.

Parameters:

R_s (float) – Stator resistance (Ω).
i_s_fcn (Callable[[Any, Any, Any], tuple[Any, Any, Any]], optional) – Currents (A) and radial force (N) as functions of the flux linkages (Vs) of the two planes and the displacement (m), e.g., CurrentMap. Needed in the machine model.
psi_s_fcn (FluxMapFcn, optional) – Flux linkages (Vs) and radial force (N) as functions of the currents (A) of the two planes and the displacement (m), with the Jacobian, e.g., FluxMap. Needed in the control systems.

df_dq(i_s1, i_s2, q_M)[source]#

Force sensitivity d f_M/d q_M at constant flux, shape (…, 2, 2).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

di_dq(i_s1, i_s2, q_M)[source]#

Current sensitivity d i_s/d q_M at constant flux, shape (…, 4, 2).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

f_M(i_s1, i_s2, q_M)[source]#

Radial force (N) as a function of currents (A) and displacement (m).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

Any

i_s(psi_s1, psi_s2, q_M, exp_j_theta_M=None)[source]#

Currents (A) and radial force (N) from flux linkages (Vs).

Parameters:

psi_s1 (Any)
psi_s2 (Any)
q_M (Any)
exp_j_theta_M (Any)

Return type:

tuple[Any, Any, Any]

incr_ind_mat(i_s1, i_s2, q_M)[source]#

Incremental inductance matrix (H), shape (…, 4, 4).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

numpy.ndarray

linearized(i_s2)[source]#

Constant parameters of the linear model at an operating point.

The inductances of the four-pole plane are the secant inductances at the given current and those of the two-pole plane are the incremental inductances at a centric rotor without the two-pole current. The force constants are fitted to the sensitivity of the radial force to the two-pole current.

Parameters:: i_s2 (complex) – Current (A) of the four-pole plane in rotor coordinates. Its both components must be nonzero.
Returns:: Parameters of the linear model.
Return type:: BearinglessSynchronousMachinePars

psi_s(i_s1, i_s2, q_M)[source]#

Flux linkages (Vs) as functions of currents (A) and displacement (m).

Parameters:

i_s1 (Any)
i_s2 (Any)
q_M (Any)

Return type:

tuple[Any, Any]