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 (sequence (size 3) of int | MonkhorstPackGrid | KpointDensity) – The kpoints to integrate over. Note that the k-points must be in the xy-plane.
Default: MonkhorstPackGrid(na, nb) where (na, nb) is the sampling used for the self-consistent calculation.
energies (list of 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 (list of 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 | 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 | 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.

uniqueString()¶: Return a unique string representing the state of the object.

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 [1].

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 [1] 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.