NX Open Transformer Automation: The Short Version
NX Open transformer automation drives Siemens NX from code, so a customer specification becomes geometry, drawings and a bill of materials without an engineer rebuilding the same design a fortieth time. inteliScience builds these generators on the platform you already own, on-premise. Order engineering that took days can come down to hours.
| Manual order engineering | NX Open generator | |
|---|---|---|
| Source of the design | Last similar job, copied and edited | Specification, read by code |
| Drawing set | Redrawn and re-checked | Derived from the model |
| Quoting a variant | Wait for an engineer | Same day, from the rule set |
The Problem: The Grid Is Waiting on Engineering Hours
Nobody in power equipment has a demand problem. Lead times for large power transformers have stretched to roughly four years, and in some cases past five — long enough that data centre developers have started building their own generation rather than wait for a connection. Around a quarter of renewable projects worldwide are already slipping because the transformers are not there.
The usual explanation stops at grain-oriented electrical steel and concentrated capacity — China accounts for something like 60% of global transformer manufacturing, and the specialist steel has very few sources. Both are true, and neither is the part an OEM controls.
What an OEM does control is how many engineering hours it burns per order. And that number is quietly enormous, because almost nothing in this industry is a catalogue product. Every unit is a variant: a different rating, a different tapping range, a different tank because the customer’s foundation is 200 mm narrower, a different bushing arrangement because of the local standard. So the engineering department rebuilds a near-copy of an existing design, redraws the drawing set, rebuilds the bill of materials, and does it again next week.
Meanwhile the same scarcity applies to the people. High-voltage engineers are hard enough to hire that the shortage is now cited as a gating factor on grid and data-centre construction, ahead of equipment. You cannot recruit your way out of this in 2026. You can stop spending senior engineering time on transcription.
What NX Open Gives an Energy OEM
NX Open is the programming interface to Siemens NX — the platform Siemens rebranded as Designcenter with the June 2026 release, generally available 23 June 2026. Anything you can build interactively you can build from code: expressions, features, assemblies, drawings, PMI, CAM operations, attributes. It has bindings for C++, C# and VB.NET, Java and Python, and most of the NX programming work we deliver now starts in Python because it needs no compiler on the target machine.
For variant-heavy equipment, four capabilities carry almost all the value.
Journaling records your interactive session as executable source. An engineer who has never written a line of Python can produce a working first script by doing the job once with recording switched on. We start every project this way — it converts “how do you actually build this” from a three-week interview into a two-hour session, and it produces the ground truth that the parameterised version gets refactored from.
Expressions are the reason transformers automate well. A tank, a core, a winding arrangement can be driven by named parameters, and NX Open reads and writes those parameters directly. The generator is then a very small program: read the specification, set the expressions, update, export. The intelligence lives in the model, not the script.
Knowledge Fusion holds the rules that must not be violated — clearances, insulation distances, thermal constraints, the standards your design office has internalised over thirty years. These are declarative, they live in the part, and they re-evaluate when inputs change. Encoding them is the highest-leverage thing an experienced designer can do before retiring, and most companies discover this two years too late.
Block UI Styler builds native NX dialogs. A generator that runs from a command line gets used by its author. A generator that is a button in the ribbon with a form for rating, voltage and tank envelope gets used by the department. We treat the dialog as part of the deliverable, not a nice-to-have.
Our position, having built a number of these: automate the variant, not the design. The first project should reproduce a family you already build repeatedly, with the constraints you already apply. Trying to encode a general-purpose transformer designer is how these projects die.
The Generator: Specification In, Model Out
Here is the shape of it. A specification row drives the expressions, NX updates the model, and the automation exports what the next department needs — nothing exotic, and that is the point.
# NX Open (Python) - drive a parametric transformer family from a spec file.
# Run with the family template open as work part (Developer tab > Journal > Play).
import csv
import NXOpen
# spec column -> NX expression name
FIELD_MAP = {
"rating_mva": "p_rating_mva",
"hv_kv": "p_hv_kv",
"lv_kv": "p_lv_kv",
"tank_length_mm": "p_tank_length",
"tank_width_mm": "p_tank_width",
"core_dia_mm": "p_core_diameter",
}
def set_expression(part, name, value):
expr = part.Expressions.FindObject(name) # raises if the template lacks it
part.Expressions.Edit(expr, str(value))
def build(session, part, spec):
mark = session.SetUndoMark(NXOpen.Session.MarkVisibility.Visible, "variant")
for column, expression in FIELD_MAP.items():
set_expression(part, expression, spec[column])
if session.UpdateManager.DoUpdate(mark) != 0: # non-zero return = update failed
raise ValueError("model update reported errors")
part.SetUserAttribute("ORDER_NO", -1, spec["order_no"], NXOpen.Update.Option.Now)
part.SetUserAttribute("SPEC_REV", -1, spec["spec_rev"], NXOpen.Update.Option.Now)
part.SaveAs(spec["out_dir"] + "/TR_" + spec["order_no"] + ".prt")
def main():
session = NXOpen.Session.GetSession()
part = session.Parts.Work
lw = session.ListingWindow
lw.Open()
with open("orders.csv", newline="", encoding="utf-8") as fh:
for spec in csv.DictReader(fh):
try:
build(session, part, spec)
lw.WriteLine("OK %s" % spec["order_no"])
except (NXOpen.NXException, ValueError) as exc:
# A violated Knowledge Fusion rule surfaces here - do not swallow it.
lw.WriteLine("FAIL %s : %s" % (spec["order_no"], str(exc)))
if __name__ == "__main__":
main()Note what the error handling does. When a specification violates a clearance rule, the update fails and the order number lands on a FAIL line with the reason. That is the automation doing its most valuable job: telling you at quotation time that a configuration is not buildable, instead of six weeks later in the design review.
The drawing set comes next and is the part customers underestimate. Once the model regenerates from parameters, the drawing views, dimensions and the title block regenerate with it — NX Open can update the drafting sheets, refresh views and export PDF and DXF in the same batch run. For a family where each order previously meant a redrawn set, this is usually a larger saving than the 3D work.
Not sure your family models are parametric enough to drive this way? Most are closer than their owners think, and the gap is measurable in days rather than months. See how we scope automated transformer variant design.
Feeding the Rest of the Company
A generator that produces a model and stops has automated the least painful part of the process.
The bill of materials is where order engineering actually leaks time. NX Open reads the assembly structure and the component attributes directly, so the BOM can be emitted at generation time and pushed into Teamcenter or straight into the ERP system — the same digital-thread pattern we describe in our write-up on keeping BOMs and ERP in sync from the CAD model. One source, one revision, no spreadsheet in the middle.
Model-based definition earns its keep here too. PMI in NX is structured product definition under ASME Y14.41, not text pinned to a view, which means tolerances and surface specifications are objects a script can read. When your quality department’s inspection plan and your supplier’s machining setup both derive from the same PMI, a tolerance change is one edit rather than four coordinated ones.
For companies already on Teamcenter, the NX Open and Teamcenter integration lets the generator write item revisions, attributes and structure into PLM as part of the same run. For companies not there yet, files and a CSV work fine and are a legitimate stopping point. We would rather ship a file-based generator that runs on Monday than a PLM-integrated one that ships next year.
AI: Where It Belongs in an Energy Engineering Office
The June 2026 Designcenter release introduced Designcenter Copilot, a natural-language assistant grounded in Siemens documentation and the user’s current activity. Useful for platform questions. It does not know your clearance rules, your standard tank families or why the 2019 design revision exists.
The AI cases with real money behind them in this sector are two, and neither is inside the CAD window.
The first is tender and quotation engineering. An incoming specification is thirty to two hundred pages of requirements, standards references and customer-specific deviations, and today a senior engineer reads it to work out what is standard, what is a variant and what is a red flag. A retrieval-based assistant over your own historical tenders, standards and past deviations turns that into a structured extraction with citations — every requirement mapped, every deviation flagged, the engineer reviewing rather than transcribing. That is the pattern behind our AI tender and quotation engineering work, and it is where quoting speed actually comes from.
The second is the archive. Retrofit and service business runs on units built decades ago whose definition exists as scanned drawings and a filing system. Vision models extract part numbers, materials, ratings and referenced standards; NX Open reconciles the extraction against live data and flags contradictions. What you get is a searchable picture of an installed base that was previously only in people’s heads — the basis for a retrofit and service drawing-mining pipeline.
On deployment we are blunt with customers: this runs on your infrastructure. Not because cloud AI is unsafe in principle, but because tender documents and installed-base data are commercially sensitive in a way that makes the conversation with your legal department longer than the project. Open-weight models on a GPU node — Llama 3.3 70B is a reasonable default for retrieval and drafting — remove the question. Where the work never touches customer data, such as generating NX Open code itself, frontier models like claude-opus-5-5 are genuinely better and we use them there.
One warning on generated code, because it costs people weeks: LLMs invent NX Open API calls that do not exist, with complete confidence. Every generated script goes through an import check and a run against a reference part before a human reviews the logic. Skip that and you have moved the effort rather than removed it.
What the First Quarter Looks Like
| Weeks | Focus | Result |
|---|---|---|
| 1–2 | Journal the three most repeated order-engineering workflows, count the hours | A ranked case with real numbers |
| 3–4 | Parametrise one family template; fix what is not expression-driven | A template a generator can actually drive |
| 5–9 | Build the generator plus a Block UI Styler dialog; add drawing and BOM export | Order engineering for one family, end to end |
| 10–13 | Extend to the second family, or wire the output into Teamcenter/ERP | Either breadth or depth — not both at once |
The sequencing that fails is starting with the hardest family because it hurts most. Start with the one you build most often. It has the cleanest data, it delivers the fastest measurable win, and it gives the department a reason to trust the next one.
We would also push back on one common request. Companies frequently want the generator to handle every exception on day one. Do not. Let it cover the eighty percent and route the rest to an engineer with a clear message about why it was rejected. A generator that refuses cleanly is trustworthy; one that silently produces something wrong for an edge case gets switched off after the first incident.
Frequently Asked Questions
How much does an NX Open transformer generator cost?
A single family — parametric cleanup, generator, dialog, drawing and BOM export — typically runs €15,000 to €40,000. The spread is almost entirely about the starting condition of the template: a well-built parametric family is fast, a collection of copied one-off models needs rebuilding first. We quote after a short assessment of the actual models, never from a specification alone.
Do we need Teamcenter for this to work?
No. The generator runs against NX and the file system, and plenty of our energy customers start exactly there. Teamcenter changes where the output lands, not whether the automation works. If you already run it, integrating from day one is worth it; if you do not, adding PLM to the scope is the most reliable way to delay the first result by six months.
NX Open or Knowledge Fusion for design rules?
Knowledge Fusion for anything that must travel with the part and re-evaluate when a parameter changes — clearances, insulation distances, geometric constraints. NX Open for the procedural work around it: reading specifications, batch execution, drawings, BOM, talking to other systems. Nearly every generator we build uses both, and the boundary between them is the first architectural decision worth spending an afternoon on.
Can this handle a customer specification that arrives as a PDF?
Partly, and it should be treated as two separate systems. Extraction from an unstructured specification is an AI problem with a human reviewing the result; generation from a confirmed parameter set is a deterministic NX Open problem. Keeping them separate matters — you never want a language model quietly deciding a tank dimension.
What happens to our drawings when the model is generated?
They are generated too. Once views, dimensions and title blocks reference the parametric model, NX Open can regenerate the sheets and export PDF and DXF in the same batch. In practice this is where most of the saved hours come from, because redrawing was always the slower half of the job.
Next Step
Bring one transformer family and the last ten orders you engineered for it. An hour is enough to say whether a generator pays for itself and roughly what it costs.