Example M7: Displacement vectors with reference configuration

This Python modifier computes each particle’s displacement vector with respect to a reference configuration of the system, which is loaded by the modifier from a separate input file. Thus, it replicates some of the functionality provided by the built-in CalculateDisplacementsModifier of OVITO.

The modifier is based on the advanced programming interface, i.e., it is implemented in the form of a Python class inheriting from ModifierInterface.

See also

• Input data caching

• User parameters

• Defining additional input slots

• Particles.remap_indices()

• SimulationCell.delta_vector()

from ovito.data import DataCollection
from ovito.pipeline import ModifierInterface, FileSource
from ovito.traits import OvitoObjectTrait
from ovito.vis import VectorVis
from traits.api import Int, Bool

class CalculateDisplacementsWithReference(ModifierInterface):

    # Give the modifier a second input slot for reading the reference config from a separate file:
    reference = OvitoObjectTrait(FileSource)

    # The trajectory frame from the reference file to use as (static) reference configuration (default 0).
    reference_frame = Int(default_value=0, label='Reference trajectory frame')

    # This flag controls whether the modifier tries to detect when particles have crossed a periodic boundary
    # of the simulation cell. The computed displacement vectors will be corrected accordingly.
    minimum_image_convention = Bool(default_value=True, label='Use minimum image convention')

    # A VectorVis visual element managed by this modifier, which will be assigned to the 'Displacement' output property to visualize the vectors.
    vector_vis = OvitoObjectTrait(VectorVis, alignment=VectorVis.Alignment.Head, flat_shading=False, title='Displacements')

    # Tell the pipeline system to keep two trajectory frames in memory: the current input frame and the reference configuration.
    def input_caching_hints(self, frame: int, **kwargs):
        return {
            'upstream': frame,
            'reference': self.reference_frame
        }

    # The actual function called by the pipeline system to let the modifier do its thing.
    def modify(self, data: DataCollection, *, input_slots: dict[str, ModifierInterface.InputSlot], **kwargs):

        # Request the reference configuration.
        ref_data = input_slots['reference'].compute(self.reference_frame)

        # Get current particle positions and reference positions, making sure the ordering of the two arrays
        # is the same even if the storage order of particles changes with time.
        current_positions   = data.particles.positions
        reference_positions = ref_data.particles.positions[ref_data.particles.remap_indices(data.particles)]

        # Compute particle displacement vectors. Use SimulationCell.delta_vector() method to
        # correctly handle particles that have crossed a periodic boundary.
        if self.minimum_image_convention and data.cell:
            displacements = data.cell.delta_vector(reference_positions, current_positions)
        else:
            displacements = current_positions - reference_positions

        # Output the computed displacement vectors as a new particle property.
        # Assign our visual element to the property to render the displacement vectors as arrows.
        data.particles_.create_property("Displacement", data=displacements).vis = self.vector_vis