A C++ implementation of the G-Scheme stiff ODE solver with multi-resolution sparse hash-table kernel lookup

Mauro Valorani; Riccardo Malpica Galassi

REVIEW 3 major objections 5 minor 11 references

A C++ implementation of the G-Scheme stiff ODE solver with multi-resolution sparse hash-table kernel lookup

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

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

Pith's one-line read Tabulated kernels let an explicit stiff solver beat CVODE by up to 9.3x

desk verdict Solid, well-engineered software paper with a plausible speed-up claim, but the CVODE baseline tolerances are undocumented—an easily fixable omission that must be addressed before the benchmark is fully convincing. read the letter →

arxiv 2607.14918 v1 pith:BGUZREFZ submitted 2026-07-16 math-ph math.MP

Riccardo Malpica Galassi , Mauro Valorani This is my paper · ORCID

classification math-phmath.MP

keywords G-SchemecomputationalsingularperturbationstiffODEsolversmulti-resolutionhashtablekernelsetretrievalcombustionkineticsn-heptaneautoignitionC++implementation

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 establishes that an explicit stiff ODE solver can outperform a mature implicit solver in wall-clock time when the expensive eigensystem updates are replaced by retrieval from a precomputed hash table. The authors present cpp-gscheme, a C++ implementation of the G-Scheme that tabulates local time-scale decompositions (kernel sets) in a multi-resolution sparse hash table. On 33 n-heptane autoignition mechanisms, the tabulated solver retrieves 100% of kernel sets, performs zero online eigendecompositions, and runs between 2.7x and 9.3x faster than CVODE, with the advantage growing with mechanism size. The solver's contribution to the error is shown to be negligible, placing the error budget on the skeletal reduction, which lets a 5% ignition-delay target be met 225x faster than CVODE on the detailed mechanism.

What carries the argument

The multi-resolution sparse hash table (multi-res hash table). A user-selected subset of state variables (e.g., temperature and major species) is Box-Cox scaled (λ=0.3), min-max normalized, binned at resolution levels ϵ=2^{-nexp} for nexp=3..10, and hashed with a polynomial hash. Retrieval probes levels from finest to coarsest, accepting a stored kernel set (eigenvalues and left/right eigenvectors) when the scaled-state distance is within τ=0.1. On a hit, the integrator adopts the stored kernel and recomputes only mode amplitudes, bypassing the finite-difference Jacobian and the O(N^3) eigendecomposition.

What would settle it

Run the 654-species n-heptane autoignition case with CVODE tolerances explicitly chosen to yield the same ignition-delay error as the hash-tabulated G-Scheme (~2×10^{-3}), and measure wall-clock time; if the reported 9.3x gap narrows to at or below 1x, the central claim fails.

Watch

Extended reading notes

Core claim

The central discovery is that the hash-tabulated G-Scheme completely eliminates the computational bottleneck of the original method: with 100% retrieval of precomputed kernel sets, the per-step Jacobian evaluation and eigendecomposition are skipped, leaving only the mode-amplitude projections. The explicit solver's inherent advantages—larger time steps via fast-mode exhaustion and integration of only a few active modes—are no longer outweighed by the kernel cost. This yields a monotone speed-up over CVODE that grows from 2.7x at 56 species to 9.3x at 654 species, with the measured cost scaling improving from ~N^1.9 to ~N^1.4.

Load-bearing premise

The comparison assumes both solvers are run at comparable accuracy; the paper reports the G-Scheme's tolerances but does not state CVODE's tolerances, so the absolute speed-up factors (2.7x–9.3x) depend on an unverified assumption of benchmark fairness.

Editorial extensions

If this is right

Explicit CSP-based solvers can compete with implicit BDF solvers on stiff combustion chemistry, not just in theory but in absolute wall-clock time.
The speed-up grows with mechanism size (2.7x at 56 species to 9.3x at 654), so the method becomes more attractive for large detailed mechanisms.
Solver-added error is negligible; the error budget is dominated by skeletal reduction, so offline reduction and online tabulation compose multiplicatively (a 5% ignition-delay budget is met 225x faster than CVODE on the detailed mechanism).
The GIL-free native integration loop enables future parallel multi-cell simulations where all cells share one table, promising high retrieval rates in turbulent reacting flows.
The tangential-stretching-rate diagnostic computed from tabulated kernels can screen skeletal mechanisms for dynamical fidelity, flagging anomalous reductions independently of ignition-delay error.

Reading between the lines

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

If the ~100% retrieval rates hold for other fuels, operating conditions, and turbulent trajectories, the approach could replace implicit solvers in production reactive-flow simulations, not just autoignition test problems.
The offline training cost is not included in the timings; for single-shot simulations the real benefit is lower, but for repeated runs (e.g., parameter sweeps, operator-splitting applications) the amortized speed-up will be closer to the reported 2.7x–9.3x.
The table's tolerance to approximate kernels (via step-size self-protection) suggests the table could be built adaptively during the first run and reused later, eliminating the separate training phase.
The TSR-proﬁle deviation, shown to flag the same anomalous skeletal mechanisms as ignition-delay error, could be promoted to a design constraint in automated mechanism-reduction algorithms.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

The load-bearing claim here is that a tabulated explicit G-Scheme beats CVODE by 2.7–9.3× on stiff ignition chemistry with zero online eigendecompositions. I think that claim is probably true, but the paper currently asks the reader to take part of it on faith. Section 6.1 specifies the G-Scheme tolerances and never gives the CVODE/Cantera ReactorNet tolerances. That is a real omission. If CVODE was run with unusually tight tolerances, the speed-up is inflated; if with loose ones, the accuracy comparison becomes self-serving. Either way, the benchmark is not reproducible without that line in the table.

What is genuinely new and good: this is not just a translation. The porting methodology is exemplary—semantic pinning of rounding and modulo behavior, key-level and trajectory-level equivalence tests, and the careful handling of conjugate-pair bookkeeping in findM/findH. The C++ implementation is a serious engineering effort, with a zero-Python RHS path and robust handling of sparse initial states for large mechanisms. The accuracy assessment is more careful than most software papers: three metrics, solver-vs-mechanism error decomposition, and a direct combined-pipeline measurement. The open-source release with test suites and benchmark drivers means the whole thing is checkable.

The in-distribution 100% retrieval is partly expected, since the table is trained at the same initial condition used for the test. The OOD result (T0±15K) is more informative, and the fact that retrieval remains 100% with only a modest time penalty suggests the method has genuine generalization. The 225× Pareto point does lean on the 80-species mechanism, which the paper itself flags as a favorable outlier—minor, but the headline number should be handled carefully.

The soft spots are fixable. Document the CVODE configuration. Add at least one OOD point farther from the training conditions, or a sensitivity test where the training bracket is narrowed. These are referee requests, not fatal flaws. The core contribution—a production-grade implementation that makes the hash-table G-Scheme competitive with CVODE in absolute terms—is real and worth publishing.

I would send this to review. The right referees will want the missing benchmark details, but the methodology and results are interesting enough to justify their time.

Referee Report

3 major / 5 minor

Summary. The paper presents cpp-gscheme, a production C++ implementation of the G-Scheme stiff ODE solver with the multi-resolution sparse hash-table kernel lookup previously introduced in a Python prototype. It documents a porting methodology based on semantic pinning (rounding, modular arithmetic, payload sharing), backed by key-level and trajectory-level equivalence tests, and reports a benchmark campaign on 33 n-heptane/air autoignition mechanisms (56--654 species) in which the hash-tabulated solver is claimed to retrieve 100% of kernel sets, perform zero online eigendecompositions, and beat natively compiled CVODE by factors from 2.7x to 9.3x. The paper also gives a three-metric accuracy assessment (ignition delay, equilibrium state, entropy-progress error) and argues that the solver contributes negligibly to the total error budget, which is dominated by skeletal reduction. All software and drivers are released as open source.

Significance. If the central speed-up claim is correct, the paper demonstrates a practically important result: an explicit, CSP-based integrator with tabulated kernel sets can beat a mature implicit BDF solver in absolute wall-clock time on stiff ignition chemistry, with an advantage that grows with mechanism size. The porting methodology is careful and unusual: the authors pin numerical semantics to the Python reference, verify hash keys and trajectories, and ship reproducible equivalence tests. The accuracy assessment, while tied to a CVODE baseline, is multi-metric and includes an out-of-distribution scenario. The software release and the parameter transparency on the G-Scheme side are strengths that make the claims independently checkable. However, two load-bearing issues -- the missing CVODE/Cantera tolerance specification and internal numerical inconsistencies between the abstract/text and the timing table -- must be resolved before the speed-up claim can be accepted as stated.

major comments (3)

[Section 6.1 and Section 6.4] The benchmark does not state the CVODE/Cantera ReactorNet tolerances used for the reference timings. Section 6.1 gives the G-Scheme tolerances (rtol_tail=1e-3, atol_tail=1e-9, rtol_head=1e-4, atol_head=1e-10, gamma=0.2) but never the CVODE configuration. The central speed-up claim (2.7x--9.3x) is only meaningful if both solvers are run to comparable accuracy. Moreover, Section 6.4 uses CVODE as the baseline for all error metrics, so differences in solver accuracy are not captured. If CVODE was run with unusually tight tolerances, the speed-up would be inflated; if with loose tolerances, the accuracy comparison would be distorted. The paper must report the exact CVODE/Cantera settings, the selected integration/output tolerances, and ideally a tolerance-sweep to demonstrate that the wall-clock advantage persists at equal accuracy.
[Abstract, Section 6.2, Table 1] The headline numbers are internally inconsistent. The abstract and Section 6.2 claim speed-ups of 2.7x at 56 species and 9.3x on the 654-species mechanism, with the latter stated as '0.67 s against CVODE's 6.2 s'. Table 1, however, lists CVODE/ID ratios of 3.0 at Ns=56 and 10.6 at Ns=654, with CPU times 0.599 s and 6.339 s respectively. Section 6.2 also says the hash solver 'outruns the classic G-Scheme by 157x' at 654 species, but Table 1 gives 105.80/0.599 ≈ 176.8x. The Pareto discussion mentions 225x in the abstract, 222x in Section 6.3, and 225x in Section 6.4, while Table 1 yields 6.339/0.093*0.093/0.028 ≈ 226x. These discrepancies affect the central quantitative claim and must be reconciled before the paper can be accepted.
[Section 6.1 and Section 6.2] The 'Out-Of-Distribution' scenario is not truly out-of-distribution. The OOD table is trained on two trajectories at T0 ± 15 K, and the test is still at T0=1000 K, so T0 lies inside the training bracket. The 100% retrieval rate and resulting zero online eigendecompositions are therefore not a predictive or generalization result; they are a direct consequence of looking up stored kernels for the same autoignition condition. The paper should either rename this scenario (e.g., 'perturbed-training' or 'bracketed') or test a genuinely disjoint condition (e.g., a different equivalence ratio or initial pressure) for which retrieval is not guaranteed. This does not invalidate the measured speed-up for the tested setup, but the current wording overstates the robustness of the method.

minor comments (5)

[Table 1] The column 'Nr' is never defined. It appears to be the number of reactions, but this should be stated explicitly in the caption or Section 6.1.
[Section 6.1] The timings are reported as single values with no indication of the number of repeats, variability, or whether they are median/minimum over runs. Given the claimed 2.7--9.3x speed-ups, a brief statement about run-to-run noise (or a measurement over several runs) would strengthen the benchmark.
[Section 5.3] The trajectory-level equivalence test is demonstrated on Van der Pol, while the table-equivalence test uses a synthetic combustion-like training set. It would be useful to state explicitly that the C++ and Python integrators have also been compared on a real combustion trajectory, or to note why the Van der Pol test is sufficient.
[Section 6.1] The phrase 'the retrieval rate was unaffected' after subsampling the training trajectories for the largest mechanisms is not accompanied by data. A brief table or sentence quantifying the effect would be helpful.
[General] The abstract and Section 6.2 should use consistent notation for the speed-up ratios (e.g., 'CVODE/hash-ID') and align the exact numbers with Table 1. Currently the abstract's 9.3x conflicts with Table 1's 10.6x, which is confusing for the reader.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central claims are measured implementation benchmarks, not derivations from fitted inputs.

full rationale

The paper's central claims—100% kernel retrieval, zero online eigendecompositions, and speedups over CVODE—are empirical performance measurements of a C++ implementation, not predictions derived from the training data by construction. The In-Distribution scenario is explicitly trained on a trajectory at the same T0 used for testing, and this is disclosed as a deliberate benchmark condition; the paper does not present that scenario as an out-of-sample prediction. The Out-Of-Distribution scenario with T0 ± 15 K provides a separate, harder control, and the retrieval and speedup results are reported separately for it. The zero-online-eigendecomposition statement follows from the code path on a hit, but the hit rate is measured, not assumed. The speedup over CVODE is a direct wall-clock comparison, and the accuracy section uses CVODE as a baseline while also cross-checking skeletal against detailed mechanisms; this is standard practice, not a circular reduction. The paper's many self-citations refer to the previously published G-Scheme and hash-table methods and do not invoke a self-cited uniqueness theorem or otherwise force the present conclusions. The omission of CVODE's tolerances is a reporting/fairness limitation that affects interpretation of the speedup magnitude, but it is not a circularity: no equation or fitted parameter is renamed as a prediction. Therefore no circular step is identifiable under the required evidence standard.

Assumptions & free parameters 8 free parameters · 5 assumptions · 0 invented entities

All 'free parameters' are method hyperparameters carried over from the authors' prior work or hand-tuned safeguards; none are fitted to the benchmark data to inflate the result. The main domain assumptions concern the slow variation of kernel sets and the tolerance of approximate kernels, which are the physical premises that make tabulation work.

free parameters (8)

G-Scheme tolerances = rtol_tail=1e-3, atol_tail=1e-9, rtol_head=1e-4, atol_head=1e-10, gamma=0.2
Chosen algorithm settings that determine step sizes and active-mode count; they directly influence the measured speed-up and accuracy.
Hash mask = {nC7H16, O2, HCO, H2O, CO2, T}
Subset of state variables used for hashing; choice affects retrieval resolution and accuracy.
Box-Cox lambda = 0.3
Transformation parameter for scaling masked variables; fixed value from method paper.
Resolution range and acceptance threshold = nexp=3..10, tau=0.1
Multi-resolution binning levels and acceptance radius; controls hit rate and approximation quality.
Hash base/modulus = base=131, modulus s (value not stated)
Polynomial hash parameters; modulus value not reported, affects collision behaviour.
Initial-condition floor = 1e-20
Replaces exactly-zero species in initial condition for large mechanisms; hand-chosen safeguard.
Per-component perturbation scales = eps_rel/eps_abs (values not stated)
Finite-difference Jacobian perturbation scales; critical for rank sufficiency on 654-species mechanism.
Step-growth cap and dt_max = 1.5x, absolute dt_max value not stated
Safeguard constants limiting adaptive step growth near equilibrium.

assumptions (5)

domain assumption CSP/G-Scheme subspace decomposition removes stiffness by projecting out exhausted fast modes
Core method premise inherited from [2]; the accuracy claims depend on it.
domain assumption Kernel sets vary on the slow scale, so a stored kernel from a nearby state can be reused with only amplitude refresh
Basis of the entire hash-table retrieval strategy; if kernels changed at the fast scale, retrieval would be invalid. Assumed and tested indirectly via OOD runs.
domain assumption Approximate retrieved kernels are tolerated by the G-Scheme through automatic step-size reduction without loss of accuracy
Claims 100% retrieval with tau=0.1; accuracy section shows error preserved, but this depends on the solver's self-protection property from [6].
domain assumption Per-component finite-difference Jacobians produce kernel sets equivalent to the Python reference
Needed for the 654-species mechanism where uniform perturbations are rank-deficient; equivalence is verified by tests on smaller cases only.
domain assumption Entropy progress xi=(s-s0)/(seq-s0) is a monotone trajectory coordinate for adiabatic isobaric autoignition
Used as the independent variable for trajectory comparison; asserted for the reactor type.

how reviews work

0 comments

Cite this review

Pith. "Pith review of A C++ implementation of the G-Scheme stiff ODE solver with multi-resolution sparse hash-table kernel lookup." pith.science (2026). https://pith.science/paper/BGUZREFZ

@misc{pith2026260714918,
  author       = {Pith},
  title        = {Pith review of: A C++ implementation of the G-Scheme stiff ODE solver with multi-resolution sparse hash-table kernel lookup},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BGUZREFZ}},
  note         = {Machine review of arXiv:2607.14918}
}

read the original abstract

The G-Scheme is an explicit, adaptive integration framework for stiff systems of ordinary differential equations that exploits a local time-scale decomposition provided by the eigensystem of the Jacobian (the kernel set). Its computational cost is dominated by the evaluation of a new kernel set at each time step. In a recent paper [R.Malpica Galassi and M.Valorani, Combust. Theory Model. 2025], we introduced a multi-resolution sparse hash-table strategy that replaces online kernel computation with retrieval from a precomputed lookup table, demonstrated in Python. Here we present cpp-gscheme, a production-grade C++ implementation of both the G-Scheme and the multi-resolution hash table, together with the porting methodology that guarantees behavioural equivalence with the Python reference: identical scaling, binning and hashing semantics, a bitwise-inert retrieval hook in the integrator, and a fully native evaluation path for the chemical source terms. On 33 n-heptane autoignition mechanisms spanning 56-459 species plus the detailed 654-species mechanism, the hash-tabulated C++ G-Scheme retrieves 100 percent of the kernel sets, performs zero online eigen decompositions, and outperforms the natively compiled CVODE solver by a factor increasing from 2.7x (56 species) to 9.3x (654 species), with observed cost scaling of approximately N power 1.4 versus CVODE's N power 1.9. A three-metric accuracy assessment (ignition delay, equilibrium state, and accumulated entropy-progress error) shows that the solver contributes negligibly to the overall error budget, which is dominated by skeletal reduction. Consequently, a 5 percent ignition-delay target is achieved by the 80-species skeletal mechanism with a 225x speed-up over CVODE on the detailed mechanism. The software, training-set builders, and benchmark drivers are released as open source.

Figures

Figures reproduced from arXiv: 2607.14918 by the authors.

**Figure 1.** The four-layer architecture of cpp-gscheme. Python orchestrates (dashed arrows: one-time setup and data exchange across the pybind11 boundary); the per-step hot path (solid red) – integrator, kernel retrieval, and source-term evaluation down to libCantera – is a single native call stack, free of the interpreter. 7 [PITH_FULL_IMAGE:figures/full_fig_p007_1.png] view at source ↗

**Figure 2.** Elapsed CPU time against the number of species: CVODE (green), classic C++ G-Scheme (purple), hash-tabulated C++ G-Scheme with In-Distribution (red, solid) and OutOf-Distribution (red, dashed) tables. Three observations: 1. The hash-tabulated C++ G-Scheme beats natively compiled CVODE by a margin that grows with the problem size: 2.7× at 56 species, 7.1× at 368 species, 9.3× on the detailed 654-species mechanism (0… view at source ↗

**Figure 3.** For comparison: the corresponding campaign of the method paper [5] with the Python implementation (CSP solver cyan, G-Scheme purple, CVODE green, hash-tabulated G-Scheme red). observed cost scalings over the 56–654 range are ∼ N1.4 (hash), ∼ N1.9 (CVODE) and ∼ N2.5 (classic G-Scheme). 2. Machine- and implementation-independent cross-validation: the classicG-Scheme-to-CVODE elapsed-time ratio at ∼370 species is 11.5… view at source ↗

Figures from the paper (4 more)

**Figure 4.** Figure 4: Anatomy of the 80-species In-Distribution run. (a) Temperature: CVODE, classic G-Scheme and hash-tabulated G-Scheme are indistinguishable. (b) Step size: the G-Scheme advances with steps one to two orders of magnitude larger than CVODE throughout the induction period; …

**Figure 5.** Figure 5: Retrieval resolution levels of the Out-Of-Distribution run (table trained only at T0 ± 15 K): the multi-resolution search falls back to coarser levels (4–8 against the In-Distribution 5–10 of Fig. 4d), retrieval remains 100% (376/376), and the solver compensates with s…

**Figure 6.** Figure 6: Ignition-delay relative error against mechanism size, for the solver layer (G-Scheme, hash-ID, hash-OOD vs same-mechanism CVODE), the mechanism layer (skeletal vs detailed, black), and the combined pipeline (hash-ID vs detailed, green dotted) [PITH_FULL_IMAGE:figures/…

**Figure 7.** Figure 7: Error–cost Pareto: combined ignition-delay error against elapsed CPU time for CVODE on each skeletal mechanism (green circles) and the hash-tabulated G-Scheme on the same mechanism (red triangles); green star: CVODE on the detailed mechanism (reference, zero error). Da…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

11 extracted references

[1]

A. C. Hindmarsh et al., SUNDIALS: Suite of nonlinear and diﬀerential/al- gebraic equation solvers, ACM Trans. Math. Softw. 31 (2005) 363–396. 24

2005
[2]

Valorani, S

M. Valorani, S. Paolucci, The G-Scheme: A framework for multi-scale adap- tive model reduction, J. Comput. Phys. 228 (2009) 4665–4701

2009
[3]

S. H. Lam, D. A. Goussis, Understanding complex chemical kinetics with computational singular perturbation, Symp. (Int.) Combust. 22 (1989) 931– 941

1989
[4]

D. A. Goussis, S. H. Lam, A study of homogeneous methanol oxidation kinetics using CSP, Symp. (Int.) Combust. 24 (1992) 113–120

1992
[5]

Malpica Galassi, M

R. Malpica Galassi, M. Valorani, A multi-resolution sparse hash table strat- egy for eﬃcient numerical integration of stiﬀ combustion systems using the G-Scheme, Combust. Theory Model. (2025)

2025
[6]

Hernández-Pérez, Mauro Valorani, Hong G

Alessandro Carinci, Riccardo Malpica Galassi, Mohammad Raﬁ Malik, Francisco E. Hernández-Pérez, Mauro Valorani, Hong G. Im, An explicit time-integration framework for accelerated direct numerical simulations of stiﬀ reacting ﬂows, Computers and Fluids, Volume 312 (2026), 107046

2026
[7]

Valorani, P

M. Valorani, P. P. Ciottoli, R. Malpica Galassi, S. Paolucci, T. Grenga, E. Martelli, Enhancements of the G-Scheme framework, Flow Turbul. Com- bust. 101 (2018) 1023–1033

2018
[8]

D. G. Goodwin, H. K. Moﬀat, I. Schoegl, R. L. Speth, B. W. Weber, Cantera: An object-oriented software toolkit for chemical kinetics, thermo- dynamics, and transport processes, Version 3.0 (2023)

2023

Show all 11 references

[9]

M. Mehl, W. J. Pitz, C. K. Westbrook, H. J. Curran, Kinetic modeling of gasoline surrogate components and mixtures under engine conditions, Proc. Combust. Inst. 33 (2011) 193–200

2011
[10]

Malpica Galassi, P

R. Malpica Galassi, P. P. Ciottoli, S. M. Sarathy, H. G. Im, S. Paolucci, M. Valorani, Automated chemical kinetic mechanism simpliﬁcation with minimal user expertise, Combust. Flame 197 (2018) 439–448. 25

2018
[11]

Valorani, S

M. Valorani, S. Paolucci, E. Martelli, T. Grenga, P. P. Ciottoli, Dynamical system analysis of ignition phenomena using the Tangential Stretching Rate concept, Combust. Flame 162 (2015) 2963–2990. Appendix A. The tangential stretching rate as a training-set diag- nostic The ke...

2015

Pith tools

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

[1] [1]

A. C. Hindmarsh et al., SUNDIALS: Suite of nonlinear and diﬀerential/al- gebraic equation solvers, ACM Trans. Math. Softw. 31 (2005) 363–396. 24

2005

[2] [2]

Valorani, S

M. Valorani, S. Paolucci, The G-Scheme: A framework for multi-scale adap- tive model reduction, J. Comput. Phys. 228 (2009) 4665–4701

2009

[3] [3]

S. H. Lam, D. A. Goussis, Understanding complex chemical kinetics with computational singular perturbation, Symp. (Int.) Combust. 22 (1989) 931– 941

1989

[4] [4]

D. A. Goussis, S. H. Lam, A study of homogeneous methanol oxidation kinetics using CSP, Symp. (Int.) Combust. 24 (1992) 113–120

1992

[5] [5]

Malpica Galassi, M

R. Malpica Galassi, M. Valorani, A multi-resolution sparse hash table strat- egy for eﬃcient numerical integration of stiﬀ combustion systems using the G-Scheme, Combust. Theory Model. (2025)

2025

[6] [6]

Hernández-Pérez, Mauro Valorani, Hong G

Alessandro Carinci, Riccardo Malpica Galassi, Mohammad Raﬁ Malik, Francisco E. Hernández-Pérez, Mauro Valorani, Hong G. Im, An explicit time-integration framework for accelerated direct numerical simulations of stiﬀ reacting ﬂows, Computers and Fluids, Volume 312 (2026), 107046

2026

[7] [7]

Valorani, P

M. Valorani, P. P. Ciottoli, R. Malpica Galassi, S. Paolucci, T. Grenga, E. Martelli, Enhancements of the G-Scheme framework, Flow Turbul. Com- bust. 101 (2018) 1023–1033

2018

[8] [8]

D. G. Goodwin, H. K. Moﬀat, I. Schoegl, R. L. Speth, B. W. Weber, Cantera: An object-oriented software toolkit for chemical kinetics, thermo- dynamics, and transport processes, Version 3.0 (2023)

2023