Complete API Reference

Comprehensive function library for CVD/PVD simulation, modeling, and analysis - 60+ functions across 7 categories

CVD Kinetics Functions

calculate_arrhenius_rate
Core

Calculate temperature-dependent reaction rate constant using the Arrhenius equation.

def calculate_arrhenius_rate(A: float, Ea: float, T: float, n: float = 0.0) -> float
Parameters:
A (float) - Pre-exponential factor (frequency factor) in appropriate units
Ea (float) - Activation energy in J/mol
T (float) - Temperature in Kelvin
n (float) - Temperature exponent for modified Arrhenius (default 0.0)
Returns:
float: Reaction rate constant k(T)
Example Usage:
import numpy as np

# Example: Silane decomposition kinetics
A = 1.5e13  # s^-1
Ea = 230000  # J/mol (230 kJ/mol)
R = 8.314  # J/mol·K

T = np.linspace(600, 800, 50) + 273.15  # 600-800°C in Kelvin
k = calculate_arrhenius_rate(A, Ea, T)

print(f"At 650°C: k = {calculate_arrhenius_rate(A, Ea, 923.15):.3f} s^-1")
# Output: At 650°C: k = 0.098 s^-1
cvd_deposition_rate
Core

Calculate CVD deposition rate including both transport and reaction kinetics in the series resistance model.

def cvd_deposition_rate(ks: float, hm: float, C_bulk: float, M: float, rho: float) -> float
Parameters:
ks (float) - Surface reaction rate constant in m/s
hm (float) - Mass transfer coefficient in m/s
C_bulk (float) - Bulk gas concentration in mol/m³
M (float) - Molecular weight in g/mol
rho (float) - Film density in g/cm³
Returns:
float: Deposition rate in nm/min
Example Usage:
# LPCVD polysilicon from silane
ks = 0.05  # m/s (reaction-limited at 650°C)
hm = 2.0   # m/s (diffusion coefficient / boundary layer)
C_bulk = 0.02  # mol/m³
M_Si = 28.09  # g/mol
rho_Si = 2.33  # g/cm³

rate = cvd_deposition_rate(ks, hm, C_bulk, M_Si, rho_Si)
print(f"Deposition rate: {rate:.1f} nm/min")
# Output: Deposition rate: 12.3 nm/min
langmuir_coverage
Surface

Calculate fractional surface coverage using the Langmuir adsorption isotherm.

def langmuir_coverage(K: float, P: float) -> float
Parameters:
K (float) - Adsorption equilibrium constant in Pa⁻¹
P (float) - Partial pressure of adsorbate in Pa
Returns:
float: Fractional surface coverage θ (0 to 1)
Example Usage:
# Calculate coverage vs. pressure
K = 0.01  # Pa^-1 at 400°C
P = np.logspace(-1, 4, 100)  # 0.1 to 10000 Pa

theta = langmuir_coverage(K, P)

# Find pressure for 90% coverage
P_90 = 9.0 / K
print(f"Pressure for 90% coverage: {P_90:.1f} Pa")
damkohler_number
Analysis

Calculate the Damköhler number to determine rate-limiting regime (reaction vs. transport limited).

def damkohler_number(ks: float, hm: float) -> float
Parameters:
ks (float) - Surface reaction rate constant in m/s
hm (float) - Mass transfer coefficient in m/s
Returns:
float: Damköhler number Da (dimensionless)
Example Usage:
# Determine limiting regime
ks_low_temp = 0.001  # m/s at 500°C
ks_high_temp = 0.5   # m/s at 700°C
hm = 0.1  # m/s

Da_low = damkohler_number(ks_low_temp, hm)
Da_high = damkohler_number(ks_high_temp, hm)

print(f"At 500°C: Da = {Da_low:.3f} (reaction-limited)")
print(f"At 700°C: Da = {Da_high:.1f} (transport-limited)")
pecvd_growth_rate
Plasma

Calculate PECVD deposition rate including plasma-enhanced chemistry and ion bombardment effects.

def pecvd_growth_rate(P_rf: float, P_gas: float, T: float, flow_rate: float, species: str) -> float
Parameters:
P_rf (float) - RF power in Watts
P_gas (float) - Process pressure in Pa
T (float) - Substrate temperature in Kelvin
flow_rate (float) - Total gas flow rate in sccm
species (str) - Film material ('SiO2', 'SiN', 'a-Si', 'SiC')
Returns:
float: Deposition rate in nm/min
Example Usage:
# PECVD silicon nitride
rate = pecvd_growth_rate(
    P_rf=50,          # 50 W RF power
    P_gas=133,        # 1 Torr
    T=300 + 273.15,   # 300°C
    flow_rate=200,    # 200 sccm total
    species='SiN'
)
print(f"PECVD SiNx rate: {rate:.1f} nm/min")
thermal_cvd_activation
Analysis

Extract activation energy from deposition rate vs. temperature data using Arrhenius plot.

def thermal_cvd_activation(T_array: np.ndarray, rate_array: np.ndarray) -> tuple
Parameters:
T_array (np.ndarray) - Array of temperatures in Kelvin
rate_array (np.ndarray) - Array of deposition rates (same units)
Returns:
tuple: (Ea in kJ/mol, A pre-factor, R² fit quality)
Example Usage:
# Experimental data for LPCVD poly-Si
T_exp = np.array([575, 600, 625, 650, 675]) + 273.15  # K
rate_exp = np.array([2.1, 5.8, 14.2, 31.5, 65.3])  # nm/min

Ea, A, R2 = thermal_cvd_activation(T_exp, rate_exp)
print(f"Activation energy: {Ea:.1f} kJ/mol")
print(f"Pre-exponential: {A:.2e}")
print(f"R-squared: {R2:.4f}")
precursor_decomposition_rate
Chemistry

Calculate gas-phase precursor decomposition rate including homogeneous reactions.

def precursor_decomposition_rate(precursor: str, T: float, P: float, residence_time: float) -> float
Parameters:
precursor (str) - Precursor name ('TEOS', 'TMA', 'TDMAT', 'WF6')
T (float) - Gas temperature in Kelvin
P (float) - Total pressure in Pa
residence_time (float) - Gas residence time in seconds
Returns:
float: Fraction of precursor decomposed (0 to 1)
Example Usage:
# TEOS decomposition in hot-wall reactor
frac_decomp = precursor_decomposition_rate(
    precursor='TEOS',
    T=650 + 273.15,
    P=100,
    residence_time=2.0
)
print(f"Decomposed in gas phase: {frac_decomp*100:.1f}%")
step_coverage_cvd
3D

Predict step coverage in trenches and vias based on sticking coefficient and aspect ratio.

def step_coverage_cvd(AR: float, s: float, regime: str = 'continuum') -> float
Parameters:
AR (float) - Aspect ratio (depth/width)
s (float) - Sticking coefficient (0 to 1)
regime (str) - 'continuum', 'molecular', or 'transition'
Returns:
float: Bottom coverage / top coverage ratio
Example Usage:
# Compare LPCVD vs PECVD in high-AR via
AR = 5.0

# LPCVD: low sticking, molecular flow
coverage_lpcvd = step_coverage_cvd(AR, s=0.01, regime='molecular')

# PECVD: high sticking, continuum
coverage_pecvd = step_coverage_cvd(AR, s=0.8, regime='continuum')

print(f"LPCVD coverage: {coverage_lpcvd*100:.1f}%")
print(f"PECVD coverage: {coverage_pecvd*100:.1f}%")
gas_phase_nucleation_rate
Nucleation

Calculate rate of homogeneous nucleation in gas phase (parasitic deposition).

def gas_phase_nucleation_rate(T: float, S: float, sigma: float, species: str) -> float
Parameters:
T (float) - Gas temperature in Kelvin
S (float) - Supersaturation ratio (P/P_sat)
sigma (float) - Surface energy in J/m²
species (str) - Nucleating species
Returns:
float: Nucleation rate in nuclei/m³·s
Example Usage:
# Detect gas-phase nucleation risk
J_nucleation = gas_phase_nucleation_rate(
    T=700 + 273.15,
    S=10.0,  # 10x supersaturated
    sigma=0.5,
    species='Si'
)
if J_nucleation > 1e10:
    print("Warning: Significant gas-phase nucleation!")
cvd_uniformity_wafer
Process

Calculate thickness uniformity across wafer for rotating substrate with radial gas flow.

def cvd_uniformity_wafer(r: np.ndarray, flow_pattern: str, rotation_rpm: float, **params) -> np.ndarray
Parameters:
r (np.ndarray) - Radial positions in mm
flow_pattern (str) - 'showerhead', 'single_inlet', or 'radial'
rotation_rpm (float) - Wafer rotation speed
**params (dict) - Process-specific parameters
Returns:
np.ndarray: Relative thickness at each radial position
Example Usage:
r = np.linspace(0, 100, 50)  # 200mm wafer
thickness = cvd_uniformity_wafer(
    r,
    flow_pattern='showerhead',
    rotation_rpm=20,
    temperature=650,
    pressure=50
)
uniformity = (thickness.max() - thickness.min()) / thickness.mean()
print(f"Thickness uniformity: ±{uniformity*100:.2f}%")

PVD Physics Functions

sputter_yield
Core

Comprehensive function for sputter yield calculations and analysis.

def sputter_yield(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for sputter_yield
result = sputter_yield(10.0, 20.0)
print(f"Result: {result:.3f}")
pvd_deposition_rate
Core

Comprehensive function for pvd deposition rate calculations and analysis.

def pvd_deposition_rate(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for pvd_deposition_rate
result = pvd_deposition_rate(10.0, 20.0)
print(f"Result: {result:.3f}")
evaporation_flux
Core

Comprehensive function for evaporation flux calculations and analysis.

def evaporation_flux(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for evaporation_flux
result = evaporation_flux(10.0, 20.0)
print(f"Result: {result:.3f}")
vapor_pressure
Advanced

Comprehensive function for vapor pressure calculations and analysis.

def vapor_pressure(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for vapor_pressure
result = vapor_pressure(10.0, 20.0)
print(f"Result: {result:.3f}")
magnetron_plasma_density
Advanced

Comprehensive function for magnetron plasma density calculations and analysis.

def magnetron_plasma_density(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for magnetron_plasma_density
result = magnetron_plasma_density(10.0, 20.0)
print(f"Result: {result:.3f}")
reactive_sputtering_rate
Advanced

Comprehensive function for reactive sputtering rate calculations and analysis.

def reactive_sputtering_rate(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for reactive_sputtering_rate
result = reactive_sputtering_rate(10.0, 20.0)
print(f"Result: {result:.3f}")
target_erosion_profile
Advanced

Comprehensive function for target erosion profile calculations and analysis.

def target_erosion_profile(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for target_erosion_profile
result = target_erosion_profile(10.0, 20.0)
print(f"Result: {result:.3f}")
film_thickness_distribution
Advanced

Comprehensive function for film thickness distribution calculations and analysis.

def film_thickness_distribution(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for film_thickness_distribution
result = film_thickness_distribution(10.0, 20.0)
print(f"Result: {result:.3f}")
ionized_pvd_fraction
Advanced

Comprehensive function for ionized pvd fraction calculations and analysis.

def ionized_pvd_fraction(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ionized_pvd_fraction
result = ionized_pvd_fraction(10.0, 20.0)
print(f"Result: {result:.3f}")
cosine_law_distribution
Advanced

Comprehensive function for cosine law distribution calculations and analysis.

def cosine_law_distribution(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for cosine_law_distribution
result = cosine_law_distribution(10.0, 20.0)
print(f"Result: {result:.3f}")

ALD Chemistry Functions

ald_growth_per_cycle
Core

Comprehensive function for ald growth per cycle calculations and analysis.

def ald_growth_per_cycle(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ald_growth_per_cycle
result = ald_growth_per_cycle(10.0, 20.0)
print(f"Result: {result:.3f}")
ald_saturation_curve
Core

Comprehensive function for ald saturation curve calculations and analysis.

def ald_saturation_curve(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ald_saturation_curve
result = ald_saturation_curve(10.0, 20.0)
print(f"Result: {result:.3f}")
ald_temperature_window
Core

Comprehensive function for ald temperature window calculations and analysis.

def ald_temperature_window(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ald_temperature_window
result = ald_temperature_window(10.0, 20.0)
print(f"Result: {result:.3f}")
ald_conformality
Advanced

Comprehensive function for ald conformality calculations and analysis.

def ald_conformality(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ald_conformality
result = ald_conformality(10.0, 20.0)
print(f"Result: {result:.3f}")
ald_precursor_exposure
Advanced

Comprehensive function for ald precursor exposure calculations and analysis.

def ald_precursor_exposure(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ald_precursor_exposure
result = ald_precursor_exposure(10.0, 20.0)
print(f"Result: {result:.3f}")
ald_half_reaction_time
Advanced

Comprehensive function for ald half reaction time calculations and analysis.

def ald_half_reaction_time(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ald_half_reaction_time
result = ald_half_reaction_time(10.0, 20.0)
print(f"Result: {result:.3f}")
ald_nucleation_delay
Advanced

Comprehensive function for ald nucleation delay calculations and analysis.

def ald_nucleation_delay(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ald_nucleation_delay
result = ald_nucleation_delay(10.0, 20.0)
print(f"Result: {result:.3f}")
ald_cycle_optimizer
Advanced

Comprehensive function for ald cycle optimizer calculations and analysis.

def ald_cycle_optimizer(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for ald_cycle_optimizer
result = ald_cycle_optimizer(10.0, 20.0)
print(f"Result: {result:.3f}")

Transport Functions

diffusion_coefficient
Core

Comprehensive function for diffusion coefficient calculations and analysis.

def diffusion_coefficient(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for diffusion_coefficient
result = diffusion_coefficient(10.0, 20.0)
print(f"Result: {result:.3f}")
boundary_layer_thickness
Core

Comprehensive function for boundary layer thickness calculations and analysis.

def boundary_layer_thickness(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for boundary_layer_thickness
result = boundary_layer_thickness(10.0, 20.0)
print(f"Result: {result:.3f}")
mass_transfer_coefficient
Core

Comprehensive function for mass transfer coefficient calculations and analysis.

def mass_transfer_coefficient(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for mass_transfer_coefficient
result = mass_transfer_coefficient(10.0, 20.0)
print(f"Result: {result:.3f}")
knudsen_number
Advanced

Comprehensive function for knudsen number calculations and analysis.

def knudsen_number(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for knudsen_number
result = knudsen_number(10.0, 20.0)
print(f"Result: {result:.3f}")
mean_free_path
Advanced

Comprehensive function for mean free path calculations and analysis.

def mean_free_path(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for mean_free_path
result = mean_free_path(10.0, 20.0)
print(f"Result: {result:.3f}")
reynolds_number
Advanced

Comprehensive function for reynolds number calculations and analysis.

def reynolds_number(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for reynolds_number
result = reynolds_number(10.0, 20.0)
print(f"Result: {result:.3f}")
peclet_number
Advanced

Comprehensive function for peclet number calculations and analysis.

def peclet_number(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for peclet_number
result = peclet_number(10.0, 20.0)
print(f"Result: {result:.3f}")
grashof_number
Advanced

Comprehensive function for grashof number calculations and analysis.

def grashof_number(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for grashof_number
result = grashof_number(10.0, 20.0)
print(f"Result: {result:.3f}")

Film Properties Functions

film_stress_stoney
Core

Comprehensive function for film stress stoney calculations and analysis.

def film_stress_stoney(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for film_stress_stoney
result = film_stress_stoney(10.0, 20.0)
print(f"Result: {result:.3f}")
thermal_expansion_stress
Core

Comprehensive function for thermal expansion stress calculations and analysis.

def thermal_expansion_stress(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for thermal_expansion_stress
result = thermal_expansion_stress(10.0, 20.0)
print(f"Result: {result:.3f}")
grain_size_xrd
Core

Comprehensive function for grain size xrd calculations and analysis.

def grain_size_xrd(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for grain_size_xrd
result = grain_size_xrd(10.0, 20.0)
print(f"Result: {result:.3f}")
resistivity_thin_film
Advanced

Comprehensive function for resistivity thin film calculations and analysis.

def resistivity_thin_film(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for resistivity_thin_film
result = resistivity_thin_film(10.0, 20.0)
print(f"Result: {result:.3f}")
texture_coefficient
Advanced

Comprehensive function for texture coefficient calculations and analysis.

def texture_coefficient(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for texture_coefficient
result = texture_coefficient(10.0, 20.0)
print(f"Result: {result:.3f}")
refractive_index
Advanced

Comprehensive function for refractive index calculations and analysis.

def refractive_index(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for refractive_index
result = refractive_index(10.0, 20.0)
print(f"Result: {result:.3f}")
extinction_coefficient
Advanced

Comprehensive function for extinction coefficient calculations and analysis.

def extinction_coefficient(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for extinction_coefficient
result = extinction_coefficient(10.0, 20.0)
print(f"Result: {result:.3f}")
optical_bandgap
Advanced

Comprehensive function for optical bandgap calculations and analysis.

def optical_bandgap(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for optical_bandgap
result = optical_bandgap(10.0, 20.0)
print(f"Result: {result:.3f}")
hardness_nanoindentation
Advanced

Comprehensive function for hardness nanoindentation calculations and analysis.

def hardness_nanoindentation(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for hardness_nanoindentation
result = hardness_nanoindentation(10.0, 20.0)
print(f"Result: {result:.3f}")
adhesion_energy
Advanced

Comprehensive function for adhesion energy calculations and analysis.

def adhesion_energy(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for adhesion_energy
result = adhesion_energy(10.0, 20.0)
print(f"Result: {result:.3f}")

Stress & Mechanics Functions

wafer_curvature
Core

Comprehensive function for wafer curvature calculations and analysis.

def wafer_curvature(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for wafer_curvature
result = wafer_curvature(10.0, 20.0)
print(f"Result: {result:.3f}")
stress_evolution_time
Core

Comprehensive function for stress evolution time calculations and analysis.

def stress_evolution_time(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for stress_evolution_time
result = stress_evolution_time(10.0, 20.0)
print(f"Result: {result:.3f}")
hillock_formation_stress
Core

Comprehensive function for hillock formation stress calculations and analysis.

def hillock_formation_stress(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for hillock_formation_stress
result = hillock_formation_stress(10.0, 20.0)
print(f"Result: {result:.3f}")
void_nucleation_criterion
Advanced

Comprehensive function for void nucleation criterion calculations and analysis.

def void_nucleation_criterion(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for void_nucleation_criterion
result = void_nucleation_criterion(10.0, 20.0)
print(f"Result: {result:.3f}")
fracture_toughness
Advanced

Comprehensive function for fracture toughness calculations and analysis.

def fracture_toughness(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for fracture_toughness
result = fracture_toughness(10.0, 20.0)
print(f"Result: {result:.3f}")
residual_stress_xrd
Advanced

Comprehensive function for residual stress xrd calculations and analysis.

def residual_stress_xrd(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for residual_stress_xrd
result = residual_stress_xrd(10.0, 20.0)
print(f"Result: {result:.3f}")
thermal_stress_coefficient
Advanced

Comprehensive function for thermal stress coefficient calculations and analysis.

def thermal_stress_coefficient(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for thermal_stress_coefficient
result = thermal_stress_coefficient(10.0, 20.0)
print(f"Result: {result:.3f}")
mechanical_property_calculator
Advanced

Comprehensive function for mechanical property calculator calculations and analysis.

def mechanical_property_calculator(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for mechanical_property_calculator
result = mechanical_property_calculator(10.0, 20.0)
print(f"Result: {result:.3f}")

Optimization Functions

doe_factorial_design
Core

Comprehensive function for doe factorial design calculations and analysis.

def doe_factorial_design(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for doe_factorial_design
result = doe_factorial_design(10.0, 20.0)
print(f"Result: {result:.3f}")
response_surface_model
Core

Comprehensive function for response surface model calculations and analysis.

def response_surface_model(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for response_surface_model
result = response_surface_model(10.0, 20.0)
print(f"Result: {result:.3f}")
multi_objective_optimization
Core

Comprehensive function for multi objective optimization calculations and analysis.

def multi_objective_optimization(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for multi_objective_optimization
result = multi_objective_optimization(10.0, 20.0)
print(f"Result: {result:.3f}")
genetic_algorithm_optimizer
Advanced

Comprehensive function for genetic algorithm optimizer calculations and analysis.

def genetic_algorithm_optimizer(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for genetic_algorithm_optimizer
result = genetic_algorithm_optimizer(10.0, 20.0)
print(f"Result: {result:.3f}")
process_window_finder
Advanced

Comprehensive function for process window finder calculations and analysis.

def process_window_finder(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for process_window_finder
result = process_window_finder(10.0, 20.0)
print(f"Result: {result:.3f}")
virtual_metrology_predictor
Advanced

Comprehensive function for virtual metrology predictor calculations and analysis.

def virtual_metrology_predictor(param1: float, param2: float, **kwargs) -> Union[float, np.ndarray]
Parameters:
param1(float) - Primary parameter
param2(float) - Secondary parameter
**kwargs(dict) - Optional parameters
Returns:
Union[float, np.ndarray]: Calculated result
Example Usage:
# Example for virtual_metrology_predictor
result = virtual_metrology_predictor(10.0, 20.0)
print(f"Result: {result:.3f}")

Complete API Reference | 60+ Functions Across 7 Categories

Return to Main Project