{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "
\n", "\n", "**This is a fixed-text formatted version of a Jupyter notebook**\n", "\n", "- Try online [![Binder](https://static.mybinder.org/badge.svg)](https://mybinder.org/v2/gh/gammapy/gammapy-webpage/v0.18.2?urlpath=lab/tree/analysis_2.ipynb)\n", "- You can contribute with your own notebooks in this\n", "[GitHub repository](https://github.com/gammapy/gammapy/tree/master/docs/tutorials).\n", "- **Source files:**\n", "[analysis_2.ipynb](../_static/notebooks/analysis_2.ipynb) |\n", "[analysis_2.py](../_static/notebooks/analysis_2.py)\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# First analysis with gammapy library API\n", "\n", "## Prerequisites:\n", "\n", "- Understanding the gammapy data workflow, in particular what are DL3 events and intrument response functions (IRF).\n", "- Understanding of the data reduction and modeling fitting process as shown in the [first gammapy analysis with the high level interface tutorial](analysis_1.ipynb)\n", "\n", "## Context\n", "\n", "This notebook is an introduction to gammapy analysis this time using the lower level classes and functions\n", "the library.\n", "This allows to understand what happens during two main gammapy analysis steps, data reduction and modeling/fitting. \n", "\n", "**Objective: Create a 3D dataset of the Crab using the H.E.S.S. DL3 data release 1 and perform a simple model fitting of the Crab nebula using the lower level gammapy API.**\n", "\n", "## Proposed approach:\n", "\n", "Here, we have to interact with the data archive (with the `~gammapy.data.DataStore`) to retrieve a list of selected observations (`~gammapy.data.Observations`). Then, we define the geometry of the `~gammapy.datasets.MapDataset` object we want to produce and the maker object that reduce an observation\n", "to a dataset. \n", "\n", "We can then proceed with data reduction with a loop over all selected observations to produce datasets in the relevant geometry and stack them together (i.e. sum them all).\n", "\n", "In practice, we have to:\n", "- Create a `~gammapy.data.DataStore` poiting to the relevant data \n", "- Apply an observation selection to produce a list of observations, a `~gammapy.data.Observations` object.\n", "- Define a geometry of the Map we want to produce, with a sky projection and an energy range.\n", " - Create a `~gammapy.maps.MapAxis` for the energy\n", " - Create a `~gammapy.maps.WcsGeom` for the geometry\n", "- Create the necessary makers : \n", " - the map dataset maker : `~gammapy.makers.MapDatasetMaker`\n", " - the background normalization maker, here a `~gammapy.makers.FoVBackgroundMaker`\n", " - and usually the safe range maker : `~gammapy.makers.SafeRangeMaker`\n", "- Perform the data reduction loop. And for every observation:\n", " - Apply the makers sequentially to produce the current `~gammapy.datasets.MapDataset`\n", " - Stack it on the target one.\n", "- Define the `~gammapy.modeling.models.SkyModel` to apply to the dataset.\n", "- Create a `~gammapy.modeling.Fit` object and run it to fit the model parameters\n", "- Apply a `~gammapy.estimators.FluxPointsEstimator` to compute flux points for the spectral part of the fit.\n", "\n", "## Setup\n", "First, we setup the analysis by performing required imports.\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "from astropy import units as u\n", "from astropy.coordinates import SkyCoord\n", "from regions import CircleSkyRegion" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from gammapy.data import DataStore\n", "from gammapy.datasets import MapDataset\n", "from gammapy.maps import WcsGeom, MapAxis, Map\n", "from gammapy.makers import MapDatasetMaker, SafeMaskMaker, FoVBackgroundMaker\n", "from gammapy.modeling.models import (\n", " SkyModel,\n", " PowerLawSpectralModel,\n", " PointSpatialModel,\n", " FoVBackgroundModel,\n", ")\n", "from gammapy.modeling import Fit\n", "from gammapy.estimators import FluxPointsEstimator" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Defining the datastore and selecting observations\n", "\n", "We first use the `~gammapy.data.DataStore` object to access the observations we want to analyse. Here the H.E.S.S. DL3 DR1. " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "data_store = DataStore.from_dir(\"$GAMMAPY_DATA/hess-dl3-dr1\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now define an observation filter to select only the relevant observations. \n", "Here we use a cone search which we define with a python dict.\n", "\n", "We then filter the `ObservationTable` with `~gammapy.data.ObservationTable.select_observations()`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "selection = dict(\n", " type=\"sky_circle\",\n", " frame=\"icrs\",\n", " lon=\"83.633 deg\",\n", " lat=\"22.014 deg\",\n", " radius=\"5 deg\",\n", ")\n", "selected_obs_table = data_store.obs_table.select_observations(selection)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now retrieve the relevant observations by passing their `obs_id` to the`~gammapy.data.DataStore.get_observations()` method." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "observations = data_store.get_observations(selected_obs_table[\"OBS_ID\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Preparing reduced datasets geometry\n", "\n", "Now we define a reference geometry for our analysis, We choose a WCS based geometry with a binsize of 0.02 deg and also define an energy axis: " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "energy_axis = MapAxis.from_energy_bounds(1.0, 10.0, 4, unit=\"TeV\")\n", "\n", "geom = WcsGeom.create(\n", " skydir=(83.633, 22.014),\n", " binsz=0.02,\n", " width=(2, 2),\n", " frame=\"icrs\",\n", " proj=\"CAR\",\n", " axes=[energy_axis],\n", ")\n", "\n", "# Reduced IRFs are defined in true energy (i.e. not measured energy).\n", "energy_axis_true = MapAxis.from_energy_bounds(\n", " 0.5, 20, 10, unit=\"TeV\", name=\"energy_true\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can define the target dataset with this geometry." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "stacked = MapDataset.create(\n", " geom=geom, energy_axis_true=energy_axis_true, name=\"crab-stacked\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data reduction\n", "\n", "### Create the maker classes to be used\n", "\n", "The `~gammapy.datasets.MapDatasetMaker` object is initialized as well as the `~gammapy.makers.SafeMaskMaker` that carries here a maximum offset selection." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "offset_max = 2.5 * u.deg\n", "maker = MapDatasetMaker()\n", "maker_safe_mask = SafeMaskMaker(methods=[\"offset-max\"], offset_max=offset_max)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "circle = CircleSkyRegion(\n", " center=SkyCoord(\"83.63 deg\", \"22.14 deg\"), radius=0.2 * u.deg\n", ")\n", "data = geom.region_mask(regions=[circle], inside=False)\n", "exclusion_mask = Map.from_geom(geom=geom, data=data)\n", "maker_fov = FoVBackgroundMaker(method=\"fit\", exclusion_mask=exclusion_mask)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Perform the data reduction loop" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Background norm obs 23523: 0.99\n", "Background norm obs 23526: 1.08\n", "Background norm obs 23559: 0.99\n", "Background norm obs 23592: 1.10\n", "CPU times: user 2.28 s, sys: 136 ms, total: 2.42 s\n", "Wall time: 2.43 s\n" ] } ], "source": [ "%%time\n", "\n", "for obs in observations:\n", " # First a cutout of the target map is produced\n", " cutout = stacked.cutout(\n", " obs.pointing_radec, width=2 * offset_max, name=f\"obs-{obs.obs_id}\"\n", " )\n", " # A MapDataset is filled in this cutout geometry\n", " dataset = maker.run(cutout, obs)\n", " # The data quality cut is applied\n", " dataset = maker_safe_mask.run(dataset, obs)\n", " # fit background model\n", " dataset = maker_fov.run(dataset)\n", " print(\n", " f\"Background norm obs {obs.obs_id}: {dataset.background_model.spectral_model.norm.value:.2f}\"\n", " )\n", " # The resulting dataset cutout is stacked onto the final one\n", " stacked.stack(dataset)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MapDataset\n", "----------\n", "\n", " Name : crab-stacked \n", "\n", " Total counts : 2479 \n", " Total background counts : 2112.97\n", " Total excess counts : 366.03\n", "\n", " Predicted counts : 2112.97\n", " Predicted background counts : 2112.97\n", " Predicted excess counts : nan\n", "\n", " Exposure min : 3.75e+08 m2 s\n", " Exposure max : 3.48e+09 m2 s\n", "\n", " Number of total bins : 40000 \n", " Number of fit bins : 40000 \n", "\n", " Fit statistic type : cash\n", " Fit statistic value (-2 log(L)) : nan\n", "\n", " Number of models : 0 \n", " Number of parameters : 0\n", " Number of free parameters : 0\n", "\n", "\n" ] } ], "source": [ "print(stacked)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspect the reduced dataset" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "stacked.counts.sum_over_axes().smooth(0.05 * u.deg).plot(\n", " stretch=\"sqrt\", add_cbar=True\n", ");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Save dataset to disk\n", "\n", "It is common to run the preparation step independent of the likelihood fit, because often the preparation of maps, PSF and energy dispersion is slow if you have a lot of data. We first create a folder:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "path = Path(\"analysis_2\")\n", "path.mkdir(exist_ok=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And then write the maps and IRFs to disk by calling the dedicated `~gammapy.datasets.MapDataset.write()` method:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "filename = path / \"crab-stacked-dataset.fits.gz\"\n", "stacked.write(filename, overwrite=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define the model\n", "We first define the model, a `SkyModel`, as the combination of a point source `SpatialModel` with a powerlaw `SpectralModel`:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "target_position = SkyCoord(ra=83.63308, dec=22.01450, unit=\"deg\")\n", "spatial_model = PointSpatialModel(\n", " lon_0=target_position.ra, lat_0=target_position.dec, frame=\"icrs\"\n", ")\n", "\n", "spectral_model = PowerLawSpectralModel(\n", " index=2.702,\n", " amplitude=4.712e-11 * u.Unit(\"1 / (cm2 s TeV)\"),\n", " reference=1 * u.TeV,\n", ")\n", "\n", "sky_model = SkyModel(\n", " spatial_model=spatial_model, spectral_model=spectral_model, name=\"crab\"\n", ")\n", "\n", "bkg_model = FoVBackgroundModel(dataset_name=\"crab-stacked\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we assign this model to our reduced dataset:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "stacked.models = [sky_model, bkg_model]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fit the model\n", "\n", "The `~gammapy.modeling.Fit` class is orchestrating the fit, connecting the `stats` method of the dataset to the minimizer. By default, it uses `iminuit`.\n", "\n", "Its contructor takes a list of dataset as argument." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------------------------------------------------------\n", "| FCN = 1.624e+04 | Ncalls=126 (126 total) |\n", "| EDM = 9.28e-05 (Goal: 0.0002) | up = 1.0 |\n", "------------------------------------------------------------------\n", "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", "------------------------------------------------------------------\n", "| True | True | False | False |\n", "------------------------------------------------------------------\n", "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", "------------------------------------------------------------------\n", "| False | True | True | True | False |\n", "------------------------------------------------------------------\n", "CPU times: user 2.15 s, sys: 264 ms, total: 2.42 s\n", "Wall time: 2.43 s\n" ] } ], "source": [ "%%time\n", "fit = Fit([stacked])\n", "result = fit.run(optimize_opts={\"print_level\": 1})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `FitResult` contains information on the fitted parameters." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Table length=8\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
namevalueunitminmaxfrozenerror
str9float64str14float64float64boolfloat64
index2.6010e+00nannanFalse1.004e-01
amplitude4.5901e-11cm-2 s-1 TeV-1nannanFalse3.705e-12
reference1.0000e+00TeVnannanTrue0.000e+00
lon_08.3619e+01degnannanFalse3.114e-03
lat_02.2024e+01deg-9.000e+019.000e+01False2.960e-03
norm9.3513e-01nannanFalse2.192e-02
tilt0.0000e+00nannanTrue0.000e+00
reference1.0000e+00TeVnannanTrue0.000e+00
" ], "text/plain": [ "\n", " name value unit min max frozen error \n", " str9 float64 str14 float64 float64 bool float64 \n", "--------- ---------- -------------- ---------- --------- ------ ---------\n", " index 2.6010e+00 nan nan False 1.004e-01\n", "amplitude 4.5901e-11 cm-2 s-1 TeV-1 nan nan False 3.705e-12\n", "reference 1.0000e+00 TeV nan nan True 0.000e+00\n", " lon_0 8.3619e+01 deg nan nan False 3.114e-03\n", " lat_0 2.2024e+01 deg -9.000e+01 9.000e+01 False 2.960e-03\n", " norm 9.3513e-01 nan nan False 2.192e-02\n", " tilt 0.0000e+00 nan nan True 0.000e+00\n", "reference 1.0000e+00 TeV nan nan True 0.000e+00" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "result.parameters.to_table()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspecting residuals\n", "\n", "For any fit it is useful to inspect the residual images. We have a few options on the dataset object to handle this. First we can use `.plot_residuals_spatial()` to plot a residual image, summed over all energies:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "stacked.plot_residuals_spatial(method=\"diff/sqrt(model)\", vmin=-0.5, vmax=0.5);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition, we can also specify a region in the map to show the spectral residuals:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "region = CircleSkyRegion(\n", " center=SkyCoord(\"83.63 deg\", \"22.14 deg\"), radius=0.5 * u.deg\n", ")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "stacked.plot_residuals(\n", " kwargs_spatial=dict(method=\"diff/sqrt(model)\", vmin=-0.5, vmax=0.5),\n", " kwargs_spectral=dict(region=region),\n", ");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also directly access the `.residuals()` to get a map, that we can plot interactively:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "residuals = stacked.residuals(method=\"diff\")\n", "residuals.smooth(\"0.08 deg\").plot_interactive(\n", " cmap=\"coolwarm\", vmin=-0.2, vmax=0.2, stretch=\"linear\", add_cbar=True\n", ");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plot the fitted spectrum" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Making a butterfly plot \n", "\n", "The `SpectralModel` component can be used to produce a, so-called, butterfly plot showing the enveloppe of the model taking into account parameter uncertainties:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "spec = sky_model.spectral_model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can actually do the plot using the `plot_error` method:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAEKCAYAAABUsYHRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3hkd3n//fctadRGs+rSqNnbi7S7tsHYgAGb4gY2ptnYuFAcuPILmJCEEAzk5yQkgYfkSejwmEDIYrOLbYqxgwvdFIMLxitp+65XfdXLzKjOzP38MSMjhDQaac4USffrunyhOXPOma9Yez77Ped77ltUFWOMMSbVstI9AGOMMeuTBZAxxpi0sAAyxhiTFhZAxhhj0sICyBhjTFpYABljjEmLnHQPYLWoqKjQjRs3pnsYxhizqjz99NMDqlq50HsWQHHauHEjTz31VLqHYYwxq4qItC32nl2CM8YYkxYWQMYYY9LCAsgYY0xaWAAZY4xJCwsgY4wxaWEBZIwxJi0sgJYgIleLyJ2jo6PpHooxxqwpFkBLUNUHVPU9xcXFKz5HIBDA+i4ZY8wfswBKgYGBAVpbWxkbG0v3UIwxJmNYAKXI1NQUx48f59SpU8zMzKR7OMYYk3ZWiifFhoeHGRsbo7a2lsrKSkQk3UMyxpi0sBlQGoRCITo6Ojhy5AiBQCDdwzHGmLSwAEqj8fFxjhw5QltbG6FQKN3DMcaYlLIAygADAwO0tLQwODiY7qEYY0zKWABliGAwyOnTpzl69CgTExPpHo4xxiSdBVCSqSr+qfgvr/n9fg4fPkxnZyfhcDiJIzPGmPSyAEqynx3t5613HeX+owGmQ/E9jKqq9Pb20tLSwvDwcJJHaIwx6WEBlGT1pQU0eQvZd9DH+x/u57G2CcJxVkWYmZnh1KlTHD9+nKmpqSSP1BhjUssCKMm2VXv41Os2cscrSinKzeIzT4zydz8apLkv/kAZGxujtbWV7u5uuyxnjFkzLIBSZG91Hp96TTl/eUExY9Nh/uHnw/zzL4ZoG42vKoKq0tPTw6FDh7DCqMaYtcACKIWyRHjF2QV87opK3r7Xw7HBGT746CBfeHKUwYn4FipMTU1x4sQJTp48yfT0dJJHbIwxyWOleNIgN1t4/Q43r9xUwLcP+3noxDi/7Jjgqm1u3rjTTaFr6b8XjIyMMDY2htfrxev1WkkfY8yqYzOgNPLkZvGOczbwuSsquLAun+8cCfDeH/TzgxMBguGlFyqEw2G6u7s5dOiQVdo2xqw6FkAZoMqdwwcuLOH/eXU5DcUuvvqMjw88MsDjnZNx9RGanJx8vtK2XZYzxqwWFkAZZGuZi3+8uJSPvKyUnCzh3x8f4aM/HeLIQHyhMjw8TGtrK2fOnLEGeMaYjGf3gDKMiPDCmjzO9ebys9MTHGjx89GfDnFhXR437vFQ54n9RxYOh+nq6mJwcJCGhgY2bNiQopEbY8zyWAClwEoWCGSL8OpNhVzUkM+Dx8b57tEAT3YPcOnmAq5rLKIkPzvm8bOX5UpLS6mvryc3N3elwzfGmKQQu1QTn/PPP1+feuqpFR0bCoXo7++nr69vxd1QRydD3HMowKOnxsnNFt6ww83V2wvJz1n6KmpWVhY1NTVUV1fbajljTEqJyNOqev6C71kAxSeRAJoVDocZHBykt7d3xaV1unxB7m728duuKUrzs7i+qYhXbiwgO2vpYMnPz7fLcsaYlLIAcoATATRLVRkeHubMmTMrbr1wZGCafQd9HB2coX5DDjfvKeKFNXlxzXBKSkpoaGiwy3LGmKSzAIoSkc3AR4FiVX3L/NexjnUygOYaGRnhzJkzK2rNrar8tmuKu5p99PhDNFXmcsteD1vLXEsem5WVZQ+xGmOSLlYAJX0Ztohki8gzIvJgAuf4moj0iUjLAu9dISJHReSEiHw41nlU9ZSq3rrY63QoKSlh586dbN++HY/Hs6xjRYQX1+fz6csr+LPzPHSMBfm7Hw/yH78ZoTcQjHns7EOsra2tVlvOGJMWqVgF95fAYeBPbjyISBUwoaq+Odu2quqJebt+Hfg8sG/e8dnAF4BLgU7gSRH5PpANfGLeOd6lqn2J/SrJ4/F48Hg8BAIBzpw5w8jISNzH5mQJV251c/HZBXzvaIAHjgX4bdckV2wp5C2NRXhyF/97xmxtueLiYhoaGsjLy3Pi1zHGmCUldQYkIvXA64D/WmSXi4H7RSQ/uv+7gc/O30lVHwOGFjj+AuBEdCYzDRwArlHVZlW9at4/KwofEblaRO5M1SzB7XazZcsWGhsbKSsrW9blsUJXFm/b7eHzV1Zy8dkF/OD4OO/9QT/fi6MZ3ujoqLV8MMakVLIvwX0a+BCw4Deaqt4LPAwcEJEbgXcB1y3j/HVAx5zXndFtCxKRchH5MnCeiNw+//UiY3xAVd9TXFy8jGElrqCggE2bNtHU1ERFRcWygqi8IJu/OL+Y//eycnaU5/KNgz5ue7ifny/RDG+25UNra6t1YjXGJF3SLsGJyFVAn6o+LSKXLLafqn5KRA4AXwK2qKp/OR+z0CljfNYg8OfzNs9/nVHy8vI4++yzqa2t5cyZMwwMDMQ9Qzmr2MVHX15Kc98U3zjo47NPjPLAsQA37/VwTvXil9qmp6c5deoUHo+HhoYGCgoKnPp1jDHmecmcAV0EvF5EThO5NPYqEblr/k4i8nJgN/Bd4I5lfkYn0DDndT3QvaLRZjiXy0VDQwN79uzB6/WSnR27EsJce6ry+OSry/nAhcX4p8P802PDfPyxIU6PxH4o1ufzcfjwYTo6OgiF4utXZIwx8UrJMuzoDOiDqnrVvO3nAfuJ3Cd6DrgLOKWqH1vgHBuBB1V195xtOcAx4NVAF/Ak8DZVbXX6d0jWMuyVCoVC9PX10dfXRzAYe8XbXDMh5aET43z7sJ/AjHLJxgJuaCqivDB2oOXk5FBbW0tlZWWiQzfGrCNpXYa9hELgWlU9qaph4O1A2/ydRGQ/8DiwQ0Q6ReRWAFUNAu8DHiGy0u6eZIRPJsrOzqampoY9e/ZQX1+Py7X0sz8ArmgzvM+/tpKrtxfyi/YJ3vdQP3c3+wjMLH5pLxgM0t7ezuHDh/H7l3OV1BhjFrauHkRNRKbNgOYLh8MMDAzQ29u7rJ5AfYEg+1v8PNY+iSdXuLaxiMu2FOJaorRPWVkZdXV1Vk3BGBOTVUJwQKYH0CxVZXBwkJ6enmUF0cnhGb5x0Edz3zRedzY37vHwkvrYpX1mqylUV1eTlZXuybQxJhNZADlgtQTQLFVlaGiInp6euAufqirPnJnmGwd9tI8F2Vbm4pa9HhorY89ycnNzqa+vp7S01ImhG2PWEAsgB6y2AJo1W/i0p6eHycnJuI4JqT7fDG9oMsyLavO4aY+H+g2xV+0XFRXR0NBAYWGhE0M3xqwBFkAOWK0BNNdsEMVbgXsqqDx4PMB3jwSYCimv2VTAdU1FlC7RDK+iooK6ujpycqzfoTHrnQWQA9ZCAM1abhCNToW595CfR0+O48oSrtnh5uodhRTEaIY3u0qvqqrKqm0bs45ZADlgLQXQrJGREXp6ehgfH49r/+5oM7zfdE1Rkp/FW5uKePUSzfDy8vKor6+npKTEqWEbY1YRCyAHrMUAmrXcIDo6OM2+Z30cGZyh3pPNTXs9nL9EMzwr62PM+mQB5IC1HECzRkdH6e7ujiuIVJUnuqe466CPbn+IxgoXt5zjYVtZ7BVzFRUV1NbWxv3grDFmdVtxAInIX8dx/oCq/n8rHdxqsR4CaNZyZkTBsPKj5ya4p9XP6FSYixryedvuIrxFiy9AsOeHjFk/EgmgHiJVqmPdRb5RVbcnNsTMt54CaNZygmhiJhxthjdOKKxcvrWQa3cV4clbPGByc3Opq6ujrKzMyWEbYzJIrABaap3sN1T1n5Y4uXvFIzMZraSkhJKSEkZGRuju7o65aq7AlcUNuz1cvqWQb7X6eej4OD89PcGbdrp57TY3edl/+neY6elpnnvuOfr6+qivr6eoqCiZv44xJsPYPaA4rccZ0HzLWb7dPjrDXc1+nu6ZorwgEk6vODuf7BgLFUpLS6mrq7O24MasIQkvQhCR84GXA7XABNAC/EhVF2qTvSZZAP3B8PAw3d3dcVVWmG2Gd3I4yMbiHG7e6+Fc7+IBIyJUVVXh9XrtQVZj1oBE7gG9A3g/kV49TwN9QD6wnUjDuRbg71W13eExZxwLoD+2nFpzYVV+3THJ3c1++sZDnFOdyy17PWwsWXwlnD3IaszakEgAvRf4mqoueM1FRM4FylX1x46MNINZAC1sOdW3Z0LKwyfHue9QpBnexWfnc8NuDxUxmuHZQgVjVjd7DsgBFkCxqSoDAwP09PQwMxO71bd/Osx3jwT43+MBAF63zc2bdrpx5y6+Ys7tdlNXV4fH43F03MaY5Eq4I6qIfEpENoiIS0R+LCIDInKTs8M0q5mIUFlZye7du6mvr495/6YoN4ub93r47BWVvLQhn/uPBnjvQ/08eDzATHjhvxAFAgGOHTvGiRMn4q7qbYzJbPEuQvi9qp4rIm8E3gD8FfBTVT0n2QPMFDYDWp5QKERfXx+9vb2EQqGY+54anmFftBletTubG/cU8dL6/EXv/YgI5eXlVlHBmFUg4RkQMPtf+WuB/etp9ZtZmdlFBLt378br9caseLC51MUdryjlYy8vJS9H+I/fjPLhHw/R2r/wPaXZy30tLS10dXUtGXDGmMwU7wzok0RmPhPABUAJ8KCqXpjc4WUOmwElZmZmhp6eHgYGBoj171xIlZ+3TbC/xc/QRHzN8HJycvB6vbZizpgM5MgiBBEpBcZUNRStfuBR1TMOjjOjWQA5Y2pqiu7uboaGYk+ip0LK/x4P8N3DASbjbIaXm5tLbW0t5eXlTg/bGLNCtgrOARZAzpqYmKCrq4vR0dGY+41NhbnvsJ9HToyTkyW8fkchr9/hjtkMr6CggLq6OoqLi50etjFmmSyAHGABlBx+v5+uri78fn/M/c74g9zV7OfxzklK8qLN8DbFboZXVFREXV2d1ZgzJo0sgBxgAZRc8RQ8BTg2OM2+gz4OD8xQ58nmpj0eXlQbuxlecXExdXV11gzPmDRwohacS1Vn5m2rUNUBh8aY8SyAUmNwcJDu7u6YVRWeb4bX7KPbF2JXhYtb9nrYXh67GV5ZWRm1tbVW7NSYFFrxMmwReaWIdALdIvKoiGyc8/ajzg0xNURks4h8VUTuW+i1Sb/y8nKampqoq6sjO3vhBQciwoV1+Xz6sgre84INdPtC3P6TIf798RHO+IOLnntoaIjW1lba29uXrNZgjEm+pZ4D+hRwuapWAncCPxSRF0ffi7neVUTyReQJEXlWRFpF5B9XOkgR+ZqI9IlIywLvXSEiR0XkhIh8ONZ5VPWUqt662GuTGWY7pu7Zs4fq6upFL69lZwmXbynkC1dWcF2jm9/1TPGXDw/w1WfGGJsKL3iMqtLf309LSwudnZ0Eg4sHljEmuZaqd5+rqq0AqnqfiBwGvhP9ol/q2t0U8CpV9YuIC/iliDykqr+Z3UFEqoAJVfXN2bZVVU/MO9fXgc8D++ZuFJFs4AvApUAn8KSIfB/IBj4x7xzvUtW+JcZsMkh2djb19fVUVVXR1dW16NLtAlcWb23ycNnmQr51yM/DJ8b52ekJ3rjLzesWaYYXDofp7e1lYGCAqqoqqqurF51xGWOSY6kZ0IyIeGdfRMPo1cAdwLZYB2rE7NImV/Sf+aF1MXC/iOQDiMi7gc8ucK7HgIW+fS4ATkRnMtPAAeAaVW1W1avm/bOi8BGRq0XkzqWWC5vkyc3NZdOmTezatStmMdLSgmz+/IXF/OflFTRW5nJ3s5/bHurnJ6fHCS1yrzMUCtHT00NLSwtnzpwhHF545mSMcd5SAfRhoHruBlXtBC4BPrnUyUUkW0R+T6SP0A9V9bfzznUv8DBwQERuBN4FXBf36KEO6JjzujO6bbHxlIvIl4HzROT2+a8XOkZVH1DV99gzJelXWFjI9u3b2bp1a8wVbfUbcrj9ZaX80yVllOZn84Unx/jbHw7yzJnF+xYFg0G6urpoaWmhr68vZrUGY4wzUrIMW0RKgO8Ct6nqQvdxDhCpM7dFVfsXOcdGIuV/ds/Zdi2Re1R/Fn19M3CBqt7m9O9gq+Ayy2wfou7u7pgLClSVX3dGmuH1BiLN8G7e62FTjGZ4EJl11dTUUF5ebuV9jEmAE+0YrhKRZ0RkSETGRMQnImPxDkBVR4CfAVcscO6XA7uJBNQd8Z4zqhNomPO6Huhe5jnMKiQiVFRUsHv3bmpqahYtdioiXNRQwGcur+Cd53o4OTzD3/5wkM8+MUL/+OJFTKenp2lra6O1tZXBwcFk/RrGrGvxVsP+NPB2It1PN6iqR1U3xDpARCqjMx9EpAB4DXBk3j7nAV8BrgHeCZSJyD8vY/xPAttEZJOI5ALXA99fxvFmlcvKyqK2tpbdu3fHrAHnyhau2ubmi1dWcs0ON493THLbQ/3sO+jDP734fZ+pqSlOnz5Na2srw8PDyfgVjFm34g2gDqBFl3e9rgb4qYgcJBIUP1TVB+ftUwhcq6onVTVMJOTa5p9IRPYDjwM7RKRTRG4FUNUg8D7gEeAwcM/sqj2zvrhcLjZu3LjkQgX3bDO8Kyu5qCGf70eb4T1wLMBMaPF/vScnJzl16hSHDh1iZGQkGb+CMetOvJUQXgR8HPg5keXVAKjqfyRvaJnF7gGtLiMjI3R2djI1tfjCA4DnRmb4xkEfz/ZOU+XO5sbdRby0IZ+sJe77FBYWUlNTQ0lJiZPDNmbNcaIUz6OAH2gGnr9eoaorfrh0tbEAWn1mHzrt7u5esmnd789Mse+gj7bRIFtKc7hlr4fdVUuX7CksLKS2ttYqbxuzCCcC6KnFTrBeWACtXsFgkJ6eHvr7+5dshvdY2yT7W3wMToR5YU0eN+/10BCjGd4st9tNTU2NBZEx8zgRQJ8EfqKqq67+m1MsgFa/yclJOjo6GBuLvYBzKqT84HiA7xwOMBlUXrWpgOubiigtWLpSgtvtpra2lg0bYq7RMWbdcCKAfICbyP2fGSJ14HSplXBriQXQ2jE6OkpnZyeTk5Mx95vbDC872gzvmu1uClxLr92xIDImwvoBOcACaG1Zzv2hM/4gdzf7+XXnJMV5WVzXVMRrNhWQE6MZ3qyioiJqamosiMy65cQM6I1ELsGNRl+XAJeo6vccHWkGswBam4LBIN3d3QwMDCxZfuf40DT7nvVxaGCG2mgzvAuWaIY3y4LIrFdOBNDvVfXcedueUdXzHBpjxrMAWtsmJibo6OjA5/PF3E9Veapnim8c9NHlC7Gz3MUt53jYsUQzvFl2ac6sN04E0EFV3TtvW7Oq7nFojBnPAmh9GB4eprOzM2ZHVoBQWPnxcxN8q9XPyFSYF9flceMeD7WepVfMga2aM+uHEwH0NWCESO8dBW4DSlX1HQ6OM6NZAK0fs72C4mnPMBEM88DRce4/GmAmrFy2pZBrG4sozouvyIgFkVnrnAggN/D3ROq5QaQd97+oasCxUWY4C6D1Z3p6ms7OzrhqwA1Phrin1c+PnpsgL1t44043V21zk5cTXyVtq6xg1ipbBecAC6D1y+fz0dHRwcTExJL7do4FuavZx5PdU5QVZHFDUxEXbywgO86WDhZEZq1ZcQCJyJ3A51S1eYH33MBbgSlVvdupwWYqC6D1bTnLtgEO9U+z76CP40MznLUhh5v3ejjPmxt3b6GCggJqamooLS1NdOjGpFUiAXQu8BFgD9AC9AP5RNpxbwC+BnxZVWNXfFwDLIAMRJZtd3Z2xtUjaLYZ3jeb/ZwJhNhTlcstez1sLo3dDG+u/Pz854PIGuOZ1ciJe0BFwPlEWixMAIdV9aijo8xwFkBmrkAgQHt7O+Pj40vuOxNWHj05zr2H/PimlVeclc8Nuz1UuZcu7TMrLy+PmpoaysrKLIjMqmL3gBxgAWQWMjAwQFdXF8FgcMl9AzNhvnckwIPHAijw2m1u3rTTTVFuvG25Iq3CvV4vFRUVFkRmVbAAcoAFkFnMbDWF/v7+uPYfGA+xv8XHz9smcbuENzcWceWWQlzZ8QdKbm4u1dXVVFRULNqO3JhMYAHkAAsgs5Tx8XHa29sJBOJ7OuF0tBne73unqSrM5m17irgojmZ4c7lcLqqrq6msrLQgMhkpkUUItwMPq+ozyRrcamEBZOK1nMtyAM/2Rkr7PDcSaYZ3814Pe+JohjdXTk7O80GUnR3/vSVjki2RALoeuAI4B3gWeAh4VFWXfjJvjbEAMssRCoXo6uqK+7JcWJXH2ifZ3+xjINoM76Y9RZxVHP+KOYDs7GyqqqqoqqoiJye+skDGJJMjl+BE5DwiYXQZkA38iMjs6AmnBprJLIDMSiz3stx0tBnet48EmJxRXrmpgLc2FVEeRzO8ubKysp4PIpdreSFmjJMcvwckIhuAS4HLVfU9CY5vVbAAMolY7mU5X7QZ3sMnxsnKgqu3u3nDDjeFcTTDmysrK4uKigqqq6vJzY2vYrcxTrJFCA6wADKJCgaDdHV1MTAwEPcxZ/xB9rf4+WXHJBvysriu0c2lmwvjaoY3l4hQXl6O1+slL29595eMSYQFkAMsgIxTlvMQ66wTQzPsO+ijtX+amqJIM7wL6+JrhjeXiFBaWkpNTQ35+fnLHboxy2YB5AALIOOk5daWmz3md2em2HfQT+dYkB3lLm7Z62FnxcourZWWluL1eiksLFzR8cbEI5FVcIeAu4EDqnoySeNbFSyATDLMzMzQ2dnJ0NBQ3MeEwspPT09woNXP8GSYC+vyuGkZzfDmKy4upqamBrfbvaLjjYklkQA6B7geuA4YAPYD96hqdzIGmsksgEwy+Xw+2tvbmZycjPuYyWCYB4+N892jAWZCyqWbC7mu0U1x/sqeA/J4PNTU1ODxeFZ0vDELcWoZ9ouJtF94M3AC2K+qX3FslBnOAsgkm6rS29tLT0/Pkp1Y5xqZDHHPIT8/PBVphveGHW6u3h5/M7z5rEurcZKj94BE5BLgP4FGVV03y2ksgEyqTE9P097ezujo6LKO6/IFueugjye6pyjLz+Ktu4t45TKa4c1nPYmME5xox/Ai4AYis5/TwAHgXlWNfz3pKmcBZFJtZGSEjo4Opqenl3Xc4YFp9j3r41i0Gd5Nez28YBnN8ObLz8/H6/VaKwizIoncA/pXIpfdhomEzgFV7UzKKDOcBZBJh3A4THd3N319fSznaoWq8puuKe5q9nHGH2J3ZS63nONhyzKa4c1nFbjNSiQSQHcQuddzLFmDWy0sgEw6TUxM0N7ejt/vX9ZxM2Hlh6fGubfVz9i08vKz8nnb7iKq3CuvE+dyuaiqqrLCpyYuTlyCKwT+BjhLVd8tItuAHar6oLNDzVwWQCYTLLekz6zxmTDfOxrggWMBwgpXbi3kzbuK8CyjGd58VvjUxMOJAPoW8DRwi6ruFpEC4HFVPdfZoWYuCyCTKYLBIJ2dnQwODi772MHxEAda/fz09ASFLuHNu4q4cmshuctohjdfVlYWlZWVVFdXW+FT8yecCKCnVPV8EXlGVc+LbntWVc9xeKwZywLIZJqVPDs0q2000gzvmTPTVBZm8bbdHl521vKa4c0nIs8XPrV6c2ZWrACKd/49HZ31aPSEW4Aph8ZnjFkBj8dDY2MjdXV1y14UcHaxi4+9vIw7XlFKUW4Wn3lilA/9aJCDvSv/z3q2vFBrayunT59eUTCa9WWpRQiPquplInIZ8FGgEXgUuAh4h6r+LCWjzAA2AzKZbGpqivb2dsbGxpZ9bFiVX7ZP8s0WH/3jYc7z5nLzXg9nL7MZ3kJKSkrwer1W5mcdS2QV3NxLbuXAiwEBfrOengECCyCzOgwPD9PR0cHMzMyyj50OKQ+fGOe+w37GZ5RXbizg+t3Lb4a3kA0bNuD1eq3MzzqUSACdAj642Puq+p3Eh7c6WACZ1WK57cDn802H+fZhPw+dGCdL4Kptbt64c/nN8BZiZX7Wn0QCaBC4n8isZz5V1Xc5M8TMZwFkVptAIEBbWxsTExMrOr4vEOSbLX5+0T7Jhlzh2qYiLt1ciGuZzfAWUlBQgNfrpbS01KorrHGJBNDvVPUFSRtZionIZiL3sopV9S3zX8c61gLIrEaqSl9fH93d3csqcDrXyeEZ9j3ro6V/Gm+0Gd6LV9AMbyF5eXl4vV7Ky8stiNaoRFbBrfjfCBFpEJGfishhEWkVkb9M4FxfE5E+EWlZ4L0rROSoiJwQkQ/HOo+qnlLVWxd7bcxaIyJUV1fT1NS04steW0pd/MPFpXzkZaW4soR/f3yEj/xkiCMDy6tRt5CpqSna2tpobm6mt7d3xSFpVqelZkC7VfVPvvTjOrFIDVCjqr8TEQ+RB1nfoKqH5uxTBUyoqm/Otq2qemLeuV4B+IF9qrp7zvZs4BhwKdAJPEmkaGo28Il5Q3qXqvZFj7tv7oxn/uuF2AzIrAUjIyO0t7evaJECRJvhtU1woCXSDO+C2jxu2uuhboXN8ObLycl5vrqClflZGxKZAX0yjpMvWI5HVXtU9XfRn33AYaBu3m4XA/eLSH70XO8GPrvAuR4DFmoZeQFwIjqTmSZSMPUaVW1W1avm/dO31O+yyO93tYjcudzS+MZkopKSEpqamqiqqlrR8dlZwms2FfL5Kyu4oamIg33TfOCRAe783Sgjk/G1Fo8lGAzS3d1Nc3MznZ2dKw5KszosNQMaAR6LdTzQpKqbY36IyMboeXar6ti89z4EvBS4F3gfcKmq/knFxeg5Hpw3A3oLcIWq/ln09c3Ahar6vkXGUQ78C5EZ038Bd859rarzZ03PsxmQWWsSXaQAMDoZ4p5DAX54ahzX883wCsnPcaZadlZWFuXl5VZdYRWLNQNaat58TRznj3khWESKgG8DH5gfPgCq+ikROQB8CdiyUPjEOv0C2xZNVFUdBP583ub5r41ZF9xuN7t27UpokUJxfjbvfsEGXretkLuafRxo9fPIyXGub4o2w0twxVw4HKa/v5+BgQFKS0vxer0UFBQkdE6TOWIGkKr+PJGTi4iLSDYyqmQAABdJSURBVPjcvdgzQyLycmA38F3gDiKzoHh1Ag1zXtcD3SsbrTHrz+wihdLS0hV1YZ1V68nhQy8t5cjANPsO+vjS02M8cHycm/cU8cKaxFfMqSpDQ0MMDQ1ZdYU1ZNktueM+ceTfuP8BhlT1A4vscx6wH3gd8BxwF3BKVT+2wL4b+dNLcDlEFiG8Gugisgjhbara6ugvg12CM+tDIpUUZqkqv402w+vxh2iqzOWWvR62ljlbKdvj8VBTU2PVFTJcwtWwV/ihLwN+ATQDs3P7j6jqD+bscxEwpqrN0dcuIjXmvjLvXPuBS4AKoBe4Q1W/Gn3vtcCniax8+5qq/ksyfh8LILNeJFpJYVYw2gzvnkMBxqbCXNQQaYbnLXK2d5Db7cbr9VJSUuLoeY0znGjHUDV/FZmI7FDVow6NMeNZAJn1xu/3097entAiBYg0w7v/aIDvHwsQDsMVWwt5y64iPHnOtvUuKCigurqasrIye6g1gzgRQEeBv1fVe6Kv/wa4VVUbHR1pBrMAMuuRqtLb20tPT0/CD4kOToS4p9XPT56bID/aDO+1CTbDW0hubu7z1RWW26bCOM+JAKohsmR5Eqgm8kzP3yxzxdqqZgFk1rPZigU+n2/pnZfQPjrDXc1+nu6ZoqIwixt2e3hFgs3wFuJyuaiqqqKystIeak0jR+4Bich7gduJ3M+5QVV/5dwQM58FkDEwODhIZ2cnwWAw4XM1902x71kfp0aCbCrJ4ea9Hs6pdv5Zn+zs7OerK+TkOHv/ySzNiRnQD4Ee4P1Eljp/DXhMVRdt1bDWWAAZExEMBuns7GRwcDDhc4VV+VXHJHc3R5rhnVsdaYa3scTZFXMQeah1tmV4bm6u4+c3C3MigN6gqt+b8zoHuF1VP+7cMDObBZAxf8zn89HW1sbU1MrbeM+aDikPnxzn24f8BGaUSzYWcENTEeWFzl86ExHKysrwer3k5+c7fn7zx9KyDHutsQAy5k+Fw2F6enro7e3Fie8Sf7QZ3g9OjJMFvG57pBme24FmeAuZra5QWFiYlPMbZ2ZAPv5Q4iYXcAF+VV03bQ0tgIxZ3MTEBG1tbQQCAUfO1xcIsr/Fz2Ptk3hyhWsbi7hsizPN8BZiLcOTx/EZkIi8AbhAVT+S6OBWCwsgY5Y2W1cuFEq8MjbAqeEZ9h300dw3jdedzdv2FPHS+vykPedjLcOdl5RLcCLyG1V9cUIjW0UsgIyJz/T0dEJ15eZTVX7fO82+Z320jwXZVubilr0eGiuTt5DAWoY7x4lLcG+a8zILOB+4WFVf4swQM58FkDHL40RdublCqvz89AT7W/0MTYR5UW0eN+3xUL8heUur8/LyqK6upqKiwoJohZwIoP+e8zIInAa+stImb6uRBZAxy+dUXbm5poLKg8cDfPdIgKmQ8ppNBVzXVERpfvIeNnW5XM8HkT3Uujy2Cs4BFkDGrJzf76etrY3JyUnHzjk6Fea+Q5H+Q64s4ZqdkWZ4BQ41w1uIPdS6fCsOIBH5HLEbvL0/8eGtDhZAxiRGVenp6eHMmTOOLNme1e0L8s0WH493TlGSn8Vbm4p4tQPN8GKxh1rjl0gAvT3WiVX1fxIc26phAWSMMyYnJ2lra8Pvd7aU5LHBaf7nWR9HBmeo82Rz814P5zvQDC8We6h1aYkEUI6qJl70aQ2wADLGWf39/XR1dTm2ZBsis6wnuqe466CPbn+IxgoXt5zjYVtZ8mcp9lDrwhIJoN+p6guiP39OVW9L0hgzngWQMc6bmZmhvb2dkZERR88bDCs/em6Ce1r9jE6FeWl9Pjfucb4Z3kLsodY/FiuAlvrTmDt3vci5IRljTGR12ZYtWxgZGaG9vd2xJds5WcIVWwq5+Kx87j8W4PtHx3mia5LLtxZybRKa4c01NjbG2NiYdWqNw1IBZEvkjDFJV1JSgsfjcXzJdoEri+ubPFy2uZBvtfp56Pg4Pz09wZt2unntNjd5DjfDmysQCHDy5El7qDWGpS7BjQMniMyEtkR/JvpaVXVv0keYIewSnDGpkYwl27PmNsMrL4g2wzs7n+wUBMN6fag1kXtAZ8c6saq2JTi2VcMCyJjUSdaS7VnNfVN846CPk8NBNhZHmuGd63W+Gd5C1lunVnsQ1QEWQMakntNVtueabYb3zRY/fYEQ51TnckuSmuEtZL081GoB5AALIGPSx+kq23PNhJRHTo5z72E/gWnl4rPzuWG3h4okNMNbyFp/qNUCyAEWQMakl9NVtucLTIf5zpEA/3s8Mtt63TY3b9rpxp2bvBVzc63Vh1oTCiAR2auqB0Vkj6o2J2WEq4AFkDGZwekq2/P1j4fY3+LjsbZJ3LnCtbuKuHxLIa4krpibr6SkhJqamjXxUGusAIon2t8lItuAW50dljHGLF9paSmNjY2Ul5cn5fyVhdm8/4ISPvWacjaXuPjvZ328/5EBftUxkZQFEQsZGRnh8OHDHD9+HJ/Pl5LPTIelVsHdAZQDNwJ3AwOq+k8pGltGsRmQMZnH5/PR1tbG1NRU0j7jmTORFXNto0G2lkZK+zQlsRneQlbzQ62JXoJ7PXAF8LCqfj8J41sVLICMyUzhcJju7m76+vqSNkMJqfJY2yT7W3wMToQ5vyaPm/cmtxneQgoKCqiurqasrGzVPEuU6CW4C1X1L4AXOTssY4xJXFZWFvX19ezcuTNp90yyRXjlxgI+d2UlN+4p4lD/NH/1yABffnqU4QnnV+YtZmJigtOnT9PS0kJ/fz/hcDhln50MtgouTjYDMibzqSq9vb309PQk9ct5bCrMvdFmeDlZwut3FHLNdjcFrtSsmJu1Gh5qtWXYDrAAMmb1mJqaoq2tLek38Hv8Qe5u9vN45yQleVlc11TEazYltxneQrKzs6msrKS6ujrjHmq1AHKABZAxq8/AwACdnZ1JeYB1rmOD0+w76OPwwAy1nmxu3uPhRbXJbYa3kEx8qNUCyAEWQMasTjMzM3R0dDA8PJzUz1FVnuqJrJjr8oXYVeHilr0etpenPggy6aHWRIqRZgN/BtQTWQX3qznvfUxV/9npwWYqCyBjVjenew4tJhRWfvzcBN9q9TMyFeYl0WZ4NSlohreQkpISvF4vbrc7LZ+fSAD9F1AIPAHcDPxcVf86+t7z3VLXAwsgY1a/UChEZ2cnAwMDSf+siZnw883wgmHl8i2FvKWxiOIkNsOLxePxUFNTk/JOrYkE0MHZnj8ikgN8EagAbgB+o6rnJWG8GckCyJi1IxUPsM4angjxrUN+fnxqgvwc4Y073bxum5u8nPQ8x5Pqh1oTCaAjqrpz3rb/C1wOVKnqNkdHmsEsgIxZW8LhMD09PfT29qakxE7nWJC7mn082T1FWUEWNzQVcfHGgpQ0w1tIfn4+Xq836Q+1JhJAdwF3qerD87b/GfAlVU1N44wMYAFkzNo0Pj5OW1sb4+PjKfm81v5pvnHQx/GhGc4qzuGWvR7Orc5NW2WD3NxcvF4v5eXlZGU5f3nQVsE5wALImLUrVQ+wzv28X3dOcnezn95AiL1Vudy818Pm0vT9nT4nJ4fq6mrHH2pdcSkeEfnQnJ+vnffevzozPGOMSS8Rwev10tjYmJKb9CLCRQ0FfObyCt55jodTIzN86EeDfPaJEfrHU1faZ65gMEhXVxfNzc309fWl5DOXmm9dP+fn2+e9d4XDYzHGmLTKy8tj+/btnH322SkpbePKFq7a7uaLV1ZyzQ43v+6Y5LaH+vnGQR+B6fTUeQuFQklr+jffUgEki/y80GtjjFkTKioqaGpqStlKMXduFjfv9fD5Kyu5qCGf+48G+IuH+nngWICZ0Nq9TbJUAOkiPy/02hhj1gyXy8WWLVvYvHkzLldq7s1UFGZz2wUl/Pul5WwpdfH1aDO8X7ZPEF6D9+uXWgUXAgJEZjsFwOwyEQHybRWcMWY9CAaDdHZ2Mjg4mNLPfbZ3in3P+jg9GmRLaWTF3O6qvKR/7oYNG9i2zZmnbFa8CEFVs1V1g6p6VDUn+vPs63UTPsaY9S0nJ4eNGzeybds28vKSHwCzzqnO41OXlvO+FxUzOhnmjp8P86+/HKZ9NLnlhFIlPTUhjDFmFdqwYQONjY1UVVWl7DNnm+F99spKbtpTxOH+af7m0UG+9NQoQylshpcMmdU4whhjMlxWVhYNDQ2UlZXR1tbGxMRESj43L1t4484iXr2pkPsO+3nkxDi/aJ/k6u2FvGFH6pvhOWH1jdgYYzKA2+1m165d1NbWprSKwYa8LN517gY+c0UF59fmcd/hAO99aICHT0aKnq4mFkDGGLNCIkJNTQ27du1KebsDb1EOf/3iEj756jLqPNl85Xdj/NWjA/y2azIlte2cYAFkjDEJKigoYOfOnTQ0NCSlnlos28py+adLyrj9ohKygE/9eoSP/XSIo4PTKR3HStg9IGOMcUhVVRUlJSW0tbUxNjaWss8VEc6vzec8bx4/OT3BgVY/H/nJEC+uy+PGPR5qPZn5VZ+ZozLGmFUqNzeXbdu2MTg4SEdHB6FQ6laqZWcJl24u5GVn5fPA0XHuPxrgye4BLttSyLVpbIa3GAsgY4xJgvLycjZs2EBHRwfDw8Mp/eyCnCyuayri0i0F3HvIzyMnx/nZ6QneuNPNVWlshjdfZsWhMcasIS6Xi82bN6e0nM9cpfnZvOcFxfznZRXsrsrlmy1+3vdQPz9+bpxQBixUsAAyxpgkKy0tpampifLy8rR8fv2GHD58USkfv6SM8sJsvvjUGB98dJDf9UyldcWcBZAxxqRAdnb28+V8cnNz0zKGxspcPvGqMj74khKmQ8q//HKYf3xsmFPD6SntYwFkjDEptGHDBpqamlJazmcuEeEl9fl8+ooKbj3XQ9vIDH/7o0E+89sR+gLBlI7FFiEYY0yKzS3nc/r0aSYnJ1M+BleW8Nptbi7eWMD3jgR48FiAX3dO8tqthbzjgtQ8VGszIGOMSRO3201jYyM1NTUpLefzR2NwZXHjnkgzvJefVcADx8Z5+z3P8ZXHTjEVTO4S8pj9gMwfWD8gY0wyTUxMcPr0acbHx5feOYlOj8yw/9AET3WNU19awN9evoOr99aSlbWygFxxPyBjjDGpMVvOp76+PuXlfObaWOLiE1fUc9etF7Ih38VfHvg9//KDw0n5LLsHZIwxGUJEqK6upqSkhNOnT+P3+9M2lpdtq+DB217G/c92sbu2OCmfYQFkjDEZJi8vjx07dtDf309XV1dKy/nMlZUlvPG8+uSdP2lnNsYYk5DKykoaGxspLk7ODCTdLICMMSaD5ebmsnXrVjZt2kROztq6aGUBZIwxq0BZWRlNTU2UlpameyiOsQAyxphVIicnh82bN7Nly5a0FDd12tqazxljzDpQUlKCx+Ohs7OTgYGBdA9nxWwGZIwxq1B2djZnn30227dvJy8vL93DWRELIGOMWcU8Hg+NjY1pK26aCAsgY4xZ5WaLm+7cuZP8/Px0DyduFkDGGLNGzBY39Xq9aStuuhwWQMYYs4aICHV1dezcuZPCwsJ0DycmCyBjjFmDCgsL2blzJ3V1dRk7G1oXASQim0XkqyJyX6xtxhizlogIXq+XxsZGioqK0j2cP5HxASQiXxORPhFpmbf9ChE5KiInROTDsc6hqqdU9dalthljzFqUn5/Pjh07aGhoSGurh/lWw4OoXwc+D+yb3SAi2cAXgEuBTuBJEfk+kA18Yt7x71LVvtQM1RhjMldVVRXFxcW0tbXh8/nSPZzMDyBVfUxENs7bfAFwQlVPAYjIAeAaVf0EcFVqR2iMMatHXl4e27dvZ2BggM7OzrS1eoBVcAluEXVAx5zXndFtCxKRchH5MnCeiNy+2LYFjnuPiDwlIk/19/c7OHxjjEmviooKmpqa0trqIeNnQItYaEmHLrazqg4Cf77UtgWOuxO4E+D8889f9PzGGLMauVwutm7dytDQEB0dHQSDwZR+/mqdAXUCDXNe1wPdaRqLMcasaulq9bBaA+hJYJuIbBKRXOB64PtpHpMxxqxa6Wj1kPEBJCL7gceBHSLSKSK3qmoQeB/wCHAYuEdVW9M5TmOMWQtKSkrYuHFjSj4r4+8BqeoNi2z/AfCDFA/HGGOMQzJ+BmSMMWZtsgAyxhiTFhZAxhhj0sICyBhjTFpYABljjEkLCyBjjDFpYQG0BBG5WkTuHB0dTfdQjDFmTbEAWoKqPqCq70lnwT5jjFmLRNVqbMZDRPqBEWAlU6EKYMDZEZkYilnZn1Omy9TfKx3jSvZnJuP8Tpwz0XOs9PhEvsPOVtXKhd6wAFoGEblTVd+zguOeUtXzkzEm86dW+ueU6TL190rHuJL9mck4vxPnTPQcmfYdZpfglueBdA/AxGWt/jll6u+VjnEl+zOTcX4nzpnoOTLq3yGbAaWAzYCMMauZzYBWtzvTPQBjjElAUr7DbAZkjDEmLWwGZIwxJi0sgIwxxqSFBZAxxpi0sABKAxFxi8j/iMhXROTGdI/HGGPiJSKbReSrInJfoueyAHKIiHxNRPpEpGXe9itE5KiInBCRD0c3vwm4T1XfDbw+5YM1xpg5lvP9paqnVPVWJz7XAsg5XweumLtBRLKBLwBXAo3ADSLSCNQDHdHdQikcozHGLOTrxP/95RgLIIeo6mPA0LzNFwAnon9jmAYOANcAnURCCOzPwBiTZsv8/nKMffklVx1/mOlAJHjqgO8AbxaRL5FhpTGMMSZqwe8vESkXkS8D54nI7Yl8QE4iB5slyQLbVFUDwDtTPRhjjFmGxb6/BoE/d+IDbAaUXJ1Aw5zX9UB3msZijDHLkfTvLwug5HoS2CYim0QkF7ge+H6ax2SMMfFI+veXBZBDRGQ/8DiwQ0Q6ReRWVQ0C7wMeAQ4D96hqazrHaYwx86Xr+8uKkRpjjEkLmwEZY4xJCwsgY4wxaWEBZIwxJi0sgIwxxqSFBZAxxpi0sAAyxhiTFhZAxjhEREIi8vs5/3x46aOSb864akXkt9Gf20Wkf85YN8475hIReXzethwR6RWRGhH5NxE5IyIfTOXvYtYWqwVnjHMmVPVcJ08oIjnRBwITMXdcF0bP+w7gfFV93yLHPAbUi8hGVT0d3fYaoEVVe4C/FZFAguMy65zNgIxJMhE5LSL/KCK/E5FmEdkZ3e6ONgJ7UkSeEZFrotvfISL3isgDwKMiUigi94jIQRH5VnQWc76I3Coi/znnc94tIv+xgvFtEZGHReRpEfmFiOxU1TBwL/DWObteD+xP6P8MY+awADLGOQXzLsHN/fIeUNUXAF8CZi9bfRT4iaq+CHgl8G8i4o6+9xLg7ar6KuAvgGFV3Qt8HHhhdJ8DwOtFxBV9/U7gv1cw7juB21T1hdGxfTG6fT+R0EFE8oDXAt9ewfmNWZBdgjPGObEuwX0n+r9PE2nJDnAZkQCZDaR84Kzozz9U1dkGYS8DPgOgqi0icjD6c0BEfgJcJSKHAZeqNi9nwCJSBLwUuFfk+er7edHzPykiRSKyA9gF/EZVh5dzfmNisQAyJjWmov8b4g//3QnwZlU9OndHEbkQmHt/ZaG+LLP+C/gIcISVzX6ygJEYwXmAyCxoF3b5zTjMLsEZkz6PALdJdOohIuctst8vgeui+zQCe2bfUNXfEunZ8jZWEBCqOgY8JyLXRs8vInLOnF32AzcBr8JaiRiHWQAZ45z594A+ucT+HwdcwEERaYm+XsgXgcropbe/Aw4Co3Pevwf4VQKXx24EbhWRZ4FW4JrZN1T1EDBO5F6VrXozjrJ2DMZkOBHJJnJ/Z1JEtgA/Brar6nT0/QeB/1TVHy9yvF9Vi5Iwrn8A/Kr6706f26wPNgMyJvMVAr+MzlC+C/wfVZ0WkRIROUZk8cOC4RM1NvsgqlMDEpF/I3JpzmZFZsVsBmSMMSYtbAZkjDEmLSyAjDHGpIUFkDHGmLSwADLGGJMWFkDGGGPSwgLIGGNMWvz/Inp7II3B+WQAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "energy_range = [1, 10] * u.TeV\n", "spec.plot(energy_range=energy_range, energy_power=2)\n", "ax = spec.plot_error(energy_range=energy_range, energy_power=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Computing flux points\n", "\n", "We can now compute some flux points using the `~gammapy.estimators.FluxPointsEstimator`. \n", "\n", "Besides the list of datasets to use, we must provide it the energy intervals on which to compute flux points as well as the model component name. " ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "energy_edges = [1, 2, 4, 10] * u.TeV\n", "fpe = FluxPointsEstimator(energy_edges=energy_edges, source=\"crab\")" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 1.79 s, sys: 105 ms, total: 1.9 s\n", "Wall time: 1.91 s\n" ] } ], "source": [ "%%time\n", "flux_points = fpe.run(datasets=[stacked])" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAEKCAYAAABUsYHRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXRkZ3nn8e+jfWm1dqm0dat3tWQTHByCQwjLZDEBwyRhDWFYHAhJyDAkcyaQZAIkZBkyJJkkBDDBAbJglsDBZnM4LPGEcRxsAkjqdtOLu6XSVtpbrVZLLemZP6qqXZa1lKSqulWl3+ccHfW9de97n+pW16P33vd9XnN3REREMq0g6ABERGRvUgISEZFAKAGJiEgglIBERCQQSkAiIhIIJSAREQlEUdAB5IqGhgbv7OwMOgwRkZzyyCOPTLh743qvKQElqbOzk4cffjjoMEREcoqZXdroNd2CExGRQCgBiYhIIJSAREQkEEpAIiISCCUgEREJhBKQiIgEQgloC2Z2h5ndNTs7G3QoIiJ5RQloC+5+n7u/sbq6esdtzM/Po3WXRESeSAkoAyYmJujv7+fy5ctBhyIikjWUgDJkcXGRs2fPcuHCBa5fvx50OCIigVMpngybnp7m8uXLtLa20tjYiJkFHZKISCDUAwrAysoKg4ODPProo8zPzwcdjohIIJSAAnT16lUeffRRLl26xMrKStDhiIhklBJQFpiYmKCvr4/JycmgQxERyRgloCyxvLzMxYsXOXPmDAsLC0GHIyKSdkpAWebKlSucPn2acDjM6upq0OGIiKSNElAWcnfGxsbo6+tjeno66HBERNJCCSiLXb9+nQsXLnD27FkWFxeDDkdEJKWUgHLA5cuX6e/vZ3h4WLflRCRvKAHlCHdnZGSEU6dOocKoIpIPlIByzOLiIufOneP8+fMsLS0FHY6IyI6pFE+OmpmZ4fLly4RCIUKhkEr6iEjOUQ8oh62urjI8PMypU6dUaVtEco4SUB64du3ajUrbui0nIrlCt+DyyPT0NLOzs7S0tNDc3KzbciKS1dQDyjOrq6sMDQ3ptpyIZD0loAwIoiei23Iiku10Cy4D2traKCkpIRKJZHw1VN2WE5FspQSUAYWFhYRCIZqampicnGRsbCyjpXXit+UmJyfp6Ohg//79Gbu2iMhGlIAyqKCggMbGRhoaGpienmZ0dDSjSy/Eb8vV1NTQ0dFBSUlJxq4tIrLWnkpAZnYY+G2g2t1fsnY7g3FQV1dHXV0dMzMzjI6OZnRpbk1iFZFskPZBCGZWaGb/YWaf30Ubd5tZxMz61nntdjM7Y2bnzOxtm7Xj7hfc/c6NtoNQU1NDV1cXx48fp6qqKmPXjU9i7e/vV205EQlEJnpAbwFOA0968GBmTcCCu88l7Dvq7ufWHPoR4K+Aj605vxB4H/ATQBj4lpndCxQCf7Smjde7e2R3byV9qqqqqKqqYn5+ntHRUWZmZjJy3Xhtuerqajo6OigtLc3IdUVE0toDMrN24AXA32xwyLOBz5lZWez4NwB/sfYgd38AmFrn/KcD52I9mSXgHuDF7t7r7i9c87Wj5GNmd5jZXZnqJVRWVnLkyBG6u7upq6vL2O2x2dlZLfkgIhmV7ltwfw78D2DdTzR3/xTwZeAeM3sV8HrgZdtovw0YTNgOx/aty8zqzewDwC1m9va12xvEeJ+7v7G6unobYe1eeXk5hw4doqenh4aGhowkoviSD/39/VqJVUTSLm234MzshUDE3R8xs+dsdJy7v8fM7gHeDxxx9yvbucx6TW5yrUngTWt2r93OKqWlpRw8eJDW1lZGR0eZmJhISQ/ld78xCcDvPaf+Sa8tLS1x4cIFqqqq6OjooLy8fNfXExFZK509oGcCLzKzi0RvjT3PzP5+7UFm9izgJuCzwDu2eY0w0JGw3Q4M7yjaLFdcXExHRwc333wzoVCIwsLCtF9zbm6O06dPMzg4yMrKStqvJyJ7S9oSkLu/3d3b3b0TeAXwNXf/hcRjzOwW4EPAi4HXAXVm9u5tXOZbwDEzO2RmJbHr3JuSN5ClioqKaGtr4+abb6a1tZWiovSOI3F3IpEIfX19jI+Pp/VaIrK3BF0LrgJ4qbufd/dV4DXApbUHmdnHgQeBE2YWNrM7Adx9GXgzcD/RkXafdPf+jEUfoMLCQlpaWrj55ptpb2+nuLg4rddbXl5mYGCA06dPc+XKdu6SioisLyMTUd39G8A31tn/zTXb14n2iNYe98pN2v4i8MVdB5mjCgoKaG5uprGxkYmJCcbGxtJafPTq1aucOXOGurq6GzXuRER2Yk9VQshnBQUFNDU10djYyOTkJCMjI1smosj8zp/rTE1NMTMzQygUorm5mYKCoDvTIpJrlIDyjJnR0NBAfX09U1NTjIyMbFj4dPzq7kbTxaspTExM0N7eTm1t7a7aE5G9RQkoA17+wQcDvf7y8jJLS4tPGL792Mwy8Phw7N0bobCwkNLSsl33hj7xS7elKCYRyWZKQHtAUVERRUVFLC8vMzg1/4Rbb/3j0fWJGisKaKrc3dDulZUVrl6dp7i4mJKSUhU5FZFNKQFlQLb9Rj89Pc1/+ci36R27xj+9NJSWa8RH6TU1NSkRici69OR4D6qtraWiogLgxvdUW1lZIRwO09/fn7HCqiKSW5SA9rC2mjJOnjzJkSNH0paIFhcXOX/+PN///vczuvieiGQ/3YLbw9pro0mnpqaGmpoaZmdnGR4e5urVqym/1tzcHKdOnaKhoYHW1ta0T5wVkeynBCQ3VFdXU11dzczMDCMjI2lJRBMTE0xNTWn+kIgoAcmTxXtE6UpEifOH2traqKurS2n76RIfTp9tg0pEcpUSkGwoMRENDw+n/BnO0tISjz32GJFIhPb2dvbt25fS9kUkuykByZbiiWh6epqRkZGUJ6L5+XnOnDlDbW0tbW1tWhZcZI9QAtqjdnIbqba2ltraWqanpxkeHubatWspjWl6epqZmRmampoIhUJpX2pCRIKl/+GybbW1tdTU1GxZa24n3J2xsTEmJiY0kVUkzykByY6YGfX19dTV1SVdfXs74hNZI5FITg1UEJHkKQHJriRW356YmGBkZITr16+nrP3EgQptbW1UVVWlrG0RCZYSkKSEmdHY2Eh9fT3j4+OMjo6yvLycsvbn5+f5/ve/T3V1Ne3t7ZSVlaWsbREJhhKQpFR8hdaGhgYikQhjY2OsrOx84bu1ZmdnuXz5MvX19YFUVAhPp35yrshetWUCMrN24BXAs4BWYAHoA74AfMndd7eqmeSleDXsxsZGxsbGiEQiT1iPaDfc/UZFhfiIucLC3S0lkayhmdSO/BPZy8zdN37R7G+BNuDzwMNABCgDjgPPBZ4GvM3dH0h/qMG69dZb/eGHHw46jJx1/fp1RkZGmJiYYLOfOdj+InlmRklJCcXFJbsJcUunRi4zd22ZHz6UfQMiVJ1BspWZPeLut6732lY9oPe6e986+/uAz5hZCXBgtwFK/isuLubAgQM0NzczPDzM1NRUytp2dxYXF1lauk5paQlFRam9LReevvqEns9Dj0Vjb6spu1HQVUS2b9MekDxOPaDUWlhYYGhoiNnZ2ZS3XV5eTltbG9XV1Slt9+UffJCHHpvi4h+/IKXtiuSz3fSAMLPbgF8g+gyohSc+A/p7d0/9J4jkvfLyco4ePcqVK1cYGhriypUrKWt7YWGBc+fOsW/fPtra2lRjTiRLbVoL38y+BPwicD9wO9EE1A38DtFnQZ8zsxelO0jJX/v27ePEiRMcOXKE8vLylLZ95coVzpw5w7lz51JWv66tRsO/RVJlqx7Qq919Ys2+K8C3Y1/vNbOGtEQme0q84Onk5CTDw8MpraowOzvL7OwsdXV1tLa27qrYqZ75iKTOpj2gePIxs0ozK4j9+biZvcjMihOPyQVmdtjMPmxmn15vW4JXX19PT08PbW1tKR9aPTU1RX9/PwMDAymt1iAiO5PscpQPAGVm1gZ8FXgd8JHNTjCzMjP7dzP7rpn1m9m7dhqkmd1tZhEze9KIPDO73czOmNk5M3vbZu24+wV3v3OjbckOBQUFhEIhbr75Zpqbm1NajNTdGR8fp6+vj3A4nNJqDSKyPckmIHP3q8DPAn/p7j9D9FnQZhaB57n7DwBPBW43s2c8oVGzJjOrWrPv6DptfYToM6gnBmVWCLwPeH4snleaWbeZ3Wxmn1/z1ZTcW5VsUVhYSHt7OzfddFPKi5Gurq4yNjZGX18fw8PDKa3WICLJSToBxUbDvYro6DfY4vmRR8WHNhXHvtaO+X420YEMZbGLvAH4i3XaegBYb+LI04FzsZ7MEnAP8GJ373X3F675iiT3Vp/IzO4ws7vSMVxYklNSUsKhQ4c4efJkyouRrqysMDIyQl9fH6Ojoymr1iAiW0s2Ab0FeDvwWXfvN7PDwNe3OsnMCs3sO0QrKHzF3R9KfN3dPwV8GbjHzF4FvB542TbibwMGE7bDsX0bxVNvZh8AbjGzt6/dXu8cd7/P3d+Y6jklsn0VFRUcP36co0ePpnzE3PLyMkNDQ/T19RGJRLas1iAiu5eRiahmVgN8Fvi19SormNk9wE8DR9x9fIM2OoHPu/tNCfteCvyUu/9ibPvVwNPd/ddS/R40ETW7uPuNEXPpGFBQUlJCS0sL9fX1WhBPZBc2m4iabA9oV9x9BvgG6z/HeRZwE9EE9Y5tNh0GOhK224HhnUUpuSS+DtFNN91ES0sLBQWp/VFeWlri0qVL9Pf3Mzm5vdp0IpKctCUgM2uM9Xwws3Lgx4FH1xxzC/Ah4MVER9bVmdm7t3GZbwHHzOxQrC7dK4B7UxG/5IaCggJaW1u56aabqK+vT3n7i4uLXLx4kf7+fqanp1Pevshels4eUAvwdTP7HtFE8RV3//yaYyqAl7r7+diyDq8BLq1tyMw+DjwInDCzsJndCeDuy8CbiVZqOA180t370/aOJGsVFxfT2dmZloEKANeuXePChQucOnWKmZmZlLcvshdt+QzIzH6K6K2tr7r7xYT9r3f3u9MbXvbQM6DcMjMzQzgcZnFxMS3tV1RU0NLSQk1NTVraF8kXO34GZGZ/CPw2cDPwVTNLfLj/5tSFKJJaNTU19PT00NHRkZbF6q5evcr58+c5ffp0Wip6i+wFW9WCuwO4xd2XzeydwD+a2WF3fyugoUGS1cyMpqYm6urqGBkZYXx8POXDq69evcq5c+eorKykpaUl5UtAiOSzrZ4BFcWes8RHst0B7DezTwHpXX5SJEWKioro6Oigu7ub/fv3p+Ua8/PznDt3jkcffZTLly+n5Roi+WarBHTezJ4d33D3lVjttDPAybRGJpJiZWVlHDt2jKNHj1JWlp5lFebn5zl79qwSkUgSNh2EEBs+jbs/aTEVM2tz96E0xpZVNAghv8SLkqa7Dty+fftoaWlJW89LJNvteEXUxMRjZk8BOtec85lUBCiSaYnPh4aHh5mYmEhL+Z0rV65w9uxZJSKRdWy5JDdEl0MAngL0A/FqjY4SkOS4oqIiDhw4QGNjI4ODg8zNzaXlOvFEVFlZSWtrqxKRCEkmIOAZ7r7V8gsiOau8vJzjx48zPT1NOBxO6YqsieLPiDRqTiT5SggPmpkSkOS92tpaenp6aG1tTXl9uUSJo+Y0j0j2qmR7QB8lmoRGiS40Z0SX/HlK2iITCUhBQcGNStjhcDitNeDiiUiVFWQvSjYB3Q28Gujl8WdAInmtpKSEw4cPMzc3x+DgIAsLTxoMmjLxygpKRLKXJJuABtxdVaZlT6qqquLkyZMZGbYdT0Tl5eW0tLRQW1ubtmuJBC3ZBPSomf0jcB/RW3AAuLtGwcmekDhsOxwOp32NoIWFBS5cuEBZWdmNRKSF8STfJJuAyokmnp9M2Kdh2LLnFBUV0dnZSWNjIwMDA1y9ejWt17t27RqPPfYYw8PDtLS0UFdXp0QkeSMjS3LnA1VCkPVMTEwwNDTE8vJyRq5XUlJCKBSioaFBiUhywq6X5Dazj8ZXN41t18Ymp4rsaQ0NDfT09NDY2JiR6y0tLTEwMEBfXx+RSITVVY0JktyV7ESHp8SqYQPg7tPALekJSSS3xKspnDx5ksrKyoxcc2lpicHBQfr6+hgbG1MikpyUbAIqMLMbw3HMrI7knx+J7AkVFRV0dXVx8OBBiooy89/j+vXrhMNhent7GR0dTesIPZFUS/Z/yXuB/2dmnyY6+OBlwB+kLSqRHNbQ0EBtbS1DQ0OMj49n5JrLy8sMDQ0xOjpKU1MTTU1NGUuCIjuV1E+ou3/MzB4Gnke0CsLPuvuptEYmksMKCws5cOAADQ0NDAwMMD8/n5HrrqysMDIywtjY2I1EVFxcnJFri2zXpgnIzPa5+xWAWMJ5UtJJPEZEnih+Wy7To+VWV1cZHR0lEonQ0NBAc3MzJSVaxFiyy1bPgD5nZu81sx8zsxtPV83ssJndaWb3A7enN0SR3BcfLdfQ0JDR666urhKJROjr6+PSpUssLi5ufZJIhmy1IN1/MrOfBn4JeGZs8MF1oktyfwF4jbuPpj9MkdxXVFTEwYMHb9yWS/ck1kTuzsTEBJOTk9TW1tLS0pK2ZclFkrXlMyB3/yLwxQzEIrInVFZW0tXVlZHacmu5O1NTU0xNTVFbW0soFKKioiJj1xdJpGEyIgGI15arra0lHA4zNTWV8Rimp6eZnp6murqalpaWjM1hEolTAhIJUHFxMYcOHbpxW+7atWsZj2F2dpbZ2VmqqqpoaWmhqqoq4zHI3qQEJJIFqqqq6O7uZmxsjJGRkUAqG8zNzTE3N6flwiVjthqG/TDwTeBLwDfcPfO/nonsEWZGKBSirq6OgYGBwJbqjq/SqjWJJN22Gob9DOCzwHOAfzGzL5rZW8zseNojE9mjSkpKOHr0KEeOHAl07k58TaL+/n4mJydR5XxJtW0tx2BmLcDzic79OQr8m7v/SppiyypajkGCsLq6yvDwMJFIJPAEUFJSQnNzMw0NDRQUJFtGUva6zZZj2PF6QGZWANzm7t/cTXC5QglIgrSwsMDAwABXrgRfdKS4uJimpiYaGxspLCwMOhzJcrteD2g97r66V5KPSNDKy8s5ceJERittb+T69esMDQ3R29vL8PBwxsoLSf7RKDiRHNLQ0EBNTQ3hcJjJyclAY0ksfNrY2Ehzc7MKn8q2bNoDMrN1u00iEpyioiI6Ozs5fvx4VpTTWV1dZWxsjN7eXgYGBlRvTpK21S24D5nZWTP7PTPrzkhEIpKU+Nyhtra2rBgU4O6Mj4/T39/PxYsXA5lUK7ll059ad78FeCGwAnzazL5jZr9pZgczEp2IbCo+d6i7u5v9+/cHHQ4QTUSTk5P09/dz/vz5jK2FJLlny1+b3P2Mu7/L3buB1wA1wNfMTAMQRLJEaWkpx44d4/Dhw1n1HGZmZoZHH32Us2fPMjc3F3Q4kmWSHoQQG3bdBDQDlUBm1hoWkaTV1tayf//+jC4HnozLly9z+fJllfmRJ9gyAZnZs4BXAv8Z6APuAd7q7sHUCRGRTcWXA6+vr+fSpUssLCwEHdINiWV+QqEQtbW1mFnQYUlAthoFNwj8MXAauMXdf9Ld787V5BNbyfXDZvbp9bZF8kllZSUnT56kvb09KwYpJFpYWOCxxx6jv7+fiYmJwKs8SDC2+qn8UXd/prv/pbuPJS7LvRUz6zCzr5vZaTPrN7O37DRIM7vbzCJm1rfOa7eb2RkzO2dmb9usHXe/4O53brQtkm/MjObmZnp6erLyttfi4iKXLl2it7eXsbGxQKqAS3C2GgV3CcDMbjOzU0R7QpjZD5jZX2/R9jLwG+5+kmhR019dO5TbzJrMrGrNvqPrtPURovXnnsDMCoH3Ea1P1w280sy6zexmM/v8mq+mLeIVyVuJBU6zaZBC3PXr1wmHw/T29jIyMpLRVWIlOMn2y/8c+ClgEsDdvwv82GYnuPuIu3879uc5osmrbc1hzwY+Z2ZlAGb2BuAv1mnrAWC9JSOfDpyL9WSWiD6ferG797r7C9d8RZJ8r09gZneY2V1BlcYXSaWamhp6enpoasrO38eWl5cZHh6mt7eXcDjM9evXgw5J0ijpG8PuPrhmV9K/ophZJ3AL8NCaNj8FfBm4x8xeBbweeFmy7RJNaIlxhXlykkuMo97MPgDcYmZvX7u93jnufp+7vzEbb1+I7ERhYSEdHR10dXVRXl4edDjrWllZYWxsjL6+PlVXyGNbLUj3DHf/N2DQzH4EcDMrAf4rsdtxWzGzfcA/Af/N3S+vfd3d32Nm9wDvB464+3bK/a43fGbDp5nuPgm8ac3utdsie0J8kEIkEmF4eDgrn7+srq4yPj7OxMQEtbW1hEKhrE2asn1b9YDiz3neBPwq0d5FGHhqbHtTZlZMNPn8g7t/ZoNjngXcRHThu3ckF/YNYaAjYbsdGN5mGyJ7VrYPUohzd6ampjh16pSqK+SRpCaiuvsE8KrtNGzRwf0fBk67+59ucMwtwIeAFwCPAX9vZu92999J8jLfAo6Z2SFgCHgF8PPbiVNEHh+kMD09zeDgYFY/e5mZmWFmZoaqqipaWlqoqqra+iTJSlsloMNmdu9GL7r7izY595nAq4FeM/tObN9vufsXE46pAF7q7ucBzOw1wGvXNmRmHye6LHiDmYWBd7j7h9192czeDNwPFAJ3u3v/Fu9JRDaQrZUU1jM3N8fc3ByVlZWEQiFqamqCDkm2adMVUc3sLPCLG73u7v+SjqCykVZElb3mypUrDAwMZFUlhc2Ul5fT3NxMXV2dqitkkc1WRN2qB3RlLyUZEXncvn37OHnyJGNjY4yMjGTlIIVECwsLXLx4keHhYUKhEPX19VlXAUKeaKt/nccyEoWIZKXE5R5y5VnL0tISAwMD9PX1MTo6qkmtWWyrBLTu4IE4M9tvZjelMB4RyUKlpaUcP36czs5OioqSLqIfqOvXrzM0NERvby/Dw8MsLy8HHZKssdVP0s+Z2XuIThZ9hOgSDGXAUeC5wEHgN9IaoYhkjfr6eqqrqwmHw0xOTgYdTlJWVlYYGRlhbGyMhoYGmpubKSkpCTosYYtBCABmVgu8hOiothZggegk1C+4+7+mPcIsoUEIIk80NzfHpUuXcq5KgZlRV1dHKBSirKws6HDy3maDELZMQBKlBCTyZKurqzd6F7n4WRKvrlBRURF0KHlrN6PgREQ2VFBQQFtbG3V1dVy6dCnnKhRMT08zPT3N/v37CYVCOTPQIl8oAYnIrpWXl9PV1XWjrlyujTzTkuHBUAISkZRpamqipqaGgYEBcnEJEy0ZnllJzdIyswoz+59m9qHY9jEze2F6QxORXBSvK3f48OGsXPwuGYlLho+Pj+fk861ckOw04b8FFoHbYtth4N1piUhE8kJtbS09PT00NjYGHcqOLS4uMjAwcGPJ8Fy7tZjtkk1AR9z9PcB1AHdfYP21eEREbigsLOTAgQOcOHEip4c8Jy4ZrkmtqZNsAloys3Jii72Z2RGiPSIRkS3t27eP7u5uWlpacvqZSnxSa29vL4ODgywtLQUdUk5LdhDCO4hWQ+gws38gOin1tekKSkTyj5nR2tp6Y8j2lSvbWfw4u6yurhKJRBgfH9ek1l1IdkG6r5jZt4FnEL319pbYInUiIttSVlbGiRMnGB8fZ2hoKKefq7g7k5OTTE5OalLrDmyagMzsB9fsGol9P2BmB9z92+kJS0TyXWNj440h2zMzM0GHs2ua1Lp9W/WA3hv7XgbcCnyXaA/oKcBDwI+mLzQRyXfFxcUcOXKEmZkZBgYGsnop8GQlTmrVSq2b23QQgrs/192fC1wCftDdb3X3pwG3AOcyEaCI5L+ampqcH7K91vz8POfPn+fUqVNMTU1pLtE6kh0F1+XuvfENd+8DnpqekERkL8qXIdtraVLrxpJNQKfN7G/M7Dlm9uxYRYTT6QxMRPamfBmyvVbipFat1BqV7DDs1wG/DLwltv0A8P60RCQie158yHZtbW3Kq2z/7jeiC+n93nPqU9bmdsRXah0dHaWpqYmmpqacWWU21ZIdhn0N+LPYl4hIRuR6le3NaKXWJBOQmT0TeCfRJbhvnOPuh9MTlojI43K9yvZm9vKk1mT7fR8G3go8AuTPryAikjPiVbanp6cZHBzMiyHbiRIntdbU1NDS0pL3k1qTTUCz7v6ltEYiIpKE2tpaqqqqCIfDTE5OBh1OWszMzDAzM5P3k1qTTUBfN7M/AT5DQhFSVUIQkSAUFRXR2dlJfX09ly5dYnExP2sj5/uk1mQT0A/Hvt+asM+B56U2HBGR5FVVVdHd3c3w8DCRSCRv59jEJ7WWl5fT3NxMXV1dXgxRT3YU3HPTHYiIyE4UFBTQ3t5+o8r21atXgw4pbRYWFrh48SLDw8OEQiHq6+spKEh2Omf22aoY6a9v9rq7/2lqwxER2ZmKigq6uroYGxtjZGSE1dXVoENKm6WlJQYGBhgZGaGpqYnGxkYKCwuDDmvbtuoBxZ98nQB+CLg3tn0H0cmoIiJZw8wIhUI3JrDOzc0FHVJaJU5qbWxspLm5OacmtW4aqbu/C8DM/ploMdK52PY7gU+lPToRkR0oLS3l+PHjTExMEA6H82oC63pWVlYYHR0lEonk1KTWZFPlASBx7dkloDPl0YiIpFBDQwPV1dUMDg4yPT19Y39kPj8TUq5Nak02Af0d8O9m9lmio99+Bvho2qISEUmR4uJiDh8+fGPNIYDxq/n7fAiePKk1FApRWVkZdFhPkuwouD8wsy8Bz4rtep27/0f6whKR7Xj5Bx8MOoQc4VycjfZ+4kVJ898kcJ7CwiJKSkp2NFjhE790W+rDIvkeUHzSqSaeikhOCk9fZWjm2o3t/vFoKZ/GigKaKnNvBNl2rawss7CwTEFBISUlJVkxWCH4CERk19L1G2o+evkHH+Shx6a48IfPv1GNOl8nsG6mrKyMUCgU6KTW3J3BJCKyCwUFBbS1tdHV1ZX3RT/Xc+3aNS5evEhfXx/j4+OBzJtSAhKRPaet5vGRYfEJrG1tbTldVWCn4pNag1ipde/9bYvIntde+8QeT3wCa3d3d95Wnt7K8vIyQ3dWDFMAAAnKSURBVEND9Pb2EolEMnJNJSARkZj4BNaDBw/mZGmbVFhZWcnYon9KQCIiazQ0NNDT05N3yx9kGyUgEZF1FBcXc+TIEQ4fPkxxcXHQ4eQlDcMWEdnEXliBNSjqAYmIbCG+AuuxY8coLS0NOpy8oQQkIpKk/fv3093dTVNTU9Ch5AUlIBGRbSgoKKCjo4Ouri7Ky8uDDienKQGJiOxAZWUlJ0+epLW1NbBSNrlOCUhEZIfMjJaWFk6ePJmVyx1kO42CE5E9JR2FW8vLy+nq6iISiTA0NBRIXbVcpB6QiEiKNDU10dPTw/79+4MOJScoAYmIpFBJSQnHjh2js7Nzz5bzSZYSkIhIGtTX19PT00NtbW3QoWQtJSARkTQpLi7m8OHDKuezASUgEZE0q62tpaenh/r6+qBDySpKQCIiGVBYWHijnE9JSUnQ4WQFJSARkQzav38/PT09KueDEpCISMYllvMpKyvb+oQ8pQQkIhKQyspKuru7aWlp2ZPlfJSAREQCZGa0trZy8uRJKioqgg4no5SARESyQLycT3t7OwUFe+OjeW+8SxGRHGBmNDc3093dzb59+4IOJ+2UgEREskxpaSknTpzgwIEDeV3ORwlIRCRLNTY20t3dTXV1ddChpIUSkIhIFispKeHo0aMcOnSIoqL8WkFHCUhEJAfU1dXlXXFTJSARkRxRVFTE4cOHOXLkSF4UN82v/pyIyB5QU1NDVVUV4XCYiYmJoMPZMfWARERyUGFhIQcPHuT48eOUlpYGHc6OKAGJiOSwqqoquru7c7K4qRKQiEiOy9XipkpAIiJ5Il7cNBQK5URxUyUgEZE8Yma0tbXR1dWV9cVNlYBERPJQRUUFXV1dtLW1ZW1vaE8kIDM7bGYfNrNPb7ZPRCSfmBmhUChri5tmfQIys7vNLGJmfWv2325mZ8zsnJm9bbM23P2Cu9+51T4RkXxUVlbGiRMn6OjoyKqlHnJhIupHgL8CPhbfYWaFwPuAnwDCwLfM7F6gEPijNee/3t0jmQlVRCR7NTU1UV1dzaVLl5ibmws6nOxPQO7+gJl1rtn9dOCcu18AMLN7gBe7+x8BL8xshCIiuaO0tJTjx48zMTFBOBxmZWUlsFiypy+2PW3AYMJ2OLZvXWZWb2YfAG4xs7dvtG+d895oZg+b2cPj4+MpDF9EJFgNDQ309PQEutRD1veANrDekA7f6GB3nwTetNW+dc67C7gL4NZbb92wfRGRXFRcXMzRo0eZmppicHCQ5eXljF4/V3tAYaAjYbsdGA4oFhGRnBbUUg+5moC+BRwzs0NmVgK8Arg34JhERHJWEEs9ZH0CMrOPAw8CJ8wsbGZ3uvsy8GbgfuA08El37w8yThGRfFBTU0NnZ2dGrpX1z4Dc/ZUb7P8i8MUMhyMiIimS9T0gERHJT0pAIiISCCUgEREJhBKQiIgEQglIREQCoQQkIiKBUALagpndYWZ3zc7OBh2KiEheUQLagrvf5+5vDLJgn4hIPjJ31dhMhpmNAzPATrpCDcBEaiOSTVSzs3+nbJet7yuIuNJ9zXS0n4o2d9vGTs/fzWfYQXdvXO8FJaBtMLO73P2NOzjvYXe/NR0xyZPt9N8p22Xr+woirnRfMx3tp6LN3baRbZ9hugW3PfcFHYAkJV//nbL1fQURV7qvmY72U9HmbtvIqp8h9YAyQD0gEcll6gHltruCDkBEZBfS8hmmHpCIiARCPSAREQmEEpCIiARCCUhERAKhBBQAM6s0s4+a2YfM7FVBxyMikiwzO2xmHzazT++2LSWgFDGzu80sYmZ9a/bfbmZnzOycmb0ttvtngU+7+xuAF2U8WBGRBNv5/HL3C+5+ZyquqwSUOh8Bbk/cYWaFwPuA5wPdwCvNrBtoBwZjh61kMEYRkfV8hOQ/v1JGCShF3P0BYGrN7qcD52K/MSwB9wAvBsJEkxDo30BEArbNz6+U0YdferXxeE8HoomnDfgM8HNm9n6yrDSGiEjMup9fZlZvZh8AbjGzt+/mAkW7OVm2ZOvsc3efB16X6WBERLZho8+vSeBNqbiAekDpFQY6ErbbgeGAYhER2Y60f34pAaXXt4BjZnbIzEqAVwD3BhyTiEgy0v75pQSUImb2ceBB4ISZhc3sTndfBt4M3A+cBj7p7v1BxikislZQn18qRioiIoFQD0hERAKhBCQiIoFQAhIRkUAoAYmISCCUgEREJBBKQCIiEgglIJEUMbMVM/tOwtfbtj4r/Szqa2Z2MCG2UTMbStguWXPOa2NzQxL3NZjZuJmVmtk9ZnYss+9E8o3mAYmkiJldcfd9KW6zKDYhcDdtvAD4cXd/a8K+dwJX3P1/b3DOfuACcMDdr8b2vQn4IXe/08yeDfxCbE0rkR1RD0gkzczsopm9y8y+bWa9ZtYV218ZWwjsW2b2H2b24tj+15rZp8zsPuCfzazCzD5pZt8zs0+Y2UNmdquZ3Wlmf5ZwnTeY2Z+uE8KrgM9tEt/TzOxfzOwRM7vfzFrc/TLwAHBHwqGvAOK9ov8L/LiZqaCx7JgSkEjqlK+5BffyhNcm3P0HgfcD/z2277eBr7n7DwHPBf7EzCpjr90GvMbdnwf8CjDt7k8Bfh94WuyYe4AXmVlxbPt1wN+uE9czgUfWCzh27l8CL3H3pwF3A38Qe/njRJMOZtYKHAe+DuDuq8A54AeS+HsRWZd+exFJnQV3f+oGr30m9v0RokuyA/wk0QQST0hlwIHYn7/i7vEFwn4U+D8A7t5nZt+L/XnezL4GvNDMTgPF7t67zrXr3H1ug7hOADcBXzEzgEJgJPba54G/jt2OexnRZeQTV/CNAK1skNxEtqIEJJIZi7HvKzz+/86An3P3M4kHmtkPA/OJuzZp92+A3wIeZf3eD8CymRXEei1rGdDv7retfcHdF8zsy8DPEO0JvXXNIWXAwiaxiWxKt+BEgnM/8GsW63qY2S0bHPevRHsgmFk3cHP8BXd/iOiaLT/P489n1joDHN7ktUYzuy3WfrGZ9SS8/nHg14Fm4N/WnHscUHV32TElIJHUWfsM6I+3OP73gWLge2bWF9tez18TTRLfA34T+B4wm/D6J4Fvuvv0Bud/AXjOei+4+xLwEuB/mdl3ge8AP5JwyD8Tvc32CU8YMmtmzURvOY4gskMahi2S5cyskOjznWtmdgT4KnA8ljwws88Df+buX93g/BbgY+7+EymM6a3AZXf/cKralL1Hz4BEsl8F8PXYiDUDftndl8ysBvh34LsbJR8Adx8xsw+Z2f7Y8OpUmAH+LkVtyR6lHpCIiARCz4BERCQQSkAiIhIIJSAREQmEEpCIiARCCUhERAKhBCQiIoH4/xUEuBWDC+LeAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ax = spec.plot_error(energy_range=energy_range, energy_power=2)\n", "flux_points.plot(ax=ax, energy_power=2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, "autoclose": false, "autocomplete": true, "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 1, "hotkeys": { "equation": "Ctrl-E", "itemize": "Ctrl-I" }, "labels_anchors": false, "latex_user_defs": false, "report_style_numbering": false, "user_envs_cfg": false }, "nbsphinx": { "orphan": true }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "16823b651ddb421d9be061faae11e4b6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "initial" } }, "1f864de0619c45afb54e19197c55eb10": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "RadioButtonsModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "RadioButtonsModel", "_options_labels": [ "linear", "sqrt", "log" ], "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "RadioButtonsView", "description": "Select stretch:", "description_tooltip": null, "disabled": false, "index": 0, "layout": "IPY_MODEL_491d80070296410c81bae0a9c86b7672", "style": "IPY_MODEL_16823b651ddb421d9be061faae11e4b6" } }, "491d80070296410c81bae0a9c86b7672": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "7ff14126b1b84a04a2537684c35bd67f": { "model_module": "@jupyter-widgets/output", "model_module_version": "1.0.0", "model_name": "OutputModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/output", "_model_module_version": "1.0.0", "_model_name": "OutputModel", "_view_count": null, "_view_module": "@jupyter-widgets/output", "_view_module_version": "1.0.0", "_view_name": "OutputView", "layout": "IPY_MODEL_fd04baf68d604d88ac7010ff351394ec", "msg_id": "", "outputs": [] } }, "9417d96445a3444e80df3fdb9301ede1": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "b84c7173cb754115a051f25beaf69940": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "initial" } }, "c17b3476baaa4868871294246b850f00": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "SelectionSliderModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "SelectionSliderModel", "_options_labels": [ "1.00e+00 TeV - 1.78e+00 TeV TeV", "1.78e+00 TeV - 3.16e+00 TeV TeV", "3.16e+00 TeV - 5.62e+00 TeV TeV", "5.62e+00 TeV - 1.00e+01 TeV TeV" ], "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "SelectionSliderView", "continuous_update": false, "description": "Select energy:", "description_tooltip": null, "disabled": false, "index": 0, "layout": "IPY_MODEL_d98eeb137b2c4932b34bfeecc906c92c", "orientation": "horizontal", "readout": true, "style": "IPY_MODEL_b84c7173cb754115a051f25beaf69940" } }, "d98eeb137b2c4932b34bfeecc906c92c": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": "50%" } }, "e1a1d2ecd50643a69adb384c81cafc18": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "VBoxModel", "state": { "_dom_classes": [ "widget-interact" ], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "VBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "VBoxView", "box_style": "", "children": [ "IPY_MODEL_c17b3476baaa4868871294246b850f00", "IPY_MODEL_1f864de0619c45afb54e19197c55eb10", "IPY_MODEL_7ff14126b1b84a04a2537684c35bd67f" ], "layout": "IPY_MODEL_9417d96445a3444e80df3fdb9301ede1" } }, "fd04baf68d604d88ac7010ff351394ec": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 4 }