sqdtoolz 0.9.3.dev1__tar.gz → 0.9.4.dev1__tar.gz

{sqdtoolz-0.9.3.dev1 → sqdtoolz-0.9.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqdtoolz
-Version: 0.9.3.dev1
+Version: 0.9.4.dev1
 Summary: toolbox to control and run experiments
 Author-email: Prasanna Pakkiam <p.pakkiam@uq.edu.au>, Rohit Beriwal <f20150302d@alumni.bits-pilani.ac.in>
 Project-URL: Homepage, https://github.com/sqdlab/sqdtoolz

{sqdtoolz-0.9.3.dev1 → sqdtoolz-0.9.4.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqdtoolz"
-version = "0.9.3.dev1"
+version = "0.9.4.dev1"
 description = "toolbox to control and run experiments"
 readme = "README.md"
 requires-python = ">=3.10"

{sqdtoolz-0.9.3.dev1 → sqdtoolz-0.9.4.dev1}/sqdtoolz/ExperimentSpecification.py

@@ -93,6 +93,14 @@ class ExperimentSpecification:
             obj = self._lab._get_resolved_obj(self._cur_mappings[cur_entry]['Destination'])
             if obj != None:
                 setattr(obj, self._cur_mappings[cur_entry]['Property'], self._cur_mappings[cur_entry]['Value'])
+   
+    def update_entries(self):
+        for cur_entry in self._cur_mappings:
+            if len(self._cur_mappings[cur_entry]['Destination']) == 0:
+                continue
+            obj = self._lab._get_resolved_obj(self._cur_mappings[cur_entry]['Destination'])
+            if obj != None:
+                self._cur_mappings[cur_entry]['Value'] = getattr(obj, self._cur_mappings[cur_entry]['Property'])
 
     def _get_targets(self):
         ret_targets = []

sqdtoolz-0.9.4.dev1/sqdtoolz/Experiments/Experimental/ExpZIBellStateFidelity.py

@@ -0,0 +1,81 @@
+from sqdtoolz.Experiments.Experimental.ExpZIqubit import ExpZIqubit
+from sqdtoolz.Utilities.DataDensityMatrix import DataDensityMatrix
+from sqdtoolz.Experiments.Experimental.ExpZIQASM import ExpZIQASM
+from sqdtoolz.Experiments.Experimental.ExpZIQASMDataViewer import ExpZIQASMDataViewer
+from sqdtoolz.Utilities.DataDensityMatrix import DataDensityMatrix
+from sqdtoolz.HAL.ZI.QuantumElements import TunableTransmonCouplerFixed
+
+class ExpZIBellStateFidelity(ExpZIqubit):   
+    def __init__(self, name, expt_config, hal_QPU, qubit_ids, **kwargs):
+
+        assert len(qubit_ids)==2, "Must provide exactly two qubits in qubit_ids, e.g. ['Q0', 'Q2']."
+
+        self._name = name
+        self._qubit_ids = qubit_ids
+        self._hal_QPU = hal_QPU
+        self._config = expt_config
+
+        self._dont_show_plot = kwargs.pop('dont_show_plot', False)
+        self._update_coupler = kwargs.pop('update', True)
+
+        self._q1_object = self._hal_QPU.get_qubit_obj(qubit_ids[0])
+        self._q2_object = self._hal_QPU.get_qubit_obj(qubit_ids[1])
+
+        self._qasm_path = kwargs.pop('save_qasm_path', f'BellStateTomography{qubit_ids[0]}{qubit_ids[1]}.qasm')
+
+        kwargs['coordinate_system'] = kwargs.get('coordinate_system', 'RH')
+        assert kwargs['coordinate_system'] in ['LH', 'RH'], "The 'coordinate_system' must be either LH or RH for left/right handed."
+
+        state_prep = """reset q[0];
+reset q[1];
+h q[0];
+h q[1];
+cz q[0], q[1];
+h q[1];
+"""     
+        print(f"Building QASM script...")
+        self._qasm_full = DataDensityMatrix.generate_tomography_qasm(state_prep, num_qubits=2, save=self._qasm_path)
+
+        self._file_path = None
+        self._purity = None
+        self._fidelity = None
+        
+    def run(self, lab):
+        all_qubits = [i[0][0] for i in self._hal_QPU._qubits]
+        exp = ExpZIQASM(self._name, self._config, self._hal_QPU, all_qubits, self._qasm_path)
+
+        qregs = exp.get_qubit_regs()
+        exp.set_qubit_reg_to_ZI_mappings({('q',0): self._qubit_ids[1],('q',1): self._qubit_ids[0]})
+        assert len(qregs) <= len(self._qubit_ids), f"The QASM script needs {len(qregs)} while only {len(self._qubit_ids)} qubits have been specified."
+
+        lab.run_single(exp, override_ACQ_params={'AcquisitionMode': 'DISCRIMINATION', 'AveragingOrder': 'SingleShot'})
+        self._file_path = exp._file_path
+
+    def post_process(self, use_abs_phase=False, readout_correction=True, state='ge'):
+        # if readout_correction != None:
+        #     self._readout_correction = readout_correction
+
+        #TODO: need to check this for the new readout configs
+
+        ledv = ExpZIQASMDataViewer(self._file_path)
+        ledv.get_inner_slicing_vars()
+        #
+        if readout_correction is True and self._q1_object.CorrectionMatrix is not None and self._q2_object.CorrectionMatrix is not None:
+            try:
+                leRho = DataDensityMatrix.fromDataViewer(ledv, readout_correction_matrices=[self._q1_object.CorrectionMatrix, self._q2_object.CorrectionMatrix])
+            except:
+                leRho = DataDensityMatrix.fromDataViewer(ledv, readout_correction_matrices=[self._q1_object.CorrectionMatrix, self._q2_object.CorrectionMatrix])
+            else:
+                pass
+        elif readout_correction:
+            print("Unable to apply readout correction as CorrectionMatrix was not found in qubit attributes. Please check the selected correction matrix (i.e. 'ge' or 'gef') is present. Continuing without readout correction.")
+            leRho = DataDensityMatrix.fromDataViewer(ledv)
+        else:
+            leRho = DataDensityMatrix.fromDataViewer(ledv)
+        self._fidelity = leRho.get_fidelity_pure_state([1,0,0,1])*100
+        leRho.plot3D([1,0,0,1], use_abs_phase=use_abs_phase, extra_title=f' - {self._qubit_ids[0]}{self._qubit_ids[1]}: $F={self._fidelity:.4f}$', save_path=self._file_path + 'BellState.png')
+        self._purity = leRho.get_purity() 
+        if self._update_coupler:
+            cpl = self._hal_QPU.get_coupler_obj_from_qubits(self._qubit_ids[0], self._qubit_ids[1], TunableTransmonCouplerFixed)
+            cpl.FidelityBell = self._fidelity
+        

{sqdtoolz-0.9.3.dev1 → sqdtoolz-0.9.4.dev1}/sqdtoolz/Experiments/Experimental/ExpZIBlobs.py

@@ -81,3 +81,12 @@ class ExpZIBlobs(ExpZIqubit):
         #
         fig.suptitle(f"Average Fidelity: {leDIQD.get_average_fidelity()*100:.4g}% {extra_title}", y=0.92)
         return fig
+
+
+    def get_correction_matrices(self, update=False):
+        ret_mats = []
+        for m,qubit in enumerate(self._qubit_ids): 
+            ret_mats.append(np.linalg.inv(self._leDIQDs[m].get_assignment_probabilities().T))
+            if update:
+                self._hal_QPU.get_qubit_obj(qubit).CorrectionMatrix = ret_mats[-1]
+        return ret_mats

sqdtoolz-0.9.4.dev1/sqdtoolz/Experiments/Experimental/ExpZICalibX.py

@@ -0,0 +1,217 @@
+from sqdtoolz.Experiments.Experimental.ExpZIqubit import ExpZIqubit
+from sqdtoolz.Utilities.DataIQNormalise import DataIQNormalise
+import matplotlib.pyplot as plt
+from sqdtoolz.Utilities.DataFitting import*
+from sqdtoolz.Utilities.Miscellaneous import Miscellaneous
+from sqdtoolz.Experiments.Experimental.ZI import single_qubit_gates_sweep
+import numpy as np
+import scipy.optimize
+
+
+class ExpZICalibX(ExpZIqubit):
+    def __init__(self, name, expt_config, hal_QPU, qubit_ids, calib_denominator=1, **kwargs):
+        self._qubit_datasets = qubit_ids
+        self._hal_QPU = hal_QPU
+
+        self._dont_show_plot = kwargs.pop('dont_show_plot', False)
+        assert (not 'update' in kwargs) or ('update' in kwargs and not kwargs['update']), "Don't set 'update=True'. The updates shall be done by calling update_qubit after running the experiment."
+        kwargs['update'] = False
+        self._fit_vals = []
+        self._fit_data = []
+        self._failed_qubits = []
+        self._cur_angle = 0.0
+        self._prev_angle = 0.0
+        self._only_every_n = kwargs.pop('only_every_n', 1)
+        assert calib_denominator in [1, 2], "Either supply 'calib_denominator' with 1 or 2 for X or X/2 gate calibration"
+        self._calib_denominator = calib_denominator
+        self._num_gates = kwargs.pop('num_gates', 20)
+
+        self._expected_corr_sign = kwargs.pop('expected_corr_sign', None)
+        assert self._expected_corr_sign in (None, 1, -1, 1.0, -1.0), "expected_corr_sign must be None, 1 or -1"
+
+        if calib_denominator == 2:
+            gate_label = 'X/2'
+        else:
+            gate_label = 'X'
+
+        kwargs['gate_lists'] = [[[gate_label] * n for _ in range(len(qubit_ids))] for n in range(1, self._num_gates + 1) if n % self._only_every_n == 0]
+
+        self._n_vals = np.array([n for n in range(1, self._num_gates + 1) if n % self._only_every_n == 0])
+        assert len(self._n_vals) >= 4, (
+            f"only_every_n={self._only_every_n} with num_gates={self._num_gates} leaves only "
+            f"{len(self._n_vals)} gate-count point(s) -- need at least 4 for a reliable fit. "
+            "Reduce only_every_n or increase num_gates."
+        )
+        super().__init__(name, expt_config, single_qubit_gates_sweep, hal_QPU, qubit_ids, **kwargs)
+
+    def _model_func(self, n_vals, corr_pct, decay_per_100):
+        if self._calib_denominator == 2:
+            return np.sin((n_vals - 1) * (1 + corr_pct / 100) * np.pi / 2) \
+                   * np.exp(-(n_vals - 1) / (decay_per_100 * 100)) / 2 + 0.5
+        else:
+            return np.cos((n_vals - 1) * (1 + corr_pct / 100) * np.pi) \
+                   * np.exp(-(n_vals - 1) / (decay_per_100 * 100)) / 2 + 0.5
+
+    def _fit_single_qubit(self, qubit_dataset):
+        leData = self.retrieve_last_dataset(qubit_dataset)
+        arr = leData.get_numpy_array()
+        assert self._normalise_data, "No point analysing this without normalised data..."
+
+        # Get calibration data
+        calib_file = qubit_dataset + '_calib'
+        leDataCalib = self.retrieve_last_dataset(calib_file)
+        dnorm = ExpZIqubit.normalise_qubit_data(leDataCalib, self._transition)
+        pop_probs = dnorm.normalise_data(arr)
+
+        n_vals = self._n_vals
+
+        # bounds
+        if self._expected_corr_sign == 1 or self._expected_corr_sign == 1.0:
+            corr_bounds = (0.0, 10.0)
+        elif self._expected_corr_sign == -1 or self._expected_corr_sign == -1.0:
+            corr_bounds = (-10.0, 0.0)
+        else:
+            corr_bounds = (-10.0, 10.0)
+        decay_bounds = (0.1, 20.0) #TODO: check this bound
+
+        # initial guess
+        corr_grid = np.linspace(*corr_bounds, 801)
+        decay_grid = np.geomspace(*decay_bounds, 25)
+        best_cost, best_guess = np.inf, (0.0, 1.0)
+        for decay in decay_grid:
+            residuals = pop_probs[None, :] - self._model_func(n_vals[None, :], corr_grid[:, None], decay)
+            costs = np.sum(residuals ** 2, axis=1)
+            i = np.argmin(costs)
+            if costs[i] < best_cost:
+                best_cost, best_guess = costs[i], (corr_grid[i], decay)
+
+        try:
+            popt, pcov = scipy.optimize.curve_fit(
+                self._model_func, n_vals, pop_probs, p0=best_guess,
+                bounds=([corr_bounds[0], decay_bounds[0]], [corr_bounds[1], decay_bounds[1]]),
+                method='trf', maxfev=20000,
+            )
+            perr = np.sqrt(np.diag(pcov)) if np.all(np.isfinite(pcov)) else (np.nan, np.nan)
+        except RuntimeError as e:
+            raise RuntimeError(f"curve_fit failed to converge from grid guess {best_guess}: {e}")
+
+        fit_data = {'Gate': 'X/2' if self._calib_denominator == 2 else 'X'}
+        fit_data['Corr_Fac_Pct'] = popt[0]
+        fit_data['Corr_Fac_Pct_err'] = perr[0]
+        fit_data['Gate_Decay_per_100'] = popt[1]
+        fit_data['Gate_Decay_per_100_err'] = perr[1]
+
+        # --- Goodness-of-fit / sanity checks --------------------------------
+        fitted = self._model_func(n_vals, *popt)
+        ss_res = np.sum((pop_probs - fitted) ** 2)
+        ss_tot = np.sum((pop_probs - np.mean(pop_probs)) ** 2)
+        r_squared = 1 - ss_res / ss_tot if ss_tot > 0 else np.nan
+        fit_data['r_squared'] = r_squared
+
+        pinned = (np.isclose(popt[0], corr_bounds, atol=0.05).any()
+                  or np.isclose(popt[1], decay_bounds, atol=0.05).any())
+        if pinned:
+            print(f"Fit for '{qubit_dataset}' has a parameter at its bound (corr={popt[0]:.3f}%, decay={popt[1]:.3f}/100) -- do not trust this calibration without inspecting the plot.")
+        if not np.isnan(r_squared) and r_squared < 0.8:
+            print(f"Poor fit quality for '{qubit_dataset}' (R^2={r_squared:.3f}). Inspect fitted_plot_{qubit_dataset}.png before trusting this correction factor.")
+
+        if (1 + popt[0] / 100) < 1:
+            fit_data['Gate_Corr_Fac'] = float(1 / (1 + popt[0] / 100))
+        else:
+            fit_data['Gate_Corr_Fac'] = 2 - float(1 / (1 + popt[0] / 100))
+
+        fig, ax = plt.subplots(1)
+        ax.plot(n_vals, pop_probs, 'o-')
+        ax.plot(n_vals, fitted, 'ro')
+        ax.set_xlabel('Number of Gates (n)')
+        ax.set_ylabel(r'Normalised $e$-Population')
+        if self._calib_denominator == 2:
+            cur_angle = (1 + popt[0] / 100) * 90
+            # self._prev_angle = (1 + popt[0] / 100) * 90
+            ax.set_title(f"Actual X/2 angle: {cur_angle:.6f}\n"
+                         f"Previous angle: {self._prev_angle:.6f}")
+        else:
+            cur_angle = (1 + popt[0] / 100) * 180
+            # self._prev_angle = (1 + popt[0] / 100) * 180
+            ax.set_title(f"Actual X angle: {cur_angle:.6f}\n"
+                         f"Previous angle: {self._prev_angle:.6f}")
+        self._prev_angle = cur_angle
+        fit_data['angle'] = cur_angle
+        ax.legend(['Raw', 'Fit'])
+        fig.savefig(self._file_path + f'fitted_plot_{qubit_dataset}.png')
+        if not self._dont_show_plot:
+            fig.show()
+        else:
+            plt.close(fig)
+
+        fit_data['n_vals'] = n_vals
+        np.save(self._file_path + f'fitted_data_{qubit_dataset}.npy', fit_data)
+        fit_data['pop_probs'] = pop_probs
+        fit_data['fitted_pop_probs'] = fitted
+        fit_data['calib_denominator'] = self._calib_denominator
+        return fit_data
+
+    def _post_process(self, data):
+        self._fit_vals = []
+        self._fit_data = []
+        self._failed_qubits = []
+        for qubit_dataset in self._qubit_datasets:
+            try:
+                fit_data = self._fit_single_qubit(qubit_dataset)
+            except Exception as e:
+                print(f"[ExpZICalibX] ERROR: fit failed for qubit '{qubit_dataset}': {e}")
+                self._failed_qubits.append(qubit_dataset)
+                self._fit_data.append({'qubit_name': qubit_dataset, 'data': None, 'error': str(e)})
+                continue
+            self._fit_data.append({'qubit_name': qubit_dataset, 'data': fit_data})
+            #TODO: Generalise it for EF later?
+            self._fit_vals.append({'qubit_obj': self._hal_QPU.get_qubit_obj(qubit_dataset),
+                                    'Gate_Corr_Fac': fit_data['Gate_Corr_Fac']})
+        if self._failed_qubits:
+            print(f"[ExpZICalibX] {len(self._failed_qubits)} qubit(s) have no usable fit and will "
+                  f"be skipped by update_qubits: {self._failed_qubits}")
+
+    @staticmethod
+    def plot_fitted_results(ax, data: dict, qubit_name=None):
+        if 'n_vals' in data:
+            data_x = data['n_vals']
+        else:
+            # Fallback for fit_data saved by an older version of this class that
+            # didn't record n_vals: this reproduces the OLD x-axis --
+            print("[ExpZICalibX] WARNING: 'n_vals' not found in saved fit data "
+                  "(this was fitted with an older version) -- plotting against "
+                  "iteration index, which is only correct if only_every_n was 1.")
+            data_x = np.arange(0, len(data['pop_probs']), 1)
+        data_y = data['pop_probs']
+        fit = data['fitted_pop_probs']
+        ax.set_ylabel(r'Normalised $e$-Population')
+        ax.set_xlabel('Gates')
+        ax.grid(visible=True, which='minor'); ax.grid(visible=True, which='major', color='k')
+        ax.plot(data_x, data_y, 'kx')
+        ax.plot(data_x, fit, 'ro-', lw=1)
+        if qubit_name is not None:
+            qstring = f'{qubit_name} '
+        else:
+            qstring = ''
+        # r2 = data.get('r_squared', None)
+        # r2_str = f" (R^2={r2:.3f})" if r2 is not None and not np.isnan(r2) else ""
+        if data['calib_denominator'] == 2:
+            ax.set_title(f"{qstring}Actual X/2 angle: {data['angle']:.6f}")
+        else:
+            ax.set_title(f"{qstring}Actual X angle: {data['angle']:.6f}")
+        ax.legend(['Raw', 'Fit'])
+
+    def update_qubits(self, reverse_parity=False):
+        assert len(self._fit_vals) > 0, "Must run ExpZICalibX Experiment before qubits can be updated."
+        if self._failed_qubits:
+            print(f"[ExpZICalibX] Skipping update for qubit(s) with no usable fit: {self._failed_qubits}")
+        while len(self._fit_vals) > 0:
+            cur_fit = self._fit_vals.pop(0)
+            if reverse_parity:
+                correction = 2 - cur_fit['Gate_Corr_Fac']
+            else:
+                correction = cur_fit['Gate_Corr_Fac']
+            if self._calib_denominator == 2:
+                cur_fit['qubit_obj'].DriveGEAmplitudeXon2 *= correction
+            elif self._calib_denominator == 1:
+                cur_fit['qubit_obj'].DriveGEAmplitudeX *= correction

{sqdtoolz-0.9.3.dev1 → sqdtoolz-0.9.4.dev1}/sqdtoolz/Experiments/Experimental/ExpZIChevrons2QFixedCoupler.py

@@ -17,6 +17,7 @@ class ExpZIChevrons2QFixedCoupler(ExpZIqubit):
         self._fit_freq = None
         assert 'amplitudes' in kwargs, "Must supply the array of flux amplitudes to sweep on the coupler."
         self._amplitudes = kwargs.pop('amplitudes')
+        assert np.min(self._amplitudes) >= -1 and np.max(self._amplitudes) <= 1, f"Magnitude of a value in the amplitude sweep is above unity ({np.min(self._amplitudes):.2f} t0 {np.max(self._amplitudes):.2f})."
         self._plot_with_frequency = kwargs.pop('plot_with_frequency', True)
         
         self.cur_coupler_obj = hal_QPU.get_coupler_obj_from_qubits(qubit_ids[0],qubit_ids[1], TunableTransmonCouplerFixed)

{sqdtoolz-0.9.3.dev1 → sqdtoolz-0.9.4.dev1}/sqdtoolz/Experiments/Experimental/ExpZICryoscope.py

@@ -30,7 +30,7 @@ class ExpZICryoscope:
         assert len(self._qubit_ids) >1 , "Also must define a second qubit as it will attempt to optimise a pulse specific to each coupler element"
 
         self._amplitudes = kwargs.pop('amplitudes', np.linspace(0.3, 0.3, 1))
-        self._lengths = kwargs.pop('lengths', np.linspace(0.0, 300e-9, (1/2.0)*1e-9))
+        self._lengths = kwargs.pop('lengths', np.arange(0.0, 300e-9, (1/2.0)*1e-9))
         self._transition = kwargs.pop('transition', 'ge')
 
         self._normalise_data = kwargs.pop('normalise_data', True)
@@ -44,42 +44,47 @@ class ExpZICryoscope:
         assert self.Ec_over_h is not None, "Must provide Ec_over_h for the qubit to convert frequency shift to flux for pulse reconstruction."
         self.norm_window = kwargs.pop('norm_window', None)
         
-        def run(self, lab):
-            qubit = self._qubit_ids[0]
-
-            lab.group_open(self._name)
-            # x90 - measures <Y>
-            exp_X = ExpZIqubit(f'cryoscope_{qubit}_X90', self._expt_config, cryo_scope, self._hal_QPU, self._qubit_ids, 
-                            lengths=self._lengths, 
-                            amplitudes=self._amplitudes,
-                            y90=False,
-                            **self._kwargs
-                            )
-            lab.run_single(exp_X, **kwargs)
-            #
-            dataX90 = exp_X.retrieve_last_dataset(qubit)
-            if self._normalise_data:
-                self.data['calibX'] = exp_X.retrieve_last_dataset(qubit+'_calib')
-
-            # y90 - measures <X>
-            exp_Y = ExpZIqubit(f'cryoscope_{qubit}_Y90', self._expt_config, cryo_scope, self._hal_QPU, self._qubit_ids, 
-                            lengths=self._lengths, 
-                            amplitudes=self._amplitudes,
-                            y90=True,
-                            **self._kwargs
-                            )
-            lab.run_single(exp_Y, **kwargs)
-            #
-            dataY90 = exp_Y.retrieve_last_dataset(qubit)
-            if self._normalise_data:
-                self.data['calibY'] = exp_Y.retrieve_last_dataset(qubit+'_calib')
-
-            lab.group_close()
-
-            self.data['Y'] = dataX90.get_numpy_array()
-            self.data['X'] = dataY90.get_numpy_array()
-            self.data['tau'] = dataX90.param_vals[1]
-            self.data['amplitude'] = dataX90.param_vals[0]
+    def run(self, lab):
+        kwargs = self._kwargs
+        qubit = self._qubit_ids[0]
+
+        lab.group_open(self._name)
+        # x90 - measures <Y>
+        exp_X = ExpZIqubit(f'cryoscope_{qubit}_X90', self._expt_config, cryo_scope, self._hal_QPU, self._qubit_ids, 
+                        lengths=self._lengths, 
+                        amplitudes=self._amplitudes,
+                        y90=False,
+                        **self._kwargs
+                        )
+        lab.run_single(exp_X, **kwargs)
+        #
+        dataX90 = exp_X.retrieve_last_dataset(qubit)
+        if self._normalise_data:
+            self.data['calibX'] = exp_X.retrieve_last_dataset(qubit+'_calib')
+
+        # y90 - measures <X>
+        exp_Y = ExpZIqubit(f'cryoscope_{qubit}_Y90', self._expt_config, cryo_scope, self._hal_QPU, self._qubit_ids, 
+                        lengths=self._lengths, 
+                        amplitudes=self._amplitudes,
+                        y90=True,
+                        **self._kwargs
+                        )
+        lab.run_single(exp_Y, **kwargs)
+        #
+        dataY90 = exp_Y.retrieve_last_dataset(qubit)
+        if self._normalise_data:
+            self.data['calibY'] = exp_Y.retrieve_last_dataset(qubit+'_calib')
+
+        lab.group_close()
+
+        self.data['Y'] = dataX90.get_numpy_array()
+        self.data['X'] = dataY90.get_numpy_array()
+        self.data['tau'] = dataX90.param_vals[1]
+        self.data['amplitude'] = dataX90.param_vals[0]
+
+        self.post_process()
+        self.plot_summary()
+        self.fit_step_response()
 
     def post_process(self, filter_window_length=7, polyorder=2):
         assert isinstance(filter_window_length, int) and filter_window_length > 0, "filter_window_length must be a positive integer"