{ "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 dislay 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", "bin_lo = None\n", "bin_hi = 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", "bin_lo = None\n", "bin_hi = None\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 colums 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" ] } ], "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", "Iterative Fit Method = None\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 relavant `get` call (in this case `ui.get_reg_proj`)." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "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 0x7f00ce698310>
" ], "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.10.5" } }, "nbformat": 4, "nbformat_minor": 4 }