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

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)

shepherd_core/vsource/virtual_source_simulation.py

@@ -14,7 +14,7 @@ import numpy as np
 from tqdm import tqdm
 
 from shepherd_core.data_models.base.calibration import CalibrationEmulator
-from shepherd_core.data_models.content.virtual_source import VirtualSourceConfig
+from shepherd_core.data_models.content.virtual_source_config import VirtualSourceConfig
 from shepherd_core.logger import log
 from shepherd_core.reader import Reader
 from shepherd_core.writer import Writer
@@ -35,81 +35,79 @@ def simulate_source(
 
     FN returns the consumed energy of the target.
     """
-    stack = ExitStack()
-    file_inp = Reader(path_input, verbose=False)
-    stack.enter_context(file_inp)
-    cal_emu = CalibrationEmulator()
-    cal_inp = file_inp.get_calibration_data()
-
-    if path_output:
-        file_out = Writer(
-            path_output, cal_data=cal_emu, mode="emulator", verbose=False, force_overwrite=True
+    with ExitStack() as stack:
+        file_inp = Reader(path_input, verbose=False)
+        stack.enter_context(file_inp)
+        cal_emu = CalibrationEmulator()
+        cal_inp = file_inp.get_calibration_data()
+
+        if path_output:
+            file_out = Writer(
+                path_output, cal_data=cal_emu, mode="emulator", verbose=False, force_overwrite=True
+            )
+            stack.enter_context(file_out)
+            file_out.store_hostname("emu_sim_" + config.name)
+            file_out.store_config(config.model_dump())
+            cal_out = file_out.get_calibration_data()
+
+        src = VirtualSourceModel(
+            config,
+            cal_emu,
+            dtype_in=file_inp.get_datatype(),
+            log_intermediate=False,
+            window_size=file_inp.get_window_samples(),
+            voltage_step_V=file_inp.get_voltage_step(),
         )
-        stack.enter_context(file_out)
-        file_out.store_hostname("emu_sim_" + config.name)
-        file_out.store_config(config.model_dump())
-        cal_out = file_out.get_calibration_data()
-
-    src = VirtualSourceModel(
-        config,
-        cal_emu,
-        dtype_in=file_inp.get_datatype(),
-        log_intermediate=False,
-        window_size=file_inp.get_window_samples(),
-        voltage_step_V=file_inp.get_voltage_step(),
-    )
-    i_out_nA = 0
-    e_out_Ws = 0.0
-    if monitor_internals and path_output:
-        stats_sample = 0
-        stats_internal = np.empty((round(file_inp.runtime_s * file_inp.samplerate_sps), 11))
-        try:
-            # keep dependencies low
-            from matplotlib import pyplot as plt  # noqa: PLC0415
-        except ImportError:
-            log.warning("Matplotlib not installed, plotting of internals disabled")
+        i_out_nA = 0
+        e_out_Ws = 0.0
+        if monitor_internals and path_output:
+            stats_sample = 0
+            stats_internal = np.empty((round(file_inp.runtime_s * file_inp.samplerate_sps), 11))
+            try:
+                # keep dependencies low
+                from matplotlib import pyplot as plt  # noqa: PLC0415
+            except ImportError:
+                log.warning("Matplotlib not installed, plotting of internals disabled")
+                stats_internal = None
+        else:
             stats_internal = None
-    else:
-        stats_internal = None
-
-    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 = 1e6 * cal_inp.voltage.raw_to_si(v_inp)
-        i_nA = 1e9 * cal_inp.current.raw_to_si(i_inp)
-
-        for _n in range(len(_t)):
-            v_uV[_n] = src.iterate_sampling(
-                V_inp_uV=int(v_uV[_n]),
-                I_inp_nA=int(i_nA[_n]),
-                I_out_nA=i_out_nA,
-            )
-            i_out_nA = target.step(int(v_uV[_n]), pwr_good=src.cnv.get_power_good())
-            i_nA[_n] = i_out_nA
-
-            if stats_internal is not None:
-                stats_internal[stats_sample] = [
-                    _t[_n] * 1e-9,  # s
-                    src.hrv.voltage_hold * 1e-6,
-                    src.cnv.V_input_request_uV * 1e-6,  # V
-                    src.hrv.voltage_set_uV * 1e-6,
-                    src.cnv.V_mid_uV * 1e-6,
-                    src.hrv.current_hold * 1e-6,  # mA
-                    src.hrv.current_delta * 1e-6,
-                    i_out_nA * 1e-6,
-                    src.cnv.P_inp_fW * 1e-12,  # mW
-                    src.cnv.P_out_fW * 1e-12,
-                    src.cnv.get_power_good(),
-                ]
-                stats_sample += 1
-
-        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(1e-6 * v_uV)
-            i_out = cal_out.current.si_to_raw(1e-9 * i_nA)
-            file_out.append_iv_data_raw(_t, v_out, i_out)
 
-    stack.close()
+        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 = 1e6 * cal_inp.voltage.raw_to_si(v_inp)
+            i_nA = 1e9 * cal_inp.current.raw_to_si(i_inp)
+
+            for _n in range(len(_t)):
+                v_uV[_n] = src.iterate_sampling(
+                    V_inp_uV=int(v_uV[_n]),
+                    I_inp_nA=int(i_nA[_n]),
+                    I_out_nA=i_out_nA,
+                )
+                i_out_nA = target.step(int(v_uV[_n]), pwr_good=src.cnv.get_power_good())
+                i_nA[_n] = i_out_nA
+
+                if stats_internal is not None:
+                    stats_internal[stats_sample] = [
+                        _t[_n] * 1e-9,  # s
+                        src.hrv.voltage_hold * 1e-6,
+                        src.cnv.V_input_request_uV * 1e-6,  # V
+                        src.hrv.voltage_set_uV * 1e-6,
+                        src.cnv.V_mid_uV * 1e-6,
+                        src.hrv.current_hold * 1e-6,  # mA
+                        src.hrv.current_delta * 1e-6,
+                        i_out_nA * 1e-6,
+                        src.cnv.P_inp_fW * 1e-12,  # mW
+                        src.cnv.P_out_fW * 1e-12,
+                        src.cnv.get_power_good(),
+                    ]
+                    stats_sample += 1
+
+            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(1e-6 * v_uV)
+                i_out = cal_out.current.si_to_raw(1e-9 * i_nA)
+                file_out.append_iv_data_raw(_t, v_out, i_out)
 
     if stats_internal is not None:
         stats_internal = stats_internal[:stats_sample, :]