Pith. sign in

REVIEW 5 major objections 5 minor 44 references

JANC: A cost-effective, differentiable compressible reacting flow solver featured with JAX-based adaptive mesh refinement

T0 review · 5 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read A JAX-based combustion solver with adaptive mesh refinement reduces detonation simulation cost to about 1 percent of OpenFOAM's, while keeping the entire numerical trajectory differentiable for machine learning.

desk verdict A genuinely new, open-source differentiable combustion solver with JIT-friendly block AMR, but the headline 1-2% cost claim rests on an apples-to-oranges benchmark and some arithmetic slips. read the letter →

arxiv 2504.13750 v1 pith:ZK5JTGIH submitted 2025-04-18 physics.flu-dyn

Haocheng Wen , Faxuan Luo , Sheng Xu , Bing Wang This is my paper · ORCID
classification physics.flu-dyn
keywords JAXadaptivemeshrefinementopensourcecompressiblereactiveflowcombustioncomputationalfluiddynamicsautomaticdifferentiationGPUacceleration
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 sets out to show that a combustion solver built entirely in JAX, with a block-structured adaptive mesh refinement that is compatible with JIT compilation, can be both dramatically cheaper to run and fully differentiable. The authors claim that in a two-dimensional detonation tube benchmark, the core solver on one A100 GPU costs 1 percent as much per million simulation steps as OpenFOAM running on 384 CPU cores, and that with AMR the cost drops to 1.2-2.1 percent. They further demonstrate an adjoint-based inverse problem in a rotating detonation combustor that converges to the correct injection equivalence ratio in minutes, where default automatic differentiation runs out of memory. If these claims hold, differentiable, GPU-native combustion simulation becomes practical for machine-learning-driven design and inverse modeling.

What carries the argument

The load-bearing mechanism is JAX-AMR, a block-structured adaptive mesh refinement scheme in which every refinement layer is a fixed collection of same-shaped JAX arrays with a predeclared maximum block count; refinement is implemented by masked-grid selection, buffer extension, and interpolation between layers, while JIT compatibility is preserved by never changing array shapes at compile time. Invalid blocks are padded, a NAN block marks missing neighbors, and the maximum block count is updated only at irregular intervals, so the solver runs as a single compiled XLA program while the mesh still adapts. The other core mechanism is the point-implicit chemical source update combined with the adjoint method imported from neural ODE work, which makes the entire time trajectory differentiable without storing all intermediate states.

What would settle it

Run both solvers on the detonation tube to the same physical end time, for example t = 10 microseconds, with accuracy-matched refinement, and record total wall-clock time and total monetary cost; if OpenFOAM reaches that physical time with no greater total cost, or if JANC requires substantially more steps because of its smaller time step, the 1 percent claim would not hold. A second check: if standard JAX automatic differentiation can compute the rotating detonation gradient on a 40 GB A100 within memory using gradient checkpointing, then the claimed need for adjoint optimization weakens.

Watch

Extended reading notes

Core claim

The central discovery is that the obstacle to JAX-based AMR, namely that JIT compilation requires static array shapes while adaptive meshes change shape, can be removed by a multi-layer block structure with fixed block positions, fixed block shapes, and a predeclared maximum block count per layer, with invalid blocks padded and a dynamically updated block-count strategy to limit overhead. On top of this JAX-AMR framework, the paper builds JANC, a two-dimensional compressible reacting Euler solver with WENO5 reconstruction, Lax-Friedrichs flux splitting, TVD-RK3 time stepping, point-implicit chemical source advancement, and Cantera-supplied thermodynamics. In the benchmark detonation tube, JANC reaches 5.0 steps per second on one A100 GPU versus 0.5 steps per second for OpenFOAM on 384 AMD CPU cores, giving a cost per million steps of $13.30 versus $1344; with AMR the comparable figures are $12.00 versus $555.80 for synchronous advance and $6.70 for the recommended crossover advance. The paper also claims that replacing JAX's default reverse-mode differentiation with adjoint optimization makes a 400,000-grid, 100-step rotating detonation inverse problem solvable at 1.2 optimizer iterations per second, whereas standard automatic differentiation fails with an out-of-memory error.

Load-bearing premise

The load-bearing premise is that the OpenFOAM comparison is a fair baseline: it assumes the same physical simulation is being compared, that cloud rental prices represent real costs, and that OpenFOAM's step count and numerical choices do not distort the cost-per-million-steps metric.

Editorial extensions

If this is right

  • High-resolution detonation and combustion simulations could run on a single GPU at a cost roughly two orders of magnitude below a 384-core CPU cluster, making high-fidelity combustion studies accessible to groups without large HPC allocations.
  • Because the whole solver, including the time-advance loop, is differentiable through adjoint optimization, inverse problems such as inferring inlet conditions from flow snapshots can be solved with gradient-based optimizers in minutes instead of requiring hand-derived adjoint codes.
  • JAX-AMR provides a reusable AMR layer for other JAX PDE solvers, not only combustion, because JIT compatibility with dynamic refinement is the general bottleneck it removes.
  • The MIT-licensed release means the solver can be extended by the community; the paper lists three-dimensional extension, viscous and turbulent models, and immersed boundary methods as natural next steps.
  • The cost-per-million-steps metric shows JANC's throughput advantage, but the practical gain for a given study depends on how many steps each solver needs to reach the same physical time.

Reading between the lines

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

  • I infer that the 1-2 percent cost figure is not a universal constant: it depends on cloud rental prices, the step counts each solver uses to reach the same physical time, and the AMR threshold choices, so a fairer comparison would report total wall-clock time to a fixed physical time with accuracy-matched refinement.
  • I infer that if JAX-AMR's dynamic block-count update strategy is optimized beyond the current doubling and halving heuristic, the redundant-block overhead will shrink and the efficiency gap over traditional CPU solvers could widen further.
  • I infer that the same fixed-shape block machinery could carry over to three-dimensional and multiphysics solvers, potentially making differentiable large-eddy simulation or reactive turbulence modeling feasible, not just Euler-equation detonation.
  • A testable extension I see is using JANC's adjoint gradients to calibrate Arrhenius parameters of a chemical mechanism directly from detonation speed or ignition delay data, which the current inverse example only hints at.
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

5 major / 5 minor

Summary. The paper introduces JAX-AMR, a block-structured adaptive mesh refinement framework implemented in JAX, and JANC, a differentiable compressible reacting-flow solver built on it. The solver solves the 2D reactive Euler equations with detailed finite-rate chemistry using WENO5 spatial reconstruction, third-order TVD Runge-Kutta time stepping, and a point-implicit chemical source term. Validation is provided for the Sod shock tube against the analytical solution and for zero-dimensional ignition delay against Cantera. The main performance claim is that in a 2D detonation-tube benchmark, JANC on one A100 GPU has a cost per million solver steps of about 1% of that of OpenFOAM on 384 CPU cores, and 1.2-2.1% when AMR is enabled. The paper also demonstrates adjoint-based gradient optimization in an inverse problem for a rotating detonation combustor flow field.

Significance. If the efficiency claim were established, a fully differentiable, GPU-native, JIT-compiled reacting-flow solver with AMR would be a genuinely useful contribution to combustion science and to machine-learning-based design. The paper provides open-source code (MIT license), validates the core solver against independent benchmarks (Sod and Cantera), and demonstrates a working adjoint optimization pipeline that avoids the memory blow-up of naive reverse-mode differentiation. The AMR design, based on fixed-shape blocks with predeclared maximum block counts, is a sensible way to reconcile JAX's static-shape JIT requirement with dynamic refinement. These strengths are real, but the headline cost comparison is not currently supported by the data reported.

major comments (5)
  1. [§5.2.2, Table 3] The cost metric is 'cost per million simulation steps' (CPMS), but the abstract and conclusions present this as 'computational cost reduced to 1% of that of OpenFOAM.' The paper never reports OpenFOAM's time step or the number of steps each solver needed to reach the common physical time t = 10 μs, while JANC's Δt = 0.5×10^-9 s implies 20,000 steps. If OpenFOAM's implicit-Euler scheme used a 10× larger Δt (which is plausible for an implicit scheme), its wall-clock cost to t = 10 μs would be roughly 10× lower than the CPMS-based estimate, changing the claimed ratio from about 1% to about 9%. Please report OpenFOAM's Δt, the step count to t = 10 μs, and the wall-clock time or dollar cost to reach that physical time for both solvers. Without these numbers, CPMS is not a time-to-solution comparison.
  2. [§5.2.2, CPMS arithmetic] The reported OpenFOAM cost is internally inconsistent. At 0.5 step/s on 384 cores and a rental price of $0.007/core-hr, one million steps take 1e6 / 0.5 s = 2×10^6 s = 555.6 hr, at a total cost of 555.6 × 384 × 0.007 ≈ $1493, not $1344. The same calculation gives JANC: 1e6 / 5.0 s = 2×10^5 s = 55.6 hr at $0.24/hr = $13.3, which is consistent. Please recompute the OpenFOAM CPMS or provide the raw measured timings so the ratio is reproducible.
  3. [§5.2.3] The AMR comparison inherits the same time-to-solution problem: OpenFOAM's time step and step count to t = 10 μs are not reported, and the refinement thresholds are explicitly adjusted 'to ensure their refined areas and total number of refined grids are similar.' This makes the cost comparison dependent on a threshold choice whose sensitivity is not explored. In addition, the crossover-advance cost (0.83 s per 'large step (8Δt)') is not directly comparable to the synchronous-advance cost without specifying how the multi-level time stepping is composed. Please report wall-clock time or dollar cost to reach the same physical time for each configuration, with error bars or at least multiple runs.
  4. [§5.2] The efficiency comparison is presented without any grid-convergence or accuracy-matching study. JANC uses WENO5/RK3 and OpenFOAM uses MUSCL with a minmod limiter and first-order implicit Euler, so cost per step is not cost at comparable fidelity. The paper states that JANC shows 'superior shock-capturing ability' and 'clearer resolution,' but no quantitative error metric is provided. Please include a resolution study or a matched-error comparison (for example, comparing solutions on several grids and reporting the cost to achieve a given error level), or restrict the conclusions to computational speed at identical grid spacing without claiming higher-fidelity efficiency.
  5. [§3.1.4, Algorithm 1] The dynamic update strategy for N_i,max contains a logic error as written. In the 'elif' branch, the condition (N_i,valid + 1) < 2.5 N_i,max is satisfied for essentially all valid states; for example, with N_i,max = 100 and N_i,valid = 99, the condition 100 < 250 is true, so N_i,max would be halved to 50 even though all 99 blocks are in use. This would cause oscillation or an invalid state. Presumably the intended reduction condition is something like N_i,valid < N_i,max / 2.5. Please correct the pseudocode to match the actual implementation, or if the implementation has the same behavior, explain how it avoids the problem.
minor comments (5)
  1. [§5.2.2, §5.2.3] The performance units are inconsistent: §5.2.2 quotes OpenFOAM speed as 0.5 step/s, while §5.2.3 quotes it as 0.75 s/step. Please use one convention throughout.
  2. [§4.1] Equations (4.3)-(4.5) have garbled symbol rendering in the submitted text (e.g., the NASA polynomial terms and the species enthalpy/specific heat definitions). Please ensure all equations are typeset correctly.
  3. [§5.2.2] The cloud rental prices are introduced and used without any sensitivity analysis. Given that these are spot-market estimates, please state that they are approximate and perhaps give a range.
  4. [§1] The claim of being 'the first' JAX-based block-structured AMR framework is strong. If the authors are not aware of prior work, suggest phrasing such as 'to our knowledge, the first' to avoid overclaiming.
  5. [§5.2.2, Fig. 9] The near-linear speedup with GPUs is stated qualitatively; please include the measured speedup factors (e.g., 1.99×, 3.02×) in the text or figure.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; the solver validations use independent external benchmarks and the inverse problem is an explicit self-consistency demonstration.

full rationale

The paper's central claims are supported by independent external checks rather than by construction or self-citation. The Sod shock tube result is compared against the analytical Riemann solution, and the ignition delay results are compared against Cantera using the same chemical mechanism; both are external references. The point-implicit chemical source advancement cites the authors' prior work [28], but this is a standard first-order implicit treatment, and the paper independently verifies its stability and accuracy through a time-step study and Cantera comparison, so the self-citation is not load-bearing. The performance comparison with OpenFOAM is a benchmark rather than a prediction: the reported CPMS values follow arithmetically from measured step rates and rental prices, and concerns about missing OpenFOAM time-step data, threshold adjustment, or cost arithmetic are correctness/fairness issues, not circularity. The rotating detonation inverse problem uses flow snapshots generated by JANC itself with a known equivalence ratio, but the text explicitly frames it as demonstrating the adjoint optimization functionality, i.e., a self-consistency test of the differentiable solver rather than an empirical prediction. No quantity is defined in terms of the target result, no fitted parameter is renamed as a prediction, and no load-bearing argument reduces to a self-citation chain. The derivation chain is self-contained against external benchmarks, so the circularity burden is not met.

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

No new physical entity is introduced; the NAN block is a software placeholder, not a physics postulate. The solver is based on standard inviscid, thermally perfect, finite-rate chemistry assumptions and inherits JAX's JIT and automatic differentiation machinery. The tuned quantities relevant to the quantitative claims are the AMR thresholds used to align the benchmark with OpenFOAM, which are not fully reported.

free parameters (3)
  • CFL number = 0.2 for Sod case; user-defined for others
    Time-step control parameter; not fitted to validation targets, but affects numerical results.
  • Ignition-delay fixed time step dt = 5e-9 s
    Selected after comparing dt=1e-9, 5e-8 and 5e-9 in one constant-volume case in Section 5.1.
  • AMR refinement thresholds and update interval = thresholds not reported; update every 40 steps
    In Section 5.2.3 the thresholds are adjusted in both solvers to equalize refined regions, so the performance comparison depends on hand-tuned values.
assumptions (6)
  • domain assumption The flow is governed by the 2D compressible reactive Euler equations with no viscosity or transport (Eq. 4.1).
    Central to the solver; appropriate for shock- and detonation-dominated flows but ignores diffusive effects.
  • domain assumption The gas is a thermally perfect mixture with NASA-polynomial heat capacities and Arrhenius finite-rate chemistry (Eqs. 4.2 to 4.9).
    Standard combustion modeling; depends on Cantera and chemkin data supplied by the user.
  • standard math Lax-Friedrichs flux splitting with WENO5 reconstruction and TVD-RK3 time stepping is stable and sufficiently accurate on the test grids (Eq. 4.11, Section 4.2).
    Numerical scheme assumption; the paper provides no grid-convergence study for the reactive cases.
  • domain assumption Strang operator splitting and a first-order point-implicit method stably integrate stiff chemical sources with dt=5e-9 in the validation cases (Eq. 4.12, Section 5.1).
    Time-step size was chosen by comparing three dt values in one ignition-delay case; robustness across all chemistry is not shown.
  • standard math The adjoint ODE method computes gradients of the discrete trajectory accurately enough for optimization (Eq. 6.5, jax.custom_vjp).
    Standard adjoint sensitivity; the paper reports no gradient-error check against direct automatic differentiation.
  • ad hoc to paper JAX JIT compilation with fixed block shapes and predeclared N_i,max is a valid way to implement AMR (Algorithm 1, Section 3.1).
    This is the paper's own design choice; it preserves JIT compatibility but forces redundant invalid blocks and overhead.

how reviews work

0 comments
Cite this review

Pith. "Pith review of JANC: A cost-effective, differentiable compressible reacting flow solver featured with JAX-based adaptive mesh refinement." pith.science (2026). https://pith.science/paper/ZK5JTGIH

@misc{pith2026250413750,
  author       = {Pith},
  title        = {Pith review of: JANC: A cost-effective, differentiable compressible reacting flow solver featured with JAX-based adaptive mesh refinement},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZK5JTGIH}},
  note         = {Machine review of arXiv:2504.13750}
}
read the original abstract

The compressible reacting flow numerical solver is an essential tool in the study of combustion, energy disciplines, as well as in the design of industrial power and propulsion devices. We have established the first JAX-based block-structured adaptive mesh refinement (AMR) framework, called JAX-AMR, and then developed a fully-differentiable solver for compressible reacting flows, named JANC. JANC is implemented in Python and features automatic differentiation capabilities, enabling an efficient integration of the solver with machine learning. Furthermore, benefited by multiple acceleration features such as XLA-powered JIT compilation, GPU/TPU computing, parallel computing, and AMR, the computational efficiency of JANC has been significantly improved. In a comparative test of a two-dimensional detonation tube case, the computational cost of the JANC core solver, running on a single A100 GPU, was reduced to 1% of that of OpenFOAM, which was parallelized across 384 CPU cores. When the AMR method is enabled for both solvers, JANC's computational cost can be reduced to 1-2% of that of OpenFOAM. The core solver of JANC has also been tested for parallel computation on a 4-card A100 setup, demonstrating its convenient and efficient parallel computing capability. JANC also shows strong compatibility with machine learning by combining adjoint optimization to make the whole dynamic trajectory efficiently differentiable. JANC provides a new generation of high-performance, cost-effective, and high-precision solver framework for large-scale numerical simulations of compressible reacting flows and related machine learning research. Now, the source codes have been available under the MIT license at https://github.com/JA4S/JAX-AMR and https://github.com/JA4S/JANC.

Figures

Figures reproduced from arXiv: 2504.13750 by the authors.

Figure 1
Figure 1. First, within each layer of grids, specific refinement criteria are applied to identify the grids that need refinement, namely masked grids. For example, the refined grids are chosen as the grids on either side of a discontinuity in [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 12
Figure 12. Iterative optimization under different initial parameters:(a) variation of the cost function with iteration steps; (b)evolution of the optimization parameter θ with iteration steps. It is important to emphasize that although the RDC example is computed on 400,000 grids and each iteration requires both forward and backward propagation for 100 time steps, the adjoint optimization, compiled with JIT, achieves an averag… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

44 extracted references · 27 canonical work pages

  1. [1]

    The flow phenomena in these fields are characterized by complex multi -physics and multi -scale interactions, including shock waves, turbulence, and chemical reactions , etc

    Introduction The numerical simulation of compressible reactive flow is a critical issue and challenge i n computational fluid dynamics (CFD), with applications spanning combustion systems [1], energy industry [2], aerospace propulsion [3], and astrophysical phenomena [4]. The flow phenomena in these fields are characterized by complex multi -physics and m...

    work page

  2. [2]

    JAX-AMR & Combustion

    Basic features of JANC JANC, as the abbreviation for “JAX-AMR & Combustion”, is a fully-differentiable compressible reacting flow solver based on JAX. The basic features of JANC are as follows:  Implementation of adaptive mesh refinement (AMR) based on JAX, namely JAX-AMR, providing a feasible AMR framework for large-scale fully-differentiable computatio...

    work page

  3. [3]

    one to four

    JAX-AMR: JAX-based adaptive mesh refinement framework We propose an adaptive mesh refinement framework based on dynamically updated multi-layer blocks with fixed positions and fixed shapes, referred to as JAX -AMR. This framework is fully compatible with JIT and vectorized operations ( jax.vmap). Furthermore, similar to all block- structured AMR framework...

    work page

  4. [4]

    The effects of viscosity and transport properties of the working fluid are neglected

    Compressible reacting flow solver 4.1 Equations solved by JANC The current version of JANC solves the two-dimensional compressible reactive Euler equations in a Cartesian coordinate system (x, y), as expressed in Equation (4.1). The effects of viscosity and transport properties of the working fluid are neglected. In Equation (4.1), the vectors are defined...

    work page

  5. [5]

    In load.py, users can load custom thermodynamic databases and detailed chemical reaction mechanisms, as long as the data format is consistent with Cantera's requirements

    work page

  6. [6]

    In boundary.py, users can customize boundary condition functions through 4 functions: left_boundary, right_boundary, bottom_boundary and up_boundary. The content of this function is entirely user -defined, as long as it accepts the flow field state variables and outputs the flow field state variables with 3 layers of ghost grids on both the x- and y- sides

    work page

  7. [7]

    These source terms will be advanced along with the convection terms using the TVD Runge-Kutta 3rd-order time-advance algorithm

    In aux_func.py, users can add custom equation source terms in the source_terms function. These source terms will be advanced along with the convection terms using the TVD Runge-Kutta 3rd-order time-advance algorithm. For example, if the user's problem does not require detailed chemical reaction mechanisms but involves a weaker stiff global reaction, the s...

    work page

  8. [8]

    In nondim.py, users can customize the nondimensionalization constants of the equations. In JANC, the default solving process is nondimensionalized, with the aim of making the physical quantities solved by the solver have comparable magnitudes, facilitating the post- processing of the computed data. For example, when combining with downstream machine learn...

    work page

Show all 44 references
  1. [9]

    In Section 5.1, the accuracy of JANC’s core solver is verified using benchmark cases

    Validation and Performance analysis of JANC This section demonstrates the capability of JANC in solving several typical compressible reacting flow and combustion problems, and compares its results with those from existing main-stream open- source solvers for validation and ana...

  2. [10]

    XlaRuntimeError: RESOURCE_EXHAUSTED: Out of memory while trying to allocate 421565057912 bytes

    Differentiable solver and adjoint optimization 6.1 Implementations of adjoint optimization in JANC All functions used in JANC are implemented using the JAX framework, which inherits JAX ’s automatic differentiation capability. As a result, the solver can be directly embedded i...

  3. [11]

    Conclusions and prospects We have developed JAX-AMR, a JAX -based adaptive mesh refinement framework. Building upon this foundation, we have created and integrated a fully- differentiable compressible reacting flows solver, which has been released as an open-source package nam...

  4. [12]

    Pitsch, Large-eddy simulation of turbulent combustion, Annual Review of Fluid Mechanics 38 (2006) 453–482

    H. Pitsch, Large-eddy simulation of turbulent combustion, Annual Review of Fluid Mechanics 38 (2006) 453–482. https://doi.org/10.1146/annurev.fluid.38.050304.092133

    2006

  5. [13]

    Poullikkas, An overview of current and future sustainable gas turbine technologies, Renewable and Sustainable Energy Reviews 9 (2005) 409–443

    A. Poullikkas, An overview of current and future sustainable gas turbine technologies, Renewable and Sustainable Energy Reviews 9 (2005) 409–443. https://doi.org/10.1016/j.rser.2004.05.009

    2005 doi

  6. [14]

    Smirnov, V .B

    N.N. Smirnov, V .B. Betelin, R.M. Shagaliev, V .F. Nikitin, I.M. Belyakov, Yu.N. Deryuguin, S.V . Aksenov, D.A. Korchazhkin, Hydrogen fuel rocket engines simulation using LOGOS code, International Journal of Hydrogen Energy 39 (2014) 10748 –10756. https://doi.org/10.1016/j.ijh...

    2014 doi

  7. [15]

    Plewa, A.C

    T. Plewa, A.C. Calder, D.Q. Lamb, Type Ia supernova explosion: gravitationally confined detonation, ApJ 612 (2004) L37. https://doi.org/10.1086/424036

    2004 doi

  8. [16]

    Bezgin, S.J

    D.A. Bezgin, S.J. Schmidt, N.A. Adams, WENO3- NN: A maximum-order three-point data- driven weighted essentially non- oscillatory scheme, Journal of Computational Physics 452 (2022) 110920. https://doi.org/10.1016/j.jcp.2021.110920

    2022

  9. [17]

    Zhang, K

    Z.J. Zhang, K. Duraisamy, Machine Learning Methods for Data-Driven Turbulence Modeling, in: 22nd AIAA Computational Fluid Dynamics Conference, American Institute of Aeronautics and Astronautics, n.d. https://doi.org/10.2514/6.2015-2460

    doi

  10. [18]

    J.I. Ryu, K. Kim, K. Min, R. Scarcelli, S. Som, K.S. Kim, J.E. Temme, C.-B.M. Kweon, T. Lee, Data-driven chemical kinetic reaction mechanism for F -24 jet fuel ignition, Fuel 290 (2021) 119508. https://doi.org/10.1016/j.fuel.2020.119508

    2021

  11. [19]

    Fukami, K

    K. Fukami, K. Fukagata, K. Taira, Super -resolution reconstruction of turbulent flows with machine learning, Journal of Fluid Mechanics 870 (2019) 106–120. https://doi.org/10.1017/jfm.2019.238

    2019 doi

  12. [20]

    M. Zhu, A. Bazaga, P. Liò, FLUID -LLM: Learning Computational Fluid Dynamics with Spatiotemporal-aware Large Language Models, (2024). https://doi.org/10.48550/arXiv.2406.04501

    2024 doi arXiv

  13. [21]

    Belbute-Peres, T

    F.D.A. Belbute-Peres, T. Economon, Z. Kolter, Combining Differentiable PDE Solvers and Graph Neural Networks for Fluid Flow Prediction, in: Proceedings of the 37th International Conference on Machine Learning, PMLR, 2020: pp. 2402–2411. https://proceedings.mlr.press/v119/de-av...

    2020

  14. [22]

    K. Um, R. Brand, Yun, Fei, P. Holl, N. Thuerey, Solver -in-the-Loop: Learning from Differentiable Physics to Interact with Iterative PDE -Solvers, (2021). https://doi.org/10.48550/arXiv.2007.00016. [12]B. List, L.-W. Chen, N. Thuerey, Learned turbulence modelling with differen...

    2021 doi arXiv

  15. [23]

    Buhendwa, D.A

    A.B. Buhendwa, D.A. Bezgin, P. Karnakov, N.A. Adams, P. Koumoutsakos, Shape inference in three -dimensional steady state supersonic flows using ODIL and JAX -Fluids, (2024). 29 https://doi.org/10.48550/arXiv.2408.10094

    2024 doi arXiv

  16. [24]

    B. Pang, E. Nijkamp, Y .N. Wu, Deep Learning With TensorFlow: A Review, Journal of Educational and Behavioral Statistics 45 (2020) 227– 248. https://doi.org/10.3102/1076998619872761

    2020 doi

  17. [25]

    Paszke, S

    A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, A. Lerer, Automatic differentiation in PyTorch, (2017). https://openreview.net/forum?id=BJJsrmfCZ (accessed April 13, 2025)

    2017

  18. [26]

    Bradbury, R

    J. Bradbury, R. Frostig, P. Hawkins, M.J. Johnson, C. Leary, D. Maclaurin, G. Necula, A. Paszke, J. VanderPlas, S. Wanderman-Milne, Q. Zhang, JAX: composable transformations of Python+NumPy programs, (2018). http://github.com/jax-ml/jax

    2018

  19. [27]

    Schoenholz, E.D

    S. Schoenholz, E.D. Cubuk, JAX MD: A Framework for Differentiable Physics, in: Advances in Neural Information Processing Systems, Curran Associates, Inc., 2020: pp. 11428 –11441. https://proceedings.neurips.cc/paper/2020/hash/83d3d4b6c9579515e1679aca8cbc8033- Abstract.html (ac...

    2020

  20. [28]

    T. Xue, S. Liao, Z. Gan, C. Park, X. Xie, W.K. Liu, J. Cao, JAX-FEM: A differentiable GPU- accelerated 3D finite element solver for automatic inverse design and mechanistic data science, Computer Physics Communications 291 (2023) 108802. https://doi.org/10.1016/j.cpc.2023.108802

    2023

  21. [29]

    Bezgin, A.B

    D.A. Bezgin, A.B. Buhendwa, N.A. Adams, JAX -Fluids: A fully -differentiable high- order computational fluid dynamics solver for compressible two- phase flows, Computer Physics Communications 282 (2023) 108527. https://doi.org/10.1016/j.cpc.2022.108527

    2023

  22. [30]

    Baniabedalruhman, Dynamic meshing around fluid- fluid interfaces with applications to droplet tracking in contraction geometries, Michigan Technological University, 2015

    A. Baniabedalruhman, Dynamic meshing around fluid- fluid interfaces with applications to droplet tracking in contraction geometries, Michigan Technological University, 2015. https://www.proquest.com/openview/639e58fe2ccaa31e39155e49e10be626/1?cbl=18750&pq -origsite=gscholar (a...

    2015

  23. [31]

    Zhang, A

    W. Zhang, A. Myers, K. Gott, A. Almgren, J. Bell, AMReX: Block- structured adaptive mesh refinement for multiphysics applications, The International Journal of High Performance Computing Applications 35 (2021) 508–526. https://doi.org/10.1177/10943420211022811

    2021 doi

  24. [32]

    https://amroc.sourceforge.net/ (accessed April 13, 2025)

    AMROC - Blockstructured Adaptive Mesh Refinement in object -oriented C++, (n.d.). https://amroc.sourceforge.net/ (accessed April 13, 2025)

    2025

  25. [33]

    Jasak, OpenFOAM: Open source CFD in research and industry, International Journal of Naval Architecture and Ocean Engineering 1 (2009) 89–94

    H. Jasak, OpenFOAM: Open source CFD in research and industry, International Journal of Naval Architecture and Ocean Engineering 1 (2009) 89–94. https://doi.org/10.2478/IJNAOE- 2013-0011

    2009 doi

  26. [34]

    R.T.Q. Chen, Y . Rubanova, J. Bettencourt, D. Duvenaud, Neural Ordinary Differential Equations, (2019). https://doi.org/10.48550/arXiv.1806.07366

    2019 doi arXiv

  27. [35]

    Goodwin, H.K

    D.G. Goodwin, H.K. Moffat, I. Schoegl, R.L. Speth, B.W. Weber, Cantera: An Object-oriented Software Toolkit for Chemical Kinetics, Thermodynamics, and Transport Processes, (2024). https://doi.org/10.5281/ZENODO.14455267

    2024 doi

  28. [36]

    Kee, F.M

    R.J. Kee, F.M. Rupley, J.A. Miller, Chemkin- II: A Fortran chemical kinetics package for the analysis of gas -phase chemical kinetics, Sandia National Lab. (SNL -CA), Livermore, CA (United States), 1989. https://doi.org/10.2172/5681118

    1989 doi

  29. [37]

    LeVeque, Finite V olume Methods for Hyperbolic Problems, Cambridge University Press, Cambridge, 2002

    R.J. LeVeque, Finite V olume Methods for Hyperbolic Problems, Cambridge University Press, Cambridge, 2002. https://doi.org/10.1017/CBO9780511791253

    2002 doi

  30. [38]

    S. Xu, X. Jin, W. Fan, H. Wen, B. Wang, Numerical investigation on the interaction 30 characteristics between the gaseous detonation wave and the water droplet, Combustion and Flame 269 (2024) 113713. https://doi.org/10.1016/j.combustflame.2024.113713

    2024

  31. [39]

    Jachimowski, An analytical study of the hydrogen-air reaction mechanism with application to scramjet combustion, (1988)

    C.J. Jachimowski, An analytical study of the hydrogen-air reaction mechanism with application to scramjet combustion, (1988). https://ntrs.nasa.gov/citations/19880006464 (accessed April 14, 2025)

    1988

  32. [40]

    J. Sun, Y . Wang, B. Tian, Z. Chen, detonationFoam: An open-source solver for simulation of gaseous detonation based on OpenFOAM, Computer Physics Communications 292 (2023) 108859. https://doi.org/10.1016/j.cpc.2023.108859

    2023

  33. [41]

    Raissi, P

    M. Raissi, P. Perdikaris, G.E. Karniadakis, Physics Informed Deep Learning (Part I): Data - driven Solutions of Nonlinear Partial Differential Equations, (2017). https://doi.org/10.48550/arXiv.1711.10561

    2017 doi arXiv

  34. [42]

    https://www.pnas.org/doi/10.1073/pnas.1814058116 (accessed April 14, 2025)

    Learning data -driven discretizations for partial differential equations | PNAS, (n.d.). https://www.pnas.org/doi/10.1073/pnas.1814058116 (accessed April 14, 2025)

    2025 doi

  35. [43]

    Rankin, M.L

    B.A. Rankin, M.L. Fotia, A.G. Naples, C.A. Stevens, J.L. Hoke, T.A. Kaemming, S.W. Theuerkauf, F.R. Schauer, Overview of Performance, Application, and Analysis of Rotating Detonation Engine Technologies, Journal of Propulsion and Power 33 (2017) 131–143. https://doi.org/10.251...

    2017 doi

  36. [44]

    Fievisohn, K.H

    R.T. Fievisohn, K.H. Yu, Steady-State Analysis of Rotating Detonation Engine Flowfields with the Method of Characteristics, Journal of Propulsion and Power 33 (2017) 89–99. https://doi.org/10.2514/1.B36103

    2017 doi

Pith tools

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