pyfplo.fedit

The fplo editor fedit has a pipe mode, which is documented elsewhere. Read the documentation in fedit help screens and in the fplo manual (FPLO..../DOC/MANUAL/doc.pdf). This module allows to use fedit pipe mode from python scripts. It is recommended that this class is used to manipulate =.in files. The low level classes in module pyfplo.fploio can be used as well, but do not ensure data consistency. E.g. one can set relativistic.type to a certain number (if one knows, which one) but the corresponding relativistic.descriptor would not be set automatically. Consequently the resulting =.in file would be correct from fplo point of view but a human will be mislead when perusing the file.

Checkout the examples delivered with fplo.

Functions

fploExecutable(suffix='')

Parameters:suffix (str) – for convenience, suffix is appended to the exec name

Return the name of the fplo executable as str, which fits the pyfplo version. This is an educated guess. There is no garantee that it is correct. If you compiled with a non-default build branch, this function does not return the name including the build branch suffix but just the generic name. Use suffix to select the correct executable or just write it out explicitely anyway.

Fedit

class Fedit(recreate=False)

Use this class as an interface for fedit pipe mode. There are general routines and specialized routines for a lot of possible input. Altogether arbitrary input can be created. To find out valid search strings or hotkeys consult fedit itself.

recreate: please consult resetPipeInput.

Most routines take keyword arguments. One only needs to specify the keyword explicitely if a selected subset of the arguments is used. Not all arguments need be given. If all are used the keywords can be left out (however the order of arguments does).

Many options are bool-like. In these cases the possible values are True, 1, 't', '+' or False, 0, 'f', '-'.

Arguments like defs in lsdau can be either a list of items, whose syntax is explained in each functions documentation, or an empty list [], which basically resets defs to an empty list. In other words there are no explicit counters for lists-like input. The number of list items in defs and the like is the counter. Have a look at the fedit LSDA+U submenu. There you have under CORRELATED STATES the item “(N)umber of definitions :” followed by the list of Wyckoff positions, states and F0…. To set this counter to zero use defs=[]. If recreate or resetPipeInput(recreate=True) is used properly this is however rarely needed.

Illustrative example:

import pyfplo.fedit as fedit
fed=fedit.Fedit(recreate=True) # if `True`, reset to default input
                               # (except symmetry)
fed.relativistic('s') # set to scalar relativisitc
# or
fed.relativistic('scal') # is the same
# or using the full explicit hotkey sequence
# note that the individual hotkey-value pairs are separated by newline
# (\n)
fed.addToPipeInput('@r@\n!scal!\n@x@')
# which is short for
fed.addToPipeInput('@r@') # enter relativistic submenu
fed.addToPipeInput('!scal!') # use search string
fed.addToPipeInput('@x@') # leave submenu
fed.pipeFedit(prot=True) # do the actual piping and show details

The simplest (old-style) way to create input is the following:

import pyfplo.fedit as fedit
fed=fed.Fedit()
fed.pipeFedit('''
# reset to default
@ e@
# vxc
@v@
!96!
@x@

#k-mesh
@k@ 16,,
#done
@q@
''',prot=False)

or with variable options:

import pyfplo.fedit as fedit
fed=fed.Fedit()
fed.pipeFedit('''
# reset to default
@ e@
# vxc
@v@
!{1}!
@x@

#k-mesh
@k@ {0},,
#done
@q@
'''.format(16,'Zunger'),prot=False)

resetPipeInput(recreate=False)

Reset all pipe input. If recreate is True the default-input- creation flag is set, which triggers non-symmetry input to become default after symmetry input. This way we start from a default input, which avoids a buildup of unwanted input from former manipulations.

addToPipeInput(txt)

Add any hotkey sequence to the fedit pipe input. This routine can be used for arbitrary sequences and in fact is underlying all the specialized routines. Example:

# All in one go. (Note the use of newline \n)
fed.addToPipeInput('@r@\n!scal!\n@x@')
# which is short for
fed.addToPipeInput('@r@') # enter relativistic submenu
fed.addToPipeInput('!scal!') # use search string
fed.addToPipeInput('@x@') # leave submenu

pipeFedit(text=None, prot=None)

Execute the pipe mode of fedit. Use text if not None. Note that text must end in @q@ for success. If text is None, use the internal pipeinput collected so far. If prot is True, show verbose output about what is going on internally. See examples in Fedit.

symmetry(compound=None, units=None, type=None, latcon=None, angles=None, atoms=None, spacegroup=None, setting=None, globalaxes=None, generators=None)

This function (like most) can be called with different key words, also sequentially, as in:

fed.symmetry(latcon=[4,5,6])
fed.symmetry(spacegroup=221)

or in a single call:

fed.symmetry(latcon=[4,5,6],
             spacegroup=221)

units can be a search string or a hotkey.

type (structure type) can be a search string or a hotkey.

spacegroup (int or str) is the group number

setting (str) is the setting. Consult fedit itself for proper values.

Example:

fed.symmetry(spacegroup='74',setting='a-cb')

latcon can be missing or a list or string containing 3 lattice constants.

angles can be missing or a list or string of 3 axis angles.

atoms can be [[element,position],...] where

element (str) is the element

position (list or str) is a list or a string of the positions x,y,z coordinates. The comma repeater can be used. in the same way as in fedit itself.

Example:

fed.symmetry(atoms=[['Sm' ,['0.123','3/4',',']]]
#or
fed.symmetry(atoms=[['Sm' ,[0.123,3./4,',']]]
#or
fed.symmetry(atoms=[['Sm' ,'0.123 3/4,']]]

Note that in python 3/4 equals 0 (integer arythmetic) while 3./4=0.75.

globalaxes can be [active,xaxis,zaxis] where

active (bool-like) says, if the axes are active.

xaxis and zaxis (list or str) are a list or string of 3 numbers.

Example:

fed.symmetry(globalaxes=[True,[1,1,0],[-1,1,2]])
# or
fed.symmetry(globalaxes=[1,"1 1 0","-1 1 2"])

generators (list) is a list or string of int and represents the list of valid subgroup generators. Use the fedit symmetry-information submenu in the symmetry menu to find out the desired numbers.

options(oplist=None)

oplist can be [[OPTION,True_or_False],...] or simply [OPTION,True_or_False] for a single option, where

OPTION is one of fedits options-menus options.

True_or_False can also be 0 or 1

Examples:

fed.options([['FULLBZ',1],['CALC_DOS',False]])
# or
fed.options(['FULLBZ',1])
fed.options(['CALC_DOS',False])

spin(spin=None, initialspinsplit=None, initialspin=None, fsm=None)

spin can be missing or 1 or 2.

initialspinsplit can be missing or True or False or equivalent values.

initialspin can be [[sort,spinmoment],...] where

sort (int) is a sort/Wyckoff postition number and

spinmoment (float) is the initial spin moment

fsm can be missing or a list: [True_or_False,fsmmoment]

Example:

fed.spin(initialspin=[[1,2],[2,0],[3,0]])
fed.spin(spin=2,initialspinsplit=True)

fed.spin(fsm=[True,2.4])

xcoptions(cmBJ=None)

cmBJ can be None or a float

Example:

fed.xcoptions(cmBJ=None)
fed.xcoptions(cmBJ=1.1)

relativistic(mode=None, quantaxis=None)

mode can be a search string or a hotkey.

quantaxis (list or str): e.g. [1,1,0] or '1 1 0'

Example:

fed.relativistic('scal')
# or
fed.relativistic('s')

# set full relativisitc and quantization axis
fed.relativistic('full',quantaxis=[1,1,0])

bzintegration(nxyz=[12, 12, 12], temperature=None, method=None, mpparam=None)

nxyz (list or str): a list or string with 3 int.

temperature (float or str): temp for molecules.

method (str): can be a hotkey ('T' or 'M') or a search string (e.g. 'tet' or 'pax'). Note that 'meth' will select the tetrahedreon method because 'meth' matches ‘method’

mpparam: can be a list [width,order] (width in Hartree)

Example:

# nxyz is the first argument to bzintegration. Hence
# we can leave out the keyword
fed.bzintegration([ 6, 9, 12])
# or we do it explicitely and use strings
fed.bzintegration(nxyz=' 6  9  12')
# choose method
fed.bzintegration(method='pax',mpparam=[0.005,1])

# or all together
fed.bzintegration([ 6, 9, 12],method='pax',mpparam=[0.005,1])

optics(active=False, bounds=None, Ne=None, jointdos=None, stopafter=None)

active (bool-like): is optics active?

bounds: can be a list with the content [lbound,ubound] where lbound… are float

Ne (int or str): number of energy points

jointdos (bool-like): see fedit help screens.

stopafter (bool-like): obvious.

Example:

fed.optics(True,bounds=[0,10],Ne=2000,stopafter=True)

charges(vca=None, charges=None)

vca: can be a list: [active,Zlist] where

active is bool-like

Zlist is [] or [[sort,Z],...] where

sort (int): is a Wyckoff position number

Z (float or str): is the nuclear charge

charges can be [mode,ionicity] where

mode (str): is a search string ('none', 'jel', 'mol') or a hotkey (1, 2, 3)

ionicity (float or str): is obvious

Example:

fed.charges(vca=[True,[
             [1,25.2],
             [2,27.9]]
       ])

vxc(version=None, xfactor=None)

version (str): a hotkey or search string (e.g. '5' or 'Ernzerhof 96')

xfactor (float or str): xc-field scaling

Example:

fed.vxc(version=5)

verbosity(level=None)

level (str): a hotkey or search string (e.g. '2' or 'basic')

Example:

fed.verbosity(level='basic')

ti(z2=None, homooffset=None, forcewanniercenters=None, integrationintervals=None, kyparamintervals=None)

z2 (bool-like): switch on/off the calculation of Z2 invariants.

homooffset (int): The code will determine the likely highest occupied valence band (assuming a real gap exists). Then it calculates the invariants for a set of bands from -offset to +offset around this band.

forcewanniercenters (bool-like): the Wannier center algo will additionaly be executed for centro symmetric systems.

integrationintervals (int): The Wannier centers are functions of a paramter (ky-parameter), which are obtained by “integrating” along a second direction. Here you specify the number of integration intervals.

kyparamintervals (int): This determines the number of intervals along the ky-parameter axis.

Example:

fed.ti(z2=True,homooffset=4,forcewanniercenters=False,
    integrationintervals=40,kyparamintervals=100)

finuc(mode=None)

Finite nucleus settings.

mode (str): hotkey or search string (e.g. 3 or 'linear')

Example:

fed.finuc('linear')

opc(active=True, functional=None, defs=None)

Orbital polarization correction.

active (bool-like): active or not?

functional (str): hotkey or search string (e.g. 1 or 'spin dependend')

defs (list): may be [] or [[sort,state-label],...] where

sort (int) is a wyckoff position number and

state-label (str) is something like '3d' or '4f'

Example:

fed.opc(True,'spin independend',[[3,'4f'],[7,'4f']])

bandplot(active=True, points=None, ksteps=None, weights=None, transaxis=None, xaxis=None, zaxis=None, bwdeffile=None, ldossites=None, interval=None, restrictbands=None, idos=None, ndos=None, coeff=None)

Bandplot options.

active (bool-like): is bandplot active?

weights (bool-like): is bandweights active?

points (list): can be [] or [ [label,[kx,ky,kz]] , ... ] alternatively the point can be written [label,"kx ky kz"]

kstep (int): steps between sym-points

bwdeffile (str): file name for band weight definitions (=.bwdef)

transaxis (bool-like): transform axes?

xaxis (list or str): xaxis for band weights

zaxis (list or str): xaxis for band weights

ldossites (list): list of ldos sites

idos (bool-like): plot idos?

ndos (bool-like): plot netdos?

interval (list): dos-energy interval: [ne,lbound,ubound] where

ne (int) is the number of energy points

lbound (float) is the lower energy bound

ubound (float) is the upper energy bound

coeff (bool-like): trigger output of +coeff

restrictbands (bool-like): restrict bands to window

Example:

...
# let's do it in two steps: general settings
fed.bandplot(active=True,ldossites=[2,17],
        weights=True,transaxis=True,xaxis='1 1 0',zaxis=[-1,1,0],
        restrictbands=True,
        interval=[2000,-2,3])
# high symmetry points
fed.bandplot(points=[
       ['$~G',[0,0,0]],
       ['X',[1,0,0]],
       ['M',[1,1,0]],
     ])

lsdau(active=True, functional=None, projection=None, defs=None, tol=None, occumode=None)

LSDA+U settings.

active (bool-like): is LSDA+U active?

functional (str): hotkey or search string (e.g. 2 or 'atomic limit')

projection (str): hotkey or search string (e.g. 4 or 'gross')

tol (float): the inner occu-matrix loop convergence tolerance

occumode (str): hotkey or search string (e.g. 2 or 'fixed')

defs (list): can be [] or [[sort,state-label,[f0,f2,f4,f6]],...] or [[sort,state-label,[],[U,J,F4oF2,F6oF2]],...]. The second option with an empty F-list is for convenience. The list elements are

sort (int) is a sort

state-label (str) is e.g. '3d' or '4f'

f0, f2, f4, f6 (float) are obvious

U, J, F4oF2, F6oF2 (float) are U, J, F4/F2 and F6/F2. If not needed, J, F4oF2 and F6oF2 can be left out. Also, if F4oF2 and/or F6oF2 are not given but needed, default values are used. If only U is given all Fi, i>0 are zero and hence J is zero:

s: only U is needed

p: only U and J make sense

d: U, J and F4oF2 (default 5.5/8.5)

f: U, J, F4oF2 and F6oF2 (default 2./3 and 1./2)

Example:

# explicit F2,F4, two sorts
fed.lsdau(True,functional='atomic',projection='gross',
     ,defs=[
         [3,'3d',[8,9,5,0]],
         [5,'3d',[8,9,5,0]],
     ])
# implicit F2, F4,  explicit U and J, two sorts
fed.lsdau(True,functional='atomic',projection='gross',
     ,defs=[
         [3,'3d',[],[8,1]],
         [5,'3d',[],[8,1]],
     ])

gridoutput(active=None, stopafter=None, defs=None)

Define the grid output settings.

active (bool-like): do we want it?

stopafter (bool-like): obvious

defs (list): can be [] or a list of dicts one for each grid definition, with the following structure:

[{ # first grid definition
   'basis': basis,
   'dir1':  list_or_str,
   'dir2':  list_or_str,
   'dir3':  list_or_str,
   'origin':list_or_str,
   'subdiv':list_or_str,
   'includeperiodicpoints': True_or_False
   'createopendx': True_or_False
   'scfenergywindow': list_or_str_of_two_float
   'quantities':quantdict,
   'outputdata':outputdatadict,
   'kresolved':kresolvedlist,
   'eresolved':eresolvedlist},
 { # second grid definition
     ...},
 ...
]

where not all dict keys need to be present! The individual values are

list_or_str: a list or string of 3 numbers. In case of subdiv these must be int.

basis (str): 'prim' or 'conv' or 'cart'

quantdict (dict): {quantityname:True|False,...}

quantityname (str): 'dens', 'pot', 'scf', 'coul', 'xc', 'ewald'

outputdatadict (dict): {outputdataname:True|False,...}

outputdataname (str): index, points, 'total', 'spin', 'up', 'down', 'comp'

kresolvedlist (list): [] or [kresdict,...]

kresdict (dict): {'name':some_name,'point':list_or_str, 'bands': list_of_int,'ewindow': [lbound, uband]}

eresolvedlist (list): [] or [eresdict,...]

eresdict (dict): {'name':some_name,'defs': defslist}

defslist (list): [[emin,emax,de,'up'|'do'|'bo'],...]

Example:

fed.gridoutput(True,stopafter=True,defs=[
   {
    'basis':'prim','dir1':[1,1,0],'dir2':[-1,1,0],'dir3':'0 0 1',
    'origin':[-0.5,-0.5,'2/3'],'subdiv':'10 20 30',
    'quantities':{'pot':True,'dens':True},
    'outputdata':{'points':True,'total':True,'spin':True},
    'kresolved':[
          {'name':'Gamma','point':[0,0,0],'ewindow':[-1.1,2.4]},
          {'name':'X','point':[1,0,0],'bands':'23 24 25'}
                ],
    'eresolved':[
          {'name':'r1','defs':[[-7,9,0.01,'b']]},
          {'name':'r2','defs':[[-1,1,0.01,'u']]},
          {'name':'r2','defs':[[-1,1,0.01,'d']]},
                ]
   }
])

coreoccupation(defs=None)

Define the core occupation. (Experimental option)

defs (list): [] or [ [sort,state-label,[occ,occ,...],[occ,occ,...]] , ...] where

sort (int) is a sort number

state-label (str) is e.g. '4f'

end where the last two lists (for spin up and down) are the occupation numbers for the 2*l+1 orbitals. Normally the occus should all be the same per spin channel. One only gives as many occupation numbers as indicated by the shell degeneracy (2*l+1). Example:

fed.coreoccupation(defs=[
    [2,'2p',[1,1,1],[0.2,0.2,0.2]]
    ])

A fancy example to avoid typing: we set all orbitals to 4/14 in order to get a homogenous non-polarized 4f shell with 4 electrons. For illustration we also add some polarized example for p-states:

fed.coreoccupation(defs=[
    [2,'4f',['4/14']*7,['4/14']*7],
    [3,'3p',[1]*3,['2/5']*3],
    ])

dhvaiso(active=None, isovalue=None, subdiv=None, bisections=None, upbands=None, downbands=None, wanhamfile=None, deleteoldfiles=None, needbandweights=None, addweifile=None, shifts=None)

Settings for the iso-branch of the dHvA module.

active (bool-like): activate the preparation active.

isovalue (float or str): obvious

subdiv (list or str): a list or string of 3 int.

bisections (int): obvious

upbands (list): [] or a list or string of band numbers

downbands (list): [] or a list or string of band numbers

wanhamfile (str): a wannier hamiltonian file name (+hamdata).

addweifile (str): a =.addwei type file

deleteoldfiles (bool-like): obvious

needbandweights (bool-like): obvious

shifts (list): [] or [[weight-index,factor],...]

Example:

fed.dhvaiso(active=True,isovalue=-0.1,subdiv='10,',bisections='4')

# special shift input (see FPLO..../DOC/MANUAL/doc.pdf)
fed.dhvaiso(shifts=[ [76,0.02], [77,-0.02] ])

dhva(fields=None, nangles=None, anglerange=None, nplanes=None, planerange=None, bands=None, areachainthreshold=None, orbitsearchoffset=None, orbitsampleportion=None, arearadiusfactor=None, smoothnessthreshold=None, outputoptions=None, debugoptions=None)

Settings for the dHvA-branch of the dHvA module.

fields (list): can be [] or [[label,[bx,by,bz]],...] alternatively a field can be written as [label,"bx by bz"]

nangles (int): number of angles

anglerange (list): can be [from,to], where from and to are int.

nplanes (int): number of planes

planerange (list): can be [from,to], where from and to are int

bands (list): can be [bandnumbers,parts,spins] where

bandnumbers (list or str) must be [] or a list or string of int

parts (list or str) must be [] or a list or string of int

spins (str) must be 'up' or 'down' or 'both' or shorter 'u', 'd' or 'b'

areachainthreshold (float): see FPLO..../DOC/MANUAL/doc.pdf

orbitsearchoffset (float): see FPLO..../DOC/MANUAL/doc.pdf

orbitsampleportion (float): see FPLO..../DOC/MANUAL/doc.pdf

arearadiusfactor (float): see FPLO..../DOC/MANUAL/doc.pdf

smoothnessthreshold (float): see FPLO..../DOC/MANUAL/doc.pdf

outputoptions (list): can be [[OPTION,True|False],...] see fedit screens for OPTION

debugoptions (list): can be [[OPTION,True|False],...] see fedit screens for OPTION

Example:

#first we set the fields (note, we could do all of it in one call)
fed.dhva(fields=[
           ['[010]',[0 ,1 ,0]],
           ['[100]',[1 ,0 ,0]],
           ['[111]','1 1 1']
   ])

# focus on particular bands, all parts and spins.
fed.dhva(bands=[[52,53],[],'b'])

# increase accuracy
fed.dhva(nangles=50,nplanes=200,noewaldcor=True)

basis(version=None, extensionlevel=None, add3d=None, addf=None, core4f=None, core4fNoValenceF=None, multicore=None, multisemicore=None)

Here some standard basis settings can be defined. If you want to switch to an extended basis in a pre-existing =.in use:

fed=fedit.Fedit(recreate=False)
fed.basis(extensionlevel=2,add3d=True,addf=True)
fed.pipeFedit(prot=True)

If you want to switch to an extended basis in a pre-existing =.in and make sure that the rest of the basis is default use:

fed=fedit.Fedit(recreate=False)
fed.basis(extensionlevel=2,add3d=True,addf=True,
    multicore=[],multisemicore=[],
    core4f=[],core4fNoValenceF=[])
fed.pipeFedit(prot=True)

version (int or str): hotkey or search string of basis version

extensionlevel (int): the level of extended basis,

• default: extensionlevel=1,
• single->double, double->tripple …: extensionlevel=2
• double->tripple, tripple->quadruple …: extensionlevel=3

add3d (bool-like): if True add 3d if no d-orbital in defautl basis. Applies to H and He.

addf (bool-like): if True add an f-orbtial if none exists in the valence section. If the semicore section contains a 4f-state a 5f-valence orbital is added. In other words this option only consideres the valence section.

core4f (list of str and/or int): a list of element names and/or sort numbers for which to shift an existing valence 4f-orbital into the core. The list can be a mix of names and sorts. To delete existing core4f definitions use:

core4f=[]

To leave this setting alone use:

core4f=None

core4fNoValenceF (list of str and/or int): a list of element names and/or sort numbers for which to shift an existing valence 4f-orbital into the core and remove remaining f-polarization orbitals from the valence section completely. The list can be a mix of names and sorts. To delete existing core4f definitions use:

core4fNoValenceF=[]

To leave this setting alone use:

core4fNoValenceF=None

multicore (list-like: [ [Q0,S0],[Q1,S1],…]): the length the list defines the multiplicity of all core orbitals. The individual list members need to be lists of two float, the first is the Q-parameter and the second the S-parameter. Example:

multicore=[[0,0],[2,10]] # double core with Q[0]=0, S[0]=0, Q[1]=2, S[1]=10

To delete an existing multicore definition use:

multicore=[]

To leave this setting alone use:

multicore=None

multisemicore (list-like: [ [Q0,S0],[Q1,S1],…]): the length the list defines the multiplicity of all semicore orbitals. The individual list members need to be lists of two float, the first is the Q-parameter and the second the S-parameter. Example:

multisemicore=[[0,0],[2,10]] # double core with Q[0]=0, S[0]=0, Q[1]=2, S[1]=10

To delete an existing multisemicore definition use:

multisemicore=[]

To leave this setting alone use:

multisemicore=None

numerics(maxL=None, thci_nr=None, thci_angmin=None, thci_angmax=None, thci_use_symmetry=None)

A subset of numerics menu options.

maxL (int): cutoff for angular momentum expansion in the potential.

thci_nr (int): number of radial mesh mesh points for three center integrals.

thci_angmin (int): smallest angular mesh type (for small radii) for three center integrals.

thci_angmax (int): largets angular mesh type (for large radii) for three center integrals.

thci_use_symmetry (bool-like): use only irreducible mesh.

iteration(n=30, acc=None, eacc=None, method=None, mixing=None, progress=None, subdim=None, occuratio=None, criterion=None)

n (int): number of iterations

acc (float or str): accuracy of density

eacc (float or str): accuracy of etot

method (str): can be missing or a search string or a hotkey (e.g. 'lciterat')

mixing can be a float

progress can be a float

subdim (int or str): maximum subspace dimension

occuratio (float or str): occu-mat/density ratio

criterion (str): hotkey (e.g. 2 for ‘density’). Note that the search strings are not very usefull here, due to their similarity (historical bad design).

Example:

fed.iterations(n=100,method='lciterat',mixing=0.1)

forces(forcemode=None, n=None, acc=None, subdim=None, vary=None, noewaldcor=None, eachstep=None)

forcemode (str): can be 'no', 'opt', 'single'

n (int): number of force iterations

acc (float or str): accuracy criterion in eV/Ang

subdim (int or str): maximum subspace dimension

vary (list of int or string of int): a list/string of sorts/Wyckoff position numbers to be varied. Empty list means ‘vary all’.

noewaldcor (bool-like): disable the expensive (marginally more accurate) nonspherical Ewald correction for forces.

eachstep (bool-like): calculate forces in each step.

Example:

fed.forces('opt',acc=1e-2,vary=[5,9])