Skip to content

About

No description, website, or topics provided.

Resources

Contributing

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

FrictionLibraryCpp20: Engineering Report

CI

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.

Library scope

  • 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 existing Correlation enum or its transition blend.
  • All-regime API: laminar 64/Re behavior 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::span interfaces 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.

Build and install

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_example

See QUICKSTART.md for installation, downstream use, CPack, and optional benchmark instructions. See CHANGELOG.md for changes planned for the next release.

API example

#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.

Model domain and transition convention

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.

Optional derivative verification with Enzyme

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-failure

The 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.

Numerical methods and performance

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 variable 1/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.

Engineering report: measured friction-factor approximations

Objective and decision metric

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.

Results

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%.

Figures

Measured throughput versus maximum relative error for both Dell hosts

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.

Accuracy-adjusted throughput score contours for a 1.0% error budget

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.

Experimental method and provenance

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.

Engineering interpretation and limits

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.

CUDA measurements on the two Dell systems

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.

Direct methods
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.

Adaptive 2D interpolants
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.

Reproduction

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.

Supplementary CPU/GPU suite reproduction

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 3

Omit --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).

Performance-suite snapshot

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

CPU direct methods

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.

CPU adaptive 2D interpolants

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

GPU results

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.

Hailo-10H Clamond surrogate experiment

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.

License

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.

GPU compressor API integration, first slice

This patch set updates the three repositories in dependency order:

  1. 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.
  2. FrictionLibraryCpp20 exposes its two-update Clamond Colebrook kernel as a host/device API, instead of leaving the CUDA implementation inside a benchmark executable.
  3. 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

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.patch

Build 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.

About

No description, website, or topics provided.

Resources

Contributing

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages