{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Notebook support in Sherpa\n", "\n", "A number of objects have been updated to support HTML output when displayed in a Jupyter notebook. Let's take a quick tour!\n", "\n", "## Data1D, Data1DInt, and Data2D\n", "\n", "First we have the data objects:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from sherpa.data import Data1D, Data1DInt, Data2D\n", "\n", "x = np.arange(100, 200, 20)\n", "y = [120, 240, 30, 95, 130]\n", "\n", "d1 = Data1D('oned', x, y)\n", "d1i = Data1DInt('onedint', x[:-1], x[1:], y[:-1])\n", " \n", "x0 = [150, 250, 100]\n", "x1 = [250, 200, 200]\n", "y2 = [50, 40, 70]\n", "d2 = Data2D('twod', x0, x1, y2) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Each can be displayed with `print`, which shows a textual representation of attribute and values:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "name = oned\n", "x = Int64[5]\n", "y = Int64[5]\n", "staterror = None\n", "syserror = None\n" ] } ], "source": [ "print(d1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Or they can be displayed as-is which, **in a Jupyter notebook**, will display either a plot or a HTML table. The `Data1D` and `Data1DInt` classes will display a plot (if the `pylab` plotting backend is selected), and the `Data2D` class a table." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<Data1D data set instance 'oned'>
" ], "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "d1" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "name = onedint\n", "xlo = Int64[4]\n", "xhi = Int64[4]\n", "y = Int64[4]\n", "staterror = None\n", "syserror = None\n" ] } ], "source": [ "print(d1i)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<Data1DInt data set instance 'onedint'>
" ], "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "d1i" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As mentioned, the `Data2D` class just gets a fancy HTML table but no plot:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "name = twod\n", "x0 = Int64[3]\n", "x1 = Int64[3]\n", "y = Int64[3]\n", "shape = None\n", "staterror = None\n", "syserror = None\n" ] } ], "source": [ "print(d2)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<Data2D data set instance 'twod'>
" ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "d2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## DataPHA, DataARF, and DataRMF\n", "\n", "The Astronomy-specific PHA, ARF, and RMF data classes can also be displayed. These (when you have `pylab` selected) display both the data and a table of information." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "read ARF file ../sherpa-test-data/sherpatest/9774.arf\n", "read RMF file ../sherpa-test-data/sherpatest/9774.rmf\n", "read background file ../sherpa-test-data/sherpatest/9774_bg.pi\n" ] } ], "source": [ "from sherpa.astro import io\n", "\n", "pha = io.read_pha('../sherpa-test-data/sherpatest/9774.pi')\n", "arf = io.read_arf('../sherpa-test-data/sherpatest/9774.arf')\n", "rmf = io.read_rmf('../sherpa-test-data/sherpatest/9774.rmf')" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "name = ../sherpa-test-data/sherpatest/9774.pi\n", "channel = Float64[1024]\n", "counts = Float64[1024]\n", "staterror = None\n", "syserror = None\n", "grouping = None\n", "quality = None\n", "exposure = 75141.227687398\n", "backscal = 4.3513325252917e-07\n", "areascal = 1.0\n", "grouped = False\n", "subtracted = False\n", "units = energy\n", "rate = True\n", "plot_fac = 0\n", "response_ids = [1]\n", "background_ids = [1]\n" ] } ], "source": [ "print(pha)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<DataPHA data set instance '../sherpa-test-data/sherpatest/9774.pi'>
" ], "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pha" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The PHA object will change the display based on the data - that is, if you change the filtering and grouping you will see a different plot,\n", "and the table will also change:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<DataPHA data set instance '../sherpa-test-data/sherpatest/9774.pi'>
" ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pha.notice(0.3, 7)\n", "pha.group_counts(20, tabStops=~pha.mask)\n", "\n", "pha" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It will also change if you change the analysis setting:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<DataPHA data set instance '../sherpa-test-data/sherpatest/9774.pi'>
" ], "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pha.set_analysis('wave')\n", "\n", "pha" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The ARF and RMF objects do not change based on their settings:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "name = ../sherpa-test-data/sherpatest/9774.arf\n", "energ_lo = Float64[1078]\n", "energ_hi = Float64[1078]\n", "specresp = Float64[1078]\n", "exposure = 75141.231099099\n", "ethresh = 1e-10\n" ] } ], "source": [ "print(arf)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<DataARF data set instance '../sherpa-test-data/sherpatest/9774.arf'>
" ], "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arf" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "name = ../sherpa-test-data/sherpatest/9774.rmf\n", "energ_lo = Float64[1078]\n", "energ_hi = Float64[1078]\n", "n_grp = UInt64[1078]\n", "f_chan = UInt64[1481]\n", "n_chan = UInt64[1481]\n", "matrix = Float64[438482]\n", "e_min = Float64[1024]\n", "e_max = Float64[1024]\n", "detchans = 1024\n", "offset = 1\n", "ethresh = 1e-10\n" ] } ], "source": [ "print(rmf)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For the RMF, five energies are selected that span the response of the instrument, and the response to these monochromatic energies are displayed." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<DataRMF data set instance '../sherpa-test-data/sherpatest/9774.rmf'>
" ], "text/plain": [ "" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rmf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## DataIMG\n", "\n", "For images with little metadata, and no WCS information, we just get an image:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "img = io.read_image('../sherpa-test-data/sherpatest/img.fits')" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<DataIMG data set instance '../sherpa-test-data/sherpatest/img.fits'>
" ], "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "img" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If the image contains WCS information, or some basic metadata, then we will get extra tables\n", "(unfortunately this test image doesn't display particularly wonderfully as the source\n", "is faint!)." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<DataIMG data set instance '../sherpa-test-data/sherpatest/acisf08478_000N001_r0043_regevt3_srcimg.fits'>
" ], "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "img2 = io.read_image('../sherpa-test-data/sherpatest/acisf08478_000N001_r0043_regevt3_srcimg.fits')\n", "\n", "img2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As with the PHA object, we can change the display slightly, such as changing the `coord` setting and spatially filtering the data:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<DataIMG data set instance '../sherpa-test-data/sherpatest/acisf08478_000N001_r0043_regevt3_srcimg.fits'>
" ], "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "img2.set_coord('physical')\n", "img2.notice2d('circle(3150, 4520, 20)')\n", "\n", "img2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Models and parameters\n", "\n", "Models and parameters can also be displayed directly as HTML tables, mirroring their `print` output." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "from sherpa.models.basic import Gauss2D, Const2D\n", "\n", "mgauss = Gauss2D()\n", "mconst = Const2D()\n", "\n", "mgauss.xpos = 3150\n", "mgauss.ypos = 4520\n", "\n", "mdl = mgauss + mconst" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can compare the model output (this also works with a single component, such as `mgauss` and `mconst`):" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "gauss2d + const2d\n", " Param Type Value Min Max Units\n", " ----- ---- ----- --- --- -----\n", " gauss2d.fwhm thawed 10 1.17549e-38 3.40282e+38 \n", " gauss2d.xpos thawed 3150 -3.40282e+38 3.40282e+38 \n", " gauss2d.ypos thawed 4520 -3.40282e+38 3.40282e+38 \n", " gauss2d.ellip frozen 0 0 0.999 \n", " gauss2d.theta frozen 0 -6.28319 6.28319 radians\n", " gauss2d.ampl thawed 1 -3.40282e+38 3.40282e+38 \n", " const2d.c0 thawed 1 -3.40282e+38 3.40282e+38 \n" ] } ], "source": [ "print(mdl)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<BinaryOpModel model instance 'gauss2d + const2d'>
" ], "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mdl" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can have a display for parameters (I chose this model since we can see the minimum and maximum columns get displayed as units of $\\pi$ in the notebook-display version):" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "val = 0.0\n", "min = -6.283185307179586\n", "max = 6.283185307179586\n", "units = radians\n", "frozen = True\n", "link = None\n", "default_val = 0.0\n", "default_min = -6.283185307179586\n", "default_max = 6.283185307179586\n" ] } ], "source": [ "print(mgauss.theta)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<Parameter 'theta' of model 'gauss2d'>
" ], "text/plain": [ "" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mgauss.theta" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fitting data\n", "\n", "Various objects related to fitting will also display in Jupyter notebooks. I fit a simple model (the model we just created, in fact) to the last image we were looking at. For this example I use the `sherpa.astro.ui` layer to fit, rather than creating the fit object manually." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING: imaging routines will not be available, \n", "failed to import sherpa.image.ds9_backend due to \n", "'RuntimeErr: DS9Win unusable: Could not find ds9 on your PATH'\n", "WARNING: failed to import sherpa.astro.xspec; XSPEC models will not be available\n" ] } ], "source": [ "from sherpa.astro import ui\n", "\n", "ui.set_data(img2)\n", "ui.set_source(mdl)\n", "\n", "ui.set_stat('cash')\n", "ui.set_method('simplex')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The output of the fit call is still just text:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset = 1\n", "Method = neldermead\n", "Statistic = cash\n", "Initial fit statistic = 2727.34\n", "Final fit statistic = 233.065 at function evaluation 841\n", "Data points = 1258\n", "Degrees of freedom = 1253\n", "Change in statistic = 2494.28\n", " gauss2d.fwhm 5.23044 \n", " gauss2d.xpos 3146.36 \n", " gauss2d.ypos 4519.61 \n", " gauss2d.ampl 0.445907 \n", " const2d.c0 0.0120648 \n" ] } ], "source": [ "ui.fit()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "However, we can see the model results (as shown above):" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<BinaryOpModel model instance 'gauss2d + const2d'>
" ], "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ui.get_source()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also display the fit results directly (I am dropping the comparison to the `print` output in part to show you can just call routines like `ui.get_git_results` and see the display without needing to call `print`, at least in a Jupyter notebook):" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<Fit results instance>
" ], "text/plain": [ "" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ui.get_fit_results()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly, the output of `conf` (or `covar`) is just text, but the results can be accessed directly with `ui.get_conf_results` or `ui.get_covar_results`:" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "gauss2d.xpos lower bound:\t-0.681324\n", "gauss2d.ypos lower bound:\t-0.634733\n", "gauss2d.fwhm lower bound:\t-0.747274\n", "gauss2d.ypos upper bound:\t0.668076\n", "gauss2d.ampl lower bound:\t-0.159288\n", "gauss2d.xpos upper bound:\t0.704771\n", "gauss2d.fwhm upper bound:\t1.19291\n", "gauss2d.ampl upper bound:\t0.21565\n", "const2d.c0 lower bound:\t-0.00297985\n", "const2d.c0 upper bound:\t0.00356563\n", "Dataset = 1\n", "Confidence Method = confidence\n", "Fitting Method = neldermead\n", "Statistic = cash\n", "confidence 1-sigma (68.2689%) bounds:\n", " Param Best-Fit Lower Bound Upper Bound\n", " ----- -------- ----------- -----------\n", " gauss2d.fwhm 5.23044 -0.747274 1.19291\n", " gauss2d.xpos 3146.36 -0.681324 0.704771\n", " gauss2d.ypos 4519.61 -0.634733 0.668076\n", " gauss2d.ampl 0.445907 -0.159288 0.21565\n", " const2d.c0 0.0120648 -0.00297985 0.00356563\n" ] } ], "source": [ "ui.conf()" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<confidence results instance>
" ], "text/plain": [ "" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ui.get_conf_results()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `get_stat_info` call returns information for each dataset. As this is a list, the overall output just gets displayed as text, but if you access an individual element you will get a HTML table: " ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ui.get_stat_info()" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<Statistic information results instance>
" ], "text/plain": [ "" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ui.get_stat_info()[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once you have created an interval- or region-projection plot, such as this comparison of the x and y centers of the gaussian, you can display the results with the relevant `get` call (in this case `ui.get_reg_proj`)." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ui.reg_proj(mgauss.xpos, mgauss.ypos)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
<sherpa.plot.RegionProjection object at 0x7e5c2d317d90>
" ], "text/plain": [ "" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ui.get_reg_proj()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.5" } }, "nbformat": 4, "nbformat_minor": 4 }