index | modules | gitlab | page source

# Vibrational modes

You can calculate the vibrational modes of an `Atoms` object in the harmonic approximation using the `Vibrations`.

class ase.vibrations.Vibrations(atoms, indices=None, name='vib', delta=0.01, nfree=2)

  Class for calculating vibrational modes using finite difference.

  The vibrational modes are calculated from a finite difference approximation of the Hessian matrix.

  The summary(), get_energies() and get_frequencies() methods all take an optional method keyword. Use method=’Frederiksen’ to use the method described in:

  > T. Frederiksen, M. Paulsson, M. Brandbyge, A. P. Jauho: “Inelastic transport theory from first-principles: methodology and applications for nanoscale devices”, Phys. Rev. B 75, 205413 (2007)

  atoms: Atoms object

    The atoms to work on.

  indices: list of int

    List of indices of atoms to vibrate. Default behavior is to vibrate all atoms.

  name: str

    Name to use for files.

  delta: float

    Magnitude of displacements.

  nfree: int

    Number of displacements per atom and cartesian coordinate, 2 and 4 are supported. Default is 2 which will displace each atom +delta and -delta for each cartesian coordinate.

  Example:

      >>> from ase import Atoms
      >>> from ase.calculators.emt import EMT
      >>> from ase.optimize import BFGS
      >>> from ase.vibrations import Vibrations
      >>> n2 = Atoms('N2', [(0, 0, 0), (0, 0, 1.1)],
      ...            calculator=EMT())
      >>> BFGS(n2).run(fmax=0.01)
      BFGS:   0  16:01:21        0.440339       3.2518
      BFGS:   1  16:01:21        0.271928       0.8211
      BFGS:   2  16:01:21        0.263278       0.1994
      BFGS:   3  16:01:21        0.262777       0.0088
      >>> vib = Vibrations(n2)
      >>> vib.run()
      >>> vib.summary()
      ---------------------
      #    meV     cm^-1
      ---------------------
      0    0.0       0.0
      1    0.0       0.0
      2    0.0       0.0
      3    1.4      11.5
      4    1.4      11.5
      5  152.7    1231.3
      ---------------------
      Zero-point energy: 0.078 eV
      >>> vib.write_mode(-1)  # write last mode to trajectory file

  clean(empty_files=False, combined=True)

    Remove json-files.

    Use empty_files=True to remove only empty files and combined=False to not remove the combined file.

  combine()

    Combine json-files to one file ending with ‘.all.json’.

    The other json-files will be removed in order to have only one sort of data structure at a time.

  fold(frequencies, intensities, start=800.0, end=4000.0, npts=None, width=4.0, type='Gaussian', normalize=False)

    Fold frequencies and intensities within the given range and folding method (Gaussian/Lorentzian). The energy unit is cm^-1. normalize=True ensures the integral over the peaks to give the intensity.

  get_energies(method='standard', direction='central', **kw)

    Get vibration energies in eV.

  get_frequencies(method='standard', direction='central')

    Get vibration frequencies in cm^-1.

  get_mode(n)

    Get mode number .

  get_vibrations(method='standard', direction='central', read_cache=True, **kw)

    Get vibrations as VibrationsData object

    If read() has not yet been called, this will be called to assemble data from the outputs of run(). Most of the arguments to this function are options to be passed to read() in this case.

    Parameters:

      - method (str) – Calculation method passed to read()

      - direction (str) – Finite-difference scheme passed to read()

      - read_cache (bool) – The VibrationsData object will be cached for quick access. Set False to force regeneration of the cache with the current atoms/Hessian/indices data.

      - **kw – Any remaining keyword arguments are passed to read()

    Returns:

      VibrationsData

  iterdisplace(inplace=False)

    Yield name and atoms object for initial and displaced structures.

    Use this to export the structures for each single-point calculation to an external program instead of using `run()`. Then save the calculated gradients to <name>.json and continue using this instance.

  iterimages()

    Yield initial and displaced structures.

  run()

    Run the vibration calculations.

    This will calculate the forces for 6 displacements per atom +/-x, +/-y, +/-z. Only those calculations that are not already done will be started. Be aware that an interrupted calculation may produce an empty file (ending with .json), which must be deleted before restarting the job. Otherwise the forces will not be calculated for that displacement.

    Note that the calculations for the different displacements can be done simultaneously by several independent processes. This feature relies on the existence of files and the subsequent creation of the file in case it is not found.

    If the program you want to use does not have a calculator in ASE, use `iterdisplace` to get all displaced structures and calculate the forces on your own.

  split()

    Split combined json-file.

    The combined json-file will be removed in order to have only one sort of data structure at a time.

  write_dos(out='vib-dos.dat', start=800, end=4000, npts=None, width=10, type='Gaussian', method='standard', direction='central')

    Write out the vibrational density of states to file.

    First column is the wavenumber in cm^-1, the second column the folded vibrational density of states. Start and end points, and width of the Gaussian/Lorentzian should be given in cm^-1.

  write_jmol()

    Writes file for viewing of the modes with jmol.

  write_mode(n=None, kT=0.02585199101165164, nimages=30)

    Write mode number n to trajectory file. If n is not specified, writes all non-zero modes.

name is a string that is prefixed to the names of all the files created. atoms is an Atoms object that is either at a fully relaxed ground state or at a saddle point. freeatoms is a list of atom indices for which the vibrational modes will be calculated, the rest of the atoms are considered frozen. displacements is a list of displacements, one for each free atom that are used in the finite difference method to calculate the Hessian matrix. method is -1 for backward differences, 0 for centered differences, and 1 for forward differences.

## Old calculations

The output format of vibrational calculations was changed from `pickle` to `json`. There is a tool to convert old `pickle`-files:

    > python3 -m ase.vibrations.pickle2json mydirectory/vib.*.pckl