pqopen-lib 0.8.5__tar.gz → 0.9.0__tar.gz

{pqopen_lib-0.8.5 → pqopen_lib-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pqopen-lib
-Version: 0.8.5
+Version: 0.9.0
 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

{pqopen_lib-0.8.5 → pqopen_lib-0.9.0}/pqopen/powerquality.py

@@ -63,6 +63,19 @@ def calc_thd(harm_rms: np.ndarray, max_harmonic: int = 40, min_harmonic: int = 2
         thd = np.sqrt(np.sum(np.power(harm_rms[min_harmonic:max_harmonic+1]/fund_rms, 2)))*100
     return thd
 
+def calc_hf_1khz_band(fft_data: np.ndarray, samplerate: float):
+    fft_data_abs = np.abs(fft_data)
+    freq_resolution = 0.5*samplerate / fft_data_abs.shape[0]
+    freq_steps = np.arange(-500, (samplerate/2) + 1500 - (samplerate/2) % 1000, 1000)
+    freq_steps[0] = 0
+    freq_steps[-1] = samplerate/2
+    freq_band_idx = (freq_steps / freq_resolution).astype(int)
+    hf_1khz_band_rms = []
+    for band_idx in range(freq_band_idx.shape[0] - 1):
+        hf_1khz_band_rms.append(np.sqrt(np.sum(fft_data_abs[freq_band_idx[band_idx]:freq_band_idx[band_idx+1]])))
+    
+    return np.array(hf_1khz_band_rms)
+
 def resample_and_fft(data: np.ndarray, resample_size: int = None) -> np.ndarray:
     """
     Resample the input data to a specified size and compute its FFT.

{pqopen_lib-0.8.5 → pqopen_lib-0.9.0}/pqopen/powersystem.py

@@ -24,6 +24,7 @@ from typing import List, Dict
 import logging
 from pathlib import Path
 import json
+from scipy.signal import get_window
 
 from daqopen.channelbuffer import AcqBuffer, DataChannelBuffer
 from pqopen.zcd import ZeroCrossDetector
@@ -91,7 +92,8 @@ class PowerSystem(object):
                           "energy_channels": {},
                           "one_period_fundamental": 0,
                           "rms_trapz_rule": False,
-                          "pmu_calculation": False}
+                          "pmu_calculation": False,
+                          "hf_1khz_band_calculation": False}
         self._prepare_calc_channels()
         self.output_channels: Dict[str, DataChannelBuffer] = {}
         self._last_processed_sidx = 0
@@ -246,6 +248,15 @@ class PowerSystem(object):
         self._pmu_last_processed_ts_us = 0
         self._pmu_time_increment_us = int(1_000_000 / self.nominal_frequency)
 
+    def enable_hf_1khz_band_calculation(self):
+        """
+        Enables the calculation of wide band analysis with 1 kHz bands (non standard)
+        """
+        num_bands = int(self._samplerate*0.5 / 1000) + 1
+        self._features["hf_1khz_band_calculation"] = num_bands
+        self._hf_1khz_window = get_window("hann", self._harm_fft_resample_size)
+        self._channel_update_needed = True
+
     def _resync_nper_abs_time(self, zc_idx: int):
         if not self._features["nper_abs_time_sync"]:
             return None
@@ -305,11 +316,11 @@ class PowerSystem(object):
             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,
+                        phase._u_fft_corr_array = create_fft_corr_array(int((self._samplerate / self.nominal_frequency) * self.nper / 2),
                                                                         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,
+                        phase._i_fft_corr_array = create_fft_corr_array(int((self._samplerate / self.nominal_frequency) * self.nper / 2),
                                                                         self._samplerate/2,
                                                                         phase._i_channel.freq_response)
             
@@ -482,7 +493,8 @@ class PowerSystem(object):
                 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)]
+                    corr_freq_idx = np.linspace(0, self._samplerate*0.5*resample_factor*self.nper/self.nominal_frequency, self._harm_fft_resample_size//2+1).astype(np.int32)
+                    data_fft_U *= phase._u_fft_corr_array[corr_freq_idx]
                 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
@@ -511,6 +523,17 @@ class PowerSystem(object):
                     output_channel.put_data_single(stop_sidx, u_rms)
                 if phys_type == "over":
                     output_channel.put_data_single(stop_sidx, u_rms)
+                if phys_type == "hf_1khz_rms":
+                    u_values_windowed = u_values[:self._harm_fft_resample_size]*self._hf_1khz_window
+                    u_real_fft = np.fft.rfft(u_values_windowed)
+                    #u_real_fft = np.fft.rfft(u_values_windowed)
+                    if phase._u_fft_corr_array is not None:
+                        corr_freq_idx = np.linspace(0, self._samplerate*0.5, u_real_fft.shape[0]).astype(np.int32)
+                        u_real_fft *= phase._u_fft_corr_array[corr_freq_idx]
+                    u_Pxx = (np.abs(u_real_fft) ** 2) / np.sum(self._hf_1khz_window ** 2)
+                    u_Pxx /= self._harm_fft_resample_size * 0.5
+                    u_hf_1khz = pq.calc_hf_1khz_band(u_Pxx, self._samplerate)
+                    output_channel.put_data_single(stop_sidx, u_hf_1khz)
                 
             if phase._i_channel:
                 i_values = phase._i_channel.read_data_by_index(start_sidx, stop_sidx)
@@ -810,6 +833,10 @@ class PowerPhase(object):
             self._calc_channels["pmu"]["voltage"]["rms"] = DataChannelBuffer('U{:s}_pmu_rms'.format(self.name), agg_type='rms', unit="V")
             self._calc_channels["pmu"]["voltage"]["phi"] = DataChannelBuffer('U{:s}_pmu_phi'.format(self.name), agg_type='phi', unit="°")
 
+        if "hf_1khz_band_calculation" in features and features["hf_1khz_band_calculation"]:
+            num_bands = features["hf_1khz_band_calculation"]
+            self._calc_channels["multi_period"]["voltage"]["hf_1khz_rms"] = DataChannelBuffer('U{:s}_HF_1kHz_rms'.format(self.name), sample_dimension=num_bands, agg_type='rms', unit="V")
+
         # Create Current Channels
         if self._i_channel:
             self._calc_channels["one_period"]["current"] = {}

{pqopen_lib-0.8.5 → pqopen_lib-0.9.0}/pyproject.toml

@@ -12,7 +12,7 @@ packages = ["pqopen"]
 
 [project]
 name = "pqopen-lib"
-version = "0.8.5"
+version = "0.9.0"
 dependencies = [
     "numpy",
     "daqopen-lib >= 0.7.4",

{pqopen_lib-0.8.5 → pqopen_lib-0.9.0}/test/powerquality-test.py

@@ -8,16 +8,17 @@ sys.path.append(os.path.dirname(SCRIPT_DIR))
 
 import pqopen.powerquality as pq
 from daqopen.channelbuffer import DataChannelBuffer
+from pqopen.helper import create_fft_corr_array
 
 class TestPowerPowerQualityHarmonic(unittest.TestCase):
     def setUp(self):
         ...
 
     def test_simple(self):
-        samplerate = 1000
+        samplerate = 5000
         f_fund = 50.0
         num_periods = 10
-        t = np.linspace(0, 0.2, samplerate, endpoint=False)
+        t = np.linspace(0, 0.2, int(samplerate*0.2), endpoint=False)
         values = np.sqrt(2)*np.sin(2*np.pi*f_fund*t) + 0.1*np.sqrt(2)*np.sin(2*np.pi*2*f_fund*t + 45*np.pi/2)
         expected_v_h_rms = [0, 1, 0.1, 0, 0, 0, 0, 0, 0, 0, 0]
 
@@ -29,10 +30,10 @@ class TestPowerPowerQualityHarmonic(unittest.TestCase):
         self.assertAlmostEqual(v_h_phi[2], -90+45*2, places=2)
 
     def test_advanced(self):
-        samplerate = 1000
+        samplerate = 5000
         f_fund = 53.0
         num_periods = 10
-        t = np.linspace(0, num_periods/f_fund, samplerate, endpoint=False)
+        t = np.linspace(0, num_periods/f_fund, int(samplerate*num_periods/f_fund), endpoint=False)
         values = (1.0*np.sqrt(2)*np.sin(2*np.pi*1.0*f_fund*t) + 
                   0.1*np.sqrt(2)*np.sin(2*np.pi*1.5*f_fund*t + 45*np.pi/2)+
                   0.1*np.sqrt(2)*np.sin(2*np.pi*2.0*f_fund*t + 45*np.pi/2))
@@ -53,6 +54,33 @@ class TestPowerPowerQualityHarmonic(unittest.TestCase):
         self.assertAlmostEqual(v_h_phi[2], -90+45*2, places=2)
         self.assertAlmostEqual(v_thd, expected_v_thd, places=1)
 
+    def test_freq_response_correction(self):
+        samplerate = 5000
+        nominal_frequency = 50
+        f_fund = 45
+        num_periods = 10
+        harm_fft_resample_size = 512
+        t = np.linspace(0, num_periods/f_fund, int(samplerate*num_periods/f_fund), endpoint=False)
+        values = (1.0*np.sqrt(2)*np.sin(2*np.pi*1.0*f_fund*t) + 
+                  0.1*np.sqrt(2)*np.sin(2*np.pi*1.5*f_fund*t + 45*np.pi/2)+
+                  0.1*np.sqrt(2)*np.sin(2*np.pi*2.0*f_fund*t + 45*np.pi/2)+
+                  0.1*np.sqrt(2)*np.sin(2*np.pi*5.0*f_fund*t + 45*np.pi/2))
+        freq_response = ((50, 1.0), (200, 1.0), (225, 0.5))
+        expected_v_h_rms = [0, 1, 0.1, 0, 0, 0.2, 0, 0, 0, 0, 0]
+
+        v_fft = pq.resample_and_fft(values, resample_size=harm_fft_resample_size)
+        resample_factor = v_fft.shape[0]*2 / values.shape[0]
+
+        v_fft_corr_array = create_fft_corr_array(int((samplerate / nominal_frequency) * num_periods / 2),
+                                                 samplerate*0.5,
+                                                 freq_response)
+
+        corr_array_to_apply = v_fft_corr_array[np.linspace(0, samplerate*0.5*resample_factor*num_periods/nominal_frequency, harm_fft_resample_size//2+1).astype(np.int32)]
+        v_fft *= corr_array_to_apply
+        v_h_rms, v_h_phi = pq.calc_harmonics(v_fft, 10, 10)
+
+        self.assertIsNone(np.testing.assert_allclose(v_h_rms, expected_v_h_rms, atol=0.01))
+
 
 class TestPowerPowerQualityFlicker(unittest.TestCase):
     def setUp(self):

{pqopen_lib-0.8.5 → pqopen_lib-0.9.0}/test/powersystem-test.py

@@ -273,7 +273,7 @@ class TestPowerSystemCalculation(unittest.TestCase):
 
 class TestPowerSystemCalculationFreqResponse(unittest.TestCase):
     def setUp(self):
-        self.u_channel = AcqBuffer(freq_response=((50,1.0), (100,0.9)))
+        self.u_channel = AcqBuffer(freq_response=((50,1.0), (100,0.9), (1000, 0.9), (2000, 0.7)))
         self.i_channel = AcqBuffer()
 
         # Create PowerSystem instance
@@ -305,6 +305,24 @@ class TestPowerSystemCalculationFreqResponse(unittest.TestCase):
         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))
 
+    def test_hf_1khz_band_calc(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.2*np.sqrt(2)*np.sin(2*np.pi*1000*t) + 
+                    0.1*np.sqrt(2)*np.sin(2*np.pi*2000*t))
+        i_values = 2*np.sqrt(2)*np.sin(2*np.pi*50*t+60*np.pi/180) # cos_phi = 0.5
+
+        expected_u_hf_rms = np.array([1, 0.2, 0.1, 0, 0, 0])
+
+        self.power_system.enable_hf_1khz_band_calculation()
+        self.u_channel.put_data(u_values)
+        self.i_channel.put_data(i_values)
+        self.power_system.process()
+
+        # Check Voltage        
+        u_hf_rms, _ = self.power_system.output_channels["U1_HF_1kHz_rms"].read_data_by_acq_sidx(0, u_values.size)
+        self.assertIsNone(np.testing.assert_allclose(u_hf_rms[3,:], expected_u_hf_rms, atol=0.01))
+
 class TestPowerSystemCalculationThreePhase(unittest.TestCase):
     def setUp(self):
         self.u1_channel = AcqBuffer()