The Material System¶
The parameters database contains the basic properties of many semiconductor materials, including silicon, germanium and many IIIV 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 IIIV semiconductors ([1]) and the Handbook Series on Semiconductor Parameters by Levinshtein et al.([2]). The carrier mobility calculator is based on the empirical lowfield 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 wellknown 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)[source]¶ The core class that manage the materials in solcore.

material
(name, sopra=False, nk_db=False)[source]¶ 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, Ntype GaAs and Ptype 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

Accessing parameters¶

solcore.parameter_system.parameter_system.
bow
(parent_0_value, parent_1_value, bowing_parameter, x)[source]¶

class
solcore.parameter_system.parameter_system.
ParameterSystem
(sources: Optional[Callable] = None)[source]¶ 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)[source]¶ 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 * (1x) + parent_1_value*x  bowing_parameter * (1x) * xThe 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.
calculate_mobility
(material, holes, N, x=0.0, y=0.0, T=300)[source]¶ 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)[source]¶ 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)[source]¶ 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)[source]¶ 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)[source]¶ 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)[source]¶ 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)[source]¶ 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)[source]¶ Calculates the fraction of electrons in the direct valley.
Parameters:  EgG – Gammavalley bandgap
 EgX – Xvalley bandgap
 EgL – Lvalley bandgap
 mnG – Gammavalley effective mass
 mnX – Xvalley effective mass
 mnL – Lvalley effective mass
 T – The temperature
Returns: The fraction.
The critical point picker¶
References¶
[1]  Vurgaftman, I., Meyer, J.R., RamMohan, 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 IIIV Com pounds, vol. 2. World Scientific, Singapore (2012) 
[3]  (1, 2)
