Atomistix ToolKit
Manual
Version 2009.06
Atomistix ToolKit: Manual
Version 2009.06
Copyright © 2009 QuantumWise A/S
Atomistix ToolKit License to Use Agreement
Licensor
QuantumWise A/S
Nørre Søgade 27A, 1.th
Copenhagen
DK-1370
Denmark
<[email protected]>
Introduction
Each complete package, including Atomistix Virtual NanoLab(R), Atomistix ToolKit(R) and related documentation, is referred to collectively as the
“Software”. The term “use” refers to the loading of the Software into computer memory, or the running of the Software in a CPU. The term “Install” refers
to the copying of the Software to a specific location on a machines hard drive. “License Features” are defined as the features in the FLEXlm license file.
“Licensee” is defined as the end user of the Software.
BY INSTALLING THIS SOFTWARE LICENSEE AGREES TO THE TERMS OF THIS AGREEMENT WHICH WILL BIND LICENSEE AND ITS EMPLOYEES.
IF LICENSEE DOES NOT AGREE TO THE TERMS OF THIS AGREEMENT, LICENSOR IS UNWILLING TO LICENSE THE SOFTWARE TO LICENSEE AND
LICENSEE MUST DISCONTINUE INSTALLATION OF THE SOFTWARE NOW. IN THIS CASE LICENSEE MUST IMMDEDIATELY DISCONTINUE THE
DOWNLOADING PROCESS OR (IF APPLICABLE) IMMEDIATELY RETURN THE MEDIUM ON WHICH THE SOFTWARE IS STORED AND ALL ACCOMPANYING DOCUMENTATION TO THE RETAILER WHERE IT WAS PURCHASED TOGETHER WITH PROOF OF PAYMENT.
1. Delivery
Licensor distributes the Software in electronic form from its website. Upon request, Licensor will ship the Software to the Licensee on other media.
The additional costs of such an arrangement will be covered by the Licensee alone.
2. Grant and scope of license
Subject to Licensees compliance with the terms of this Agreement Licensor hereby grants a non-exclusive, non-transferable license to the Licensee
to install and use the Software on a network server (floating license) or on an individual workstation computer (node-locked license) for a specified
period of time, as indicated in the accompanying license file.
With a floating license the Licensee is granted the right to run the software according to the individual number of each “License Feature” on any
computer in the network during the time period determined in the license file.
With a node-locked license the Licensee is granted the right to use the software on 1 cpu on 1 workstation, during the time period determined in the
license file.
Part of this software is covered by other licenses. Where relevant, these are enclosed in the installation in their original form, in conjunction with the
software component they refer to.
3. Restrictions
a. The Licensee may not lease, sub-license, rent, loan, translate, merge, adapt vary, modify or otherwise exploit the Software other than for the
Licensees internal business purposes. In case of an academic or non-profit license, the Licensee may use the Software exclusively for non-profit
research.
b. The Licensee may not de-compile, reverse engineer, or disassemble the Software, or otherwise reduce it to a human-perceivable form.
c. The Licensee may not incorporate, or let others incorporate, the Software, in part or in whole, into another program that may reasonably be
considered to constitute, in part or in whole, directly or indirectly, now or in the future, a potential competitor to the licensed Software.
d. The Licensee may only copy the Software as part of backup and maintenance of the Licensees computer. These archive copies may not be in use
at any time and must remain in the possession and control of the Licensee.
e. Under no circumstances may the Licensee publish anything based on a trial license.
f. The Licensee undertakes to supervise and control the use of the Software and ensure that the Software is used in accordance with the terms of this
Agreement by Licensees employees.
g. Licensee must permit the Licensor and its representatives, at all reasonable times and on reasonable advance notice, to inspect and have access
to any premises, and to the computer equipment located there, at which the Software is being kept or used, and any records kept pursuant to this
Licence, for the purpose of ensuring that you are complying with the terms of this Agreement.
4. Intellectual Property Rights
a. Licensee acknowledges that all intellectual property rights in the Software throughout the world belong to the Licensor, that rights in the Software
are licensed (not sold) to Licensee, and that Licensee has no rights in, or to, the Software other than the right to use it in accordance with the terms
of this Agreement.
b. Licensee acknowledges that it has no right to have access to the Software in source code form or in unlocked coding or with comments.
c. The integrity of this Software is protected by technical protection measures (TPM) so that the intellectual property rights, including copyright, in
the Software of the Licensor are not misappropriated. Licensee must not attempt in any way to remove or circumvent any such TPM, nor to apply,
manufacture for sale, hire, import, distribute, sell, nor let, offer, advertise or expose for sale or hire, nor have in your possession for private or
commercial purposes, any means whose sole intended purpose is to facilitate the unauthorised removal or circumvention of such TPM.
5. Warranty
Licensor expressly disclaims all warranties, expressed and implied to the extent permissible by mandatory law. The Licensee expressly acknowledges
and agrees that (i) the Software has not been developed to meet Licensees individual requirements and that it is therefore Licensees responsibility to
ensure that the facilities and functions of the Software as described in any pertaining documentation meet its requirements and (ii) that use of the
Software is at the Licensees sole risk. The Software and related documentation are provided “as is”, without warranty of any kind. No oral or written
information or advice given by Licensor) or by any of its representatives shall create or imply a warranty.
6. Liabilities
a. Under no circumstances shall Licensor or its directors, representatives, employees, or agents, be liable for any loss including but not limited to
loss of income, loss of business profits or contracts, business interruption, loss of information, loss of opportunity, goodwill or reputation, loss of,
damage to or corruption of data unless such loss is attributable to Licensors fraud [or gross negligence]. Licensor, its directors, representatives,
employees, and agents shall not be liable for any incidental, indirect, special or consequential damages arising out of the use, misuse or inability
to use the Software howsoever arising. In no event shall the total liability of Licensor to the Licensee exceed the amount paid by the Licensee for
the Software.
b. This Licence sets out the full extent of the Licensors obligations and liabilities in respect of the supply of the Software. In particular, there are no
conditions, warranties, representations or other terms, express or implied, that are binding on the Licensor except as specifically stated in this
Licence. Any condition, warranty, representation or other term concerning the supply of the Software which might otherwise be implied into, or
incorporated in, this Licence, or any collateral contract, whether by statute, common law or otherwise, is hereby excluded to the fullest extent
permitted by law.
7. Termination
The Licensor may terminate this Agreement immediately by written notice to Licensee if
a. Licensee commits a breach of any provision of this Agreement; or
b. the Licensee becomes insolvent or unable to pay its debts, enters into liquidation, whether voluntary or compulsory (other than for reasons of bona
fide amalgamation or reconstruction), passes a resolution for its winding-up, has a receiver or administrator manager, trustee, liquidator or similar
officer appointed over the whole or any part of its assets, makes any composition or arrangement with its creditors or takes or suffers any similar
action in consequence of its debt, or becomes unable to pay its debts.
Upon termination for any reason:
a. all rights granted to Licensee under this Licence shall cease;
b. Licensee must cease all activities authorised by this Agreement;
c. Licensee must immediately pay to the Licensor any sums due to the Licensor under this Agreement; and
d. Licensee must immediately delete or remove the Software from all computer equipment in its possession and immediately destroy or return to the
Licensor (at the Licensors option) all copies of the Software then in its possession, custody or control and, in the case of destruction, certify to the
Licensor that it has done so.
8. Transfer of rights and obligations
a. This Agreement is binding on Licensee and Licensor and on Licensors respective successors and assigns.
b. Licensee may not transfer, assign, charge or otherwise dispose of this Agreement, or any of Licensees rights or obligations arising under it, without
Licensors prior written consent.
c. The Licensor may transfer, assign, charge, sub-contract or otherwise dispose of this Agreement, or any of his rights or obligations arising under it,
at any time during the term of the Agreement.
9. Force majeure
The Licensor will not be liable or responsible for any failure to perform, or delay in performance of, any of his obligations under this Agreement that
is caused by an event outside its reasonable control (Force Majeure Event).
A Force Majeure Event includes any act, event, non-happening, omission or accident beyond Licensors reasonable control and includes in particular
(without limitation) the following:
a. strikes, lock-outs or other industrial action;
b. civil commotion, riot, invasion, terrorist attack or threat of terrorist attack, war (whether declared or not) or threat or preparation for war;
c. fire, explosion, storm, flood, earthquake, subsidence, epidemic or other natural disaster;
d. impossibility of the use of railways, shipping, aircraft, motor transport or other means of public or private transport;
e. impossibility of the use of public or private telecommunications networks;
f. the acts, decrees, legislation, regulations or restrictions of any government.
The Licensors performance under this Agreement is deemed to be suspended for the period that the Force Majeure Event continues, and Licensor will
have an extension of time for performance for the duration of that period. Licensor will use its reasonable endeavours to bring the Force Majeure
Event to a close or to find a solution by which Licensors obligations under this Agreement may be performed despite the Force Majeure Event.
1 Waiver
0.
a. If the Licensor fails, at any time during the term of this Licence, to insist on strict performance of any of the Licensees obligations under this
Agreement, or if the Licensor fails to exercise any of the rights or remedies to which it is entitled under this Agreement, this shall not constitute a
waiver of such rights or remedies and shall not relieve Licensee from compliance with such obligations.
b. A waiver by the Licensor of any default shall not constitute a waiver of any subsequent default.
c. No waiver by the Licensor of any of these terms and conditions shall be effective unless it is expressly stated to be a waiver and is communicated
to Licensee in writing.
1 General
1.
a. This Agreement and any document expressly referred to in it represents the entire agreement between Licensor and Licensee in relation to the
licensing of the Software and supersedes any prior agreement, understanding or arrangement between Licensor and Licensee, whether oral or in
writing.
b. If any term or provision of this agreement shall be found to be illegal or unenforceable, then, notwithstanding that term, all other terms of this
Agreement will remain in full force and effect.
c. The laws of Denmark will govern this Agreement in all respects. The Copenhagen Maritime and Commercial Court will adjudicate all disputes
arising in connection with this agreement. The Licensee acknowledges and agrees that this clause will supersede any conflicting standard clauses,
terms, or similar rules that the Licensee may otherwise apply in agreements.
Additional copyrights
Part of this software is covered by other licenses. Where relevant, these are enclosed in the installation in their original form, in conjunction with the
software component they refer to.
The license management portion of this software is based on: SentinelRMS*, ©1989-2006 SafeNet, Inc. All rights reserved. Sentinel is a registered*
trademark of SafeNet, Inc.
TABLE OF CONTENTS
1. Introduction ............................................................................................................ 1
Preface ............................................................................................................... 1
Introduction to NanoLanguage .............................................................................. 2
How To Read This Manual ................................................................................... 4
Moving On ......................................................................................................... 5
2. The ATK-SE Package ................................................................................................ 7
Introduction ........................................................................................................ 7
Quick Tour ......................................................................................................... 7
Background Information ..................................................................................... 23
3. External Calculators ............................................................................................... 67
Introduction ...................................................................................................... 67
GPAW .............................................................................................................. 67
4. NanoLanguage Reference Manual ........................................................................... 69
Geometry ......................................................................................................... 69
Calculators ....................................................................................................... 69
Analysis ............................................................................................................ 70
Bravais Lattices .................................................................................................. 70
IO .................................................................................................................... 71
Periodic Table ................................................................................................... 71
Physical quantities and units ............................................................................... 71
5. Appendix .............................................................................................................. 73
What is New in NL 2009.06 ............................................................................... 73
Python basics .................................................................................................... 74
Python Packages in NanoLanguage ..................................................................... 86
Bibliography ............................................................................................................. 89
I. Core NanoLanguage elements .................................................................................. 91
MoleculeConfiguration ...................................................................................... 93
BulkConfiguration ............................................................................................. 95
DeviceConfiguration .......................................................................................... 99
BoxRegion ....................................................................................................... 103
HuckelCalculator ............................................................................................. 105
DeviceHuckelCalculator ................................................................................... 107
IterationControlParameters ................................................................................ 111
NumericalAccuracyParameters .......................................................................... 115
HuckelBasisParameters ..................................................................................... 117
SlaterOrbital .................................................................................................... 121
DoubleContourIntegralParameters ...................................................................... 123
Poisson Solvers ................................................................................................. 127
MultigridSolver ................................................................................................. 129
SelfEnergyCalculators ........................................................................................ 131
DirectSelfEnergy ............................................................................................... 133
RecursionSelfEnergy ......................................................................................... 135
KrylovSelfEnergy .............................................................................................. 137
MolecularEnergySpectrum ................................................................................. 139
ElectronDifferenceDensity ................................................................................. 141
ElectrostaticDifferencePotential .......................................................................... 145
TransmissionSpectrum ...................................................................................... 147
Bandstructure ................................................................................................... 153
BravaisLattice ................................................................................................... 155
nlread ............................................................................................................. 161
nlsave ............................................................................................................. 163
nlprint ............................................................................................................. 165
PeriodicTable ................................................................................................... 167
v
Index ....................................................................................................................... 173
vi
CHAPTER 1. INTRODUCTION
PREFACE
This manual describes the new QuantumWise version of the Atomistix ToolKit, ATK. ATK is a
set of atomic-scale simulators, so-called calculators that can calculate properties of nano-scale
systems. This first QuantumWise version of ATK, only includes semi-empirical calculators, implemented in the module Atomistix ToolKit Semi-Empirical(ATK-SE). In future versions, ATK
will also include Density Functional Methods.
The input format for ATK is NanoLanguage which is an extension to the Python scripting language. Compared to the previous version ATK-2008.10, the NanoLanguage syntax has been
extended and slightly modified to provide better support for the use of different calculators.
ATK supports simulations of isolated systems (molecules), periodic systems (crystals), and systems of the type bulk-nanodevice-bulk (device systems). In this new version, it is also possible
to include continuum dielectric and metallic regions for all system types. For device systems, it
is thus possible to calculate current-voltage characteristics of nano-scale transistors, i.e. systems
where a number of electro-static gates are controlling the source-drain current.
Figure 1.1: A typical device system, consisting of a z-shaped Graphene Nano Ribbon, on top of a dielectric
and controlled by three metallic gates. The contour plot illustrates the electrostatic potential through the
system. The unique capability of ATK is its ability to study the electron transport through such types of
systems. The current version supports device systems with two electrodes, and gate electrodes are included
as non current carrying electro-static gates. The underlying algorithms are readily extended to multi-probe
systems; support for device systems with several current carrying electrodes are projected in future
versions.
1
Introduction
INTRODUCTION TO NANOLANGUAGE
WHAT IS NANOLANGUAGE?
NanoLanguage is the scripting Language that binds all QuantumWise products together, and is
a platform on which other developers and companies can build applications and extend the
functionality of QuantumWise products. In the following sections, we will try to explain some
of the idea's behind NanoLanguage; users familiar with NanoLanguage may consult the section
called “What is New in NL 2009.06” .
Put shortly, NanoLanguage is a new way of thinking scientific computing, combining the
strength of flexible object-oriented scripting interfaces (known from Mathematica and MATLAB)
with sophisticated high performance scientific computing algorithms. The goal is to enable
scientists to efficiently extend, specialize and combine methods to calculate nanoscale properties of matter, including density functional theory, semi-empirical tight-binding, classical
potentials, as well as various quantum-chemical methods.
NanoLanguage admits both low and high level detailed control of the computer simulations.
At the high level, it offers a common interface for setting up complex atomic-scale simulations
and analyzing the results. On the lower level, it provides an interface to the low-level functionality in ATK.
NanoLanguage is built on top of Python, a powerful and well-established interpreted programming language, and thus includes basic programming constructions, as well as support for
efficient manipulations of e.g. numerical array data. It is therefore an ideal tool for automating
series of batch simulations where geometric, material, and other parameters are to be optimized.
NanoLanguage allows scientists to express models of nature in a common language without the
need to re-implement already developed algorithms, and facilitates third-party development of
new functionality on top of the ATK platform. Such functionality may consist of new atomicscale modeling methodologies, tailored semi-empirical methods, or complex post-processing
methods for calculating new quantities from the fundamental simulation results.
BENEFITS OF NANOLANGUAGE
With a Python interface, the user is immediately offered all kinds of extended functionality out
of the box. This list could be made very long, and below we will just highlight some of the most
important advantages and features of NanoLanguage. First, however, it is necessary to clearly
define where “NanoLanguage” fits into this concept. That is, how is NanoLanguage related to,
or different from, Python itself.
From a programming language point of view, ATK is just a Python interpreter. That is, the syntax
is the same as in Python, and the entire behavior of the ATK application will therefore be as
close as possible to any other Python interpreter.
NanoLanguage further extends a standard Python environment with concepts and objects relevant for quantum physics and chemistry. That is, in NanoLanguage there is a periodic table
containing elements, units such as Rydberg and Angstrom, methods for calculating the oneelectron spectrum of a molecules, band-structure of solids, transmission spectra of nano-scale
devices as well of constructors for creating molecules, Bravais lattices, and nano-scale devices.
Among many other things, NanoLanguage offers you
2
Benefits of NanoLanguage
CONTROL
Using a programming language gives the user control of the program execution path, as opposed
to program using a text based input file. For instance, performing calculations of current-voltage
characteristics with different gate potentials and using combinations of self consistent potentials
from previous runs as initial guess, can easily be defined in the input file. Other tasks as defining
tight binding parameters, optimizing semi-empirical parameters based on reference calculations, or performing relaxations are planned to be in open source python modules which can
easily be modified or extended.
TRANSPARENCY
By delivering parts of the end-user functionality in the form of open scripts, NanoLanguage offers
a software transparency, giving the user increased insight as to what actually goes on inside the
program. As a consequence, the user will also have the ability to tweak the behavior, or define
new functionality within a given framework. Also, no operations are performed unless the user
requests them. Obviously this saves time, but it also makes the scripts much more self-documenting. This is also reflected in more low-level details such as that all physical quantities must
be defined with a unit. Again, this is related to transparency; nothing is implicit (and hence
subject to misunderstandings or oversights).
EXTENDABLE FUNCTIONALITY
Given the native capabilities of Python, users have the chance to extend the functionality of
NanoLanguage. On the simplest level, this can be in the form of small functions performing
routine tasks, or loops for simplifying automation (calculating the properties of a bulk sample
for a range of lattice constants, for instance). A more advanced application could be to define
entire classes to represent complex geometries (such as a nanotube).
ACCESS
NanoLanguage gives access to data, such as the electron difference density, in native Python
types (basically, numerical arrays). This, for example, enables you to perform integration over
the plane perpendicular to the transport direction to plot the effective potential along the transport axis in a two-probe system, or make cut-lines in the data. Later on, it will also be possible
to access individual elements of the density matrix and other core constituents of the calculation
through native Python types. This will allow for a multitude of user-defined analysis options,
which in many cases can be defined and delivered as open scripts, instead of core functionality
with a rigid interface.
PYTHON
In addition to the features of NanoLanguage mentioned above, we would also like to highlight
some of the specific advantages offered by using Python as the platform for ATK.
• Python is fully programmable, mature, modern object-oriented programming language.
• The Python syntax is very powerful, yet surprisingly simple to learn. It is similar to other wellknown languages such as C, but requires less unnecessary typing (in particular compared to
e.g. Perl) and gives a better structural overview via its indentation scheme.
• There are several standard Python modules which are of particular relevance for scientific
applications. As the most notable example, we can mention the fast handling of large data
arrays obtained via the NumPy package.
3
Introduction
• Since Python is inherently modularized, it will be much easier to modularize ATK. In particular, this offers great simplifications in order for users to develop their own extensions to the
basic ATK package.
• Python is an interpreted language, which could be used as an argument against it, for performance reasons. However, ATK takes advantage of the rich possibilities to couple Python
with efficient code written in C, C++, or Fortran, and all performance-critical operations are
carried out in compiled libraries, including the possibility to run in parallel. Therefore, Python, as an interpreted language, gains an advantage as it can be used interactively without
compromising the power and speed of a compiled program.
• Since the language is interpreted, the source code is, with minor exceptions, automatically
cross-platform compatible.
• Python comes with “batteries included”, meaning that you can perform a very large variety
of operations out of the box.
• On the more technical level, dynamical type-checking and name resolution are major benefits for the flexibility of the code.
For more information about Python, see the Python website. Also, we highly recommend the
Wikipedia page on Python which contains a large number of links for further reading.
HOW TO READ THIS MANUAL
In this manual, you will find a few simple examples on how to use ATK that should get you
started, for more detailed examples of usage we are planning a number of tutorials that will be
available from our website. The main purpose of the manual is to give a reference to the NanoLanguage input format. A detailed summary of all input and output parameters and available
NanoLanguage commands can be found in the alphabetically ordered Reference manual index.
This manual contains several ATK script examples, as well as in-line text references to ATK and
Python objects and functions. To ease the reading of these, we use the following style and link
conventions
• All ATK objects and functions are type set as links in bold face monospace. For example, the
object “HuckelCalculator” will appear as HuckelCalculator. Click on the link, and you will
be taken to the relevant section of the reference manual, where a detailed description of the
object “HuckelCalculator” is provided.
• More information for using basic Python constructions are provided in a separate chapter
Python basics. References to this chapter, for example regarding Python for loops and tuples, are given directly in the manual pages.
• In the HTML version of this manual, all script examples are syntax highlighted, for example
All ATK elements are color highlighted as in
MoleculeConfiguration
Python structures are type set as in
from and import
whereas script comments are displayed as
4
Moving On
# This is a comment
Beneath each script example, a link is provided in the right margin. Use this to download your
own copy of the displayed script.
MOVING ON
Before you start using ATK, we suggest that you consult the section Introduction to NanoLanguage for a presentation of all the novel concepts and features available in NanoLanguage.
Once you feel up to learning more advanced techniques for handling molecular, bulk, and twoprobe structures, you may dive into to the quick tour of the ATK-SE package.
Remember to visit our website for updates both to the manual and the software
5
6
CHAPTER 2. THE ATK-SE PACKAGE
INTRODUCTION
The Atomistix ToolKit - Semi-Empirical (ATK-SE) program can model the electronic properties
of closed and open quantum systems using both self-consistent and non-self-consistent tightbinding models. In the first version, the implemented tight-binding model is based on the
extended-Hückel model
The key parameter in the self-consistent loop is the density matrix. For open systems, the density
matrix is calculated using non-equilibrium Green's functions, while for closed or periodic systems it is calculated by diagonalization of Hamiltonian. The Density Matrix defines the electron
density, and the electron density sets up an electrostatic potential, i.e. the Hartree potential. The
Hartree potential is obtained by solving the Poisson equation in real space. In the section called
“Background Information”, we describe the mathematical formalism behind the extendedHückel Model.
QUICK TOUR
In the first part of this quick tour, we present a calculation of the band structure of a graphene
nano-ribbon using a self-consistent extended-Hückel Model. In the second part we will set up
a nano-ribbon device with a gate and calculate the transmission coefficient as a function of the
gate potential and the applied bias.
BANDSTRUCTURE OF A GRAPHENE NANO-RIBBON
In this section, we will build a NanoLanguage script for calculating the Band structure of a
graphene nano-ribbon with the ATK-SE package. The script contains three parts,
• defining the geometry
• specifying the extended-Hückel calculator
• performing the calculation and the analysis
In the following we go through these different parts of the script in detail.
SPECIFYING THE GEOMETRY OF THE NANO-RIBBON
In this section, we will setup a one-dimensional structure of carbon atoms, a so-called zigzag
edged graphene nano-ribbon. Figure 2.1 shows the structure of the system.
7
The ATK-SE Package
Figure 2.1: Unit cell with the graphene nano-ribbon visualized with VNL. The contour plot shows the
electro-static potential. The structure is periodic along the C-direction.
The input script for the geometry consists of a specification of the unit cell vectors, the atom
types, and the atom basis within the unit cell.
from NanoLanguage import *
#------------------------------------------------------------# Bulk configuration
#------------------------------------------------------------# Set up lattice
vector_a = [19.3063, 0.0, 0.0]*Angstrom
vector_b = [0.0, 10.0, 0.0]*Angstrom
vector_c = [0.0, 0.0, 2.4610017104423147]*Angstrom
lattice = UnitCell(vector_a, vector_b, vector_c)
# Define elements
elements = [Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Hydrogen, Hydrogen]
# Define coordinates
cartesian_coordinates = [[
[
[
[
[
[
[
[
[
[
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
,
,
,
,
,
,
,
,
,
,
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
# Set up configuration
bulk_configuration = BulkConfiguration(
bravais_lattice=lattice,
elements=elements,
cartesian_coordinates=cartesian_coordinates
)
The first line in the script
from NanoLanguage import *
8
,
,
,
,
,
,
,
,
,
,
0.61525043],
1.84575128],
1.84575128],
0.61525043],
0.61525043],
1.84575128],
1.84575128],
0.61525043],
0.61525043],
0.61525043]]*Angstrom
Bandstructure of a Graphene Nano-ribbon
specifies that the ATK python interpreter nlpython should load the NanoLanguage package. The
following lines specify the input geometry through the use of the BulkConfiguration keyword.
Note, the use of length unit when specifying the cell vectors and input coordinates.
By saving the NanoLanguage script into a file, it is possible to import the structure into VNL and
visualize it with the Nanoscope as illustrated in Figure 2.1
SETTING UP THE HÜCKEL CALCULATOR
The next task is to specify the calculation method that should be used for describing the electronic structure of the system. We will use an extended-Hückel calculator, specified by the
HuckelCalculator keyword. The calculator takes a number of parameters specifying the details of the calculation. In the following, we only specify a few of these parameters; when no
parameters are specified, the calculator uses default settings.
#------------------------------------------------------------# Calculator
#------------------------------------------------------------basis_set = [
CerdaHuckelParameters.Carbon_graphite_Basis,
CerdaHuckelParameters.Hydrogen_C2H4_Basis,
]
numerical_accuracy_parameters = NumericalAccuracyParameters(
electron_temperature=300.0*Kelvin,
k_point_sampling=(1,1,50)
)
calculator = HuckelCalculator(
basis_set=basis_set,
numerical_accuracy_parameters=numerical_accuracy_parameters
)
bulk_configuration.set_calculator(calculator)
To obtain good accuracy, the extended-Hückel calculator requires a set of modelling parameters
optimized for structures not too different from the structure under investigation. The ATK-SE
packages comes with the original Hoffmann-Hückel parameters, which are optimized for studying molecular structures. We will use these parameters for describing Hydrogen and which is
specified through the keyword HoffmannHuckelParameters.Hydrogen_Basis.
For carbon, we will use parameters optimized for modelling the electronic structure of graphene.
The parameters are obtained from the website of J. Cerda.. These parameters were fitted to the
GGA band structure of graphene calculated with a spd localized basis set. Here the basis set
parameters are specified through the HuckelBasisParameters keyword.
In the last line we attach the HuckelCalculator to the BulkConfiguration. Now we can
inquire the BulkConfiguration about the properties, such as the electron density, which can be
calculated with the HuckelCalculator. In the following, we will look into some of the BulkConfiguration properties which can be calculated with the Hückel calculator.
SPECIFYING THE BAND-STRUCTURE CALCULATION
In the first line of the analysis part of the script shown below, we inquire about the electron
density of the bulk configuration. The bulk configuration will now use the attached calculator
for calculating its electron density. To calculate the electron density we need the self-consistent
state of the calculator, and at this point a self-consistent calculation is performed. The Bulk
configuration stores the self-consistent state and will use it for the remainder of the analysis part.
9
The ATK-SE Package
The electron density as well as the electrostatic potential and atomic configuration are saved
into the file nanowire_band.nc. This file can be visualized with VNL. Note that the electron
density for the Hückel Model is defined in ATK-SE as the electron difference density, i.e. the
electron density relative to neutral atoms. The electrostatic potential is defined as the corresponding difference Hartree potential.
#------------------------------------------------------------# Analysis
#------------------------------------------------------------filename= 'nanowire_band.nc'
difference_density = ElectronDifferenceDensity(bulk_configuration)
nlsave(filename, difference_density)
electrostatic_potential = ElectrostaticDifferencePotential(bulk_configuration)
nlsave(filename, electrostatic_potential)
nlsave(filename, bulk_configuration)
bandstructure = Bandstructure(
configuration=bulk_configuration,
route=['G', 'Z'],
points_per_segment=20,
bands_above_fermi_level=None
)
nlsave(filename, bandstructure)
The last part of the analysis is the band-structure calculation. This is done using the Bandstructure class. The route of the band structure within the Brillouin Zone is specified through
the symmetry points. The symmetry points are a property which can be retrieved from the
BravaisLattice of the BulkConfiguration. In this case, the energy bands will be sampled
using twenty points along the - direction. The band structure is subsequently stored in the
file nanowire_band.nc; this file can also be visualized with VNL.
THE COMPLETE BAND STRUCTURE CALCULATION SCRIPT
Below we show the complete script for the extended-Hückel Bandstructure calculation of the
graphene nano-ribbon.
from NanoLanguage import *
#------------------------------------------------------------# Bulk configuration
#------------------------------------------------------------# Set up lattice
vector_a = [19.3063, 0.0, 0.0]*Angstrom
vector_b = [0.0, 10.0, 0.0]*Angstrom
vector_c = [0.0, 0.0, 2.4610017104423147]*Angstrom
lattice = UnitCell(vector_a, vector_b, vector_c)
# Define elements
elements = [Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Hydrogen, Hydrogen]
# Define coordinates
cartesian_coordinates = [[
[
[
[
[
[
[
[
[
10
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
,
,
,
,
,
,
,
,
,
5.
5.
5.
5.
5.
5.
5.
5.
5.
,
,
,
,
,
,
,
,
,
0.61525043],
1.84575128],
1.84575128],
0.61525043],
0.61525043],
1.84575128],
1.84575128],
0.61525043],
0.61525043],
Bandstructure of a Graphene Nano-ribbon
[ 14.3063
,
5.
,
0.61525043]]*Angstrom
# Set up configuration
bulk_configuration = BulkConfiguration(
bravais_lattice=lattice,
elements=elements,
cartesian_coordinates=cartesian_coordinates
)
#------------------------------------------------------------# Calculator
#------------------------------------------------------------basis_set = [
CerdaHuckelParameters.Carbon_graphite_Basis,
CerdaHuckelParameters.Hydrogen_C2H4_Basis,
]
numerical_accuracy_parameters = NumericalAccuracyParameters(
electron_temperature=300.0*Kelvin,
k_point_sampling=(1,1,50)
)
calculator = HuckelCalculator(
basis_set=basis_set,
numerical_accuracy_parameters=numerical_accuracy_parameters
)
bulk_configuration.set_calculator(calculator)
#------------------------------------------------------------# Analysis
#------------------------------------------------------------filename= 'nanowire_band.nc'
difference_density = ElectronDifferenceDensity(bulk_configuration)
nlsave(filename, difference_density)
electrostatic_potential = ElectrostaticDifferencePotential(bulk_configuration)
nlsave(filename, electrostatic_potential)
nlsave(filename, bulk_configuration)
bandstructure = Bandstructure(
configuration=bulk_configuration,
route=['G', 'Z'],
points_per_segment=20,
bands_above_fermi_level=None
)
nlsave(filename, bandstructure)
By clicking the link below the script, the script can be stored on your computer, and then
executed using the command
nlpython nanowire_band.py
The command performs a self-consistent calculation of the Carbon nanowire and saves the
analysis results to the file nanowire_band.nc. This file can be visualized with VNL. The result
of the visualization is illustrated in Figure 2.1 and Figure 2.2.
11
The ATK-SE Package
Figure 2.2: The bandstructure of the carbon nano-ribbon calculated within the extended-Hückel model.
PROPERTIES OF A NANO-RIBBON TRANSISTOR
We will now setup a device system consisting of a graphene nano ribbon, with a gate potential
and an applied bias potential, and then calculate the transmission spectrum. The structure of
the system is illustrated in Figure 2.3. Again, we divide the discussion into three parts
• setting up the geometry
• defining the calculator
• performing the analysis
12
Properties of a Nano-ribbon Transistor
Figure 2.3: The geometry of the graphene nano-ribbon device visualized with VNL. The device consists
of a left and a right electrode with tubes illustrating the unit cells of these bulk configurations. The central
region is located in between the two electrodes. Within the central region there is a dielectric region (brown
transparent region) and below this an electro-static gate. The contour plot shows the electro-static potential
for a gate potential of 1 Volt and a bias across the nano-ribbon of 0.2 Volt.
SETTING UP THE DEVICE CONFIGURATION
The DeviceConfiguration consists of a central region and a number of electrode regions. All
are object of the type BulkConfiguration. For the present geometry, we have two electrodes,
a left and a right, which is a so-called two-probe system. Currently, only two-probe systems are
supported in ATK-SE, but future extensions with support for one-probe and multi-probe systems
are planned.
Compared to the previous band-structure calculation, the electrode configurations have twice
as many atoms within the unit cell. This is because the structures are repeated twice along the
C-direction. For the electrodes to be valid configurations, they must be periodic along the C
direction and only have matrix elements with the neighbouring cell, i.e. the interaction range
of the attached calculator should be comparable or less than the lattice constant along the C
direction.
In the following script we set up an ideal graphene nano-ribbon two probe device
from NanoLanguage import *
# -------------------------------------------------------------------# electrodes
# -------------------------------------------------------------------# Set up lattice
vector_a = [19.3063, 0.0, 0.0]*Angstrom
vector_b = [0.0, 15.0, 0.0]*Angstrom
vector_c = [0.0, 0.0, 4.9220034208846295]*Angstrom
electrode_lattice = UnitCell(vector_a, vector_b, vector_c)
# Define elements
electrode_elements = [Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Hydrogen, Hydrogen, Carbon, Carbon, Carbon, Carbon, Carbon,
Carbon, Carbon, Carbon, Hydrogen, Hydrogen]
13
The ATK-SE Package
# Define coordinates
electrode_coordinates = [[
6.101
,
5.
[ 6.81143
,
[ 8.23229
,
[ 8.94272
,
[ 10.36358
,
[ 11.07401
,
[ 12.49487
,
[ 13.2053
,
[ 5.
,
[ 14.3063
,
[ 6.101
,
[ 6.81143
,
[ 8.23229
,
[ 8.94272
,
[ 10.36358
,
[ 11.07401
,
[ 12.49487
,
[ 13.2053
,
[ 5.
,
[ 14.3063
,
,
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
0.61525043],
,
1.84575128],
,
1.84575128],
,
0.61525043],
,
0.61525043],
,
1.84575128],
,
1.84575128],
,
0.61525043],
,
0.61525043],
,
0.61525043],
,
3.07625214],
,
4.30675299],
,
4.30675299],
,
3.07625214],
,
3.07625214],
,
4.30675299],
,
4.30675299],
,
3.07625214],
,
3.07625214],
,
3.07625214]]*Angstrom
# Set up configuration
left_electrode = BulkConfiguration(
bravais_lattice=electrode_lattice,
elements=electrode_elements,
cartesian_coordinates=electrode_coordinates
)
right_electrode = BulkConfiguration(
bravais_lattice=electrode_lattice,
elements=electrode_elements,
cartesian_coordinates=electrode_coordinates
)
# -------------------------------------------------------------------# Central region
# -------------------------------------------------------------------# Set up lattice
vector_a = [19.3063, 0.0, 0.0]*Angstrom
vector_b = [0.0, 15.0, 0.0]*Angstrom
vector_c = [0.0, 0.0, 19.688013683538518]*Angstrom
central_region_lattice = UnitCell(vector_a, vector_b, vector_c)
# Define elements
central_region_elements = [Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Hydrogen, Hydrogen, Carbon, Carbon, Carbon, Carbon, Carbon,
Carbon, Carbon, Carbon, Hydrogen, Hydrogen, Carbon, Carbon,
Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Hydrogen,
Hydrogen, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Carbon, Hydrogen, Hydrogen, Carbon, Carbon, Carbon, Carbon,
Carbon, Carbon, Carbon, Carbon, Hydrogen, Hydrogen, Carbon,
Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Hydrogen,
Hydrogen, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Carbon, Hydrogen, Hydrogen, Carbon, Carbon, Carbon, Carbon,
Carbon, Carbon, Carbon, Carbon, Hydrogen, Hydrogen]
# Define coordinates
central_region_coordinates = [[
[
[
[
[
[
[
[
[
[
[
14
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
,
,
,
,
,
,
,
,
,
,
,
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
,
,
,
,
,
,
,
,
,
,
,
0.61525043],
1.84575128],
1.84575128],
0.61525043],
0.61525043],
1.84575128],
1.84575128],
0.61525043],
0.61525043],
0.61525043],
3.07625214],
Properties of a Nano-ribbon Transistor
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
4.30675299],
4.30675299],
3.07625214],
3.07625214],
4.30675299],
4.30675299],
3.07625214],
3.07625214],
3.07625214],
5.53725385],
6.7677547 ],
6.7677547 ],
5.53725385],
5.53725385],
6.7677547 ],
6.7677547 ],
5.53725385],
5.53725385],
5.53725385],
7.99825556],
9.22875641],
9.22875641],
7.99825556],
7.99825556],
9.22875641],
9.22875641],
7.99825556],
7.99825556],
7.99825556],
10.45925727],
11.68975812],
11.68975812],
10.45925727],
10.45925727],
11.68975812],
11.68975812],
10.45925727],
10.45925727],
10.45925727],
12.92025898],
14.15075984],
14.15075984],
12.92025898],
12.92025898],
14.15075984],
14.15075984],
12.92025898],
12.92025898],
12.92025898],
15.38126069],
16.61176155],
16.61176155],
15.38126069],
15.38126069],
16.61176155],
16.61176155],
15.38126069],
15.38126069],
15.38126069],
17.8422624 ],
19.07276326],
19.07276326],
17.8422624 ],
17.8422624 ],
19.07276326],
19.07276326],
17.8422624 ],
17.8422624 ],
17.8422624 ]]*Angstrom
15
The ATK-SE Package
# Set up configuration
central_region = BulkConfiguration(
bravais_lattice=central_region_lattice,
elements=central_region_elements,
cartesian_coordinates=central_region_coordinates
)
The DeviceConfiguration is constructed by placing the left electrode to the left of the central
region and the right electrode to the right of the central region. It is important that the structure
is seemless across the boundaries between the different regions, thus, the electrode regions must
be repeated into the device region. Further details on the definition of the DeviceConfiguration can be found in the reference section.
ATTACHING DIELECTRIC AND METALLIC REGIONS TO A CONFIGURATION
We will now define a region below the nano-ribbon where there is a dielectric material with
. This is done with the BoxRegion command. Similarly, we define
the dielectric constant
the electro-static gate as a metallic region below the nano-ribbon with electro-static potential
1 Volt. The two regions are attached to the central configuration, as visualized in Figure 2.3.
Finally, we define the DeviceConfiguration from the BulkConfiguration of the left, right
and central regions.
#add dielectric regions
dielectric_region_0 = BoxRegion(
4.,
xmin = 0*Angstrom, xmax = 19.3063*Angstrom,
ymin = 0.5*Angstrom, ymax = 3.5*Angstrom,
zmin = 5*Angstrom, zmax = 15.*Angstrom
)
dielectric_regions = [dielectric_region_0]
central_region.set_dielectric_regions(dielectric_regions)
#add metallic regions
metallic_region_0 = BoxRegion(
1*Volt,
xmin = 0*Angstrom, xmax = 19.3063*Angstrom,
ymin = 0*Angstrom, ymax = 0.5*Angstrom,
zmin = 5*Angstrom, zmax = 15.*Angstrom
)
metallic_regions = [metallic_region_0 ]
central_region.set_metallic_regions(metallic_regions)
device_configuration = DeviceConfiguration(
central_region,
[left_electrode, right_electrode]
)
SETTING UP THE DEVICE CALCULATOR
Next we will set up a DeviceHuckelCalculator and attach it to the DeviceConfiguration.
A device calculator includes calculators for each electrode as well as the central region. The
electrode calculators are setup similar to the previous bulk example. However, in the section
called “Bandstructure of a Graphene Nano-ribbon”, we did not explicitly setup a Poisson solver,
implying that the default Poisson solver was used. The default Poisson solver uses periodic
boundary conditions in all three directions. For the current system, we will use Neumann
boundary conditions in the A and B directions. The Neumann boundary conditions constrain
the electric field to be zero at the boundaries.
16
Properties of a Nano-ribbon Transistor
# -------------------------------------------------------------------# Calculator
# -------------------------------------------------------------------basis_set = [
CerdaHuckelParameters.Carbon_graphite_Basis,
CerdaHuckelParameters.Hydrogen_C2H4_Basis,
]
electrode_numerical_accuracy_parameters = NumericalAccuracyParameters(
electron_temperature=300.0*Kelvin,
k_point_sampling=(1,1,100)
)
electrode_poisson_solver = MultigridSolver(boundary_conditions=[NeumannBoundaryCondition,
NeumannBoundaryCondition, PeriodicBoundaryCondition])
left_electrode_calculator = HuckelCalculator(
basis_set=basis_set,
numerical_accuracy_parameters=electrode_numerical_accuracy_parameters,
poisson_solver=electrode_poisson_solver
)
right_electrode_calculator = HuckelCalculator(
basis_set=basis_set,
numerical_accuracy_parameters=electrode_numerical_accuracy_parameters,
poisson_solver=electrode_poisson_solver
)
numerical_accuracy_parameters = NumericalAccuracyParameters(
electron_temperature=300.0*Kelvin,
k_point_sampling=(1,1,100)
)
poisson_solver = MultigridSolver(boundary_conditions=[NeumannBoundaryCondition,
NeumannBoundaryCondition, DirichletBoundaryCondition])
double_contour_integral_parameters = DoubleContourIntegralParameters(
real_axis_point_density=0.01*eV,
)
calculator = DeviceHuckelCalculator(
basis_set=basis_set,
numerical_accuracy_parameters=numerical_accuracy_parameters,
contour_parameters=double_contour_integral_parameters,
poisson_solver=poisson_solver,
electrode_calculators=
[left_electrode_calculator, right_electrode_calculator],
electrode_voltages=( -0.1*Volt, 0.1*Volt),
)
device_configuration.set_calculator(calculator)
The DeviceHuckelCalculator parameters are used in the central region. In the A and B direction, we need the same parameters in the central region and in the electrodes, i.e. the same
boundary conditions, k-point sampling, etc. In the C direction, the parameters will differ. For
the Poisson equation for the central region, we use the electro-static potential of the electrodes
(appropriately shifted, according to the applied electrode potential), as boundary condition.
Thus, we specify Dirichlet boundary conditions, which fixes the electro-static potential at the
boundary.
Other parameters that must be set are the applied electrode potential and the DoubleContourIntegralParameters which specifies the complex contour used for the integral in the density
matrix calculation.
SETTING UP THE TRANSMISSION SPECTRUM CALCULATION
Finally, we setup the analysis part. The calculation of the electron difference density and the
electrostatic potential is similar to the previous example. For calculating the transmission spec-
17
The ATK-SE Package
trum, we use the TransmissionSpectrum command. The transmission spectrum is sampled at
100 points in the range -2 eV to 2 eV around the average Fermi Level of the two electrodes.
# -------------------------------------------------------------------# Analysis
# -------------------------------------------------------------------filename='nanowire_device.nc'
difference_density = ElectronDifferenceDensity(device_configuration)
nlsave(filename, difference_density)
electrostatic_potential = ElectrostaticDifferencePotential(device_configuration)
nlsave(filename, electrostatic_potential)
nlsave(filename, device_configuration)
transmission_spectrum = TransmissionSpectrum(
configuration=device_configuration,
energies=numpy.linspace(-2,2,100)*Units.eV,
kpoints=MonkHorstPackGrid(1,1,1),
energy_zero_parameter=AverageFermiLevel,
infinitesimal=1e-06*Units.eV
)
nlsave(filename,transmission_spectrum)
THE COMPLETE DEVICE CALCULATION SCRIPT
Below you find the complete device calculation script for the transmission spectrum of the
graphene nano-ribbon.
from NanoLanguage import *
# -------------------------------------------------------------------# electrodes
# -------------------------------------------------------------------# Set up lattice
vector_a = [19.3063, 0.0, 0.0]*Angstrom
vector_b = [0.0, 15.0, 0.0]*Angstrom
vector_c = [0.0, 0.0, 4.9220034208846295]*Angstrom
electrode_lattice = UnitCell(vector_a, vector_b, vector_c)
# Define elements
electrode_elements = [Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Hydrogen, Hydrogen, Carbon, Carbon, Carbon, Carbon, Carbon,
Carbon, Carbon, Carbon, Hydrogen, Hydrogen]
# Define coordinates
electrode_coordinates = [[
18
6.101
,
5.
[ 6.81143
,
[ 8.23229
,
[ 8.94272
,
[ 10.36358
,
[ 11.07401
,
[ 12.49487
,
[ 13.2053
,
[ 5.
,
[ 14.3063
,
[ 6.101
,
[ 6.81143
,
[ 8.23229
,
[ 8.94272
,
[ 10.36358
,
[ 11.07401
,
[ 12.49487
,
[ 13.2053
,
[ 5.
,
[ 14.3063
,
,
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
0.61525043],
,
1.84575128],
,
1.84575128],
,
0.61525043],
,
0.61525043],
,
1.84575128],
,
1.84575128],
,
0.61525043],
,
0.61525043],
,
0.61525043],
,
3.07625214],
,
4.30675299],
,
4.30675299],
,
3.07625214],
,
3.07625214],
,
4.30675299],
,
4.30675299],
,
3.07625214],
,
3.07625214],
,
3.07625214]]*Angstrom
Properties of a Nano-ribbon Transistor
# Set up configuration
left_electrode = BulkConfiguration(
bravais_lattice=electrode_lattice,
elements=electrode_elements,
cartesian_coordinates=electrode_coordinates
)
right_electrode = BulkConfiguration(
bravais_lattice=electrode_lattice,
elements=electrode_elements,
cartesian_coordinates=electrode_coordinates
)
# -------------------------------------------------------------------# Central region
# -------------------------------------------------------------------# Set up lattice
vector_a = [19.3063, 0.0, 0.0]*Angstrom
vector_b = [0.0, 15.0, 0.0]*Angstrom
vector_c = [0.0, 0.0, 19.688013683538518]*Angstrom
central_region_lattice = UnitCell(vector_a, vector_b, vector_c)
# Define elements
central_region_elements = [Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Hydrogen, Hydrogen, Carbon, Carbon, Carbon, Carbon, Carbon,
Carbon, Carbon, Carbon, Hydrogen, Hydrogen, Carbon, Carbon,
Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Hydrogen,
Hydrogen, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Carbon, Hydrogen, Hydrogen, Carbon, Carbon, Carbon, Carbon,
Carbon, Carbon, Carbon, Carbon, Hydrogen, Hydrogen, Carbon,
Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Hydrogen,
Hydrogen, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon, Carbon,
Carbon, Hydrogen, Hydrogen, Carbon, Carbon, Carbon, Carbon,
Carbon, Carbon, Carbon, Carbon, Hydrogen, Hydrogen]
# Define coordinates
central_region_coordinates = [[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
0.61525043],
1.84575128],
1.84575128],
0.61525043],
0.61525043],
1.84575128],
1.84575128],
0.61525043],
0.61525043],
0.61525043],
3.07625214],
4.30675299],
4.30675299],
3.07625214],
3.07625214],
4.30675299],
4.30675299],
3.07625214],
3.07625214],
3.07625214],
5.53725385],
6.7677547 ],
6.7677547 ],
5.53725385],
5.53725385],
6.7677547 ],
6.7677547 ],
5.53725385],
5.53725385],
5.53725385],
7.99825556],
9.22875641],
19
The ATK-SE Package
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
[
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
6.101
6.81143
8.23229
8.94272
10.36358
11.07401
12.49487
13.2053
5.
14.3063
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
5.
# Set up configuration
central_region = BulkConfiguration(
bravais_lattice=central_region_lattice,
elements=central_region_elements,
cartesian_coordinates=central_region_coordinates
)
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
#add dielectric regions
dielectric_region_0 = BoxRegion(
4.,
xmin = 0*Angstrom, xmax = 19.3063*Angstrom,
ymin = 0.5*Angstrom, ymax = 3.5*Angstrom,
zmin = 5*Angstrom, zmax = 15.*Angstrom
)
dielectric_regions = [dielectric_region_0]
central_region.set_dielectric_regions(dielectric_regions)
#add metallic regions
metallic_region_0 = BoxRegion(
1*Volt,
xmin = 0*Angstrom, xmax = 19.3063*Angstrom,
20
9.22875641],
7.99825556],
7.99825556],
9.22875641],
9.22875641],
7.99825556],
7.99825556],
7.99825556],
10.45925727],
11.68975812],
11.68975812],
10.45925727],
10.45925727],
11.68975812],
11.68975812],
10.45925727],
10.45925727],
10.45925727],
12.92025898],
14.15075984],
14.15075984],
12.92025898],
12.92025898],
14.15075984],
14.15075984],
12.92025898],
12.92025898],
12.92025898],
15.38126069],
16.61176155],
16.61176155],
15.38126069],
15.38126069],
16.61176155],
16.61176155],
15.38126069],
15.38126069],
15.38126069],
17.8422624 ],
19.07276326],
19.07276326],
17.8422624 ],
17.8422624 ],
19.07276326],
19.07276326],
17.8422624 ],
17.8422624 ],
17.8422624 ]]*Angstrom
Properties of a Nano-ribbon Transistor
ymin = 0*Angstrom, ymax = 0.5*Angstrom,
zmin = 5*Angstrom, zmax = 15.*Angstrom
)
metallic_regions = [metallic_region_0 ]
central_region.set_metallic_regions(metallic_regions)
device_configuration = DeviceConfiguration(
central_region,
[left_electrode, right_electrode]
)
# -------------------------------------------------------------------# Calculator
# -------------------------------------------------------------------basis_set = [
CerdaHuckelParameters.Carbon_graphite_Basis,
CerdaHuckelParameters.Hydrogen_C2H4_Basis,
]
electrode_numerical_accuracy_parameters = NumericalAccuracyParameters(
electron_temperature=300.0*Kelvin,
k_point_sampling=(1,1,100)
)
electrode_poisson_solver = MultigridSolver(boundary_conditions=[NeumannBoundaryCondition,
NeumannBoundaryCondition, PeriodicBoundaryCondition])
left_electrode_calculator = HuckelCalculator(
basis_set=basis_set,
numerical_accuracy_parameters=electrode_numerical_accuracy_parameters,
poisson_solver=electrode_poisson_solver
)
right_electrode_calculator = HuckelCalculator(
basis_set=basis_set,
numerical_accuracy_parameters=electrode_numerical_accuracy_parameters,
poisson_solver=electrode_poisson_solver
)
numerical_accuracy_parameters = NumericalAccuracyParameters(
electron_temperature=300.0*Kelvin,
k_point_sampling=(1,1,100)
)
poisson_solver = MultigridSolver(boundary_conditions=[NeumannBoundaryCondition,
NeumannBoundaryCondition, DirichletBoundaryCondition])
double_contour_integral_parameters = DoubleContourIntegralParameters(
real_axis_point_density=0.01*eV,
)
calculator = DeviceHuckelCalculator(
basis_set=basis_set,
numerical_accuracy_parameters=numerical_accuracy_parameters,
contour_parameters=double_contour_integral_parameters,
poisson_solver=poisson_solver,
electrode_calculators=
[left_electrode_calculator, right_electrode_calculator],
electrode_voltages=( -0.1*Volt, 0.1*Volt),
)
device_configuration.set_calculator(calculator)
# -------------------------------------------------------------------# Analysis
# -------------------------------------------------------------------filename='nanowire_device.nc'
difference_density = ElectronDifferenceDensity(device_configuration)
nlsave(filename, difference_density)
electrostatic_potential = ElectrostaticDifferencePotential(device_configuration)
nlsave(filename, electrostatic_potential)
21
The ATK-SE Package
nlsave(filename, device_configuration)
transmission_spectrum = TransmissionSpectrum(
configuration=device_configuration,
energies=numpy.linspace(-2,2,100)*Units.eV,
kpoints=MonkHorstPackGrid(1,1,1),
energy_zero_parameter=AverageFermiLevel,
infinitesimal=1e-06*Units.eV
)
nlsave(filename,transmission_spectrum)
By clicking the link the script will be saved on your computer, and it can then be executed with
the command
nlpython nanowire_device.py
The command performs a self-consistent calculation of the nano-ribbon device and saves the
analysis results to the file nanowire_device.nc. This file can be visualized with VNL. The
result of the visualization is illustrated in Figure 2.3 and Figure 2.4.
Figure 2.4: Transmission spectrum of the graphene nano-ribbon device with an applied bias potential of
-0.1 Volt on the left electrode, 0.1 Volt on the right electrode and an applied gate potential of 1 Volt.
It is interesting to see that the transmission is almost zero in the energy range between the
electrode Fermi Levels, while outside this energy range the transmission is close to integer values
and therefore almost ideal. The zero transmission is surprising since the nano-ribbon is metallic,
thus, we assemble three metals and obtain an insulator. In the following we will briefly discuss
the origin of this effect.
From Figure 2.3, we see that the gate potential is screened out inside the nano-ribbon and
therefore only has a minor effect on the transmission; as a consequence, we will neglect the
gate effects. From the band structure in Figure 2.2, we see that two bands meet at the Fermi
level. The two bands have different symmetry, one is the bonding band and the other is the
anti-bonding
band. For the energy range between the two Fermi levels in Figure 2.4, we will
therefore have a band from the left electrode propagating into a band in the right electrode.
22
Background Information
These two bands are orthogonal and the transmission coefficient therefore close to zero. For
energies below or above both Fermi levels, the bands in the left and right electrode have similar
symmetry giving rise to a high transmission.
BACKGROUND INFORMATION
The extended-Hückel Model provides a description of the electronic structure of the valence
electrons of molecules and solids. In this section we will describe the mathematical formalism
behind ATK-SE.
The electronic structure is expanded in a basis of local atomic orbitals (LCAO's)
where
is a spherical harmonic and
is a superposition of Slater orbitals
The LCAO basis is described by the adjustable parameters
, these parameters must
be defined for each angular shell of valence orbitals for each element.
The central object in the extended-Hückel model is the overlap matrix,
where is a composite index for
and
is the position of the center of orbital .
From the overlap matrix we define the Hamiltonian,
where
is an orbital energy, and
is a Hückel fitting parameter (often chosen to be 1.75).
is the Hartree potential from the electron density, and must be determined self-consistently. In the non-self-consistent Hückel Model the Hartree potential is not included.
WEIGHTING SCHEMES
The are two variants of the weighting schemes of the orbital energy of the off-site Hamiltonian.
The scheme used above
where
where
is due to Wolfsberg[27], while Hoffmann[28] and [29] use the scheme
.
Both variants are available in ATK-SE through the methods WolfsbergWeighting and HoffmannWeighting .
23
The ATK-SE Package
SOLVING POISSON'S EQUATION TO OBTAIN THE HARTREE POTENTIAL
The Hartree potential is obtained by solving Poisson's equation with the electron density from
the Hückel tight-binding model. The electron density is given by the occupied eigenfunctions
where
ature, and
is the Fermi function,
the energy of eigenstate
.
the Fermi energy,
the electron temper-
We next write the eigenstates in the Slater orbital basis,
and see that the total number of electrons,
where
is given by
is the Density Matrix.
Introducing the Mulliken population of atom number
we can write the total electron density as a sum of atom contributions,
. The radial
dependence of each atom density contribution is represented by a Gaussian function, and the
total induced charge in the system is
where
is the total charge of atom , i.e. the sum of the valence electron charge
and the ionic charge
.
To see the significance of the width of the Gaussian orbital, , we now calculate the electro,
static potential from a single Gaussian density at position
The onsite value of the Hartree potential is
, where
is
the onsite Hartree shift. In ATK-SE it is the value of
which is specified, and this value is used
to determine the width of the Gaussian
using the above relation.
In ATK-SE the Poisson equation is solved using a real space multigrid solver. The system is
enclosed in a bounding box, and the Hartree potential is defined on a regular grid inside the
bounding box. Different boundary conditions can be imposed on the solution at bounding box
surface.
24
DirichletBoundaryCondition
For Dirichlet boundary conditions the Hartree potential is
zero at the boundary.
NeumannBoundaryCondition
For Neumann boundary conditions the gradient of the Hartree potential, e.g. the electric field, is zero at the boundary.
The Extended-Hückel Parameters
PeriodicBoundaryCondition
For Periodic boundary conditions the potential has identical values on opposite faced boundaries.
It is possible to include an electro-static interaction with a continuum metallic or dielectric
material inside the bounding box. The continuum metals are handled by constraining the Hartree potential within the metallic region to a fixed value. Dielectric materials are handled by
introducing a spatial dependent dielectric constant,
, where
inside the dielectric
material with dielectric constant
, and
outside the dielectric materials
THE EXTENDED-HÜCKEL PARAMETERS
The parameters,
must be defined for each valence orbital, while
only
depends on the element type. Different parameter sets are provided with ATK-SE, but it is also
possible to provide user defined parameters in the input file using the HuckelBasisParameters keyword.
Table 2.1: HuckelBasisParameters
Symbol
HuckelBasisParameters
ionization_potential
wolfsberg_helmholtz_constant
onsite_hartree_shift
vacuum_level
Table 2.2: SlaterOrbital parameters
Symbol
SlaterOrbital parameters
principal_quantum_number
azimuthal_quantum_number
slater_coefficients
weights
In the current version we provide a Hoffmann parameter set which is appropriate for organic
molecules. The parameter set is available with the keyword HoffmannHuckelParameters.ElementName, where ElementName is the name of the element. For crystal parameters we refer
to the website of J. Cerda. and his paper [23],
In future versions of ATK-SE we plan to have additional parameters and functions for generating
new parameters that fit first principles data generated with ATK.
To combine parameters from different sources it is important to make sure they use the same
energy zero, in order to obtain correct charge transfers. This can be obtained by ensuring that
the crystals have the correct work function and molecules the correct ionisation energies. For
this purpose we have introduced an additional parameter
which shift the energy of the
vacuum level. I.e. if a calculation with
eV has a work function of 6.5 eV, then by
setting
eV all bands shift rigidly up by 1.5 eV and the work function becomes
5.0 eV.
A table showing the values of the electro-static parameter used in ATK-SE is shown here. A
table showing the values used for the Hoffmann-Hückel basis set parameters can be found
here; A similar table for the Müller-Hückel basis set parameters is located here. Finally, a table
for the Cerda-Hückel basis set parameters can be found here.
25
The ATK-SE Package
Table 2.3: The Hoffmann-Hückel basis set parameters. The unit of Eion is eV, where as the respective units of wi and
ηi are Bohr-3/2 and Bohr-1.
Z=1
H
Nv = 1
β = 1.75
U = 12.848 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
1
0
-13.6
1
1.3
-
Nv = 2
β = 1.75
Z=2
He
HoffmannHuckelParameters.Helium_Basis
U = 9 eV
n
l
Eion
W1
η1
W2
1
0
-23.4
1
1.688
-
HoffmannNv = 1
HuckelParameters.Lithium_Basis
Z=3
Li
β = 1.75
U = 3.469
eV
η2
EVAC
= 0 eV
η2
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-5.4
1
0.65
-
-
2
1
-3.5
1
0.65
-
Nv = 2
β = 1.75
Z=4
Be
HoffmannHuckelParameters.Beryllium_Basis
U = 5.935
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-10
1
0.975
-
-
1
0.975
2
1
Z=5
B
-6
HoffmannHuckelParameters.Boron_Basis
Nv = 3
β = 1.75
U = 8 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-15.2
1
1.3
-
-
2
1
-8.5
1
1.3
-
Nv = 4
β = 1.75
Z=6
C
HoffmannHuckelParameters.Carbon_Basis
U = 10.207
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-21.4
1
1.625
-
-
2
1
-11.4
1
1.625
-
Z=7
N
26
HoffmannHuckelParameters.Hydrogen_Basis
HoffmannHuckelParameters.Nitrogen_Basis
Nv = 5
β = 1.75
U = 11.052
eV
EVAC
= 0 eV
Eion
W1
η1
W2
η2
0
-26
1
1.95
-
-
1
-13.4
1
1.95
-
-
n
l
2
2
The Extended-Hückel Parameters
Z=8
O
HoffmannHuckelParameters.Oxygen_Basis
Nv = 6
β = 1.75
U = 13.625 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
2
0
-32.3
1
2.275
-
-
2
1
-14.8
1
2.275
-
HoffmannNv = 7
HuckelParameters.Fluorine_Basis
Z=9
F
β = 1.75
U = 15.054
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-40
1
2.425
-
-
2
1
-18.1
1
2.425
-
Z = 10
Ne
HoffmannHuckelParameters.Neon_Basis
Nv = 8
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-43.2
1
2.879
-
-
2
1
-20
1
2.879
-
Z = 11
Na
HoffmannHuckelParameters.Sodium_Basis
Nv = 1
β = 1.75
U = 2.982
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-5.1
1
0.733
-
-
3
1
-3
1
0.733
-
Z = 12
Mg
HoffmannNv = 2
HuckelParameters.Magnesium_Basis
β = 1.75
U = 4.623
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-9
1
1.1
-
-
3
1
-4.5
1
1.1
-
Nv = 3
β = 1.75
Z = 13
Al
HoffmannHuckelParameters.Aluminium_Basis
U = 5.682
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-12.3
1
1.167
-
-
3
1
-6.5
1
1.167
-
Z = 14
Si
HoffmannHuckelParameters.Silicon_Basis
Nv = 4
β = 1.75
U = 6.964
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-17.3
1
1.383
-
-
27
The ATK-SE Package
3
Z = 15
P
1
HoffmannNv = 5
HuckelParameters.Phosphorus_Basis
1.383
β = 1.75
U = 9.878
eV
EVAC
= 0 eV
l
Eion
W1
η1
W2
η2
3
0
-18.6
1
1.75
-
-
3
1
-14
1
1.3
-
Nv = 6
β = 1.75
Z = 16
HoffmannHuckelParameters.Sulfur_Basis
U = 9.205
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-20
1
2.122
-
-
1
1.827
-
-
3
1
Z = 17
Cl
-11
HoffmannHuckelParameters.Chlorine_Basis
Nv = 7
β = 1.75
U = 10.292 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
3
0
-26.3
1
2.183
-
-
3
1
-14.2
1
1.733
-
Z = 19
K
HoffmannHuckelParameters.Potassium_Basis
Nv = 1
β = 1.75
U = 3.702
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-4.34
1
0.874
-
-
4
1
-2.73
1
0.874
-
Z = 20
Ca
HoffmannNv = 2
HuckelParameters.Calcium_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-7
1
1.2
-
-
4
1
-4
1
1.2
-
HoffmannNv = 3
HuckelParameters.Scandium_Basis
β = 1.75
Z = 21
Sc
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-8.87
1
1.3
-
-
4
1
-2.75
1
1.3
-
-
0.422783
4.35
3
28
-9.2
n
S
Ti
1
2
Z = 22
-8.51
HoffmannHuckelPara-
Nv = 4
β = 1.75
0.72757
U = 9 eV
1.7
EVAC = 0 eV
The Extended-Hückel Parameters
meters.Titanium_Basis
n
l
Eion
W1
η1
W2
η2
4
0
-8.97
1
1.075
-
-
4
1
-5.44
1
1.075
-
-
3
2
-10.81
0.420607
4.55
0.783913
Z = 23
V
HoffmannNv = 5
HuckelParameters.Vanadium_Basis
β = 1.75
U = 9 eV
1.4
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-8.81
1
1.3
-
-
4
1
-5.52
1
1.3
-
-
3
2
-11
0.475509
4.75
0.705213
Z = 24
Cr
HoffmannNv = 6
HuckelParameters.Chromium_Basis
β = 1.75
U = 9 eV
1.7
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-8.66
1
1.7
-
-
4
1
-5.24
1
1.7
-
-
3
2
-11.22
0.505792
4.95
0.674723
Z = 25
Mn
HoffmannNv = 7
HuckelParameters.Manganese_Basis
β = 1.75
U = 9 eV
1.8
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-9.75
1
0.97
-
-
4
1
-5.89
1
0.97
-
-
-11.67
0.513906
5.15
3
2
Z = 26
Fe
HoffmannNv = 8
HuckelParameters.Iron_Basis
β = 1.75
0.692909
U = 9 eV
1.7
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-9.1
1
1.9
-
-
4
1
-5.32
1
1.9
-
-
3
2
-12.6
0.5505
5.35
0.626
Z = 27
Co
HoffmannHuckelParameters.Cobalt_Basis
Nv = 9
β = 1.75
U = 9 eV
2
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-9.21
1
2
-
-
4
1
-5.29
1
2
-
-
3
2
-13.18
0.567865
5.55
0.605856
2.1
29
The ATK-SE Package
Z = 28
Ni
U = 9 eV
EVAC = 0 eV
l
Eion
W1
η1
W2
η2
4
0
-10.95
1
2.1
-
-
4
1
-6.27
1
2.1
-
-
3
2
-14.2
0.549306
5.75
0.60817
Z = 29
HoffmannHuckelParameters.Copper_Basis
Nv = 11
β = 1.75
U = 9 eV
2.3
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-11.4
1
2.2
-
-
4
1
-6.06
1
2.2
-
-
-14
0.593322
5.95
3
2
Z = 30
Zn
HoffmannNv = 12
HuckelParameters.Zinc_Basis
β = 1.75
0.574421
U = 9 eV
2.3
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-12.41
1
2.01
-
-
4
1
-6.53
1
1.7
-
HoffmannNv = 3
HuckelParameters.Gallium_Basis
β = 1.75
Z = 31
Ga
U = 5.936
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-14.58
1
1.77
-
-
4
1
-6.75
1
1.55
-
HoffmannNv = 4
HuckelParameters.Germanium_Basis
β = 1.75
Z = 32
Ge
U = 6.608
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-16
1
2.16
-
-
4
1
-9
1
1.85
-
Nv = 5
β = 1.75
Z = 33
As
30
β = 1.75
n
Cu
Se
HoffmannNv = 10
HuckelParameters.Nickel_Basis
HoffmannHuckelParameters.Arsenic_Basis
U = 8.399
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-16.22
1
2.23
-
-
4
1
-12.16
1
1.89
-
Nv = 6
β = 1.75
Z = 34
HoffmannHuckelParameters.Selenium_Basis
U = 9.121
eV
EVAC
= 0 eV
The Extended-Hückel Parameters
n
l
Eion
W1
η1
W2
η2
4
0
-20.5
1
2.44
-
-
4
1
-14.4
1
2.07
-
Nv = 7
β = 1.75
Z = 35
Br
HoffmannHuckelParameters.Bromine_Basis
U = 8.823
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-22.07
1
2.588
-
-
4
1
-13.1
1
2.131
-
Z = 37
Rb
HoffmannNv = 1
HuckelParameters.Rubidium_Basis
β = 1.75
U = 2.495
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-4.18
1
0.997
-
-
5
1
-2.6
1
0.997
-
Z = 38
Sr
HoffmannHuckelParameters.Strontium_Basis
Nv = 2
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-6.62
1
1.214
-
-
5
1
-3.92
1
1.214
-
Z = 40
Zr
HoffmannHuckelParameters.Zirconium_Basis
Nv = 4
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-9.87
1
1.817
-
-
5
1
-6.76
1
1.776
-
-
4
2
-11.18
0.622416
3.835
0.578216
1.505
Z = 41
Nb
HoffmannHuckelParameters.Niobium_Basis
Nv = 5
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-10.1
1
1.89
-
-
5
1
-6.86
1
1.85
-
-
4
2
-12.1
0.640101
4.08
0.551601
Z = 42
Mo
HoffmannHuckelParameters.Molybdenum_Basis
Nv = 6
β = 1.75
U = 9 eV
1.64
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-8.34
1
1.96
-
-
5
1
-5.24
1
1.9
-
-
31
The ATK-SE Package
4
Z = 43
Tc
-10.5
0.589879
HoffmannNv = 7
HuckelParameters.Technetium_Basis
4.54
β = 1.75
0.589879
U = 9 eV
1.9
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-10.07
1
2.018
-
-
5
1
-5.4
1
1.984
-
-
-12.82
0.5715
4.9
4
2
Z = 44
Ru
HoffmannNv = 8
HuckelParameters.Ruthenium_Basis
β = 1.75
0.6012
U = 9 eV
2.094
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-10.4
1
2.08
-
-
5
1
-6.87
1
2.04
-
-
4
2
-14.9
0.534242
5.38
0.636789
Z = 45
Rh
HoffmannHuckelParameters.Rhodium_Basis
Nv = 9
β = 1.75
U = 9 eV
2.3
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-8.09
1
2.135
-
-
5
1
-4.57
1
2.1
-
-
4
2
-12.5
0.580698
4.29
0.568498
1.97
Z = 46
Pd
HoffmannNv = 10
HuckelParameters.Palladium_Basis
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-7.32
1
2.19
-
-
5
1
-3.75
1
2.152
-
-
4
2
-12.02
0.526436
5.983
0.637334
Z = 48
Cd
HoffmannHuckelParameters.Cadmium_Basis
Nv = 12
β = 1.75
U = 9 eV
2.613
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-11.8
1
1.64
-
-
1
1.6
Nv = 3
β = 1.75
5
1
Z = 49
In
32
2
-8.2
HoffmannHuckelParameters.Indium_Basis
-
-
U = 5.53 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-12.6
1
1.903
-
-
5
1
-6.19
1
1.677
-
-
The Extended-Hückel Parameters
Z = 50
Sn
HoffmannHuckelParameters.Tin_Basis
Nv = 4
β = 1.75
U = 4.297 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
5
0
-16.16
1
2.12
-
-
5
1
-8.32
1
1.82
-
Nv = 5
β = 1.75
Z = 51
Sb
HoffmannHuckelParameters.Antimony_Basis
U = 7.657
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-18.8
1
2.323
-
-
5
1
-11.7
1
1.999
-
Z = 52
Te
HoffmannNv = 6
HuckelParameters.Tellurium_Basis
β = 1.75
U = 8.985
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-20.8
1
2.51
-
-
5
1
-14.8
1
2.16
-
Nv = 7
β = 1.75
Z = 53
I
HoffmannHuckelParameters.Iodine_Basis
U = 9.448
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-18
1
2.679
-
-
5
1
-12.7
1
2.322
-
Z = 55
Cs
HoffmannHuckelParameters.Caesium_Basis
Nv = 1
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-3.88
1
1.06
-
-
6
1
-2.49
1
1.06
-
Nv = 3
β = 1.75
Z = 57
La
HoffmannHuckelParameters.Lanthanum_Basis
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-7.67
1
2.14
-
-
6
1
-5.01
1
2.08
-
-
5
2
-8.21
0.776515
3.78
0.458609
Z = 58
Ce
n
l
HoffmannHuckelParameters.Cerium_Basis
Eion
Nv = 4
W1
β = 1.75
η1
U = 9 eV
W2
1.381
EVAC
= 0 eV
η2
33
The ATK-SE Package
6
0
-4.97
1
1.799
-
-
6
1
-4.97
1
1.799
-
-
5
2
-6.43
1
2.747
-
-
4
3
-11.28
1
3.907
-
Z = 62
Sm
Nv = 8
β = 1.75
U = 9 eV
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.86
1
1.4
-
-
6
1
-4.86
1
1.4
-
-
5
2
-6.06
0.718435
2.747
0.444722
1.267
4
3
-11.28
0.735406
6.907
0.459703
Z = 64
Gd
HoffmannHuckelParameters.Gadolinium_Basis
β = 1.75
U = 9 eV
= 0 eV
η1
-5.44
1
1.369
-
-
-6.06
0.718435
2.747
0.444722
1.267
-11.28
0.735406
6.907
0.459703
l
Eion
6
0
5
2
4
3
Z = 70
Nv = 10
2.639
EVAC
W1
n
Yb
HoffmannHuckelParameters.Ytterbium_Basis
Nv = 16
β = 1.75
η2
W2
U = 9 eV
2.639
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-5.35
1
1.54
-
-
6
1
-5.35
1
1.54
-
-
5
2
-5.21
0.706344
2.81
0.48343
1.216
4
3
-13.86
0.746226
8.629
0.456538
Z = 71
Lu
HoffmannNv = 17
HuckelParameters.Lutetium_Basis
β = 1.75
U = 9 eV
3.198
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-6.05
1
1.666
-
-
6
1
-6.05
1
1.666
-
-
5
2
-5.12
0.704411
2.813
0.488008
1.21
0.733001
9.136
4
3
Z = 72
Hf
34
HoffmannHuckelParameters.Samarium_Basis
EVAC
-22.4
HoffmannHuckelParameters.Hafnium_Basis
Nv = 4
β = 1.75
0.445901
U = 9 eV
3.666
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.84
1
1.527
-
-
The Extended-Hückel Parameters
Z = 73
Ta
HoffmannHuckelParameters.Tantalum_Basis
Nv = 5
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-10.1
1
2.28
-
-
6
1
-6.86
1
2.241
-
-
5
2
-12.1
0.610612
4.762
0.610612
Z = 74
W
HoffmannNv = 6
HuckelParameters.Tungsten_Basis
β = 1.75
U = 9 eV
1.938
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-8.26
1
2.341
-
-
6
1
-5.17
1
2.309
-
-
0.668535
4.982
5
2
Z = 75
Re
-10.37
HoffmannHuckelParameters.Rhenium_Basis
Nv = 7
β = 1.75
0.542438
U = 9 eV
2.068
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-9.36
1
2.398
-
-
6
1
-5.96
1
2.372
-
-
5
2
-12.66
0.637752
5.343
0.565763
Z = 76
Os
HoffmannHuckelParameters.Osmium_Basis
Nv = 8
β = 1.75
U = 9 eV
2.277
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-8.17
1
2.452
-
-
6
1
-4.81
1
2.429
-
-
5
2
-11.84
0.637195
5.571
0.559795
Z = 77
Ir
HoffmannHuckelParameters.Iridium_Basis
Nv = 9
β = 1.75
U = 9 eV
2.416
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-11.36
1
2.5
-
-
6
1
-4.5
1
2.2
-
-
5
2
-12.17
0.635059
5.796
0.555605
Z = 78
Pt
HoffmannNv = 10
HuckelParameters.Platinum_Basis
β = 1.75
U = 8.604
eV
2.557
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-9.077
1
2.554
-
-
6
1
-5.475
1
2.554
-
-
5
2
-12.59
0.633378
6.013
0.551281
2.696
35
The ATK-SE Package
Z = 79
Au
Nv = 11
β = 1.75
U = 8.604 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
6
0
-10.92
1
2.602
-
-
6
1
-5.55
1
2.584
-
-
5
2
-15.07
0.644177
6.163
0.535576
Z = 80
Hg
HoffmannHuckelParameters.Mercury_Basis
Nv = 12
β = 1.75
U = 9 eV
2.794
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-13.68
1
2.649
-
-
6
1
-8.47
1
2.631
-
-
5
2
-17.5
0.643776
6.436
0.521481
3.032
Z = 81
Tl
HoffmannNv = 3
HuckelParameters.Thallium_Basis
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-11.6
1
2.3
-
-
6
1
-5.8
1
1.6
-
Nv = 4
β = 1.75
Z = 82
Pb
HoffmannHuckelParameters.Lead_B
asis
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-15.7
1
2.35
-
-
6
1
-8
1
2.06
-
-
Nv = 5
β = 1.75
Z = 83
Bi
HoffmannHuckelParameters.Bismuth_Basis
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-15.19
1
2.56
-
-
6
1
-7.79
1
2.072
-
Z = 90
Th
36
HoffmannHuckelParameters.Gold_B
asis
HoffmannHuckelParameters.Thorium_Basis
Nv = 0
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
3
-9.64
0.768182
4.477
0.42669
1.837
7
0
-5.39
1
1.834
-
-
7
1
-5.39
1
1.834
-
-
6
2
-10.11
0.761171
2.461
0.407085
1.165
5
3
-9.64
0.768182
4.477
0.42669
1.837
The Extended-Hückel Parameters
Z = 92
U
HoffmannHuckelParameters.Uranium_Basis
Nv = 0
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
7
0
-5.5
1
1.914
-
-
7
1
-5.5
1
1.914
-
-
6
2
-9.19
0.760793
2.581
0.412596
1.207
5
3
-10.62
0.784411
4.943
0.390806
2.106
Table 2.4: The Müller-Hückel basis set parameters. The unit of Eion is eV, where as the respective units of wi and ηi
are Bohr-3/2 and Bohr-1.
Z=1
H
MullerHuckelParameters.Hydrogen_Basis
Nv = 1
β = 1.75
U = 12.848 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
1
0
-13.606
1
1
-
Z=2
He
MullerHuckelParameters.Helium_Basis
Nv = 2
β = 1.75
U = 9 eV
n
l
Eion
W1
η1
W2
1
0
-24.979
1
1.618
-
MullerNv = 1
HuckelParameters.Lithium_Basis
Z=3
Li
β = 1.75
U = 3.469
eV
η2
EVAC
= 0 eV
η2
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-5.342
1
0.645
-
-
2
1
-3.499
1
0.524
-
Z=4
Be
MullerHuckelParameters.Beryllium_Basis
Nv = 2
β = 1.75
U = 5.935
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-8.416
1
0.944
-
-
2
1
-5.632
1
0.875
-
Z=5
B
MullerHuckelParameters.Boron_Basis
Nv = 3
β = 1.75
U = 8 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-13.462
1
1.265
-
-
2
1
-8.432
1
1.134
-
-
Z=6
C
n
MullerHuckelParameters.Carbon_Basis
l
Eion
Nv = 4
W1
β = 1.75
η1
U = 10.207 EVAC = 0 eV
eV
W2
η2
37
The ATK-SE Package
2
0
-19.376
1
1.576
-
2
1
-11.072
1
1.435
-
Z=7
N
β = 1.75
U = 11.052
eV
= 0 eV
l
Eion
W1
η1
W2
η2
2
0
-26.223
1
1.885
-
-
1
1.728
-
-
2
1
Z=8
-13.841
MullerHuckelParameters.Oxygen_Basis
Nv = 6
β = 1.75
U = 13.625 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
2
0
-34.024
1
2.192
-
-
2
1
-16.768
1
2.018
-
MullerNv = 7
HuckelParameters.Fluorine_Basis
Z=9
F
β = 1.75
U = 15.054
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-42.791
1
2.497
-
-
2
1
-19.865
1
2.305
-
Z = 10
Ne
MullerHuckelParameters.Neon_Basis
Nv = 8
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
2
0
-52.529
1
2.802
-
-
2
1
-23.141
1
2.59
-
Nv = 1
β = 1.75
Z = 11
Na
MullerHuckelParameters.Sodium_Basis
U = 2.982
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-4.955
1
0.832
-
-
3
1
-2.976
1
0.611
-
-
Z = 12
Mg
38
Nv = 5
EVAC
n
O
Al
MullerHuckelParameters.Nitrogen_Basis
-
MullerNv = 2
HuckelParameters.Magnesium_Basis
β = 1.75
U = 4.623 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
3
0
-6.886
1
1.076
-
-
3
1
-4.169
1
0.862
-
Z = 13
MullerHuckelParameters.Alu-
Nv = 3
β = 1.75
U = 5.682
eV
EVAC
= 0 eV
The Extended-Hückel Parameters
minium_Basis
n
l
Eion
W1
η1
W2
η2
3
0
-10.706
1
1.347
-
-
3
1
-5.713
1
1.019
-
Z = 14
Si
MullerHuckelParameters.Silicon_Basis
Nv = 4
β = 1.75
U = 6.964
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-14.792
1
1.588
-
-
3
1
-7.585
1
1.256
-
Z = 15
P
MullerNv = 5
HuckelParameters.Phosphorus_Basis
β = 1.75
U = 9.878
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-19.221
1
1.816
-
-
3
1
-9.539
1
1.478
-
-
Z = 16
S
MullerHuckelParameters.Sulfur_Basis
Nv = 6
β = 1.75
U = 9.205 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
3
0
-24.019
1
2.035
-
-
3
1
-11.601
1
1.691
-
Z = 17
Cl
MullerHuckelParameters.Chlorine_Basis
Nv = 7
β = 1.75
U = 10.292
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-29.196
1
2.25
-
-
1
1.9
Nv = 8
β = 1.75
3
1
Z = 18
Ar
-13.78
MullerHuckelParameters.Argon_Basis
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
3
0
-34.759
1
2.461
-
-
3
1
-16.083
1
2.105
-
Z = 19
K
MullerHuckelParameters.Potassium_Basis
Nv = 1
β = 1.75
U = 3.702
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-4.013
1
0.858
-
-
4
1
-2.599
1
0.671
-
-
39
The ATK-SE Package
3
Z = 20
Ca
-1.581
1
MullerNv = 2
HuckelParameters.Calcium_Basis
0.364
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-5.321
1
1.067
-
-
4
1
-3.573
1
0.893
-
-
3
2
-3.337
1
1.906
-
Z = 21
Sc
MullerNv = 3
HuckelParameters.Scandium_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-5.717
1
1.136
-
-
4
1
-3.739
1
0.951
-
-
3
2
-9.353
0.4599
3.807
0.701847
1.455
Z = 22
Ti
MullerHuckelParameters.Titanium_Basis
Nv = 4
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-6.039
1
1.195
-
-
4
1
-3.863
1
0.998
-
-
3
2
-11.043
0.468935
4.218
0.685904
Z = 23
V
MullerNv = 5
HuckelParameters.Vanadium_Basis
β = 1.75
U = 9 eV
1.664
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-6.325
1
1.248
-
-
4
1
-3.963
1
1.041
-
-
-12.549
0.474002
4.6
3
2
Z = 24
Cr
MullerNv = 6
HuckelParameters.Chromium_Basis
β = 1.75
0.677004
U = 9 eV
1.846
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-6.583
1
1.296
-
-
4
1
-4.042
1
1.077
-
-
3
2
-13.909
0.474986
4.978
0.67298
Z = 25
Mn
40
2
MullerNv = 7
HuckelParameters.Manganese_Basis
β = 1.75
U = 9 eV
2.022
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-6.84
1
1.344
-
-
4
1
-4.12
1
1.113
-
-
The Extended-Hückel Parameters
3
2
Z = 26
Fe
-15.27
0.480857
MullerNv = 8
HuckelParameters.Iron_Basis
5.318
β = 1.75
0.665802
U = 9 eV
2.176
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-7.079
1
1.388
-
-
4
1
-4.183
1
1.145
-
-
0.484872
5.653
3
2
Z = 27
Co
-16.541
MullerHuckelParameters.Cobalt_Basis
Nv = 9
β = 1.75
0.660825
U = 9 eV
2.325
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-7.309
1
1.431
-
-
4
1
-4.237
1
1.174
-
-
3
2
-17.77
0.485886
5.996
0.658846
Z = 28
Ni
MullerNv = 10
HuckelParameters.Nickel_Basis
β = 1.75
U = 9 eV
2.476
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-7.532
1
1.473
-
-
4
1
-4.284
1
1.203
-
-
3
2
-18.969
0.486001
6.339
0.658001
Z = 29
Cu
MullerHuckelParameters.Copper_Basis
Nv = 11
β = 1.75
U = 9 eV
2.625
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-7.755
1
1.515
-
-
4
1
-4.331
1
1.232
-
-
3
2
-20.188
0.486895
6.676
0.656859
Z = 30
Zn
MullerNv = 12
HuckelParameters.Zinc_Basis
β = 1.75
U = 9 eV
2.768
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-7.96
1
1.553
-
-
4
1
-4.361
1
1.251
-
-
3
2
-21.294
0.48724
7.015
0.656323
2.911
Z = 31
Ga
MullerNv = 3
HuckelParameters.Gallium_Basis
β = 1.75
U = 5.936 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
4
0
-11.554
1
1.808
-
-
41
The ATK-SE Package
4
Z = 32
Ge
1
MullerNv = 4
HuckelParameters.Germanium_Basis
1.314
β = 1.75
U = 6.608
eV
EVAC
= 0 eV
l
Eion
W1
η1
W2
η2
4
0
-15.158
1
2.024
-
-
4
1
-7.329
1
1.55
-
Nv = 5
β = 1.75
Z = 33
MullerHuckelParameters.Arsenic_Basis
U = 8.399
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-18.916
1
2.222
-
-
1
1.757
-
-
4
1
Z = 34
Se
-8.984
MullerHuckelParameters.Selenium_Basis
Nv = 6
β = 1.75
U = 9.121 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
4
0
-22.862
1
2.409
-
-
4
1
-10.681
1
1.949
-
Z = 35
Br
MullerHuckelParameters.Bromine_Basis
Nv = 7
β = 1.75
U = 8.823
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-27.013
1
2.588
-
-
4
1
-12.438
1
2.131
-
Z = 36
Kr
MullerNv = 8
HuckelParameters.Krypton_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
4
0
-31.373
1
2.762
-
-
-14.264
1
2.306
-
-
4
1
Z = 37
Rb
42
-5.674
n
As
Sr
1
MullerNv = 1
HuckelParameters.Rubidium_Basis
β = 1.75
U = 2.495 EVAC = 0 eV
eV
n
l
Eion
W1
η1
W2
η2
5
0
-3.752
1
0.977
-
-
5
1
-2.452
1
0.774
-
-
4
2
-1.636
1
0.523
-
Z = 38
MullerHuckelParameters.Strontium_Basis
Nv = 2
β = 1.75
U = 9 eV
EVAC
= 0 eV
The Extended-Hückel Parameters
n
l
Eion
W1
η1
W2
η2
5
0
-4.856
1
1.187
-
-
5
1
-3.299
1
1
-
-
4
2
-3.179
1
1.694
-
Z = 39
Y
β = 1.75
U = 9 eV
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-5.337
1
1.279
-
-
5
1
-3.515
1
1.079
-
-
4
2
-6.799
0.601963
2.554
0.577964
Z = 40
Zr
MullerHuckelParameters.Zirconium_Basis
Nv = 4
β = 1.75
U = 9 eV
1.068
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-5.735
1
1.36
-
-
5
1
-3.694
1
1.151
-
-
4
2
-8.461
0.650366
2.769
0.508286
Z = 41
Nb
MullerHuckelParameters.Niobium_Basis
Nv = 5
β = 1.75
U = 9 eV
1.224
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-5.923
1
1.403
-
-
5
1
-3.757
1
1.186
-
-
4
2
-10.001
0.685854
2.955
0.461902
1.333
Z = 42
Mo
MullerHuckelParameters.Molybdenum_Basis
Nv = 6
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-6.112
1
1.446
-
-
5
1
-3.819
1
1.221
-
-
4
2
-11.541
0.71711
3.126
0.426065
Z = 43
Tc
Ru
MullerNv = 3
HuckelParameters.Yttrium_Basis
EVAC
MullerNv = 7
HuckelParameters.Technetium_Basis
β = 1.75
U = 9 eV
1.408
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-6.3
1
1.49
-
-
5
1
-3.882
1
1.256
-
-
4
2
-13.08
0.742534
3.293
0.39875
Z = 44
MullerHuckelPara-
Nv = 8
β = 1.75
U = 9 eV
1.468
EVAC
= 0 eV
43
The ATK-SE Package
meters.Ruthenium_Basis
n
l
Eion
W1
η1
W2
η2
5
0
-6.488
1
1.533
-
-
5
1
-3.945
1
1.291
-
-
4
2
-14.62
0.779822
3.429
0.367916
Z = 45
Rh
β = 1.75
U = 9 eV
= 0 eV
l
Eion
W1
η1
W2
η2
5
0
-6.677
1
1.576
-
-
5
1
-4.008
1
1.326
-
-
4
2
-16.16
0.80486
3.577
0.347939
1.452
Z = 46
MullerNv = 10
HuckelParameters.Palladium_Basis
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-6.865
1
1.619
-
-
5
1
-4.07
1
1.362
-
-
4
2
-17.7
0.814894
3.746
0.337956
Z = 47
Ag
MullerHuckelParameters.Silver_Basis
Nv = 11
β = 1.75
U = 9 eV
1.501
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-7.054
1
1.662
-
-
5
1
-4.133
1
1.397
-
-
0.824441
3.912
4
2
Z = 48
Cd
-19.24
MullerHuckelParameters.Cadmium_Basis
Nv = 12
β = 1.75
0.328777
U = 9 eV
1.545
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-7.242
1
1.706
-
-
5
1
-4.196
1
1.432
-
-
4
2
-20.78
0.823957
4.094
0.324983
Z = 49
In
44
Nv = 9
n
Pd
Sn
MullerHuckelParameters.Rhodium_Basis
1.453
EVAC
MullerHuckelParameters.Indium_Basis
Nv = 3
β = 1.75
U = 5.53 eV
1.64
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-10.141
1
1.934
-
-
5
1
-5.368
1
1.456
-
Z = 50
MullerHuckelParame-
Nv = 4
β = 1.75
U = 4.297
eV
EVAC
= 0 eV
The Extended-Hückel Parameters
ters.Tin_Basis
n
l
Eion
W1
η1
W2
η2
5
0
-13.043
1
2.129
-
-
5
1
-6.764
1
1.674
-
Z = 51
Sb
MullerHuckelParameters.Antimony_Basis
Nv = 5
β = 1.75
U = 7.657
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-16.026
1
2.305
-
-
5
1
-8.143
1
1.863
-
Z = 52
Te
MullerNv = 6
HuckelParameters.Tellurium_Basis
β = 1.75
U = 8.985
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-19.122
1
2.47
-
-
5
1
-9.54
1
2.036
-
Z = 53
I
MullerHuckelParameters.Iodine_Basis
Nv = 7
β = 1.75
U = 9.448
eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-22.344
1
2.626
-
-
1
2.198
5
1
Z = 54
Xe
-10.971
MullerHuckelParameters.Xenon_Basis
Nv = 8
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
5
0
-25.699
1
2.776
-
-
5
1
-12.444
1
2.352
-
Z = 55
Cs
MullerHuckelParameters.Caesium_Basis
Nv = 1
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-3.365
1
1.031
-
-
6
1
-2.286
1
0.845
-
-
5
2
-1.844
1
0.906
-
Z = 56
Ba
MullerHuckelParameters.Barium_Basis
Nv = 2
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.287
1
1.236
-
-
6
1
-3.063
1
1.071
-
-
5
2
-4.143
1
1.96
-
-
45
The ATK-SE Package
Z = 57
La
Nv = 3
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.637
1
1.318
-
-
6
1
-3.233
1
1.142
-
-
5
2
-7.316
0.593989
3.153
0.611989
Z = 58
Ce
MullerHuckelParameters.Cerium_Basis
Nv = 4
β = 1.75
U = 9 eV
1.338
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.697
1
1.335
-
-
6
1
-3.261
1
1.157
-
-
5
2
-7.359
1
2.027
-
-
4
3
-11.95
1
4.22
-
Nv = 5
β = 1.75
Z = 59
Pr
MullerHuckelParameters.Praseodymium_Basis
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.466
1
1.288
-
-
6
1
-3.29
1
1.127
-
-
5
2
-7.376
1
2.055
-
-
4
3
-12.94
1
4.415
-
Z = 60
Nd
MullerNv = 6
HuckelParameters.Neodymium_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.518
1
1.303
-
-
6
1
-3.318
1
1.187
-
-
5
2
-7.373
1
2.08
-
-
4
3
-13.892
1
4.619
-
Z = 61
Pm
46
MullerHuckelParameters.Lanthanum_Basis
MullerHuckelParameters.Promethium_Basis
Nv = 7
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.586
1
1.317
-
-
6
1
-3.346
1
1.201
-
-
5
2
-7.353
1
2.103
-
-
4
3
-14.901
1
4.81
-
-
The Extended-Hückel Parameters
Z = 62
Sm
MullerHuckelParameters.Samarium_Basis
Nv = 8
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.616
1
1.331
-
-
6
1
-3.375
1
1.216
-
-
5
2
-7.32
1
2.122
-
-
-15.719
1
4.991
4
3
Z = 63
Eu
MullerNv = 9
HuckelParameters.Europium_Basis
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.663
1
1.345
-
-
6
1
-3.403
1
1.231
-
-
5
2
-7.276
1
2.14
-
-
4
3
-16.451
1
5.165
-
Z = 64
Gd
MullerHuckelParameters.Gadolinium_Basis
Nv = 10
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-5.033
1
1.427
-
-
6
1
-3.431
1
1.246
-
-
5
2
-7.22
1
2.155
-
-
4
3
-17.079
1
5.33
-
Z = 65
Tb
MullerHuckelParameters.Terbium_Basis
Nv = 11
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.753
1
1.371
-
-
6
1
-3.46
1
1.261
-
-
5
2
-7.156
1
2.169
-
-
4
3
-17.707
1
5.495
-
Z = 66
Dy
MullerNv = 12
HuckelParameters.Dysprosium_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.797
1
1.383
-
-
6
1
-3.488
1
1.276
-
-
5
2
-7.084
1
2.181
-
-
4
3
-18.246
1
5.654
-
-
47
The ATK-SE Package
Z = 67
Ho
β = 1.75
U = 9 eV
EVAC = 0 eV
l
Eion
W1
η1
W2
η2
6
0
-4.84
1
1.396
-
-
6
1
-3.516
1
1.291
-
-
5
2
-7.004
1
2.19
-
-
4
3
-18.733
1
5.808
-
Z = 68
MullerHuckelParameters.Erbium_Basis
Nv = 14
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.882
1
1.408
-
-
6
1
-3.545
1
1.306
-
-
5
2
-6.917
1
2.199
-
-
4
3
-19.174
1
5.96
-
Z = 69
Tm
MullerNv = 15
HuckelParameters.Thulium_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.924
1
1.42
-
-
6
1
-3.573
1
1.32
-
-
5
2
-6.824
1
2.205
-
-
1
6.109
4
3
Z = 70
Yb
-19.571
MullerHuckelParameters.Ytterbium_Basis
Nv = 16
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-4.965
1
1.432
-
-
6
1
-3.601
1
1.335
-
-
5
2
-6.726
1
2.21
-
-
4
3
-19.929
1
6.256
-
Z = 71
Lu
48
Nv = 13
n
Er
Hf
MullerHuckelParameters.Holmium_Basis
MullerNv = 17
HuckelParameters.Lutetium_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-5.411
1
1.526
-
-
6
1
-3.63
1
1.35
-
-
5
2
-6.622
1
2.213
-
-
4
3
-20.313
1
6.404
-
Z = 72
MullerHuckelPara-
Nv = 4
β = 1.75
U = 9 eV
EVAC
= 0 eV
The Extended-Hückel Parameters
meters.Hafnium_Basis
n
l
Eion
W1
η1
W2
η2
6
0
-5.725
1
1.598
-
-
6
1
-3.658
1
1.365
-
-
5
2
-8.141
0.636594
3.337
0.545652
Z = 73
Ta
Nv = 5
β = 1.75
U = 9 eV
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-5.979
1
1.658
-
-
6
1
-3.757
1
1.417
-
-
5
2
-9.569
0.673894
3.478
0.495922
Z = 74
W
MullerNv = 6
HuckelParameters.Tungsten_Basis
β = 1.75
U = 9 eV
1.606
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-6.196
1
1.711
-
-
6
1
-3.836
1
1.463
-
-
5
2
-10.963
0.705262
3.609
0.456169
Z = 75
Re
MullerHuckelParameters.Rhenium_Basis
Nv = 7
β = 1.75
U = 9 eV
1.683
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-6.386
1
1.76
-
-
6
1
-3.902
1
1.503
-
-
5
2
-12.348
0.732016
3.734
0.424009
Z = 76
Os
MullerHuckelParameters.Osmium_Basis
Nv = 8
β = 1.75
U = 9 eV
1.742
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-6.556
1
1.804
-
-
6
1
-3.958
1
1.54
-
-
5
2
-13.737
0.757831
3.851
0.394912
1.782
Z = 77
Ir
Pt
MullerHuckelParameters.Tantalum_Basis
1.505
EVAC
MullerHuckelParameters.Iridium_Basis
Nv = 9
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-6.71
1
1.845
-
-
6
1
-4.006
1
1.574
-
-
5
2
-15.136
0.779917
3.968
0.37096
Z = 78
MullerHuckelPara-
Nv = 10
β = 1.75
U = 8.604
eV
1.813
EVAC
= 0 eV
49
The ATK-SE Package
meters.Platinum_Basis
n
l
Eion
W1
η1
W2
η2
6
0
-6.875
1
1.888
-
-
6
1
-4.034
1
1.593
-
-
5
2
-16.528
0.79785
4.084
0.351934
Z = 79
Au
Nv = 11
β = 1.75
U = 8.604
eV
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-7.037
1
1.931
-
-
6
1
-4.068
1
1.615
-
-
5
2
-17.922
0.813667
4.2
0.335863
1.861
Z = 80
Hg
MullerHuckelParameters.Mercury_Basis
Nv = 12
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-7.104
1
1.953
-
-
6
1
-4.117
1
1.66
-
-
5
2
-19.434
0.809955
4.353
0.331981
Z = 81
Tl
MullerNv = 3
HuckelParameters.Thallium_Basis
β = 1.75
U = 9 eV
1.979
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-9.827
1
2.191
-
-
6
1
-5.235
1
1.656
-
Z = 82
Pb
MullerHuckelParameters.Lead_B
asis
Nv = 4
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-12.486
1
2.386
-
-
6
1
-6.527
1
1.88
-
Nv = 5
β = 1.75
Z = 83
Bi
MullerHuckelParameters.Bismuth_Basis
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-15.189
1
2.56
-
-
6
1
-7.788
1
2.072
-
Z = 84
Po
n
50
MullerHuckelParameters.Gold_B
asis
1.84
EVAC
l
MullerNv = 6
HuckelParameters.Polonium_Basis
Eion
W1
β = 1.75
η1
U = 9 eV
W2
EVAC
= 0 eV
η2
The Extended-Hückel Parameters
6
0
-17.965
1
2.72
-
6
1
-9.053
1
2.245
-
Z = 85
At
MullerNv = 7
HuckelParameters.Astatine_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-20.827
1
2.87
-
-
6
1
-10.337
1
2.45
-
Nv = 8
β = 1.75
Z = 86
Rn
MullerHuckelParameters.Radon_Basis
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
6
0
-23.783
1
3.014
-
-
-11.647
1
2.556
6
1
Z = 87
Fr
MullerNv = 1
HuckelParameters.Francium_Basis
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
7
0
-3.209
1
1.131
-
-
7
1
-2.205
1
0.939
-
-
6
2
-1.931
1
1.258
-
Z = 88
Ra
MullerNv = 2
HuckelParameters.Radium_Basis
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
7
0
-4.048
1
1.346
-
-
7
1
-2.934
1
1.177
-
-
6
2
-4.108
1
2.113
-
Z = 89
Ac
MullerHuckelParameters.Actinium_Basis
Nv = 3
β = 1.75
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
7
0
-4.381
1
1.433
-
-
7
1
-3.098
1
1.253
-
-
6
2
-6.843
1
2.12
-
Nv = 4
β = 1.75
Z = 90
Th
MullerHuckelParameters.Thorium_Basis
U = 9 eV
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
7
0
-5.31
1
1.742
-
-
7
1
-3.345
1
1.256
-
-
6
2
-4.98
0.624003
2.811
0.503002
1.554
5
3
-6.03
0.58187
5.475
0.547877
2.863
51
The ATK-SE Package
Z = 91
Pa
Nv = 5
β = 1.75
U = 9 eV
EVAC = 0 eV
n
l
Eion
W1
η1
W2
η2
7
0
-5.41
1
1.699
-
-
7
1
-3.375
1
1.286
-
-
6
2
-5.07
0.617317
2.894
0.511263
1.595
0.594817
5.659
5
3
Z = 92
U
-7.63
MullerHuckelParameters.Uranium_Basis
Nv = 6
β = 1.75
0.530836
U = 9 eV
2.991
EVAC = 0 eV
Eion
W1
η1
W2
η2
0
-5.51
1
1.728
-
-
1
-3.406
1
1.315
-
-
6
2
-5.1
0.622063
2.944
0.509052
1.611
5
3
-9.045
0.592502
5.885
0.530449
n
l
7
7
Z = 93
Np
MullerHuckelParameters.Neptunium_Basis
Nv = 7
β = 1.75
U = 9 eV
3.135
EVAC
= 0 eV
Eion
W1
η1
W2
η2
0
-5.61
1
1.756
-
-
1
-3.436
1
1.345
-
-
6
2
-5.095
0.615803
3.017
0.516835
1.646
5
3
-10.35
0.519698
3.254
0.600651
n
l
7
7
Z = 94
Pu
MullerHuckelParameters.Plutonium_Basis
Nv = 8
β = 1.75
U = 9 eV
6.068
EVAC
= 0 eV
Eion
W1
η1
W2
η2
0
-5.71
1
1.681
-
-
1
-3.467
1
1.375
-
-
6
2
-5.06
0.609204
3.085
0.525176
1.677
5
3
-11.585
0.509646
3.364
0.608577
n
l
7
7
Z = 95
Am
52
MullerHuckelParameters.Protactinium_Basis
MullerNv = 9
HuckelParameters.Americium_Basis
β = 1.75
U = 9 eV
6.241
EVAC
= 0 eV
n
l
Eion
W1
η1
W2
η2
7
0
-5.8
1
1.704
-
-
7
1
-3.497
1
1.405
-
-
6
2
-5.01
0.596362
3.169
0.539327
1.719
5
3
-12.75
0.496199
3.457
0.620249
6.392
The Extended-Hückel Parameters
Table 2.5: The Cerda-Hückel basis set parameters. The unit of Eion is eV, where as the respective units of wi and ηi
are Bohr-3/2 and Bohr-1.
Z=1
H
CerdaHuckelParameters.Hydrogen_C2H4_
Basis
Reference structure: C2H4
n
l
1
0
-17.8384
Z=5
β = 2.3
U = 12.848 EVAC
=
eV
-6.2568 eV
Computational model: LDA-DFT
Eion
B
Nv = 1
CerdaHuckelParameters.Boron_BN_wur
tz_Basis
Reference structure: BN wurtz
W1
η1
W2
0.50494
0.87223
-
Nv = 3
β = 2.3
U = 8 eV
η2
EVAC
= -6 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
2
0
-22.6243
0.66811
1.60645
-
-
2
1
-16.6839
0.87705
1.63627
-
-
3
2
-9.36241
0.70894
0.89284
-
Z=5
B
CerdaHuckelParameters.Boron_BN_hexag_Basis
Reference structure: BN hexag
Nv = 3
β = 2.3
U = 8 eV
EVAC
= -6 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
2
0
-21.7174
0.66811
1.60645
-
-
2
1
-14.1676
0.99022
1.63627
-
-
3
2
-5.55352
0.6544
0.89284
-
Z=6
C
CerdaHuckelParameters.Carbon_graphite_Basis
Reference structure: graphite
Nv = 4
β = 2.8
EVAC
U = 10.207
=
eV
-7.36577 eV
Computational model: LDA-DFT
η1
η2
n
l
Eion
2
0
-19.8892
0.76422
2.0249
-
-
2
1
-13.08
0.27152
1.62412
0.73886
2.17687
3
2
-2.04759
0.49066
1.1944
-
Z=6
C
CerdaHuckelParameters.Carbon_diamond_Basis
Reference structure: diamond
W1
Nv = 4
β = 2.8
W2
EVAC
U = 10.207
=
eV
-9.43285 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
2
0
-21.3959
0.71927
2.0029
-
-
2
1
-15.2271
0.55108
1.63935
0.53135
3.48317
3
2
-4.06791
0.88307
0.86366
-
-
53
The ATK-SE Package
CerdaHuck- Nv = 4
elParameters.Carbon_GW_diamond_Basis
Z=6
C
Reference structure: diamond
U = 10.207 EVAC
=
eV
-9.4143 eV
Computational model: GW
W1
η1
η2
n
l
Eion
2
0
-22.5994
0.77991
2.10199
-
-
2
1
-14.7745
0.09615
1.00122
0.93068
2.16332
3
2
-3.42637
0.69317
0.91626
-
Z=6
C
CerdaHuckelParameters.Carbon_GW_Si
C_Basis
Reference structure: SiC
Nv = 4
β = 2.8
W2
EVAC
U = 10.207
=
eV
-6.14175 eV
Computational model: GW
W1
η1
W2
η2
n
l
Eion
2
0
-19.4265
0.77991
2.10199
-
-
2
1
-12.8029
0.09614
1.00122
0.93069
2.16335
3
2
-1.62663
0.69317
0.91626
-
Z=6
C
CerdaHuckelParameters.Carbon_C2H4_
Basis
Reference structure: C2H4
Nv = 4
β = 2.8
EVAC
U = 10.207
=
eV
-6.2568 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
2
0
-18.4006
0.7449
2.04927
-
-
2
1
-12.3453
0.74031
1.71703
0.3554
3.31214
3
2
-3.53572
0.76455
0.94043
-
-
Z=7
N
CerdaHuckelParameters.Nitrogen_BN_wu
rtz_Basis
Reference structure: BN wurtz
Nv = 5
β = 2.3
U = 11.052 EVAC = -6 eV
eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
2
0
-27.127
1
2.74251
-
-
2
1
-17.5276
1
2.26145
-
-
0.37978
0.62169
-
-
3
2
Z=7
N
-5.60857
CerdaHuckelParameters.Nitrogen_BN_he
xag_Basis
Reference structure: BN hexag
54
β = 2.8
Nv = 5
β = 2.3
U = 11.052 EVAC = -6 eV
eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
2
0
-26.4216
1
2.74251
-
-
2
1
-17.0156
1
2.26145
-
-
The Extended-Hückel Parameters
3
2
Z = 13
Al
-3.59026
0.51048
CerdaHuck- Nv = 3
elParameters.Aluminium_fcc_Basis
Reference structure: fcc
0.62169
β = 2.3
-
EVAC
U = 5.682
=
eV
-5.74486 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
3
0
-12.9807
0.72564
1.62763
-
-
3
1
-8.90927
0.71507
1.28508
-
-
3
2
-4.66958
0.77928
0.88276
-
-
Z = 13
Al
CerdaHuck- Nv = 3
elParameters.Aluminium_AlP_G
W_Basis
Reference structure: AlP
β = 2.3
U = 5.682 EVAC
=
eV
-6.44826 eV
Computational model: GW
W1
η1
W2
η2
n
l
Eion
3
0
-14.3073
0.72564
1.62763
-
-
3
1
-9.67525
0.71507
1.28508
-
-
-4.88276
0.77928
0.88276
-
-
3
2
Z = 13
Al
CerdaHuck- Nv = 3
elParameters.Aluminium_AlAs_G
W_Basis
Reference structure: AlAs
β = 2.3
U = 5.682 EVAC
=
eV
-6.8946 eV
Computational model: GW
W1
η1
W2
η2
n
l
Eion
3
0
-14.7568
0.72564
1.62763
-
-
3
1
-10.2301
0.71507
1.28508
-
-
0.77928
0.88276
-
-
3
2
Z = 14
Si
-4.7515
CerdaHuckelParameters.Silicon_diamond_Basis
Reference structure: diamond
Nv = 4
β = 2.3
U = 6.964 EVAC
=
eV
-7.75692 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
3
0
-18.0388
0.65715
1.78044
-
-
3
1
-11.8203
0.81839
1.61427
-
-
-6.3232
0.56273
0.79668
0.65807
2.49718
3
2
Z = 14
Si
CerdaHuck- Nv = 4
elParameters.Silicon_GW_diamond_Basis
Reference structure: diamond
β = 2.3
U = 6.964 EVAC
=
eV
-7.67047 eV
Computational model: GW
n
l
Eion
3
0
-18.1026
W1
η1
W2
η2
0.70366
1.83611
-
-
55
The ATK-SE Package
3
1
-11.253
0.0277
0.78901
0.98313
3
2
-5.34706
0.68383
0.68292
0.46957
Z = 14
Si
CerdaHuckelParameters.Silicon_GW_Si
C_Basis
Reference structure: SiC
U = 6.964
=
eV
-6.14175 eV
Computational model: GW
l
Eion
W1
η1
3
0
-19.4736
0.70366
1.83611
-
-
3
1
-11.9665
0.0277
0.78901
0.98313
1.70988
3
2
-6.45414
0.68383
0.68292
0.46957
Z = 15
CerdaHuckelParameters.Phosphorus_AlP_G
W_Basis
Reference structure: AlP
Nv = 5
β = 2.3
η2
W2
1.72102
EVAC
U = 9.878
=
eV
-6.44826 eV
Computational model: GW
W1
η1
W2
η2
n
l
Eion
3
0
-20.9897
0.64007
1.9419
-
-
3
1
-12.8889
0.71876
1.68957
0.344
3.05784
3
2
-3.60739
0.79107
0.89643
-
Z = 15
P
CerdaHuckelParameters.Phosphorus_GaP_G
W_Basis
Reference structure: GaP
Nv = 5
β = 2.3
EVAC
U = 9.88788
=
eV
-6.88753 eV
Computational model: GW
W1
η1
W2
η2
n
l
Eion
3
0
-21.3273
0.64007
1.9419
-
-
3
1
-13.1613
0.71876
1.68957
0.344
3.05784
3
2
-4.58537
0.79107
0.89643
-
Z = 15
P
CerdaHuckelParameters.Phosphorus_InP_G
W_Basis
Reference structure: InP
Nv = 5
β = 2.3
EVAC
U = 9.878
=
eV
-6.92207 eV
Computational model: GW
W1
η1
W2
η2
n
l
Eion
3
0
-21.2204
0.64007
1.9419
-
-
3
1
-13.2123
0.71876
1.68957
0.344
3.05784
-4.89407
0.79107
0.89643
3
56
β = 2.3
1.72102
EVAC
n
P
Sc
Nv = 4
1.70988
2
Z = 21
CerdaHuck- Nv = 3
elParameters.Scandium_hcp_Basis
β = 2.3
U = 9 eV
EVAC
=
-6.47371 eV
The Extended-Hückel Parameters
Reference structure: hcp
Computational model: LDA-DFT
η1
W2
η2
l
4
0
-8.36905
0.65566
1.41412
-
-
4
1
-5.82003
0.66104
1.16027
-
-
3
2
-8.36623
0.58803
1.39314
-
Z = 21
Sc
CerdaHuckelParameters.Scandium_bcc_Basis
Reference structure: bcc
Nv = 3
β = 2.3
U = 9 eV
EVAC
=
-6.47033 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-8.27398
0.65566
1.41412
-
-
4
1
-5.68802
0.66104
1.16027
-
-
3
2
-8.43933
0.58803
1.39314
-
Z = 22
Ti
CerdaHuck- Nv = 4
elParameters.Titanium_hcp_Basis
Reference structure: hcp
β = 2.3
U = 9 eV
EVAC
=
-5.55606 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-7.84958
0.45558
0.89722
-
-
4
1
-7.32609
0.49494
1.00909
-
-
3
2
-9.42441
0.28536
1.15327
0.81231
Z = 22
Ti
CerdaHuckelParameters.Titanium_fcc_Basis
Reference structure: fcc
Nv = 4
β = 2.3
U = 9 eV
2.63915
EVAC
=
-5.46065 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-7.70802
0.45558
0.89722
-
-
4
1
-7.21524
0.49494
1.00909
-
-
3
2
-9.27229
0.28536
1.15327
0.81231
Z = 22
Ti
CerdaHuckelParameters.Titanium_bcc_Basis
Reference structure: bcc
V
W1
n
Eion
Nv = 4
β = 2.3
U = 9 eV
2.63915
EVAC
=
-5.8819 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-7.61918
0.45558
0.89722
-
-
4
1
-7.129
0.49494
1.00909
-
-
3
2
-9.08015
0.28536
1.15327
0.81231
Z = 23
CerdaHuckelParameters.Vanadi-
Nv = 5
β = 2.3
U = 9 eV
2.63915
EVAC
=
-5.81563 eV
57
The ATK-SE Package
um_bcc_Basis
Reference structure: bcc
Computational model: LDA-DFT
W2
η2
4
0
-7.902
0.88449
1.51793
-
-
4
1
-5.37821
0.66078
1.30693
-
-
3
2
-9.44229
0.62062
1.68218
-
Z = 24
CerdaHuck- Nv = 6
elParameters.Chromium_bcc_Basis
Reference structure: bcc
β = 2.3
U = 9 eV
EVAC
=
-5.69969 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-8.07927
0.64199
0.99961
-
-
4
1
-7.26305
0.58547
1.10362
-
-
3
2
-10.7296
0.33576
1.45656
0.7694
Z = 25
Mn
CerdaHuck- Nv = 7
elParameters.Manganese_fcc_Basis
Reference structure: fcc
β = 2.3
U = 9 eV
3.27523
EVAC
=
-5.92104 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-8.93247
0.60538
1.39823
-
-
4
1
-6.56812
0.59765
1.20449
-
-
3
2
-10.8763
0.3231
1.52037
0.78115
Z = 25
Mn
CerdaHuckelParameters.Manganese_bcc_B
asis
Reference structure: bcc
Nv = 7
β = 2.3
U = 9 eV
3.44592
EVAC
=
-5.91948 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-9.14276
0.60538
1.39823
-
-
4
1
-6.92114
0.59765
1.20449
-
-
3
2
-11.2151
0.3231
1.52037
0.78115
Z = 26
Fe
CerdaHuckelParameters.Iron_bc
c_Basis
Reference structure: bcc
Nv = 8
β = 2.3
U = 9 eV
3.44592
EVAC
= -5.21
eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
4
0
-9.39204
0.5892
1.4884
-
-
4
1
-6.66953
0.59596
1.25262
-
-
0.26494
1.48912
3
58
η1
l
Cr
Co
W1
n
Eion
2
Z = 27
-11.4024
CerdaHuckelParameters.Co-
Nv = 9
β = 2.3
0.82466
U = 9 eV
3.3483
EVAC
=
-4.95579 eV
The Extended-Hückel Parameters
balt_fcc_Basis
Reference structure: fcc
Computational model: LDA-DFT
η1
W2
η2
l
4
0
-9.90499
0.53969
1.48379
-
-
4
1
-6.97352
0.59446
1.2556
-
-
3
2
-11.7395
0.24393
1.4872
0.84379
Z = 27
Co
CerdaHuck- Nv = 9
elParameters.Cobalt_hcp_Basis
Reference structure: hcp
β = 2.3
U = 9 eV
3.41646
EVAC
=
-5.08683 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-10.0487
0.53969
1.48379
-
-
4
1
-7.18148
0.59446
1.2556
-
-
3
2
-11.7495
0.24393
1.4872
0.84379
Z = 28
Ni
CerdaHuckelParameters.Nickel_fcc_Basis
Reference structure: fcc
Nv = 10
β = 2.3
U = 9 eV
3.41646
EVAC
=
-4.64694 eV
Computational model: LDA-DFT
W1
η1
W2
η2
-
-
n
l
Eion
4
0
-9.7934
0.60557
1.58729
4
1
-6.69928
0.61588
1.29812
-
-
3
2
-11.7794
0.29586
1.63992
0.81374
3.94689
Z = 29
Cu
CerdaHuckelParameters.Copper_fcc_Basis
Reference structure: fcc
Nv = 11
β = 2.3
U = 9 eV
EVAC
=
-5.17805 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
4
0
-10.5742
0.6063
1.69318
-
-
4
1
-6.86172
0.63888
1.33731
-
-
0.32382
1.79662
3
2
Z = 30
Zn
-12.8961
CerdaHuckelParameters.Zinc_fc
c_Basis
Reference structure: fcc
Ga
W1
n
Eion
Nv = 12
β = 2.3
0.82655
U = 9 eV
5.14331
EVAC
=
-6.67286 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
4
0
-12.9625
1
2.36615
-
-
4
1
-9.23345
0.4167
1.63016
-
-
3
2
-18.035
0.15524
2.01067
0.87781
Z = 31
CerdaHuckelParameters.Galli-
Nv = 3
β = 2.3
3.565
EVAC
U = 5.935
=
eV
-5.68337 eV
59
The ATK-SE Package
um_fcc_Basis
Reference structure: fcc
Computational model: LDA-DFT
W2
η2
4
0
-14.5101
0.67038
2.03484
-
-
4
1
-8.56214
0.71632
1.63083
-
-
4
2
-3.16883
0.89901
0.90717
-
Z = 31
CerdaHuckelParameters.Gallium_GaP_G
W_Basis
Reference structure: GaP
Nv = 3
β = 2.3
EVAC
U = 5.936
=
eV
-6.88753 eV
Computational model: GW
n
l
Eion
W1
η1
W2
η2
4
0
-16.3708
0.67038
2.03484
-
-
4
1
-10.0152
0.71632
1.63083
-
-
4
2
-3.79622
0.89901
0.90717
-
Z = 31
Ga
CerdaHuckelParameters.Gallium_GaAs_B
asis
Reference structure: GaAs
Nv = 3
β = 2.3
EVAC
U = 5.936
=
eV
-7.60579 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
4
0
-17.2549
0.57998
1.93753
-
-
4
1
-11.2889
0.64383
1.58044
-
-
4
2
-6.68155
0.65154
0.9494
-
Z = 31
Ga
CerdaHuckelParameters.Gallium_GaAs_
GW_Basis
Reference structure: GaAs
Nv = 3
β = 2.3
EVAC
U = 5.936
eV
eV
= -7.41
Computational model: GW
n
l
Eion
W1
η1
W2
η2
4
0
-16.9187
0.67038
2.03484
-
-
4
1
-10.7539
0.71632
1.63083
-
-
4
2
-3.96693
0.89901
0.90717
-
Z = 33
As
CerdaHuckelParameters.Arsenic_AlAs_G
W_Basis
Reference structure: AlAs
60
η1
l
Ga
As
W1
n
Eion
Nv = 5
β = 2.3
EVAC
U = 8.399
=
eV
-6.8946 eV
Computational model: GW
n
l
Eion
W1
η1
W2
η2
4
0
-21.9456
0.54624
2.19335
-
-
4
1
-13.0744
0.7307
1.9686
-
-
4
2
-3.38857
0.9902
0.94359
-
Z = 33
CerdaHuckelParame-
Nv = 5
β = 2.3
EVAC
U = 8.399
=
eV
-7.60579 eV
The Extended-Hückel Parameters
ters.Arsenic_GaAs_Basis
Reference structure: GaAs
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
4
0
-20.6851
0.62857
2.2775
-
-
4
1
-12.1021
0.999
2.28904
-
-
4
2
-3.36392
0.9902
1.67268
-
Z = 33
As
CerdaHuckelParameters.Arsenic_GaAs_G
W_Basis
Reference structure: GaAs
Nv = 5
β = 2.3
EVAC
U = 8.399
eV
eV
= -7.41
Computational model: GW
W1
η1
W2
η2
n
l
Eion
4
0
-22.1472
0.54624
2.19335
-
-
4
1
-13.1706
0.7307
1.9686
-
-
4
2
-4.137
0.9902
0.94359
-
Z = 33
As
CerdaHuckelParameters.Arsenic_InAs_G
W_Basis
Reference structure: InAs
Nv = 5
β = 2.3
EVAC
U = 8.399
=
eV
-7.5043 eV
Computational model: GW
W1
η1
W2
η2
n
l
Eion
4
0
-22.0247
0.54624
2.19335
-
-
4
1
-13.2078
0.7307
1.9686
-
-
4
2
-4.6414
0.9902
0.94359
-
Z = 39
Y
CerdaHuckelParameters.Yttrium_fcc_Basis
Reference structure: fcc
Nv = 3
β = 2.3
U = 9 eV
EVAC
= -6 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
5
0
-8.45573
0.66414
1.62475
-
-
5
1
-5.03686
0.72293
1.30361
-
-
4
2
-8.01171
0.68038
1.58038
-
Z = 39
Y
CerdaHuck- Nv = 3
elParameters.Yttrium_hcp_Basis
Reference structure: hcp
β = 2.3
U = 9 eV
EVAC
= -6 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
5
0
-8.47712
0.66414
1.62475
-
-
5
1
-5.08407
0.72293
1.30361
-
-
4
2
-7.99731
0.68038
1.58038
-
-
61
The ATK-SE Package
Z = 40
Zr
CerdaHuck- Nv = 4
elParameters.Zirconium_hcp_Basis
Reference structure: hcp
U = 9 eV
EVAC
=
-5.97812 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
5
0
-8.21277
0.66589
1.56164
-
-
5
1
-6.00133
0.53606
1.2688
-
-
0.61574
1.66473
4
2
Z = 40
Zr
-9.03884
CerdaHuckelParameters.Zirconium_fcc_Basis
Reference structure: fcc
Nv = 4
β = 2.3
0.64065
U = 9 eV
5.0542
EVAC
=
-5.9684 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
5
0
-8.08839
0.66589
1.56164
-
-
5
1
-5.73102
0.53606
1.2688
-
-
4
2
-8.94122
0.61574
1.66473
0.64065
Z = 40
Zr
CerdaHuckelParameters.Zirconium_bcc_Basis
Reference structure: bcc
Nv = 4
β = 2.3
U = 9 eV
5.0542
EVAC
=
-6.02619 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
5
0
-7.8852
0.66589
1.56164
-
-
5
1
-5.58256
0.53606
1.2688
-
-
4
2
-8.74286
0.61574
1.66473
0.64065
Z = 41
Nb
CerdaHuckelParameters.Niobium_bcc_Basis
Reference structure: bcc
Nv = 5
β = 2.3
U = 9 eV
5.0542
EVAC
=
-5.791 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
5
0
-7.83515
0.78125
1.66071
-
-
5
1
-5.03085
0.68753
1.27372
-
-
4
2
-9.3306
0.68669
1.85049
-
Z = 42
Mo
CerdaHuckelParameters.Molybdenum_bcc_B
asis
Reference structure: bcc
62
β = 2.3
Nv = 6
β = 2.3
U = 9 eV
EVAC
=
-5.19421 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
5
0
-8.36662
0.83018
1.72218
-
-
5
1
-5.39352
0.72696
1.3365
-
-
The Extended-Hückel Parameters
4
2
Z = 43
Tc
-10.8671
0.67217
CerdaHuck- Nv = 4
elParameters.Technetium_hcp_Basis
Reference structure: hcp
1.9978
β = 2.3
U = 9 eV
EVAC
=
-7.5149 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
5
0
-8.50569
0.77154
1.64956
-
-
5
1
-5.74739
0.63636
1.36162
-
-
4
2
-11.4215
0.45903
1.87926
0.66939
Z = 43
Tc
CerdaHuck- Nv = 4
elParameters.Technetium_fcc_Basis
Reference structure: fcc
U = 9 eV
=
-7.45582 eV
Computational model: LDA-DFT
Eion
W1
η1
W2
η2
0
-8.2267
0.77154
1.64956
-
-
1
-5.70711
0.63636
1.36162
-
-
2
-11.3582
0.45903
1.87926
0.66939
n
l
5
5
4
Z = 44
Ru
β = 2.3
3.90392
EVAC
CerdaHuck- Nv = 8
elParameters.Ruthenium_hcp_Basis
Reference structure: hcp
β = 2.3
U = 9 eV
3.90392
EVAC
=
-5.59144 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
5
0
-9.32602
0.60076
1.63558
-
-
5
1
-6.34065
0.58839
1.37066
-
-
4
2
-12.4218
0.27066
1.71196
0.80993
Z = 44
Ru
CerdaHuck- Nv = 8
elParameters.Ruthenium_fcc_Basis
Reference structure: fcc
β = 2.3
U = 9 eV
3.31356
EVAC
=
-5.17748 eV
Computational model: LDA-DFT
W1
η1
W2
η2
-
-
n
l
Eion
5
0
-8.84268
0.60076
1.63558
5
1
-6.06874
0.58839
1.37066
-
-
4
2
-11.9364
0.27066
1.71196
0.80993
3.31356
Z = 45
Rh
CerdaHuckelParameters.Rhodium_fcc_Basis
Reference structure: fcc
Nv = 9
β = 2.3
U = 9 eV
EVAC
=
-4.96235 eV
Computational model: LDA-DFT
n
l
Eion
5
0
-9.22928
W1
η1
W2
η2
0.72992
1.86894
-
-
63
The ATK-SE Package
5
1
-5.15799
0.71084
1.40344
-
4
2
-12.433
0.41591
2.00068
0.70707
Z = 46
Pd
CerdaHuckelParameters.Palladium_fcc_Basis
Reference structure: fcc
β = 2.3
U = 9 eV
4.15195
EVAC
=
-4.38749 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
5
0
-9.07916
0.63338
1.77352
-
-
5
1
-5.8727
0.64064
1.43651
-
-
4
2
-12.3746
0.31704
1.9082
0.78406
Z = 47
Ag
CerdaHuckelParameters.Silver_fcc_Basis
Reference structure: fcc
Nv = 11
β = 2.3
U = 9 eV
3.88573
EVAC
=
-5.43566 eV
Computational model: LDA-DFT
W1
η1
W2
η2
-
-
n
l
Eion
5
0
-10.3592
0.61985
1.91661
5
1
-6.20001
0.66651
1.50982
-
-
4
2
-14.5109
0.28692
2.01944
0.80921
4.14345
Z = 48
Cd
CerdaHuckelParameters.Cadmium_fcc_Basis
Reference structure: fcc
Nv = 12
β = 2.3
U = 9 eV
EVAC
=
-5.78433 eV
Computational model: LDA-DFT
W1
η1
W2
η2
0.60994
2.10439
-
-
n
l
Eion
5
0
-12.3344
5
1
-7.85805
0.5758
1.66558
-
-
4
2
-19.8661
0.93688
14.8833
0.32073
2.31681
U = 5.53 eV
EVAC
=
-5.90444 eV
Z = 49
In
CerdaHuckelParameters.Indium_fcc_Basis
Reference structure: fcc
Nv = 3
β = 2.3
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
5
0
-13.9371
0.59101
2.11757
-
-
5
1
-8.22964
0.71392
1.84269
-
-
5
2
-3.54891
0.61732
1.02658
-
-
U = 5.53 eV
EVAC
=
-6.92207 eV
W2
η2
Z = 49
In
CerdaHuckelParameters.Indium_InP_G
W_Basis
Reference structure: InP
n
64
Nv = 10
-
l
Nv = 3
β = 2.3
Computational model: GW
Eion
W1
η1
The Extended-Hückel Parameters
5
0
-15.9796
0.59101
2.11757
-
-
5
1
-9.05671
0.71392
1.84269
-
-
5
2
-3.77804
0.61732
1.02658
-
Z = 49
In
CerdaHuckelParameters.Indium_InAs_G
W_Basis
Reference structure: InAs
β = 2.3
U = 5.53 eV
=
-7.5043 eV
Computational model: GW
n
l
Eion
W1
η1
W2
η2
5
0
-16.4496
0.59101
2.11757
-
-
5
1
-9.83157
0.71392
1.84269
-
-
5
2
-3.6995
0.61732
1.02658
-
Z = 74
W
CerdaHuck- Nv = 6
elParameters.Tungsten_bcc_Basis
Reference structure: bcc
β = 2.3
U = 9 eV
EVAC
=
-5.6645 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
6
0
-10.5819
0.80244
2.30427
-
-
6
1
-5.53905
0.68049
1.72283
-
-
5
2
-10.7394
0.69067
2.3028
-
Z = 75
Re
CerdaHuck- Nv = 7
elParameters.Rhenium_hcp_Basis
Reference structure: hcp
η2
0.20733
1.6507
0.84382
2.6424
0.76128
1.58733
-
-
0.65008
2.33586
-
-10.004
1
-5.98158
2
-11.3579
6
5
Z = 77
=
-5.45363 eV
W2
0
6
U = 9 eV
η1
W1
l
β = 2.3
EVAC
Computational model: LDA-DFT
Eion
n
Ir
CerdaHuckelParameters.Iridium_fcc_Basis
Reference structure: fcc
Pt
Nv = 3
EVAC
Nv = 9
β = 2.3
U = 5.53 eV
EVAC
=
-4.2382 eV
Computational model: LDA-DFT
n
l
Eion
W1
η1
W2
η2
6
0
-12.1196
0.64865
2.32336
-
-
6
1
-6.44135
0.69422
1.80105
-
-
5
2
-13.1059
0.32075
2.16073
0.77521
Z = 78
Reference structure: fcc
CerdaHuck- Nv = 10
elParameters.Platinum_fcc_Basis
β = 2.3
4.01172
EVAC
U = 8.604
=
eV
-4.07837 eV
Computational model: LDA-DFT
65
The ATK-SE Package
n
l
Eion
W1
η1
W2
η2
6
0
-11.7091
0.65212
2.32872
-
-
6
1
-6.08105
0.7288
1.77159
-
-
5
2
-13.301
0.38501
2.30384
0.74491
Z = 79
Au
CerdaHuckelParameters.Gold_fc
c_Basis
Reference structure: fcc
66
Nv = 11
β = 2.3
4.63467
EVAC
U = 8.604
=
eV
-4.8533 eV
Computational model: LDA-DFT
W1
η1
W2
η2
n
l
Eion
6
0
-12.1342
0.60326
2.31605
-
-
6
1
-6.73967
0.62661
1.74458
-
-
5
2
-14.0257
0.37598
2.32731
0.79437
5.44496
CHAPTER 3. EXTERNAL CALCULATORS
INTRODUCTION
VNL 2009.06 supports the creation and execution of scripts for other calculators than ATK
2009.06. This chapter will present each of the calculators that are supported, and how they may
be installed such that they can be used with VNL 2009.06.
Currently, the following external calculators are supported in VNL 2009.06:
• GPAW
GPAW
GPAW is a density-functional theory Python code based on the projector-augmented wave
(PAW) method. More information about GPAW can be obtained from its website.
INSTALLATION
The GPAW calculator is not installed by default in ATK 2009.06 as distributing GPAW in this
manner is not allowed under its GPL license. You can, however, fetch GPAW and its associated
dependencies on your own and install it separately. This process, however, has been automated
for your convenience in an executable script.
The GPAW install script install_gpaw can be found in the nlpython binary directory where ATK
2009.06 has been installed. Navigate to this directory and execute the following command:
./install_gpaw
This command will unpack GPAW 0.5.3667 and install it into ATK such that it becomes available to ATK and VNL as a standard Python module. The use of GPAW depends on ASE, the
Atomistic Simulation Environment. ASE comes pre-installed in ATK.
In order to run GPAW, the Atomic PAW setups are needed. These setups are installed by the
GPAW install script into the share directory where ATK has been installed and is automatically
referenced when nlpython is run. The install script installs version 0.5.3574 of these setups.
More information about the setups is available from the GPAW website here.
67
External Calculators
EXECUTION
Once GPAW has been installed, it can be accessed and used as a standard Python module
within nlpython. This enables the execution of a GPAW Python script gpaw_script.py by
executing:
nlpython gpaw_script.py
Alternatively, GPAW can be used in interactive mode by executing nlpython to bring up an
interactive prompt and e.g. writing:
>>> from gpaw import *
Tutorials, documentation and any further assistance in running GPAW can be obtained on the
GPAW website.
68
CHAPTER 4. NANOLANGUAGE REFERENCE
MANUAL
GEOMETRY
• MoleculeConfiguration
• BulkConfiguration
• DeviceConfiguration
• Dielectric and metallic box regions
CALCULATORS
COMMON PARAMETERS
• IterationControlParameters
• NumericalAccuracyParameters
• DoubleContourIntegralParameters
• SlaterOrbital
• PoissonSolver
• SelfEnergyCalculator
ATK-SE CALCULATOR
EXTENDED HUCKEL CALCULATOR
• HuckelCalculator
• DeviceHuckelCalculator
• HuckelBasisParameters
69
NanoLanguage Reference Manual
ANALYSIS
COMMON ANALYSIS
• ElectronDifferenceDensity
• ElectrostaticDifferencePotential
MOLECULE ANALYSIS
• MolecularEnergySpectrum
BULK ANALYSIS
• Bandstructure
DEVICE ANALYSIS
• TransmissionSpectrum
BRAVAIS LATTICES
• SimpleCubic
• BodyCenteredCubic
• FaceCenteredCubic
• Rhombohedral
• Hexagonal
• SimpleTetragonal
• BodyCenteredTetragonal
• SimpleOrthorhombic
• BodyCenteredOrthorhombic
• FaceCenteredOrthorhombic
• BaseCenteredOrthorhombic
• SimpleMonoclinic
• BaseCenteredMonoclinic
• Triclinic
70
IO
• UnitCell
IO
• nlread
• nlsave
• nlprint
PERIODIC TABLE
• PeriodicTable
PHYSICAL QUANTITIES AND UNITS
• PhysicalQuantity
71
72
CHAPTER 5. APPENDIX
WHAT IS NEW IN NL 2009.06
The new QuantumWise version of NanoLanguage, 2009.06, has been modified a number of
places compared with the previous Atomistix version. In the following we give a brief summary
of the changes.
NAME OF THE BASE MODULE
Previously there were two modules ATK.KohnSham and ATK.TwoProbe; these are now merged
into a single module, with the name NanoLanguage. Thus, the old syntax
from ATK.KohnSham import *
from ATK.TwoProbe import *
should be changed to
from NanoLanguage import *
SPECIFICATION OF TWO-PROBE CONFIGURATIONS
Previously, an open system consisting of a central region and two electrodes was constructed
with the TwoProbeConfiguration. This is now substituted with the DeviceConfiguration class.
The device configuration take as input what was previously known as the equivalent bulk system
of the two-probe configuration.
METALLIC AND DIELECTRIC REGIONS AND THE POISSON SOLVER
In NL 2009.06, it is possible to specify a BoxRegion with a specific dielectric constant or specific
electro-static potential. The regions can be used for both MoleculeConfiguration, BulkConfiguration, and DeviceConfiguration, through the methods set_dielectric_region,
set_metallic_region.
To use metallic and dielectric regions requires that the MultigridSolver is selected as the
Poisson solver. With this solver it is possible to specify both a PeriodicBoundaryCondition,
DirichletBoundaryCondition, or NeumannBoundaryCondition at the unit cell boundaries.
73
Appendix
CALCULATORS
What was previously known as methods is now called calculators. The NL 2009.06 version has
support for calculators that use the extended-Hückel Model. Future versions will also have
support for DFT models. The following script
from ATK.KohnSham import *
configuration = BulkConfiguration(..)
method = KohnShamMethod()
scf_state = executeSelfconsistentCalculation(configuration,method)
density=calculateElectronDensity(scf_state)
is in NL 2009.06 written as
from NanoLanguage import *
configuration = BulkConfiguration(..)
calculator = HuckelCalculator()
configuration.set_calculator(calculator)
density=ElectronDifferenceDensity(configuration)
The calculators take a number of parameters, and a description of these parameters can be found
here:
• HuckelCalculator
• DeviceHuckelCalculator
FILE FORMAT
In NL 2009.06 there is a single NetCDF file format for saving data and configurations. Data is
saved with the nlsave command and read with the nlread command.
ANALYSIS
In NL 2009.06, the analysis is performed on the configuration after a calculator has been attached, see the section called “Calculators”. There are a number of new analysis keywords, see
the section called “Analysis”
PYTHON BASICS
INTRODUCTION
NanoLanguage is a dialect of Python, and all the standard features from Python is available
when you invoke ATK. This implies that when you construct and build up your NanoLanguage
scripts, you will have all the power of Python behind you.
If you are not familiar with Python there are many good tutorials available on the web, such as
• Official Python Tutorial (covers basic Python concepts)
• Dive into Python (a more advanced, but nevertheless, useful guide for beginners)
74
Indentation
If this is your first encounter with NanoLanguage and Python, we recommend that you keep the
Python tutorial and this Python basics page handy as you start using NanoLanguage. The spectrum of features offered by Python is enormous, and a lot of them will not be needed when you
write scripts in NanoLanguage. The minimum set of structures you really should know about
when using NanoLanguage is
• Code indentation
• Comments in Python
• Modules
• Lists
• Tuples
• Dictionaries
• For loops
• Objects
• Functions and arguments
In the next few sections, we will discuss the basic usage of the above Python concepts and some
general Python features.
INDENTATION
One important point you must know, before you embark on writing your first NanoLanguage
script is that Python relies on indentation when interpreting your script. If your code is not
correctly indented, Python will stop executing the provided script and return an error. Precisely,
when and how you should indent code in your scripts, will become apparent through the examples in this manual; a brief example, however, showing how to define a function illustrates
the point
def myNewMethod():
print 'Hello World'
The colon “:” and the indentation of the following line tells us that the print statement is a part
of the myNewMethod() function. The indentation determines if the code belongs to the defined
function or to the remaining code.
It is important to know that using both spaces and tabulation when indenting code sections or
statements could mean trouble. The reason for this is that tabulation might not be interpreted
the same way in different editors. This could become an issue if you work on the same script
using different operating systems or collaborate with others on writing them. Some editors allow
you to specify the number of spaces that should be inserted when pressing the TAB key, and
we recommend that you use this option when available or simply use the SPACE key for indentation to increase interoperability.
This will do for now, but keep in mind that Python code must be properly indented and never
to use both types of indentation in the same script. For a more complete discussion of the
indentation rules used in Python see this on-line resource on Indenting Code.
75
Appendix
COMMENTS
A comment line in Python starts with a the character “#”
# This is a comment line in Python
print 'This line will be executed'
The first line is ignored when interpreting the Python script. The second line will print the words
This line will be executed
to the screen.
Longer (multi-line) comments can be made using triple quotes
a = 2
"""
A value was just assigned to a
We will now assign a value to b
Are you ready?
"""
b = 3
print "a x b = ", b*a
The lines between the triple quotes are ignored by the Python interpreter so the result printed
by the above would be
a x b = 6
In Python, it does not matter whether you use single quotes (') or double quotes (") for declaring
a triple-quoted region.
IMPORTING MODULES
A Python module is a file containing a collection of functions, classes, and many other tools
that initially are not available when Python is invoked. In some sense, you may think of a Python
module as a library. You load a Python module by using the import statement. Modules are
typically imported in three different ways
• either by importing the entire module, for example
import math
#
x
y
z
Entire math module is now available
= 3.14
= math.cos(x)
= math.sin(x)
• or by importing specific elements from the module, for example
from math import cos
# Only cos() has been loaded from the math module
76
Lists
x = 3.14
y = cos(x)
• or by importing all methods from a module
from math import *
#
x
y
z
All names have been loaded from the math module
= 3.14
= cos(x)
= sin(x)
As mentioned above, a “#” denotes a comment in Python. Everything past this character, but
still on the same line, will not get interpreted.
You will find more information on modules in the Python tutorial, whereas an overview of the
math module is provided here.
LISTS
A list is an object used to collect elements. Lists are created as easy as
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
romans = ['a', 'b', 'c', 'd']
gases
= ['Hydrogen', 'Helium']
The last of the above examples creates a list containing two strings and saves the defined list in
a variable gases. Lists can contain several different data types at the same time, which makes
it a very flexible data structure.
Elements in a list are numbered starting from zero – so the first element in the list gases (Hydrogen) can be accessed as
print gases[0]
It is also possible to store different data types within the same list structure
gases = [1, 'Hydrogen', 2, 'Helium']
and extend these with additional elements
gases.extend([7,'Nitrogen']) print gases
which produces
[1, 'Hydrogen', 2, 'Helium', 7, 'Nitrogen']
Here we extended elements from another list to the list gases. Had we instead applied the list
method append() to the list
gases.append([8,'Oxygen'])
print gases
77
Appendix
we get
[1, 'Hydrogen', 2, 'Helium', 7, 'Nitrogen', [8, 'Oxygen']]
So, in this case, the actual list (and not the elements in it!) is added to the gases list. Another
(and shorter) way of adding elements to a list is by using the “+” operator:
a = [1,2]
a = a + [3,4]
print a
which gives
[1, 2, 3, 4]
Additional information on lists can be found here in the Python tutorial.
TUPLES
A tuple is constructed very similar to a list, but by using parentheses instead of square brackets
mytuple = ('uno','duo') # Note the curved parentheses
myothertuple = ('uno', ) # Note the comma just after 'uno'
An important detail in the above example, is that a trailing comma is needed when the tuple
only contains a single element; otherwise, it could not be distinguished from an ordinary parentheses construction. For example,
t = ('uno',) # t is a tuple
s = ('uno') # s is 'just' a string
Contrary to a list, a tuple is immutable, meaning that, once it is defined, its values can not be
changed. For example, doing this
mytuple = ('uno','duo')
mytuple[1] = 'quattro'
is illegal and results in the output
Traceback (most recent call last): File "<stdin>", line 1, in ?
object does not support item assignment
TypeError:
Here, Python raises the error
TypeError: object does not support item assignment
since the above assignment is illegal. Python informs that the error occurred on “line 1”. This
is the kind of message you would get when using Python interactively. Had we used it in a
script, the line number would refer to the actual line in the script.
Combinations of tuples and lists are allowed. To set up a collection of vectors to describe atomic
coordinates, we may use lists and tuples in this fashion
78
Dictionaries
atom_coordinate_1 = (0.1, 0.2, 0.3) atom_coordinate_2 = (0.4, 0.5, 0.6)
atom_coordinate_3 = (0.7, 0.8, 0.9)
collection_of_atoms = [
atom_coordinate_1,
atom_coordinate_2,
atom_coordinate_3
]
print collection_of_atoms
producing the output
[(0.10000000000000001, 0.20000000000000001, 0.29999999999999999),
(0.40000000000000002, 0.5,
0.59999999999999998),
(0.69999999999999996, 0.80000000000000004, 0.90000000000000002)]
Here, we have displayed the output over several lines for aesthetic reasons.
For more details on tuples, consult this section of the Python tutorial.
DICTIONARIES
Often it can be useful to assign tags or a keys to different values, in order distinguish among
these. This can be accomplished in Python by using so-called dictionaries. In Python, a dictionary is called a dict. A dict is created like this
myDict = {'username' : 'henry', 'password' : 'secret'}
print myDict['username']
which yields
henry
In this example, username and henry are a key:value pair. So is password and secret. Note that
dictionaries are created using curly braces “{}” (tuples use parentheses “()” and lists use square
brackets “[]”).
There is no internal ordering in a dict, i.e. keys and values are not stored in the same order as
they are entered into the dict. Values in the dict are accessed via their key. A value can be
associated with several keys, whereas a key may be associated with a single value only.
Two frequently used methods associated with a dict are keys() and values(). The method keys
() returns a list containing the keys of the dict whereas values() returns the values. For example
myDict = {'username':'henry','password':'secret'}
print myDict.keys()
print myDict.values()
producing
['username', 'password'] ['henry', 'secret']
It is also possible to query a dict regarding its length using the method len()
79
Appendix
myDict = {'username':'henry','password':'secret'} print 'myDict has
length', len(myDict)
resulting in the output
myDict has length 2
The return value of len() corresponds to the number of key:value pairs in the dict. You can find
more information about dict usage here in the Python tutorial.
FOR LOOPS
Once we have created lists, it would be nice if we had an automatic way of addressing its
individual elements. Python offers this functionality by using a for-loop construction, e.g.
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for x in numbers:
print x,
which generates the output
1 2 3 4 5 6 7 8 9
Another way to use a for-loop is when constructing iterative loops in numerical algorithms.
Here is a simple example using Newton-Raphson iteration for determining √2
x = 20.0
for i in range(8):
x = x - (x*x - 2.0)/(2.0*x)
print x
which converges quadratically to √2 as
10.05
5.12450248756
2.75739213842
1.74135758045
1.44494338196
1.41454033013
1.41421360012
1.41421356237
Python has lots of so-called built-in functions, for example the range() function, which we have
just used above.
The range() function returns a list containing all positive integers less than the argument (including zero), which was passed to the range(). The for-loop now iterates over all the elements
generated by the range(8) call, performing a Newton update of the variable x for each iteration
step of the loop. The value of the first element in a list and the increments between neighboring
elements can be controlled by calling range() like this
80
Objects
for i in range(9,21,3):
print i
giving rise to the output
9
12
15
18
It is also possible to find the length of a list (or a tuple) using the built-in len() function. This
can neatly be combined with a for-loop to iterate over a list. For example
m = range(6)
for i in range(len(m)):
print m[i],
produces
0 1 2 3 4 5
So, len() returns the length (i.e. the number of elements) of the list. This is then used to create
a new list (using the range() function) over which the for-loop iterates. The comma “,” at the
end of the print statement instructs Python to suppress printing a new line character. Otherwise,
each number would have been printed on separate lines.
Consult the links for-loop, range() and len() for more info on loop construction in Python tutorial.
OBJECTS
Many of the structures which you work with in both NanoLanguage and Python are so-called
objects. An object is a structure, which contains a lot of handy functions for accessing and
manipulating the data assigned to the object. These special functions are called methods. Let
us see how we work with these in practice. If we define a list like
numbers = [1, 5, 3, 6, 2, 8, 7, 9, 4]
the
variable
numbers
in
fact
refers
to
a
list
object
holding
the
numbers
[1,5,3,6,2,8,7,9,4]. A list object contains several helpful methods, one of them being
reverse().
You call reverse() like this
numbers.reverse()
print numbers
which gives the output
[4, 9, 7, 8, 2, 6, 3, 5, 1]
Another list method is sort(), which sorts the elements of a list
81
Appendix
numbers.sort()
print numbers
producing
[1, 2, 3, 4, 5, 6, 7, 8, 9]
You can always use the built-in Python function dir() to display information about the functionality provided by a given object. For example,
print dir(list)
returns the following methods for the list type
['append', 'count', 'extend', 'index',
'insert', 'pop', 'remove', 'reverse', sort']
For instructions about their specific usage, e.g. for reverse(), you can apply Python's built-in
help system using the built-in help function. So, to get more information on the method reverse
(), invoke help like this
help(list.reverse)
producing the output
Help on method_descriptor:
reverse(...)
L.reverse() -- reverse *IN PLACE*
For further information about Python objects, consult the following entry in Python tutorial.
FUNCTIONS AND ARGUMENTS
Very often, you will find that you keep copying and repeating almost identical segments of your
Python code. A common approach to avoid this redundancy, is to encapsulate these structures
in a so-called function. By doing this, you keep your code readable, as well as concise and
clear. Besides this, you also avoid reinventing the wheel every time your start on a new problem.
Instead, you merely grab the function you made in a previous script.
We will use the above Newton iteration scheme as an example. To encapsulate this in a function, we could do the following
def newton():
x = 20.0
for i in range(10):
x = x - (x*x - 2.0)/(2.0*x)
print x
In the above, the def statement declares the begin of the definition of the function newton().
This also instructs the Python interpreter that all indented lines following the colon “:” belong
82
Functions and Arguments
to the function definition. Indention is very important: All lines belonging to the function must
be indented by the same number of spaces within the region that defines function. We may then
call the function, simply as
newton()
yielding
10.05
5.12450248756
2.75739213842
1.74135758045
1.44494338196
1.41454033013
1.41421360012
1.41421356237
1.41421356237
1.41421356237
Even though this already makes things easier to use, the function newton() still has certain short
comings. For example, it would be nice, if we could
• supply the initial guess (currently x = 20 is always used).
• set the maximum number of iterations steps.
In Python, we do this by passing arguments to the function. Here is an implementation of the
above wish list by passing arguments to the function newton()
def newton(n,x):
for i in range(n):
x = x - (x*x - 2.0)/(2.0*x)
print x
newton(8,4.0)
giving
2.25
1.56944444444
1.42189036382
1.41423428594
1.41421356252
1.41421356237
1.41421356237
1.41421356237
The function now uses 8 iterations steps and the initial guess for the root is set to 4.0. Still, this
is somewhat useless. Suppose that we actually wanted to use the result of the calculation (the
numerical value of √2) in some subsequent parts of our script. We solve this problem by letting
the function return the result of the calculation, which we then may “grab” and store in a new
variable. Here is how
def newton(n,x):
for i in range(n):
x = x - (x*x - 2.0)/(2.0*x)
return x
83
Appendix
x = newton(8,4.0)
print 'sqrt(2) = ', x
giving the output
sqrt(2) =
1.41421356237
This is more satisfactory, but there are still some handy features regarding function definitions
that can make life even nicer for us. Often we might be completely satisfied with using x =
2.0 and n = 8, when we call the newton() function. To avoid supplying this redundant information, we can define default values for the function arguments. We accomplish this by
specifying arguments in the following way
def newton(n=10, x=2.0):
for i in range(n):
x = x - (x*x - 2.0)/(2.0*x)
return x
If we are happy about the default settings, we may invoke the function by calling it as newton
(). On the contrary, should the default settings be changed, we may also invoke the function
by calling newton(8,2.0). When the variables for a Python function are specified like above,
they are called optional variables as opposed to required variables which have no default value.
This is certainly handy, but what if we often wanted to change the initial guess for x whereas
the value of n should be kept at the default setting? It is possible to override the default value
by explicitly naming the variable like this:
newton(x=3.0)
which overrides the default value of x while keeping the default value of the argument n. This
way of assigning values to variables makes it possible to specify the variables of the function in
whichever order you prefer:
newton(x=2.0, n=30)
The above is a valid call to the newton() function. You may include both optional and required
variables when calling a function. In this case, however, the order is important! Once you have
specified your first variable by name, no more variables may be specified according to order.
If you want to know more on specifying functions and their arguments, please see the function
section of the Python tutorial or this on-line resource on optional and required arguments.
USING NUMPY IN NANOLANGUAGE
The NumPy module is used throughout NanoLanguage to e.g. store values from analysis functions. It can be used to perform advanced mathematical operations at much faster pace than
using Python lists. NumPy objects resembles lists but they contain a lot more functionality. We
ship NanoLanguage with built-in NumPy support to easily facilitate its usage.
A few major differences between ordinary lists and a NumPy array can be seen from this short
NanoLanguage script:
84
Using NumPy in NanoLanguage
from numpy import array
a = array([1,2]) # a NumPy array
a = a+[3,4]
print a
Output:
[4, 6]
a = [1,2]
a = a+[3,4]
print a
# an ordinary Python list
Output:
[1, 2, 3, 4]
NumPy arrays can in many ways be regarded as matrices as they have much the same functionality:
a = array([[1,2],[3,4]])
a = a * [3,4]
print a
Output:
[[ 3 8]
[ 9 16]]
print a.trace()
Output:
19
a.transpose()
print a
Output:
[[ 3 9]
[ 8 16]]
print a.trace()
Output:
85
Appendix
19
Note in the above that the values 8 and 9 changed place in the matrix, however, the trace of
the matrix remains the same.
NumPy arrays may also be converted into lists
a = array([[1,2],[3,4]])
print a.tolist()
Output:
[[1, 2], [3, 4]]
There are many more possibilities using arrays from the NumPy module, plus it is usually faster
than iterating through for-loops or using lists!
More information about the NumPy module can be found at the NumPy homepage or by using
the dir() command on a NumPy array object. Details on how NumPy can be used for performance can be found on the Python speed/performance tips page.
PYTHON PACKAGES IN NANOLANGUAGE
A number of Python packages are part of the ATK distribution and can be used from the nlpython executable
Table 5.1: Python packages available from the nlpython executable
Package
Load Command Description
NumPy
import numpy
matplotlib import pylab
Support for linear algebra and numerical routines
Support for 2D plotting
math
import math
Support for a number of standard mathematical functions
ase
import ase
Support for a number of atomic-scale calculators
MAKING A 2D PLOT
The following script uses the NumPy and Matplotlib modules for making a 2D plot
from NanoLanguage import *
import pylab
x = numpy.linspace(-1,5,10)
y = numpy.exp(x)
pylab.figure()
pylab.plot(x,y)
pylab.show()
Note that the NumPy package is automatically loaded with the NanoLanguage module, and the
import numpy
86
Making a 2D Plot
statement is not needed.
87
88
BIBLIOGRAPHY
[1] ATK Manual “ATK version 2009.06”,
Atomistix A/S (www.atomistix.com).
[2] Phys. Rev. B 65, 165401, 2002 M. Brandbyge, J.-L. Mozos, P. Ordejón, J. Taylor, and K. Stokbro.
Phys. Rev. B, 65, 165401, 2002 (link).
[3] Math. Comp. 19, 577, 1965 C.G. Broyden. Math. Comp., 19, 577-593, 1965 (link).
[4] Phys. Rev. B 63, 54416, 2001 W.H. Butler, X.-G. Zhang, T.C. Schulthess, and J.M. MacLaren. Phys.
Rev. B, 63, 54416, 2001 (link).
[5] Phys. Rev. Lett. 45, 566, 1980 D.M. Ceperley and B.J Alder. Phys. Rev. Lett., 45, 566, 1980
[6] Phys. Rev. 136, B864, 1964 P. Hohenberg and W. Kohn. Phys. Rev., 136, B864, 1964 (link).
[7] Phys. Rev. B. 13, 5188, 1976 H.J. Monkhorst and J.D. Pack. Phys. Rev. B., 13, 5188, 1976 (link).
[8] Phys. Rev. Lett. 77, 3865, 1996 J.P. Perdew, K. Burke, and M. Ernzerhof. Phys. Rev. Lett., 77, 3865,
1996 (link).
[9] Phys. Rev. B 23, 5048, 1981 J.P. Perdew and A. Zunger. Phys. Rev. B, 23, 5048, 1981 (link).
[10] Chem. Phys. Lett. 73, 393, 1980 P. Pulay. Chem. Phys. Lett., 73, 393, 1980. (link)
[11] Nature 419, 906, 2002 R.H.M. Smit, Y. Noat, C. Untiedt, N. Lang, M.C. van Hemert, and J.M. van
Ruitenbeek. Nature, 419, 906, 2002 (link).
[12] J. Phys.: Condens. Matter 14, 2745, 2002 J.M. Soler, E. Artacho, J.D. Gale, A. García, J. Junquera,
P. Ordejón, and D. Sánchez-Portal, J. Phys.: Condens. Matter, 14, 2745, 2002.
[13] Comp. Mat. Sci. 27, 151, 2003 K. Stokbro, J.L. Mozos, P. Ordejón, M. Brandbyge, and J. Taylor.
Comp. Mat. Sci., 27, 151, 2003. (link)
[14] Phys. Rev. B 63, 245407, 2001 J. Taylor, H. Guo, and J. Wang. Phys. Rev. B, 63, 245407, 2001
(link).
[15] J. Phys. Cond. Mat. 16, S5819, 2004 D. Wortmann, G. Bihlmayer, and S. Blügel.
Mat., 16, S5819, 2004 (link).
J. Phys. Cond.
[16] Phys. Rev. Lett. 80, 890, 1998 Y. Zhang and W. Wang. Phys. Rev. Lett., 80, 890, 1998 (link).
[17] S. Datta S. Datta, “Electronic Transport in Mesoscopic Systems”, Cambridge University Press, (United
Kingdom), 1997.
[18] Theor. Chim. Acta. (1992) 82: 189-205 P. Culot, G. Dive, V.H. Nguyen, and J.M. Ghuysen. Theor.
Chim. Acta., 82, 189-205, 1992 (link).
89
Bibliography
[19] J. Chem. Phys. 113, 9978 (2000) G. Henkelman and H. Jonsson. J. Chem. Phys., 113, 9978, 2000
(link).
[20] Phys. Rev. B 65, 144433 (2002) H. L.Meyerheim, P. Popescu, N. Jedrecy. M. Vedpathak, M. SauvageSimkin, R. Pinchaux, B. Heinrich, and J. Kirchner. J. Chem. Phys., 113, 9978, 2000 (link).
[21] neb-98 H. Johnson, G. Mills, and K.W. Jacobsen. “Classical and Quantum Dynamics in Condensed
Phase Systems”, World Scientific, (Singapore), 1998 (link).
[22] Phys. Rev. B 67, 115404, 2003 K.S. Thygesen, M.V. Bollinger, and K.W. Jacobsen. Phys. Rev. B,
67, 115404, 2003 (link). Phys. Rev. Lett., 97, 237205, 2003.
[23] Phys. Rev. B 61, 7965, 2000 J. Cerda, F. Soria, and Phys. Rev. B, 61, 7965, 2000 (link).
[24] J. Phys. F 15, 851, (1985) M. P. Lopez Sancho, J. M. Lopez Sancho, and J. Rubio. J. Phys. F., 15,
851, 1985 (link).
[25] Phys. Rev B. 77, 155301, (2008). H. H. Sørensen, P. C. Hansen, D. E. Petersen, S. Skelboe, and K.
Stokbro. Phys. Rev. B, 77, 155301, 2008
[26] Phys. Rev. B. 59, 11936 (1999) S. Sanvito, C. J. Lambert, J. H. Jefferson, and A. M. Bratkovsky. Phys.
Rev. B, 59, 11936, 1999 (link).
[27] J. Chem. Phys. {\bf 20}, 837 (1952). M. Wolfsberg, and L. Helmholtz.
1952
J. Chem. Phys., 20, 837,
[28] J. Chem. Phys. 68, , 5498 (1978) M. H. Whangbo, and R. Hoffmann. J. Chem. Phys., 68, 5498,
1978
[29] J. Am. Chem. Soc. 100, 3686 (1978). J. H. Ammeter, H. B. Burgi, J. C. Thibeault, and R. Hoffmann. J. Am. Chem. Soc., 100, 3686, 1978
90
CORE NANOLANGUAGE ELEMENTS
The subsequent sections provide separate entries for each NanoLanguage class and function.
91
92
MoleculeConfiguration
MoleculeConfiguration — Class for representing an isolated structure, i.e a molecule.
SYNOPSIS
Namespace: NanoLanguage
Object MoleculeConfiguration(
elements,
cartesian_coordinates,
xyz_format
)
DESCRIPTION
Construction of an atomic configuration from its elements and the corresponding Cartesian
coordinates. The input can be given in two ways: (i) Either by supplying the elements and Cartesian coordinates as two separate lists of the same length, or (ii) by supplying a formatted XYZ
string as input.
List of Arguments
elements
A sequence containing the elements of the configuration.
cartesian_coordinates
A sequence containing a sequence of atomic coordinates
for each element in the configuration,
xyz_format
A XYZ formatted string representing the configuration.
When the xyz_format argument is used, the arguments
elements and cartesian_coordinates cannot be used.
OBJECT METHODS
A MoleculeConfiguration object provides the following query functions:
• get_calculator(): Return the calculator attached to the configuration, i.e. the calculator that
will be used for both simulation and analysis.
• get_cartesian_coordinates(): The Cartesian coordinates of the atoms.
• get_dielectric_regions(): Get the dielectric regions for the configuration.
• get_elements(): The elements of the configuration.
• get_metallic_regions(): Get the metallic regions for the configuration.
• get_symbols(): The element symbols of the configuration.
• nlprint(stream, name): Print a string containing an XYZ representation of the MoleculeConfiguration.
stream
The stream the XYZ representation should be written to.
93
MoleculeConfiguration
name
The name of the configuration being printed.
• set_calculator(calculator, initial_state): Attach a Calculator class to the configuration which will be used in calculations involving the configuration.
calculator
The Calculator object (HuckelCalculator) that should
be attached to the configuration.
initial_state
The initial state to be used for this configuration.
• set_dielectric_regions(dielectric_regions): Set the dielectric regions for the configuration.
dielectric_regions
A sequence of BoxRegions.
• set_metallic_regions(metallic_regions): Set the metallic regions for the configuration.
metallic_regions
A sequence of BoxRegions.
• update(): Using the configurations set calculator, a self-consistent solution is generated.
USAGE EXAMPLES
Define the geometry of and construct a water molecule:
# Import NanoLanguage modules
from NanoLanguage import *
# Set up elements and positions
elm = [ Oxygen, Hydrogen, Hydrogen ]
pos = [[ 0.000, 0.000, 0.0],
[ 0.757, 0.586, 0.0],
[-0.757, 0.586, 0.0]]*Angstrom
# Add them to a configuration
h2o = MoleculeConfiguration(elm, pos)
Alternative way of specification
# Import NanoLanguage modules
from NanoLanguage import *
# Set up elements and positions using xyz format
h2o = MoleculeConfiguration(xyz_format=
"""3
O
H
H
0.000 0.000 0.0
0.757 0.586 0.0
-0.757 0.586 0.0""")
NOTES
A molecule is considered to be a system isolated in space. The ATK calculators will place the
molecule within an unit cell, in order to obtain a real space grid for describing the effective
potential of the system.
94
BulkConfiguration
BulkConfiguration — Class for representing a periodic structure, i.e bulk configuration
SYNOPSIS
Namespace: NanoLanguage
Object BulkConfiguration(
bravais_lattice,
elements,
cartesian_coordinates,
cartesian_coordinates
)
DESCRIPTION
Construction of a bulk configuration from a BravaisLattice object bravais_lattice. The additional arguments are the elements, the Cartesian coordinates or fractional coordinates. The
cartesian_coordinates and fractional coordinates can not be given at the same time. The list
arguments containing the elements and coordinates must have the same length.
List of Arguments
bravais_lattice
A BravaisLattice defining the lattice of the bulk configuration.
elements
A sequence containing the elements of the configuration.
cartesian_coordinates
A sequence containing a sequence of atomic coordinates
for each element in the configuration,
cartesian_coordinates
A sequence containing sequences of fractional coordinates
for each element in the configuration
OBJECT METHODS
A BulkConfiguration object provides the following query functions:
• get_bravais_lattice(): Method for obtaining the BravaisLattice associated with a bulk
configuration
• get_calculator(): Return the calculator attached to the configuration, i.e. the calculator that
will be used for both simulation and analysis.
• get_cartesian_coordinates(): The Cartesian coordinates of the atoms.
• get_dielectric_regions(): Get the dielectric regions for the configuration.
• get_elements(): The elements of the configuration.
• get_metallic_regions(): Get the metallic regions for the configuration.
95
BulkConfiguration
• get_symbols(): The element symbols of the configuration.
• nlprint(stream, name): Print a string containing an ASCII description of the BulkConfiguration.
stream
The stream the description should be written to.
name
The name of the configuration being printed.
• repeat(na, nb, nc): Repeat the BulkConfiguration with the integer values na, nb, and
nc along the three primitive unit cell vectors. The repeated system is constructed with a cell
of the type UnitCell.
na
The repetition along the a-axis.
nb
The repetition along the b-axis.
nc
The repetition along the c-axis.
• set_calculator(calculator, initial_state): Attach a Calculator class to the configuration which will be used in calculations involving the configuration.
calculator
The Calculator object (HuckelCalculator) that should
be attached to the configuration.
initial_state
The initial state to be used for this configuration.
• set_dielectric_regions(dielectric_regions): Set the dielectric regions for the configuration.
dielectric_regions
A sequence of BoxRegions.
• set_metallic_regions(metallic_regions): Set the metallic regions for the configuration.
metallic_regions
A sequence of BoxRegions.
• update(): Using the configurations set calculator, a self-consistent solution is generated.
USAGE EXAMPLES
Define the geometry of a lithium BCC crystal
# Import NanoLanguage modules
from NanoLanguage import *
lattice = BodyCenteredCubic( 3.509 * Ang)
li_bcc_bulk = BulkConfiguration(
lattice,
[Lithium],
[ ( 0.0, 0.0, 0.0 ) * Ang ]
)
Specify the geometry of a diamond crystal
# Import NanoLanguage modules
from NanoLanguage import *
elements = [ Carbon ] * 2
96
coordinates = [
( 0.00, 0.00, 0.00 ),
( 0.25, 0.25, 0.25 )
]
diamond_lattice = FaceCenteredCubic( 3.567 * Ang )
diamond = BulkConfiguration(
diamond_lattice,
elements,
fractional_coordinates = coordinates
)
NOTES
ATK recognizes three types of atomic geometries:
• Molecules (MoleculeConfiguration)
• Bulk (BulkConfiguration)
• Two Probe (DeviceConfiguration)
1D or 2D periodic geometries, such as nanotubes, slabs, and atomic chains must be represented
as a BulkConfiguration with sufficient vacuum to isolate the system in the non-periodic directions. A molecule (MoleculeConfiguration) is a 0D system, and the calculators in ATK use
a similar trick for performing calculations on molecule systems.
97
98
DeviceConfiguration
DeviceConfiguration — Class for representing a structure coupled with semi-infinite bulk, i.e.
one-probe, two-probe, etc.
SYNOPSIS
Namespace: NanoLanguage
Object DeviceConfiguration(
central_region,
electrodes
)
DESCRIPTION
Construction of the device configuration class. The DeviceConfiguration is formed from a
central region given as BulkConfiguration, and one or more electrodes given as BulkConfiguration(s) as well.
List of Arguments
central_region
The central described as a BulkConfiguration.
electrodes
Electrodes of the device given as a BulkConfiguration or
a sequence of BulkConfiguration's. If there is only one
given one-electrode it is considered a one-probe. If two
electrodes are given, the device is considered a two-probe,
with the first considered to the left electrode, and the second the right electrode. If three electrodes are given, it is
considered a three-probe, where the third electrode is the
gate electrode.
OBJECT METHODS
A DeviceConfiguration object provides the following query functions:
• get_bravais_lattice(): Method for getting the Bravais lattice of the central region
• get_calculator(): Return the calculator attached to the configuration, i.e. the calculator that
will be used for both simulation and analysis.
• get_cartesian_coordinates(): The Cartesian coordinates of the atoms.
• get_central_region(): Method for obtaining the central region of a DeviceConfiguration
• get_dielectric_regions(): Method for getting the dielectric regions of the central region.
• get_electrodes(): Method for obtaining the electrode BulkConfiguration of a DeviceConfiguration
99
DeviceConfiguration
• get_electrodes_displacement(): Method for obtaining the displacement of the BravaisLattice of the electrodes in the C-direction in order to match the BravaisLattice of the
central_region
• get_elements(): Method for getting the elements of the central region.
• get_metallic_regions(): Method for getting the metallic regions of the central region.
• get_symbols(): The element symbols of the configuration.
• nlprint(stream, name): Print a string containing an ASCII description of the DeviceConfiguration.
stream
The stream the description should be written to.
name
The name of the configuration being printed.
• set_calculator(calculator, initial_state): Attach a Calculator class to the configuration which will be used in calculations involving the configuration.
calculator
The Calculator object (HuckelCalculator) that should
be attached to the configuration.
initial_state
The initial state to be used for this configuration.
• set_dielectric_regions(dielectric_regions): Set the dielectric regions of the central
region.
dielectric_regions
A sequence of BoxRegions.
• set_metallic_regions(metallic_regions): Set the metallic regions of the central region
metallic_regions
A sequence of BoxRegions.
• update(): Using the configurations set calculator, a self-consistent solution is generated.
USAGE EXAMPLES
Construct a device system consisting of a hydrogen molecule connected with two chains of
Lithium atoms.
from NanoLanguage import *
# Define A,B directions of lattice
vector_a = [5.0, 0.0, 0.0]*Angstrom
vector_b = [0.0, 5.0, 0.0]*Angstrom
# setup electrode
electrode = BulkConfiguration(
bravais_lattice=UnitCell(vector_a, vector_b,
[0.0, 0.0, 9.0]*Angstrom),
elements=[Lithium, Lithium, Lithium],
cartesian_coordinates=[[ 2.5, 2.5, 1.5],
[ 2.5, 2.5, 4.5],
[ 2.5, 2.5, 7.5]]*Angstrom
)
# setup Central region
central_region = BulkConfiguration(
bravais_lattice= UnitCell(vector_a, vector_b,
100
[0.0, 0.0, 22.0]*Angstrom),
elements=[Lithium, Lithium, Lithium, Hydrogen, Hydrogen,
Lithium, Lithium, Lithium],
cartesian_coordinates=[[ 2.5,
2.5,
1.5],
[ 2.5,
2.5,
4.5],
[ 2.5,
2.5,
7.5],
[ 2.5,
2.5, 10.5],
[ 2.5,
2.5, 11.5],
[ 2.5,
2.5, 14.5],
[ 2.5,
2.5, 17.5],
[ 2.5,
2.5, 20.5]]*Angstrom
)
#setup Device configuration
device_configuration = DeviceConfiguration(
central_region,
[electrode, electrode]
)
NOTES
• The setup of device configurations with two electrodes
A device system with two electrodes is created by placing two electrode BulkConfiguration to the left and the right of of a central BulkConfiguration. The properties within the
electrode regions are fixed at their bulk properties, while the central region of the device
configuration is described self-consistently. The device configuration must fulfill the following
properties:
◦ The electrodes and the central BulkConfiguration must have the same cell vectors in the A
and B direction.
◦ The C direction must be perpendicular to the A and B directions.
◦ If the left A-B face of the central unit cell is aligned with the left A-B face of the left electrode,
the first atoms in the central unit cell must be identical with the atoms in the left electrode.
See Figure 6 for an example.
◦ If the right A-B face of the central unit cell is aligned with the right A-B face of the right
electrode, the last atoms in the central unit cell must be identical with the atoms in the right
electrode. See Figure 6 for an example.
101
DeviceConfiguration
Figure 6: Upper panel: Example for the constituents of a device system with 2 electrodes. The
constituents are Left Electrode, Central Region, Right Electrode. Note that the first atoms in the central
region must be positioned identical to the atoms in the left electrode. Similarly, the last atoms in the
central region must be positioned relative to the right face of the unit cell, identical to the atoms in the
right electrode. Lower panel: The (periodically-repeated) two-probe system. The unit cell of the central
region is indicated with dashed lines while the unit cells of the electrodes are indicated by solid lines.
102
BoxRegion
BoxRegion — Class for representing an orthorhombic region, i.e. a rectangular box of metallic
or dielectric material.
SYNOPSIS
Namespace: NanoLanguage
Object BoxRegion(
value,
xmin,
xmax,
ymin,
ymax,
zmin,
zmax
)
DESCRIPTION
A box region object. The box is infinite in a direction if the direction is not specified.
List of Arguments
value
The value that should be assigned to the box.
xmin
The lower boundary of the box along the x-axis.
xmax
The upper boundary of the box along the x-axis.
ymin
The lower boundary of the box along the y-axis.
ymax
The upper boundary of the box along the y-axis.
zmin
The lower boundary of the box along the z-axis.
zmax
The upper boundary of the box along the z-axis.
OBJECT METHODS
A BoxRegion object provides the following query functions:
• get_value(): Function for asking for the value of the box region.
• get_xmax(): Function for asking for the maximum x-value of the box
• get_xmin(): Function for asking for the minimum x-value of the box
• get_ymax(): Function for asking for the maximum y-value of the boy
• get_ymin(): Function for asking for the minimum y-value of the box
103
BoxRegion
• get_zmax(): Function for asking for the maximum z-value of the box
• get_zmin(): Function for asking for the minimum z-value of the box
USAGE EXAMPLES
Define a dielectric region with dielectric constant
dielectric_region = BoxRegion(
4.,
xmin = 0*Angstrom, xmax = 41.439*Angstrom,
ymin = 0.5*Angstrom, ymax = 3.57914*Angstrom,
zmin = 5*Angstrom, zmax = 50.4135*Angstrom
)
Define a metallic region with electro-static potential 1 Volt.
metallic_region = BoxRegion(
1*Volt,
xmin = 0*Angstrom, xmax = 41.439*Angstrom,
ymin = 0*Angstrom, ymax = 0.5*Angstrom,
zmin = 5*Angstrom, zmax = 15.*Angstrom
)
NOTES
104
HuckelCalculator
HuckelCalculator — Class for representing calculations using the extended Huckel model for
configurations of the type MoleculeConfiguration and BulkConfiguration.
SYNOPSIS
Namespace: NanoLanguage
Object HuckelCalculator(
basis_set,
numerical_accuracy_parameters,
iteration_control_parameters,
poisson_solver,
weighting_scheme
)
DESCRIPTION
The constructor for the HuckelCalculator.
List of Arguments
basis_set
An object describing the basis set used for the ExtendedHuckel calculation. For further information, please consult
the section.
numerical_accuracy_parameters
The NumericalAccuracyParameters used for the selfconsistent Huckel calculation.
iteration_control_parameters
The IterationControlParameters used for the self-consistent Huckel calculation. For non-self-consistent calculations set this parameter to NotSelfConsistent.
poisson_solver
The Poisson solver used to determine the electrostatic potential.
weighting_scheme
The weighting scheme used for calculating off-site matrix
elements of the Huckel Hamiltonian. For further information, please consult the section.
OBJECT METHODS
A HuckelCalculator object provides the following query functions:
• get_basis_set(): Query method for getting the basis set.
• get_iteration_control_parameters(): Query method for the IterationControlParameters.
• get_numerical_accuracy_parameters(): Query method for the NumericalAccuracyParameters.
105
HuckelCalculator
• get_poisson_solver(): Query method for getting the Poisson solver.
• get_weighting_scheme(): Query method for the Weighting Scheme
USAGE EXAMPLES
Define a Hückel calculator with user defined IterationControlParameters
from NanoLanguage import *
iteration_control_parameters = IterationControlParameters(
damping_factor=0.05,
number_of_history_steps=12,
)
calculator = HuckelCalculator(
iteration_control_parameters=iteration_control_parameters,
)
Define a Hückel calculator without a Hartree term, i.e. non-self-consistent model.
from NanoLanguage import *
calculator = HuckelCalculator(
iteration_control_parameters=NonSelfconsistent
)
Restart a Hückel calculation using the self-consistent state from a previous calculation
from NanoLanguage import *
# Read in the BulkConfiguration with the old scf state
old_calculation=nlread("filename.nc",BulkConfiguration)[0]
# Define the BulkConfiguration with similar number of atoms
new_calculation=BulkConfiguration(...)
# Define the calculator
calculator = HuckelCalculator()
# Attach the calculator and use the old initial state
new_calculation.set_calculator(calculator,initial_state=old_calculation)
NOTES
For the mathematical definition of the extended-Hückel model, see Background Information.
106
DeviceHuckelCalculator
DeviceHuckelCalculator — Class for representing calculations using the extended Huckel
Model for DeviceConfigurations.
SYNOPSIS
Namespace: NanoLanguage
Object DeviceHuckelCalculator(
electrode_calculators,
contour_parameters,
basis_set,
numerical_accuracy_parameters,
iteration_control_parameters,
weighting_scheme,
self_energy_calculator_real,
self_energy_calculator_complex,
poisson_solver,
electrode_voltages
)
DESCRIPTION
A DeviceHuckelCalculator object.
List of Arguments
electrode_calculators
A sequence of HuckelCalculator's containing a calculator for each electrode.
contour_parameters
The DoubleContourIntegralParameters used for the
complex contour integration.
basis_set
An object describing the basis set used for the ExtendedHuckel calculation. For further information, please consult
the section.
numerical_accuracy_parameters
The NumericalAccuracyParameters used for the selfconsistent Huckel calculation.
iteration_control_parameters
The IterationControlParameters used for the self-consistent Huckel calculation. For non-self-consistent calculations set this parameter to NotSelfConsistent.
weighting_scheme
The weighting scheme used for calculating off-site matrix
elements of the Huckel Hamiltonian. For further information, please consult the section.
self_energy_calculator_real
The SelfEnergyCalculator that should be used for real
energies.
107
DeviceHuckelCalculator
self_energy_calculator_complex
The SelfEnergyCalculator that should be used for the
complex energies.
poisson_solver
The Poisson solver used to determine the electrostatic potential.
electrode_voltages
The voltages applied to the electrodes.
OBJECT METHODS
A DeviceHuckelCalculator object provides the following query functions:
• get_basis_set(): Query method for used basis set.
• get_contour_parameters(): Query method for the DoubleContourIntegralParameters.
• get_electrode_calculators(): Query method for the electrode calculators (see HuckelCalculator).
• get_electrode_fermi_levels(): Query method for the electrode Fermi levels.
• get_electrode_voltages(): Query method for the electrode voltages.
• get_iteration_control_parameters(): Query method for the IterationControlParameters.
• get_numerical_accuracy_parameters(): Query method for the NumericalAccuracyParameters.
• get_poisson_solver(): Query method for getting the Poisson solver.
• get_self_energy_calculator_complex(): Query method for getting the self energy calculator for the complex energies.
• get_self_energy_calculator_real(): Query method for getting the self energy calculator
for the real energies.
• get_weighting_scheme(): Query method for the Weighting Scheme
USAGE EXAMPLES
Define a DeviceHuckelCalculator with user defined NumericalAccuracyParameters,
MultigridSolver, and DoubleContourIntegralParameters
numerical_accuracy_parameters = NumericalAccuracyParameters(
grid_mesh_cutoff = 10.*Units.Hartree,
k_point_sampling=(3,2,100),
interaction_max_range = 10.*Angstrom,
)
electrode_poisson_solver = MultigridSolver(
boundary_conditions=[PeriodicBoundaryCondition,
PeriodicBoundaryCondition,
PeriodicBoundaryCondition]
)
poisson_solver = MultigridSolver(
boundary_conditions=[PeriodicBoundaryCondition,
PeriodicBoundaryCondition,
108
DirichletBoundaryCondition]
)
electrode_calculator = HuckelCalculator(
numerical_accuracy_parameters=numerical_accuracy_parameters,
poisson_solver=electrode_poisson_solver
)
contour_parameters = DoubleContourIntegralParameters(
integral_lower_bound=5.0*Units.Hartree
)
device_calculator = DeviceHuckelCalculator(
electrode_calculators=[electrode_calculator,electrode_calculator],
contour_parameters = contour_parameters,
numerical_accuracy_parameters = numerical_accuracy_parameters,
poisson_solver=poisson_solver,
electrode_voltages=(0.2*Volt, -0.3*Volt)
)
Perform a voltage sweep, and calculate I-V characteristics
calculator = DeviceHuckelCalculator()
device_configuration = DeviceConfiguration(...)
# Define voltages for voltage ramp, [0.0,0.1, ..., 1.0]*Volt
voltages = numpy.linspace(0.0,1.0,11)*Volt
v in voltages:
# Set the calculator on the configuration using the old calculation as starting input.
device_configuration.set_calculator(calculator(electrode_voltages=(0*Volt,v)),
initial_state=device_configuration)
# Calculate the transmission
t = TransmissionSpectrum(device_configuration)
# Calculate the current.
current = t.get_current()
print t.get_bias(), t.get_current()
Perform a gate bias scan
calculator = DeviceHuckelCalculator()
device_configuration = DeviceConfiguration(...)
metal_region = BoxRegion(...)
# Define gate_voltages for scan, [0.0,0.1, ..., 1.0]*Volt
gate_voltage=numpy.linspace(0.0,1.0,11)*Volt
for v in gate_voltage:
device_configuration.set_metallic_regions([metallic_region(value = gate_voltage)] )
# Set the calculator on the configuration using the old calculation as starting input.
device_configuration.set_calculator(calculator(), initial_state=device_configuration)
# Calculate the transmission
t = TransmissionSpectrum(device_configuration)
# Calculate the conductance
print t.get_bias(), t.get_conductance()
NOTES
The parameters for the constructor of a DeviceHuckelCalculator object and the parameters of
its electrode calculators must fulfill the following conditions:
109
DeviceHuckelCalculator
• The NumericalAccuracyParameters must be the same for the electrodes and the device.
The central region of the device does not use k-points in the C-direction and this parameter
is only used for the electrodes. The electrodes need a very dense k-point sampling in the C
direction.
• The poisson_solver must be set to the MultigridSolver with the same boundary conditions
in the A and B directions for the electrodes and device. In the C directions the user setting is
ignored and the program always uses PeriodicBoundaryCondition for the electrodes and
DirichletBoundaryCondition for the device.
• The electrode_voltages rise to a shift of the Fermi Levels of the electrodes by
, where
is the applied bias. Thus, a positive
on the right electrode, gives rise to an electron
flow from left to right, corresponding to an electrical current from right to left.
For the mathematical definition of the extended-Hückel model, see Background Information.
110
IterationControlParameters
IterationControlParameters — Class for representing the parameters relevant for SCF iteration
control within self-consistent electronic structure models
SYNOPSIS
Namespace: NanoLanguage
Object IterationControlParameters(
tolerance,
max_steps,
algorithm,
damping_factor,
number_of_history_steps,
start_mixing_after_step,
mixing_variable
)
DESCRIPTION
List of Arguments
tolerance
The accuracy which the SCF loop must reach before termination.
max_steps
The maximum number of iteration steps the SCF loop
should execute.
algorithm
The mixing strategy employed on the mixing variable in the
SCF loop.
damping_factor
The fraction of the output value of the mixing parameter
which is mixed into the next step.
number_of_history_steps
The total number of history steps to take into account for
the mixing algorithm.
start_mixing_after_step
The total number of steps to wait before the mixing algorithm is used.
mixing_variable
The mixing variable used in the SCF loop.
OBJECT METHODS
A IterationControlParameters object provides the following query functions:
• get_algorithm(): Return the mixing algorithm stored by the IterationControlParameters object
• get_damping_factor(): Return the damping factory stored by the IterationControlParameters object
111
IterationControlParameters
• get_max_steps(): Return the maximum steps value stored by the IterationControlParameters object
• get_mixing_variable(): Return the mixing variable stored by the IterationControlParameters object
• get_number_of_history_steps(): Return the number of history steps value stored by the
IterationControlParameters object
• get_start_mixing_after_step(): Return the step to start mixing after value stored by the
IterationControlParameters object
• get_tolerance(): Return the tolerance value stored by the IterationControlParameters object
USAGE EXAMPLES
Setup iteration control parameters for difficult convergence case
from NanoLanguage import *
iteration_control_parameters = IterationControlParameters(
damping_factor=0.05,
number_of_history_steps=12,
)
calculator = HuckelCalculator(
iteration_control_parameters=iteration_control_parameters,
)
NOTES
Currently the only SCF mixing algorithm is a PulayMixer. The Pulay Mixer implements the
Pulay-Kerker method
where
is the input value and
is the output value of the mixing_variable at iteration .
the number_of_history_steps used for finding
The parameter is the damping_factor and
the input value for the next iteration. The variables are obtained by minimizing the Residual
error of the mixing_variable assuming a linear relation between the residual errors of different
iteration numbers.
• A few notes on the variable tolerance are listed in the following.
◦ The tolerance in ATK is not relative, but absolute. For the total energy and the bandstructure energy the internal unit is Hartree, thus for these quantities the tolerance gives the
accuracy as measured in Hartree. For iteration control of a matrix (e.g., the Hamiltonian
or the density matrix) it is maximum value of the difference between the corresponding
matrix elements of the old and new matrix.
This means that the tolerance should be interpreted as given in Hartree for the total energy,
the band-structure energy, and the Hamiltonian, and as dimensionless for the density matrix. The tolerance parameter itself should, however, always be given without any unit!
◦ In order to achieve a better accuracy than the one corresponding to the choice of default
values, it is often a good idea to decrease the tolerance by one or two orders of magnitude.
112
Often, but not always, this will only add a few extra iterations to the calculation, since the
Pulay mixing algorithm usually performs very well once it approaches equilibrium. If only
a fast rough estimation of the results is needed the accuracy can be lowered by increasing
the tolerance value.
113
114
NumericalAccuracyParameters
NumericalAccuracyParameters — Class for representing the parameters for setting numerical
accuracy of a calculation.
SYNOPSIS
Namespace: NanoLanguage
Object NumericalAccuracyParameters(
grid_mesh_cutoff,
k_point_sampling,
radial_grid_sampling,
density_cutoff,
interaction_max_range,
number_of_reciprocal_points,
reciprocal_energy_cutoff,
electron_temperature
)
DESCRIPTION
A NumericalAccuracyParameters object.
List of Arguments
grid_mesh_cutoff
The mesh cutoff to be used to determine the grid sampling.
The grid_mesh_cutoff must be an energy quantity.
k_point_sampling
The k-point sampling in reciprocal space given by the Monkhorst-Park indices.
radial_grid_sampling
The sampling distance in all the radial grids as length quantity. The default is 0.01*Units.Angstrom.
density_cutoff
The density cutoff determines the limit where a density is
considered to to be zero. Smaller values therefore leads to
longer ranges and less sparsity of the models.
interaction_max_range
The interaction max_range determines the maximum allowed interaction distance between two orbital.
number_of_reciprocal_points
The number of reciprocal points used for evaluating twocenter integrals.
reciprocal_energy_cutoff
The energy cutoff in reciprocal space used for evaluating
of the two-center integrals.
electron_temperature
The electron temperature used in determining the shape of
the Fermi function.
OBJECT METHODS
A NumericalAccuracyParameters object provides the following query functions:
115
NumericalAccuracyParameters
• get_density_cutoff(): Query method for getting the density cutoff.
• get_electron_temperature(): Query method for getting the electron temperature.
• get_grid_mesh_cutoff(): Query method for getting the grid mesh cutoff distance.
• get_interaction_max_range(): Query method for getting the density cutoff.
• get_k_point_sampling(): Query method for getting the k-point sampling.
• get_number_of_reciprocal_points(): Query method for getting the number of reciprocal
points used in two-center integration.
• get_radial_grid_sampling(): Query method for getting the radial grid sampling.
• get_reciprocal_energy_cutoff(): Query method for getting the reciprocal cutoff energy.
USAGE EXAMPLES
Define the k-point sampling and real space grid mesh-cutoff.
from NanoLanguage import *
numerical_accuracy_parameters = NumericalAccuracyParameters(
grid_mesh_cutoff=12.0*Hartree,
k_point_sampling=(2, 1, 1),
electron_temperature = 200*Kelvin
)
calculator = HuckelCalculator(
iteration_control_parameters=iteration_control_parameters,
)
Specify the electron temperature in units of eV instead of Kelvin
numerical_accuracy_parameters = NumericalAccuracyParameters(
electron_temperature = 0.02 * electronVolt/Boltzmann_constant
)
NOTES
• The distance between the points in the real space grid,
off,
, through
In atomic units
, is related to the grid_mesh_cut-
, thus for energies in Hartree and distances in Bohr,
.
• When setting interaction_max_range some matrix elements are set to zero. For very long
ranged basis sets this can make the overlap matrix ill defined at certain k-points (i.e. it is not
positive definite), in such cases the matrix diagonalization routine will give a segmentation
fault. The cure is to change the interaction_max_range , i.e. either make it very large to
include all long range elements, or make it small so no long range elements are included.
116
HuckelBasisParameters
HuckelBasisParameters — Class for representing the parameters that determine the properties
of a Huckel basis.
SYNOPSIS
Namespace: NanoLanguage
Object HuckelBasisParameters(
element,
orbitals,
ionization_potential,
onsite_hartree_shift,
number_of_valence_electrons,
wolfsberg_helmholtz_constant,
vacuum_level
)
DESCRIPTION
Construction of the parameters that determines the properties of a Huckel Basis.
List of Arguments
element
The PeriodicTable element associated with the basis set.
orbitals
The basis orbitals.
ionization_potential
The ionization potential for each of the given orbitals
onsite_hartree_shift
The on-site Hartree shift.
number_of_valence_electrons
The number of valence electrons used to determine the
neutral state.
wolfsberg_helmholtz_constant
The Wolfsberg-Helmholtz constant provided as a float.
vacuum_level
The energy level of vacuum.
OBJECT METHODS
A HuckelBasisParameters object provides the following query functions:
• get_element(): Query method for getting the element of the basis set.
• get_ionization_potential(): Query for getting the ionization potential of the basis set.
• get_number_of_valence_electrons(): Query method for getting the number of valence electrons assigned to the basis set.
117
HuckelBasisParameters
• get_onsite_hartree_shift(): Query method for getting the on-site Hartree shift of the basis
set.
• get_orbitals(): Query for getting the orbitals of the basis set.
• get_vacuum_level(): Query method for getting the vacuum level of the basis set.
• get_wolfsberg_helmholtz_constant(): Query method for getting the Wolfsberg-Helmholtz
constant.
• serialize(): Serialize the basis set.
USAGE EXAMPLES
Define an Extended Huckel Basis for Carbon
from NanoLanguage import *
carbon_2s = SlaterOrbital(
principal_quantum_number=2,
azimuthal_quantum_number=0,
slater_coefficients=[ 2.0249*1/Bohr ],
weights=[ 0.76422*1/Bohr**1.5 ]
)
carbon_2p = SlaterOrbital(
principal_quantum_number=2,
azimuthal_quantum_number=1,
slater_coefficients=[ 1.62412*1/Bohr , 2.17687*1/Bohr ],
weights=[ 0.27152*1/Bohr**1.5 , 0.73886*1/Bohr**1.5 ]
)
carbon_3d = SlaterOrbital(
principal_quantum_number=3,
azimuthal_quantum_number=2,
slater_coefficients=[ 1.1944*1/Bohr ],
weights=[ 0.49066*1/Bohr**1.5 ]
)
CarbonBasis = HuckelBasisParameters(
element=Carbon,
orbitals=[ carbon_2s , carbon_2p , carbon_3d ],
ionization_potential=[ -19.88924*eV , -13.08001*eV , -2.04759*eV ],
onsite_hartree_shift=10.207*eV,
number_of_valence_electrons=4,
wolfsberg_helmholtz_constant=2.8,
vacuum_level=0.0*eV,
)
NOTES
Tables with the available parameter sets can be found in the section called “The Extended-Hückel Parameters”.
The overlap matrix,
is the central object in the extended Huckel model, where
one-electron Hamiltonian is defined by
118
is of the type SlaterOrbital. The
where the parameters
and the vacuum_level,
is the ionization_potential, the wolfsberg_helmholtz_constant,
, is used to shift the position of the vacuum level.
is the Hartree potential, which is obtained by solving Poisson's equation for the charge
density
where
is the total charge of atom , i.e. the sum of the Mulliken population
and the ionic charge
.
The width of the Gaussian,
, is specified through the onsite_hartree_shift,
.
Table 7: HuckelBasisParameters
Symbol
HuckelBasisParameters
ionization_potential
wolfsberg_helmholtz_constant
onsite_hartree_shift
vacuum_level
119
120
SlaterOrbital
SlaterOrbital — Class for representing a Slater orbital.
SYNOPSIS
Namespace: NanoLanguage
Object SlaterOrbital(
principal_quantum_number,
azimuthal_quantum_number,
slater_coefficients,
weights
)
DESCRIPTION
Constructor for the Slater orbitals.
List of Arguments
principal_quantum_number
The Principal quantum number (n) of the orbital.
azimuthal_quantum_number
The Azimuthal quantum number (l) of the orbital.
slater_coefficients
The Slater coefficients as inverse length
weights
The weight for each of the Slater coefficients.
OBJECT METHODS
A SlaterOrbital object provides the following query functions:
• get_angular_momentum(): Query method for getting the angular momentum for the orbital.
• serialize(): Method for serializing the Slater orbital.
USAGE EXAMPLES
Define a 1s Slater orbital from a single exponential function
from NanoLanguage import *
carbon_2s = SlaterOrbital(
principal_quantum_number=2,
azimuthal_quantum_number=0,
slater_coefficients=[ 2.0249*1/Bohr ],
weights=[ 0.76422*1/Bohr**1.5 ]
)
Define a 2p Slater orbital as superposition of two exponential functions
from NanoLanguage import *
carbon_2p = SlaterOrbital(
121
SlaterOrbital
principal_quantum_number=2,
azimuthal_quantum_number=1,
slater_coefficients=[ 1.62412*1/Bohr , 2.17687*1/Bohr ],
weights=[ 0.27152*1/Bohr**1.5 , 0.73886*1/Bohr**1.5 ]
)
NOTES
Within the extended-Hückel Model, the electronic structure is expanded in a basis of local
atomic orbitals (LCAO's)
where
is a spherical harmonic and
is a Slater orbital
The Slater orbital is described by the adjustable parameters
, and . These parameters
must be defined for each angular shell of valence orbitals for each element.
Table 8:Slater orbital parameters
Symbol
SlaterOrbital parameters
principal_quantum_number
azimuthal_quantum_number
slater_coefficients
weights
In the current version we provide a Hoffmann parameter set which is appropriate for organic
molecules. The parameter set is available with the keyword HoffmannHuckelParameters.ElementName, where ElementName is the name of the element. For crystal parameters, we refer to
the website of J. Cerda. and his paper [23].
122
DoubleContourIntegralParameters
DoubleContourIntegralParameters — Class for representing the parameters relevant for setting
up a complex contour integration.
SYNOPSIS
Namespace: NanoLanguage
Object DoubleContourIntegralParameters(
integral_lower_bound,
circle_eccentricity,
logarithmic_bunching,
circle_points,
real_axis_point_density,
real_axis_infinitesimal,
real_axis_kbt_padding_factor,
fermi_line_points,
fermi_function_poles
)
DESCRIPTION
List of Arguments
integral_lower_bound
The distance between the lowest Fermi-level to the lowest
energy circle contour point. This must be an energy quantity (default is 1.5 Hartree).
circle_eccentricity
The eccentricity of the circle contour, 0 -> circle, 1 -> line.
logarithmic_bunching
Logarithmic bunching of the circle contour points, 0 -> no
bunching,
circle_points
The number of points on the circle contour.
real_axis_point_density
Spacing between the points on bias window integration
line close to the real axis . This must be an energy quantity,
(default is 0.001 Hartree).
real_axis_infinitesimal
Small imaginary shift of the bias window integration line
from the real axis . This must be an energy quantity (default
is 0.001 Hartree).
real_axis_kbt_padding_factor
The integration line is extended with the amount real_axis_kbt_padding_factor*k_b*T below and above the electrode Fermi levels.
fermi_line_points
The number of points on the line from the Fermi energy
level up to infinity.
fermi_function_poles
The number of poles the Fermi function should have between the Fermi energy level and infinity.
123
DoubleContourIntegralParameters
OBJECT METHODS
A DoubleContourIntegralParameters object provides the following query functions:
• get_circle_eccentricity(): Return the eccentricity of circle contour, 0 -> circle, 1 -> line.
• get_circle_points(): Return the number of points on the circle contour.
• get_fermi_function_poles(): The number of poles, the Fermi function should have between
the Fermi energy level and infinity.
• get_fermi_line_points(): The number of points on the line from the Fermi energy level up
to infinity.
• get_integral_lower_bound(): Return the distance from the lowest Fermi-level to the lowest
energy circle contour point.
• get_logarithmic_bunching(): Return the logarithmic bunching of the circle contour points,
0 -> no bunching, 1 -> all points close to upper circle contour point.
• get_real_axis_infinitesimal(): Return the complex shift of the the non-equilibrium integration line above the real axis.
• get_real_axis_kbt_padding_factor(): Return the scaling of k_b*T used for extending the
line integration line below and above the electrode Fermi levels.
• get_real_axis_point_density(): Return the density of the points on the non-equilibrium
integration line.
USAGE EXAMPLES
Define the most important DoubleContourIntegralParameters
from NanoLanguage import *
contour_parameters = DoubleContourIntegralParameters(
integral_lower_bound = 5.*Hartree,
circle_points = 30,
real_axis_point_density = 0.002*eV,
real_axis_infinitesimal=1e-05*eV
)
NOTES
The double contour defines two equilibrium contours, to the left and to the right of the Fermi
levels, and a real axis non-equilibrium contour between the two Fermi levels. The different
contour integrals are mixed according to the scheme in [2] to give a highly accurate and reliable
calculation of the density matrix at a finite bias.
124
Figure 7: Points on the double contour for an applied bias of 1 Volt. The two equilibrium contours (black
circles, red circles) start at integral_lower_bound = 60.0*eV below the Fermi levels. There are 30
circle_points on each contour, and the ellipsoid form of the circle is due to an circle_eccentricity of
0.3. The point density on the circle is higher near the Fermi levels due to a logarithmic_bunching of 0.3.
The inset shows a magnification of the region around the Fermi levels. We see that each equilibrium
contour has 2 fermi_function_poles points positioned above each Fermi level at the Fermi poles, and
10 fermi_line_points covering the region from the end of the circle contour to infinity. The blue crosses
shows the points on the real axis for the non-equilibrium part of the contour with
real_axis_point_density = 0.01*eV. Note that the non-equilibrium points extend a little below and
above the Fermi levels, due to a real_axis_kbt_padding_factor of 5.
125
126
The following PoissonSolvers are supported by ATK
• MultigridSolver
127
128
MultigridSolver
MultigridSolver — Class for representing a multigrid-based Poisson solver.
SYNOPSIS
Namespace: NanoLanguage
Object MultigridSolver(boundary_conditions)
DESCRIPTION
Constructor for a multigrid-based Poisson solver.
List of Arguments
boundary_conditions
The boundary conditions for the multigrid solver.
OBJECT METHODS
A MultigridSolver object provides the following query functions:
• get_boundary_conditions(): Query method to obtain boundary conditions.
USAGE EXAMPLES
Define a Multi-grid solver with specified boundary conditions on the 6 faces
from NanoLanguage import *
poisson_solver = MultigridSolver(
boundary_conditions=[[DirichletBoundaryCondition, NeumannBoundaryCondition ],
[DirichletBoundaryCondition, DirichletBoundaryCondition],
[PeriodicBoundaryCondition , PeriodicBoundaryCondition ]]
)
calculator = HuckelCalculator(poisson_solver=poisson_solver)
Define a Multi-grid solver with specified boundary conditions in the A, B, and C-direction, but
similar boundary conditions on opposite faces.
from NanoLanguage import *
poisson_solver = MultigridSolver(
boundary_conditions=[DirichletBoundaryCondition,
DirichletBoundaryCondition,
PeriodicBoundaryCondition ]
)
calculator = HuckelCalculator(poisson_solver=poisson_solver)
NOTES
129
130
The following SelfEnergyCalculator are supported by ATK
• DirectSelfEnergy
• RecursionSelfEnergy
• KrylovSelfEnergy
131
132
DirectSelfEnergy
DirectSelfEnergy — Class for representing a self energy calculation using direct diagonalization.
SYNOPSIS
Namespace: NanoLanguage
Object DirectSelfEnergy(
save_self_energies,
lambda_min
)
DESCRIPTION
Constructor for a self-energy calculator based on the direct method. The direct method use direct
diagonalization for getting all the electrode modes.
List of Arguments
save_self_energies
If True, the self energies are stored between iterations for
maximum speed.
lambda_min
The smallest logarithmic decrement of a mode to take into
account.
OBJECT METHODS
A DirectSelfEnergy object provides the following query functions:
• get_lambda_min(): Query method for getting the lambda min value defined in paper (......)
• get_save_self_energies(): Query method for getting the Boolean telling if the self energies
should be saved or not
• set_save_self_energies(): Set method for setting the Boolean telling if the self energies
should be saved or not
USAGE EXAMPLES
Define that the self energy on the real contour is calculated with Direct diagonalization.
calculator=DeviceHuckelCalculator(
self_energy_calculator_real=DirectSelfEnergy() )
NOTES
The DirectSelfEnergy use a diagonalization scheme to find all propagating and decaying modes
of the electrodes. The self energy matrix is then determined from the modes[26].
133
134
RecursionSelfEnergy
RecursionSelfEnergy — Class for representing a self energy calculation using the recursion
method.
SYNOPSIS
Namespace: NanoLanguage
Object RecursionSelfEnergy(
save_self_energies,
tolerance,
maximum_iteration
)
DESCRIPTION
Constructor for a self-energy calculator based on the Recursion method. The Recursion is an
iterative scheme for getting self energies, with convergence O(2^N)
List of Arguments
save_self_energies
If True, the self energies are stored between iterations for
maximum speed.
tolerance
The tolerance of convergence of the self energies before
termination of the recursion.
maximum_iteration
The maximum number of recursion steps allowed before
termination.
OBJECT METHODS
A RecursionSelfEnergy object provides the following query functions:
• get_maximum_iteration(): Query method for getting the maximum iteration
• get_save_self_energies(): Query method for getting the Boolean telling if the self energies
should be saved or not
• get_tolerance(): Query method for getting the tolerance
• set_save_self_energies(): Set method for setting the Boolean telling if the self energies
should be saved or not
USAGE EXAMPLES
Define that the self energy on the complex contour is calculated with the recursion method,
and the self energies are not saved.
calculator=DeviceHuckelCalculator(
self_energy_calculator_complex=RecursionSelfEnergy(
save_self_energies=false) )
135
RecursionSelfEnergy
NOTES
The RecusionSelfEnergy uses the iterative scheme by Lopez, Lopez and Rubio[24] for calculating the self energy matrix.
136
KrylovSelfEnergy
KrylovSelfEnergy — Class for representing a self energy calculation using the iterative Krylov
scheme.
SYNOPSIS
Namespace: NanoLanguage
Object KrylovSelfEnergy(
save_self_energies,
lambda_min
)
DESCRIPTION
Constructor for a self-energy calculator based on the Krylov method. The Krylov scheme use an
iterative approach for getting a subset of all the electrode modes.
List of Arguments
save_self_energies
If True, the self energies are stored between iterations for
maximum speed.
lambda_min
The smallest logarithmic decrement of a mode to take into
account.
OBJECT METHODS
A KrylovSelfEnergy object provides the following query functions:
• get_lambda_min(): Query method for getting the lambda min value defined in paper (......)
• get_save_self_energies(): Query method for getting the Boolean telling if the self energies
should be saved or not
• set_save_self_energies(): Set method for setting the Boolean telling if the self energies
should be saved or not
USAGE EXAMPLES
Define that the self energy on the real contour is calculated with the Krylov method, and the
self energies are saved. Only decay modes with a slower decay than 0.05 are included.
calculator=DeviceHuckelCalculator(
self_energy_calculator_real=KrylovSelfEnergy(
save_self_energies=true,
lambda_min=0.05) )
137
KrylovSelfEnergy
NOTES
The KrylovSelfEnergy uses the iterative Krylov subspace method by H. H. Sørensen et. al. [25]
for calculating the self energy matrix. The lambda_min parameter determines the size of the
Krylov subspace. In the limit lambda_min → 0, the full space will be included.
138
MolecularEnergySpectrum
MolecularEnergySpectrum — Class for calculating the molecular energy spectrum for a MoleculeConfiguration.
SYNOPSIS
Namespace: NanoLanguage
Object MolecularEnergySpectrum(
configuration,
energy_zero_parameter
)
DESCRIPTION
Constructor for the MolecularEnergySpectrum object.
List of Arguments
configuration
The MoleculeConfiguration the molecular energy spectrum should be calculated for.
energy_zero_parameter
Specifies the choice for the energy zero,
OBJECT METHODS
A MolecularEnergySpectrum object provides the following query functions:
• evaluate(): Return the molecular energy spectrum
• get_energy_zero(): Return the energy zero used for the energy scale in this molecular energy
spectrum
• get_fermi_level(): Return the Fermi level in absolute energies used in this molecular energy
spectrum
• get_fermi_temperature(): Return the Fermi_temperatures used in this molecular energy
spectrum
• nlprint(stream): Print a string containing an ASCII table useful for plotting the molecular
energy spectrum.
stream
The stream the molecular energy spectrum should be
written to.
• occupation(): Method for calculating the occupation for these eigenstates.
USAGE EXAMPLES
Calculate the molecular energy spectrum of an ammonia molecule and print out the energy
levels and occupations
139
MolecularEnergySpectrum
from NanoLanguage import *
# Set up configuration
molecule_configuration = MoleculeConfiguration(
elements=[Nitrogen, Hydrogen, Hydrogen, Hydrogen],
cartesian_coordinates= [[ 0.
, 0.
, 0.124001],
[ 0.
, 0.941173, -0.289336],
[ 0.81508 , -0.470587, -0.289336],
[-0.81508 , -0.470587, -0.289336]]*Angstrom )
# Define the calculator
calculator = HuckelCalculator()
molecule_configuration.set_calculator(calculator)
# Calculate and save the molecular energy spectrum
molecular_energy_spectrum = MolecularEnergySpectrum(
configuration=molecule_configuration,
energy_zero_parameter=AbsoluteEnergy
)
nlsave('molecular.nc', molecular_energy_spectrum)
# Extract the energy
energy = molecular_energy_spectrum.evaluate()
occ = molecular_energy_spectrum.occupation()
# ... and print it out
print "level
energy(eV)
occupation"
for i in range(energy.shape[0]):
print ' %d %12.4f %12.4f ' % (i, energy[i].in_units_of(eV),occ[i])
NOTES
• To export the data of a molecular energy spectrum, use the method nlprint.
• The MolecularEnergySpectrum can be visualized with VNL, when saved with nlsave.
140
ElectronDifferenceDensity
ElectronDifferenceDensity — Class for calculating a difference density
SYNOPSIS
Namespace: NanoLanguage
Object ElectronDifferenceDensity(configuration)
DESCRIPTION
A class for calculating the electron difference density for a configuration.
List of Arguments
configuration
The configuration for which the difference density should
be calculated.
OBJECT METHODS
A ElectronDifferenceDensity object provides the following query functions:
• get_shape(): Return the shape of the difference density.
• get_unit_cell(): Return the unit cell for this grid
• get_volume_element(): Return the volume element of the difference density grid
• nlprint(stream): Print a string containing an ASCII table useful for plotting the electron
difference density.
stream
The stream the electron difference density should be
written to.
USAGE EXAMPLES
Calculate the electron difference density and save it to a file
from NanoLanguage import *
# Set up configuration
molecule_configuration = MoleculeConfiguration(
elements=[Nitrogen, Hydrogen, Hydrogen, Hydrogen],
cartesian_coordinates=[[ 0.
, 0.
, 0.124001],
[ 0.
, 0.941173, -0.289336],
[ 0.81508, -0.470587, -0.289336],
[-0.81508, -0.470587, -0.289336]]*Angstrom
)
# Define the calculator
calculator = HuckelCalculator()
molecule_configuration.set_calculator(calculator)
# Calculate and save the electron difference density
141
ElectronDifferenceDensity
difference_density = ElectronDifferenceDensity(molecule_configuration)
nlsave('results.nc', difference_density)
Read in the electron difference density from a file and print
from NanoLanguage import *
# import an electron difference density
difference_density = nlread('results.nc', ElectronDifferenceDensity)[0]
# Get the shape of the data.
shape = difference_density.get_shape()
# Find the volume elements.
dX, dY, dZ = difference_density.get_volume_element()
# Calculate the unit area in the y-z plane.
dAYZ = numpy.linalg.norm( numpy.cross(dY,dZ) )
# calculate density along x integrated over y,z
n_x = [ difference_density[i,:,:].sum() * dAYZ for i in range(shape[0]) ]
#print out the result
dx = dX.norm()
sum = 0 * Units.Bohr**-2
for i in range(shape[0]):
print dx*i, n_x[i]
sum+=n_x[i]*dx
print 'total density=', sum
Read in the electron difference density from a file and calculate multipoles of the density.
from NanoLanguage import *
# import an electron difference density
difference_density = nlread('results.nc', ElectronDifferenceDensity)[0]
# Get the shape of the data.
ni, nj, nk = difference_density.get_shape()
# Find the volume elements.
dX, dY, dZ = difference_density.get_volume_element()
length_unit = dX.unit()
# Calculate the volume of the volume element.
dV = numpy.dot(dX, numpy.cross(dY,dZ)) * length_unit**3
# Get a reference for the data of the difference density.
grid_data = difference_density[:]*Units.e
# Calculate the absoute density sum.
density_abs_sum = abs(grid_data).sum()
# Calculate center of mass
Mi = sum([ i*abs(grid_data[i,:,:]).sum() for i in range(ni)])/density_abs_sum
Mj = sum([ j*abs(grid_data[:,j,:]).sum() for j in range(nj)])/density_abs_sum
Mk = sum([ k*abs(grid_data[:,:,k]).sum() for k in range(nk)])/density_abs_sum
center_of_mass = Mi*dX + Mj*dY+ Mk*dZ
# Calculate monopole
density_sum = grid_data.sum()
m0 = density_sum*dV
#calculate dipole
density_i = sum([ (i-Mi)*grid_data[i,:,:].sum() for i in range(ni)])
density_j = sum([ (j-Mj)*grid_data[:,j,:].sum() for j in range(nj)])
density_k = sum([ (k-Mk)*grid_data[:,:,k].sum() for k in range(nk)])
m1 = (dX*density_i + dY*density_j + dZ*density_k)*dV
# Calculate quadropoles (3 x_i *x_j-r*r delta_ij)*dens
density_ii = sum([ (i-Mi)**2 * grid_data[i,:,:].sum() for i
density_jj = sum([ (j-Mj)**2 * grid_data[:,j,:].sum() for j
density_kk = sum([ (k-Mk)**2 * grid_data[:,:,k].sum() for k
density_ij = sum([ (i-Mi)*(j-Mj)*grid_data[i,j,:].sum() for
142
in range(ni)])
in range(nj)])
in range(nk)])
i in range(ni) for j in range(nj)])
density_ik = sum([ (i-Mi)*(k-Mk)*grid_data[i,:,k].sum() for i in range(ni) for k in range(nk)])
density_jk = sum([ (j-Mj)*(k-Mk)*grid_data[:,j,k].sum() for j in range(nj) for k in range(nk)])
m2 = (dX.outer(dX)*density_ii + dY.outer(dY)*density_jj + dZ.outer(dZ)*density_kk + \
(dX.outer(dY)+dY.outer(dX))*density_ij + (dX.outer(dZ)+dZ.outer(dX))*density_ik + \
(dY.outer(dZ)+dZ.outer(dY))*density_jk) * dV
r2 = sum(m2)
m2 = 3*m2 - numpy.identity(3)*r2
print "center of mass (bohr)
print
print
print
print
= ", center_of_mass
"monopole
(e)
= ", m0
"dipole
(e*bohr)
= ", m1
"quadropole (e*bohr**2) = "
m2
NOTES
• To export the grid data of an electron difference potential, use the method nlprint.
• For the ATK-SE package, ElectronDifferenceDensity, returns the electron difference density,
i.e. the difference between the self-consistent valence charge density and the superposition
of atomic valence densities.
143
144
ElectrostaticDifferencePotential
ElectrostaticDifferencePotential — Class for calculating the Hartree potential corresponding to
a difference density.
SYNOPSIS
Namespace: NanoLanguage
Object ElectrostaticDifferencePotential(configuration)
DESCRIPTION
A class for calculating the electrostatic difference potential for a configuration.
List of Arguments
configuration
The configuration for which the electrostatic difference potential should be calculated.
OBJECT METHODS
A ElectrostaticDifferencePotential object provides the following query functions:
• get_shape(): Return the shape of the electrostatic potential.
• get_unit_cell(): Return the unit cell for this grid
• get_volume_element(): Return the volume element of the electrostatic potential grid
• nlprint(stream): Print a string containing an ASCII table useful for plotting the electrostatic
difference potential.
stream
The stream the electrostatic difference potential should
be written to.
USAGE EXAMPLES
Calculate the electrostatic difference potential and save it to a file
from NanoLanguage import *
# Set up configuration
molecule_configuration = MoleculeConfiguration(
elements=[Nitrogen, Hydrogen, Hydrogen, Hydrogen],
cartesian_coordinates=[[ 0.
, 0.
, 0.124001],
[ 0.
, 0.941173, -0.289336],
[ 0.81508, -0.470587, -0.289336],
[-0.81508, -0.470587, -0.289336]]*Angstrom
)
# Define a calculator
calculator = HuckelCalculator()
molecule_configuration.set_calculator(calculator)
145
ElectrostaticDifferencePotential
# Calculate and save the electrostatic difference potential
potential = ElectrostaticDifferencePotential(molecule_configuration)
nlsave('results.nc', potential)
Read in the electrostatic difference potential from a file and calculate the average along the axis.
from NanoLanguage import *
# Import an ElectrostaticDifferencePotential object
potential = nlread('results.nc', ElectrostaticDifferencePotential)[0]
# Calculate the mean
v_z = numpy.apply_over_axes(numpy.mean,potential[:],[0,1]).flatten() * potential[:].unit()
# Print out the result
dX, dY, dZ = potential.get_volume_element()
dz = dZ.norm()
shape = potential.get_shape()
for i in range(shape[2]):
print dz*i, v_z[i]
NOTES
• To export the grid data of an electrostatic difference potential, use the method nlprint.
• For the ATK-SE package, the class ElectrostaticDifferencePotential represents the electrostatic difference potential, i.e. the difference between the electrostatic potential of the selfconsistent valence charge density and the electrostatic potential from a superposition of
atomic valence densities.
146
TransmissionSpectrum
TransmissionSpectrum — Class for representing the transmission spectrum for a given configuration and calculator.
SYNOPSIS
Namespace: NanoLanguage
Object TransmissionSpectrum(
configuration,
energies,
kpoints,
kpoints_weights,
self_energy_calculator,
energy_zero_parameter,
infinitesimal
)
DESCRIPTION
Constructor for the TransmissionSpectrum object.
List of Arguments
configuration
The two-probe configuration with attached calculator for
which the transmission spectrum should be calculated.
energies
The energies for which the transmission spectrum should
be calculated.
kpoints
The k-points for which the transmission spectrum should
be calculated.
kpoints_weights
The weight of each k-point for which the transmission
spectrum should be calculated.
self_energy_calculator
The SelfEnergyCalculator to be used for the transmission spectrum.
energy_zero_parameter
Specifies the choice for the energy zero.
infinitesimal
Small energy, used to move the transmission calculation
away from the real axis. This is only relevant for recursionstyle self-energy calculators.
OBJECT METHODS
A TransmissionSpectrum object provides the following query functions:
• evaluate(): Return the k-point averaged transmission spectrum
• get_bias(): Return the applied bias
147
TransmissionSpectrum
• get_conductance(electrode_voltages,
electrode_temperatures,
pling_rates): Calculate the differential conductance
cou-
electrode_voltages
The electrode voltages to be used for defining the bias
window for the current calculation. If no voltage is specified it will use the voltages in the self-consistent calculation. If voltages are specified the current will be
obtained non-self-consistent. Must be given as 2 voltages
- for example, [-0.5, 0.5]*Volt
electrode_temperatures
The electrode temperatures to be used the current calculation. If no temperature is specified it will use the
temperature from the self-consistent calculation. If temperatures are specified the current will be obtained nonself-consistent. Given as 2 temperatures - for example,
[100, 200]*Kelvin
coupling_rates
Two fractions (alfa_L, alfa_R) with alfa_L+ alfa_R=1,
which specifies the fraction of the differential voltage,
alfa_L*dV, added to the left electrode_voltage, and ,alfa_R*dV, added to the right electrode voltage. See also
note below. Default [0.5,0.5]
• get_current(electrode_voltages, electrode_temperatures): Calculate the current
with positive direction from left to right
electrode_voltages
The electrode voltages to be used for defining the bias
window for the current calculation. If no voltage is specified it will use the voltages in the self-consistent calculation. If voltages are specified the current will be
obtained non-self-consistent. Must be given as 2 voltages
- for example, [-0.5, 0.5]*Volt
electrode_temperatures
The electrode temperatures to be used the current calculation. If no temperature is specified it will use the
temperature from the self-consistent calculation. If temperatures are specified the current will be obtained nonself-consistent. Given as 2 temperatures - for example,
[100, 200]*Kelvin.
• get_electrode_fermi_levels(): Return the electrodes Fermi levels in absolute energies
• get_electrode_fermi_temperatures(): Return the electrodes Fermi temperature used in this
transmission spectrum
• get_electrode_voltages(): Return the electrode_voltages used in this transmission spectrum
• get_energies(): Return the energies used in this transmission spectrum
• get_energy_zero(): Return the energy zero used for the energy scale in this transmission
spectrum
• get_infinitesimal(): Return the infinitesimal used in for calculating the transmission
• get_kpoints(): Return the k-points used in this transmission spectrum
• get_kpoints_weights(): Return the weights of the k-points used in this transmission spectrum
148
• get_transmission(): Return the transmission coefficients of the transmission spectrum
• nlprint(stream): Print a string containing an ASCII table useful for plotting the transmission
spectrum.
stream
The stream the transmission spectrum should be written
to.
USAGE EXAMPLES
Calculate the transmission spectrum and for each energy print out all k-dependent coefficients
from NanoLanguage import *
# Define A,B directions of lattice
vector_a = [5.0, 0.0, 0.0]*Angstrom
vector_b = [0.0, 5.0, 0.0]*Angstrom
# Setup a device configuration
electrode = BulkConfiguration(
bravais_lattice=UnitCell(vector_a, vector_b,
[0.0, 0.0, 9.0]*Angstrom),
elements=[Lithium, Lithium, Lithium],
cartesian_coordinates=[[ 2.5, 2.5, 1.5],
[ 2.5, 2.5, 4.5],
[ 2.5, 2.5, 7.5]]*Angstrom
)
central_region = BulkConfiguration(
bravais_lattice= UnitCell(vector_a, vector_b,
[0.0, 0.0, 22.0]*Angstrom),
elements=[Lithium, Lithium, Lithium, Hydrogen, Hydrogen,
Lithium, Lithium, Lithium],
cartesian_coordinates=[[ 2.5,
2.5,
1.5],
[ 2.5,
2.5,
4.5],
[ 2.5,
2.5,
7.5],
[ 2.5,
2.5, 10.5],
[ 2.5,
2.5, 11.5],
[ 2.5,
2.5, 14.5],
[ 2.5,
2.5, 17.5],
[ 2.5,
2.5, 20.5]]*Angstrom
)
device_configuration = DeviceConfiguration(
central_region,
[electrode, electrode]
)
# Setup calculators
numerical_accuracy_parameters = NumericalAccuracyParameters(
k_point_sampling=(1, 1, 100))
electrode_calculator = HuckelCalculator(
numerical_accuracy_parameters=numerical_accuracy_parameters)
calculator = DeviceHuckelCalculator(
numerical_accuracy_parameters=numerical_accuracy_parameters,
electrode_calculators=[electrode_calculator, electrode_calculator])
device_configuration.set_calculator(calculator)
# Calculate the transmission coefficient
transmission_spectrum = TransmissionSpectrum(
configuration=device_configuration,
energies=numpy.linspace(-0.5,0.5,10)*eV,
kpoints=MonkHorstPackGrid(3,3,1),
energy_zero_parameter=AverageFermiLevel,
infinitesimal=1e-06*Units.eV
)
149
TransmissionSpectrum
# Print out all k-dependent transmission coefficients
data = transmission_spectrum.get_transmission()
energies = transmission_spectrum.get_energies()
kpoints = transmission_spectrum.get_kpoints()
for i in range(data.shape[0]):
print 'Transmission at energy = %12.6f eV' % (energies[i].in_units_of(eV))
print '
kx
ky
transmission '
for j in range(data.shape[1]):
print '%10.4f %10.4f %16.6e' % (kpoints[j][0],kpoints[j][1],data[i][j])
print
Alternatively to using the MonkHorstPackGrid class, we can also specify the k-points and weights
directly. The k-points are specified in units of the reciprocal lattice vectors. Note that except for
the Gamma point, the k-points have weight 2 due to use of time-reversal symmetry, i.e
.
transmission_spectrum = TransmissionSpectrum(
configuration=device_configuration,
energies=numpy.linspace(-0.5,0.5,10)*eV,
kpoints=[[0.0,0.0,0.0],[0.0,1./3.,0.0],[1./3.,-1./3.,0.0],
[1./3.,0.0,0.0],[1./3.,1./3.,0.0]],
kpoints_weights = [1.,2.,2.,2.,2.],
energy_zero_parameter=AverageFermiLevel,
infinitesimal=1e-06*Units.eV
)
Calculate the current and differential conductance for different electron temperatures in the
electrodes.
temp = numpy.linspace(0,1000,21)
current = []
conductance = []
for t in temp:
current = current + [ transmission_spectrum.get_current(electrode_temperatures=[200.,t]*Kelvin)]
conductance = conductance + [ transmission_spectrum.get_conductance(electrode_temperatures=[200.,t]
print "Temperature[Left]
Temperature[Right]
for i in range(len(temp)):
print "
%6.0f K
%6.0f K
%s
Current
Differential-Conductance "
%s" % (200.,
temp[i], current[i], conductance[i])
NOTES
To export the data of a transmission spectrum, use the method nlsave.
THE CURRENT
The current is calculated from the transmission spectrum using
where is the Fermi function. A positive current goes from left to right. The transmission spectrum is usually insensitive to the value of
and
used in the self-consistent calculation,
however, very sensitive to the value of
and
used in the self-consistent calculation. Thus,
for an accurate estimate of the current, the Transmission spectrum must be calculated from a
self-consistent calculation which used
and
. The self-consistently calculated current is
independent of how the Voltages were applied, it only depends on
.
150
Note that in ATK-SE the chemical potentials of the left electrode,
and the right
electrode,
are defined relative to the Fermi level of the left electrode, and
related to the applied bias through
THE DIFFERENTIAL CONDUCTANCE
The differential conductance is calculated from the Transmission spectrum using
The coupling constants
models how the transmission spectrum couples with
the left and right electrode. For a molecule strongly bound to the left electrode we must have
and
.
A more accurate estimate of the differential conductance which avoid introducing
is
obtained by calculating the self-consistent current at a number of applied biases,
, and performing numerical differentiation
151
152
Bandstructure
Bandstructure — Class for calculating the bandstructure for a BulkConfiguration.
SYNOPSIS
Namespace: NanoLanguage
Object Bandstructure(
configuration,
route,
points_per_segment,
bands_above_fermi_level
)
DESCRIPTION
Constructor for the bandstructure object.
List of Arguments
configuration
The BulkConfiguration for which the bandstructure
should be calculated.
route
The route to take through the Brillouin-zone.
points_per_segment
The number of points per segment of the route.
bands_above_fermi_level
The number of bands above the Fermi level.
OBJECT METHODS
A Bandstructure object provides the following query functions:
• evaluate(): Return the bandstructure
• get_energy_zero(): Return the energy zero
• get_fermi_level(): Return the Fermi level in absolute energy
• get_fermi_temperature(): Return the Fermi_temperatures used in this bandstructure
• get_kpoints(): Return the k-points used in this calculation
• get_route(): Return the route used in this calculation
• nlprint(stream): Print a string containing an ASCII table useful for plotting the bandstructure.
stream
The stream the bandstructure should be written to.
USAGE EXAMPLES
Calculate the band structure of silicon and save it to a file
153
Bandstructure
from NanoLanguage import *
# Setup a BulkConfiguration
bulk_configuration = BulkConfiguration(
bravais_lattice=FaceCenteredCubic(5.4306*Angstrom),
elements=[Silicon, Silicon],
cartesian_coordinates=[[ 0.
, 0.
, 0.
],
[ 1.35765, 1.35765, 1.35765]]*Angstrom)
# Define a calculator
calculator = HuckelCalculator(
basis_set = [CerdaHuckelParameters.Silicon_GW_diamond_Basis])
bulk_configuration.set_calculator(calculator)
# Calculate the bandstructure
bandstructure = Bandstructure(
configuration=bulk_configuration,
route=['G', 'X'],
points_per_segment=40,
bands_above_fermi_level=4
)
# Determine indirect band gap
energies = bandstructure.evaluate()
e_valence_max = energies[0][3]
e_conduction_min = energies[0][4]
i_valence_max=0
i_conduction_min=0
# Locate extrema
for i in range(energies.shape[0]):
#find maximum of valence band
if (energies[i][3] > e_valence_max):
e_valence_max=energies[i][3]
i_valence_max=i
#find minimum of conduction band
if (energies[i][4] < e_conduction_min):
e_conduction_min=energies[i][4]
i_conduction_min=i
# Print out results
print 'Valence band maximum (eV) ',e_valence_max, 'at ',
print bandstructure.get_kpoints()[i_valence_max]
print 'Conduction band minimum (eV)',e_conduction_min, 'at ',
print bandstructure.get_kpoints()[i_conduction_min]
print 'Band gap = %7.4f eV ' % (e_conduction_min-e_valence_max)
Note that the k-points are giving in units of reciprocal vectors, and in these units
.
NOTES
• To export the data of a bandstructure, use the method nlprint.
• Symmetry points of the Brillouin zones can be found here BravaisLattice
154
BravaisLattice
Bravais lattices
— The 14 Bravais lattices used to describe crystal structures.
SYNOPSIS
Namespace: NanoLanguage
Object SimpleCubic(a)
Object BodyCenteredCubic(a)
Object FaceCenteredCubic(a)
Object Rhombohedral(
a,
alpha
)
Object Hexagonal(
a,
c
)
Object SimpleTetragonal(
a,
c
)
Object BodyCenteredTetragonal(
a,
c
)
Object SimpleOrthorhombic(
a,
b,
c
)
Object BodyCenteredOrthorhombic(
a,
b,
c
155
BravaisLattice
)
Object FaceCenteredOrthorhombic(
a,
b,
c
)
Object BaseCenteredOrthorhombic(
a,
b,
c
)
Object SimpleMonoclinic(
a,
b,
c,
beta
)
Object BaseCenteredMonoclinic(
a,
b,
c,
beta
)
Object Triclinic(
a,
b,
c,
alpha,
beta,
gamma
)
Object UnitCell(
vector_a,
vector_b,
vector_c
)
DESCRIPTION
NanoLanguage has built-in support for all 14 three-dimensional Bravais lattices. If the Lattice is
specified with the UnitCell keyword, it is categorized as Triclinic. To allow ATK to take ad-
156
vantage of the symmetries of the lattice, and define the symmetry points in the Brillouin zone,
the user must use the correct Bravais lattice keyword, cf. the above list of lattices.
None of the parameters have any default value, and they must all be specified with units (see
the examples below).
OBJECT METHODS
All Bravais lattice classes share the following member functions:
• get_primitive_vectors(): Returns a NumPy array containing the vectors of the primitive unit
cell.
• get_conventional_vectors(): Returns a list containing the vectors of the conventional unit
cell.
• get_a(): Returns the lattice constant a.
• get_b(): Returns the lattice constant b.
• get_c(): Returns the lattice constant c.
• get_alpha(): Returns the angle alpha.
• get_beta(): Returns the angle beta.
• get_gamma(): Returns the angle gamma.
• get_symmetry_points(): Returns a dict with the symmetry points of the lattice.
Thus, Bravais lattices are classes, and their constructors take at most 6 arguments, corresponding
to the lattice parameters:
For the non-primitive lattices, such as face-centered cubic, the lattice constants correspond to
the conventional cell, not the primitive one. The cell created by ATK and used in the calculations
is, however, the primitive one.
Finally, all Bravais lattices except triclinic have a higher degree of symmetry. This means, that
the lattice parameters are constrained to certain values or relationships. For example, in a simple
. In those cases, the constructors only accept
cubic lattice,
the free parameters as arguments ( , in the cubic case). For a complete list of the free parameters
of each lattice, see the table below.
Table 9: The seven crystal classes; the dots indicate the free lattice parameters.
Bravais lattice
a
Cubic
•
Hexagonal
•
b c
alpha beta gamma
•
Rhombohedral •
•
Tetragonal
•
•
Orthorhombic
• • •
Monoclinic
• • •
Triclinic
• • •
•
•
•
UnitCell
• • •
•
•
•
•
157
BravaisLattice
USAGE EXAMPLES
Specify a face-centered cubic lattice with lattice constants a = 5.1 Å:
from NanoLanguage import *
lattice = FaceCenteredCubic(5.1*Ang)
Specify a base-centered monoclinic lattice with lattice constants a = 4.07 Å, b = 8.02 Å, c =
2.04 Å, and angle beta = 56°:
lattice = BaseCenteredMonoclinic(
a = 4.07*Angstrom,
b = 8.02*Angstrom,
c = 2.04*Angstrom,
beta = 56*degrees
)
Specify a lattice by providing the unit cell vectors:
lattice = UnitCell(
[19.3, 1.0, 0.0]*Angstrom,
[-2.0, 15.0, 1.0]*Angstrom,
[ 0.2, 0.4, 4.9]*Angstrom
)
Print a in Bohr, and the c/a ratio, of a hexagonal lattice:
lattice = Hexagonal(...)
print "a = %g Bohr" % (lattice.get_a().in_units_of(Bohr))
print "c/a = %g" % (lattice.get_a()/lattice.get_c())
Function that prints the lattice vectors, in Angstrom, of a given lattice:
def printLatticeVectors(lattice):
for vector in lattice.get_primitive_vectors():
for i in range(3):
print vector[i].in_units_of(Ang),'
',
print
Print the primitive vectors of a Bravais lattice and the x-coordinate of the first and third primitive
vector:
from NanoLanguage import *
lattice = FaceCenteredCubic(2.5*Angstrom)
vectors = lattice.get_primitive_vectors()
for vector in vectors:
print vector
print vectors[0][0] #x-coordinate of the first vector
print vectors[2][0] #x-coordinate of the third vector
giving rise to the output
[0.0 Ang 1.25 Ang 1.25 Ang]
[1.25 Ang 0.0 Ang 1.25 Ang]
[1.25 Ang 1.25 Ang 0.0 Ang]
0.0 Ang
1.25 Ang
158
NOTES
Use BulkConfiguration to insert atoms in the lattice.
159
160
nlread
nlread
SYNOPSIS
Namespace: NanoLanguage
Object nlread(
filename,
class_type,
object_id
)
DESCRIPTION
Function for reading a NetCDF file and retrieving the data contained within.
List of Arguments
filename
The NetCDF file that objects should be loaded from from.
class_type
Only load objects of this type.
object_id
Only load objects that match object_id.
USAGE EXAMPLES
Restore the self-consistent state of a previous calculation (to save the state, see the Usage Examples for the nlsave function).
from NanoLanguage import *
# Read self-consistent calculations
molecule_configuration_list = nlread(
'nh3_scf.nc',
MoleculeConfiguration
)
# Choose the first configuration in the list
molecule_configuration = molecule_configuration_list[0]
Restore the object with object_id = 0 from the NetCDF file bandstructure.nc (to save the
state, consult the nlsave function).
molecular_energy_spectrum = nlread(filename='spectrum.nc',object_id='id0')
Restore all MolecularEnergySpectrum objects from the file spectrum.nc and select the first
object.
molecular_energy_spectrums = nlread(
'spectrum.nc',
MolecularEnergySpectrum
161
nlread
)
molecular_energy_spectrum = molecular_energy_spectrums[0]
NOTES
162
nlsave
nlsave
SYNOPSIS
Namespace: NanoLanguage
Object nlsave(
filename,
nl_object,
object_id,
labels,
comment
)
DESCRIPTION
Function for saving the given object to a NetCDF file.
List of Arguments
filename
The full or relative filename path that the NanoLanguage
object should be saved to.
nl_object
The NanoLanguage object that should be saved to a
NetCDF file.
object_id
A unique identifier that should be attached to the saved
object.
labels
A list of strings that can serve to tag the object with.
comment
A free-text descriptive comment string that should be attached to the saved object.
USAGE EXAMPLES
Save the self-consistent state of a calculation:
from NanoLanguage import *
# Set up configuration
molecule_configuration = MoleculeConfiguration(
elements=[Nitrogen, Hydrogen, Hydrogen, Hydrogen],
cartesian_coordinates=[[ 0.
, 0.
, 0.124001],
[ 0.
, 0.941173, -0.289336],
[ 0.81508, -0.470587, -0.289336],
[-0.81508, -0.470587, -0.289336]]*Angstrom
)
calculator = HuckelCalculator()
molecule_configuration.set_calculator(calculator)
# Perform SCF loop
molecule_configuration.update()
163
nlsave
# Save state
nlsave('nh3_scf.nc', molecule_configuration)
Restore the self-consistent state from a saved file, calculate the MolecularEnergySpectrum,
and save it to the file spectrum.nc with object_id = 0. This will overwrite any data in the file
spectrum.nc associated with the object_id.
from NanoLanguage import *
# Read self-consistent calculation
molecule_configurations = nlread(
'nh3_scf.nc',
MoleculeConfiguration
)
molecule_configuration = molecule_configurations[0]
# Calculate the molecular energy spectrum
spectrum = MolecularEnergySpectrum(molecule_configuration)
# Save the molecular energy spectrum
nlsave('spectrum.nc', spectrum, 'id0')
NOTES
The nc file is written in the NetCDF format. This is a platform independent format, and the files
can for instance be written on a Linux platform and later be read on a Windows platform.
The content of the file can be converted to ASCII format with the command ncdump.
Each entry in the NetCDF file is associated with a unique id, unique_id. If a new entry is saved
without specifying a unique_id, the entry is appended to the file with an auto-generated
unique_id. If a unique_id is specified which already is present in the file, the old entry is automatically deleted.
164
nlprint
nlprint
SYNOPSIS
Namespace: NanoLanguage
Object nlprint(
object,
stream
)
DESCRIPTION
Print an ASCII representation of the object to the stream pointed to by stream. A typical usage
is to store the data as an ASCII file and then use a third party application for generating a visualization of the data.
List of Arguments
object
The object whose data should be printed.
stream
The stream the data should be printed to.
USAGE EXAMPLES
Print the data of a Bandstructure to the screen
# Set up a bandstructure object
bandstructure = Bandstructure(bulk_configuration)
nlprint(bandstructure)
Store the data of a ElectronDifferenceDensity to the file grid.dat
# Set up an electron difference density
electron_difference_density = ElectronDifferenceDensity(molecule_configuration)
# Store grid data on disk
f = open('grid.dat', 'w')
electron_difference_density.nlprint(f)
f.close()
NOTES
165
166
PeriodicTable
PeriodicTable — A class for representing elements from the periodic table.
DESCRIPTION
A set of classes used for constructing the elements from periodic table.
OBJECT METHODS
A PeriodicTable object provides the following query functions:
• get_atomic_number(): Return the atomic number of the element.
• get_symbol(): Return the elements symbol.
• get_name(): Return the name of the element.
• get_atomic_mass(): Return the atomic mass of the element.
USAGE EXAMPLES
Use the elements Hydrogen and Oxygen to set up a MoleculeConfiguration
# Import NanoLanguage modules
from NanoLanguage import *
# Set up elements and positions
elm = [ Oxygen, Hydrogen, Hydrogen ]
pos = [[ 0.000, 0.000, 0.0],
[ 0.757, 0.586, 0.0],
[-0.757, 0.586, 0.0]]*Angstrom
# Add them to a configuration
h2o = MoleculeConfiguration(elm, pos)
Alternatively, the shorter names H and O can also be used as in
# Import NanoLanguage modules
from NanoLanguage import *
# Set up elements and positions
elm = [PeriodicTable.O, PeriodicTable.H, PeriodicTable.H]
pos = [[ 0.000, 0.000, 0.0],
[ 0.757, 0.586, 0.0],
[-0.757, 0.586, 0.0]]*Angstrom
# Add them to a configuration
h2o = MoleculeConfiguration(elm, pos)
PERIODIC TABLE
The entire set of elements from the periodic system, as well as some of their key properties are
listed in the table below:
167
PeriodicTable
Table 10:Atomic data.
Z
Symbol
Name
Electron
configuration
Valence
configuration
Valence
charge
U / eV
1
H
Hydrogen
1s1
1s1
1
12.848
Helium
1s2
2s2
2
9.0
Lithium
[He]2s1
2s1
1
3.469
2s2
2
3
Li
4
Be
Beryllium
[He]2s2
2
5.935
5
B
Boron
[He]2s22p1
2s22p1
3
8.0
Carbon
[He]2s22p2
2s22p2
4
10.207
Nitrogen
[He]2s22p3
2s22p3
5
11.052
Oxygen
[He]2s22p4
2s22p4
6
13.625
2s22p5
6
7
8
C
N
O
9
F
Fluorine
[He]2s22p5
7
15.054
10
Ne
Neon
[He]2s22p6
2s22p6
8
9.0
11
Na
Sodium
[Ne]3s1
3s1
1
2.982
Magnesium
[Ne]3s2
3s2
2
4.623
Aluminium
[Ne]3s23p1
3s23p1
3
5.682
Silicon
[Ne]3s23p2
3s23p2
4
6.964
3s23p3
12
13
14
Mg
Al
Si
15
P
Phosphorus
[Ne]3s23p3
5
9.878
16
S
Sulfur
[Ne]3s23p4
3s23p4
6
9.205
Chlorine
[Ne]3s23p5
3s23p5
7
10.292
Argon
[Ne]3s23p6
3s23p6
8
9.0
Potassium
[Ar]3d04s1
4s1
1
3.702
Calcium
[Ar]3d04s2
4s2
2
3.977
4s23d1
17
18
19
20
Cl
Ar
K
Ca
21
Sc
Scandium
[Ar]3d14s2
3
9.0
22
Ti
Titanium
[Ar]3d24s2
4s23d2
4
9.0
Vanadium
[Ar]3d34s2
4s23d3
5
9.0
Chromium
[Ar]3d44s2
4s23d4
6
9.0
Manganese
[Ar]3d54s2
4s23d5
7
9.0
4s23d6
23
24
25
V
Cr
Mn
26
Fe
Iron
[Ar]3d64s2
8
9.0
27
Co
Cobalt
[Ar]3d74s2
4s23d7
9
9.0
28
Ni
Nickel
[Ar]3d84s2
4s23d8
10
9.0
Copper
[Ar]3d104s1
4s13d10
11
9.0
Zinc
[Ar]3d104s2
4s23d10
12
9.0
3
5.936
29
30
168
He
Cu
Zn
31
Ga
Gallium
[Ar]
3d104s24p1
4s24p1
32
Ge
Germanium
[Ar]
3d104s24p2
4s24p2
4
6.608
33
As
Arsenic
[Ar]
3d104s24p3
4s24p3
5
8.399
34
Se
Selenium
[Ar]
3d104s24p4
4s24p4
6
9.121
35
Br
Bromine
[Ar]
3d104s24p5
4s24p5
7
8.823
36
Kr
Krypton
[Ar]
3d104s24p6
4s24p6
8
9.0
37
Rb
Rubidium
[Kr]4d05s1
5s1
1
2.495
Z
Symbol
Name
Electron
configuration
Valence
configuration
Valence
charge
U / eV
38
Sr
Strontium
[Kr]4d05s2
5s2
2
3.749
39
Y
Yttrium
[Kr]4d15s2
5s24d1
3
9.0
Zirconium
[Kr]4d25s2
5s24d2
4
9.0
Niobium
[Kr]4d45s1
5s24d3
5
9.0
5s14d5
6
9.0
40
41
Zr
Nb
42
Mo
Molybdenum
[Kr]4d55s1
43
Tc
Technetium
[Kr]4d55s2
5s24d5
7
9.0
Ruthenium
[Kr]4d75s1
5s24d6
8
9.0
Rhodium
[Kr]4d85s1
5s14d8
9
9.0
Palladium
[Kr]4d105s0
4d10
10
9.0
Silver
[Kr]4d105s1
5s14d10
11
9.0
5s24d10
44
45
46
47
Ru
Rh
Pd
Ag
48
Cd
Cadmium
[Kr]4d105s2
12
9.0
49
In
Indium
[Kr]
4d105s25p1
5s25p1
3
5.53
50
Sn
Tin
[Kr]
4d105s25p2
5s25p2
4
4.297
51
Sb
Antimony
[Kr]
4d105s25p3
5s25p3
5
7.657
52
Te
Tellurium
[Kr]
4d105s25p4
5s25p4
6
8.985
53
I
Iodine
[Kr]
4d105s25p5
5s25p5
7
9.448
54
Xe
Xenon
[Kr]
4d105s25p6
5s25p6
8
9.0
55
Cs
Caesium
[Xe]5d06s1
6s15p6
7
9.0
56
Ba
Barium
[Xe]5d06s2
6s25p6
8
9.0
Lanthanum
[Xe]5d16s2
6s25d1
3
9.0
4
9.0
57
La
58
Ce
Cerium
[Xe]
4f25d06s2
6s24f2
59
Pr
Praseodymium
[Xe]
4f35d06s2
6s24f3
5
9.0
60
Nd
Neodymium
[Xe]
4f45d06s2
6s24f4
6
9.0
61
Pm
Promethium
[Xe]
4f55d06s2
6s24f5
7
9.0
62
Sm
Samarium
[Xe]
4f65d06s2
6s24f6
8
9.0
63
Eu
Europium
[Xe]
4f75d06s2
6s24f7
9
9.0
64
Gd
Gadolinium
[Xe]
4f75d16s2
6s25d14f7
10
9.0
65
Tb
Terbium
[Xe]
4f95d06s2
6s24f9
11
9.0
66
Dy
Dysprosium
[Xe]
4f105d06s2
6s24f10
12
9.0
67
Ho
Holmium
[Xe]
4f115d06s2
6s24f11
13
9.0
169
PeriodicTable
Z
Symbol
Name
Electron
configuration
Valence
configuration
Valence
charge
U / eV
68
Er
Erbium
[Xe]
4f125d06s2
6s24f12
14
9.0
69
Tm
Thulium
[Xe]
4f135d06s2
6s24f13
15
9.0
70
Yb
Ytterbium
[Xe]
4f145d06s2
6s24f14
16
9.0
71
Lu
Lutetium
[Xe]
4f145d16s2
6s25d14f14
17
9.0
72
Hf
Hafnium
[Xe]
4f145d26s2
6s25d2
4
9.0
73
Ta
Tantalum
[Xe]
4f145d36s2
6s25d3
5
9.0
74
W
Tungsten
[Xe]
4f145d46s2
6s15d5
6
9.0
75
Re
Rhenium
[Xe]
4f145d56s2
6s25d5
7
9.0
76
Os
Osmium
[Xe]
4f145d66s2
6s25d6
8
9.0
77
Ir
Iridium
[Xe]
4f145d76s2
6s25d7
9
9.0
78
Pt
Platinum
[Xe]
4f145d106s0
6s15d9
10
8.604
79
Au
Gold
[Xe]
4f145d106s1
6s15d10
11
8.604
80
Hg
Mercury
[Xe]
4f145d106s2
6s25d10
12
9.0
81
Tl
Thallium
[Xe]
4f145d106s2
6p1
6s26p1
3
9.0
82
Pb
Lead
[Xe]
4f145d106s2
6p2
6s26p2
4
9.0
83
Bi
Bismuth
[Xe]
4f145d106s2
6p3
6s26p3
5
9.0
84
Po
Polonium
[Xe]
4f145d106s2
6p4
6s26p4
6
9.0
85
At
Astatine
[Xe]
4f145d106s2
6p5
6s26p5
7
9.0
86
Rn
Radon
[Xe]
4f145d106s2
6p6
6s26p6
8
9.0
87
Fr
Francium
[Rn]7s1
7s16p6
7
9.0
7s26p6
88
Ra
Radium
[Rn]7s2
8
9.0
89
Ac
Actinium
[Rn]7s26d1
7s26d1
3
9.0
Thorium
[Rn]7s26d2
7s26d2
4
9.0
90
170
Th
Z
Symbol
Name
Electron
configuration
Valence
configuration
Valence
charge
U / eV
91
Pa
Protactinium
[Rn]
7s25f26d1
7s26d15f2
5
9.0
92
U
Uranium
[Rn]
7s25f36d1
7s25f36d1
6
9.0
93
Np
Neptunium
[Rn]
7s25f46d1
7s25f46d1
7
9.0
94
Pu
Plutonium
[Rn]7s25f6
7s25f6
8
9.0
Americium
[Rn]7s25f7
7s25f7
9
9.0
10
9.0
95
Am
96
Cm
Curium
[Rn]
7s25f76d1
7s25f76d1
97
Bk
Berkelium
[Rn]7s25f9
7s25f9
11
9.0
Californium
[Rn]7s25f10
7s25f10
12
9.0
Einsteinium
[Rn]7s25f11
7s25f11
13
9.0
Fermium
[Rn]7s25f12
7s25f12
14
9.0
7s25f13
15
9.0
98
99
100
Cf
Es
Fm
101
Md
Mendelevium
[Rn]7s25f13
102
No
Nobelium
[Rn]7s25f14
7s25f14
16
9.0
17
9.0
103
Lr
Lawrencium
[Rn]
7s25f147p1
7s25f147p1
104
Rf
Rutherfordium
[Rn]
7s25f146d2
7s25f146d2
18
9.0
105
Db
Dubnium
[Rn]
7s25f146d3
7s25f146d3
19
9.0
106
Sg
Seaborgium
[Rn]
7s25f146d4
7s25f146d4
20
9.0
107
Bh
Bohrium
[Rn]
7s25f146d5
7s25f146d5
21
9.0
108
Hs
Hassium
[Rn]
7s25f146d6
7s25f146d6
22
9.0
109
Mt
Meitnerium
[Rn]
7s25f146d7
7s25f146d7
23
9.0
110
Ds
Darmstadtium
[Rn]
7s15f146d9
7s15f146d9
24
9.0
111
Rg
Roentgenium
[Rn]
7s25f146d9
7s25f146d9
25
9.0
171
172
INDEX
degrees, 0
density_cutoff, 115
DeviceConfiguration, 99
DeviceHuckelCalculator, 107
dielectric_regions, 94, 96, 100
DirectSelfEnergy, 133
DoubleContourIntegralParameters, 123
E
A
a, 157
algorithm, 111
alpha, 157
Ampere, 0
Ang, 0
Angstrom, 0
azimuthal_quantum_number, 121
B
b, 157
Bandstructure, 153
bands_above_fermi_level, 153
BaseCenteredMonoclinic, 155
BaseCenteredOrthorhombic, 155
basis_set, 105, 107
beta, 157
BodyCenteredCubic, 155
BodyCenteredOrthorhombic, 155
BodyCenteredTetragonal, 155
Bohr, 0
Boltzmann_constant, 0
boundary_conditions, 129
BoxRegion, 103
bravais_lattice, 95
BulkConfiguration, 95
C
c, 157
calculator, 94, 96, 100
cartesian_coordinates, 93, 95
central_region, 99
circle_eccentricity, 123
circle_points, 123
class_type, 161
comment, 163
configuration, 139, 141, 145, 147, 153
contour_parameters, 107
coupling_rates, 148
D
damping_factor, 111
electrodes, 99
electrode_calculators, 107
electrode_temperatures, 148
electrode_voltages, 108, 148
ElectronDifferenceDensity, 141
electronVolt, 0
electron_temperature, 115
ElectrostaticDifferencePotential, 145
element, 117
elements, 93, 95
energies, 147
energy_zero_parameter, 139, 147
eV, 0
F
FaceCenteredCubic, 155
FaceCenteredOrthorhombic, 155
fermi_function_poles, 123
fermi_line_points, 123
filename, 161, 163
G
gamma, 157
grid_mesh_cutoff, 115
H
Hartree, 0
hbar, 0 , 0
Hexagonal, 155
HoffmannWeighting, 23
HuckelBasisParameters, 117
HuckelCalculator, 105
I
infinitesimal, 147
initial_state, 94, 96, 100
integral_lower_bound, 123
interaction_max_range, 115
ionization_potential, 117
IterationControlParameters, 111
iteration_control_parameters, 105, 107
K
Kelvin, 0
kpoints, 147
kpoints_weights, 147
173
Index
KrylovSelfEnergy, 137
k_point_sampling, 115
L
labels, 163
lambda_min, 133, 137
logarithmic_bunching, 123
real_axis_point_density, 123
reciprocal_energy_cutoff, 115
RecursionSelfEnergy, 135
Rhombohedral, 155
route, 153
Rydberg, 0
S
M
maximum_iteration, 135
max_steps, 111
metallic_regions, 94, 96, 100
mixing_variable, 111
MolecularEnergySpectrum, 139
MoleculeConfiguration, 93
MultigridSolver, 129
N
na, 96
name, 94, 96, 100
nanometer, 0
nanoNewton, 0
nb, 96
nc, 96
Newton, 0
nlprint, 165
nlread, 161
nlsave, 163
nl_object, 163
non-self-consistent calculation, 106
NonSelfconsistent, 106
number_of_history_steps, 111
number_of_reciprocal_points, 115
number_of_valence_electrons, 117
NumericalAccuracyParameters, 115
numerical_accuracy_parameters, 105, 107
O
object, 165
object_id, 161, 163
onsite_hartree_shift, 117
orbitals, 117
P
PeriodicTable, 167
Planck_constant, 0
points_per_segment, 153
poisson_solver, 105, 108
principal_quantum_number, 121
R
radial_grid_sampling, 115
radians, 0
real_axis_infinitesimal, 123
real_axis_kbt_padding_factor, 123
174
save_self_energies, 133, 135, 137
self_energy_calculator, 147
self_energy_calculator_complex, 108
self_energy_calculator_real, 107
Siemens, 0
SimpleCubic, 155
SimpleMonoclinic, 155
SimpleOrthorhombic, 155
SimpleTetragonal, 155
SlaterOrbital, 121
slater_coefficients, 121
start_mixing_after_step, 111
stream, 93, 96, 100, 139, 141, 145, 149, 153, 165
T
tolerance, 111, 135
TransmissionSpectrum, 147
Triclinic, 155
U
UnitCell, 155
Units.Ha, 0
Units.meV, 0
Units.nm, 0
Units.Ry, 0
V
vacuum_level, 117
value, 103
Volt, 0
W
weighting_scheme, 105, 107
weights, 121
WolfsbergWeighting, 23
wolfsberg_helmholtz_constant, 117
X
xmax, 103
xmin, 103
xyz_format, 93
Y
ymax, 103
ymin, 103
Z
zmax, 103
zmin, 103
175
176