acceptodds
Under review as a conference paper at ICLR 2027

MeshFiLM: Fast Physics Surrogates on Unstructured Meshes via Node-Wise Modulation

Abstract

Neural surrogates for physics on unstructured meshes usually exchange information between nodes in every layer, by message passing along mesh edges or through a small set of slice tokens. We study how far a surrogate can go when this exchange happens once. MeshFiLM embeds every node independently, pools the embeddings once into a context vector for each node, and decodes the fields with a pointwise MLP whose hidden features are modulated in every layer by feature-wise linear modulation, computed from the node's own embedding and its context. We compare two pooling operators: statistics pooling gives every node the same summary, and routed pooling lets each node read its own mixture of learned region summaries. On five PLAID benchmarks and the surface and volume fields of AhmedML, we compare models in one training pipeline using the same node features and hardware. MeshFiLM trains - faster per epoch than the fastest baseline on PLAID and - faster on AhmedML, with fewer parameters. At equal epochs, its routed variant has lower mean error than the strongest baseline in four of seven settings and comparable error in a fifth. In four PLAID settings with equal-time runs, MeshFiLM-R has -% lower error than the strongest baseline on three; on the fourth, both MeshFiLM variants remain about % higher.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
MeshFiLM, Neural PDE Surrogates, Unstructured Mesh, Feature-Wise Linear Modulation, Pooling, Transolver, Graph Neural Networks, Computational Fluid Dynamics, AI for Science.

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_KC4AOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
1
Soundness
2
Read review
Paper summary

The paper proposes MeshFiLM, a lightweight neural operator for approximately solving PDEs with neural networks. Instead of global-local interactions, a single global pooling with node feature-wise modulation (via FiLM) is applied. The papers evaluated on five PLAID dataset and AhmedML.

Critical strengths

the architecture is simple and lightweight the experiments are broad and diverse and include relevant baselines

Critical weaknesses
  • On some datasets like 2DMultiscHypEl the single global-pooling step seems to be insufficient and MeshFiLM underperforms
  • limited novelty as global-information informed feature processing is not novel by itself and neither is FiLM.
  • insufficient justification for FiLM layer. while the global aggregation is motivated, it's not clear why the FiLM is an essential component. Simple residual updates (or low-rank) or concatenation could be potentially even more performant
Questions for authors

How does the method compare against a simple DeepSets or a GNN that globally pools node features and broadcasts the resulting representation through FiLM or concatenation? How does the method perform when changing FiLM to other components such e.g. simple additive or concat+linear layer -based conditioning?

3 comments
AuthorsOpenReview ↗

Response to Reviewer KC4A (1/3)

We sincerely thank the reviewer for the comments, and we answer the three weaknesses and the question.

W1: 2D_MultiScHypEl.

We agree that the stress results motivate a closer look at this dataset. At the same time, MeshFiLM-R has the lowest macro error of all models on 2D_MultiScHypEl (Table 1). Grouping the fields of Table 12 shows where the remaining gap lies (Table J).

Table J. 2D_MultiScHypEl, RRMSE (×10⁻³), three seeds.

ModelMacroDisplacements (u1, u2)Stresses (P11, P12, P22, P21)s/epochParams (M)
MGN27.16 ± 0.9023.2027.1735.40.92
MGN-Tree26.07 ± 0.4322.9525.4243.00.92
Transolver26.02 ± 0.1812.0032.6315.50.79
Transolver++26.48 ± 0.1911.9633.3415.80.73
MeshFiLM-R25.12 ± 0.039.6432.182.80.47

Compared with MGN-Tree, MeshFiLM-R has a 2.4× lower displacement error, trains 15× faster per epoch, and has half the parameters. The two graph networks are more accurate only on the four stress components, by 17–27% (MGN-Tree) and 12–21% (MGN). These stresses concentrate around the holes: message passing along mesh edges reads this local geometry directly, while an edge-free model sees it only through the node features. The gap is local and not a limit of the single exchange. MeshFiLM-R is ahead of Transolver and Transolver++ on every stress component, although they exchange information in every layer, and two or three pooling rounds lower its stress error by only 2% (32.18 → 31.44×10⁻³, one seed), with MGN-Tree still 19% lower.

W2: novelty.

We agree that neither FiLM nor pooling is new in isolation. Our contribution is to show that a single exchange between nodes, followed by node-wise conditioning in every decoder layer, can rival architectures that exchange information in every layer. Three points make this specific.

  1. The question. Mesh surrogates exchange information between nodes in every layer, by message passing or through slice tokens. We ask how far a single exchange can go. Under a controlled protocol, it matches or improves on per-layer exchange in five of seven settings at equal epochs, with 1.7–8.4× faster epochs and fewer parameters. To our knowledge, this had not been established for mesh surrogates.
  2. Node-wise conditioning computed from the node embedding zjz_j and the context cjc_j, in every decoder layer. PointNet-style models concatenate one pooled feature once; MARIO and BlendedNet modulate with a sample-level code, so every point of a sample receives the same modulation; enf2enf and CORAL fit latents per sample. MeshFiLM is the only model in Table 41 that modulates every decoder layer node-wise after a single exchange, in one training stage and without per-sample fitting. The experiments below (W3) test this choice.
  3. Routed pooling is not a global pooling. Each node reads its own mixture of KK region summaries, through separate write and read routers, so the context matrix has rank up to KK. Transolver slices use one router for both roles, and our learned routers exploit the asymmetry: on four datasets, regions read more than ten times as much as they are written supply 32–89% of the context (App. K). With the same decoder, routed pooling is also more accurate than a single global mean pooling on all three datasets we tested (Table K below).
AuthorsOpenReview ↗

Response to Reviewer KC4A (2/3)

W3 and Q: why FiLM? Additive, concatenation, DeepSets and GNN baselines.

Our FiLM head is already a low-rank residual update: [γj∥βj]=U(Azj+Bcj)+d[\gamma_j \Vert \beta_j] = U(A z_j + B c_j) + d, of rank 32, with UU and dd initialized to zero so that the decoder starts as a plain MLP. In MeshFiLM-R, cj=[∑krjkqtk∥p]c_j = [\sum_k r^q_{jk} t_k \Vert p] is the routed read of the KK region summaries, concatenated with p=P(sin)∈R128p = P(s_{\mathrm{in}}) \in \mathbb{R}^{128}, the encoding of the sample-level scalar inputs (Eq. 3). Concatenation followed by a linear layer is additive conditioning, W[h;c]=Whh+WccW[h; c] = W_h h + W_c c, where the added term is a linear function of the context alone. The question therefore has three parts: node-wise head or concatenation, routed pooling or a single global pooling (DeepSets), and whether the multiplicative term matters. We ran the following variants in the MeshFiLM-R pipeline:

  • shift only, h+βjh + \beta_j: our FiLM head with γj=0\gamma_j = 0, i.e. a low-rank residual update, still computed node-wise from zjz_j and cjc_j;
  • cjc_j concatenated to the decoder input, or to every block;
  • DeepSets + concat: routed pooling replaced by a mean over the nodes (K=1K = 1), the pooled vector concatenated, with pp, to the decoder input of every node (the PointNet design, with mean instead of max pooling);
  • DeepSets + FiLM: the same mean-pooled vector, broadcast through our FiLM head, i.e. MeshFiLM-R with K=1K = 1.

Table K. Fields only, macro RRMSE (×10⁻³), one seed. Tensile2d: 2000 epochs, as in Table 2; 2D_MultiScHypEl and 2D_profile: 1000 epochs. Every run decays its learning rate over its own budget (on 2D_profile, Table 1 reports 28.14 ± 0.22 for MeshFiLM-R because its equal-epoch values are read from longer runs before the learning rate has decayed). Last column: on each dataset, the relative gap to the lowest error among the six variants with context; we report the largest of the three gaps.

PoolingDecoder conditioningTensile2d2D_MultiScHypEl2D_profileParams (M, Tensile2d)s/epoch (Tensile2d)Largest gap to the best
Routed, K=8K = 8FiLM, (1+γj)⊙h+βj(1+\gamma_j) \odot h + \beta_j (MeshFiLM-R)0.77525.1227.310.472.84.6%
Routed, K=8K = 8Shift only, h+βjh + \beta_j0.76624.9926.120.442.62.5%
Routed, K=8K = 8cjc_j concatenated to the input0.98924.3926.460.422.429%
Routed, K=8K = 8cjc_j concatenated to every block0.82824.5226.260.502.48.1%
Mean, K=1K = 1 (DeepSets)FiLM0.87225.9327.810.462.714%
Mean, K=1K = 1 (DeepSets)concatenated to the input1.05425.0126.200.422.238%
Nonepointwise MLP (Table 35)46.5–––1.5

We draw four conclusions.

  1. The key contribution is the node-wise conditional modulation itself, computed from zjz_j and cjc_j in every decoder layer. FiLM provides the most general affine form of this conditioning; in MeshFiLM-R, a purely additive variant of the same head (shift only) performs similarly on the tested datasets (0.5–4.4% lower error, one seed). We will add these rows to Table 2 and state this in Sec. 2.2.
  2. Concatenating the context instead is less robust. Both forms of the head are within 5% of the best variant on every dataset. On Tensile2d, concatenating cjc_j is 8–29% worse than the best variant, and DeepSets + concat (mean pooling, concatenated to the input) is 38% worse; on the two other datasets, concatenation is within 3% of the head, sometimes ahead.
  3. Routed pooling beats a single global pooling, which answers the DeepSets question. With the same FiLM head, the routed context lowers the error by 11% on Tensile2d, 3% on 2D_MultiScHypEl and 2% on 2D_profile.
  4. On 2D_MultiScHypEl and 2D_profile, the conditioning is not the bottleneck: every variant with context lies within 6.5% of the others. These datasets are limited by the stresses near the holes (W1) and by the shock, which a second pooling round removes on 2D_profile (25.72 vs. 25.80×10⁻³ for Transolver++; reply to Qy5h, W2).
AuthorsOpenReview ↗

Response to Reviewer KC4A (3/3)

A GNN that pools globally and broadcasts through FiLM. We added this to MGN, in the same pipeline as our MGN baseline (15 message-passing steps, width 80). After message passing, the node latents of each mesh are pooled once (mean, maximum, standard deviation, as in MeshFiLM-S), and every hidden layer of the node decoder is modulated by the same rank-32 FiLM head, computed from each node's latent and the pooled context. MGN and MGN + FiLM use the same code and budgets as Table K, one seed.

Table L. Fields only, macro RRMSE (×10⁻³), one seed.

ModelTensile2d2D_profileParams (M)s/epoch (Tensile2d)
MGN2.1350.120.9232.9
MGN + pooled context through FiLM1.6026.780.9734.7
MeshFiLM-R (Table K)0.77527.310.472.8

The pooled context lowers the error of MGN by 25% on Tensile2d and by 47% on 2D_profile, although MGN already exchanges information along edges in 15 layers: one global summary supplies what local message passing does not. MeshFiLM-R obtains this without message passing. It is 2.1× more accurate than MGN + FiLM on Tensile2d and within 2% of it on 2D_profile, with half the parameters and 12× faster epochs.

Reviewer_Qy5hOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates whether neural surrogates for physics can achieve strong performance with a single round of simple information exchange, replacing the repeated message passing or Transformer attention used by prior methods. Context is collected through global or region-based pooling and injected into each node’s decoder through repeated feature modulation. Both pooling strategies demonstrate competitive performance.

Critical strengths
  1. The method reduces computation by exchanging information among mesh nodes only once.

  2. Two simple pooling strategies capture global or region-based context without computationally expensive Transformer attention.

  3. Context-conditioned modulation guides each node’s predictions throughout decoding.

  4. The method achieves faster inference with fewer parameters while outperforming strong baselines on most benchmarks.

Critical weaknesses
  1. Despite strong results on some datasets, the proposed single-step pooling shows less consistent performance across benchmarks than Transolver++. The degradation of MeshFiLM-R on Rotor37 and MeshFiLM-S on AhmedML-volume raises concerns about its reliability on new benchmarks.

  2. Would additional rounds of routed pooling over updated node features improve MeshFiLM-R’s performance, or would the gains quickly saturate?

  3. How sensitive is prediction accuracy on AhmedML to the choice of chunk size (e.g., 131,072 nodes)?

  4. The parameters wkcw_k^c, wkqw_k^q, and VV are not defined. Please clarify their dimensions and roles in the routing and pooling operations.

Questions for authors

None.

2 comments
AuthorsOpenReview ↗

Response to Reviewer Qy5h (1/2)

We sincerely thank the reviewer for the accurate summary and the precise questions.

W1: consistency across benchmarks.

The two degradations each come from one variant and have identified causes; they do not come from the single exchange itself. MeshFiLM-R, our default variant, stays close to Transolver++ in all seven settings at equal epochs (Table F). For scale, Transolver itself is 11% behind Transolver++ on both AhmedML settings.

Table F. Macro RRMSE of MeshFiLM-R relative to Transolver++, equal epochs (Table 1).

Tensile2dVKI-LS59Rotor372D_MultiScHypEl2D_profileAhmedML surf.AhmedML vol.
−27%−2.5%+4%−5%+9%−6%−7%

On Rotor37, the gap of MeshFiLM-R comes from the path of the operating point, not from the operator. Replacing routed pooling by statistics pooling raises its error (4.89 → 6.19×10⁻³, Table 26), and so does adding the statistics to the routed context (5.60–6.16 vs. 4.69×10⁻³, new; Table D in our reply to Reviewer GxTh). The Rotor37 geometries vary little (1.6% of the blade size), so the operating point drives most of the variation of the fields. Passing it through the node features, as MeshFiLM-S does, lowers the error of MeshFiLM-R by 34%, to 4.69×10⁻³, below Transolver (6.82) and Transolver++ (6.88) (Table 36).

On the AhmedML volume, the gap of MeshFiLM-S comes from the maximum statistic. A chunk holds 0.5% of the volume nodes, and the maximum over a random chunk underestimates the maximum over the mesh and varies between chunks of the same sample. Region summaries are ratios of sums and are estimated consistently, so MeshFiLM-R has the lowest error of all models of Table 1 on this setting.

The largest remaining gap of MeshFiLM-R, +9% on 2D_profile, closes with a second pooling round (W2 below). With the operating point in the node features on Rotor37 and two rounds on 2D_profile, MeshFiLM-R is at or below Transolver++ in all seven settings (one seed for these two new runs), while training 3.9–6× faster per epoch. The two causes also give simple rules for a new benchmark: sample-level inputs that drive the variation of the fields should enter through the encoder, and the maximum should be avoided when the context is a small random subset.

W2: more rounds of routed pooling.

This is the experiment we proposed at L447. After decoder block r, we apply routed pooling again to the current decoder features of all nodes, with a new write router, value map and read router for each round; the new routed read replaces the routed part of cjc_j for the following FiLM heads, while pp, the encoding of the sample-level inputs (W4), is kept. We tested two and three rounds on 2D_profile, where the position of the shock depends on the whole flow, and on 2D_MultiScHypEl, where the stresses concentrate near the holes.

Table G. 2D_profile, fields, RRMSE (×10⁻³). 1000 epochs with the learning rate decayed over these 1000 epochs, as for Transolver++; MeshFiLM rows: one seed. Table 1 reports 28.14 ± 0.22 for one round because its equal-epoch values are read at epoch 1000 of longer runs, before the learning rate has decayed; we will state this in App. E.

ModelMachPressureVxVyMacros/epoch
MeshFiLM-R, 1 round31.2418.3039.0220.7027.314.6
MeshFiLM-R, 2 rounds29.2116.7137.2319.7825.724.9
MeshFiLM-R, 3 rounds29.9118.1337.7519.8726.415.3
Transolver++ (Table 13, three seeds)29.1017.5436.0420.5325.80 ± 0.5229.7

Table H. 2D_MultiScHypEl, fields, 1000 epochs, RRMSE (×10⁻³); field groups are means over the listed fields (Table 12).

ModelMacroDisplacements (u1, u2)Stresses (P11, P12, P22, P21)psis/epoch
MeshFiLM-R, 1 round (three seeds)25.12 ± 0.039.6432.1827.812.8
MeshFiLM-R, 2 rounds (one seed)24.759.4631.6227.853.0
MeshFiLM-R, 3 rounds (one seed)24.639.6231.4427.493.3
MGN-Tree (three seeds)26.07 ± 0.4322.9525.4234.9643.0
Transolver (three seeds)26.02 ± 0.1812.0032.6327.6415.5

The gain comes with the second round and saturates after it. On 2D_profile, two rounds lower the error on every field and the macro error by 6% (27.31 → 25.72×10⁻³), to the level of Transolver++, for 7% more time per epoch; a third round brings no further gain. This supports the hypothesis of Sec. 4 that a single exchange limits the transonic case. On 2D_MultiScHypEl, the extra rounds lower the error by 1.5–2%, and MGN-Tree remains 19% lower on the stresses, so that gap is local and not caused by the single exchange. We will report this result in Sec. 4 in place of the hypothesis.

AuthorsOpenReview ↗

Response to Reviewer Qy5h (2/2)

W3: chunk size on AhmedML.

Part of this is already in the paper. For MeshFiLM-R trained with random context subsets, the error is flat from 32,768 to 131,072 context nodes and rises by 18% at 8,192 (Sec. 3.4, Fig. 5, Table 40). We now evaluate the checkpoints of Table 1, all trained with chunks of 131,072 nodes, with other chunk sizes at inference (Table I). For MeshFiLM, the chunk is also the context set.

Table I. AhmedML, macro RRMSE vs. inference chunk size, mean ± std over three seeds. The 131,072 column is the protocol of Table 1. Best per setting and chunk size in bold.

SettingModel32,76865,536131,072 (training size)262,144Δ 32,768 vs. 131,072
SurfaceTransolver++0.01070 ± 0.000190.01067 ± 0.000190.01066 ± 0.000190.01065 ± 0.00019+0.4%
SurfaceSMART0.01009 ± 0.001000.01009 ± 0.001010.01009 ± 0.001010.01008 ± 0.001020.0%
SurfaceMeshFiLM-S0.01103 ± 0.000070.01098 ± 0.000070.01097 ± 0.000080.01096 ± 0.00008+0.6%
SurfaceMeshFiLM-R0.01017 ± 0.000410.01005 ± 0.000420.00998 ± 0.000430.00995 ± 0.00044+2.0%
VolumeTransolver++0.01516 ± 0.000370.01512 ± 0.000370.01510 ± 0.000370.01509 ± 0.00037+0.4%
VolumeSMART0.01384 ± 0.001110.01384 ± 0.001120.01384 ± 0.001120.01384 ± 0.001120.0%
VolumeMeshFiLM-S0.03765 ± 0.001050.03712 ± 0.000940.03689 ± 0.000970.03687 ± 0.00100+2.1%
VolumeMeshFiLM-R0.01419 ± 0.000460.01406 ± 0.000470.01401 ± 0.000470.01398 ± 0.00047+1.3%

The sensitivity is small for every model. Dividing the chunk by four (32,768 nodes, i.e. 3% of the surface nodes or 0.12% of the volume nodes) raises the error of MeshFiLM-R by 2.0% (surface) and 1.3% (volume), of MeshFiLM-S by 0.6% and 2.1%, and of Transolver++ by 0.4%; doubling it changes no error by more than 0.3%. The ranking is stable: on the surface, MeshFiLM-R is the most accurate model from 65,536 nodes up and within 1% of SMART at 32,768; on the volume, it is within one standard deviation of SMART at every chunk size. As expected from the bias of the maximum, MeshFiLM-S is the most sensitive model on the volume. At 131,072 nodes, a volume sample takes 5.6 s with MeshFiLM-R, against 10.7 s with Transolver++ and 22.6 s with SMART.

W4: notation.

Thank you. The text after Eq. 3 describes the roles of these parameters only briefly, their dimensions appear only in Table 4, and wkcw^c_k, wkqw^q_k are not defined explicitly. We will add the following after Eq. 3, with a notation table in App. A.

  • zi∈RHz_i \in \mathbb{R}^H is the embedding of node ii, with H=256H = 256.
  • Each router has K=8K = 8 learned vectors: wkc∈RHw^c_k \in \mathbb{R}^H for writing and wkq∈RHw^q_k \in \mathbb{R}^H for reading, k=1,…,Kk = 1, \dots, K.
  • The write logit of node ii for region kk is (wkc⊤zi+bkc)/τc(w_k^{c\top} z_i + b^c_k) / \tau_c, with a learned bias bkcb^c_k, and a softmax over kk gives rikcr^c_{ik}. The read weights rjkqr^q_{jk} are obtained in the same way from wkqw^q_k, bkqb^q_k and τq\tau_q, with τc=τq=1\tau_c = \tau_q = 1.
  • V∈RC×HV \in \mathbb{R}^{C \times H}, with C=32C = 32, and a bias bV∈RCb_V \in \mathbb{R}^C project each embedding to a value Vzi+bV∈RCV z_i + b_V \in \mathbb{R}^C. The region summary tk∈RCt_k \in \mathbb{R}^C is the mean of these values weighted by rikcr^c_{ik} (Eq. 2).
  • p=P(sin)∈R128p = P(s_{\mathrm{in}}) \in \mathbb{R}^{128} encodes the sample-level scalar inputs sins_{\mathrm{in}} (e.g. the pressure and rotation speed of Rotor37) with a two-layer MLP PP; it is computed once per sample and is the same for every node (Sec. 2.1).
  • Node jj reads ∑krjkqtk∈RC\sum_k r^q_{jk} t_k \in \mathbb{R}^C, concatenated with pp, so cj∈RC+128c_j \in \mathbb{R}^{C+128} and dc=160d_c = 160 in Eq. 5.

Separate write and read vectors let a node read regions other than the one it is written to. The learned routers use this: some regions are read more than ten times as much as they are written (App. K, Fig. 4).

Reviewer_GxThOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces a neural surrogate architecture called MeshFiLM, which decodes fields using a learnable node- and context-specific modulation. The paper introduces a statistics-based modulation and a routing-based variant similar to physics attention. MeshFiLM is evaluated on the PLAID benchmark dataset and on the AhmedML dataset, where it outperforms a set of standard baselines.

Critical strengths
  • The paper addresses a relevant problem for neural surrogates.
  • The idea of node- and context-specific modulation is very intuitive. Especially the implementation using routed pooling is quite clever in my opinion.
  • Performance against standard baselines seems strong at a low compute cost and parameter count.
Critical weaknesses
  • I'm not fully convinced by the comparison to existing methods. Table 1 seems to contain self-reported values and for PLAID they seem to be different to the ones reported in the PLAID benchmark paper. Please correct me if I am wrong here. In Table 3 a public leaderboard for PLAID is included, but the scores achieved by the best entries are 2x lower than MeshFiLM in many cases. While the authors note that the training setup is not disclosed for submitted entries, it raises doubts whether the training setup used for training MeshFiLM and the baselines is optimized and results will carry over to more optimized setups.
  • Also in Table 2, RRMSE is reported for AhmedML. This is not the same as in some standard papers that include this benchmark, for example AB-UPT (https://arxiv.org/abs/2502.09692) which uses relative L2. Ideally, some recent strong benchmarks are included in the comparison, such as GeoTransolver (https://arxiv.org/pdf/2512.20399) or SMART (https://arxiv.org/abs/2601.18707).
  • I would expect a benchmark on some high-fidelity datasets that other neural surrogate architectures on unstructured meshes compare on, for example DrivaerML (https://arxiv.org/abs/2408.11969), to assess the scaling properties of MeshFiLM.
  • At times the text is a bit hard to read and doesn't feel polished and unnatural, for example in L447: "a variant with two pooling steps would test it".
  • The overall presentation and plots can be polished and improved further. Tables take up too much space and especially Table 2 is hard to parse and the takeaways from the ablation are not clearly presented.
Questions for authors
  • Can we combine statistics pooling and routed pooling for MeshFiLM?
  • Can you include the mentioned additional baselines and explain potential reasons why the leaderboard scores of PLAID are significantly better than MeshFiLM in some cases?
  • How does the method scale when applied to million-scale meshes like data from DrivAerML?
  • How does MeshFiLM scale when increasing or reducing the network size?
3 comments
AuthorsOpenReview ↗

Response to Reviewer GxTh (1/3)

We sincerely thank the reviewer for the positive assessment of node-wise modulation and of routed pooling. We answer the concerns in order.

W1/Q2: Table 1, the PLAID paper and the leaderboard.

Table 1 and the PLAID paper measure different quantities. The PLAID paper and the leaderboards report total_error, which averages the RRMSE of fields and scalars, whereas Table 1 reports the macro RRMSE of the fields, for models trained on fields only. We will make this explicit in Sec. 3.1.

As the reviewer notes, every number in Table 1 comes from our own runs. All models are trained in one code base, with the same node inputs, optimizer, precision and GPU, hyperparameters selected on validation, and three seeds. This is what lets us compare errors and training cost directly.

On the leaderboards, among the entries whose method is publicly described (Table 3), MeshFiLM has the lowest total error on three of the five benchmarks and the second lowest on the other two. The PLAID leaderboards are live: scores change as new entries arrive, and several teams submit models under the same architecture name without disclosing their features, training budgets, losses or ensembling. A gap between two entries therefore cannot be attributed to the architecture. On 2D_profile, for instance, the PhysicsX Transolver and Transolver+ entries differ by a factor of 1.5 (0.0134 vs. 0.0199). On Tensile2d, VKI-LS59 and Rotor37, the three entries ranked above MeshFiLM are such industrial submissions. Our own entry, a single run of 5000 epochs, matches the entries ranked 2nd and 3rd on all five Tensile2d fields; its higher total error comes from the scalars, mainly max_U2_top (Table A).

Table A. Tensile2d leaderboard (Table 28 of the paper).

EntryU1U2sig11sig22sig12max_U2_top
NPCo (rank 2)0.00020.00030.00130.00060.00090.0006
PhysicsX Transolver (rank 3)0.00020.00020.00120.00060.00090.0008
MeshFiLM (rank 4)0.00020.00030.00120.00060.00090.0022

On whether the results carry over to more optimized setups: trained for the wall-clock time that Transolver++ needs for its 1000 epochs, MeshFiLM-R runs about 5× more epochs, and its Tensile2d error halves, to 64% below Transolver++ (Table 1, equal time). Its standing relative to the strongest baseline improves on all four PLAID settings with equal-time runs, and the leaderboard entry above shows the same with per-benchmark settings. In addition, Table 1 is conservative for MeshFiLM at equal epochs (see Q4).

AuthorsOpenReview ↗

Response to Reviewer GxTh (2/3)

W2/Q2: relative L2 on AhmedML; GeoTransolver and SMART.

Relative L2 is already reported in App. F (Tables 14, 16, 19 and 21), together with RMSE and MAE; we will move it into Table 1.

We added SMART. We ran its official implementation with its AhmedML architecture under our AhmedML protocol: same split, optimizer settings and precision as the other models, 1000 epochs (against 200 in the SMART paper), evaluation on every node of the 125 test meshes, three seeds. As in its paper, SMART is mesh-free: it reads 65,536 points sampled on the body surface (positions only), the query coordinates and the 8 simulation parameters, and not the node features of the other models.

Table B. AhmedML, mean ± std over three seeds. Best per column in bold.

ModelRRMSE ×10⁻³, surfaceRRMSE ×10⁻³, volumeRel. L2 (%), surfaceRel. L2 (%), volumeParams (M)s/epoch (surf. / vol.)s per test sample (surf. / vol.)
Transolver11.85 ± 0.4216.76 ± 0.476.19 ± 0.236.64 ± 0.323.0550.1 / 50.80.36 / 8.4
Transolver++10.66 ± 0.1915.10 ± 0.375.59 ± 0.035.91 ± 0.162.7957.9 / 57.90.46 / 10.7
SMART (new)10.09 ± 1.0113.84 ± 1.125.03 ± 0.465.42 ± 0.528.74117.4 / 118.30.97 / 22.6
MeshFiLM-S10.97 ± 0.0836.89 ± 0.975.85 ± 0.0616.65 ± 0.220.6319.6 / 21.60.21 / 4.5
MeshFiLM-R9.98 ± 0.4314.01 ± 0.475.57 ± 0.115.84 ± 0.210.4529.2 / 25.90.24 / 5.6

MeshFiLM-R and SMART are the two most accurate models. In RRMSE, MeshFiLM-R has the lowest mean on the surface and SMART on the volume, within one standard deviation of each other; in relative L2, SMART is ahead (5.0 / 5.4% against 5.6 / 5.8%). SMART has 19× more parameters, is 4–4.6× slower per epoch and 4× slower per test sample, and its standard deviation over seeds is more than twice as large.

Absolute values are not comparable across papers. The SMART paper reports only the surface pressure and the three velocity components, on 16k sampled points, with 400 training samples: Transolver at 3.44 / 5.47% and SMART at 3.12 / 5.15%. On the same fields, our pipeline (337 training samples, every node evaluated) gives 5.32 / 6.95% for Transolver, 4.34 / 5.72% for SMART and 4.38 / 6.14% for MeshFiLM-R. Both baselines are higher than in the SMART paper, by 1.4–1.6× on the pressure and 1.1–1.3× on the velocity, so the difference comes mostly from the pipeline, not from weaker baselines.

GeoTransolver extends the Transolver backbone with cross-attention to multi-scale geometry and global context in every block, i.e. more exchange per layer, the opposite direction to our study. Since this backbone is represented in Table 1 by Transolver and Transolver++, we chose SMART, a mesh-free design, as the new baseline. We will discuss both works in Sec. 1.

W3/Q3: million-scale meshes and DrivAerML.

AhmedML shows that MeshFiLM can already predict every node of meshes with tens of millions of nodes (26.8M per volume mesh on average, 3.4×10⁹ test nodes in total), a prerequisite for DrivAerML-scale use. The cost of MeshFiLM is linear in the number of nodes, the exchange between nodes happens once, and query nodes are decoded in chunks, so memory is set by the chunk size and not by the mesh size. One volume sample takes 5.6 s with MeshFiLM-R, against 10.7 s with Transolver++ and 22.6 s with SMART. A model trained with random context subsets reaches the same accuracy with 32,768 context nodes as with 131,072 (Fig. 5), and accuracy changes little with the chunk size: dividing it by four raises the error of MeshFiLM-R by at most 2% (Table I, in our reply to Reviewer Qy5h). We did not train on DrivAerML, whose volume meshes have ≈160M cells: three seeds per model were not feasible within the discussion period. We will state this in the limitations.

AuthorsOpenReview ↗

Response to Reviewer GxTh (3/3)

Q1: combining statistics and routed pooling.

Yes, the two contexts can be concatenated before the FiLM head. We tested this in MeshFiLM-R, with all three statistics or with the mean and standard deviation only.

Notation. In MeshFiLM-R, node jj receives the context cj=[∑krjkqtk∥p]c_j = [\sum_k r^q_{jk} t_k \Vert p] (Eq. 3). Below, regions is this routed read of the KK region summaries tkt_k ([t1∥⋯∥tK][t_1 \Vert \cdots \Vert t_K] for the scalar head), statistics is G([mean∥max∥std])G([\mathrm{mean} \Vert \mathrm{max} \Vert \mathrm{std}]) of the node embeddings, the context of MeshFiLM-S (Eq. 1), and p∈R128p \in \mathbb{R}^{128} is the encoding, by a two-layer MLP, of the sample-level scalar inputs sins_{\mathrm{in}}: the pressure and five material parameters on Tensile2d, the operating point on Rotor37. MeshFiLM-S has no pp; it appends sins_{\mathrm{in}} to the node features fif_i (Sec. 2.1).

Table C. Tensile2d, fields and scalars trained jointly, 5000 epochs, one seed, RRMSE (×10⁻³). In the new rows, the scalar head also reads regions ‖ statistics ‖ p, as in Table 25, row 3 (0.66 / 3.98 / 1.91).

Context of the FiLM headFieldsScalarsAll 8 outputs
regions ‖ p (MeshFiLM-R, Table 25)0.673.981.91
statistics ‖ p (Table 25)0.723.121.62
regions ‖ statistics (mean, max, std) ‖ p (new)0.704.242.03
regions ‖ statistics (mean, std) ‖ p (new)0.865.072.44
MeshFiLM-S (Table 24)0.732.941.56

Table D. Rotor37, fields only, 1000 epochs, one seed unless stated, macro RRMSE (×10⁻³). In all rows but the first, the operating point (P, Ω) enters through the node features fif_i.

ModelMacro RRMSE
MeshFiLM-R, operating point through p (Table 36)7.10
MeshFiLM-R, operating point through fif_i (Table 36)4.69
regions ‖ statistics (mean, max, std) (new)6.16
regions ‖ statistics (mean, std) (new)5.60
MeshFiLM-S (Table 1, three seeds)2.79 ± 0.12
Transolver (Table 1, three seeds)6.82 ± 0.11

The combination does not combine the strengths of the two operators. On Tensile2d, it keeps the field error of MeshFiLM-R but not the scalar error of statistics pooling (4.24 vs. 3.12), and removing the maximum makes the scalars worse (5.07), consistent with these scalars being maxima. On Rotor37, adding the statistics to the routed context raises the error (5.60–6.16 vs. 4.69), which confirms that the operator is not what separates the two variants on this dataset (Sec. 3.3). We therefore keep the two variants separate and choose the operator per benchmark on validation, as for our leaderboard entries.

Q4: network size.

We varied the width H and the depth L of MeshFiLM-R one at a time (Table 33 of the paper reports the depth of MeshFiLM-S). Every configuration is more accurate than Transolver++ and trains 3.6–8× faster per epoch; all but the widest (H = 512) also have fewer parameters.

Table E. Tensile2d, fields only, one seed. Every row is trained for 1000 epochs with the learning rate decayed over these 1000 epochs, as for the baselines of Table 1.

HLParams (M)s/epochMacro RRMSE (×10⁻³)
6430.081.81.32
12830.172.11.00
2563 (default)0.472.80.89
51231.564.10.82
25620.372.50.93
25650.663.40.85
Transolver++ (Table 1, three seeds)128, 4 blocks0.7314.61.87 ± 0.03

Width is the main lever: from H = 64 to H = 512, the error falls from 1.32 to 0.82×10⁻³ while an epoch goes from 1.8 to 4.1 s. Depth matters less (0.85–0.93 for L = 2 to 5). Even H = 64, with 9× fewer parameters than Transolver++, has a 29% lower error.

The default reaches 0.89×10⁻³ here, against 1.36 ± 0.04 in Table 1. On the four PLAID datasets with equal-time runs, the equal-epoch values of MeshFiLM in Table 1 are read at epoch 1000 of the equal-time runs, whose cosine schedule spans about 5000 epochs, so the learning rate has barely decayed at that point. The baselines, and the runs of Table E, decay it over 1000 epochs. Table 1 is therefore conservative for MeshFiLM at equal epochs, and its conclusions are unchanged. We will state this protocol in App. E.

W4/W5: writing and presentation.

We agree. In the revision, we will replace the sentence at L447 by the result of the experiment it proposed (a second pooling round brings MeshFiLM-R to the level of Transolver++ on 2D_profile; reply to Reviewer Qy5h, W2), rewrite Table 2 with one row per question and a takeaway column, add a notation table, round the parameter counts of Table 1, and proofread the text.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.