Source code for solcore.optics.tmm

import types
from typing import List, Optional

import numpy as np
from numpy.typing import NDArray

from ..absorption_calculator import (
from ..registries import register_optics
from ..solar_cell import SolarCell
from ..structure import Junction, Layer, TunnelJunction

[docs]@register_optics(name="TMM") def solve_tmm( solar_cell: SolarCell, wavelength: NDArray, position: NDArray, BL_correction: bool = True, theta: float = 0.0, pol: str = "u", zero_threshold: float = 1e-5, no_back_reflection: bool = True, coherency_list: Optional[List[str]] = None, **kwargs ) -> None: """Calculates the RAT of a solar cell object using the transfer matrix method. Internally, it creates an OptiStack and then it calculates the optical properties of the whole structure. A substrate can be specified in the SolarCell object, which is treated as a semi-infinite transmission medium. Shading can also be specified (as a fraction). A coherency_list option can be provided: Args: solar_cell: A solar_cell object wavelength: Array of wavelegth at which the optics are calculated. position: Array of positions in the z direction to calculate the absorption vs depth. BL_correction: If is set to True, thick layers (thickness > 10*maximum wavelength) are treated incoherently using the Beer-Lambert law, to avoid the calculation of unphysical interference oscillations in the R/A/T spectra. theta: the polar incidence angle, in degrees, with 0 degrees being normal incidence. pol: the polarization of the light ('s', 'p' or 'u') zero_threshold: when the fraction of incident light absorbed in a layer is less than this value, the absorption profile is completely set to zero for both coherent and incoherent calculations. This is applied on a wavelength-by-wavelength basis and is intended to prevent errors where integrating a weak absorption profile in a layer over many points leads to calculated EQE > total absorption in that layer. no_back_reflection: Sets whether reflections from the back surface are suppressed (if set to True, the default), or taken into account (if set to False). coherency_list: If present, this should have the same number of elements than number of layers (if a Junction contains multiple Layers, each should have its own entry in the coherency list). Each element is either 'c' for coherent treatment of that layer or 'i' for incoherent treatment. Return: None """ # We include the shadowing losses initial = (1 - solar_cell.shading) if hasattr(solar_cell, "shading") else 1 # Now we calculate the absorbed and transmitted light. We first get all the relevant # parameters from the objects all_layers = [] widths = [] n_layers_junction = [] for j, layer_object in enumerate(solar_cell): # Attenuation due to absorption in the AR coatings or any layer in the front # that is not part of the junction if type(layer_object) is Layer: all_layers.append(layer_object) widths.append(layer_object.width) n_layers_junction.append(1) # For each junction, and layer within the junction, we get the absorption # coefficient and the layer width. elif type(layer_object) in [TunnelJunction, Junction]: n_layers_junction.append(len(layer_object)) for i, layer in enumerate(layer_object): all_layers.append(layer) widths.append(layer.width) # With all the information, we create the optical stack full_stack = OptiStack( all_layers, no_back_reflection=no_back_reflection, substrate=solar_cell.substrate, incidence=solar_cell.incidence, ) if coherency_list is not None: coherent = False if len(coherency_list) != full_stack.num_layers: raise ValueError( "Error: The coherency list must have as many elements (now {}) as the " "number of layers (now {}).".format( len(coherency_list), full_stack.num_layers ) ) else: coherent = True # assume it's safe to ignore interference effects if BL_correction and any(widths > 10 * np.max(wavelength)): make_incoherent = np.where(np.array(widths) > 10 * np.max(wavelength))[0] print("Treating layer(s) " + str(make_incoherent).strip("[]") + " incoherently") if not coherency_list: coherency_list_ = np.array(len(all_layers) * ["c"]) coherent = False else: coherency_list_ = np.array(coherency_list) coherency_list_[make_incoherent] = "i" coherency_list = coherency_list_.tolist() position = position * 1e9 profile_position = position[position < sum(full_stack.widths)] print("Calculating RAT...") RAT = calculate_rat( full_stack, wavelength * 1e9, angle=theta, coherent=coherent, coherency_list=coherency_list, no_back_reflection=no_back_reflection, pol=pol, ) print("Calculating absorption profile...") out = calculate_absorption_profile( full_stack, wavelength * 1e9, dist=profile_position, angle=theta, no_back_reflection=no_back_reflection, pol=pol, coherent=coherent, coherency_list=coherency_list, zero_threshold=zero_threshold, RAT_out=RAT, ) # With all this information, we are ready to calculate the differential absorption # function diff_absorption, all_absorbed = calculate_absorption_tmm(out, initial) # Each building block (layer or junction) needs to have access to the absorbed light # in its region. We update each object with that information. # first entry is R, last entry is T layer = 0 A_per_layer = np.array(RAT["A_per_layer"][1:-1]) for j in range(len(solar_cell)): solar_cell[j].layer_absorption = initial * np.sum( A_per_layer[layer : (layer + n_layers_junction[j])], axis=0 ) solar_cell[j].diff_absorption = diff_absorption solar_cell[j].absorbed = types.MethodType(absorbed, solar_cell[j]) layer = layer + n_layers_junction[j] solar_cell.reflected = RAT["R"] * initial solar_cell.absorbed = sum( [solar_cell[x].layer_absorption for x in np.arange(len(solar_cell))] ) solar_cell.transmitted = initial - solar_cell.reflected - solar_cell.absorbed
[docs]def absorbed(self, z): out = self.diff_absorption(self.offset + z) * (z < self.width) return out.T
[docs]def calculate_absorption_tmm(tmm_out, initial=1): all_z = tmm_out["position"] * 1e-9 all_abs = initial * tmm_out["absorption"] / 1e-9 def diff_absorption(z): idx = all_z.searchsorted(z) idx = np.where(idx <= len(all_z) - 1, idx, len(all_z) - 1) idx = np.where(idx > 0, idx, 1) try: z1 = all_z[idx - 1] z2 = all_z[idx] f = np.divide(z - z1, z2 - z1, out=np.zeros_like(z), where=np.abs(z2-z1) > 1e-12) # this is to avoid divide by zero errors (|f| gets very large) when z1 = z2 out = (1-f) * all_abs[:, idx - 1] + f * all_abs[:, idx] except IndexError: out = all_abs[:, idx] return out all_absorbed = np.trapz(diff_absorption(all_z), all_z) return diff_absorption, all_absorbed