Tiled arrays of images are a major application of the code and this functionality should be made easily accessible. In the short term this will use Imagemagick.

In the published images the phonon modes are displayed in a tiled array with their corresponding frequencies. This was does with a bit of scripting and imagemagick montage, but could be automated for convenience.

As there are a lot of command-line options and some are a bit verbose, tab-completion would be very handy. There looks to be a decent wrapper for adding tab-completion to argparse: https://github.com/kislyuk/argcomplete . As this is not widely installed, the dependency should be made optional if possible.

One of the projects which inspired this is Clemens Barth's Atomic Blender packages, which renders animated .XYZ files in Blender. Instead of assigning unique meshes to each atom, they are grouped by type and specified as duplicates of a hidden reference atom.

This approach was originally avoided because it makes further modelling more complicated; however, if there is a significant performance advantage to be gained then this is worth doing.

The movement of light atoms such as hydrogen is much greater than that of heavier elements in modes that involve both atoms. While this is a physical effect, it can make it difficult to see coupling between atoms when the modes are visualised. An option to reduce the mass-weighting of phonon modes by rescaling the eigenvectors of lighter elements before normalisation would improve the legibility when illustrating systems such as hybrid organic-inorganic frameworks.

While this is not done by Phonopy, the v_sim format supports multiple q-points in a single ascii file. The mode index should be for a given q-point.

• CLI / python interface: If only a single q-point is present, use it. If more than one, raise a warning and default to first one.
• GUI: provide a drop-down menu listing available q-points.

It should be easy for users to customise their background colour. This should be possible from:

1. the command line,
2. a config file.

Thanks for the nice code.
There are two papers mentioned in the http://ascii-phonons.readthedocs.io : http://dx.doi.org/10.1063/1.4917044 and http://dx.doi.org/10.1103/PhysRevB.92.144308 .
Should I cite one of those or directly add github repository link?

Very minor nitpick, but the example command:

python blend_ascii.py /path/to/my/phonons.ascii -m 1 --gif -o pretty

Doesn't produce anything and gives no warnings if Imagemagick isn't installed.

At the moment the GUI becomes non-responsive while rendering occurs. As it is possible to request an infeasibly complicated model, it would be nice if it could be cancelled from the GUI.

Requested by @aronwalsh

When a primitive cell is provided (as is typical for phonon calculations) the lattice vectors are usually not aligned with the conventional cell vectors. The .ascii format discards this information by using a 6-value unit cell description, but it might be recovered using the standard primitive cell vectors of a spacegroup.

Pros

More intuitive "Miller indices" can be used, default alignment will look better for primitive cells

Cons

Added spglib dependency (or need to integrate/re-implement spglib)

Crystallographers don't think about cameras and raytracing, they think about crystallographic axes. It should be possible to select a sensible camera angle with "a" "b" or "c".

BONUS feature:
Accept a Miller index and face the camera to show the corresponding plane. Possibly use an orthographic lens (i.e. no perspective)?

1. I think it would be beneficial allow to use non-integer supercell indices, e.g. for a large and/or messy cells where "1 1 1" cell is too small and "2 2 2" is too big.
   Also it seem like in case of "1 1 1" supercell any ions with coordinates containing full lattice translations (e.g. if I have ion in origin position, ions with coordinates "1 1 1", "1 0 0", etc.) are not shown , which makes the cell kinda asymmetric and little bit ugly.
2. I think in many cases users (or at least me) would like to show the "1 1 1" supercell with ions close to outside cell in each direction, e.g. to fully reveal the structural groups.
   In VESTA we can use negative "supercell" indices to do it, e.g. show all from -0.3 -0.3 -0.3 to 1.3 1.3 1.3. Is it possible to add such a feature to ascii-phonons?
   I tried to tinker with the code by myself, but to no avail.

The version of Blender packaged for Ubuntu 14.04 does not include the "WIREFRAME" modifier which is used by the new rendering engine. Requiring a more recent version of Blender is a "pain point". This can be worked around by either

a) using the older tracing engine with these versions of Blender, breaking consistency or
b) implementing a solid bounding-box generator in the code to avoid this dependency.

In many cases an orthographic projection is more useful than one with perspective.

• Modify the camera creator to allow an orthographic view to be requested.
• Add option to GUI, perhaps as a pre-ticked "perspective" checkbox

It would be nice if multiple modes could be animated simultaneously, like this example. There is a primitive implementation (which reads from the phonopy mesh.yaml and vasp POSCAR) in Julia here.

There are two save/load options that would be useful from the GUI:

• Loading a user-specific file with element settings (i.e. custom colours, radii...)
• Saving the settings for the current render

The GUI is already a little cluttered in terms of buttons, so it might be beneficial to put these in an application File menu.

The file format would naturally be the same .conf files as found in addons/vsim2blender.
It isn't entirely clear how the two settings files should be related:

• Does the "current render" conf remember the preferred element settings file?
• Are the element settings dumped into the "current render" conf?

The difference between these in practice is what happens when the user saves a configuration and then modifies their personal elements conf.

The current use of Freestyle is causing some odd effects where atoms and unit cell overlap.

This can be fixed by rendering the unit cell separately and compositing with Z information.

Demo here (with some fun aesthetics added):

https://twitter.com/binarystate/status/834388535771791362

Arrow scaling is very system-dependent. It would be helpful if an heuristic method could be used to set the initial scale factor, with the user control normalised to 1.0.

A little floating axis gizmo would help keep track of images with different projections.

This seems like a good opportunity to learn the Sphinx/Readthedocs workflow

Explain how to set up PYTHONPATH for ascii_phonons library.

I just use the example file, but it has a problem in python.

import sys
from os.path import pathsep

sys.path = ['D:\programFiles\ascii-phonons-master\addons'] + sys.path

import bpy
import vsim2blender
import vsim2blender.plotter

config = vsim2blender.read_config(user_config='C:\Users\JINHO-~1\AppData\Local\Temp\tmphryt1lxd')

Final line made the problem (SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \UXXXXXXXX escape).

Eigenvectors from Phonopy for v_sim are already mass-weighted. At the moment, the mass-weighting is being exaggerated. This is unphysical and does not show the Gamma-point acoustic modes as rigid displacements, which they should be.

In principle gif files and image arrays, provided by convert and montage respectively, can both be generated using the PIL tools which are already a project dependency.

While development has focussed on the command-line interface, this is largely implemented as Blender plug-ins, and an interactive control panel could be created for Blender.

At the moment this is not seen as a high priority as the majority of people computing phonons are not Blender users already, and the Blender GUI has a steep learning curve. If this is a feature you would like to see (or to work on!) please comment on this Issue.

The Freestyle tools in Blender offer much more control over line tracing. However, they are not very compatible with the wireframe object currently used to display the bounding box.

For an attractive tracing setup:

• enable Freestyle (SCENE.render.use_freestyle)
• Setup two Freestyle line sets (one is created by default)
  • Atom outlines, using 'Silhouette' and 'Border' edge types and a thin (3pt) black line
  • Bounding box, using 'Edge Mark' edge type, round caps and a thicker (5pt) line
• Bounding box line set should be above atom outlines
• Make bounding box tracable
  • Instead of wireframe, use a regular solid material for bounding box
  • Create thin wireframe with wireframe modifier and apply to create new mesh
  • Select all edges of wireframe mesh and add Freestyle edge marks

The result of this is that the bounding box is stroked twice, with the thicker box line settings hiding the thin outline. Atoms are stroked once, with a configurable line thickness and colour.

Hello there.

I'm trying to run ascii-phonons 1.0 on the following scenario:
OS = centos 6.5 x86_64
CC = gcc 5.3.0
Python = 3.5.5
Numpy = 1.14.2
Requests = 2.18.4
Blender = 2.79b compiled with the following options: (output from cmake -L)

CMAKE_BUILD_TYPE:STRING=RelWithDebInfo
WITH_ALEMBIC:BOOL=OFF
WITH_ALEMBIC_HDF5:BOOL=OFF
WITH_BOOST:BOOL=OFF
WITH_BUILDINFO:BOOL=ON
WITH_BULLET:BOOL=ON
WITH_CODEC_AVI:BOOL=ON
WITH_CODEC_FFMPEG:BOOL=OFF
WITH_CODEC_SNDFILE:BOOL=OFF
WITH_COMPOSITOR:BOOL=ON
WITH_CYCLES:BOOL=OFF
WITH_CYCLES_CUDA_BINARIES:BOOL=OFF
WITH_CYCLES_OPENSUBDIV:BOOL=OFF
WITH_CYCLES_OSL:BOOL=OFF
WITH_CYCLES_STANDALONE:BOOL=OFF
WITH_CYCLES_STANDALONE_GUI:BOOL=OFF
WITH_DOC_MANPAGE:BOOL=OFF
WITH_FFTW3:BOOL=OFF
WITH_FREESTYLE:BOOL=ON
WITH_GAMEENGINE:BOOL=ON
WITH_GAMEENGINE_DECKLINK:BOOL=ON
WITH_GHOST_XDND:BOOL=ON
WITH_GTESTS:BOOL=OFF
WITH_IK_ITASC:BOOL=ON
WITH_IK_SOLVER:BOOL=ON
WITH_IMAGE_CINEON:BOOL=ON
WITH_IMAGE_DDS:BOOL=ON
WITH_IMAGE_FRAMESERVER:BOOL=ON
WITH_IMAGE_HDR:BOOL=ON
WITH_IMAGE_OPENEXR:BOOL=OFF
WITH_IMAGE_OPENJPEG:BOOL=ON
WITH_IMAGE_TIFF:BOOL=ON
WITH_INPUT_NDOF:BOOL=ON
WITH_INSTALL_PORTABLE:BOOL=ON
WITH_INTERNATIONAL:BOOL=ON
WITH_JACK:BOOL=OFF
WITH_JACK_DYNLOAD:BOOL=OFF
WITH_LIBMV:BOOL=ON
WITH_LLVM:BOOL=OFF
WITH_LZMA:BOOL=ON
WITH_LZO:BOOL=ON
WITH_MOD_FLUID:BOOL=ON
WITH_MOD_OCEANSIM:BOOL=OFF
WITH_MOD_REMESH:BOOL=ON
WITH_MOD_SMOKE:BOOL=ON
WITH_OPENAL:BOOL=ON
WITH_OPENCOLLADA:BOOL=OFF
WITH_OPENCOLORIO:BOOL=OFF
WITH_OPENGL_DRAW_TESTS:BOOL=OFF
WITH_OPENGL_RENDER_TESTS:BOOL=OFF
WITH_OPENIMAGEIO:BOOL=ON
WITH_OPENMP:BOOL=ON
WITH_OPENSUBDIV:BOOL=OFF
WITH_OPENVDB:BOOL=OFF
WITH_OPENVDB_BLOSC:BOOL=OFF
WITH_PLAYER:BOOL=OFF
WITH_PYTHON_INSTALL:BOOL=ON
WITH_PYTHON_INSTALL_NUMPY:BOOL=ON
WITH_PYTHON_INSTALL_REQUESTS:BOOL=ON
WITH_PYTHON_MODULE:BOOL=OFF
WITH_RAYOPTIMIZATION:BOOL=ON
WITH_SDL:BOOL=OFF
WITH_SDL_DYNLOAD:BOOL=OFF
WITH_STATIC_LIBS:BOOL=OFF
WITH_SYSTEM_EIGEN3:BOOL=OFF
WITH_SYSTEM_GLES:BOOL=OFF
WITH_SYSTEM_GLEW:BOOL=OFF
WITH_SYSTEM_LZO:BOOL=OFF
WITH_SYSTEM_OPENJPEG:BOOL=OFF
WITH_X11_ALPHA:BOOL=ON
WITH_X11_XF86VMODE:BOOL=ON
WITH_X11_XFIXES:BOOL=ON
WITH_X11_XINPUT:BOOL=ON

The blender executable is found by *which blender, but when trying to execute both ascii-phonons or ascii-phonons-gui it barfs the same error message:

[user@machine examples]$ ascii-phonons -o kesterite kesterite.ascii
Color management: using fallback mode for management
found bundled python: /path/to/blender/2.79/2.79/python
addon not found: 'cycles'
Traceback (most recent call last):
  File "/home/user/ascii-phonons-1.0.0/examples/tmpzvyuxsz5.py", line 14, in <module>
    vsim2blender.plotter.setup_render_freestyle(**{'output_file': 'kesterite', 'input_file': '/home/user/ascii-phonons-1.0.0/examples/kesterite.ascii'})
  File "/path/to/blender/2.79/2.79/python/lib/python3.5/site-packages/vsim2blender/plotter.py", line 508, in setup_render_freestyle
    bpy.ops.object.modifier_add(type='SUBSURF')
  File "/path/to/blender/2.79/2.79/scripts/modules/bpy/ops.py", line 189, in __call__
    ret = op_call(self.idname_py(), None, kw)
TypeError: Converting py args to operator properties:  enum "SUBSURF" not found in ()
Blender quit

I had to compile blender because the binary release segfaults even when using 2.19 libc shared libraries via LD_PRELOAD.

Any clue where the error might be?

Thanks for any help,
Fabricio

I want to simply visualize the ascii files printed by phonopy.

I am using ./ascii-phonons -b /Applications/Blender.app/Contents/MacOS/Blender ../../animations/animation_G.ascii .

The call breaks giving the error

Blender 3.4.1 (hash 55485cb379f7 built 2022-12-20 00:48:52)
Read prefs: "/Application Support/Blender/3.4/config/userpref.blend
Error: Python: Traceback (most recent call last):
  File "/phonons/ascii-phonons/scripts/tmpojzggnou.py", line 13, in <module>
    vsim2blender.plotter.open_mode(**{'input_file': 'phonons/animations/animation_G.ascii', 'blender_bin': '/Applications/Blender.app/Contents/MacOS/Blender'})
  File "/phonons/ascii-phonons/addons/vsim2blender/plotter.py", line 359, in open_mode
    draw_bounding_box(lattice_vectors, offset=bbox_offset)
  File "/phonons/ascii-phonons/addons/vsim2blender/plotter.py", line 37, in draw_bounding_box
    cart_offset = offset * Matrix(cell)
TypeError: Element-wise multiplication: not supported between 'Vector' and 'Matrix' types

Blender quit

I am trying to figure if there is a way out around this?

Thanks!

YAML is slow and is an annoying dependency to add on systems that don't otherwise use Python 3 for anything. A simpler text format using a default parser would be fine. Configparser looks like the way to go

There aren't many users at the moment, so we can probably afford to make the change now. If made later, a script should probably be provided to migrate existing YAML files to the new format.

When we displace the system along a normal mode, how to write the new coordinates in POSCAR format?

If you're looking at this on GitHub you probably already know that command line interfaces are a superior way to interact with most non-interactive programs ;-) Nonetheless, a simple GUI would make this more accessible and would also make the features more discoverable.

This feature request refers to a standalone GUI which would still call Blender in batch mode.

At the moment only the real part of the displacement vector is used when displaying arrows. This is useful in combination with animated atoms as it helps show how the phase difference leads to different positions on the same trajectory. However, for static images it would be useful to incorporate this information into the arrows.

• This could be enabled automatically for single-frame images
• The arrow-head tracks the position of displaced atoms corresponding to the current frame