calculateGreenFunctionComponent

calculateGreenFunctionComponent(device_configuration, energy=PhysicalQuantity(0.0, eV), kpoint=None, spin=<class 'NL.ComputerScienceUtilities.NLFlag.Spin.All'>, contribution=<class 'NL.ComputerScienceUtilities.NLFlag._NLFlag.Left'>, eta=PhysicalQuantity(1e-06, Hartree), self_energy_calculator=None)

Calculate the Green Function component, \(G \Gamma G^\dagger\).

Parameters:
  • device_configuration (DeviceConfiguration | SurfaceConfiguration) – The configuration to use for the calculation.
  • energy (PhysicalQuantity of type energy.) – Absolute energy for the calculation
    Default: 0.0 * eV
  • kpoint (tuple of floats) – The kpoint as three floats representing fractional reciprocal space coordinates.
    Default: The Gamma point (0.0, 0.0, 0.0)
  • spin (Spin.Up | Spin.Down | Spin.All) – The spin flag.
    Default: Spin.All
  • contribution (Left | Right) – Which electrode (side) should be considered. Only the Left contribution is allowed for a SurfaceConfiguration.
    Default: Left
  • eta (PhysicalQuantity of type energy.) – Complex energy for electrode transform matrices, imag part.
    Default: 1.0e-6 * Hartree
  • self_energy_calculator (RecursionSelfEnergy | DirectSelfEnergy | KrylovSelfEnergy | SparseRecursionSelfEnergy) – The self energy evaluation strategy to use.
    Default: A default RecursionSelfEnergy instance.
Returns:

The Green Function Component as an array

Return type:

PhysicalQuantity of type inverse energy

Usage Examples

Calculate the left Green’s function component of a DeviceConfiguration:

energy=1.0*eV
G_L = calculateGreenFunctionComponent(device_configuration, energy, contribution=Left)

Equivalent calculation from the basic H, S variables:

energy=1.0*eV
H,S = calculateHamiltonianAndOverlap(device_configuration)
S_L = calculateSelfEnergy(device_configuration, energy, contribution=Left)
S_L = S_L.inUnitsOf(Hartree)
S_R = calculateSelfEnergy(device_configuration, energy, contribution=Right)
S_R = S_R.inUnitsOf(Hartree)

# Setup E*S-H-S_L-S_R
lhs = energy.inUnitsOf(Hartree)*S-H.inUnitsOf(Hartree)
n=S_L.shape[0]
lhs[:n,:n] -= S_L
n=S_R.shape[0]
lhs[-n:,-n:] -= S_R
G = numpy.linalg.inv(lhs)

# Calculate Gamma_L
g_L = 1j*(S_L-numpy.conj(S_L.transpose()))

# Do the G gamma G^dagger
n = g_L.shape[0]
G_L = numpy.dot(numpy.dot(G[:,:n],g_L), numpy.conj(G.transpose())[:n,:])*Hartree

Notes

  • Calculates the spectral density matrix components
\[G^{L,R}(E,{\bf k}) = G^R(E,{\bf k}) \Gamma^{L,R}(E,{\bf k}) G^R(E,{\bf k})^\dagger,\]

where \(G^R\) is the retarded Green function and \(\Gamma = i (\Sigma-\Sigma^\dagger)\) is the broadening function.

\(G^{L,R}\) are closely related to \(G^<\).