I need to assign a polyhedral shape to approximately 5000 particles, where each particle has a different shape. The only way I found to do this in Ovito is by using the “Particle types” option, changing the particle shape to “Mesh/User-defined,” and selecting the corresponding .obj file, which specifies the vertex coordinates and triangular-face connections.
This approach is manageable for a single particle but becomes impractical for all 5000 particles, as each particle has a unique shape associated with a specific .obj file.
I assume the only solution is to create a Python script to automate this process. However, I’m not sure which modifiers or API commands would allow me to achieve this. I couldn’t find relevant examples or documentation on the Ovito website.
Could someone help me with guidance or an example script for this task?
This is an interesting use case. In fact, this can only be achieved with the help of a Python modifier function, which you have to insert into the pipeline in the OVITO Pro GUI. Or you have to implement all work as a standalone program using the OVITO Python module.
It must be said, however, that OVITO is not designed for such a scenario. Both the particle type system and the rendering system are designed for only a handful of different particle shapes to exist in the system. 5000 different particle shapes is at the limit of what OVITO is capable of. You will experience significant performance bottlenecks.
Here is a Python modifier script that shows how to load the particle shapes from the OBJ files and assign them to the particles.
from ovito.data import DataCollection
from ovito.vis import ParticlesVis
from ovito.io import import_file
# First, preload the 5000 .obj files to produce a list of TriangleMesh objects
meshes = []
for i in range(5000):
mesh = import_file(f"meshes/shape{i}.obj").compute().triangle_meshes['mesh']
meshes.append(mesh)
# Custom modifier function, which creates the ParticleTypes for the triangle meshes and
# assigns them to the existing particles in the simulation.
def modify(frame: int, data: DataCollection):
# Create a modifiable copy of the "Particle Type" property.
particle_types = data.particles_.particle_types_
for i, mesh in enumerate(meshes):
# Create the i-th particle type
t = particle_types.add_type_id(i, data.particles)
t.mesh = mesh
t.shape = ParticlesVis.Shape.Mesh
# Assign the i-th particle type to the i-th particle
particle_types[i] = i
I would like to invite you to provide more detailed background information on your use case. What kind of simulation model are you dealing with? Perhaps we can make improvements to OVITO in the future to better support such applications.
Thank you for the reply! I will try using this Python script to evaluate Ovito’s performance. I typically rely on Ovito to visualize particle trajectories, including their positions and orientations, in my Monte Carlo simulations. Since I work with hard-core particles, Ovito is a great tool for verifying the accuracy of my overlap algorithm. Currently, I am working with particles with polyhedral shapes and analyzing their packing behavior.
@stukowski Sorry for the late reply. I’ve just purchased the Ovito PRO version and tested your Python script.
The script that you’ve provided is compiling and running but apparently it’s not selecting the particle types accordingly, which is probably due to the formatting of my XYZ file.
My XYZ file look like this (sorry but I can’t upload the file because I’m a new user):
I have 5000 particles + 2 hard walls at the bottom and top of my simulation box. I reserved the index 0 to these walls. The first column of my XYZ file is the particle type, followed by XYZ positions, XYZW orientation quaternions, and XYZ aspherical shape, which is not really necessary for describing the meshes, but it is for the hard walls.
I also don’t have in this example 5000 particle types. I have only 1000 types that are distributed randomly to the particles, so you can have more than one type selected for different particles.
I couldn’t figure out what’s happening in the script and why it is not selecting the particle types accordingly. Could you help me with that?
It’s difficult for me to say from here what’s happening in the script and why this fails. I would like to have a direct look at it. Could you please send the XYZ file and your current visualisation setup to [email protected]? If you save the current program session state as an .ovito file, it should also contain the script. As for the 1000 .obj files, it may not be necessary to send them (if the data is too large). If we’re lucky, I can already identify the problem without them. Thanks.
Thank you for your answer! I may have fixed the issue but I’ll send to you just in case the OVITO session file with the OBJ files (they are less than 1KB each) and the XYZ file.
What I did was:
from ovito.data import DataCollection
from ovito.vis import ParticlesVis
from ovito.io import import_file
# Number of objects
n_objects = 10
# Number of particles
n_particles = 10
# First, preload the N .obj files to produce a list of TriangleMesh objects
meshes = []
for i in range(0, n_objects):
mesh = import_file(f"Shapes/prism_{i+1:05d}.obj").compute().triangle_meshes['mesh']
meshes.append(mesh)
print(f"Object #{i+1:05d} | Mesh: {meshes[i]}") # The OBJ indexes begin with 1
print(" ")
# Custom modifier function, which creates the ParticleTypes for the triangle meshes and
# assigns them to the existing particles in the simulation.
def modify(frame: int, data: DataCollection):
# Create a modifiable copy of the "Particle Type" property.
particle_types = data.particles_.particle_types_
for i in range(0, n_particles): # Maybe I don't need to loop over the N particles if the number of particle types is less than N
t = particle_types.add_type_id(particle_types[i], data.particles)
t.mesh = meshes[particle_types[i]-1] # Access one index below
print(f"Particle type {particle_types[i]} is receiving mesh {t.mesh}")
t.shape = ParticlesVis.Shape.Mesh
Yes, now that you load a XYZ file that contains 1000(+1) different particle types, you don’t have to newly create these types in the script anymore. It’s sufficient to modify these existing particle types and assign a shape to each of them.
I’ve prepared an updated modifier script for you that is based on the “advanced” programming interface for user-defined modifiers. The advantage of this extended interface is that the loading of the 1000 obj files can be integrated into the modify routine and be performed asynchronously. This avoids blocking the user interface during this lengthy operation.
from ovito.pipeline import ModifierInterface
from ovito.data import DataCollection
from ovito.vis import ParticlesVis
from ovito.io import import_file
class LoadShapesModifier(ModifierInterface):
def modify(self, data: DataCollection, *, data_cache: DataCollection, **kwargs):
# Load the 1000 .obj files to produce a list of TriangleMesh objects
num_files = 1000
if not (meshes := data_cache.attributes.get('meshes', None)):
meshes = data_cache.attributes['meshes'] = []
yield f"Loading {num_files} mesh files..."
for i in range(num_files):
yield i / num_files
mesh = import_file(f"Shapes/prism_{i+1:05d}.obj").compute().triangle_meshes['mesh']
meshes.append(mesh)
# Modify the types list of the "Particle Type" property.
particle_types = data.particles_.particle_types_
for t in particle_types.types_:
if t.id != 0:
t.mesh = meshes[t.id - 1]
t.shape = ParticlesVis.Shape.Mesh
