main
History Download
John Lauer 0.10.0: lean by default; optional modules with board-specific hints; grouped findings; lean fields.json + detail.json;… 4bbb86d

Adom Fields

Adom Fields: where the current and the heat go on your board. Solved from the board file itself, painted on the board in 3D, ordered by what matters, with the fix next to every issue. The AI does the analysis and drives the view; the human orbits, zooms and hovers for the number.

Every view in under four minutes (3 min 40 s, with captions and chapters): all fifteen views, from current density and heat to EMC, ground, noise, power delivery and signals. Also on YouTube: watch it there.

The full tour, 13 minutes

Want the long version? Here every view explains itself in full, the way the app does when you press its speaker button: what the colours mean, the numbers on this board, and what to click next. It's the same fifteen views on a 12 V to 5 V buck and an ESC motor controller.

Play the 13-minute full tour of every Adom Fields view on YouTube

Watch the full tour on YouTube (13 min 44 s, chapters in the description).

Current density on the top copper of the ESC G431, every loaded net at its spec current

The ESC G431's top copper with the current density of every loaded net at 20 A. The yellow arcs are the necks: 20 A through 1.5 mm of 35 µm copper.

What it solves

  • Current density per loaded net: a DC conduction solve on the filled copper of every layer, between the net's terminals (the wire pads and connectors on one side, the parts that draw the current on the other, each part's share by its pad area), through the via barrels. Amps per square millimetre on every cell, the peak and where it is.
  • Heat flow in the copper: four layers, each conducting in its plane, coupled through the dielectric and through every via barrel, losing to the air on both faces. Heat comes from the hot tabs in the spec and from the Joule loss of the current above. Read as watts per millimetre of width on each layer, with each chip's split: along its layer, down its vias, through the bare dielectric.
  • Temperature over the board: the same solve read as the rise above ambient, in still air (10 W/m²K) and in moving air (25 W/m²K).
  • Issues, with the fix: a net over 60 A/mm² (about what IPC-2221 allows at 35 µm for 10 °C), a tab over its rise budget, a chip with fewer thermal vias than the spec asks.

Heat flow in the top copper, the hot parts labelled with their rise

Heat flow in the top copper. Q3 runs hottest: it has no thermal via within 3 mm, so its 0.6 W has only the top copper to spread on.

The temperature rise over the whole board in still air

The temperature over the board, the FR4 spreading, still air.

Watch each view

Each clip is the app on the 12 V to 5 V buck (Signals on the ESC G431), explaining the view in its own voice (the narration the app writes from the solve, voiced by adom-tts).

Current density

How many amps flow through each square millimetre of copper, every loaded net at its spec current.

Download the current density video

Heat flow

Where the watts travel from the hot parts, along the copper and down the vias.

Download the heat flow video

Temperature

The rise above the room over the whole board, in still or moving air.

Download the temperature video

Flow

The solved current as moving charge: speed and glow follow the density, each via takes its share.

Download the flow video

River

Every net lifted to its voltage, the current running over it as water, loads as waterfalls.

Download the river video

Energy

The energy travels in the fields between the copper layers, while the electrons crawl at millimetres per second.

Download the energy video

Light

How fast a change crosses the board as a share of the speed of light, and when a switch-on reaches each part.

Download the light video

Energy cycle

One switching period: the input capacitors, the inductor's magnetic field, the output, and the heat.

Download the energy cycle video

Charge

The board as capacitors: charge on facing copper, the field between, and the capacitor parts beside it.

Download the charge video

Magnetic

The field every current makes: field lines looping around the copper, and a probe sheet that shows the strength at a height above the board.

Download the magnetic video

EMC screen

Where the board could radiate: the switching hot loop and the smallest it could be, copper with no ground under it, the loop's estimated emissions against the FCC class B limit, each chip power pin's decoupling capacitor, and the connector pins with no ESD protection.

Download the EMC video

Ground

The return path: ground's own voltage drop, the possible loops through cables, floating islands, and the stitching-via fence along the board edge.

Download the ground video

Noise

Where switching noise can ring and spread: each power pour over the ground plane ringing like a drum at its own frequencies, and the switching edges reaching quiet nets through stray capacitance.

Download the noise video

Signals

Copper as capacitors, on the ESC G431 (the buck has no signal checks): each checked pair of facing copper glows as two plates with the electric field crossing between them, one at a time, with its picofarads. The three motor phases' switching copper has 25 to 36 pF to the ground plane under it, charged and emptied on every PWM edge; the two inner planes make 134 pF.

Download the signals video

Power

How stiff each rail is, from slow changes to fast ones: each rail's impedance seen from its load pin, 1 kHz to 1 GHz, against its target, while the frequency sweeps. Each part's column is its share of the load's current at that frequency (the regulator or the supply leads at the low end, the bulk capacitors, then the small ones nearest the pin); the glass sleeve at the load pin is the target. ngspice runs the same circuit as a cross-check.

Download the power video

Lean by default, more when the board needs it

analyze runs the core on every board: current and IR drop, heat, necks and hot tabs, part temperatures, ground offset, decoupling, the converter's hot loop and ripple. Six optional modules add EMC and compliance (emc), connector protection (esd), power delivery (pdn), signal integrity (si), noise (noise) and receivers (rf). Turn them on with --with emc,pdn or --with all.

A module that does not run is never silent. The output reads the board and says why each one may matter here. For example: "U1 switches at 500 kHz and 7 connectors can carry cables: a switcher's noise riding out on a cable is the most common reason a board fails FCC/CISPR radiated". It then says what --with emc would add, so the AI calling it can decide. Repetitive findings come grouped, and fields.json holds what an AI needs to read, with the bulk the app draws in detail.json.

What to fix: the review for the AI

Every solve now ends with a design review an AI flow can act on without looking at a screen: each finding (a current neck, a hot tab, the switching hot loop, copper with no ground under it, ground offset, islands, gaps in the stitching fence, IR drop, converter ripple, a rail's impedance over its target) comes with a plain fix and an action to carry out (move this capacitor to these pins, add ground vias at these points, widen this net here), and fixPlan orders them. On the buck: the hot loop is fine (2.7 mm² against a best of 1.5), but only a third of the board edge is stitched, so the plan adds eight ground vias at the exact points it lists.

Fix it, then prove it: verify

adom-fields verify --board board.kicad_pcb --spec spec.json --step 1,3 --refill --out verify carries out fix-plan steps on a copy of the board, adding the vias and widening the traces. KiCad refills the zones and runs DRC on both boards, and both are solved. The report says which issues cleared, every number that moved and which way, and whether the fix introduced any DRC error. On the 4-layer ESC, four thermal vias under each of two FETs drop Q2 from +90.8 to +86.0 °C with no new DRC errors. Widening the boxed-in necks lowers every hot part by about 0.5 °C, but the issue stays: the report shows that a layout change is the real fix there. Part, move and reroute steps are refused with the reason, for the AI's layout pass.

Will it pass the lab? review.compliance and report

Every solve predicts each emission test (radiated, conducted, a receiver's antenna port) with an uncertainty band. It ranks the fixes by the dB they buy, finds the cheapest set that gets every source to 6 dB, and writes a bench plan that says what a LISN, a current clamp or a near-field probe should read. Bench readings go back into the spec and move the prediction onto them. On the buck: radiated at risk on J2's cable, conducted a likely fail without an input filter; the cheapest set is an input filter, spread spectrum and a slower edge. adom-fields report folds that, Adom Safety's creepage check and Adom Mechanics' reliability screen into one readiness report: each area ready, needs work or blocked, with its findings.

What it assumed, and the edges

Every solve lists the inputs it had to assume, most important first. For each it gives the part's MPN, the datasheet field that replaces it, and the spec key it goes in, so an AI can read the datasheets and close the gaps. Nets where edges matter (impedance targets, clocks, length groups) are walked from driver to receiver, each segment a line with the cross-section solve's impedance, for a TDR profile and the overshoot in use. On the ESC, the SWD clock overshoots 40 % with a fast edge, and the report gives the 38 Ω series resistor that fixes it.

The app

adom-fields serve puts the board in 3D on the canonical Adom 3D viewer (adom/adom-3d-viewer, vendored and served by the binary: its camera, ViewCube, studio lighting, framing and Z-up frame, as 3d-viewer-design asks): the picked field on the picked layer, the other layers faded, the vias as dots, the hot parts labelled, the legend, the number under the cursor. On the left the nets by what they carry and the hot parts hottest first; on the right the issues and the method. Every click is a command: the state lives on the server and goes out over a live channel, so adom-fields ui view --quantity heat --layer B.Cu does exactly what the button does, and adom-fields tour walks the whole board for the AI Flow video.

An issue in view: the camera flies to the +VBAT neck

Click an issue and the camera flies to it: 20 A of +VBAT through a 1.5 mm neck on the top copper.

Run it

adom-fields analyze --board esc.kicad_pcb --spec spec.json --out fields     # about two minutes
adom-fields serve --fields fields --port 8874 &                             # https://<slug>.adom.cloud/proxy/8874/
adom-fields ui view --quantity current --net +VBAT --camera top             # drive it
adom-fields tour                                                            # the walkthrough, for a clip

The spec is Adom AI Flow's: loads (net: amps, maxRiseC), hot (ref: watts, tabNet), copperUm, hotMaxRiseC, thermalVias, optional stackupMm. The board must be saved with its zones filled.

In the AI Flow

Adom Fields is the analysis step of Adom's AI Flow: after the pours land, the AI solves the fields, reads the issues, and walks the board on camera with adom-fields tour while the flow records the window. The clip goes into the run's video; the numbers go on the run page.

Honest limits, 0.1

DC only; one copper thickness for all layers; a flat convection coefficient, no heatsink, no enclosure, no radiation; the tab watts come from the spec. A screen that finds the necks and the starved tabs and shows them, not a datasheet number. Next: heatsinks as conducting blocks, pour capacitance, differential pair and impedance checks (the signals tab), and an Altium reader. (The Fusion reader landed in 0.6.0, below.)

Give it back

Anything wrong, rigid or missing: an issue or a PR on this page. Adom processes PRs within minutes during business hours.

Input identity in 0.3.1

Every solve records SHA-256 identities of its exact board/spec and refuses if either changes during the solve. AI Flow uses this to reject stale current/thermal evidence and skipped required loads. This proves input identity, not the validity of terminal, material, loss or air assumptions. Existing summaries need a fresh solve.

Gentle walkthrough on the ESC

Recorded through AI Flow on AdomLapper, 129.8 seconds raw and 13.1 seconds at 10x. The contact sheet was inspected and the camera remained stable when drift was disabled. This is a viewer demonstration: the board still has current and thermal findings, not an independent qualification pass.

Conducting heatsinks and signals in 0.4.0

Specify finite-conductivity rectangular blocks with contact resistance, inspect heat entering them, and compare still/moving air. The Signals view reports copper-overlap capacitance, differential-pair length skew, sampled reference coverage and conservative microstrip impedance estimates. Unsupported geometry is explicit. Inputs, limitations, sources and reproducible fixture.

The chips over the heat in 0.5.0

A hot zone alone does not say what is heating it. Fields now stands each part's own 3D model on the board, where KiCad places it, see-through by default so the field glows through the body: the regulator sits in its hot spot, the inductor in its own. The models come from the board's footprints, converted once on the Adom STEP service and cached; a footprint with no model gets a box from its courtyard. The header's cube button (or ui view --parts ghost|solid|off) switches them. Every camera move and the idle sway now run at half speed, so a clip the flow plays at ten times speed stays calm.

The first buck board's heat flow with the parts see-through: U1 and L1 standing in their hot zones

The flow and the river in 0.7.0

Two new views, both from the same DC solve, both animated on the GPU so the eye reads the field as motion.

Flow turns the solved current into charge streaming through the copper: thousands of glowing streaks whose speed and heat follow the current density (slow and dim on a quiet pour, white-hot through a neck), dropping through each via barrel in proportion to the current the solve says that barrel carries. The layer button in the header pulls the stack apart, so the inner copper shows and the current falling between the layers is plain.

The buck's layers pulled apart, the current streaming over both copper layers and down the via barrels

The 12 V to 5 V buck, layers pulled apart: charge on the top and bottom copper, and the current pouring down the barrels between them.

River lifts every net's copper to its voltage: the rail where the net is fed, plus the IR drop the solve found (exaggerated, and the badge says by how much). The current runs over it as water. A ground is the sea, a supply a terrace above it, a switching node a tide between its rails (slowed to a rate the eye can follow, and labelled). The loads are waterfalls down to ground; the sources are fountains back up. Each net carries a sign with its voltage and its drop, and the cursor reads the volts under it.

The river: VIN at 12 V, VOUT at 5 V, SW swinging between them, GND at sea level

VIN's 12 V plateau, VOUT's 5 V terrace, SW at the top of its tide and the GND sea, with the waterfalls where U1 and the loads take their current. VIN loses 1.4 mV from J1 to U1; the ground under U1 sits 1.6 mV above the connectors.

The rails come from the net names (GND 0, 3V3 3.3, +12V 12) or the spec's voltages; sources names the part a net is fed from when that is not the connector (a regulator's output); switching marks a node that swings between rails. A rail the spec does not give stays at its drop alone, and its sign says so. Drive both like everything else: adom-fields ui view --quantity flow --explode 1, ui view --quantity river.

Energy and light in 0.7.0

Two more views from the same solve. Energy shows that the energy does not travel inside the copper: pink particles stream through the board material between the layers (the Poynting vector, E × H), rising into each part that takes its power, while blue dots show the electrons themselves crawling through the copper at their real speed, a few millimetres per second, against the current. Light colours the copper by how fast a change travels around it, as a percentage of the speed of light, and sweeps a switch-on front out from each source with the arrival time at each part: on the buck, VIN reaches U1 103 ps after J1.

Energy: pink energy flowing between the copper layers into U1 and L1, blue electrons crawling on the copper

The buck's layers apart: the energy runs through the board between the copper layers into the regulator and the inductor, while the electrons on the copper barely move.

Light: the copper coloured by the local speed of a change, with each part's arrival time

Each piece of copper coloured by how fast a change travels around it; the tags give when a switch-on reaches each part.

The energy cycle in 0.7.2

One switching period of the buck, slowed 1.6 million times: energy leaves the input capacitors (red) while the switch is on and flows through U1 into L1, whose magnetic field (blue) grows with its current; when the switch turns off the field collapses and keeps pushing current into the output capacitors and the load. A meter tracks each store, the heat lost and the 10 µJ delivered every cycle. L and C are the parts' own values from the board.

The energy cycle from the top, over the board's own silkscreen: energy from the VIN corner through U1 into L1, the meter on the left

The board's own silkscreen now lies over every view (the T button toggles it), so VIN, VOUT, the connectors and every part's reference and value read right on the field.

Explained out loud in 0.7.1

Each view can explain itself in plain words, by voice, with this board's own numbers: the speaker button in the header, or automatically the first time a viewer opens each kind of view (the left panel sets First time, Always or On ask). The explanation is written by the app from the solve, so it costs no AI tokens, and voiced once by adom-tts.

Fusion boards in 0.6.0

--board now also takes a Fusion Electronics board saved as EAGLE source (.brd: the Fusion bridge's fusion_export_eagle_source, or Fusion's own export). The same solve, the same app, the same tour.

adom-fields analyze --board buck.brd --spec spec.json --out fields --models-dir 3d
  • The copper is Fusion's own. Fusion stores each pour's computed fill in the board file (every island's outline and its holes, polygonfilldetails), so the reader uses that, the way it uses KiCad's filled polygons. A pour that was never filled (no RATSNEST since it was drawn) is filled on the solve grid instead: the outline, minus every other net's copper grown by the pour's isolate distance, keeping only the islands that touch the pour's own net, higher-priority pours first.
  • Placement. Elements are placed with their rotation and mirroring (a mirrored element is on the bottom, its SMD pads on B.Cu). Checked on a routed Fusion board: every trace end lands on a pad of its own net, and every pad without a trace belongs to a poured net.
  • Coordinates. EAGLE is y up; the reader negates y so reports, --at points and the app read the way they do for a KiCad board.
  • Parts. A Fusion board binds its 3D packages by cloud urn, so the viewer's models are found by name: the element's MPN attribute as <MPN>.step, else its deviceset or package name, in the --models-dir folders. Each STEP is placed with its own origin on the footprint origin, the way the Fusion bridge binds it.
  • Two copper layers plus up to two inner layers, as for KiCad boards.