Open files.

How it works

Parts

The frame is four pieces made from two part numbers.

Material

All pieces are FDM printed in PPA-CF (carbon-fiber-filled polyamide).

Joining

The four pieces are fused into a single frame with a soldering iron. No fasteners, inserts or snap features are used, which keeps the design low in part count and complexity.

Geometry and use

• The side profile is triangular, with an angle of about 18 degrees.
• Lying orientation: supports a laptop.
• Standing orientation: holds an iPad upright against the lip on the tall side of the triangle.

Files

• side-o1.0A.stl, top-o1.0A.stl: the original meshes and the source of truth.
• side-o1.0A.step, top-o1.0A.step: solids rebuilt from the STLs. The meshes were sewn into closed solids and coplanar triangles were merged into flat faces (side: 580 triangles to 145 faces; top: 2344 triangles to 498 faces). They are valid closed solids you can use for measuring and boolean edits, but they are not parametric.

Build and use

1. Print two copies of side-o1.0A.stl and two copies of top-o1.0A.stl in PPA-CF on an FDM printer.
2. Arrange the two side pieces and two top pieces into the frame.
3. Fuse the pieces together along their joints with a soldering iron to form one rigid part.
4. Use it lying down to hold a laptop at about 18 degrees, or flip it upright to hold an iPad.

Known limits

• The uppermost lip on the tall side of the triangle is shallow, so in the upright position the iPad is held partly by friction rather than by a deeper mechanical lip.
• The STEP files are rebuilt from the STL meshes and are not parametric; the STL files are the true originals.

How it works

The design has two parts:

The parts have been printed in PETG.

Fans and power

The fans are 90 mm desktop PC fans. They are powered over USB: the USB leads are wired in series, so the fans see about 10 V instead of a 12 V supply.

Filter

Filtration is done by a Briggs & Stratton 593260 air filter, the oval pleated paper filter. It is a common replacement part, so it is easy to find and swap.

Build and use

What you need:

• The printed body and inlet, in PETG
• 90 mm desktop PC fans
• USB leads, wired in series to supply about 10 V to the fans
• A Briggs & Stratton 593260 air filter (oval pleated paper)

Files in this revision:

• body-o1.0A.step: body (STEP)
• inlet-o1.0A.step: inlet (STEP)
• inlet-o1.0A.stl: inlet (STL, ready to slice)
• Print the inlet from inlet-o1.0A.stl, or export an STL from the STEP file.
• Export the body from body-o1.0A.step to a mesh and print it.
• The parts have been printed in PETG.
• Mount the inlet to the body.
• Fit the fans and wire their USB leads in series.
• Fit the Briggs & Stratton 593260 filter.

Known limits

• Airflow and CADR (clean air delivery rate) have not been measured.
• Filtration performance has not been tested. The 593260 is an engine intake filter, not a rated HEPA filter, and no particle capture figures exist for this build.
• Running 12 V PC fans at about 10 V from USB means they spin slower than their rated speed and move less air than their spec sheets state.
• The body is provided as STEP only. You need to export your own mesh from body-o1.0A.step before slicing it.

How it works

Governing equations

du/dt + div(u u) = -grad(p)/rho + nu*lap(u) + f_ibm
div(u) = 0

Incompressible, isothermal, Newtonian, constant density.

Numerical choices

The FFT pressure solver is the load-bearing decision. It is what makes the runtime budget achievable, and it is why the grid must be uniform: there is no local refinement near the body, and that is the method's main cost. The compute kernels are written in Numba; they are the solver, not an optional speed-up.

Axis convention

x is streamwise (inlet to outlet), y is vertical (ground at y=0, lift along +y), z is spanwise. The axis_order setting permutes the STL's axes into that frame.

Code layout

waterfall_core/     solver package
  grid.py           staggered MAC grid; nz=1 collapses to 2D
  poisson.py        DCT pressure solver
  kernels.py        numba convection, diffusion, divergence, IBM, derived fields
  boundary.py       boundary conditions
  solver.py         fractional-step time loop
  geometry.py       STL -> solid volume fraction
  shapes.py         analytic geometry for benchmarks
  sgs.py            Vreman subgrid model
  config.py         YAML config, domain sizing, pre-flight
  io.py             frame output (npz) and VTK export
  runs.py           run registry and subprocess supervision (UI)
benchmarks/         verification cases with published reference values
cases/              example configurations
ui.py               local web app (FastAPI)
ui/                 front end (no build step)
legacy/             the previous ray-based estimator, kept for reference

Validation

The benchmark suite covers exact checks (Poisson, freestream, divergence), a laminar Blasius boundary layer against the similarity solution, a circular cylinder (Cd, Strouhal number, recirculation length) and a square cylinder for sharp-edged separation. Measured results:

• Velocity and pressure fields: Blasius profile L2 error 0.7-1.3%
• Wake structure, separation and recirculation length converge into the reference range
• Shedding dynamics: Strouhal number within 2.6% of reference
• Drag: treat as +/-10%

Legacy ray estimator

legacy/ray_solver.py is the original ray-based estimator. It contained no fluid physics: no momentum equation, no continuity, no pressure-velocity coupling and no Reynolds-number dependence. It could not run any of the benchmarks. It is kept only as a record of what the numbers in old summary.txt files meant.

Build and use

Install

Create a virtual environment and install the dependencies:

python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
python -m pip install numpy scipy trimesh matplotlib rtree numba scikit-image imageio imageio-ffmpeg pyyaml fastapi "uvicorn[standard]" python-multipart

Numba is required.

The app

python ui.py

A browser opens at http://127.0.0.1:8010. The app listens on loopback only, so nothing is exposed to the network.

• New run: drag an STL onto the page. The app reads the mesh, guesses the flow axis, and draws side, plan and front previews with the flow direction marked. Enter the part's real length in metres and the scale factor is worked out automatically. Runtime and cell count update live as settings change.
• Running: progress bar, ETA, step count, live divergence and force, a tail of the solver log, and a Stop button.
• Projects: every past run as a card with its Cd and a thumbnail. Open one for the result tiles, the animation, the geometry preview, the full log, and every file the run produced, all downloadable.

Always check the orientation preview before running. The flow-axis guess assumes the longest dimension faces the flow. That is right for a car and wrong for a bumper, wing or splitter. A wrong axis does not raise an error; it returns a confident, wrong drag number. Results in the app carry their own caveats: if subgrid viscosity or resolution made a number untrustworthy, the run says so next to the number.

Run a case from the terminal

The Tesla case geometry (geometries/tesla_model_s_2023.stl) is a third-party model and is not shipped; bring your own STL and point geometry.path at it.

Pre-flight only (geometry validity, orientation preview, domain bounds, blockage, cell count and estimated wall-clock time). Always run this first:

python waterfall.py cases/tesla.yaml --check

Full run, writing summary.json (Cd, Cl, forces, diagnostics) and a directory of frames:

python waterfall.py cases/tesla.yaml

Render PNG frames and an MP4 (coloured slice, streamlines and a 3D Q-criterion iso-surface of the wake):

python visualize_waterfall.py output/tesla/frames --layout dashboard --fps 30

Configuration

See cases/tesla.yaml for a fully commented example.

geometry:
  path: geometries/car.stl
  units: mm
  axis_order: yzx        # which STL axis becomes solver x (streamwise), y (up), z (span)
domain:
  cells_per_length: 40   # resolution, measured along the STREAMWISE extent
  upstream: 1.5          # domain padding, in body lengths
  downstream: 4.0
flow:
  speed: 30.0            # m/s
  viscosity: 1.5e-5      # kinematic, m^2/s
  rolling_road: true     # a fixed floor is a tunnel artefact
run:
  convective_times: 6.0
  output: output/car

Override settings from the command line without editing the file:

python waterfall.py cases/tesla.yaml --override domain.cells_per_length=24

Validation benchmarks

python benchmarks/smoke.py        # exact checks: Poisson, freestream, divergence
python benchmarks/blasius.py      # laminar boundary layer vs similarity solution
python benchmarks/cylinder.py     # bluff body: Cd, Strouhal, recirculation
python benchmarks/bluff_body.py   # square cylinder, sharp-edged separation

Known limits

• Force magnitude is not grid-converged: on a Re=40 cylinder Cd moves away from a limit under refinement (1.610, 1.622, 1.779 at 16/24/32 cells per diameter) while the flow field converges. Treat drag as +/-10% and never compare cases run at different resolutions, because the bias is resolution dependent.
• Absolute vehicle Cd is out of envelope: the Model S case returns 0.557 against a published 0.208. Subgrid viscosity on an affordable grid reaches 1.2e4 times molecular, putting the effective Reynolds number near 850 instead of 1e7.
• Streamlined bodies are the worst case: at 138 mm cells the smooth pressure-recovery taper becomes a staircase drowned in eddy viscosity, and the body behaves bluff. Every passing benchmark is a bluff body.
• There is no wall model: the first cell off the body sits far outside the viscous sublayer at vehicle Reynolds numbers, so friction drag is not physical.
• The grid is uniform with no local refinement near the body, a direct consequence of the FFT pressure solve and the reason resolution is expensive.
• An incorrect axis_order still produces a plausible drag number instead of an error, so orientation must be checked by the user.