Electrical Machines Cheatsheet Cheatsheet

🔄

Transformers

CORE

EMF Equation

E = 4.44 f N Φ_m [V]

Φ_m = B_m × A_c [Wb]; B_m = peak flux density (1.5–1.7 T)

f = P×N_s/120; P = poles, N_s = synchronous speed (rpm)

a = N₁/N₂ = V₁/V₂ (ideal); actual: a ≈ V₁/V₂ + regulation

Transformer Types

Type	Construction	Application	Efficiency
Core type	Windings on two limbs	Power, distribution	97–99%
Shell type	Windings on central limb	High current, low voltage	96–98%
Auto-transformer	Single winding, tapped	Starter, HVDC, earthing	98–99.5%
Instrument (CT/PT)	Burrden-limited	Metering, protection	N/A (ratio accuracy)

transformer_efficiency.py

# Transformer efficiency & maximum efficiency
import math

S_rated = 500e3    # 500 kVA
V1 = 11000         # Primary voltage (V)
V2 = 400           # Secondary voltage (V)
f = 50             # Hz

# Test results
P0 = 1200          # No-load loss (core) in W  [W]
Psc = 4800         # Short-circuit loss (copper) at rated load [W]
pf = 0.8           # load power factor lagging

# Core loss is constant
P_core = P0

# Copper loss varies with load²
def efficiency(load_fraction, power_factor=0.8):
    P_cu = Psc * load_fraction**2
    P_out = S_rated * load_fraction * power_factor
    P_in = P_out + P_core + P_cu
    return P_out / P_in * 100

# Maximum efficiency occurs when P_core = P_cu
load_max_eff = math.sqrt(P_core / Psc)
print(f"Max efficiency at {load_max_eff*100:.1f}% load")
print(f"Max η = {efficiency(load_max_eff, 1.0):.3f}% (at unity PF)")
print(f"η at full load (0.8 PF) = {efficiency(1.0, 0.8):.3f}%")
print(f"η at half load (0.8 PF) = {efficiency(0.5, 0.8):.3f}%")

# All-day efficiency (24-hour duty cycle)
loads = [(1.0, 8), (0.5, 8), (0.0, 8)]  # (fraction, hours)
total_out = sum(S_rated * lf * pf * h for lf, h in loads)
total_cu  = sum(Psc * lf**2 * h for lf, h in loads)
total_core = P0 * 24
all_day_eff = total_out / (total_out + total_cu + total_core) * 100
print(f"\nAll-day efficiency = {all_day_eff:.2f}%")

Transformer Losses

Loss Type	Component	Cause	Reduction
Hysteresis	Core	Domain reversal	Silicon steel (3%), grain-oriented
Eddy current	Core	Induced circulating currents	Laminations (0.3–0.5 mm)
Copper (I²R)	Windings	Load current	Lower R, more copper area
Stray	Tank/structural	Leakage flux	Magnetic shielding

💡

Auto-transformers save copper when the voltage ratio is close to unity (e.g., 132/110 kV). Copper saving ≈ (1 − 1/a) × 100%. However, they provide no electrical isolation between primary and secondary.

⚙️

DC Machines

CORE

DC Motor Types

Type	τ vs ω curve	Starting torque	Speed regulation	Application
Shunt	Flat (nearly constant speed)	Medium	5–10%	Lathes, fans, blowers
Series	High torque at low speed	Very high	Poor (runs away no-load)	Traction, cranes
Compound (cum.)	Between shunt & series	High	5–10%	Presses, rolling mills
PMDC	Linear (good servo)	Moderate	1–2%	Servos, robotics, EVs

Fundamental Equations

E_b = V − I_a R_a = PΦNZ / (60A)

E_g = PΦNZ / (60A) = kΦω

τ = PΦI_aZ / (2πA) = kΦI_a [N·m]

N = (V − I_a R_a) / kΦ [rpm]

P_dev = E_b × I_a = τ × ω [W]

dc_motor_speed_torque.py

# DC shunt motor: speed-torque characteristic
import numpy as np
import math

V = 220            # Supply voltage (V)
R_a = 0.5          # Armature resistance (Ω)
I_a_rated = 50     # Rated armature current (A)
k_phi = 2.2        # Motor constant × flux (V·s/rad)

# Speed and torque vs armature current
print(f"{'I_a (A)':>8s}  {'E_b (V)':>8s}  {'N (rpm)':>8s}  {'τ (N·m)':>8s}  {'P_dev (kW)':>10s}")
print("-" * 55)

for I_a in np.linspace(0, I_a_rated * 1.5, 8):
    Eb = V - I_a * R_a
    omega = Eb / k_phi if k_phi != 0 else 0
    N = omega * 60 / (2 * math.pi)
    tau = k_phi * I_a
    P = Eb * I_a / 1000
    print(f"{I_a:>8.1f}  {Eb:>8.1f}  {N:>8.1f}  {tau:>8.1f}  {P:>10.2f}")

# Speed regulation at full load
Eb_fl = V - I_a_rated * R_a
N_fl = Eb_fl / k_phi * 60 / (2 * math.pi)
Eb_nl = V  # no-load Ia ≈ 0
N_nl = Eb_nl / k_phi * 60 / (2 * math.pi)
SR = (N_nl - N_fl) / N_fl * 100
print(f"\nSpeed regulation = {SR:.2f}%")
print(f"Full-load speed = {N_fl:.1f} rpm")
print(f"No-load speed   = {N_nl:.1f} rpm")

DC Motor Starting & Speed Control

Limits I_a to 125–150% rated at start (R_st = V/I_a_start − R_a)

Below base speed; wastes energy, poor efficiency

Above base speed; weakening flux increases speed

Smooth 4-quadrant speed control via separate M-G set

PWM duty cycle: V_avg = D × V_s; used in EV drives

🚫

NEVER start a DC series motor without load — it will accelerate to dangerous speeds (runaway condition) because N ∝ 1/Φ and Φ drops with I_a.

🌀

Induction Motors

CORE

Slip & Speed

N_s = 120f / P [rpm]; f = supply freq, P = poles

s = (N_s − N) / N_s; typical full-load slip = 2–5%

N = N_s(1 − s) [rpm]

f_r = s × f [Hz]

s_m = R₂ / √(R₁² + (X₁ + X₂)²)

Torque Equations

τ = (3V₁²R₂/s) / [ωs{(R₁ + R₂/s)² + (X₁+X₂)²}] [N·m]

τ_max = 3V₁² / [2ωs{R₁ + √(R₁²+(X₁+X₂)²)}]

τ_start = τ at s=1 (plug s=1 into torque equation)

R₂ = s_m × √(R₁² + (X₁ + X₂)²)

induction_motor_torque.py

# 3-phase squirrel-cage induction motor torque-slip curve
import numpy as np
import math

V = 400             # Line voltage (V)
f = 50              # Hz
P = 4               # Poles
N_s = 120 * f / P   # 1500 rpm
omega_s = N_s * 2 * math.pi / 60

# Equivalent circuit parameters (referred to stator)
R1 = 1.0    # Stator resistance (Ω)
R2 = 0.8    # Rotor resistance (Ω)
X1 = 1.5    # Stator reactance (Ω)
X2 = 1.5    # Rotor reactance (Ω)

V_ph = V / math.sqrt(3)

def torque(s):
    num = 3 * V_ph**2 * (R2 / s)
    den = omega_s * ((R1 + R2/s)**2 + (X1 + X2)**2)
    return num / den

# Key points
s_max_torque = R2 / math.sqrt(R1**2 + (X1 + X2)**2)
T_max = torque(s_max_torque)
T_start = torque(1.0)
T_full = torque(0.04)  # 4% slip

print(f"Synchronous speed   = {N_s} rpm")
print(f"Slip at max torque  = {s_max_torque:.4f}")
print(f"Max torque          = {T_max:.1f} N·m")
print(f"Starting torque     = {T_start:.1f} N·m  (T_start/T_max = {T_start/T_max:.2f})")
print(f"Full-load (s=4%)    = {T_full:.1f} N·m  at {N_s*(1-0.04):.0f} rpm")

# Torque-speed curve
print(f"\n{'Slip':>6s}  {'Speed (rpm)':>12s}  {'Torque (N·m)':>12s}")
print("-" * 36)
for s in [1.0, 0.5, 0.3, s_max_torque, 0.1, 0.04, 0.01, 0.001]:
    T = torque(s)
    N = N_s * (1 - s)
    print(f"{s:>6.3f}  {N:>12.1f}  {T:>12.1f}")

Starting Methods

Method	Starting current", "Starting torque	Cost
DOL (direct)	5–8 × FL current	150–200% FLT	Low (contactor only)
Star-delta	⅓ of DOL current	⅓ of DOL torque	Low
Auto-transformer	K² × DOL (K = tap)	K² × DOL	Medium
Soft starter	2–3 × FL	40–80% FLT	Medium
VFD (variable freq)	100–150% FLT	100–150% FLT	High (best control)

⚠️

To achieve maximum starting torque equal to breakdown torque, use a wound-rotor IM with external resistance. As motor accelerates, gradually cut out external resistance (rotor resistance starter).

🧲

Synchronous Machines

CORE

EMF Equation

E = 4.44 k_w k_d f N Φ [V]

k_w = k_d × k_p; k_d = sin(mα/2)/(m sin(α/2))

k_p = cos(β/2); β = short-pitch angle

k_d = sin(nα/2) / (n sin(α/2))

Φ = B_av × πDL / P [Wb]

Synchronous Impedance Method

Z_s = E_oc / I_sc (from OC & SC tests)

X_s = √(Z_s² − R_a²) ≈ Z_s (X_s >> R_a)

%VR = |E₀ − V| / |V| × 100

E₀ = √((V cosφ + I R_a)² + (V sinφ + I X_s)²)

δ = tan⁻¹[(I_a X_s cosφ − I_a R_a sinφ) / (V + I_a R_a cosφ + I_a X_s sinφ)]

sync_generator_regulation.py

# Synchronous generator voltage regulation — EMF method
import math

V = 3300            # Line voltage (V)
V_ph = V / math.sqrt(3)
I = 100             # Phase current (A)
pf = 0.8            # lagging
R_a = 0.2           # Armature resistance (Ω)
X_s = 8.0           # Synchronous reactance (Ω)

phi = math.acos(pf)

# EMF calculation (lagging PF)
E0 = math.sqrt(
    (V_ph * math.cos(phi) + I * R_a)**2 +
    (V_ph * math.sin(phi) + I * X_s)**2
)

regulation = (E0 - V_ph) / V_ph * 100

print(f"V_phase    = {V_ph:.1f} V")
print(f"E0         = {E0:.1f} V")
print(f"Regulation = {regulation:.2f}% (lagging PF)")

# Leading PF case
pf_lead = 0.8
phi_lead = math.acos(pf_lead)
E0_lead = math.sqrt(
    (V_ph * math.cos(phi_lead) + I * R_a)**2 +
    (V_ph * math.sin(phi_lead) - I * X_s)**2  # note: minus X_s drop
)
reg_lead = (E0_lead - V_ph) / V_ph * 100
print(f"
Leading PF {pf_lead}:")
print(f"E0         = {E0_lead:.1f} V")
print(f"Regulation = {reg_lead:.2f}% (negative = voltage rise)")

# Power output
P_max = V_ph * E0_lead / X_s  # per phase
P_total = 3 * P_max
print(f"
Max power output = {P_total/1000:.1f} kW (3-phase)")
print(f"Occurs at δ = 90°")

Power & Torque

P = (VE/X_s) sin δ + (V²(R_s − R_s))/(2X_s²)

P ≈ (3V₁E₁/X_s) sin δ [W] for 3-phase

P_max = 3VE/X_s at δ = 90°

P_syn = (3VE/X_s) cos δ₀ per radian of displacement

Over-excited = leading VArs (capacitor); Under-excited = lagging

💡

Synchronous motors are used for power factor correction. An over-excited synchronous motor (running at leading PF) acts as a capacitor bank. Motor starting requires damper winding (amortisseur winding) or VFD.

🔧

Special Machines

SPECIALIZED

Stepper Motors

θ_step = 360° / (N_r × N_ph); N_r = rotor teeth, N_ph = phases

Steps = 360° / θ_step

Variable reluctance (VR), Permanent magnet (PM), Hybrid

High torque + small step angle (0.9°–1.8° typical)

Full step, Half step, Micro-stepping (1/16, 1/256)

Holding torque 0.1–20 N·m; varies with step rate

Servo Motors

Motor + encoder + controller; closed-loop position/speed control

DC servo, AC servo (PMSM-based), Brushless DC (BLDC)

Incremental encoder, Absolute encoder, Resolver

Typical: 1000–20,000 counts/revolution

Servo loop bandwidth: 100–1000 Hz

Other Special Machines

Machine	Principle	Application
Universal motor	Series DC on AC	Drills, blenders, vacuum cleaners
Reluctance motor	Saliency torque	SynRM in EVs, compressors
Hysteresis motor	Hysteresis torque	Clocks, timers, gyroscopes
Linear motor	Flattened rotary motor	Maglev, linear actuators
Switched reluctance	Variable reluctance, rotor saliency	High-speed drives, EVs

stepper_speed_calc.py

# Stepper motor speed calculation
rotor_teeth = 50       # N_r (hybrid stepper)
phases = 4             # N_ph (4-phase or 2-phase with microstepping)

step_angle = 360 / (rotor_teeth * phases)
print(f"Full step angle: {step_angle}°")
print(f"Steps per revolution: {int(360/step_angle)}")

# Speed calculation
pulse_rate = 10000     # pulses per second (pps)
rpm = pulse_rate * step_angle / 360
print(f"\nAt {pulse_rate} pps:")
print(f"Speed = {rpm:.1f} rpm")
print(f"Speed = {rpm * 2 * 3.14159 / 60:.2f} rad/s")

# Resolution with microstepping
for microstep in [1, 2, 4, 8, 16, 256]:
    effective_step = step_angle / microstep
    print(f"  {microstep:>4d}× microstep → {effective_step:.4f}°/step ({int(360/effective_step)} steps/rev)")

⚠️

For CNC and 3D printers, use micro-stepping (16× or higher) for smooth motion, but note that micro-stepping reduces holding torque by ~30% compared to full-step operation. Always ensure adequate torque margin.

🔬

Testing & Measurements

PRACTICAL

Open Circuit (OC) Test — Transformer

Determine core loss (P_i) and shunt parameters (R₀, X₀)

Rated voltage applied to LV side; HV side open

V₀, I₀, P₀ (wattmeter reads core loss)

cos φ₀ = P₀ / (V₀ I₀)

R₀ = V₀²/P₀; X₀ = V₀²/√(P₀² − (V₀I₀)²)

Short Circuit (SC) Test — Transformer

Determine copper loss (P_cu) and series impedance (R_eq, X_eq)

LV side shorted; reduced voltage applied to HV side

Apply until rated current flows (typically 2–8% of rated V)

V_sc, I_sc, P_sc

Z_eq = V_sc/I_sc; R_eq = P_sc/I_sc²; X_eq = √(Z_eq² − R_eq²)

transformer_tests.py

# Transformer OC and SC test results → equivalent circuit
S = 100e3          # 100 kVA
V1 = 2200          # HV (V)
V2 = 220           # LV (V)

# Open circuit test (LV side)
V_oc = 220;  I_oc = 5.0;  P_oc = 400   # V, A, W

# Short circuit test (HV side, LV shorted)
V_sc = 60;  I_sc = 45.5;  P_sc = 800    # V, A, W

# From OC test — referred to LV side
R0 = V_oc**2 / P_oc
I_m = I_oc * (1 - (P_oc / (V_oc * I_oc))**2)**0.5
X0 = V_oc / I_m

# From SC test — referred to HV side
Zeq = V_sc / I_sc
Req = P_sc / I_sc**2
Xeq = (Zeq**2 - Req**2)**0.5

print("=== Shunt branch (referred to LV) ===")
print(f"R₀ = {R0:.1f} Ω")
print(f"X₀ = {X0:.1f} Ω")
print(f"Core loss = {P_oc} W")
print(f"No-load PF = {P_oc/(V_oc*I_oc):.4f}")

print("\n=== Series branch (referred to HV) ===")
print(f"R_eq = {Req:.3f} Ω")
print(f"X_eq = {Xeq:.3f} Ω")
print(f"Z_eq = {Zeq:.3f} Ω")
print(f"%Z = {Zeq * I_sc / V1 * 100:.2f}%")
print(f"Copper loss at full load = {P_sc} W")

# Efficiency at 75% load, 0.8 PF
load = 0.75
P_cu_75 = P_sc * load**2
P_out = S * load * 0.8
eff = P_out / (P_out + P_cu_75 + P_oc) * 100
print(f"\nEfficiency at {load*100:.0f}% load, 0.8 PF = {eff:.2f}%")

Motor Testing

Test	Purpose	Key Parameter
No-load test (IM)	Core + friction/windage loss	P₀ = V₀I₀cosφ₀; separate friction at V → 0
Blocked rotor (IM)	Equivalent R₂, X₂	Like SC test; current at rated V extrapolated
Load test	Efficiency, temperature rise	Direct method: η = P_out/P_in
Back-to-back (Sumpner)	Core + Cu losses simultaneously	Regeneration; both transformers loaded
Slip test (SM)	X_d, X_q measurement	Apply low V; rotate rotor slowly; plot V/I curve

🚫

Always perform the OC test at rated voltage and rated frequency to get accurate core loss values. Core loss is voltage-dependent, not load-dependent. Running a transformer at over-voltage (>5%) causes significant core heating.

📐

Equivalent Circuits

ANALYSIS

Transformer Exact Equivalent Circuit

R₁, X₁ (primary); R₂′, X₂′ (secondary referred to primary)

R₀ (core loss), X₀ (magnetizing) — placed at primary terminals

R₂′ = a²R₂, X₂′ = a²X₂, V₂′ = aV₂, I₂′ = I₂/a

Move shunt branch to input terminals (negligible error)

R_eq = R₁ + R₂′, X_eq = X₁ + X₂′

Induction Motor Equivalent Circuit

R₁ (stator R), X₁ (stator leakage reactance)

R_m (core loss), X_m (magnetizing reactance)

R₂′/s (variable with slip), X₂′ (rotor leakage)

Air-gap power P_ag : rotor Cu loss sP_ag : mechanical (1−s)P_ag

τ = 3I₂′²R₂′/(sωs)

im_equivalent_circuit.py

# Induction motor equivalent circuit — exact solution
import math, cmath

# Per-phase equivalent circuit parameters
V_ph = 230         # Phase voltage (V)
f = 50;  P = 4
N_s = 120*f/P      # 1500 rpm
omega_s = N_s * 2 * math.pi / 60

R1 = 0.5;  X1 = 1.2
R2 = 0.4;  X2 = 1.2    # referred to stator
Xm = 40.0;  Rm = 350.0
s = 0.04                # 4% slip (near full load)

# Impedances
Z1 = complex(R1, X1)
Zm = complex(Rm, Xm)       # parallel combination: 1/Zm = 1/Rm + 1/jXm
Z2 = complex(R2/s, X2)     # rotor branch

# Exact: Zm in parallel with Z2, then series with Z1
Z_parallel = (Zm * Z2) / (Zm + Z2)
Z_total = Z1 + Z_parallel

I1 = V_ph / Z_total
V_airgap = V_ph - I1 * Z1
I2 = V_airgap / Z2
I0 = V_airgap / Zm

# Power calculations
P_input = 3 * V_ph * I1.real   # not exact; use 3*|V||I|cosφ
pf = math.cos(cmath.phase(I1))
P_input = 3 * V_ph * abs(I1) * pf
P_ag = 3 * abs(I2)**2 * R2 / s   # air-gap power
P_cu_rotor = s * P_ag
P_mech = (1 - s) * P_ag
P_stator_cu = 3 * abs(I1)**2 * R1
P_core = 3 * abs(I0)**2 * Rm

print(f"Supply current  I₁ = {abs(I1):.2f} A  (PF = {pf:.3f})")
print(f"Rotor current   I₂′ = {abs(I2):.2f} A")
print(f"Magnetizing     I₀  = {abs(I0):.2f} A")
print(f"\nAir-gap power       = {P_ag:.0f} W")
print(f"Rotor Cu loss        = {P_cu_rotor:.0f} W")
print(f"Mechanical power     = {P_mech:.0f} W")
print(f"Stator Cu loss       = {P_stator_cu:.0f} W")
print(f"Core loss            = {P_core:.0f} W")
print(f"Output ≈ {P_mech:.0f} W (neglecting friction)")
print(f"Efficiency ≈ {P_mech/P_input*100:.1f}%")
print(f"Speed = {N_s*(1-s):.0f} rpm")
print(f"Torque = {P_mech/(N_s*(1-s)*2*math.pi/60):.1f} N·m")

Synchronous Machine Phasor Diagram

Operating Condition	E vs V	δ	Power Factor
Normal (motoring, lagging)	E < V	Small positive	Lagging (under-excited)
Normal (motoring, leading)	E > V	Small positive	Leading (over-excited)
Generator (lagging)	E > V	Positive	Lagging (over-excited)
Generator (leading)	E < V	Positive	Leading (under-excited)
Maximum power	E >> V	δ → 90°	Unity at P_max (approx)

💡

For the exact equivalent circuit of an induction motor, the Thevenin equivalent of the stator + magnetizing branch simplifies torque calculations: V_th = V × Z_m / (Z₁ + Z_m), Z_th = Z₁∥Z_m, then τ = 3V_th²(R₂/s) / [ωs((R_th+R₂/s)²+X_th²)].

🏭

Applications & Selection

PRACTICAL

Motor Selection Guide

Application	Motor Type	Reason	Control
Centrifugal fans	Squirrel-cage IM	Nearly constant speed, rugged	VFD for variable flow
Cranes / Hoists	DC series / Slip-ring IM	High starting torque	Armature R, VFD
Elevators	DC shunt / PMSM	Smooth speed control	VVVF, closed-loop
EV traction	BLDC / PMSM / Induction	High efficiency, regen	FOC, DTC
CNC / Robotics	Servo (PMSM)	Precise positioning	Encoder feedback, PID
Compressors	Synchronous motor	PF correction + drive	VFD / DOL
Clocks / Timers	Hysteresis / Stepper	Constant speed / position	Simple drive
Pumps	Squirrel-cage IM	Simple, reliable	VFD for energy saving

Transformer Selection Criteria

Match system voltages; allow ±5% tap range

S ≥ P_load / PF × 1.25 (25% margin recommended)

Distribution 4–6%, Power 10–15%, Generator 15–20%

Dyn11 (distribution), YNd1 (power), Yy0 (small)

ONAN (natural), ONAF (forced air), OFWF (forced oil-water)

Class A (105°C), B (130°C), F (155°C), H (180°C)

motor_sizing.py

# Motor sizing example: conveyor belt drive
import math

# Load requirements
load_mass = 5000      # kg (conveyor + material)
speed = 2.0           # m/s
inclination = 5       # degrees
efficiency = 0.85     # mechanical transmission efficiency

# Force calculations
g = 9.81
F_gravity = load_mass * g * math.sin(math.radians(inclination))
F_friction = load_mass * g * 0.02  # 2% friction coefficient
F_accel = load_mass * 0.5          # acceleration force (0.5 m/s²)
F_total = F_gravity + F_friction + F_accel

# Power
P_shaft = F_total * speed
P_motor = P_shaft / efficiency

print(f"Required shaft power: {P_shaft:.0f} W ({P_shaft/1000:.2f} kW)")
print(f"Motor rating needed:  {P_motor:.0f} W ({P_motor/1000:.2f} kW)")
print(f"Select next standard: {math.ceil(P_motor/1000 * 2)/2:.1f} kW motor")

# Speed selection for direct drive vs geared
drum_diameter = 0.4   # m
drum_rpm = speed * 60 / (math.pi * drum_diameter)
print(f"\nDrum speed: {drum_rpm:.1f} rpm")
print(f"Use 4-pole motor (1450 rpm) with gear ratio: {1450/drum_rpm:.1f}:1")
print(f"Or 6-pole motor (960 rpm) with gear ratio: {960/drum_rpm:.1f}:1")

⚠️

When selecting motors for variable-torque loads (fans, pumps), remember that power ∝ speed³ (affinity laws). A 20% speed reduction saves nearly 50% energy. VFDs typically pay for themselves in 6–24 months on pump/fan applications.

⏳

Loading cheatsheet...

Type

Construction

Application

Efficiency

Core type

Windings on two limbs

Power, distribution

97–99%

Shell type

Windings on central limb

High current, low voltage

96–98%

Auto-transformer

Single winding, tapped

Starter, HVDC, earthing

98–99.5%

Instrument (CT/PT)

Burrden-limited

Metering, protection

N/A (ratio accuracy)

# Transformer efficiency & maximum efficiency import math S_rated = 500e3 # 500 kVA V1 = 11000 # Primary voltage (V) V2 = 400 # Secondary voltage (V) f = 50 # Hz # Test results P0 = 1200 # No-load loss (core) in W [W] Psc = 4800 # Short-circuit loss (copper) at rated load [W] pf = 0.8 # load power factor lagging # Core loss is constant P_core = P0 # Copper loss varies with load² def efficiency(load_fraction, power_factor=0.8): P_cu = Psc * load_fraction**2 P_out = S_rated * load_fraction * power_factor P_in = P_out + P_core + P_cu return P_out / P_in * 100 # Maximum efficiency occurs when P_core = P_cu load_max_eff = math.sqrt(P_core / Psc) print(f"Max efficiency at {load_max_eff*100:.1f}% load") print(f"Max η = {efficiency(load_max_eff, 1.0):.3f}% (at unity PF)") print(f"η at full load (0.8 PF) = {efficiency(1.0, 0.8):.3f}%") print(f"η at half load (0.8 PF) = {efficiency(0.5, 0.8):.3f}%") # All-day efficiency (24-hour duty cycle) loads = [(1.0, 8), (0.5, 8), (0.0, 8)] # (fraction, hours) total_out = sum(S_rated * lf * pf * h for lf, h in loads) total_cu = sum(Psc * lf**2 * h for lf, h in loads) total_core = P0 * 24 all_day_eff = total_out / (total_out + total_cu + total_core) * 100 print(f"\nAll-day efficiency = {all_day_eff:.2f}%")

Loss Type

Component

Cause

Reduction

Hysteresis

Core

Domain reversal

Silicon steel (3%), grain-oriented

Eddy current

Core

Induced circulating currents

Laminations (0.3–0.5 mm)

Copper (I²R)

Windings

Load current

Lower R, more copper area

Stray

Tank/structural

Leakage flux

Magnetic shielding

Type

τ vs ω curve

Starting torque

Speed regulation

Application

Shunt

Flat (nearly constant speed)

Medium

5–10%

Lathes, fans, blowers

Series

High torque at low speed

Very high

Poor (runs away no-load)

Traction, cranes

Compound (cum.)

Between shunt & series

High

5–10%

Presses, rolling mills

PMDC

Linear (good servo)

Moderate

1–2%

Servos, robotics, EVs

# DC shunt motor: speed-torque characteristic import numpy as np import math V = 220 # Supply voltage (V) R_a = 0.5 # Armature resistance (Ω) I_a_rated = 50 # Rated armature current (A) k_phi = 2.2 # Motor constant × flux (V·s/rad) # Speed and torque vs armature current print(f"{'I_a (A)':>8s} {'E_b (V)':>8s} {'N (rpm)':>8s} {'τ (N·m)':>8s} {'P_dev (kW)':>10s}") print("-" * 55) for I_a in np.linspace(0, I_a_rated * 1.5, 8): Eb = V - I_a * R_a omega = Eb / k_phi if k_phi != 0 else 0 N = omega * 60 / (2 * math.pi) tau = k_phi * I_a P = Eb * I_a / 1000 print(f"{I_a:>8.1f} {Eb:>8.1f} {N:>8.1f} {tau:>8.1f} {P:>10.2f}") # Speed regulation at full load Eb_fl = V - I_a_rated * R_a N_fl = Eb_fl / k_phi * 60 / (2 * math.pi) Eb_nl = V # no-load Ia ≈ 0 N_nl = Eb_nl / k_phi * 60 / (2 * math.pi) SR = (N_nl - N_fl) / N_fl * 100 print(f"\nSpeed regulation = {SR:.2f}%") print(f"Full-load speed = {N_fl:.1f} rpm") print(f"No-load speed = {N_nl:.1f} rpm")

# 3-phase squirrel-cage induction motor torque-slip curve import numpy as np import math V = 400 # Line voltage (V) f = 50 # Hz P = 4 # Poles N_s = 120 * f / P # 1500 rpm omega_s = N_s * 2 * math.pi / 60 # Equivalent circuit parameters (referred to stator) R1 = 1.0 # Stator resistance (Ω) R2 = 0.8 # Rotor resistance (Ω) X1 = 1.5 # Stator reactance (Ω) X2 = 1.5 # Rotor reactance (Ω) V_ph = V / math.sqrt(3) def torque(s): num = 3 * V_ph**2 * (R2 / s) den = omega_s * ((R1 + R2/s)**2 + (X1 + X2)**2) return num / den # Key points s_max_torque = R2 / math.sqrt(R1**2 + (X1 + X2)**2) T_max = torque(s_max_torque) T_start = torque(1.0) T_full = torque(0.04) # 4% slip print(f"Synchronous speed = {N_s} rpm") print(f"Slip at max torque = {s_max_torque:.4f}") print(f"Max torque = {T_max:.1f} N·m") print(f"Starting torque = {T_start:.1f} N·m (T_start/T_max = {T_start/T_max:.2f})") print(f"Full-load (s=4%) = {T_full:.1f} N·m at {N_s*(1-0.04):.0f} rpm") # Torque-speed curve print(f"\n{'Slip':>6s} {'Speed (rpm)':>12s} {'Torque (N·m)':>12s}") print("-" * 36) for s in [1.0, 0.5, 0.3, s_max_torque, 0.1, 0.04, 0.01, 0.001]: T = torque(s) N = N_s * (1 - s) print(f"{s:>6.3f} {N:>12.1f} {T:>12.1f}")

Method

Starting current", "Starting torque

Cost

DOL (direct)

5–8 × FL current

150–200% FLT

Low (contactor only)

Star-delta

⅓ of DOL current

⅓ of DOL torque

Low

Auto-transformer

K² × DOL (K = tap)

K² × DOL

Medium

Soft starter

2–3 × FL

40–80% FLT

Medium

VFD (variable freq)

100–150% FLT

High (best control)

# Synchronous generator voltage regulation — EMF method import math V = 3300 # Line voltage (V) V_ph = V / math.sqrt(3) I = 100 # Phase current (A) pf = 0.8 # lagging R_a = 0.2 # Armature resistance (Ω) X_s = 8.0 # Synchronous reactance (Ω) phi = math.acos(pf) # EMF calculation (lagging PF) E0 = math.sqrt( (V_ph * math.cos(phi) + I * R_a)**2 + (V_ph * math.sin(phi) + I * X_s)**2 ) regulation = (E0 - V_ph) / V_ph * 100 print(f"V_phase = {V_ph:.1f} V") print(f"E0 = {E0:.1f} V") print(f"Regulation = {regulation:.2f}% (lagging PF)") # Leading PF case pf_lead = 0.8 phi_lead = math.acos(pf_lead) E0_lead = math.sqrt( (V_ph * math.cos(phi_lead) + I * R_a)**2 + (V_ph * math.sin(phi_lead) - I * X_s)**2 # note: minus X_s drop ) reg_lead = (E0_lead - V_ph) / V_ph * 100 print(f" Leading PF {pf_lead}:") print(f"E0 = {E0_lead:.1f} V") print(f"Regulation = {reg_lead:.2f}% (negative = voltage rise)") # Power output P_max = V_ph * E0_lead / X_s # per phase P_total = 3 * P_max print(f" Max power output = {P_total/1000:.1f} kW (3-phase)") print(f"Occurs at δ = 90°")

Machine

Principle

Application

Universal motor

Series DC on AC

Drills, blenders, vacuum cleaners

Reluctance motor

Saliency torque

SynRM in EVs, compressors

Hysteresis motor

Hysteresis torque

Clocks, timers, gyroscopes

Linear motor

Flattened rotary motor

Maglev, linear actuators

Switched reluctance

Variable reluctance, rotor saliency

High-speed drives, EVs

# Stepper motor speed calculation rotor_teeth = 50 # N_r (hybrid stepper) phases = 4 # N_ph (4-phase or 2-phase with microstepping) step_angle = 360 / (rotor_teeth * phases) print(f"Full step angle: {step_angle}°") print(f"Steps per revolution: {int(360/step_angle)}") # Speed calculation pulse_rate = 10000 # pulses per second (pps) rpm = pulse_rate * step_angle / 360 print(f"\nAt {pulse_rate} pps:") print(f"Speed = {rpm:.1f} rpm") print(f"Speed = {rpm * 2 * 3.14159 / 60:.2f} rad/s") # Resolution with microstepping for microstep in [1, 2, 4, 8, 16, 256]: effective_step = step_angle / microstep print(f" {microstep:>4d}× microstep → {effective_step:.4f}°/step ({int(360/effective_step)} steps/rev)")

# Transformer OC and SC test results → equivalent circuit S = 100e3 # 100 kVA V1 = 2200 # HV (V) V2 = 220 # LV (V) # Open circuit test (LV side) V_oc = 220; I_oc = 5.0; P_oc = 400 # V, A, W # Short circuit test (HV side, LV shorted) V_sc = 60; I_sc = 45.5; P_sc = 800 # V, A, W # From OC test — referred to LV side R0 = V_oc**2 / P_oc I_m = I_oc * (1 - (P_oc / (V_oc * I_oc))**2)**0.5 X0 = V_oc / I_m # From SC test — referred to HV side Zeq = V_sc / I_sc Req = P_sc / I_sc**2 Xeq = (Zeq**2 - Req**2)**0.5 print("=== Shunt branch (referred to LV) ===") print(f"R₀ = {R0:.1f} Ω") print(f"X₀ = {X0:.1f} Ω") print(f"Core loss = {P_oc} W") print(f"No-load PF = {P_oc/(V_oc*I_oc):.4f}") print("\n=== Series branch (referred to HV) ===") print(f"R_eq = {Req:.3f} Ω") print(f"X_eq = {Xeq:.3f} Ω") print(f"Z_eq = {Zeq:.3f} Ω") print(f"%Z = {Zeq * I_sc / V1 * 100:.2f}%") print(f"Copper loss at full load = {P_sc} W") # Efficiency at 75% load, 0.8 PF load = 0.75 P_cu_75 = P_sc * load**2 P_out = S * load * 0.8 eff = P_out / (P_out + P_cu_75 + P_oc) * 100 print(f"\nEfficiency at {load*100:.0f}% load, 0.8 PF = {eff:.2f}%")

Test

Purpose

Key Parameter

No-load test (IM)

Core + friction/windage loss

P₀ = V₀I₀cosφ₀; separate friction at V → 0

Blocked rotor (IM)

Equivalent R₂, X₂

Like SC test; current at rated V extrapolated

Load test

Efficiency, temperature rise

Direct method: η = P_out/P_in

Back-to-back (Sumpner)

Core + Cu losses simultaneously

Regeneration; both transformers loaded

Slip test (SM)

X_d, X_q measurement

Apply low V; rotate rotor slowly; plot V/I curve

# Induction motor equivalent circuit — exact solution import math, cmath # Per-phase equivalent circuit parameters V_ph = 230 # Phase voltage (V) f = 50; P = 4 N_s = 120*f/P # 1500 rpm omega_s = N_s * 2 * math.pi / 60 R1 = 0.5; X1 = 1.2 R2 = 0.4; X2 = 1.2 # referred to stator Xm = 40.0; Rm = 350.0 s = 0.04 # 4% slip (near full load) # Impedances Z1 = complex(R1, X1) Zm = complex(Rm, Xm) # parallel combination: 1/Zm = 1/Rm + 1/jXm Z2 = complex(R2/s, X2) # rotor branch # Exact: Zm in parallel with Z2, then series with Z1 Z_parallel = (Zm * Z2) / (Zm + Z2) Z_total = Z1 + Z_parallel I1 = V_ph / Z_total V_airgap = V_ph - I1 * Z1 I2 = V_airgap / Z2 I0 = V_airgap / Zm # Power calculations P_input = 3 * V_ph * I1.real # not exact; use 3*|V||I|cosφ pf = math.cos(cmath.phase(I1)) P_input = 3 * V_ph * abs(I1) * pf P_ag = 3 * abs(I2)**2 * R2 / s # air-gap power P_cu_rotor = s * P_ag P_mech = (1 - s) * P_ag P_stator_cu = 3 * abs(I1)**2 * R1 P_core = 3 * abs(I0)**2 * Rm print(f"Supply current I₁ = {abs(I1):.2f} A (PF = {pf:.3f})") print(f"Rotor current I₂′ = {abs(I2):.2f} A") print(f"Magnetizing I₀ = {abs(I0):.2f} A") print(f"\nAir-gap power = {P_ag:.0f} W") print(f"Rotor Cu loss = {P_cu_rotor:.0f} W") print(f"Mechanical power = {P_mech:.0f} W") print(f"Stator Cu loss = {P_stator_cu:.0f} W") print(f"Core loss = {P_core:.0f} W") print(f"Output ≈ {P_mech:.0f} W (neglecting friction)") print(f"Efficiency ≈ {P_mech/P_input*100:.1f}%") print(f"Speed = {N_s*(1-s):.0f} rpm") print(f"Torque = {P_mech/(N_s*(1-s)*2*math.pi/60):.1f} N·m")

Operating Condition

E vs V

Power Factor

Normal (motoring, lagging)

E < V

Small positive

Lagging (under-excited)

Normal (motoring, leading)

E > V

Small positive

Leading (over-excited)

Generator (lagging)

E > V

Positive

Lagging (over-excited)

Generator (leading)

E < V

Positive

Leading (under-excited)

Maximum power

E >> V

δ → 90°

Unity at P_max (approx)

Application

Motor Type

Reason

Control

Centrifugal fans

Squirrel-cage IM

Nearly constant speed, rugged

VFD for variable flow

Cranes / Hoists

DC series / Slip-ring IM

High starting torque

Armature R, VFD

Elevators

DC shunt / PMSM

Smooth speed control

VVVF, closed-loop

EV traction

BLDC / PMSM / Induction

High efficiency, regen

FOC, DTC

CNC / Robotics

Servo (PMSM)

Precise positioning

Encoder feedback, PID

Compressors

Synchronous motor

PF correction + drive

VFD / DOL

Clocks / Timers

Hysteresis / Stepper

Constant speed / position

Simple drive

Pumps

Squirrel-cage IM

Simple, reliable

VFD for energy saving

# Motor sizing example: conveyor belt drive import math # Load requirements load_mass = 5000 # kg (conveyor + material) speed = 2.0 # m/s inclination = 5 # degrees efficiency = 0.85 # mechanical transmission efficiency # Force calculations g = 9.81 F_gravity = load_mass * g * math.sin(math.radians(inclination)) F_friction = load_mass * g * 0.02 # 2% friction coefficient F_accel = load_mass * 0.5 # acceleration force (0.5 m/s²) F_total = F_gravity + F_friction + F_accel # Power P_shaft = F_total * speed P_motor = P_shaft / efficiency print(f"Required shaft power: {P_shaft:.0f} W ({P_shaft/1000:.2f} kW)") print(f"Motor rating needed: {P_motor:.0f} W ({P_motor/1000:.2f} kW)") print(f"Select next standard: {math.ceil(P_motor/1000 * 2)/2:.1f} kW motor") # Speed selection for direct drive vs geared drum_diameter = 0.4 # m drum_rpm = speed * 60 / (math.pi * drum_diameter) print(f"\nDrum speed: {drum_rpm:.1f} rpm") print(f"Use 4-pole motor (1450 rpm) with gear ratio: {1450/drum_rpm:.1f}:1") print(f"Or 6-pole motor (960 rpm) with gear ratio: {960/drum_rpm:.1f}:1")