The Material System

• The Material System

The parameters database contains the basic properties of many semiconductor materials, including silicon, germanium and many III-V semiconductor binary and ternary alloys. Among other parameters, it includes the energy bandgap, the electron and hole effective masses, the lattice constants and the elastic constants.

The main sources of data are the article by I. Vurgaftman on Band parameters for III-V semiconductors ([1]) and the Handbook Series on Semiconductor Parameters by Levinshtein et al.([2]). The carrier mobility calculator is based on the empirical low-field mobility model by Sotoodeh et al. ([3]) and it is available only for some materials where the inputs for the model are available.

There are two methods for retrieving parameters from the database. The first one consists simply of getting the data using the get_parameter function with the required inputs. For example:

get_parameter("GaAsP", "band_gap", P=0.45, T=300)

will return the bandgap of GaAsP for a phosphorus concentration of 45% at a temperature of 300 K, equal to 1.988 eV. This method only uses the existing data. Another method is to create a material object which will contain all the properties existing in the database for that material, as well as those included as input, which will override the value of the database parameter, if it exists. The following example creates a GaAs object and an AlGaAs object, using a custom electron effective mass in the latter:

GaAs = material("GaAs")(T=300, Na=1e24)
AlGaAs = material("AlGaAs")(T=300, Al=0.3, Nd=1e23, eff_mass_electron=0.1)

Now, any parameter - including the custom ones - are attributes that can be easily accessed and used anywhere in the program. For example GaAs.band_gap is the GaAs bandgap and AlGaAs.lattice_constant is the AlGaAs lattice constant, both at the composition and temperature chosen when creating the objects.

The image below shows the well-known bandgap vs. lattice constant map of all semiconductor materials and alloys (only ternary compounds) currently implemented into Solcore. However, any other material can be used in all of the Solcore functions, as long as the necessary input parameters are provided. This can be done by overriding all the properties of an existing material during the creation as above, or adding it as an external material in the configuration files.

The material class

class solcore.material_system.material_system.MaterialSystem(sources=None)

The core class that manage the materials in solcore.

read(source, value)

Reads a new source.

material(name, sopra=False, nk_db=False)

This function checks if the requested material exists and creates a class that contains its properties, assuming that the material does not exists in the database, yet.

Such class will serve as the base class for all the derived materials based on that SpecificMaterial. For example, N-type GaAs and P-type GaAs use the same SpecificMaterial, just with a different doping, and the happens with GaAs at 300K or 200K.

The derived materials based on a SpecificMaterial are instances of the SpecificMaterial class.

>>> GaAs = solcore.material('GaAs')      # The SpecificMaterial class
>>> n_GaAs = GaAs(Nd=1e23)               # Instance of the class
>>> p_GaAs = GaAs(Na=1e22)               # Another instance of GaAs with different doping

>>> AlGaAs = solcore.material('AlGaAs')  # The SpecificMaterial class
>>> AlGaAs_1 = AlGaAs(Al=0.3)            # Instance of the class. For compounds, the variable element MUST be present
>>> AlGaAs_2 = AlGaAs(Al=0.7, T=290)     # Different composition and T (the default is T=300K)

The material is created from the parameters in the parameter_system and the n and k data if available. If the n and k data does not exists - at all or for that composition - then n=1 and k=0 at all wavelengths. Keep in mind that the available n and k data is valid only at room temperature.

Parameters:

• name – Name of the material
• sopra – If a SOPRA material must be used, rather than the normal database material, in case both exist.

Returns:

A class of that material

parameterised_material(name)

The function that actually creates the material class.

sopra_material(name)

Creates an optical material fromt he SOPRA database.

nk_material(name)

Creates an optical material from the refractiveindex.info database.

class solcore.material_system.material_system.BaseMaterial(T, **kwargs)

The solcore base material class

material_string = 'Unnamed'

composition = []

material_directory = None

k_path = None

n_path = None

strained = False

main_fraction = 0

load_n_data

load_k_data

n_interpolated(x)

k_interpolated(x)

get(parameter)

alpha(wavelength)

alphaE(energy)

latex_string()

plain_string()

html_string()

Accessing parameters

solcore.parameter_system.parameter_system.safe_cacher(maxsize)

solcore.parameter_system.parameter_system.grouper(iterable, n, fillvalue=None)

solcore.parameter_system.parameter_system.bow(parent_0_value, parent_1_value, bowing_parameter, x)

class solcore.parameter_system.parameter_system.ParameterSystem(sources: Optional[Callable] = None)

Parameter database/bowing system for compound materials.

Once instantiated, this plugin loads the materials parameterisations Parameters for compound materials can be retrieved with the get_parameter function.

get_parameter(material, parameter, verbose=False, **others)

Calculate/look up parameters for materials, returns in SI units

Usage: .get_parameter(material_name, parameter_name, **kwargs) - material_name is a string of element symbols/fractions, e.g.: In0.2GaAsP0.1 - parameter_name is a string of - **kwargs captures parameters that may be necessary for some calculations, eg. Temperature

material fractions may also be specified here, e.g.: .get_parameter(“InGaAs”, “band_gap”, In=0.2)

If a compound material is bowed between two parent materials, the parent materials’ parameters are calculated recursively with this function. The final parameter is calculated as:

result=parent_0_value * (1-x) + parent_1_value*x - bowing_parameter * (1-x) * x

The function is cached, so that multiple calls with the same parameters do not incur additional overhead.

The mobility module

This module allows to calculate the carrier mobilities based on the material composition, temperature (T>100K) and impurity concentration. It is an implementation of the mobility model by Sotoodeh et al. ([3]). The material class described above uses this module internally to get the mobililty of the materials it is implemented for.

The material parameters used in the model are included in the file mobility_parameters.json. At the moment, the supported materials are:

• Binaries: AlAs, GaAs, InAs, InP, GaP
• Ternaries: InAlAs, AlGaAs, InGaAs, GaInP, (GaAsP), (InAsP)
• Quaternaries: InGaAsP

The last two ternaries are simply calculated as a linear interpolation of the parameters of the corresponding binaries, so the transition from direct to indirect bandgap and other dependencies might not be very accurate. InGaAsP, in turn, is calculated only based on the InGaAs and GaInP data and it is mostly valid for compositions lattice matched to InP.

solcore.material_data.mobility.Log(x)

solcore.material_data.mobility.mobility_low_field(N, muMin, muMax, Nref, l, t1, t2, T=300)

solcore.material_data.mobility.calculate_mobility(material, holes, N, x=0.0, y=0.0, T=300)

Calculates the mobility using the model by Sotoodeh et al. If the material is not in the database, then the function returns the mobility for GaAs at that temperature, T, and impurity concentration, N.

Parameters:

• material – A string with the material name
• holes – If calculation should be done for electrons (holes=0) or holes (holes=1)
• N – Impurity concentration
• x – The fractional composition in the case of ternaries
• y – The other fractional composition in the case of quaternaries
• T – Temperature

Returns:

The calculated mobility

solcore.material_data.mobility.calculate_InGaAs(x, i)

Calculates the parameters for an InGaAs alloy.

Parameters:

• x – Indium fraction
• i – If the data for electrons (1) or holes (2) should be calculated

Returns:

solcore.material_data.mobility.calculate_InGaP(x, i, T)

Calculates the parameters for an InGaP alloy.

Parameters:

• x – Indium fraction
• i – If the data for electrons (1) or holes (2) should be calculated

Returns:

solcore.material_data.mobility.calculate_AlGaAs(x, i, T)

Calculates the parameters for an AlGaAs alloy.

Parameters:

• x – Al fraction
• i – If the data for electrons (1) or holes (2) should be calculated

Returns:

solcore.material_data.mobility.calculate_InAlAs(x, i, T)

Calculates the parameters for an InAlAs alloy.

Parameters:

• x – Al fraction
• i – If the data for electrons (1) or holes (2) should be calculated

Returns:

solcore.material_data.mobility.calculate_InGaAsP(x, y, i, T)

Calculates the parameters for an InGaAsP alloy. The calculation is based on a interpolation scheme between InGaP and InGaAs using data of compositions lattice matched to InP. Results for compositions away from this might not be very accurate.

Parameters:

• x – Indium fraction
• y – Phosphorus fraction
• i – If the data for electrons (1) or holes (2) should be calculated

Returns:

solcore.material_data.mobility.calculate_General(material, x, i, T)

Calculates the parameters for a general alloy of the materials in the database assuming a simple linear interpolation. Only ternaries are supported this way.

Parameters:

• material – Material to calculate, which must be in the database
• x – Main fraction
• i – If the data for electrons (1) or holes (2) should be calculated

Returns:

solcore.material_data.mobility.Rd(EgG, EgX, EgL, mnG, mnX, mnL, T)

Calculates the fraction of electrons in the direct valley.

Parameters:

• EgG – Gamma-valley bandgap
• EgX – X-valley bandgap
• EgL – L-valley bandgap
• mnG – Gamma-valley effective mass
• mnX – X-valley effective mass
• mnL – L-valley effective mass
• T – The temperature

Returns:

The fraction.

solcore.material_data.mobility.mind(EgX, EgL, mnX, mnL, T)

solcore.material_data.mobility.interpolate_parameter_linear(x, AC, BC, ABC=0)

solcore.material_data.mobility.interpolate_parameter_quad(x, y0, y1, y2, x1, x0=1, x2=0)

solcore.material_data.mobility.interpolate_epsilon(x, AC, BC)

The critical point picker

References

[1]	Vurgaftman, I., Meyer, J.R., Ram-Mohan, L.R.: Band parameters for III–V compound semiconductors and their alloys. J. Appl. Phys. 89(11), 5815–5875 (2001)

[2]	Levinshtein, M., Rumyantsev, S., Shur, M., Levinshtein, M., Rumyantsev, S., Shur, M.: Handbook Series on Semiconductor Parameters, ser. Volume 2: Ternary and Quaternary III-V Com- pounds, vol. 2. World Scientific, Singapore (2012)

[3]	(1, 2) Sotoodeh, A. H. Khalid, and A. A. Rezazadeh, “Empirical low-field mobility model for III–V compounds applicable in device simulation codes,” J. Appl. Phys., 87, 2890, (2000).