RealSpaceSE¶

class sisl.physics.RealSpaceSE(parent, semi_axis, k_axes, unfold=1, 1, 1, **options)¶

Bases: sisl.physics.SelfEnergy

Bulk real-space self-energy (or Green function) for a given physical object with periodicity

The real-space self-energy is calculated via the k-averaged Green function:

\[\boldsymbol\Sigma^\mathcal{R}(E) = \mathbf S^\mathcal{R} (E+i\eta) - \mathbf H^\mathcal{R} - \Big[\sum_{\mathbf k} \mathbf G_{\mathbf k}(E)\Big]^{-1}\]

The method actually used is relying on RecursiveSI and Bloch objects.

Parameters

parent (SparseOrbitalBZ) – a physical object from which to calculate the real-space self-energy. The parent object must have only 3 supercells along the direction where self-energies are used.
semi_axis (int) – semi-infinite direction (where self-energies are used and thus exact precision)
k_axes (array_like of int) – the axes where k-points are desired. 1 or 2 values are required and the semi_axis cannot be one of them
unfold ((3,) of int) – number of times the parent structure is tiled along each direction The resulting Green function/self-energy ordering is always tiled along the semi-infinite direction first, and then the other directions in order.
eta (float, optional) – imaginary part in the self-energy calculations (default 1e-4 eV)
dk (float, optional) – fineness of the default integration grid, specified in units of Ang, default to 1000 which translates to 1000 k-points along reciprocal cells of length 1. Ang^-1.
bz (BrillouinZone, optional) – integration k-points, if not passed the number of k-points will be determined using dk and time-reversal symmetry will be determined by trs, the number of points refers to the unfolded system.
trs (bool, optional) – whether time-reversal symmetry is used in the BrillouinZone integration, default to true.

Examples

>>> graphene = geom.graphene()
>>> H = Hamiltonian(graphene)
>>> H.construct([(0.1, 1.44), (0, -2.7)])
>>> rse = RealSpaceSE(H, 0, 1, (3, 4, 1))
>>> rse.green(0.1)

The Brillouin zone integration is determined naturally.

>>> graphene = geom.graphene()
>>> H = Hamiltonian(graphene)
>>> H.construct([(0.1, 1.44), (0, -2.7)])
>>> rse = RealSpaceSE(H, 0, 1, (3, 4, 1))
>>> rse.set_options(eta=1e-3, bz=MonkhorstPack(H, [1, 1000, 1]))
>>> rse.initialize()
>>> rse.green(0.1) # eta = 1e-3
>>> rse.green(0.1 + 1j * 1e-4) # eta = 1e-4

Manually specify Brillouin zone integration and default \(\eta\) value.

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__`(parent, semi_axis, k_axes[, unfold])	Initialize real-space self-energy calculator
`__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__`()	String representation of RealSpaceSE
`__subclasshook__`	Abstract classes can override this to customize issubclass().
`_setup`(args, *kwargs)	Class specific setup routine
`clear`()	Clears the internal arrays created in `initialize`
`green`(E[, k, dtype])	Calculate the real-space Green function
`initialize`()	Initialize the internal data-arrays used for efficient calculation of the real-space quantities
`real_space_coupling`([ret_indices])	Real-space coupling parent where sites fold into the parent real-space unit cell
`real_space_parent`()	Return the parent object in the real-space unfolded region
`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, bulk, coupling, dtype])	Calculate the real-space self-energy
`set_options`(**options)	Update options in the real-space self-energy

clear()[source]¶: Clears the internal arrays created in initialize

green(E, k=0, 0, 0, dtype=None, **kwargs)[source]¶

Calculate the real-space Green function

The real space Green function is calculated via:

\[\mathbf G^\mathcal{R}(E) = \sum_{\mathbf k} \mathbf G_{\mathbf k}(E)\]

Parameters

E (float/complex) – energy to evaluate the real-space Green function at
k (array_like, optional) – only viable for 3D bulk systems with real-space Green functions along 2 directions. I.e. this would correspond to a circular real-space Green function
dtype (numpy.dtype, optional) – the resulting data type, default to np.complex128
**kwargs (dict, optional) – arguments passed directly to the self.parent.Pk method (not self.parent.Sk), for instance spin

initialize()[source]¶

Initialize the internal data-arrays used for efficient calculation of the real-space quantities

This method should first be called after all options has been specified.

If the user hasn’t specified the bz value as an option this method will update the internal integration Brillouin zone based on dk and trs options. The \(\mathbf k\) point sampling corresponds to the number of points in the non-folded system and thus the final sampling is equivalent to the sampling times the unfolding (per \(\mathbf k\) direction).

real_space_coupling(ret_indices=False)[source]¶

Real-space coupling parent where sites fold into the parent real-space unit cell

The resulting parent object only contains the inner-cell couplings for the elements that couple out of the real-space matrix.

Parameters

ret_indices (bool, optional) – if true, also return the atomic indices (corresponding to real_space_parent) that encompass the coupling matrix

Returns

parent (object) – parent object only retaining the elements of the atoms that couple out of the primary unit cell
atoms (numpy.ndarray) – indices for the atoms that couple out of the geometry, only if ret_indices is true

real_space_parent()[source]¶: Return the parent object in the real-space unfolded region

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!