ChargedPointDefectConfiguration

class ChargedPointDefectConfiguration(pristine_configuration, point_defect, atomic_chemical_potentials, charge_states=None, pre_relaxation_calculator=None, pre_relaxation_parameters=None, relax_atomic_coordinates=None, relaxation_parameters=None, rattle_atomic_coordinates=None, random_seed=None, use_ghost_atoms=None, fix_atom=None)

Create a charge point defect based on a specific configuration.

Parameters:

  • pristine_configuration (PristineConfiguration) – The original material without defects.

  • point_defect (NamedPointDefect) – The named point defect used to generate the defected structure.

  • atomic_chemical_potentials (Sequence or table of CalculatedChemicalPotential | ReferenceChemicalPotential) – List of chemical potentials for the elements in the defect configuration.

  • charge_states (Sequence of int) – The integer charge states to calculate.

  • relax_atomic_coordinates (bool) – Whether to relax the atomic coordinates.
    Default: True.

  • pre_relaxation_calculator (All calculators | None) – The calculator used for relaxing the atomic coordinates. If not specified and relaxation is enabled the reference calculator is used.

  • pre_relaxation_parameters (OptimizeGeometryParameters | None) – The parameters for the atomic pre-relaxation, if enabled. Only constraints of type FixAtomConstraints and RigidBody will be maintained, others will be discarded.

  • relaxation_parameters (OptimizeGeometryParameters | None) – The parameters for the atomic relaxation, if enabled. The parameters will also be used when calculating the vibrations if a phonon calculator has been supplied. Only constraints of type FixAtomConstraints and RigidBody will be maintained, others will be discarded.

  • rattle_atomic_coordinates (bool) – Whether to rattle the atomic coordinates before relaxation to destroy symmetry.
    Default: False

  • random_seed (int | None) – The random seed for the atomic rattling.

  • use_ghost_atoms (bool) – Whether to use ghost atoms when generating single vacancy defects. For other defect types ghost atoms are not supported.
    Default: False

  • fix_atom –
    Deprecated: from v2024.09, has no effect and should no longer be used.

allConverged()
Returns:

Whether all calculated SCF loops and geometry optimizations are converged.

Return type:

bool

atomicChemicalPotentials(element=None)

Return one or all of the atomic chemical potentials used to define the zero of energy in the defect system.

Parameters:

element (PeriodicTableElement | None) – The element for which the chemical potential is sought. If not given a list of all chemical potentials is returned.

Returns:

The atomic chemical potentials used to define the zero energy in the configuration.

Return type:

list | ReferenceChemcialPotential | CalculatedChemicalPotential

chargeStates()
Returns:

The charge states, in integer electron charges, calculated for the defect.

Return type:

tuple of int

concentration(charge_state=0, element_in_pristine=None, electronic_chemical_potential=None, electronic_chemical_potential_reference=None, temperature=PhysicalQuantity(300.0, K), equivalent_defects=None, internal_degrees_of_freedom=1)

Calculates the concentration of the defect in the given charge state and at the given temperature.

Parameters:

  • charge_state (int) – The charge state of the defect.

  • element_in_pristine (None | All | PeriodicTableElement) – The element whose chemical potential value is taken from the pristine material. Can be None (elemental reference), All (thermodynamic reference), or an element in the pristine material (element poor reference).

  • electronic_chemical_potential (PhysicalQuantity of type energy) – The electronic chemical potential relative to electronic_chemical_potential_reference.
    Default: 0.0 * eV

  • electronic_chemical_potential_reference (ValenceBandEdge | ConductionBandEdge) – The reference level for the electronic chemical potential.
    Default: ValenceBandEdge

  • temperature (PhysicalQuantity of type temperature) – The temperature at which the concentration should be calculated.
    Default: 300K.

  • equivalent_defects (int) – The number of equivalent sites for this defect in the primitive host cell.
    Default: Automatically determined using symmetry.

  • internal_degrees_of_freedom (int) – The internal degrees of freedom of the defect. E.g. spin states or equivalent orientations (self-interstitials).
    Default: 1.

Returns:

The concentration of the defect.

Return type:

PhysicalQuantity of type inverse volume

defectCenterConfiguration(charge_state=None, symmetry_group_index=0, symmetry_operation_index=0, unit_cell_translation=None, symmetry_type=<class 'NL.ComputerScienceUtilities.NLFlag._NLFlag.DefectSuperCell'>)

Retrieve the calculated position of the defect center for a given supercell, in the form of a bulk configuration (the configuration has a single hydrogen atom at the defect center).

This result will only be available after the calculation ran successfully.

Parameters:

  • charge_state (int) – The charge state of the defect.
    Default: 0

  • symmetry_group_index (int) – The index of the group of symmetry operations that give the same configuration.

  • symmetry_operation_index (int) – The index of the operation within the group to apply.

  • unit_cell_translation (sequence (size 3) of int) – An additional translation to apply in terms of the unit cell vectors.
    Default: No translation.

  • symmetry_type (DefectUnitCell | DefectSuperCell) – Whether the supercell or unit cell symmetry is used to transform the defect position.
    Default: DefectSuperCell.

Returns:

The defect center configuration. If not available, returns None.

Return type:

BulkConfiguration | None

defectConfiguration(charge_state=None)

The defect configuration associated with a given change state.

Parameters:

charge_state (int) – The charge of the defect.

Returns:

The configuration of the defect.

Return type:

BulkConfiguration

defectSymmetryData(charge_state=None)

Return information about the symmetry of the optimized defect.

Parameters:

charge_state (int) – The charge state of the defect.
Default: 0

Returns:

The symmetry information for the defect supercell. If not available, returns None.

Return type:

dict | None

finiteSizeCorrection(charge_state=None)

The finite size correction for the defect.

Parameters:

charge_state (int) – The charge of the defect.

Returns:

The band shift correction.

Return type:

IsotropicFiniteSizeCorrection | InterfaceFiniteSizeCorrection

fitConcentrationArrheniusParameters(charge_state=None, element_in_pristine=None, electronic_chemical_potential=None, electronic_chemical_potential_reference=None, temperatures=None, equivalent_defects=None, internal_degrees_of_freedom=1)

Fit Arrhenius parameters describing concentration at a particular charge state or the intrinsic concentration. The Arrhenius equation is given as:

\(C = A \exp(B/T)\)

Parameters:

  • charge_state (int | None) – The charge state at which the parameters are calculated. If None is given parameters are calculated for the intrinsic concentration.

  • element_in_pristine (None | All | PeriodicTableElement) – The element whose chemical potential value is taken from the pristine material. Can be None (elemental reference), All (thermodynamic reference), or an element in the pristine material (element poor reference).

  • electronic_chemical_potential (PhysicalQuantity of type energy) – The electronic chemical potential relative to electronic_chemical_potential_reference.
    Default: 0.0 * eV

  • electronic_chemical_potential_reference (ValenceBandEdge | ConductionBandEdge) – The reference level for the electronic chemical potential.
    Default: ValenceBandEdge

  • temperatures (PhysicalQuantity of type temperature) – A list of temperatures at which the concentration is calculated for fitting.
    Default: Temperature range of 300K to 1500K in 100K increments.

  • equivalent_defects (int) – The number of equivalent sites for this defect in the primitive host cell.
    Default: Automatically determined using symmetry.

  • internal_degrees_of_freedom (int) – The internal degrees of freedom of the defect. E.g. spin states or equivalent orientations (self-interstitials).

Returns:

Tuple of the Arrhenius pre-factor and barrier.

Return type:

tuple of PhysicalQuantity of type inverse volume and PhysicalQuantity of type temperature.

fixAtom()

Deprecated: Drift automatically removed in the structure relaxation without fixing an atom.


Deprecated: Drift automatically removed in the structure relaxation without fixing an atom.

formationEnergyCalculator()
Returns:

The calculator used to calculate the formation energy.

Return type:

Calculator

formationEntropy(charge_state=None, temperature=None, element_in_pristine=None)

Determines the formation entropy for a given defect, defined as

\(S_f^{\mathrm{harmonic}} = S^{\mathrm{def}}_{\mathrm{vib}} \ - S^{\mathrm{pr}}_{\mathrm{vib}} - \sum_i \Delta n_i s_i\)

where the first and second terms correspond to the defect and pristine entropies, respectively, and the third term is the sum of the atomic partial entropies.

Parameters:

  • charge_state (int) – The charge of the defect.

  • temperature (PhysicalQuantity of type temperature) – The temperature used for calculating the formation entropy.
    Default: 300.0 * Kelvin

  • element_in_pristine (None | All | PeriodicTableElement) – The element whose chemical potential value is taken from the pristine material. Can be None (elemental reference), All (thermodynamic reference), or an element in the pristine material (element poor reference).

Returns:

The calculated formation entropy.

Return type:

PhysicalQuantity of type energy per temperature.

formationFreeEnergy(charge_state=None, element_in_pristine=None, electronic_chemical_potential=None, electronic_chemical_potential_reference=None, defect_type=None, enable_finite_size_corrections=None, temperature=None, include_vibrations=None)

Return the Helmholtz formation free energy. This is calculated as:

\(F_f = U_f - TS_f\)

If vibrations are not included, the entropy \(S_f\) is zero and the formation internal energy and free energy is simply the electronic formation energy of the defect. If vibrations are included, vibrational corrections are included with both \(U_f\) and \(S_f\). These are calculated based on the change in vibrational modes between the defect, pristine and reference materials.

Parameters:

  • charge_state (int) – The charge of the defect.

  • element_in_pristine (None | All | PeriodicTableElement) – The element whose chemical potential value is taken from the pristine material. Can be None (elemental reference), All (thermodynamic reference), or an element in the pristine material (element poor reference).

  • electronic_chemical_potential (PhysicalQuantity of type energy) – The electronic chemical potential relative to electronic_chemical_potential_reference.
    Default: 0.0 * eV

  • electronic_chemical_potential_reference (ValenceBandEdge | ConductionBandEdge) – The reference level for the electronic chemical potential.
    Default: ValenceBandEdge

  • defect_type (DeepLevelDefect | ShallowAcceptor | ShallowDonor) – The assumption of the type of defect to use for aligning the transition levels in the band gap calculated with band_gap_calculator; see Notes below for details. Note that this parameter only has an effect if band_gap_calculator is different from formation_energy_calculator.
    Default: DeepLevelDefect

  • enable_finite_size_corrections (bool) – Whether to include finite size corrections for the supercell in the calculation of the formation energy.
    Default: True

  • temperature (bool) – The temperature used for calculating vibrational energy
    Default: 300K

  • include_vibrations (bool) – Whether vibrational terms are included, if available.
    Default: True

Returns:

The calculated formation energy.

Return type:

PhysicalQuantity of type energy

formationInternalEnergy(charge_state, element_in_pristine=None, electronic_chemical_potential=None, electronic_chemical_potential_reference=None, defect_type=None, enable_finite_size_corrections=None, temperature=None, include_vibrations=None)

The internal formation energy for a given charge state \(q\) of the defect, defined as

\(U_f^q = U^{\mathrm{def}, q} - U^{\mathrm{bulk}, q} - \sum_i \Delta n_i \ \mu_i + q \left ( \mu_e^\mathrm{ref} + \Delta \mu_e \right )\).

The first two terms are the total internal energy of the supercell with and without the defect, respectively. \(\Delta n_i\) is the difference in the number of atoms between the two supercells for species \(i\), and \(\mu_i\) is the atomic chemical potential for that species. \(\mu_e^\mathrm{ref}\) is the absolute position of the reference level for the electronic chemical potential (either the valence band maximum or the conduction band minimum), and \(\Delta \mu_e\) is the electronic chemical potential relative to it.

Parameters:

  • charge_state (int) – The charge state of the defect.

  • element_in_pristine (None | All | PeriodicTableElement) – The element whose chemical potential value is taken from the pristine material. Can be None (elemental reference), All (thermodynamic reference), or an element in the pristine material (element poor reference).

  • electronic_chemical_potential (PhysicalQuantity of type energy) – The electronic chemical potential relative to electronic_chemical_potential_reference.
    Default: 0.0 * eV

  • electronic_chemical_potential_reference (ValenceBandEdge | ConductionBandEdge) – The reference level for the electronic chemical potential.
    Default: ValenceBandEdge

  • defect_type (DeepLevelDefect | ShallowAcceptor | ShallowDonor) – The assumption of the type of defect to use for aligning the transition levels in the band gap calculated with band_gap_calculator. Note that this parameter only has an effect if band_gap_calculator is different from formation_energy_calculator.
    Default: DeepLevelDefect

  • enable_finite_size_corrections (bool) – Whether to include finite size corrections for the supercell in the calculation of the formation energy.
    Default: True

  • temperature (bool) – The temperature used for calculating vibrational energy
    Default: 300K

  • include_vibrations (bool) – Whether vibrational terms are included, if available.
    Default: True

Returns:

The calculated formation energy.

Return type:

PhysicalQuantity of type energy

geometryConverged(charge_state)

Return whether a specific geometry optimization converged.

Parameters:

charge_state (int) – The charge of the defect.

Returns:

Whether the geometry optimization converged for this defect.

Return type:

bool

intrinsicConcentration(element_in_pristine=None, electronic_chemical_potential=None, electronic_chemical_potential_reference=None, temperature=PhysicalQuantity(300.0, K), equivalent_defects=None, internal_degrees_of_freedom=1)

The sum of concentrations of all available charge states.

Parameters:

  • element_in_pristine (None | All | PeriodicTableElement) – The element whose chemical potential value is taken from the pristine material. Can be None (elemental reference), All (thermodynamic reference), or an element in the pristine material (element poor reference).

  • electronic_chemical_potential (PhysicalQuantity of type energy) – The electronic chemical potential relative to electronic_chemical_potential_reference.
    Default: 0.0 * eV

  • electronic_chemical_potential_reference (ValenceBandEdge | ConductionBandEdge) – The reference level for the electronic chemical potential.
    Default: ValenceBandEdge

  • temperature (PhysicalQuantity of type temperature) – The temperature at which the concentration should be calculated.

  • equivalent_defects (int) – The number of equivalent sites for this defect in the primitive host cell.
    Default: Automatically determined using symmetry.

  • internal_degrees_of_freedom (int) – The internal degrees of freedom of the defect. E.g. spin states or equivalent orientations (self-interstitials).

isConverged(charge_state)

Return whether a specific SCF loop and geometry optimization are converged.

Parameters:

charge_state (int) – The charge of the defect.

Returns:

Whether the SCF loop converged for this defect.

Return type:

bool

namedPointDefect()
Returns:

The named point defect used to generate the defected configuration.

Return type:

NamedPointDefect

nlinfo()
Returns:

Information summarizing the defect calculation.

Return type:

dict

nlprint(stream)

Print a string containing an ASCII table summarizing the available results for the defect.

Parameters:

stream (file-like) – The stream to write to. This should be an object that supports strings being written to it using a write method.

numberOfSymmetricDefects(charge_state=None, symmetry_type=<class 'NL.ComputerScienceUtilities.NLFlag._NLFlag.DefectSuperCell'>)

Return the number of distinct but symmetrically equivalent defect configurations.

Parameters:

  • charge_state (int) – The charge state of the defect.

  • symmetry_type (DefectSuperCell | DefectUnitCell.) – Whether the nunber of defects is according to the unit cell or supercell symmetry.
    Default: DefectSuperCell

Returns:

The total number of symmetrically equivalent defects.

Return type:

int

numberOfSymmetryOperations(charge_state=None, symmetry_group_index=0, symmetry_type=<class 'NL.ComputerScienceUtilities.NLFlag._NLFlag.DefectSuperCell'>)

Return the number of symmetry operations that produce identical defects.

Parameters:

  • charge_state (int) – The charge state of the defect.

  • symmetry_group_index (int) – The index of the unique defect.

  • symmetry_type (DefectSuperCell | DefectUnitCell) – Whether the number of defects is according to the unit cell or supercell symmetry.
    Default: DefectSuperCell.

Returns:

The total number of symmetry operations that produce the same defect.

Return type:

int

phononDensityOfStates(charge_state=None)

Phonon density of states of the defect.

Parameters:

charge_state (int) – The charge of the defect.

Returns:

The phonon DOS if vibrational corrections are enabled. None if not.

Return type:

PhononDensityOfStates | None

pointDefect()
Returns:

The point defect used to generate the defected configuration.

Return type:

BasePointDefect

possibleTransition(other)

Check to see if there is a possible transition path between the current and another defect.

Parameters:

other (ChargedPointDefectConfiguration) – The other defect to test.

Returns:

Whether a transition is possible.

Return type:

bool

preRelaxationCalculator()
Returns:

The calculator used to relax the atomic coordinates in the pre-optimization step.

Return type:

Calculator

preRelaxationParameters()
Returns:

The parameters of the optimization used to pre-relax the defect configuration.

Return type:

OptimizeGeometryParameters

pristineConfiguration()
Returns:

The reference pristine configuration from which the defect is formed.

Return type:

PristineConfiguration

randomSeed()
Returns:

Random seed used for generating random numbers.

Return type:

int

rattleAtomicCoordinates()
Returns:

Whether the atomic coordinates are rattled before optimization to break symmetry.

Return type:

bool

relaxAtomicCoordinates()
Returns:

Whether the atomic coordinates are relaxed using the formation energy calculator.

Return type:

bool

relaxationParameters()
Returns:

The parameters of the optimization used to relax the atomic coordinates.

Return type:

OptimizeGeometryParameters

sameFormationEnergyCalculators(other)

Check that the same formation energy calculator was used in two different defects.

Parameters:

other (ChargedPointDefectConfiguration) – The other defect to test for possible transitions to.

Returns:

Whether the formation energy calculators are the same.

Return type:

bool

scfConverged(charge_state)

Return whether a specific SCF loop converged.

Parameters:

charge_state (int) – The charge of the defect.

Returns:

Whether the SCF loop converged for this defect.

Return type:

bool

stableChargeState(electronic_chemical_potential, electronic_chemical_potential_reference=None, defect_type=None, enable_finite_size_corrections=None, temperature=None, include_vibrations=None)

The stable charge state at a given electronic chemical potential.

Parameters:

  • electronic_chemical_potential (PhysicalQuantity of type energy) – The electronic chemical potential relative to electronic_chemical_potential_reference.

  • electronic_chemical_potential_reference (ValenceBandEdge | ConductionBandEdge) – The reference level for the electronic chemical potential.
    Default: ValenceBandEdge

  • defect_type (DeepLevelDefect | ShallowAcceptor | ShallowDonor) – The assumption of the type of defect to use for aligning the transition levels in the band gap calculated with band_gap_calculator; see Notes below for details. Note that this parameter only has an effect if band_gap_calculator is different from formation_energy_calculator.
    Default: DeepLevelDefect

  • enable_finite_size_corrections (bool) – Whether to include finite size corrections for the supercell in the calculation of the formation energy.
    Default: True

  • temperature (bool) – The temperature used for calculating vibrational energy
    Default: 300K

  • include_vibrations (bool) – Whether vibrational terms are included, if available.
    Default: True

Returns:

The calculated stable charge state.

Return type:

int

stableTransitions(electronic_chemical_potential_reference=None, defect_type=None, enable_finite_size_corrections=None, temperature=None, include_vibrations=None)

The list of transitions between stable charge states across the whole range of the electronic chemical potential. The transition levels are given relative to electronic_chemical_potential_reference.

Parameters:

  • electronic_chemical_potential_reference (ValenceBandEdge | ConductionBandEdge) – The reference level for the electronic chemical potential.
    Default: ValenceBandEdge

  • defect_type (DeepLevelDefect | ShallowAcceptor | ShallowDonor) – The assumption of the type of defect to use for aligning the transition levels in the band gap calculated with band_gap_calculator; see Notes below for details. Note that this parameter only has an effect if band_gap_calculator is different from formation_energy_calculator.
    Default: DeepLevelDefect

  • supercell_repetitions (sequence (size 3) of int | ExtrapolationScheme) – The number of repetitions of the bulk unit cell along the (a, b, c) directions. If ExtrapolationScheme, the extrapolation to the infinite supercell size limit is used.
    Default: The largest calculated supercell.

  • enable_finite_size_corrections (bool) – Whether to include finite size corrections for the supercell in the calculation of the formation energy.
    Default: True

  • temperature (bool) – The temperature used for calculating vibrational energy
    Default: 300K

  • include_vibrations (bool) – Whether vibrational terms are included, if available.
    Default: True

Returns:

The list of transitions between stable charge states in order as the electronic chemical potential is increased, and the values of the corresponding transition levels.

Return type:

tuple of (list of list (size 2) of int, list of float)

symmetricDefect(charge_state=None, symmetry_group_index=0, symmetry_operation_index=0, unit_cell_translation=None, symmetry_type=<class 'NL.ComputerScienceUtilities.NLFlag._NLFlag.DefectSuperCell'>)

Generate a symmetrically equivalent defect configuration using the symmetry operations of the pristine material.

Parameters:

  • charge_state (int) – The charge state of the defect.
    Default: 0

  • symmetry_group_index (int) – The index of the group of symmetry operations that give the same configuration.

  • symmetry_operation_index (int) – The index of the operation within the group to apply.

  • unit_cell_translation (Sequence of int of size 3) – An additional translation to apply in terms of the unit cell vectors. This can be used move the defect within the supercell.

  • symmetry_type (DefectUnitCell | DefectSuperCell) – Whether the supercell or unit cell symmetry is used to transform the defect position.
    Default: DefectSuperCell.

Returns:

The symmetrically equivalent defect.

Return type:

BulkConfiguration

symmetricDefectPosition(charge_state=0, symmetry_group_index=0, symmetry_operation_index=0, unit_cell_translation=None, coordinate_type=<class 'NL.ComputerScienceUtilities.NLFlag._NLFlag.Fractional'>, symmetry_type=<class 'NL.ComputerScienceUtilities.NLFlag._NLFlag.DefectSuperCell'>)

Get the symmetrically equivalent defect position using the symmetry operations of the pristine cell.

Parameters:

  • charge_state (int) – The charge state of the defect.
    Default: 0

  • symmetry_group_index (int) – The index of the group of symmetry operations that give the same configuration.

  • symmetry_operation_index (int) – The index of the operation within the group to apply.

  • unit_cell_translation (Sequence of int of size 3) – An additional translation to apply in terms of the unit cell vectors. This can be used move the defect within the supercell.

  • coordinate_type (Fractional | Cartesian) – Whether the defect coordinates are given in Cartesian or fractional coordinates. Fractional coordinates are given in reference to the supercell translation vectors.

  • symmetry_type (DefectUnitCell | DefectSuperCell) – Whether the supercell or unit cell symmetry is used to transform the defect position.
    Default: DefectSuperCell.

Returns:

The symmetrically equivalent defect position.

Return type:

PhysicalQuantity of type length | numpy.ndarray

totalEnergy(charge_state=None)

The defect total energy associated with a given charge state.

Parameters:

charge_state (int) – The charge of the defect.

Returns:

The total energy analysis of the defect.

Return type:

TotalEnergy

transitionLevel(charge_states, electronic_chemical_potential_reference=None, defect_type=None, enable_finite_size_corrections=None, temperature=None, include_vibrations=None)

The transition level between two calculated charge states \(m\) and \(n\), defined as

\(E \left ( m/n \right ) = \frac{E_f^n \left ( \Delta \mu_e = 0 \right ) - E_f^m \left ( \Delta \mu_e = 0 \right )}{m - n}\).

The transition level is given relative to electronic_chemical_potential_reference.

Parameters:

  • charge_states (sequence (size 2) of int) – The two charge states to calculate the transition level for.

  • electronic_chemical_potential_reference (ValenceBandEdge | ConductionBandEdge) – The reference level for the electronic chemical potential.
    Default: ValenceBandEdge

  • defect_type (DeepLevelDefect | ShallowAcceptor | ShallowDonor) – The assumption of the type of defect to use for aligning the transition levels in the band gap calculated with band_gap_calculator; see Notes below for details. Note that this parameter only has an effect if band_gap_calculator is different from formation_energy_calculator.
    Default: DeepLevelDefect

  • enable_finite_size_corrections (bool) – Whether to include finite size corrections for the supercell in the calculation of the formation energy.
    Default: True

  • temperature (bool) – The temperature used for calculating vibrational energy
    Default: 300K

  • include_vibrations (bool) – Whether vibrational terms are included, if available.
    Default: True

Returns:

The calculated transition level.

Return type:

PhysicalQuantity of type energy

uniqueString()

Return a unique string representing the state of the object.

update()

Perform the calculation.

useGhostAtoms()
Returns:

Whether ghost atoms replace lattice atoms in vacancy defects.

Return type:

bool

vibrations(charge_state=None)

Vibrational frequencies of the defect.

Parameters:

charge_state (int) – The charge of the defect.

Returns:

The vibrations if vibrational corrections are enabled. None if not.

Return type:

PhysicalQuantity of type inverse time | None

Usage Examples

In this example the vacancy and anti-site defects in silicon carbide are calculated using the ChargedPointDefectConfiguration object. Note that the DFT calculations can take several hours.

A workflow for the calculation can be downloaded here with a corresponding python script SiC_Defects_Example.py.

Notes

The ChargedPointDefectConfiguration object calculates the properties of a defect at one or more charge states. The defect configuration can be optimized for each charge state.

The ChargedPointDefectConfiguration is created by supplying a PristineConfiguration, a NamedPointDefect that defines the defect and a BaseChemicalPotential for each element in the defect. Additional arguments set the optimization procedure for the defects and also whether or not ghost atoms are used in vacancy defects. The calculation of the defects is started by calling the update method.

Once the calculation is completed the ChargedPointDefectConfiguration object can be analyzed in the Charged Point Defect Analyzer. Derived properties of the defects such as +formation energy, defect concentration and trap levels can be queried individually using the +corresponding methods.