Changelog

Version 3.9.4 (04-Nov-2023)

  • Fix: OpenGL rendering of ellipsoidal/superquadric/box particles with wrong orientations (regression since v3.9.0)

Version 3.9.3 (01-Nov-2023)

  • Expand selection modifier: Added new output attribute ExpandSelection.num_added

  • Identify diamond structure modifier: Added missing output attribute IdentifyDiamond.counts.OTHER

  • Fix: Section “Modifier templates” of available modifiers list not updated correctly when adding/removing templates

  • Fix: LAMMPS data file reader: vector vis settings of Velocity property lost after loading a state file

  • Fix: Segfault when opening a .ovito state file with macOS Finder while OVITO is already running

  • Fix: Construct surface mesh modifier: Option Map particles to regions may yield invalid results when used with option Use only selected input particles

  • Updated third-party components: OpenSSL 1.1.1w, Qt/PySide6 6.5.3, Python 3.11.6

  • pro PyPI packages for Python 3.12

Version 3.9.2 (31-Aug-2023)

  • Support Ctrl+C copy to clipboard in table of distances, angles, and dislocations in the data inspector

  • Fix: Text label viewport layer accidentally disables 3d depth test in interactive viewports if used as an underlay

  • pro render_image() and render_anim() now raise exceptions in case an error occurs in any of the scene pipelines (can be changed via new parameter stop_on_error)

  • pro New class-based programming interface for custom viewport overlays: ovito.vis.ViewportOverlayInterface

  • pro New flag Pipeline.preliminary_updates

  • pro Corrected data column headers in XYZ, LAMMPS dump, and IMD files written via export_file() if a vector property was specified in the columns list

  • pro Build Conda package as monolithic binaries for improved performance of the Python interface

  • pro Updated third-party components: OpenSSL 1.1.1v, PySide6 6.5.2, Python 3.11.5

Version 3.9.1 (06-Aug-2023)

Version 3.9.0 (02-Aug-2023)

Dark mode support on Windows

To enable the dark UI theme on Windows, go to the application settings and switch on Enable automatic dark mode. OVITO will follow the Windows system color theme.

_images/windows_dark_mode_support.png

OpenSSH client integration pro

OVITO Pro is now able to access data files on remote machines using OpenSSH’s sftp utility, which fully supports smartcard authentication and other advanced ssh features. See OpenSSH client for further information.

User-defined file format readers pro

This program release introduces a programming interface for user-defined file readers, which enables you to develop parser functions for new file formats in Python. User-defined file readers are fully integrated into the GUI of OVITO Pro and work seamlessly with the import_file() function from the OVITO Python module.

Discovery mechanism for Python extensions pro

Python extensions for OVITO Pro or the OVITO Python module (i.e. user-defined modifiers and file readers) can now be packaged as Python modules, making it easier to deploy and install them (using pip install). Custom extensions you’ve developed can be put under version control in a Git repo and shared online with other OVITO users if desired – we have set up the new OVITO Extensions Directory for that purpose. After easy installation on a user’s computer, OVITO Pro automatically discovers all extensions and makes them available in the GUI.

_images/python_extension_workflow.jpg _images/empty.png _images/python_settings_dialog.png

New Python Settings dialog pro

The new Python Settings dialog provides access to all things related to a Python extension in OVITO Pro:

  • Configure the current working directory used for file I/O operations

  • Hot reload function for imported Python modules, which streamlines development of Python code located in external source files

  • Import the source code of installed extensions into the current program session to selectively customize functions when needed

  • List of all installed Python packages that are available for import by user code

Support for more file formats

OVITO can now import DCD trajectory files, which are written by the CHARMM, NAMD, and LAMMPS simulation codes. OVITO Pro and the OVITO Python module can additionally read ASE trajectory files.

Further changes in this program release:

  • Support for additional property data types (float32, int8) to reduce memory footprint of particle properties with low precision requirements (e.g. Color, Selection)

  • OpenGL renderer: Performance optimizations, direct upload of float32 and int8 array values to GPU memory

  • GSD file reader: Do not skip log/ chunks containing / in their names (issue #226)

  • Fix: Color Coding modifier’s “Adjust Range” function does not follow option “Only selected”

  • Search patterns for trajectory file series: Avoid asterisk in file extensions containing digits, e.g. snapshot0000.h5 → snapshot*.h5

  • Data table file exporter does not require a y-property anymore

  • Automatic name mangling of atom attributes imported from LAMMPS dump, GSD, and XYZ files in case they do not conform to OVITO’s property naming rules

  • The Vulkan viewport renderer has been temporarily disabled in this release

  • pro New Python methods Property.add_type_id and Property.add_type_name

  • pro New Python method VoxelGrid.view

  • pro Performance optimizations for property data access from Python code

Version 3.8.5 (19-Jun-2023)

  • Voronoi analysis modifier now outputs per-face Area and Voronoi Order mesh properties

  • PDB file reader: Refined detection of cells with periodic boundary conditions

  • GSD file reader: Support time-varying radii of spherical type shapes; display simulation step numbers in timeline

  • LAMMPS dump file reader: Automatically map file columns to standard particle properties if names match

  • Bug fix: Particle selection in data inspector is lost when playing animation or moving viewport camera

  • Workaround for macOS (Apple Silicon) OpenGL stencil buffer issue: Highlighted particles not rendered correctly

  • Update third-party libraries: ffmpeg 6.0, OpenSSL 1.1.1u, libssh 0.10.5, Qt 6.5.1, PySide6 6.5.1.1, HDF5 1.14.1-2, NetCDF 4.9.2

Version 3.8.4 (03-May-2023)

  • Fix: ffmpeg video encoding crashes on Windows if output path contains non-ascii characters

  • Silence console message “Numeric mode unsupported in the posix collation implementation” on Linux by enabling ICU support in Qt build

  • pro Fix: Segfault in PySide6 package initialization on Linux when adding a Python layer to a viewport

  • pro Fix: Interchanged xz/yz simulation box shear components in lammps_to_ovito() Python function

Version 3.8.3 (16-Apr-2023)

  • Further improved performance of sequential loading of compressed trajectory files

  • Fixed regression (since v3.8.0): Viewport.render_anim() renders only first animation frame

  • pro Python exceptions raised in user-defined modifier functions are now propagated up the call chain to where the pipeline evaluation was triggered

  • pro Included bz2 and sqlite3 standard modules, which were missing in embedded Python interpreter on Linux

Version 3.8.2 (04-Apr-2023)

  • Implemented fast access to trajectory frames in compressed (gzipped) files

  • Fix: Segfault when using zoom function in viewport with an attached camera object

  • Fix: Segfault in Coordination polyhedra modifier on Linux

  • Fix: Function ‘load/save session state’ does not follow global working directory

Version 3.8.1 (27-Mar-2023)

Identification of volumetric regions using the Gaussian density method pro

The Construct surface mesh modifier’s implementation of the Gaussian density method has been extended to support the identification of volumetric regions, e.g. pores, cavities, and filled spatial regions. Their respective surface areas and volumes are calculated and output by the modifier in tabulated form.

To make this possible, we have developed an extension to the Marching Cubes algorithm for isosurface construction, which provides the capability to identify disconnected spatial regions separated by the surface mesh and compute their enclosed volumes – of course with full support for periodic boundary conditions.

_images/surface_mesh_regions_gaussian_density_example.png _images/construct_surface_mesh_regions_example_table.jpg

New efficient Python method for computing neighbor lists pro

OVITO’s Python interface now offers the new CutoffNeighborFinder.find_all() method for vectorized computation of neighbor lists for many or all particles at once.

Further changes:

  • LAMMPS data file reader: Accept ‘#’ in type names, which are referenced in data sections of the file

Version 3.8.0 (03-Mar-2023)

Develop custom modifiers with extended capabilities pro

A newly devised programming interface enables you to write advanced modifier functions in Python that

  • access more than one frame of a simulation trajectory,

  • perform computations that involve data from several input files, or

  • need control over the caching of computational results.

Take simulation post-processing to the next level! Develop your own trajectory analysis algorithms in Python, which are fully integrated into OVITO’s pipeline system and the interactive interface of OVITO Pro.

class CalculateIncrementalDisplacementsModifier(ModifierInterface):
    def modify(self, data, frame, input_slots, **kwargs):
        next_frame = input_slots['upstream'].compute(frame + 1)
        displacements = next_frame.particles.positions - data.particles.positions

Have a look at our completely revised introduction to user-defined modifiers and check out the new advanced programming interface for user-defined modifiers.

Improved color legends

OVITO can now render tick marks in color mapping legends to label intermediate values. Furthermore, the legend’s title may be rotated by 90 degrees:

_images/color_legend_ticks_horizontal.png _images/color_legend_ticks_vertical.png

File reader for ASE database files pro

Load atomic structures from database files of the Atomic Simulation Environment (ASE) into OVITO. The new file reader lets you scroll through all structures in a database or pick specific structures using a query string. Metadata associated with structures is made available in OVITO as global attributes.

_images/ase_database_reader.gif

New modifier: Identify fcc planar faults pro

Easily identify different planar defect types, such as stacking faults and coherent twin boundaries, in face-centered cubic (fcc) crystals. We have developed a powerful classification algorithm for hcp-like atoms that make up such planar defects:

_images/planar_faults.jpg

New modifier: Render LAMMPS regions pro

Use this new tool to generate mesh-based representations of the parametric regions defined in your LAMMPS simulation, e.g., cylinders, spheres, or blocks, and visualize the boundaries of these spatial regions along with the particle model:

_images/lammps_regions.png

Spatial binning modifier: New unity input option pro

This options offers a shortcut for calculating particle density distributions, i.e. counting the particles per grid cell. Previous versions required first defining an auxiliary particle property with a uniform value of 1 to calculate the number density:

_images/spatial_binning.png

See Spatial binning modifier.

Support for LAMMPS dump grid files

OVITO can now read and visualize the new volumetric grid file format written by recent LAMMPS versions thanks to the newly added LAMMPS dump grid file reader:

_images/volumetric_grid_discrete.png

Slice modifier on voxel grids

When you apply the Slice modifier to a voxel grid, cell values now get copied to the mesh faces and interpolated field values to the mesh vertices of the generated cross-section. This enables both discrete and interpolated visualizations of the field values along arbitrary planar cross-sections:

_images/volumetric_grid_slice_discrete.png _images/volumetric_grid_slice_interpolated.png

See Slice modifier and Voxel grids.

Support for point-based volumetric grids

In addition to the classical cell-based voxel grids, OVITO now also supports point-based volumetric grids, in which field values are associated with the grid points instead of the voxel cells. All functions in OVITO that operate on grids, e.g. the Create isosurface modifier, also support periodic and mixed boundary conditions.

_images/voxel_grid_types.png

See ovito.data.VoxelGrid.grid_type and Gaussian Cube file reader.

Load Trajectory modifier now supports removal of particles

Previously, the Load trajectory modifier required the trajectory file to contain coordinates for all particles that were initially present in the topology dataset. The improved version of the modifier can now deal with particles disappearing in later frames of a trajectory, e.g., when particles get removed from the simulation over time.

Further additions and changes in this program release:

  • Added dark mode UI support for Linux platform.

  • Spatial correlation function modifier: Added support for 2d simulations.

  • Wrap at periodic boundaries modifier: Added support for 2d simulations.

  • Save and restore maximized state of main window across program sessions.

  • LAMMPS data file reader & writer: Added support for extended Velocities file section for when using LAMMPS atom styles electron, ellipsoid, or sphere.

  • LAMMPS data file writer: Added the option to renumber all particle/bond/angle/dihedral/improper types during export. Avoids conversion problems from 0-based type IDs loaded from GSD files.

  • New option to clip surfaces at open box boundaries (see SurfaceMeshVis.clip_at_domain_boundaries).

  • Cluster analysis modifier: Abort calculation of center of mass and radius of gyration if masses of all input particles are zero.

  • pro Added user option that makes OVITO Pro import multiple files of the same kind as separate objects into the scene.

  • pro Accept os.PathLike objects in Python functions import_file() and export_file().

  • pro PropertyContainer.create_property: Accept data values that are broadcastable to shape of property array.

Version 3.7.12 (16-Dec-2022)

Version 3.7.11 (29-Oct-2022)

  • Added user option to application settings dialog for changing the working directory behavior.

  • Fixed regression: Slice modifier does not work on voxel grids.

  • pro Vectorized all query methods of SurfaceMeshTopology class.

  • pro Provide PyPI package for Python 3.11.

  • pro Added flat array option to method SurfaceMesh.get_face_vertices().

Version 3.7.10 (09-Oct-2022)

  • Optimization of main window UI widgets to improve rapid animation playback at high frame rates.

  • Enhancements to the pipeline editor: Brief information display for some modifiers.

  • New right-click context menu in pipeline editor: Branched and cloned pipelines Added ‘Copy to…’ function for copying modifiers within and across pipelines.

  • pro Standalone Python module: Run in headless mode by default. OVITO_GUI_MODE env variable requests OpenGL renderer support.

  • pro PyPI package on Linux: Switched back to PySide6 version 6.2.4 for better backward compatibility with older Ubuntu distros.

  • pro Fixed loading of files opened via double click in case license validation dialog pops up.

  • pro Generalized the Vectors element to support visualization of vector quantities in more types of PropertyContainers.

  • pro New Python function ovito.modifiers.PolyhedralTemplateMatchingModifier.calculate_misorientation().

  • pro Automatic conversion of NumPy array scalars to Python numbers when storing them as OVITO global ovito.data.DataCollection attributes.

Version 3.7.9 (12-Sep-2022)

  • Voronoi analysis: Added calculation of cavity radius.

  • GSD file importer/exporter: Added support for particle attributes “angmom” and “body”.

  • Fix: Affine Transformation modifier not transforming particles in target-cell mode in rare situations (when called from Python).

  • Fix: File import via drag & drop not working when Vulkan viewport renderer is active.

  • Upgraded Qt cross-platform framework to version 6.3.1.

  • Cluster analysis modifier: Warn user if center of mass cannot be computed due to cluster’s total mass being zero.

  • pro Upgraded OVITO Pro integrated interpreter embedded interpreter to Python 3.10.6.

  • pro Installing third-party Python modules Installation of PyPI packages with the --user option in the embedded interpreter is now supported.

  • pro New Python API for creating ovito.data.SurfaceMesh objects.

  • pro Improved operation of Python module in Jupyter environments. Interrupting long-running operations is fully supported now.

  • pro New experimental Jupyter notebook visualization widget (ovito.vis.Viewport.create_jupyter_widget()).

  • pro Added Python API ovito.vis.ColorLegendOverlay color_mapping_source.

  • pro Fix: Segfault during Python statement del ovito.scene.pipelines[:].

Version 3.7.8 (29-Jul-2022)

  • Fix: Program crash when quickly skipping through a trajectory consisting of a series of files loaded via SSH (regression OVITO 3.7.0).

  • Fix: Visual artifacts when rendering cone primitives (3d arrow heads) at small length scales due to numerical precision issue.

  • pro Added conda packages for Python 3.10.

  • pro Added conda packages for macOS arm64/M1 platform.

  • pro Work around a memory leak in some OpenGL graphics driver implementations when the ovito.vis.Viewport.render_image() Python function is called repeatedly.

Version 3.7.7 (06-Jul-2022)

  • Ubuntu 22.04 compatibility - Linux package of OVITO now includes a private copy of OpenSSL 1.1 libraries.

Version 3.7.6 (23-Jun-2022)

  • PDB file reader: Added support for CP2K trajectory format.

  • LAMMPS dump file reader: Recognize quat{ijkw} and shape{xyz} columns and automatically them to correct particle properties.

  • Fix: Camera FOV parameter not animatable when rendering a movie.

  • Fix: Segfault when loading .ovito state files written by OVITO 3.3 or older containing a Python script.

  • Fix: Grain segmentation algorithm never terminates for particular inputs.

  • PyPI package for Linux: disabled built-in SSH client to improve compatibility with Ubuntu 22.04, which doesn’t provide OpenSSL 1.1 libraries anymore.

  • pro New Python class ovito.data.SurfaceMeshTopology, which provides script access to the face connectivity information of surface meshes.

  • pro Conda channel now provides additional variants of the `ovito <https://conda.ovito.org>`_ package (built against tbb v2020 and v2021), which avoids dependency conflicts with certain third-party packages when installing them in the same environment.

Version 3.7.5 (28-May-2022)

  • Smooth trajectory modifier now supports varying number of particles.

  • SSH client: Try password first before keyboard-interactive authentication for successful handshaking with some SSH servers.

  • Performance improvements to OpenGL high-quality sphere rendering code

  • Bug fix: Data inspector shows a 3rd text label in bar charts with 2 bars.

  • Bug fix: Sporadic program crashes when importing CA files.

  • pro DataCollection.attributes dictionary can now store arbitrary Python objects.

  • pro New Python method ovito.data.Particles.remap_indices().

  • pro New Python method ovito.data.SurfaceMesh.to_triangle_mesh().

  • pro Bumped maximum neighbor limit of ovito.data.NearestNeighborFinder to 64.

  • pro Dropped support for Python 3.6, which has reached its end-of-life date.

Version 3.7.4 (18-Apr-2022)

Version 3.7.3 (29-Mar-2022)

Version 3.7.2 (03-Mar-2022)

  • Improved render output window with image zoom function.

  • Fix: Particle type colors not initialised correctly if imported LAMMPS dump file contains both ‘type’ and ‘element’ columns (issue #193 note 403792737).

  • pro macOS: Fixed PySide6 loading error due to wrong rpath information when importing PyPI ovito package.

  • pro Linux: Fixed sqlite3 Python package included in the embedded Python interpreter of OVITO Pro.

Version 3.7.1 (26-Feb-2022)

Version 3.7.0 (15-Feb-2022)

  • Visual element and particle type settings can now be preserved when picking a new input simulation file in the External file external file panel.

  • Support for HTML formatted text in viewport layers Text label layer, Color legend layer, and Coordinate tripod layer.

  • Improved color quality of animated GIFs produced by OVITO

  • Added dark mode UI support on macOS.

  • Availability of native arm64/M1 builds of OVITO Basic, OVITO Pro and the OVITO Python package for Apple Silicon machines.

  • Ported OVITO code base from C++14 to C++17 language standard.

  • Switched from old Qt 5.x to version 6.2 of the Qt cross-platform C++ framework and, correspondingly, from PySide2 to PySide6. (Exception: Packages for Anaconda, where dependencies Qt6/PySide6 are not yet available).

  • Completely reworked and modernized the internal asynchronous task system and the scene rendering framework of OVITO.

  • New standard Bonds property “Width”, which allows controlling the diameter of bond cylinders on a per-bond basis.

  • Added detailed documentation for some of the file readers of OVITO. See the Input file formats.

  • LAMMPS data file reader & writer: Added preliminary support for type labels, which will be supported by a future version of LAMMPS.

  • LAMMPS dump file reader: Map columns c_diameter[...] to particle property Aspherical Shape and perform division by 2.

  • GSD file reader & writer: Added support for angles/dihedrals/impropers.

  • User can now rename individual structure types in the UI of structure identification modifiers.

  • Implemented new OpenGL rendering technique *Weighted Blended Order-Independent Transparency*, providing an alternative to the classical painter’s algorithm. Can be activated in the app settings dialog and gives better results if there’s a mix of several different object types (e.g. particles and surfaces) that are all semi-transparent.

  • Detect if the triangle mesh is not closed when loading a custom particle shape. Automatically disable back-face culling for the particle type in this case.

  • CA file reader: Compute dislocation line statistics for re-imported datasets the same way the DXA modifier does.

  • Fix: Particles visual element does not use uniform scaling factor when rendering some non-spherical particle shapes.

Version 3.6.0 (19-Nov-2021)

  • Vectors, Surface mesh, Voxel grid, Trajectory lines visual elements: Added direct color mapping option as a faster alternative to the Color coding modifier.

  • Bonds visual element: Added explicit control of the coloring mode.

  • Made number and Viewport layouts configurable by the user.

  • Visibility of pipelines can be controlled on a Viewport menu per viewport basis.

  • Coordination polyhedra modifier now makes particle properties available for the color coding as mesh region properties and mesh vertex properties.

  • Generate trajectory lines modifier: New capability to transfer time-dependent particle properties to the trajectory lines.

  • Load trajectory modifier: Support non-contiguous atom IDs in LAMMPS bond dump files

  • Added file reader for binary STL files.

  • Customizing the initial program state: New mechanism for customizing the initial program session state.

  • Raised limit on the number of FFT bins in Spatial Correlation Modifier to support finer grid resolutions.

  • Fix: PTM modifier may crash if graphene/diamond are the only enabled structure types.

  • Fix: Traced trajectory lines may be rendered in wrong colors.

  • Took out code that transmits random installation ID to web server.

  • OpenSSL shared libraries are no longer shipped with OVITO for Linux to avoid compatibility issues on some Linux distributions.

  • pro Rendering images or movies of a viewport layout : Added capability to render multi-viewport layouts in one step.

  • pro Python code generator has been extended to generate code for all visual elements and for reenacting manual changes made by the user to data objects (e.g. particle type names, color, radii).

  • pro Added the input_format keyword parameter to the ovito.io.import_file() Python function for specifying the file format explicitly.

  • pro Upgraded OSPRay to version 2.7.1.

  • pro Renamed ovito.vis.Viewport.create_qt_widget() method and made it work in all distributions of the ovito Python module.

  • pro Added experimental ovito.vis.Viewport.create_jupyter_widget() method for embedding OVITO viewports in Jupyter notebooks (see demo binder).

  • pro Support for site-wide software licenses.

  • pro Fix: Bounding box clipping artifact when rendering rotated superquadrics particles with OSPRay or Tachyon renderers.

  • pro Fix: Warning “This plugin does not support createPlatformOpenGLContext!” when running in headless mode on Linux machines.

Version 3.5.4 (31-Jul-2021)

  • LAMMPS data file reader and writer now support all LAMMPS atom styles, including the hybrid style.

  • Fix: Construct surface mesh with region identification fails or never completes for some inputs.

  • pro Fix: Tachyon renderer crashes when triangle mesh contains a degenerate vertex normal.

Version 3.5.3 (30-Jun-2021)

  • Added two Tutorials to the documentation.

  • Voxel grid visual element now supports mouse-over data display in the status bar.

  • Added invert function to Manual selection modifier.

  • Warn user if OVITO Python module was installed via pip command in an Anaconda Python interpreter. Use conda install instead!

  • Fix: Configure Trajectory Playback dialog shows no contents.

  • Fix: Neighbor finder facilities do not ignore PBC flag along third dimension in 2D mode.

Version 3.5.2 (26-May-2021)

  • Affine transformation modifier now allows entering the translation vector in reduced cell coordinates.

  • Load trajectory modifier can now import ReaxFF bond information files written by the LAMMPS fix reax/c/bonds command.

  • GSD file reader: Fill particle property array with default values if a chunk is not present in current frame (issue #206)

  • pro Fix: Invisible simulation cell edges when rendering image with orthographic projection with OSPRay

Version 3.5.1 (18-May-2021)

  • The Coordination analysis modifier has gained an option ‘Only selected particles’, which restricts RDF calculation to a subset of particles.

  • The ‘Generate neighbor bonds’ option of the Voronoi analysis modifier is now able to deal with small periodic simulation cells.

  • Fix: Wireframe line rendering issue in perspective viewports.

  • pro The Slice modifier now accepts (hkl) Miller indices as input for defining the plane orientation. The plane position can be specified in terms of the interplanar spacing.

  • pro OVITO Pro for Linux now ships with a current Python 3.9.5 interpreter.

  • pro Fix: ovito.data.PropertyContainer.create_property() method cannot create user-defined property of data type int64.

Version 3.5.0 (02-May-2021)

  • Pipeline editor supports drag-and-drop operations, which allow easy rearranging of modifiers with the mouse.

  • Modifiers can be grouped in the pipeline editor to collapse complex sequences of modifiers into a single list entry.

  • Color legend layer can render a legend for typed particle properties, showing the discrete colors representing the defined particle types.

  • New implementation of the OpenGL viewport renderer. Provides better compatibility with GPU hardware, older OpenGL drivers, and virtual machine environments. OVITO now works on systems with only OpenGL 2.1 support (previous OVITO version required OpenGL 3.2).

  • New viewport renderer based on the Vulkan graphic hardware interface as an alternative option to the OpenGL renderer. Can be activated in the application settings dialog (not available on macOS). Supports rendering in head-less mode on HPC nodes with GPU hardware.

  • New Pipeline concept pipeline selector widget in the toolbar of OVITO, which lets you manage the data pipelines in the current scene and add new pipelines.

  • Extended the Create bonds modifier. A new parameter-free mode allows creating bonds based on van der Waals radii of the atoms.

  • Performance improvement: Create Bonds modifier can now make use of multiple processor cores.

  • Affine Transformation modifier can now transform triangle meshes (imported from STL, OBJ, VTK files).

  • Several file format readers now provide the option to generate interatomic bonds during data import (relieves from having to apply the Create Bonds modifier).

  • Some file format readers provide a new option to dynamically recenter the simulation cell on the coordinate origin. Useful for visualizing trajectories with varying cell shape.

  • Gromacs, PDB, and mmCIF file readers now import atom names and residue names as particle properties.

  • Internal chemical database of OVITO has been extended to include all elements and mass information, which will be assigned to particle types during file import.

  • The Particles visual element provides a Particles new parameter controlling the uniform scaling of atom radii. Useful for quickly producing a typical “balls-and-sticks” representation of a molecular structure.

  • A bonds-only visualization of a molecular structure (with particles turned off) now adds spheres at the nodal points of the bond network to yield a typical “stick” representation.

  • XYZ file reader now supports the exyz format variant of OpenBabel.

  • Fix: CFG file reader loosing particle type settings during file reload.

  • Fix: Segfault when loading certain NetCDF files with >1M particles.

  • Fix: Error when deleting some regions of a surface mesh structure.

  • Fix: Slow performance of Particles visual element when some particle types use mesh-based shapes.

  • Rearranged the Render settings panel. The viewport preview mode can now be activated from here.

  • Extended the Python API to support ovito.data.VoxelGrid from scripts.

  • OVITO User Manual uses a new layout theme and supports full-text search.

  • Environment variable OVITO_LOG_FILE allows redirecting terminal output of OVITO to a text file (useful on Windows platform, where console output is otherwise inaccessible).

  • pro New modifier Color by type modifier for recoloring particles based on one of their typed properties, e.g. discrete Residue Type or Atom Name property.

  • pro New pipeline data source type Python script . Run a user-defined Python function that builds or synthesizes an input DataCollection for a pipeline (instead of loading a structure from disk). Can also be used to import data formats into OVITO which are not directly supported by the software.

  • pro LAMMPS script : The new data pipeline source type LAMMPS script allows editing and executing LAMMPS input scripts within OVITO to generate a dataset using LAMMPS commands. Useful for prototyping LAMMPS simulation setups with immediate visual feedback in OVITO.

  • pro Updated OSPRay rendering library to version 2.5.0, offering a better denoising filter.

  • pro Spatial Binning modifier can now process vector particle properties in addition to scalar properties.

  • pro Python API: Added the method ovito.data.CutoffNeighborFinder.find_at() for enumerating all particles around an arbitrary spatial position.

  • pro Python code generator: Emit valid code for visualization setups including a PythonViewportLayer.

  • pro Python code generator: Emit call to generate() method of Generate Trajectory Lines modifier.

  • pro Fix: Made auto-crop function work for pictures rendered with OSPRay and denoising filter enabled.

  • pro Fix: Python viewport layer does not get called with current values of user-defined parameters.

Version 3.4.4 (12-Mar-2021)

  • Fix: Number of data columns not correctly detected for XYZ files with 5 atoms or less.

  • Fix: Program crash when playing back animation with less than 1 frame per second in interactive viewports.

  • Fix: Simulation cell not visible in interactive viewports on some computer systems (issue #203).

  • Fix: CIF file reader not automatically recognizing files written by Open Babel (issue #204).

  • pro Fix: OSPRay not rendering arrow glyphs correctly.

Version 3.4.3 (25-Feb-2021)

  • Added text outline option to Coordinate Tripod viewport layer.

  • Fixed UI issue: Status bar resizing due to invalid unicode character in text string.

  • Corrected camera orientation of “Bottom” viewport view type when rotation constraint is turned on.

  • Improved automatic detection of PDB file format.

  • pro It’s now okay to assign a simple string to the ovito.modifiers.ExpressionSelectionModifier expression field.

Version 3.4.2 (15-Feb-2021)

  • Long text strings displayed in the status bar of OVITO now get broken into two lines in order to show more property values in the available space.

  • Bug fix: Status bar doesn’t display latest set of particle properties while positioning the mouse cursor over a particle. This fix corrects a regression introduced with OVITO 3.4.0.

  • Fixed a limitation of the PTM modifier not identifying diamond and graphene structures in small periodic simulation cells.

Version 3.4.1 (03-Feb-2021)

  • Fixed runtime linker error when importing ovito Python module installed via pip on Linux.

  • pro Spatial binning modifier can now operate on vectorial particle properties.

Version 3.4.0 (28-Jan-2021)

  • Backward incompatible .ovito state file format change: Program sessions saved with OVITO 3.4 or later cannot be opened in previous versions!

  • Extensive redesign of OVITO’s internal C++ data object model to make it thread-safe. User experience and Python API remain largely unaffected.

  • State files (.ovito) now store relative paths to imported data files, enabling the relocation of an entire directory tree containing the state file and the data file without breaking the reference.

  • Rewrite of the OpenGL rendering code, making use of geometry shaders on a wider range of hardware. OVITO now requires OpenGL 3.0 or higher (previous releases required OpenGL 2.1).

  • Color Coding modifier: Added an auto-adjust option, which dynamically adjusts the min/max interval to the current range of input values.

  • File importers reading the Velocity vector particle property automatically generate the Velocity Magnitude particle property too.

  • OVITO can now visualize particles with superellipsoid shapes, which are controlled by the Superquadric Roundness particle property.

  • Preliminary file reader support for ParaView VTP, VTI, VTM and PVD formats, as written by the Aspherix DEM simulation code.

  • pro OVITO Pro gives the user the option to edit Python scripts in an external editor application or IDE (e.g. Visual Studio Code). Changes the user makes to the script code in the external editor are automatically loaded back into OVITO Pro.

  • pro The Python script modifier displays the current working directory and lets the user control it if necessary.

  • pro Python-based viewport layers now support user-defined parameters passed to the render() function.

  • pro OSPRay and Tachyon renderers can now render polyhedral meshes with highlighted edges (wireframe overlay).

  • pro New Python method ovito.data.NearestNeighborFinder.find_at().