solphin 0.0.0__py3-none-any.whl

solphin/__init__.py

@@ -0,0 +1,9 @@
+import solphin.pv_fom
+import solphin.db_fom
+import solphin.final_results
+import solphin.db_plotting
+import solphin.vasp_inputs
+import solphin.spectral
+import solphin.optics
+from .version import __version__
+import solphin.resources

solphin/db_fom.py

@@ -0,0 +1,304 @@
+import scipy.constants as sc
+import numpy as np
+import logging
+from importlib.resources import files
+
+logging.basicConfig(level=logging.INFO)
+
+''' This section details the calculation of the detailed balance limit efficiency and associated values.'''
+
+h = sc.h        # Planck's constant (J·s)
+c = sc.c        # Speed of light (m/s)
+k = sc.k        # Boltzmann constant (J/K)
+q = sc.e        # Elementary charge (Coulombs)
+
+# Convert the spectrum to the useful units - taken from https://github.com/kaklin/sq-limit?tab=readme-ov-file
+
+def load_spectrum(spectrum_type):
+
+    if spectrum_type == "AM1.5":
+        filename = 'ASTMG173.csv'
+
+    elif spectrum_type == "Fluorescent":
+        filename = 'fluorescent.csv'
+
+    elif spectrum_type == "Blue LED":
+        filename = 'led_blue.csv'
+
+    elif spectrum_type == "Green LED":
+        filename = 'led_green.csv'
+
+    elif spectrum_type == "Red LED":
+        filename = 'led_red.csv'
+
+    elif spectrum_type == "White LED":
+        filename = 'led_white.csv'
+
+    elif spectrum_type == "IR LED":
+        filename = 'led_ir.csv'
+
+    elif spectrum_type == "Photopic":
+        filename = 'photopic.csv'
+
+    else:
+        print("Unrecognisable spectrum selected")
+        print("Options: AM1.5, Fluorescent, Blue LED, Green LED, Red LED, White LED, IR LED, Photopic")
+        print("reverting to AM1.5")
+
+        filename = 'ASTMG173.csv'
+
+    csv_path = files("placeholder.resources") / f"{filename}"
+
+    with csv_path.open("r", encoding="utf-8") as f:
+        spectrum = np.loadtxt(f, delimiter=",", skiprows=1)
+
+    return spectrum
+
+def convert_spectrum(spectrum):
+
+    """
+    Converts the input spectrum from standard format to the required units for this code. 
+
+    Parameters:
+        spectrum(numpy.ndarray): Input spectrum loaded from a csv file with numpy.loadtxt.
+
+    Returns:
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+
+    Spectrum input:
+        y: Irradiance (W/m2/nm)
+        x: Wavelength (nm)
+    Converted output:
+        y: Number of photons (Np/m2/s/dE)
+        x: Energy (eV)
+    """
+    converted = np.copy(spectrum)
+    converted[:, 0] = converted[:, 0] * 1e-9  # wavelength to m
+    converted[:, 1] = converted[:, 1] / 1e-9  # irradiance to W/m2/m (from W/m2/nm)
+
+    E = h * c / converted[:, 0]
+    d_lambda_d_E = h * c / E**2
+    converted[:, 1] = converted[:, 1] * d_lambda_d_E * q / E
+    converted[:, 0] = E / q
+
+    return converted
+
+
+def photons_above_bandgap(E_gap, photon_spectrum):
+    """Counts number of photons above given bandgap.
+    
+    Parameters:
+        E_gap(float): Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+
+    Returns:
+       (float): Integration of the spectrum for the number of photons above the bandgap.  
+    """
+    indexes = np.where(photon_spectrum[:, 0] > E_gap)
+    y = photon_spectrum[indexes, 1][0]
+    x = photon_spectrum[indexes, 0][0]
+    return np.trapz(y[::-1], x[::-1])
+
+def rr0(E_gap, photon_spectrum, Tcell):
+    '''
+    Calculates the radiative recombination rate at 0 Quasi-Fermi Level splitting. 
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+        Radiative recomination rate(float) in cm⁻³s⁻¹ 
+
+    '''
+    k_eV = k / q
+    h_eV = h / q
+    const = (2 * np.pi) / (c**2 * h_eV**3)
+
+    k_eV = k / q
+    E = photon_spectrum[::-1, ]  # in increasing order of bandgap energy
+    egap_index = np.where(E[:, 0] >= E_gap)
+    numerator = E[:, 0]**2
+    exponential_in = E[:, 0] / (k_eV * Tcell)
+    denominator = np.exp(exponential_in) - 1
+    integrand = numerator / denominator
+
+    integral = np.trapz(integrand[egap_index], E[egap_index, 0])
+
+    result = const * integral
+    return result[0]
+
+def recomb_rate(E_gap, photon_spectrum, voltage, Tcell):
+    '''
+    Calculates the radiative recombination rate. 
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+        voltage(float): Open circuit voltage in V
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+        Radiative recomination rate(float) in cm⁻³s⁻¹ 
+
+    '''
+
+    print ('recomb rate')
+    return q * rr0(E_gap, photon_spectrum) * np.exp(q * voltage / (k * Tcell))
+
+def current_density(E_gap, photon_spectrum, voltage, Tcell):
+    '''
+    Calculates the current density. 
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+        voltage(float): Open circuit voltage in V
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+        Current density (float):  Current that flows across a cross sectional area in C cm⁻³s⁻¹. 
+
+    '''
+
+    return q * (photons_above_bandgap(E_gap, photon_spectrum) - rr0(E_gap, photon_spectrum, Tcell) * np.exp(q * voltage / (k * Tcell)))
+
+
+def jsc(E_gap, photon_spectrum, Tcell):
+
+    '''
+    Calculates the current density. 
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+
+    Returns:
+        Short circuit current density (float):  Current that flows across a cross sectional area at 0 applied voltage in C cm⁻³s⁻¹.  
+
+    '''
+    
+    return current_density(E_gap, photon_spectrum, 0, Tcell)
+
+
+def voc(E_gap, photon_spectrum, Tcell):
+    '''
+    Calculates the open circuit voltage.
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+        Open circuit voltage (float):  Maximum voltage across a solar cell with no current flow in V. 
+
+    '''
+
+    # print 'voc'
+    return (k * Tcell / q) * np.log(photons_above_bandgap(E_gap, photon_spectrum) / rr0(E_gap, photon_spectrum, Tcell))
+
+def v_at_mpp(E_gap, photon_spectrum):
+
+    '''
+    Calculates the voltage at maximum power point (mpp) of a solar cell.
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+
+    Returns:
+        Voltage at MPP (float):  Voltage across a solar cell at the maximum power point in V. 
+
+    '''
+
+    v_open = voc(E_gap, photon_spectrum)
+    # print v_open
+    v = np.linspace(0, v_open)
+    index = np.where(v * current_density(E_gap, photon_spectrum, v)==max(v * current_density(E_gap, photon_spectrum, v)))
+    return v[index][0]
+
+
+def j_at_mpp(E_gap, photon_spectrum):
+
+    '''
+    Calculates the current at maximum power point (mpp) of a solar cell.
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+
+    Returns:
+       Current at MPP (float):  Current across a solar cell at the maximum power point. 
+
+    '''
+
+    return max_power(E_gap, photon_spectrum) / v_at_mpp(E_gap, photon_spectrum)
+
+
+def max_power(E_gap, photon_spectrum, Tcell):
+
+    '''
+    Calculates the maximum power of a solar cell.
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+       Maximum power (float):  Maximum power of the solar cell in V C cm⁻³ s⁻¹. 
+
+    '''
+
+    v_open = voc(E_gap, photon_spectrum, Tcell)
+    v = np.linspace(0, v_open)
+    index = np.where(v * current_density(E_gap, photon_spectrum, v, Tcell)==max(v * current_density(E_gap, photon_spectrum, v, Tcell)))
+    return max(v * current_density(E_gap, photon_spectrum, v, Tcell))
+
+
+def max_eff(E_gap, photon_spectrum, Tcell):
+
+    '''
+    Calculates the maximum efficiency of a solar cell.
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+       Maximum efficiency (float):  Maximum effeciency of the solar cell relative to the total irradiance in %.
+    '''
+
+    photon_spectrum_1 = photon_spectrum[::-1, 1] 
+    photon_spectrum_0 = photon_spectrum[::-1, 0]
+
+    irradiance =  np.trapz(photon_spectrum_1 * q * photon_spectrum_0, photon_spectrum_0)
+    return max_power(E_gap, photon_spectrum, Tcell) / irradiance
+
+def FillFactor(E_gap, photon_spectrum, Tcell):
+
+    '''
+    Calculates the fill factor of a solar cell.
+
+    Parameters: 
+        E_gap(float):  Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarray): Output spectrum as numpy ndarray.
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+       fill_factor (float):  The fill factor of a solar cell.
+    '''
+
+    j_sc = jsc(E_gap, photon_spectrum)
+    v_oc = voc(E_gap, photon_spectrum, Tcell)
+    v_mpp = v_at_mpp(E_gap, photon_spectrum)
+    j_mpp = j_at_mpp(E_gap, photon_spectrum)
+
+    fill_factor = (j_mpp * v_mpp) / (j_sc, v_oc)
+
+    return fill_factor
+
+

solphin/db_plotting.py

@@ -0,0 +1,81 @@
+import solphin.db_fom as db_fom
+import numpy as np
+import matplotlib.pyplot as plt
+
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+def photons_above_bandgap_plot(spectrum, Egap):
+    """Plot of photons above bandgap as a function of bandgap"""
+    a = np.copy(spectrum)
+    for row in a:
+        # print row
+        row[1] = db_fom.photons_above_bandgap(row[0], spectrum)
+    plt.plot(a[:, 0], a[:, 1], color='#231123')
+
+    p_above_1_1 = db_fom.photons_above_bandgap(Egap, spectrum)
+    plt.plot([Egap], [p_above_1_1], 'ro', color='#FF6666')
+    plt.text(Egap+0.05, p_above_1_1, '{}eV, {:.4}'.format(Egap, p_above_1_1))
+
+    plt.xlabel('$E_{gap}$ (eV)')
+    plt.ylabel('# Photons $m^{-2}s^{-1}$')
+    plt.title('Number of above-bandgap \nphotons as a function of bandgap')
+    plt.show()
+
+def iv_curve_plot(egap, spectrum, Tcell, power=False):
+    """Plots the ideal IV curve, or the ideal power for a given material"""
+    v_open = db_fom.voc(egap, spectrum, Tcell)
+    v = np.linspace(0, v_open)
+    if power:
+        p =  v * db_fom.current_density(egap, spectrum, v, Tcell)
+        plt.xlabel('Voltage (V)')
+        plt.ylabel('Power generated ($W$)')
+        plt.title('Power Curve')
+        plt.plot(v, p, color='#231123')
+    else:
+        i =  db_fom.current_density(egap, spectrum, v, Tcell)
+        plt.xlabel('Voltage (V)')
+        plt.ylabel('Current density $J$ ($Am^{-2}$)')
+        plt.title('IV Curve')
+        plt.plot(v, i, color='#231123')
+
+
+def iv_curve_plot_2(egap, spectrum, Tcell, power=False):
+    """Plots the ideal IV curve, and the ideal power for a given material"""
+    v_open = db_fom.voc(egap, spectrum, Tcell)
+    v = np.linspace(0, v_open)
+
+    fig, ax1 = plt.subplots()
+    p =  v * db_fom.current_density(egap, spectrum, v, Tcell)
+    i =  db_fom.current_density(egap, spectrum, v, Tcell)
+    
+    ax1.plot(v, i, color='#231123')
+    ax1.set_xlabel('Voltage (V)')
+    ax1.set_ylabel('Current density $J$ ($Am^{-2}$)')
+    ax1.legend(['Current'], loc=2)
+    
+    ax2 = ax1.twinx()
+    ax2.plot(v, p, color='#FF6666')
+    ax2.set_ylabel('Power generated ($W$)')
+    ax2.legend(['Power'], loc=3)
+    return
+
+
+def sq_limit_plot(spectrum, Egap, Tcell):
+    # Plot the famous SQ limit
+    a = np.copy(spectrum)
+    # Not for whole array hack to remove divide by 0 errors
+    for row in a[2:]:
+        # print row
+        row[1] = db_fom.max_eff(row[0], spectrum, Tcell)
+    # Not plotting whole array becase some bad values happen
+    plt.plot(a[2:, 0], a[2:, 1])
+    e_gap = Egap
+    p_above_1_1 = db_fom.max_eff(e_gap, spectrum, Tcell)
+    plt.plot([e_gap], [p_above_1_1], 'ro')
+    plt.text(e_gap+0.05, p_above_1_1, '{}eV, {:.4}'.format(e_gap, p_above_1_1))
+
+    plt.xlabel('$E_{gap}$ (eV)')
+    plt.ylabel('Max efficiency')
+    plt.title('SQ Limit')

solphin/final_results.py

@@ -0,0 +1,73 @@
+from solphin.pv_fom import Final_equation
+from solphin.db_fom import max_eff
+
+# Calculating equation 33 from the FOM paper
+
+def Crovetto_efficiency(E_gap, photon_spectrum, alpha, tau, sigma, dos_mass, dop_density, epsilon, mu, Tcell):
+
+    ''' Calculates the final value for the photovoltaic figure of merit from Crovetto 2024
+    
+    Parameters:
+        E_gap(float): Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarrray): Converted input spectrum from DB_FOM.convert_spectrum y: Number of photons (Np/m2/s/dE) x: Energy (eV)
+        alpha(float): Spectral average of incident light in cm⁻¹
+        tau(float): Non-radiative recombination lifetime in s
+        sigma(float): Spectral dispersion of the absorption coefficient spectrum, unitless
+        dos_mass(float): Density of States effective mass in m₀
+        dop_density(float): Doping density in cm⁻³
+        epsilon(float): Static dielectric constant, unitless
+        mu(float): Charge carrier mobility in cm²V⁻¹s⁻¹
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+        efficiency(float): Percentage photovoltaic figure of merit efficiency.
+    '''
+
+    PV_FOM = Final_equation(E_gap, alpha, tau, sigma, dos_mass, dop_density, epsilon, mu)
+
+    k_1 = 3.3e-1
+    k_2 = 9.06e-2
+    k_3 = 2.48e-3
+
+    FOM_Pv_235 = PV_FOM ** (-0.235)
+    FOM_Pv_869 = PV_FOM ** 0.869
+    FOM_Pv_362 = PV_FOM ** (-0.362)
+
+    fraction = (k_1 * FOM_Pv_235) / (1 + k_2 * FOM_Pv_869)
+    denom_bracket = 1 + (k_3 * FOM_Pv_362)
+
+    SQ_eff = max_eff(E_gap, photon_spectrum, Tcell)
+    SQ = SQ_eff * 100
+
+    efficiency = SQ / ((1 + fraction) * denom_bracket)
+
+    return efficiency
+
+# Crovetto efficiency realtive to SQ limit
+
+def SQ_relative_Crovetto_efficiency(E_gap, photon_spectrum, alpha, tau, sigma, dos_mass, dop_density, epsilon, mu, Tcell):
+
+    ''' Calculates the final value for the photovoltaic figure of merit relative to the SQ limit from Crovetto 2024
+    
+    Parameters:
+        E_gap(float): Optical Band Gap in eV  
+        photon_spectrum(numpy.ndarrray): Converted input spectrum from DB_FOM.convert_spectrum y: Number of photons (Np/m2/s/dE) x: Energy (eV)
+        alpha(float): Spectral average of incident light in cm⁻¹
+        tau(float): Non-radiative recombination lifetime in s
+        sigma(float): Spectral dispersion of the absorption coefficient spectrum, unitless
+        dos_mass(float): Density of States effective mass in m₀
+        dop_density(float): Doping density in cm⁻³
+        epsilon(float): Static dielectric constant, unitless
+        mu(float): Charge carrier mobility in cm²V⁻¹s⁻¹
+        Tcell(float): Operating temperature of the cell in K
+
+    Returns:
+        efficiency(float): Percentage photovoltaic figure of merit efficiency relative to the SQ limit.
+    '''
+
+    Crovetto_eff = Crovetto_efficiency(E_gap, photon_spectrum, alpha, tau, sigma, dos_mass, dop_density, epsilon, mu, Tcell)
+    SQ = max_eff(E_gap, photon_spectrum, Tcell)
+
+    SQ_relative = Crovetto_eff / SQ
+
+    return SQ_relative

solphin/optics.py

@@ -0,0 +1,220 @@
+from pymatgen.io.vasp import Vasprun
+import numpy as np
+from os.path import join
+import scipy.special as sc
+import pandas as pd
+
+q=1.60217662E-19
+kT=0.0258519975 # eV for T=300K
+k=0.000086173325 #eV/K
+h=4.135667E-15 #eVs
+c=2.9979E+8 #m/s
+
+def calc_dielectric(filename):
+
+    '''Calculates the dielectric constants from a vasprun.xml
+    
+    Parameters:
+        filename(string): filename/ path of the vasprun, typically vasprun.xml.
+        
+    Returns:
+        eps_full(np.array): static dielectric constant (complex, contains both real and imaginary components)
+        energies(np.array): energy of the incident radiation eV
+        '''
+
+    load_vasprun = Vasprun(filename)
+    dielectric = load_vasprun.dielectric
+
+    energies = np.array(dielectric[0])
+
+    real_eps = np.array(dielectric[1])[:, [[0, 3, 5], [3, 1, 4], [5, 4, 2]]]
+    imag_eps = np.array(dielectric[2])[:, [[0, 3, 5], [3, 1, 4], [5, 4, 2]]]
+    eps_full = real_eps + 1j * imag_eps
+
+    return eps_full, energies
+
+def calc_absorption(eps_full, energies):
+
+    '''Calculates the averages of the real and imaginary components of the refractive index, absorption, losses, real and imaginary components of the 
+    static dielectric constant.
+    
+    Parameters:
+        eps_full(np.array): static dielectric constant (complex, contains both real and imaginary components)
+        energies(np.array): energy of the incident radiation eV
+        
+    Returns:
+        data(dictionary):
+        '''
+
+    # take sqrt of eps matrix; if eps = V S V^-1; then eps^1/2 = V S^{1/2} V^-1;
+    eigvals, eigvecs = np.linalg.eig(eps_full)
+
+    # fancy einsum to calculate V S^{1/2} V^-1 at every energy
+    n = np.einsum("ijk,ik,ikl->ijl", eigvecs, np.sqrt(eigvals), np.linalg.inv(eigvecs))
+
+    # calculate optical absorption
+    alpha = n.imag * energies[:, None, None] * 4 * np.pi / 1.23984212e-4
+
+    # Invert epsilon to obtain energy-loss function
+    loss = -np.linalg.inv(eps_full).imag
+
+    eps = np.linalg.eigvals(eps_full).mean(axis=1)
+    n = np.linalg.eigvals(n).mean(axis=1)
+    loss = np.linalg.eigvalsh(loss).mean(axis=1)
+    alpha = np.linalg.eigvalsh(alpha).mean(axis=1)
+
+    data = {
+        "eps_real": eps.real,
+        "eps_imag": eps.imag,
+        "n_real": n.real,
+        "n_imag": n.imag,
+        "loss": loss,
+        "absorption": alpha,
+    }
+
+    return data
+
+def print_n_real_file(data, energies):
+
+    filename = 'n_real.dat'
+    directory = 'dos'
+
+    if directory:
+            filename = join(directory, filename)
+
+    header = "energy(eV)"
+
+    header += " alpha"
+    data = np.stack((energies, data['n_real']), axis=1)
+
+    np.savetxt(filename, data, header=header)
+
+def generate_n_real(filename):
+     
+     eps_full, energies = calc_dielectric(filename)
+
+     data = calc_absorption(eps_full, energies)
+
+     print_n_real_file(data, energies)
+
+
+def blank_flat(alpha, n, length): 
+
+    #Absorptance for flat scatterer, from Matlab script
+    the_c = np.arcsin(1/n[0])
+    theta = np.linspace(0.0, the_c, num=200)
+    a_len = len(alpha)
+    t_len = len(theta)
+    toft = np.zeros(a_len*t_len)
+    toft = toft.reshape(a_len, t_len)
+    absorb_tr = np.zeros(a_len)
+
+    for i, a_pt in enumerate(alpha):
+        for j, t_pt in enumerate(theta):
+            toft_pt = np.exp(((2*np.multiply((-a_pt), length))/np.cos(t_pt)))
+            toft[i, j] = toft_pt
+        a_t_1 = np.trapz((toft[i,:]*np.cos(theta)*np.sin(theta)), theta)
+        a_t_2 = np.trapz((np.cos(theta)*np.sin(theta)), theta)
+        absorb_tr[i] = 1 - (a_t_1/a_t_2)
+
+    absorb = absorb_tr.conjugate()
+    return(absorb)
+
+
+def blank_lambert(alpha, n, length):
+
+    #Absorptance for Lambertian scatterer coating, from Matlab script
+    x = np.multiply(2,np.multiply(alpha,length))
+    T = np.exp((-x)) - np.multiply(x, np.exp((-x))) + (x**2*sc.exp1(x))
+    R = 1.0/(np.multiply(n,n))
+    Abs = (1-T)/(1-T+(R*T))
+    Abs = np.nan_to_num(Abs)
+    Emi = (R*T)/(1-T+(R*T))
+
+    return(Abs)
+
+def blank_eta(spectrum, E, alpha, n, length, Qi, trap):
+    #For given scatterer, calculates Blank et al. eta
+    dE = E[1]-E[0]
+    if trap == 1:
+        Abs = blank_flat(alpha, n, length)
+    elif trap == 2:
+        Abs = blank_lambert(alpha, n, length)
+    
+    #np divide necessary to have array divide here?
+    phibb = 2*np.divide(np.divide(np.multiply(E,E),((h**3)*(c**2))),(np.exp(E/kT)-1))
+    phibb = np.nan_to_num(phibb) # NaNs to 0, as in Matlab
+
+    ps_E = spectrum[:, 0]
+    phi_sun = spectrum[:, 1]
+    
+    # works for all E values above 0.03? won't extrapolate for 0
+    # values < gap shouldn't be relevant?
+    phisun = 10000*np.interp(E, ps_E, phi_sun)
+        
+    Jsc = q*np.sum(Abs*phisun)*dE
+    J0rad = q*np.sum(Abs*phibb)*dE
+    
+    Rrad = 4*np.pi*np.sum(alpha*(n**2)*phibb)*dE
+    Rnrad = (Rrad-Qi*Rrad)/Qi
+    
+    pe = J0rad/(q*Rrad*length)
+    J0 = q*length*(Rnrad + pe*Rrad)
+    #Looks like this scans over only voltages between 0 and 2 V
+    #need testing for band gaps>2 eV?
+    V = np.linspace(0, 2, 1001)
+    Pmax = np.max(V*(Jsc - J0*(np.exp(V/kT)-1)))
+    eta = Pmax/1000
+
+    return(eta)
+
+def blank_parse(folder):
+    
+    # Parses outputs from current directory
+
+    abs_data = pd.read_table(f'{folder}/absorption.dat', delim_whitespace=True,
+                                skiprows=1, header=None)
+    n_data = pd.read_table(f'{folder}/n_real.dat', delim_whitespace=True,
+                    skiprows=1, header=None)
+    
+    E_p = list(abs_data[0])
+    alpha_p = list(abs_data[1])
+    n_p = list(n_data[1])
+
+    return{"E": E_p, "alpha": alpha_p, "n": n_p}
+
+def blank_calculate(spectrum, folder):
+
+    data = blank_parse(folder)
+
+    E = np.asarray(data["E"])
+    alpha = np.asarray(data["alpha"])
+    alpha = np.multiply(alpha, 100)
+    n = np.asarray(data["n"])
+
+    #Remove data for E>5eV, necessary for speed! Also done in Matlab
+
+    E = np.asarray([o for o in E if o <= 5])
+    alpha = alpha[0:(len(E))]
+    n = n[0:(len(E))]
+
+    #main, looping over lengths and Qi, outputs eta table
+    length_arr = np.logspace(-8.0, -3.0, num=36)
+    Qi_arr = np.logspace(0, -6, num=4)
+    trap = [1, 2]
+
+    for tr_pt in trap:
+        eta_arr = np.zeros(len(length_arr)*(len(Qi_arr)+1))
+        eta_arr = eta_arr.reshape(len(length_arr), (len(Qi_arr)+1))
+        for k, l_pt in enumerate(length_arr):
+            for l, q_pt in enumerate(Qi_arr):
+                eta_max = blank_eta(spectrum, E, alpha, n, l_pt, q_pt, tr_pt)
+                eta_arr[k, 0] = l_pt
+                eta_arr[k, l+1] = eta_max
+        if tr_pt == 1:
+            head="Thickness[m] \t Eta as fraction for Flat scatterer with Qi = 1.0, 0.01, 1E-4, 1E-6"
+            np.savetxt('flat_eta_out', eta_arr, header=head)
+        elif tr_pt == 2:
+            head="Thickness[m] \t Eta as fraction for Lambertian scatterer with Qi = 1.0, 0.01, 1E-4, 1E-6"
+            np.savetxt('lamb_eta_out', eta_arr, header=head)
+