scambio.cell

  1r"""Solar cell."""
  2
  3import numpy as np
  4import seaborn as sns
  5from collections.abc import Mapping, Sequence
  6from math import ceil
  7from matplotlib import pyplot as plt
  8from numbers import Real
  9from scipy.optimize import minimize_scalar, root_scalar
 10from typing import Self
 11from scambio.absorbance import ResolvedSpectralAbsorbancePPoly
 12from scambio.balance import DetailedBalanceModel
 13from scambio.constant import Constant
 14from scambio.represent import repr_num_seq
 15
 16
 17sns.set_theme(
 18    context="talk",
 19    style="white",
 20    rc={"figure.titlesize": "medium", "axes.formatter.useoffset": False},
 21)
 22
 23
 24class AppliedSolarCell:
 25    r"""Solar cell at given temperature and Sunlight concentration factor.
 26
 27    Args:
 28        rsv_sp_absorb_ppoly: Resolved spectral absorbance piecewise polynomials.
 29        temperature: Temperature [$\mathrm{K}$].
 30        concentration: Sunlight concentration factor.
 31    """
 32
 33    def __init__(
 34        self,
 35        rsv_sp_absorb_ppoly: ResolvedSpectralAbsorbancePPoly,
 36        *,
 37        temperature: Real,
 38        concentration: Real,
 39    ) -> None:
 40        r"""Initialize AppliedSolarCell object."""
 41        self.rsv_sp_absorb_ppoly = rsv_sp_absorb_ppoly
 42        self.temperature = temperature
 43        self.concentration = concentration
 44        self.clear_voltage_sweep()
 45
 46    def __repr__(self) -> str:
 47        r"""Represent AppliedSolarCell object."""
 48        return "\n".join(
 49            [
 50                "Applied solar cell:",
 51                f"-       ii band / eV: [{self.onset_ii:.2f}, {self.offset_ii:.2f}]",
 52                f"-       vi band / eV: [{self.onset_vi:.2f}, {self.offset_vi:.2f}]",
 53                f"-       ic band / eV: [{self.onset_ic:.2f}, {self.offset_ic:.2f}]",
 54                f"-       vc band / eV: [{self.onset_vc:.2f}, {self.offset_vc:.2f}]",
 55                f"-    temperature / K: {self.temperature:.1f}",
 56                f"-      concentration: {self.concentration:.0f}",
 57                f"-  voltage sweep / V: {repr_num_seq(self.voltage_sweep, margin=22)}",
 58            ]
 59        )
 60
 61    @property
 62    def rsv_sp_absorb_ppoly(self) -> ResolvedSpectralAbsorbancePPoly:
 63        r"""Resolved spectral absorbance piecewise polynomials."""
 64        return self._rsv_sp_absorb_ppoly
 65
 66    @rsv_sp_absorb_ppoly.setter
 67    def rsv_sp_absorb_ppoly(self, arg: ResolvedSpectralAbsorbancePPoly) -> None:
 68        if not isinstance(arg, ResolvedSpectralAbsorbancePPoly):
 69            raise TypeError("Not a ResolvedSpectralAbsorbancePPoly object!")
 70        self._rsv_sp_absorb_ppoly = arg
 71
 72    @property
 73    def temperature(self) -> float:
 74        r"""Temperature [$\mathrm{K}$]."""
 75        return self._temperature
 76
 77    @temperature.setter
 78    def temperature(self, arg: Real) -> None:
 79        if not isinstance(arg, Real) or not arg > 0.0:
 80            raise ValueError("Temperature must be a positive number!")
 81        self._temperature = float(arg)
 82        self.clear_cached_properties()
 83
 84    @property
 85    def concentration(self) -> float:
 86        r"""Sunlight concentration factor."""
 87        return self._concentration
 88
 89    @concentration.setter
 90    def concentration(self, arg: Real) -> None:
 91        if not isinstance(arg, Real) or not (0.0 <= arg <= 46200.0):
 92            raise ValueError(
 93                "Sunlight concentration factor must be between 0 and 46200!"
 94            )
 95        self._concentration = float(arg)
 96        self.clear_cached_properties()
 97
 98    @property
 99    def onset_ii(self) -> float:
100        r"""Intermediate-intermediate onset [$\mathrm{eV}$]."""
101        if self._onset_ii is None:
102            sp_absorb_ii = self.rsv_sp_absorb_ppoly.ii
103            if sp_absorb_ii is not None:
104                self._onset_ii = sp_absorb_ii.onset
105            else:
106                self._onset_ii = np.nan
107        return self._onset_ii
108
109    @property
110    def offset_ii(self) -> float:
111        r"""Intermediate-intermediate offset [$\mathrm{eV}$]."""
112        if self._offset_ii is None:
113            sp_absorb_ii = self.rsv_sp_absorb_ppoly.ii
114            if sp_absorb_ii is not None:
115                self._offset_ii = sp_absorb_ii.offset
116            else:
117                self._offset_ii = np.nan
118        return self._offset_ii
119
120    @property
121    def onset_vi(self) -> float:
122        r"""Valence-intermediate onset [$\mathrm{eV}$]."""
123        if self._onset_vi is None:
124            sp_absorb_vi = self.rsv_sp_absorb_ppoly.vi
125            if sp_absorb_vi is not None:
126                self._onset_vi = sp_absorb_vi.onset
127            else:
128                self._onset_vi = np.nan
129        return self._onset_vi
130
131    @property
132    def offset_vi(self) -> float:
133        r"""Valence-intermediate offset [$\mathrm{eV}$]."""
134        if self._offset_vi is None:
135            sp_absorb_vi = self.rsv_sp_absorb_ppoly.vi
136            if sp_absorb_vi is not None:
137                self._offset_vi = sp_absorb_vi.offset
138            else:
139                self._offset_vi = np.nan
140        return self._offset_vi
141
142    @property
143    def onset_ic(self) -> float:
144        r"""Intermediate-conduction onset [$\mathrm{eV}$]."""
145        if self._onset_ic is None:
146            sp_absorb_ic = self.rsv_sp_absorb_ppoly.ic
147            if sp_absorb_ic is not None:
148                self._onset_ic = sp_absorb_ic.onset
149            else:
150                self._onset_ic = np.nan
151        return self._onset_ic
152
153    @property
154    def offset_ic(self) -> float:
155        r"""Intermediate-conduction offset [$\mathrm{eV}$]."""
156        if self._offset_ic is None:
157            sp_absorb_ic = self.rsv_sp_absorb_ppoly.ic
158            if sp_absorb_ic is not None:
159                self._offset_ic = sp_absorb_ic.offset
160            else:
161                self._offset_ic = np.nan
162        return self._offset_ic
163
164    @property
165    def onset_vc(self) -> float:
166        r"""Valence-conduction onset [$\mathrm{eV}$]."""
167        if self._onset_vc is None:
168            sp_absorb_vc = self.rsv_sp_absorb_ppoly.vc
169            if sp_absorb_vc is not None:
170                self._onset_vc = sp_absorb_vc.onset
171            else:
172                self._onset_vc = np.nan
173        return self._onset_vc
174
175    @property
176    def offset_vc(self) -> float:
177        r"""Valence-conduction offset [$\mathrm{eV}$]."""
178        if self._offset_vc is None:
179            sp_absorb_vc = self.rsv_sp_absorb_ppoly.vc
180            if sp_absorb_vc is not None:
181                self._offset_vc = sp_absorb_vc.offset
182            else:
183                self._offset_vc = np.nan
184        return self._offset_vc
185
186    @property
187    def voltage_ub(self) -> float:
188        r"""Voltage upper bound [$\mathrm{V}$]."""
189        if self._voltage_ub is None:
190            voltage_ub = min(
191                np.nan_to_num(self.onset_vi + self.onset_ic, nan=np.inf),
192                np.nan_to_num(self.onset_vc, nan=np.inf),
193                np.inf
194            )
195            self._voltage_ub = float(voltage_ub)
196        return self._voltage_ub
197
198    @property
199    def voltage_oc(self) -> float:
200        r"""Open circuit voltage [$\mathrm{V}$]."""
201        if self._voltage_oc is None:
202            voltage_b = self.voltage_ub
203            voltage_a = voltage_b - 1.0
204            curr_den_a = self.curr_den_vs_voltage(voltage_a)
205            while curr_den_a > 0.0:
206                voltage_a -= 0.1
207
208            def objective(voltage):
209                if voltage == voltage_b:
210                    return np.inf
211                else:
212                    return self.curr_den_vs_voltage(voltage)
213
214            sol = root_scalar(
215                objective,
216                method="brentq",
217                bracket=[voltage_a, voltage_b],
218            )
219            if not sol.converged:
220                print("Open circuit voltage did not converge!")
221                self._voltage_oc = np.nan
222            else:
223                self._voltage_oc = sol.root
224
225        return self._voltage_oc
226
227    @property
228    def curr_den_sc(self) -> float:
229        r"""Short circuit current density [$\mathrm{mA \, cm^{-2}}$]."""
230        if self._curr_den_sc is None:
231            self._curr_den_sc = self.curr_den_vs_voltage(0.0)
232        return self._curr_den_sc
233
234    @property
235    def voltage_mpp(self) -> float:
236        r"""Maximum power point voltage [$\mathrm{V}$]."""
237        if self._voltage_mpp is None:
238            res = minimize_scalar(
239                self.power_den_vs_voltage,
240                method="bounded",
241                bounds=sorted([0.0, self.voltage_oc]),
242            )
243            if not res.success:
244                print("Maximum power point voltage did not converge!")
245                self._voltage_mpp = np.nan
246            else:
247                self._voltage_mpp = res.x
248
249        return self._voltage_mpp
250
251    @property
252    def db_model_mpp(self) -> DetailedBalanceModel:
253        r"""Maximum power point detailed balance model."""
254        if self._db_model_mpp is None:
255            self._db_model_mpp = self.db_model_vs_voltage(self.voltage_mpp)
256        return self._db_model_mpp
257
258    @property
259    def curr_den_mpp(self) -> float:
260        r"""Maximum power point current density [$\mathrm{mA \, cm^{-2}}$]."""
261        if self._curr_den_mpp is None:
262            if abs(self.db_model_mpp.curr_den_vb) < abs(
263                self.db_model_mpp.curr_den_cb
264            ):
265                self._curr_den_mpp = self.db_model_mpp.curr_den_vb
266            else:
267                self._curr_den_mpp = self.db_model_mpp.curr_den_cb
268        return self._curr_den_mpp
269
270    @property
271    def power_den_mpp(self) -> float:
272        r"""Maximum power point power density [$\mathrm{mW \, cm^{-2}}$]."""
273        if self._power_den_mpp is None:
274            self._power_den_mpp = self.curr_den_mpp * self.voltage_mpp
275        return self._power_den_mpp
276
277    @property
278    def efficiency_mpp(self) -> float:
279        r"""Maximum power point power conversion efficiency [$\mathrm{\%}$]."""
280        if self._efficiency_mpp is None:
281            self._efficiency_mpp = (
282                -100.0
283                * self.power_den_mpp
284                / (self.concentration * Constant.psun)
285            )
286        return self._efficiency_mpp
287
288    @property
289    def fill_factor(self) -> float:
290        r"""Fill factor."""
291        if self._fill_factor is None:
292            self._fill_factor = self.power_den_mpp / (
293                self.voltage_oc * self.curr_den_sc
294            )
295        return self._fill_factor
296
297    @property
298    def voltage_sweep(self) -> np.ndarray[float]:
299        r"""Voltage sweep [$\mathrm{V}$]."""
300        return self._voltage_sweep
301
302    @property
303    def db_model_sweep(self) -> list[DetailedBalanceModel, ...]:
304        r"""Detailed balance model sweep."""
305        if self._db_model_sweep is None:
306            self._db_model_sweep = [
307                self.db_model_vs_voltage(voltage)
308                for voltage in self.voltage_sweep
309            ]
310        return self._db_model_sweep
311
312    @property
313    def curr_den_sweep(self) -> np.ndarray[float]:
314        r"""Current density sweep [$\mathrm{mA \, cm^{-2}}$]."""
315        if self._curr_den_sweep is None:
316            self._curr_den_sweep = np.array([], dtype=float)
317            for db_model in self.db_model_sweep:
318                if abs(db_model.curr_den_vb) < abs(db_model.curr_den_cb):
319                    self._curr_den_sweep = np.append(
320                        self._curr_den_sweep,
321                        db_model.curr_den_vb,
322                    )
323                else:
324                    self._curr_den_sweep = np.append(
325                        self._curr_den_sweep,
326                        db_model.curr_den_cb,
327                    )
328        return self._curr_den_sweep
329
330    @property
331    def power_den_sweep(self) -> np.ndarray[float]:
332        r"""Power density sweep [$\mathrm{mW \, cm^{-2}}$]."""
333        if self._power_den_sweep is None:
334            self._power_den_sweep = self.curr_den_sweep * self.voltage_sweep
335        return self._power_den_sweep
336
337    @property
338    def efficiency_sweep(self) -> np.ndarray[float]:
339        r"""Power conversion efficiency sweep [$\mathrm{\%}$]."""
340        if self._efficiency_sweep is None:
341            self._efficiency_sweep = (
342                -100.0
343                * self.power_den_sweep
344                / (self.concentration * Constant.psun)
345            )
346        return self._efficiency_sweep
347
348    def clear_cached_properties(self) -> None:
349        r"""Clear cached properties."""
350        self._onset_ii = None
351        self._offset_ii = None
352        self._onset_vi = None
353        self._offset_vi = None
354        self._onset_ic = None
355        self._offset_ic = None
356        self._onset_vc = None
357        self._offset_vc = None
358        self._voltage_ub = None
359        self._voltage_oc = None
360        self._curr_den_sc = None
361        self._voltage_mpp = None
362        self._db_model_mpp = None
363        self._curr_den_mpp = None
364        self._power_den_mpp = None
365        self._efficiency_mpp = None
366        self._fill_factor = None
367        self._db_model_sweep = None
368        self._curr_den_sweep = None
369        self._power_den_sweep = None
370        self._efficiency_sweep = None
371
372    def db_model_vs_voltage(self, voltage: Real) -> DetailedBalanceModel:
373        r"""Detailed balance model vs voltage.
374
375        Args:
376            voltage: Voltage [$\mathrm{V}$].
377
378        Returns:
379            Detailed balance model.
380        """
381        return DetailedBalanceModel(
382            self.rsv_sp_absorb_ppoly,
383            temperature=self.temperature,
384            voltage=voltage,
385            concentration=self.concentration,
386        )
387
388    def curr_den_vs_voltage(self, voltage: Real) -> float:
389        r"""Current density vs voltage.
390
391        Note:
392            Valence and conduction band current densities should be the same.
393            However, the condition of zero intermediate band current density
394            cannot always be reached, such as in narrow-gap intermediate
395            band solar cells at high concentration.
396            This introduces a non-negligible difference between valence and
397            conduction band current densities, according to the continuity
398            equation.
399            Currently, the smaller among the two current densities is taken
400            as the solar cell current density.
401            This is particularly helpful to aid numerical optimization
402            methods.
403
404        Args:
405            voltage: Voltage [$\mathrm{V}$].
406
407        Returns:
408            Current density [$\mathrm{mA \, cm^{-2}}$].
409        """
410        db_model = self.db_model_vs_voltage(voltage)
411        if abs(db_model.curr_den_vb) < abs(db_model.curr_den_cb):
412            return db_model.curr_den_vb
413        else:
414            return db_model.curr_den_cb
415
416    def power_den_vs_voltage(self, voltage: Real) -> float:
417        r"""Power density vs voltage.
418
419        Args:
420            voltage: Voltage [$\mathrm{V}$].
421
422        Returns:
423            Power density [$\mathrm{mW \, cm^{-2}}$].
424        """
425        return voltage * self.curr_den_vs_voltage(voltage)
426
427    def apply_voltage_sweep(self, voltage_sweep: Sequence[Real, ...]) -> None:
428        r"""Apply voltage sweep."""
429        self._voltage_sweep = np.unique(voltage_sweep).astype(float)
430        self._db_model_sweep = None
431        self._curr_den_sweep = None
432        self._power_den_sweep = None
433        self._efficiency_sweep = None
434
435    def clear_voltage_sweep(self) -> None:
436        r"""Clear voltage sweep."""
437        self.apply_voltage_sweep([])
438
439    def plot_rsv_sp_absorb_vs_energy(
440        self,
441        *,
442        energy_min: Real,
443        energy_max: Real,
444        energy_inc: Real,
445        ax: plt.Axes | None = None,
446    ) -> plt.Figure | None:
447        r"""Plot resolved spectral absorbance vs photon energy.
448
449        Args:
450            energy_min: Photon energy minimum [$\mathrm{eV}$].
451            energy_max: Photon energy maximum [$\mathrm{eV}$].
452            energy_inc: Photon energy increment [$\mathrm{eV}$].
453            ax: Plot axes. If None, new figure and axes are created.
454
455        Returns:
456            Plot figure.
457        """
458        return self.rsv_sp_absorb_ppoly.plot_rsv_sp_absorb_vs_energy(
459            energy_min=energy_min,
460            energy_max=energy_max,
461            energy_inc=energy_inc,
462            ax=ax,
463        )
464
465    def plot_voltage_oc(
466        self,
467        *,
468        ax: plt.Axes | None = None,
469        color: str | None = "k",
470        label: str | None = None,
471    ) -> plt.Figure:
472        r"""Plot open circuit voltage.
473
474        Args:
475            ax: Plot axes. If None, new figure and axes are created.
476            color: Color.
477            label: Label.
478
479        Returns:
480            Plot figure.
481        """
482        if ax is None:
483            fig, ax = plt.subplots(tight_layout=True)
484            ax.set_xlabel(r"Voltage / $\mathrm{V}$")
485        else:
486            fig = ax.get_figure()
487
488        ax.axvline(self.voltage_oc, linestyle=":", color=color, label=label)
489        return fig
490
491    def plot_curr_den_sc(
492        self,
493        *,
494        ax: plt.Axes | None = None,
495        color: str | None = "k",
496        label: str | None = None,
497    ) -> plt.Figure:
498        r"""Plot short circuit current density.
499
500        Args:
501            ax: Plot axes. If None, new figure and axes are created.
502            color: Color.
503            label: Label.
504
505        Returns:
506            Plot figure.
507        """
508        if ax is None:
509            fig, ax = plt.subplots(tight_layout=True)
510            ax.set_ylabel(r"Current density / $\mathrm{mA \cdot cm^{-2}}$")
511        else:
512            fig = ax.get_figure()
513
514        ax.axhline(self.curr_den_sc, linestyle=":", color=color, label=label)
515        return fig
516
517    def plot_voltage_mpp(
518        self,
519        *,
520        ax: plt.Axes | None = None,
521        color: str | None = "k",
522        label: str | None = None,
523    ) -> plt.Figure:
524        r"""Plot maximum power point voltage.
525
526        Args:
527            ax: Plot axes. If None, new figure and axes are created.
528            color: Color.
529            label: Label.
530
531        Returns:
532            Plot figure.
533        """
534        if ax is None:
535            fig, ax = plt.subplots(tight_layout=True)
536            ax.set_xlabel(r"Voltage / $\mathrm{V}$")
537        else:
538            fig = ax.get_figure()
539
540        ax.axvline(self.voltage_mpp, linestyle=":", color=color, label=label)
541        return fig
542
543    def plot_curr_den_mpp(
544        self,
545        *,
546        ax: plt.Axes | None = None,
547        color: str | None = "k",
548        label: str | None = None,
549    ) -> plt.Figure:
550        r"""Plot maximum power point current density.
551
552        Args:
553            ax: Plot axes. If None, new figure and axes are created.
554            color: Color.
555            label: Label.
556
557        Returns:
558            Plot figure.
559        """
560        if ax is None:
561            fig, ax = plt.subplots(tight_layout=True)
562            ax.set_ylabel(r"Current density / $\mathrm{mA \cdot cm^{-2}}$")
563        else:
564            fig = ax.get_figure()
565
566        ax.axhline(self.curr_den_mpp, linestyle=":", color=color, label=label)
567        return fig
568
569    def plot_power_den_mpp(
570        self,
571        *,
572        ax: plt.Axes | None = None,
573        color: str | None = "k",
574        label: str | None = None,
575    ) -> plt.Figure:
576        r"""Plot maximum power point power density.
577
578        Args:
579            ax: Plot axes. If None, new figure and axes are created.
580            color: Color.
581            label: Label.
582
583        Returns:
584            Plot figure.
585        """
586        if ax is None:
587            fig, ax = plt.subplots(tight_layout=True)
588            ax.set_ylabel(r"Power density / $\mathrm{mA \cdot cm^{-2}}$")
589        else:
590            fig = ax.get_figure()
591
592        ax.axhline(self.power_den_mpp, linestyle=":", color=color, label=label)
593        return fig
594
595    def plot_efficiency_mpp(
596        self,
597        *,
598        ax: plt.Axes | None = None,
599        color: str | None = "k",
600        label: str | None = None,
601    ) -> plt.Figure:
602        r"""Plot maximum power point efficiency.
603
604        Args:
605            ax: Plot axes. If None, new figure and axes are created.
606            color: Color.
607            label: Label.
608
609        Returns:
610            Plot figure.
611        """
612        if ax is None:
613            fig, ax = plt.subplots(tight_layout=True)
614            ax.set_ylabel(r"Efficiency / $\mathrm{\%}$")
615        else:
616            fig = ax.get_figure()
617
618        ax.axhline(self.efficiency_mpp, linestyle=":", color=color, label=label)
619        return fig
620
621    def plot_curr_den_vs_voltage(
622        self,
623        *,
624        ax: plt.Axes | None = None,
625        color: str | None = None,
626        label: str | None = None,
627    ) -> plt.Figure:
628        r"""Plot current density vs voltage.
629
630        Args:
631            color: Color.
632            label: Label.
633            ax: Plot axes. If None, new figure and axes are created.
634
635        Returns:
636            Plot figure.
637        """
638        if ax is None:
639            fig, ax = plt.subplots(tight_layout=True)
640            ax.set_xlabel(r"Voltage / $\mathrm{V}$")
641            ax.set_ylabel(r"Current density / $\mathrm{mA \cdot cm^{-2}}$")
642            ax.set_ylim(ceil(self.curr_den_sc / 10) * 10 - 20, 0.0)
643        else:
644            fig = ax.get_figure()
645
646        ax.plot(
647            self.voltage_sweep,
648            self.curr_den_sweep,
649            color=color,
650            label=label,
651        )
652        return fig
653
654    def plot_power_den_vs_voltage(
655        self,
656        *,
657        ax: plt.Axes | None = None,
658        color: str | None = None,
659        label: str | None = None,
660    ) -> plt.Figure:
661        r"""Plot power density vs voltage.
662
663        Args:
664            ax: Plot axes. If None, new figure and axes are created.
665            color: Color.
666            label: Label.
667
668        Returns:
669            Plot figure.
670        """
671        if ax is None:
672            fig, ax = plt.subplots(tight_layout=True)
673            ax.set_xlabel(r"Voltage / $\mathrm{V}$")
674            ax.set_ylabel(r"Power density / $\mathrm{mW \cdot cm^{-2}}$")
675            ax.set_ylim(ceil(self.power_den_mpp / 10) * 10 - 20, 0.0)
676        else:
677            fig = ax.get_figure()
678
679        ax.plot(
680            self.voltage_sweep,
681            self.power_den_sweep,
682            color=color,
683            label=label,
684        )
685        return fig
686
687    def plot_efficiency_vs_voltage(
688        self,
689        *,
690        ax: plt.Axes | None = None,
691        color: str | None = None,
692        label: str | None = None,
693    ) -> plt.Figure:
694        r"""Plot efficiency vs voltage.
695
696        Args:
697            ax: Plot axes. If None, new figure and axes are created.
698            color: Color.
699            label: Label.
700
701        Returns:
702            Plot figure.
703        """
704        if ax is None:
705            fig, ax = plt.subplots(tight_layout=True)
706            ax.set_xlabel(r"Voltage / $\mathrm{V}$")
707            ax.set_ylabel(r"Efficiency / $\mathrm{\%}$")
708            ax.set_ylim(0.0, ceil(self.efficiency_mpp / 10) * 10 + 10)
709        else:
710            fig = ax.get_figure()
711
712        ax.plot(
713            self.voltage_sweep,
714            self.efficiency_sweep,
715            color=color,
716            label=label,
717        )
718        return fig
719
720    def plot_db_model_qty_mpp(
721        self,
722        qty: str,
723        *,
724        ax: plt.Axes | None = None,
725        color: str | None = "k",
726        label: str | None = None,
727    ) -> plt.Figure:
728        r"""Plot maximum power point detailed balance model quantity.
729
730        Args:
731            qty: Quantity, among 'potential_ii', 'potential_vi', 'potential_ic',
732                'potential_vc', 'phot_flux_ii', 'phot_flux_vi', 'phot_flux_ic',
733                'phot_flux_vc', 'curr_den_ib', 'curr_den_vb', and 'curr_den_cb'.
734            ax: Plot axes. If None, new figure and axes are created.
735            color: Color.
736            label: Label.
737
738        Returns:
739            Plot figure.
740        """
741        if qty not in [
742            "potential_ii",
743            "potential_vi",
744            "potential_ic",
745            "potential_vc",
746            "phot_flux_ii",
747            "phot_flux_vi",
748            "phot_flux_ic",
749            "phot_flux_vc",
750            "curr_den_ib",
751            "curr_den_vb",
752            "curr_den_cb",
753        ]:
754            raise ValueError("Quantity not supported!")
755
756        if ax is None:
757            fig, ax = plt.subplots(tight_layout=True)
758            if qty in [
759                "potential_ii",
760                "potential_vi",
761                "potential_ic",
762                "potential_vc",
763            ]:
764                ax.set_ylabel(r"Chemical potential / $\mathrm{eV}$")
765            elif qty in [
766                "phot_flux_ii",
767                "phot_flux_vi",
768                "phot_flux_ic",
769                "phot_flux_vc",
770            ]:
771                ax.set_ylabel(r"Photon flux / $\mathrm{s^{-1} \cdot cm^{-2}}$")
772            elif qty in [
773                "curr_den_ib",
774                "curr_den_vb",
775                "curr_den_cb",
776            ]:
777                ax.set_ylabel(r"Current density / $\mathrm{mA \cdot cm^{-2}}$")
778        else:
779            fig = ax.get_figure()
780
781        qty_value = getattr(self.db_model_mpp, qty)
782        ax.axhline(qty_value, linestyle=":", color=color, label=label)
783        return fig
784
785    def plot_db_model_qty_vs_voltage(
786        self,
787        qty: str,
788        *,
789        ax: plt.Axes | None = None,
790        color: str | None = None,
791        label: str | None = None,
792    ) -> plt.Figure:
793        r"""Plot detailed balance model quantity vs voltage.
794
795        Args:
796            qty: Quantity, among 'potential_ii', 'potential_vi', 'potential_ic',
797                'potential_vc', 'phot_flux_ii', 'phot_flux_vi', 'phot_flux_ic',
798                'phot_flux_vc', 'curr_den_ib', 'curr_den_vb', and 'curr_den_cb'.
799            ax: Plot axes. If None, new figure and axes are created.
800
801        Returns:
802            Plot figure.
803        """
804        if qty not in [
805            "potential_ii",
806            "potential_vi",
807            "potential_ic",
808            "potential_vc",
809            "phot_flux_ii",
810            "phot_flux_vi",
811            "phot_flux_ic",
812            "phot_flux_vc",
813            "curr_den_ib",
814            "curr_den_vb",
815            "curr_den_cb",
816        ]:
817            raise ValueError("Quantity not supported!")
818
819        if ax is None:
820            fig, ax = plt.subplots(tight_layout=True)
821            ax.set_xlabel(r"Voltage / $\mathrm{V}$")
822            if qty in [
823                "potential_ii",
824                "potential_vi",
825                "potential_ic",
826                "potential_vc",
827            ]:
828                ax.set_ylabel(r"Chemical potential / $\mathrm{eV}$")
829            elif qty in [
830                "phot_flux_ii",
831                "phot_flux_vi",
832                "phot_flux_ic",
833                "phot_flux_vc",
834            ]:
835                ax.set_ylabel(r"Photon flux / $\mathrm{s^{-1} \cdot cm^{-2}}$")
836            elif qty in [
837                "curr_den_ib",
838                "curr_den_vb",
839                "curr_den_cb",
840            ]:
841                ax.set_ylabel(r"Current density / $\mathrm{mA \cdot cm^{-2}}$")
842        else:
843            fig = ax.get_figure()
844
845        qty_values = np.array(
846            [getattr(db_model, qty) for db_model in self.db_model_sweep],
847            dtype=float,
848        )
849        ax.plot(self.voltage_sweep, qty_values, color=color, label=label)
850        return fig
851
852    @classmethod
853    def sq1961(
854        cls,
855        *,
856        bandgap_vc: Real,
857        bandwidth_vc: Real,
858        temperature: Real,
859        concentration: Real,
860    ) -> Self | None:
861        r"""Shockley-Queisser solar cell at given temperature and concentration.
862
863        Note:
864            See https://dx.doi.org/10.1063%2F1.1736034 for details.
865
866        Args:
867            bandgap_vc: Valence-conduction optical band gap [$\mathrm{eV}$].
868            bandwidth_vc: Valence-conduction optical band width [$\mathrm{eV}$].
869            temperature: Temperature [$\mathrm{K}$].
870            concentration: Sunlight concentration factor.
871
872        Returns:
873            Applied solar cell.
874        """
875        rsv_sp_absorb_ppoly = ResolvedSpectralAbsorbancePPoly.sq1961(
876            bandgap_vc=bandgap_vc,
877            bandwidth_vc=bandwidth_vc,
878        )
879        if rsv_sp_absorb_ppoly is None:
880            return None
881        else:
882            return cls(
883                rsv_sp_absorb_ppoly,
884                temperature=temperature,
885                concentration=concentration,
886            )
887
888    @classmethod
889    def lh2008(
890        cls,
891        *,
892        bandgap_vi: Real,
893        bandgap_ic: Real,
894        bandgap_vc: Real,
895        bandwidth_ii: Real,
896        bandwidth_vi: Real,
897        bandwidth_ic: Real,
898        bandwidth_vc: Real,
899        variant: str,
900        temperature: Real,
901        concentration: Real,
902    ) -> Self | None:
903        r"""Levi-Honsberg solar cell at given temperature and concentration.
904
905        Note:
906            See http://dx.doi.org/10.1103%2FPhysRevB.78.165122 for details.
907
908        Args:
909            bandgap_vi: Valence-intermediate optical band gap [$\mathrm{eV}$].
910            bandgap_ic: Intermediate-conduction optical band gap
911                [$\mathrm{eV}$].
912            bandgap_vc: Valence-conduction optical band gap
913                [$\mathrm{eV}$].
914            bandwidth_ii: Intermediate-intermediate optical band width
915                [$\mathrm{eV}$].
916            bandwidth_vi: Valence-intermediate optical band width
917                [$\mathrm{eV}$].
918            bandwidth_ic: Intermediate-conduction optical band width
919                [$\mathrm{eV}$].
920            bandwidth_vc: Valence-conduction optical band width
921                [$\mathrm{eV}$].
922            variant: Model variant ('equal', 'inter', or 'intra').
923            temperature: Temperature [$\mathrm{K}$].
924            concentration: Sunlight concentration factor.
925
926        Returns:
927            Applied solar cell.
928        """
929        rsv_sp_absorb_ppoly = ResolvedSpectralAbsorbancePPoly.lh2008(
930            bandgap_vi=bandgap_vi,
931            bandgap_ic=bandgap_ic,
932            bandgap_vc=bandgap_vc,
933            bandwidth_ii=bandwidth_ii,
934            bandwidth_vi=bandwidth_vi,
935            bandwidth_ic=bandwidth_ic,
936            bandwidth_vc=bandwidth_vc,
937            variant=variant,
938        )
939        if rsv_sp_absorb_ppoly is None:
940            return None
941        else:
942            return cls(
943                rsv_sp_absorb_ppoly,
944                temperature=temperature,
945                concentration=concentration,
946            )
947
948    @classmethod
949    def from_data(
950        cls,
951        energy: Sequence[Real, ...],
952         rsv_sp_absorb: Mapping[str, Sequence[Real, ...]],
953        *,
954        temperature: Real,
955        concentration: Real,
956    ) -> Self | None:
957        r"""Solar cell at given temperature and concentration from data.
958
959        Args:
960            energy: Photon energy values [$\mathrm{eV}$].
961            rsv_sp_absorb: Mapping of transition labels ('ii', 'vi', 'ic', 'vc')
962                into corresponding spectral absorbance values.
963            temperature: Temperature [$\mathrm{K}$].
964            concentration: Sunlight concentration factor.
965
966        Returns:
967            Applied solar cell.
968        """
969        rsv_sp_absorb_ppoly = ResolvedSpectralAbsorbancePPoly.from_data(
970            energy,
971            rsv_sp_absorb,
972        )
973        if rsv_sp_absorb_ppoly is None:
974            return None
975        else:
976            return cls(
977                rsv_sp_absorb_ppoly,
978                temperature=temperature,
979                concentration=concentration,
980            )