pytesprocess 0.1.1__py3-none-any.whl

pytesprocess/core/template.py

@@ -0,0 +1,450 @@
+import copy
+
+import numpy as np
+import qetpy as qp
+from qetpy.core._template import Template as QETpyTemplate
+from pytesdaqx.io import StreamReader
+
+from pytesprocess.core.filterdata import FilterData
+from pytesprocess.utils import convert_length_msec_to_samples
+
+
+class Template(FilterData):
+    """
+    pytesprocess wrapper around qetpy.core._template.Template.
+
+    pytesprocess handles trace I/O and FilterData persistence.
+    QETpy handles the array-based template calculations and fitting.
+    """
+
+    def __init__(self, verbose=True, filter_data=None):
+        super().__init__(verbose=verbose, filter_data=filter_data)
+        self._qp_template = QETpyTemplate(verbose=verbose)
+
+    def clear(self, channels=None, clear_filter_data=False, tag=None):
+        self._qp_template.clear(channels=channels)
+        if clear_filter_data:
+            self.clear_data(channels=channels, tag=tag)
+
+    def _normalize_channels(self, channels):
+        if isinstance(channels, str):
+            channels = [channels]
+        elif isinstance(channels, (list, tuple, np.ndarray)):
+            channels = list(channels)
+        else:
+            raise ValueError('ERROR: "channels" should be a string or a list of strings!')
+        if not channels:
+            raise ValueError('ERROR: "channels" cannot be empty!')
+        if not all(isinstance(chan, str) for chan in channels):
+            raise ValueError('ERROR: all channel names should be strings!')
+        return channels
+
+    def _get_trace_axis_info(self, metadata, trace_length_samples=None,
+                             pretrigger_length_msec=None,
+                             pretrigger_length_samples=None):
+        fs = float(metadata[0]['sample_rate_hz'])
+        nsamples = int(trace_length_samples) if trace_length_samples is not None else None
+        if nsamples is None:
+            if 'nb_samples' in metadata[0]:
+                nsamples = int(metadata[0]['nb_samples'])
+            else:
+                raise ValueError('ERROR: unable to determine trace length in samples.')
+
+        trigger_index = nsamples // 2
+        if pretrigger_length_msec is not None:
+            trigger_index = convert_length_msec_to_samples(pretrigger_length_msec, fs) - 1
+        elif pretrigger_length_samples is not None:
+            trigger_index = int(pretrigger_length_samples) - 1
+
+        t = np.arange(nsamples, dtype=np.float64) / fs
+        freqs = np.fft.fftfreq(nsamples, d=1.0 / fs)
+        return fs, nsamples, trigger_index, t, freqs
+
+    def _store_template(self, channels, template, sample_rate,
+                        pretrigger_length_samples, tag='default', metadata=None):
+        template = np.asarray(template)
+        if template.ndim == 1:
+            if len(channels) != 1:
+                raise ValueError('ERROR: 1D template provided for multiple channels.')
+            self.set_template(
+                channels=channels[0],
+                template=template,
+                sample_rate=sample_rate,
+                pretrigger_length_samples=pretrigger_length_samples,
+                metadata=metadata,
+                tag=tag,
+            )
+        elif template.ndim == 2:
+            if template.shape[0] != len(channels):
+                raise ValueError('ERROR: template channel dimension is inconsistent with channels.')
+            for ichan, chan in enumerate(channels):
+                chan_metadata = copy.deepcopy(metadata) if metadata is not None else {}
+                self.set_template(
+                    channels=chan,
+                    template=template[ichan],
+                    sample_rate=sample_rate,
+                    pretrigger_length_samples=pretrigger_length_samples,
+                    metadata=chan_metadata,
+                    tag=tag,
+                )
+        else:
+            raise ValueError('ERROR: template should be 1D or 2D [nchans, nsamples].')
+
+    def _load_dpdi_from_store(self, channels, poles, dpdi_tag):
+        if poles is None:
+            raise ValueError(
+                'ERROR: dpdi=None and no internal dpdi available. '
+                'Need "poles" (and optionally "dpdi_tag") to load stored dpdi.'
+            )
+
+        dpdi_dict = {}
+        dpdi_freqs_dict = {}
+        metadata_dict = {}
+        for chan in channels:
+            dpdi_vals, dpdi_freqs = self.get_dpdi(chan, poles=poles, tag=dpdi_tag)
+            dpdi_dict[chan] = np.asarray(dpdi_vals, dtype=np.complex128)
+            dpdi_freqs_dict[chan] = np.asarray(dpdi_freqs, dtype=np.float64)
+            metadata_dict[chan] = {'poles': poles, 'tag': dpdi_tag}
+        return dpdi_dict, dpdi_freqs_dict, metadata_dict
+
+    def calc_average_pulses(self, channels, file_path, event_list,
+                            trace_length_msec=None,
+                            pretrigger_length_msec=None,
+                            trace_length_samples=None,
+                            pretrigger_length_samples=None,
+                            nevents=2000,
+                            lgc_plot=False,
+                            lgc_filter_freq=True,
+                            filter_freq=50e3,
+                            time_lims=None,
+                            store_filterdata=True,
+                            tag='default_mean_current'):
+        channels = self._normalize_channels(channels)
+
+
+        # get traces
+        reader = StreamReader(file_path)
+        traces, metadata = reader.read_records(
+            record_list=event_list,
+            n_records=nevents,
+            channels=channels,
+            trace_length_msec=trace_length_msec,
+            trace_length_samples=trace_length_samples,
+            pretrigger_length_msec=pretrigger_length_msec,
+            pretrigger_length_samples=pretrigger_length_samples,
+            include_metadata=True,
+            units='amps',
+            stack=True)
+        
+        detector_config = reader.get_detector_settings()
+        
+        if traces.ndim != 3:
+            raise ValueError(
+                'ERROR: expected traces array with shape [nevents, nchans, nsamples]. '
+                f'Got shape {traces.shape}.'
+            )
+        if traces.shape[1] != len(channels):
+            raise ValueError(
+                'ERROR: traces shape is inconsistent with the requested channels. '
+                f'Expected {len(channels)} channels, got {traces.shape[1]}.'
+            )
+
+        fs, _, trigger_index, _, _ = self._get_trace_axis_info(
+            metadata,
+            trace_length_samples=traces.shape[-1],
+            pretrigger_length_msec=pretrigger_length_msec,
+            pretrigger_length_samples=pretrigger_length_samples,
+        )
+
+        self._qp_template.calc_average_pulses(
+            traces=traces,
+            channels=channels,
+            sample_rate=fs,
+            trigger_index=trigger_index,
+            lgc_plot=lgc_plot,
+            lgc_filter_freq=lgc_filter_freq,
+            filter_freq=filter_freq,
+            time_lims=time_lims,
+        )
+
+        if store_filterdata:
+            mean_i_t, _ = self._qp_template.get_template_in_current(
+                channels, use_fit=False, domain='time'
+            )
+            metadata_out = {
+                'template_source': 'average_current_pulse',
+                'template_domain': 'current',
+                'template_kind': 'mean',
+                'nb_events': traces.shape[0],
+            }
+            self._store_template(
+                channels=channels,
+                template=mean_i_t,
+                sample_rate=fs,
+                pretrigger_length_samples=trigger_index,
+                tag=tag,
+                metadata=metadata_out,
+            )
+
+    def calc_power_template(self, channels, dpdi=None, dpdi_err=None,
+                            dpdi_freqs=None, poles=None, dpdi_tag='default',
+                            dpdi_metadata=None, lgc_plot=False,
+                            filter_freq=50e3, time_lims=None,
+                            store_filterdata=True, tag='default_mean_power'):
+        channels = self._normalize_channels(channels)
+
+        if dpdi is None:
+            missing = [chan for chan in channels if chan not in self._qp_template._dpdi]
+            if missing:
+                loaded_dpdi, loaded_freqs, loaded_meta = self._load_dpdi_from_store(channels, poles, dpdi_tag)
+                dpdi_dict = loaded_dpdi
+                dpdi_freqs_dict = loaded_freqs
+                if dpdi_metadata is None:
+                    dpdi_metadata = loaded_meta
+            else:
+                dpdi_dict = {chan: self._qp_template._dpdi[chan] for chan in channels}
+                dpdi_freqs_dict = {chan: self._qp_template._dpdi_freqs.get(chan, self._qp_template._freqs[chan])
+                                   for chan in channels}
+        else:
+            dpdi_dict = self._qp_template._prepare_channel_dict(dpdi, channels, dtype=np.complex128, name='dpdi')
+            dpdi_freqs_dict = None if dpdi_freqs is None else self._qp_template._prepare_channel_dict(
+                dpdi_freqs, channels, dtype=np.float64, name='dpdi_freqs'
+            )
+
+        if dpdi_err is None:
+            dpdi_err_dict = {chan: self._qp_template._dpdi_err.get(
+                chan, np.zeros_like(dpdi_dict[chan], dtype=np.complex128)
+            ) for chan in channels}
+        else:
+            dpdi_err_dict = self._qp_template._prepare_channel_dict(dpdi_err, channels, dtype=np.complex128, name='dpdi_err')
+
+        self._qp_template.calc_power_template(
+            channels=channels,
+            dpdi=dpdi_dict,
+            dpdi_err=dpdi_err_dict,
+            dpdi_freqs=dpdi_freqs_dict,
+            dpdi_metadata=dpdi_metadata,
+            lgc_plot=lgc_plot,
+            filter_freq=filter_freq,
+            time_lims=time_lims,
+        )
+
+        if store_filterdata:
+            mean_p_t, _ = self._qp_template.get_template_in_power(
+                channels, use_fit=False, domain='time'
+            )
+            fs = self._qp_template._sample_rate[channels[0]]
+            pretrigger_samples = self._qp_template._pretrigger_samples[channels[0]]
+            metadata_out = {
+                'template_source': 'average_power_pulse',
+                'template_domain': 'power',
+                'template_kind': 'mean',
+            }
+            self._store_template(
+                channels=channels,
+                template=mean_p_t,
+                sample_rate=fs,
+                pretrigger_length_samples=pretrigger_samples,
+                tag=tag,
+                metadata=metadata_out,
+            )
+
+    def fit_templates(self, channels, template_model='twopole',
+                      guess=None, bounds=None, f_fit_cutoff=50e3,
+                      max_nfev=800, dt=0.0, lgc_diagnostics=False,
+                      lgc_plot=True, filter_freq=50e3,
+                      time_lims=None, store_filterdata=True,
+                      tag='default'):
+        channels = self._normalize_channels(channels)
+        fit_result = self._qp_template.fit_templates(
+            channels=channels,
+            template_model=template_model,
+            guess=guess,
+            bounds=bounds,
+            dt=dt,
+            f_fit_cutoff=f_fit_cutoff,
+            max_nfev=max_nfev,
+            lgc_diagnostics=lgc_diagnostics,
+            lgc_plot=lgc_plot,
+            filter_freq=filter_freq,
+            time_lims=time_lims,
+        )
+
+        if store_filterdata:
+            fit_i_t, _ = self._qp_template.get_template_in_current(
+                channels, use_fit=True, domain='time'
+            )
+            fs = self._qp_template._sample_rate[channels[0]]
+            pretrigger_samples = self._qp_template._pretrigger_samples[channels[0]]
+            metadata_out = {
+                'template_source': 'fitted_current_template',
+                'template_domain': 'current',
+                'template_kind': 'fit',
+                'template_model': template_model,
+            }
+            self._store_template(
+                channels=channels,
+                template=fit_i_t,
+                sample_rate=fs,
+                pretrigger_length_samples=pretrigger_samples,
+                tag=tag,
+                metadata=metadata_out,
+            )
+
+        return fit_result
+
+    def get_template_in_current(self, channels, use_fit=True, domain='time', return_metadata=False):
+        channels = self._normalize_channels(channels)
+        return self._qp_template.get_template_in_current(
+            channels=channels,
+            use_fit=use_fit,
+            domain=domain,
+            return_metadata=return_metadata,
+        )
+
+    def get_template_in_power(self, channels, dpdi=None, dpdi_freqs=None,
+                              use_fit=True, domain='time', return_metadata=False):
+        channels = self._normalize_channels(channels)
+        return self._qp_template.get_template_in_power(
+            channels=channels,
+            dpdi=dpdi,
+            dpdi_freqs=dpdi_freqs,
+            use_fit=use_fit,
+            domain=domain,
+            return_metadata=return_metadata
+        )
+
+    @property
+    def qp_template(self):
+        return self._qp_template
+
+    # ------------------------------------------------------------------
+    # Original template creation helpers retained
+    # ------------------------------------------------------------------
+    def create_template(self, channels,
+                        sample_rate=None,
+                        trace_length_msec=None,
+                        trace_length_samples=None,
+                        pretrigger_length_msec=None,
+                        pretrigger_length_samples=None,
+                        A=1, B=None, C=None,
+                        tau_r=None,
+                        tau_f1=None, tau_f2=None, tau_f3=None,
+                        tag='default'):
+        if sample_rate is None:
+            raise ValueError('ERROR: "sample_rate" argument required')
+        if trace_length_msec is None and trace_length_samples is None:
+            raise ValueError('ERROR: Trace length required ("trace_length_msec" or "trace_length_samples")!')
+        if pretrigger_length_msec is None and pretrigger_length_samples is None:
+            raise ValueError('ERROR: Pretrigger length required ("pretrigger_length_msec" or "pretrigger_length_samples")!')
+        if tau_r is None:
+            raise ValueError('ERROR: "tau_r" argument required')
+        if A is None and B is None and C is None:
+            raise ValueError('ERROR: "A" and/or "B" and/or "C" argument(s) required!')
+        if tau_f1 is None and tau_f2 is None and tau_f3 is None:
+            raise ValueError('ERROR: "tau_f1" and/or "tau_f2" and/or "tau_f3" argument(s) required!')
+
+        if trace_length_samples is None:
+            trace_length_samples = int(round(1e-3 * trace_length_msec * sample_rate))
+        if pretrigger_length_msec is None:
+            pretrigger_length_msec = 1e3 * pretrigger_length_samples / sample_rate
+        else:
+            pretrigger_length_samples = int(round(1e-3 * pretrigger_length_msec * sample_rate))
+
+        dt = 1 / sample_rate
+        t0 = pretrigger_length_msec * 1e-3
+        t = np.asarray(list(range(trace_length_samples))) * dt
+
+        if A is not None and B is not None and C is not None:
+            poles = 4
+            template = qp.utils.make_template_fourpole(
+                t, A, B, C, tau_r, tau_f1, tau_f2, tau_f3,
+                t0=t0, fs=sample_rate, normalize=True
+            )
+        elif A is not None and B is not None:
+            poles = 3
+            template = qp.utils.make_template_threepole(
+                t, A, B, tau_r, tau_f1, tau_f2,
+                t0=t0, fs=sample_rate, normalize=True
+            )
+        else:
+            poles = 2
+            template = qp.utils.make_template_twopole(
+                t, A, tau_r, tau_f1,
+                t0=t0, fs=sample_rate, normalize=True
+            )
+
+        metadata = {
+            'sample_rate': sample_rate,
+            'sample_rate_hz': sample_rate,
+            'nb_samples': trace_length_samples,
+            'nb_pretrigger_samples': pretrigger_length_samples,
+            'nb_poles': poles,
+            'A': A, 'tau_r': tau_r, 'tau_f1': tau_f1,
+        }
+        if B is not None:
+            metadata['B'] = B
+            metadata['tau_f2'] = tau_f2
+        if C is not None:
+            metadata['C'] = C
+            metadata['tau_f3'] = tau_f3
+
+        channels = self._normalize_channels(channels)
+        for chan in channels:
+            self.set_template(
+                chan,
+                template,
+                sample_rate=sample_rate,
+                pretrigger_length_samples=pretrigger_length_samples,
+                metadata=metadata,
+                tag=tag,
+            )
+
+    def create_template_sum_twopoles(self, channels,
+                                     amplitudes,
+                                     rise_times,
+                                     fall_times,
+                                     sample_rate=None,
+                                     trace_length_msec=None,
+                                     trace_length_samples=None,
+                                     pretrigger_length_msec=None,
+                                     pretrigger_length_samples=None,
+                                     tag='default'):
+        if sample_rate is None:
+            raise ValueError('ERROR: "sample_rate" argument required')
+        if trace_length_msec is None and trace_length_samples is None:
+            raise ValueError('ERROR: Trace length required ("trace_length_msec" or "trace_length_samples")!')
+        if pretrigger_length_msec is None and pretrigger_length_samples is None:
+            raise ValueError('ERROR: Pretrigger length required ("pretrigger_length_msec" or "pretrigger_length_samples")!')
+
+        if trace_length_samples is None:
+            trace_length_samples = int(round(1e-3 * trace_length_msec * sample_rate))
+        if pretrigger_length_msec is None:
+            pretrigger_length_msec = 1e3 * pretrigger_length_samples / sample_rate
+        else:
+            pretrigger_length_samples = int(round(1e-3 * pretrigger_length_msec * sample_rate))
+
+        dt = 1 / sample_rate
+        time_array = np.asarray(list(range(trace_length_samples))) * dt
+        template = qp.utils.make_template_sum_twopoles(
+            time_array, amplitudes, rise_times, fall_times, normalize=True
+        )
+
+        metadata = {
+            'sample_rate': sample_rate,
+            'sample_rate_hz': sample_rate,
+            'nb_samples': trace_length_samples,
+            'nb_pretrigger_samples': pretrigger_length_samples,
+            'nb_sum_twopoles': len(amplitudes),
+        }
+
+        channels = self._normalize_channels(channels)
+        for chan in channels:
+            self.set_template(
+                chan,
+                template,
+                sample_rate=sample_rate,
+                pretrigger_length_samples=pretrigger_length_samples,
+                metadata=metadata,
+                tag=tag,
+            )

pytesprocess/process/__init__.py

@@ -0,0 +1,6 @@
+from .features import *
+from .triggers import *
+from .processing_data import *
+from .randoms import *
+from .ivprocess import *
+from .filterprocess import *

pytesprocess/process/data_source.py

@@ -0,0 +1,185 @@
+"""Raw-stream and trigger-dataframe sources used by ProcessingData."""
+
+import copy
+
+import vaex as vx
+
+from pytesdaqx.io import StreamReader
+from pytesprocess.utils import extract_stream_id
+
+
+class RawDataSource:
+    """Storage-independent access to one raw stream at a time."""
+
+    def __init__(self, raw_files, catalog=None):
+        self._raw_files = raw_files
+        self._catalog = catalog
+        self._reader = None
+        self._stream_id = None
+
+        self._partition_target_duration_s = 10.0
+        self._partition_overlap_left_samples = 0
+        self._partition_overlap_right_samples = 0
+        self._partition_next_core_start_index = 0
+        self._partition_core_start_index = None
+        self._partition_core_length_samples = None
+        self._partition_read_start_index = None
+        self._partition_read_length_samples = None
+        self._stream_length_samples = None
+        self._use_continuous_partitions = False
+
+    @property
+    def stream_id(self):
+        return self._stream_id
+
+    @property
+    def reader(self):
+        return self._reader
+
+    @property
+    def uses_continuous_partitions(self):
+        return self._use_continuous_partitions
+
+    def configure_partitions(self, partition_target_duration_s=10.0,
+                             overlap_left_samples=0,
+                             overlap_right_samples=0):
+        if float(partition_target_duration_s) <= 0:
+            raise ValueError('ERROR: partition_target_duration_s must be positive!')
+        if int(overlap_left_samples) < 0 or int(overlap_right_samples) < 0:
+            raise ValueError('ERROR: partition overlap must be non-negative!')
+        self._partition_target_duration_s = float(partition_target_duration_s)
+        self._partition_overlap_left_samples = int(overlap_left_samples)
+        self._partition_overlap_right_samples = int(overlap_right_samples)
+
+    def select_stream(self, stream, force=False):
+        stream_id = extract_stream_id(stream)
+        if stream_id not in self._raw_files:
+            raise ValueError(f'ERROR: raw stream {stream_id} not found!')
+        if (not force and self._reader is not None
+                and self._stream_id == stream_id):
+            return
+
+        self.close()
+        self._stream_id = stream_id
+        self._reader = StreamReader(copy.deepcopy(self._raw_files[stream_id]))
+        self._reset_partition_state()
+
+        if self._catalog is not None:
+            view = self._catalog.filter(streams=stream_id)
+            if (view.storage_format == 'zarr'
+                    and self._reader.is_continuous_stream):
+                if view.n_samples is None:
+                    raise ValueError(
+                        f'ERROR: Unable to determine stream length for {stream_id}!'
+                    )
+                self._stream_length_samples = int(view.n_samples)
+                self._use_continuous_partitions = True
+
+    def read_next_native(self, channels=None):
+        return self._reader.read_next(
+            channels=channels, units='amps', include_metadata=True
+        )
+
+    def read_record(self, record, channels=None, **kwargs):
+        return self._reader.read_record(
+            record, channels=channels, units='amps', include_metadata=True,
+            **kwargs,
+        )
+
+    def read_next_partition(self, channels=None, sample_rate_hz=None):
+        core_start = int(self._partition_next_core_start_index)
+        if (self._stream_length_samples is None
+                or core_start >= self._stream_length_samples):
+            return None
+        if sample_rate_hz is None:
+            raise ValueError('ERROR: sample_rate_hz is required for partitions!')
+
+        target_samples = max(
+            1, int(round(self._partition_target_duration_s * float(sample_rate_hz)))
+        )
+        core_stop = min(
+            core_start + target_samples, self._stream_length_samples
+        )
+        read_start = max(
+            0, core_start - self._partition_overlap_left_samples
+        )
+        read_stop = min(
+            self._stream_length_samples,
+            core_stop + self._partition_overlap_right_samples,
+        )
+
+        traces, info = self._reader.read_partition(
+            partition_start_index=read_start,
+            partition_length_samples=read_stop-read_start,
+            channels=channels, units='amps', include_metadata=True,
+        )
+
+        self._partition_core_start_index = core_start
+        self._partition_core_length_samples = core_stop-core_start
+        self._partition_read_start_index = read_start
+        self._partition_read_length_samples = read_stop-read_start
+        self._partition_next_core_start_index = core_stop
+
+        return traces, info, read_start
+
+    def partition_context(self):
+        if not self._use_continuous_partitions:
+            return None
+        return {
+            'partition_start_index': self._partition_core_start_index,
+            'partition_length_samples': self._partition_core_length_samples,
+            'partition_read_start_index': self._partition_read_start_index,
+            'partition_read_length_samples': self._partition_read_length_samples,
+            'stream_length_samples': self._stream_length_samples,
+            'stream_id': self._stream_id,
+        }
+
+    def get_detector_settings(self):
+        return self._reader.get_detector_settings()
+
+    def close(self):
+        if self._reader is not None:
+            try:
+                self._reader.close()
+            except Exception:
+                pass
+        self._reader = None
+
+    def _reset_partition_state(self):
+        self._partition_next_core_start_index = 0
+        self._partition_core_start_index = None
+        self._partition_core_length_samples = None
+        self._partition_read_start_index = None
+        self._partition_read_length_samples = None
+        self._stream_length_samples = None
+        self._use_continuous_partitions = False
+
+
+class TriggerDataframeSource:
+    """Iterate independent trigger-dataframe tasks."""
+
+    def __init__(self, trigger_files):
+        self._trigger_files = trigger_files or {}
+        self._dataframe = None
+        self._index = -1
+        self._task_id = None
+
+    @property
+    def task_id(self):
+        return self._task_id
+
+    def select_task(self, task_id):
+        task_id = str(task_id)
+        if task_id not in self._trigger_files:
+            raise ValueError(
+                f'ERROR: trigger dataframe task {task_id} not found!'
+            )
+        self._task_id = task_id
+        self._dataframe = vx.open_many(self._trigger_files[task_id])
+        self._index = -1
+
+    def next_row(self):
+        self._index += 1
+        if self._dataframe is None or self._index >= len(self._dataframe):
+            return None
+        return self._dataframe.to_records(index=self._index)

pytesprocess/process/event_context.py

@@ -0,0 +1,35 @@
+"""Canonical state for the event/window currently being processed."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class EventContext:
+    """Mutable per-event state shared by ProcessingData accessors.
+
+    Raw-data provenance is canonicalized around streams.  Legacy HDF5
+    coordinates are retained only where they are physically meaningful.
+    """
+
+    full_traces: object = None
+    admin_info: dict | None = None
+    truncated_traces: dict = field(default_factory=dict)
+    dataframe_info: object = None
+    stream_id: str | None = None
+    stream_number: int | None = None
+    stream_trigger_index: int | None = None
+    global_segment_number: int | None = None
+    segment_trigger_index: int | None = None
+    salting_info: dict | None = None
+
+    def reset(self, *, stream_id=None):
+        self.full_traces = None
+        self.admin_info = None
+        self.truncated_traces = {}
+        self.dataframe_info = None
+        self.stream_id = stream_id
+        self.stream_number = None
+        self.stream_trigger_index = None
+        self.global_segment_number = None
+        self.segment_trigger_index = None
+        self.salting_info = None