Pith. sign in

REVIEW 2 major objections 4 minor 34 references

General Field Evaluation in High-Order Meshes on GPUs

T0 review · 2 major / 4 minor · reviewed 2026-08-10 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims a robust technique for evaluating any field at arbitrary points in large-scale high-order quadrilateral and hexahedral meshes, including meshes split across MPI ranks and meshes that lie on surfaces, with per-point cost…

desk verdict Solid engineering paper: GPU kernels and surface-mesh support are genuinely new, but the robustness claim leans on an unproven bounding-box construction that deserves either a proof or an explicit scope. read the letter →

arxiv 2501.12349 v1 pith:XY52A3FH submitted 2025-01-21 cs.MS cs.CE

Ketan Mittal , Aditya Parik , Som Dutta , Paul Fischer , Tzanio Kolev , James Lottes This is my paper · ORCID
classification cs.MScs.CE MSC 65D0565N3065Y05
keywords high-ordermeshesgeneralfieldevaluationpointlocationGPUsfiniteelementmethodspectralLagrangianparticletrackingboundingboxes
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims a robust, efficient way to evaluate a finite-element or spectral-element solution at arbitrary physical points in high-order quadrilateral and hexahedral meshes, including meshes split across MPI ranks and meshes that are curved or lie on surfaces. The method first narrows each query point to a short list of candidate elements using two Cartesian-aligned maps, one global and one per processor, then filters with bounding boxes, and finally inverts the element map by a Newton iteration with a trust region to get the reference-space coordinates. If it works as claimed, any point in a valid mesh is located and the solution interpolated at machine precision, with per-point cost nearly independent of mesh size, and the same machinery serves particle tracking, mesh-to-mesh transfer during r-adaptivity, and overlapping-grid coupling. The paper also documents GPU kernels that make the search and interpolation steps an order of magnitude faster than the previous CPU implementation on large point sets.

What carries the argument

Four components carry the argument. Two Cartesian-aligned search structures map a point to candidate ranks and candidate elements: a global mesh $M_G$ partitioned across MPI ranks yields the multi-valued map $\Psi_G$, and a processor-local mesh $M_L$ yields $\Psi_L$. Candidate elements are then filtered by two bounding boxes per element: an axis-aligned box computed from piecewise-linear envelope bounds on the Lagrange bases via Chebyshev interval points, and a tighter oriented box aligned by the center Jacobian. For the final inversion, a Newton method with trust-region factor $\alpha$ minimizes the distance functional $0.5\|x^* - x(r)\|_2^2$ with the step constrained to the reference element, using the exact Hessian (second-derivative terms) only when the iterate is on the element boundary. The GPU implementation gives one thread block per query point with $N\cdot D$ threads, exploiting the tensor-product basis structure.

What would settle it

Take an element of degree p=30 or higher, set the coordinate map to a single high-order Lagrange basis function with a large coefficient, compute the bound from Eqs. (7)-(9), and compare against the element's true image obtained by dense sampling; if the bound is below any true coordinate value, that element will be missing from the candidate list and a query point at that location will return NOT FOUND.

Watch

Extended reading notes

Core claim

The central claim is that general field evaluation—finding which element of a high-order mesh contains a given physical point and what the reference-space coordinates are—can be made robust and fast at scale by layering cheap filters around a local Newton solve. A globally partitioned Cartesian map returns candidate MPI ranks in $O(1)$, a processor-local map returns candidate elements, axis-aligned and oriented bounding boxes cut that list further, and a trust-region Newton method inverts the element's nonlinear map to tolerance $10^{-10}$. The paper demonstrates this on meshes with up to tens of thousands of elements and hundreds of millions of query points, on both volumes and surfaces, and shows the point-finding cost scaling linearly with the number of points while remaining nearly independent of total mesh size. It further claims that the setup cost is paid once per mesh and reused across point sets and multiple solution fields.

Load-bearing premise

The whole pipeline assumes the axis-aligned bounding boxes never shrink below an element's true extent; the authors verify this only by experiment for polynomial orders up to 29, not by proof, so a hidden under-estimate could silently drop the element that contains a query point.

Editorial extensions

If this is right

  • Queries that previously required a global rendezvous or k-nearest-node heuristics can now be answered by point location and interpolation at machine precision, so spectrally accurate values are available at arbitrary monitor points or particle positions.
  • After a one-time setup, any number of point sets and any number of solution fields on the same mesh reuse the same maps and bounding boxes, making the per-query cost nearly independent of mesh size.
  • Surface meshes are supported through a zero-extent-aware AABB, a rotation-based oriented box, and a distance threshold in the interior test, enabling closest-point projection and tangential relaxation along curved boundaries.
  • On GPUs the find and interpolate steps scale linearly in the number of points; in the reported turbulent channel run, particle tracking costs match the fluid solve when there are about 0.23 particles per computational point, with find and interpolate accounting for roughly 95% of the particle time.
  • The trust-region Newton inversion converges in about five iterations per point even for a 9th-order spiral element, yielding machine-precision field values.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Because the robustness of the bounding boxes is the only unproven link, a formal proof for arbitrary polynomial orders would remove the last empirical assumption; the authors list this as future work.
  • The same filter cascade could be applied to meshes with simplices or mixed element types if the tensor-product GPU kernels are replaced by simplex-specific basis evaluation, since the Cartesian maps and bounding boxes are element-type agnostic.
  • The near mesh-size-independence of per-point cost suggests the method could be used for in-situ visualization, feature extraction, or data reduction on exascale outputs, where query points are far fewer than the mesh's degrees of freedom.
  • If the oriented box were aligned using a global optimization instead of the center Jacobian, candidate lists on strongly deformed meshes would likely shrink further, improving the Find step's constant factor.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 4 minor

Summary. The paper describes a complete pipeline, implemented in the open-source findpts/gslib, MFEM, and NekRS codes, for evaluating finite/spectral element fields at arbitrary points in high-order quadrilateral and hexahedral meshes and on surface meshes. The method builds global and processor-local Cartesian bin maps from element axis-aligned bounding boxes, refines the candidate list with oriented bounding boxes, inverts the element map with a trust-region Newton method, and evaluates the solution with tensor-product interpolation. Specialized GPU kernels are described and benchmarked. The paper reports that the find step is up to 12.7x faster on GPUs than on CPUs and demonstrates the method on r-adaptivity, overlapping grids, and Lagrangian particle tracking.

Significance. The contribution is significant for the spectral-element and high-order FEM communities. The method is open source, the algorithmic description is detailed enough to be reproduced, and the numerical experiments evaluate interpolation against known functions rather than against the method's own output. The reported GPU speedups are substantial and measured at realistic scales. The principal weakness is that the element bounding boxes, which are the gatekeeper for all candidate searches, rely on an empirically verified but unproven bound on Lagrange bases, so the advertised robustness guarantee is conditional on that empirical evidence.

major comments (2)
  1. [Section 3.1.1, Eqs. (7)-(9); Section 7] The AABB construction is load-bearing for both candidate maps Psi_L and Psi_G and for the subsequent OBB construction: if an element's AABB is too small, the element is absent from the candidate list and a point inside it is permanently NOT FOUND; the Newton iteration cannot recover it. The paper states in footnote 5 that the piecewise-linear basis bounds are only empirically verified for Lagrange bases at GLL points with M=2N up to N<=30, and Section 7 lists 'theoretically provable bounds' as future work. This leaves the central robustness claim of the abstract unproven in the general high-order regime the paper promises. Please either provide a proof, restrict the robustness claim to the verified range and state that restriction in the abstract, or add a fallback mechanism (e.g., detection of under-bounds and iterative local refinement of the Cartesian maps) that restores completeness.
  2. [Section 3.1.1, text after Eq. (9)] The statement that the interval-bounding approach 'is guaranteed to work for a function that is strictly convex/concave in each interval' is correct only for such functions; Lagrange interpolants are not generally convex/concave on Chebyshev intervals, as the following sentence implicitly concedes with 'predominantly convex/concave.' The manuscript should distinguish the proven guarantee from the empirical validation that follows, and should state explicitly that no guarantee is currently claimed for N>30 or for nodal sets other than GLL.
minor comments (4)
  1. [Figure 8 and Section 3.1.3] The caption of Figure 8 describes the left panel as intersecting '8 elements,' while the text in Section 3.1.3 says '6 elements' for the same example; please reconcile the numbers.
  2. [Section 3.2.1, Eq. (22)] The underbrace on H^{-1}J is labeled Delta r_l and the constraint reads Delta r_l in alpha_l[-1,1]^D, but the update is r_{l+1} = r_l - H^{-1}J; as written it is ambiguous whether the trust-region factor applies to the negative step or to the labeled quantity. Please fix the notation.
  3. [References [10] and [22]; Section 6.7] References [10] and [22] contain a duplicated 'https://' in their URLs, and Section 6.7 contains the typos 'noder' and 'independednt'; please correct these errors.
  4. [Section 4.4] The threshold epsilon_d for the INTERIOR criterion on surface meshes is defined only through examples ('epsilon_d = 10^{-10}' or 'epsilon_d = 10^{-10}|Omega_e*|'); please state the default value actually used in the numerical experiments.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the derivation is self-contained, and the main limitation (empirically verified AABB bounds) is an unsupported robustness assumption rather than a circular step.

full rationale

The paper's central claim is an algorithmic method: given a mesh and a query point, construct Cartesian maps from geometry-derived bounding boxes, reduce candidates, and invert the element map with trust-region Newton iteration. None of these stages is defined in terms of the target output, and no parameter is fitted to the points being located. Accuracy is benchmarked against known functions (Sections 6.1, 6.2), providing an external check on the interpolation result. Citations to gslib [10], NekRS [21], MFEM [19], and the authors' prior overlapping-grid work [5] are provenance and application references; no load-bearing uniqueness theorem or ansatz is imported from those self-citations. The only notable weakness is in Section 3.1.1: the piecewise-linear basis bounds of Eqs. (7)-(9) are justified by empirical verification up to N<=30 (footnote 5: 'we have empirically verified that the proposed approach works with M = 2N points for at-least N<=30'), and Section 7 explicitly defers 'theoretically provable bounds' to future work. That is a genuine correctness/robustness gap, since an under-bound could silently drop the true containing element from the candidate list, but it is not a circularity: the bounds are not fitted to the test points, nor do they encode the interpolation output. Accordingly, the paper does not exhibit any self-definitional reduction, fitted-input-called-prediction pattern, or self-citation chain that forces its conclusion.

Assumptions & free parameters 6 free parameters · 3 assumptions · 0 invented entities

The method relies on user-set resolutions and tolerances (M, NL, NG, expansions) and on an empirically verified bounding claim. There are no invented physical entities.

free parameters (6)
  • M (Chebyshev interval points for bounding) = 2N by default
    Controls tightness of piecewise linear bounds in AABB computation; chosen by default as 2N, increasing tightness and cost.
  • NL (local Cartesian mesh resolution) = based on mesh size (default)
    Resolution of the process-local map; trades memory/cost against candidate-list length, set by user or default heuristic.
  • NG (global Cartesian mesh resolution) = based on mesh size (default)
    Resolution of the global map from points to candidate MPI ranks; similar trade-off to NL.
  • Bounding box expansion factor = 10% (default); 100% for tangential relaxation
    Expands AABB/OBB by a nominal percentage to avoid floating-point false negatives for points on box boundaries.
  • Surface INTERIOR threshold epsilon_d = 1e-10 or 1e-10 |Omega_e|
    Distance threshold used to set c*=INTERIOR for surface meshes; user-specified tolerance.
  • Newton tolerance and max iterations = 1e-10, 50
    Convergence tolerance and iteration cap for the trust-region Newton solve; typical values, not tuned to specific data.
assumptions (3)
  • domain assumption Mesh elements are images of [-1,1]^d under polynomial maps with nonsingular Jacobian at least at the element center.
    Section 3.1.2 uses J(r=0) to define the OBB orientation; a singular or inverted Jacobian would break the transformation in Eq. (20).
  • ad hoc to paper The piecewise-linear bounding construction in Eqs. (7)-(9) is conservative for Lagrange bases at GLL points with M=2N for N<=30.
    Section 3.1.1 and footnote 5: verified empirically, not proven; used to build AABBs that must never produce false negatives.
  • domain assumption Newton's method with trust region, with at most 50 iterations, converges to the closest point on the element boundary for points inside the bounding boxes.
    Section 3.2.1: no convergence proof is given; relies on smoothness of the polynomial map and trust-region safeguards.

how reviews work

0 comments
Cite this review

Pith. "Pith review of General Field Evaluation in High-Order Meshes on GPUs." pith.science (2026). https://pith.science/paper/XY52A3FH

@misc{pith2026250112349,
  author       = {Pith},
  title        = {Pith review of: General Field Evaluation in High-Order Meshes on GPUs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XY52A3FH}},
  note         = {Machine review of arXiv:2501.12349}
}
read the original abstract

Robust and scalable function evaluation at any arbitrary point in the finite/spectral element mesh is required for querying the partial differential equation solution at points of interest, comparison of solution between different meshes, and Lagrangian particle tracking. This is a challenging problem, particularly for high-order unstructured meshes partitioned in parallel with MPI, as it requires identifying the element that overlaps a given point and computing the corresponding reference space coordinates. We present a robust and efficient technique for general field evaluation in large-scale high-order meshes with quadrilaterals and hexahedra. In the proposed method, a combination of globally partitioned and processor-local maps are used to first determine a list of candidate MPI ranks, and then locally candidate elements that could contain a given point. Next, element-wise bounding boxes further reduce the list of candidate elements. Finally, Newton's method with trust region is used to determine the overlapping element and corresponding reference space coordinates. Since GPU-based architectures have become popular for accelerating computational analyses using meshes with tensor-product elements, specialized kernels have been developed to utilize the proposed methodology on GPUs. The method is also extended to enable general field evaluation on surface meshes. The paper concludes by demonstrating the use of proposed method in various applications ranging from mesh-to-mesh transfer during r-adaptivity to Lagrangian particle tracking.

Figures

Figures reproduced from arXiv: 2501.12349 by the authors.

Figure 1
Figure 1. Schematic showing a finite element (p = 3) mapped from the reference space to physical space. geometry of the physical element Ωe : x(r)|Ωe = Φe(r) ≡ N X d i=1 x e i ϕi(r), r ∈ Ω¯ e , x = x(r) ∈ Ω e , (1) where x e i denotes the coordinates of the i-th node of Ωe . Hereafter, x(r) will denote the element-wise position function defined by (1) with Ωe omitted for brevity [PITH_FULL_IMAGE:figures/full_fig_p007_1.png] view at source ↗
Figure 2
Figure 2. Key ingredients used to determine candidate elements that overlap a given point [PITH_FULL_IMAGE:figures/full_fig_p010_2.png] view at source ↗
Figure 3
Figure 3. (a) ϕi(r), i = 1...4, Lagrange interpolants. (b) Cubic 1D function u(r) with nodal coeffi￾cients ui = {−2.4,0.8,1.4,−1} in (5). Then, using subscripts ()i j to represent quantities associated with the ith basis function and the jth interval point, superscript ()′ to represent the derivative of the basis function, and j + and j − to represent the midpoint between the jth in￾terval point and the interval point to its … view at source ↗
Figures from the paper (14 more)
Figure 4
Figure 4. Figure 4: Lagrange interpolants ϕi(r), i = 1...4 at GLL points (•) along with the piecewise linear bounds constructed with M = 8 Chebyshev interval points (x). (a) ϕ1(r), (b) ϕ2(r), (c) ϕ3(r), and (d) ϕ4(r). We further compact these bounds by rewriting u(r) = X N i=1 uiϕi(r) = a…
Figure 5
Figure 5. Figure 5: Piecewise linear bounds on u(r) constructed using (a) M = 6, (b) M = 8, and (c) M = 12 Chebyshev interval points. Higher number of interval points lead to tighter bounds around u(r). Here, Pl(r) represents the lth Legendre polynomial, and the Legendre expansion ensures…
Figure 6
Figure 6. Figure 6: Axis-aligned bounding box and oriented bounding box around a unit-sized cubic element [PITH_FULL_IMAGE:figures/full_fig_p017_6.png]
Figure 7
Figure 7. Figure 7: Jacobian of the transformations used to compute the oriented bounding box around an [PITH_FULL_IMAGE:figures/full_fig_p019_7.png]
Figure 8
Figure 8. Figure 8: Axis-aligned bounding box of one of the elements of [PITH_FULL_IMAGE:figures/full_fig_p021_8.png]
Figure 9
Figure 9. Figure 9: (a) Quartic surface mesh (solid black) extracted from a mesh for analyzing fluid flow [PITH_FULL_IMAGE:figures/full_fig_p028_9.png]
Figure 10
Figure 10. Figure 10: (left) 9th-order spiral element and (right) time to find and interpolate a known function [PITH_FULL_IMAGE:figures/full_fig_p034_10.png]
Figure 11
Figure 11. Figure 11: (left) Cubic mesh (NE = 1024) for the triple-point problem that is oct-refined to obtain a mesh with NE = 65,536 elements. (right) Time to find and evaluate a known function at Npt = 103 to 108 points on CPUs versus GPUs. We observe that for low number of points (e.g.…
Figure 12
Figure 12. Figure 12: (left) Cubic surface mesh and (right) time to find and interpolate a known function at [PITH_FULL_IMAGE:figures/full_fig_p036_12.png]
Figure 13
Figure 13. Figure 13: (left) Solution mimicing a sharp circular wave front ( [PITH_FULL_IMAGE:figures/full_fig_p038_13.png]
Figure 14
Figure 14. Figure 14: (left) Target mesh size computed using the gradient of the solution on the original mesh. [PITH_FULL_IMAGE:figures/full_fig_p038_14.png]
Figure 15
Figure 15. Figure 15: (a) A deformed quadratic mesh with the boundaries for tangential relaxation highlighted [PITH_FULL_IMAGE:figures/full_fig_p039_15.png]
Figure 16
Figure 16. Figure 16: (left) Domain Ω ∈ [0,1]2 modeled using three overlapping meshes. (right) The solution to the Poisson problem −∇2u = 1 is obtained on the overlapping grids using a predictor-corrector scheme following [32]. error at the boundary (Section 2.3 of [5]). This interdomain b…
Figure 17
Figure 17. Figure 17: (left) Flow and particle setup for the test case. (right) Solve times for the most expensive [PITH_FULL_IMAGE:figures/full_fig_p043_17.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

34 extracted references · 33 canonical work pages

  1. [1]

    S. J. Plimpton, B. Hendrickson, J. R. Stewart, A parallel rendezvous algo- rithm for interpolation between multiple grids, Journal of Parallel and Dis- tributed Computing 64 (2) (2004) 266–276. 3

    work page 2004

  2. [2]

    A. M. Herring, C. R. Ferenbaugh, C. M. Malone, D. W. Shevitz, E. Kikin- zon, G. A. Dilts, H. N. Rakotoarivelo, J. Velechovsky, K. Lipnikov, N. Ray, et al., Portage: A modular data remap library for multiphysics applications on advanced architectures, Journal of Open Research Software 9 (LA-UR- 20-24654) (2021). 3

    work page 2021

  3. [3]

    N. Ray, D. Shevitz, Y . Li, R. Garimella, A. Herring, E. Kikinzon, K. Lip- nikov, H. Rakotoarivelo, J. Velechovsky, E fficient kd-tree based mesh redistribution for data remapping algorithms, in: International Meshing Roundtable, Springer, 2023, pp. 25–41. 3

    work page 2023

  4. [4]

    Slattery, P

    S. Slattery, P. Wilson, R. Pawlowski, The data transfer kit: A geometric rendezvous-based tool for multiphysics data transfer, in: International con- ference on mathematics & computational methods applied to nuclear science & engineering (M&C 2013), 2013, pp. 5–9. 3

    work page 2013

  5. [5]

    Mittal, S

    K. Mittal, S. Dutta, P. Fischer, Nonconforming schwarz-spectral element methods for incompressible flow, Computers & Fluids 191 (2019) 104237. 4, 5, 40, 41 47

    work page 2019

  6. [6]

    Aparicio-Estrems, A

    G. Aparicio-Estrems, A. Gargallo-Peir ´o, X. Roca, Defining a stretching and alignment aware quality measure for linear and curved 2D meshes, Springer International Publishing, 2019, pp. 37–55. 4

    work page 2019

  7. [7]

    Lipnikov, M

    K. Lipnikov, M. Shashkov, Conservative high-order data transfer method on generalized polygonal meshes, Journal of Computational Physics 474 (2023) 111822. 4

    work page 2023

  8. [8]

    Lacroix, S

    M. Lacroix, S. F ´evrier, E. Fern´andez, L. Papeleux, R. Boman, J.-P. Ponthot, A comparative study of interpolation algorithms on non-matching meshes for pfem-fem fluid-structure interactions, Computers & Mathematics with Applications 155 (2024) 51–65. 4

    work page 2024

Show all 34 references
  1. [9]

    D. D. Chandar, On overset interpolation strategies and conservation on unstructured grids in openfoam, Computer Physics Communications 239 (2019) 72–83. 4

    2019

  2. [10]

    GSLIB, https://https://github.com/Nek5000/gslib. 5, 32

  3. [11]

    Dutta, P

    S. Dutta, P. Fischer, M. H. Garcia, Large eddy simulation (les) of flow and bedload transport at an idealized 90-degree diversion: Insight into bulle- effect, in: Proc., Int. Conf. on Fluvial Hydraulics, CRC, Boca Raton, FL, 2016, pp. 101–109. 5, 41

    2016

  4. [12]

    Zwick, S

    D. Zwick, S. Balachandar, A scalable euler–lagrange approach for multi- phase flow simulation on spectral elements, The International Journal of High Performance Computing Applications 34 (3) (2020) 316–339. 5, 41 48

    2020

  5. [13]

    Fabregat, F

    A. Fabregat, F. Gisbert, A. Vernet, J. A. Ferr´e, K. Mittal, S. Dutta, J. Pallar`es, Direct numerical simulation of turbulent dispersion of evaporative aerosol clouds produced by an intense expiratory event, Physics of Fluids 33 (3) (2021). 5, 41

    2021

  6. [14]

    Y . Yang, S. Balachandar, A scalable parallel algorithm for direct-forcing im- mersed boundary method for multiphase flow simulation on spectral ele- ments, The Journal of Supercomputing 77 (2021) 2897–2927. 5

    2021

  7. [15]

    Min, Y .-H

    M. Min, Y .-H. Lan, P. Fischer, E. Merzari, T. Nguyen, H. Yuan, P. Shriwise, S. Kerkemeier, A. Davis, A. Dubas, et al., Exascale simulations of fusion and fission systems, arXiv preprint arXiv:2409.19119 (2024). 5

    2024 arXiv

  8. [16]

    Dutta, M

    S. Dutta, M. W. V . Moer, P. Fischer, M. H. Garcia, Visualization of the bulle- effect at river bifurcations, in: Proceedings of the practice and experience on advanced research computing, 2018, pp. 1–4. 5, 41

    2018

  9. [17]

    Mittal, S

    K. Mittal, S. Dutta, P. Fischer, Direct numerical simulation of rotating el- lipsoidal particles using moving nonconforming schwarz-spectral element method, Computers & Fluids 205 (2020) 104556. 5, 41

    2020

  10. [18]

    MFEM, https://github.com/mfem/mfem/. 5, 32

  11. [19]

    Andrej, N

    J. Andrej, N. Atallah, J.-P. B¨acker, J. Camier, D. Copeland, V . Dobrev, Y . Du- douit, T. Duswald, B. Keith, D. Kim, et al., High-performance finite elements with MFEM, arXiv preprint arXiv:2402.15940 (2024). 5, 6, 31 49

    2024 arXiv

  12. [20]

    Lindquist, P

    N. Lindquist, P. Fischer, M. Min, Scalable interpolation on gpus for thermal fluids applications, Tech. rep., Argonne National Lab.(ANL), Argonne, IL (United States) (2021). 5

    2021

  13. [21]

    Fischer, S

    P. Fischer, S. Kerkemeier, M. Min, Y .-H. Lan, M. Phillips, T. Rathnayake, E. Merzari, A. Tomboulides, A. Karakus, N. Chalmers, et al., Nekrs, a gpu- accelerated spectral element navier–stokes solver, Parallel Computing 114 (2022) 102982. 5, 31, 32

    2022

  14. [22]

    NekRS, https://https://github.com/Nek5000/nekrs. 5, 32

  15. [23]

    Anderson, J

    R. Anderson, J. Andrej, A. Barker, J. Bramwell, J.-S. Camier, J. Cerveny, V . A. Dobrev, Y . Dudouit, A. Fisher, T. V . Kolev, W. Pazner, M. Stowell, V . Z. Tomov, I. Akkerman, J. Dahm, D. Medina, S. Zampini, MFEM: a modular finite elements methods library, Comput. Math. Appl....

    2021 doi

  16. [24]

    M. O. Deville, P. F. Fischer, E. H. Mund, High-order methods for incom- pressible fluid flow, V ol. 9, Cambridge university press, 2002. 7, 16

    2002

  17. [25]

    Nov ´ak, C

    J. Nov ´ak, C. Dachsbacher, Rasterized bounding volume hierarchies, in: Computer Graphics Forum, V ol. 31, Wiley Online Library, 2012, pp. 403–

    2012

  18. [26]

    V . A. Dobrev, P. Knupp, T. V . Kolev, K. Mittal, R. N. Rieben, V . Z. Tomov, Simulation-driven optimization of high-order meshes in ALE hydrodynam- ics, Comput. Fluids (2020). 37 50

    2020

  19. [27]

    V . A. Dobrev, P. Knupp, T. V . Kolev, K. Mittal, V . Z. Tomov, The Target- Matrix Optimization Paradigm for high-order meshes, SIAM J. Sci. Comp. 41 (1) (2019) B50–B68. 37, 39

    2019

  20. [28]

    Mittal, P

    K. Mittal, P. Fischer, Mesh smoothing for the spectral element method, Jour- nal of Scientific Computing 78 (2) (2019) 1152–1173. 39

    2019

  21. [29]

    Dobrev, T

    V . Dobrev, T. Kolev, R. Rieben, High-order curvilinear finite element meth- ods for Lagrangian hydrodynamics, SIAM J. Sci. Comp. 34 (5) (2012) 606–

    2012

  22. [30]

    Mittal, S

    K. Mittal, S. Dutta, P. Fischer, Multirate timestepping for the incompress- ible Navier-Stokes equations in overlapping grids, Journal of Computational Physics 437 (2021) 110335. 41

    2021

  23. [31]

    Lloyd, K

    C. Lloyd, K. Mittal, S. Dutta, R. Dorrell, J. Peakall, G. Keevil, A. Burns, Multi-fidelity modelling of shark skin denticle flows: insights into drag gen- eration mechanisms, Royal Society Open Science 10 (2) (2023) 220684. 41

    2023

  24. [32]

    Mittal, Highly scalable solution of incompressible Navier-Stokes equa- tions using the spectral element method with overlapping grids, Ph.D

    K. Mittal, Highly scalable solution of incompressible Navier-Stokes equa- tions using the spectral element method with overlapping grids, Ph.D. thesis, University of Illinois at Urbana-Champaign (2019). 41

    2019

  25. [33]

    Dutta, Bulle-e ffect and its implications for morphodynamics of river di- versions, Ph.D

    S. Dutta, Bulle-e ffect and its implications for morphodynamics of river di- versions, Ph.D. thesis, University of Illinois at Urbana-Champaign (2017). 41 51

    2017

  26. [34]

    NekRS Example: Wall-resolved LES of turbulent channel flow, https:// github.com/Nek5000/nekRS/tree/master/examples/turbChannel. 42 52

Pith tools

Reviewed August 10, 2026 · model on record in the stance chip above.