diff --git a/docs/api/models.md b/docs/api/models.md index b01d26e..687621b 100644 --- a/docs/api/models.md +++ b/docs/api/models.md @@ -18,6 +18,42 @@ Concrete implementations of cell, converter, degradation, and thermal models. ::: simses.model.converter.fix_efficiency.FixedEfficiency +### Notton + +::: simses.model.converter.notton.Notton + +### AsymmetricNotton + +::: simses.model.converter.notton.AsymmetricNotton + +### NottonType1 + +::: simses.model.converter.notton.NottonType1 + +### NottonType2 + +::: simses.model.converter.notton.NottonType2 + +### NottonType3 + +::: simses.model.converter.notton.NottonType3 + +### Rampinelli + +::: simses.model.converter.rampinelli.Rampinelli + +### BonfiglioliTL4Q + +::: simses.model.converter.bonfiglioli.BonfiglioliTL4Q + +### BonfiglioliTL4QFieldData + +::: simses.model.converter.bonfiglioli.BonfiglioliTL4QFieldData + +### SungrowSC1000TL + +::: simses.model.converter.sungrow.SungrowSC1000TL + ### SinamicsS120 ::: simses.model.converter.sinamics.SinamicsS120 diff --git a/docs/guides/cell-models.md b/docs/guides/cell-models.md index 8c72de1..2cc9749 100644 --- a/docs/guides/cell-models.md +++ b/docs/guides/cell-models.md @@ -13,7 +13,7 @@ All values are per cell, taken directly from the model constructors. ## `SonyLFP` -A small-format cylindrical LFP cell (Sony/Murata US26650FTC1) with a flat OCV plateau, strong cycle life, and a notably asymmetric C-rate (1.0 charge, 6.6 discharge). OCV, hysteresis, and the entropic coefficient are 1-D lookups in SOC; internal resistance is a 2-D lookup over (SOC, T) with separate charge and discharge tables. This is the only cell in the library that ships a default degradation pair — [Naumann 2018 calendar](https://doi.org/10.1016/j.est.2018.01.019) and [Naumann 2020 cyclic](https://doi.org/10.1016/j.jpowsour.2019.227666) — so multi-year stationary-storage runs with aging work out of the box. +A small-format cylindrical LFP cell (Sony/Murata US26650FTC1) with a flat OCV plateau, strong cycle life, and a notably asymmetric C-rate (1.0 charge, 6.6 discharge). OCV, hysteresis, and the entropic coefficient are 1-D lookups in SOC; internal resistance is a 2-D lookup over (SOC, T) with separate charge and discharge tables. Ships a default degradation pair — [Naumann 2018 calendar](https://doi.org/10.1016/j.est.2018.01.019) and [Naumann 2020 cyclic](https://doi.org/10.1016/j.jpowsour.2019.227666) — so multi-year stationary-storage runs with aging work out of the box. Additional source: Naumann, M. *Techno-economic evaluation of stationary lithium-ion energy storage systems with special consideration of aging*. PhD Thesis, Technical University Munich, 2018. @@ -58,4 +58,4 @@ Writing a new cell model means subclassing `CellType` and implementing `open_cir - [Battery concept](../concepts/battery.md) — how `CellType` composes into `Battery` and scales to pack level. - [`CellType` API reference](../api/battery.md#cell-interface). -- [Models API reference](../api/models.md) — the `SonyLFP` and `Samsung94AhNMC` classes. +- [Models API reference](../api/models.md) — the shipped cell classes. diff --git a/docs/guides/converter-models.md b/docs/guides/converter-models.md index 8e3fe95..24e7209 100644 --- a/docs/guides/converter-models.md +++ b/docs/guides/converter-models.md @@ -1,16 +1,30 @@ # Choosing a Converter Model -simses ships three built-in AC/DC converter loss models. All three implement the [`ConverterLossModel`][simses.converter.converter.ConverterLossModel] protocol and operate on normalised power (p.u. of the converter's rated `max_power`). +simses ships ten built-in AC/DC converter loss models, split into two categories. **Fit families** (`Notton`, `AsymmetricNotton`, `Rampinelli`) are generic parametric forms that require explicit coefficients; the `NottonTypeN` subclasses are presets of published coefficients. **Product models** (`BonfiglioliTL4Q`, `BonfiglioliTL4QFieldData`, `SungrowSC1000TL`, `SinamicsS120`, `SinamicsS120Fit`) are specific manufacturer hardware with baked-in coefficients. All implement the [`ConverterLossModel`][simses.converter.converter.ConverterLossModel] protocol and operate on normalised power (p.u. of the converter's rated `max_power`). ## Comparison -| Model | Loss shape | Data source | Direction symmetry | Constructor args | -|---|---|---|---|---| -| [`FixedEfficiency`](#fixedefficiency) | Constant η per direction | User-supplied | Symmetric by default; asymmetric via `(charge, discharge)` tuple | `eff: float \| tuple[float, float]` | -| [`SinamicsS120`](#sinamicss120) | 101-point lookup built from measured efficiency curves | Schimpe et al. 2018 | Symmetric by default; asymmetric via `use_discharging_curve=True` | `use_discharging_curve: bool = False` | -| [`SinamicsS120Fit`](#sinamicss120fit) | Closed-form fit `loss(p) = k₀(1 − e^(−m₀|p|)) + k₁|p| + k₂|p|²` | Least-squares fit to the same Schimpe 2018 data | Symmetric | (none) | +### Fit families (parametric, require coefficients) -At runtime all three evaluate to linear interpolation on a 101-point internal table — the distinction is how those points were generated. +| Model | Loss shape | Constructor args | +|---|---|---| +| [`Notton`](#notton) | `η(p) = p / (p + P0 + K·p²)`, symmetric | `P0: float, K: float` | +| [`AsymmetricNotton`](#asymmetricnotton) | Notton form with independent charge and discharge coefficients | `charge: (P0, K), discharge: (P0, K)` | +| [`Rampinelli`](#rampinelli) | `η(p) = p / (p + K0 + K1·p + K2·p²)`, symmetric | `K0: float, K1: float, K2: float` | +| [`NottonType1`](#nottontypen), [`NottonType2`](#nottontypen), [`NottonType3`](#nottontypen) | Three published inverter presets from Notton et al. 2010 | (none — no-arg subclasses of `Notton`) | + +### Product models (specific hardware, no-arg constructors) + +| Model | Inherits from | Data source | Direction symmetry | +|---|---|---|---| +| [`FixedEfficiency`](#fixedefficiency) | — | User-supplied | Symmetric by default; asymmetric via `(charge, discharge)` tuple | +| [`BonfiglioliTL4Q`](#bonfigliolitl4q) | `Notton` | F. Müller thesis — RPS TL-4Q datasheet | Symmetric | +| [`BonfiglioliTL4QFieldData`](#bonfigliolitl4qfielddata) | `AsymmetricNotton` | F. Müller thesis — FCR field data | Asymmetric | +| [`SungrowSC1000TL`](#sungrowsc1000tl) | `AsymmetricNotton` | F. Müller thesis — FCR field data | Asymmetric | +| [`SinamicsS120`](#sinamicss120) | — | Schimpe et al. 2018 (measured) | Symmetric by default; asymmetric via `use_discharging_curve=True` | +| [`SinamicsS120Fit`](#sinamicss120fit) | — | Schimpe et al. 2018 (parametric fit) | Symmetric | + +At runtime all loss models except `FixedEfficiency` evaluate to linear interpolation on a 201-point internal table (101 per direction, mirrored about zero) — the distinction is how those points were generated. ## `FixedEfficiency` @@ -27,6 +41,134 @@ converter = Converter( ) ``` +## `Notton` + +A generic parametric PV-inverter loss family with efficiency `η(p) = p / (p + P0 + K·p²)`, where `p` is the magnitude of normalised power. Symmetric about zero. Use this when you have a Notton-form fit to measured data, or when you want a physically reasonable two-parameter baseline. + +For custom asymmetric ch/dch use [`AsymmetricNotton`](#asymmetricnotton). For the three published inverter presets see [`NottonTypeN`](#nottontypen) below. + +Source: Notton, G., Lazarov, V., Stoyanov, L. *Optimal sizing of a grid-connected PV system for various PV module technologies and inclinations, inverter efficiency characteristics and locations*, [Renewable Energy 35(2) (2010) 541–554](https://doi.org/10.1016/j.renene.2009.07.013). + +```python +from simses.converter import Converter +from simses.model.converter.notton import Notton + +converter = Converter( + loss_model=Notton(P0=0.0072, K=0.0345), + max_power=100_000, + storage=battery, +) +``` + +## `AsymmetricNotton` + +Notton-form fit with independent charge and discharge parameter sets. Each direction takes its own `(P0, K)` pair — useful for fitting converters whose measured efficiency curves differ between charging and discharging. + +```python +from simses.converter import Converter +from simses.model.converter.notton import AsymmetricNotton + +converter = Converter( + loss_model=AsymmetricNotton( + charge=(0.0072, 0.0345), + discharge=(0.005, 0.018), + ), + max_power=100_000, + storage=battery, +) +``` + +## `NottonTypeN` + +Three published inverter presets from Notton et al. 2010, provided as no-arg subclasses of `Notton` for convenience: + +- `NottonType1` — `P0 = 0.0145, K = 0.0437` +- `NottonType2` — `P0 = 0.0072, K = 0.0345` +- `NottonType3` — `P0 = 0.0088, K = 0.1149` + +```python +from simses.converter import Converter +from simses.model.converter.notton import NottonType2 + +converter = Converter( + loss_model=NottonType2(), + max_power=100_000, + storage=battery, +) +``` + +## `Rampinelli` + +A three-parameter generalisation of the Notton form: `η(p) = p / (p + K0 + K1·p + K2·p²)`. The extra linear term lets the fit capture a wider range of measured efficiency curves — useful when a two-parameter Notton fit leaves a visible residual at mid-power. + +Source: Rampinelli, G. A., Krenzinger, A., Chenlo Romero, F. *Mathematical models for efficiency of inverters used in grid connected photovoltaic systems*, [Renewable and Sustainable Energy Reviews 34 (2014) 578–587](https://doi.org/10.1016/j.rser.2014.03.047). + +```python +from simses.converter import Converter +from simses.model.converter.rampinelli import Rampinelli + +converter = Converter( + loss_model=Rampinelli(K0=0.003, K1=0.014, K2=0.003), + max_power=100_000, + storage=battery, +) +``` + +## `BonfiglioliTL4Q` + +Bonfiglioli RPS TL-4Q inverter parameterised from the manufacturer datasheet — a `Notton` subclass with symmetric coefficients `P0 = 0.0072, K = 0.034`. + +See [`BonfiglioliTL4QFieldData`](#bonfigliolitl4qfielddata) for the asymmetric variant parameterised from FCR field data. + +Source: F. Müller (M.Sc. thesis, TUM) — Notton fit of the [Bonfiglioli RPS TL-4Q datasheet](http://www.docsbonfiglioli.com/pdf_documents/catalogue/VE_CAT_RTL-4Q_STD_ENG-ITA_R00_5_WEB.pdf). + +```python +from simses.converter import Converter +from simses.model.converter.bonfiglioli import BonfiglioliTL4Q + +converter = Converter( + loss_model=BonfiglioliTL4Q(), + max_power=100_000, + storage=battery, +) +``` + +## `BonfiglioliTL4QFieldData` + +Bonfiglioli RPS TL-4Q inverter parameterised from frequency containment reserve (FCR) battery-system field measurements — an `AsymmetricNotton` subclass with distinct charge and discharge coefficients. Reflects real deployment losses including auxiliary consumption that the datasheet curves do not capture. Charge: `P0 = 0.00195, K = 0.01349`. Discharge: `P0 = 0.00292, K = 0.03609`. + +Source: F. Müller (M.Sc. thesis, TUM) — field fit on FCR BESS deployments of the Bonfiglioli RPS TL-4Q. + +```python +from simses.converter import Converter +from simses.model.converter.bonfiglioli import BonfiglioliTL4QFieldData + +converter = Converter( + loss_model=BonfiglioliTL4QFieldData(), + max_power=100_000, + storage=battery, +) +``` + +## `SungrowSC1000TL` + +Sungrow SC1000TL inverter, an `AsymmetricNotton` subclass backed by field data from an FCR battery system. Charge: `P0 = 0.007701864, K = 0.017290859`. Discharge: `P0 = 0.005511580, K = 0.018772838`. + +The original thesis also characterised Rampinelli and rational-form fits of the same measurements; the Notton fit was the default in the legacy simses implementation and is the one ported here. + +Source: F. Müller (M.Sc. thesis, TUM) — field fit on a Sungrow SC1000TL inverter. + +```python +from simses.converter import Converter +from simses.model.converter.sungrow import SungrowSC1000TL + +converter = Converter( + loss_model=SungrowSC1000TL(), + max_power=1_000_000, # 1 MW rated + storage=battery, +) +``` + ## `SinamicsS120` Lookup-table model built from measured efficiency curves for the Siemens Sinamics S120, a common utility-scale drive. The bundled CSV carries 1001 sample points, re-sampled down to 101 at construction. The measurement splits into `Charging` and `Discharging` columns that differ by a mean of 0.23 % and a maximum of 0.40 %. By default the charging curve is mirrored onto the discharge branch so the model is symmetric about zero; set `use_discharging_curve=True` to preserve the measured asymmetry. @@ -69,4 +211,4 @@ Writing a new converter loss model means implementing `ac_to_dc(power_norm)` and - [Converter concept](../concepts/converter.md) — how `ConverterLossModel` composes into `Converter`, the two-pass resolution, and sign handling at the AC/DC boundary. - [`Converter` API reference](../api/converter.md). -- [Models API reference](../api/models.md) — the three shipped loss models. +- [Models API reference](../api/models.md) — all ten shipped loss models. diff --git a/docs/guides/extending-cells.md b/docs/guides/extending-cells.md index 9195c1e..8e40954 100644 --- a/docs/guides/extending-cells.md +++ b/docs/guides/extending-cells.md @@ -3,7 +3,7 @@ How to implement a new cell chemistry as a `CellType` subclass, drop it into a `Battery`, and plug it into the existing test harness. !!! info "Who this is for" - Researchers or engineers who want to simulate a cell not covered by the shipped `SonyLFP` / `Samsung94AhNMC`. If you just need to pick between the existing models, see [Choosing a Cell Model](cell-models.md) instead. For the architectural picture of how `CellType` and `Battery` interact, see [Battery concept](../concepts/battery.md#battery-and-celltype). + Researchers or engineers who want to simulate a cell not covered by the shipped models (`SonyLFP`, `Samsung94AhNMC`). If you just need to pick between the existing models, see [Choosing a Cell Model](cell-models.md) instead. For the architectural picture of how `CellType` and `Battery` interact, see [Battery concept](../concepts/battery.md#battery-and-celltype). ## The contract diff --git a/src/simses/model/converter/bonfiglioli.py b/src/simses/model/converter/bonfiglioli.py new file mode 100644 index 0000000..d92eaf3 --- /dev/null +++ b/src/simses/model/converter/bonfiglioli.py @@ -0,0 +1,40 @@ +from simses.model.converter.notton import AsymmetricNotton, Notton + + +class BonfiglioliTL4Q(Notton): + """Bonfiglioli RPS TL-4Q converter — datasheet parameterisation. + + Symmetric Notton-form fit with ``P0 = 0.0072, K = 0.034`` measured + under manufacturer datasheet conditions. + + See :class:`BonfiglioliTL4QFieldData` for the asymmetric variant + parameterised from FCR field data. + + Source: F. Müller (M.Sc. thesis, TUM) — Notton fit of the + `Bonfiglioli RPS TL-4Q datasheet + `_. + """ + + def __init__(self) -> None: + super().__init__(P0=0.0072, K=0.034) + + +class BonfiglioliTL4QFieldData(AsymmetricNotton): + """Bonfiglioli RPS TL-4Q converter — FCR field-data parameterisation. + + Asymmetric Notton-form fit measured on frequency containment reserve + (FCR) battery systems; reflects real deployment losses including + auxiliary consumption. Charge: ``P0 = 0.00195, K = 0.01349``. + Discharge: ``P0 = 0.00292, K = 0.03609``. + + See :class:`BonfiglioliTL4Q` for the symmetric datasheet variant. + + Source: F. Müller (M.Sc. thesis, TUM) — field fit on FCR BESS + deployments of the Bonfiglioli RPS TL-4Q. + """ + + def __init__(self) -> None: + super().__init__( + charge=(0.00195, 0.01349), + discharge=(0.00292, 0.03609), + ) diff --git a/src/simses/model/converter/notton.py b/src/simses/model/converter/notton.py new file mode 100644 index 0000000..1c49415 --- /dev/null +++ b/src/simses/model/converter/notton.py @@ -0,0 +1,124 @@ +import numpy as np + +from simses.interpolation import interp1d_scalar + + +def _notton_lut(P0_ch: float, K_ch: float, P0_dch: float, K_dch: float) -> tuple[list[float], list[float]]: + """Build a 201-point input/output LUT for a Notton-form loss model. + + Efficiency follows ``η(p) = p / (p + P0 + K·p²)`` on each direction + independently. The LUT stitches charge (0 → 1) and discharge (−1 → 0) + branches into a single monotonic curve so that ``interp1d_scalar`` + can invert it exactly. + """ + p = np.linspace(0, 1, 101) + + # Charge branch (AC -> DC): efficiency reduces DC output; P_dc = P_ac · η. + eff_ch = p[1:] / (p[1:] + P0_ch + K_ch * p[1:] ** 2) + input_ch = p + output_ch = np.zeros_like(p) + output_ch[1:] = p[1:] * eff_ch + + # Discharge branch (DC -> AC): battery supplies the loss; P_dc = P_ac / η + # (i.e. |DC| > |AC|). With input_dch = −p, output_dch = input_dch / η. + eff_dch = p[1:] / (p[1:] + P0_dch + K_dch * p[1:] ** 2) + input_dch = -p + output_dch = np.zeros_like(p) + output_dch[1:] = -p[1:] / eff_dch + + inp = np.hstack((input_dch[1:][::-1], 0.0, input_ch[1:])).tolist() + out = np.hstack((output_dch[1:][::-1], 0.0, output_ch[1:])).tolist() + return inp, out + + +class Notton: + """Generic parametric PV-inverter loss family — symmetric form. + + Efficiency curve of the form ``η(p) = p / (p + P0 + K·p²)`` where + ``p`` is the magnitude of normalised power (p.u. of the converter's + rated max power). Same coefficients apply to charge and discharge. + + For the three published inverter presets see :class:`NottonType1`, + :class:`NottonType2`, :class:`NottonType3`. For Notton-form fits + with per-direction coefficients see :class:`AsymmetricNotton`. + + Source: Notton, G.; Lazarov, V.; Stoyanov, L. (2010). *Optimal sizing + of a grid-connected PV system for various PV module technologies and + inclinations, inverter efficiency characteristics and locations.* + Renewable Energy 35(2) 541–554, doi:10.1016/j.renene.2009.07.013. + """ + + def __init__(self, P0: float, K: float) -> None: + """ + Args: + P0: No-load loss coefficient (p.u.). + K: Quadratic-loss coefficient (p.u.). + """ + self._inp, self._out = _notton_lut(P0, K, P0, K) + + def ac_to_dc(self, power_ac: float) -> float: + return interp1d_scalar(power_ac, self._inp, self._out) + + def dc_to_ac(self, power_dc: float) -> float: + return interp1d_scalar(power_dc, self._out, self._inp) + + +class AsymmetricNotton: + """Notton-form loss family with per-direction coefficients. + + Same efficiency law as :class:`Notton` but with independent charge + and discharge parameter sets — each a ``(P0, K)`` pair. Used by + manufacturer product models whose measured efficiency differs + between charging and discharging (e.g. :class:`BonfiglioliTL4QFieldData`, + :class:`SungrowSC1000TL`). + """ + + def __init__( + self, + charge: tuple[float, float], + discharge: tuple[float, float], + ) -> None: + """ + Args: + charge: ``(P0, K)`` coefficients for the charge branch. + discharge: ``(P0, K)`` coefficients for the discharge branch. + """ + P0_ch, K_ch = charge + P0_dch, K_dch = discharge + self._inp, self._out = _notton_lut(P0_ch, K_ch, P0_dch, K_dch) + + def ac_to_dc(self, power_ac: float) -> float: + return interp1d_scalar(power_ac, self._inp, self._out) + + def dc_to_ac(self, power_dc: float) -> float: + return interp1d_scalar(power_dc, self._out, self._inp) + + +class NottonType1(Notton): + """Notton Type-1 inverter preset (``P0 = 0.0145, K = 0.0437``). + + Source: Notton et al. 2010, Renewable Energy 35(2) 541–554. + """ + + def __init__(self) -> None: + super().__init__(P0=0.0145, K=0.0437) + + +class NottonType2(Notton): + """Notton Type-2 inverter preset (``P0 = 0.0072, K = 0.0345``). + + Source: Notton et al. 2010, Renewable Energy 35(2) 541–554. + """ + + def __init__(self) -> None: + super().__init__(P0=0.0072, K=0.0345) + + +class NottonType3(Notton): + """Notton Type-3 inverter preset (``P0 = 0.0088, K = 0.1149``). + + Source: Notton et al. 2010, Renewable Energy 35(2) 541–554. + """ + + def __init__(self) -> None: + super().__init__(P0=0.0088, K=0.1149) diff --git a/src/simses/model/converter/rampinelli.py b/src/simses/model/converter/rampinelli.py new file mode 100644 index 0000000..d012204 --- /dev/null +++ b/src/simses/model/converter/rampinelli.py @@ -0,0 +1,50 @@ +import numpy as np + +from simses.interpolation import interp1d_scalar + + +class Rampinelli: + """Generic parametric PV-inverter loss family. + + Efficiency curve of the form + ``η(p) = p / (p + K0 + K1·p + K2·p²)`` + where ``p`` is the magnitude of normalised power (p.u. of the + converter's rated max power). Three-parameter extension of the + Notton form — the extra linear term lets the fit capture a wider + range of measured efficiency curves. Symmetric about zero. The fit + is sampled at 201 points (101 per direction, mirrored about zero) + at construction and interpolated at runtime, so ``ac_to_dc`` and + ``dc_to_ac`` remain numerical inverses of each other. + + Source: Rampinelli, G. A.; Krenzinger, A.; Chenlo Romero, F. (2014). + *Mathematical models for efficiency of inverters used in grid + connected photovoltaic systems.* Renewable and Sustainable Energy + Reviews 34, 578–587, doi:10.1016/j.rser.2014.03.047. + """ + + def __init__(self, K0: float, K1: float, K2: float) -> None: + """ + Args: + K0: No-load loss coefficient (p.u.). + K1: Linear loss coefficient (p.u.). + K2: Quadratic loss coefficient (p.u.). + """ + p = np.linspace(0, 1, 101) + eff = np.zeros_like(p) + eff[1:] = p[1:] / (p[1:] + K0 + K1 * p[1:] + K2 * p[1:] ** 2) + + input_ch = p + output_ch = input_ch * eff + + input_dch = -p + output_dch = np.zeros_like(p) + output_dch[1:] = input_dch[1:] / eff[1:] + + self._inp = np.hstack((input_dch[1:][::-1], 0.0, input_ch[1:])).tolist() + self._out = np.hstack((output_dch[1:][::-1], 0.0, output_ch[1:])).tolist() + + def ac_to_dc(self, power_ac: float) -> float: + return interp1d_scalar(power_ac, self._inp, self._out) + + def dc_to_ac(self, power_dc: float) -> float: + return interp1d_scalar(power_dc, self._out, self._inp) diff --git a/src/simses/model/converter/sungrow.py b/src/simses/model/converter/sungrow.py new file mode 100644 index 0000000..f4c6d2a --- /dev/null +++ b/src/simses/model/converter/sungrow.py @@ -0,0 +1,22 @@ +from simses.model.converter.notton import AsymmetricNotton + + +class SungrowSC1000TL(AsymmetricNotton): + """Sungrow SC1000TL converter — FCR field-data parameterisation. + + Asymmetric Notton-form fit, backed by field data from a frequency + containment reserve storage system. Charge: ``P0 = 0.007701864, + K = 0.017290859``. Discharge: ``P0 = 0.005511580, K = 0.018772838``. + + Source: field fit by F. Müller (M.Sc. thesis, TUM) on a Sungrow + SC1000TL inverter deployed in an FCR BESS. The thesis also provides + Rampinelli and rational-form fits of the same dataset; the Notton + fit was the configured default in the legacy simses implementation + and is the one reproduced here. + """ + + def __init__(self) -> None: + super().__init__( + charge=(0.007701864, 0.017290859), + discharge=(0.005511580, 0.018772838), + ) diff --git a/tests/test_converter_models.py b/tests/test_converter_models.py index 7968a39..834c0e2 100644 --- a/tests/test_converter_models.py +++ b/tests/test_converter_models.py @@ -10,8 +10,12 @@ import pytest +from simses.model.converter.bonfiglioli import BonfiglioliTL4Q, BonfiglioliTL4QFieldData from simses.model.converter.fix_efficiency import FixedEfficiency +from simses.model.converter.notton import NottonType1, NottonType2 +from simses.model.converter.rampinelli import Rampinelli from simses.model.converter.sinamics import SinamicsS120, SinamicsS120Fit +from simses.model.converter.sungrow import SungrowSC1000TL # --------------------------------------------------------------------------- @@ -34,6 +38,30 @@ class ConverterModelSpec: name="FixedEfficiency_Asymmetric", factory=lambda: FixedEfficiency((0.96, 0.94)), ), + ConverterModelSpec( + name="NottonType2", + factory=NottonType2, + ), + ConverterModelSpec( + name="NottonType1", + factory=NottonType1, + ), + ConverterModelSpec( + name="Rampinelli", + factory=lambda: Rampinelli(0.003407887, 0.013809826, 0.003155305), + ), + ConverterModelSpec( + name="BonfiglioliTL4Q", + factory=BonfiglioliTL4Q, + ), + ConverterModelSpec( + name="BonfiglioliTL4QFieldData", + factory=BonfiglioliTL4QFieldData, + ), + ConverterModelSpec( + name="SungrowSC1000TL", + factory=SungrowSC1000TL, + ), ConverterModelSpec( name="SinamicsS120", factory=SinamicsS120,