sisl.Atom

class sisl.Atom(*args, **kwargs)

Bases: _Dispatchs

Atomic information for a single atomic species

An atomic object retaining information about a single atomic species. It describes the atomic number (integer), the mass of the atom, and holds a list of atomic centered orbitals. It also allows one to tag the atom to distinguish it from other atoms of the same species.

Parameters:

Z – determine species for the atomic species.
orbitals (list of Orbital or float, optional) – orbitals associated with this atom. See Orbital for details on how to define orbitals. Defaults to one orbital.
mass – the atomic mass, defaults to the mass found in PeriodicTable.
tag – arbitrary designation for user handling similar atoms with different settings (defaults to the label of the atom)

Examples

>>> Carbon = Atom(6)
>>> Carbon = Atom("C")
>>> Carbon = Atom("Carbon")

Add a tag to be able to distinguish it from other atoms >>> tagged_Carbon = Atom(“Carbon”, tag=”siteA”)

Create deuterium >>> D = Atom(“H”, mass=2.014)

Define an atom with 3 orbitals, each with a range of 2 Angstroem >>> C3 = Atom(“C”, orbitals=[2, 2, 2])

Define an atom outside of the periodic table (negative will yield an AtomGhost object) >>> ghost_C = Atom(-6)

Define an unknown atom (basically anything can do) >>> unknown_atom = Atom(1000)

Notes

One can define atoms outside of the periodic table. They will generally be handled in this order:

negative numbers will be converted into positive ones, and the returned object will be an AtomGhost
any other number (or name) not found in the periodic table will be returned in an AtomUnknown object

The mass for atoms outside the periodic table will default to 1e40 amu.

See also

Orbital: define an orbital
Atoms: an efficient collection of Atom objects

Conversion

`to`	A dispatcher for classes, using __get__ it converts into ObjectDispatcher upon invocation from an object, or a TypeDispatcher when invoked from a class
`to.Sphere`(*args[, center])

Methods

`copy`([Z, orbitals, mass, tag])	Return copy of this object
`equal`(other[, R, psi])	True if other is the same as this atomic species
`index`(orbital)	Return the index of the orbital in the atom object
`iter`([group])	Loop on all orbitals in this atom
`maxR`()	Return the maximum range of orbitals.
`radius`([method])	Return the atomic radius of the atom (in Ang)
`remove`(orbitals)	Return the same atom without a specific set of orbitals
`scale`(scale)	Scale the atomic radii and return an equivalent atom.
`sub`(orbitals)	Return the same atom with only a subset of the orbitals present
`toSphere`([center])	Return a sphere with the maximum orbital radius equal

Attributes

`Z`	Atomic number
`mass`	Atomic mass
`no`	Number of orbitals on this atom
`orbitals`	List of orbitals
`symbol`	Return short atomic name (Au==79).
`tag`	Tag for atom

copy(Z: int | str | None = None, orbitals=None, mass: float | None = None, tag: str | None = None) → Atom: Return copy of this object

equal(other, R: bool = True, psi: bool = False)[source]

True if other is the same as this atomic species

Parameters:

other (Atom) – the other object to check againts
R (bool, optional) – if True the equality check also checks the orbital radius, else they are not compared
psi (bool, optional) – if True, also check the wave-function component of the orbitals, see Orbital.psi

index(orbital)[source]: Return the index of the orbital in the atom object

iter(group: bool = False)[source]

Loop on all orbitals in this atom

Parameters:: group (bool, optional) – if two orbitals share the same radius one may be able to group two orbitals together
Returns:: Orbital – current orbital, if group is True this is a list of orbitals, otherwise a single orbital is returned

maxR()[source]: Return the maximum range of orbitals.

radius(method: Literal['calc', 'empirical', 'vdw'] = 'calc')[source]

Return the atomic radius of the atom (in Ang)

See PeriodicTable.radius for details on the argument.

remove(orbitals: sisl.typing.SimpleIndex) → Atom

Return the same atom without a specific set of orbitals

Parameters:: orbitals – indices of the orbitals to remove
Returns:: Atom – without the specified orbitals

See also

Atom.sub: retain a selected set of orbitals

scale(scale: float) → Atom

Scale the atomic radii and return an equivalent atom.

Parameters:: scale – the scale factor for the atomic radii

sub(orbitals: sisl.typing.SimpleIndex) → Atom

Return the same atom with only a subset of the orbitals present

Parameters:: orbitals – indices of the orbitals to retain
Returns:: Atom – with only the subset of orbitals
Raises:: ValueError – if the number of orbitals removed is too large or some indices are outside the allowed range

to.Sphere(*args, center=None, **kwargs)

toSphere(center=None)[source]

Return a sphere with the maximum orbital radius equal

Returns:: Sphere – a sphere with radius equal to the maximum radius of the orbitals

property Z: int: Atomic number

property mass: float: Atomic mass

property no: int: Number of orbitals on this atom

property orbitals: List of orbitals

property symbol: Return short atomic name (Au==79).

property tag: str: Tag for atom

to

A dispatcher for classes, using __get__ it converts into ObjectDispatcher upon invocation from an object, or a TypeDispatcher when invoked from a class

This is a class-placeholder allowing a dispatcher to be a class attribute and converted into an ObjectDispatcher when invoked from an object.

If it is called on the class, it will return a TypeDispatcher.

This class should be an attribute of a class. It heavily relies on the __get__ special method.

Parameters:

name (str) – name of the attribute in the class
dispatchs (dict, optional) – dictionary of dispatch methods
obj_getattr (callable, optional) – method with 2 arguments, an obj and the attr which may be used to control how the attribute is called.
instance_dispatcher (AbstractDispatcher, optional) – control how instance dispatchers are handled through __get__ method. This controls the dispatcher used if called from an instance.
type_dispatcher (AbstractDispatcher, optional) – control how class dispatchers are handled through __get__ method. This controls the dispatcher used if called from a class.

Examples

>>> class A:
...   new = ClassDispatcher("new", obj_getattr=lambda obj, attr: getattr(obj.sub, attr))

The above defers any attributes to the contained A.sub attribute.