shepherd-core 2025.6.4__py3-none-any.whl → 2025.10.1__py3-none-any.whl

shepherd_core/data_models/content/virtual_storage_config.py

@@ -0,0 +1,426 @@
+"""Generalized virtual energy storage data models (config).
+
+Additions in near future:
+- TODO: DC Bias to improve Capacitor-behavior, p_VOC / LuT
+
+Possible Extensions:
+- scale cell-count (determine how to change parameters) as
+    2 cell Lipo or 2 cell lead would be advantageous
+- add temperature-component?
+
+"""
+
+import math
+import sys
+from collections.abc import Sequence
+from datetime import timedelta
+from typing import Annotated
+from typing import Any
+
+from annotated_types import Ge
+from annotated_types import Gt
+from annotated_types import Le
+from pydantic import Field
+from pydantic import NonNegativeFloat
+from pydantic import PositiveFloat
+from pydantic import model_validator
+from pydantic import validate_call
+from typing_extensions import Self
+
+from shepherd_core.config import config
+from shepherd_core.data_models.base.content import ContentModel
+from shepherd_core.data_models.base.shepherd import ShpModel
+from shepherd_core.logger import log
+from shepherd_core.testbed_client import tb_client
+
+soc_t = Annotated[float, Ge(0.0), Le(1.0)]
+# TODO: adapt V_max in vsrc,
+# TODO: do we need to set initial voltage, or is SoC ok? add V_OC_to_SoC()
+
+
+class VirtualStorageConfig(ContentModel, title="Config for the virtual energy storage"):
+    """KiBaM Battery model based on two papers.
+
+    Model An Accurate Electrical Battery Model Capable
+        of Predicting Runtime and I-V Performance
+    https://rincon-mora.gatech.edu/publicat/jrnls/tec05_batt_mdl.pdf
+
+    A Hybrid Battery Model Capable of Capturing Dynamic Circuit
+        Characteristics and Nonlinear Capacity Effects
+    https://digitalcommons.unl.edu/cgi/viewcontent.cgi?article=1210&context=electricalengineeringfacpub
+    """
+
+    SoC_init: soc_t = 0.8
+    """ ⤷ State of Charge that is available when emulation starts.
+    Allows a proper / fast startup.
+    """
+
+    q_As: PositiveFloat
+    """ ⤷ Capacity (electrical charge) of Storage."""
+    p_VOC: Annotated[Sequence[float], Field(min_length=6, max_length=6)] = [0, 0, 0, 1, 0, 0]
+    """ ⤷ Parameters for V_OC-Mapping
+        - direct SOC-Mapping by default
+        - named a0 to a5 in paper
+        """
+    p_Rs: Annotated[Sequence[float], Field(min_length=6, max_length=6)] = [0, 0, 0, 0, 0, 0]
+    """ ⤷ Parameters for series-resistance
+        - no resistance set by default
+        - named b0 to b5 in paper
+        """
+    p_RtS: Annotated[Sequence[float], Field(min_length=3, max_length=3)] = [0, 0, 0]
+    """ ⤷ Parameters for R_transient_S (short-term),
+        - no transient active by default
+        - named c0 to c2 in paper
+        """
+    p_CtS: Annotated[Sequence[float], Field(min_length=3, max_length=3)] = [0, 0, 0]
+    """ ⤷ Parameters for C_transient_S (short-term)
+        - no transient active by default
+        - named d0 to d2 in paper
+        """
+    p_RtL: Annotated[Sequence[float], Field(min_length=3, max_length=3)] = [0, 0, 0]
+    """ ⤷ Parameters for R_transient_L (long-term)
+        - no transient active by default
+        - named e0 to e2 in paper
+        """
+    p_CtL: Annotated[Sequence[float], Field(min_length=3, max_length=3)] = [0, 0, 0]
+    """ ⤷ Parameters for C_transient_L (long-term)
+        - no transient active by default
+        - named f0 to f2 in paper
+        """
+
+    p_rce: Annotated[float, Gt(0), Le(1.0)] = 1.0
+    """ ⤷ Parameter for rate capacity effect
+        - Set to 1 to disregard
+        - named c in paper
+        """
+    kdash: PositiveFloat = sys.float_info.min  # TODO: use k directly?
+    """ ⤷ Parameter for rate capacity effect
+        - temporary component of rate capacity effect, valve in KiBaM (eq 17)
+        - k' = k/c(1-c),
+        """
+
+    R_leak_Ohm: PositiveFloat = sys.float_info.max
+    """ ⤷ Parameter for self discharge (custom extension)
+        - effect is often very small, mostly relevant for some capacitors
+        """
+
+    @classmethod
+    @validate_call
+    def lipo(
+        cls,
+        q_mAh: PositiveFloat,  # TODO: charge is more correct
+        SoC_init: soc_t | None = None,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> Self:
+        """Modeled after the PL-383562 2C Polymer Lithium-ion Battery.
+
+        Nominal Voltage     3.7 V
+        Nominal Capacity    860 mAh
+        Discharge Cutoff    3.0 V
+        Charge Cutoff       4.2 V
+        Max Discharge       2 C / 1.72 A
+        https://www.batteryspace.com/prod-specs/pl383562.pdf
+
+        """
+        name_lmnts: list[str] = ["LiPo", f"{q_mAh:.0f}mAh", "3.7V"]
+        if name is not None:
+            name_lmnts = [name]  # specific name overrules params
+        if description is None:
+            description = "Model of a LiPo battery (3 to 4.2 V) with adjustable capacity"
+        return cls(
+            SoC_init=SoC_init if SoC_init else cls.model_fields["SoC_init"].default,
+            q_As=q_mAh * 3600 / 1000,
+            p_VOC=[-0.852, 63.867, 3.6297, 0.559, 0.51, 0.508],
+            p_Rs=[0.1463, 30.27, 0.1037, 0.0584, 0.1747, 0.1288],
+            p_RtS=[0.1063, 62.49, 0.0437],
+            p_CtS=[-200, 138, 300],  # most likely a mistake (d1=-138) in the table/paper!
+            p_RtL=[0.0712, 61.4, 0.0288],
+            p_CtL=[-3083, 180, 5088],
+            # y10 = 2863.3, y20 = 232.66 # unused
+            p_rce=0.9248,
+            kdash=0.0008,
+            R_leak_Ohm=55.9e6 / q_mAh,  # from wiki ~ 5 % discharge/month
+            # content-fields below
+            name="_".join(name_lmnts),
+            description=description,
+            owner="NES Lab",
+            group="NES Lab",
+            visible2group=True,
+            visible2all=True,
+        )
+
+    @classmethod
+    @validate_call
+    def lead_acid(
+        cls,
+        q_mAh: PositiveFloat,
+        SoC_init: soc_t | None = None,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> Self:
+        """Modeled after the LEOCH LP12-1.2AH lead acid battery.
+
+        Nominal Voltage     12 V (6 Cell)
+        Nominal Capacity    1.2 Ah
+        Discharge Cutoff    10.8 V
+        Charge Cutoff       13.5 V
+        Max Discharge       15 C / 18 A
+        https://www.leoch.com/pdf/reserve-power/agm-vrla/lp-general/LP12-1.2.pdf
+        # NOTE: 1 cell has 2.1 V nom, cell-count as param?
+        # NOTE: add temperature-component? -5mV/cell/K, also capacity-decrease
+        """
+        name_lmnts: list[str] = ["Lead-Acid", f"{q_mAh:.0f}mAh", "12V"]
+        if name is not None:
+            name_lmnts = [name]  # specific name overrules params
+        if description is None:
+            description = "Model of a 12V lead acid battery with adjustable capacity"
+        return cls(
+            SoC_init=SoC_init if SoC_init else cls.model_fields["SoC_init"].default,
+            q_As=q_mAh * 3600 / 1000,
+            p_VOC=[5.429, 117.5, 11.32, 2.706, 2.04, 1.026],
+            p_Rs=[1.578, 8.527, 0.7808, -1.887, -2.404, -0.649],
+            p_RtS=[2.771, 9.079, 0.22],
+            p_CtS=[-2423, 75.14, 55],
+            p_RtL=[2.771, 9.079, 0.218],
+            # ⤷ first 2 values of p_RtL are identical with p_RtS in table/paper
+            #   (strange, but plots look fine)
+            p_CtL=[-1240, 9.571, 3100],
+            # y10 = 2592, y20 = 1728 # unused
+            p_rce=0.6,
+            kdash=0.0034,
+            R_leak_Ohm=174e6 / q_mAh,
+            # ⤷ from datasheet - 3-20 % discharge/month for 1.2 Ah, here 5%
+            # content-fields below
+            name="_".join(name_lmnts),
+            description=description,
+            owner="NES Lab",
+            group="NES Lab",
+            visible2group=True,
+            visible2all=True,
+        )
+
+    @classmethod
+    @validate_call
+    def capacitor(
+        cls,
+        C_uF: PositiveFloat,
+        V_rated: PositiveFloat,
+        SoC_init: soc_t | None = None,
+        R_series_Ohm: NonNegativeFloat | None = None,
+        R_leak_Ohm: PositiveFloat | None = None,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> Self:
+        name_lmnts: list[str] = ["Capacitor", f"{C_uF:.0f}uF", f"{V_rated:.1f}V"]
+        if name is not None:
+            name_lmnts = [name]  # specific name overrules params
+        if description is None:
+            description = "Model of an Capacitor with various effects"
+        if R_leak_Ohm is not None:
+            description += f", R_leak = {R_leak_Ohm / 1e3:.3f} Ohm"
+        if R_series_Ohm is not None:
+            description += f", R_serial = {R_series_Ohm:.0f} Ohm"
+        return cls(
+            SoC_init=SoC_init if SoC_init else cls.model_fields["SoC_init"].default,
+            q_As=1e-6 * C_uF * V_rated,
+            p_VOC=[0, 0, 0, V_rated, 0, 0],  # 100% SoC is @V_rated,
+            # no transients per default
+            p_Rs=[0, 0, R_series_Ohm, 0, 0, 0]
+            if R_series_Ohm
+            else cls.model_fields["p_Rs"].default,  # const series resistance
+            R_leak_Ohm=R_leak_Ohm if R_leak_Ohm else cls.model_fields["R_leak_Ohm"].default,
+            # content-fields below
+            name="_".join(name_lmnts),
+            description=description,
+            owner="NES Lab",
+            group="NES Lab",
+            visible2group=True,
+            visible2all=True,
+        )
+
+    @model_validator(mode="before")
+    @classmethod
+    def query_database(cls, values: dict[str, Any]) -> dict[str, Any]:
+        values, chain = tb_client.try_completing_model(cls.__name__, values)
+        values = tb_client.fill_in_user_data(values)
+        log.debug("vStorage-Inheritances: %s", chain)
+        return values
+
+    @model_validator(mode="after")
+    def post_validation(self) -> Self:
+        return self
+
+    def without_rate_capacity(self) -> Self:
+        model_dict = self.model_dump()
+        model_dict["p_rce"] = 1
+        model_dict["name"] += " no_rate_cap"
+        return type(self)(**model_dict)
+
+    def without_transient_voltages(self) -> Self:
+        model_dict = self.model_dump()
+        model_dict["p_RtS"] = [0, 0, 0]
+        model_dict["p_CtS"] = [0, 0, 0]
+        model_dict["p_RtL"] = [0, 0, 0]
+        model_dict["p_CtL"] = [0, 0, 0]
+        model_dict["name"] += " no_transient_vs"
+        return type(self)(**model_dict)
+
+    @staticmethod
+    @validate_call
+    def calc_k(kdash: PositiveFloat, c: Annotated[float, Gt(0), Le(1)]) -> float:
+        """Translate between k & k'.
+
+        As explained below equation 4 in paper: k' = k / (c * (c - 1))
+        """
+        return kdash * c * (1 - c)
+
+    @property
+    def kdash_(self) -> float:
+        return self.k / (self.p_rce * (self.p_rce - 1))
+
+    @validate_call
+    def calc_R_leak_capacitor(
+        self,
+        duration: timedelta,
+        SoC_final: Annotated[float, Ge(0), Le(1)],
+        SoC_0: Annotated[float, Ge(0), Le(1)] = 1.0,
+    ) -> float:
+        # based on capacitor discharge: U(t) = U0 * e ^ (-t/RC)
+        # Example: 50mAh; SoC from 100 % to 85 % over 30 days => ~1.8 MOhm
+        U0 = self.calc_V_OC(SoC_0)
+        Ut = self.calc_V_OC(SoC_final)
+        return duration.total_seconds() * U0 / (self.q_As * math.log(U0 / Ut))
+
+    @validate_call
+    def calc_R_leak_battery(
+        self,
+        duration: timedelta,
+        SoC_final: Annotated[float, Ge(0), Le(1)],
+        SoC_0: Annotated[float, Ge(0), Le(1)] = 1.0,
+    ) -> float:
+        U0 = self.calc_V_OC(SoC_0)
+        U1 = self.calc_V_OC(SoC_final)
+        current_A = (SoC_0 - SoC_final) * self.q_As / duration.total_seconds()
+        return (U0 + U1) / 2 / current_A
+
+    def calc_V_OC(self, SoC: float) -> float:
+        return (
+            self.p_VOC[0] * math.pow(math.e, -self.p_VOC[1] * SoC)
+            + self.p_VOC[2]
+            + self.p_VOC[3] * SoC
+            - self.p_VOC[4] * SoC**2
+            + self.p_VOC[5] * SoC**3
+        )
+
+    @property
+    def capacity_in_uF(self) -> float:
+        return 1e6 * self.q_As / self.calc_V_OC(SoC=1.0)
+
+    @property
+    def charge_in_mAh(self) -> float:
+        return 1e3 * self.q_As / 3600
+
+    @property
+    def V_init(self) -> float:
+        return self.calc_V_OC(SoC=self.SoC_init)
+
+    def calc_R_series(self, SoC: float) -> float:
+        return (
+            self.p_Rs[0] * math.pow(math.e, -self.p_Rs[1] * SoC)
+            + self.p_Rs[2]
+            + self.p_Rs[3] * SoC
+            - self.p_Rs[4] * SoC**2
+            + self.p_Rs[5] * SoC**3
+        )
+
+    def calc_R_transient_S(self, SoC: float) -> float:
+        return self.p_RtS[0] * math.pow(math.e, -self.p_RtS[1] * SoC) + self.p_RtS[2]
+
+    def calc_C_transient_S(self, SoC: float) -> float:
+        return self.p_CtS[0] * math.pow(math.e, -self.p_CtS[1] * SoC) + self.p_CtS[2]
+
+    def calc_R_transient_L(self, SoC: float) -> float:
+        return self.p_RtL[0] * math.pow(math.e, -self.p_RtL[1] * SoC) + self.p_RtL[2]
+
+    def calc_C_transient_L(self, SoC: float) -> float:
+        return self.p_CtL[0] * math.pow(math.e, -self.p_CtL[1] * SoC) + self.p_CtL[2]
+
+    def approximate_SoC(self, V_OC: float) -> float:
+        SoC_next = SoC_now = 0.5
+        step_size = 0.05
+        go_up = True
+        match = 5
+        counter = 0
+
+        while match > 0.001:
+            SoC_now = SoC_next
+            V_OC_now = self.calc_V_OC(SoC_now)
+            match_new = abs(V_OC_now / V_OC - 1)
+            if match_new > match:
+                go_up = not go_up
+                if go_up:
+                    step_size /= 2
+            SoC_next += step_size if go_up else -step_size
+            match = match_new
+            counter += 1
+            if counter > 100:
+                raise RuntimeError("Could not approximate SoC for given Voltage")
+
+        return SoC_now
+
+
+# constants & custom types
+TIMESTEP_s_DEFAULT: float = 1.0 / config.SAMPLERATE_SPS
+LuT_SIZE_LOG: int = 7
+LuT_SIZE: int = 2**LuT_SIZE_LOG
+u32 = Annotated[int, Field(ge=0, lt=2**32)]
+lut_storage = Annotated[list[u32], Field(min_length=LuT_SIZE, max_length=LuT_SIZE)]
+
+
+class StoragePRUConfig(ShpModel):
+    """Map settings-list to internal state-vars struct StorageConfig.
+
+    NOTE:
+      - yaml is based on si-units like nA, mV, ms, uF
+      - c-code and py-copy is using nA, uV, ns, nF, fW, raw
+      - ordering is intentional and in sync with shepherd/commons.h
+    """
+
+    SoC_init_1_n30: u32
+    """ ⤷ initial charge of storage """
+    Constant_1_per_nA_n60: u32
+    """ ⤷ Convert I_charge to delta-SoC with one multiplication."""
+    Constant_1_per_uV_n60: u32
+    """ ⤷ Leakage - Convert V_OC to delta-SoC with one multiplication.
+    Combines prior constant and R_leak, to maximize resolution.
+    """
+    LuT_VOC_uV_n8: lut_storage
+    """⤷ ranges from 3.9 uV to 16.7 V"""
+    LuT_RSeries_kOhm_n32: lut_storage
+    """⤷ ranges from 233n to 1 kOhm"""
+
+    @classmethod
+    @validate_call
+    def from_vstorage(
+        cls,
+        data: VirtualStorageConfig | None,
+        dt_s: PositiveFloat = TIMESTEP_s_DEFAULT,
+        *,
+        optimize_clamp: bool = True,
+    ) -> Self:
+        x_off = 0.5 if optimize_clamp else 0.0
+        SoC_min = 1.0 / LuT_SIZE
+        if data is None:
+            data = VirtualStorageConfig.capacitor(C_uF=100, V_rated=10)
+        V_OC_LuT = [data.calc_V_OC(SoC_min * (x + x_off)) for x in range(LuT_SIZE)]
+        R_series_LuT = [data.calc_R_series(SoC_min * (x + x_off)) for x in range(LuT_SIZE)]
+        Constant_1_per_A: float = dt_s / data.q_As
+        Constant_1_per_V: float = Constant_1_per_A / data.R_leak_Ohm
+        return cls(
+            SoC_init_1_n30=round(2**30 * data.SoC_init),
+            Constant_1_per_nA_n60=round((2**60 / 1e9) * Constant_1_per_A),
+            Constant_1_per_uV_n60=round((2**60 / 1e6) * Constant_1_per_V),
+            LuT_VOC_uV_n8=[round((2**8 * 1e6) * y) for y in V_OC_LuT],
+            LuT_RSeries_kOhm_n32=[round((2**32 * 1e-3) * y) for y in R_series_LuT],
+        )

shepherd_core/data_models/content/virtual_storage_fixture_creator.py

@@ -0,0 +1,267 @@
+"""Script for generating YAML-fixture for virtual storage."""
+
+import sys
+from pathlib import Path
+
+import yaml
+from virtual_storage_config import VirtualStorageConfig
+
+from shepherd_core import local_now
+from shepherd_core.data_models import Wrapper
+from shepherd_core.logger import log
+
+dsc_ideal = "Model of an ideal Capacitor (true to spec, no losses)"
+dsc_tantal = "Tantal-Capacitor similar to ideal Model, but with R_leak & R_series"
+dsc_mlcc = "MLCC-Capacitor with R_leak & R_series and planned DC-Bias-Effect"
+dsc_super = "SuperCapacitor with typically 1000 hours / 500 k cycles (not modeled)"
+
+# Ideal Capacitor, E6 row 10 to 1000 uF
+# typical voltage-ratings: 2.5, 4.0, 6.3, 10, 16, 20 V
+E6: list[int] = [10, 15, 22, 33, 47, 68, 100, 150, 220, 330, 470, 680, 1000]
+fixture_ideal: list[VirtualStorageConfig] = [
+    VirtualStorageConfig.capacitor(C_uF=_v, V_rated=10.0, description=dsc_ideal) for _v in E6
+]
+
+# Tantal Capacitors, E6 row
+# ⤷ verified with AVX TAJB107M006RNJ
+#       - Tantal, 100 uF, 6V3, 20%, 1411 package -> 100 uF measured
+#       - R_series taken from Datasheet
+#       - R_leak = 1 MOhm in datasheet (6.3V/6.3uA), but ~2 MOhm in experiment
+# see https://github.com/orgua/bq_characteristics/tree/main/eval_kit_behavior_var1#capacitor
+fixture_tantal: list[VirtualStorageConfig] = [
+    VirtualStorageConfig.capacitor(
+        C_uF=10,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 10,
+        R_series_Ohm=3.0,
+        name="AVX TAJB106x006",  # Note: small x is * in datasheet
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=15,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 15,
+        R_series_Ohm=2.0,
+        name="AVX TAJB156x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=22,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 22,
+        R_series_Ohm=2.5,
+        name="AVX TAJB226x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=33,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 33,
+        R_series_Ohm=2.2,
+        name="AVX TAJB336x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=47,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 47,
+        R_series_Ohm=2,
+        name="AVX TAJB476x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=68,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 68,
+        R_series_Ohm=0.9,
+        name="AVX TAJB686x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=100,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 100,
+        R_series_Ohm=1.7,
+        name="AVX TAJB107x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=150,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 150,
+        R_series_Ohm=1.3,
+        name="AVX TAJC157x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=220,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 220,
+        R_series_Ohm=1.2,
+        name="AVX TAJC227x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=330,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 330,
+        R_series_Ohm=0.5,
+        name="AVX TAJC337x006",
+        description=dsc_tantal,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=470,
+        V_rated=6.3,
+        R_leak_Ohm=196e6 / 470,
+        R_series_Ohm=0.4,
+        name="AVX TAJD477x006",
+        description=dsc_tantal,
+    ),
+]
+
+# MLCC
+# ⤷ verified with Taiyo Yuden JMK316ABJ107ML-T
+#       - MLCC, 100uF, 6V3, 20%, X5R, 1206 package -> 74 uF measured
+#       - Insulation Resistance (min) 100 MΩ·μF (datasheet), 97.8 MΩ measured
+# https://github.com/orgua/bq_characteristics/tree/main/eval_kit_behavior_var1/data_capacitor
+# BQ25570EVM uses Murata GRM43SR60J107ME20L
+#       - MLCC, 100uF, 6V3, 20%, X5R, 1812 package -> 79 uF measured
+#       - murata-DB does not know this part, but direct substitute is GRM31CR60J107MEA8
+# https://pim.murata.com/en-global/pim/details/?partNum=GRM31CR60J107MEA8%23
+# TODO: add DC-Bias
+fixture_mlcc: list[VirtualStorageConfig] = [
+    VirtualStorageConfig.capacitor(
+        C_uF=10, V_rated=6.3, R_leak_Ohm=97.8e6 / 10, description=dsc_mlcc
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=33, V_rated=6.3, R_leak_Ohm=97.8e6 / 33, description=dsc_mlcc
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=47, V_rated=6.3, R_leak_Ohm=97.8e6 / 47, description=dsc_mlcc
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=100, V_rated=6.3, R_leak_Ohm=97.8e6 / 100, description=dsc_mlcc
+    ),
+]
+
+# SuperCap
+fixture_super: list[VirtualStorageConfig] = [
+    VirtualStorageConfig.capacitor(
+        C_uF=25e6,
+        V_rated=3.0,
+        R_leak_Ohm=3 / 55e-6,
+        R_series_Ohm=17e-3,
+        name="Maxwell BCAP0025 P300 X11",
+        description=dsc_super,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=12e6,
+        V_rated=6.0,
+        R_leak_Ohm=6 / 80e-6,
+        R_series_Ohm=90e-3,
+        name="Abracon ADCM-S06R0SA126RB",
+        description=dsc_super,
+    ),
+    VirtualStorageConfig.capacitor(
+        C_uF=7.5e6,
+        V_rated=5.5,
+        R_leak_Ohm=6 / 78e-6,
+        R_series_Ohm=90e-3,
+        name="AVX SCMT32F755SRBA0 ",
+        description=dsc_super,
+    ),
+]
+
+fixture_lipo: list[VirtualStorageConfig] = [
+    # LiPo-Coin-cells 5.4mm, https://www.lipobatteries.net/3-8v-rechargeable-mini-button-lipo-coin-cell-battery/
+    VirtualStorageConfig.lipo(
+        q_mAh=80, name="LPM1254", description="LiPo-Coin-Cell 80mAh, 1 cell, w=12mm, d=5.4mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=65, name="LPM1154", description="LiPo-Coin-Cell 65mAh, 1 cell, w=11mm, d=5.4mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=50, name="LPM1054", description="LiPo-Coin-Cell 50mAh, 1 cell, w=10mm, d=5.4mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=40, name="LPM0954", description="LiPo-Coin-Cell 40mAh, 1 cell, w=9mm, d=5.4mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=35, name="LPM0854", description="LiPo-Coin-Cell 35mAh, 1 cell, w=8mm, d=5.4mm"
+    ),
+    # LiPo-Coin-cells 4.0mm, https://www.lipobatteries.net/3-8v-rechargeable-mini-button-lipo-coin-cell-battery/
+    VirtualStorageConfig.lipo(
+        q_mAh=55, name="LPM1240", description="LiPo-Coin-Cell 55mAh, 1 cell, w=12mm, d=4.0mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=45, name="LPM1140", description="LiPo-Coin-Cell 45mAh, 1 cell, w=11mm, d=4.0mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=35, name="LPM1040", description="LiPo-Coin-Cell 35mAh, 1 cell, w=10mm, d=4.0mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=30, name="LPM0940", description="LiPo-Coin-Cell 30mAh, 1 cell, w=9mm, d=4.0mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=18, name="LPM0840", description="LiPo-Coin-Cell 18mAh, 1 cell, w=8mm, d=4.0mm"
+    ),
+    # small LiPos, https://www.lipobatteries.net/lipo-batteries-within-100mah/
+    VirtualStorageConfig.lipo(
+        q_mAh=12, name="LP151020", description="LiPo-Pouch 12mAh, 1 cell, 20x10x1.5mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=15, name="LP251212", description="LiPo-Pouch 15mAh, 1 cell, 12x12x2.5mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=22, name="LP500522", description="LiPo-Pouch 20mAh, 1 cell, 22x05x5.0mm"
+    ),
+    VirtualStorageConfig.lipo(
+        q_mAh=22, name="LP271015", description="LiPo-Pouch 22mAh, 1 cell, 15x10x2.7mm"
+    ),
+    # Example from the paper
+    VirtualStorageConfig.lipo(q_mAh=860, name="PL-383562"),
+]
+
+fixture_lead: list[VirtualStorageConfig] = [
+    # Example from the paper
+    VirtualStorageConfig.lead_acid(q_mAh=1200, name="LEOCH_LP12-1.2AH"),
+]
+
+
+if __name__ == "__main__":
+    path_here = Path(__file__).parent.absolute()
+    path_db = path_here  # .parent / "shepherd_core/shepherd_core/data_models/content"
+
+    if not path_db.exists() or not path_db.is_dir():
+        log.error("Path to db must exist and be a directory!")
+        sys.exit(1)
+
+    fixtures: dict[str, list[VirtualStorageConfig]] = {
+        "ideal": fixture_ideal,
+        "tantal": fixture_tantal,
+        "mlcc": fixture_mlcc,
+        "super": fixture_super,
+        "lipo": fixture_lipo,
+        "lead": fixture_lead,
+    }
+
+    for name, fixture in fixtures.items():
+        file_path = path_db / f"virtual_storage_fixture_{name}.yaml"
+        if file_path.exists():
+            log.warning("File %s already exists! -> will skip", file_path.name)
+        models_wrap = []
+        for model in fixture:
+            model_dict = (
+                model.model_dump()
+            )  # exclude_unset=True, exclude_defaults=True, include={"id",})
+            model_wrap = Wrapper(
+                datatype=type(model).__name__,
+                created=local_now(),
+                comment=f"created by script '{Path(__file__).name}'",
+                parameters=model_dict,
+            )
+            models_wrap.append(model_wrap.model_dump(exclude_unset=True, exclude_defaults=True))
+
+        models_yaml = yaml.safe_dump(models_wrap, default_flow_style=False, sort_keys=False)
+        with file_path.open("w") as f:
+            f.write(models_yaml)