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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pqopen-lib
-Version: 0.8.4
+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.4 → 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.4 → 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)
@@ -676,6 +699,14 @@ class PowerSystem(object):
                             self._last_known_freq = self.nominal_frequency
                 self._calculation_mode = "FALLBACK"
         elif self._calculation_mode == "FALLBACK":
+            remaining_virtual_zc = []
+            last_rel_zc = self._zero_crossings[-1] - start_acq_sidx 
+            zc_gap = zero_crossings[0] - last_rel_zc
+            num_zc_to_fill = int(zc_gap / (self._samplerate/self._last_known_freq)) + 1
+            virtual_zc_interval = int(zc_gap / num_zc_to_fill)
+            remaining_virtual_zc = [last_rel_zc + i*virtual_zc_interval for i in range(1,num_zc_to_fill)]
+            logger.debug("Finishing Fallback: Added virtual zero crossing: idx=" + ",".join([f"{virtual_zc:.1f}" for virtual_zc in remaining_virtual_zc]))
+            zero_crossings = remaining_virtual_zc + zero_crossings
             self._calculation_mode = "NORMAL"
         else:
             self._calculation_mode = "NORMAL"
@@ -698,6 +729,21 @@ class PowerSystem(object):
             output_values[ch_name] = ch_data
         return output_values
     
+    def get_channel_info(self) -> dict:
+        channel_info = {}
+        for phase in self._phases:
+            for calc_interval, interval_group in phase._calc_channels.items():
+                for derived_type, phys_group in interval_group.items():
+                    for phys_type, channel in phys_group.items():
+                        channel_info[channel.name] = {
+                            "unit": channel.unit,
+                            "phys_type": phys_type,
+                            "derived_type": derived_type,
+                            "calc_interval": calc_interval,
+                            "phase": phase.name
+                        }
+        return channel_info
+    
     def __del__(self):
         if self._features["energy_channels"]:
             w_pos_value = float(self._calc_channels["multi_period"]["energy"]["w_pos"].last_sample_value)
@@ -787,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.4 → pqopen_lib-0.9.0}/pqopen/storagecontroller.py

@@ -57,11 +57,13 @@ import numpy as np
 from pqopen.helper import floor_timestamp, JsonDecimalLimiter
 from pqopen.eventdetector import Event
 from daqopen.channelbuffer import DataChannelBuffer, AcqBuffer
+from daqopen.daqinfo import DaqInfo
 from pathlib import Path
 from typing import List, Dict
 import logging
 import json
 import gzip
+import time
 import paho.mqtt.client as mqtt
 
 
@@ -91,7 +93,7 @@ class StorageEndpoint(object):
         """
         Writes aggregated data to the storage endpoint.
 
-        Args:
+        Parameters:
             data: The aggregated data to store.
             timestamp_us: The timestamp in microseconds for the aggregated data.
             interval_seconds: The aggregation interval in seconds.
@@ -101,6 +103,17 @@ class StorageEndpoint(object):
     def write_event(self, event: Event):
         pass
 
+    def write_measurement_config(self, m_config: dict, daq_info: DaqInfo, channe_info: dict, **kwargs):
+        """
+        Writes measurement config to the storage endpoint.
+
+        Parameters:
+            m_config: The measurement config to store.
+            daq_info: The daq info to store.
+            channel_info: The channel's specific infos
+        """
+        pass
+
 class StoragePlan(object):
     """Defines a plan for storing data with specified intervals and channels."""
 
@@ -190,6 +203,9 @@ class StoragePlan(object):
         if self._store_events_enabled:
             self.storage_endpoint.write_event(event, **self._additional_config)
 
+    def store_measurement_config(self, m_config: dict, daq_info: DaqInfo, channel_info: dict):
+        self.storage_endpoint.write_measurement_config(m_config, daq_info, channel_info, **self._additional_config)
+
 class StorageController(object):
     """Manages multiple storage plans and processes data for storage."""
 
@@ -304,7 +320,10 @@ class StorageController(object):
                                          available_channels: dict, 
                                          measurement_id: str, 
                                          device_id: str,
-                                         start_timestamp_us: int):
+                                         start_timestamp_us: int,
+                                         m_config: dict | None = None,
+                                         daq_info: DaqInfo | None = None,
+                                         channel_info: dict| None = None):
         """
         Setup endpoints and storage plans from config
 
@@ -319,7 +338,7 @@ class StorageController(object):
         Raises:
             NotImplementedError: If a not implemented endpoint will be configured
         """
-        self._configured_eps = {}
+        self._configured_eps: dict[str, StorageEndpoint] = {}
         for ep_type, ep_config in endpoints.items():
             if ep_type == "csv":
                 csv_storage_endpoint = CsvStorageEndpoint("csv", measurement_id, ep_config.get("data_dir", "/tmp/"))
@@ -375,8 +394,11 @@ class StorageController(object):
                     else:      
                         logger.warning(f"Channel {channel} not available for storing")
             self.add_storage_plan(storage_plan)
-
-            
+            # Initially store the measurement config if configured
+            if sp_config.get("store_config", False) and m_config and daq_info and channel_info:
+                storage_plan.store_measurement_config(m_config=m_config,
+                                                      daq_info=daq_info,
+                                                      channel_info=channel_info)
 
 class TestStorageEndpoint(StorageEndpoint):
     """A implementation of StorageEndpoint for testing purposes."""
@@ -499,6 +521,27 @@ class MqttStorageEndpoint(StorageEndpoint):
             self._client.publish(topic_prefix + f"/{self._device_id:s}/event/json",
                             json_item.encode('utf-8'), qos=2)
             
+    def write_measurement_config(self, m_config: dict, daq_info: DaqInfo, channel_info: dict, **kwargs):
+        """
+        Write measurement config
+        """
+        m_config_object = {
+            "type": "m_config",
+            "measurement_uuid": self.measurement_id,
+            "timestamp": time.time(),
+            "m_config": m_config,
+            "daq_info": daq_info.to_dict(),
+            "channel_info": channel_info
+        }
+        json_item = json.dumps(m_config_object)
+        topic_prefix = kwargs.get("mqtt_topic_prefix", self._topic_prefix)
+        if self._compression:
+            self._client.publish(topic_prefix + f"/{self._device_id:s}/m_config/gjson",
+                            gzip.compress(json_item.encode('utf-8')), qos=2)
+        else:
+            self._client.publish(topic_prefix + f"/{self._device_id:s}/m_config/json",
+                            json_item.encode('utf-8'), qos=2)
+            
 class HomeAssistantStorageEndpoint(StorageEndpoint):
     """Represents a MQTT endpoint (MQTT) for HomeAssistant."""
     def __init__(self, 

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

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

{pqopen_lib-0.8.4 → 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.4 → pqopen_lib-0.9.0}/test/powersystem-test.py

@@ -52,6 +52,12 @@ class TestPowerSystemChannelConfig(unittest.TestCase):
         # Assuming process is to be implemented, we just check its existence
         self.assertTrue(callable(self.power_system.process))
 
+    def test_get_channel_info(self):
+        self.power_system.add_phase(u_channel=self.mock_acq_buffer)
+        self.power_system._update_calc_channels()
+        channel_info = self.power_system.get_channel_info()
+        self.assertTrue(isinstance(channel_info, dict))
+
 class TestPowerPhaseChannelConfig(unittest.TestCase):
     def setUp(self):
         # Mock AcqBuffer
@@ -267,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
@@ -299,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()