FluidX3D v2.3 (particles)

Particle update:

• added particles with immersed-boundary method (either passive or 2-way-coupled, only supported with single-GPU)
• minor optimization to GPU voxelization algorithm (workgroup threads outside mesh bounding-box return after ray-mesh intersections have been found)
• displayed GPU memory allocation size is now fully accurate
• fixed bug in write_line() function in src/utilities.hpp
• removed .exe file extension for Linux/macOS
• refactoring and cosmetics

FluidX3D v2.2 (velocity voxelization)

Velocity voxelization update:

• simulation of moving/rotating geometry is now possible, here is a demo
  • added option to voxelize moving/rotating geometry on GPU, with automatic velocity initialization for each grid point based on center of rotation, linear velocity and rotational velocity
  • cells that are converted from solid->fluid during re-voxelization now have their DDFs properly initialized
  • added option to not auto-scale mesh during read_stl(...), with negative size parameter
• added kernel for solid boundary rendering with marching-cubes

FluidX3D v2.1 (fast voxelization)

Fast GPU voxelization update:

• new algorithm for .stl mesh GPU voxelization: ~500x faster now, from minutes to milliseconds
• added unvoxelize kernel, to quickly remove all boundaries in the mesh bounding box.
• removed old hull voxelization algorithm

Old: naive GPU voxelization

• For each voxel in the 3D grid, cast a ray from the voxel center in an arbitrary direction, and check with all mesh triangles for intersection.
• Count the number of intersections.
• Odd number of intersections means the voxel is inside.
• Runtime: N³×Triangles

New: fast GPU voxelization

• Only for the 2D bottom layer of grid points, shoot vertical rays upward and check with all mesh triangles for intersection.
• The vertical rays pass through all voxels in the columns above, so these don't have to be checked for ray-mesh intersection at all.
• Store all intersection distances in a short array in registers.
• Sort this array with insertion sort.
• Iterate through the vertical column of voxels.
  • The first voxel is inside/outside depending on odd/even total intersection count.
  • Each time one of the stored distances in the sorted array is passed, switch inside/outside state.
• Optimizations
  • Only check inside the bounding box of the mesh.
  • Don't always start from the bottom (z-direction), but from the direction where the mesh bounding box has the smallest cross-section area, so the smallest number of ray-mesh intersections have to be tested.
  • To avoid errors on the odd/even total number of intersections, shoot a second ray in the opposite direction and only count the intersection number. Both have to be odd for the bottom voxel to start in inside state.
• Runtime: N²×Triangles, if N=500, this is 500x faster than naive voxelization

Known issues:

• voxelization might not always produce binary identical results in multi-GPU (floating-point round-off on ray-triangle instersection distances may differ for different ray origin) --> fixed in v2.16!

FluidX3D v2.0 (multi-GPU upgrade)

Big multi-GPU Update:

• Multi-GPU simulations are now possible on a single node (PC/laptop/server), allowing to pool VRAM from multiple GPUs.
  • Easy setup with minimal changes to the user: instead of LBM lbm(Nx, Ny, Nz, nu, ...);, use LBM lbm(Nx, Ny, Nz, Dx, Dy, Dz, nu, ...);, with Dx/Dy/Dz indicating how many domains (GPUs) in each spatial direction to use. By default, all identical GPUs will be automatically assigned their domains, however the GPUs can also be manually set with a list of their indices: ./make.sh 2 6 3 4 or /bin/FluidX3D 2 6 3 4.
  • All extensions are supported and validated to produce binary identical results compared to single-GPU simulations.
  • Multi-GPU also works with non-identical GPUs, regardless of vendor. Yes, you can run FluidX3D on unholy combinations of Nvidia/AMD/Intel GPUs/CPUs at the same time. I only recommend similar memory capacity and bandwidth, as the weakest GPU will bottleneck performance.
  • No SLI/Crossfire/NVLink/InfinityFabric is required. All communication runs over PCIe and is compatible with all hardware.
  • No MPI installation is required.
  • Total grid resolution must be equally divisible into domains, such that all domains are the same size.
  • The resolution of each domain is restricted to 4.29 billion grid points (2³², 225GB VRAM), but domain number and thus total grid resolution is unrestricted.
  • Under the hood: Complete re-write of C++ backend, to account for the domain decomposition architecture. The code is already fully optimized and shortened for maximum maintainability/upgradeability.
• Grid resolution can now be arbitrary and is not anymore restricted to the condition (Nx*Ny*Nz)%WORKGROUP_SIZE==0.

Known issues:

• Raytracing graphics are disabled for multi-GPU. The simulated light rays would have to travel through the entire simulation box, crossing domain boundaries. This is not easily possible, because each GPU only keeps its own domain in VRAM.

FluidX3D v1.4 (Linux graphics)

• Big update for Linux users: Added interactive graphics mode on Linux with X11. No external dependencies, compiles out-of-the-box with the "compile on Linux with X11" command in make.sh.
• Re-wrote C++ graphics library to minimize API dependencies
• Colors are now signed int consistently.
• Fixed streamline visualization in 2D.

FluidX3D v1.3 (minor bug fixes)

• added OpenCL driver bug workaround for old AMD GPUs (binary number literals for flag bitmasks don't work, so change to hexadecimal literals)
• FORCE_FIELD and VOLUME_FORCE can now be used independently
• added unit conversion functions for torque

FluidX3D v1.2 (force/torque compuatation)

• added functions to compute force/torque on objects
• added function to translate Mesh
• added Stokes drag validation setup
• added more benchmarks in Readme

FluidX3D v1.1 (GPU voxelization)

• added new GPU voxelization
• fixed broken triangle rendering with some Intel iGPUs (driver bug workaround in marching_cubes)
• added tool to print current camera position (key G)
• refactoring

FluidX3D v1.0 (public release)

Initial public release of FluidX3D.