pqopen-lib 0.8.0__tar.gz → 0.8.2__tar.gz

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pqopen-lib
-Version: 0.8.0
+Version: 0.8.2
 Summary: A power quality processing library for calculating parameters from waveform data
 Project-URL: Homepage, https://github.com/DaqOpen/pqopen-lib
 Project-URL: Issues, https://github.com/DaqOpen/pqopen-lib/issues
@@ -10,7 +10,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
-Requires-Dist: daqopen-lib
+Requires-Dist: daqopen-lib>=0.7.4
 Requires-Dist: numpy
 Requires-Dist: scipy
 Provides-Extra: numba

pqopen_lib-0.8.0/pqopen/goertzel.py → pqopen_lib-0.8.2/pqopen/auxcalc.py

@@ -9,7 +9,7 @@ except ImportError:
         return func
     float32 = float64 = None
 
-@njit
+@njit(cache=True)
 def calc_single_freq(x: np.array, f_hz: float, fs: float) -> tuple[float, float]:
     """Compute the amplitude and phase of a specific frequency component
     in a signal using the Goertzel algorithm.
@@ -48,6 +48,29 @@ def calc_single_freq(x: np.array, f_hz: float, fs: float) -> tuple[float, float]
 
     return amp, phase
 
+def calc_rms_trapz(values: np.array, start_frac: float, end_frac: float, frequency: float, samplerate: float):
+    u2 = values * values
+    s = 0.0
+    s += 0.5 * (u2[0] + u2[1]) * start_frac # left edge
+    s += 0.5*u2[1:-2].sum() + 0.5*u2[2:-1].sum() # middle
+    s += 0.5 * (u2[-2] + u2[-1]) * end_frac # right edge
+    return (s * frequency / samplerate) ** 0.5
+
+@njit(fastmath=True)
+def fast_interp(y, out_len):
+    n = y.size
+    scale = (n - 1) / out_len
+    out = np.empty(out_len, dtype=y.dtype)
+    for i in range(out_len):
+        x = i * scale
+        j = int(x)
+        t = x - j
+        if j+1 < n:
+            out[i] = (1-t)*y[j] + t*y[j+1]
+        else:
+            out[i] = y[-1]
+    return out
+
 # >>>>>>> Pre-Compile for float32 und float64 <<<<<<<
 if float32 is not None and float64 is not None:
     sigs = [

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/pqopen/helper.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 import re
+import numpy as np
 
 def floor_timestamp(timestamp: float | int, interval_seconds: int, ts_resolution: str = "us"):
     """Floor eines Zeitstempels auf ein gegebenes Intervall."""
@@ -44,4 +45,19 @@ class JsonDecimalLimiter(object):
         return self._float_pattern.sub(self._round_float_match, json_string)
     
     def _round_float_match(self, m):
-        return format(round(float(m.group()), self._decimal_places), f'.{self._decimal_places}f')
+        return format(round(float(m.group()), self._decimal_places), f'.{self._decimal_places}f')
+    
+def create_harm_corr_array(nom_frequency: float, num_harmonics: int, freq_response: tuple, interharm=False):
+    if interharm:
+        freqs = np.arange(0.5*nom_frequency, nom_frequency*(num_harmonics+1.5), nom_frequency)
+    else:
+        freqs = np.arange(0, nom_frequency*(num_harmonics+1), nom_frequency)
+    freq_response_arr = np.array(freq_response)
+    freq_corr = 1/np.interp(freqs, freq_response_arr[:,0], freq_response_arr[:,1])
+    return freq_corr
+
+def create_fft_corr_array(target_size: int, freq_nyq: float, freq_response: tuple):
+    freqs = np.linspace(0, freq_nyq, target_size)
+    freq_response_arr = np.array(freq_response)
+    freq_corr = 1/np.interp(freqs, freq_response_arr[:,0], freq_response_arr[:,1])
+    return freq_corr

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/pqopen/powerquality.py

@@ -76,7 +76,7 @@ def resample_and_fft(data: np.ndarray, resample_size: int = None) -> np.ndarray:
         np.ndarray: The FFT of the resampled data, scaled by sqrt(2) and normalized by the resample size.
     """
     if not resample_size:
-        resample_size = 2**int(np.ceil(np.log2(data.size)))
+        resample_size = 2**int(np.floor(np.log2(data.size)))
     x_data = np.arange(len(data))
     x = np.linspace(0, len(data), resample_size, endpoint=False)
     data_resampled = np.interp(x, x_data, data)
@@ -149,11 +149,7 @@ class VoltageFluctuation(object):
     def process(self, start_sidx: int, hp_data: np.ndarray, raw_data: np.ndarray):
         """
         """
-        stage0_tp_filtered_data,_ = signal.lfilter(self.stage0_tp_filter_coeff[0], self.stage0_tp_filter_coeff[1], raw_data, zi=self.stage0_tp_filter_zi)
-        self.stage0_tp_filter_zi = signal.lfiltic(self.stage0_tp_filter_coeff[0], 
-                                                  self.stage0_tp_filter_coeff[1], 
-                                                  stage0_tp_filtered_data[-3:][::-1],
-                                                  raw_data[-3:][::-1])
+        stage0_tp_filtered_data, self.stage0_tp_filter_zi = signal.lfilter(self.stage0_tp_filter_coeff[0], self.stage0_tp_filter_coeff[1], raw_data, zi=self.stage0_tp_filter_zi)
         
         samples_skip_next_start = len(stage0_tp_filtered_data) % self._calc_samplerate_decimation
         stage0_tp_filtered_data = stage0_tp_filtered_data[self._next_reduction_start_idx::self._calc_samplerate_decimation]
@@ -161,37 +157,17 @@ class VoltageFluctuation(object):
             self._next_reduction_start_idx += self._calc_samplerate_decimation - samples_skip_next_start
             if self._next_reduction_start_idx >= self._calc_samplerate_decimation:
                 self._next_reduction_start_idx %= self._calc_samplerate_decimation
-        stage1_tp_filtered_data,_ = signal.lfilter(self.stage1_tp_filter_coeff[0], self.stage1_tp_filter_coeff[1], hp_data, zi=self.stage1_tp_filter_zi)
-        self.stage1_tp_filter_zi = signal.lfiltic(self.stage1_tp_filter_coeff[0], 
-                                                  self.stage1_tp_filter_coeff[1], 
-                                                  stage1_tp_filtered_data[-2:][::-1],
-                                                  hp_data[-2:][::-1])
+        stage1_tp_filtered_data, self.stage1_tp_filter_zi = signal.lfilter(self.stage1_tp_filter_coeff[0], self.stage1_tp_filter_coeff[1], hp_data, zi=self.stage1_tp_filter_zi)
         blk_size = int(len(stage0_tp_filtered_data)/len(hp_data))
         for idx,val in enumerate(stage1_tp_filtered_data[:-1]):
             stage0_tp_filtered_data[idx*blk_size:(idx+1)*blk_size] /= val
         stage0_tp_filtered_data[(idx+1)*blk_size:] /= stage1_tp_filtered_data[-1]
         stage2_output = np.power(stage0_tp_filtered_data, 2)
-        stage3_hp_filtered_data,_ = signal.lfilter(self.stage3_hp_filter_coeff[0], self.stage3_hp_filter_coeff[1], stage2_output, zi=self.stage3_hp_filter_zi)
-        self.stage3_hp_filter_zi = signal.lfiltic(self.stage3_hp_filter_coeff[0], 
-                                                  self.stage3_hp_filter_coeff[1], 
-                                                  stage3_hp_filtered_data[-2:][::-1],
-                                                  stage2_output[-2:][::-1])
-        stage3_tp_filtered_data,_ = signal.lfilter(self.stage3_tp_filter_coeff[0], self.stage3_tp_filter_coeff[1], stage3_hp_filtered_data, zi=self.stage3_tp_filter_zi)
-        self.stage3_tp_filter_zi = signal.lfiltic(self.stage3_tp_filter_coeff[0], 
-                                                  self.stage3_tp_filter_coeff[1], 
-                                                  stage3_tp_filtered_data[-7:][::-1],
-                                                  stage3_hp_filtered_data[-7:][::-1])
-        stage3_weight_filtered_data,_ = signal.lfilter(self.stage3_weight_filter_coeff[0], self.stage3_weight_filter_coeff[1], stage3_tp_filtered_data, zi=self.stage3_weight_filter_zi)
-        self.stage3_weight_filter_zi = signal.lfiltic(self.stage3_weight_filter_coeff[0], 
-                                                  self.stage3_weight_filter_coeff[1], 
-                                                  stage3_weight_filtered_data[-len(self.stage3_weight_filter_coeff[1])-1:][::-1],
-                                                  stage3_tp_filtered_data[-len(self.stage3_weight_filter_coeff[1])-1:][::-1])
+        stage3_hp_filtered_data, self.stage3_hp_filter_zi = signal.lfilter(self.stage3_hp_filter_coeff[0], self.stage3_hp_filter_coeff[1], stage2_output, zi=self.stage3_hp_filter_zi)
+        stage3_tp_filtered_data, self.stage3_tp_filter_zi = signal.lfilter(self.stage3_tp_filter_coeff[0], self.stage3_tp_filter_coeff[1], stage3_hp_filtered_data, zi=self.stage3_tp_filter_zi)
+        stage3_weight_filtered_data, self.stage3_weight_filter_zi = signal.lfilter(self.stage3_weight_filter_coeff[0], self.stage3_weight_filter_coeff[1], stage3_tp_filtered_data, zi=self.stage3_weight_filter_zi)
         stage3_output = np.power(stage3_weight_filtered_data, 2)
-        stage4_tp_filtered_data,_ = signal.lfilter(self.stage4_tp_filter_coeff[0], self.stage4_tp_filter_coeff[1], stage3_output, zi=self.stage4_tp_filter_zi)
-        self.stage4_tp_filter_zi = signal.lfiltic(self.stage4_tp_filter_coeff[0], 
-                                                  self.stage4_tp_filter_coeff[1], 
-                                                  stage4_tp_filtered_data[-2:][::-1],
-                                                  stage3_output[-2:][::-1])
+        stage4_tp_filtered_data, self.stage4_tp_filter_zi = signal.lfilter(self.stage4_tp_filter_coeff[0], self.stage4_tp_filter_coeff[1], stage3_output, zi=self.stage4_tp_filter_zi)
         # Append buffer since steady state
         self.processed_samples += len(raw_data)
         # Steady State after approx. 20 Seconds

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/pqopen/powersystem.py

@@ -28,8 +28,8 @@ import json
 from daqopen.channelbuffer import AcqBuffer, DataChannelBuffer
 from pqopen.zcd import ZeroCrossDetector
 import pqopen.powerquality as pq
-from pqopen.helper import floor_timestamp
-from pqopen.goertzel import calc_single_freq 
+from pqopen.helper import floor_timestamp, create_fft_corr_array
+from pqopen.auxcalc import calc_single_freq, calc_rms_trapz
 logger = logging.getLogger(__name__)
 
 class PowerSystem(object):
@@ -78,6 +78,7 @@ class PowerSystem(object):
         self._zcd_minimum_frequency = zcd_minimum_freq
         self.nominal_frequency = nominal_frequency
         self.nper = nper
+        self._harm_fft_resample_size = 2**int(np.floor(np.log2((self._samplerate / self.nominal_frequency) * self.nper)))
         self._nominal_voltage = None
         self._phases: List[PowerPhase] = []
         self._features = {"harmonics": 0, 
@@ -301,6 +302,17 @@ class PowerSystem(object):
                     tmp = {channel.name: channel for channel in calc_type.values()}
                     self.output_channels.update(tmp)
 
+            if self._features["harmonics"]:
+                for phase in self._phases:
+                    if phase._u_channel.freq_response:
+                        phase._u_fft_corr_array = create_fft_corr_array(self._harm_fft_resample_size//2+1,
+                                                                        self._samplerate/2,
+                                                                        phase._u_channel.freq_response)
+                    if phase._i_channel is not None and phase._i_channel.freq_response:
+                        phase._i_fft_corr_array = create_fft_corr_array(self._harm_fft_resample_size//2+1,
+                                                                        self._samplerate/2,
+                                                                        phase._i_channel.freq_response)
+            
             if self._features["fluctuation"]:
                 for phase in self._phases:
                     phase._voltage_fluctuation_processor = pq.VoltageFluctuation(samplerate=self._samplerate,
@@ -403,18 +415,8 @@ class PowerSystem(object):
             for phys_type, output_channel in phase._calc_channels["one_period"]["voltage"].items():
                 if phys_type == "trms":
                     if self._features["rms_trapz_rule"]:
-                        add_start_idx_sample = 1 if self._last_zc_frac < 0 else 0
-                        add_stop_idx_sample = 1 if actual_zc_frac > 0 else 0
-                        u_trapz_values = phase._u_channel.read_data_by_index(phase_period_start_sidx-add_start_idx_sample, phase_period_stop_sidx+add_stop_idx_sample)
-                        sample_points = np.arange(len(u_values), dtype=np.float64)
-                        if add_start_idx_sample:
-                            u_trapz_values[0] = (u_trapz_values[1] - u_trapz_values[0])*(1+self._last_zc_frac) + u_trapz_values[0]
-                            sample_points = np.insert(sample_points,0,self._last_zc_frac)
-                        if add_stop_idx_sample:
-                            u_trapz_values[-1] = (u_trapz_values[-1] - u_trapz_values[-2])*self._last_zc_frac + u_trapz_values[-2]
-                            sample_points = np.insert(sample_points,len(sample_points),sample_points[-1]+actual_zc_frac)
-                        integral = np.trapezoid(np.power(u_trapz_values,2), sample_points)
-                        u_rms = np.sqrt(integral * frequency / self._samplerate)
+                        u_trapz_values = phase._u_channel.read_data_by_index(phase_period_start_sidx-1, phase_period_stop_sidx+1)
+                        u_rms = calc_rms_trapz(u_trapz_values, self._last_zc_frac, actual_zc_frac, frequency, self._samplerate)     
                     else:
                         u_rms = np.sqrt(np.mean(np.power(u_values, 2)))
                     output_channel.put_data_single(phase_period_stop_sidx, u_rms)
@@ -477,7 +479,9 @@ class PowerSystem(object):
             u_values = phase._u_channel.read_data_by_index(start_sidx, stop_sidx)
             u_rms = np.sqrt(np.mean(np.power(u_values, 2)))
             if self._features["harmonics"]:
-                data_fft_U = pq.resample_and_fft(u_values)
+                data_fft_U = pq.resample_and_fft(u_values, self._harm_fft_resample_size)
+                if phase._u_fft_corr_array is not None:
+                    data_fft_U *= phase._u_fft_corr_array
                 u_h_mag, u_h_phi = pq.calc_harmonics(data_fft_U, self.nper, self._features["harmonics"])
                 u_ih_mag = pq.calc_interharmonics(data_fft_U, self.nper, self._features["harmonics"])
                 if phase._number == 1: # use phase 1 angle as reference
@@ -672,13 +676,8 @@ class PowerSystem(object):
                 self._calculation_mode = "FALLBACK"
         else:
             self._calculation_mode = "NORMAL"
-        
-        # Remove Non monotonic rising zero crossings
-        filtered_zero_crossings = []
-        for idx,zc in enumerate(zero_crossings):
-            if (int(zc)+start_acq_sidx) >= self._zero_crossings[-1] or np.isnan(self._zero_crossings[-1]):
-                filtered_zero_crossings.append(zc)
-        return filtered_zero_crossings
+
+        return zero_crossings
 
     def get_aggregated_data(self, start_acq_sidx: int, stop_acq_sidx: int) -> dict:
         """
@@ -734,6 +733,8 @@ class PowerPhase(object):
         self._calc_channels = {}
         self._voltage_fluctuation_processor: pq.VoltageFluctuation = None
         self._mains_signaling_tracer: pq.MainsSignalingVoltageTracer = None
+        self._u_fft_corr_array = None
+        self._i_fft_corr_array = None
 
     def update_calc_channels(self, features: dict):
         """

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/pqopen/zcd.py

@@ -48,6 +48,7 @@ class ZeroCrossDetector:
         self._last_zc_p = None
         self._last_zc_n = None
         self._last_zc_n_val = None
+        self._last_zc = None
 
         # Calculate the filter delay in samples
         w, h = signal.freqz(self._filter_coeff[0], self._filter_coeff[1], worN=[self.f_cutoff], fs=self.samplerate)
@@ -111,9 +112,15 @@ class ZeroCrossDetector:
             k = (y2 - y1) / (x2 - x1)
             d = y1 - k * x1
             real_zc = -d/k
-            #real_zc = (threshold_p_cross[p_idx] - threshold_n_cross[n_idx] + 1) / 2 + threshold_n_cross[n_idx]
-            zero_crossings.append(real_zc + self.filter_delay_samples)
-            last_used_p_idx = p_idx
+            if np.isnan(real_zc):
+                logger.warning("Detection Error: real_zc is NaN, ignoring")
+            else:
+                if self._last_zc  and (real_zc <= self._last_zc):
+                    logger.warning("Detected ZC before last one, ignoring")
+                else:    
+                    zero_crossings.append(real_zc + self.filter_delay_samples)
+                    last_used_p_idx = p_idx
+                    self._last_zc = real_zc
 
         # Update the last negative threshold-crossing for the next block
         if last_used_p_idx < len(threshold_p_cross) and len(threshold_n_cross) > 0:
@@ -126,4 +133,8 @@ class ZeroCrossDetector:
         else:
             self._last_zc_n = None
 
+        # Update Last Valid ZC Index
+        if self._last_zc:
+            self._last_zc -= len(data)
+
         return zero_crossings

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/pyproject.toml

@@ -12,10 +12,10 @@ packages = ["pqopen"]
 
 [project]
 name = "pqopen-lib"
-version = "0.8.0"
+version = "0.8.2"
 dependencies = [
     "numpy",
-    "daqopen-lib",
+    "daqopen-lib >= 0.7.4",
     "scipy"
 ]
 

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/test/goertzel-test.py

@@ -6,7 +6,7 @@ import numpy as np
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 sys.path.append(os.path.dirname(SCRIPT_DIR))
 
-from pqopen.goertzel import calc_single_freq 
+from pqopen.auxcalc import calc_single_freq 
 
 class TestSingleFrequency(unittest.TestCase):
     def test_fund_only(self):

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/test/helper-test.py

@@ -1,12 +1,13 @@
 import unittest
 import sys
 import os
+import numpy as np
 from datetime import datetime
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 sys.path.append(os.path.dirname(SCRIPT_DIR))
 
-from pqopen.helper import floor_timestamp, JsonDecimalLimiter
+from pqopen.helper import floor_timestamp, JsonDecimalLimiter, create_harm_corr_array, create_fft_corr_array
 
 class TestFloorTimestamp(unittest.TestCase):
 
@@ -100,5 +101,31 @@ class TestLimitDecimalPlaces(unittest.TestCase):
         input_json = '{"sci": 1.23e10}'
         self.assertEqual(float_limiter.process(input_json), input_json)
 
+class TestHarmCorrCreater(unittest.TestCase):
+
+    def test_harmonic(self):
+        freq_response = ((50, 1.0), (100, 0.9))
+        expected_corr_factors = 1/np.array([1, 1, 0.9, 0.9, 0.9, 0.9])
+        corr_factors = create_harm_corr_array(50, 5, freq_response)
+
+        self.assertIsNone(np.testing.assert_array_almost_equal(corr_factors, expected_corr_factors))
+
+    def test_interharmonic(self):
+        freq_response = ((50, 1.0), (100, 0.9))
+        expected_corr_factors = 1/np.array([1, 0.95, 0.9, 0.9, 0.9, 0.9])
+        corr_factors = create_harm_corr_array(50, 5, freq_response, interharm=True)
+
+        self.assertIsNone(np.testing.assert_array_almost_equal(corr_factors, expected_corr_factors))
+
+class TestFftCorrCreater(unittest.TestCase):
+
+    def test_small(self):
+        freq_response = ((50, 1.0), (100, 0.9))
+
+        expected_corr_factors = 1/np.array([1, 1, 0.9, 0.9, 0.9, 0.9])
+        corr_factors = create_fft_corr_array(6, 250, freq_response)
+
+        self.assertIsNone(np.testing.assert_array_almost_equal(corr_factors, expected_corr_factors))
+
 if __name__ == '__main__':
     unittest.main()

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/test/powerquality-test.py

@@ -69,7 +69,7 @@ class TestPowerPowerQualityFlicker(unittest.TestCase):
 
         blocksize = 1000
         for blk_idx in range(t.size // blocksize):
-            hp_data = 230*np.ones(samplerate//blocksize*f_fund*2)
+            hp_data = 230*np.ones((f_fund*2*blocksize)//samplerate)
             voltage_fluctuation.process(blk_idx*blocksize, hp_data, u_values[blk_idx*blocksize:(blk_idx+1)*blocksize])
         pst = voltage_fluctuation.calc_pst(0, duration*samplerate)
 
@@ -90,7 +90,7 @@ class TestPowerPowerQualityFlicker(unittest.TestCase):
 
         blocksize = 1000
         for blk_idx in range(t.size // blocksize):
-            hp_data = 230*np.ones(samplerate//blocksize*f_fund*2)
+            hp_data = 230*np.ones((f_fund*2*blocksize)//samplerate)
             voltage_fluctuation.process(blk_idx*blocksize, hp_data, u_values[blk_idx*blocksize:(blk_idx+1)*blocksize])
         pinst_1s, _ = voltage_fluctuation._pinst_channel.read_data_by_acq_sidx((duration-1)*samplerate, duration*samplerate)
 

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/test/powersystem-test.py

@@ -249,6 +249,40 @@ class TestPowerSystemCalculation(unittest.TestCase):
         freq, _ = self.power_system.output_channels["Freq"].read_data_by_acq_sidx(0, u_values.size)
         self.assertIsNone(np.testing.assert_array_almost_equal(freq[1:], expected_freq, 3))
 
+class TestPowerSystemCalculationFreqResponse(unittest.TestCase):
+    def setUp(self):
+        self.u_channel = AcqBuffer(freq_response=((50,1.0), (100,0.9)))
+        self.i_channel = AcqBuffer()
+
+        # Create PowerSystem instance
+        self.power_system = PowerSystem(
+            zcd_channel=self.u_channel,
+            input_samplerate=10000.0,
+            zcd_threshold=0.1
+        )
+        # Add Phase
+        self.power_system.add_phase(u_channel=self.u_channel, i_channel=self.i_channel)
+
+    def test_multi_period_calc_harmonic_msv(self):
+        t = np.linspace(0, 1, int(self.power_system._samplerate), endpoint=False)
+        u_values = np.sqrt(2)*np.sin(2*np.pi*50*t) + 0.09*np.sqrt(2)*np.sin(2*np.pi*150*t) + 0.009*np.sqrt(2)*np.sin(2*np.pi*375*t)
+        i_values = 2*np.sqrt(2)*np.sin(2*np.pi*50*t+60*np.pi/180) # cos_phi = 0.5
+
+        expected_u_h3_rms = np.array(np.zeros(4)) + 0.1
+        expected_u_msv_rms = np.array(np.zeros(4)) + 0.01
+
+        self.power_system.enable_harmonic_calculation(10)
+        self.power_system.enable_mains_signaling_calculation(375)
+        self.u_channel.put_data(u_values)
+        self.i_channel.put_data(i_values)
+        self.power_system.process()
+
+        # Check Voltage        
+        u_h_rms, _ = self.power_system.output_channels["U1_H_rms"].read_data_by_acq_sidx(0, u_values.size)
+        self.assertIsNone(np.testing.assert_allclose(u_h_rms[:,3], expected_u_h3_rms, rtol=0.01))
+        u_msv_rms, _ = self.power_system.output_channels["U1_msv_rms"].read_data_by_acq_sidx(0, u_values.size)
+        self.assertIsNone(np.testing.assert_allclose(u_msv_rms, expected_u_msv_rms, rtol=0.01))
+
 class TestPowerSystemCalculationThreePhase(unittest.TestCase):
     def setUp(self):
         self.u1_channel = AcqBuffer()

{pqopen_lib-0.8.0 → pqopen_lib-0.8.2}/test/storagecontroller-test.py

@@ -88,7 +88,7 @@ class TestStorageController(unittest.TestCase):
 
         self.storage_controller.process_events(events)
 
-        self.assertEqual(storage_endpoint._event_list[0].start_ts, 0.01)
+        self.assertAlmostEqual(storage_endpoint._event_list[0].start_ts, 0.01)
 
     def test_one_storageplan_series_slow(self):
         start_timestamp = int(1000000000*1e6)