How to Estimate Motor Core Loss in Lamination Stacks: Steinmetz, iGSE, and Practical Shortcuts

Motor core loss in lamination stacks is usually estimated from clean material data, then quietly distorted by the real stack.

Punching. Edge damage. Joining. Press fit. Tooth ripple. Minor loops. Rotating flux in the corners. The base model may still be fine. The inputs are not.

This guide is for that gap. Motor core loss. Iron loss. Stator lamination loss. Steinmetz fitting. iGSE. FEA-driven region splitting. Shortcuts that still survive first hardware.

Motor Core Loss Models for Lamination Stacks

Classical Steinmetz equation for sinusoidal regions

Start here when the local flux waveform is close to sinusoidal.

Pspec = k * f^alpha * Bpk^beta

Where:

• Pspec = specific core loss, usually W/kg
• k = fitted Steinmetz coefficient
• f = electrical frequency, Hz
• alpha = frequency exponent
• beta = flux-density exponent
• Bpk = peak flux density in the steel, T

Use Bpk in steel. Not in gross stack area. If the region is back yoke and the waveform is smooth, this is often enough.

If the region is tooth root under PWM ripple. No. Move on.

Loss separation model for hysteresis loss, eddy current loss, and excess loss

Use this when the design change is physical and you want to know which part of the iron loss moved.

Pspec = kh * f * Bpk^n + ke * f^2 * Bpk^2 + kex * f^1.5 * Bpk^1.5

Where:

• kh = hysteresis-loss coefficient
• ke = classical eddy-current coefficient
• kex = excess-loss coefficient
• n = hysteresis flux exponent
• f = electrical frequency, Hz
• Bpk = peak flux density in steel, T

This model is useful when lamination thickness changed, or punch quality changed, or stress changed, and you do not want all of that hidden inside one fitted constant.

iGSE for PWM-rich and minor-loop-rich flux waveforms

When the local B(t) is distorted, the plain Steinmetz form starts acting cleaner than the machine.

Use a time-domain form.

Pspec = (1/T) * sum_over_i( integral_from_t1_i_to_t2_i[ ki * abs(dB/dt)^alpha * (DeltaB_i)^(beta-alpha) dt ] )

Where:

• T = electrical period
• i = monotonic segment or extracted subloop index
• ki = waveform-adjusted coefficient derived from the fitted Steinmetz constants
• dB/dt = local flux-density slew rate, T/s
• DeltaB_i = flux swing tied to segment or subloop i, in T
• t1_i, t2_i = start and end of segment or extracted loop portion
• alpha, beta = Steinmetz exponents from fitted material data

The trap is DeltaB_i.

For a clean single-loop waveform, DeltaB_i can be the excursion over that segment. For PWM ripple, nested minor loops, or harmonic-rich teeth, do not use one global max(B) - min(B) for the whole period. That is the wrong object.

You need loop extraction first.

Comparison of Motor Core Loss Models for Stator Laminations

Step-by-Step Workflow for Stator Lamination Core Loss Calculation

1. Fit Steinmetz coefficients from the actual material window

Do not fit one elegant curve across the whole map unless the operating window is narrow.

Use at least two bands:

• normal operating band
• high-flux band near the knee

The fitted form is:

ln(Pspec) = ln(k) + alpha * ln(f) + beta * ln(Bpk)

This is a multiple linear regression problem after log transform.

Set up the regression like this:

x1 = ln(f)
x2 = ln(Bpk)
y  = ln(Pspec)

y = a0 + a1*x1 + a2*x2

alpha = a1
beta  = a2
k     = exp(a0)

In a spreadsheet, build three columns for ln(Pspec), ln(f), and ln(Bpk), then run a built-in multiple linear regression or LINEST-style function on those log-transformed columns. The two slopes are alpha and beta. The intercept is ln(k).

Three-point back-solving still has a place. Quick first pass. Nothing more.

alpha = ln(P2/P1) / ln(f2/f1)
beta  = ln(P3/P2) / ln(B3/B2)
k     = P1 / (f1^alpha * B1^beta)

Good for screening. Weak for release work.

2. Split the lamination stack into regions before calculating iron loss

One average flux density for the whole stator usually hides the part that matters.

At minimum, split into:

• tooth body
• tooth root / slot shoulder
• back yoke

If the machine is fast, small, or heavily loaded, add:

• tooth tip
• bridge region
• corner regions with rotating flux

The reason is simple enough. Tooth and yoke do not see the same waveform. They do not see the same stress state either.

3. Use local steel flux density from FEA, not gross magnetic loading

For each region, extract one of these:

• Bpk for classical Steinmetz
• full B(t) for iGSE
• flux-density locus if rotating-field loss is likely

Do not feed one global air-gap loading number into a lamination loss model and expect it to behave.

4. Calculate clean-sheet region loss

For each region r:

Pclean_r = m_r * Pspec_r

Where:

• m_r = steel mass of region r, kg
• Pspec_r = specific core loss of region r, W/kg

Then sum:

Pcore_clean = sum_over_r( Pclean_r )

This is the material-only estimate. It is not the production-stack estimate.

5. Add process correction and rotating-flux correction

Use the built-stack form for anything serious:

Pstack_r = m_r * Cproc_r * Crot_r * Pspec_r

and

Pcore_stack = sum_over_r( Pstack_r )

Where:

• Cproc_r = process correction for region r
• Crot_r = rotating-flux correction for region r

Cproc_r covers the usual damage sources: cutting, burrs, edge degradation, welding heat, interlock distortion, stack compression, press fit. Crot_r exists because alternating-flux loss and rotating-flux loss are not the same thing, and corners do not care what your simplified spreadsheet assumed.

How to Define DeltaB_i in iGSE Without Faking It

This is the part people tend to jump over.

For a clean single major loop, life is easy. For PWM-rich stator teeth, it is not.

Do not define iGSE with one global swing:

DeltaB_global = max(B) - min(B)

That is acceptable only when the waveform is basically one clean loop with no meaningful embedded minor loops.

For distorted waveforms, define loss intervals segment by segment, or loop by loop.

Practical loop-handling workflow

1. Smooth numerical noise just enough to stop false turning points.
2. Find turning points in B(t).
3. Split the waveform into monotonic segments.
4. Extract closed minor loops using a peak-valley or rainflow-style routine.
5. Assign one local swing to each extracted object.
6. Evaluate iGSE on each segment or subloop.
7. Sum all contributions over one electrical period.

For a monotonic segment i:

DeltaB_i = abs( B_end_i - B_start_i )

For an extracted minor loop j:

DeltaB_j = abs( Bpeak_j - Bvalley_j )

Then compute:

Pspec = (1/T) * sum_over_all_segments_and_loops( local_iGSE_contribution )

This matters because the waveform shape changes the loss path, not just the peak value. A tooth waveform with nested minor loops can look modest in Bpk and still run expensive.

A workable coding sequence

If you are implementing this from FEA time-series data, the safe order is:

• resample B(t) to uniform time spacing
• apply very light smoothing if numerical noise is obvious
• detect turning points
• remove trivial oscillations below a threshold
• pair closed loops with a rainflow-style or peak-valley extractor
• compute DeltaB_i for each segment or loop
• evaluate the time-domain integral on each object
• sum over one electrical period

Not pretty. It works.

Practical Process Correction Factors for Lamination Stacks

These are engineering starting bins, not universal constants.

A rough rule. Useful enough.

• small machines with high edge length per core volume: start higher
• clean back yoke with low stress: start lower
• welding near active flux paths: start higher
• unknown manufacturing discipline: do not pretend the lower end is safe

Keep the material fit clean. Keep the process penalty explicit.

Practical Shortcuts for Fast Motor Core Loss Estimates

Shortcut 1: Two-zone stator model for early design

If time is short, split only into:

• teeth
• back yoke

Give them separate Bpk, separate fitted coefficients, separate correction factors. Still much better than one whole-core average.

Shortcut 2: Promote tooth-root loss early

If the tooth root is narrow, highly utilized, and close to slot opening distortion, do not leave it at clean-sheet loss.

A conservative starting correction is:

Proot_stack = 1.2 to 1.4 * Proot_clean

Then calibrate after first hardware.

Shortcut 3: Do not assume thinner laminations automatically fix total iron loss

Classical eddy-current loss usually moves the way you expect. Built stacks do not always follow cleanly. Punch damage, excess loss, and stress can eat part of the gain.

Shortcut 4: Report two numbers, not one

Always report:

• Pcore_clean
• Pcore_stack

If you publish only one number, someone will assume it means more than it does.

Common Errors in Lamination Stack Core Loss Calculation

Using one coefficient set across the full operating map

This usually makes the high-flux region look cheaper than it is.

Regressing Pspec directly against f and Bpk

Wrong fit space. Regress ln(Pspec) against ln(f) and ln(Bpk) if you want Steinmetz coefficients.

Using a single DeltaB for a waveform with minor loops

This is the main iGSE trap. A global max(B) - min(B) is not a substitute for loop extraction.

Using average stator flux density instead of local steel flux density

That tends to erase the teeth. The teeth still exist.

Treating raw sheet loss as production truth

The stack has been cut, joined, pressed, maybe welded. That changed the answer.

Ignoring rotating-field loss in corners and bridges

Scalar alternating-field models often look calm exactly where the flux locus is not calm at all.

What a Motor Core Loss Report Should Actually Include

At minimum:

• lamination thickness
• stack factor used for steel-area conversion
• fitted coefficient ranges
• regression method used
• region definitions
• local Bpk or B(t) source
• chosen loss model by region
• Cproc and Crot assumptions
• clean-sheet and built-stack totals

Without that, the final watt number may still be usable. It is just hard to trust.

FAQ: Motor Core Loss, Steinmetz Fitting, and Lamination Stack Estimates

Final Rule for Motor Core Loss in Lamination Stacks

Use Steinmetz for speed. Use region splitting for realism. Use iGSE when the local waveform stops behaving like a sine wave. Use loop extraction before defining DeltaB in distorted waveforms. Use log-transformed multiple regression when fitting k, alpha, and beta. Use explicit process correction because lamination stacks are manufactured parts, not magnetic coupons.

That is usually enough to move the estimate from clean spreadsheet fiction to something closer to the test stand.