pqopen-lib 0.7.6__tar.gz → 0.7.7__tar.gz

{pqopen_lib-0.7.6 → pqopen_lib-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pqopen-lib
-Version: 0.7.6
+Version: 0.7.7
 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
@@ -13,6 +13,8 @@ Requires-Python: >=3.11
 Requires-Dist: daqopen-lib
 Requires-Dist: numpy
 Requires-Dist: scipy
+Provides-Extra: numba
+Requires-Dist: numba; extra == 'numba'
 Description-Content-Type: text/markdown
 
 # pqopen-lib

pqopen_lib-0.7.7/pqopen/goertzel.py

@@ -0,0 +1,58 @@
+import numpy as np
+try:
+    from numba import njit, float32, float64
+except ImportError:
+    # Dummy-Decorator if numba not available
+    def njit(func=None, **kwargs):
+        if func is None:
+            return lambda f: f
+        return func
+    float32 = float64 = None
+
+@njit
+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.
+
+    Parameters:
+        x: Input signal (time-domain samples).
+        f_hz: Target frequency in Hertz (Hz).
+        fs: Sampling frequency of the signal in Hertz (Hz).
+
+    Returns:
+        tuple:
+            amp: Amplitude of the frequency component.
+            phase: Phase of the frequency component in radians.
+    """
+    N = len(x)                  # Number of samples
+    k = (f_hz * N) / fs         # Corresponding DFT bin index (can be fractional)
+    w = 2 * np.pi * k / N       # Angular frequency for the bin
+    cw = np.cos(w)              # Cosine component
+    c = 2 * cw                  # Multiplier used in recurrence relation
+    sw = np.sin(w)              # Sine component
+    z1, z2 = 0, 0               # Initialize state variables
+
+    # Recursive filter loop
+    for n in range(N):
+        z0 = x[n] + c * z1 - z2  # Apply recurrence relation
+        z2 = z1                  # Shift states
+        z1 = z0
+
+    # Compute real and imaginary parts of the result
+    ip = cw * z1 - z2   # In-phase (real) component
+    qp = sw * z1        # Quadrature (imaginary) component
+
+    # Compute amplitude and phase of the frequency component
+    amp = np.sqrt((ip**2 + qp**2)/2) / (N / 2)
+    phase = np.arctan2(qp, ip)
+
+    return amp, phase
+
+# >>>>>>> Pre-Compile for float32 und float64 <<<<<<<
+if float32 is not None and float64 is not None:
+    sigs = [
+        "(float32[:], float32, float32)",
+        "(float64[:], float64, float64)"
+    ]
+    for sig in sigs:
+        calc_single_freq.compile(sig)

{pqopen_lib-0.7.6 → pqopen_lib-0.7.7}/pqopen/powersystem.py

@@ -29,7 +29,7 @@ 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 
 logger = logging.getLogger(__name__)
 
 class PowerSystem(object):
@@ -87,7 +87,8 @@ class PowerSystem(object):
                           "under_over_deviation": 0,
                           "mains_signaling_tracer": {},
                           "debug_channels": False,
-                          "energy_channels": {}}
+                          "energy_channels": {},
+                          "one_period_fundamental": False}
         self._prepare_calc_channels()
         self.output_channels: Dict[str, DataChannelBuffer] = {}
         self._last_processed_sidx = 0
@@ -213,6 +214,13 @@ class PowerSystem(object):
         self._features["energy_channels"] = {"persist_file": persist_file, "energy_counters": energy_counters}
         self._channel_update_needed = True
 
+    def enable_one_period_fundamental(self):
+        """
+        Enables the calculation of one (single) period fundamental values
+        """
+        self._features["one_period_fundamental"] = True
+        self._channel_update_needed = True
+
     def _resync_nper_abs_time(self, zc_idx: int):
         if not self._features["nper_abs_time_sync"]:
             return None
@@ -366,6 +374,10 @@ class PowerSystem(object):
                     output_channel.put_data_single(phase_period_stop_sidx, msv_value)
                 if phys_type == "slope":
                     output_channel.put_data_single(phase_period_stop_sidx, np.abs(np.diff(u_values)).max())
+                if phys_type == "fund_rms":
+                    # Use sample-discrete frequency, not the exact one for full cycle
+                    fund_amp, fund_phase = calc_single_freq(u_values, self._samplerate/len(u_values), self._samplerate)
+                    output_channel.put_data_single(phase_period_stop_sidx, fund_amp)
             for phys_type, output_channel in phase._calc_channels["half_period"]["voltage"].items():
                 if phys_type == "trms":
                     # First half period
@@ -641,6 +653,7 @@ class PowerPhase(object):
         self._calc_channels["half_period"]["voltage"]["trms"] = DataChannelBuffer('U{:s}_hp_rms'.format(self.name), agg_type='rms', unit="V")
         self._calc_channels["one_period"]["voltage"]["trms"] = DataChannelBuffer('U{:s}_1p_rms'.format(self.name), agg_type='rms', unit="V")
         self._calc_channels["one_period"]["voltage"]["slope"] = DataChannelBuffer('U{:s}_1p_slope'.format(self.name), agg_type='max', unit="V/s")
+        self._calc_channels["one_period"]["voltage"]["fund_rms"] = DataChannelBuffer('U{:s}_1p_H1_rms'.format(self.name), agg_type='rms', unit="V")
         self._calc_channels["one_period_ovlp"]["voltage"]["trms"] = DataChannelBuffer('U{:s}_1p_hp_rms'.format(self.name), agg_type='rms', unit="V")
         self._calc_channels["multi_period"]["voltage"]["trms"] = DataChannelBuffer('U{:s}_rms'.format(self.name), agg_type='rms', unit="V")
 

{pqopen_lib-0.7.6 → pqopen_lib-0.7.7}/pyproject.toml

@@ -12,7 +12,7 @@ packages = ["pqopen"]
 
 [project]
 name = "pqopen-lib"
-version = "0.7.6"
+version = "0.7.7"
 dependencies = [
     "numpy",
     "daqopen-lib",
@@ -30,6 +30,9 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 
+[project.optional-dependencies]
+numba = ["numba"]
+
 [project.urls]
 Homepage = "https://github.com/DaqOpen/pqopen-lib"
 Issues = "https://github.com/DaqOpen/pqopen-lib/issues"

pqopen_lib-0.7.7/test/goertzel-test.py

@@ -0,0 +1,32 @@
+import unittest
+import sys
+import os
+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 
+
+class TestSingleFrequency(unittest.TestCase):
+    def test_fund_only(self):
+        fs = 100
+        t = np.arange(0, 1, 1/fs)
+        u = np.sqrt(2)*np.sin(2*np.pi*t)
+        amp, phase = calc_single_freq(u, 1, fs)
+
+        self.assertAlmostEqual(1, amp)
+        self.assertAlmostEqual(-90*np.pi/180, phase)
+
+    def test_mixed(self):
+        fs = 100
+        t = np.arange(0, 1, 1/fs)
+        u = np.sqrt(2)*np.sin(2*np.pi*t)
+        u += 0.5*np.sqrt(2)*np.sin(2*3*np.pi*t)
+        amp, phase = calc_single_freq(u, 1, fs)
+
+        self.assertAlmostEqual(1, amp)
+        self.assertAlmostEqual(-90*np.pi/180, phase)
+
+if __name__ == "__main__":
+    unittest.main()