GilbertDamping

class GilbertDamping(configuration, kpoints=None, broadenings=None)

Class for calculating the Gilbert damping for a BulkConfiguration.

Parameters:
  • configuration (BulkConfiguration) – The BulkConfiguration for which to calculate the inter-site coupling matrix.

  • kpoints (sequence (size 3) of int | MonkhorstPackGrid | KpointDensity | RegularKpointGrid) – The k-points with which to calculate the Gilbert damping.
    Default: The k-point sampling from the calculator.

  • broadenings (PhysicalQuantity of type energy.) – Energy level broadening due finite life time.
    Default: numpy.linspace(0.01, 0.1, 11)*eV

alpha()
Returns:

Dimensionless Gilbert damping tensor

Return type:

numpy.array of shape (3,3).

broadenings()
Returns:

Energy level broadening due finite life time.

Return type:

PhysicalQuantity of type energy.

dampingConstant()
Returns:

Dimensionless Gilbert damping constant

Return type:

float

dampingRate()
Returns:

Gilbert damping constant

Return type:

PhysicalQuantity of type inverse time

dampingRateTensor()
Returns:

Gilbert damping tentor

Return type:

PhysicalQuantity of type inverse time

kpoints()
Returns:

The k-points with which to calculate the Heisenberg exchange constants.

Return type:

class:~.MonkhorstPackGrid | RegularKpointGrid

magneticMoment()
Returns:

The total magnetic moment.

Return type:

PhysicalQuantity of type Bohr magneton

metatext()
Returns:

The metatext of the object or None if no metatext is present.

Return type:

str | None

nlprint(stream=None)

Print a string containing an ASCII table useful for plotting the AnalysisSpin object.

Parameters:

stream (python stream) – The stream the table should be written to.
Default: NLPrintLogger()

setMetatext(metatext)

Set a given metatext string on the object.

Parameters:

metatext (str | None) – The metatext string that should be set. A value of “None” can be given to remove the current metatext.

uniqueString()

Return a unique string representing the state of the object.

Usage Examples

Calculate the GilbertDamping for iron.

# -------------------------------------------------------------
# Bulk Configuration
# -------------------------------------------------------------

# Set up lattice
lattice = BodyCenteredCubic(2.8665*Angstrom)

# Define elements
elements = [Iron]

# Define coordinates
fractional_coordinates = [[ 0.,  0.,  0.]]

# Set up configuration
bulk_configuration = BulkConfiguration(
    bravais_lattice=lattice,
    elements=elements,
    fractional_coordinates=fractional_coordinates
    )

# -------------------------------------------------------------
# Calculator
# -------------------------------------------------------------
#----------------------------------------
# Basis Set
#----------------------------------------
basis_set = [
    BasisGGAPseudoDojoSO.Iron_Medium,
    ]

#----------------------------------------
# Exchange-Correlation
#----------------------------------------
exchange_correlation = SOGGA.PBE

k_point_sampling = MonkhorstPackGrid(
    na=13,
    nb=13,
    nc=13,
    force_timereversal=False,
    )
numerical_accuracy_parameters = NumericalAccuracyParameters(
    density_mesh_cutoff=120.0*Hartree,
    k_point_sampling=k_point_sampling,
    )

calculator = LCAOCalculator(
    basis_set=basis_set,
    exchange_correlation=exchange_correlation,
    numerical_accuracy_parameters=numerical_accuracy_parameters,
    )

bulk_configuration.setCalculator(calculator)
nlprint(bulk_configuration)
bulk_configuration.update()
nlsave('gilbert_damping_iron.hdf5', bulk_configuration)

# -------------------------------------------------------------
# Gilbert Damping
# -------------------------------------------------------------
kpoint_grid = MonkhorstPackGrid(
    na=38,
    nb=38,
    nc=38,
    force_timereversal=False,
    )

gilbert_damping = GilbertDamping(
    configuration=bulk_configuration,
    kpoints=kpoint_grid,
    broadenings=numpy.linspace(0.01, 0.1, 11)*eV,
)
nlsave('gilbert_damping_iron.hdf5', gilbert_damping)

gilbert_damping.py

Notes

The unitless Gilbert damping tensor is calculated using Kambersky’s torque-torque correlation model following refs. [1][2][3] :

\[\mathbf{\alpha}_{\mu,\nu} = \frac{g}{m \pi} \sum_k w_k \sum_{ij} W_{ij}(k) T_{ij}^\nu(k) \left(T_{ij}^\mu(k) \right)^\dagger\]

where \(g = 2.0023\) is the g-factor, \(m\) is the magnetization (has unit of Bohr magnetons). The sum over \(i,j\) runs over the band indices and the \(k\) sum is over the Brillouin zone with \(w_k\) being the k-point weight. The matrix elements of the torque operator are

\[T_{ij}^\nu(k) = \langle \psi_{ik} | \left[\sigma^\nu, H_{SO} \right] |\psi_{jk} \rangle\]

where \(\sigma^\nu\) is a Pauli spin matrix, \(H_{SO}\) is the spin-orbit contribution to the Hamiltonian and \(\psi_{ik}\) is the Bloch eigenstate of band \(n\) evaluated at k-point \(k\). The spectral overlap function is

\[W_{ij}(k) = \int \left(-\frac{\partial f(\epsilon, \epsilon_F)}{\partial \epsilon} \right) A_{ik}(\epsilon, \Lambda) A_{jk}(\epsilon, \Lambda) d\epsilon\]

where \(f(\epsilon, \epsilon_F)\) is the Fermi-Dirac distribution function (\(\epsilon_F\) is the Fermi energy), and \(A_{ik}(\epsilon, \Lambda) = \frac{1}{\pi}\frac{\Lambda}{(\epsilon_{ik}-\epsilon)^2 + \Lambda^2}\) is a Lorentzian spectral function with broadening \(\Lambda\) and centered around the band energy \(\epsilon_{ik}\).

Assuming that the spectral life-time broadening \(\Lambda\) is due to electron-phonon coupling, it is reasonable to assume that \(\Lambda > k_B T\) in which case we can approximate the derivative of the Fermi-Dirac distribution can be approximated by a \(\delta\)-function resulting in the simplified expression

\[W_{ij}(k) \approx A_{ik}(\epsilon_F, \Lambda) A_{jk}(\epsilon_F, \Lambda)\]

which is implemented in QuantumATK.

The unitless damping tensor can be obtained as

# Unitless damping tensor.
alpha_tensor = gilbert_damping.alpha()

When the magnetic moment is oriented along the \(z\)-direction as will usually be the case, the quantity of interest will often be calculated from the torque operator \(\langle \psi_{ik} | \left[\sigma^-, H_{SO} \right] |\psi_{jk} \rangle\), where \(\sigma^- = \sigma^x - i \sigma^y\). This corresponds to the sum of the tensor elements \(\alpha = \mathbf{\alpha}_{xx} + \mathbf{\alpha}_{yy}\) This number is obtained for each value of the broadening as

# Sum of xx and yy components of the dimensionless damping tensor.
alpha = gilbert_damping.dampingConstant()

The relation between the unitless damping tensor and the physical damping rate in units of inverse time is:

\[\mathbf{\lambda} = \gamma M \mu_0 \mathbf{\alpha}\]

where the gyro-magnetic ratio is \(\gamma = g \mu_B / \hbar\) and the magnetization \(M=\frac{m}{V}\) is the magnetic moment divided by unit cell volume. \(\mu_0\) is the vacuum permeability and \(\mu_B\) is the Bohr magneton.

The damping rate in units of inverse time is obtained as

# Damping rate tensor in units of inverse time
damping_rate_tensor = gilbert_damping.dampingRateTensor()

# Sum of xx and yy components of the damping rate tensor.
damping_rate = gilbert_damping.dampingRate()

The life-time broadening, \(\Lambda\)

The life-time broadening \(\Lambda\) can in principle have several origins such as electron-phonon scattering, impurity scattering or alloy scattering. It is often assumed that the electron-phonon coupling is the dominant scattering mechanism, at least at temperatures \(T \gg 0K\). In QuantumATK it is possible to calculate the scattering rate, or inverse life time, due to electron phonon coupling. See the ElectronPhononCoupling object for more information.