BornEffectiveCharge¶

class BornEffectiveCharge(configuration, kpoints_a=None, kpoints_b=None, kpoints_c=None, atomic_displacement=None, use_symmetry=None, non_selfconsistent_update=None, polarization_cartesian_directions=None, atom_indices=None, processes_per_displacement=None)¶

Class for calculating the Born effective charge of a configuration.

Parameters:

configuration (BulkConfiguration) – The configuration with attached calculator that supports Berry-phase polarization calculations.
kpoints_a (sequence (size 3) of int | MonkhorstPackGrid | KpointDensity) – The k-point sampling to use for integrating along the first direction.
Default: MonkhorstPackGrid(n_aa, n_ab, n_ac), where n_aa, n_ab, and n_ac are determined from the sampling (na, nb, nc) used for the self consistent calculation as follows: n_aa = 2 * na + 1, n_ab = nb, n_ac = nc.
kpoints_b (sequence (size 3) of int | MonkhorstPackGrid | KpointDensity) – The k-point sampling to use for integrating along the second direction.
Default: MonkhorstPackGrid(n_ba, n_bb, n_bc), where n_ba, n_bb, and n_bc are determined from the sampling (na, nb, nc) used for the self consistent calculation as follows: n_ba = na, n_bb = 2 * nb + 1, n_bc = nc.
kpoints_c (sequence (size 3) of int | MonkhorstPackGrid | KpointDensity) – The k-point sampling to use for integrating along the third direction.
Default: MonkhorstPackGrid(n_ca, n_cb, n_cc), where n_ca, n_cb, and n_cc are determined from the sampling (na, nb, nc) used for the self consistent calculation as follows: n_ca = na, n_cb = nb, n_cc = 2 * nc + 1.
atomic_displacement (PhysicalQuantity of type length) – The distance the atoms are displaced in the finite difference method.
Default: 0.01*Angstrom
use_symmetry (bool) – If enabled, only the symmetrically unique atoms are displaced and the remaining born effective charges are calculated using symmetry.
Default: True
non_selfconsistent_update (bool) – If True, the displaced configurations are updated non-self-consistently. This leads to a computational speed-up, but the results should be carefully checked against self-consistent calculations.
Default: False
polarization_cartesian_directions (list of CartesianDirection.{X,Y,Z}) – Restrict the evaluation of the Polarization to specific Cartesian directions. For example, if [CartesianDirection.X] is specified, only the xx, xy, xz components of the born effective charge tensor are calculated. This option can be used to speed up the calculation if only such components are required.
Default: [CartesianDirection.X, CartesianDirection.Y, CartesianDirection.Z]
atom_indices (All | list of ints.) – The atom indices for which to calculate the Born effective charges. If not All, the use of symmetries will be disabled.
Default: All i.e. all atoms in the configuration.
processes_per_displacement (Automatic | int) – The number of processes to use per atomic displacement. When set to Automatic the number will be determined automatically maximizing the number of displacements calculated in parallel and minimizing the number of idle processes. One may set this number manually in order to reduce the memory requirements for each process.
Default: Automatic

atomIndices()¶

Returns:: The atom indices.
Return type:: list of int.

atomicDisplacement()¶

Returns:: The distance the atoms are displaced in the finite difference method.
Return type:: PhysicalQuantity of type length

evaluate(charge_sum_rule_method=None)¶

The Born effective charge \(Z_{\alpha, i j}\) for the ion \(\alpha\) displaced in direction j leading to the Polarization in direction i.

Parameters:: charge_sum_rule_method (None | DistributeEvenly | DistributeRelative.) – Keyword specifying if a charge sum-rule should be applied to the Born effective charges. Can be None for no sum-rule application. Alternatively the charge error is either distributed evenly (DistributeEvenly) or relative (DistributeRelative) to the Born effective charges on the atoms.
Default: None
Returns:: The Born effective charge as an array of shape (n, 3, 3), where n is the number of atoms. The second last entry is the Cartesian direction of polarization and the last is the direction in which the ion is displaced.
Return type:: PhysicalQuantity of type charge

kpointsA()¶

Returns:: The k-point sampling used for integrating along the first direction.
Return type:: MonkhorstPackGrid

kpointsB()¶

Returns:: The k-point sampling used for integrating along the second direction.
Return type:: MonkhorstPackGrid

kpointsC()¶

Returns:: The k-point sampling used for integrating along the third direction.
Return type:: MonkhorstPackGrid

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()

nonSelfconsistentUpdate()¶

Returns:: True if the displaced configurations are updated non-selfconsistently.
Return type:: bool

polarizationCartesianDirections()¶

Returns:: The Cartesian components for which the polarization is evaluated.
Return type:: list of CartesianDirection.{X,Y,Z}

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.

useSymmetry()¶

Returns:: True if the use of crystal symmetry to reduce the number of displacements is enabled.
Return type:: bool

Usage Examples¶

Calculate the born effective charge of GaAs:

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

# Set up lattice
lattice = FaceCenteredCubic(5.6537*Angstrom)

# Define elements
elements = [Gallium, Arsenic]

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

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

# -------------------------------------------------------------
# Calculator
# -------------------------------------------------------------
#----------------------------------------
# Exchange-Correlation
#----------------------------------------
exchange_correlation = LDA.PZ

k_point_sampling = MonkhorstPackGrid(
    na=14,
    nb=14,
    nc=14,
    )
numerical_accuracy_parameters = NumericalAccuracyParameters(
    density_mesh_cutoff=30.0*Hartree,
    k_point_sampling=k_point_sampling,
    occupation_method=FermiDirac(100.0*Kelvin*boltzmann_constant),
    )

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

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

# -------------------------------------------------------------
# Born Effective Charge
# -------------------------------------------------------------
born_effective_charge = BornEffectiveCharge(
    configuration=bulk_configuration,
    kpoints_a=MonkhorstPackGrid(21, 5, 5),
    kpoints_b=MonkhorstPackGrid(5, 21, 5),
    kpoints_c=MonkhorstPackGrid(5, 5, 21),
    atomic_displacement=0.01*Angstrom,
    )
nlsave('GaAs.hdf5', born_effective_charge)

born_effective_charge.py

The output from the calculation is:

+------------------------------------------------------------------------------+
| Born Effective Charge Report                                                 |
+------------------------------------------------------------------------------+
|                                                                              |
| 0 Ga:                                                                        |
|                                                                              |
| [[ 2.08384046e+00  2.01655410e-16 -2.01655418e-16]                           |
|  [ 2.01655410e-16  2.08384046e+00 -2.01655418e-16]                           |
|  [ 0.00000000e+00  0.00000000e+00  2.08384046e+00]] e                        |
|                                                                              |
+------------------------------------------------------------------------------+
|                                                                              |
| 1 As:                                                                        |
|                                                                              |
| [[-2.08597738e+00 -2.01862227e-16  2.01862227e-16]                           |
|  [-2.01862228e-16 -2.08597738e+00  2.01862228e-16]                           |
|  [ 0.00000000e+00  0.00000000e+00 -2.08597738e+00]] e                        |
|                                                                              |
+------------------------------------------------------------------------------+

The calculated Born effective charge tensors are diagonal with a diagonal value of around \(\pm 2.1\) for Ga and As, respectively, in agreement with experiments and previous calculations [1].

Notes¶

The Born effective charge tensor is defined as the derivative of the polarization with respect to the atomic coordinate

\[Z^*_{\mu, ij} = \Omega_0 \frac{\partial \mathbf{P}_i}{\partial \mathbf{r}_{\mu, j}},\]

where \(\Omega_0\) is the unit cell volume, \(\mathbf{P}_i\) is the i’th Cartesian component of the Polarization and \(\mathbf{r}_{\mu, j}\) is the j’th Cartesian component of the position of atom \(\mu\).

When calculating the Born effective charge notice the following

Perform the calculation with a low electronic broadening (e.g. 100 K). The default of 1000 K can lead to wrong results for small band gap materials.
Carefully check the results agaist the parameter atomic_displacement. Ususally the default value of 0.01*Angstrom is a good choice but you might need to either increase or decrease it.