DeviceDensityOfStates

	DeviceDensityOfStates
DensityOfStates	LocalDeviceDensityOfStates

Name

DeviceDensityOfStates — Class for representing the Device Density of States for a given configuration and calculator.

Synopsis

Namespace: NanoLanguage

DeviceDensityOfStates(
configuration,
energies,
kpoints,
contributions,
self_energy_calculator,
energy_zero_parameter,
infinitesimal
)

Description

Constructor for the Device Density of States object.

DeviceDensityOfStates Arguments

configuration

The two-probe configuration with attached calculator for which the density of states. should be calculated.

Type: DeviceConfiguration

Default:


          None

energies

The energies for which the density of states should be calculated.

Type: List containing elements of the type PhysicalQuantity with energy unit.

Default:


          numpy.linspace(-2.,2.,200)*eV

kpoints

The k-points for which the density of states should be calculated.

Type: MonkhorstPackGrid

Default:


          MonkhorstPackGrid(nx,ny), where nx, ny is the sampling used for the self consistent calculation.

contributions

The density contributions to include in the density of states.

Type: Left | Right | All

Default:

All

self_energy_calculator

The SelfEnergyCalculator to be used for the density of states.

Type: DirectSelfEnergy | RecursionSelfEnergy | KrylovSelfEnergy

Default:


          KrylovSelfEnergy

energy_zero_parameter

Specifies the choice for the energy zero.

Type: AverageFermiLevel | AbsoluteEnergy.

Default:


          AverageFermiLevel

infinitesimal

Small energy, used to move the density of states calculation away from the real axis. This is only relevant for recursion-style self-energy calculators.

Type: PhysicalQuantity with energy unit.

Default:


          1.0e-6*eV

DeviceDensityOfStates Methods

A DeviceDensityOfStates object provides the following methods:

bias(): Return the applied bias
electrodeFermiLevels(): Return the electrodes Fermi levels in absolute energies
electrodeFermiTemperatures(): Return the electrodes Fermi temperature used in this density of states
electrodeVoltages(): Return the electrode_voltages used in this density of states spectrum
elements(): Query for the elements in the configuration used for generating the dos
energies(): Return the energies used in this density of states
energyZero(): Return the energy zero used for the energy scale in this density of states
evaluate(spin, projection_list): Return the density of states.

spin

The spin to select.
Type: Spin.Sum | Spin.Up | Spin.Down |
Default: Spin.Sum

projection_list

ProjectionList with projections to include in the density of states.
Type: ProjectionList
Default: ProjectionList(range(n_left, n_central-n_right))
infinitesimal(): Return the infinitesimal used for calculating the density of states
nlprint(stream): Print a string containing an ASCII table useful for plotting the density of states

stream

The stream the density of states should be written to.
Type: A stream that supports strings being written to using 'write'.
Default: sys.stdout
numberOfElectrodeAtoms(): Query for the number of electrode atoms in the configuration used for generating the dos
spins(): Return the spins used in this density of states

Usage Examples

Calculate the Density of states of a Lithium H2 Lithium system.

# setup Huckel calculation for Li-H2-Li device

electrode_lattice = UnitCell([8., 0., 0.]*Angstrom,
                             [0., 8., 0.]*Angstrom,
                             [0., 0., 8.7]*Angstrom)

electrode_elements = [Lithium, Lithium, Lithium]
electrode_coordinates = [ [ 4.,  4., 1.45+i*2.9] for i in range(3)]*Angstrom

electrode = BulkConfiguration(
    bravais_lattice=electrode_lattice,
    elements=electrode_elements,
    cartesian_coordinates=electrode_coordinates
    )

lattice = UnitCell([8., 0., 0.]*Angstrom,
                   [0., 8., 0.]*Angstrom,
                   [0., 0., 37.376]*Angstrom)

elements = [Lithium,]*6 +[Hydrogen,]*2+[Lithium,]*6

coordinates = [ [ 4.,  4., 1.45+i*2.9] for i in range(6)] + \
              [ [ 4.,  4., 18.286+i*0.8] for i in range(2)] + \
              [ [ 4.,  4., 21.426+i*2.9] for i in range(6)]

central_region = BulkConfiguration(
    bravais_lattice=lattice,
    elements=elements,
    cartesian_coordinates=coordinates*Angstrom
    )

device_configuration = DeviceConfiguration(
    central_region,
    [electrode, electrode]
    )

calculator = DeviceHuckelCalculator(
    iteration_control_parameters = NonSelfconsistent,
    )

device_configuration.setCalculator(calculator)

device_configuration.update()
nlsave('device.nc', device_configuration)

#setup energies, and calculate DOS
energies = numpy.linspace(-2,3,100) * eV
dos = DeviceDensityOfStates(device_configuration, energies=energies)
nlsave('device.nc', dos)

device.py

	Note
	The spectrum can be shown by selecting the file `device.nc` in the result browser of VNL

Plot the atom projected density of states for the non surface atoms in the central region.

# read the dos
dos = nlread('device.nc',DeviceDensityOfStates)[0]
conf = nlread('device.nc', DeviceConfiguration)[0]
energies = dos.energies()

# calculate projection on atoms in the central region
dos_projection = [dos.evaluate(projection_list = ProjectionList([i])) \
                  for i in range(3,11)]

# plot the projections
import pylab
pylab.figure()
for i in range(3,11):
    label = conf.elements()[i].symbol()+'('+str(i)+')'
    pylab.plot(energies.inUnitsOf(eV),dos_projection[i-3].inUnitsOf(eV**-1), \
               label = label)
pylab.legend()    
pylab.xlabel("Energy (eV)")
pylab.ylabel("dos (1/eV)")
pylab.show()

dos.py

The density of states of the Li-H2-Li systems projected onto the atoms in the central region. Note that half the curves are not visible because they fall on top of the other curves due to symmetry.

Figure 11: The density of states of the Li-H2-Li systems projected onto the atoms in the central region. Note that half the curves are not visible because they fall on top of the other curves due to symmetry.

Calculate the Density of States contribution from scattering states with origin in the left electrode

conf = nlread('device.nc',DeviceConfiguration)[0]

#setup energies
energies = numpy.linspace(-2,3,100) * eV

#calculate the dos from the Left electrode
dos = DeviceDensityOfStates(conf, energies=energies, contributions=Left)

#calculate the projections on the atoms in the central region
dos_projection = [
     dos.evaluate(projection_list = ProjectionList([i])) for i in range(3,11)
     ]

#plot the data
import pylab
pylab.figure()
for i in range(3,11):
    label = conf.elements()[i].symbol()+'('+str(i)+')'
    pylab.plot(
        energies.inUnitsOf(eV),
	dos_projection[i-3].inUnitsOf(eV**-1),
	label=label
	)
pylab.legend()
pylab.xlabel("Energy (eV)")
pylab.ylabel("dos (1/eV)")
pylab.show()

dos_left.py

The density of states from the left electrode of the Li-H2-Li systems projected onto the atoms in the central region. Note how the density of states in the right lithium atoms are reduced, due do damping of the propagation by the hydrogen molecule.

Figure 12: The density of states from the left electrode of the Li-H2-Li systems projected onto the atoms in the central region. Note how the density of states in the right lithium atoms are reduced, due do damping of the propagation by the hydrogen molecule.

k-point average of the DOS

     dos =  DeviceDensityOfStates(conf, kpoints = MonkhorstPackGrid(4,4),
     energies=energies, contributions=Left)

Notes

The routine utilizes the symmetries of the configuration to reduce the computational load for k-point averages.