A header-only C++20 library for Darcy–Weisbach pipe friction factors. It provides implementations for turbulent flow, an explicit laminar and transition wrapper, analytic first derivatives, and allocation-free batch evaluation.
- Colebrook–White: Clamond's specialized two-update solver, based on Clamond (2009), plus fixed-point and Newton solvers for comparison.
- Swamee–Jain: explicit turbulent-flow approximation.
- Explicit Colebrook approximations: Haaland, Serghides, Goudar–Sonnad, Brkić, Brkić–Praks, Praks–Brkić, and Niazkar, plus the smooth-pipe Blasius and all-regime Swamee equations. Include
<friction/approximations.hpp>or<friction/friction.hpp>; these named functions are direct APIs and do not alter the existingCorrelationenum or its transition blend. - All-regime API: laminar
64/Rebehavior and a cubic smoothstep transition into the selected turbulent correlation. - Derivatives: closed-form first derivatives with respect to Reynolds number and relative roughness, plus optional reverse-mode checks using Enzyme and LLVM.
- Batch API: validated, allocation-free
std::spaninterfaces for scalar and derivative batches. - Experiments: optional CPU and CUDA benchmarks, including adaptive one- and two-dimensional tensor interpolants. These are exploratory tools; their measured limits are documented separately.
Inputs use relative roughness k_s/D. Returned factors are Darcy factors, not Fanning factors.
Requirements: CMake 3.20 or later and a C++20 compiler. The library has no third-party runtime dependencies.
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --parallel
ctest --test-dir build --output-on-failure
./build/friction_exampleSee QUICKSTART.md for installation, downstream use, CPack, and optional benchmark instructions. See CHANGELOG.md for changes planned for the next release.
#include <friction/analytic_derivatives.hpp>
#include <friction/friction.hpp>
int main() {
const double re = 700'000.0;
const double relative_roughness = 0.01;
const double f = friction::darcy_friction_factor(
re, relative_roughness, friction::Correlation::colebrook);
const auto d = friction::analytic::darcy_friction_factor(
re, relative_roughness, friction::Correlation::colebrook);
// f and d.value are equal; d contains both first derivatives.
return (f > 0.0 && d.d_reynolds < 0.0) ? 0 : 1;
}The scalar derivative result contains value, d_reynolds, and d_relative_roughness. Include <friction/batch.hpp> for the span-based batch APIs. Inputs must have equal lengths and valid values; batch functions validate the complete input before writing outputs. Output spans must not overlap input spans. Calls are serial and allocation-free; applications can parallelize by passing disjoint spans to separate threads.
The turbulent Colebrook solver accepts finite Re >= 2000; the standalone Swamee–Jain function accepts finite Re >= 5000. Swamee–Jain is commonly used over approximately 5000 <= Re <= 1e8; using it outside that range is extrapolation.
The all-regime wrapper applies 64/Re below Re=2000, then uses a cubic smoothstep to blend into the selected turbulent correlation. The blend ends at Re=2300 for Colebrook and Re=5000 for Swamee–Jain. This is an explicit engineering convention, not a universal transitional-flow model. The smoothstep makes the friction factor and its first derivative continuous at the blend endpoints.
The default derivative API uses analytic formulas. To build the optional Enzyme-generated derivative implementation, use Clang and the matching ClangEnzyme plugin:
cmake -S . -B build-enzyme -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_CXX_COMPILER=clang++-21 \
-DFRICTION_ENABLE_ENZYME_AD=ON \
-DFRICTION_ENZYME_PLUGIN=/path/to/ClangEnzyme-21.so
cmake --build build-enzyme --parallel
ctest --test-dir build-enzyme --output-on-failureThe test compares generated derivatives against the analytic results. In a project configured and installed with Enzyme enabled, link the optional friction::friction_enzyme_ad target to use the generated functions declared in <friction/enzyme_derivatives.hpp>. The Enzyme build is optional and requires a compatible plugin; it is not needed to use the library.
The library includes several ways to obtain a turbulent Darcy friction factor:
- Clamond Colebrook solver (
colebrook_turbulent): a specialized two-update solution to the implicit Colebrook–White equation, based on Clamond (2009). This is the library's default direct Colebrook method. - Fixed-point Colebrook (
colebrook_fixed_point): repeatedly substitutes the current estimate into the Colebrook equation until convergence. It is straightforward and useful as an independent reference, but took more iterations and ran slower in the measured CPU comparison. - Newton Colebrook (
colebrook_newton): applies Newton's method to the Colebrook residual in the variable1/sqrt(f). It converged in fewer iterations than fixed point in the recorded run, but remained slower than Clamond. - Swamee–Jain (
swamee_jain_turbulent): an explicit turbulent-flow correlation. It avoids solving the implicit Colebrook equation; its measured accuracy and throughput are compared with the other direct approximations below. - Adaptive bilinear and bicubic tensor interpolants: prebuilt approximations over a configured Reynolds-number/relative-roughness domain. They trade setup time and coefficient storage for faster repeated GPU evaluation. Their accuracy, especially for derivatives, must be checked for the intended use.
The direct analytic derivative API returns the factor and its first derivatives with respect to Reynolds number and relative roughness. The derivative rows below time those three outputs together; the iterative solver rows time the primal factor only.
This report compares explicit Darcy friction-factor correlations with the Clamond two-update Colebrook solver. It reports maximum relative error on a deterministic accuracy grid, measured CPU throughput on two Dell systems, and CUDA throughput on the Quadro M3000M and RTX 4090 Laptop GPU. The score combines approximation error and CPU throughput for a stated tolerance; it is a ranking aid, not a substitute for checking a correlation's validity range.
For method throughput S, Clamond throughput on the same host S_ref, maximum relative error E in percentage points, and error budget ε, the accuracy-adjusted throughput score is
Bε = (S / S_ref) / (1 + (E / ε)^2).
The report uses one budget, ε = 1.0%. A score of 1 is the Clamond reference by construction. Scores above 1 indicate greater throughput than Clamond after the stated error penalty; scores below 1 indicate lower adjusted throughput. The selected budget expresses an engineering tolerance and should reflect the intended application.
| Method | Maximum relative error | Dell 7710 throughput (M eval/s) | Dell 7680 throughput (M eval/s) | Score (7710) | Score (7680) |
|---|---|---|---|---|---|
| Clamond Colebrook (reference) | 0% | 13.50 | 19.79 | 1.000 | 1.000 |
| Goudar–Sonnad | 1.04 × 10⁻¹⁰% | 9.82 | 10.47 | 0.727 | 0.529 |
| Niazkar | 0.000143% | 7.32 | 8.48 | 0.542 | 0.429 |
| Serghides | 0.00314% | 9.89 | 13.03 | 0.733 | 0.658 |
| Praks–Brkić | 0.124% | 29.69 | 46.08 | 2.166 | 2.293 |
| Brkić–Praks | 0.169% | 30.09 | 46.62 | 2.167 | 2.290 |
| Haaland | 1.42% | 16.16 | 20.51 | 0.396 | 0.342 |
| Swamee all-regime | 2.47% | 6.83 | 8.00 | 0.071 | 0.057 |
| Blasius, smooth pipe | 2.84% | 35.55 | 39.44 | 0.291 | 0.220 |
| Brkić | 2.86% | 9.25 | 11.73 | 0.075 | 0.065 |
| Swamee–Jain | 2.95% | 18.45 | 25.95 | 0.141 | 0.135 |
Rows are ordered by maximum relative error, with throughput as the secondary ordering key. The score values above are recomputed from Slurm job 122 measurements at ε = 1.0%.
Figure 1. Throughput versus accuracy. Marker shape identifies the host; color identifies the correlation. The error axis is symmetric-logarithmic so the zero-error Clamond reference remains visible. Higher points are faster; points farther left are more accurate.
Figure 2. Constant-score contours for ε = 1.0%, overlaid on each method's maximum error and throughput relative to the Clamond result on that host. Contour labels are score values; higher is better under the selected metric.
Slurm job 122 compiled each benchmark on the target node using -O3 -march=native. The Dell 7710 used GCC 15.2 on an Intel Core i7-6920HQ; the Dell 7680 used GCC 14.2 on a 13th Gen Intel Core i9-13950HX. Throughput is the median of five runs over one million deterministic (Re, k_s/D) inputs, with 5,000 <= Re <= 10^8 and 0 <= k_s/D <= 0.05. Values are in millions of scalar evaluations per second.
Accuracy is the maximum relative difference from Clamond over 161 logarithmically spaced Reynolds numbers from 4,000 to 10^8 and 82 roughness values: zero plus 81 logarithmic samples from 10^-6 to 0.05. Each correlation is evaluated only where its implemented Reynolds-number domain permits. Swamee–Jain starts at Re = 5,000. Blasius is evaluated only at zero roughness and 4,000 <= Re <= 100,000. Its throughput input is mapped into that Reynolds-number interval. Swamee all-regime is checked over 0.1 < Re < 10^8: its laminar branch is compared with 64/Re, its turbulent branch with Clamond, and 2,000 <= Re < 4,000 is excluded because the transition regime has no unique reference in this comparison.
On both hosts, Praks–Brkić and Brkić–Praks are substantially faster than Clamond while remaining below 0.17% maximum error on this grid. Their scores are nearly tied on the Dell 7710; the small score difference should not be treated as a significant performance separation without repeated process-level measurements. Goudar–Sonnad, Niazkar, and Serghides are much closer to the reference in error, but their measured throughput is below Clamond on these CPUs.
The error values are sampled-grid maxima, not proofs of a global error bound. The measurements characterize these compiler and host configurations; they do not predict performance on other CPUs, compilers, vectorization settings, or application input distributions. Blasius is a smooth-pipe-only comparison. The score penalizes maximum error but does not account for memory use, derivatives, setup costs, branch behavior, or application-specific worst cases. Validate the selected method on the application's own domain before using it for design or safety-critical calculations.
Both CUDA runs evaluate the same 1,048,576-element batch and summarize three process runs. GPU-kernel throughput keeps input data resident on the GPU. GPU + copies includes transfer of both input arrays and the output array for each pass. Rates are medians; ranges are shown where reported.
| Method | Dell 7710 CPU M/s | M3000M kernel M/s | M3000M + copies M/s | Dell 7680 CPU M/s | RTX 4090 kernel M/s | RTX 4090 + copies M/s |
|---|---|---|---|---|---|---|
| Swamee–Jain, primal | 19.47 (19.39–19.56) | 346.77 (346.65–346.88) | 138.62 (136.33–138.83) | 25.63 (25.62–25.64) | 1769.79 (1769.79–1770.30) | 231.03 (230.05–231.24) |
| Swamee–Jain + derivatives | 18.80 (18.76–18.81) | 269.69 (269.65–269.88) | 123.85 (120.32–124.77) | 22.97 (22.92–22.98) | 1393.20 (1392.82–1393.58) | 223.14 (222.07–223.25) |
| Clamond Colebrook, primal | 13.86 (13.85–13.89) | 198.33 (198.31–198.33) | 106.79 (106.77–106.89) | 20.45 (20.41–20.45) | 1019.92 (1019.72–1019.92) | 210.11 (209.51–210.24) |
| Colebrook Newton, primal | 12.56 (12.46–12.57) | 196.33 (196.32–196.36) | 104.96 (104.93–106.18) | 14.71 (14.68–14.71) | 1006.49 (1005.28–1006.70) | 210.21 (209.12–210.29) |
| Colebrook fixed point, primal | 7.16 (7.08–7.17) | 147.80 (147.72–147.92) | 90.12 (90.00–90.34) | 7.09 (7.07–7.09) | 731.13 (727.69–733.31) | 194.86 (194.06–195.04) |
| Clamond Colebrook + derivatives | 11.66 (11.66–11.68) | 128.96 (128.92–129.02) | 82.92 (82.85–82.93) | 13.13 (13.11–13.15) | 678.06 (677.98–678.16) | 190.30 (189.82–190.94) |
The RTX 4090 has higher measured throughput in both kernel and transfer-inclusive rates for every direct method in this workload. GPU speedup depends on method and batch size; these one-million-element rates do not imply a benefit for small batches. The benchmark's elementwise checks reported no failures for the direct GPU methods.
| Host / method | GPU kernel M/s | GPU + copies M/s | Max scaled errors (value / Re slope / roughness slope) | Failed checks |
|---|---|---|---|---|
| Dell 7710 Quadro M3000M — direct Colebrook | 131.90 (131.80–131.90) | 84.30 (84.20–84.50) | reference | 0 |
| Dell 7710 Quadro M3000M — adaptive bilinear | 172.00 (172.00–172.00) | 98.90 (98.40–99.20) | 1.7e-04 / 2.6e-01 / 2.6e-02 | 0 / 9425 / 11393 |
| Dell 7710 Quadro M3000M — adaptive bicubic | 134.20 (134.10–134.20) | 85.30 (84.90–85.50) | 6.2e-06 / 1.8e-02 / 1.7e-05 | 0 / 0 / 0 |
| Dell 7680 RTX 4090 Laptop — direct Colebrook | 950.70 (699.90–951.50) | 208.40 (195.30–211.60) | reference | 0 |
| Dell 7680 RTX 4090 Laptop — adaptive bilinear | 1234.70 (909.50–1235.50) | 219.60 (214.60–223.10) | 1.7e-04 / 2.6e-01 / 2.6e-02 | 0 / 9425 / 11393 |
| Dell 7680 RTX 4090 Laptop — adaptive bicubic | 986.90 (986.70–987.00) | 213.00 (212.10–213.50) | 6.2e-06 / 1.8e-02 / 1.7e-05 | 0 / 0 / 0 |
Scaled-error limits are 2e-4 for the factor, 2e-2 for the Reynolds slope, and 2e-3 for the roughness slope. Bilinear interpolation meets the factor tolerance but fails both derivative tolerances on both GPUs. Bicubic interpolation meets all three tolerances with zero failed checks. Bilinear is faster end-to-end than direct Colebrook on both GPUs, but its derivative failures make that speed unsuitable when both derivatives must meet the stated tolerances. Bicubic is slightly faster end-to-end than direct Colebrook on these batches and passes the checks.
The adaptive tables use 94,556 nodes (307 x 308). Bilinear coefficients occupy 2.87 MiB; bicubic coefficients occupy 11.47 MiB. Reported build times (bilinear / bicubic) were 226.35 / 225.14 ms on the M3000M and 221.51 / 185.59 ms on the RTX 4090. Initial uploads took 3.51 ms and 3.19 ms, respectively; upload is a separate setup cost and is not included in the GPU + copies rates.
These GPU results are host-specific measurements, not estimates for other GPUs or batch distributions. The 7680 direct and adaptive GPU results have noticeably wider run-to-run ranges for some kernels than the 7710 results; use the reported ranges when judging small throughput differences.
The two Markdown reports from a Slurm run are saved under /cluster/results/FrictionLibraryCpp20/approximation-comparison/JOB_ID/. The checked-in job 122 figures can be regenerated from those reports without rerunning the benchmark. From the repository root, install the pinned plotting dependencies and invoke the script:
python3 -m venv .venv-plots
. .venv-plots/bin/activate
python -m pip install -r scripts/requirements-approximation-plots.txt
JOB_ID=122
python3 scripts/plot_approximation_comparison.py \\
"/cluster/results/FrictionLibraryCpp20/approximation-comparison/$JOB_ID/dell7710.md" \\
"/cluster/results/FrictionLibraryCpp20/approximation-comparison/$JOB_ID/dell7680.md" \\
--error-budget-percent 1.0 \\
--output-dir "build/approximation-plots-job$JOB_ID"The output directory receives the throughput-versus-accuracy PNG, score-contour PNG, and combined PDF. Replace JOB_ID with another completed comparison job to plot its measurements. The default score budget is 1.0%; use --error-budget-percent PERCENT to make a separate plot at a different single budget.
To collect new measurements on the Dell Slurm nodes, submit scripts/run_approximation_comparison.sbatch from a checkout visible to both nodes. The job writes one report per host and uses the same 1.0% default; FRICTION_ERROR_BUDGET_PERCENT overrides it.
Run the suite on the machine whose results you want to report:
python3 scripts/run_performance_suite.py --cuda --cuda-arch 52 --runs 7 --gpu-runs 3Omit --cuda on systems without the CUDA Toolkit and a supported NVIDIA GPU. The script writes a full report and raw logs into the selected build directory (default: build-performance/) and replaces the generated-results block below in this README. Commit the README update only after reviewing the machine, compiler, test results, and accuracy checks in the report. To insert a report you already generated without rerunning benchmarks, use python3 scripts/run_performance_suite.py --insert-results build-performance-v2/performance-results.md (an absolute path also works).
The generated block below is the earlier one-process CPU-only run on the Dell 7710; CUDA was not requested for that run. The two-host CUDA measurements from the later three-process runs are reported in the comparison above. Running scripts/run_performance_suite.py replaces this generated block with a machine-specific report, so it does not combine the two GPU hosts.
Generated: Linux-7.0.0-42-generic-x86_64-with-glibc2.43
CPU: Intel(R) Core(TM) i7-6920HQ CPU @ 2.90GHz
C++ compiler: c++ (Ubuntu 15.2.0-16ubuntu1) 15.2.0
CPU benchmark repetitions: 1 process runs; CPU rows show median (min–max) throughput.
CPU compiler flags: CMake Release plus -O3 -march=native for benchmark targets.
Tests:
Test project /cluster/projects/FrictionLibraryCpp20/build-phase3-4
Start 1: friction
1/8 Test #1: friction ............................. Passed 0.00 sec
Start 2: analytic_derivatives
2/8 Test #2: analytic_derivatives ................. Passed 0.00 sec
Start 3: batch
3/8 Test #3: batch ................................ Passed 0.00 sec
Start 4: colebrook_methods
4/8 Test #4: colebrook_methods .................... Passed 0.00 sec
Start 5: approximations
5/8 Test #5: approximations ....................... Passed 0.03 sec
Start 6: approximation_score
6/8 Test #6: approximation_score .................. Passed 0.00 sec
Start 7: adaptive_tensor_surrogate
7/8 Test #7: adaptive_tensor_surrogate ............ Passed 0.23 sec
Start 8: adaptive_bilinear_tensor_surrogate
8/8 Test #8: adaptive_bilinear_tensor_surrogate ... Passed 0.24 sec
100% tests passed, 0 tests failed out of 8
Total Test time (real) = 0.52 sec
Primal rows are friction-factor solves/evaluations; derivative rows compute the primal plus both first derivatives.
| Method | CPU M/s (median; range) | Outputs |
|---|---|---|
| Swamee–Jain | 19.59 (19.59–19.59) | Primal explicit correlation |
| Swamee–Jain + derivatives | 17.77 (17.77–17.77) | Primal + df/dRe + df/d(k_s/D) |
| Newton Colebrook | 13.03 (13.03–13.03) | Primal; converged solve |
| Clamond Colebrook | 12.96 (12.96–12.96) | Primal; 2 updates |
| Clamond Colebrook + derivatives | 11.52 (11.52–11.52) | Primal + df/dRe + df/d(k_s/D) |
| Fixed-point Colebrook | 7.08 (7.08–7.08) | Primal; converged solve |
All direct CPU methods use the same deterministic 8,192-point turbulent input set and benchmark executable. It performs 250 passes per method. Solver results also report iteration counts and checksums in the raw logs.
All three methods evaluate the same 1,048,576 deterministic (Re, k_s/D) inputs and return the factor and both derivatives. Each executable run reports the median of five passes; the table below reports the median (range) across process runs.
| Method | CPU M eval/s (median; range) |
|---|---|
| Direct Colebrook + gradients | 10.81 (10.78–10.85) |
| Adaptive bicubic + gradients | 7.69 (5.55–9.82) |
| Adaptive bilinear + gradients | 4.12 (4.12–4.12) |
Adaptive bilinear tensor: 94556 nodes (307 x 308), 6.08 MiB, 12 refinement rounds, build=0.222 s Adaptive tensor table: 94556 nodes (307 x 308), 15.78 MiB, 12 refinement rounds, build=0.233 s, final indicator=0.000
Measured on both Dell systems with CUDA, using a 1,048,576-element batch and three process runs. Kernel rates keep inputs resident; GPU + copies includes transfers of both inputs and the output.
| Host / method | GPU kernel M/s | GPU + copies M/s |
|---|---|---|
| Dell 7710 Quadro M3000M — Clamond | 198.33 | 106.79 |
| Dell 7710 Quadro M3000M — Swamee–Jain | 346.77 | 138.62 |
| Dell 7680 RTX 4090 Laptop — Clamond | 1019.92 | 210.11 |
| Dell 7680 RTX 4090 Laptop — Swamee–Jain | 1769.79 | 231.03 |
Adaptive interpolation results:
| Host / method | GPU kernel M/s | GPU + copies M/s | Failed value / Re-slope / roughness-slope checks |
|---|---|---|---|
| Dell 7710 — direct Colebrook | 131.90 | 84.30 | reference |
| Dell 7710 — adaptive bilinear | 172.00 | 98.90 | 0 / 9425 / 11393 |
| Dell 7710 — adaptive bicubic | 134.20 | 85.30 | 0 / 0 / 0 |
| Dell 7680 — direct Colebrook | 950.70 | 208.40 | reference |
| Dell 7680 — adaptive bilinear | 1234.70 | 219.60 | 0 / 9425 / 11393 |
| Dell 7680 — adaptive bicubic | 986.90 | 213.00 | 0 / 0 / 0 |
Bilinear met the factor tolerance but failed both derivative tolerances. Bicubic passed all three tolerances on both GPUs.
An experimental MLP surrogate was trained against direct Clamond
Colebrook results over 4000 <= Re <= 1e8 and
1e-6 <= k_s/D <= 0.05, then compiled to Hailo-10H. The full
Slurm/Podman training, compilation, and validation workflow is documented in
scripts/hailo/README.md.
The width sweep did not improve useful evaluation throughput on the Hailo: the built-in HailoRT benchmark stayed near 3.2k eval/s, and the pipelined Python validator stayed near 3.4k eval/s for all three models. Wider networks raised nominal operations per evaluation, so the derived MLP-equivalent rate rose without increasing the number of friction predictions per second.
| Hidden width | Parameters | MAC/eval | HailoRT FPS | Pipelined eval/s | Hailo max relative error | Hailo RMS relative error |
|---|---|---|---|---|---|---|
| 64 | 6,465 | 6,304 | 3,242.99 | 3,355.54 | 2.319% | 0.687% |
| 128 | 21,057 | 20,768 | 3,245.60 | 3,376.28 | 2.184% | 0.675% |
| 256 | 74,817 | 74,272 | 3,222.87 | 3,378.73 | 2.229% | 0.701% |
The width-128 model gave the best Hailo holdout metrics, but the improvement
over width 64 was modest. Width 256 added substantially more parameters and
arithmetic without improving the Hailo error metrics or evaluation rate.
The DFC compiler_optimization_level=max setting and larger HailoRT batches
also failed to improve evaluation throughput. On the Dell 7710 Quadro M3000M,
the corresponding CUDA rates were 20.214M, 13.926M, and 6.764M eval/s for
widths 64, 128, and 256. This is a negative result for using this small scalar
Colebrook surrogate to exploit Hailo compute throughput; it does not establish
a limitation for larger engineering surrogates or other workloads.
The project is licensed under GNU Affero General Public License version 3 only (AGPL-3.0-only); see LICENSE. If you need different commercial terms, contact the rights holders to discuss a separate written agreement. This repository does not grant a commercial license or specify a fee or royalty schedule; any such terms must be agreed separately by the relevant rights holders. See COPYRIGHT for the project-level rights notice.
This patch set updates the three repositories in dependency order:
- ThermoGPU adds a device-callable full-state fixed-composition PR mixture evaluator and a CUDA workspace. It returns density, enthalpy, entropy, caloric properties, compressibility, and the analytic T,p derivatives used by the compressor equations. The CPU mixture implementation is included so the CUDA API does not depend on an unmerged local-only type.
- FrictionLibraryCpp20 exposes its two-update Clamond Colebrook kernel as a host/device API, instead of leaving the CUDA implementation inside a benchmark executable.
- TurboCompGPU adds an optional CUDA parity executable that evaluates a natural-gas mixture through ThermoGPU CUDA and friction factors through the friction CUDA API, then compares both with CPU results.
This is the API and parity foundation for the compressor GPU port. It does not yet move TurboCompGPU's nonlinear impeller/diffuser stage solve onto the GPU. The next implementation slice is the batched stage kernel, using the device mixture parameter block and friction function established here. No GPU build or runtime test was possible in this workspace because it has no CUDA compiler or GPU; the parity executable is intended for the Slurm nodes.
Apply each patch in its own repository, in this order:
cd ~/Sync/ThermoGPU
git apply --check /path/to/01-thermogpu-pr-mixture-cuda.patch
git apply /path/to/01-thermogpu-pr-mixture-cuda.patch
cd ~/Sync/FrictionLibraryCpp20
git apply --check /path/to/02-friction-cuda-api.patch
git apply /path/to/02-friction-cuda-api.patch
cd ~/Sync/TurboCompGPU
git apply --check /path/to/03-turbocompgpu-cuda-api.patch
git apply /path/to/03-turbocompgpu-cuda-api.patch
git apply --check /path/to/04-gpu-parity-program.patch
git apply /path/to/04-gpu-parity-program.patchBuild and install ThermoGPU with CUDA enabled, then install FrictionLibrary so
its friction::friction CMake target and new header are available. Configure
TurboCompGPU with -DTURBOCOMPGPU_ENABLE_CUDA=ON and both installs on
CMAKE_PREFIX_PATH, then build turbocompgpu_gpu_backend_parity.
The FrictionLibrary CUDA header is AGPL-3.0-only. Confirm the desired distribution/license treatment for binaries that combine it with the GPL-3.0-or-later TurboCompGPU executable before distributing those binaries.

