CurrentDensity

class CurrentDensity(configuration=None, kpoints=None, energies=None, energy_weights=None, spin=None, electrode_temperatures=None, self_energy_calculator=None, energy_zero_parameter=None, infinitesimal=None)

Constructor for the CurrentDensity object.

Parameters:
  • configuration (DeviceConfiguration) – The device configuration to calculate the current density for.
  • kpoints (MonkhorstPackGrid) – The kpoints to integrate over.
    Default: MonkhorstPackGrid(nx,ny), where nx, ny is the sampling used for the self consistent calculation.
  • energies (PhysicalQuantity of type energy.) – The energies to integrate over.
    Default: An energy range that covers the bias window as specified by the DoubleContourIntegralParameters on the calculator attached to the configuration.
  • energy_weights (Current | Left | Right | list of floats) – The weight of each energy point. The keyword Current gives an energy dependent weight, \(f_R(E) -f_L(E)\), corresponding to the current integral. Left/Right gives an energy independent weight of 1, for current carrying states from Left/Right.
    Default: Current
  • spin (Spin.All | Spin.Up | Spin.Down | Spin.Sum | Spin.RealUpDown | Spin.ImagUpDown | Spin.X | Spin.Y | Spin.Z) – The spin for which the current density should be calculated.
    Default: Spin.Sum for UNPOLARIZED, else Spin.All
  • electrode_temperatures (PhysicalQuantity of type temperature) – The electrode temperatures to be used the current calculation. Must be given as 2 temperatures - for example, [100, 200]*Kelvin.
    Default: The temperature used for the self-consistent calculation.
  • self_energy_calculator (DirectSelfEnergy | RecursionSelfEnergy | SparseRecursionSelfEnergy | KrylovSelfEnergy) – The self energy calculator to be used for the current density.
    Default: RecursionSelfEnergy(storage_strategy=NoStorage())
  • energy_zero_parameter (AverageFermiLevel | AbsoluteEnergy) – Specifies the choice for the energy zero.
    Default: AverageFermiLevel
  • infinitesimal (PhysicalQuantity of type energy.) – Small positive energy, used to move the self-energy calculation away from the real axis. This is only relevant for recursion-style self-energy calculators.
    Default: 1.0e-6*eV.
electrodeFermiLevels()
Returns:The Fermi levels of the left and right electrodes in absolute energies.
Return type:PhysicalQuantity of type energy.
electrodeFermiTemperatures()
Returns:The Fermi temperature of the left and right electrodes.
Return type:PhysicalQuantity of type temperature.
energies()
Returns:The energies used in this current density
Return type:PhysicalQuantity of type energy
energyWeights()
Returns:The energy weights used in this current density
Return type:numpy.array
energyZero()
Returns:The energy zero used for the energy scale in this current density.
Return type:PhysicalQuantity of type energy.
evaluate(x, y, z, spin=None)

Evaluate in the point x,y,z.

Parameters:
  • x (PhysicalQuantity with type length) – The cartesian x coordinate.
  • y (PhysicalQuantity with type length) – The cartesian y coordinate.
  • z (PhysicalQuantity with type length) – The cartesian z coordinate.
  • spin (Spin.All | Spin.Sum | Spin.X | Spin.Y | Spin.Z) – The spin component to project on.
    Default: The spin that the object was constructed with.
Returns:

The vector grid value at the specified point for the given spin. For Spin.All, a tuple with (Spin.Sum, Spin.X, Spin.Y, Spin.Z) components is returned.

Return type:

PhysicalQuantity

gridCoordinate(i, j, k)

Return the grid coordinate for a given grid index.

Parameters:
  • i (int) – The grid index in the A direction.
  • j (int) – The grid index in the B direction.
  • k (int) – The grid index in the C direction.
Returns:

The Cartesian coornate of the given grid index.

Return type:

PhysicalQuantity of type length.

infinitesimal()
Returns:The infinitesimal used for calculating the current density.
Return type:PhysicalQuantity of type energy
metatext()
Returns:The metatext of the object or None if no metatext is present.
Return type:str | unicode | None
nlprint(stream=None)

Print a string containing an ASCII table useful for plotting the AnalysisSpin object.

Parameters:stream (python stream) – The stream the table should be written to.
Default: NLPrintLogger()
scale(scale)

Scale the field with a float.

Parameters:scale (float) – The parameter to scale with.
setMetatext(metatext)

Set a given metatext string on the object.

Parameters:metatext (str | unicode | None) – The metatext string that should be set. A value of “None” can be given to remove the current metatext.
shape()
Returns:The number of grid points in each direction.
Return type:tuple of three int.
spin()
Returns:The spins used in this current density.
Return type:tuple of spin component flags.
spinProjection(spin=None)

Query method to get a spin component of the VectorGridValue object.

Parameters:spin (Spin.Sum | Spin.Up | Spin.Down | Spin.X | Spin.Y | Spin.Z | Spin.RealUpDown | Spin.ImagUpDown) – The spin component for which to return the GridValues object.
Default: Spin.Sum
Returns:A new VectorGridValues object for the specified spin.
Return type:VectorGridValues
toArray()
Returns:The values of the grid as a numpy array slicing off any units.
Return type:numpy.array.
unit()
Returns:The unit of the data in the grid.
Return type:A physical unit.
unitCell()
Returns:The unit cell of the grid.
Return type:PhysicalQuantity of type length.
volumeElement()
Returns:The volume element of the grid represented by three vectors.
Return type:PhysicalQuantity of type length.

Usage Examples

Calculate the CurrentDensity for a DeviceConfiguration and plot it density along z, integrated over the x,y plane:

# Calculate the current density at the fermi level from right to left going states
cd = CurrentDensity(
    configuration,
    energies = [0.0]*eV,
    energy_weights = Right,
    kpoints=MonkhorstPackGrid(1,11),
    )

# Calculate the volume element and x,y integration area
dX, dY, dZ = cd.volumeElement()
dAXY = numpy.linalg.norm( numpy.cross(dX,dY) )

# Calculate the current density along z integrated over x,y
shape = cd.shape()
# Take out spin up (index 0) z component (index 2) in every grid point.
cd_z = numpy.array( [ [ [ cd[i,j,k][0][2] for k in range(shape[2])] for j in range(shape[1])] for i in range(shape[0]) ] )

# Sum across x and y dimensions
cd_z_integrated = numpy.array([cd_z[:,:,k].sum() * dAXY for k in range(shape[2])])


# Plot the data
import pylab
pylab.figure()
dz = dZ.norm()
z = numpy.arange(shape[2])*dz.inUnitsOf(Bohr)
pylab.plot(z,cd_z_integrated)
pylab.show()

current_density1.py

Calculate the CurrentDensity from right to left going states at the Fermi level. Plot the current density in the x-z plane as a contour plot:

from QuantumATK import *

# Calculate the current density at the fermi level from right to left going states
cd = CurrentDensity(
    configuration,
    energies = [0.0]*eV,
    energy_weights = Right,
    kpoints=MonkhorstPackGrid(1,11),
    )

# Calculate the volume element
dX, dY, dZ = cd.volumeElement()
dx = dX.norm()
dy = dY.norm()
dz = dZ.norm()

# Calculate the current density along z integrated over x,y
shape = cd.shape()
# Take out spin up (index 0) z component (index 2) in every grid point.
cd_z = numpy.array( [ [ [ cd[i,j,k][0][2] for k in range(shape[2])] for j in range(shape[1])] for i in range(shape[0]) ] )

# Sum across y dimensions
cd_xz = numpy.array([ [cd_z[i,:,k].sum() * dy for k in range(shape[2])] for i in range(shape[0] )] )


# Make 2-d arrays for contour plot of the data
shape = cd.shape()
x = dx.inUnitsOf(Ang)*numpy.arange(shape[0])
z = dz.inUnitsOf(Ang)*numpy.arange(shape[2])
Z, X = numpy.meshgrid(z,x)
F = numpy.array(cd_xz).reshape(numpy.shape(Z))

#plot the current density in the (z,x) plane
import pylab
pylab.xlabel('z (Angstrom)',fontsize=12,family='sans-serif')
pylab.ylabel('x (Angstrom)',fontsize=12,family='sans-serif')
pylab.contourf(Z, X, F)
pylab.colorbar()
pylab.savefig('cd.png',dpi=100)
pylab.show()

current_density2.py

Notes

The current density is given by

\[{\bf J}(r) = -\frac{e \hbar}{4 \pi m } \int dE \sum_{\mu, \nu} D_{\mu, \nu}(E) \phi_\nu(r) {\bf \nabla} \phi_\mu(r) (f_L(E) - f_R(E)),\]

where \(D(E) = G(E) \, \Gamma_{L/R}(E) \, G^\dagger(E)\), \(\phi_{\nu/\mu}(r)\) are atomic basis orbitals, and \(f_{L/R}(E)\) are the left and right Fermi functions. \(G\) is the retarded Green function, \(\Gamma_{L/R}\) the broadening function from either left or right electrode [LWWW08].

  • The positive current direction is from left to right (corresponding to electron propagation from right to left).
  • Through the energy_weights keyword, it is possible for the user to define the spectral weight \(w(E)=f_{R}(E) - f_{L}(E)\). This is particular useful when using the current density to analyze zero bias calculations. Setting the energy weights to Right is a short cut for setting the energy_weights to 1 for all states Setting the energy weights to Left is short cut for setting the energy_weights to -1 for all states. Note that a positive weight corresponds to calculating right to left going modes (positive current) while a negative weight corresponds to calculating left to right going modes (negative current).
  • The current density does not include the non-local potential correction [LWWW08] and spill in contributions from the electrodes. Thus, the area integrated current density is not constant along z but has a small fluctuating component from the non-local potential and larger errors near the electrodes from spill in components.

[LWWW08](1, 2) C. Li, L. Wan, Y. Wei, and J. Wang. Definition of current density in the presence of a non-local potential. Nanotechnology, 19(15):155401, 2008. URL: http://stacks.iop.org/0957-4484/19/i=15/a=155401.