Arbirary Order Frozen Phonon

Arbitrary order frozen phonon method is the key to compute lattice dynamics at arbitrary order with any system, with arbitrary first-principles approach.

Here we introduce the basics of our implementation.

Most of the symmetry analysis works are done in other places, here the code mostly deals with the finite displacement method, either creating runs for a given first-principles method or solving for the derivatives from the calculated data.

In the future, these two core features will be abstracted to a generic finite displacement class. And this code will simply combine the sysmtry analysis and the finite displacement together.

from frozen_phonon_n import frozen_phonons
from frozen_phonon_sym import Frozen_Phonon_Sym

poscar = """\
graphene
   1.00000000000000
     2.1217113285639000    1.2249706066897641    0.0000000000000000
     2.1217113285639000   -1.2249706066897641    0.0000000000000000
     0.0000000000000000    0.0000000000000000  -15.0000000000000000
   2
Direct
  0.00000000  0.00000000  0.0000000000000000 C:p
  0.33333333  0.33333333  0.0000000000000000 C:p
""".strip()

Here let’s show the frozen phonon class that has symmetry included with the above graphene primitive cell structure.

fps = Frozen_Phonon_Sym(
    pos=poscar, # Primitive structure
    qvecs="0 0 0", # The Q without the hidden q
    supa='1 0 0  0 1 0  0 0 1', # (Optional) Provide a supercell that fits the Q, if not provided one will be found
    pgn="D6h", # Point group.
    pg_loc="1/3 1/3 0", # (Optional) The symmetry site.
    fp_fname='fp_info', # The name of the info file to save essential data.
    use_symadt=True # (Optional) If True use the full group adt, if False use the little group version
)

((0, 0, 0), (0, 0, 0))

# Following the construction, use call the following method to construct displacements
fps.construct_displacement_grid()

In the process of constructing the displacement grid, displacements in the reciprocal space will be found. Then a unitary transformation between the reciprocal space (complex) and the real space will be determined so that the displacement of the calculations will be all real. The forward and backward displacements of the central finite displacements will be embedded to the displacement to finally produce the displacement grid.

For the symmetrized version, the displacement grid shows along which q-point, which irrep of the q-point, real/imaginary part of the basis and forward/backward direction of the displacement.

For the non-symmetry verion, the grid shows the irrep of the q-point is replaced by atom and polarization.

At second order, each displacement contains 1 set of q-point, basis and direction, but at higher order one displacemnt consists of several sets of them. Since this is an implementation uses force, we only need to take order-1 finite displacement derivatives.

fps.displaced_grid

[(((Fraction(0, 1), Fraction(0, 1), Fraction(0, 1)),
   (('B2g', (('B2g', 0), 0)), 0),
   'c',
   -1),),
 (((Fraction(0, 1), Fraction(0, 1), Fraction(0, 1)),
   (('B2g', (('B2g', 0), 0)), 0),
   'c',
   1),),
 (((Fraction(0, 1), Fraction(0, 1), Fraction(0, 1)),
   (('E2g', (('E2g', 0), 0)), 0),
   'c',
   -1),),
 (((Fraction(0, 1), Fraction(0, 1), Fraction(0, 1)),
   (('E2g', (('E2g', 0), 0)), 0),
   'c',
   1),),
 (((0, 0, 0), (0, 's'), 0),)]

To create DFT calculations, the make_runs method should be called.

method make_runs(delta,dft_io_interface=None,overide_naming_scheme=None,renorm_delta=False,sequence=False,defaults={},dry_run=False,skip_delta_check=False)

• delta: The displacement amplitute, normally takes in a floating point number. It is possible to specify different amplitute for different q-points, but it has not been tested if it will produce better results or worse.
• dft_io_interface: This is a method that with a provided structure, directory and some default settings, create files for a specific DFT engine at the given directory that later the DFT enegine can be executed there and calculate the energy of the system and forces on the atoms. An interface to VASP is provided in file_io.vasp_io.vasp.gen_files.
• overide_naming_scheme: A function that replace the one in the code that determine a uniq name for each displacement runs.
• sequence: Whether or not add a sequential number prefix to the directory names of the runs.
• defaults: Some default setting for the DFT interface.
• dry_run: Whether or not to perform a dry run with no directories created.
• skip_delta_check: Whether or not to skip the check on the type of the delta input.

Example

fps.make_runs(
    delta=0.01,
    dft_io_interface=vasp.gen_files,
    sequence=True,
    )