Jorge Iribas Cerda Home Page
GUIDE TO THE green PROGRAM
INDEX:

I. INTRODUCTION
    I.1. Types of calculations allowed with the green program
    I.2. Constructing your system: Blocks (BLs)
    I.3. Matching BLs with different dimensionalities: lattices & k-sampling
    I.4. Hamiltonians and AO basis sets in green
    I.5. k-space representation
    I.6. Green's function calculation
    I.7. Charges, Density of States and Local Density of States (Q/PDOS/COOP/DM/RHO)
    I.8. Current/Conductance
    I.9. Band structure, surface states and PES simulations.
    I.10. Charge Fitting (Q_fit)
    I.11.Band structure and PDOS fitting (EK/PDOS_fit)
   
I.12. Forces/Molecular Dynamics
    I.13. Phonons/Vibrational modes
   
I.14. Self-Consistency
   
I.15. green-siesta Interface

II. PROGRAM INSTALLATION
    II.1  Retrieving, Installing and Running the green program
    II.2  Test calculations
    II.3  Example Files

III. QUICK GUIDE FOR SPECIAL SIMULATIONS
     III.1. Isolated molecules (Molecular Orbitals, PDOS, Charge Density Plots...)
     III.2. Molecules attached to wires
     III.3. Surfaces (Surface States, Fermi Surfaces, PES simulations)
     III.4. Magnetic Multilayer systems (Magnetoresistances)
     III.5. Charge Fitting
     III.6. Band structure and PDOS fitting
     III.7. STM/STS/CITS simulations
     III.8. RHO/LDOS plots for UCs (real space images of the MOs)
     III.9. Tersoff-Hamann (TH) images for surfaces

IV. I/O FILES
    IV.1 Standard Input File
    IV.2. Standard Output File and Other Output Files
    IV.3. Auxiliary Program for Plotting: green_plot

A. APPENDICES
    A.1  Standard Abbreviations
    A.2  Symmetry Codes
    A,3, Units handled by green
    A.4. Program Structure




I. INTRODUCTION

I.1. Types of calculations allowed with the green program

green is a Fortran 90 code designed to calculate electronic, transport and magnetic properties for almost any type of system and for all dimensionalities: clusters, bulk, slabs, surfaces, infinite inhomogeneous, any kind of interfaces, etc. In general, green calculates the one-electron Green's function of the entire system (or its projection onto different regions of the system), and obtains from it the desired properties. For small unit cells, however, straight diagonalization of the Hamiltonian is typically better, and green also handles this case. Many features make the code specially appealing for studying large systems: highly effiicient k-sampling schemes for periodic regions in the system, sparse matrix storage, dynamical allocation optimized to reduce memory requirements, use of first-order approximations when suitable, etc.

Although the code is designed for employing different Hamiltonians, currently only the Extended Hückel Theory (EHT) Hamiltonian is internally implemented. However, green has options for reading the Hamiltonian matrix elements obtained with other codes; most interestingly any ab-initio LCAO code. 

A list of properties that may be calculated is the following:




Property/Simulation
Remarks
Input Card
Electronic Projected Density of States (PDOS) Projected onto AOs, atoms or LCAOs and k-resolved. %pdos

Mulliken Charges Projected onto AOs, atoms or LCAOs and k-resolved. %pdos

COOP populations Projected onto any pair of AOs, atoms or LCAOs and k-resolved. %pdos

Local Charge Fitting On-site energies varied selfconsistently until desired charges on any AO, atom or LCAO are obtained. %pdos , %fit

Fermi Surfaces Projected onto AOs, atoms or LCAOs and k-resolved. %pdos

Photo Electron Spectroscopy ARPES(k,E) within the dipolar approxmation, but neglecting diffraction effects and self-energy corrections.  %bands

Band Structures For periodic systems (Non-periodic systems not yet implemented) %bands

Band Structure/PDOS Fitting EHT parameters fitted to yield ab-initio bands structures and/or PDOS %pdos,%bands,%fit

Localized (surface) states
& their k(E) dispersion
Only semi-infinite systems (surfaces). %bands

Density Matrix
%dm

Charge Density Plots or
Local DOS (LDOS)
Projected onto AOs, MOs, atoms ... %rho
Transport Electronic Currents (IV spectra) For any bias V, but not self-consistent. 
Resolved for AOs, atoms or LCAOs and k-points.
%current

Differential Conductance For any bias V, but not self-consistent. 
Resolved for AOs, atoms or LCAOs and k-points.
%current

STM images or STS data Either for topographic or current mode. %current , %scan
Magnetic Magnetic Moments Projected onto AOs, atoms or LCAOs and k-resolved.
Valid for spin-polarized systems (LS coupling may be included)
%spin , %pdos

Magneto-Resistances Resolved for AOs, atoms or LCAOs and k-points.
Valid for spin-polarized systems (LS coupling may be included)
%spin , %current
Vibrational
Forces, Vibrational Modes &IETS

%phonon
Molecular Dynamics Equilibrium configuration
Conjugate Gradient (CG)
or T=cte (Nose thermostat)

%md
Note: Although the implementation of several properties are on their way, if you are interested on one in particular which is not in the table, please contact me. I might be able to implement it easily, or we may try a collaboration instead.

I.2. Constructing your system: Blocks (BLs)

Fairly small systems may be defined by a single BL, referred as a Unit Cell (UC). However, when the system is large, it is highly advantageous to  split it into the so-called Principal Layers, which are sections of the system thick enough so that only nearest neighbor interactions between PLs are taken into account. In order to optimize the calculation and gain a large flexibility in the input of the geometry, green uses BLOCKS (BLs), which consist of sub-units which may be stacked onto each other until the final system, BL_sys, is build up. Each BL is either a stack of PLs or just one PL.The build up may be carried out in several steps; i.e. piling up sequentially BLs with higher and higher levels of complexity.

The Allowed types of BLs are:

Unit Cell (UC)
Principal Layer (PL)
Bulk
Slab (PL+PL or PL+slab or slab+PL or slab+slab)
Surface (bulk+slab or bulk+PL or slab+bulk or PL+bulk)
Infinite system (bulk+bulk or bulk+slab+bulk)
e.g.  STM system
        Multilayer system


I.3. Matching BLs with different dimensionalities: lattices & k-sampling
green allows to build up your system by stacking BLs with different dimensionalities. All is needed is that there exists a commensurate lattice between the two PLs linking the two sub_BLs to be stacked.

Let us denote:
- PL_1 the rightmost PL at the left sub_BL with dimensionality ndim_1 and lattice vectors VEC_1
- PL_2 the leftmost PL at the right sub_BL with dimensionality ndim_2 and lattice vectors VEC_2
- ndim_c the dimensionality of the commensurate lattice with lattice vectors VEC_C
where VEC_C/1/2 are (3 x ndim_c/1/2) matrices containing the ndim_c/1/2 lattice vectors for the commensurate lattice, PL_1and PL_2, respectively (that is, the XYZ components of each lattice vector are stored as columns in the VEC_C/1/2 matrices).
Then the requirement that a commensurate lattice exists is equivalent to require that there exist two matrices, M_1 and M_2, with all their elements integer numbers, and which satisfy the following matrix relation:


VEC_C  = VEC_1 * M_1 = VEC_2 * M_2
(3 x ndim_c )
(3 x ndim_1)
(ndim_1 x ndim_c )
(3 x ndim_2 )
(ndim_2 x ndim_c )

The dimensionality of the lattices to be matched, ndim_1/2, may be 0, 1 or 2, whereas the dimensionality of the commensurate lattice is in general given by: ndim_c = min( ndim_1 , ndim_2 ), except for the following cases:
- ndim_1 = ndim_2 = 1, but with VEC_1 not parallel to VEC_2. In this case, ndim_c = 0.
- ndim_1 = ndim_2 = 2, but with the plane generated by vectors VEC_1 not parallel to VEC_2. In this case, no commensurate lattice can be generated.

  For input purposes, the user only needs to define the lattices at each PL, while green takes care of finding commensurate lattices (i.e. matrices M_1 and M_2) at all stacking steps. If it fails to find a commensurate lattice, then program stops and displays an ERROR message.

Some examples of commensurate lattices are given below. Blue and green lattices correspond to VEC_1 and VEC_2, whereas the dark lines give the commnesurate VEC_C lattice:
 


ndim_1 = 1
ndim_2 = 1
ndim_c = 0
ndim_1 = 1
ndim_2 = 1
ndim_c = 1
ndim_1 = 1
ndim_2 = 2
ndim_c = 1
ndim_1 = 2
ndim_2 = 2
ndim_c = 2

Recall that "bent" geometries may be straightforwardly generated. For instance, you may link two 2D lattices which are not parallel by placing in between a BL with a Gamma lattice (ndim=0), or a 1D lattice (ndim=1) which is the intersection of the two 2D lattices.
Apart from finding the commensurate lattice between the two PLs linking the two BLs, VEC_C, green also loads the commensurate lattice between the lattices at both sub_BLs, and assigns it to the new stacked BL. This way each BL has a lattice and, by construction, it will be commensurate to all lattices at all PLs in the BL. Notice that the dimensionality of the BL lattice must be equal to or lower than the smallest dimensionality of any of the lattices in the PLs.

K-sampling is handled in green by a set of k-points for the lattice corresponding to the final system, BL_sys. When all PLs share the same dimensionality, then the k-points at all PLs are univoquely defined from the BL_sys k-points. However, if BL_sys is a mixture of different dimensionalities, for those PLs which have a dimensionality larger than BL_sys, k-points will be missing along the extra dimensions. The program then automatically generates a grid of k-points along the extra dimensions whose size is controlled by a single input parameter, kcut, which may attain a different value for each PL.


I.4. Hamiltonians and AO basis sets in green

Our highly recommended way of choosing the correct Hamiltonian is the following:

  1. Try first using the default EHT parameters in file Green/Src/huckel.data and compare the resulting Density of States (DOS) for your system (or a closely related one) against any other already published accurate DOS. In case you believe the correspondance is satisfactory, you may proceed to calculate any other quantities (e.g. STM images). If not, go to step 2.
  2. Shift the on-site energies of the EHT parameters in order to see if the correspondance improves. You may do this by hand (see card "%element") or invoking preselected charges via a Q_fit (see card "%dos"). If things don't improve go to step 3.
  3. You will need to perform an accurate electronic calculation for your system (e.g. using siesta), and then fit the EHT parameters to the ab-initio results via an EK+PDOSK_fit.
  4. However, if you really want very accurate results, then use directly the siesta interface.
Hybrid Hartree-Fock/Extended Hückel Theory (EHT)
    2-center Slater-Koster (SK)

    SIESTA

Classical potentials:For  completeness reasons, we have also implemented classical 2-body potentials which may be used for Molecular Dynamics simulations or calculation of vibrational spectra/phonons


I.5. k-space representation

I.6. Green's function calculation

I.7. Charges, Density of States and Local Density of States  (Q/PDOS/COOP/DM/RHO)

I.8. Current/Conductance

I.9. Band structure, surface states and PES simulations

I.10. Charge Fitting (Q_fit)

I.11. Band structure and PDOS fitting (EK/PDOS_fit)

I.12. Forces/Molecular Dynamics

I.13. Phonons/Vibrational Modes

I.14. Self-Consistency

I.15. green-siesta interface


II. PROGRAM INSTALLATION

II.1  Retrieving, Installing and Running the green program

The green source code and its auxiliary programs and directories are all contained in the file green.tar.gz. Once you have downloaded this file, place it on top of the directory from where you want the Green/ directory to hang, and then uncompress and untar it by typing:
gunzip green.tar.gz
tar -xvf green.tar

This will have generated the main Green/ directory, from which the following subdirectories should be hanging:


Green/Sys  Files with compilation options for different architechtures and Fortran compilers. 
Green/Src Main green source code and Makefile
Green/bin  Auxiliary executable files for running green and other related programs. 
Green/Test  green test calculations
Green/Inputs Example files containing specific "%cards" useful for generating new input files.

In order to compile green, first you need to define the $GREEN_DIR variable giving the location of the Green/ directory and include the Green/bin/ directory in your PATH environment.
If you are using csh or tcsh, then edit the .login file in your home directory and include the following lines:
setenv GREEN_DIR ~/Green
setenv PATH "$GREEN_DIR/bin:${PATH}"

If you use ksh or bash, then edit the .profile or the .bashrc file in your home directory and include the following lines:
export GREEN_DIR=~/Green
export PATH=$GREEN_DIR/bin:${PATH}

where by ~/Green we refer to the path where the Green/ directory has been installed (e.g.  /home/user_name/Green).

Load and check these variable definitions by typing either:
source .login
env
or
source .bashrc
env
and check that the new definitions appear on your screen.

Next, you must set the compilation options. To this end, you must cd to Green/Sys:
cd $GREEN_DIR/Sys
and inspect the different  make.inc.* files available to see which one coincides with or is closer to your own system. Copy the selected file into $GREEN_DIR/make.inc by typing:
cp make.inc.my_choice ../make.inc
cd ..
and then edit this file and modify the variables: FORTRAN, OPTS, ARCH, ARCHFLAGS, RANLIB and LIBS to specify the compiler, compiler options, archiver, archiver options, ranlib and Linear Algebra libraries specific of your machine, respectively. Recall that some options are "very" machine dependent, so that you should always check out if the OPTS variable is suitable for your case.

The LIBS variable should be set to the LAPACK and BLAS libraries. We leave it up to you to find out if your machine has already installed these LInear Algebra libraries (such as mkl or atlas).

Once the make.inc file has been modified to suit your needs and the libraries have been installed, you may start compiling the green program in the Green/Src directory by typing:

cd $GREEN_DIR/Src
make

This will generate the executable version of the program
green. If you are not sure the compilation worked out, type:
ls -l green

and see if the file is present.

If you change any options in the make.inc file,  and wish to recompile, then make sure you clean up the Green/Libs and Green/Src directories, by typing:
cd $GREEN_DIR/Src
make clean
cd $GREEN_DIR/Libs
make clean cleanlib

Note: From previous experiences, it is quite typical that things will not work ok (wrong variable values in make.inc, or problems with the libraries). Once you get desperate with these things, contact me.

In principle, in order to run the program you just need to type:
green < file_in > file_out
where file_in is the main input file (explained below in IV) and file_out is the standard output file (both I/O files may take in principle any name).
However, in the subdirectory $GREEN_DIR/bin, we include the auxiliary executable files related to the green program: mgreenand rgreen, which are intended to simplify I/O file naming and handling.

These commands are highly recommended and may be executed from any directory. Their syntax and action is the following:

mgreen
Compiles the green program and places it in the current directory. If the compilation did not succeed, then an ERROR message appears in the screen.
 
rgreen name [-d dir]
Runs the green program assuming the input file name.in (i.e. it has the .in extension) is in the current directory. If name.in does not exist, then rgreen will complain and stop (the optional argument -d dir may be used to indicate that the file name.in is not in the current directory but in the directory /dir). The main output file will be written out to name.out. If the green executable file  is not in the current directory, then rgreen calls the mgreen command. Next, it opens a subdirectory name.TMP/, where it actually performs the calculation. But before, it copies into the name.TMP/ directory the default file for the EHT parameters, Green/Src/huckel.data, and also appends at the end of the name.in file the default value for option [include_path]:
include_path = $(GREEN_DIR)/Inputs/
This statement has no effect if you had already defined your own [include_path] option in name.in. All these commands invoked by rgreen will appear on your screen. Once finished, the file name.out, together with any other output files holding the calculated quantities are copied to the original directory. In the subdirectory  name.TMP/, only information files are left: IN, BLOCKS, KPOINTS, *.RIJ, ENERGY, PDOS, SPIN, etc, so that you may check them out, or you may just remove the entire subdirectory.
Important Note: The rgreen command
is our highly recommended way of running green

II.2  Test calculations

In order to check a succesful installation of the green package, you should perform the following test calculations:
cd $GREEN_DIR/Test
test.green &
which will try to run the green program, via the rgreen command, for various input files: *.in
Beware that these files do not correspond to any realistic calculation; most parameters have been set to non-converged values so as to speed up the test (it should take some minutes if your machine is not too slow).

If the program runs ok, then once the test calculation is finished, the following message will appear in your screen:
 ********************************************************************
 * test.green:'green' test calculation finished                                                                   *
 * test.green: Edit file 'diff.green' to check performance                                               *
 ********************************************************************
The test.green will compare the just calculated ouput files *.out against the refererence ones, *out.test, the results of the comparison being loaded in file diff.green. The test calculations may be considered succesful if the diff.green file is empty (apart from the headings for each comparison), only contains format type differences or small relative numerical differences.
You should also inspect the file diff.green_plot , which is generated in parallel to diff.green, in order to check the correct performance of green_plot.



II.3  Example Files
- Quite complete set of STM related calculations for the Rh(111)-c(4x2)+2NO system.  
- Lots of additional sample files may be found hanging from Samples/ . Many of these input files make use of files included in the Green/Inputs/ directory, which you should also inspect in order to get acquainted with the main input file structure. Most of the directories contain a README file giving a short overview of the contents in the directory, together with the required instructions in order to retrieve the final images.



IV. I/O FILES

    IV.1  Standard Input File



IV.2. Standard Output File and Other Output Files
The standard output file is more or less self-explanatory. First, information on all input cards is printed out, in the following order:
%defaults , %hamiltonian , %element , %lattice , %block , %scan , %energy , %spin , %dos , %current , %bands , %fit, %io , %md  , %phonon , %rho

However, since the printed information you will get is only partial, green generates several formatted output files which contain complete descriptions of several issues. If you use the rgreen command, then all these files will be located in the name.TMP/ directory:
 


Output file
Content
Cards
IN
Copy of the main input file after reading any "%include" cards.
This is actually the main input file used by green.
%include
ELEMENTS
Type of Hamiltonian, and list of all elements used.
%hamiltonian
%element
KPOINTS
All lattices and their respective k-samplings
%lattice
k-sampling options
BLOCKS
Al UCs and BLs used in the calculation plus all atoms and their coordinates for the final system
%block
ENERGY
Summary of energy related quantities: Energy loops, Potential drops and complex contours.
%energy
SPIN
Summary of spin configurations.
%spin
*.RIJ
Information on each of the overlaps calculated (intra- and inter-PL), including:
interatomic distances and details on the # cells and sub-cells used.
 %block
PDOS
The AOs contributing to each PDOS projection.
%dos

For Hamiltonians of the EHT type, all overlap and Hamiltonian matrix elements are then tabulated as a function of inter-AO distances, and a few realated lines will appear in the standard output file.

Next part in the output file deals with the main loop ordering that the program will follow, plus some information on the number of matrices required in the calculation.  green runs over all loops twice. In the first run (the 'allocation' pass), information on the loading/unloading of dynamical matrices is stored, so that in the second run (the 'calculation' pass), all matrices are allocated/deallocated as needed. During the 'allocation' pass, hardly any information will be written out. Once finished, a line similar to:
CALCULATION LOOP :  n_gs_mat/m_gs/cm=2851   0   0
will be printed out, signaling the beginning of the calculation loop. This message may also appear several times within an outer loop. Depending on the output level [out_level], some or all loops will be printed out in a self-explanatory way, allowing this way to watch the program evolution.

Once the energy, spin and k points loops are finished, the charges Q and intensities i, if required, are printed out for any internal loops to these ones
e.g. say we have the pix loop inner to the k, spin and energy loops. Then the charges or intensities will be printed out together for all pixels. Otherwise, if the pix loop is external, then the charges or intensities will be printed out for each pixel.

If any kind of fit has been required (Q/EK/PQK/PDOSK_fit or topographic mode), then the evolution of the fit will be printed out at each cycle, together with the final converged values.

You should always inspect the standard output file in order to check that all cards were properly readin and that the program ran ok. Any ERROR message will signal an incorrect program termination. We should warn you, however, that most of the times this type of message is caused by errors in the standard input file (i.e. omission of cards, not allowed values, etc.). Therefore, whenever you find an error of this type, you should first check the input file thoroughly, and only then try to understand the reason for the ERROR message. Some of these messages are preceded by the word internal:
internal ERROR
which means that there might  be a bug in the program, and you should inform me about it attaching the input and output files.

On the other hand, WARNING messages are not usually too relevant, and they do not interrupt program execution. These messages are generally preceded by the name of the subroutine that printed out the message, followed by a short explanation for the reason of the WARNING.  You should always try to understand what is going on (you may always ask me its meaning). Pay special attention to any WARNING messages displayed when a required fit algorithm did not converge.

Aside from the standard output file and the above information files,  and depending on the required quantites stated in the input, the calculation may generate the following unformatted (non-ASCII) output files. All these files should be processed by the program green_plot in order to extract the desired quantities.


Unformatted
Output file
Content
Cards
tdos.DOS
DOS(E) projected onto selected groups of AOs which belong to the same PL.
%dos
tdos.COOP
COOP(E) projected onto two selected groups of AOs which belong to two PLs. The two PLs may be adjacent (inter-PL COOP), or may be the same one (intra-PL COOP). 
%dos
tdos.PQK
Mulliken Charges, Q(m,k),  k- and band-resolved and projected onto selected groups of AOs which belong to a UC
%dos
tdos.PBOK
Charge (Bond Order) matrices, Q(m,k), k- and band-resolved and projected onto selected groups of AOs which belong to a UC
label_sys.I
Electronic current, I
%current
label_sys.TE
Transmission coefficient or differential conductance, T(E)
%current
label_sys.TA
Interference terms between AO tunneling paths
%current
label.RHO
Real space electronic density, k-, band-, AO- resolved at any UC/PL
%rho
label_sys.Z
STM z tip values calculated when [mode=topographic]
%scan
label_sys.dIdZ
dI/dZ logarithmic slopes for each calculated Z value in file label_sys.Z
%scan
label.EK
Band structure E(k) for each input UC (only when only UCs are input).
%bands
label_1-2.KE
Band dispersion k(E) (i.e. the k-points at each energy rather than E(k)) associated to the T(2,1,k_parallel) propagator.
%bands
label_pes.PES
ARPES data, for different photon energies, k- and AO- resolved
%bands
label_sys.SS
Band dispersion E(k) associated to the the surfaces states of a surface BL
%bands
label_sys_SS.DOS
DOS_ss(E) associated to the the surfaces states of a surface BL projected onto the AOs of the surface-most PL
%bands
label.UA
The UA matrices for a surface BL
%io
trho.RHO
The charge density or LDOS in real space
%rho
label.WV
Real space wave functions (only for Gamma point)
%bands
label.O/H
Overlap/Hamiltonian matrix elements in k-space for each required UC or BL
label_i-j.G/F/T/S
The G/F/T/S matrix elements in k-space linking PLs i & j, for each required BL
%io
label_i-j.DM
Density Matrix relating AOs at PLs i and j

Further, the following formatted ASCII files may also be generated. Typically, these files may be re-used by green as input files (see the corresponding cards).


Formatted
Output file
Content
Cards
el_i-el_j_SK
The EHT Overlap/Hamiltonian terms as Slater-Koster (SK) parameters tabulated as a function of the inter-atomic distance between elements el_i and el_j
%hamiltonian
label.EK_data
The Band structure E(k) and Mulliken charges PQK for each input UC (only when only UCs are input).
%block
label.PDOS_data
The k-integrated DOS(E) projected onto selected groups of AOs which belong to the same PL.
%block


IV.3. Auxiliary Program for Plotting: green_plot
Since most of the green output files are unformatted (i.e. non-ASCII files), they require to be processed by green_plot. This code generates either 2D maps, 1D graphs or tables for analyzing or viewing the calculated data. If a given quantity f(a,b,c,..) has been stored in terms of different variables a, b, c, ... , then green_plot extracts or calculates projections of the type f(x,y), where x and y correspond to any of the variables a, b, c, ..., while for the remaining variables, if any, you may sum, for each (x,y) point. either all available values in the file, or any input set of values. The number of quantities or files that may be processed in a single run is unlimited.
e.g. Say that COOPs have been stored in a file tdos.coop, as a function of the variables p1,p2,e,k1,k2,spin,spin_conf. Then you may generate, for instance, an f(x,y) 2D map for the dispersion of f=COOP as a function of the energy x=e and the k-points y=k1, for any specific value of p1,p2,k2,spin,spin_conf  or by a any sum over any values of each parameter. In this example, for instance, you would generally fix spin_conf, and/or may be spin and p2, but sum up over k2.

green_plot should be run from the rgreen_plot command, with the following syntax:
rgreen_plot file
where the name of the main input file should be file.gin. The main output file will be named file.gout, and contains information on the details of each required projection. The rgreen_plot command will also take care of the the compilation of the green_plot code if necessary. The compilation should work if the green program has been succesfully compiled and no modifications have been made to the make.inc file.

Depending on the type of green output file extension, the quantities that may be extracted or calculated from the data in the file, together with the possible variables that may be projected (if required in the previous green runs) are listed in the following table:
 


green_file
extension
Option
name:
f(a,b,c,...)
Description
Variables: a,b,c,...
(see below for meaning of each)
Remarks
Associated subcard
.DOS
.COOP
.PQK
.PBOK
dos
LDOS
p1,k1,kc,ks,e,spin,
pix,z,v,spin_conf
p1 refers to each PDOS projection (see file PDOS)
If .COOP or .PBOK, requires sum over p2 and k2.
 %dos
.DOS
.COOP
.PQK
.PBOK
Q
Charges (Q)
p1,k1,kc,ks,spin,
pix,z,v,spin_conf
p1 refers to each PDOS projection (see file PDOS)
Requires integration over e
 %dos
.COOP
.PBOK
BO
Bond Order (BO)
p1,p2,k1,k2,kc,ks,spin,
pix,z,v,spin_conf
p1, p2 refer to each PDOS projection at PLs 1 and 2 (see file PDOS)
Requires integration over e
%dos
.COOP
.PBOK
coop
COOP
p1,p2,k1,k2,kc,ks,e,spin,
pix,z,v,spin_conf
 p1, p2 refer to each PDOS projection (see file PDOS)
%dos

.RHO

rho

Electronic Density
or
Local Density of States (LDOS)

r,spin,m
May be processed either with type=cube|grid|line
Requires x=y=z=r and %uv card for specifying output 1/2/3D grid, together with limits_x/y

%rho
.I
.TE
.TA
i
Intensity
p1,k1,p2,k2,kc,ks,spin,
pix,z,v,spin_conf
p1, p2 refer to each AO in PLs + and -
If .TE or .TA, requires integration over e
If TA, interference terms avaibale(p12/p12i)
%current
.I
.TE
.TA
di/dv
dI/dV
p1,k1,p2,k2,kc,ks,spin,
pix,z,spin_conf
p1, p2 refer to each AO in PLs + and -
Requires # bias values > 1.
If .TE, requires integration over e.
If TA, interference terms avaibale(p12/p12i)
%current
.I
.TE
.TA
di/dz
Log(dI/dZ)
p1,k1,p2,k2,kc,ks,spin,
pix,v,spin_conf
p1, p2 refer to each AO in PLs + and -
Requires # z values > 1.
If .TE, requires integration over e.
If TA, interference terms avaibale(p12/p12i)
%current
.Z
z
Z displacements
pix,i,v,spin_conf
 
%scan
.dIdZ
di/dz
Log(dI/dZ)
pix,i,v,spin_conf
 
%scan
.TE
.KE
te
Differential Conductance (TE)
p1,k1,p2,k2,kc,ks,e,
spin,pix,z,v,spin_conf
If .TE, p1, p2 refer to each AO in PLs + and -
If .KE, then only variables p1, k1, e, spin are allowed, and T(E)=1 (0) if there is (not) a band at each energy, k1 and spin.
%current
or
%bands
.EK
e
Band structure E(k,m)
or surface states
p1,k1,kc,ks,
spin,spin_conf
p1 refers to the band index. 
Setting f=e, x=k1, y=p1,will print out the band structure in the usual way.
For surface states 
%bands
.KE
ke
Inverted Band Structure k(E,m)
p1,e,spin
Requires f=ke, x=e, y=p1, type=table.
It will print out a two column file: energy vs k-point. Different bands at a given energy appear consecutively,while if there are no bands, the line for this energy is skipped.
The file should be plotted without joining the (k,E) points, but just placing symbols at each point.
%bands

.WV

wv

Wave function values at a 3D grid in real space

r,spin,m

May be processed either with type=cube|grid|line
Requires x=y=z=r and %uv card for specifying output 1/2/3D grid, together with limits_x/y

%bands
.PES
pes
I_pes(E,k_par)
PES intensity
p1,e,k1,kc,ks,spin
p1 refers to the AOs in the bulk or surface PL.
p2 refers to the photon energy, hw, or k_perp_hw value. Requires type=table
%bands
.O/H
O/H
Overlap O_12 Hamiltonian H_12
p1,k1,p2,k2,kc,ks,cell,
spin,pix,z,v,spin_conf
p1 and p2 refer to the AOs at PL_1 and PL_2
%io
.U/.V
U/V
Eigenvectors
p1,k1,p2,kc,ks,spin,
pix,z,v,spin_conf
p1 referes to the AO at PL_1 and p2refers to the band index
%io
.G/F/T/S
G/F/T/S
Inter-PL Green's functions between PL_1 and PL_2
p1,k1,p2,k2,kc,ks,cell,
e,spin,pix,z,v,spin_conf
p1 and p2 refer to the AOs at PL_1 and PL_2
%io

The main input file for green_plot typically consists of any number of "%plot" cards, each corresponding to a quantity to be processed, plus any number of  cards "%graph" and "%img2d" employed for generating 1D or 2D graphs/maps. Each card follows the same syntax rules as those explained in IV.1:
%plot
   ... option lines ...
%end_plot
Make sure you know this syntax before going any further !!!.


%plot
    Main card for processing the binary files generated by green. The card specifies the required quantity [f] to be processed/calculated from the unformatted green output file [green_file], together with the type of output required (a 1D plot or a 2D grid or a table or just a drawing containing lines,text and/or symbols or *.cube files to be used by molekel, depending on option [type]). This card also reads the variables to project or sum plus additional comments/text/lines to be inserted in the graph.
Use:  Card is mandatory for any quantity to be extracted for a green calculation.
Allowed Options: green_file , print , out_file , type , f , x , y , z ,%uv, originlimits_x , limits_y , limits_z  ,p1 , p2 , k1 , k2 , ks , kc , m , g_unfold , %cell , cell , e , v , spin , spin_conf , z   , pix , i , kT , ef , header , %symbols , %lines , %text , stop
Default: None
e.g. Generating a 2D map Z(x,y)  for an STM topographic image calculated for different biases:
%plot
  green_file = stm.Z       ! output file from green calculation
  out_file   = stm.grid    ! ASCII file containing the 2D map (see "%grid_files")
  type       = grid        ! Generate a 2D grid
  f = z                    ! plot z_tip (i.e. topographic image)
  x = pix  U A             ! (x,y) map corresponds to the (x,y) tip positions
  y = pix  U  A
  limits_x = -10  10  201  ! output grid is [-10,10]A in 201 steps along x & Y
  limits_y = -10  10  201
  v  = 1                   ! use z-tip values calculated for a bias of 1*inc
%end_plot
e.g. Generating a 1D line scan along y-axis, Z(y), from the same calculation as in the previous example:
%plot
  green_file = stm.Z       ! output file from green calculation
  out_file   = line.dat    ! ASCII file containing the 1D line (two columns)
  type       = line        ! Draw a line interpolated from the calculated grid
  f = z                    ! plot z_tip (i.e. topographic image)
  x = pix U |dA|           ! (x,y) line corresponds to the (x,y) tip positions
  %uv
    1 0  0                 ! Direction along line scan
  %end_uv
  limits_x = -10  10  201  ! line ranges from (0,-10) to (0,10) A in 201 steps
  v  = 2                   ! use z-tip values calculated for a bias of 2*inc
%end_plot
e.g. Generating a table, Z(pix), for the z-tip values as a function of bias and the first 5 pixels:
%plot
  green_file = stm.Z       ! output file from green calculation
  out_file   = pix-v.dat   ! ASCII file containing the table
  type       = table       ! generate a table
  f = z                    ! plot z_tip (i.e. topographic image)
  x = pix U i              ! one row per pixel (no pixels units, just indexes 1,2,3, etc)
  y = v U V                ! one column per bias (+ 1st. column for pixel index)
  limits_x =  1 5 5        ! Consider only pixels 1 to 5, but all available biases
%end_plot
e.g. Generating a 2D dispersion map, DOS(k,E), of the surface states DOS projected onto the 2nd-10th AOs at the surface PL and for spin down:
%plot
  green_file = surf_ss.dos ! output file from green calculation
  out_file   = ek.grid     ! ASCII file containing the table
  type       = grid        ! generate 2D map
  f = dos                  ! plot dos (default for [green_file] extension)
  x = ks                   ! use system k-points as x-axis
  y = e                    ! use energy values as y-axis
  limits_y = -5.0 5 101    ! Energy range and grid in y-axis
  p1 = 2 - 10              ! Project onto 2nd to 10th AOs
  spin= 2                  ! Project onto spin down (2nd component)
%end_plot

%graph
    Card for generating a Post-script graph which may contain as many 1D plots as desired.
Use: Optional. One card for each desired graph, with whatever the number of plots, must be input. In principle, the input data is any combination of columns contained in any number of [out_file] files generated with option [type=table|line] in card "%plot", although you may include any other formatted data file stored in columns. In fact, the "%plot" cards are not mandatory for running green_plot. The number of "%graph" cards in the input file is unrestricted, so that you can generate as many PostScript files as you wish.
Allowed Options: ps_file , orientationsize , origin , axis_l  , axis_r  , axis_t  , axis_b  , %data_files , %1dplotlimits_xlimits_y ,   scale , %symbols , %lines , %text , %legend , legend_origin , stop
Default: None
Note: Read carefully the description of the [ps_file] option in order to view or print the output PostScript files.

%img2d 
 Allows to create a PostScript with any number of 2D images (maps)

Use: Ony 2D maps which have been generated with the option [type=grid] in card "%plot" may be included. However, the 2D maps need not have been generated in current green_plot run, so that you can use any others previously generated. In fact, the "%plot" cards are not mandatory for running green_plot. The number of "%img2d" cards in the input file is unrestricted, so that you can generate as many PostScript files as you wish.
Allowed Options: ps_file , orientationsize , origin , boxesaxis_l  , axis_r  , axis_t  , axis_b   , limits_z , %grid_files , %ps_files , scale , %symbols , %lines , %text , %legend , legend_origin , stop
Default: None
Note: Read carefully the description of the [ps_file] option in order to view or print the output PostScript files.





A. APPENDICES

    A.1  Standard Abbreviations



    A.2  Symmetry Codes


    A.3. Units handled by green

    A.4. Program Structure


Go Back Home