How Many Sheets Are in a Transformer Core? A Small Python Estimator for CRGO Steel

Goes Steel — Thu, 29 Oct 2026 09:31:12 +0000

`I work on the supply side of grain-oriented electrical steel, the 0.23–0.30 mm silicon steel that transformer cores are stacked from. Almost every inquiry I get boils down to three questions:

How many sheets go into this core?
How much steel do I need to buy?
Is the expensive grade worth it?

All three can be answered with about 40 lines of Python and some numbers from the mill's datasheet. This post walks through a small estimator. It's a first-pass model, not a design tool, but it's close enough to settle most "is it worth it" arguments before anyone opens a FEM package.

The inputs

A grade of grain-oriented (CRGO) steel is mostly described by three numbers:

Field	Example	Meaning
Thickness	0.27 mm	Nominal sheet thickness
P1.7/50	1.20 W/kg	Maximum core loss at 1.7 T and 50 Hz
Stacking factor	0.96	Share of a measured stack height that is actually steel

The grade name usually encodes the first two. In the Chinese GB standard, 27Q120 means 0.27 mm with at most 1.20 W/kg. 23QG085 is a Hi-B (high permeability) grade at 0.23 mm with at most 0.85 W/kg.

The stacking factor is the one people forget. Every sheet carries a thin insulation coating, and no stack is perfectly flat, so a 150 mm stack of 0.27 mm steel is not 150 mm of steel. Thinner sheets mean more coating layers per millimetre, so the factor drops a little as the gauge gets thinner.

For the core itself, I'll use the simplest shape: a single-phase rectangular core with a limb width, a stack height, and a window.

The model

`python
from dataclasses import dataclass

DENSITY = 7650 # kg/m3, grain-oriented silicon steel

@dataclass(frozen=True)
class Grade:
name: str
thickness_mm: float
p17: float # max core loss, W/kg at 1.7 T / 50 Hz
stacking_factor: float # share of the stack height that is steel

@dataclass(frozen=True)
class Core:
limb_width_mm: float # lamination width
stack_mm: float # stack height, measured
window_w_mm: float
window_h_mm: float

@property
def path_m(self):
    # mean magnetic path around a single-phase rectangular core
    w = self.limb_width_mm
    return (2 * (self.window_w_mm + w) + 2 * (self.window_h_mm + w)) / 1000

def sheet_count(core, grade):
return round(core.stack_mm * grade.stacking_factor / grade.thickness_mm)

def core_mass_kg(core, grade):
area_m2 = core.limb_width_mm * core.stack_mm * grade.stacking_factor / 1e6
return area_m2 * core.path_m * DENSITY

def no_load_loss_w(core, grade, building_factor=1.2):
return core_mass_kg(core, grade) * grade.p17 * building_factor
`

Three things in there deserve a comment.

The mean path. Flux runs around the window roughly through the middle of the steel, so the path length is the window perimeter plus one limb width on each side. That gives 2(a + w) + 2(h + w).

The net area. Mass uses the limb width times the stack height times the stacking factor. If you skip that factor, you overestimate the steel by about 4% and every number after that comes out too high.

The building factor. The datasheet loss is measured on a single strip in a lab tester. An assembled core always does worse: flux crowds at the joints, cutting and handling add stress, and the corners carry flux partly against the grain. The ratio of real core loss to datasheet loss is the building factor. For modern step-lap cores it is often somewhere around 1.1 to 1.3. I default to 1.2, but if you have measured data from your own cores, use that instead.

Running it

Take a core with a 150 mm limb width, a 150 mm stack, and a 200 × 500 mm window, then compare a conventional grade with a Hi-B grade:

`python
core = Core(limb_width_mm=150, stack_mm=150, window_w_mm=200, window_h_mm=500)
grades = [
Grade("27Q120", 0.27, 1.20, 0.960),
Grade("23QG085", 0.23, 0.85, 0.955),
]

print(f"mean path: {core.path_m:.2f} m\n")
print(f"{'grade':<8} {'sheets':>6} {'mass kg':>8} {'loss W':>7} {'kWh/yr':>7}")
for g in grades:
loss = no_load_loss_w(core, g)
print(f"{g.name:<8} {sheet_count(core, g):>6} {core_mass_kg(core, g):>8.1f} "
f"{loss:>7.0f} {loss * 8760 / 1000:>7.0f}")
`

`text
mean path: 2.00 m

grade sheets mass kg loss W kWh/yr
27Q120 533 330.5 476 4169
23QG085 623 328.8 335 2938
`

Reading the result

Sheet count. Moving from 0.27 mm to 0.23 mm adds 90 sheets to the same stack. That means 17% more pieces to cut, handle, and stack, and the extra labour shows up in the quote. Thinner steel is not free even when its price per ton is similar.

Mass. It barely changes: 330.5 kg against 328.8 kg. The only difference is the slightly lower stacking factor of the thinner gauge.

Loss. This is the column that matters. The Hi-B core loses about 141 W less.

Then comes the line that usually ends the argument. A distribution transformer stays energised around the clock, loaded or not, so its no-load loss runs 8,760 hours a year. Those 141 W add up to roughly 1,230 kWh per year, for every unit, for a service life usually measured in decades. Multiply that by your electricity price and by the number of units in a project, and you have a number a buyer can compare directly with the price difference of the steel.

That's why utilities often specify a loss evaluation formula (a cost per watt of no-load loss) in their tenders instead of simply picking the cheapest steel.

Where this model is wrong

It is useful because it is simple, so here is what it leaves out:

It uses the guaranteed maximum loss. P1.7/50 on a grade is a ceiling. Real coils usually test lower, and the actual value is on the mill test certificate. For a real comparison, use certificate values from the coils you would actually receive.
It assumes the core runs at 1.7 T. Designers pick the operating flux density, and loss rises steeply with it. If your design runs at 1.5 T or 1.8 T, take the loss at that point from the grade's B–P curve, not the 1.7 T figure.
It assumes 50 Hz. At 60 Hz the same core loses more per kilogram. Datasheets usually list a separate P1.7/60 value.
It ignores corner geometry. Mitred corners and step-lap overlaps change the mass by a few percent. Close enough for a comparison, not for a bill of materials.
It's single-phase. A three-phase three-limb core has three limbs and two yokes, so the path calculation changes. The rest of the code stays the same.

Wrapping up

Always apply the stacking factor before computing mass or flux area.
Treat the datasheet loss as a lab number and multiply it by a building factor for real cores.
Compare grades on loss per year, not price per ton. The steel is paid for once; the no-load loss is paid for every hour.

If you've built tools for other "the datasheet number isn't the real number" problems (motor efficiency classes, battery capacity ratings, cable derating), I'd like to hear how you modelled the correction factors in the comments.

Disclosure: I work at GOES Steel, a supplier of grain-oriented and non-oriented electrical steel in Wuxi, China. The grades above are ones we handle every day. The code is free to use.
`