AtomicOrbital¶

class sisl.AtomicOrbital(*args, **kwargs)[source]¶

A projected atomic orbital consisting of real harmonics

The AtomicOrbital is a specification of the SphericalOrbital by assigning the magnetic quantum number \(m\) to the object.

AtomicOrbital should always be preferred over the SphericalOrbital because it explicitly contains all quantum numbers.

Parameters:	args : list of arguments list of arguments can be in different input options q0 : float, optional initial charge tag* : str, optional user defined tag

Examples

>>> r = np.linspace(0, 5, 50)
>>> f = np.exp(-r)
>>> #                    n, l, m, [Z, [P]]
>>> orb1 = AtomicOrbital(2, 1, 0, 1, (r, f))
>>> orb2 = AtomicOrbital(n=2, l=1, m=0, Z=1, (r, f))
>>> orb3 = AtomicOrbital('2pzZ', (r, f))
>>> orb4 = AtomicOrbital('2pzZ1', (r, f))
>>> orb5 = AtomicOrbital('pz', (r, f))
>>> orb2 == orb3
True
>>> orb2 == orb4
True
>>> orb2 == orb5
True

Attributes:	R : float maximum radius (in Ang) n : int principal quantum number l : int azimuthal quantum number m : int magnetic quantum number Z : int zeta shell P : bool whether this corresponds to a polarized shell (`True`) f : func interpolation function that returns f(r) for a given radius q0 : float initial electronic charge tag : str user defined tag

Attributes

`P`
`R`
`Z`
`f`
`l`
`m`
`n`
`orb`
`q0`
`tag`

Methods

`__init__`(args, *kwargs)	Initialize atomic orbital object
`copy`()	Create an exact copy of this object
`equal`(other[, psi, radial])	Compare two orbitals by comparing their radius, and possibly the radial and psi functions
`name`([tex])	Return named specification of the atomic orbital
`psi`(r)	Calculate \(\phi(\mathbf r)\) at a given point (or more points)
`psi_spher`(r, theta, phi[, cos_phi])	Calculate \(\phi(\|\mathbf R\|, \theta, \phi)\) at a given point (in spherical coordinates)
`radial`(r[, is_radius])	Calculate the radial part of the wavefunction \(f(\mathbf R)\)
`scale`(scale)	Scale the orbital by extending R by `scale`
`set_radial`(*args)	Update the internal radial function used as a \(f(\|\mathbf r\|)\)
`spher`(theta, phi[, cos_phi])	Calculate the spherical harmonics of this orbital at a given point (in spherical coordinates)
`toGrid`([precision, c, R, dtype, Z])	Create a Grid with only this orbital wavefunction on it
`toSphere`([center])	Return a sphere with radius equal to the orbital size

P¶

R¶

Z¶

copy()[source]¶: Create an exact copy of this object

equal(other, psi=False, radial=False)[source]¶

Compare two orbitals by comparing their radius, and possibly the radial and psi functions

Parameters:	other : Orbital comparison orbital psi : bool, optional also compare that the full psi are the same radial : bool, optional also compare that the radial parts are the same

f¶

l¶

m¶

n¶

name(tex=False)[source]¶: Return named specification of the atomic orbital

orb¶

psi(r)[source]¶

Calculate \(\phi(\mathbf r)\) at a given point (or more points)

The position r is a vector from the origin of this orbital.

Parameters:	r : array_like the vector from the orbital origin
Returns:	psi : the orbital value at point r

psi_spher(r, theta, phi, cos_phi=False)[source]¶

Calculate \(\phi(|\mathbf R|, \theta, \phi)\) at a given point (in spherical coordinates)

This is equivalent to psi however, the input is given in spherical coordinates.

Parameters:	r : array_like the radius from the orbital origin theta : array_like azimuthal angle in the \(x-y\) plane (from \(x\)) phi : array_like polar angle from \(z\) axis cos_phi : bool, optional whether phi is actually \(cos(\phi)\) which will be faster because cos is not necessary to call.
Returns:	psi : the orbital value at point r

q0¶

radial(r, is_radius=True)[source]¶

Calculate the radial part of the wavefunction \(f(\mathbf R)\)

The position r is a vector from the origin of this orbital.

Parameters:	r : array_like radius from the orbital origin, for `is_radius=False` r must be vectors is_radius : bool, optional whether r is a vector or the radius
Returns:	f : the orbital value at point r

scale(scale)¶: Scale the orbital by extending R by scale

set_radial(*args)[source]¶

Update the internal radial function used as a \(f(|\mathbf r|)\)

See SphericalOrbital.set_radial where these arguments are passed to.

spher(theta, phi, cos_phi=False)[source]¶

Calculate the spherical harmonics of this orbital at a given point (in spherical coordinates)

Parameters:	theta : array_like azimuthal angle in the \(x-y\) plane (from \(x\)) phi : array_like polar angle from \(z\) axis cos_phi : bool, optional whether phi is actually \(cos(\phi)\) which will be faster because cos is not necessary to call.
Returns:	spher : the spherical harmonics at angles \(\theta\) and \(\phi\).

tag¶

toGrid(precision=0.05, c=1.0, R=None, dtype=<class 'numpy.float64'>, Z=1)¶

Create a Grid with only this orbital wavefunction on it

Parameters:	precision : float, optional used separation in the `Grid` between voxels (in Ang) c : float or complex, optional coefficient for the orbital R : float, optional box size of the grid (default to the orbital range) dtype : numpy.dtype, optional the used separation in the `Grid` between voxels Z : int, optional atomic number associated with the grid

toSphere(center=None)¶

Return a sphere with radius equal to the orbital size

Returns:	Sphere : the sphere with a radius equal to the radius of this orbital