CFD / AI SURROGATE / OMNIVERSE KIT-CAE
From CFD to an interactive data-center twin
The surrogate takes a GPU load setting and the ON/OFF states of four air-conditioning units, then predicts temperature and three velocity components over 3,494,065 fluid cells. Kit-CAE visualizes the predicted fields through an in-memory pipeline.
This article reports the 100-case surrogate and external accuracy results for five additional interpolation cases. The contour plots and latency benchmark use the 92% heat-generation case with air-conditioning units 1, 3 and 4 ON. All latency figures identify cold or warm operation.
100
Fluent cases
10 heat loads × 10 AC patterns
3.49M
Fluid cells
One aligned mesh
5
External test cases
4 added + the 92% case
1.552 s
Warm update
Temperature + velocity
READING THE RESULTS
External accuracy results now cover heat-generation settings of 15%, 38%, 62%, 85% and 92%, with five air-conditioning configurations. These heat-generation settings lie between the 10%-step training levels, and all cooling configurations are included in the training dataset. The tests cover interpolation, not out-of-range settings or unseen cooling configurations. The contour plots show only the 92% case with units 1, 3 and 4 ON and unit 2 OFF.
Workflow overview
The workflow has an offline training stage and an online prediction and visualization stage. A surrogate model maps the GPU load setting and four air-conditioning ON/OFF states to CFD fields. The visualization pipeline displays the predicted fields using volumes, planar slices, streamlines and flow animations, without rerunning Fluent for each update.
Principal component analysis (PCA) represents each spatial field using nine components. A multilayer perceptron (MLP) predicts their coefficients from the five operating inputs. The implementation predicts and visualizes CFD fields for selected operating conditions. Live sensor integration and cooling control are not demonstrated.
01 · LEARN OFFLINE
100 Fluent cases
Align cells, fit PCA, and train four MLP ensembles.
02 · PREDICT ONLINE
5 inputs → 4 fields
Predict nine coefficients per field on the GPU.
03 · EXPLORE IN KIT-CAE
Cached voxels → 3D view
Inspect volumes, slices, streamlines, and flow animations.
01 / CFD data and cell alignment
The model takes five operating inputs: one GPU load setting and four air-conditioning ON/OFF states.
- GPU load setting: the prescribed heat-generation percentage in the CFD model, normalized to 0–1 for inference. This is a scenario setting, not a live GPU-utilization measurement.
- Four air-conditioning units: one independent ON/OFF input per unit.
The dataset combines ten heat-generation levels (10% to 100%, in 10% steps) with ten cooling configurations: six combinations with two units ON and four with three units ON. This gives 100 converged steady-state cases. For example, one configuration has units 1, 3 and 4 ON and unit 2 OFF.
Each case provides cell-centered temperature (Fluent SV_T) and velocity components (SV_U, SV_V, SV_W). Speed is derived after prediction as sqrt(u² + v² + w²); it is not a fifth independently trained field. The source case is a Fluent 2026 R1 double-precision 3D solution. Boundary conditions, turbulence settings and convergence criteria remain those in the Fluent case file; this workflow does not redefine them.
CFD MODEL / DATA-CENTER GEOMETRY

Fluent may repartition cells on startup, so array index i in its API output does not necessarily identify the same cell as index i in the native HDF5 data. The dataset builder launches Fluent once, reads fluid-cell centroids and all four fields, constructs a per-cell fingerprint from the 64-bit T/U/V/W values, and finds a permutation from Fluent API order to HDF5 order. It verifies all four quantities cell by cell, then reads the other 99 results directly with h5py. The resulting dataset uses a common cell order across cases.
Cases were stratified by air-conditioning configuration into 69 training, 16 validation and 15 internal test cases. Input/output standardization and PCA are fitted on training cases only. Validation selects models and stops training; the internal test split is held back for final evaluation. The five external cases at 15%, 38%, 62%, 85% and 92% heat generation are separate from the 100-case dataset.
02 / Surrogate model: PCA and MLP ensembles
For each physical quantity, the data matrix has operating cases as rows and 3,494,065 fluid cells as columns. The sample-space Gram matrix G = XcenteredXcenteredT/(n−1) is computed on the GPU instead of a cell-by-cell covariance matrix. With 69 training cases, the Gram matrix is 69 × 69. Gram/PCA fitting uses float64; the stored PCA bases are converted to float32 for inference.
| Field | PCA coefficients | Stored cumulative explained variance |
|---|---|---|
| Temperature | 9 | 0.999860 |
| Velocity U | 9 | 0.999691 |
| Velocity V | 9 | 0.999667 |
| Velocity W | 9 | 0.999528 |
Four separate MLP ensembles predict nine standardized PCA coefficients, one ensemble per field. Each network has five input values, two hidden layers with 64 neurons and Tanh activation, and nine outputs. Training uses Adam, a learning rate of 5×10−4, weight decay of 10−4, batch size 8, up to 3,000 epochs and early-stopping patience of 300 epochs for candidate models. The loss is mean squared error in standardized coefficient space.
Model selection reconstructs a fixed sample of 50,000 validation cells and minimizes MAE + 0.25 × P99 absolute error. The score includes both mean absolute error and the 99th percentile of absolute error. Seven candidate networks are trained with different random initializations for each field. A candidate is added to the ensemble only when it reduces the validation score. Selected coefficient predictions are averaged before the PCA inverse transform.
| Field | Models in ensemble | Validation score |
|---|---|---|
| Temperature | 4 | 0.00163856 |
| Velocity U | 7 | 0.00144356 |
| Velocity V | 7 | 0.00110074 |
| Velocity W | 6 | 0.00127862 |
At inference time, the input, networks, coefficient scaling, PCA basis and output scaling remain on one CUDA device. The full cell field is reconstructed with a coefficient–basis matrix multiplication under torch.inference_mode(). Models and PCA/scaler tensors are cached in the worker process. This turns a five-dimensional operating condition into four spatial fields without solving the CFD equations again.
03 / Accuracy against Fluent
The external evaluation now includes five cases at 15%, 38%, 62%, 85% and 92% heat generation, with the air-conditioning ON/OFF conditions listed in the tables below. Each case contains 3,494,065 fluid cells. All five heat-generation settings are absent from the 10%-step training grid, while their cooling configurations are included. The evaluation covers interpolation within the trained heat-generation range at known cooling configurations. It does not test out-of-range settings or unseen cooling configurations. The four additional cases are taken from the newly supplied test summaries; the 92% values retain the previously reported evaluation results.
Reported metrics: MAE is the mean absolute cellwise error, P99 is the 99th percentile of absolute error, and MAX is the largest cellwise absolute error. Temperature errors are in kelvin (K); speed errors are in metres per second (m/s). Speed is the magnitude of velocity, calculated as sqrt(u² + v² + w²); it is not a directional component or a vector-error norm. These metrics compare the surrogate with Fluent, not physical sensor measurements. The GPU load setting is the prescribed CFD heat-generation percentage. Values in the tables are rounded to six decimal places.
Temperature error
| GPU load setting (%) | AC units ON | AC units OFF | MAE (K) | P99 (K) | MAX (K) |
|---|---|---|---|---|---|
| 15 | 1, 2 | 3, 4 | 0.001052 | 0.011200 | 0.226959 |
| 38 | 2, 4 | 1, 3 | 0.000939 | 0.008789 | 0.429596 |
| 62 | 3, 4 | 1, 2 | 0.000815 | 0.008759 | 0.139923 |
| 85 | 1, 2, 3 | 4 | 0.002951 | 0.039795 | 1.151581 |
| 92 | 1, 3, 4 | 2 | 0.002242 | 0.032288 | 1.194550 |
Speed-magnitude error
| GPU load setting (%) | AC units ON | AC units OFF | MAE (m/s) | P99 (m/s) | MAX (m/s) |
|---|---|---|---|---|---|
| 15 | 1, 2 | 3, 4 | 0.001119 | 0.008545 | 0.412387 |
| 38 | 2, 4 | 1, 3 | 0.000755 | 0.006119 | 1.119324 |
| 62 | 3, 4 | 1, 2 | 0.000613 | 0.004668 | 0.963135 |
| 85 | 1, 2, 3 | 4 | 0.007447 | 0.078335 | 0.803782 |
| 92 | 1, 3, 4 | 2 | 0.002131 | 0.016291 | 1.527859 |
PER-CASE MAXIMUM ABSOLUTE ERRORS
Across the five cases, temperature MAX ranges from 0.139923 to 1.194550 K, and speed MAX from 0.412387 to 1.527859 m/s. Each value is the maximum cellwise absolute error for its case over the full fluid mesh, not only the cells visible in the contour plots.
Reading the contour comparisons
The following four plots show only the 92% heat-generation case with air-conditioning units 1, 3 and 4 ON and unit 2 OFF. The other four cases are reported in the tables above. From upper left clockwise, the panels show the Fluent reference field, surrogate prediction, absolute error and signed error (prediction minus reference). The reference and prediction panels of each plot share a color scale. The image headings report full-cell MAE, P99 and maximum errors for the 92% case, not statistics restricted to the displayed slices. Slice membership is defined by a ±0.040 m thickness. Error-panel color ranges differ between plots.
FIGURE 01 / TEMPERATURE · HORIZONTAL SLICE

FIGURE 02 / TEMPERATURE · VERTICAL SLICE

FIGURE 03 / SPEED · HORIZONTAL SLICE

FIGURE 04 / SPEED · VERTICAL SLICE

04 / In-memory visualization with Kit-CAE
For the current surrogate, the file-based filebase writes a compressed prediction NPZ, resamples the polyhedral CFD mesh with VTK, generates CPU OpenVDB, saves a VDB file, and references it through an OpenUSD OpenVDBAsset for NVIDIA IndeX. In a measured temperature-plus-velocity run, the intermediate prediction NPZ was about 86.9 MiB and the temperature VDB about 17.7 MiB. That path still incurs repeated disk I/O and geometric resampling after inference.
FIGURE 05 / WORKFLOW COMPARISON

The in-memory extension keeps a separate Python inference worker to isolate PyTorch/CUDA from Kit’s ABI and exchanges control messages via JSON Lines. It avoids per-update NPZ and VDB interchange. The extension supplies a custom MemoryVolumeAdapter, not an unmodified built-in adapter: a USD prim attribute ikulab:memoryDatasetId identifies the in-process record. It exposes temperature as a Warp volume and velocity components and validity mask as GPU fields. Kit-CAE / warp-simdata APIs provide the dataset, field and adapter interfaces; they do not train the surrogate or solve the CFD equations. CaeViz creates volume, planar slice, streamline and flow-animation operators, rendered through NVIDIA IndeX. When an in-memory dataset changes, the extension explicitly invalidates/synchronizes the active controller because no file-path change triggers an automatic refresh.
Extension interface and visualization
EXTENSION UI / SURROGATE CONTROL

From operating inputs to a 3D view
Operating conditions
Set the GPU load level, represented by the CFD heat-generation percentage, and select the ON/OFF state of each of the four air-conditioning units. Velocity fields can be included for airflow visualization.
Visualization controls
Toggle the temperature volume and configure the planar slice, including its field, direction, position and opacity. The extension also provides Streamline and Flow Animation settings for airflow visualization.
Live analytics
The panel also displays temperature summaries. The screenshot illustrates the interface, not an additional accuracy or latency benchmark.
Affine voxel cache
For a fixed mesh and fixed interpolation grid, PCA reconstruction is affine in the predicted coefficients and cell-to-voxel interpolation is linear. We can therefore apply the interpolation operator V to the bias and each PCA basis once, then combine the voxelized bases for each new condition:
cell_field = bias + Σᵢ cᵢ · basisᵢ
voxel_field = V(cell_field) = V(bias) + Σᵢ cᵢ · V(basisᵢ)
There are nine coefficients and one bias column per physical field. The grid is 343 × 288 × 134, or 13,237,056 grid points, with 11,409,635 active voxels at 0.03 m spacing. The four-field affine cache occupies 2,170,880,292 bytes (about 2.02 GiB). It stores the interpolated bias and nine basis fields per quantity for reuse in subsequent updates. Changes to the mesh, voxel size or model signature require rebuilding the relevant cache.
Warp allocates an index-space NanoVDB on the GPU with wp.Volume.allocate, uploads float32 values to CUDA arrays and writes voxels in a launched kernel using wp.volume_store_f. USD transform supplies the physical placement and 0.03 m scale. The SimData/CaeViz bridge then renders the GPU-resident field without a VDB file round trip.
05 / End-to-end latency
Measurements used the 92% heat-generation case with air-conditioning units 1, 3 and 4 ON and unit 2 OFF, an NVIDIA RTX PRO 6000 Blackwell Max-Q, the 0.03 m grid above, and the same PCA/MLP ensembles. The first run of each condition is reported as cold. Each warm result is the mean of 10 subsequent runs, excluding the first run. Filebase and in-memory four-field results both include temperature and all three velocity components.
| Condition | Cold total | Warm mean (10 runs) | Warm SD | Warm P95 |
|---|---|---|---|---|
| Filebase, T + U/V/W | 29.402 s | 13.342 s | 0.458 s | 14.195 s |
| In-memory, temperature only | 7.851 s | 0.448 s | 0.042 s | 0.527 s |
| In-memory, T + U/V/W | 56.290 s | 1.552 s 8.60× faster | 0.161 s | 1.703 s |
LIKE-FOR-LIKE WARM COMPARISON
The four-field warm end-to-end means were 13.342 s for the filebase and 1.552 s for the in-memory path, making the in-memory path 8.60× faster. The visualization-path means were 9.259 s and 1.300 s, making the in-memory path 7.12× faster. Four-field cold totals were 29.402 s for the filebase and 56.290 s for the in-memory path. Preparation of the three velocity affine caches took 45.599 s in the latter cold run.
FIGURE 06 / WARM PROCESSING-TIME COMPARISON

| Warm-stage mean | filebase, T + U/V/W | In-memory, T + U/V/W |
|---|---|---|
| Inference and/or NPZ output | 4.066 s | 0.252 s inference |
| VTK + OpenVDB / voxel generation | 9.231 s | 0.201 s affine reconstruction; 0.034 s temperature NanoVDB; 0.628 s velocity voxel generation |
| Field upload + operator synchronization | 0.027 s USD/IndeX stage | 0.056 s upload; 0.149 s sync |
| Whole visualization path | 9.259 s | 1.300 s 7.12× faster |
| End-to-end | 13.342 s | 1.552 s 8.60× faster |
For temperature alone on the in-memory path, the warm mean was 0.448 s. Reported stage means were approximately 0.042 s for inference, 0.140 s for reconstruction, 0.044 s for NanoVDB generation, 0.016 s for field upload and 0.148 s for operator synchronization. The end-to-end mean also includes measurement and other overhead. This condition covers temperature only, not all four fields.
Individual visualization interactions were each measured once, not as 10-run averages: slice creation 1.059 s, slice-position update 0.0317 s, streamline creation 0.782 s, and flow-animation creation 0.0345 s. These timings exclude screenshot capture.
06 / Experimental environment and limits
The recorded workstation ran Windows 11 Enterprise on an Intel Core i9-13900K with about 127.8 GiB of physical RAM and an NVIDIA RTX PRO 6000 Blackwell Max-Q (95.6 GiB of GPU memory as reported by PyTorch; driver 591.86). The training-pipeline record used Python 3.13.3. The dataset NPZ is 7,197,785,544 bytes (about 6.70 GiB), and the four-field affine cache is about 2.02 GiB.
The recorded pipeline took 308.560 s to build the 100-case dataset and 253.165 s for the PCA/MLP stage. These are stage measurements, not an end-to-end ensemble-training measurement. The approximately 3,012 s artifact timeline also includes temperature retraining and orchestration waits.
Evaluation scope and limits
- External comparison: five heat-generation settings (15%, 38%, 62%, 85% and 92%) were compared with Fluent, each at a cooling configuration included in the training dataset. Unseen cooling configurations and settings outside the training range are not covered by these tests.
- Local error statistics: per-case maximum absolute temperature errors range from 0.139923 to 1.194550 K; per-case speed maxima range from 0.412387 to 1.527859 m/s. The reported evaluation does not validate safety or hotspot-control decisions.
- Visualization grid: the displayed volume uses a resampled regular voxel grid with 0.03 m spacing, rather than the original unstructured Fluent mesh. The accuracy metrics above were calculated on the original fluid cells, not the resampled voxels.
- Initialization and cache: the in-memory four-field cold total was 56.290 s, and the affine cache occupied about 2.02 GiB. Changes to the mesh, grid or model signature invalidate the relevant cache.
- Undemonstrated functions: the measurements report surrogate errors against Fluent and visualization-update timings. They do not demonstrate sensor assimilation, closed-loop cooling optimization or compliance with a hard real-time deadline.
The video below shows the Kit-CAE extension interface. The accuracy and latency figures in this article come from the reported tests, not measurements taken from the video.
Reported results and scope
The implementation reconstructs temperature and three velocity components over 3,494,065 fluid cells from a GPU load setting and four air-conditioning ON/OFF states. External accuracy evaluation now covers five interpolation cases. Temperature MAE ranges from 0.000815 to 0.002951 K, and speed MAE from 0.000613 to 0.007447 m/s; per-case P99 and MAX values are listed in the accuracy tables. The contour plots and latency benchmark remain specific to the 92% case with units 1, 3 and 4 ON. For that latency benchmark, four-field warm end-to-end means were 13.342 s for the file-based filebase and 1.552 s for the in-memory path, each averaged over 10 runs. The in-memory path is 8.60× faster. Corresponding cold totals were 29.402 s and 56.290 s. The accuracy comparisons use Fluent as the reference and cover known cooling configurations within the trained heat-generation range. Live sensor integration, closed-loop cooling control and hard real-time deadlines are not demonstrated.
further reading
For platform context, see NVIDIA’s Kit-CAE User Guide, the Kit-CAE extension architecture, and the Warp SimData repository. Kit-CAE provides an engineering-data visualization framework, and Warp SimData supplies simulation-data processing interfaces. The surrogate and memory adapter described here are project-specific implementations. These references describe the platform tools. The accuracy and timing values reported in this article are project-specific measurements, not benchmark results from these platform references.




