cselab / mirheo Goto Github PK

Add a tool (written in c++, wrapped in python) that dumps SDF (from sdf files, analytical shapes) in hdf5.

• merge sdf function
• dump sdf

The current restart mechanism coupled with ObjectBelonging object will delete one of the particle vectors

mesh dump should be able to have additional fields, such as velocity, stresses, energy density...

• use xdmf + hdf5 to dump positions (new grid type...)
• attach extra fields per vertex
• add tests

When sampling a lot of particles per bin, floats aren't enough!

• add Buffer of doubles which keeps accumulated data (along time)
• send that buffer and convert to float on the postprocess rank
• switch pinned to device buffers where not needed

must first merge the SDFs and then freeze only once to avoid replicated frozen particles

Generate or pass mesh to the ellipsoid objects to enable PLY dumps and other mesh-related stuff

add tests for averaged stresses per cell

As of now, the extra particle vector channel are not persistent. They are communicated via MPI, but not preserved during the cell-list update. The goal is to make them truly stick:

• Make CellList reorder data of the extra channels
• Non-primary CellList should keep the reordered extra channels
• Views should be aware of the channels store within the non-primary CellList (e.g. for interactions with charge, etc.)
• Permanent channels should be written and read to/from the restart files

Add a plugin which:

• adds a given magnetic moment to given rigid objects
• apply torque to the rigids as a function of external magnetic field

• add tags in git
• synchronize with pip and "hello message" from udx

The abbreviation is probably ymr.
We have to rename everything, including (but not probably limited to):

• Repo name
• Python module
• Coordinator
• Bindings
• Tests
• Documentation
• Tools
• Grep for udevice(x), udx and u. to make sure nothing remains

• More comment in the code, most of the files lack them
• Revive the dev docs build system with Sphinx and RTD
• Add the code overview description with task dependencies

Change time step at run time according to maximum forces

• pass dt at every step from simulation
• adapt DPD parameters according to dt
• change dumpEvery parameters to DPD time unit?
• adapt dt based on forces

Add a section with tutorials in the docs.
Should include several sections, with commented scripts.
The scripts must be part of the tests for maintainability reasons.

• a simple "hello world" setup
• a basic setup with plugins example
• walls creation
• object belonging: membranes with inner/outer
• object belonging: create rigid objects

Add a test section in the docs

• compute volume from walls
• compute volume of objects
• add tests

• Make exchangers use ParticleExchanger instead of inheriting from it
• Add a single-rank exchanger that calls no MPI and simply manipulates with memory

Create benchmarks for representative cases
Report weak (and strong?) scaling for each case

• dump timings in stats file
• bulk fluid
• bulk blood
• bulk suspended rigid objects
• with walls
• with IO
• add corresponding entries in documentation

overlad warp instructions to remove warnings in newer CUDA versions (__shfl()...)

add a security check:
bounce back needs that the pvs have an integrator!

compute and report wall stresses/forces;
this will allow to measure viscosity for couette flow with cells

• reduce total stresses/forces acting on wall frozen particles
• compute and reduce stresses/forces induced by bounce-back on walls

• make all unit tests compile
• add tests

allow stress-free shape to be different than initial shape of membranes

Not sure why this happens, need to look at the algorithm and/or tolerances

factories return raw pointers which are not deleted.
Need to use shared_ptr instead

On Uniform grids

• fix output
• add a test

See here: https://udevicex.readthedocs.io/en/latest/user/interactions.html#_udevicex.Interactions.MembraneForces

add tests for bounce back:

• analytic shape: ellipsoid
• rigid mesh
• membrane

Need to talk to the ETH people to determine an appropriate one

Make possible to initialize mpi outside of the udx coordinator constructor
This would allow multiple instances of udx in the same python script

Create and test the restarting mechanism based on XDMF / HDF5

• Read XDMF files
• Regular ParticleVector restart
• test it
• test it, mpi
• ObjectVector restart
• test it
• test it, mpi
• Object quantities restart
• test it
• test it, mpi

add tests for restart

This would allow plugins to have a sdf; benefits:

• apply something in specific and possibly complex regions only, in e.g. plugins
• can be constructed from function pointer on host: configuration more general in python

for now all quantities are averaged by dividing by number density.
stresses need to be divided by volume instead
-> make configurable scaling

Add Skalak elastic forces in membrane interactions

Make a more "pythonic" interface for membranes

add more accurate bending kernels for membranes

• implement Julicher bending
• separate bending from other forces in interaction kernel
• configure it from python
• add test

pass string argument to name the stress storage array
this would allow to separate different stresses (e.g. fsi and self interactions)

• add separate connectivity structures for different membranes
• edge-flip for more robust bending

make the wall freezing have a custom cutoff radius, such that MDPD can has the correct density

Stats at timestep 1001 (simulation time 0.250250):
One timestep takes 0.69 ms Number of particles (total, min/proc, max/proc): 383247, 383247, 383247
Average momentum: [8.583316e-02 1.185539e-04 -2.597606e-04]
Max velocity magnitude: 6.462542
Temperature: 0.1575

Stats at timestep 2001 (simulation time 0.500250):
One timestep takes 14.61 ms Number of particles (total, min/proc, max/proc): 383247, 383247, 383247
Average momentum: [1.778514e-01 6.261818e-04 -3.726583e-02]
Max velocity magnitude: 5.070049
Temperature: 0.6456

Stats at timestep 3001 (simulation time 0.750250):
One timestep takes 14.59 ms Number of particles (total, min/proc, max/proc): 383247, 383247, 383247
Average momentum: [2.302195e-01 -2.846199e-04 -3.787914e-02]
Max velocity magnitude: 5.572831
Temperature: 0.6607

Add a base class for all uDeviceX objects which contains common quantities (name)
Optionally, this class should have access to global quantities that are shared by everyone (time, domain, dt...).

Implement many body DPD: repulsive force needs a density per particle, which is computed from neighbouring particles. (within a different cut of radius rd in general).
This is a 2-step interaction and implies some reorganisation in the code.

• interaction kernel should have a more generic input and output
• new kind of interactions: intermediate (only different from simulation point of view)
• more general packers
• scheduler: intermediate, then normal
• general reverse exchanger for ovs
• exchange back and clear intermediate quantities
• add documentation

add a possibility to save forces for dumping/postprocessing purpose:
For now, the object forces are cleared after integration so the getForces() function returns zeros after run() returns.
Can be implemented as a plugin

Allow mixed precision for membrane interactions

add a state object which contains global quantities (some might change over time):

• domain info
• time step
• current simulation time
• flag: compute task
  every YmeroObject must accept a (const) pointer to this in their constructor.
  This will allow the users to know that internal variables, such as domain in pvs, are needed

Add stress computation also on membrane

Looks like udx.load always checks the hostname when it's run, and fails on compute nodes with names like "nidXXXXX". Probably better to make it resolve the hostname only once when installing