Trick Smoothed Particle Hydrodynamics (TSPH) Sim README (#1175)

* Create base simulation file/directory structure

* Create particle class in a Trick header file

* Create Fluid class with simulation initialization and update jobs in Trick header

* Create S_define for SIM_fluid

* Create S_overrides.mk for SIM_fluid

* Change Particle to a struct and initialize pos, velocity, and force arrays in constructor

* Store particles as an std::vector instead of an array

* Implement default_data method and dummy update_SPH for Fluid.cpp

* Add core CUDA SPH simulation code to Trick simulation

* Copy CPU-based SPH fluid sim code to Trick src directory

* Remove all code involving rigid body simulation

* Modify updateSPH routine to use CPU-based routines rather than GPU-based routines

* Temporarily comment out neighbor list logic

* Replace use of glm::vec3 with float[3] in sph.cpp and sph.h

* Move simulation parameters from sph.h to Trick Fluid.hh

* Remove particle struct and function prototypes from sph.h

* Move core simulation routines from sph.cpp to Fluid.cpp

* Remove neighbor list comments from Fluid.cpp

* Remove extraneous initSPH function

* Add calls to core simulation routines in Fluid::update_SPH()

* Refactor core simulation functions into private member functions of the Fluid class

* Remove static qualifier from simulation parameters in Fluid.hh

* Include <cmath> and use std scope resolution operater on pow

* Comment out isnan check in computeForces for now

* Initialize p_start and p_end in update_SPH

* Remove const qualifier from simulation paramters in Fluid class

* Remove n_particles member variable from Fluid class

* Create runtime.py to enable real-time synchronization and sim control panel

* Create input.py to exec realtime.py and limit simulation time

* Create simple python variable server client to unit test connection by accessing VISC member of fluid

* Create unit test to see if particle position is being updated correctly

* Create pointer to particles vector data for use in variable client

* Implement simple 2D GUI in order to render a single fluid particle

* Temporarily comment out unit tests

* Support 2D rendering of multiple particles in python variable client

* Scale size of simulation GUI based on BOUND variable from Trick variable server

* Comment out trick.stop(5) temporarily

* Set default value of BOUND to 400

* Fix sideways rendering bug by indexing field 1 position earlier

* Start variable server client from input.py rather than from command line

* Determine number of particles to render based on value of NUM_PARTICLES from Trick Variable Server. Also added TODO for correctly indexing into field.

* Reduce number of particles for 2D simulation

* Add CUDA runtime library flag and include directories

* Rename .cu/.cuh files to .cpp/.h

* Add sph_gpu.o as a library dependency of Fluid.cpp and call updateSPH_GPU in update_SPH

* Successfully compile and link Trick with CUDA in S_overrides.mk

* Call CUDA wrapper callVectorAdd() in update_SPH() to test Trick compilation/linking

* Create vectorAdd.cu to test CUDA kernel with Trick

* Change sph_gpu to a .cu file

* Pass pointer to Fluid object into updateSPH_GPU in order to access fluid parameters on GPU

* Refactor comptueDensityAndPressureGPU to use float[3] and fluid pointer to access sim parameters

* Refactor computeForcesGPU to use float[3] and fluid pointer to access sim parameters

* Refactor timeIntegrationGPU to use float[3] and fluid pointer to access sim parameters

* Refactor verletUpdatePosition to use float[3] and fluid pointer to access sim parameters

* Add base code for OpenGL particle renderer and TCP socket communication

* Create .gitignore(s) and delete built files

* Replace char* with char[] to remove warnings

* Receive and parse number of particles and particle positions

* Move connection initialization to stupComm

* Move TCP client to graphics folder and use it within OpenGL particle renderer

* Render particle position data from Trick

* Distinguish between trick and custom client

* Attempt to fix variable server client freezing

* Create input file that doesn't launch python VSC

* Remove extraneous call to initSPH

* Modify number of particles to 2048

* Create .gitignore for sim

* Create FluidServer class header

* Add Trick Header to FluidServer.hh and add clientfd member to FluidServer

* Send simple message from FluidServer in Trick to custom_client.cpp via TCP

* Add FluidServer to S_define

* Delete client directory

* Send particle data on initialization and decrease frequency of sendParticleData scheduled job

* Implement sendParticleData() to stream particle positions to client

* Implement client to receive particle position data from custom TCP fluid server

* Use custom_client interface in particle renderer of Trick variable server client

* Pass fluid pointer as parameter to FluidServer::sendParticleData(Fluid* fluid)

* Remove sim binary

* Remove TCP client usage from OpenGL particle renderer

* Rename particle renderer main.cc to opengl.cc

* Create openGLCaller, which spawns a thread that handles the OpenGL particle rendering

* Change openGLCaller signature

* Remove FluidServer usage from S_define

* Add make targets to OpenGL particle renderer source files and include OpenGL libraries in S_overrides.mk

* Temporarily set argc and argv in openGLCaller and change signature of openGLCaller

* Rename Particle to ParticleGL in sph.cpp and sph.h to avoid naming conflicts

* Hard code .obj file name in openGLMain rather than passing it as a command line arg

* Call openGLCaller inside of Fluid::default_data()

* Fix compilation bug with g++ and add .o files to nvcc device linking and TRICK_USER_LINK_LIBS

* Add 100_sphere.obj to root sim directory

* Pass pointer to Fluid object to openGLMain

* Make getParticlePositions() member function public

* Update particle positions with data from Trick sim

* Remove usage of Trickless SPH sim

* Include .o files in .gitignore

* Remove glm folder from repo

* Ignore local glm folder in .gitignore

* Copy Marching Cubes lookup tables from Cory Bloyd's implementation

* Create simple shaders to render the fluid mesh

* Create GridCell struct to store the isoValues and vertices of each voxel for Marching Cubes

* Add Trickless SPH sim back temporarily to test Marching Cubes functionality

* Implement generateCellMesh similar to Polygonise from Paul Borke
's 'Polygonising a Scalar Field'

* Implement vertex isovalue interpolation

* Create marching_cubes.h

* Modify OpenGL program to render fluid mesh rather than particles

* Create prototypes for updateIsoValues and initializeGridCells

* Implement function to initialize vector of GridCell structs

* Implement function to update isoValues of each vertex in each GridCell. (currently setting each isoValue to distance from origin)

* Support triangle indexing for more than one GridCell and do quick fix for interpolation bug

* Initialize and update both SPH particles and isoValues in grid for Marching Cubes

* Control OpenGL graphics refresh rate via usleep

* Set isoValues for vertices equal to distance from origin in order to demonstrate expanding sphere

* Fix bug with mesh vertex and face data failing to update

* Reduce number of particles to speed up sim testing

* Fix bug where only a quarter of vertex positions update

* Make particle depth greater than one to test marching cubes behavior for 3D fluid

* Redefine isoValues of gridCells to have a value equal to the number of particles within a given radius of the grid cell vertex

* Successfully update fluid mesh in response to particle positions

* Add spatial grid member and prototypes for neighbor list methods in Fluid header

* Implement buildSpatialGrid which assigns each particle to a grid cell

* Implement getCandidateNeighbors, which returns a vector of all particles within a given grid cell and up to its 26 neighboring cells

* Implement Marching Cubes isoValue update on the GPU

* Use GPU implementation of isoValue update

* Include files with build commands

* Write code for unoptimized GPU neighborlist in comments

* Add constants for spatial grid in Fluid.hh

* Use neighbor list in computeForces and computeDensityAndPressure procedures

* Keep count of the number of timesteps simulated for use in the marching cubes update

* Remove trickless SPH from unit testing

* Use Trick SPH particle data to update mesh from marching cubes

* Modify S_overrides.mk to compile and link files from Marching Cubes implementation

* Remove extraneous include

* Remove debugging code from opengl.cc

* Add back OpenGL program to render particles

* Implement ability to toggle between fluid mesh and particle modes

* Reverse surface normal direction for fluid mesh

* Add directory variables to S_overrides.mk

* Remove comment from S_overrides.mk

* Remove unused files

* Cleanup commented code

* Cleanup includes and remove unused variable

* Move marching cubes parameters to Fluid class

* Create variables to toggle GPU mode and neighbor list

* Fix malloc to include null terminated character of string and call free in loadObj

* Remove graphics window title

* Add GPU sim support for a number of particles that is not a multiple of NUM_THREADS

* Create initial conditions to demo

* Rename .cc files to .cpp

* Perform major structural refactoring on opengl.cpp

* Create refreshRate and mcUpdateFreq members in Fluid class

* Credit tables to Cory Bloyd

* Add Paul Bourke attribution

* Replace extern usage with header files

* Rename input files

* Remove unused Particle.cpp

* Move sphere models and move model file path to Fluid class

* Replace marching cubes triangle construction while loop with for loop

Co-authored-by: Scott Fennell <spfennell@gmail.com>

* Condense MC logic using loops

* Remove deprecated FluidServer from master

* Fix memory leak in iso_values.cu

* Change environment specific path to relative path in launch_vsc.py

* Write comment and TODO for CPU isoValue update code

* Add comments for demos and reduce usage of magic numbers in input.py

* Add enum for demos and fix concentric circle demo bug

* Fix style in input.py

* Replace scheduled job with flag for SPH initialization with initialization job

* Add shutdown job to free memory used by CUDA

* Add newlines to the end of files

* Delete deprecated FluidServer.cpp

* Add basic README for sim

Co-authored-by: Scott Fennell <spfennell@gmail.com>

trick_sims/SIM_fluid/README.md

@@ -0,0 +1,26 @@
+# Summer 2021 Intern Project for Nate Hill
+TSPH is a robust particle-based fluid simulation within the Trick simulation framework.
+
+## Applications
+
+- Serves as an example of how to use GPU hardware acceleration within Trick
+- Serves as an example of how to write shared memory graphics for Trick simulations using OpenGL
+- Serves as an example of using scheduled time integration outside of the Trick integration system. (TSPH uses Velocity Verlet)
+- Demonstrates performing time integration in smaller durations than real time. By default, TSPH is scheduled to simulate one time step of the fluid every 0.02 seconds. Since the time step size of the fluid simulation is 0.001 seconds, every second TSPH simulates 0.05 seconds of the fluid.
+- Demonstrates the application of a popular computer graphics/physical simulation research topic within Trick
+- Can be used to simulate a wide range of fluids in a cuboidal region of space in quasi-real time. (Quasi-real time meaning that the complete evolution of the fluid state can be observed in a small amount of time. See above.) TSPH users have control over the viscosity, kernel radius, and other physical parameters of the fluid.
+- User can create various initial conditions of the fluid particles from the Python input file
+## Future Applications
+
+- If physically correct rigid body-fluid interaction is implemented in the future, then TSPH can be used for the following simulations:
+    - Splashdown simulation of spacecraft in the ocean
+    - Simulate interactions between spacecraft and air fluid particles
+    - Simulate fluids within tank of a rocket
+    - Could serve as a starting point for future particle-based fluid simulation research
+
+## Demos
+- TSPH Particle Real Time: https://youtu.be/i3YgT9ZVXLM
+- TSPH Marching Cubes Real Time: https://youtu.be/7kZGGRVzTts
+- TSPH Paraboloid: https://youtu.be/yvON0uI0Zpo
+- TSPH Marching Cubes Dam Break: https://youtu.be/aN4TR_0ftZI
+- TSPH Particle Dam Break: https://youtu.be/OyaTB79UXFE