solphin 0.0.0__tar.gz

solphin-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 ireaml
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

solphin-0.0.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: solphin
+Version: 0.0.0
+Summary: Figure of Merit for Photovoltaics
+Home-page: https://github.com/SMTG-Bham/PV-FoM
+Author: Philippa U Cox, Peter P Russell
+Author-email: puc369@student.bham.ac.uk, ppr466@student.bham.ac.uk
+License: MIT
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.9
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib>=3.9.4
+Requires-Dist: pymatgen>=2024.8.9
+Requires-Dist: mpmath
+Requires-Dist: pathlib
+Requires-Dist: typing_extensions
+Requires-Dist: monty
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

solphin-0.0.0/README.md

@@ -0,0 +1,30 @@
+# PV-FoM
+
+**Please note that this code is still under development and not currently suitable for use**
+
+`solphin` is a code developed to assist with the characterisation of novel photovoltaic materials with `VASP`. It combines detailed balance analysis with other tools such as the photovoltaic figure of merit proposed by A.Crovetto, Spectroscopic Limited Maximum Efficiency (SLME), Blank et al Maximum Efficiency and Optical tauc plots to provide a full picture of a materials theoretical photovoltaic efficiency. 
+
+*We request that any use of `solphin` in your work cites the code and theory papers*
+
+## Installation 
+
+`solphin` is currently only installable through the following method:
+
+```
+git clone https://<PATOKEN>@github.com/SMTG-Bham/PV-FoM
+```
+
+Navigate into `solphin` and run:
+
+```
+pip install -e.
+```
+
+If using the `VASP` input file generation functionality, please ensure that your `VASP` pseudopotentials are added to your path through the use of a `pymatgen` configuration file `$HOME/.pmgrc.yaml`. The file should contain:
+
+```
+PMG_VASP_PSP_DIR: <Path to VASP pseudopotential top directory>
+```
+
+
+

solphin-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

solphin-0.0.0/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup
+
+setup(
+    name='solphin',
+    version='0.0.0',    
+    description='Figure of Merit for Photovoltaics',
+    url='https://github.com/SMTG-Bham/PV-FoM',
+    author='Philippa U Cox, Peter P Russell',
+    author_email='puc369@student.bham.ac.uk, ppr466@student.bham.ac.uk',
+    license='MIT',
+    packages=['solphin'],
+    install_requires=['numpy',
+                      'scipy',
+                      'matplotlib>=3.9.4',
+                      'pymatgen>=2024.8.9',
+                      'mpmath',
+                      'pathlib',
+                      'typing_extensions',
+                      'monty'                     
+                      ],
+
+    classifiers=[
+        'Development Status :: 1 - Planning',
+        'Intended Audience :: Science/Research',
+        'License :: OSI Approved :: MIT License',  
+        'Operating System :: POSIX :: Linux',        
+        'Programming Language :: Python :: 3.9',
+    ],
+)

solphin-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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