Hashing on Turbulence Invariants: Lookup-Table Super-Resolution for 3D Flow Fields

Super-resolution means taking a coarse grid of values and producing a finer one. For 3D turbulent flow data it faces two costs that pull against each other. Deep 3D networks recover fine eddies far better than smooth interpolation, but they are expensive to train and run, and they often exhaust GPU memory on $128^3$ volumes. Fast image methods avoid that cost by replacing the network with precomputed tables of small reconstruction filters, but they index those tables by raw neighboring pixel values. In 3D this indexing becomes unworkable: a $2\times2\times2$ block of 8-bit voxels already implies $(2^8)^8$ table entries. We propose to index the table by a few physically meaningful quantities instead of raw voxels. Turbulence has a natural candidate. The velocity gradient tensor, which is the $3\times3$ matrix of how each velocity component changes along each axis, has two rotation-invariant scalars, conventionally called $Q$ and $R$. Together they describe whether a point is dominated by rotation or by strain, and whether vortices there are being stretched. A table indexed by normalized $(Q, R)$ and a local resolution ratio, with orientation handled by exact grid symmetries, needs only about a thousand filters. It should run at close to tricubic cost.

The dimensional argument is what makes this more than a port of an image method. In 2D incompressible flow the $R$ invariant vanishes identically, because vortex stretching cannot occur there. The 3D table therefore gains an axis that encodes exactly the physics 2D methods cannot represent, the forward energy cascade. Our core claim is that a small set of learned linear filters, chosen per voxel by $(Q, R, \Delta/\lambda)$ and followed by a cheap Fourier-space projection that makes the output divergence-free by construction, can match a compute-matched 3D convolutional network on turbulence statistics at a fraction of its cost. The same selection by physical invariants should also transfer across flow types better than hashing on generic image gradients.

What exists, and what this adds

Lookup-table super-resolution is well established in 2D. RAISR (Romano et al.) hashes each pixel neighborhood by gradient angle, strength and coherence and applies a pre-learned filter. SR-LUT (Jo and Kim) bakes a trained network into a table indexed by 2 to 4 pixels and runs a 720p frame in 15 ms on a phone, against 60 ms for bicubic. MuLUT (Li et al.) cascades tables to widen the receptive field and gains up to 1.1 dB over SR-LUT. LeRF (Li et al.) bakes continuous resampling functions into tables. These papers supply our mechanism, which is hash then filter, with cascading. They also motivate the change we make. Their index is built from natural-image statistics, and that index grows exponentially with neighborhood size, so none of them reaches 3D. We keep RAISR's idea of hashing on derived statistics and replace image-gradient statistics with invariants from fluid mechanics.

On the physics side, the closest systems solve the 3D problem with heavy networks. Chung et al. benchmark 49 variants of EDSR, RCAN, RRDB and Fourier-style networks on BLASTNet 2.0 at roughly 15,000 GPU-hours. They find that a gradient-based physics loss helps up to 50M parameters and that all models hit a "32× wall" where they sometimes lose to tricubic interpolation. SoZoGAN (Wu et al.) is the nearest relative in spirit. It builds a library of GANs indexed by the Taylor microscale $\lambda$, the length scale at which velocity gradients decorrelate, and transfers zero-shot from isotropic turbulence to channel flow. It reports $R^2>0.9$, velocity-variance error under 5%, and 0.075 s per snapshot. It also shows about 18% error in third- and fourth-order velocity-gradient moments, attributed to near-wall anisotropy, and it collapses once grid spacing exceeds about $1.1\lambda$. SoZoGAN selects a whole generator per spatial zone using a single scalar scale. We select a small linear filter per voxel using a scale together with local flow topology, $(Q,R)$ plus orientation. That is the part SoZoGAN's isotropic assumption discards, and it is plausibly the source of its higher-moment error. PhySR (PhySR) shows that physics-informed super-resolution can fit in 3D memory where MeshfreeFlowNet (Jiang et al.) runs out of memory on a 32 GB GPU. PhySR constrains our design by showing that hard-coding physics into the forward pass beats soft penalties. It still uses dense recurrent blocks and was not tested on 3D Navier–Stokes turbulence. Finally, FALCON (Kim et al.) is a 2D precedent for pairing a physics-derived map with a Fourier operation to get global effects cheaply. We borrow that pairing for the divergence constraint.

Core Claim

Let $A_{ij}=\partial u_i/\partial x_j$ be the velocity gradient tensor, estimated on the coarse grid with finite differences. We normalize its invariants as $q = Q/\lVert A\rVert^2$ and $r = R/\lVert A\rVert^3$, where $Q=-\tfrac12\mathrm{tr}(A^2)$ and $R=-\tfrac13\mathrm{tr}(A^3)$ for incompressible flow. After this normalization, $q$ and $r$ lie in a bounded region, the familiar "teardrop" shape of turbulence. The third index is $s=\Delta/\hat\lambda$, the coarse grid spacing divided by a locally estimated Taylor microscale. Each voxel's output is

$$\hat u_{\text{fine}} = P\Big(\mathcal{T}(u_{\text{coarse}}) + g^{-1}\cdot W_{k(q,r,s)}\, \big(g\cdot N(u_{\text{coarse}})\big)\Big),$$

where $\mathcal{T}$ is tricubic interpolation and $N(\cdot)$ is the $3^3$ neighborhood of all three velocity components. The operator $g$ is the one of 24 cube rotations that maps the local principal strain axes closest to a canonical frame. Because it only permutes grid indices and flips signs of vector components, it applies exactly on the grid with no resampling. $W_k$ is the learned linear filter in table bin $k$, and $P$ is the Leray projection, the Fourier-space operation that removes the divergent part of a velocity field in $O(N\log N)$.

With 16 bins on each of $q$ and $r$ and 4 on $s$, the table holds 1,024 filters. At a single $2\times$ stage each filter maps 81 inputs to 24 outputs, so the whole table is a few megabytes, of the same order as SR-LUT's 1.27 MB. Larger factors are handled by cascading $2\times$ stages, recomputing invariants at each stage as MuLUT does. The per-voxel work is one finite-difference gradient, one small $3\times3$ eigenproblem, one table read and one small matrix-vector product. It has no layers and no activations.

The claims we test are specific. First, invariant-indexed filters should reach the turbulence statistics of a 3D CNN at matched or lower cost. Second, the $r$ axis carries information that a 2D-style index, $q$ alone, misses. Third, filters selected by topology should transfer to wall-bounded flow better than filters selected by generic gradient structure.

Research Program

The first stage builds and trains the table. Filters are fitted jointly by gradient descent through the soft-binned forward model. Soft assignment to neighboring bins during training becomes hard lookup with trilinear blending between bins at deployment, mirroring SR-LUT's interpolation. The loss combines velocity error with the spatial-gradient loss that Chung et al. found consistently helpful, and the Leray projection sits inside the forward pass. Training data are coarsened homogeneous isotropic turbulence at $Re_\lambda\approx1200$ from the Johns Hopkins Turbulence Databases (JHTDB), the same source SoZoGAN uses.

The second stage handles regimes where local reconstruction breaks down. The $s$ axis lets the table learn different behavior near and beyond the $1.1\lambda$ threshold identified by Wu et al.. We will check whether bins with $s>1.1$ converge to near-zero residual filters, meaning the method falls back to tricubic. That outcome would be an honest, interpretable account of the 32× wall: the input no longer contains the information, and the method says so voxel by voxel.

The third stage addresses domain limits. The Fourier projection assumes periodic boundaries. For channel and boundary-layer flows, we apply it only along the periodic directions and add a finite-difference divergence penalty in the wall-normal direction. For compressible BLASTNet data the projection is dropped, since the target is not divergence-free. There we evaluate the lookup filters alone, with $q, r$ computed from the full gradient tensor including its trace. This is a real weakening of the hard constraint, and we report it separately.

Baselines

The naive reference is tricubic interpolation. It needs no training, it is the speed target, and per Chung et al. it occasionally wins at 32×. In 2D turbulence, bicubic gives 30.86% relative error (Zayats et al.). No reported 3D JHTDB number for tricubic was found on Lacuna, so we will measure it. Beating it means lower spectrum and dissipation error at no more than roughly 3× its wall-clock cost.

The strongest existing method on this data is SoZoGAN (Wu et al.). On zero-shot channel flow at $Re_\tau=1000$ it reports $R^2>0.9$, velocity-variance error below 5%, and about 18% error in third- and fourth-order gradient moments, with 0.075 s inference per snapshot and 18 GPU-hours of training. We will reproduce it on the same JHTDB training set and the same test snapshots and hardware. We will match its training budget, which should be generous for a linear table. Beating it means matching its variance error while clearly reducing the higher-moment error, the gap our topology index targets, at lower inference time.

The strongest compute-matched competitor is a small 3D CNN trained with the same gradient loss and the same Leray projection. We use two versions: an RCAN-style network under 17M parameters, since RCAN led the small-model regime in Chung et al., and a 3D collapsible-linear network in the style of SESR (Bhardwaj et al.). The latter is sized so that its deployed per-voxel operation count equals ours. Both get the same data, the same hyperparameter-search budget in trials, and the same projection. Beating the compute-matched network means equal or better statistics at equal cost. Beating the RCAN network means coming within a stated margin, for example 10% on spectrum error, at an order of magnitude less compute. On BLASTNet Momentum128 at 8×, 16× and 32×, no per-configuration numbers are reported in the file, so we will run these models ourselves.

Three ablations isolate the key ingredient. A "RAISR-3D" variant hashes on 3D structure-tensor statistics (gradient orientation, strength, coherence of the velocity magnitude) with the same number of bins, which tests whether physics invariants matter or whether any hashing works. A $q$-only variant with $r$ removed tests the claim that the inherently 3D invariant carries information. Removing the projection $P$ tests the hard constraint.

Why not just…?

Why not just use tricubic interpolation? It is fast and needs no training, and at 32× it is sometimes competitive (Chung et al.). It is also a pure smoother, and in 2D turbulence it roughly triples the error of a physics-informed model (Zayats et al.). Our design builds on tricubic as its base term. If the learned residual adds nothing, that shows up directly as near-zero filters, especially in the high-$s$ bins, so the experiments tell us where tricubic is already sufficient.

Why not just train a small 3D CNN at the same compute? This is the real threat. Nothing in the file shows that a tiny 3D CNN cannot learn the same topology dependence implicitly. We settle it with the compute-matched and SESR-style baselines above, which use the same loss, the same projection and the same tuning budget. If they match us in-distribution, our remaining claim rests on transfer from isotropic turbulence to channel flow and on interpretability. If they match us there too, the lookup table offers only a deployment convenience, and we would report that plainly.

Why not just hash on image-style gradient statistics, as RAISR does? It is simpler and already known to work in 2D (Romano et al.). Structure-tensor statistics of a scalar field, however, cannot tell a vortex tube from a strain sheet with the same gradient magnitude, and $(q,r)$ can. The RAISR-3D ablation tests this directly. Our proposal only earns its place if that ablation loses clearly on gradient moments and on the $Q$–$R$ joint distribution.

Why not just use SoZoGAN's scale-indexed library? It already transfers zero-shot. It indexes only by scale, however, and its higher-moment error of about 18% (Wu et al.) is exactly what local topology should address. It is also a nonlinear generator rather than a table read. The head-to-head comparison on channel flow decides this.

Proposed Experiments

We train on JHTDB isotropic turbulence at $Re_\lambda\approx1200$ and test at 4× and 8×. The tests are in-distribution, on isotropic turbulence at $Re_\lambda\approx433$, and zero-shot, on channel flow at $Re_\tau=1000$ and the boundary layer at $Re_\theta\approx1000$. We then test on BLASTNet Momentum128 at 8×, 16× and 32× to probe compressible flow and the 32× wall.

The metrics are velocity $R^2$ and relative error, energy-spectrum error in the dissipation range, and dissipation-rate error. We also report skewness and flatness of the longitudinal velocity gradients (the third- and fourth-order moments), the divergence of the output, and the distance between the predicted and true $Q$–$R$ joint distributions. For cost we report per-voxel operations, wall-clock time per $128^3$ volume on a single GPU and on a CPU, table memory, and training GPU-hours.

The decisive checks come in four parts. The first is whether the full method beats the RAISR-3D and $q$-only ablations on gradient moments and on the $Q$–$R$ distribution. The second is whether it narrows SoZoGAN's higher-moment error on channel flow. The third is whether it matches the compute-matched CNN at equal cost. The fourth is whether the high-$s$ bins degrade gracefully toward tricubic rather than hallucinating structure.

A negative result on the second ablation, where removing $r$ changes nothing, would falsify the central 2D-to-3D argument. A loss to the compute-matched CNN on transfer would reduce the contribution to an engineering one.