Nanosurf Lab

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
//Note:// If you work with the **flexible-tip**=**PP-AFM** adjust the geometry into the necessary box for the force-field calculations. Don't forget to put the top-most atoms above ''0.0'', but lower part of the box in the //z// direction.

At the moment the PP-STM code can read inputs from following DFT codes:

== Fireball ==
[[http://www.fireball-dft.org]]

Official version of //FireballTG// can write out input files now.

A working executable for creation of necessary input files is also at: 
/storage/praha1/home/krejcio/bin_fireball_stable/fireball.x

Input files can computed with McWEDA functional as well as with computing XC on a grid. Cluster systems as well as systems with Periodic Boundary Conditions (PBC) can be computed.
A __fireball.in__ file for calculations with McWEDA:

  &OPTION
  basisfile =     'answer.bas'
  lvsfile =       'input.lvs'
  kptpreference = 'input.kpts'    ! only gamma point-calculations work at the moment
  nstepf     = 1
  icluster   = 0     ! 0 for PBC / 1 for cluster calculation
  itdse      = 0
  iqout      = 1
  ifixcharge = 1     ! 0 if you don't have pre-calculated atomic charges in CHARGES
  iquench    = -1
  &END
  
  &OUTPUT
  iwrtcdcoefs = -2   ! print the important files
  &END

A __fireball.in__ file for calculations with XC on a grid computations:

  &OPTION
  basisfile     = 'answer.bas'
  lvsfile       = 'input.lvs'
  kptpreference = 'samplek.kpts'
  nstepf     = 1
  icluster   = 0      ! 0 for PBC / 1 for cluster calculation
  itdse      = 0
  iqout      = 1
  ifixcharge = 0
  dt         = 0.5
  iquench    = -1
  iks        = 1
  imcweda    = 0
  idogs      = 0
  bmix       = 0.05
  &END
  
  &OUTPUT
  iwrtcdcoefs =  -2
  &END

In case of PBC calculations __phik_0001_s.dat__, __phik_0001_py.dat__, ... files are produced by the Fireball. In case of cluster calculations __phik_s.dat__, __phik_py.dat__, ... are outputs of the //Fireball// calculations. They serve as inputs for the PP-STM calculations. Inside they look like:

        38     280     -5.37896401                                                          Number of atoms   Number of states (Molecular orbitals)   The Fermi Level
   -27.58251      -0.00004   0.00000      -0.00006   0.00000       0.00002   0.00000   ...  Eigen-energy of the 1st state  Real & Imaginary part for the LCAO coeficient for 1st state 1st atom for (s, py ... depending on the name of file) etc.
   -27.58139       0.02716   0.00000       0.04766   0.00000       0.00660   0.00000   ...  eigen-energy of the 2nd state  Real & Imaginary part for the LCAO coeficient for 2nd state 1st atom for (s, py ... depending on the name of file) etc.
   ... 

== GPAW ==
[[http://wiki.fysik.dtu.dk/gpaw/]]

Even though the //GPAW// is mainly used for representing the wave-function on a grid it can work in LCAO mode as well. For the purpose of making inputs for the PP-STM calculations the LCAO mode is necessary. Both - default or double-zeta (basis='dzp'; for more information look at the //GPAW// web page http://wiki.fysik.dtu.dk/gpaw/) - basis sets can be used. The PP-STM code reads the stored *.gpw binary produced by the //GPAW// calculations. Here is an example of some //GPAW// script for the calculations of the input:

  from ase import *
  from ase.visualize import *
  from ase.io import*
  from gpaw import *
  import numpy as npy
  
  mol = read('input.xyz')                                       # xyz geometry of the sample
  cell = npy.loadtxt('input.lvs')                               # cell in which a sample is
  mol.set_cell(cell)
  mol.set_pbc(False)                                            # cluster calculation, but PBC can be used as well: mol.set_pbc(True)
  mol.center()
  xc='LDA'                                                      # other XC like PBE, RPBE, PW91, BLYP can be used, too.
  calc = GPAW(txt='out_LCAO.txt',xc=xc,mode='lcao',basis='dzp')
  mol.set_calculator(calc)
  en = mol.get_potential_energy()
  print en
  calc.write('out_LCAO_'+xc+'.gpw',mode='all')                  # saves the calculation into binary 'out_LCAO_LDA.gpw' file

The results of the //GPAW// calculations is stored in binary file '__out_LCAO_LDA.gpw__'


== FHI-aims ==
[[http://aimsclub.fhi-berlin.mpg.de/]]

Works for PBC calculations serial or parallel (mpi.scalapack) version. Ideally with the final geometry run a single point calculation with the following outputs added to your __control.in__:
  output eigenvectors
  output band 0 0 0 0.5 0.5 0.0 2 G K
      KS_method lapack_fast  # for mpi-version (mpi.scalapack): The error message with HDF5 is not true in the aims output; use this keywords instead of recompilation #
See the [[https://github.com/ondrejkrejci/PPSTM/blob/master/tests/CuPc/control.in|CuPc example]]

In the case of hybrid functionals (B3LYP, PBE0, HSE) add also:
  exx_band_structure_version 1 ## for hybrid functionals only; both options 1 and 2 are working (1 takes more memory) ##
into your __control.in__ file.

The calculations produces: __KS_eigenvectors.band_1.kpt_1.out__ for spin-restricted calculations or __KS_eigenvectors_dn.band_1.kpt_1.out__ & __KS_eigenvectors_up.band_1.kpt_1.out__ in the case of spin-polarized calculations.
You will also need __geometry.in__ in the same directory. All of these files are supposed to be easily read by the __PPSTM_simple.py__ script or within __GUI.py__.

Note: Under normal conditions, please use PBC calculations, Just adjust the __geometry.in__ with a suitable ''lattice_vector''s (for small molecules ''30.0 30.0 30.0'' box is enough). There is a possibility to run strict cluster calculations, but additional parsing through Mathematica scripts (and some additional outputs) have to be used for creating PP-STM inputs.

== CP2K ==
[[http://www.cp2k.org/]]

into your input file __YOUR_INPUT_FILE.inp__ into FORCE_EVAL → DFT → PRINT section add:

      &MO ON
        EIGVECS
        CARTESIAN
        FILENAME cartesian-mos
        &EACH
          QS_SCF 0
        &END EACH
      &END MO

Examples of input (and output) files can be found in the code in __examples/__ __4N-coronene/__ __CuPc/__ and __TOAT/__ .

Note: CP2K reading procedure was mainly written by Ole Schütt, those days working at EMPA, Switzerland.
Nanosurf Lab

User Tools

Site Tools

Page Tools
