pqopen-lib 0.8.4__py3-none-any.whl → 0.9.0__py3-none-any.whl

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/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/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.dist-info → pqopen_lib-0.9.0.dist-info}/METADATA

@@ -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.9.0.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=Cg7rwXOo3S63idE4XmrlC8CXHgGHbqI6-Urmhlg6ySc,16558
+pqopen/powersystem.py,sha256=1Fi5SbS4PsUNz3hANjJBzTNtuM5bvQ6Oivae80K6RXI,52415
+pqopen/storagecontroller.py,sha256=8JkeRX3HDWGFR40wO1ejxctQp53eMgEtsJMbOl7ea1Y,33468
+pqopen/zcd.py,sha256=olJZsHRd1CjU65vysc2emR5wFGMkayIWdUEDNE8jfIc,6253
+pqopen_lib-0.9.0.dist-info/METADATA,sha256=-UoUljXNQMLQUuR0GE_bBZpBY_sdBl5k5G1ZZ8GCwOw,4787
+pqopen_lib-0.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pqopen_lib-0.9.0.dist-info/licenses/LICENSE,sha256=yhYwu9dioytbAvNQa0UBwaBVcALqiOoBViEs4HLW6aU,1064
+pqopen_lib-0.9.0.dist-info/RECORD,,

pqopen_lib-0.8.4.dist-info/RECORD

@@ -1,12 +0,0 @@
-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=BDB-Xf-xe3UYVBUyX2gjKXnWpeZWTQTaLDSGCvtmGZ4,49256
-pqopen/storagecontroller.py,sha256=AhVaPgIh4CBKKMJm9Ja0dOjVd4dLppWprxeeg3vrmAk,31266
-pqopen/zcd.py,sha256=olJZsHRd1CjU65vysc2emR5wFGMkayIWdUEDNE8jfIc,6253
-pqopen_lib-0.8.4.dist-info/METADATA,sha256=hC1fidnpdel5XKb8T5zDJ6H3zidLNtTTJuhnYnKAVQE,4787
-pqopen_lib-0.8.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pqopen_lib-0.8.4.dist-info/licenses/LICENSE,sha256=yhYwu9dioytbAvNQa0UBwaBVcALqiOoBViEs4HLW6aU,1064
-pqopen_lib-0.8.4.dist-info/RECORD,,