Extending TB2J

In this section we show how to extend TB2J to interface with other first principles or similar codes and to write the output formats useful for codes such as spin dynamics.

Interface TB2J with other first principles or similar codes.

To interface a DFT code with TB2J, one has only to implement a tight-binding-like model which has certain methods and properties implemented. TB2J make use of the duck type feature of python, thus any class which has these things can be plugged in. Then the object can be inputted to the TB2J.Exchange class.

The methods and properties of AbstractTB class is listed as below.

class TB2J.myTB.AbstractTB(R2kfactor, nspin, norb)

HS_and_eigen(kpts)

get Hamiltonian, overlap matrices, eigenvalues, eigen vectors for all kpoints.

Param:

kpts: list of k points.

Returns:

H, S, eigenvalues, eigenvectors for all kpoints
H: complex array of shape (nkpts, nbasis, nbasis)
S: complex array of shape (nkpts, nbasis, nbasis). S=None if the basis set is orthonormal.
evals: complex array of shape (nkpts, nbands)
evecs: complex array of shape (nkpts, nbasis, nbands)

get_hamR(R): get the Hamiltonian H(R), array of shape (nbasis, nbasis)

get_orbs(): returns the orbitals.

is_siesta: \(\alpha\) used in \(H(k)=\sum_R H(R) \exp( \alpha k \cdot R)\), Should be \(2\pi i\) or \(-2\pi i\)

nbasis: nbasis=nspin*norb

norb: number of orbitals. Each orbital can have two spins.

nspin: number of spin. 1 for collinear, 2 for spinor.

xcart: The array of cartesian coordinate of all basis. shape:nbasis,3

xred: The array of cartesian coordinate of all basis. shape:nbasis,3

To pass the tight-binding-like model to the Exchange class is quite simple, here I take the sisl interface as an example

# read hamiltonian using sisl
fdf = sisl.get_sile(fdf_fname)
H = fdf.read_hamiltonian()
# wrap the hamiltonian to SislWrapper
tbmodel = SislWrapper(H, spin=None)
# pass to ExchangeNCL
exchange = ExchangeNCL(
    tbmodels=tbmodel,
    atoms=atoms,
    efermi=0.0,
    magnetic_elements=magnetic_elements,
    kmesh=kmesh,
    emin=emin,
    emax=emax,
    nz=nz,
    exclude_orbs=exclude_orbs,
    Rcut=Rcut,
    ne=ne,
    description=description)
exchange.run()

In which the SislWrapper is a AbstractTB-like class which use sisl to read the Hamiltonian and overlap matrix from Siesta output.

Extend the output to other formats

The calculated magnetic interaction parameters, together with other informations, such as the atomic structure and some metadata, are saved in “SpinIO” object. By making use of it, it is easy to output the parameters to the file format needed. Some parameters, which cannot be calculated in TB2J can also be inputted so that they can be written to the files. The list of stored data is listed below, by using which it should be easy to write the output function as a member of the SpinIO class. A method write_some_format(path) can be implemented and called in the write_all method. Then the format is automatically written after the TB2J calculation.

class TB2J.io_exchange.SpinIO(atoms, spinat, charges, index_spin, orbital_names={}, colinear=True, distance_dict=None, exchange_Jdict=None, Jiso_orb=None, DMI_orb=None, Jani_orb=None, dJdx=None, dJdx2=None, dmi_ddict=None, Jani_dict=None, biquadratic_Jdict=None, debug_dict=None, k1=None, k1dir=None, NJT_Jdict=None, NJT_ddict=None, damping=None, gyro_ratio=None, write_experimental=True, description=None)

Jani_dict: The dictionary of anisotropic exchange. The vlaues are matrices of shape (3,3).

atoms: atomic structures, ase.Atoms object

colinear: If the calculation is collinear or not

dmi_ddict: The dictionary of DMI. the key is the same as exchange_Jdict, the values are 3-d vectors (Dx, Dy, Dz).

get_DMI(i, j, R, default=None)

get_J(i, j, R, default=None)

get_J_tensor(i, j, R, iso_only=False): Return the full exchange tensor for atom i and j, and cell R. param i : spin index i param j: spin index j param R (tuple of integers): cell index R

get_Jani(i, j, R, default=None): Return the anisotropic exchange tensor for atom i and j, and cell R. param i : spin index i param j: spin index j param R (tuple of integers): cell index R

get_Jiso(i, j, R, default=None)

get_charge_iatom(iatom)

get_charge_ispin(i)

get_full_Jtensor_for_Rlist(asr=False, iso_only=False)

get_full_Jtensor_for_one_R(R): Return the full exchange tensor of all i and j for cell R. param R (tuple of integers): cell index R returns:

Jmat: (3*nspin,3*nspin) matrix.

get_spin_iatom(iatom)

get_spin_ispin(i)

get_symbol_number_ispin(symnum): Return the spin index for a given symbol number.

gyro_ratio: Gyromagnetic ratio for each atom

has_bilinear: Whether there is anisotropic exchange term

has_dmi: Whether there is DMI.

has_exchange: whether there is isotropic exchange

i_spin(i)

iatom(i)

property ind_atoms

classmethod load_pickle(path='TB2J_results', fname='TB2J.pickle')

model(path)

plot_DvsR(ax=None, fname=None, show=False)

plot_JanivsR(ax=None, fname=None, show=False)

plot_JvsR(ax=None, color='blue', marker='o', fname=None, show=False, **kwargs)

plot_all(title=None, savefile=None, show=False)

spinat: spin for each atom. shape of (natom, 3)

write_Jq(kmesh, path, gamma=True, output_fname='EigenJq.txt', **kwargs)

write_all(path='TB2J_results')

write_multibinit(path)

write_pickle(path='TB2J_results', fname='TB2J.pickle')

write_tom_format(path)

write_txt(*args, **kwargs)

write_uppasd(path)

write_vampire(path)