class CosineModel(lmfit.model.Model):\n",
" """\n",
" Exemplary lmfit model with a guess for a cosine.\n",
"\n",
" .. note::\n",
"\n",
" The :mod:`lmfit.models` module provides several fitting models that might fit\n",
" your needs out of the box.\n",
" """\n",
"\n",
" def __init__(self, *args, **kwargs):\n",
" # pass in the model's equation\n",
" super().__init__(cos_func, *args, **kwargs)\n",
"\n",
" # configure constraints that are independent from the data to be fitted\n",
" self.set_param_hint("frequency", min=0, vary=True) # enforce positive frequency\n",
" self.set_param_hint("amplitude", min=0, vary=True) # enforce positive amplitude\n",
" self.set_param_hint("offset", vary=True)\n",
" self.set_param_hint(\n",
" "phase", vary=True, min=-np.pi, max=np.pi\n",
" ) # enforce phase range\n",
"\n",
" # pylint: disable=missing-function-docstring\n",
" def guess(self, data, x, **kws) -> lmfit.parameter.Parameters:\n",
" """\n",
" Guess parameters based on the data\n",
"\n",
" Parameters\n",
" ----------\n",
" data: np.ndarray\n",
" Data to fit to\n",
" x: np.ndarray\n",
" Independet variable\n",
" """\n",
"\n",
" self.set_param_hint("offset", value=np.average(data))\n",
" self.set_param_hint("amplitude", value=(np.max(data) - np.min(data)) / 2)\n",
"\n",
" # Guess frequency and phase using Fourier Transform\n",
" freq_guess, phase_guess = fft_freq_phase_guess(data, x)\n",
" phase_wrap = (phase_guess + np.pi) % (2 * np.pi) - np.pi\n",
" self.set_param_hint("frequency", value=freq_guess)\n",
" self.set_param_hint("phase", value=phase_wrap)\n",
"\n",
" params = self.make_params()\n",
" return lmfit.models.update_param_vals(params, self.prefix, **kws)\n",
"\n",
" # Same design patter is used in lmfit.models to inherit common docstrings.\n",
" # We adjust these common docstrings to our docs build pipeline\n",
" __init__.__doc__ = get_model_common_doc() + mk_seealso("cos_func")\n",
" guess.__doc__ = get_guess_common_doc()\n",
"class CosineAnalysis(ba.BaseAnalysis):\n",
" """\n",
" Exemplary analysis subclass that fits a cosine to a dataset.\n",
" """\n",
"\n",
" def process_data(self):\n",
" """\n",
" In some cases, you might need to process the data, e.g., reshape, filter etc.,\n",
" before starting the analysis. This is the method where it should be done.\n",
"\n",
" See :meth:`~quantify_core.analysis.spectroscopy_analysis.ResonatorSpectroscopyAnalysis.process_data`\n",
" for an implementation example.\n",
" """ # pylint: disable=line-too-long\n",
"\n",
" def run_fitting(self):\n",
" """\n",
" Fits a :class:`~quantify_core.analysis.fitting_models.CosineModel` to the data.\n",
" """\n",
" # create a fitting model based on a cosine function\n",
" model = CosineModel()\n",
" guess = model.guess(self.dataset.y0.values, x=self.dataset.x0.values)\n",
" result = model.fit(\n",
" self.dataset.y0.values, x=self.dataset.x0.values, params=guess\n",
" )\n",
" self.fit_results.update({"cosine": result})\n",
"\n",
" def create_figures(self):\n",
" """\n",
" Creates a figure with the data and the fit.\n",
" """\n",
" fig, ax = plt.subplots()\n",
" fig_id = "cos_fit"\n",
" self.figs_mpl.update({fig_id: fig})\n",
" self.axs_mpl.update({fig_id: ax})\n",
"\n",
" self.dataset.y0.plot(ax=ax, x="x0", marker="o", linestyle="")\n",
" qpl.plot_fit(ax, self.fit_results["cosine"])\n",
" qpl.plot_textbox(ax, ba.wrap_text(self.quantities_of_interest["fit_msg"]))\n",
"\n",
" adjust_axeslabels_SI(ax)\n",
" qpl.set_suptitle_from_dataset(fig, self.dataset, "x0-y0")\n",
" ax.legend()\n",
"\n",
" def analyze_fit_results(self):\n",
" """\n",
" Checks fit success and populates :code:`quantities_of_interest`.\n",
" """\n",
" fit_result = self.fit_results["cosine"]\n",
" fit_warning = ba.check_lmfit(fit_result)\n",
"\n",
" # If there is a problem with the fit, display an error message in the text box.\n",
" # Otherwise, display the parameters as normal.\n",
" if fit_warning is None:\n",
" self.quantities_of_interest["fit_success"] = True\n",
" unit = self.dataset.y0.units\n",
" text_msg = "Summary\\n"\n",
" text_msg += format_value_string(\n",
" r"$f$", fit_result.params["frequency"], end_char="\\n", unit="Hz"\n",
" )\n",
" text_msg += format_value_string(\n",
" r"$A$", fit_result.params["amplitude"], unit=unit\n",
" )\n",
" else:\n",
" text_msg = fit_warning\n",
" self.quantities_of_interest["fit_success"] = False\n",
"\n",
" # save values and fit uncertainty\n",
" for parameter_name in ["frequency", "amplitude"]:\n",
" self.quantities_of_interest[parameter_name] = ba.lmfit_par_to_ufloat(\n",
" fit_result.params[parameter_name]\n",
" )\n",
" self.quantities_of_interest["fit_msg"] = text_msg\n",
"