pqopen-lib 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

pqopen/{goertzel.py → 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/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/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/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/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.dist-info → pqopen_lib-0.8.2.dist-info}/METADATA

@@ -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.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+pqopen/__init__.py,sha256=sMVEOm5j6AZYnnEox5PHOUyZlL5TJjpsNMm5ATLx6ec,329
+pqopen/auxcalc.py,sha256=P11Nu9pgJRoPYZDjLk-mXI6Ha02LoTH5bS9FdFTvC9M,2733
+pqopen/eventdetector.py,sha256=NKZU7GbeorZdkYu3ET4lhMaeynw70GhIGO2p1xH4aTA,11962
+pqopen/helper.py,sha256=0msrm6i1v8jj2Z5X8F7wDEW0KD5i91RBNZwPJC05YrA,2533
+pqopen/powerquality.py,sha256=dRVCedWa1QJKHgdiYoIIdvhH_p40cwpgeUePO5u1j28,15953
+pqopen/powersystem.py,sha256=R9nOIv5Qpuc1JPDzP67NGP9LNqB74unpY85yS1CuWPg,48921
+pqopen/storagecontroller.py,sha256=AhVaPgIh4CBKKMJm9Ja0dOjVd4dLppWprxeeg3vrmAk,31266
+pqopen/zcd.py,sha256=jN4jkGgFNBWQWRebefLc1GjUKm1xdYQXav_ajYfkuo4,6054
+pqopen_lib-0.8.2.dist-info/METADATA,sha256=tdCcqLVphJ4slcPgOe9gofVITNC2k4qNMnPwuViNCAE,4787
+pqopen_lib-0.8.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pqopen_lib-0.8.2.dist-info/licenses/LICENSE,sha256=yhYwu9dioytbAvNQa0UBwaBVcALqiOoBViEs4HLW6aU,1064
+pqopen_lib-0.8.2.dist-info/RECORD,,

{pqopen_lib-0.8.0.dist-info → pqopen_lib-0.8.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pqopen_lib-0.8.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-pqopen/__init__.py,sha256=sMVEOm5j6AZYnnEox5PHOUyZlL5TJjpsNMm5ATLx6ec,329
-pqopen/eventdetector.py,sha256=NKZU7GbeorZdkYu3ET4lhMaeynw70GhIGO2p1xH4aTA,11962
-pqopen/goertzel.py,sha256=JhehuEj-xNnwQEh4Ti8dXiGvfDmxbdEoaxIsFswZNcM,2008
-pqopen/helper.py,sha256=bM_wDck5OfeEy96U_2FjCwZuLZRPYyKVeiYD3-vzP6M,1761
-pqopen/powerquality.py,sha256=Qwyaj7BQqQPRivei140mv-Leh6u9uIQzViKLOY7bHyw,17877
-pqopen/powersystem.py,sha256=unaQLrCb5V1l6kjX6R186MflAV9BsWVeJd_Sc8azsq8,48895
-pqopen/storagecontroller.py,sha256=AhVaPgIh4CBKKMJm9Ja0dOjVd4dLppWprxeeg3vrmAk,31266
-pqopen/zcd.py,sha256=cqGURF6dtvdYanI-vby95Gn9Kvh8F4cfKCqUFlyM15Y,5678
-pqopen_lib-0.8.0.dist-info/METADATA,sha256=pvr3sXmlAPcGiEYp9KEqgcrZ1-qKEFkVrgxvRQQKB5E,4780
-pqopen_lib-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pqopen_lib-0.8.0.dist-info/licenses/LICENSE,sha256=yhYwu9dioytbAvNQa0UBwaBVcALqiOoBViEs4HLW6aU,1064
-pqopen_lib-0.8.0.dist-info/RECORD,,