Paper deep dive
From Fixed Grids to Moving Particles:A Transferable Latent Operator for Fluid Dynamics
Meng Li, Chuqi Chen, Zhengqing Gao, Xi Zhou, Xiao Sun, Yang Xiang, Huaxi Huang
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 8/18/2026, 4:34:52 AM
Summary
The paper introduces the Transferable Latent Operator (TLO), a neural operator architecture that learns a unified flow representation from Eulerian field data to enable zero-shot generalization to Lagrangian particle rollout. TLO decouples latent flow evolution from coordinate-dependent decoding, allowing the same model to predict fixed-grid Eulerian fields and query velocities at moving particle positions without requiring Lagrangian supervision during training. The model demonstrates superior performance across multiple fluid dynamics benchmarks compared to existing neural operators.
Entities (7)
Relation Signals (7)
Transferable Latent Operator → uses → Latent Processor
confidence 95% · The Latent Processor learns the temporal evolution of underlying dynamics... We implement the Latent Processor with L attention-based blocks
Transferable Latent Operator → uses → Query Decoder
confidence 95% · The Query Decoder provides a coordinate-conditioned readout from the coordinate-independent latent state
Transferable Latent Operator → uses → patch encoder
confidence 95% · The model advances this state by one time step... Formally, the one-step operator G_theta is decomposed into an encoder E_theta...
Transferable Latent Operator → trainedon → Eulerian fields
confidence 94% · A model is trained exclusively with Eulerian field supervision, without particle coordinates, particle velocities, or trajectory labels.
Transferable Latent Operator → enables → zero-shot Lagrangian rollout
confidence 93% · can a model trained solely on Eulerian observations generalize zero-shot from Eulerian field prediction to Lagrangian particle rollout... TLO consistently outperforms existing neural operators in both Eulerian field prediction and zero-shot Lagrangian rollout
patch encoder → employs → Cross-Attention
confidence 88% · The Patch Encoder employs cross-attention as a permutation-invariant aggregation mechanism
Latent Processor → implements → attention-based blocks
confidence 88% · We implement the Latent Processor with L attention-based blocks inspired by the slice-based aggregation mechanism in Transolver
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Lagrangian modeling is vital to fluid dynamics, as it characterizes particle transport and complements the Eulerian representation. However, Lagrangian trajectories are less commonly available than Eulerian fields, while most neural operators are trained and evaluated primarily in the Eulerian representation. This mismatch motivates a new learning problem: can a model trained solely on Eulerian observations generalize zero-shot from Eulerian field prediction to Lagrangian particle rollout, without Lagrangian supervision or task-specific adaptation? To address this problem, we propose the Transferable Latent Operator (TLO), which learns a unified flow representation shared by Eulerian field prediction and Lagrangian particle rollout. TLO decouples latent flow evolution from coordinate-dependent decoding: querying the evolving latent representation at fixed spatial coordinates yields Eulerian fields, whereas querying velocities at particle positions and recursively updating these positions enables Lagrangian rollout. Across five fluid-dynamics benchmarks, TLO consistently outperforms existing neural operators in both Eulerian field prediction and zero-shot Lagrangian rollout, with further gains from limited Lagrangian fine-tuning.
Tags
Links
- Source: https://arxiv.org/abs/2608.14120v2
- Canonical: https://arxiv.org/abs/2608.14120v2
Trouble viewing inline? Open PDF directly →
Full Text
44,113 characters extracted from source content.
Expand or collapse full text
From Fixed Grids to Moving Particles: A Transferable Latent Operator for Fluid Dynamics Meng Li Chuqi Chen Zhengqing Gao Xi Zhou Xiao Sun Yang Xiang Huaxi Huang Abstract Lagrangian modeling is vital to fluid dynamics, as it characterizes particle transport and complements the Eulerian description. However, Lagrangian trajectories are less commonly available than Eulerian fields, while most neural operators are trained and evaluated primarily in the Eulerian representation. This mismatch motivates a new learning problem: can a model trained solely on Eulerian observations generalize zero-shot from Eulerian field prediction to Lagrangian particle rollout, without Lagrangian supervision or task-specific adaptation? To address this problem, we propose the Transferable Latent Operator (TLO), which learns a unified flow representation shared by Eulerian field prediction and Lagrangian particle rollout. TLO decouples latent flow evolution from coordinate-dependent decoding: querying the evolving latent representation at fixed spatial coordinates yields Eulerian fields, whereas querying velocities at particle positions and recursively updating these positions enables Lagrangian rollout. Across five fluid-dynamics benchmarks, TLO consistently outperforms existing neural operators in both Eulerian field prediction and zero-shot Lagrangian rollout, with further gains from limited Lagrangian fine-tuning. Introduction Lagrangian particle trajectories provide a direct description of transport, mixing, and dispersion in fluid flows. However, most fluid-learning datasets are available as time-dependent fields on fixed Eulerian grids (11; 9; 18; 13). Native Lagrangian data are less commonly available because they require specifying and tracking particle populations. At high particle counts, trajectory generation, storage, and particle-based training can also become expensive in time and memory (16; 20; 15). This mismatch motivates a practical question: can a model trained only on fixed-grid Eulerian data also support Lagrangian particle rollout of the same flow? We formulate this problem as zero-shot Eulerian-to-Lagrangian generalization. A model is trained exclusively with Eulerian field supervision, without particle coordinates, particle velocities, or trajectory labels. At test time, the same model is queried at moving particle positions, and its predicted velocities are recursively integrated without parameter adaptation. This is more than ordinary arbitrary-coordinate evaluation: each velocity prediction changes the next particle position and therefore determines the next query location. Errors can consequently induce a history-dependent query shift and accumulate into trajectory drift. Although existing methods have explored Eulerian–Lagrangian modeling, they do not directly address zero-shot Eulerian-to-Lagrangian rollout. Approaches based on latent particles, joint field–trajectory learning, or trajectory reconstruction (22; 19; 1; 12) typically require additional Lagrangian supervision or particle-specific modeling, preventing zero-shot transfer. Alternatively, Eulerian neural operators (9; 21; 14) can be combined with numerical interpolation to obtain particle velocities from predicted grid fields. However, this strategy remains tied to the resolution and finite support of the Eulerian discretization. Once particles move beyond the grid support, standard interpolation cannot continue without additional extrapolation rules. These limitations motivate a neural operator that learns flow dynamics from Eulerian observations while supporting direct evaluation at recursively evolving particle locations. We therefore introduce the Transferable Latent Operator (TLO), which uses one latent flow evolution with two query modes. An encoder maps fixed-grid Eulerian observations into spatially localized tokens augmented with global flow context, and a shared latent processor advances this representation independently of the output query set. A coordinate-conditioned decoder then evaluates the predicted field at requested locations. Querying on the fixed Eulerian grid produces an Eulerian field forecast, whereas querying the velocity channels at recursively advected particle positions produces a Lagrangian rollout. Particle coordinates are used only as decoder queries and are not required by the Eulerian training objective. We evaluate TLO on five fluid-dynamics benchmarks for Eulerian forecasting and on three benchmarks for zero-shot Lagrangian particle rollout. TLO achieves strong Eulerian accuracy while transferring directly to reference-path velocity prediction and closed-loop trajectories. We additionally compare with a native particle-based model and grid interpolation. Direct decoding is competitive with interpolation within the Eulerian support and remains evaluable after particles leave that support, where standard interpolation becomes undefined. We separately study decoder-only adaptation using sparse particle-velocity supervision. Our main contributions are summarized as follows: • We formulate and evaluate zero-shot Eulerian-to-Lagrangian generalization, in which a model trained only with fixed-grid Eulerian supervision performs closed-loop particle rollout without particle supervision or parameter adaptation. • We propose the Transferable Latent Operator, whose output-query-independent latent evolution and coordinate-conditioned decoder allow the same trained model to support both fixed-grid forecasting and moving particle queries. • Across five Eulerian benchmarks and three particle-rollout benchmarks, TLO achieves strong performance, compares favorably with neural-operator and native particle-based baselines, and remains evaluable beyond the fixed Eulerian grid support. Related Work Neural operators. Neural operators learn mappings between function spaces for PDE modeling (11; 8; 24). Representative architectures include spectral operators, coordinate-based models, and attention- or token-based operators (9; 5; 10; 26; 1; 3). Although several of these models support arbitrary-coordinate evaluation, they are generally evaluated on fixed or externally specified query locations. We instead consider moving queries whose positions are recursively generated by the model’s predicted velocities. Eulerian–Lagrangian modeling. Classical particle-grid methods couple Eulerian fields and Lagrangian particles through transfers between the two representations (2; 17). Recent neural methods use latent particles to improve Eulerian forecasting (12), infer fields or trajectories from particle observations (22; 19), or learn particle-based simulators (15; 27). In contrast, the zero-shot version of TLO is trained only on fixed-grid Eulerian fields, with particle positions introduced at inference time solely as decoder queries. The same learned flow representation therefore supports both Eulerian field prediction and closed-loop Lagrangian rollout. Sparse decoder adaptation is studied separately as a non-zero-shot extension. Problem Setting Let Ω⊂ℝd ^d be the spatial domain. At time t, the state of a flow is represented by a vector-valued field t:Ω→ℝdu u_t: ^d_u, where the c channels may contain velocity, pressure, density, or other physical variables. We denote the velocity by t():=Πvt()∈ℝd v_t( x):= _v u_t( x) ^d, where Πv _v is the projection operator extracting the velocity channels. The available data do not provide the continuous function t u_t directly. Instead, each state is observed at a fixed set of Eulerian coordinates XE:=ii=1NE,t:=[t(i)]i=1NE∈ℝNE×du. X_E:=\ x_i\_i=1^N_E,\,U_t:=[ u_t( x_i)]_i=1^N_E ^N_E× d_u. (1) The coordinates in XEX_E remain fixed over time, while the field values tU_t evolve. The dataset therefore consists of temporal sequences 0,1,…\U_0,U_1,…\ observed on the same Eulerian coordinates. Our goal is to learn the one-step evolution from the current Eulerian observation tU_t to the next physical field t+1 u_t+1. In particular, the learned operator should not be restricted to returning values only on XEX_E. Given any finite set of output coordinates Q=jj=1NQ⊂ΩQ=\ q_j\_j=1^N_Q⊂ , it predicts ^t+1(Q):=θ(XE,t,Q) U_t+1(Q):=G_θ(X_E,U_t;Q) =[^t+1(1),…,^t+1(NQ)]⊤. =[ u_t+1( q_1),…, u_t+1( q_N_Q)] . Here, a query is simply a coordinate j q_j at which the next field is requested. Setting Q=XEQ=X_E produces the next Eulerian grid field. Setting Q to particle coordinates provides the local velocity values needed to evolve Lagrangian particles. Figure 1: Workflow of TLO for unified Eulerian field forecasting and Lagrangian particle rollout from a shared latent flow representation. Notations XEX_E, U^t U_t, and y^t y_t follow Section Problem Setting. Learning from Eulerian fields. Fluid-dynamics datasets are commonly available as time-dependent fields on fixed spatial grids. We therefore use consecutive Eulerian fields as the primary source of supervision. Although the operator accepts a general query set Q, its training targets are provided only on XEX_E: ℒEul=t[1NEdu‖θ(XE,t,XE)−t+1‖F2].L_Eul=E_t\! [ 1N_Ed_u \|G_θ(X_E,U_t;X_E)-U_t+1 \|_F^2 ]. (2) Thus, neither particle coordinates nor trajectory labels are required to train the field-evolution model. Starting from an observed initial state 0U_0, choosing Q=XEQ=X_E at every step gives the autoregressive Eulerian rollout ^t+1=θ(XE,^t,XE),^0=0. U_t+1=G_θ(X_E, U_t;X_E), U_0=U_0. (3) This produces the predicted field sequence ^1,…,^H\ U_1,…, U_H\ on the fixed Eulerian grid support. Besides providing a field forecast, this rollout supplies the evolving flow state from which velocities at moving coordinates can be evaluated. Figure 2: Overview of the Transferable Latent Operator (TLO). TLO learns coordinate-independent latent dynamics from Eulerian observations. The hierarchical encoder extracts local and global flow representations, while the latent processor evolves the fused tokens without spatial coordinates. A coordinate-conditioned decoder then queries the latent state at arbitrary locations, enabling both fixed-grid Eulerian prediction and Lagrangian rollout. Particle positions are used only as inference-time queries and are not required for Eulerian training. Recovering Lagrangian trajectories. Fixed-grid forecasts describe how the flow evolves at stationary spatial locations. Many transport problems, however, concern material carried by the flow and therefore require following moving particles. Particle trajectories provide a direct description of transport and expose accumulated drift that may not be evident from an average fixed-grid field error. To obtain this Lagrangian view, let Y0=i,0i=1NPY_0=\ y_i,0\_i=1^N_P denote a set of initial particle positions. Once ^t u_t has been predicted, its velocity channels are evaluated at the current particle positions and integrated through ^i,t+1=ℬ(^i,t+Δt^t(^i,t)),^i,0=i,0, y_i,t+1=B\! ( y_i,t+ t\, v_t( y_i,t) ), y_i,0= y_i,0, (4) where ℬB enforces the physical boundary condition during particle integration, ensuring that the updated particle positions remain within the spatial domain Ω . The Eulerian state continues to evolve through Equation (3); the particles only determine where the predicted velocity field is evaluated. Thus, in the Eulerian-only setting, the same trained operator predicts fields on the fixed grid and provides velocities at moving particle positions. The particle trajectories are then obtained by numerical integration, without training a separate particle-dynamics model. Field and trajectory errors. Since Lagrangian rollout is driven by velocities queried from the predicted flow, fixed-grid field error alone does not fully characterize model performance. We therefore distinguish errors in Eulerian field prediction, velocity evaluation at particle positions, and the resulting closed-loop trajectories. We refer to these quantities as Eul, Ref, and Path, respectively, and report them throughout the experiments. Let H denote the rollout horizon, NEN_E the number of Eulerian grid points, and NpN_p the number of particles. We use dud_u, dvd_v, and dxd_x for the dimensions of the predicted state, velocity, and particle position, respectively. First, the fixed-grid Eulerian error is ℰEul:=1HNEdu∑t=1H∑∈XE‖^t()−t()‖22.E_Eul:= 1HN_Ed_u _t=1^H _ g∈ X_E \| u_t( g)- u_t( g) \|_2^2. (5) This measures the autoregressive field prediction on the Eulerian support XEX_E. To evaluate velocity without position feedback, we query at the reference positions i,t y_i,t: ℰRef:=1HNpdv∑t=1H∑i=1Np‖^t(i,t)−t(i,t)‖22.E_Ref:= 1HN_pd_v _t=1^H _i=1^N_p \| v_t( y_i,t)- v_t( y_i,t) \|_2^2. (6) The Eulerian field is still predicted autoregressively, but the query coordinates are reset to the reference pathline at every step. Hence, ℰRefE_Ref measures velocity accuracy along the correct trajectory without propagating particle-position errors. Finally, in the closed-loop rollout, the particle positions ^i,t y_i,t are recursively generated using the model’s queried velocities. The resulting trajectory error is ℰPath:=1HNpdx∑t=1H∑i=1NpdΩ2(^i,t,i,t),E_Path:= 1HN_pd_x _t=1^H _i=1^N_pd_ ^2\! ( y_i,t, y_i,t ), (7) where dΩd_ accounts for the domain geometry and uses the minimum-image distance on periodic domains. Transferable Latent Operator TLO follows an encode–process–decode architecture (16) that separates latent flow modeling from coordinate-dependent field evaluation. Given an Eulerian observation on XE=ii=1NEX_E=\ x_i\_i=1^N_E, we denote its sampled state by t=[t(i)]i=1NEU_t=[ u_t( x_i)]_i=1^N_E. The model advances this state by one time step and evaluates the predicted field at a specified query set Q=jj=1NQQ=\ q_j\_j=1^N_Q. Formally, the one-step operator θG_θ is decomposed into an encoder ℰθE_θ, a latent processor θT_θ, and a coordinate-conditioned decoder θD_θ: t0 Z_t^0 =ℰθ(XE,t), =E_θ(X_E,U_t), (8) tL Z_t^L =θ(t0), =T_θ( Z_t^0), ^t+1|Q U_t+1 |_Q =θ(tL,Q). =D_θ( Z_t^L,Q). The encoder constructs a latent representation of the observed flow, the processor advances this representation, and the decoder evaluates the predicted state at the requested coordinates. Importantly, the encoder and latent processor are independent of Q; only the final readout depends on the output coordinates. Setting Q=XEQ=X_E produces the next Eulerian field, whereas setting Q to the current particle positions provides the velocities used for Lagrangian rollout. The following sections describe each component in detail. Patch Encoder employs cross-attention as a permutation-invariant aggregation mechanism to map local and global observations into a fixed-size latent representation. To capture both localized transport dynamics and long-range flow dependencies, we construct a hierarchical domain representation consisting of local patches Ωp _p and the global domain Ωg _g: =Ω1,…,ΩP⏟local patches,Ωg⏟global context,Ωg=⋃p=1PΩp.D=\ _1,…, _P_local patches, _g_global context\, _g= _p=1^P _p. For each region Ω∗∈ _* , we first lift coordinate-attached observations into position-physical features. Specifically, i r_i =ϕ[PE(i),PE(ip),i,ep], =φ [PE( x_i),PE( x_i^\,p), u_i,e_p ], R∗ R_* =i∣i∈Ω∗, =\ r_i x_i∈ _*\, where i x_i denotes the global coordinate in Ω , ip x_i^\,p represents the local coordinate relative to its patch, and i u_i is the associated physical state. The fixed Fourier feature encoding PE(⋅)PE(·) provides continuous coordinate information, while the learnable patch embedding epe_p identifies local spatial regions. The lifting function ϕφ follows the standard formulation used in neural operator learning (9). For each local patch and the global domain, learnable latent queries l Q^l and g Q^g aggregate observations through cross-attention: ∗=Attn(∗,K(R∗),V(R∗)), Z_*=Attn( Q^*,K(R_*),V(R_*)), where ∗* indicates either a local patch or the global domain. The resulting latent tokens from different spatial regions are fused to form the initial latent state: 0=concat(∗) Z^0=concat(\ Z_*\) By integrating local coordinate encoding with global context aggregation, the hierarchical Patch Encoder converts coordinate-attached observations into a discretization-independent latent representation. This latent state preserves both local transport structures and global flow dependencies, providing a unified representation that can be queried on fixed Eulerian grids or evolving Lagrangian particle trajectories. The Latent Processor learns the temporal evolution of underlying dynamics and separats physical evolution from spatial discretization. We implement the Latent Processor with L attention-based blocks inspired by the slice-based aggregation mechanism in Transolver (26). Different from coordinate-conditioned neural operators, the proposed processor operates purely on latent tokens. At layer ℓ , the latent tokens are flattened as ℓ∈ℝN×h Z ^N× h, where N denotes the total number of latent tokens. The processor first assigns tokens into M adaptive latent slices: ℓ=softmax(ψ(ℓ))∈ℝN×M, W =softmax(ψ( Z )) ^N× M, where each row of ℓ W represents the contribution of a token to the latent slices. The slice representations are obtained by weighted and are then updated through self-attention: ℓ=Attn(^ℓ),^ℓ=~ℓ,Tℓ, S =Attn( S ),\, S = W ,T Z , where W~i,jℓ=Wi,jℓ/∑iWi,jℓ W _i,j=W _i,j/ _iW _i,j. The updated slice information is distributed back to the latent tokens: ℓ+1=ℓ+Proj(ℓℓ)+αFFN(ℓ). Z +1= Z +Proj( W S )+ ( Z ). Through latent-space evolution independent of spatial coordinates, the processor provides a reusable dynamic representation ZLZ^L that can be decoded at arbitrary Eulerian locations or evolving Lagrangian particle positions. Query Decoder provides a coordinate-conditioned readout from the coordinate-independent latent state, decoupling latent dynamics evolution from spatial discretization. For each query point, we first identify its corresponding patch Ωp(j) _p(j) and construct a query representation j=ψ[PE(j),PE(jp)], g_j=ψ[PE( q_j),PE( q_j^\,p)], using the previous embedding strategy. The physical quantity at the query location is recovered through cross-attention between the query feature and latent tokens from neighboring patches: ^(j)=∑pk∈(j)αkAttn(Q(j),K(pk),V(pk)), u( q_j)= _p_k ( q_j) _kAttn (Q( g_j),K( Z_p_k),V( Z_p_k) ), where (j)N( q_j) denotes the set of neighboring patches around the patch containing j q_j, and αk _k represents the aggregation weight of each neighboring patch. Error Analysis TLO predicts velocity, whereas a Lagrangian rollout is ultimately evaluated through particle position. Consider particle i over a rollout of T steps, indexed by t=0,…,Tt=0,…,T. Let Δt t be the integration step, and let t v_t and ^t v_t denote the reference and predicted velocity fields at step t, respectively. The corresponding reference and predicted particle positions are denoted by i,t y_i,t and ^i,t y_i,t. Using forward Euler, their positions evolve as i,t+1 y_i,t+1 =ℬ(i,t+Δtt(i,t)), =B\! ( y_i,t+ t\, v_t( y_i,t) ), (9) ^i,t+1 y_i,t+1 =ℬ(^i,t+Δt^t(^i,t)),t=0,…,T−1. =B\! ( y_i,t+ t\, v_t( y_i,t) ),\,t=0,…,T-1. where ℬB is the bounce operator that handles particles that reach the boundary of the physical-domain during rollout. Define the position error and the velocity error evaluated at the reference particle position as δi,t:=dΩ(^i,t,i,t),ri,t:=‖^t(i,t)−t(i,t)‖2. _i,t:=d_ ( y_i,t, y_i,t),\,r_i,t:= \| v_t( y_i,t)- v_t( y_i,t) \|_2. (10) Proposition 1 (Velocity error to trajectory error). Assume that ^i,0=i,0 y_i,0= y_i,0, that ℬB is non-expansive under dΩd_ , and that ^t v_t is L^t L_t-Lipschitz over the region visited by the two particles. Then, for every t=0,…,T−1t=0,…,T-1, δi,t+1≤(1+ΔtL^t)δi,t+Δtri,t. _i,t+1≤(1+ t\, L_t) _i,t+ t\,r_i,t. (11) Consequently, the position error at the rollout horizon T satisfies δi,T≤Δt∑s=0T−1ri,s∏k=s+1T−1(1+ΔtL^k), _i,T≤ t _s=0^T-1r_i,s _k=s+1^T-1(1+ t\, L_k), (12) with the convention that an empty product equals one. Proposition 1 connects the velocity predicted by the model to the particle position evaluated in a Lagrangian rollout. At each step, a velocity error ri,tr_i,t causes an immediate position error of approximately Δtri,t t\,r_i,t. The updated position is then used as the query coordinate at the next step. Therefore, once the predicted particle deviates from the reference path, subsequent velocities are evaluated at a different location, which may introduce further error. The factor 1+ΔtL^t1+ t\, L_t describes the strength of this feedback. Over a long rollout, these errors accumulate, and errors made earlier can affect more subsequent steps. Thus, a small Ref vel. error is important but does not necessarily imply a small Path error, which motivates reporting both metrics. Experiments Benchmarks. We evaluate TLO on five fluid benchmarks covering particle-based simulations, grid-based PDEs, and real-world SEA (ocean current). DAM2D and TGV3D are SPH datasets from LagrangeBench (20) and are converted to Eulerian fields by kernel splatting; see supplementary material for details. NS2D, Burgers3D, and SEA provide grid-based velocity fields from, respectively, incompressible Navier–Stokes dynamics, nonlinear advection–diffusion, and ocean reanalysis data (7; 6; 12). DAM2D uses its native particle trajectories, while virtual tracers for Burgers3D and SEA are generated from the reference velocity fields using Parcels (4). These particles are passive tracers and do not influence the Eulerian dynamics. Dataset Native data Support Evaluation Horizon DAM2D SPH 32×6432× 64 Eul/Ref/Path 10 NS2D Grid 64264^2 Eul 10 TGV3D SPH 20320^3 Eul 5 Burgers3D Grid 32332^3 Eul/Ref/Path 5 SEA Grid 180×300180× 300 Eul/Ref/Path 10 Table 1: Benchmark summary. Eul, Ref, and Path denote fixed-grid field, reference-query velocity, and closed-loop trajectory evaluation. Baselines. We compare with LSM (25), GINO (10), GNOT (5), Transolver (26), UPT (1), LNO (23), and DeepLag (12), covering latent-space, geometry-aware, attention-based, and Eulerian–Lagrangian operator architectures. For particle evaluation, query-native models are evaluated directly at particle coordinates, whereas grid-output models use bilinear or trilinear interpolation of their predicted fields. We additionally evaluate both direct decoding and grid interpolation from the same TLO checkpoint. Training and evaluation. All models are trained for one-step Eulerian field prediction and evaluated through autoregressive rollout. We report fixed-grid field error (Eul), velocity error along reference particle trajectories (Ref), and closed-loop particle-position error (Path), as defined in Eqs. (5)–(7). For Ref, reference particle positions are supplied as queries at each step, while the predicted field continues to evolve autoregressively. For Path, only the initial particle positions are given; subsequent positions are obtained by integrating the predicted velocities and are used as the next queries. Thus, Path measures the accumulated effect of velocity errors on the particle trajectory. The main experiments use only Eulerian training data, with the sparse decoder-adaptation study reported separately. Eulerian prediction Autoregressive Eulerian field rollout. We first examine whether TLO preserves predictive accuracy in the standard Eulerian setting. Starting from the ground-truth initial field, each model recursively predicts the next state on the fixed Eulerian grid and feeds its previous prediction back as input. We report the fixed-grid field error (Eul) defined in Eq. (5), averaged over all rollout steps H, spatial locations, state channels, and test trajectories. This evaluation isolates temporal field-forecasting error from spatial-query error and particle-position feedback. As shown in Table 2, TLO achieves strong Eulerian rollout performance across all five benchmarks. The improvements cover SPH-derived and grid-native data, two- and three-dimensional systems, and both simulated and reanalysis flows. These results show that TLO retains strong fixed-grid Eulerian forecasting accuracy while supporting moving particle queries through the same learned representation. Method DAM2D NS2D TGV3D Burgers3D SEA LSM 2.97E-02 3.46E-03 9.57E-04 2.17E-03 5.72E-01 GINO 6.04E-03 3.68E-05 2.47E-04 5.35E-03 5.90E-01 GNOT 2.24E-02 1.72E-03 9.37E-04 4.21E-04 4.19E-01 Transolver 6.13E-03 1.40E-04 7.67E-04 4.22E-04 5.22E-01 LNO 3.75E-03 8.73E-05 7.54E-03 4.42E-03 5.21E-01 UPT 2.38E-02 1.31E-03 7.54E-03 5.59E-03 8.97E-01 DeepLag 1.65E-02 4.04E-03 3.17E-04 3.38E-03 8.17E-01 TLO (Ours) 3.12E-03 1.98E-05 1.75E-04 9.88E-05 1.77E-01 Table 2: Mean squared error (MSE) of autoregressive Eulerian rollout. Lower is better. The best result in each column is highlighted in bold. Model ablations analysis. Figure 3 shows that the 12×1212× 12 patch lattice yields the lowest error, suggesting a trade-off between finer spatial partitioning and the amount of information available within each patch. Under the same total token budget, Local+Global consistently outperforms Local, showing that its gain cannot be explained by additional latent capacity alone. And the Local+Global error exhibits an overall downward trend and reaches its lowest value at 160 tokens. These results support the complementary roles of local tokens for spatially resolved information and global tokens for domain-level context. Figure 3: Patch and token ablations on NS2D. Left: Eul MSE versus patch lattice size. Right: two models use matched total tokens, with a fixed 8×88× 8 patch and global token equals 8 for Local+Global. Lower is better. In Table 3, all variants are controlled with comparable model sizes to ensure a fair comparison. TLO has 150.8K parameters versus 146.7K without FFN, while Local-only and Global-only use the same number of tokens as TLO. Thus, the gains cannot be explained solely by model capacity, but arise from the local–global representation and latent processing. Design Eul ↓ TLO (Local 56 + Global 8) 1.98E-05 Local-only (64) 2.22E-05 Global-only (64) 4.21E-05 w/o FFN 4.51E-05 Table 3: Ablation of TLO components on NS2D under comparable model sizes. Token-allocation variants share the same 64-token budget. Lower L2 error is better. Transfer from Eulerian to Lagrangian rollout Having established strong Eulerian forecasting accuracy, we next evaluate whether the learned dynamics can transfer from fixed-grid field prediction to closed-loop rollout at moving particle coordinates. Because the latent processor in TLO evolves the flow representation independently of the output query set, the same Eulerian-trained checkpoint can be used by changing the decoder queries from fixed-grid locations to recursively advected particle positions. We first consider the Eulerian-only (EO) setting. The model is trained using only Eulerian field supervision, without particle coordinates, particle velocities, or trajectory labels during training. At inference time, particle positions are introduced only as decoder queries, and the queried velocities are recursively integrated to form a closed-loop rollout. As shown in Table 4, TLO achieves the lowest Ref and Path errors among the compared methods on all three Lagrangian benchmarks. These results show that an Eulerian-trained TLO checkpoint can transfer directly to moving-particle queries without particle-based training supervision or parameter adaptation. They also motivate evaluating closed-loop trajectories in addition to fixed-grid forecasting accuracy. We further consider a decoder-adapted (DA) setting. Starting from the Eulerian-trained checkpoint, we fine-tune only the decoder using sparse velocity samples at particle coordinates, while keeping the encoder and latent processor fixed. This adaptation provides additional, dataset-dependent improvements in the coordinate readout. The results are consistent with the Eulerian-trained latent representation already containing transport-relevant information, which can be further calibrated for moving-coordinate evaluation through limited particle supervision. Figure 4 provides a qualitative comparison of closed-loop particle rollouts. All methods start from the same initial particle positions and recursively update them using their predicted velocities. The resulting trajectory deviations visualize the accumulated effects of velocity-prediction error and feedback through recursively generated query locations. Dataset Setting Method Eul ↓ Ref ↓ Path ↓ DAM2D EO UPT 2.38E-02 7.62E-02 1.44E-01 LNO 3.75E-03 4.35E-03 5.30E-03 TLO (Ours) 3.12E-03 2.41E-03 3.72E-03 DA TLO (Ours) 3.08E-03 2.39E-03 3.72E-03 Burgers3D EO UPT 5.59E-03 2.91E-03 7.73E-03 LNO 4.42E-03 3.36E-03 9.42E-03 TLO (Ours) 9.88E-05 6.17E-04 3.01E-03 DA TLO (Ours) 9.48E-05 2.25E-04 2.59E-03 SEA EO UPT 8.97E-01 4.92E-02 1.06E-02 LNO 5.21E-01 5.29E-02 1.10E-02 TLO (Ours) 1.77E-01 3.00E-02 8.99E-03 DA TLO (Ours) 1.72E-01 2.95E-02 8.29E-03 Table 4: Transfer from Eulerian training to Lagrangian rollout. EO directly applies the Eulerian-trained checkpoint without particle-based training supervision. For TLO, DA fine-tunes only the decoder using sparse velocity samples at particle coordinates. Eul, Ref, and Path denote fixed-grid field, reference-path velocity, and closed-loop particle-position MSE, respectively. Lower is better. Figure 4: Qualitative closed-loop Lagrangian rollout on SEA. Each column shows the Eulerian velocity field and the corresponding particle trajectories at different rollout steps (T=2,6,10T=2,6,10). Comparison with Lagrangian baseline. We compare TLO-DA with GNS (16), a native Lagrangian model trained from particle trajectories, in Table 5. This comparison examines whether latent dynamics learned from Eulerian fields, together with lightweight decoder adaptation, can support competitive particle rollout. GNS learns particle interactions directly through trajectory supervision, whereas TLO-DA keeps its Eulerian-trained encoder and latent processor fixed and fine-tunes only the decoder using sparse velocity samples at particle coordinates, without a trajectory loss. On DAM2D, TLO-DA achieves more accurate particle rollout with lower computational overhead than GNS. This advantage comes from the different representations used for dynamics modeling: GNS explicitly propagates information among particles through graph message passing, whose cost grows with particle interactions, while TLO evolves a compact latent flow representation and only decodes velocities at queried locations. These results show that an Eulerian latent representation can recover accurate particle dynamics without the cost of explicit particle interaction modeling. Method Ref ↓ Path ↓ Mem. ↓ Time ↓ TLO-DA 2.39E-03 3.72E-03 35.94 7.26 GNS 4.19E-02 2.50E-02 47.99 8.68 Table 5: Comparison with a native Lagrangian model on DAM2D particle rollout. TLO and GNS contain 144K and 146K parameters, respectively. Memory and runtime are reported in MiB and ms/step, respectively. Beyond-Grid Lagrangian Rollout We further evaluate TLO on Lagrangian rollouts beyond the fixed Eulerian grid support. Starting from the same latent flow state, we compare two readout strategies: TLO-Interp obtains particle velocities by interpolating the predicted Eulerian field, whereas TLO-Direct evaluates the coordinate-conditioned decoder at particle locations. Within the grid support, the two strategies achieve comparable accuracy. Once particles leave the grid domain, however, standard interpolation is no longer defined without an additional extrapolation rule, while TLO-Direct can still be evaluated at the off-grid particle coordinates. TLO-DA, which fine-tunes only the decoder using sparse particle-velocity supervision, further reduces the off-grid rollout error. These results highlight the advantage of decoupling latent flow evolution from coordinate-dependent readout: Lagrangian rollout is not restricted to the spatial support of the Eulerian output grid. In-grid 10 steps Outside 20 steps Full 20 steps Method Ref Path Ref Path Path TLO-Interp 2.89E-04 1.63E-04 – – – TLO-Direct 3.22E-04 1.89E-04 1.35E-01 6.05E-02 4.48E-03 TLO-DA 3.22E-04 1.89E-04 3.82E-02 3.51E-02 2.51E-03 Table 6: Direct decoding and grid interpolation on DAM2D. A dash indicates that interpolation cannot continue after grid exit. Figure 5: Closed-loop rollout beyond the fixed Eulerian grid support on DAM2D. Light- and dark-blue points show reference particles at Steps 15 and 20, respectively. The inset follows a particle crossing Ωgrid _grid: grid interpolation becomes undefined after the exit, whereas direct decoding continues the rollout. Conclusion To answer whether flow dynamics learned only from fixed-grid Eulerian data can support closed-loop Lagrangian particle rollout, we formulated zero-shot Eulerian-to-Lagrangian generalization and developed TLO. By separating query-independent latent dynamics from coordinate-conditioned decoding, TLO supports both fixed-grid field prediction and rollout at recursively evolving particle locations. Across five field-prediction and three particle-rollout benchmarks, TLO achieves strong Eulerian accuracy and lower rollout errors than the evaluated baselines; sparse decoder adaptation further improves accuracy and outperforms GNS on DAM2D. The decoder can also be queried after particles leave the fixed-grid domain, whereas interpolation requires an additional extrapolation rule. Overall, these results show that fixed-grid supervision can learn transferable flow dynamics beyond fixed-grid inference, while closed-loop moving queries provide a stringent test of this transferability. References Alkin et al. (2024) B. Alkin, A. Fürst, S. Schmid, L. Gruber, M. Holzleitner, and J. Brandstetter Universal physics transformers: a framework for efficiently scaling neural operators. In Advances in Neural Information Processing Systems, Vol. 37. External Links: Link, 2402.12365 Cited by: Introduction, Neural operators., Baselines.. Brackbill and Ruppel (1986) J. U. Brackbill and H. M. Ruppel FLIP: a method for adaptively zoned, particle-in-cell calculations of fluid flows in two dimensions. Journal of Computational physics 65 (2), p. 314–343. Cited by: Eulerian–Lagrangian modeling.. Cao (2021) S. Cao Choose a transformer: fourier or galerkin. Advances in neural information processing systems 34, p. 24924–24940. Cited by: Neural operators.. Delandmeter and Van Sebille (2019) P. Delandmeter and E. Van Sebille The parcels v2. 0 lagrangian framework: new field interpolation schemes. Geoscientific Model Development 12 (8), p. 3571–3584. Cited by: Benchmarks.. Hao et al. (2023) Z. Hao, Z. Wang, H. Su, C. Ying, Y. Dong, S. Liu, Z. Cheng, J. Song, and J. Zhu Gnot: a general neural operator transformer for operator learning. In International conference on machine learning, p. 12556–12569. Cited by: Neural operators., Baselines.. Koehler et al. (2024) F. Koehler, S. Niedermayr, R. Westermann, and N. Thuerey APEBench: a benchmark for autoregressive neural emulators of pdes. Advances in Neural Information Processing Systems 37, p. 120252–120310. Cited by: Benchmarks.. Kovachki et al. (2023) N. Kovachki, Z. Li, B. Liu, K. Azizzadenesheli, K. Bhattacharya, A. Stuart, and A. Anandkumar Neural operator: learning maps between function spaces with applications to pdes. Journal of Machine Learning Research 24 (89), p. 1–97. Cited by: Benchmarks.. Li et al. (2024) Z. Li, H. Song, D. Xiao, Z. Lai, and W. Wang Harnessing scale and physics: a multi-graph neural operator framework for pdes on arbitrary geometries. arXiv preprint arXiv:2411.15178. Cited by: Neural operators.. Li et al. (2021) Z. Li, N. Kovachki, K. Azizzadenesheli, B. Liu, K. Bhattacharya, A. Stuart, and A. Anandkumar Fourier neural operator for parametric partial differential equations. In International Conference on Learning Representations, External Links: Link, 2010.08895 Cited by: Introduction, Introduction, Neural operators., Transferable Latent Operator. Li et al. (2023) Z. Li, N. Kovachki, C. Choy, B. Li, J. Kossaifi, S. Otta, M. A. Nabian, M. Stadler, C. Hundt, K. Azizzadenesheli, et al. Geometry-informed neural operator for large-scale 3d pdes. Advances in Neural Information Processing Systems 36, p. 35836–35854. Cited by: Neural operators., Baselines.. Lu et al. (2021) L. Lu, P. Jin, G. Pang, Z. Zhang, and G. E. Karniadakis Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators. Nature Machine Intelligence 3 (3), p. 218–229. External Links: Document, Link Cited by: Introduction, Neural operators.. Ma et al. (2024) Q. Ma, H. Wu, L. Xing, S. Miao, and M. Long Deeplag: discovering deep lagrangian dynamics for intuitive fluid prediction. Advances in Neural Information Processing Systems 37, p. 122833–122866. Cited by: Introduction, Eulerian–Lagrangian modeling., Benchmarks., Baselines.. Ohana et al. (2024) R. Ohana, M. McCabe, L. Meyer, R. Morel, et al. The well: a large-scale collection of diverse physics simulations for machine learning. Advances in Neural Information Processing Systems 37, p. 44989–45037. Cited by: Introduction. Rahman et al. (2022) M. A. Rahman, Z. E. Ross, and K. Azizzadenesheli U-no: u-shaped neural operators. arXiv preprint arXiv:2204.11127. Cited by: Introduction. Rochman-Sharabi et al. (2025) O. Rochman-Sharabi, S. Lewin, and G. Louppe A neural material point method for particle-based emulation. Transactions on Machine Learning Research. External Links: ISSN 2835-8856, Link Cited by: Introduction, Eulerian–Lagrangian modeling.. Sanchez-Gonzalez et al. (2020) A. Sanchez-Gonzalez, J. Godwin, T. Pfaff, R. Ying, J. Leskovec, and P. Battaglia Learning to simulate complex physics with graph networks. In Proceedings of the 37th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 119, p. 8459–8468. External Links: Link, 2002.09405 Cited by: Introduction, Transferable Latent Operator, Comparison with Lagrangian baseline.. Sulsky et al. (1994) D. Sulsky, Z. Chen, and H. L. Schreyer A particle method for history-dependent materials. Computer methods in applied mechanics and engineering 118 (1-2), p. 179–196. Cited by: Eulerian–Lagrangian modeling.. Takamoto et al. (2022) M. Takamoto, T. Praditia, R. Leiteritz, D. MacKinlay, F. Alesiani, D. Pflüger, and M. Niepert PDEBench: an extensive benchmark for scientific machine learning. In Advances in Neural Information Processing Systems, Vol. 35. External Links: Link, 2210.07182 Cited by: Introduction. Thakur and Raissi (2025) S. Thakur and M. Raissi ELPINN: eulerian lagrangian physics-informed neural network. arXiv preprint arXiv:2504.09053. Cited by: Introduction, Eulerian–Lagrangian modeling.. Toshev et al. (2023) A. Toshev, G. Galletti, F. Fritz, S. Adami, and N. Adams Lagrangebench: a lagrangian fluid mechanics benchmarking suite. Advances in Neural Information Processing Systems 36, p. 64857–64884. Cited by: Introduction, Benchmarks.. Tripura and Chakraborty (2023) T. Tripura and S. Chakraborty Wavelet neural operator for solving parametric partial differential equations in computational mechanics problems. Computer Methods in Applied Mechanics and Engineering 404, p. 115783. Cited by: Introduction. Wan et al. (2025) J. Wan, H. Wang, B. Liu, X. Yang, X. Hu, S. Cai, G. He, and Y. Liu TrajectoryFlowNet: lagrangian–eulerian learning of flow field and trajectories. External Links: 2507.09621, Link Cited by: Introduction, Eulerian–Lagrangian modeling.. Wang and Wang (2024) T. Wang and C. Wang Latent neural operator for solving forward and inverse pde problems. Advances in Neural Information Processing Systems 37, p. 33085–33107. Cited by: Baselines.. Wen et al. (2026) S. Wen, A. Kumbhat, L. Lingsch, S. Mousavi, Y. Zhao, P. Chandrashekar, and S. Mishra Geometry aware operator transformer as an efficient and accurate neural surrogate for pdes on arbitrary domains. Advances in Neural Information Processing Systems 38, p. 155423–155501. Cited by: Neural operators.. Wu et al. (2023) H. Wu, T. Hu, H. Luo, J. Wang, and M. Long Solving high-dimensional pdes with latent spectral models. In International Conference on Machine Learning, p. 37417–37438. Cited by: Baselines.. Wu et al. (2024) H. Wu, H. Luo, H. Wang, J. Wang, and M. Long Transolver: a fast transformer solver for PDEs on general geometries. In International Conference on Machine Learning, External Links: Link, 2402.02366 Cited by: Neural operators., Transferable Latent Operator, Baselines.. Xiong et al. (2023) S. Xiong, X. He, Y. Tong, Y. Deng, and B. Zhu Neural vortex method: from finite lagrangian particles to infinite dimensional eulerian dynamics. Computers & Fluids 258, p. 105811. Cited by: Eulerian–Lagrangian modeling..