Realtime CFD ?

[Cd]

Placing this here in the hope that some of you smart people can figure this program/app out.

The (software ? ) is called Fluid X3D

Here is a link to a video of a render : https://youtu.be/5AzxwQpng0M

It APPEARS to even be opensorce :
" The fastest and most memory efficient lattice Boltzmann CFD software, running on any GPU via OpenCL."

[freebeard]

"Space Shuttle 10 billion voxel CFD on 8x 64GB GPUs"

An example (DDGs first choice) of a computer that would take eight GPU: www.titancomputers.com/Titan-A575-Up-to-8x-NVIDIA-Multi-GPUs-Computing-p/a575.htm. $9,700 with one GPU; so 8xhundreds more. that's no home gamer rig.

OTOH the Github FAQ says

I'm on a budget and have only a cheap computer. Can I run FluidX3D on my toaster PC/laptop?

Absolutely. Today even the most inexpensive hardware, like integrated GPUs or entry-level gaming GPUs, support OpenCL. You might be a bit more limited on memory capacity and grid resolution, but you should be good to go. I've tested FluidX3D on very old and inexpensive hardware and even on my Samsung S9+ smartphone, and it runs just fine, although admittedly a bit slower.

https://github.com/ProjectPhysX/FluidX3D

Have you tried it yet? It will be a while until I clear my schedule for this.

[aerohead]

There's much we'd need to know.
* The Space Shuttle was a MACH-8, un-powered glider. Automobiles are subsonic.
* It only spent a very limited time in the atmosphere.
* It entered the upper atmosphere at 18,000-mph.
* Transitioning down to a couple hundred mph upon touch down.
* It operated in an unbounded flow domain, unlike an automobile which is severely constrained by the ground plane.
* It was essentially an all-vortex-generator, delta-wing lifting device. Vortex-drag on an automobile is of the highest form of drag. Designers would do all they could to prevent its formation.
--------------------------------------------------------------------------------------
If Fluid X3D is an aeronautical CFD software package, it may be of zero use to us.
There may be requirements for the data cloud which precede the use of the program.
We might need a mini-supercomputer to run it.
Automotive requirements include 3D flow, which in implied in the software's title.
Viscous flow is a requirement.
Theoretically, it would require solving the Full Navier-Stokes Equation, which is for supercomputers, not desk-tops. 130-parallel desk-tops, yes!

We'd need the help of a qualified modeler.

[freebeard]

We might need a mini-supercomputer to run it.
....
Theoretically, it would require solving the Full Navier-Stokes Equation, which is for supercomputers, not desk-tops. 130-parallel desk-tops, yes!

Did you look at it at all?

Compatibility
works in Windows, Linux and Android with C++17
runs on any hardware that supports OpenCL 1.2, from any vendor (Nvidia, AMD, Intel, ...):
world's fastest datacenter GPUs like H100, A100, MI250(X), MI210, MI100, V100(S), P100, ...
gaming GPUs (desktop or laptop)
"professional"/workstation GPUs
integrated GPUs
Xeon Phi
CPUs
even smartphone ARM GPUs

www.opensourceagenda.com/projects/fluidx3d

also:

Compute Features
CFD model: lattice Boltzmann method (LBM)

[aerohead]

Originally Posted by freebeard

Did you look at it at all?


www.opensourceagenda.com/projects/fluidx3d

None of that information addresses the specifics.
Vekke would have had to pay 23,000 Euros for the Solidworks CFD package.
A three-month rental was 2,300-Euro.
And his school may have been providing his work station.
According to Anthony Jameson, McDonnel Professor of Aerospace Engineering, Princeton University, just solving a wing section required 294,912 cells, requiring a solution for 1,474,560 unknowns.
EXA POWERFLOW required almost 48-hours run time, on a 130-core processor, for a single iteration of a Tesla.
Where do we get the billion-cell 3D laser-scan/ data-cloud of our test car?

[Piotrsko]

I would like to remind: todays semi obsolete desktop 4+ core is equivalent to a cray supercomputer in 1990. Just needs a better OS.

[freebeard]

None of that information addresses the specifics.

Did you look at it at all?

[aerohead]

Originally Posted by freebeard

Did you look at it at all?

I looked at your list.
I didn't see anything that would inform about decisions.
--------------------------------------------------------------------------------------
1) where does the full-scale 3D laser-scan of millimeter-scale resolution point cloud come from? Or CAD-CAM file from the automaker?
2) do we need to pre-condition the cloud with a Kappa-Epsilon turbulence model?
3) do we need a 120-core processor, as with SIEMENS' STAR-CCM+ software?
4) does it perform wheel rotation?
5) how long can we expect to wait for a result? ( 3-hours and 25-minutes? as with a 120-core & SIEMENS? )
6) do we 'buy' it?
7) do we 'lease' it?

[freebeard]

1) To Be Determined
2) [shrug]
3) Compatibility
4) [shrug]
5) Follows from 3).
6) and 7) Demonstrates a total lack of understandig of Free and Open Source software. You can charge for support.

This suggests you haven't visited the GitHub page at all. I'm not going to reproduce the nested list format for your convenience. The source is just a click away.

FluidX3D
The fastest and most memory efficient lattice Boltzmann CFD software, running on any GPU via OpenCL.

Compute Features
CFD model: lattice Boltzmann method (LBM)
streaming (part 2/2):
f0temp(x,t) = f0(x, t)
fitemp(x,t) = f(t%2 ? i : (i%2 ? i+1 : i-1))(i%2 ? x : x-ei, t) for i ∈ [1, q-1]

collision:
ρ(x,t) = (Σi fitemp(x,t)) + 1

u(x,t) = 1∕ρ(x,t) Σi ci fitemp(x,t)

fieq-shifted(x,t) = wi ρ · ((u°ci)2∕(2c4) - (u°u)∕(2c2) + (u°ci)∕c2) + wi (ρ-1)

fitemp(x, t+Δt) = fitemp(x,t) + Ωi(fitemp(x,t), fieq-shifted(x,t), τ)

streaming (part 1/2):
f0(x, t+Δt) = f0temp(x, t+Δt)
f(t%2 ? (i%2 ? i+1 : i-1) : i)(i%2 ? x+ei : x, t+Δt) = fitemp(x, t+Δt) for i ∈ [1, q-1]

peak performance on most GPUs (datacenter/gaming/professional/laptop), validated with roofline model
up to 4.29 billion (2³²) lattice points, or 1624³ resolution, on a single GPU (if it has 225 GB memory)
optimized to minimize memory demand to 55 Bytes/node (~⅙ (~⅓) of conventional FP64 (FP32) LBM solvers)
in-place streaming with Esoteric-Pull: almost cuts memory demand in half and slightly increases performance due to implicit bounce-back boundaries; offers optimal memory access patterns for single-node in-place streaming
decoupled arithmetic precision (FP32) and memory precision (FP32 or FP16S or FP16C): all arithmetic is done in FP32 for compatibility on all hardware, but LBM density distribution functions in memory can be compressed to FP16S or FP16C: almost cuts memory demand in half again and almost doubles performance, without impacting overall accuracy for most setups
DDF-shifting and other algebraic optimization to minimize round-off error
updating density and velocity in the stream_collide() kernel is optional (higher performance if disabled)
velocity sets:
D2Q9
D3Q15
D3Q19 (default)
D3Q27
collision operators
single-relaxation-time (SRT/BGK) (default)
two-relaxation-time (TRT)
only 8 flag bits per lattice point (can be used independently / at the same time):
TYPE_S (stationary or moving) solid boundaries
TYPE_E equilibrium boundaries (inflow/outflow)
TYPE_T temperature boundaries
TYPE_F free surface (fluid)
TYPE_I free surface (interface)
TYPE_G free surface (gas)
TYPE_X remaining for custom use or further extensions
TYPE_Y remaining for custom use or further extensions
Optional Compute Extensions
boundary types
stationary mid-grid bounce-back boundaries (stationary solid boundaries)
moving mid-grid bounce-back boundaries (moving solid boundaries)
equilibrium boundaries (non-reflective inflow/outflow)
temperature boundaries (fixed temperature)
global force per volume (Guo forcing), can be modified on-the-fly
local force per volume (force field)
optional computation of forces from the fluid on solid boundaries
state-of-the-art free surface LBM (FSLBM) implementation:
volume-of-fluid model
fully analytic PLIC for efficient curvature calculation
improved mass conservation
ultra efficient implementation with only 4 kernels additionally to stream_collide() kernel
thermal LBM to simulate thermal convection
D3Q7 subgrid for thermal DDFs
in-place streaming with Esoteric-Pull for thermal DDFs
optional FP16S or FP16C compression for thermal DDFs with DDF-shifting
Smagorinsky-Lilly subgrid turbulence LES model to keep simulations with very large Reynolds number stable
equations

Can you tell us what the lattice Boltzmann method is or does?

Lattice Boltzmann methods
The lattice Boltzmann methods, originated from the lattice gas automata method, is a class of computational fluid dynamics methods for fluid simulation. Instead of solving the Navier–Stokes equations directly, a fluid density on a lattice is simulated with streaming and collision processes.Wikipedia

[aerohead]

here's some things it would incorporate:
MACH number
Kutta & Joukowski airfoil theory
Karman vortex street
Haye's theory of linearized supersonic flow
Jone's slender wing theory
Prandtl's wing theory
Prandtl's boundary layer theory
Whitcomb's area rule for transonic flow
Navier-Stokes Equation
conservation of mass, momentum, and energy
Cartesian tensor notation
Reynolds equations
turbulence models
shock wave-boundary layer interactions
inviscid Euler equations
Kelvin's theorem
Crocco's theorem
entropy
Prandtl-Glauert equation
Laplace's equation\
Galerkin Method
frozen oscillatory modes
one-dimensional scalar conservation law
total variation diminishing ( TVD )
upwind biasing
rotated difference scheme
first-order accurate
second-order accurate
flux limiters
higher order antidiffusive terms
higher order corrective terms
multidimensional Euler equations
Courant-Friedrichs-Lewy ( CFL ) condition
Newton iteration
Gauss-Seidel method
Jacobi method
lower-upper ( LU ) factorization
Blended multistage schemes
Multigrid time-stepping
elliptic equations
hyperbolic systems
mesh generation
viscous flow simulation
Hyperbolic marching methods
potential flow equation
single finite element approximation
Delaunay triangulation
Voronoi diagram
polyhedral neighborhoods
constrained optimization
partial differential equations
conformal mapping
perturbation analysis
integration by parts