RecursiveSI¶

class sisl.physics.RecursiveSI(spgeom, infinite, eta=0.0001)¶

Bases: sisl.physics.SemiInfinite

Self-energy object using the Lopez-Sancho Lopez-Sancho algorithm

Attributes

`__dict__`
`__doc__`
`__module__`
`__weakref__`	list of weak references to the object (if defined)

Methods

`__delattr__`	Implement delattr(self, name).
`__dir__`	Default dir() implementation.
`__eq__`	Return self==value.
`__format__`	Default object formatter.
`__ge__`	Return self>=value.
`__getattr__`(attr)	Overload attributes from the hosting object
`__getattribute__`	Return getattr(self, name).
`__gt__`	Return self>value.
`__hash__`	Return hash(self).
`__init__`(spgeom, infinite[, eta])	Create a `SelfEnergy` object from any SparseGeometry
`__init_subclass__`	This method is called when a class is subclassed.
`__le__`	Return self<=value.
`__len__`()	Dimension of the self-energy
`__lt__`	Return self<value.
`__ne__`	Return self!=value.
`__new__`	Create and return a new object.
`__reduce__`	Helper for pickle.
`__reduce_ex__`	Helper for pickle.
`__repr__`	Return repr(self).
`__setattr__`	Implement setattr(self, name, value).
`__sizeof__`	Size of object in memory, in bytes.
`__str__`()	Representation of the RecursiveSI model
`__subclasshook__`	Abstract classes can override this to customize issubclass().
`_setup`(spgeom)	Setup the Lopez-Sancho internals for easy axes
`green`(E[, k, dtype, eps])	Return a dense matrix with the bulk Green function at energy E and k-point k (default Gamma).
`scattering_matrix`(args, *kwargs)	Calculate the scattering matrix by first calculating the self-energy
`se2scat`(SE)	Calculate the scattering matrix from the self-energy
`self_energy`(E[, k, dtype, eps, bulk])	Return a dense matrix with the self-energy at energy E and k-point k (default Gamma).
`self_energy_lr`(E[, k, dtype, eps, bulk])	Return two dense matrices with the left/right self-energy at energy E and k-point k (default Gamma).

green(E, k=0, 0, 0, dtype=None, eps=1e-14, **kwargs)[source]¶

Return a dense matrix with the bulk Green function at energy E and k-point k (default Gamma).

Parameters

E (float/complex) – energy at which the calculation will take place
k (array_like, optional) – k-point at which the Green function should be evaluated. the k-point should be in units of the reciprocal lattice vectors.
dtype (numpy.dtype) – the resulting data type
eps (float, optional) – convergence criteria for the recursion
**kwargs (dict, optional) – arguments passed directly to the self.parent.Pk method (not self.parent.Sk), for instance spin

Returns

the self-energy corresponding to the semi-infinite direction

Return type

numpy.ndarray

scattering_matrix(*args, **kwargs)¶

Calculate the scattering matrix by first calculating the self-energy

Any arguments that is passed to this method is directly passed to self_energy.

See self_energy for details.

This corresponds to:

\[\boldsymbol\Gamma = i(\boldsymbol\Sigma - \boldsymbol \Sigma ^\dagger)\]

Examples

Calculating both the self-energy and the scattering matrix.

>>> SE = SelfEnergy(...)
>>> self_energy = SE.self_energy(0.1)
>>> gamma = SE.scattering_matrix(0.1)

For a huge performance boost, please do:

>>> SE = SelfEnergy(...)
>>> self_energy = SE.self_energy(0.1)
>>> gamma = SE.se2scat(self_energy)

Notes

When using both the self-energy and the scattering matrix please use se2scat after having calculated the self-energy, this will be much, MUCH faster!