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

shepherd_core/data_models/task/testbed_tasks.py

@@ -34,7 +34,8 @@ class TestbedTasks(ShpModel):
             tb = Testbed()  # this will query the first (and only) entry of client
 
         tgt_ids = xp.get_target_ids()
-        obs_tasks = [ObserverTasks.from_xp(xp, tb, _id) for _id in tgt_ids]
+        xp_folder = xp.folder_name()
+        obs_tasks = [ObserverTasks.from_xp(xp, xp_folder, tb, _id) for _id in tgt_ids]
         return cls(
             name=xp.name,
             observer_tasks=obs_tasks,
@@ -46,6 +47,9 @@ class TestbedTasks(ShpModel):
                 return tasks
         return None
 
+    def get_observers(self) -> set[str]:
+        return {tasks.observer for tasks in self.observer_tasks}
+
     def get_output_paths(self) -> dict[str, Path]:
         # TODO: computed field preferred, but they don't work here, as
         #  - they are always stored in yaml despite "repr=False"
@@ -56,6 +60,7 @@ class TestbedTasks(ShpModel):
         return values
 
     def is_contained(self) -> bool:
+        """Limit paths to allowed directories."""
         paths_allowed: AbstractSet[PurePosixPath] = {
             PurePosixPath("/var/shepherd/"),
             PurePosixPath("/tmp/"),  # noqa: S108

shepherd_core/decoder_waveform/uart.py

@@ -50,6 +50,7 @@ class Uart:
     def __init__(
         self,
         content: Path | np.ndarray,
+        *,
         baud_rate: int | None = None,
         frame_length: int | None = 8,
         inversion: bool | None = None,
@@ -155,7 +156,7 @@ class Uart:
         """Analyze bit-state during long pauses (unchanged states).
 
         - pause should be HIGH for non-inverted mode (default)
-        - assumes max frame size of 64 bit + x for safety
+        - assumes maximum frame size of 64 bit + x for safety
         """
         events = self.events_sig[:1000, :]  # speedup for large datasets
         pauses = events[:, 2] > 80

shepherd_core/fw_tools/patcher.py

@@ -1,6 +1,8 @@
 """Read and modify symbols in ELF-files."""
 
+import shutil
 from pathlib import Path
+from tempfile import TemporaryDirectory
 from typing import Annotated
 
 from pydantic import Field
@@ -28,22 +30,27 @@ def find_symbol(file_elf: Path, symbol: str) -> bool:
         return False
     if ELF is None:
         raise RuntimeError(elf_error_text)
-    elf = ELF(path=file_elf)
-    try:
-        addr = elf.symbols[symbol]
-    except KeyError:
-        addr = None
-    if addr is None:
-        log.debug("Symbol '%s' not found in ELF-File %s", symbol, file_elf.name)
-        return False
-    log.debug(
-        "Symbol '%s' found in ELF-File %s, arch=%s, order=%s",
-        symbol,
-        file_elf.name,
-        elf.arch,
-        elf.endian,
-    )
-    elf.close()
+    with TemporaryDirectory(ignore_cleanup_errors=True) as tmp:
+        # switcheroo that might prevent windows bug - overwrite fails in modify_symbol_value()
+        file_tmp = Path(tmp) / file_elf.name
+        shutil.copy(file_elf, file_tmp)
+        elf = ELF(path=file_tmp)
+        try:
+            addr = elf.symbols[symbol]
+        except KeyError:
+            addr = None
+        if addr is None:
+            elf.close()  # better be safe
+            log.debug("Symbol '%s' not found in ELF-File %s", symbol, file_elf.name)
+            return False
+        log.debug(
+            "Symbol '%s' found in ELF-File %s, arch=%s, order=%s",
+            symbol,
+            file_elf.name,
+            elf.arch,
+            elf.endian,
+        )
+        elf.close()
     return True
 
 
@@ -60,8 +67,9 @@ def read_symbol(file_elf: Path, symbol: str, length: int) -> int | None:
     elf = ELF(path=file_elf)
     addr = elf.symbols[symbol]
     value_raw = elf.read(address=addr, count=length)[-length:]
+    endian = elf.endian
     elf.close()
-    return int.from_bytes(bytes=value_raw, byteorder=elf.endian, signed=False)
+    return int.from_bytes(bytes=value_raw, byteorder=endian, signed=False)
 
 
 def read_uid(file_elf: Path) -> int | None:
@@ -76,8 +84,11 @@ def read_arch(file_elf: Path) -> str | None:
     if ELF is None:
         raise RuntimeError(elf_error_text)
     elf = ELF(path=file_elf)
-    if "exec" in elf.elftype.lower():
-        return elf.arch.lower()
+    elf_type = elf.elftype.lower()
+    elf_arch = elf.arch.lower()
+    elf.close()
+    if "exec" in elf_type:
+        return elf_arch
     log.error("ELF is not Executable")
     return None
 
@@ -102,22 +113,37 @@ def modify_symbol_value(
         return None
     if ELF is None:
         raise RuntimeError(elf_error_text)
-    elf = ELF(path=file_elf)
-    addr = elf.symbols[symbol]
-    value_raw = elf.read(address=addr, count=config.UID_SIZE)[-config.UID_SIZE :]
-    # ⤷ cutting needed -> msp produces 4b instead of 2
-    value_old = int.from_bytes(bytes=value_raw, byteorder=elf.endian, signed=False)
-    value_raw = value.to_bytes(length=config.UID_SIZE, byteorder=elf.endian, signed=False)
-
-    try:
-        elf.write(address=addr, data=value_raw)
-    except AttributeError:
-        log.warning("ELF-Modifier failed @%s for symbol '%s'", f"0x{addr:X}", symbol)
-        return None
+    with TemporaryDirectory(ignore_cleanup_errors=True) as tmp:
+        # switcheroo that also prevents windows bug (overwrite fails)
+        file_tmp = Path(tmp) / file_elf.name
+        shutil.copy(file_elf, file_tmp)
+
+        elf = ELF(path=file_elf)
+        addr = elf.symbols[symbol]
+        value_raw = elf.read(address=addr, count=config.UID_SIZE)[-config.UID_SIZE :]
+        # ⤷ cutting needed -> msp produces 4b instead of 2
+        value_old = int.from_bytes(bytes=value_raw, byteorder=elf.endian, signed=False)
+        value_raw = value.to_bytes(length=config.UID_SIZE, byteorder=elf.endian, signed=False)
+
+        try:
+            elf.write(address=addr, data=value_raw)
+        except AttributeError:
+            log.warning("ELF-Modifier failed @%s for symbol '%s'", f"0x{addr:X}", symbol)
+            elf.close()
+            return None
+
+        file_new = file_elf if overwrite else file_elf.with_stem(file_elf.stem + "_" + str(value))
+        try:
+            file_new.unlink(missing_ok=True)
+        except PermissionError:
+            elf.close()
+            log.error(
+                "Failed to overwrite file, because it's somehow still in use (typical for WinOS)."
+            )
+            return None
+        elf.save(path=file_new)
+        elf.close()
 
-    file_new = file_elf if overwrite else file_elf.with_stem(file_elf.stem + "_" + str(value))
-    elf.save(path=file_new)
-    elf.close()
     log.debug(
         "Value of Symbol '%s' modified: %s -> %s @%s",
         symbol,

shepherd_core/fw_tools/validation.py

@@ -5,6 +5,7 @@ TODO: Work in Progress.
     - detection-functions that register in main validator.
 """
 
+import shutil
 import tempfile
 from pathlib import Path
 
@@ -92,7 +93,12 @@ def is_elf(file: Path) -> bool:
     if not file.is_file():
         return False
     try:
-        _ = ELF(path=file)
+        with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as tmp:
+            # switcheroo that might prevent windows bug - overwrite fails in modify_symbol_value()
+            file_tmp = Path(tmp) / file.name
+            shutil.copy(file, file_tmp)
+            elf = ELF(path=file_tmp)
+            elf.close()
     except ELFError:
         log.debug("File %s is not ELF - Magic number does not match", file.name)
         return False

shepherd_core/inventory/system.py

@@ -21,7 +21,7 @@ except ImportError:
     psutil = None
 
 from pydantic import ConfigDict
-from pydantic.types import PositiveInt
+from pydantic import PositiveInt
 
 from shepherd_core.data_models import ShpModel
 

shepherd_core/reader.py

@@ -314,16 +314,17 @@ class Reader:
         voltage_step: float | None = (
             self.get_config().get("virtual_harvester", {}).get("voltage_step_mV", None)
         )
+        if voltage_step is not None:  # convert mV to V
+            voltage_step = 1e-3 * voltage_step
         if voltage_step is None:
-            dsv = self.ds_voltage[0:2000]
+            dsv = self._cal.voltage.raw_to_si(self.ds_voltage[0:2000])
             diffs_np = np.unique(dsv[1:] - dsv[0:-1], return_counts=False)
             diffs_ls = [_e for _e in list(np.array(diffs_np)) if _e > 0]
             # static voltages have 0 steps, so
             if len(diffs_ls) == 0:
+                self._logger.warning("Voltage-Step could not be determined from source-material")
                 return None  # or is 0 better? that may provoke div0
             voltage_step = min(diffs_ls)
-        if voltage_step is not None:
-            voltage_step = 1e-3 * voltage_step
         return voltage_step
 
     def get_hrv_config(self) -> dict:

shepherd_core/version.py

@@ -1,3 +1,3 @@
 """Separated string avoids circular imports."""
 
-version: str = "2025.06.4"
+version: str = "2025.10.1"

shepherd_core/vsource/__init__.py

@@ -9,15 +9,19 @@ from .virtual_harvester_model import VirtualHarvesterModel
 from .virtual_harvester_simulation import simulate_harvester
 from .virtual_source_model import VirtualSourceModel
 from .virtual_source_simulation import simulate_source
+from .virtual_storage_model import VirtualStorageModel
+from .virtual_storage_simulator import StorageSimulator
 
 __all__ = [
     "ConstantCurrentTarget",
     "ConstantPowerTarget",
     "PruCalibration",
     "ResistiveTarget",
+    "StorageSimulator",
     "VirtualConverterModel",
     "VirtualHarvesterModel",
     "VirtualSourceModel",
+    "VirtualStorageModel",
     "simulate_harvester",
     "simulate_source",
 ]

shepherd_core/vsource/virtual_converter_model.py

@@ -17,8 +17,11 @@ Compromises:
 import math
 
 from shepherd_core.data_models import CalibrationEmulator
-from shepherd_core.data_models.content.virtual_source import LUT_SIZE
-from shepherd_core.data_models.content.virtual_source import ConverterPRUConfig
+from shepherd_core.data_models.content.virtual_source_config import LUT_SIZE
+from shepherd_core.data_models.content.virtual_source_config import ConverterPRUConfig
+from shepherd_core.data_models.content.virtual_storage_config import StoragePRUConfig
+
+from .virtual_storage_model import VirtualStorageModelPRU
 
 
 class PruCalibration:
@@ -59,13 +62,16 @@ class PruCalibration:
 class VirtualConverterModel:
     """Ported python version of the pru vCnv."""
 
-    def __init__(self, cfg: ConverterPRUConfig, cal: PruCalibration) -> None:
+    def __init__(
+        self, cfg: ConverterPRUConfig, cal: PruCalibration, storage_cfg: StoragePRUConfig
+    ) -> None:
         self._cal: PruCalibration = cal
         self._cfg: ConverterPRUConfig = cfg
 
+        self.storage = VirtualStorageModelPRU(storage_cfg)
+
         # simplifications for python
         self.R_input_kOhm = float(self._cfg.R_input_kOhm_n22) / 2**22
-        self.Constant_us_per_nF = float(self._cfg.Constant_us_per_nF_n28) / 2**28
 
         # boost internal state
         self.V_input_uV: float = 0.0
@@ -74,7 +80,7 @@ class VirtualConverterModel:
         self.interval_startup_disabled_drain_n: int = self._cfg.interval_startup_delay_drain_n
 
         # container for the stored energy
-        self.V_mid_uV: float = self._cfg.V_intermediate_init_uV
+        self.V_mid_uV: float = self.storage.calc_V_OC_uV()
 
         # buck internal state
         self.enable_storage: bool = (int(self._cfg.converter_mode) & 0b0001) > 0
@@ -83,19 +89,19 @@ class VirtualConverterModel:
         self.enable_log_mid: bool = (int(self._cfg.converter_mode) & 0b1000) > 0
         # back-channel to hrv
         self.feedback_to_hrv: bool = (int(self._cfg.converter_mode) & 0b1_0000) > 0
-        self.V_input_request_uV: int = self._cfg.V_intermediate_init_uV
+        self.V_input_request_uV: int = int(self.V_mid_uV)
 
         self.V_out_dac_uV: float = self._cfg.V_output_uV
         self.V_out_dac_raw: int = self._cal.conv_uV_to_dac_raw(self._cfg.V_output_uV)
         self.power_good: bool = True
 
         # prepare hysteresis-thresholds
-        self.dV_enable_output_uV: float = self._cfg.dV_enable_output_uV
-        self.V_enable_output_threshold_uV: float = self._cfg.V_enable_output_threshold_uV
-        self.V_disable_output_threshold_uV: float = self._cfg.V_disable_output_threshold_uV
+        self.dV_mid_enable_output_uV: float = self._cfg.dV_mid_enable_output_uV
+        self.V_mid_enable_output_threshold_uV: float = self._cfg.V_mid_enable_output_threshold_uV
+        self.V_mid_disable_output_threshold_uV: float = self._cfg.V_mid_disable_output_threshold_uV
 
-        self.V_enable_output_threshold_uV = max(
-            self.dV_enable_output_uV, self.V_enable_output_threshold_uV
+        self.V_mid_enable_output_threshold_uV = max(
+            self.dV_mid_enable_output_uV, self.V_mid_enable_output_threshold_uV
         )
 
         # pulled from update_states_and_output() due to easier static init
@@ -125,7 +131,7 @@ class VirtualConverterModel:
                 input_voltage_uV = 0.0
             # TODO: vdrop in case of v_input > v_storage (non-boost)
         elif self.enable_storage:
-            # no boost, but cap, for ie. diode+cap (+resistor)
+            # no boost, but cap, for i.e. diode+cap (+resistor)
             V_diff_uV = (
                 (input_voltage_uV - self.V_mid_uV) if (input_voltage_uV >= self.V_mid_uV) else 0
             )
@@ -162,14 +168,14 @@ class VirtualConverterModel:
         current_adc_raw = max(0, current_adc_raw)
         current_adc_raw = min((2**18) - 1, current_adc_raw)
 
-        P_leak_fW = self.V_mid_uV * self._cfg.I_intermediate_leak_nA
+        # TODO: remove P_leak in C-Code
         I_out_nA = self._cal.conv_adc_raw_to_nA(current_adc_raw)
         if self.enable_buck:  # noqa: SIM108
             eta_inv_out = self.get_output_inv_efficiency(I_out_nA)
         else:
             eta_inv_out = 1.0
 
-        self.P_out_fW = eta_inv_out * self.V_out_dac_uV * I_out_nA + P_leak_fW
+        self.P_out_fW = eta_inv_out * self.V_out_dac_uV * I_out_nA
 
         if self.interval_startup_disabled_drain_n > 0:
             self.interval_startup_disabled_drain_n -= 1
@@ -177,17 +183,12 @@ class VirtualConverterModel:
 
         return round(self.P_out_fW)  # Python-specific, added for easier testing
 
-    # TODO: add range-checks for add, sub Ops
     def update_cap_storage(self) -> int:
-        # TODO: this calculation is wrong for everything beside boost-cnv
         if self.enable_storage:
-            V_mid_prot_uV = max(1.0, self.V_mid_uV)
-            P_sum_fW = self.P_inp_fW - self.P_out_fW
-            I_mid_nA = P_sum_fW / V_mid_prot_uV
-            dV_mid_uV = I_mid_nA * self.Constant_us_per_nF
-            self.V_mid_uV += dV_mid_uV
-
-        self.V_mid_uV = min(self.V_mid_uV, self._cfg.V_intermediate_max_uV)
+            I_delta_nA = abs((self.P_inp_fW - self.P_out_fW) / self.V_mid_uV)
+            is_charging: bool = self.P_inp_fW >= self.P_out_fW
+            self.V_mid_uV = self.storage.step(2**4 * I_delta_nA, is_charging=is_charging)
+        self.V_mid_uV = min(self.V_mid_uV, self._cfg.V_mid_max_uV)
         self.V_mid_uV = max(self.V_mid_uV, 1)
         return round(self.V_mid_uV)  # Python-specific, added for easier testing
 
@@ -200,11 +201,11 @@ class VirtualConverterModel:
         if check_thresholds:
             self.sample_count = 0
             if self.is_outputting:
-                if V_mid_uV_now < self.V_disable_output_threshold_uV:
+                if V_mid_uV_now < self.V_mid_disable_output_threshold_uV:
                     self.is_outputting = False
-            elif V_mid_uV_now >= self.V_enable_output_threshold_uV:
+            elif V_mid_uV_now >= self.V_mid_enable_output_threshold_uV:
                 self.is_outputting = True
-                self.V_mid_uV -= self.dV_enable_output_uV
+                self.V_mid_uV -= self.dV_mid_enable_output_uV
 
         if check_thresholds or self._cfg.immediate_pwr_good_signal:
             # generate power-good-signal

shepherd_core/vsource/virtual_harvester_model.py

@@ -16,7 +16,7 @@ Compromises:
 
 """
 
-from shepherd_core.data_models.content.virtual_harvester import HarvesterPRUConfig
+from shepherd_core.data_models.content.virtual_harvester_config import HarvesterPRUConfig
 from shepherd_core.logger import log
 
 
@@ -64,33 +64,34 @@ class VirtualHarvesterModel:
         self.voltage_step_x4_uV: int = 4 * self._cfg.voltage_step_uV
         self.age_max: int = 2 * self._cfg.window_size
 
+        self.voc_now: int = self._cfg.voltage_max_uV
+        self.voc_nxt: int = self._cfg.voltage_max_uV
+        self.voc_min: int = max(1000, self._cfg.voltage_min_uV)
+
+        self.lin_extrapolation: bool = bool(self._cfg.hrv_mode & (2**2))
+
         # INIT static vars: CV
         self.voltage_last: int = 0
         self.current_last: int = 0
-        self.compare_last: int = 0
-        self.lin_extrapolation: bool = bool(self._cfg.hrv_mode & (2**2))
-        self.current_delta: int = 0
         self.voltage_delta: int = 0
+        self.current_delta: int = 0
+        self.compare_last: int = 0
 
         # INIT static vars: VOC
         self.age_now: int = 0
-        self.voc_now: int = self._cfg.voltage_max_uV
         self.age_nxt: int = 0
-        self.voc_nxt: int = self._cfg.voltage_max_uV
-        self.voc_min: int = max(1000, self._cfg.voltage_min_uV)
 
         # INIT static vars: PO
-        # already done: interval step
         self.power_last: int = 0
 
         # INIT static vars: OPT
-        # already done: age_now, age_nxt
-        self.power_now: int = 0
+        # already done in VOC: age_now, age_nxt
         self.voltage_now: int = 0
         self.current_now: int = 0
-        self.power_nxt: int = 0
         self.voltage_nxt: int = 0
         self.current_nxt: int = 0
+        self.power_now: int = 0
+        self.power_nxt: int = 0
 
     def ivcurve_sample(self, _voltage_uV: int, _current_nA: int) -> tuple[int, int]:
         if self._cfg.window_size <= 1:
@@ -116,19 +117,25 @@ class VirtualHarvesterModel:
             if distance_now < distance_last and distance_now < self.voltage_step_x4_uV:
                 self.voltage_hold = _voltage_uV
                 self.current_hold = _current_nA
-                self.current_delta = _current_nA - self.current_last
                 self.voltage_delta = _voltage_uV - self.voltage_last
-                # TODO: voltage_delta is static
+                self.current_delta = _current_nA - self.current_last
             elif distance_last < distance_now and distance_last < self.voltage_step_x4_uV:
                 self.voltage_hold = self.voltage_last
                 self.current_hold = self.current_last
-                self.current_delta = _current_nA - self.current_last
                 self.voltage_delta = _voltage_uV - self.voltage_last
+                self.current_delta = _current_nA - self.current_last
         elif self.lin_extrapolation:
             # apply the proper delta if needed
+            # TODO: C-Code differs here slightly, but only to handle unsigned int
             if (self.voltage_hold < self.voltage_set_uV) == (self.voltage_delta > 0):
-                self.voltage_hold += self.voltage_delta
-                self.current_hold += self.current_delta
+                if self.voltage_hold > -self.voltage_delta:
+                    self.voltage_hold += self.voltage_delta
+                else:
+                    self.voltage_hold = 0
+                if self.current_hold > -self.current_delta:
+                    self.current_hold += self.current_delta
+                else:
+                    self.current_hold = 0
             else:
                 if self.voltage_hold > self.voltage_delta:
                     self.voltage_hold -= self.voltage_delta
@@ -168,10 +175,11 @@ class VirtualHarvesterModel:
 
         _voltage_uV, _current_nA = self.ivcurve_2_cv(_voltage_uV, _current_nA)
         if self.interval_step < self._cfg.duration_n:
-            self.voltage_set_uV = self.voc_now
+            self.voltage_set_uV = self._cfg.voltage_max_uV
+            _current_nA = 0
         elif self.interval_step == self._cfg.duration_n:
             self.voltage_set_uV = int(self.voc_now * self._cfg.setpoint_n8 / 256)
-
+            _current_nA = 0
         return _voltage_uV, _current_nA
 
     def ivcurve_2_mppt_po(self, _voltage_uV: int, _current_nA: int) -> tuple[int, int]:
@@ -211,7 +219,7 @@ class VirtualHarvesterModel:
                 self.voltage_set_uV = self._cfg.voltage_min_uV
                 self.is_rising = True
                 self.volt_step_uV = self._cfg.voltage_step_uV
-            if self.voltage_set_uV <= self._cfg.voltage_step_uV:
+            if self.voltage_set_uV < self._cfg.voltage_step_uV:
                 self.voltage_set_uV = self._cfg.voltage_step_uV
                 self.is_rising = True
                 self.volt_step_uV = self._cfg.voltage_step_uV

shepherd_core/vsource/virtual_harvester_simulation.py

@@ -13,8 +13,8 @@ from pathlib import Path
 from tqdm import tqdm
 
 from shepherd_core.data_models.base.calibration import CalibrationHarvester
-from shepherd_core.data_models.content.virtual_harvester import HarvesterPRUConfig
-from shepherd_core.data_models.content.virtual_harvester import VirtualHarvesterConfig
+from shepherd_core.data_models.content.virtual_harvester_config import HarvesterPRUConfig
+from shepherd_core.data_models.content.virtual_harvester_config import VirtualHarvesterConfig
 from shepherd_core.reader import Reader
 from shepherd_core.writer import Writer
 
@@ -28,45 +28,44 @@ def simulate_harvester(
 
     Fn return the harvested energy.
     """
-    stack = ExitStack()
-    file_inp = Reader(path_input, verbose=False)
-    stack.enter_context(file_inp)
-    cal_inp = file_inp.get_calibration_data()
+    with ExitStack() as stack:
+        file_inp = Reader(path_input, verbose=False)
+        stack.enter_context(file_inp)
+        cal_inp = file_inp.get_calibration_data()
 
-    if path_output:
-        cal_hrv = CalibrationHarvester()
-        file_out = Writer(
-            path_output, cal_data=cal_hrv, mode="harvester", verbose=False, force_overwrite=True
-        )
-        stack.enter_context(file_out)
-        cal_out = file_out.get_calibration_data()
-        file_out.store_hostname("hrv_sim_" + config.name)
+        if path_output:
+            cal_hrv = CalibrationHarvester()
+            file_out = Writer(
+                path_output, cal_data=cal_hrv, mode="harvester", verbose=False, force_overwrite=True
+            )
+            stack.enter_context(file_out)
+            cal_out = file_out.get_calibration_data()
+            file_out.store_hostname("hrv_sim_" + config.name)
 
-    hrv_pru = HarvesterPRUConfig.from_vhrv(
-        config,
-        for_emu=True,
-        dtype_in=file_inp.get_datatype(),
-        window_size=file_inp.get_window_samples(),
-        voltage_step_V=file_inp.get_voltage_step(),
-    )
-    hrv = VirtualHarvesterModel(hrv_pru)
-    e_out_Ws = 0.0
+        hrv_pru = HarvesterPRUConfig.from_vhrv(
+            config,
+            for_emu=True,
+            dtype_in=file_inp.get_datatype(),
+            window_size=file_inp.get_window_samples(),
+            voltage_step_V=file_inp.get_voltage_step(),
+        )
+        hrv = VirtualHarvesterModel(hrv_pru)
+        e_out_Ws = 0.0
 
-    for _t, v_inp, i_inp in tqdm(
-        file_inp.read(is_raw=True), total=file_inp.chunks_n, desc="Chunk", leave=False
-    ):
-        v_uV = cal_inp.voltage.raw_to_si(v_inp) * 1e6
-        i_nA = cal_inp.current.raw_to_si(i_inp) * 1e9
-        length = min(v_uV.size, i_nA.size)
-        for _n in range(length):
-            v_uV[_n], i_nA[_n] = hrv.ivcurve_sample(
-                _voltage_uV=int(v_uV[_n]), _current_nA=int(i_nA[_n])
-            )
-        e_out_Ws += (v_uV * i_nA).sum() * 1e-15 * file_inp.sample_interval_s
-        if path_output:
-            v_out = cal_out.voltage.si_to_raw(v_uV / 1e6)
-            i_out = cal_out.current.si_to_raw(i_nA / 1e9)
-            file_out.append_iv_data_raw(_t, v_out, i_out)
+        for _t, v_inp, i_inp in tqdm(
+            file_inp.read(is_raw=True), total=file_inp.chunks_n, desc="Chunk", leave=False
+        ):
+            v_uV = cal_inp.voltage.raw_to_si(v_inp) * 1e6
+            i_nA = cal_inp.current.raw_to_si(i_inp) * 1e9
+            length = min(v_uV.size, i_nA.size)
+            for _n in range(length):
+                v_uV[_n], i_nA[_n] = hrv.ivcurve_sample(
+                    _voltage_uV=int(v_uV[_n]), _current_nA=int(i_nA[_n])
+                )
+            e_out_Ws += (v_uV * i_nA).sum() * 1e-15 * file_inp.sample_interval_s
+            if path_output:
+                v_out = cal_out.voltage.si_to_raw(v_uV / 1e6)
+                i_out = cal_out.current.si_to_raw(i_nA / 1e9)
+                file_out.append_iv_data_raw(_t, v_out, i_out)
 
-    stack.close()
     return e_out_Ws

shepherd_core/vsource/virtual_source_model.py

@@ -12,9 +12,10 @@ NOTE: DO NOT OPTIMIZE -> stay close to original code-base
 
 from shepherd_core.data_models.base.calibration import CalibrationEmulator
 from shepherd_core.data_models.content.energy_environment import EnergyDType
-from shepherd_core.data_models.content.virtual_harvester import HarvesterPRUConfig
-from shepherd_core.data_models.content.virtual_source import ConverterPRUConfig
-from shepherd_core.data_models.content.virtual_source import VirtualSourceConfig
+from shepherd_core.data_models.content.virtual_harvester_config import HarvesterPRUConfig
+from shepherd_core.data_models.content.virtual_source_config import ConverterPRUConfig
+from shepherd_core.data_models.content.virtual_source_config import VirtualSourceConfig
+from shepherd_core.data_models.content.virtual_storage_config import StoragePRUConfig
 
 from .virtual_converter_model import PruCalibration
 from .virtual_converter_model import VirtualConverterModel
@@ -36,25 +37,28 @@ class VirtualSourceModel:
     ) -> None:
         self._cal_emu: CalibrationEmulator = cal_emu
         self._cal_pru: PruCalibration = PruCalibration(cal_emu)
-
         self.cfg_src = VirtualSourceConfig() if vsrc is None else vsrc
-        cnv_config = ConverterPRUConfig.from_vsrc(
-            self.cfg_src,
-            dtype_in=dtype_in,
-            log_intermediate_node=log_intermediate,
-        )
-        self.cnv: VirtualConverterModel = VirtualConverterModel(cnv_config, self._cal_pru)
 
-        hrv_config = HarvesterPRUConfig.from_vhrv(
+        # init Harvester
+        cfg_hrv = HarvesterPRUConfig.from_vhrv(
             self.cfg_src.harvester,
             for_emu=True,
             dtype_in=dtype_in,
             window_size=window_size,
             voltage_step_V=voltage_step_V,
         )
+        self.hrv: VirtualHarvesterModel = VirtualHarvesterModel(cfg_hrv)
 
-        self.hrv: VirtualHarvesterModel = VirtualHarvesterModel(hrv_config)
+        # init Converters
+        cfg_cnv = ConverterPRUConfig.from_vsrc(
+            self.cfg_src,
+            dtype_in=dtype_in,
+            log_intermediate_node=log_intermediate,
+        )
+        cfg_storage = StoragePRUConfig.from_vstorage(self.cfg_src.storage, optimize_clamp=True)
+        self.cnv: VirtualConverterModel = VirtualConverterModel(cfg_cnv, self._cal_pru, cfg_storage)
 
+        # state for simulation
         self.W_inp_fWs: float = 0.0
         self.W_out_fWs: float = 0.0
 
@@ -74,8 +78,8 @@ class VirtualSourceModel:
 
         # fake ADC read
         A_out_raw = self._cal_emu.adc_C_A.si_to_raw(I_out_nA * 10**-9)
-
         P_out_fW = self.cnv.calc_out_power(A_out_raw)
+
         V_mid_uV = self.cnv.update_cap_storage()
         V_out_raw = self.cnv.update_states_and_output()
         V_out_uV = int(self._cal_emu.dac_V_A.raw_to_si(V_out_raw) * 10**6)