pytesprocess 0.1.1__py3-none-any.whl

pytesprocess/core/didv.py

@@ -0,0 +1,1648 @@
+from datetime import datetime
+from pathlib import Path
+import os
+import stat
+
+import numpy as np
+import pandas as pd
+import qetpy as qp
+from scipy.signal import unit_impulse
+
+from pytesdaqx.io import AcquisitionCatalog, StreamReader
+
+from pytesprocess.core.filterdata import FilterData
+
+
+class DIDVAnalysis(FilterData):
+    """
+    Class to manage didv calculations using 
+    QETpy. DIDV data are stored 
+    """
+    def __init__(self, verbose=True,
+                 auto_save_hdf5=False,
+                 save_path=None,
+                 filter_data=None):
+
+        super().__init__(verbose=verbose, filter_data=filter_data)
+
+        self._didv_data = {}
+
+        # save results
+        self._save_hdf5 = auto_save_hdf5
+        self._save_path = None
+        self._file_name = self._set_file_name()
+      
+            
+        if save_path is not None:
+            path = Path(save_path)
+            if path.is_file():
+                self._save_path = str(path.parent)
+                self._file_name = path.name
+            elif path.is_dir():
+                self._save_path = str(path)
+            else:
+                raise ValueError('ERROR: "save_path" should be a '
+                                 'file or path!')
+
+        
+
+            
+        # display
+        if self._save_hdf5:
+            full_path_file = self._file_name
+            if self._save_path is not None:
+                full_path_file = self._save_path + '/' + self._file_name
+            print(f'INFO: Results will be automatically saved '
+                  f'in {full_path_file}')
+
+            
+    def clear(self, channels=None):
+        """
+        Clear all data
+        """
+        
+        # clear data
+        if channels is None:
+            self._didv_data.clear()
+        else:
+            if isinstance(channels, str):
+                channels = [channels]
+            for chan in channels:
+                if chan in self._didv_data:
+                    self._didv_data.pop(chan)
+
+
+    def get_didv_data(self, channel):
+        """
+        Get dictionary with didv data
+        """
+
+        if channel in self._didv_data:
+            return self._didv_data[channel]
+        else:
+            raise ValueError(f'ERROR: No didv data available '
+                             f'for channel "{channel}"!')
+
+    
+    def get_dpdi(self, channel, poles=3):
+        """
+        Get dpdi data and frequencies
+        """
+
+        
+        if channel not in self._didv_data:
+            raise ValueError(f'ERROR: No didv data available '
+                             f'for channel "{channel}"!')
+        
+        list_of_fitted_poles = (
+            self._didv_data[channel]['didvobj'].get_list_fitted_poles()
+        ) or []
+        
+        if poles not in list_of_fitted_poles:
+            raise ValueError(f'ERROR: No {poles}-poles fit found for '
+                             f'channel {channel}!')
+
+            
+        # check dpdi available
+        poles_str = str(poles) + 'poles'
+        if 'dpdi_' + poles_str not in self._didv_data[channel]:
+            raise ValueError(f'ERROR: No dpdi found for '
+                             f'channel {channel}!')
+     
+        dpdi = self._didv_data[channel]['dpdi_' +  poles_str]
+        dpdi_freqs = self._didv_data[channel]['dpdi_freqs_' +  poles_str]
+        dpdi_err = self._didv_data[channel]['dpdi_err_' + poles_str]
+
+        return dpdi_freqs, dpdi, dpdi_err
+        
+        
+    def get_qetpy_object(self, channel):
+        """
+        Get QETpy object
+        """
+        
+        didv_data = self.get_didv_data(channel)
+        if 'didvobj' in didv_data.keys():
+            return  didv_data['didvobj']
+        else:
+            raise ValueError(f'ERROR: No dIdV QETpy object available '
+                             f'for channel "{channel}"!')
+
+    def get_bias_params(self, channel, poles=3):
+        """
+        Get "bias" (I0, R0, P0) parameters
+        (can be either "true" current or set by user)
+        """
+        
+        fit_result = self.get_fit_results(channel, poles=poles)
+        if 'biasparams' in fit_result.keys():
+            return fit_result['biasparams']
+        else:
+            raise ValueError(f'ERROR: No bias parameters available '
+                             f'for channel "{channel}"!')
+
+
+    def get_bias_params_infinite_loop_gain(self, channel, poles=3):
+        """
+        Get "bias" (I0, R0, P0) parameters with infinite loop gain
+        (can be either "true" current or set by user)
+        """
+
+        if (channel in self._didv_data
+            and 'biasparams_ilg' in self._didv_data[channel]
+            and poles in self._didv_data[channel]['biasparams_ilg']):
+            return self._didv_data[channel]['biasparams_ilg'][poles]
+        else:
+            raise ValueError(f'ERROR: No bias parameters with infinite '
+                             f'loop gain available for channel "{channel}"!')
+
+
+        
+    def process_raw_data(self, channels, data_path,
+                         stream=None,
+                         overwrite=False):
+        
+        """
+        Set dIdV data for a specific channel
+        form raw traces. Apply cuts and pre-process
+        data. The function can be called multiple
+        times for different channels 
+        """
+
+        # loop channel and process data
+        if isinstance(channels, str):
+            channels = [channels]
+
+        for chan in channels:
+            self._process_raw_data(chan, data_path,
+                                   stream=stream,
+                                   overwrite=overwrite)
+
+        # update save path if not set already
+        if self._save_path is None:
+            self._save_path = self._default_save_path(data_path)
+        
+    def set_processed_data(self, channels,
+                           data,
+                           overwrite=False):
+        
+        """
+        Set dIdV data from already processed raw 
+        data, in the form of pandas Series or 
+        dictionary. The function can be called multiple
+        times for different channels 
+        """
+
+
+        didv_data = data.copy()
+        
+        # check channels and data
+        if isinstance(channels, str):
+            if channels not in data.keys():
+                didv_data = dict()
+                didv_data[channels] = data     
+            channels = [channels]
+        
+        for chan in channels:
+            if chan not in didv_data.keys():
+                raise ValueError(f'ERROR: Unable to find channel '
+                                 f' {chan} in data dictionary!')
+
+        # set data
+        for chan in channels:
+            self._set_processed_data(chan,
+                                     didv_data[chan],
+                                     overwrite=overwrite)
+
+    def set_bias_params_from_data(self, channel, results,
+                                  result_type='noise', tag='default',
+                                  metadata=None):
+        """Attach operating-point bias parameters to a processed dIdV.
+
+        The bias parameters may come from a full IV sweep or from a short
+        beginning-of-cycle normal-IV calibration.  ``set_ivsweep_results_from_data``
+        remains as a compatibility wrapper around this more general method.
+        """
+        if isinstance(results, pd.Series):
+            results = results.to_dict()
+        elif not isinstance(results, dict):
+            raise ValueError(
+                'ERROR: "results" should be a dictionary or pandas Series'
+            )
+        if not isinstance(channel, str):
+            raise ValueError('ERROR: This function is for a single channel!')
+        if channel not in self._didv_data:
+            raise ValueError(
+                f'ERROR: Channel {channel} not found. You first need to set dIdV data!'
+            )
+
+        biasparams = results.copy()
+        self.set_ivsweep_results(
+            channel,
+            pd.Series(biasparams),
+            result_type,
+            metadata=metadata,
+            tag=tag,
+        )
+        self._didv_data[channel]['ivsweep_results'] = biasparams.copy()
+
+        rp = biasparams.get('rp')
+        r0 = biasparams.get('r0')
+        rshunt = biasparams.get('rshunt', biasparams.get('rsh'))
+        if rp is None:
+            raise ValueError(
+                f'ERROR: "rp" is missing from bias parameters for channel {channel}!'
+            )
+        self._didv_data[channel]['data_config']['rp'] = rp
+        self._didv_data[channel]['didvobj']._rp = rp
+        if r0 is not None:
+            self._didv_data[channel]['didvobj']._r0 = r0
+        if rshunt is not None:
+            self._didv_data[channel]['data_config']['rshunt'] = rshunt
+            self._didv_data[channel]['didvobj']._rsh = rshunt
+
+
+    def set_ivsweep_results_from_data(self,
+                                      channel,
+                                      results,
+                                      iv_type='noise',
+                                      tag='default',
+                                      metadata=None):
+        """Compatibility wrapper for :meth:`set_bias_params_from_data`."""
+        return self.set_bias_params_from_data(
+            channel,
+            results,
+            result_type=iv_type,
+            tag=tag,
+            metadata=metadata,
+        )
+
+
+    def set_ivsweep_results_from_file(self,
+                                      channels,
+                                      file_name,
+                                      iv_type='noise',
+                                      include_bias_parameters=False):
+        """
+        Set results from IV sweeps, in particular
+        I0 offset, V0 offset
+        """
+        
+        # check channels
+        if isinstance(channels, str):
+            channels = [channels]
+           
+        for chan in channels:
+            if chan not in self._didv_data:
+                raise ValueError(f'ERROR: Channel {chan} not found. '
+                                 ' You first need to set data!' )
+           
+     
+        # load data from file
+        if file_name is not None:
+            self.load_hdf5(file_name)
+
+            
+        # loop channels
+        for chan in channels:
+
+            #  get tes bias
+            tes_bias = None
+            if include_bias_parameters:
+                data_config = self._didv_data[chan]['data_config']
+                tes_bias = data_config['tes_bias']
+
+            # get results
+            results =  self.get_ivsweep_results(
+                chan,
+                iv_type=iv_type,
+                include_bias_parameters=include_bias_parameters,
+                tes_bias=tes_bias,
+            )
+
+            # save in include bias parameters
+            if include_bias_parameters:
+                pd_series = pd.Series(results.copy())
+                self.set_ivsweep_results(chan,
+                                         pd_series,
+                                         iv_type)
+                
+            # keep a copy as part of didv data
+            self._didv_data[chan]['ivsweep_results'] = results.copy()
+            
+            # check if Rp, Rshunt, R0 available
+            if 'rp' in results.keys():
+                rp = results['rp']
+            else:
+                raise ValueError(f'ERROR: "rp" is missing from IV results for '
+                                 f'channel {chan}. It needs to be added!')
+            
+            r0 = None
+            if 'r0' in results.keys():
+                r0 = results['r0']
+            
+            rshunt = None
+            if 'rshunt' in results.keys():
+                rshunt = results['rshunt']
+                      
+            # replace internal object data
+            if rp is not None:
+                self._didv_data[chan]['data_config']['rp'] = rp
+                self._didv_data[chan]['didvobj']._rp = rp
+            
+            if r0 is not None:
+                self._didv_data[chan]['didvobj']._r0 = r0
+                
+            if (rshunt is not None
+                and self._didv_data[chan]['data_config']['rshunt'] is None):
+                self._didv_data[chan]['data_config']['rshunt'] = rshunt
+                self._didv_data[chan]['didvobj']._rsh = rshunt
+        
+            
+        
+    def dofit(self, list_of_poles, channels=None,
+              fcutoff=np.inf, bounds=None, guess_params=None,
+              guess_isloopgainsub1=None, lgc_fix=None,
+              add180phase=False, dt0=1.5e-6,
+              lgc_plot=False,
+              tag='default'):
+        
+        """
+        Do dIdV fit for one or more channels. The function
+        "set_data" needs to be called prior "dofit" to store
+        didv data
+        
+        """
+
+        # check if data available for each channel
+        if channels is None:
+            channels = self._didv_data.keys()
+        elif isinstance(channels, str):
+            channels = [channels]
+
+            
+        for chan in channels:
+            if chan not in self._didv_data:
+                raise ValueError(
+                    f'ERROR: dIdV data for channel {chan} not available. '
+                    'Set data first!'
+                )
+            
+
+        # poles
+        if isinstance(list_of_poles, int):
+            list_of_poles = [list_of_poles]
+        else:
+            list_of_poles = list(list_of_poles)
+        list_of_poles.sort()
+                   
+            
+        # loop channel and do fit
+        for chan in channels:
+            
+            # get didv obj
+            didvobj = self._didv_data[chan]['didvobj']
+            didvobj._add180phase = add180phase
+            didvobj._dt0 = dt0
+            
+            for poles in list_of_poles:
+                didvobj.dofit(
+                    poles,
+                    fcutoff=fcutoff,
+                    bounds=bounds,
+                    guess_params=guess_params,
+                    guess_isloopgainsub1=guess_isloopgainsub1,
+                    lgcfix=lgc_fix
+                )
+            
+            # replace object with results included
+            self._didv_data[chan]['didvobj'] =  didvobj
+
+
+            if lgc_plot:
+                
+                if 2 in list_of_poles:
+                    self.print_fit_result(chan, poles=2)
+                    
+                if 3 in list_of_poles:
+                    self.print_fit_result(chan, poles=3)
+                
+                self.plot_fit_result(chan)
+
+
+        # save data
+        self.save_didv_data(save_hdf5=self._save_hdf5, tag=tag)
+          
+    
+    
+    def calc_smallsignal_params(self,
+                                channels=None,
+                                poles=None,
+                                priors_fit_method=False,
+                                lgc_diagnostics=False,
+                                tag='default'):
+        """
+        Calculate small signal parameters with uncertainties
+        (optionally) using current from IV sweep.
+        
+        """
+        print('Calculating small signal parameters...')
+        # check channels
+        if channels is None:
+            channels = self._didv_data.keys()
+        elif isinstance(channels, str):
+            channels = [channels]
+
+        for chan in channels:
+            if chan not in self._didv_data.keys():
+                raise ValueError(f'ERROR: dIdV fit not available for '
+                                 f'channel {chan}! Use "dofit" first.')
+       
+        # loop channel
+        for chan in channels:
+
+            if self._verbose:
+                print(f'INFO: Calculating small signal parameters '
+                      f'uncertainties for channel {chan}')
+
+            # data config
+            data_config = self._didv_data[chan]['data_config']
+            tes_bias = data_config['tes_bias']
+                
+            # get didvobj
+            didvobj = self._didv_data[chan]['didvobj']
+
+            # get bias parameters from IV-sweep/normal-IV processing
+            biasparams = None
+            if ('ivsweep_results' in self._didv_data[chan]
+                    and self._didv_data[chan]['ivsweep_results'] is not None):
+                biasparams = self._didv_data[chan]['ivsweep_results']
+                
+                if 'ibias' in biasparams:
+                    tes_bias = biasparams['ibias']
+                else:
+                    biasparams['ibias'] = tes_bias
+                                   
+                if self._verbose:
+                    print(f'INFO: Using ibias={tes_bias:.3e} A from '
+                          f'IV sweep for channel {chan}')
+                    
+
+            # calculate small signal params
+            didvobj.calc_smallsignal_params(
+                biasparams=biasparams,
+                poles=poles,
+                lgc_diagnostics=lgc_diagnostics
+            )
+
+            # replace
+            self._didv_data[chan]['didvobj'] = didvobj
+
+            
+        # store data
+        self.save_didv_data(save_hdf5=self._save_hdf5, tag=tag)
+               
+    
+    def calc_bias_params_infinite_loop_gain(self, channels=None, tag='default'):
+                                           
+        #
+        #Calculate I0,R0, and P0 with infinite loop gain
+        #approximation
+        #
+
+        # check channels
+        if channels is None:
+            channels = self._didv_data.keys()
+        elif isinstance(channels, str):
+            channels = [channels]
+        # get list of fitted poles
+        for chan in channels:
+            if chan not in self._didv_data.keys():
+                raise ValueError(f'ERROR: channel {chan} not available!')
+            didvobj = self._didv_data[chan]['didvobj']
+            list_of_fitted_poles =  didvobj.get_list_fitted_poles()
+            if (list_of_fitted_poles is None
+                or (2 not in list_of_fitted_poles
+                    and 3 not in list_of_fitted_poles)):
+                raise ValueError(f'ERROR: No fit available for '
+                                 f'channel {chan}!')
+            
+        # loop channel
+        for chan in channels:
+                   
+            if self._verbose:
+                print(f'INFO: Calculating bias parameters with '
+                      f'infinite loop gain approximation '
+                      f'for channel {chan}')
+
+            biasparams_ilg = dict()
+                
+            # get data config
+            data_config = self._didv_data[chan]['data_config']
+                
+            # get didvobj
+            didvobj = self._didv_data[chan]['didvobj']
+            list_of_fitted_poles =  didvobj.get_list_fitted_poles()
+         
+            # loop poles
+            for poles in list_of_fitted_poles:
+                
+                if (poles != 2 and poles != 3):
+                    continue
+                
+                fitresult = didvobj.fitresult(poles)
+
+                # check if result available
+                if (fitresult is None
+                    or 'params' not in fitresult):
+                    continue
+                                
+                ibias = None
+                ibias_err = 0
+                rp = None
+                rshunt = None
+                rn = None
+                if ('biasparams' in fitresult.keys() and
+                    fitresult['biasparams'] is not None):
+                 
+                    ibias = fitresult['biasparams']['ibias']
+                    if 'ibias_err' in  fitresult['biasparams']:
+                        ibias_err =  fitresult['biasparams']['ibias_err']
+                    else:
+                        ibias_err = 0
+                    rp = fitresult['biasparams']['rp']
+                    rshunt = fitresult['biasparams']['rshunt']
+                    if 'rn' in fitresult['biasparams']:
+                        rn = fitresult['biasparams']['rn']
+                else:
+                    ibias = data_config['tes_bias']
+                    if 'rp' not in data_config:
+                        raise ValueError('ERROR: Unable to find rp!'
+                                         'use "set_ivsweep_results()"  first')
+                    rp =  data_config['rp']
+                    rshunt = data_config['rshunt']
+                    if 'rn' in data_config:
+                        rn = data_config['rn']
+                        
+                biasparams_ilg[poles] = qp.get_biasparams_ilg(
+                    fitresult['params'],
+                    fitresult['cov'],
+                    ibias,
+                    ibias_err,
+                    rshunt,
+                    rp,
+                    rn=rn)
+                
+            self._didv_data[chan]['biasparams_ilg'] = biasparams_ilg
+
+        # store data
+        self.save_didv_data(save_hdf5=self._save_hdf5, tag=tag)
+                              
+   
+    def calc_dpdi(self, freqs, channels=None, list_of_poles=None,
+                  lgc_plot=False, tag='default'):
+        """
+        calculate dpdi in units of Volts
+        """
+
+        # check channels
+        if channels is None:
+            channels = self._didv_data.keys()
+        elif isinstance(channels, str):
+            channels = [channels]
+
+        for chan in channels:
+            if chan not in self._didv_data.keys():
+                raise ValueError(
+                    f'ERROR: No data found for channel {chan}!'
+                )
+            
+        for chan in channels:
+            
+            # get didvobj
+            didvobj = self._didv_data[chan]['didvobj']
+
+            # list of poles
+            list_of_fitted_poles = didvobj.get_list_fitted_poles() or []
+            if list_of_poles is None:
+                poles_to_process = list(list_of_fitted_poles)
+            elif isinstance(list_of_poles, int):
+                poles_to_process = [list_of_poles]
+            else:
+                poles_to_process = list(list_of_poles)
+
+
+            # loop poles
+            for poles in poles_to_process:
+
+                if poles not in list_of_fitted_poles:
+                    raise ValueError(f'ERROR: No fit available for poles '
+                                     f'{poles}. Use "dofit" function first!')
+
+                fitresult = didvobj.fitresult(poles)
+            
+                dpdi, dpdi_err = qp.get_dPdI_with_uncertainties(
+                    freqs, fitresult,
+                    lgcplot=lgc_plot)
+                
+                poles_str = str(poles) + 'poles'
+                self._didv_data[chan]['dpdi_' +  poles_str] = dpdi
+                self._didv_data[chan]['dpdi_err_' +  poles_str] = dpdi_err
+                self._didv_data[chan]['dpdi_freqs_' + poles_str] = freqs
+
+
+                
+        # store data
+        self.save_didv_data(save_hdf5=self._save_hdf5, tag=tag)
+                       
+    def calc_energy_resolution(self, channel, psd,
+                               poles=3, fs=None, template=None,
+                               collection_eff=1,
+                               lgc_power_template=False):
+        """
+        Get energy resolution based using  calculated dpdi and input
+        psd and template (dirac delta power input if template is None)
+        Default is template in current. 
+        """
+
+        # check data availability
+        if channel not in self._didv_data.keys():
+            raise ValueError(f'ERROR: No data found for channel {channel}!')
+
+        list_of_fitted_poles = (
+            self._didv_data[channel]['didvobj'].get_list_fitted_poles()
+        )
+        if poles not in list_of_fitted_poles:
+            raise ValueError(
+                f'ERROR: No {poles}-poles fit found for channel {channel}!'
+            )
+
+            
+        # check dpdi available
+        poles_str = str(poles) + 'poles'
+        if 'dpdi_' + poles_str not in self._didv_data[channel]:
+            raise ValueError(f'ERROR: No dpdi found for channel {channel}!')
+     
+        dpdi = self._didv_data[channel]['dpdi_' +  poles_str]
+        dpdi_freqs = self._didv_data[channel]['dpdi_freqs_' +  poles_str]
+
+        # sample rate
+        if fs is None:
+
+            if 'fs' not in self._didv_data[channel]['data_config']:
+                raise ValueError(f'ERROR: sample rate (fs) required!')
+
+            fs = self._didv_data[channel]['data_config']['fs']
+        
+
+        if template is None:
+
+            # dirac delta input power
+            nbins = psd.shape[-1]
+            pretrigger_index = nbins//2
+            template = unit_impulse(nbins, idx=pretrigger_index)
+
+        elif not lgc_power_template:
+            template = qp.convert_template_to_power(template,  dpdi=dpdi)
+
+            
+        # calculate energy resolution
+        resolution = qp.utils.energy_resolution(
+            psd, template, dpdi, fs,
+            collection_eff=collection_eff)
+
+        # store
+        res_dict = dict()
+        res_dict['psd'] = psd
+        res_dict['template'] = template
+        res_dict['fs'] = fs
+        res_dict['collection_efficiency'] = collection_eff
+        res_dict['energy_resolution'] = resolution
+        self._didv_data[channel]['resolution'] = res_dict
+
+        return resolution
+            
+                
+    def dofit_prior(self, channels=None, list_of_poles=None,
+                    use_ivsweep_current=True):
+        """Refit 2/3-pole models with priors derived from existing fits.
+
+        This is a legacy helper.  The previous implementation referenced
+        several undefined analysis-local variables.  Priors are now built
+        only from the selected channel's existing QETpy fit result, with
+        available bias-parameter uncertainties used for Rsh, Rp, and R0.
+        """
+
+        if channels is None:
+            channels = list(self._didv_data)
+        elif isinstance(channels, str):
+            channels = [channels]
+        else:
+            channels = list(channels)
+
+        for chan in channels:
+            if chan not in self._didv_data:
+                raise ValueError(
+                    f'ERROR: dIdV fit result not found for channel {chan}! '
+                    'Use "dofit" first.'
+                )
+
+            didvobj = self._didv_data[chan]['didvobj']
+            fitted_poles = didvobj.get_list_fitted_poles() or []
+            if list_of_poles is None:
+                poles_to_fit = [p for p in fitted_poles if p in (2, 3)]
+            elif isinstance(list_of_poles, int):
+                poles_to_fit = [list_of_poles]
+            else:
+                poles_to_fit = list(list_of_poles)
+
+            if not poles_to_fit:
+                raise ValueError(
+                    f'ERROR: No 2/3-pole fit available for channel {chan}'
+                )
+            missing = [p for p in poles_to_fit if p not in fitted_poles]
+            if missing:
+                raise ValueError(
+                    f'ERROR: Missing existing fit(s) {missing} for channel {chan}'
+                )
+
+            if self._verbose:
+                print(f'INFO: Do prior fit(s) for channel {chan}')
+
+            didvobj_prior = qp.DIDVPriors(
+                rawtraces=None,
+                fs=didvobj._fs,
+                sgfreq=didvobj._sgfreq,
+                sgamp=didvobj._sgamp,
+                rsh=didvobj._rsh,
+                dutycycle=didvobj._dutycycle,
+            )
+            didvobj_prior._time = didvobj._time
+            didvobj_prior._freq = didvobj._freq
+            didvobj_prior._didvmean = didvobj._didvmean
+            didvobj_prior._didvstd = didvobj._didvstd
+            didvobj_prior._offset = didvobj._offset
+            didvobj_prior._offset_err = didvobj._offset_err
+            didvobj_prior._tmean = didvobj._tmean
+            didvobj_prior._dt0 = didvobj._dt0
+
+            for poles_select in poles_to_fit:
+                results = didvobj.fitresult(poles_select)
+                smallsignal = results.get('smallsignalparams') if results else None
+                if not smallsignal:
+                    raise ValueError(
+                        f'ERROR: Small-signal parameters are required before '
+                        f'prior fitting {poles_select} poles for channel {chan}'
+                    )
+
+                if poles_select == 2:
+                    names = ['rsh', 'rp', 'r0', 'beta', 'l', 'L', 'tau0', 'dt']
+                elif poles_select == 3:
+                    names = [
+                        'rsh', 'rp', 'r0', 'beta', 'l', 'L',
+                        'tau0', 'gratio', 'tau3', 'dt',
+                    ]
+                else:
+                    raise ValueError('ERROR: prior fitting supports 2 or 3 poles')
+
+                priors = np.asarray([smallsignal[name] for name in names], dtype=float)
+                priors_cov = np.diag((0.1 * np.abs(priors)) ** 2)
+
+                biasparams = results.get('biasparams') or {}
+                sigma_rsh = float(
+                    biasparams.get('rshunt_err', biasparams.get('rsh_err', 0.1 * abs(priors[0])))
+                )
+                sigma_rp = float(
+                    biasparams.get('rp_err', 0.1 * abs(priors[1]))
+                )
+                sigma_r0 = float(
+                    biasparams.get('r0_err', 0.1 * abs(priors[2]))
+                )
+
+                priors_cov[0, 0] = sigma_rsh ** 2
+                priors_cov[1, 1] = sigma_rp ** 2
+                priors_cov[2, 2] = sigma_r0 ** 2
+                priors_cov[0, 1] = priors_cov[1, 0] = 0.5 * sigma_rsh * sigma_rp
+                priors_cov[0, 2] = priors_cov[2, 0] = 0.5 * sigma_rsh * sigma_r0
+                priors_cov[1, 2] = priors_cov[2, 1] = -0.2 * sigma_rp * sigma_r0
+
+                didvobj_prior.dofit(
+                    poles=poles_select,
+                    priors=priors,
+                    priorscov=priors_cov,
+                )
+
+            self._didv_data[chan]['didvobj_prior'] = didvobj_prior
+
+    def get_fit_results(self, channel, poles, verbose=True):
+        """
+        Get fit result
+        """
+
+        # check if object available
+        if channel not in self._didv_data:
+            raise ValueError(f'ERROR: dIdV data not available for '
+                             f'channel {channel}!')
+        
+        # check if fit done
+        result = self._didv_data[channel]['didvobj'].fitresult(poles)
+        if not result:
+            if self._verbose and verbose:
+                print(f'WARNING: {channel}: No fit result found for poles {poles}! '
+                      'Returning empty dictionary.')
+        return result
+
+    
+    def plot_fit_result(self, channels=None,
+                        lgc_plot_fft=True, lgc_gray_mean=True,
+                        lgc_didv_freq_filt=True,
+                        zoom_factor=None, fcutoff=2e4,
+                        lgc_save=False, save_path=None,
+                        save_name=None):
+        """
+        Plot fit results for multiple channels
+        """
+
+        
+        # check channels
+        if channels is None:
+            channels = self._didv_data.keys()
+        elif isinstance(channels, str):
+            channels = [channels]
+
+        for chan in channels:
+            if chan not in self._didv_data.keys():
+                raise ValueError(
+                    f'ERROR: dIdV fit result not found for channel {chan}! '
+                    'Use "dofit" first.'
+                )
+                  
+        # look chanels
+        for chan in channels:
+            
+            didvobj = self._didv_data[chan]['didvobj']
+
+            # check if any results
+            is_fitted = False
+            poles_list = [1,2,3]
+            for poles in poles_list:
+                if didvobj.fitresult(poles):
+                    is_fitted = True
+            if not is_fitted:
+                print(f'WARNING: No fit result available for channel {chan}!')
+                continue
+                    
+            # display
+            if self._verbose:
+                print(f'\n{chan} dIdV Fit Plots:')
+
+            didvobj.plot_full_trace(
+                didv_freq_filt=lgc_didv_freq_filt,
+                gray_mean=lgc_gray_mean,
+                saveplot=lgc_save,
+                savepath=save_path,
+                savename=save_name,
+                lp_cutoff=fcutoff,
+            )
+
+            if zoom_factor is not None:
+                didvobj.plot_zoomed_in_trace(
+                    didv_freq_filt=lgc_didv_freq_filt,
+                    saveplot=lgc_save,
+                    savepath=save_path,
+                    savename=save_name,
+                    lp_cutoff=fcutoff,
+                    zoomfactor=zoom_factor,
+                ) 
+
+            if lgc_plot_fft:
+                didvobj.plot_re_im_didv(
+                    poles='all',
+                    saveplot=lgc_save,
+                    savepath=save_path,
+                    savename=save_name,
+                )
+    
+                
+    def print_fit_result(self, channels=None, poles=3):
+        """
+        Print fit information
+        """
+
+        # check channels
+        if channels is None:
+            channels = self._didv_data.keys()
+        elif isinstance(channels, str):
+            channels = [channels]
+
+        for chan in channels:
+            if chan not in self._didv_data.keys():
+                raise ValueError(
+                    f'ERROR: dIdV fit result not found for channel {chan}! '
+                    'Use "dofit" first.'
+                )
+                  
+        # look chanels
+        for chan in channels:
+            
+            didvobj = self._didv_data[chan]['didvobj']
+
+            # check if any results
+            results = didvobj.fitresult(poles)
+            if not results:
+                print(f'WARNING: No fit result available for channel {chan}!')
+                continue
+            
+            print(f'\n{chan} dIdV {poles}-poles Fit Result:')
+
+            
+            print('Fit chi2/Ndof = {:.3f}'.format(results['cost']))
+            print('\nFit time constants, NOT dIdV Poles: ')
+            print('Tau1: {:.3g} s'.format(np.abs(results['params']['tau1'])))
+            print('Tau2: {:.3g} s'.format(results['params']['tau2']))
+            print('Tau3: {:.4g} s'.format(results['params']['tau3']))
+            print(' ')
+            print('\nTrue dIdV Poles: ')
+            print('Tau_plus: {:.3g} s'.format(results['falltimes'][0]))
+            print('Tau_minus: {:.3g} s'.format(results['falltimes'][1]))
+            print('Tau_third: {:.4g} s'.format(results['falltimes'][2]))
+            
+            if 'ssp_light' in results:
+                vals_vector = results['ssp_light']['vals']
+                sigmas_vector = results['ssp_light']['sigmas']
+                print('\nSmall Signal Parameters:')
+                print('l (loop gain) = {:.3f} +/- {:.4f}'.format(
+                    vals_vector['l'], sigmas_vector['sigma_l']))
+                print('beta = {:.3f} +/- {:.4f}'.format(
+                    vals_vector['beta'], sigmas_vector['sigma_beta']))
+                print('gratio = {:.3f} +/- {:.4f}'.format(
+                    vals_vector['gratio'], sigmas_vector['sigma_gratio']))
+                print('tau0 = {:.3g} +/- {:.4g} ms'.format(
+                    vals_vector['tau0']*1e3, sigmas_vector['sigma_tau0']*1e3))
+                print('L = {:.3f} +/- {:.4f} nH'.format(
+                    vals_vector['L']*1e9, sigmas_vector['sigma_L']*1e9))
+                
+                    
+    def compare_with_ivsweep(self, channel, poles=3):
+        """
+        Create a dataframe to compare results with
+        IV sweep
+        """
+
+        # check channel
+        if channel not in self._didv_data.keys():
+            raise ValueError(f'ERROR:  channel {channel} not found!')
+                 
+
+        didv_results = self.get_fit_results(channel, poles=poles)
+        ivsweep_results = self.get_ivsweep_results(channel)
+
+        data = dict()
+        
+        
+        if ('biasparams' in didv_results
+            and didv_results['biasparams'] is not None):
+
+            # define parameter list
+            param_list = ['r0','i0','p0']
+            norm_list = [1e3, 1e6, 1e15]
+            label_list = ['R0 [mOhms]','I0 [muAmps]','P0 [fWatts]']
+            label_inf_lgain_list = ['R0 Inf loop gain [mOhms]',
+                                    'I0 Inf loop gain [muAmps]',
+                                    'P0 Inf loop gain [fWatts]']
+
+            # results
+            results = didv_results['biasparams']
+            results_infinite_lgain = None
+            if 'biasparams_infinite_lgain' in didv_results:
+                results_infinite_lgain = (
+                    didv_results['biasparams_infinite_lgain']
+                )
+
+            # loop parameters
+            for iparam, param in enumerate(param_list):
+                
+                if param not in ivsweep_results:
+                    continue
+
+                # normalization/label
+                norm = norm_list[iparam]
+                label = label_list[iparam]
+                label_infinite_lgain = label_inf_lgain_list[iparam]
+
+                
+                # build string dIdV
+                val = results[param]
+                val_err = results[param + '_err']
+                val_str = '{:.3g} +/- {:.4g}'.format(
+                    val*norm, val_err*norm
+                )
+
+                
+                # build string IV 
+                iv_val = ivsweep_results[param]
+                iv_val_err = ivsweep_results[param + '_err']
+                iv_val_str = '{:.3g} +/- {:.4g}'.format(
+                    iv_val*norm, iv_val_err*norm
+                )
+                    
+                data[label] = [val_str, iv_val_str]
+
+                    
+                # infinite loop gain
+                if (results_infinite_lgain is not None
+                    and 'r0_infinite_lgain' in ivsweep_results):
+
+                    # build string dIdV
+                    val = results_infinite_lgain[param]
+                    val_err = results_infinite_lgain[param + '_err']
+                    val_str = '{:.3g} +/- {:.4g}'.format(
+                        val*norm, val_err*norm
+                    )
+
+                    # build string IV 
+                    iv_val = ivsweep_results[param + '_infinite_lgain']
+                    iv_val_err = ivsweep_results[param + '_err_infinite_lgain']
+                    iv_val_str = '{:.3g} +/- {:.4g}'.format(
+                        iv_val*norm, iv_val_err*norm
+                    )
+                    
+                    data[label_infinite_lgain] = [val_str, iv_val_str]
+
+
+        # small signal parmaters
+        if ('ssp_light' in didv_results
+            and 'didv_fit_l' in ivsweep_results):
+            
+            # define parameter list
+            param_list = ['l','beta','gratio', 'L', 'tau0']
+            norm_list = [1, 1, 1, 1e9, 1e3]
+            label_list = ['l (loop gain)','beta', 'gratio',
+                          'L [nH]', 'tau0 [ms]']
+
+            
+            vals_vector = didv_results['ssp_light']['vals']
+            sigmas_vector = didv_results['ssp_light']['sigmas']
+
+
+            # loop parameters
+            for iparam, param in enumerate(param_list):
+
+                param_iv = 'didv_fit_' + param
+                
+                # normalization/label
+                norm = norm_list[iparam]
+                label = label_list[iparam]
+             
+                
+                # build string dIdV
+                val = vals_vector[param]
+                val_err = sigmas_vector['sigma_' + param]
+                val_str = '{:.3g} +/- {:.4g}'.format(
+                    val*norm, val_err*norm
+                )
+                
+                # build string IV 
+                iv_val = ivsweep_results[param_iv]
+                iv_val_err = ivsweep_results[param_iv + '_err']
+                iv_val_str = '{:.3g} +/- {:.4g}'.format(
+                    iv_val*norm, iv_val_err*norm
+                )
+
+                # store data
+                data[label] = [val_str, iv_val_str]
+
+        #  fall times
+        if ('falltimes' in didv_results
+            and 'didv_fit_tau+' in ivsweep_results):
+            
+            # define parameter list
+            param_list = ['tau+','tau-','tau3']
+            norm_list = [1e6, 1e6, 1e6]
+            label_list = ['tau+ [usec]', 'tau- [usec]', 'tau3 [usec]']
+
+
+            falltimes = didv_results['falltimes']      
+        
+
+            # loop parameters
+            for iparam, param in enumerate(param_list):
+
+                if (poles == 2 and iparam>1):
+                    break
+
+                
+                param_iv = 'didv_fit_' + param
+                
+                # normalization/label
+                norm = norm_list[iparam]
+                label = label_list[iparam]
+             
+                
+                # build string dIdV
+                val = falltimes[iparam]
+                val_str = '{:.3g}'.format(val*norm)
+                
+                
+                # build string IV 
+                iv_val = ivsweep_results[param_iv]
+                iv_val_str = '{:.3g}'.format(iv_val*norm)
+
+                # save
+                data[label] = [val_str, iv_val_str]
+
+                  
+                        
+        df = None
+        if data:
+            df = pd.DataFrame.from_dict(data, orient='index', columns=['dIdV', 'IV Sweep'])
+            
+        return df
+
+
+    def save_didv_data(self, channels=None, save_path=None, save_hdf5=False, tag='default'):
+        """
+        Save didv data
+        """
+
+        # channels
+        if channels is None:
+            channels = self._didv_data.keys()
+        elif isinstance(channels, str):
+            channels = [channels]
+
+        for chan in channels:
+            if chan not in self._didv_data.keys():
+                raise ValueError(
+                    f'ERROR: No data found for channel {chan}!'
+                )
+
+
+        # loop channels and set data
+        save_data = False
+        for chan in channels:
+
+            # metadata
+            metadata = dict()
+            metadata['channel'] = chan
+            
+            data_config = self.get_didv_data(chan)['data_config']
+            if data_config is not None:
+                metadata.update(data_config.copy())
+                
+            # 2-poles
+            results = self.get_fit_results(chan, 2, verbose=False)
+            if results:
+                self.set_didv_results(chan, results, 2,
+                                      metadata=metadata, tag=tag)
+                save_data = True
+
+                
+            # 3-poles
+            results = self.get_fit_results(chan, 3, verbose=False)
+            if results:
+                self.set_didv_results(chan, results, 3,
+                                      metadata=metadata, tag=tag)
+                save_data = True
+            
+            # dpdi
+            fs = None
+            if ('data_config' in self._didv_data[chan]
+                and 'fs' in self._didv_data[chan]['data_config']):
+                fs = self._didv_data[chan]['data_config']['fs']
+            
+            if 'dpdi_2poles' in self._didv_data[chan]:
+                dpdi_freqs, dpdi, dpdi_err = self.get_dpdi(chan, 2)
+                self.set_dpdi(chan, dpdi, dpdi_err, dpdi_freqs, 2,
+                              sample_rate=fs,
+                              metadata=metadata, tag=tag)
+                save_data = True
+                
+            if 'dpdi_3poles' in self._didv_data[chan]:
+                dpdi_freqs, dpdi, dpdi_err = self.get_dpdi(chan, 3)
+                self.set_dpdi(chan, dpdi, dpdi_err, dpdi_freqs, 3,
+                              sample_rate=fs,
+                              metadata=metadata, tag=tag)
+                save_data = True
+
+        if not save_data:
+            return
+
+        if save_hdf5:
+
+            # file_name
+            file_path = self._save_path
+            if file_path is None:
+                file_path = './'
+            file_name = self._file_name
+        
+            if  save_path is not None:
+                if os.path.isfile(save_path):
+                    file_path = os.path.dirname(save_path)
+                    file_name = os.path.basename(save_path)
+                elif os.path.isdir(save_path):
+                    file_path = save_path
+                else:
+                    raise ValueError('ERROR: "save_path" should be a '
+                                     'file or path!')
+            full_file_name = file_path + '/' + file_name
+            if file_path[-1] == '/':
+                full_file_name = file_path + file_name
+
+            self.save_hdf5(full_file_name, overwrite=True)
+     
+                        
+    
+    def _process_raw_data(self, channel,
+                          data_path, stream=None,
+                          overwrite=False):
+        
+        """
+        Set dIdV data for a specific channel
+        form raw traces. Apply cuts and pre-process
+        data. The function can be called multiple
+        times for different channels 
+        """
+
+        if not overwrite and channel in self._didv_data:
+            raise ValueError(
+                f'ERROR: Data for channel {channel} already available. '
+                'Set overwrite=True'
+            )
+             
+        # Instantiate QETpy DIDV Object
+        didvobj = None
+        if self._verbose:
+            print(f'INFO: Getting raw data and processing channel {channel}')
+
+        
+        with StreamReader(
+            data_path,
+            streams=stream,
+            measurement_types='didv',
+        ) as reader:
+            selected_stream_ids = reader.selected_stream_ids
+            if len(selected_stream_ids) > 1:
+                raise ValueError(
+                    'ERROR: DIDVAnalysis.process_raw_data requires one dIdV '
+                    'stream at a time. Selected streams: '
+                    + ', '.join(selected_stream_ids)
+                )
+
+            traces, info = reader.read_records(
+                channels=channel,
+                include_metadata=True,
+                units='amps',
+                stack=True,
+            )
+            detector_settings = reader.get_detector_settings()
+
+            acquisition_name = reader.acquisition_name
+            stream_id = (
+                selected_stream_ids[0]
+                if selected_stream_ids
+                else None
+            )
+
+        traces = np.asarray(traces)
+        if traces.ndim != 3 or traces.shape[1] != 1:
+            raise ValueError(
+                'ERROR: Expected dIdV traces with shape '
+                f'(n_traces, 1, n_samples), got {traces.shape}'
+            )
+        if traces.shape[0] == 0 or not info:
+            raise ValueError(
+                f'ERROR: No dIdV records found for channel {channel}'
+            )
+
+        traces = traces[:, 0, :]
+        fs = float(info[0]['sample_rate_hz'])
+
+        if channel not in detector_settings:
+            raise ValueError(
+                f'ERROR: Detector settings for channel {channel} not found'
+            )
+        settings = detector_settings[channel]
+
+        tes_bias = self._required_float(
+            settings, 'tes_bias_dc_amps', channel
+        )
+        output_gain = self._optional_float(settings.get('output_gain'))
+        close_loop_norm = self._optional_float(settings.get('close_loop_norm'))
+        output_offset = self._optional_float(settings.get('output_offset_vdc'))
+        sgamp = self._required_float(
+            settings, 'tes_bias_ac_amplitude_amps', channel
+        )
+        sgfreq = self._required_float(
+            settings, 'tes_bias_ac_frequency_hz', channel
+        )
+
+        if sgfreq <= 0:
+            raise ValueError(
+                f'ERROR: Invalid dIdV frequency {sgfreq} Hz for {channel}'
+            )
+
+        rshunt = self._first_optional_float(
+            settings,
+            'shunt_resistance_ohm',
+            'rshunt',
+        )
+        if rshunt is None:
+            raise ValueError(
+                f'ERROR: Shunt resistance is required for channel {channel}'
+            )
+
+        rp = self._first_optional_float(
+            settings,
+            'parasitic_resistance_ohm',
+            'rp',
+        )
+
+        dutycycle = self._first_optional_float(
+            settings,
+            'dutycycle',
+            'duty_cycle',
+            'tes_bias_ac_dutycycle',
+        )
+        if dutycycle is None:
+            dutycycle = 0.5
+
+        if acquisition_name is None:
+            acquisition_name = info[0].get('acquisition_name')
+        if stream_id is None:
+            stream_id = info[0].get('stream_id')
+        stream_name = info[0].get('stream_name', stream_id)
+
+                        
+        # save relevant detector settings in dictionary
+        data_config = dict()
+        data_config['stream_id'] = stream_id
+        data_config['stream_name'] = stream_name
+        data_config['acquisition_name'] = acquisition_name
+        data_config['fs'] = fs
+        data_config['output_variable_gain'] = output_gain
+        data_config['output_variable_offset'] = output_offset
+        data_config['close_loop_norm'] = close_loop_norm
+        data_config['rshunt'] = rshunt
+        data_config['rp'] = rp
+        data_config['tes_bias'] = tes_bias
+        data_config['sgfreq'] = sgfreq
+        data_config['sgamp'] = sgamp
+        data_config['dutycycle'] = dutycycle
+
+
+
+        # add temperature
+        temperature_list = ['cp','mc','still']
+        for temp in temperature_list:
+            temp_par = 'temperature_' + temp
+            if temp_par in settings:
+                data_config[temp_par] = (
+                    float(settings[temp_par])
+                )
+                      
+
+        # Apply cuts
+        nonzero = ~np.all(traces == 0, axis=1)
+        traces = traces[nonzero]
+        if traces.shape[0] == 0:
+            raise ValueError(
+                f'ERROR: All dIdV traces are zero for channel {channel}'
+            )
+    
+        # cut pileup
+        cut = qp.autocuts_didv(traces, fs=fs)
+        traces = traces[cut]
+        if traces.shape[0] == 0:
+            raise ValueError(
+                f'ERROR: No dIdV traces survive autocuts for channel {channel}'
+            )
+
+        # Fit data
+        didvobj = qp.DIDV(traces,
+                          fs,
+                          sgfreq, 
+                          sgamp, 
+                          rshunt, 
+                          rp=rp,
+                          dutycycle=dutycycle,
+                          add180phase=False)
+            
+        # process
+        didvobj.processtraces()
+        
+        # store
+        self._didv_data[channel] = {'didvobj': didvobj,
+                                    'acquisition_name': acquisition_name,
+                                    'stream_id': stream_id,
+                                    'base_path': data_path,
+                                    'ivsweep_results': None,
+                                    'data_config': data_config,
+                                    'resolution': None}
+
+
+        
+    def _set_processed_data(self, channel,
+                            didv_data,
+                            overwrite=False,
+                            **kwargs ):
+        
+        """
+        Set dIdV data from already processed raw 
+        data, in the form of pandas stream or 
+        dictionary. The function can be called multiple
+        times for different channels 
+        """
+
+        if not overwrite and channel in self._didv_data:
+            raise ValueError(
+                f'ERROR: Data for channel {channel} already available. '
+                'Set overwrite=True'
+            )
+            
+        # check didv data
+        if isinstance(didv_data, pd.Series):
+            didv_data = didv_data.to_dict()
+        elif not isinstance(didv_data, dict):
+            raise ValueError(
+                'ERROR: "didv_data" should be a dictionary '
+                ' or pandas Series')
+               
+        # check variables 
+        available_vars = list(didv_data.keys())
+        required_vars = ['avgtrace_didv', 'didvmean','didvstd',
+                         'offset_didv','offset_err_didv',
+                         'sgamp', 'sgfreq',
+                         'fs_didv']
+        
+        for var in required_vars:
+            if var not in available_vars:
+                raise ValueError(f'ERROR: Missing variable {var} '
+                                 ' in didv_data')
+            
+        # check if channel stored in didv_data
+        if 'channel' in didv_data.keys():
+            channel_didv = str(didv_data['channel'])
+            if channel != channel_didv:
+                raise ValueError(
+                    f'ERROR: Channel name in didv data "{channel_didv}" '
+                    'is different than input channel!')
+
+        # check if other parameters are available
+        rshunt = None
+        if 'rshunt_noise' in didv_data.keys():
+            rshunt =  didv_data['rshunt_noise']
+        elif 'rshunt_didv' in didv_data.keys():
+            rshunt =  didv_data['rshunt_didv']
+        rshunt = self._first_finite_value(rshunt)
+        if rshunt is None:
+            raise ValueError(
+                f'ERROR: Missing/invalid rshunt in processed dIdV data for '
+                f'channel {channel}'
+            )
+            
+        # parasitic resistance 
+        rp = None
+        if 'rp_noise' in didv_data.keys():
+            rp =  didv_data['rp_noise']
+        elif 'rp_didv' in didv_data.keys():
+            rp =  didv_data['rp_didv']
+        rp = self._first_finite_value(rp)
+
+            
+        # duty cycle
+        dutycycle = 0.5
+        if 'dutycycle' in didv_data.keys():
+            dutycycle = didv_data['dutycycle']
+
+        # data config
+        data_config_pars = ['stream_id', 'stream_name', 'acquisition_name',
+                            'fs', 'output_variable_gain',
+                            'output_variable_offset',
+                            'close_loop_norm', 'tes_bias',
+                            'sgfreq','sgamp']
+        
+        data_config = dict()
+        for config in  data_config_pars:
+            config_name = config + '_didv'
+            if  config_name in didv_data.keys():
+                data_config[config] = didv_data[config_name]
+            elif config in ('sgfreq', 'sgamp') and config in didv_data:
+                data_config[config] = didv_data[config]
+            else:
+                data_config[config]= None
+                
+        data_config['rshunt'] = rshunt
+        data_config['rp'] = rp
+        data_config['dutycycle'] = dutycycle
+
+                 
+        # Instantiate QETpy DIDV Object
+        didvobj = qp.didvinitfromdata(
+            didv_data['avgtrace_didv'][:len(didv_data['didvmean'])],
+            didv_data['didvmean'],
+            didv_data['didvstd'],
+            didv_data['offset_didv'],
+            didv_data['offset_err_didv'],
+            didv_data['fs_didv'],
+            didv_data['sgfreq'],
+            didv_data['sgamp'],
+            rsh=rshunt,
+            rp=rp,
+            dutycycle=dutycycle,
+        )
+
+
+        # store
+        self._didv_data[channel] = {'didvobj': didvobj,
+                                    'acquisition_name': data_config['acquisition_name'],
+                                    'stream_id': data_config['stream_id'],
+                                    'base_path': None,
+                                    'ivsweep_results': None,
+                                    'data_config': data_config,
+                                    'resolution': None}
+
+    @staticmethod
+    def _optional_float(value):
+        if value is None:
+            return np.nan
+        try:
+            output = float(value)
+        except (TypeError, ValueError):
+            return np.nan
+        return output
+
+    @classmethod
+    def _first_finite_value(cls, value):
+        output = cls._optional_float(value)
+        if np.isfinite(output):
+            return output
+        return None
+
+    @classmethod
+    def _required_float(cls, settings, key, channel):
+        value = cls._optional_float(settings.get(key))
+        if not np.isfinite(value):
+            raise ValueError(
+                f'ERROR: Invalid or missing "{key}" for channel {channel}'
+            )
+        return value
+
+    @classmethod
+    def _first_optional_float(cls, settings, *keys):
+        for key in keys:
+            if key not in settings:
+                continue
+            value = cls._optional_float(settings.get(key))
+            if np.isfinite(value):
+                return value
+        return None
+
+    def _default_save_path(self, data_path):
+        """Choose the default filterdata directory for raw input."""
+
+        try:
+            catalog = AcquisitionCatalog(data_path, verbose=False)
+            source_path = Path(catalog.acquisition_path)
+        except Exception:
+            if isinstance(data_path, (list, tuple)):
+                if not data_path:
+                    source_path = Path('.')
+                else:
+                    source_path = Path(data_path[0])
+            else:
+                source_path = Path(data_path)
+            if source_path.is_file():
+                source_path = source_path.parent
+
+        path_text = str(source_path)
+        if '/processed/' in path_text:
+            path_text = path_text.replace('/processed/', '/filterdata/')
+        elif '/raw/' in path_text:
+            path_text = path_text.replace('/raw/', '/filterdata/')
+
+        output_path = Path(path_text)
+        try:
+            output_path.mkdir(parents=True, exist_ok=True)
+            os.chmod(
+                output_path,
+                stat.S_IRWXG | stat.S_IRWXU | stat.S_IROTH | stat.S_IXOTH,
+            )
+        except OSError as exc:
+            raise ValueError(
+                f'ERROR: Unable to create directory "{output_path}"!'
+            ) from exc
+        return str(output_path)
+        
+
+    def _set_file_name(self):
+        """
+        Set file name 
+        """
+
+        
+        now = datetime.now()
+        timestamp_id = now.strftime("D%Y%m%d_T%H%M%S")
+        file_name = f"didv_analysis_{timestamp_id}.hdf5"
+        
+        return file_name