RunMat for automotive and transportation

Fit cell models from pulse tests, run pack designs through drive cycles and check module temperatures, in the MATLAB language, on hardware your team already has.

Talk to us

Define and run physics simulations quickly

Check a module's cell temperatures as a study in the same project as your cell and pack models. The study selects the cells and their cooled faces by name from the pack's STEP file and sets each cell's heat and the cold plate's cooling, with a unit on every number. Its header works out a hand estimate of the peak to check the solved result against.

Change the cell heat or the coolant and rerun. Sweep heat load and cooling over dozens of studies in parallel, on a workstation or a cluster you run, and compare them in one script.

ThermalSimulation in RunMat

battery-module-cells.fea
Temperature of the eight cells of a battery module on its cold plate, from 301.066 K at the cold plate to 303.869 K at the cell tops, drawn inside the translucent CAD of the rest of the pack, solved in RunMat
Solved peak at the cell tops
303.9 K
Hand estimate in the study's header
303.86 K
Example: a battery module of eight prismatic cells at 20 W each, cooled from below by its cold plate. Results shows the solved temperature inside the rest of the pack; Source shows the study.

Run battery analysis in the language your team already knows

Your cell identification, state-of-charge and drive-cycle scripts run in RunMat as they are, so nobody rewrites them in Python and validates them again.

The fit beside this recovers the cell it was built from.

Curve fittingMigration guide

cell-model.m
[t, V] = pulse_test();
ocv = 3.65; % open-circuit voltage here (V)
on = @(t) t >= 5 & t < 15;
fall = @(t, tau) (t >= 15).*(1 - exp(-10/tau)).*exp(-(t - 15)/tau);
rise = @(t, tau) on(t).*(1 - exp(-(t - 5)/tau)) + fall(t, tau);
% Parameters: R0 and R1 in milliohms, the RC time constant in seconds.
model = @(p, t) ocv - p(1)/1000*50*on(t) - p(2)/1000*50*rise(t, p(3));
p = lsqcurvefit(model, [1 1 5], t, V);
fprintf('R0 %.2f mOhm, R1 %.2f mOhm\n', p(1), p(2));
fprintf('time constant %.1f s\n', p(3));
Terminal
$ runmat cell-model.m
R0 2.10 mOhm, R1 1.50 mOhm
time constant 13.5 s

Analyze large test data and share it across the team

Point the same script at every logged trace from every pack variant, and the whole team opens the results in one project, with each run kept beside the data that produced it.

The example beside this takes a pack through the EPA's urban cycle; swap in your own logs and rerun.

Differential equations

Scale from a laptop to a cluster with the same script

Change for to parfor and RunMat runs each pack variant through each cycle across the cores of a workstation or a cluster you run, so the pack decision rests on every cycle, not the one there was time to run.

Results from every run come back into one table, kept with the variant and cycle that produced them, so the comparison behind a pack decision can be rerun when the cells change.

ParallelGPU

% Every pack variant through every EPA cycle
cycles = {'udds', 'hwfet', 'us06'};
whkm = zeros(numel(packs), numel(cycles));
parfor k = 1:numel(packs)
    whkm(k, :) = cycle_energy(packs(k), cycles);
end
[~, best] = min(mean(whkm, 2));
LaptopRemote serverLARGE CLUSTER

Run your model checks in CI like the rest of your code

RunMat gives the same answer from the same data every time, so your model fits can sit in CI as regression tests. A change that moves a parameter fails the build before it reaches the BMS team.

RunMat is a single executable of about 200 MB that installs on a CI runner in one line, with no license server.

CI and containersSelf-hosted deployment

.github/workflows/cell-model.yml
name: cell-model
on: [push, pull_request]
jobs:
regression:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: curl -fsSL https://runmat.com/install.sh | sh
- run: runmat cell-model-check.m
Terminal
$ runmat cell-model-check.m
3 of 3 parameters within 1% of the reference
cell model regression: pass

Work on the same results together, live

The battery engineer and the thermal lead work in the same project at once, so a question about the hottest cell gets answered on the trace itself, not over email.

Each run is kept with the cycle and parameters that produced it.

A deterministic engine designed for AI models to use in controlled loops

The same script and data give the same result in RunMat every time, which makes it safe to put in a loop with an AI model. Ask the model to add a second RC branch to the cell model and refit.

RunMat checks types, shapes and units, sends any error back for the model to fix, then runs it. Every number the model reports was computed by RunMat and can be rerun from the saved run.

It works with Claude Code, Codex, any MCP client or the agent built into RunMat, on the model your company already uses.

AI integrations

Works withClaude CodeCodexAny MCP client

AI modelSets up and interpretsRunMatChecks and runs the studystudyerrors and results
  1. ModelWrites cantilever.fea
  2. RunMatline 28: traction must be force per area, found N
  3. ModelFixes the load unit: N → Pa
  4. RunMatSolved · tip deflection 0.199 mm, beam theory 0.200 mm
  5. ModelReports the results and how they were computed

Keep test data and pack designs in-house

RunMat runs on servers you control, offline if needed, so cell test data and pack designs stay inside the company.

Self-hosted deployment

Examples

Terminal voltage of a cell through a 50 A pulse with the fitted model over it, rendered by RunMat

Cell model from a pulse test

A one-RC equivalent circuit fitted to a 50 A pulse.

Battery power of an EV over the EPA urban drive cycle, rendered by RunMat

EV energy on the EPA urban cycle

Battery power, Wh/km and range from the EPA's own trace.

Temperature of twelve cells rising over three US06 cycles, rendered by RunMat

Module temperatures on US06

Twelve cells on a cold plate through three aggressive cycles.

Body acceleration RMS of a quarter car against damping, rendered by RunMat

Quarter-car ride

Body acceleration against damping on an ISO 8608 class C road.

Order spectrum of a 4-cylinder run-up with the second order dominant, rendered by RunMat

Order tracking on a run-up

A 4-cylinder's orders, resampled to shaft angle.

Engine order lines crossing a bracket's first two modes over engine speed, rendered by RunMat

Bracket modes against engine orders

Where the second and fourth orders cross a bracket's modes.

What RunMat does not do

  • Crash and occupant safety
  • External aerodynamics CFD
  • Multibody vehicle dynamics
  • AUTOSAR and ISO 26262 production code generation

Start here

  1. 01

    Open the cell model example in a browser. No account needed.

  2. 02

    Run three of your battery scripts and compare results and run times.

  3. 03

    Talk to us about your test data and where the analysis needs to run.

Curve fittingDifferential equationsSignal processingSimulation in RunMat