Add constant force directly to wall on DEM simulation

[dohyeongkim1]

Description

Description

Currently, HOOMD-blue 5.1.0 does not provide functionality to apply a constant force directly to walls. This feature is essential for the following DEM simulation use cases:

1. Simulating compressive deformation of particle systems under constant pressure in the Z direction
2. Modeling interactions where forces applied to walls move them until force equilibrium is reached with particles
3. Simulating realistic physical compression processes (applying constant force rather than constant displacement)

At present, we can only apply forces directly to particles or change the box size over time (using BoxResize), but these approaches do not accurately model the physics of applying constant forces to walls.

Proposed solution

1. Add a mechanism to apply forces to hoomd.wall.WallGeometry classes (Plane, Sphere, Cylinder, etc.):

   • Introduce properties to set force vectors on wall objects (e.g., wall.force = (0, 0, -1000))
   • Enable the physics engine to dynamically update wall positions based on applied forces

2. Improve the interface for handling wall-particle interactions:

   • Calculate the balance between forces applied to walls and repulsive forces from particles
   • Update wall positions as a result of these forces
   • Include damping elements to prevent oscillations in wall movement

Additional context

This functionality would be valuable for DEM (Discrete Element Method) simulations, material compression tests, soil mechanics, and various fields studying particle system responses to pressure. Currently, we must resort to applying forces directly to particles as a workaround, but this does not provide physically accurate modeling.

I have attempted to implement test cases for this functionality but was unable to apply forces directly to walls due to API limitations. Any guidance on developing custom components to achieve this would also be greatly appreciated.

Thank you for considering this feature request. It would significantly enhance the capabilities of HOOMD-blue for realistic physical simulations.

Proposed solution

3. User-friendly API example:

   # Example code
   wall = hoomd.wall.Plane(origin=(0, 0, L/2), normal=(0, 0, -1))
   wall_force = hoomd.wall.ConstantForce(walls=[wall])
   wall_force.forces['wall_0'] = (0, 0, -pressure * area)  # Force due to pressure

Additional context

No response

[joaander]

Thank you for the clearly explained request.

One of the fundamental assumptions made in the beginning of HOOMD-blue development is that the particles are the only entities that have degrees of freedom and that the integrator is the only object that grants those degrees of freedom. All the other values that influence your model (such as the position of a wall) are fixed parameters in the view of the internal engine. There is therefore no way to naturally express a movable wall in HOOMD-blue, nor is there a way to quickly modify the code to achieve this. I am currently working on a brand new code that plans for this this type of flexibility (along with many others) from the beginning. Such customization will be possible in every user script and will compile to fast machine code without needing to write a complicated external component. You will probably also be interested to hear that this new code will also support open boundary conditions (you will also be able to customize the boundary conditions with user-provided code). I'll announce that code on the discussion board when it is ready to share: https://github.com/glotzerlab/hoomd-blue/discussions

The best you can do in HOOMD-blue follows:

At the Python level, you could use one wall force object per plane. The force on the wall itself is the negative of the force on the particles, so you could compute it with something like sum(-wall.forces[:]). You will need to do a convex hull computation from all your planes to determine the total force based on your pressure. Based on this force and your chosen equations of motion for the wall, you can then update the wall positions using a Updater. For non-planar walls, the computation will be more complex than a sum of the forces. It all depends on the equations of motion for your wall degrees of freedom.

You could implement the same model in an C++ component to improve performance (https://github.com/glotzerlab/hoomd-component-template/). Write a custom ForceCompute that applies the forces from all of your walls at once and properly accounts for the forces (or stresses, or whatever is needed) from the particles on each wall. Write the wall equations of motion in a Updater implemented in C++. That Updater will hold a shared pointer to your ForceCompute so that it can update the wall degrees of freedom. Edit: Note that you'll need a weak pointer in there to break the circular dependency between the Updater and the ForceCompute.

This doesn't exactly match what you are asking for, but we are working on flexible barriers defined by meshes: https://hoomd-blue.readthedocs.io/en/v5.1.0/hoomd/md/module-mesh.html. The meshes are made up of particles and you can describe their equations of motion with various bending and area/volume conservation potentials. Currently, the only interaction between the mesh particles and the rest of the system is via particle-particle interactions. We are thinking about ways to implement forces between particles and the triangles that form the mesh. With the right constraints on the mesh, it is possible that you could use this system to implement your intended model. If your model can tolerate coarse walls made of particles, you can use the existing mesh infrastructure in 5.1. If you need the triangle-particle interactions, watch for future pull requests https://github.com/glotzerlab/hoomd-blue/pulls. There is no tutorial yet, but the developers are working on one right now.