pqopen-lib 0.8.1__tar.gz → 0.8.3__tar.gz

{pqopen_lib-0.8.1 → pqopen_lib-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pqopen-lib
-Version: 0.8.1
+Version: 0.8.3
 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.1/pqopen/goertzel.py → pqopen_lib-0.8.3/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.1 → pqopen_lib-0.8.3}/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.1 → pqopen_lib-0.8.3}/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.1 → pqopen_lib-0.8.3}/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,
+                                                                        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,
+                                                                        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,10 @@ 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:
+                    resample_factor =  min(self._harm_fft_resample_size / u_values.size, 1)
+                    data_fft_U *= phase._u_fft_corr_array[np.linspace(0, self._harm_fft_resample_size*resample_factor, self._harm_fft_resample_size//2+1).astype(np.int32)]
                 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
@@ -729,6 +734,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.1 → pqopen_lib-0.8.3}/pyproject.toml

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

{pqopen_lib-0.8.1 → pqopen_lib-0.8.3}/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.1 → pqopen_lib-0.8.3}/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.1 → pqopen_lib-0.8.3}/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.1 → pqopen_lib-0.8.3}/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.1 → pqopen_lib-0.8.3}/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)