pytesprocess 0.1.1__py3-none-any.whl

pytesprocess/process/processing_data.py

@@ -0,0 +1,967 @@
+import numpy as np
+import vaex as vx
+from pytesprocess.utils import utils
+from pytesprocess.core import FilterData
+from pytesprocess.salting import SaltInjector
+import copy
+import pyarrow as pa
+from pytesdaqx.io import StreamReader
+from pytesprocess.utils import extract_stream_id
+from .data_source import RawDataSource, TriggerDataframeSource
+from .event_context import EventContext
+vx.settings.main.thread_count = 1
+vx.settings.main.thread_count_io = 1
+pa.set_cpu_count(1)
+
+__all__ = [
+    'ProcessingData'
+]
+
+class ProcessingData:
+    """
+    Class to manage data used for processing,
+    in particular
+      - raw data files, event traces/windows and metadata
+      - lightweight filter-template access needed by trigger processing
+
+    """
+
+    def __init__(self, raw_path, raw_files,
+                 acquisition_name=None,
+                 trigger_files=None,
+                 trigger_group_name=None,
+                 filter_file=None,
+                 available_channels=None,
+                 salting_dataframe=None,
+                 verbose=True,
+                 catalog=None):
+        """
+        Intialize data processing
+
+        Parameters
+        -----------
+
+        input_files : list
+           list of raw data files to be processed
+
+        acquisition_name : str, optional
+           raw data group name
+           default: None
+
+        filter_file : str, optional
+          full path to filter file
+          default: None
+
+        verbose :  bool, optional
+          if True, display info
+           Default: True
+
+        """
+
+        # verbose
+        self._verbose = verbose
+
+        # input raw files/path
+        self._raw_path = raw_path
+        self._raw_files = raw_files
+        self._acquisition_name = acquisition_name
+        self._catalog = catalog
+
+        # trigger dataframe
+        self._trigger_files = trigger_files
+        self._trigger_group_name = trigger_group_name
+
+        # filter data
+        self._filter_data = None
+        self._filter_file = filter_file
+        if filter_file is not None:
+            self._filter_data = FilterData()
+            self._filter_data.load_hdf5(filter_file, overwrite=True)
+              
+        # trigger-dataframe mode
+        self._is_trigger_dataframe = False
+        if self._trigger_files is not None:
+            self._is_trigger_dataframe = True
+
+
+        # Data sources and current event/window state.  ProcessingData remains
+        # the public facade while source iteration and per-event state live in
+        # dedicated objects.
+        self._raw_source = RawDataSource(self._raw_files, catalog=self._catalog)
+        self._trigger_source = (
+            TriggerDataframeSource(self._trigger_files)
+            if self._is_trigger_dataframe else None
+        )
+        self._event = EventContext()
+
+        # get ADC and file info
+        self._data_info = self._extract_data_info()
+                
+        # available channels
+        self._available_channels =  available_channels
+
+        # salting
+        self._salting_dataframe = salting_dataframe
+        self._salting_inst = None
+        if salting_dataframe is not None:
+            if self._filter_data is None:
+                raise ValueError(
+                    'ERROR: A filter_file is required when salting injection is enabled.'
+                )
+            self._salting_inst = SaltInjector(
+                self._filter_data, verbose=verbose
+            )
+        
+        
+    @property
+    def verbose(self):
+        return self._verbose
+
+    def get_filter_data_inst(self):
+        return self._filter_data
+    
+    def load_salting_dataframe(self):
+        """
+        Load salting dataframe
+        """
+
+        if self._salting_dataframe is None:
+            return
+        
+        # disable vaex multi-threading
+        vx.settings.main.thread_count = 1
+        vx.settings.main.thread_count_io = 1
+        pa.set_cpu_count(1)
+           
+        # SaltInjector accepts either a Vaex dataframe or a path to one.
+        self._salting_inst.set_dataframe(self._salting_dataframe)
+    
+    def configure_trigger_partitions(self, partition_target_duration_s=10.0,
+                                     overlap_left_samples=0,
+                                     overlap_right_samples=0):
+        """Configure logical partitions used for continuous Zarr triggering."""
+        self._raw_source.configure_partitions(
+            partition_target_duration_s=partition_target_duration_s,
+            overlap_left_samples=overlap_left_samples,
+            overlap_right_samples=overlap_right_samples,
+        )
+
+    def get_partition_context(self):
+        """Return current logical-partition coordinates, or ``None``."""
+        return self._raw_source.partition_context()
+
+    def set_stream(self, stream):
+        """Select an input trigger-dataframe task or raw-data stream."""
+        vx.settings.main.thread_count_io = 1
+        self._event.reset()
+
+        if self._is_trigger_dataframe:
+            task_id = str(stream)
+            if self._verbose:
+                print('INFO: Loading dataframe trigger task ' + task_id)
+            self._trigger_source.select_task(task_id)
+            self._raw_source.close()
+            return
+
+        self._select_raw_stream(stream, force=True)
+
+    def _select_raw_stream(self, stream, force=False):
+        """Select one canonical raw stream."""
+        self._raw_source.select_stream(stream, force=force)
+        self._event.stream_id = self._raw_source.stream_id
+
+    def get_raw_path(self):
+        return self._raw_path
+
+
+    def read_next_event(self, channels=None, traces_config=None):
+        """Read the next native record or dataframe-selected event."""
+        # Keep the established per-worker Vaex/PyArrow limits.  These settings
+        # are intentionally unchanged in v14 because they avoid known
+        # multicore oversubscription/file-reading problems.
+        vx.settings.main.thread_count = 1
+        vx.settings.main.thread_count_io = 1
+        pa.set_cpu_count(1)
+
+        if not self._is_trigger_dataframe:
+            if self._raw_source.uses_continuous_partitions:
+                return self._read_next_continuous_partition(channels)
+
+            try:
+                traces, info = self._raw_source.read_next_native(channels)
+            except StopIteration:
+                self._event.full_traces = None
+                return False
+
+            self._event.reset(stream_id=self._raw_source.stream_id)
+            self._event.full_traces = traces
+            self._event.admin_info = self._normalize_reader_info(info, channels)
+            self._event.stream_number = int(
+                self._event.admin_info.get('stream_num', -1)
+            )
+            global_segment = self._event.admin_info.get('global_segment_num')
+            if global_segment is not None and int(global_segment) >= 0:
+                self._event.global_segment_number = int(global_segment)
+
+            if self._salting_inst is not None:
+                if self._event.global_segment_number is None:
+                    raise NotImplementedError(
+                        'Salting for native Zarr records is not implemented yet.'
+                    )
+                chans = self._event.admin_info['detector_chans']
+                self._event.full_traces, self._event.salting_info = (
+                    self._salting_inst.inject_record(
+                        chans, self._event.full_traces,
+                        stream_id=self._event.stream_id,
+                        stream_number=self._event.stream_number,
+                        global_segment_number=self._event.global_segment_number,
+                        include_metadata=True,
+                    )
+                )
+            return True
+
+        if traces_config is None:
+            raise ValueError(
+                'ERROR: No trace info available. Something went wrong...'
+            )
+
+        row = self._trigger_source.next_row()
+        if row is None:
+            self._event.full_traces = None
+            return False
+
+        self._event.reset()
+        self._event.dataframe_info = row
+
+        def row_get(*names, default=None):
+            for name in names:
+                try:
+                    if name in row and row[name] is not None:
+                        return row[name]
+                except TypeError:
+                    pass
+            return default
+
+        raw_stream = row_get('stream_id', 'stream_number')
+        if raw_stream is None:
+            raise ValueError(
+                'ERROR: Trigger dataframe does not identify the raw stream.'
+            )
+        self._select_raw_stream(raw_stream)
+        self._event.stream_id = self._raw_source.stream_id
+
+        stream_trigger_index = row_get('stream_trigger_index')
+        global_segment_number = row_get(
+            'global_segment_num', 'global_segment_number'
+        )
+        segment_trigger_index = row_get('segment_trigger_index')
+
+        if stream_trigger_index is None and global_segment_number is None:
+            raise ValueError(
+                'ERROR: Trigger dataframe needs stream_trigger_index (Zarr) or '
+                'global_segment_number (HDF5).'
+            )
+
+        self._event.truncated_traces = {}
+
+        # HDF5 salts are injected into the full native segment;
+        # stream-global salts are injected directly into each window.
+        if self._salting_inst is not None and stream_trigger_index is None:
+            full_record = {'global_segment_num': int(global_segment_number)}
+            traces, info = self._raw_source.read_record(
+                full_record, channels=channels
+            )
+            self._event.full_traces = traces
+            self._event.admin_info = self._normalize_reader_info(info, channels)
+            self._event.global_segment_number = int(global_segment_number)
+            self._event.stream_number = int(
+                row_get('stream_number', default=-1)
+            )
+            self._event.segment_trigger_index = int(segment_trigger_index)
+            chans = self._event.admin_info['detector_chans']
+            self._event.full_traces, self._event.salting_info = (
+                self._salting_inst.inject_record(
+                    chans, self._event.full_traces,
+                    stream_id=self._event.stream_id,
+                    stream_number=self._event.stream_number,
+                    global_segment_number=self._event.global_segment_number,
+                    include_metadata=True,
+                )
+            )
+            for key_tuple in traces_config:
+                nb_samples = int(key_tuple[0])
+                nb_pretrigger_samples = int(key_tuple[1])
+                min_idx = self._event.segment_trigger_index - nb_pretrigger_samples
+                max_idx = min_idx + nb_samples
+                window = None
+                if (min_idx >= 0
+                        and max_idx <= self._event.full_traces.shape[-1]):
+                    window = self._event.full_traces[:, min_idx:max_idx].copy()
+                self._event.truncated_traces[key_tuple] = {
+                    'traces': window, 'channels': chans
+                }
+        else:
+            for key_tuple in traces_config:
+                nb_samples = int(key_tuple[0])
+                nb_pretrigger_samples = int(key_tuple[1])
+                record = {}
+                if stream_trigger_index is not None:
+                    record['stream_trigger_index'] = int(stream_trigger_index)
+                else:
+                    record['global_segment_num'] = int(global_segment_number)
+                    record['segment_trigger_index'] = int(segment_trigger_index)
+
+                try:
+                    traces, info = self._raw_source.read_record(
+                        record,
+                        channels=channels,
+                        trace_length_samples=nb_samples,
+                        pretrigger_length_samples=nb_pretrigger_samples,
+                    )
+                except (ValueError, IndexError):
+                    traces, info = None, None
+
+                if info is not None:
+                    info = self._normalize_reader_info(info, channels)
+                    self._event.admin_info = info
+                    trace_channels = info['detector_chans']
+                else:
+                    trace_channels = list(
+                        channels or self._available_channels or []
+                    )
+
+                if (self._salting_inst is not None
+                        and traces is not None
+                        and stream_trigger_index is not None):
+                    trace_start_index = (
+                        int(stream_trigger_index) - nb_pretrigger_samples
+                    )
+                    traces, salting_info = self._salting_inst.inject_window(
+                        trace_channels, traces,
+                        stream_id=self._event.stream_id,
+                        trace_start_index=trace_start_index,
+                        include_metadata=True,
+                    )
+                    if salting_info:
+                        self._event.salting_info = salting_info
+
+                self._event.truncated_traces[key_tuple] = {
+                    'traces': traces, 'channels': trace_channels
+                }
+
+        if self._event.admin_info is None:
+            self._event.admin_info = {'detector_config': {}}
+        if global_segment_number is not None:
+            self._event.global_segment_number = int(global_segment_number)
+        self._event.stream_number = int(
+            row_get('stream_number', default=-1)
+        )
+        if stream_trigger_index is not None:
+            self._event.stream_trigger_index = int(stream_trigger_index)
+        elif segment_trigger_index is not None:
+            self._event.segment_trigger_index = int(segment_trigger_index)
+        return True
+
+    def _read_next_continuous_partition(self, channels=None):
+        """Read one expanded logical partition from a continuous Zarr stream."""
+        result = self._raw_source.read_next_partition(
+            channels=channels, sample_rate_hz=self.get_sample_rate()
+        )
+        if result is None:
+            self._event.full_traces = None
+            return False
+
+        traces, info, read_start = result
+        self._event.reset(stream_id=self._raw_source.stream_id)
+        self._event.full_traces = traces
+        self._event.admin_info = self._normalize_reader_info(info, channels)
+        self._event.stream_number = int(
+            self._event.admin_info.get('stream_num', -1)
+        )
+
+        stream_start = self._event.admin_info.get('stream_start')
+        if stream_start is not None:
+            self._event.admin_info['event_time'] = (
+                float(stream_start) + read_start / float(self.get_sample_rate())
+            )
+
+        if self._salting_inst is not None:
+            trace_channels = self._event.admin_info['detector_chans']
+            self._event.full_traces, self._event.salting_info = (
+                self._salting_inst.inject_window(
+                    trace_channels, self._event.full_traces,
+                    stream_id=self._event.stream_id,
+                    trace_start_index=read_start,
+                    include_metadata=True,
+                )
+            )
+        return True
+
+    def _normalize_reader_info(self, info, channels=None):
+        """Normalize reader metadata to canonical stream/acquisition names."""
+        out = dict(info or {})
+        detector_chans = out.get('detector_channels', out.get('detector_chans'))
+        if detector_chans is None:
+            detector_chans = list(channels or self._available_channels or [])
+        elif isinstance(detector_chans, str):
+            detector_chans = [detector_chans]
+        else:
+            detector_chans = list(detector_chans)
+        out['detector_channels'] = detector_chans
+        # Internal compatibility for existing trace/channel accessors.  This is
+        # not written as a dataframe provenance field.
+        out['detector_chans'] = detector_chans
+
+        out.setdefault('stream_num', -1)
+        out.setdefault('stream_id', self._raw_source.stream_id)
+        out.setdefault('global_segment_num', -1)
+        out.setdefault('event_id', -1)
+        out.setdefault('event_time', 0)
+
+        measurement_type = out.get(
+            'measurement_type', out.get('run_type', out.get('data_type', 'unknown'))
+        )
+        out['measurement_type'] = measurement_type
+        out.pop('run_type', None)
+        out.setdefault('fridge_run', -1)
+        out['fridge_run_start'] = out.get(
+            'fridge_run_start', out.get('fridge_run_start_time', 0)
+        )
+        out.setdefault('stream_start', 0)
+        out.setdefault('acquisition_start', 0)
+
+        if 'detector_config' not in out:
+            try:
+                detector_config = copy.deepcopy(
+                    self._raw_source.get_detector_settings()
+                )
+            except Exception:
+                detector_config = {}
+            for config in detector_config.values():
+                if ('tes_bias' not in config
+                        and config.get('tes_bias_dc_amps') is not None):
+                    config['tes_bias'] = config['tes_bias_dc_amps']
+            out['detector_config'] = detector_config
+        return out
+
+    @staticmethod
+    def _get_pytesprocess_trigger_type(info):
+        """Return the legacy numeric pytesprocess trigger category.
+
+        Current pytesdaqx uses ``trigger_type`` for the DAQ trigger
+        configuration and stores string values such as ``"none"`` or
+        ``"digital_edge"``.  pytesprocess historically stores a different
+        quantity in its output dataframe:
+
+          1 = continuous/background
+          2 = external trigger
+          3 = random
+          4 = threshold/software trigger
+
+        Numeric values from legacy raw files are preserved.  Otherwise the
+        value is derived from the current ``measurement_type``.
+        """
+
+        if not info:
+            return np.nan
+
+        raw_trigger_type = info.get('trigger_type')
+
+        # Legacy pytesdaq/pytesdaqx files may already contain the numeric
+        # pytesprocess category.  Preserve it when unambiguous.
+        if isinstance(raw_trigger_type, (int, np.integer)):
+            return np.int16(raw_trigger_type)
+        if isinstance(raw_trigger_type, (float, np.floating)):
+            if np.isfinite(raw_trigger_type):
+                return np.int16(raw_trigger_type)
+        if isinstance(raw_trigger_type, str):
+            value = raw_trigger_type.strip()
+            if value.isdigit():
+                return np.int16(int(value))
+
+        measurement_type = str(
+            info.get('measurement_type', info.get('run_type', ''))
+        ).strip().lower()
+
+        measurement_map = {
+            # Current canonical pytesdaqx names
+            'background': 1,
+            'external_trigger': 2,
+            'threshold': 4,
+
+            # Legacy aliases that may still occur in old metadata
+            'cont': 1,
+            'continuous': 1,
+            'open_cont': 1,
+            'restricted_cont': 1,
+            'exttrig': 2,
+            'thresh': 4,
+        }
+        if measurement_type in measurement_map:
+            return np.int16(measurement_map[measurement_type])
+
+        # Legacy files may provide data_mode even when measurement_type is
+        # absent or too generic.  Do not synthesize data_mode for new data.
+        data_mode = str(info.get('data_mode', '')).strip().lower()
+        data_mode_map = {
+            'cont': 1,
+            'trig-ext': 2,
+            'rand': 3,
+            'threshold': 4,
+        }
+        if data_mode in data_mode_map:
+            return np.int16(data_mode_map[data_mode])
+
+        # A continuous ADC acquisition is safely equivalent to the legacy
+        # continuous category even for measurement types such as calibration.
+        adc_mode = str(info.get('adc_mode', '')).strip().lower()
+        if adc_mode == 'continuous':
+            return np.int16(1)
+
+        return np.nan
+
+    def get_event_admin(self, return_all=False):
+        """Return canonical metadata for the current event/window."""
+        info = self._event.admin_info
+        if info is None:
+            return {}
+
+        if self._is_trigger_dataframe:
+            row = self._event.dataframe_info
+            if row is None:
+                return {}
+            admin = {}
+            for key, val in row.items():
+                admin[key] = np.nan if val is None else val
+            return admin
+
+        if return_all:
+            return info
+
+        admin = {}
+        global_segment = info.get('global_segment_num')
+        if global_segment is not None and int(global_segment) >= 0:
+            admin['global_segment_number'] = np.int64(global_segment)
+
+        admin['stream_number'] = np.int64(info.get('stream_num', -1))
+        if info.get('stream_id') is not None:
+            admin['stream_id'] = str(info['stream_id'])
+        if info.get('event_id') is not None:
+            admin['event_id'] = np.int32(info['event_id'])
+        if info.get('event_time') is not None:
+            admin['event_time'] = np.float64(info['event_time'])
+        admin['measurement_type'] = str(
+            info.get('measurement_type', 'unknown')
+        )
+
+        if self._acquisition_name is not None:
+            admin['acquisition_name'] = self._acquisition_name
+        else:
+            admin['acquisition_name'] = np.nan
+
+        admin['trigger_type'] = self._get_pytesprocess_trigger_type(info)
+        admin['trigger_amplitude'] = info.get('trigger_amplitude', np.nan)
+        admin['trigger_time'] = info.get('trigger_time', np.nan)
+
+        if info.get('fridge_run') is not None:
+            admin['fridge_run_number'] = np.int64(info['fridge_run'])
+
+        # Absolute start timestamps. EventBuilder derives per-trigger elapsed
+        # times from these when needed.
+        for source, dest in (
+            ('fridge_run_start', 'fridge_run_start_time'),
+            ('stream_start', 'stream_start_time'),
+            ('acquisition_start', 'acquisition_start_time'),
+        ):
+            value = info.get(source)
+            if value is not None:
+                admin[dest] = np.float64(value)
+
+        if self._event.salting_info is not None:
+            if 'salting_type' in self._event.salting_info:
+                admin['salting_type'] = self._event.salting_info['salting_type']
+            for key in (
+                'salting_dataframe_group_name',
+                'salting_dataframe_group_id',
+                'salting_dataframe_group_number',
+            ):
+                if key in self._event.salting_info:
+                    admin[key] = self._event.salting_info[key]
+
+        return admin
+
+
+    def get_channel_settings(self, channel):
+        """
+        Get channel settings dictionary
+
+        Parameters
+        ---------
+
+        channel : str
+           channel can be a single channel
+           or sum of channels "chan1+chan2"
+           or multiple channels "chan1|chan2"
+
+
+        Return
+        ------
+        settings_dict : dict
+          dictionnary with various detector settings variable
+
+        """
+
+        # initialize output
+        settings_dict = dict()
+
+
+        # check info filled
+        if (self._event.admin_info is None or
+            'detector_config' not in self._event.admin_info):
+            return settings_dict
+
+        #  get channels list
+        available_channels = self._available_channels
+        if available_channels is None:
+            available_channels = self._event.admin_info['detector_chans']
+               
+        channels, separator = utils.split_channel_name(
+            channel,
+            available_channels=available_channels
+        )
+
+        # fill dictionary
+        for chan in channels:
+            settings_dict['tes_bias_' + chan] =  (
+                self._event.admin_info['detector_config'][chan]['tes_bias'])
+            settings_dict['output_gain_' + chan] =  (
+                self._event.admin_info['detector_config'][chan]['output_gain'])
+
+        return settings_dict
+
+
+
+    def get_channel_trace(self, channel,
+                          nb_samples=None,
+                          nb_pretrigger_samples=None,
+                          weights=None):
+        """
+        Get trace (s)
+
+        Parameters
+        ----------
+
+        channel : str
+           channel can be a single channel
+           or sum of channels "chan1+chan2"
+           or multiple channels "chan1|chan2"
+
+        Return:
+        -------
+        array : ndarray
+          array with trace values
+
+        """
+
+        array = None
+
+        #  get channels for case + or | used
+        available_channels = self._available_channels
+        if available_channels is None:
+            available_channels = self._event.admin_info['detector_chans']
+            
+        channels, separator = utils.split_channel_name(
+            channel,
+            available_channels=available_channels
+        )
+
+        weights_array = None
+        if weights is not None:
+            
+            weights_array = np.ones(len(channels))
+            
+            for ichan, chan in enumerate(channels):
+                param = f'weight_{chan}'
+                if param not in weights:
+                    raise ValueError(
+                        f'ERROR: Missing parameter weight {param} '
+                        f'for channel {channel}!'
+                    )
+                val = weights[param]
+                weights_array[ichan] = val
+
+        # case full trace
+        if nb_samples is None:
+
+            # get array indices
+            channel_indices = list()
+            for chan in channels:
+                channel_indices.append(
+                    self._event.admin_info['detector_chans'].index(chan)
+                )
+
+            if not channel_indices:
+                raise ValueError('Unable to get event  traces for '
+                                 + channel)
+            # get array
+            array = self._event.full_traces[channel_indices,:]
+
+        else:
+
+            if nb_pretrigger_samples is None:
+                raise ValueError(
+                    'ERROR: "nb_pretrigger_samples" required!')
+
+            key = (nb_samples, nb_pretrigger_samples)
+            
+            if (self._event.truncated_traces is None
+                or key not in self._event.truncated_traces.keys()):
+                raise ValueError('ERROR: Traces not available!')
+
+            channel_indices = list()
+            for chan in channels:
+                channel_indices.append(
+                    self._event.truncated_traces[key]['channels'].index(chan)
+                )
+
+            # get array
+            if (self._event.truncated_traces[key]['traces'] is not None):
+                array = self._event.truncated_traces[key]['traces'][channel_indices,:]
+           
+        # Build output
+        if array is None:
+            return array
+
+        
+        if separator == '+':
+            if weights is not None:
+                weights_array = weights_array[:, np.newaxis]
+                array = array * weights_array
+            array = np.sum(array,axis=0)
+            
+        elif separator == '-':
+            if weights is not None:
+                array = (array[0,:]*weights_array[0]
+                         - array[1,:]*weights_array[1])
+            else:
+                array = array[0,:] - array[1,:]
+                
+        elif separator is None:
+            array = array[0,:]
+
+        return array
+
+
+
+    def get_template(self, channel, tag='default'):
+        """Return a template and metadata from the loaded FilterData.
+
+        TriggerProcessing still uses this lightweight accessor. Feature OF
+        resource management is handled separately by FeatureResources.
+        """
+        if self._filter_data is None:
+            raise ValueError('ERROR: No filter_file is loaded.')
+        template, _time, metadata = self._filter_data.get_template(
+            channel, tag=tag, return_metadata=True
+        )
+        return template, metadata
+
+
+    def get_noise(self, channel, tag='default'):
+        """Return PSD/CSD data from the loaded FilterData.
+
+        Kept as a lightweight compatibility accessor; feature OF resource
+        preparation no longer lives in ProcessingData.
+        """
+        if self._filter_data is None:
+            raise ValueError('ERROR: No filter_file is loaded.')
+        channel_list = str(channel).replace(' ', '').split('|')
+        if len(channel_list) == 1:
+            return self._filter_data.get_psd(
+                channel, tag=tag, fold=False, return_metadata=True
+            )
+        return self._filter_data.get_csd(
+            channel, tag=tag, fold=False, return_metadata=True
+        )
+
+
+    def get_psd(self, channel, tag='default'):
+        """Return an unfolded PSD and metadata from the loaded FilterData."""
+        if self._filter_data is None:
+            raise ValueError('ERROR: No filter_file is loaded.')
+        return self._filter_data.get_psd(
+            channel, tag=tag, fold=False, return_metadata=True
+        )
+
+
+    def get_facility(self):
+        """
+        Function to extract facility # from
+        metadata
+
+        Parameters
+        ----------
+        None
+
+        Return
+        ------
+
+        facility : int
+         facility number
+
+        """
+        facility = None
+        if 'facility' in self._data_info.keys():
+            facility = self._data_info['facility']
+
+        return facility
+
+    def get_sample_rate(self):
+        """
+        Function to extract sample rate from
+        metadata
+
+        Parameters
+        ----------
+        None
+
+        Return
+        ------
+
+        sample_rate : float
+         ADC sample rate used to take data
+
+
+        """
+        sample_rate = None
+        if 'sample_rate_hz' in self._data_info:
+            sample_rate = self._data_info['sample_rate_hz']
+        elif 'sample_rate' in self._data_info:
+            sample_rate = self._data_info['sample_rate']
+
+        return sample_rate
+
+    def get_nb_samples(self):
+        """
+        Function to extract number of samples information
+        from metadata
+
+        Parameters
+        ----------
+        None
+
+        Return
+        ------
+
+        nb_samples : int
+         number of samples of the traces
+
+        """
+        nb_samples = None
+        if 'nb_samples' in self._data_info.keys():
+             nb_samples = self._data_info['nb_samples']
+
+        return nb_samples
+
+
+    def get_nb_pretrigger_samples(self):
+        """
+        Function to extract number of pretrigger samples
+        information  from metadata
+
+        Parameters
+        ----------
+        None
+
+        Return
+        ------
+
+        nb_samples : int
+         number of pretrigger samples
+
+
+
+        """
+        nb_pretrigger_samples = None
+        if 'nb_pretrigger_samples' in self._data_info.keys():
+             nb_pretrigger_samples = self._data_info['nb_pretrigger_samples']
+
+        return nb_pretrigger_samples
+
+
+
+    def _extract_data_info(self, stream=None):
+        """
+        Function to extract all metadata
+        from raw data
+
+        Parameters
+        ----------
+        None
+
+        Return
+        ------
+
+        data_info : dict
+         dictionary with ADC/data information
+
+
+        """
+
+        # convert to stream id
+        stream_id  = None
+        if stream is not None:
+            stream_id = extract_stream_id(stream)
+        
+
+        data_info = None
+
+        if not self._raw_files:
+            raise ValueError('No file available to get sample rate!')
+
+        # StreamReader is the storage-independent metadata boundary for current
+        # pytesdaqx.  Prefer the acquisition catalog when available; retain a
+        # resource-level fallback for older/direct ProcessingData callers.
+        reader_kwargs = {}
+        if stream_id is not None:
+            reader_kwargs['streams'] = stream_id
+
+        if self._catalog is not None:
+            reader_source = self._catalog.acquisition_path
+            reader_kwargs['catalog'] = self._catalog
+        elif stream_id is None:
+            reader_source = next(iter(self._raw_files.values()))[0]
+        else:
+            reader_source = self._raw_files[stream_id][0]
+
+        with StreamReader(reader_source, **reader_kwargs) as reader:
+            metadata = reader.get_metadata()
+
+        data_info = copy.deepcopy(metadata.get('groups', {}).get('adc', {}))
+        data_info['comment'] = metadata.get('comment')
+        data_info['facility'] = metadata.get('facility')
+        data_info['run_purpose'] = metadata.get('run_purpose', 'unknown')
+
+        # AcquisitionCatalog is the canonical source for storage/sample-rate
+        # information in current pytesdaqx.  Keep the legacy names used by this
+        # class as aliases for now.
+        if self._catalog is not None:
+            view = self._catalog if stream_id is None else self._catalog.filter(streams=stream_id)
+            if view.sample_rate_hz is not None:
+                data_info['sample_rate_hz'] = float(view.sample_rate_hz)
+                data_info['sample_rate'] = float(view.sample_rate_hz)
+            if view.storage_format is not None:
+                data_info['storage_format'] = view.storage_format
+            if view.entries:
+                entry = view.entries[0]
+                if entry.get('facility') is not None:
+                    data_info['facility'] = entry['facility']
+                native_length = entry.get('trace_length_samples')
+                if native_length is None:
+                    native_length = entry.get('segment_length_samples')
+                if native_length is not None:
+                    data_info.setdefault('nb_samples', int(native_length))
+
+        return data_info
+
+