Repository: LSSTDESC/sacc

Issue:
Beams
Allow tracers to have beams associated with them.

Discussion:

Patch:
diff --git a/.travis.yml b/.travis.yml
index a3c229c..97e951f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,4 +7,4 @@ install:
   - pip install numpy --upgrade
   - python setup.py install
 script:
-  - pytest
+  - pytest -vv
diff --git a/examples/CMB_LSS_read.ipynb b/examples/CMB_LSS_read.ipynb
new file mode 100644
index 0000000..3654859
--- /dev/null
+++ b/examples/CMB_LSS_read.ipynb
@@ -0,0 +1,441 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Reading a SACC file with CMB and LSS data\n",
+    "This example shows how to read LSS and CMB-like data from a SACC file. You should run the `CMB_LSS_write` notebook before this one in order to have some data to read!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sacc\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Reading the data\n",
+    "This is as simple as:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/alonso/.local/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
+      "  from ._conv import register_converters as _register_converters\n"
+     ]
+    }
+   ],
+   "source": [
+    "s = sacc.Sacc.load_fits('cmblss.fits')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Inspecting the contents\n",
+    "Let's now understand the contents of this file."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Tracers\n",
+    "First, let's see what quantities have been correlated"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ck cmb_convergence <class 'sacc.tracers.MapTracer'>\n",
+      "B20_T cmb_temperature <class 'sacc.tracers.NuMapTracer'>\n",
+      "B20_P cmb_polarization <class 'sacc.tracers.NuMapTracer'>\n",
+      "gc galaxy_density <class 'sacc.tracers.NZTracer'>\n",
+      "wl galaxy_shear <class 'sacc.tracers.NZTracer'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "for n, t in s.tracers.items():\n",
+    "    print(t.name, t.quantity, type(t))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "OK, so there is a CMB lensing tracer (as a `Map` tracer), a galaxy clustering tracer and a cosmic shear tracer (as `NZ` tracers), and the temperature and polarization of a given frequency map (as two `NuMap` tracers).\n",
+    "\n",
+    "Let's look at the redshift distributions, bandpasses and beams."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# N(z)\n",
+    "plt.figure()\n",
+    "plt.plot(s.tracers['gc'].z, s.tracers['gc'].nz, 'r-', label='GC')\n",
+    "plt.plot(s.tracers['wl'].z, s.tracers['wl'].nz, 'k--', label='WL')\n",
+    "plt.xlabel('$z$', fontsize=16)\n",
+    "plt.ylabel('$N(z)$', fontsize=16)\n",
+    "plt.legend(loc='upper right')\n",
+    "\n",
+    "# Bandpass\n",
+    "plt.figure()\n",
+    "plt.plot(s.tracers['B20_T'].nu, s.tracers['B20_T'].bandpass, 'r-', label='T')\n",
+    "plt.plot(s.tracers['B20_P'].nu, s.tracers['B20_P'].bandpass, 'k--', label='Q/U')\n",
+    "plt.xlabel(r'$\\nu$', fontsize=16)\n",
+    "plt.ylabel(r'$\\tau_\\nu$', fontsize=16)\n",
+    "plt.legend(loc='upper right')\n",
+    "\n",
+    "# Beam\n",
+    "plt.figure()\n",
+    "plt.plot(s.tracers['B20_T'].ell, s.tracers['B20_T'].beam)\n",
+    "plt.xscale('log')\n",
+    "plt.xlabel(r'$\\ell$', fontsize=16)\n",
+    "plt.ylabel(r'$B_\\ell$', fontsize=16)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Power spectra\n",
+    "Let's find out which two-point functions are included\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data types:  ['cl_00' 'cl_0b' 'cl_0e' 'cl_bb' 'cl_be' 'cl_eb' 'cl_ee']\n",
+      "Tracer combinations:  [('B20_T', 'B20_T'), ('ck', 'B20_T'), ('ck', 'ck'), ('gc', 'B20_T'), ('gc', 'ck'), ('gc', 'gc'), ('B20_T', 'B20_P'), ('ck', 'B20_P'), ('gc', 'B20_P'), ('gc', 'wl'), ('wl', 'B20_T'), ('wl', 'ck'), ('B20_P', 'B20_P'), ('wl', 'B20_P'), ('wl', 'wl')]\n",
+      "Size:  2800\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Type of power spectra\n",
+    "data_types = np.unique([d.data_type for d in s.data])\n",
+    "print(\"Data types: \", data_types)\n",
+    "\n",
+    "# Tracer combinations\n",
+    "print(\"Tracer combinations: \", s.get_tracer_combinations())\n",
+    "\n",
+    "# Data size\n",
+    "print(\"Size: \", s.mean.size)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cutting the data\n",
+    "Let's remove anything that we don't care about.\n",
+    "\n",
+    "First let's say we're not interested in any B-mode data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2800\n",
+      "1500\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(s.mean.size)\n",
+    "s.remove_selection(data_type='cl_eb')\n",
+    "s.remove_selection(data_type='cl_be')\n",
+    "s.remove_selection(data_type='cl_bb')\n",
+    "s.remove_selection(data_type='cl_0b')\n",
+    "print(s.mean.size)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's ignore all power spectra involving the `B20_P` tracer, and also all cross-correlations with `B20_T`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/alonso/.local/lib/python3.6/site-packages/sacc-0.2.3-py3.6.egg/sacc/sacc.py:368: UserWarning: Empty index selected - maybe you should check the tracer order?\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[('B20_T', 'B20_T'),\n",
+       " ('ck', 'ck'),\n",
+       " ('gc', 'ck'),\n",
+       " ('gc', 'gc'),\n",
+       " ('gc', 'wl'),\n",
+       " ('wl', 'ck'),\n",
+       " ('wl', 'wl')]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.get_tracer_combinations()\n",
+    "for t in s.tracers:\n",
+    "    s.remove_selection(tracers=('B20_P', t))\n",
+    "    s.remove_selection(tracers=(t, 'B20_P'))\n",
+    "    if t!='B20_T':\n",
+    "        s.remove_selection(tracers=('B20_T', t))\n",
+    "        s.remove_selection(tracers=(t, 'B20_T'))\n",
+    "        \n",
+    "s.get_tracer_combinations()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, let's impose some scale cuts. \n",
+    "Since small-scale clustering is tricky, let's remove all ells > 100 for any power spectrum involving `gc`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "700\n",
+      "430\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/alonso/.local/lib/python3.6/site-packages/sacc-0.2.3-py3.6.egg/sacc/sacc.py:368: UserWarning: Empty index selected - maybe you should check the tracer order?\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(s.mean.size)\n",
+    "for t in s.tracers:\n",
+    "    s.remove_selection(tracers=('gc', t), ell__gt=100)\n",
+    "    s.remove_selection(tracers=(t, 'gc'), ell__gt=100)\n",
+    "print(s.mean.size)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The full covariance matrix and data vector can be obtained through `Sacc.covariance.covmat` and `Sacc.mean` respectively."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(430, 430) (430,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(s.covariance.covmat.shape,s.mean.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bandpower window functions\n",
+    "Let's now access bandpower window functions. To do this, we first need to get the indices corresponding to a given power spectrum and then use `get_bandpower_windows`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD4CAYAAAAAczaOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2dfbBlWVnef+/ap2dg+IZpFGdGZ1IzqBM0QDp8CKUofsygmUmVxhqiUZQ4VQlEIiYpKCyCmNIyGj+DmFEJaBkQ0ZiOjKLhI6QsQRoxIzPjaDNDmA9gGoMIItP37PXmj7XWPvvc6b53d/ddz+m773qquu49556+a+979nnOc573ed9l7k5DQ0NDw8FA2PQBNDQ0NDTo0Ei/oaGh4QChkX5DQ0PDAUIj/YaGhoYDhEb6DQ0NDQcIi00tfPHFF/vll1++qeUbGhoa9iXe//73f8LdD5/t/98Y6V9++eUcO3ZsU8s3NDQ07EuY2f89l//f7J2GhoaGA4RG+g0NDQ0HCI30GxoaGg4QGuk3NDQ0HCA00m9oaGg4QNiV9M3sdWZ2v5l98DQ/NzP7GTM7bma3mNlT9/4wGxoaGhr2AlOU/uuBa3b4+bXAVfnfjcBrz/2wGhoaGhpqYNecvru/28wu3+Eh1wO/7GlG83vM7NFm9gR3/+hOv/fjf/05fuL37jijgz1TfOkTHsm1X/YE+PAfwJ3vqroWAF/4DLjyubz7nndzy4lbqi/37EuezZMf/2Q+9da3cvJDH6q+3iOuuYaHPPGJ3Pq/7+Uzn3yg6lpm8CXPfAKPeOyF/PHv/A8+9zefrrpe6Dq+/LnXcNHDHsmn/+A+/GRfdT07FHj4M7+Az8WTHDt2jOVyWXW9Cy+8kKc//eks+09w331vxr3u+V1wweO49JJ/yp1/+wC/8fFPUnuC+xc99AJueMLj6i4yE+xFc9YlwN2j2/fk+x5E+mZ2I+nTABd8/pX87DuP78Hyp4Y7PPqiQ4n03/6DcPd7Aau2Hjgc/lK48rn88Ht/mHs/cy9WcT3HueXELdz09Tfx0Ze9HN/aSkxZbUFn6977eOwrf4h3/Wp+s6785+yXzlV/v+Ndv/wLeb1KC2ZGuvCih3P1lc/mr3/3w3m9OsuRCXBx8UP58/5e3vGOd1RaaB2XXXYZMb6Vu+766XxP3RO8+HFfzevuMX7p3k/UvlQAuP7xj+GhXStT7gZpR6673wTcBHDkyBE/9iPfWG2tf//bt/HGP/pIutGfhKu+Hr7t16utx1u+G+77EwC2+i2++apv5lVf8apqy33X734XW3ELd8e3trj4X/xzDn/v91Zb70PfcA2+tUW/jAB81T/5Yp70lZdUW++ml/wv+j7SL9NL+vp//QNc+Q+eUWWtk3/7WX72Bd9KXG7hfVrv8S96Mhdc9ogq622d+Cwf/4/vh97p+6S4X/rSl/LIRz6yynp33XUXb3jDG+j7HmcLgK/56r/ArA5BfuxjR7n1tu8jxi22/BCHL1jwp896UpW1AF77kfv5wQ/dR982hJqEvXjW7wUuG92+NN+3UXSdsYz5IohLCJXf38IirQMsfUlnXdXlutDRew8x5jvqrsdigfc9nv+mIdTUbhA6w3snxj7frnd+ln93jBEy6VPx/Cz/7nR+6fkLoZ5CLb87xoj7ErBqhA9g+dp3X7J0Z1HzEygMv3/ZSH8S9uKZPwp8R07xPAP41G5+vgKdGbFcBDFCxYscAOvA0ws4eiRUXq+zTPpZKVpl0rcQIPbETPrV/5xmeHQ8k6IJSNFjHKyemqQ/2FS+In2rSIzD+bnjHgdSroWB9In0Xj8XXp6qvnH+JOwqf83sjcBzgIvN7B7g3wGHANz954GbgecBx4HPAt9V62DPBIugVvrdoPT72LOovF5nHX3s8Uz6EqW/1Cl964wYnZjPL4R651d+dxx9kqn6ptZlpR/1St/CUkf6vqQXKv1m70zDlPTO83f5uQMv2rMj2iN0IeAOMTphxvaOD0q/7vlZ1+H9kpjllHWV7Z1QSD+TYsUCnYUAZslKijp7hw2QfrAes8rXSv797n2zd85DzLbUXTiidwfvkxKvidBB9p+jx6ovYjiVvVP5qewC9LE4WFXtCEhKW2XvQCJGj3Gk9GvaO/lrTJZLWb/acvm5Sp5+X9XPT+vl3+99snfqXiore6fuMrPBjEk/nVofPZGxROn3ec2eRWU19WB7p7bST4Xc4ukHldIXFHLTel2ykoRKfxP2TiJ9jdKP3jd75zzEjEk/fV1GT7aLopA7sndUhVzPTT21lb6FAMvlSglXV/o5vVM+yVRW+hbCmqdfVZ6ewt5RFHJX6Z3ar4VSOE7pna7ytdI1e+eMMGPSVyv9DrwnZv+jq2wndSEpfWlkM0ax0mewd2oWciF9kvAYodhXAtJXK313B48EkdLHU3qn8qUy/P6W3pmG2ZL+Ir+w+qL0RYXcPtsREnvHe3ypLeRKc/pCe8e6bmOF3Nr1n+1Kv3Z6J7T0znmN2ZJ+GJO+sJDb55km1e2doTmrePqaQm5UFDrz74+bLOTWPL0R6bt7ddJfL+TGZEVWXbCQfqRHYO/QSP9MsLGN0WtjXemLCrk4fb+V1xcVcmVKP3fk9iKlH7LS71WF3LBeyK3pSZTerOiSpJda6W/vyFXZO8vG+ZMwW6XfZVJaxpjtHYHSB5bLNH2yttIPFnJkMxdyF5VfyIsOlku50lc0Z0G2d3pNZNPMktqPuWGqshLeVHrHc2SzqzpubVXIbUp/GuZL+sNHWpLSF32kjXErr193vUVYJE+/FHIFb2pj+0NRyNXn9PvVGIbKRExIhVWlp+/uOIKcPmW9Ftk8HzFfe6fbrvQV9g70fVL6OntHpPS7DSh90cC18vtVA9cg//36Tdg7+o7c+pHN9LVFNqdhtko/DEq/B1xm7xRPX5HTjx5Xkc3KxEG3TekLSNFdp/TNQibF1fqVFwTfRCFX15Hr3hMlkc18fo3zJ2G2pF8KucOORNVJvyj9k0B9e6cLHUtfjpS+aPaOSOmHLit9VSG361J3cxTMDSDNLvKNRDbb7J2DjtnaO6WQ2w+kL2jOYkX6KntHNVqZRQfLfhi4pkvvaJqzSk7fRaSfCrkHJb3TOnLPJ8ye9D2PRlAVcvuos3ccJ/aaTzKWC7nF/6g+1WLI6WvGMJScPtGrnxuQ7J2YhvOp0jubmKevsXfS11h3mdlgtvbOSuknEtYVcrO9IxjDANBvpfNTRTaHnL4ovTOMKajcfLY2cE1h7wSdvQO5D2FDSr/ZO+cXZq/0VUp4yOlHjadfPkmUwrEqsjl4+oLRyrEfF3Lr7wxWBq5VL+JCklsiewfS81U6cg0V6SdPXzVauZH+NDTS3ytkpV/Wq57TL+NrlyKlnyObPrQFCJS+MyrkVlb6w8A1rdJ36qd3YJvSr/0GOiL9CDKl39I70zBbe2dRilf9TAu5Zb3lyXxH/ULueJ5+9Zx+Z8Q+Djn92jHD0IU8cA1tIVdu77T0zkHHbEm/CMOiFGWFXE9vMooxDABxqUnv2PaO3NrpHTM8j1a2EAR2UmrO8ujV1wLWSF+xXgghj1buh47ZWljfOcuHnplaKGfTOnKnYcb2TlH6GyrkiuydovQ1kc3RHrnCjdFrZ/Qhk2Ip5NaOmzAq5KJV+lG+cxYsKv85V2MY6q4zF8yW9BcP8vTnRfpD9jqndxTbJeLj3Lxu4FrtjD6sD1zTFHKz0heR/qqQWz+9wzB7J+f0RQPXmr0zDbO1d4YxDMXeqf3CKh579qBrRzaL0vdetF1i/v0+NIPpBq7Vzuin9UYD1wScTy5UK8YwwErpI8npW1rDe6KwOavZO9MwW9IvA9dcZu+sN2cpxjDAqA+hstIvv79fapT+KqevsndGA9dE6Z3NFHIVSj8leFIhV2HvpK/N3pmG2do7K6WfSVHckavK6Ue10i+FY9GUTZXSl+f0jcHeURVyY4w4gp2zAOiEUzabvXMmmC3pF0+/tPHLPP089kFm75TZQrXVcP79xdOvPm5+tHOWROmXnL6j7cgVFnLTGAad0u9jj0Ozd84zzNbeeXBzlor0tUq/H5qzBIVcIC4jFkwQoSyF3Cgp5IbRwDWJ0u+09s6qkFs/vZPWW9DnTj7V7J1m70zD7El/2DhcXcgVefpDIbf6PP1SyI3V/XxIHb+eB67J7B1hRy6Wz09cyFXM04eU1V/mEWiynbNorD8FsyV9fWRzfRMVlb0Ti72jUvp9rJ7cgbKJCvR9X30EA6RC7mqefvXlNljIFSr9vih9TXNW8/SnYbakHwZPXzxa2TWzdx5UyK29+1JX1ouaKQWlozrG6rNiYFshV9aRq9kYHTal9BMJ19YIZkZnzd6ZitmS/mI76c+skLvd3qmt9NmA0k/r9RolPB64Jjk/5KOVUyFXp/SXXqzO+n/PhVkr5E7EbEl/2ERFXshVT9kskU3BPH1SIVfi6ZeO46UqvRO0hdwDkNMvJFzb04f0xtLsnWmYdLWZ2TVmdoeZHTezl53i519oZu80sw+Y2S1m9ry9P9Qzw+YKuVp7B1nHcS7kikjR1uwdRSE3N2c59fOokDtydYXclN7pAa8+Tz+t17GMGnsHoKONVp6KXa82S7LgNcC1wNXA883s6m0P+wHgze7+FOAG4Of2+kDPFENkU2bvbCP92oXcMFL6XVc/Qjmyd1TpHUhjH6QD15Qdub1a6edPhTKlrynkQvo00ZT+NEy52p4GHHf3O939JPAm4Pptj3Hgkfn7RwH37d0hnh3KPP2VEhbZO66JbBal7/2y/oRNVvaO9yKlb2NPX5TTLwPXFNI0WBpgJx2tXPYmUHn6WekLhhmFRvqTMYX0LwHuHt2+J983xquAbzeze4CbgX95ql9kZjea2TEzO3bixImzONzpKLw0dOTKxjBo7J1VIbev340LwycZtdKPvS6n7x5lA9c2sUfuivQ16Z2Vp199ORbW7J2p2Ktn//nA6939UuB5wK/YKa4sd7/J3Y+4+5HDhw/v0dKnhpkliydqt0sclL5wDINU6UevvlUibEvviAauge6TzCYKue7F3lEp/WbvnI+YcrXdC1w2un1pvm+MFwJvBnD3PwQeAly8Fwd4LuhMSfqbKeR6VCt9DSmGoSajG7gGaacuTUcueM7pywq5SqVPoPf0d1SQfrN3pmPKs/8+4Cozu8LMLiAVao9ue8xHgOcCmNmXkki/rn8zAV0wcJWnv6ExDMteqvQTCc9Q6Zc1hBujIx7D4HEzSl9m79RfZhbY9Wrz9JnwxcDbgNtJKZ1bzezVZnZdftj3A99jZv8HeCPwAvfNv+0ugulz+vlNpvYeueVNRVbI7Ub2jlTp65qz0oK6gWseI+6aDuB1T1+b01co/ZbTn45JTOjuN5MKtOP7Xjn6/jbgWXt7aOeOEAxz9cboPZ3Vj1AOnyRUhdwR6ZtAuhXi9V43hgGS5SJR+nnqJR0ypV+0sIr0o5j0W0fuNMy2Ixey0lcXcmNf3dqBVU7fe5G90608fWl6J+oGrqUFdYXcGMsuZOpCrqg5K3OwoiN3YW2e/lTMmvRDMExdyPW+enIHtnXkKgu5cdUtWxOD0hcOXEvrKffITSSlKuS66lNvXiOvJurIteFNpmFnzJr0F8ESS0F9T98MLAz2Tm2s7J2ojWy6JrI5Tu+oPX3NwDUbpr/rc/rz9PSb0p+GWZN+Su+ICrl5jd776kVcGBdy+4GQ6y448vQFL+LyJ5SNYShreP39f9OCRsy0P9+O3PS9ZEfeZu9MxvxJX9WRm9eIHge/vSYGC6nv61tXjDz9iFTpKzdGB5LSF72pOTp7Z72Qq+7IVY1Wrr7MLDB70rdhyqbC907ZZK29oy3kyiKba4VczcA1QLYx+ljp6+0d1R656ftO8Pds9s50zJr0F8EwXyaVLxmX2+nsnSFtEutvoALDGqmQqxu45lG3MbrlCq7K3lEq/XEhV+fp547c6qsle6fl9Kdh1qQfLPe6K1Q+QBDaO+NCrnJMgWuUvnWrQq7q/Ky8HEQduW5ipZ/zNKp5+j3qQm71ZWaBWZP+osuRTUURFwZ7R1nIpe9BUsjNfQEipb/y9HWF3OJ1z7WQa+LmrMHeaemd8wqzJv3OckeuoogLKZss8vTNLL25qHLsZWN0UbplyOm7TumHEtBX9CGY3tPHtKSvbs5q9s40zJv0yxgGmb2zkNk7kNV+H7WRTdend1SjlYdUyww9/RACZuWThWoMQ/pe0pxlNjSDNeyMWZP+IoSU3pHZO53M3oFE+hbjYL3UhJVCrlrpSwu5Qnun0xdybbCTRDl9dKOVm70zHbMm/fRaUir9VMhV2DuQEzzyQi6ayOawcbiwkFvISZJO0uf0zYQ5fcKg9HU5/Ub6UzBr0l+EQJAq/QVLtPaO9drIpoz0O4NCiqKBa1Klv4Gc/sreEeX0B6Vffbkc2ay/zhwwa9IfRitLC7kutXdQ7yzlJrR3yhRKzcC14XmTdORuIL0j9fTDiPQF9g5N6U/FrEl/IS/kdkS09k5S+uJCriyymUlKNHCtNGdJpOlGCrnK9M6i2TvnKWZN+l0wgovtHXfJaGVI45UtOqYo5IYAIRDdhKOVs9KX5/SrL5dIX9icZWYgTu/0uQlM8WoIzd6ZjHmTvhmm7sjFZUp/YQssxiFDXx1dl0bTqCKbrttkZK0jV2zvzDaymf+eCntnYTbs1NWwM+ZN+p0R0Hbk9h5lSn+wdwRKH9LQNZmnPyrkKgbKhdClsR2oCrmbTO8oCrkdfaYXlb3TmrOmYdakvxjsHV1z1lKo9FNO3yWkmBbscESkb6As5IZOP3tHP4ZBqfQXxGLvaEokzd6ZiFmT/mDvyNI7QWrvFNJHZu8khaiObGrSSZ2U9NnAzlnF3tHsLRGIBAKaN7XFaKxFw86YN+kHoxMXcnvXkX4IAeujpJALwOIQoOvIdVcWcoN84JojrFmYDfZOECn9nk6i8iEJvGbvTMPsST+IO3KX6NI7qZCrU/reJdKXKH0b5/RFA9eGjtzqy21o4FohRVUht5MUcaFsl8iw2XzD6TF70k/pHZ3SjyC1d4IosgkMXbmK9I4FW6VNVAPXxB25m7J3lOmdhUjpl2Jx1Cy3rzFr0l8EoxMr/V7o6YeQc/qK5ixWSl/h0aZ1ihLWDlyTFHK7TXbk6tI7KoLpcmNds3h2x6xJPwRLG0coxzCI7Z0QXfem1umUPoxJf34D1zDkO2dpB65plX65JNvuWbtj1qS/2EQhF529EzBC1NgfAC4s5KZ1hPaOerTyBvbI1ds7neT9E1YNYG0Uw+6YNemHjdg7OtJflHVkhVxdZBNW4xB0hdyZd+TigGmUfh7DIHrlDZ5+s3d2x6xJPzVnKccwLKT2zgUxrSMr5OZ1ZErfdOmdVMjNHbmzHrimuTZTc1ZgYRoSbvbOdMya9LsQstLX7ZylVPqleCUr5C5KZFOyHGXopSa9s8rpz7UjF3OJtQOr9E6zd84/THr5mtk1ZnaHmR03s5ed5jHfama3mdmtZvZf9/Ywzw6dGYGISwu5QnvHC0npPsmASAkDQV7ILfZO9eU2pPQdlc4bcvqS1Vb2TiP93bGrBLYkDV4DfB1wD/A+Mzvq7reNHnMV8HLgWe7+STN7fK0DPhMsOmNBTzTRxRcW9IbO3smkr1L6hfQVJAWr9I6qUN0FoX21MXtHR/r9Buyd5unvjilXwNOA4+5+p7ufBN4EXL/tMd8DvMbdPwng7vfv7WGeHbpgdCZU+uL0Tudl0w91ekeyHJhu4NraOqLmM2Uhd5XeUdo7nS6nPyh90YL7GFOek0uAu0e378n3jfFE4Ilm9gdm9h4zu+ZUv8jMbjSzY2Z27MSJE2d3xGeAzlJaWEX6boHeTJfTL0pfNWUzk9Mc0zuwmkkjaT4bjVbWNmcp7Z1AJ1L6g73Thq7tir26AhbAVcBzgOcDv2Bmj97+IHe/yd2PuPuRw4cP79HSp0eXI5tRRPoxk71qj9zB0xeRflSnd3JTvepNbRjspirkqpuz8FXXcWUMA9dEJByavTMZU66Ae4HLRrcvzfeNcQ9w1N233P0u4M9JbwIbRReMBREXXeh9VhsLQZs7wMLLph9qT39+Hbkwmj4p6chNnr5KIOg9/UC/CaXfOH9XTLkC3gdcZWZXmNkFwA3A0W2P+S2SysfMLibZPXfu4XGeFZLSj4MCr40+k4bK3jkkLuR6V/oCRDm8QvoqpV/sHVEhN+KryZ61lyv2jiyyucAJMqXf0jvTsSvpu/sSeDHwNuB24M3ufquZvdrMrssPexvwl2Z2G/BO4N+4+1/WOuipWIjtnT4r0k6S+YMwFHJVfQg5py8euKb6JDO8Wav2C0j7kFVfC0Ybo7syvdMRVPZO/trsnd0xiS3c/Wbg5m33vXL0vQMvzf/OG4Ss9LdEiYVi76hIf7B3VGMYQoBeqPSF8/RhtUOXKp3kpqv/FHtHZXWyoUJubJy/K2bdkbso9o5Y6Qcx6csim5vy9MX2jqqNNJrLxlRvIr2jVPpdm70zGbMm/S4Yh6ynVxVy8zoL1W5Bg9LXDZQDXXpHuUcujEhf9Py5uUwgrEhflbzKSl9G+ulrI/3dMW/Sz0pRldPvTevp65V+jqTOVemHkHx20fltwt7RNmcFOtPsZdXsnemYNekfsh6AXubpa+2dLhalrynkunJMAQzpHaXSd2Fzj7qQaygLuYtm75ynmDXpl4+WUXSaMS8jytJsppCLTumvCrkqdRpASPrRdEmoYu+47E0mZHtHo/TblM3pmDXpF6WvKuQui9IXXXddfj25iPQZcuya5QoBB9H5yZW+6ZS+vjlrkWfvtHn65xtmTfplwp/O3smRTXEhN6oKj8XTV+2RWwq5svRO0Ns7oucOUn3axTl9taff7J3dMWvS7zxdcFEkTYf0jmS1lacfRc+iKztWAXlOX0z6UZjegbLnsHjgmtreaQPXdsWsSX+RVYZa6cvsnaL0Rcp77p5+UvoakgLKjrWy9cwcd5Wnn3fOkpF++trsnd0xa9JP+1ihy+lnO0mm9H193dpwKx2r80zvyJU+Uav0zVNOVLJW2Ri92TvnG2ZN+nqlX3L6GoRSyFVtWmtaTz8pfd0laog9fUM26hiQjmHQK/2W3pmKeZN+vuBUkc0+qzbZbkH59STz9EtHrqz46Mqo0AbsHdkkHEBdyC3pHRHp56/N3tkdsyb98tFSpfRjJv2FSG0UeyeKOHiwd0R2Eh5RjQ2AbO8IlaKyOQuS0tfZOyWn30vWa6OVp2PepG9aT3+ZX0+yeSqZ7XtVIbeQvqvUsC5tAsXe0Sn9KCd9lyl9SPtLqJR+aJ7+ZMyb9LPKWMoKuXldmdIvHceiQi5q0o9SUgxmRKXSV0c2TVmxQBrZXAzpnUb6u2HmpF+as0RjGIq9o9o4Qu3pF6UfdaSv9PTnr/QjrrpYIBdy1faOZLl9jVmT/gLtwLWVvaNBIX25vaMiRhfbOxZw2aeYUsidZ04/ejq7Zu+cf5g16Yf8Al6KfMxyeavsnYH0hTl9iz3ea9RbUt1CUsTk6R2l0i+fLRQoiltXyE1f22jl3TFr0pcXcvMLSkf62dMXpneMCMulaEF9Tj8KlX7EMZHyBm0htyhuE5F+G608HfMm/VLIdVFzVvbyO9F1t7J3NOs5AfOIyzz9NKjARfLNMC3pu9reibhIIZSCqkrpt43Rp2PWpF/snV5UDCyvp4WIOIrS19k7hnkvV/qqRI1hek9fylGOihML6QfXkL6ZsTCE5tz+xaxJv3TkbokSC4UKVTPEC2H0KnuHAEKlXzx9F0Uy1Erf0e1ZC0npR5GdtMxPWTAN6UOyeJrS3x2q2WAbgXmiYdnANRfbO71Y6WPJ3pEp/TSGIQrtHaXSV9s7oLd3VEofGulPxayVfsnpq5qz4tCcJfpIO9g7KuWdSB9Vesd7IIg9fR1JKdM77jHP3hGRftn1TOTpQ5q/o2yu26+YNekHcSF3qS7kOiwD9CJ1OhRye20hV6n0temdiGyMUX4zk9s7QtJfmA3rNpweMyf9ktMXNaTkr52qkNtHokEvUqcrpa+xdzwXcnU8LC7kuhNE12YhfZW9UxR3QGQFkuydNoZhd8yb9GO64LZE2eRVZFNDHOZODNBHDenH4umrlL5HMCOqCrme7B1VoVrXKjVW+pr1lhvx9NvsnSmYNembF3tH9ZG2kL6IpPpM+jNW+kYgikg4deS6bL3ouuYstdJf2Ts6pd/snWmYNekTy5RN1Tz9TPoqkuojvdreIerGMESxvePJ3tFFUpWkv8xfxfaO60g/NHtnEmZO+lp7Zym3d6AX2jvuxd5RrZdz+rJCbuoNiCq7zKPO0y+7yIneQJcb8PQXzd6ZhHmT/mDvaAeuBRFphD6K7Z1smYlIP3n6upx+UvouUfrFQtKld5Z5Xe3ANaWnvzDVpJ/9jUlsaGbXmNkdZnbczF62w+O+2czczI7s3SGeAzL5bsku9Ejnrhs9HMWevhvmLivkbkLpRyJR8KZWtmVUkX7xyFTvn/0GlH6zd6ZhV9I3sw54DXAtcDXwfDO7+hSPewTwEuC9e32QZ41s75wU2judM7zZ1EaIUWrvpPROL49sqtI7xdNXkH5R+rrIZlH6kuVG6R2tvdM6cnfHFDZ8GnDc3e9095PAm4DrT/G4HwJ+FPjcHh7fuSFqRytHj6kLOGoudOtdm9N3tJ5+KeSq0lCeiqtae8ck56dO7/QbSO+knL5suX2LKWx4CXD36PY9+b4BZvZU4DJ3f+tOv8jMbjSzY2Z27MSJE2d8sGeMovRFA9d6jyknJFLeFKUvtHdQF3KFOX08vXErCrkD6aMZDTnk9EVKfxP2Tkezd6bgnNnQzALwE8D37/ZYd7/J3Y+4+5HDhw+f69K7o6R3VNnkuMz2jkrp545cWdoE7eydrPR1hdyc3hHULAZ7B5MY7WrSX9k7W5oFKTn9Rvq7YQrp3wtcNrp9ab6v4BHAk4B3mdmHgWcAR8+LYm4uXm1J7R1kpI84vUOxd5a6gWsmLOTi5PSOsJArOj+1p1/+gia1d9rG6FMwhQ3fB1xlZleY2QXADcDR8kN3/5S7X+zul7v75cB7gOvc/ViVIz4TiJV+73kLdlVOX2zvDOP+9YcAABghSURBVEpf1RcgVPruPuyRK1f6Qk+/l49W1in9NntnGnYlfU8S4cXA24DbgTe7+61m9mozu672AZ4TYk9PEMbUer3SN2STIVMht9cp/Zhy+hKln/+ETpQo/bGnr9gkZlXIrb4UsBnSXzTSn4RJm6i4+83Azdvue+VpHvuccz+sPUJc0tOxFLF+H/uNFHKXojcZdzBcp/RzTl9SyC2bzHuUzN4Zp3eUSl/n6aevJh3DQJu9MwHz7siNSyKBXkT6S99AIVdp78QNKH3RJiplDce1OX11IdeRRERX6Z2m9M83zJv0PdJbJyP96JFgplPCfU8MJpy9Q+7I1byppeikaSyJTBaqgWurQi7SQq67ZmppP3Qcqwu5jfR3w7xJPy6J6Ei/jz0LbJj5U3/BHg8mV/qoxjBE3eyd4qu7aAzDutKvvtywOYy7SUh/E5HNro1WnoSZk35PNJ29oy7keiZ9XSHXxR25wj1yB6Uv7shV2VdFcYs6gOPg6WvtnTLevOH0mDnpi5W+91m56ZR+DKYr5EZdZNPdMzmJ9sgthVzRaOUV6aPx9ClKX2PvLAd7R630G+nvhpmTfk9vHUtRZGGwd4RKP3ZKe8dlzVk+UsKK9M5QyFUPXJMVclebqEjtHWEht2sD1yZh3qTvPU4n69JTK33vl7gp7Z0ycK3+m9qKeEUD14acvsbe0Xfk5py+iPTLCuYnq69V0GGynpz9jHmTflwSraNXKX3v6UxZyI14F2T2TlH6ikLuQLyigWtrSl9o76gjmzJ7J59Tx1I2JbXN3pmGA0D6gaVI6m/C3lGmd7z3vEeuQOnHkdKXevranL75PJX+yt7ph7Vro9k70zBz0u9x64ZNmmtjE4VcD0Fm70R3zJAo/RUxaQu5qpz+2mhlxeVZSB9Reid/DUQQbWLYWbN3pmD2pB9NPIbBxEq/E6Z3+kT6isim91qlv+rI3UAhVzl7R5ze6YRKv9k70zBv0s+FXNU89t57FgRpIReR0k8Ryjx7R1nIVW2MLlb6PtgfGnsnjnL6yo7cQJTaO2208u6YN+nnQq5M6XufxjCIC7kKT78QUzo9rb2jVPoR1w5cE41WRtyR2zsEPI2ZkJF+m70zBbMnfVd25Mai9LWFXIW9U9R2MM3sHR8VcpVTNtX2jnoTFaW901n59KR5PTR7ZxpmTvo9HhbajlzhwDX6HjqRvbNKUEoLubKds0pOfxOFXAnpr5S+aspmIRcXBQ1CHmOkiojuV8yf9IVTNlNOX+npp/TOUqCk4pq9Mz9Pf6OF3Bl25PYOiw0o/bJ2w+kxb9L3Ptk7onf+6FFq77BcJqWvKDyO7B0UYxgy8VoXxKOVNZ6+upCrTu/07mn4IDpPfyD9NnRtR8yb9OMStwW96K1/GZcEC7JCrseId52kkFt8dQsmtT+CadJXq0KueLtEV41W1jdnBVtfuzYKmTVff2fMn/SDNr2T7B1BodN98PQVhdxxekcR2RwGroUg2UO2eALqgWs6T7+ck9Le2b52XTR7ZxpmTvoxefpCe0dF+hRiEuX01zx9gb1TiNdC0HRUF3tHHtlU7pwVQNSR2zMu5Grszm4g/cb6O2HmpL8E06V3lnFJZ51k9+nBYhHZO4OnH0xrf4ROovTHA9cUHcerQm6QzdM369bWroml+0jpa9I7na3Wbjg9Zk/6Jaevianp7B2WeQ2RvTN4+uJCbhB35KbmLG16R6v0NaTf+4qEW3rn/MK8Sd9TTh8kYmpl70iUd1H6ujEMACEEvdIX5vSRz9NH0pHrrlX6a+kdRaWaZu9MxbxJPy4hpEtPsXvWyt4RKv2gTe+EgETpF7Udgjann0YniQu5koFrS7m9o1b6zd6ZhpmTfoThQhcsNxRyhVMoVbN3ygspmHTKpgXtPH2CJse+bu9UXy4naLr8vWLA20p5Kz4Zwmq9Nl55Z8yc9JeQ7Z3aSt/ds6ffSUnfuo5eYbf0q0IuykJnp83pW9CQlHrgmnu/OaUvmqdfPP2m9HfG7Enf84VeO8FT1HYXRPbOQPoLjb0zkKKL0i0jpS8cuJb2wNEofTOT7pGrT+/YsLYCXSP9SZg36XuPdRrSL8XUzjpNIbdfFXI1kc30VVXI9UHpa9M7BE3zkrtjmaQkfoSY9OMovaPqUC/racrG+xfzJv24Su/UJv0SmxyUfm21kbtibbGQ2DsDCQfTFHIHT1+T3hmmiIpqFjFGQsgvP5nSXwxr10ayd7RKv9k70zB70i/qpnaMa03pA7Wrcz4iRY29Q15PW8gNoZMU4XGt0h9I3zQdudGXmKWXu2q08sreaR255xMmkb6ZXWNmd5jZcTN72Sl+/lIzu83MbjGzt5vZF+39oZ4FxoXcyr7w4OkX0q+tvof0jqgjd0OF3DRlUzdFNK0nVPplCHxteJQq/X6c3lF15I7Wbjg9diV9S1L5NcC1wNXA883s6m0P+wBwxN2/HHgL8B/2+kDPCnEJIk9/Ze8sVmtXxKD0RfbOUMhdqOyP/CYqSu8wmiKqyumHEPLU0rnm9LVKv9k70zBF6T8NOO7ud7r7SeBNwPXjB7j7O939s/nme4BL9/YwzwLuqYC0MXunLnGsRTaVs3csSJS+r3XkVl9Obu8MhVwTTdkUz97pcbnSL6Ocm72zM6aQ/iXA3aPb9+T7TocXAr9zqh+Y2Y1mdszMjp04cWL6UZ4NvJDGIUAZ2dQo/SGyuRDl9Avpq5R+P8rpqwauWVpPWsgNup2zgtTe0Xv6bfbONOxpIdfMvh04AvzYqX7u7je5+xF3P3L48OG9XPrByKRrOSFR29Mf7B0rpF9Z6S9LoVOU0x9voiIh/WLvCCObwdIoZ6Gnn5rBFG9q6pw+8px+s3emYTHhMfcCl41uX5rvW4OZfS3wCuCr3P2BvTm8c0B54XZJ6deeyT7YO0FUyC2/Pyv9tdx3BQwD1zqxvdN1+AOayKYFy2khYXoniDpy6bH8KVQzhsHTSBKEO2e19M4kTFH67wOuMrMrzOwC4Abg6PgBZvYU4D8D17n7/Xt/mGeBrLzDMIahstJ3cSF3uSrkAtUnbQ5KvwvSQq5qDENR+kF2fqNCrmTg2ibGMKiVfvraSH9n7Er6ngy5FwNvA24H3uzut5rZq83suvywHwMeDvy6mf2JmR09za/ToVxoQdSROzQvFaVfO72T39Q6DemPRysPEz4rIo5y+rKBa1bsHWEhV+jpm3V5aqk6sqnO6UuW27eYYu/g7jcDN2+775Wj7792j4/r3FFmt3Sajtziqy9y4bh66/lgf+RPMr7kEIfqLVeU/kKzMfpqDEOHx5OC9RzrIHinz+lLdoOMYtJ3FsXeEc/Tb57+zphvR+5QyNXM03+wvVO7kJvXW5R0UuX18ptmF0T2R1H6iyBJ76wpfdHAtU3k9FWkv3RnEYqnr0rvpK/N3tkZMyb9daVf+zovLyQV6Q8nVJrPavcFDJFNUSHXI1j22BWFzugbKuQisndSR66ZaGN0Z1TIFe+cJVlt/2LGpJ+VfqeZp7/K6R9aW78WhshmLuTWJv2hI1eVY+97QugIwXRKP5g8pz9Xpb9m74g9/Wbv7IxJnv6+hJeNtUuhU+Ppqwq5qAu5ZbTywmSFXCUp4qScPuJCrqojN6d3ZKSPPr1TZu+0nbN2xoyV/rq9U33gWtQWcss8/ZA9/WXlN5lVZDNvuVd7J7IYsS4rfdHOWZaVvrI5i26epL90sqdvrTnrPMOMST8r4YVonn4p5HbF3qlN+uX8ciG3ur1T3mSynqqs9mPsCV2Qkf5g74S52jtipZ/HMJgt2s5Z5xlmTPqrefOgG7gWRGMYGJS+Zp7KsMlIVza7Fij90GVSrLpUXs+xgCynv5qnr4ls4j1GJyzkOh2kGf7qnbMa6e+I+Xr6Rel3ooFrxd7pRIXcfv38lpWLZUVtd/lNxivvnjV4+p1Y6aPP6Ss7chVK391Z5uYspdJf2TuS5fYtZq/0S2G1+sC1IaevIX36bekdRU7fcmQThkJyLcQ+kWIQkeLawDWpvYPE04/C9E757cneCcS2c9Z5hfkqfV+fTSOzdzptIbeTefqeBlrlwriqkCvzvEshF01Of20MgyTHnnL6CtIvr7XOSLt1yXL66+s3nBozVvrrhVWZvRM0hVzEhVzvHesMkxZydemdjQ5cm1lOv9gryd7pNrBzlmS5fYsZk/5qZynQzd4JItIflP4wOrryR3ZPSpjSWi9Q+oUU0+26z59HpAPX9JuopNk7ikJuHJS+YXRttPJ5hhmTvljpl4Fr3QVr69fCUMg9pMnpe++EYEPfQ3Wl3/dY7sgF6qv9mD7JpJz+HElfqfTT+SyMrPR1gxEW1kh/N8yY9Fc7S0H9efrF3ulE6R369fUknn4w6LLSr2yBlPRO6HSkj6XI5jztnbRftNreQU761uydXTBf0vf1dEtt0niQvVN7LEIh/YXG3hly7KWQW5kY3XMh10T2jmsHrq3P06++nDSyuWbvWIcLR6AFM3pJ48P+xXxJP66PHlYpfZW9Q9+D2ej86uf0QxgVciVKv1sp/dqxzX6+A9fSlEuXpXdW9o42p5/WbPbObpgx6a/n9HUD14RTNruOrmyBJ1H6NuxEprJ38qDG+l2kPt4YXdmRS3VPv6RnzIKkkFuujGBpTVV6B6DD2s5Zu2DGpL9N6dceuFZGKw9Kv/7G6DYifYmn3+mU/njgGtRX+hsbuCYo5JZ59uqc/krpa3L6kCylpvR3xoxJv2ysfQgz6Gtf6IO9c2Fev77St66jG3YGq5/esWDDpi3VlX4euKaKbBIZBq7hXj2SOtg7ncLeKUpfnd7R5vTLmm3g2s6YL+kPG6MHybv/YO90okJu1No7MZIjmzqlP87p1y7EF6VvuQ9BMZ9mmKdf+dpcKX0N6ZcPZQF9ZLOztjH6bpgv6RflGxZ0weoXcsU5fZbr9k7tgWsDKaqUfsnpdyqlvyrkAtUtnrVCbmVOVCv9/kFKX0n6zd7ZDfMnfevogtGLNlGRFXL7pPRDVqa1B67F7YXc6lM2MymaztMvOX1Q2FdKTz93p+fRyip7p9tAc1ZnbZ7+bpgx6Rd7Jyl9nb2jLeQuTLVd4rbIZvWpnrmQOyj9qsutOnJL2qsiMQ4b0hTSr23v5DxNUfrV0zsPmr2jbc5q9s7OOBCkvwgmGcOwsAWmmqe/7GGhK+SW9M5QyK2t9ONqY/Syft0FVwPXgKrjlcekL8nplzlUG0vvNHvnfMJ8SX9cyBWRfrAw2B/VpWlMnrc0p2+jQq5A6asHrpnZsNNazfROUdqpIxfB7J1C+kE8WtmkO2elNWkdubtgvqS/rZCrGK3chY6hm0gV2VTl9PttSl9RyO02qPQrvqltV/p43Te1wdMXd+SWefpqpb/UtQXsS8yf9K3LF0J9pd9ZlyJ41ukKuflNpnpOf5i9U+wdwTx9qdJfdeTCanR1Dax5+rlQXdPXj9s6clWRzTRaeRMduU3p74QZk/6okCvYZ3VQ+nnN+puo5EJu0BRyh9k7g70jmKevVPqjgWtpPRHpD7t5V1tusBqL0q9fyN3m6SsmymUs2sC1XTHf7RLXCrlBp/TzmhKlv1jI7J2k9MNqu0TBxugWOqykd2pHMqJDYJXTFxZyIf99K623ntOv33j24MimUOm3yOaumK/SHxVyg2DyXvQ4Iv2ufiG377EQBntHM08frCs1C00hN5TlKj5/Hh2ctY5cWSFXYO+sPH3txuibiGx2Zoo9afY15kv6cZkUN7AIoXpz1jIuR/aOyNNfrOyd2s1Zw5RNpdLvupHHXvH5K4Qr6shdV/r5ECqen5r0Hzx7R72JSmP9nTCJ9M3sGjO7w8yOm9nLTvHzC83s1/LP32tml+/1gZ4xRqSvGsOgtXeWWLeQjWEo6Z3SnFW2a6y2Xh64JvH044j0g9beWXn6Lb2zF2j2zu7YlfTNrANeA1wLXA0838yu3vawFwKfdPcrgZ8EfnSvD/SMEdP2cJBIXzFPfyB96wSF3Lhm71TP6Wf7Y/BbKqZbYJzTL7dr2jvpq8reUad3BtK10ViLmudX0jtprkWzd84z2G6VfDN7JvAqd/+GfPvlAO7+I6PHvC0/5g/NbAF8DDjsO/zyi554lX/Jz/3UHpxCQ8PeQckXhmOkWGPN1d0cLNL97WM4GQMP2JLgtcrG8MChQ3zmwofwz/7w3XzZpb/P4y65nQc++6hq643xnx7yIv60+zIeH++XrLcJfODrvun97n7kbP//lPTOJcDdo9v3AE8/3WPcfWlmnwIeB3xi/CAzuxG4EeCRV17O5299goaG06JwoNUjqLXl3HEcFfVbHzGMQ+GC+ot5IHzqYSwd/qbbqr7cRSdP8ITPnOSz9z2RCxefo1o0aRu+4uQHsIs6zWL7FNLIprvfBNwEcOTIEb/52u9ULt/Q0CDFP5Sv+I/kK+phvOCc/v+UQu69wGWj25fm+075mGzvPAr4y3M6soaGhoaGPccU0n8fcJWZXWFmFwA3AEe3PeYoUGT7twDv2MnPb2hoaGjYDHa1d7JH/2LgbUAHvM7dbzWzVwPH3P0o8EvAr5jZceD/kd4YGhoaGhrOM0zy9N39ZuDmbfe9cvT954B/vLeH1tDQ0NCw15hvR25DQ0NDw4PQSL+hoaHhAKGRfkNDQ8MBQiP9hoaGhgOEXccwVFvY7NPAHRtZXIOL2daRPDPM+fzmfG7Qzm+/44vd/RFn+583uYnKHecyP+J8h5kda+e3PzHnc4N2fvsdZnbsXP5/s3caGhoaDhAa6Tc0NDQcIGyS9G/a4NoKtPPbv5jzuUE7v/2Oczq/jRVyGxoaGhr0aPZOQ0NDwwFCI/2GhoaGA4SNkP5uG63vJ5jZZWb2TjO7zcxuNbOX5Psfa2a/b2Z/kb8+ZtPHei4ws87MPmBmv51vX2Fm783P4a/lsdv7Emb2aDN7i5n9mZndbmbPnNPzZ2bfl6/ND5rZG83sIfv5+TOz15nZ/Wb2wdF9p3y+LOFn8nneYmZP3dyR747TnNuP5WvzFjP7b2b26NHPXp7P7Q4z+4Ypa8hJf+JG6/sJS+D73f1q4BnAi/L5vAx4u7tfBbw9397PeAlw++j2jwI/6e5XAp8EXriRo9ob/DTwu+7+JcDfI53nLJ4/M7sE+F7giLs/iTQe/Qb29/P3euCabfed7vm6Frgq/7sReK3oGM8Wr+fB5/b7wJPc/cuBPwdeDpB55gbg7+b/83OZX3fEJpT+04Dj7n6nu58E3gRcv4Hj2BO4+0fd/Y/z958mEcYlpHN6Q37YG9jHO7mZ2aXANwK/mG8b8DXAW/JD9u35mdmjgK8k7QmBu590979iRs8fqQnzoXlXu4uAj7KPnz93fzdp344xTvd8XQ/8sie8B3i0mT1Bc6RnjlOdm7v/nrsv8833kHYvhHRub3L3B9z9LuA4iV93xCZI/1QbrV+ygePYc5jZ5cBTgPcCn+fuH80/+hjweRs6rL3ATwH/Foj59uOAvxpdiPv5ObwCOAH8l2xf/aKZPYyZPH/ufi/w48BHSGT/KeD9zOf5Kzjd8zU3vvlu4Hfy92d1bq2Qu0cws4cDvwH8K3f/6/HP8taR+zIba2bfBNzv7u/f9LFUwgJ4KvBad38K8Ddss3L2+fP3GJIivAL4AuBhPNg+mBX28/O1E8zsFSQ7+VfP5fdsgvSnbLS+r2Bmh0iE/6vu/pv57o+Xj5H56/2bOr5zxLOA68zswyQr7mtIHvijs10A+/s5vAe4x93fm2+/hfQmMJfn72uBu9z9hLtvAb9Jek7n8vwVnO75mgXfmNkLgG8Cvm20//hZndsmSH/KRuv7Btnf/iXgdnf/idGPxpvFfyfw39XHthdw95e7+6XufjnpuXqHu38b8E7gW/LD9vP5fQy428y+ON/1XOA2ZvL8kWydZ5jZRflaLec3i+dvhNM9X0eB78gpnmcAnxrZQPsCZnYNyV69zt0/O/rRUeAGM7vQzK4gFav/aNdf6O7yf8DzSFXoDwGv2MQx7OG5PJv0UfIW4E/yv+eRfO+3A38B/E/gsZs+1j041+cAv52//zv5AjsO/Dpw4aaP7xzO68nAsfwc/hbwmDk9f8APAn8GfBD4FeDC/fz8AW8k1Se2SJ/UXni65wswUlrwQ8CfklJMGz+HMzy34yTvvvDLz48e/4p8bncA105Zo41haGhoaDhAaIXchoaGhgOERvoNDQ0NBwiN9BsaGhoOEBrpNzQ0NBwgNNJvaGhoOEBopN/Q0NBwgNBIv6GhoeEA4f8DnvOn/yFtNgkAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Get spectra\n",
+    "l, cl_gg, cov_gg, ind_gg = s.get_ell_cl('cl_00', 'gc', 'gc', return_cov=True, return_ind=True)\n",
+    "# Query windows from indices\n",
+    "bpw = s.get_bandpower_windows(ind_gg)\n",
+    "\n",
+    "# Let's plot them!\n",
+    "plt.figure()\n",
+    "for w in bpw.weight.T:\n",
+    "    plt.plot(bpw.values, w)\n",
+    "plt.xlim([0, 120]);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plotting the data\n",
+    "We can now do stuff with the contents of the SACC file\n",
+    "\n",
+    "Let's plot all power spectra with their error bars."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "for t1, t2 in s.get_tracer_combinations():\n",
+    "    l, cl, cov = s.get_ell_cl(None, t1, t2, return_cov=True)\n",
+    "    err = np.sqrt(np.diag(cov))\n",
+    "    plt.errorbar(l, cl, err, label='%s - %s' % (t1, t2))\n",
+    "plt.loglog()\n",
+    "plt.legend(ncol=2)\n",
+    "plt.xlabel(r'$\\ell$',fontsize=16)\n",
+    "plt.ylabel(r'$C_\\ell$',fontsize=16)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "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.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/CMB_LSS_write.ipynb b/examples/CMB_LSS_write.ipynb
new file mode 100644
index 0000000..b94cb05
--- /dev/null
+++ b/examples/CMB_LSS_write.ipynb
@@ -0,0 +1,538 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# SACC file for CMB and LSS data\n",
+    "This example shows how to use the different functionality in SACC to write data from LSS-like and CMB-like experiments."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sacc\n",
+    "import pyccl as ccl\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate the data\n",
+    "We will first use CCL to generate some data. This will include all the auto- and cross-correlations between a redshift bin with galaxy clustering and cosmic shear, one CMB lensing map and I/Q/U maps in a given frequency channel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup (cosmology, number of bins, number of bands, ell range etc.)\n",
+    "d_ell = 10\n",
+    "n_ell = 100\n",
+    "ells = (np.arange(100) + 0.5) * d_ell\n",
+    "n_ell = len(ells)\n",
+    "# density, shear_E, shear_B, I, Q, U, kappa\n",
+    "n_maps = 3 + 3 + 1\n",
+    "\n",
+    "# Cosmology\n",
+    "cosmo = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.72, n_s=0.96, A_s=2.1e-9)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### LSS power spectra\n",
+    "First we create the galaxy clustering (GC), weak lensing (WL) and CMB lensing tracers with CCL for which we will compute power spectra"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# CCL tracers\n",
+    "z = np.linspace(0., 2., 1000)\n",
+    "nz = z**2 * np.exp(-(z / 0.25)**1.5)\n",
+    "bz = 1 + z\n",
+    "ndens = 10.  # 10 gals per amin^2\n",
+    "\n",
+    "# 3 tracers\n",
+    "gc = ccl.NumberCountsTracer(cosmo, False, (z,nz), (z, bz))\n",
+    "sh = ccl.WeakLensingTracer(cosmo, (z,nz))\n",
+    "ck = ccl.CMBLensingTracer(cosmo, 1100.)\n",
+    "\n",
+    "# Noise power spectra\n",
+    "nl_gc = np.ones(n_ell) / (ndens * (60 * 180 / np.pi)**2)\n",
+    "nl_sh = np.ones(n_ell) * 0.28**2 / (ndens * (60 * 180 / np.pi)**2)\n",
+    "\n",
+    "# Plot N(z)\n",
+    "plt.figure()\n",
+    "plt.plot(z, nz)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Frequency maps\n",
+    "Now we create some information for the frequency map. Let's put it at some low frequency so that it is dominated by synchrotron, and we can ignore its cross-correlation with the LSS tracers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Frequency bandpass\n",
+    "nu = np.linspace(1, 40, 2000)\n",
+    "bpass = np.exp(-((nu - 20.) / 10.)**8)\n",
+    "plt.figure()\n",
+    "plt.plot(nu,bpass)\n",
+    "\n",
+    "# Beam\n",
+    "fwhm = 60.  # 3 arcmin\n",
+    "sigma = (fwhm / 2.355) * np.pi / 180 / 60\n",
+    "ell_beam = np.arange(3000)\n",
+    "beam = np.exp(-ell_beam * (ell_beam + 1) * sigma**2)\n",
+    "plt.figure()\n",
+    "plt.loglog(ell_beam, beam)\n",
+    "plt.ylim([1E-3,1.1])\n",
+    "\n",
+    "# Noise power spectrum\n",
+    "sigma_T = 10.  # 10. uK arcmin\n",
+    "nl_tt = np.ones(n_ell) * (sigma_T * np.pi / 180 / 60) **2\n",
+    "nl_pp = 2 * nl_tt\n",
+    "\n",
+    "# Signal power spectrum\n",
+    "cl_syn_tt = 0.01 * (ells / 80.)**(-2.4)\n",
+    "cl_syn_ee = 0.1 * cl_syn_tt\n",
+    "cl_syn_bb = 0.5 * cl_syn_ee\n",
+    "cl_syn_eb = 0.5 * cl_syn_bb\n",
+    "plt.figure()\n",
+    "plt.plot(ells, cl_syn_tt)\n",
+    "plt.plot(ells, cl_syn_ee)\n",
+    "plt.plot(ells, cl_syn_bb)\n",
+    "plt.plot(ells, nl_tt)\n",
+    "plt.plot(ells, nl_pp)\n",
+    "plt.loglog()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Power spectra\n",
+    "Now let us generate all non-zero power spectra."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9d3DcV3bv+fl1BrqRc85EIAiQIEgwiBIzKZKSqBlJ4xmva6pm7alx2a7d8XON11Nlz7x65TdTtVVbM2+fy89eW+vn91aTpBElkZKYFEiKSQABBoDIOTVy6gY6/e7+8WuABHMA0Gjgfqp+hV/u2wT4Peeee+65ihACiUQikax8dIFugEQikUiWBin4EolEskqQgi+RSCSrBCn4EolEskqQgi+RSCSrBCn4EolEskowBLoBjyI2NlZkZmYGuhkSiUQSVFRVVQ0JIeLuPb8sBV9RlFeAV3Jzc6msrAx0cyQSiSSoUBSl40Hnl2VIRwjxkRDi+xEREYFuikQikawYlqXgSyQSiWThkYIvkUgkq4RlKfiKoryiKMo/j4+PB7opEolEsmJYloIvY/gSiUSy8CxLwZdIJBLJwrMs0zJXK6oq8KoCnyrwqipe351jj0+9c14Vd127c9/ssUGnIyMmlJTIEAx6adMlEonGihT81sEpBiddfoG8I54+VeB5gEh658RU278jsv57HyKw84V4vkg/9t67Pke7R0Vd4KUJjHqF9OhQsmJtZMdZyYq9s8WHmVEUZWE/UCKRLGuWpeDfPfHqWfgvZ5s4VtP7XG3QKWDQ6TDoFfQ6BYNOwaDXYdBpx0a97q7zCnqdds2gU7AYddqzj7tXr/jv0WF8wOcYdAr6u/ZnnzX636s9f+dzZp+b8fjoGHbSNuygbdBB25CDc02DuL3q3PezmvRk+sU/O9ZKVpyVzBgr2bE2IkKNz/VvJ5FIlifKcl7xqry8XDzLTNv6/gmGp9wPFViDTne/YOoVjLo7wqzTrSzvV1UFvePTtA1pBqB10EH7sLbfNeKc17uItprm9QayY61kxmoGIcSkD9yXkEgkT4SiKFVCiPL7zq9EwZc8HW6vSueI028MpuYZBPuEa969yREWsubCQ7Y5Y5AaFYJRjhdIJMuChwn+sgzpSJYWk0FHbryN3HgbkDDv2pTLS7u/VzDXOxhy8GFNLxMz3rn7jHqFoqRwyjKiKM+IpjwzioRwyxJ/E4lE8iikhy95JoQQjDo9tA1N0TrooHlwiurOMa53jeHyjxWkRoWwMSOK8owoNmZEk58Yhn6FhcokkuWI9PAlC4qiKERbTURbo9mYET133u1VqeuboLJ9hGudo1xqGeYD/wC6zWxgQ3okGzOi2JgRxYb0KGxm+ScokSwV8n+bZEExGXSsT4tkfVokoPUEukenqewYoapjlMr2UX55tgkhtEyogsRwyjOj5oxASmSITBeVSBaJZRnSuSst80+ampoC3RzJAjMx46Gmc4zKjlGqOkao7hzD6fYBkBhuYWNGFJuzotmeG0NOnE0aAInkKZFZOpJli9enUt8/SVXH6NzWMzYNQEK4me05sWzLjWV7bgxJESEBbq1EsvyRgi8JKjqHnXzVMsRXzUNcbBlmxOEGIDvOyvacWLbnxrI1O0ZOEpNIHoAUfEnQoqqC+v5JLrYMcaF5iKttIzjdPnQKrEuJ0Lz/nFjKM6OwGOXEMIlECr5kxeD2qlzvHuNC0xAXW4ao7hzDqwpMBh3lGVG8tCaOnfnxrEmQ8X/J6kQKvmTF4nB5udo2wlfNWg+gvn8S0GYFv5Qfx0tr4tmeG0OYRYZ/JKsDKfiSVUPf+DRfNgzyRcMgF5qHmHJ5MegUyjOj2Jkfz878OPITwqT3L1mxBFzwFUXZCfwnoBb4tRDii8c9IwVf8rx4fCpVHaN80TDIFw0Dc95/UoSFl9bEsasgnh15sYSa5JQUycrhuWbaKoryNnAEGBBCFN91/iDwS0AP/IsQ4uePeI0ApgAL0P0UbZdInhmjXseW7Bi2ZMfwf7xcQP/4DF82DvBFwyAnbvTx66+7MBt07MiLZV9RAnsKE4i1mQPdbIlkUXgiD19RlBfRxPrfZwVfURQ90AjsQxPwr4Fvo4n/z+55xfeAISGEqihKAvB/CSH+8HGfKz18yWLi8al83TbCqTo7p+vs9IxNoyhQlh7FvqIE9hUlkBNnC3QzJZKn5rlDOoqiZALH7xL8rcBPhRAH/Md/AyCEuFfs732PCXhHCPHG4z5TCr5kqRBCUNc3wWm/+Nf2TgBa3v++ogQOFSdRkhoh4/6SoGAxiqelAF13HXcDFY9owDeAA0Ak8F8fcd/3ge8DpKenP0fzJJInR1EU1iZHsDY5gv997xp6xqY54xf/fz3fxj992UpqVAiHS5I4vC6JdSlS/CXBx/N4+G8AB4UQf+w//iOgQgjx5wvVOOnhS5YDY043p+rsnLjRx1fNQ3hVQVp0CIfXJXOkJIm1yeFS/CXLisXw8HuAtLuOU/3nnpvnXdNWIllIIkNNvFWexlvlaZr419o5frOP/+d8K//tyxbSo0N5tTSZoxuSyY0PC3RzJZKH8jwevgFt0HYPmtB/DXxHCFG7UI2THr5kOTPqcHOqrp/jfs9fFVCcEs7R9Sm8UposV/ySBIznGrRVFOVXwE4gFrADPxFC/KuiKIeAX6Bl5rwthPj7BWqsLI8sCSoGJmc4fr2PYzU93OgeR6fAtpxYXlufzMHiRDnLV7KkBHzi1bMgPXxJMNIyOMUHNb0cq+6hc8SJxajjwNpEvlmWyvbcWLnMo2TRCSrBlx6+ZCUghKC6a4zfX+vmo+t9jE97SAy3cHRDCm9sTJHxfsmiEVSCP4v08CUrBZfXx9nbA7xb1c2XjYP4VEFpagRvlKfxakmyrOsvWVCCSvClhy9ZyQxMzvBhTS/vVnVT3z+JyaBjf1ECb5an8YIM+UgWgKAS/Fmkhy9ZyQghuNUzwbtVXRyr6WV82kNShIVvlqXyxsZUMmOtgW6iJEiRgi+RLGNcXh9n6gb4XVUX5xoHUQVszormzY2pHFqXhNUsq3lKnpygEnwZ0pGsZvrHZ3jvWjfvVnXTNuTAatJzpCSZtzalUpYeJWf1Sh5LUAn+LNLDl6xmhBBUdozy26+7OHGzD6fbR3aclTc3pvHNshTi5cQuyUOQgi+RBDEOl5cTN/v4XWUXX7ePotcp7FwTx5vlqewuSMBk0AW6iZJlhBR8iWSF0Do4xbtV3bx3rRv7hItoq4nXN6TwZnkqBYnhgW6eZBkQVIIvY/gSyePx+lTONw/xu8ouTtfZ8fgEJakRvClz+1c9QSX4s0gPXyJ5MkYcbo5V9/Dbyq653P6DaxN5szyV7Tmx6GRu/6pCCr5EsgoQQlDbO8HvKu/k9qdEhvDNjam8uTGVtOjQQDdRsgRIwZdIVhkzHh+n6+z8trKLC81DCAFbsqN5qzyNl4uTCDHpA91EySIhBV8iWcX0jk3zXlU3v6vqpnPEic1s4JXSJN7YmEZZeqTM7V9hBJXgy0FbiWRxUFXB1fYRflvZxSc3+5n2+MiJs/JmeRrf2CBz+1cKQSX4s0gPXyJZPKZcXk7c6OV3ld1Udsjc/pWEFHyJRPJQWvy5/b+/K7f/tfXJvLExlbXJEYFunuQpkYIvkUgei9encr5piHerujldZ8ftUylKCueNjam8tj6ZGJs50E2UPAFS8CUSyVMx5nTz4fVe3qvq5nr3OAadwq6CeL5ZlsrugngZ8lnGSMGXSCTPTKN9knerunm/uofBSRdRoUZeKU3mm2WplKRGyCyfZUZQCb7M0pFIliez5Rzeq+rmVJ0dt1clJ87KN8pSObohhZTIkEA3UUKQCf4s0sOXSJYv49MePr7Zx/vXerjaPgJoE7te35DCy+uSCLfIWj6BQgq+RCJZNLpGnLxf3cP71T20DTkwGXTsK0zgtfXJ7MyX8f6lRgp+kKEKFbfPjVt1az9nN/XB+y6fC7fPjUf1AJBoTSQhNIEkWxJhxjAZY5UsCUIIarrG+KCml4+u9zLscBMRYuTQuiSOrk9mU2a0LOS2BEjBfwKEEHhUzzzxnN2/T3j95x5472PE+d53uXwu3Kobj88zt+9VvQv2vUINoSRaE0myJpFoTZzb7j4262W6nWRh8fhULjQNcaymh1O1dqY9PpIjLLxSmsyr65MpSgqXjsgisaoE/73G97g2cO2JvGKP6pm3vxDoFB1mvRmjzohZb8akNz10f27Tzd83680Y9ca5fZPehFHvf073kOf02r1e1Yvdaaff0T9v63P00e/oZ3hm+L42R1uitR6B3wjcaxziQuLQ62SxLcmz4XR7OV1n51h1D+ebhvCqgpw4K6+UJvNKaTI5cbZAN3FFsaoE/+dXf85nnZ/dJ5p3C+YDxfMBwnu3kM577hH3GnSGRfjXWDjcPjd2h10zAM75xmB2m/JMzXtGr+iJD40nyZpEgjXhjlEITSTJlkSSNYkIs5yRKXk8Iw43n9zq48OaXq62jyAEFCWF80ppMkdKkmQJ5wVgVQm+5PmZdE/e1zPod/TPGYh+R/99PaL4kHiKYormbXGhcQH6BpJgoH98hhM3+/joei81XWMAlKZFcmRdEodKkmSa5zMScMFXFEUH/CcgHKgUQvz3xz0jBX/5ogqVkZmROfHvmeqhYaSBuuE6WsdbEWh/V9IISJ6UrhEnJ272cfxGL7d6JgDYkB7J4XVJvLxOiv/T8FyCryjK28ARYEAIUXzX+YPALwE98C9CiJ8/4h2vA0eBYeCEEOLs4z5XCn5w4vQ4qR+pp264jrrhOmqHa2kbb5NGQPLEdAw7OH6jj49v9lHbq4n/+rRIDq1L5OViGfZ5HM8r+C8CU8C/zwq+oih6oBHYB3QDXwPfRhP/n93ziu/5t1EhxD8pivKuEOKNx32uFPyVw91GoHa4lrrhukcagXVx64i2RAe41ZLlQPuQg49v9fHJzX5u9owDUJwSzsvFSRwsTpQDvg/guUM6iqJkAsfvEvytwE+FEAf8x38DIIS4V+xnn/9fALcQ4reKovxGCPGtx32mFPyVzawRmDUA9xqB7IhsyhPK2ZS4ifLEcmJDYgPcYkmg6Rpx8smtPj6+2T8X88+Lt/FycSL71yayNlmmesLiCP4bwEEhxB/7j/8IqBBC/PlDng8F/m/ACdQLIf7hIfd9H/g+QHp6+saOjo4nap9kZeD0OLk9cpvqgWoq7ZVU26txep0AZIZnsjFhI+WJ5ZQnlJNoTQxwayWBpG98mpO3+vnkVj9ft4+gCkiNCuHg2kQOFCdSlh6FfpVO8gq44D9lY2XxNAkAXtVL/Ug9lf2VVNoruWa/xqRnEoBUW+qc+JcnlpNiSwlwayWBYnjKxZnbdk7W2rnQNITbpxJrM7G3MIH9axPYlhOLxbh65pEEPKTzLMiQjuRefKqPxtFGKu2VVPZXUjVQxbhLi+smWZPYlLiJLUlb2Jq8VYaAVimTMx6+aBjkZG0/XzQMMuXyYjXp2Zkfz96ieHbnJxARurILuy2G4BvQBm33AD1og7bfEULULkBjpYcveSJUodI02kSlvZIqexWV/ZWMukYByIvKY1vSNrYmb6UsoYwQg0zrW224vD4utgxzqrafM7cHGJx0YdApbM6KZl9RAnsLE1Zkxs/zZun8CtgJxAJ24CdCiH9VFOUQ8Au0zJy3hRB/v5CNlh6+5GlRhUr9SD2Xei9xqfcS1wau4VE9mHQmyhLK2Jq8lW3J21gTtQadIis4riZUVXC9e4zTdXZO1dlpHtBmkxcmhbOvKIF9hQkUp6yMQd+AT7x6FqTgS56Xae80VfYqLvZe5FLvJZrHmgGtdtCWpC1sT9nO9uTtxITEBLilkqWmbcjBmTo7p+r6qeoYRRWQGG5hT2E8e4sS2JYTg9kQnHH/oBJ8GdKRLBYDzgHN++/TegAjMyMoKBTHFrMjZQc7UndQFFMkvf9VxojDzWf1A5yps3OuaRCn24fVpOfFNXHsLUxgd0E8UVZToJv5xASV4M8iPXzJYqIKldsjtznffZ7zPee5OXgTgSDaEs0LKS+wI3UH25K3EW4KD3RTJUvIjMfHxZYhztwe4OxtO/YJFzoFyjO0uP+ewniyl/lkr6ASfOnhSwLB6MwoX/V+xbnuc3zV8xUT7gn0ip7SuFJ2pu1kV9ouMiMyA91MyRKiqoKbPeOcuW3ndJ2d+n4tJTg7zsq+wgT2FSWwYRnm+weV4M8iPXxJoPCpPm4O3eRc9znOdZ+jYbQBgKyILHam7WR32m7Wxa6TawSsMrpHnZyps3P6tp0rrSN4VUGM1cTuAi3uvyMvllBT4MujS8GXSJ6D3qlevuj6gs+7PqeyvxKv8BJtieal1JfYlbaLrclbsRgsgW6mZAmZ8Of7n6mz83nDAJMzXswGHTvyYtlXlMDuggTiwgKzklxQCf5zh3TqP4ahRjBZwWQDU+idfWPo/PNGK+jkAJ3kyZlwT/BVz1d83vk553vOM+WZIsQQwo6UHezL2MeLqS8Salx5ud2Sh+PxqVxtG+F0nRb66RmbRlGgLD2K/UVa6Gcp4/5BJfizPLOH/+734NZ7T36/MfQeQ2D1Gwn//r1G4mHG4+7nDSHSkKwCPD4PX9u/5mzHWc52nmV4Zhiz3sy25G3sy9jHS2kvyUHfVYYQgrq+iTnxny3vnBtvY39RAgfWJrIuJWJRF3NfXYKvquCdBrcD3FPgdt7Z99y173b4r/n35117wDMe59O1w2h9RuPxoGdm90NgBUwMWYn4VB/VA9Wc6TzDmY4z2J12DDoDW5O2cjDrILvSdhFmCgt0MyVLTPeoU5vsVWvnavsIPlWQGG7hwFpN/DdnRWPQL6xzuLoEf7FQ1flG4XEG4rEGx7/vnX6KRih+g3CPIbjbeITGQOI6SN4AMbkgBxaXHFWo3Bq6xemO05xqP0WvoxeTzsQLKS/wctbLMuyzShlzujl7e4BPa/s53zTIjEclMtTI3sIEDq5N5IW8hSnyFlSCv+rSMlXfPUbirs3zgHOPNDgOcAzeMSJGKySVQvJ6zQAkrfcbARluWiqEENwYusGnbZ9ysv0kg9ODhBhCeCn1JQ5nH2Z78naM+pVdzEtyP063l3ONg5ystXPmtp3JGa3I266CeF4uTmJXQdwzZ/wEleDPsuw8/GBB9WmD1r3V0Fuj/ey/eccImGyaEUjyG4Hk9RCdI43AEuBTfVwbuManbZ9yquMUY64xIswRHMw8yOHsw6yPW78iarlIng63V+VS6zCf3urjVK2dYYebX/3JFrbmPFvJDyn4qx2f944R6LvbCMxo101h9/cEorOlEVhEPKqHiz0XOdF6gs+7PmfGN0OKLYVDWYd4NedVOclrleJTBV+3j7ApM/qZJ3RJwZfcj88Lg/V+A+A3AvZbd4yAOfyOEZjtDURny0HjRcDhcXC28ywnWk9wue8yqlApiSvhtZzXOJB5gAhzRKCbKAkipOBLngyfRzMCswagrwb6b4HPpV03R0DybDjIbwSisqQRWEAGnAOcaD3Bhy0f0jzWjFFnZGfaTo7mHmVb8jYMusDP5JQsb4JK8FfdoO1yx+eBgdvzw0H2WvC5teuWCM0AZGyDrJcgtRzkIORzI4Tg9shtPmr5iBOtJxh1jRIbEsuR7CO8lvMauVG5gW6iZJkSVII/i/TwlzFeNwzevjMw3FOljQkgtMygzO2a+Ge/BPFr5VjAc+LxeTjXc44Pmj/gfPd5vMJLcUwxR3OP8nL2y3Jyl2QeUvAli49zBNovQNuX0PolDPt7Z6ExkPXiHQMgQ0DPxfD0MCdaT3Cs5RhNo02Y9WZ2p+/maO5RtiRtkbX8JVLwJQuPqvpwOZ24pqZwOR143W5Unxefz4fq9eKbGEDtu4naV4tvoB51egKfUFAt0fiislEjMvGFp6HqLfi8XlSfV3vO6wNAp9eh0+vR6Q3aT50OncGATqf3n9c2RadHb5j9acBosWCyhGAKCfH/DMXo39cbVk78WwhB3Ugdx5qOcaLtBJPuSZKsSbyW+xpHc4+SYksJdBMlAUIKvuSB+LweZqammHFM4XI4cDm0/dlj7ecUM1P+n07H3LF7+ilLTTwEnSLQ6XXoDSZ0RrMmyoqC6vOhqiqq14uq+hA+Hz6fD57jb1ZvMGAMCZ0zCBarjZCwcELCwwkNj/DvR2hbmP9ceAQG4/Iek3D5XHzW+RnHmo9xqfcSAkFFUgWv577OnvQ9spLnKkMK/gpHCMHM1CQTgwNMjQ7fEehZ8Z6aL9az4u11uR75XoPZjMVqw2K1YbZaMfv3tWMbFv85s9WGwWRC7/fI9QaD5o3rNa/7vnM6HbrBWnQd51HazkHnZW1imKLXMn9ydkPefkgpu680hFBVVNWnGYR7Np/Xi2dmGvf0NO65n0480/591wzu6Wk8007cM9PMOKaYnpjAOTHOzOQkQqgP/Hew2MIIi47BFh2DLSYWW1QMYTGx2KJjCIuOITwuHlPI8iiV0DfVxwctH3Cs+Rg9Uz2EGcM4lH2I13NfpyimSE7sWgUEleDLLJ37EULgHB9jYnCAiaEBxgfsTAwNMjFo958bxDPz4Jo8ppBQLDYb5lDrHaG2+X+GWjHb7hHx2XttNvSGJfJsvS7ounon/t9TCULV4v+5+2DNfsjZAyGRi9YEoarMOKZwTowzPTnB9MS4ZgzGx5gaHWFqdJjJ4SGmRoZxjo/d93xIWDgRCYlExCcSmZBIeFwCkQmJRCYmERYdi7LEA9eqUKnsr+T3zb/nTMcZXD4XeVF5vJ77OkeyjxBliVrS9kiWjqAS/FlWk4cvVJWpsREmBjRBnxjUtvFBTdgnBwfwetzznjFbrYTHJRAeG09EXDzhcfGEx8Zji4nBYgvTBDzUik4fhMXTnCPQ8hk0noTm0zA9qnn/6Vs0z3/NAYgrCNjgr8/rwTE6yuTwEJMjQ9rvaqCf8QE74/Z+JoYGUH2+ufsNJjNRySlEJ6UQnZJKVHIq0cmpRKekYjQt/iIZE+4JPm37lPeb3ufW8C0MOgO70nbJ3P4VihT8AKP6fEwOD90n5pNDA4wPDjA5NITq8857JiQsXBP0uLg7wh6viXp4XDzmUGuAvs0So/qguxKaTkLjKbDf1M5HpGuef94ByNqhlY5eJsz+vscH+hnt62W0r5uRnm5G+nqYGBiYCx0pio7IxCRi0zOITfNv6VlEJSYtWo+gcbSR95ven8vtjw+J59XcVzmae5SM8IxF+UzJ0iIFf5HxejxMDg/OifnE0AAT/rDL+KCdqZFhhDo/PmyNiiY81i/mcX4vPTbeL+5xGC1yoO2BjPdA0yloOg2tX2gVRQ0WLfVzzQHIPwThyYFu5UPxut2M9fcy3NPNcHcHQ50dDHW1M9rfNzcgbTRbiMvIIj4rh/isbOIzc4hNy1jQLCOPz8OX3V/yfvP7XOi5gCpUyuLLeD3vdfZn7Jflm4MYKfjPicc144+Zz3rod8R8cnCAqbHRedkjiqLD5h/MmxXzsNi79mPiMJhMAfxGKwSvS8v9bzqlhX9G27TzqZug4AgUvgIxOYFt4xPicc0w0tPNQEcrg+1tDLS3MNDeNjc2ozcaic/IJiEnj8ScPBJz1xCdlLIgPYEB5wAftXzEseZjtE+0E2oI5UDmAV7Pe11W8AxCpOA/Bve00x9mmR9DnxX2ewfpdHo9YbFxmkfuF/I5Lz0uHlt07IrK+Q4KhNAqgt7+COqPa7OAAeKLNOEvOKItDBNE4iVUlTF7H/a2FvpbmrC3NGFvbcbj0grcma1WkvIKSMrNJ3lNAUl5BZhDn90zF0JQPVDNseZjfNr+KdPeaTLDMzmae5RXcl4hPjR+ob6aZBFZ1YIvhMDlcPgHQAfuGhi1MzE4yMTQADNTk/Oe0RuN84R8dmA0LC6eiLgErFFR6ORKUsubsU6oPwG3j0PnRS3rJzJDE//CVyB1c1CWfFBVHyM93fQ1N9DXWE9fUwND3Z0gBIqiIzYjk5T8QlLyi0gpXEtYdOwzfY7T4+Rk+0mONR/j2sA1dIqOF1Je4GjuUXam7pSLtixjVpXgN16+QFfdrTnvfGLQjnt6fsqi0WyZJ+bzhD0+gdDwiCVPo5MsIo4haPhYE//Wz7XCb9Z4KDwCxd+E9K1BvRSky+mgr7mR3oY6eurr6GtqmOsFRCYkkVK4lrSidaQVrSM87um99Pbxdo41H+Ojlo8YmB4gyhzF4ezDHM09Sn50/kJ/HclzEnDBVxRlB/CHgAEoEkJse9wzzyr4J//bL2m6clEbEI1PuCfkkkBYbBwhYeEyLrlamZnQUj3rPtRi/x4n2BJh7etQ/A0t/h/kfxuqz8dAeyvdt2/RfbuWnvrauV5sRHwCaWtLSF9bQlpxKbao6Cd+r1f1cqn3Eu83v88XXV/gUT0URhdyNPcoh7MPy7r9y4TnEnxFUd4GjgADQojiu84fBH4J6IF/EUL8/AnedRRIEEL80+PufVbB93m9Mn4ueTLcDm2w99Z7WtaPz6Wle649qol/0vqgF3/QxgKGujroqrtJV+0NuutuMeOYAiAmNZ304lIyStaTVrTuiWcMj82McaLtBB80f8DtkdsYdUZ2pe3itdzXZG5/gHlewX8RmAL+fVbwFUXRA43APqAb+Br4Npr4/+yeV3xPCDHgf+63wP8qhJjkMSynLB3JKmBmQgv73Po9tJwF1aut8LX2G1DyFsStnNCFqvoYbG+j42YNnbeu01Nfh9ftQqfXk5SXT0bJBjJLy0jIzn2isaqGkQaONR+bl9t/JEer258dmb0E30hyN88d0lEUJRM4fpfgbwV+KoQ44D/+GwAhxL1if/c70oG/FUL8yZN8phR8ScBwjmiZPrfeg7Zz2oBvUimsewvWvQFhiYFu4YLi9XjobbhNx81qOm7UYG9rBiGw2MLIWLeezPUbySwte2z4Zza3/4PmDzjfcx6f8FESW8KrOa9yMOugDPksEYsh+G8AB4UQf+w//iOgQgjx5494x38ETgohLj7inu8D3wdIT0/f2NHR8UTtk0gWjakBzeu/8RvovQaKTqvtX/ItbdDXHBboFi44zolxOm/W0H79Gu3Xr+EYGwUgLjObrPUbydpQTnJewYeJMdMAACAASURBVCPLdgxND2l1+5uP0TzWjElnYmfaThnyWQKWheA/RWNl8TTJ8mSoCW78VhP/sQ4whEDBISj5A63Cp37liZgQgsGONtpqqmivqaKnoQ6hqlisNjJKy8gp20Tm+o2EhD141a3ZpRo/bPmQE60nGHONEWOJ4VD2IV7NeZWC6IIl/kYrn2UR0nlaZEhHsmwRQqvuefO3mvc/PaKleZa8BaXfhsTix78jSJlxTNFxo4a26kraaipxjo+hKDqS1hSQs3Ez2WWbiElNf2AWnMfn4XzPeT5s+ZAvu7/Eq3rJi8rjlexXOJx9WE7sWiAWQ/ANaIO2e4AetEHb7wghahegsdLDlwQPXreW3nn9V1rGj+qBhHWw/tuw7k2wrVwRE6qKvbWZlmtf01p1lYH2FgAiEhLJ2VhBzsYKUgvXPjD0MzYzxqftn/JR60fcGLyBgkJFUgWv5LzCnvQ9WI2rpDjgIvC8WTq/AnYCsYAd+IkQ4l8VRTkE/AItM+dtIcTfL2SjpYcvCTocw9pA7/Vf+eP9esjdC+u/A/kvg2HxSyEHksnhIVqvXaWl6iqdt67j83iwWG1klW0id9MWMkvLMFnur2raPt7O8dbjHG89Ts9UDxa9hV3puziSfYStyVsx6uSs3qch4BOvngbp4UtWBAP1mvDf+C1M9oIlUsvwWf8dSC5bEfn9j8I9M03HjWpaKq/QUnWVmalJ9EYjGevWk7t5KzkbKwgNn5+1I4SgZrCGE60n+LT9U8Zd40SZo9ifuZ8j2UcojSuVEyafgKAS/Fmkhy9ZEag+rYxzzTtaqqd3Rlu8pfTbWqZPeFKgW7joqD4fPQ11NF+9RNPXl5gcGkRRdKQWFZO3eSu5m7feV/PH4/NwoecCJ9pO8EXXF7h8LlJsKRzKOsShrEPkRuUG6Nssf6TgSyTLgZlxqH1fE/+uK1qKZ84ef8jnEBhX/hoIQggG2lpo/voSjVcuMtLTBUDymkLWbNlOXsV2wmPj5j0z5Z7is67PONF6gst9l1GFSl5UHoeyDnEw8yCpYamB+CrLlqASfBnSkawKhpq1kM/1X8FED1gioPgNWP+H2uLtqyR0MdzdRdOVr2i8epHB9lYAkvLyyd+6gzVbXiAsZr7nPzQ9xKn2U3zS9gk1gzUAlMSV8HLmy+zP3C8zfQgywZ9FeviSVYHq02bz1ryj1fL3TkPsGs3rL/nWsl69a6EZ7e+l8dIFGi9/NZfxk5xfRME2TfytkfMXXu+Z6uHTtk/5pO0TGkYbUFDYmLCRg5kH2Zuxl5iQmEB8jYAjBV8iCQZmJqDumCb+nZe0kE/2Lk38Cw4vq3V7F5vRvh4aLl2g4eI5hro6UBQdacUlFG5/ibyKbfet6dw63srJtpN80v4JbeNt6BQdmxM3cyDzAHvS9xBliXrIJ608gkrwZUhHIgGGW/whn1/DeBeYI7Qqnuv/ENI2r5qQD8BQVwcNF89x+6svGbf3ozcaySnbTOGOXWRt2IjecCdtUwhB42gjJ9tPcrL9JJ2TnegVPRVJFRzIPMDutN1EWiID+G0Wn6AS/Fmkhy+RAKoK7ec18a/7QKvfH52jZfmUfgsi0wPdwiVDCEF/cyO3L3xB/cVzTE+MYwkLp2DbDope3E1izpp5aZtCCOpH6vm0/VNOtZ+ie6obg2Jgc9Jm9mfsZ3f67hXp+UvBl0hWAq4puP2hFvJpP6+dy9yhiX/Ra2C2BbZ9S4jP66XjZjV1X35GS+UVvB430cmprN25l6Idu7BFz4/fz9b0OdV+ipPtJ+me6kav6NmUuIl9GfvYk75nxcT8peBLJCuN0Q5tUtf1d2CkFYyhUPgqlP4BZL0Y1Es2Pi0up4OGSxeoO3eWnvo6FEVH5voyinftI2fj5nkhH7gj/qc7TnO64zQdEx3oFB0bEzayN30vezP2BnW2T1AJvozhSyRPwWwht+vvwK33wTUOYcl3CrnFr65qlKN9PdR+eZbaL84wNTpCSHgERS/uZt3u/cSkpN13/2zMf1b8W8dbUVAojStlb8Ze9mXsI9kWXJlSQSX4s0gPXyJ5Sjwz2qpd138NzWdA+LRlGku/rS3Wbot7/DtWCKrqo+N6NTc/O0VL1RVUn4+UgiJK9hwkb8t2jKYH1zVqHWudE/+G0QYAimKK5jz/rIispfwaz4QUfIlktTE1ADff1QZ7+2/cKeRW+gdaIbdVlOLpGBul9suz3PzsJGP9fVisNope2kPJ3oMP9Ppn6Zro4kznGc50nOHG0A0AciJy2JuhiX9+VP6yrO0jBV8iWc3Y6+DGr+HG77RCbuZwbZC35FuQsR10ukC3cEkQQtBVe5PrZz6h+eolVJ+XtKJ1lO4/RO6mLffF+u+m39HP2c6znOk4w7WBa6hCJdWWyt6MvexJ30NJXAk6ZXn8OwaV4MsYvkSySKg+f4rnb7RsH/cUhKdqVTxLvgUJRYFu4ZLhGBvl1uenuXH2JBODdkIjIinZc4B1ew7eV8vnXoanh/m863POdJ7hSt8VvKqX+JB4dqXvYl/GPjYmbAzoEo5BJfizSA9fIllE3E4t3n/jN9B8Vov3JxRri7asewMiVkdBMqGqtF2v4vqpj2mtrkRBIad8M+sPHCG9+PHlmCfdk3zZ/SVnO85yoecCM74ZIs2R7Ezbyd70vWxJ3oJZv7TrIEjBl0gkD2dqUKvieeM30FMJKFqop+RNLdUzNDrQLVwSxgfsXD/zCTc/O8XM5ATRyamsP3CYohf3YA4NfezzTo+Ti70XOd1xmnPd55jyTGE1Wnkx5UX2ZOxhR8oOQo2Pf8/zsqoE//P/r562mkHMoUbMoQZtCzHMHZtCDVhCjZhCDJit91wLMaDTLb9BGIlkyRhu0VbtuvFbGG4CnVEb7F33hjbYa1r5Sw963W4aLp2n5tQJ+psbMVpCKHpxNxsOHCYm9clmNnt8Hi73XeZs51k+6/yMUdcoZr2Z7cnb2Zuxl5fSXiLc9OCF35+XVSX4DZf76GsZx+X04pr24nJ47uw7vQj10d/ZFOI3AncZA9MDDIe2GefdazCtnskukhWOENBXo2X63Pq9NthrDNVEv/gNyN2z4pdsBOhvbqT65HEaLp3H5/GQXlzK+oNHyNm4Gd0TTm7zql6qB6o53XGas51nGXAOYNAZ2JK0hX0Z+9iVtmtBSzysKsF/FEIIPC4fLqcX97QXl9NvDOa2+cZh9tg97WXG6cXr8j3y/XqDzt+D0HoL842DAXOI8S5DMv+6yWJAkb0LyXJEVaHzoib+dR/A9IhWzK3wFSh+HbJeAv3KXnfWOTHOzbMnuX76EyaHBwmPi6d03yGKd+27b6nGR6EKlRuDNzjbeZbTHafpmepBr+gpTyxnf8b+BSnxIAV/gfD5VNz3GojpBxgLh3Y8ayjc/vOP7F0oYA6ZNRT39CBC5xsIU4gBi9U4716DUfYuJEuAz6Mt2Xjr99qSja4JCInW0jzXvg6ZL6zosg6qz0dL5RWqP/2IrrqbGIwm8re/yIaDr5CQlfNU73pUiYcfbfoRBdHPNks6qAR/paZl3t27mGcg7jEc7vsMiXbsdauPfL/eqMMcYiAk3ERcqo24jDDi0sKITQvDaF65/wElAcQzo83orf09NHyiVfK0xmkDvWtfh4xtK1r8hzrbqTl1gtpzn+F1uUjOL2LDgcPkVWxHb3i6tMy7Szyc6TjDP+79R5Jsz7becVAJ/izL0cMPJD6v+mjj4NB6EVOjMwx2TjI96QG0sumRCaHEZYQRnx5OXLqN2LQwTJbA5QlLViBuJzSd0rJ9mk75xT9eC/usPeqf4LUyxX/GMUXtF2eoOXmCMXsftqhoSva9TMmeg/et0rUUSMFfZQghcIy5GeyaZLBjgsGuKQY7JnCMu7UbFIiMDyUuXesFaL0BG+bQlR2HlSwRbgc0ntRW72o8pS3baI2DgiNa6CdzB+hXnsMhVJW2miqqP/2I9uvX0BsM5G/dwYaXXyUxJ2/J2iEFXwKAY9zFYOckQ12TDHRMMtg1ydSIa+56eFwIcWlhxPvDQXHpYVhs0ghIngO3A5pOa4O9jSfB49Bi/gWHoPA1yH5pRWb7jPR2U/3pcWq/PItnZpqkNQWUvfwqeZu3PXW452mRgi95KNOT/p5A551tYmhm7npYtGVuPEALC4UREmYKYIslQYtnWpvVW/cBNH6qDfiaw2HNQSh6FXL2gGnxJyYtJS6ng9ovzlB98jhj/X3YomNYv/8w6/YceKrsnqdhVQn+dE0NvvFxDElJGJOT0dtWzypAC8WMw3OfERgfmJ67bosya+GguzZrxMrz0iSLiNcFrV/C7Q+g/gRMj4IhRMvvL3wV1hyAkJWz9qxQVVqrK7n2yYd03qzBYDRR9OJuyg69+sSTuZ6UVSX4PX/5H5j4+OO5Y11YGMbkZIxJSRiTkzRDkJSMMTkJY1IShvh4FP3KHExaSFzTXobuMQKjdif4/4TC40JIzY8iNT+KlPwoQsNlL0DyhPi80PGVVtCt/gRM9oHOoK3cVfgK5B+GsIRAt3LBGOrq4NonH3L73Od4PW4yS8vYeOg1MkrLFqTc8qoSfO/QEO6uLrx9fXh6e/H09uHpu7Op4+PzH9DrMSYkYEj2GwK/YTD6ewiGpGT0tpU/nfxZcM94GeqeYqB9gt6mMXoax3BPewGITraSMmsA1kTKAWHJk6Gq0FPlF//j2vKNKJC2WRv0LTgMMU+X775ccU6Mc+P0J9Sc/hjH6AgxqelsPHyUwhd2YjA9u8MUcMFXFCUd+C/ACNAohPj5455ZrBi+b8qBt/9eY9CLd3bfbgevd94zuvBwzQDMGoPk5Hk9BUNcnOwlAKoqGOqapLt+lJ6GUXqbx/C6VRQF4tLD5gxAUm6knBsgeTxCwMBtTfhvf6Qt5AIQX6QJf8FhbUWvZbgIydPg83qo/+ocVSeOMdjRRmhEJK/+5Y9JKXi2ctXPJfiKorwNHAEGhBDFd50/CPwS0AP/8igRVxTlMBAlhPifiqL8Rgjxrcd9bqAGbYXPh3dw0G8Mev09hcf0EgwGjPHxWi8hOfm+nsJq7SX4vCr29gl6Gkbprh+lv20c1SvQ6RQSssPnDEBiVgR64/JYPEKyjBnt0Eo63z6ulXoQKkSkQf4hTfwztgV1iQchBJ23rlNz8gQHfvC/YXnG8cfnFfwXgSng32cFX1EUPdAI7AO6ga+Bb6OJ/8/uecX3AB/wLlrE938IIf7fx33ucs7S8U1NaYZgnjHw9xJ6e7Vegm9+3R1dePidsYR7xxNSkjHExq74XoLH7aO/ZZzu+lG6G0YZ7JhACG2WcFJOxJwBiM8IQ6eXBkDyCBzDWqZP/XFo+Qy8M2CJ1AZ7Cw5rGT/m1Zmw8dwhHUVRMoHjdwn+VuCnQogD/uO/ARBC3Cv2s8//FXBVCHFOUZR3hRBvPOS+7wPfB0hPT9/Y0dHxRO1bbjy0l9Dbe6eXMDEx/yGDAWNCgtYjuHs8IeWOkdBZV1YvwTXt1WL/fgMw3DMFaBVL04uiySiOIX1tjBwAljwat0MT/fqPofETf8aPBbJ3aeKf/zJYYwPdyiVjMQT/DeCgEOKP/cd/BFQIIf78Ic8XAz8FhoApIcRfPe4zl7OHvxDc10uYMwb+nsKDegkREXd6CHcZg9kU1GDvJUxPuulpHKOzbpiOW8M4/TOD4zPCyCiOIaM4lviMMFlVVPJwfF4t3FN/QjMA452g6CBty524f3RWoFu5qARc8J+ysSuyeNrTcm8vwdN7/3jCg3oJppQUQtavJ6SsjNCyDZhyclCCcJFqIQRDXVN03NLE3942jhAQEmYkvSiGjOIY0oqisViDN2YrWWSE0AZ6609om/2Wdj5+7V2DvqVBP+h7LwEP6TwLK93DXwjmegmzvYPePlytLUxX1+AbHga0sYOQ9aWElpURsqGMkJJ16EJCAtzyp2dmykPn7WE6bg7TWTvCjMODokBiToTf+48hJsW2IHnMkhXKaLvm9dcfh85L/kHfdE34C49ovYAVUONnMQTfgDZouwfoQRu0/Y4QonYBGis9/OdECIGnsxPntWqmr11juqYaV1OzdtFgwFJYSMiG9XNGwJgQH9gGPyWqKhhon5jz/gc7JwGwRprJLIkluzSWlPwo9Ibg69lIlgjHkFbSuf44tHwOPheExmjx/sJXtUVdjJZAt/KZeN4snV8BO4FYwA78RAjxr4qiHAJ+gZaZ87YQ4u8XstHSw19YfOPjTNfU3DECN28iZrSaOcaUFEI2bCCkbAOhZWWY8/KCaizAMe6is3aY9pvDdNYO43WrmCx60otjyC6NI704BnNI8HtukkXCNaXV9a8/rhV4c02AyQZ5+7WZvnn7wBwW6FY+MQGfePU0SA9/aRAeDzP19UxfuzZnBLyDgwDobDZCSks1A7BhA5aS0qCZR+B1++iuH6Xt+iBtN4aYnvSg0yuk5EeRXRpLZkkctihZ90fyELwuaDunTfRq+Bgcg6A3Q85urcDbmoMQGh3oVj6SoBL8WaSHv7QIIfD09GgGoLqa6WvVuBobtYEvnQ5zQT6hG8rmjIAxOTnQTX4sqiqwt03QVjNI6/XBuQJw8RlhZJXGkb0+jujk4DBkkgCg+qDzsib+tz+Cie47NX6KXtNKPSzDdE8p+JJnwjc5yXTNdaar/b2AGzcQTicAhsREQss2aAPBZRuwFBQs6zCQEILRfqfm+V8fwt6mZThFJYaSUxZPTlk8MSlWOegreTBCQO81qPtQK+882qale2a+AEVHtdCPbXmMhQWV4MuQzvJFeL3MNDQwfa16zgh4+/sBrSpp6ObNWCsqsG7dgik3d1mLp2PMRWvNIC3XBuhtGkMIiIgPIacsntyyeGLTZMaP5CEIAf03NeGv+wCGmzTxz9iureVb+CrY4gLWvKAS/Fmkhx8cePr6cFZdw3nlCo7Ll/F0dQGgj4nBWlFB6JYKrFu3YkxNXbYC6pxwz4l/T+MYQhWEx1rI2aB5/vGZYcu27ZIAIwQM1Glr+dYeuyP+mTug+Bua+C9xzF8KvmTJcHf3aOJ/5TLOS5fnBoKNycmEbtmCdUsFoRVblm0q6PSUm7brQ7RcG6D79iiqKgiLsZBXHk9ueQKxqdLzlzwEIcBe6xf/92GkRYv5Z++C4m9q+f6W8EVvRlAJvgzprByEELjb2nBc1sTfcfXqXKVRU3b2nPiHbt6EISoqwK29nxmHh7brQzRX2em6PYpQBZEJoeSWx5O3MUEO+Eoezuws31vvwa33tRIPejOs2Q/r3oS8A4uW5x9Ugj+L9PBXHkJVcdXX47h8BcflSzgrq7RBYEXBXFiAtcLfAygvX3aF4qan3LRWD9JUaaencQwExKRYyd2YQN6mBCLigm/2smSJEAK6v/aL/+/BMaCt5Vv4iib+WS+CbuESHqTgS5YlwuNh+uYtnFcu47h0menqaoTHAwYDIetLsW7bhnXrVkLWrUMxLJ+JU45xFy3XBmiuHKCvReuxJGSFs2ZzArkbE2R1T8nD8Xmh/RzcfFdL9XRNgC0R1r0BJW9BYslz1/YJKsGXIZ3Vizozw/S1azguXcZx8SIzdXUgBDqbjdCKCqzbtmLdtg1TZuayiaNPjszQ9LWdxqt2hnumUHQKaQVRrNmcQNb6OEyW5WOoJMsMz7RW0//G76DpFKgeiCuE0j+A9X/4zJk+QSX4s0gPX+IdHdUGgL+6iOPiRTw9PQAYkpLmxN+6dSuG6OUx83G4Z4rGr+00XbUzOTKDwagjszSW/IpE0oqi0ctFXSQPwzkCtb+H67/Wwj9//BmkbnymV0nBlwQ9Qgg8XV04Ll7UDMCVK3Ploc2FhVi3agYgtHwjOktgi14JVdDfOk7jVTvNVQPMODyEhBnJLU8gf3OiTPOUPJqRNojKfObQjhR8yYpD+HzM1NZqBuDiJZzV1eDxoJhMhGwsw7p1G9Zt27AUFQZ0PQCfV6WzdpiGK3babwzh86pEJoSyZnMC+RWJhMfKwV7JwiIFX7LiUZ1OnJWVOC5ewnHxolYHCNBHRmr5/9u2Yt22HVNqSsDa6Jr20nJtgMYr/VqmD5CUG0HBliRyyuIwh8rFXCTPT1AJvhy0lSwE3sFBHJcvz8X/vQMDABgz0ufCP9aKCvQREQFp3+TIDI1X+2m43M9ovxO9QUdmSSwFWxJJWyvj/ZJnJ6gEfxbp4UsWCiEE7tbWOfF3Xr2K6nSCTodl7VqsW7Zg3bqFkLKyJY//CyEY6Jik4Uo/TV/bmZnS4v1rNiWSvyVR1vSRPDVS8CWSuxAeD9PXr2vpn5cvM339Oni9Wvx/wwatB7B1C5a1a5c0/38u3n+5n7abQ6heQXSylfwtieRvTsQaKev4Sx7PihF8j8dDd3c3M/6VmiTBg8ViITU1FaNx+cWpVYdDi//7DYCrvh7QFoLRKoBuJrSiAvOaNUs2ADzj8NBcNUDD5T76WydQFEgtjKZgSyJZ6+MwmpZvKWpJYFkxgt/W1kZYWBgxMTGymxtECCEYHh5mcnKSrKysQDfnsXhHRnBevjxnAOYqgEZEELp5E6GbKwit2Iw5N3dJDMCY3UnDFS3ePzkyg9GsJ2djPAUViSTnRaLo5P8FyR1WjODfvn2bgoICKfZBiBCC+vp6CgsLA92Up8bT24vj6lWcV67ivHp1bgKYPiqK0M2bCS0vJ3RT+aKvBSxUQV/LGPWX+mm+NoBnxoct2kz+Zi3eH5W4vOoPSQLDihL8YBQMicZK+f25u3twXr2qzQK+ehVvXx+gLQITUraB0I3lhJaXE1K8FsW0OHV1PG4fbdcHabjcT1fdCEJoSzfmb0kib1M8ITZZz2e1ElSC/6i0zJUiGKuVlfr78/T04KysxFlZhbOqCndrKwCK2UzIunWEbNjg39YvShlox7iLxqt2Gq70M9w9hU6nkF4cQ35FIpklMRiMMt6/mggqwZ9luXr4drudH/7wh1y+fJmoqChMJhM/+tGPeP3117l69So/+tGP6OnpISwsjKSkJH7+85+zbt26gLZ5obDZbExNTc0799Of/hSbzcZf/dVfPfb55fD7Wwq8IyM4q6qYrqzEWV2jFYHzegEwZWRo4r9+PSGlJVoYaAEzgYa6p2i40k/j1X6c427MoQZyyuLJr0gkKSdCxvtXAQ8TfFnG7ykRQnD06FG++93v8s477wDQ0dHBhx9+iN1u56233uKdd95h27ZtAFy4cIGWlpYVI/iSJ8MQHU34vn2E79sHaFVAZ27dYrqmBmd1DVPnzjF+7BgAisWCZe1arSdQWoJl3TqMKSnPPE4Vm2ojNjWXra/n0FM/Sv2VPhqv9lN3oZewGAv5FYms2Zwg4/2rECn4T8lnn32GyWTiBz/4wdy5jIwM/uIv/oK//du/5bvf/e6c2AO88MILgWimZJmhs1i0gd3ycmK4Uwhu+sZNpm9cZ+bGTUbfeYeRf/s3QMsGsqxdi6W4WDMGxWsxJCc/lRHQ6RTSiqJJK4rG/W0vbTWDNFy1U/VJO5UftxOfEcaaikTyymX9/tVCUAv+f/yolrreiQV9Z1FyOD95Ze1Dr9fW1lJWVvbQa9/97ncXtD0Po/8//2dct+sX9J3mwgISf/zjBX2n5MEoioIpPR1TejoRRw4DINxuZhqbmLl5g+naWmZq6xh+++25UJAuIgJLQQGWwkIshQWYCwoxZ2U+0aCwyWIgf0sS+VuS5uL9jVf7ufDbJr56t5m0wmjyKxLIKo3DaJbx/pVKUAv+cuDP/uzPuHDhAiaTibS0tHnXKioqmJiYYP/+/fzyl78MUAslwYJiMhFSrHnzs8O6qsuFq6GBmdpaZm7XM3P7NqO/+hXC5dJuMBoxZ2djzl+DJT8fc14e5rw8DImJD+0NWCPMbNiXzoZ96Qz3Ts2J/+m3hzGY9WSXxrJmcyJphVHoZD2fFUVQC/6jPPHFYu3atbz33ntzx//wD//A0NAQ5eXlHDx4kGvXrvHaa68BcOXKFd59912OHz++4O2QnvjqQGc2E1JSQkhJydw54fXibm9n5vZtXI2NzDQ04LxylYkPP7rznM2GOTcXU24O5pxczDnZmLJzMCYnzZsoFpNsY+tRG1tezaavZYyGq3ZaqgZovGqfq9+/ZnMCCZnhcu7LCiCoBT8Q7N69mx//+Mf84z/+I3/6p38KgNPpBDRvv6KiggMHDszF8WevSSQLhWIwYM7NxZybO++8d3QUd3MzruZmXE1NuJqamfrsc8bfveOgKBYLpsxMTFmZmLOyMGVkaMcZGSTnRZGcF8WLb62ho3aYxiv91J3v5ebn3YTHhbBmU4Ic7A1yliwtU1GUIuCnwDBwVgjx7uOeWa5pmX19ffzwhz/kypUrxMXFYbVa+cEPfsC3vvUtLl++zF//9V/T09NDfHw8sbGx/N3f/R3l5fdlSAUlOp2O5OTkueO//Mu/ZGJigl/84hfYbLa5893d3Q98fjn8/lYb3tFR3C0tuFpacbe14Wprxd3Wjqe7G1R17j59RATGjAz/2EIaxtQ0SEylezyMloZpehpGEQLi0sPI25RAXnk8tqjAriwmeTDPlYevKMrbwBFgQAhRfNf5g8AvAT3wL0KInz/iHf8BuCqEOK8oyodCiFcf97nLVfAlz478/S0fVLcbT3c37vZ23O0duDs78HR24u7oxNPXN88YKEYjvrRcBpO30GtZw6g3HBAkJhrILYtlzYtZhESGBu7LSObxvHn4/wb8V+Df73qhHvgHYB/QDXytKMqHaOL/s3ue/x7wP4CfKIryKhDztF9AIpEsLDqTSRvwzc6+75rwePD09uLu6sbT3Y2npxt3dzehPVUk3/6QSacOe/xG7I5NXOj38dXxXmKcraQoXaRETROaFIshPgFDQgLGhHgMiYkY4uICvtbwaueJBF8IcU5RlMx7Tm8GmoUQrQCKovwaeE0I8TO03sCD+DO/ofj9wz5LUZTvA98HSE9Pf5Lm2fsLxAAADlhJREFUSSSSBUYxGrX4fkbGA6+rMzN4evtw9/Qw2DxIa7OHztFUrqt53JzxEFN9m4S+M8QM30Kveuae04WHY4iPwxDn32LjMMTGYoiLxRAbiz4mRvsZEbGoRehWK88zaJsCdN113A1UPOxmv8H4MWAF/s+H3SeE+Gfgn0EL6TxH+yQSySKhs1gwZ2dhzs4ibAdko1Xy7G+boOlrO83XrAxGl2A0KqSmKKRHTBAn+hFDdryDg3gHBpiuuoZ3cBDhdj/gA3Too6IwxMSgj47GEB2NPjoafVSkth8VjT4qCn1kpHYuMnLRitStJJYsS0cI0Y7fc38cdxVPW9Q2SSSShUPRKSTlRJCUE8ELb+XR0zhKc+UALdUDtLXbMIUUkF36/7d377FR3dkBx79nxm+PX2OPzcMO9owxZjcQbGMoj2WTUFZmN1BaR3nQqGm1okqUbdREqTaN0pY/oigQokZZVdmmYsNKS7KBKEGbYkIihHmlKcFAtCFgY6AsDsHjBwY/sMGeX/8Y4xiC3zNzZzznI41m5t479x6Pj8789Ju55y6l8K9yyJudgd1uwxiDr72d3uZmepub6Wtpobe5hd6WZvpaWultbaWvpYVrJ76ir/Uyvvb2IY9vS0ryfwCkp2NPT8OWloY9LQ17Wjr21FTsaanYUlOxp6ZhT03BdvPe4QjZRW2sNpGC/w0w+Eyj3P5lE2aM+Qj4aP78+esCsT+lVGjZbEJesZO8YifLHiniwslWztR4OXu8iVOfXyI+OQb3PBczy3KYPiud+NTUO36XcDtz/Tq9bW30Xb7sv9183NY2cOtta8PXdoUbF7+l78oV+q5ehb6+oXcqgs3hwJbiwO5IwZaSgt3hwJaSgs2R7H/sSMGWnOzfLjnJvyw52X9LShq4lzC8mttgEyn4XwAzRaQAf6F/BFgbiKB0hK/U5GGPsZE/J4v8OVnce8PHn062Un+kkfojXk4e+pYERyzueS4Ky7KZXpQ+7Nm9EhdHbHY2sdnZoz6+MQZfZye+/uLfd+UqfVev4Gtvp+9qO772q/S1d/ift7fja2/nRpMX37lz+Nrb8XV0YG7cGPlA+L/7sCUnI0mJ/g+CxCRsiYn+W3ISktD/ODEBSUzEltB/H5/gX5aQ4F8WH0/8rFnYB/3UORBGVfBF5F3gXiBLRBqAfzPGbBaRXwC78f8y5zfGmBOBCCrcR/hDtUfOyMhg06ZNQTmzNlyM1B65u7ubVatWsWTJEtavX29NkCps2WNtFMzNomBuFr3X+/jTiVbqj3qp+6KRrw9e9Bf/EheFpSMX/9ESEewOB3aHg9jp08e1D9/16/g6Ovy3zs5bbn03H3d1Ybq68HV14evsv792Dd+1a9xo8mLO+x/7ursx167d+buLQWa88w5JpSXjincoo/2VzqNDLK8CqgIaEeE9wh+uPXJGEC5sEUmuX79OZWUlZWVlWuzViGLi7LhLXLhLXN8V/5pG6g438vWBiwMjf0+pi+mz/HP+VrHFxWFzOsHpDNg+TV8fvmvdmO7+D4HubnzdPf3Pe4gv9ATsWDeFZWuFcB7hD9ceubq62rrALNbb28vDDz/MzJkzeeWVIc+/U+qOhir+p/tH/jfn/D2l2eQWW1v8A0XsduyOZHCErlVFWBb8Udv1PFz6Y2D3OWUOrBy6YA3XHjmUDmyro/lCx8gbjkFWnoMfPVQ0rtdu3LiRFStW8Prrrwc0JhV9vlf8v26lvsZLfY1/zj8+KYaCuVl4SrPJm+3EHhv5xT9UwrLgh/OUzu0Gt0d+9dUhTy+Y9JYuXcpnn31GXV0dRUXj+9BQ6nYxcXbc81y457novdHHhZOXOXvUy9kvmzn1+SXiEuzkz83CU5LNXT90EhOnJ2sNJywL/qindIYZiQfLcO2RQ2m8I/FgWbZsGY8//jgrV67k4MGDTJ061eqQ1CQTE2sf+ML33l4fDacuc+aY/6eedYcbiYm3k393Jp5Sf/GPSwjL8mYpfUfGaLj2yNGusrISr9dLRUUF+/btIz093eqQ1CRlj7Ex4+5MZtydyY/XzuJibRv1x7ycO95EfY0Xe6yNGT/MxF3iIn9uFvGJWuogTAt+OE/piAg7duzgmWeeYePGjQPtkTds2ADAnj17yM3NHdh++/btLFq0yKpwA66rq+uWv+/ZZ5+9Zf2TTz5JY2Mjq1ev5pNPPiFBm2WpILPbbQPX7v3xo7P49nQbZ441cbZ/9G+LEe6a7cRTmk3+3CwSksP75KhgClk//PHQ9siTj/7/VKgYn6Hx/65SX+Nv79DR2oPNJuQWZ+ApzaZgXhaJjsnZf2ei7ZGVUiqiiE2Y4k5jijuNJQ8W4j3fzpmjXs4c9bL3d6eo3grTijIoLMvGPc9FUurkLP6DhWXBD+cpHaVU5BERcvJTyclPZdFfemi+0OEv/sea2PdOLfverWVaYTqe0mw8JS6S0+OtDjkodEpHhZT+/1Q4McbQerGT+qNezhxt4vK3nSAw1ZOGpyQbT2k2jozIK/46paOUUrcRETKnO8ic7mDhKjetFzs5c8w/7XNw+2kObj/NFHcahWXZeEpdEX8NXy34SinVzzktGee0Asp/VsDlS52cOeqlvqZpoPhP9aThKcvGUxKZI38t+EopdQcZU5KZ/9MC5v90cPH3cnDbd8W/sCwHT6mL5LTIKP5h2YRCRFaJyFtXrlyxOpQ7amxsZO3atbjdbsrKyli0aBEffvgh1dXVPPDAd5fzffHFF6moqKCnp8fCaAPLMag/d1VVFUVFRZw/f57169ezadMmALq7u1mxYoV2zFSTxs3i/8i/LGTt+oUseKCAnq5eDrxXx2+fP8SOfz/KV/u/4VrH8C2PrRaWI/xw7pY52vbIL730EocOHaKqqor4+Mj49B+LPXv28PTTT7N7925mDLrQtbZIVpNdxpRkyn/mn/Zpudjhb+x2xMu+d2rZ//s68mZnMHN+DgXzXGF3hm94RRMBRtMe+bXXXmPXrl3s3r2bxMREiyINnv3797Nu3TqqqqrweL7r2a0tklW0yZzmIHOagwUPFNDc0EH9kUZOH/Gy57cnsW+tZcbdmcwszyF/TmZYNHaL6IK/4fAGTrWeCug+i53F/HLBL4dcP1J75EOHDlFbW0tNTc0t0x+BtnfLW3jPnw3oPrNnuLnvb4e/znxPTw9r1qyhurqa4uLiW9Zpi2QVrUQEV14KrrwU/myNh8ZzVzndfxnHs8ebiE3wd/2cWZ5DXnFGQK7kNR5hOYcfSZ566inuueceysvLASgsLMQYw6effmpxZMERGxvL4sWL2bx58/fWDW6RrFS0EvGf4fujh4p4/JUlrP7HeRSWZnPuy2b++1dfsuX5Q+x/r45L564Q6vOgInqEP9xIPFhGao+ck5PD1q1bWb58OU6nk/vuuy8ocYw0Eg8Wm83Gtm3bWL58OS+//DIvvPDCwDptkazUrWw2Ia/YSV6xv7Hb+RMt1B2+xNcHLvLHvQ2kuRIpWjiFogU5pGcnBT+eoB9hkrn//vvp7u7mzTffHFh2e3vkoqIiPvjgAx577DGOHz8e6hCDLikpiZ07d7J169bvjfQrKyt57rnnqKiooK2tzaIIlQo/9lgb7nkuKv5+Dn/36lLu/5tiHM4Evth5jq3/+jnvbzjCV/sa6O68EbQYwnKEH869dEZqj3xTeXk5b7/9NqtXr2bv3r23fLk5GTidTj7++GOWLVuGy+W6ZZ22SFZqePGJMcxePI3Zi6fRcbmbusON1P7vJfa9W8eB7afJn5PFwlVunNMCe71b7aWjQkr/f0rdmTGG5gsd1H5+ibojjVT+UylprvFN82gvHaWUCmMiguuuFFx3pbD4wUJsNgn4MXQOXymlwkwwij1EaMEP52koNTT9vyllrYgr+AkJCbS0tGjxiDDGGFpaWvQLXKUsFHFz+Lm5uTQ0NNDU1GR1KGqMEhISbrkAulIqtCKu4MfGxlJQUGB1GEopFXEibkpHKaXU+GjBV0qpKKEFXymlokRYn2krIk3AeSANGOvlr8bympG2ncj6odZlAc2jis4a43nPQ7nvYObEaLYbb05oPgRn/5GaD8Otm0hOzDDGuL631BgT9jfgrWC+ZqRtJ7J+qHXAEavf10C/56HcdzBzYjTbjTcnNB+Cs/9IzYdQ50SkTOl8FOTXjLTtRNaPJ/ZwEMy4A7HvYObEaLYbb05oPgRn/5GaD2OJY8LCekpnMhORI+YOzY1UdNJ8ULcLRk5Eygh/MnrL6gBUWNF8ULcLeE7oCF8ppaKEjvCVUipKaMFXSqkooQVfKaWihBb8MCEibhHZLCLvWx2Lsp6IrBGR/xKR90TkJ1bHo6wlIrNF5Nci8r6IPDne/WjBDyIR+Y2IeEXkq9uWV4hIrYjUi8jzAMaYs8aYn1sTqQqFMebDDmPMOuAJ4GEr4lXBNcZ8OGmMeQJ4CFgy3mNqwQ+uLUDF4AUiYgf+A1gJ/AB4VER+EPrQlAW2MPZ8eLF/vZp8tjCGfBCR1cBOoGq8B9SCH0TGmP1A622LFwD1/SP668Dvgb8IeXAq5MaSD+K3AdhljDka6lhV8I21Phhj/mCMWQn89XiPqQU/9KYDFwY9bwCmi0imiPwaKBGRf7YmNGWBO+YD8A/AnwMPisgTVgSmLDFUfbhXRN4Qkf9kAiP8iLvi1WRljGnBP1+rFMaYN4A3rI5DhQdjTDVQPdH96Ag/9L4B8gY9z+1fpqKT5oMaLKj5oAU/9L4AZopIgYjEAY8Af7A4JmUdzQc1WFDzQQt+EInIu8D/ALNEpEFEfm6M6QV+AewGTgLbjDEnrIxThYbmgxrMinzQ5mlKKRUldISvlFJRQgu+UkpFCS34SikVJbTgK6VUlNCCr5RSUUILvlJKRQkt+EopFSW04CulVJTQgq+UUlHi/wGDe7ibCypFygAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Compute power spectra\n",
+    "# We will assume that the cross-correlation between clustering, lensing,\n",
+    "# and CMB lensing with the frequency maps is zero.\n",
+    "cls = np.zeros([n_maps, n_maps, n_ell])\n",
+    "\n",
+    "plt.figure()\n",
+    "# GC - GC\n",
+    "cls[0, 0, :] = ccl.angular_cl(cosmo, gc, gc, ells) + nl_gc\n",
+    "plt.plot(ells, cls[0, 0, :], label='GG')\n",
+    "\n",
+    "# GC - WL (E-only, B is zero)\n",
+    "cls[0, 1, :] = ccl.angular_cl(cosmo, gc, sh, ells)\n",
+    "cls[1, 0, :] = cls[0, 1, :]\n",
+    "plt.plot(ells, cls[0, 1, :], label='GL')\n",
+    "\n",
+    "# GC - CMBK\n",
+    "cls[0, 3, :] = ccl.angular_cl(cosmo, gc, ck, ells)\n",
+    "cls[3, 0, :] = cls[0, 3, :]\n",
+    "plt.plot(ells, cls[0, 3, :], label='GK')\n",
+    "\n",
+    "# WL - WL\n",
+    "# EE\n",
+    "cls[1, 1, :] = ccl.angular_cl(cosmo, sh, sh, ells) + nl_sh\n",
+    "# BB\n",
+    "cls[2, 2, :] = nl_sh\n",
+    "plt.plot(ells, cls[1, 1, :], label='LL')\n",
+    "\n",
+    "# WL - CMBK (E-only, B is zero)\n",
+    "cls[1, 3, :] = ccl.angular_cl(cosmo, sh, ck, ells)\n",
+    "cls[3, 1, :] = cls[1, 3, :]\n",
+    "plt.plot(ells, cls[1, 3, :], label='LK')\n",
+    "\n",
+    "# CMBK - CMBK\n",
+    "cls[3, 3, :] = ccl.angular_cl(cosmo, ck, ck, ells)\n",
+    "plt.plot(ells, cls[3, 3, :], label='KK')\n",
+    "\n",
+    "# T - T\n",
+    "cls[4, 4, :] = cl_syn_tt\n",
+    "# E - E\n",
+    "cls[5, 5, :] = cl_syn_ee\n",
+    "# E - B\n",
+    "cls[5, 6, :] = cl_syn_eb\n",
+    "cls[6, 5, :] = cls[5, 6, :]\n",
+    "# B - B\n",
+    "cls[6, 6, :] = cl_syn_bb\n",
+    "\n",
+    "plt.loglog()\n",
+    "plt.legend(loc='lower left', ncol=2)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Bandpower window functions\n",
+    "For simplicity let's just assume top-hat windows"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_ell_large = 3001\n",
+    "ells_large = np.arange(n_ell_large)\n",
+    "window_single = np.zeros([n_ell, n_ell_large])\n",
+    "for i in range(n_ell):\n",
+    "    window_single[i, i * d_ell : (i + 1) * d_ell] = 1.\n",
+    "\n",
+    "plt.figure()\n",
+    "for w in window_single:\n",
+    "    plt.plot(ells_large, w)\n",
+    "plt.xlim([200,300])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Covariance\n",
+    "Finally, let's create a covariance matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fsky = 0.1\n",
+    "n_cross = (n_maps * (n_maps + 1)) // 2\n",
+    "covar = np.zeros([n_cross, n_ell, n_cross, n_ell])\n",
+    "\n",
+    "id_i = 0\n",
+    "for i1 in range(n_maps):\n",
+    "    for i2 in range(i1, n_maps):\n",
+    "        id_j = 0\n",
+    "        for j1 in range(n_maps):\n",
+    "            for j2 in range(j1, n_maps):\n",
+    "                cl_i1j1 = cls[i1, j1, :]\n",
+    "                cl_i1j2 = cls[i1, j2, :]\n",
+    "                cl_i2j1 = cls[i2, j1, :]\n",
+    "                cl_i2j2 = cls[i2, j2, :]\n",
+    "                # Knox formula\n",
+    "                cov = (cl_i1j1 * cl_i2j2 + cl_i1j2 * cl_i2j1) / (d_ell * fsky * (2 * ells + 1))\n",
+    "                covar[id_i, :, id_j, :] = np.diag(cov)\n",
+    "                id_j += 1\n",
+    "        id_i += 1\n",
+    "covar = covar.reshape([n_cross * n_ell, n_cross * n_ell])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create SACC file"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We start by creating an empty `Sacc` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = sacc.Sacc()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Tracers\n",
+    "Now we add all maps as individual tracers.\n",
+    "The GC and WL maps will be `NZ` tracers, the CMBK tracer will be a `Map` tracer, and the I/Q/U maps will be two `NuMap` tracers (one for temperature, another one for polarization)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# GC\n",
+    "s.add_tracer('NZ', 'gc',  # Name\n",
+    "             quantity='galaxy_density',  # Quantity\n",
+    "             spin=0,  # Spin\n",
+    "             z=z,  # z\n",
+    "             nz=nz)  # nz\n",
+    "# WL\n",
+    "s.add_tracer('NZ', 'wl',  # Name\n",
+    "             quantity='galaxy_shear',  # Quantity\n",
+    "             spin=2,  # Spin\n",
+    "             z=z,  # z\n",
+    "             nz=nz,  # nz\n",
+    "             extra_columns={'error': 0.1*nz},  # You can include extra columns for the N(z)\n",
+    "             sigma_g=0.28)  # You can add any extra information as **kwargs\n",
+    "# CMBK\n",
+    "s.add_tracer('Map', 'ck',  # Name\n",
+    "             quantity='cmb_convergence',  # Quantity\n",
+    "             spin=0,  # Spin\n",
+    "             ell=ell_beam, beam=beam)  # Beam\n",
+    "\n",
+    "# T\n",
+    "s.add_tracer('NuMap', 'B20_T',  # Name\n",
+    "             quantity='cmb_temperature',  # Quantity\n",
+    "             spin=0,  # Spin\n",
+    "             nu=nu, bandpass=bpass,  # Bandpass\n",
+    "             bandpass_extra={'error': 0.01 * bpass},  # You can add some extra bandpass data.\n",
+    "             ell=ell_beam, beam=beam,  # Beam\n",
+    "             beam_extra={'error': 0.01 * beam},\n",
+    "             nu_unit='GHz',  # Frequency units\n",
+    "             map_unit='uK_RJ',  # Map units\n",
+    "            )\n",
+    "\n",
+    "# Q/U\n",
+    "s.add_tracer('NuMap', 'B20_P',  # Name\n",
+    "             quantity='cmb_polarization',  # Quantity\n",
+    "             spin=2,  # Spin\n",
+    "             nu=nu, bandpass=bpass,  # Bandpass\n",
+    "             bandpass_extra={'error': 0.01 * bpass},  # You can add some extra bandpass data.\n",
+    "             ell=ell_beam, beam=beam,  # Beam\n",
+    "             beam_extra={'error': 0.01 * beam},\n",
+    "             nu_unit='GHz',  # Frequency units\n",
+    "             map_unit='uK_RJ',  # Map units\n",
+    "            )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Power spectra\n",
+    "Now we add all power spectra one-by-one"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a SACC bandpower window object\n",
+    "wins = sacc.BandpowerWindow(ells_large, window_single.T)\n",
+    "# GC-GC\n",
+    "s.add_ell_cl('cl_00',  # Data type\n",
+    "             'gc',  # 1st tracer's name\n",
+    "             'gc',  # 2nd tracer's name\n",
+    "             ells,  # Effective multipole\n",
+    "             cls[0, 0, :],  # Power spectrum values\n",
+    "             window=wins,  # Bandpower windows\n",
+    "            )\n",
+    "# GC-WL\n",
+    "s.add_ell_cl('cl_0e', 'gc', 'wl', ells, cls[0, 1, :], window=wins)\n",
+    "s.add_ell_cl('cl_0b', 'gc', 'wl', ells, cls[0, 2, :], window=wins)\n",
+    "# GC-CMBK\n",
+    "s.add_ell_cl('cl_00', 'gc', 'ck', ells, cls[0, 3, :], window=wins)\n",
+    "# GC-T\n",
+    "s.add_ell_cl('cl_00', 'gc', 'B20_T', ells, cls[0, 4, :], window=wins)\n",
+    "# GC-P\n",
+    "s.add_ell_cl('cl_0e', 'gc', 'B20_P', ells, cls[0, 5, :], window=wins)\n",
+    "s.add_ell_cl('cl_0b', 'gc', 'B20_P', ells, cls[0, 6, :], window=wins)\n",
+    "# WL-WL\n",
+    "s.add_ell_cl('cl_ee', 'wl', 'wl', ells, cls[1, 1, :], window=wins)\n",
+    "s.add_ell_cl('cl_eb', 'wl', 'wl', ells, cls[1, 2, :], window=wins)\n",
+    "s.add_ell_cl('cl_bb', 'wl', 'wl', ells, cls[2, 2, :], window=wins)\n",
+    "# WL-CMBK\n",
+    "s.add_ell_cl('cl_0e', 'wl', 'ck', ells, cls[1, 3, :], window=wins)\n",
+    "s.add_ell_cl('cl_0b', 'wl', 'ck', ells, cls[2, 3, :], window=wins)\n",
+    "# WL-T\n",
+    "s.add_ell_cl('cl_0e', 'wl', 'B20_T', ells, cls[1, 4, :], window=wins)\n",
+    "s.add_ell_cl('cl_0b', 'wl', 'B20_T', ells, cls[2, 4, :], window=wins)\n",
+    "# WL-E/B\n",
+    "s.add_ell_cl('cl_ee', 'wl', 'B20_P', ells, cls[1, 5, :], window=wins)\n",
+    "s.add_ell_cl('cl_eb', 'wl', 'B20_P', ells, cls[1, 6, :], window=wins)\n",
+    "s.add_ell_cl('cl_be', 'wl', 'B20_P', ells, cls[2, 5, :], window=wins)\n",
+    "s.add_ell_cl('cl_bb', 'wl', 'B20_P', ells, cls[2, 6, :], window=wins)\n",
+    "# CMBK-CMBK\n",
+    "s.add_ell_cl('cl_00', 'ck', 'ck', ells, cls[3, 3, :], window=wins)\n",
+    "# CMBK-T\n",
+    "s.add_ell_cl('cl_00', 'ck', 'B20_T', ells, cls[3, 4, :], window=wins)\n",
+    "# CMBK-P\n",
+    "s.add_ell_cl('cl_0e', 'ck', 'B20_P', ells, cls[3, 5, :], window=wins)\n",
+    "s.add_ell_cl('cl_0b', 'ck', 'B20_P', ells, cls[3, 6, :], window=wins)\n",
+    "# T-T\n",
+    "s.add_ell_cl('cl_00', 'B20_T', 'B20_T', ells, cls[4, 4, :], window=wins)\n",
+    "# T-P\n",
+    "s.add_ell_cl('cl_0e', 'B20_T', 'B20_P', ells, cls[4, 5, :], window=wins)\n",
+    "s.add_ell_cl('cl_0b', 'B20_T', 'B20_P', ells, cls[4, 6, :], window=wins)\n",
+    "# P-P\n",
+    "s.add_ell_cl('cl_ee', 'B20_P', 'B20_P', ells, cls[5, 5, :], window=wins)\n",
+    "s.add_ell_cl('cl_eb', 'B20_P', 'B20_P', ells, cls[5, 6, :], window=wins)\n",
+    "s.add_ell_cl('cl_bb', 'B20_P', 'B20_P', ells, cls[6, 6, :], window=wins)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Covariance\n",
+    "Finally, add the covariance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.add_covariance(covar)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Writing\n",
+    "Finally, write it to file!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.save_fits(\"cmblss.fits\", overwrite=True)"
+   ]
+  },
+  {
+   "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.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/SACC_read.ipynb b/examples/SACC_read.ipynb
new file mode 100644
index 0000000..a7db907
--- /dev/null
+++ b/examples/SACC_read.ipynb
@@ -0,0 +1,345 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sacc\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Read SACC files\n",
+    "\n",
+    "This notebook illustrates how to read and interpret data from a SACC file.\n",
+    "We will read the BK15 data we wrote into SACC format in SACC_write.ipynb (so run that notebook first!)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Reading the file is as simple as:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/alonso/.local/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
+      "  from ._conv import register_converters as _register_converters\n"
+     ]
+    }
+   ],
+   "source": [
+    "# First, read data\n",
+    "s = sacc.Sacc.load_fits(\"BK15.fits\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here are some examples of how to cut the data. There are lots of different slice-and-dice functions in sacc, from very convenient to very generic. Have a look at the documentation of `sacc/sacc.py`.\n",
+    "\n",
+    "### E.g. 1: keep only the BB correlations\n",
+    "This will drop all other elements of the data vector and the corresponding elements of the covariance matrix."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.keep_selection('cl_bb')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### E.g. 2: removing things\n",
+    "For instance, let's remove all multipoles larger than 400 (in this case this won't remove anything, since all power spectra are only given for ell<~300).\n",
+    "\n",
+    "Note that you can use the syntax `tag__gt=X` or `tag__lt=Y` to impose scale cuts on a given scale-like tag (we're using it for `tag==ell`, but it could be something else)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/alonso/.local/lib/python3.6/site-packages/sacc-0.2.3-py3.6.egg/sacc/sacc.py:366: UserWarning: Empty index selected\n"
+     ]
+    }
+   ],
+   "source": [
+    "s.remove_selection(ell__gt=400)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Accessing the data vector and covariance\n",
+    "At this point, we can access the full data vector or covariance matrix as:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(702,)\n",
+      "(702, 702)\n"
+     ]
+    }
+   ],
+   "source": [
+    "data_vector = s.mean\n",
+    "covariance = s.covariance.covmat\n",
+    "print(data_vector.shape)\n",
+    "print(covariance.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Accessing the different power spectra\n",
+    "\n",
+    "Now let's do some plotting. \n",
+    "We will use `get_tracer_combinations` to loop through all cross-correlations. \n",
+    "We will then use `get_ell_cl` to read off the corresponding power spectra."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEcCAYAAADpzeJvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAatUlEQVR4nO3de7hddX3n8ffHYCiKRC4ppEBMbOkFW4biKcpUkTFQxTrgTOkUWxVabcZWpnasT4syZaxOWy9Ta72MitaKVqGKOkZLayGSdqYTL8FCABFJAbkFErEGHRTEfPvHWge2232SnXX2OXvnnPfrefZz1uV31v7+9krOZ6/fWnuvVBWSJO2pR4y7AEnS3skAkSR1YoBIkjoxQCRJnRggkqRODBBJUicGiCSpEwNEI5fkvUmq5/HVJJ9M8uN97SrJGT3zS5L8RZJ7kjypXbY2yRVJvt62XzXg+W7pe75K8toha/03SS5KcluSbyW5IcnvJnlET5uTknw8ydYk9yXZnOTXBmzraUmuTPLtJDclefHwr9pwkpzd189vJPlckp/va7chyVv7lv16kgeS/Od2/sQk65Lc0W7r7AHP178vK8lnhqz1oCRvSfKl9rW9Lcnbkxzc02ZVkj9vX69vtT//OMl+fdtameQTSf5/++/pzUmW7sFLpzlggGiuXA6saB8/B+wHfGymxkl+APgIcDLw1Kr6bLvqUcDfAa/azfO9uuf5VgD/Y8g6nwhsB54PPAH478DvA+f2tPm3wDXAGcBPAm8HLkjyyz31rwYuBf4f8NPAHwNvSfILQ9axJ+7j4X4+sX3OjyY5cqZfSPIK4C3AL1fVO9vF+wPXAi8FvrWL5+vdlyuAZw1Z5w8BhwO/C/wU8DzgROCinjY/DiwBfoPm9f8vwAuAP+upfQnw18BjgKcCz6XZF38yZB2aK1Xlw8dIH8B7gU/2LXs2UMB+PcuK5g/BAcAG4EvAyhm2OdW2XzVg3S3Ay0dY/+uBK3fT5kPAR3rmXwfc2Nfm3cDGXWzj94G7gB/sWXYR8AVg6Qy/czbwzb5l+7evzak9yzYAbwVC84f2G8DJu6jlm8DZw+zLWb62zwJ2Agfsos1vAvf0zJ/a/s6RPcueB3x7V9vxMfcPj0A055I8Bvgl4Jqq6n+n+4M0f+z2pznyuLXj07y8Hfq6Ksl5sxzeOAD4lz1scwLNkVKvTwFTSR45wzb+CLgReA9AkhcAp9McJTwwTKFJ9gF+leaP6dV9q/cB/oLmHf3Tq+ryYbY5wFOSbEvy5STvSvKDHbcDzet2P81R1K7a9L+211fVbT3LPgXsS3MEpjHZZ9wFaMF6ZpJvttOPBm5j8NDHnwK3A8dW1Tc6PtebgX8C7gGOB14LrAZetKcbSnIczbv8X9lFm2cDa4Cf7Vl8GM1QT6+7af6PHQJs7d9OVX03yfOAq5O8Hngx8DtV9aXdlPnontd2P5o/yL9aVXf2tftVmuGh46pq8262OZO/BT4K3Aysohka/HSSJ1bV/XuyoSSPBV4DvKuqHpyhzeOAl9OE67TDaF7LXl8Fvtuu05gYIJor/wCsbacPpBmW+LskT+p7J/lJmnfdvwX8YZcnqqo39sxuTnIv8FdJfq+q7hl2O0l+jGas/U1V9ZEZ2vws8EHgt6rqc13q7VVVX0nyUpqhor+uqrcP8Wv3Ace204+iOW/0F0nurapLe9r9I825hz9Mcsae/sFv67u4Z/aaJFcCXwF+niZYhpJkf+ATwB0050QGtTmUJrAuo3ljoQnnEJbmyn1VtaV9fJ7maOAAHg6VaRfRnMD+gyTnj+i5p0/A/8iwv9BeIbYBuLiqzp2hzVOAvwHOH/CH/i7g0L5lhwIP0rxb3pUTad5NH5lk3yHKrZ7XdnMboH8PvKKv3ReBf0dzVPaxIbe9uye+k+aI8ahhf6cNj+lge3ZVfXtAm8OAK2hO6j+/qnq/JnzQa3sIzdHVXcNXr1EzQDRfiuZE6KO+b0XVRTRX1vx+kj8YwXNNvzv/vmGjQZIcTRMeH66q/zpDmxNpwuNVVfWmAU02Aqf0LTsF2FRV39nFc/9HmuGypwPLaK7e6uK7DH5trwVOorky7OPt1W6dJTmE5sqqYV/bx9AcVSwBnlVV3xzQZgXN63898NwBw1sbgZ9IckTPslNohu6u3NM+aHQcwtJc2bd9VwnNENY5NCfKPzGocVV9OMmDNENP+1TVefDQO9PDgB9tmx7djqXfWlVfS3IC8GSad687gJ+hGf5YN8wJ+SRPAD7d/v4f9dRMVd3VtjmJZmjrfwEf7Gnz3ara3k6/AzgnyZuAd9KcHzmbJhhneu7DgXcBr6yqf0jyfJrzC5fu5oR3emrYj+aP6TNoLmX+PlV1fZKntX38RJLTqupb7ZHB9FHaI4CVSY4FvlZVt7brX0VzefVWmnMgfwxsYxeXZPcU+RiaCwsOAJ5Dc+7m0e3qr1XVA0l+iCY87gR+GzgkyfQmtlfVd9ttXAe8L8nvAAcDb6A5l3Lv7urQHBr3ZWA+Ft6DZjy/eh73Ap8DfqGvXQFn9C379zTvLF/Xzr+qb1vTj7Pb9ccBnwG+TvNZhi+1v/OoIWudafu1i/5MP27p29bTaC7BvZ/mpPOLd/G8oRnrvxxIz/LX0JwnOHiG3zu7r4ZvAzcArwSW9LTbALy173d/BLiVJjAfRXNkMqhf723b70dztdM24AGacx/vpedy2t28tjNtv4CTZuhP72NVz7ZW0pwvu4/mYok3A/uO+9/6Yn+k3TmSJO0Rz4FIkjoxQLSgJXlHkm/O8HjHuOvbmyX5lV28tteNuz7NPYewtKC1n5o+YIbV91bVtvmsZyFpT5L3X1477TtV9ZX5rEfzzwCRJHWyqC7jPeSQQ2rVqlXjLkOS9ipXXnnlV6tqef/yRRUgq1atYtOmTeMuQ5L2KkkGDkd6El2S1IkBIknqxACRJHVigEiSOjFAJEmdGCCSpE4MEElSJwaIJKkTA0SSFrKTTmoec8AAkSR1YoBIkjoxQCRJnRggkqRODJBhzOFJKEnaWxkgkqRODBBJUicGiCSpEwNEktSJASJJ6sQAkSR1YoBIkjoxQCRJnUxsgCR5ZpIbkmxJcu6A9S9Ock2Sq5L83yRHj6NOSVqsJjJAkiwB3gacChwNPHdAQHywqn6qqo4FXg+8cZ7LlKRFbSIDBDge2FJVN1XVA8DFwOm9Darq3p7ZRwM1j/VJ0qK3z7gLmMHhwG0987cDT+pvlOQlwMuApcDT56c0SRJM7hHIUKrqbVX1w8DvAf9tUJska5NsSrJp+/bt81ugJC1gkxogdwBH9swf0S6bycXAcwatqKoLqmqqqqaWL18+whIlaXGb1AD5PHBUktVJlgJnAut6GyQ5qmf254Eb57E+SVr0JvIcSFU9mOQc4FPAEuA9VXVdklcDm6pqHXBOkpOB7wD/Apw1voolafGZyAABqKpLgUv7lp3fM/3SeS9KkvSQSR3CkiRNOANEktSJASJJ6sQAkSR1YoBIkjoxQCRJnRggkqRODBBJUicGyDB27IBbb4WNG8ddiSRNDANkdzZuhM2b4eabYc0aQ0SSWgbI7mzYADt3NtMPPNDMS5IMkN066SR4RPsyLV3azEuSDJDdOuEEOOYYWL0a1q9v5iVJk/ttvBNl2bLmYXhI0kM8ApEkdWKASJI6MUAkSZ0YIJKkTgwQSVInExsgSZ6Z5IYkW5KcO2D9y5J8McnmJOuTPG4cdUrSYjWRAZJkCfA24FTgaOC5SY7ua/ZPwFRVHQNcArx+fquUpMVtIgMEOB7YUlU3VdUDwMXA6b0NquqKqrqvnf0McMQ81yhJi9qkBsjhwG0987e3y2byQuBvBq1IsjbJpiSbtm/fPsISJWlxm9QAGVqS5wFTwBsGra+qC6pqqqqmli9fPr/FSdICNqlfZXIHcGTP/BHtsu+R5GTgPOBpVXX/PNUmSWJyj0A+DxyVZHWSpcCZwLreBkl+GngncFpVbRtDjZK0qE1kgFTVg8A5wKeA64EPVdV1SV6d5LS22RuA/YEPJ7kqyboZNidJmgOTOoRFVV0KXNq37Pye6ZPnvShJ0kMm8ghEe5mTTvJGW9IiZIBI0mwt0jdRBogkqRMDRJLUiQEiSerEAJEkdWKAaOFbpCc4pblmgEiSOjFAJEmdGCB7A4dgJE2gif0qk4myYcO4K5CkieMRiCSpEwNEktSJAaLZ27EDbr0VNm4cdyWS5pEBotnZuBE2b4abb4Y1awwRaRExQDQ7GzbAzp3N9AMPeMGBtIgYIJqdk06CR7T/jJYu9XJjaRExQDQ7J5wAxxwDq1fD+vXNvIbj53u0l5vYAEnyzCQ3JNmS5NwB609M8oUkDyY5Yxw1qrVsGaxcaXhIi8xEBkiSJcDbgFOBo4HnJjm6r9mtwNnAB+e3OkkSTO4n0Y8HtlTVTQBJLgZOB7443aCqbmnX7RxHgZK02E3kEQhwOHBbz/zt7TJJ0oSY1AAZmSRrk2xKsmn79u3jLqcbP6gnaQJNaoDcARzZM39Eu2yPVdUFVTVVVVPLly8fSXHzyg/qSZpQkxognweOSrI6yVLgTGDdmGsaDz+oN3sewUlzYiIDpKoeBM4BPgVcD3yoqq5L8uokpwEk+ZkktwO/CLwzyXXjq3gO+UG92fEITpozk3oVFlV1KXBp37Lze6Y/TzO0tbBNf1Bvxw74wAf8rMWeGnQE52sojcTEBoh6LFvWPPzDt+emj+B27vQIThqxiRzCkkbGr1qR5oxHIFr4PIKT5oRHIJKkTjwC0ex5abG0KHkEIknqxACRJHVigEiSOjFAJO0dvIPjxDFAJEmdGCCSpE4MEElSJ34OZG/g5ywkTSCPQCRJnRggkqRODBBJUid7HCBJfjLJryU5rm/5/u3tZyUNw1vtai/X5QjkN4ATgFOTfCDJy5LsB+wLvGek1UkLlbfa1QLQJUB+D/gy8BTgscBpwJeAVwIegUjDGHSrXWkvs0eX8SZ5LPCdqnoD8IYk+wJHAcuBFUCNqrAkzwT+DFgCvLuqXtu3fl/gfcATgXuAX6qqW0b1/FpAJvGPs7fa1XzZsaN5bNw48puqDXUEkuTMJDfT/KG+N8ltSf4UOLCqrq2qK6rqg8DvjqKoJEuAtwGnAkcDz01ydF+zFwL/UlU/Avwp8LpRPLc0L7zVrubDHA+V7jZAkqwBPghcDbwE+HXgIuB04NokPzvdtqp2jqiu44EtVXVTVT0AXNw+X6/TgQvb6UuANUkyoueX5t6yZbBy5eSFh19auHDM8VDpMENYvw28v6rO6l2Y5JU0Q0wfS/KEqto+wroOB27rmb8deNJMbarqwSQ7gIOBr/bVuRZYC7By5coRlihJE26Oh0qHGcL6GeBd/Qur6sGqegnwReA3R1rVCFXVBVU1VVVTy5cvH3c5kjR/5niodJgAORi4dRfr3wr83GjKecgdwJE980e0ywa2SbIPsIzmHI0kadocDpUOEyBLgG/vYv1VwI+OppyHfB44Ksnq9sOJZwLr+tqsA6aH1c4APl1VI7sKTJK0a8N+DuTXk5yYZP8B675B8+5/ZKrqQeAc4FPA9cCHquq6JK9Oclrb7M+Bg5NsAV4GnDvKGiRJuzbMSfQrgN8BXgPsTPLPwJXtYxNwF81RykhV1aXApX3Lzu+Z/jbwi6N+XknScHYbIFW1BiDJ42k+tPdE4DjgFcBB083mqkBJ0mQa+pPoVXUTcBPw4ellSVYBUzSBIklaRGZ1R8L2q0NuofkgnyRpEfF+IJKkTgwQSVInBogkqRMDRJLUiQEiSerEAJEkdWKASJI6MUAkSZ0YIJI0Wzt2wK23jvyWsZPOAJGk2Zjj+45PMgNEkmZjju87PskMEEmajen7jsOc3Hd8khkgkjQbc3zf8Uk2q2/jlSTR3Hd82bJFFR7gEYgkqaOJC5AkByW5LMmN7c8DZ2j3t0m+nuST812jNBIbNiyqE65aeCYuQIBzgfVVdRSwvp0f5A3A8+etKknS95jEADkduLCdvhB4zqBGVbUe+MZ8FSVJ+l6TGCCHVtXWdvou4NBxFiNJGmwsV2EluRw4bMCq83pnqqqS1Cyfay2wFmDlypWz2ZQkqcdYAqSqTp5pXZK7k6yoqq1JVgDbZvlcFwAXAExNTc0qjCRJD5vEIax1wFnt9FnAx8dYiyRpBpMYIK8FTklyI3ByO0+SqSTvnm6U5P8AHwbWJLk9yTPGUq0kLVIT90n0qroHWDNg+SbgRT3zT53PuiRJ32sSj0Ak6fst0ntuTDIDRNLkW8T33JhkBoik7zWJ7/QX8T03JpkBIulhk/pOfxHfc2OSGSCSHjap7/QX8T03JtnEXYUlaYym3+nv3Dl57/QX6T03JplHIJIe5jt97QGPQCR9L9/pa0gegUiSOjFAJEmdGCCSpE4MEElSJwaIJKkTA0SS1IkBIknqxACRJHVigEiSOjFAJEmdGCCSpE4mLkCSHJTksiQ3tj8PHNDm2CQbk1yXZHOSXxpHrZK0mE1cgADnAuur6ihgfTvf7z7gBVX1BOCZwJuSPHYea5SkRW8SA+R04MJ2+kLgOf0NqurLVXVjO30nsA1YPm8VSpImMkAOraqt7fRdwKG7apzkeGAp8M8zrF+bZFOSTdu3bx9tpZK0iI3lfiBJLgcOG7DqvN6ZqqoktYvtrADeD5xVVTsHtamqC4ALAKampmbcliRpz4wlQKrq5JnWJbk7yYqq2toGxLYZ2h0A/DVwXlV9Zo5KlSTNYBKHsNYBZ7XTZwEf72+QZCnwMeB9VXXJPNYmSWpNYoC8FjglyY3Aye08SaaSvLtt85+AE4Gzk1zVPo4dT7mStDhN3D3Rq+oeYM2A5ZuAF7XTfwn85TyXJknqMYlHIJKkvYABIknqxACRJHVigEiSOjFAJEmdGCCSpE4MEElSJwaIJKkTA0SS1IkBIknqxACRJHVigEiSOjFAJEmdGCCSpE4m7uvcJY3Zhg3jrkB7CY9AJEmdGCCSpE4MEElSJxMXIEkOSnJZkhvbnwcOaPO4JF9o74V+XZIXj6NWSVrMJi5AgHOB9VV1FLC+ne+3FTihqo4FngScm+SH5rFGSVr0JjFATgcubKcvBJ7T36CqHqiq+9vZfZnMfkjSgjaJf3gPraqt7fRdwKGDGiU5Mslm4DbgdVV153wVKEka0+dAklwOHDZg1Xm9M1VVSWrQNqrqNuCYdujqfye5pKruHvBca4G1ACtXrpx17ZKkxlgCpKpOnmldkruTrKiqrUlWANt2s607k1wLPBW4ZMD6C4ALAKampgaGkaS9gB9wnDiTOIS1DjirnT4L+Hh/gyRHJNmvnT4QeApww7xVKEmayAB5LXBKkhuBk9t5kkwleXfb5ieAzya5Gvh74H9W1TVjqVaSFqmJ+y6sqroHWDNg+SbgRe30ZcAx81yaJA22SIfXJvEIRJK0FzBAJEmdGCCSpE4MEElSJwaIJKkTA0SS1IkBIknqxACRJHVigEiSOjFAJEmdTNxXmUiSRmgOv2bFIxBJUicGiCSpEwNEktSJASJJ6sQAkSR1YoBIkjoxQCRJnRggkqRODBBJUiepqnHXMG+SbAe+MqLNHQJ8dUTbmnT2dWFaLH1dLP2Euevr46pqef/CRRUgo5RkU1VNjbuO+WBfF6bF0tfF0k+Y/746hCVJ6sQAkSR1YoB0d8G4C5hH9nVhWix9XSz9hHnuq+dAJEmdeAQiSerEABlSkluSXJPkqiSb2mUHJbksyY3tzwPHXWcXSd6TZFuSa3uWDexbGm9OsiXJ5iTHja/yPTNDP1+V5I52v16V5Fk9617R9vOGJM8YT9XdJDkyyRVJvpjkuiQvbZcvxP06U18X3L5N8gNJPpfk6ravf9AuX53ks22f/irJ0nb5vu38lnb9qpEWVFU+hngAtwCH9C17PXBuO30u8Lpx19mxbycCxwHX7q5vwLOAvwECPBn47Ljrn2U/XwW8fEDbo4GrgX2B1cA/A0vG3Yc96OsK4Lh2+jHAl9s+LcT9OlNfF9y+bffP/u30I4HPtvvrQ8CZ7fJ3AL/RTv8m8I52+kzgr0ZZj0cgs3M6cGE7fSHwnDHW0llV/QPwtb7FM/XtdOB91fgM8NgkK+an0tmZoZ8zOR24uKrur6qbgS3A8XNW3IhV1daq+kI7/Q3geuBwFuZ+namvM9lr9227f77Zzj6yfRTwdOCSdnn/fp3e35cAa5JkVPUYIMMr4O+SXJlkbbvs0Kra2k7fBRw6ntLmxEx9Oxy4rafd7ez6P+ve4Jx22OY9PcOQC6af7bDFT9O8W13Q+7Wvr7AA922SJUmuArYBl9EcQX29qh5sm/T256G+tut3AAePqhYDZHhPqarjgFOBlyQ5sXdlNceIC/KStoXcN+DtwA8DxwJbgT8ZbzmjlWR/4CPAb1fVvb3rFtp+HdDXBblvq+q7VXUscATNkdOPj6sWA2RIVXVH+3Mb8DGaHXf39GF++3Pb+CocuZn6dgdwZE+7I9ple6Wqurv9D7kTeBcPD2Xs9f1M8kiaP6gfqKqPtosX5H4d1NeFvG8BqurrwBXACTRDjvu0q3r781Bf2/XLgHtGVYMBMoQkj07ymOlp4OeAa4F1wFlts7OAj4+nwjkxU9/WAS9or9p5MrCjZ0hkr9M3zv8faPYrNP08s72KZTVwFPC5+a6vq3ac+8+B66vqjT2rFtx+namvC3HfJlme5LHt9H7AKTTnfK4Azmib9e/X6f19BvDp9shzNMZ9VcHe8AAeT3PVxtXAdcB57fKDgfXAjcDlwEHjrrVj/y6iOcT/Ds346Qtn6hvNVSBvoxl3vQaYGnf9s+zn+9t+bG7/s63oaX9e288bgFPHXf8e9vUpNMNTm4Gr2sezFuh+namvC27fAscA/9T26Vrg/Hb542lCcAvwYWDfdvkPtPNb2vWPH2U9fhJdktSJQ1iSpE4MEElSJwaIJKkTA0SS1IkBIknqxACRJHVigEgTIMkhSd6f5J3jrkUalgEiTYbX0Hzp3a+MuxBpWAaINGbt9zj9Is39OO4ccznS0AwQafyeTHMTpCcC/zjmWqShGSDS+D0V+AxwGvDR3bSVJoYBIo3fFM0XPB5FM4wl7RX22X0TSXNsFfATwBvr4bvKSRPPb+OVxizJHcBO4Meq6r5x1yMNyyEsafweBF5heGhvY4BIY5Tk2cBK4P4kRyfxcyDaa3gORBqTJEuAs4HnAa+muVviC8dZk7QnPAciSerEISxJUicGiCSpEwNEktSJASJJ6sQAkSR1YoBIkjoxQCRJnRggkqRODBBJUif/Cmo4E2ZRwl22AAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for b1, b2 in s.get_tracer_combinations():\n",
+    "    l, cl, cov = s.get_ell_cl('cl_bb', b1, b2, return_cov=True)\n",
+    "    # Let's plot only the auto-correlations. Otherwise it gets unwieldy\n",
+    "    if b1==b2:\n",
+    "        plt.figure()\n",
+    "        plt.title(b1+\" x \"+b2,fontsize=14)\n",
+    "        plt.errorbar(l, cl, yerr=np.sqrt(np.diag(cov)), fmt='r.')\n",
+    "        plt.xlabel('$\\\\ell$',fontsize=14)\n",
+    "        plt.ylabel('$D_\\\\ell$',fontsize=14)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Accessing tracer information\n",
+    "\n",
+    "You can also access the information describing each of the different tracers. In this case, let's plot the bandpasses."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "# Loop through tracers\n",
+    "for tn,t in s.tracers.items():\n",
+    "    plt.plot(t.nu,t.bandpass/np.amax(t.bandpass),label=tn)\n",
+    "plt.xscale('log')\n",
+    "plt.legend(loc='upper right')\n",
+    "plt.ylim([0,1.1])\n",
+    "plt.xlim([10,2000])\n",
+    "plt.xlabel('$\\\\nu\\\\,\\\\,[{\\\\rm GHz}]$',fontsize=14)\n",
+    "plt.ylabel('Transmission',fontsize=14)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "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.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/SACC_write.ipynb b/examples/SACC_write.ipynb
new file mode 100644
index 0000000..246997c
--- /dev/null
+++ b/examples/SACC_write.ipynb
@@ -0,0 +1,400 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import wget\n",
+    "import sacc\n",
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Writing SACC files\n",
+    "\n",
+    "This notebook illustrates how to create a SACC file from scratch.\n",
+    "For this example we will download the BICEP-Keck-Planck 2018 analysis (BK15, https://arxiv.org/pdf/1810.05216.pdf) and transform it into SACC format.\n",
+    "Note that reading the BK15 data is slightly convoluted, but this is precisely the type of issue SACC is meant to solve. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Reading the BK15 data\n",
+    "\n",
+    "We start by downloading the data if we don't have it"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not os.path.isfile(\"BK15_cosmomc/BK15_README.txt\"):\n",
+    "    wget.download(\"http://bicepkeck.org/BK15_datarelease/BK15_cosmomc.tgz\")\n",
+    "    os.system(\"tar -xvf BK15_cosmomc.tgz\")\n",
+    "    os.system(\"rm BK15_cosmomc.tgz\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "These are the names of the 12 different maps that went into the analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Names for the different frequency maps\n",
+    "map_names = np.array([\"BK15_95\",\"BK15_150\",\"BK15_220\",\n",
+    "                      \"W023\",\"P030\",\"W033\",\"P044\",\n",
+    "                      \"P070\",\"P100\",\"P143\",\"P217\",\"P353\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We start by reading all the **bandpasses**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bandpasses = {}\n",
+    "for n in map_names:\n",
+    "    fname = \"BK15_cosmomc/data/BK15/bandpass_\"+n+\".txt\"\n",
+    "    bandpasses[n] = np.loadtxt(fname, unpack=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we read the **data vector** (i.e. the array of D_ell values):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dv = np.loadtxt(\"BK15_cosmomc/data/BK15/BK15_cl_hat.dat\",unpack=True)[1:]\n",
+    "ncls, nells = dv.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we read all the **bandpower windows**. Note that they are all sampled on the same ell values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ls = np.loadtxt(\"BK15_cosmomc/data/BK15/windows/BK15_bpwf_bin1.txt\",unpack=True)[0]\n",
+    "windows=np.array([np.loadtxt(\"BK15_cosmomc/data/BK15/windows/BK15_bpwf_bin%d.txt\"%(i+1),\n",
+    "                             unpack=True)[1:]\n",
+    "                  for i in range(nells)])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we read the **covariance matrix** and put it in the right order"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cov_raw = np.loadtxt(\"BK15_cosmomc/data/BK15/BK15_covmat_dust.dat\", unpack=True)\n",
+    "cov = np.transpose(cov_raw.reshape([nells,ncls,nells,ncls]),\n",
+    "                   axes=[1,0,3,2]).reshape([nells*ncls,nells*ncls])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "OK, this is the **order** in which all the BK15 data is stored.\n",
+    "Right now we need to read this off a txt file and parse it. Since there are 300 possible cross-correlations, this is a huge kerfuffle, hence SACC."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "corr_ordering=np.array([['BK15_95_E','BK15_95_E'],['BK15_95_B','BK15_95_B'],['BK15_150_E','BK15_150_E'],\n",
+    "                        ['BK15_150_B','BK15_150_B'],['BK15_220_E','BK15_220_E'],['BK15_220_B','BK15_220_B'],\n",
+    "                        ['W023_E','W023_E'],['W023_B','W023_B'],['P030_E','P030_E'],['P030_B','P030_B'],\n",
+    "                        ['W033_E','W033_E'],['W033_B','W033_B'],['P044_E','P044_E'],['P044_B','P044_B'],\n",
+    "                        ['P070_E','P070_E'],['P070_B','P070_B'],['P100_E','P100_E'],['P100_B','P100_B'],\n",
+    "                        ['P143_E','P143_E'],['P143_B','P143_B'],['P217_E','P217_E'],['P217_B','P217_B'],\n",
+    "                        ['P353_E','P353_E'],['P353_B','P353_B'],['BK15_95_E','BK15_95_B'],\n",
+    "                        ['BK15_95_B','BK15_150_E'],['BK15_150_E','BK15_150_B'],['BK15_150_B','BK15_220_E'],\n",
+    "                        ['BK15_220_E','BK15_220_B'],['BK15_220_B','W023_E'],['W023_E','W023_B'],\n",
+    "                        ['W023_B','P030_E'],['P030_E','P030_B'],['P030_B','W033_E'],['W033_E','W033_B'],\n",
+    "                        ['W033_B','P044_E'],['P044_E','P044_B'],['P044_B','P070_E'],['P070_E','P070_B'],\n",
+    "                        ['P070_B','P100_E'],['P100_E','P100_B'],['P100_B','P143_E'],['P143_E','P143_B'],\n",
+    "                        ['P143_B','P217_E'],['P217_E','P217_B'],['P217_B','P353_E'],['P353_E','P353_B'],\n",
+    "                        ['BK15_95_E','BK15_150_E'],['BK15_95_B','BK15_150_B'],['BK15_150_E','BK15_220_E'],\n",
+    "                        ['BK15_150_B','BK15_220_B'],['BK15_220_E','W023_E'],['BK15_220_B','W023_B'],\n",
+    "                        ['W023_E','P030_E'],['W023_B','P030_B'],['P030_E','W033_E'],['P030_B','W033_B'],\n",
+    "                        ['W033_E','P044_E'],['W033_B','P044_B'],['P044_E','P070_E'],['P044_B','P070_B'],\n",
+    "                        ['P070_E','P100_E'],['P070_B','P100_B'],['P100_E','P143_E'],['P100_B','P143_B'],\n",
+    "                        ['P143_E','P217_E'],['P143_B','P217_B'],['P217_E','P353_E'],['P217_B','P353_B'],\n",
+    "                        ['BK15_95_E','BK15_150_B'],['BK15_95_B','BK15_220_E'],['BK15_150_E','BK15_220_B'],\n",
+    "                        ['BK15_150_B','W023_E'],['BK15_220_E','W023_B'],['BK15_220_B','P030_E'],\n",
+    "                        ['W023_E','P030_B'],['W023_B','W033_E'],['P030_E','W033_B'],['P030_B','P044_E'],\n",
+    "                        ['W033_E','P044_B'],['W033_B','P070_E'],['P044_E','P070_B'],['P044_B','P100_E'],\n",
+    "                        ['P070_E','P100_B'],['P070_B','P143_E'],['P100_E','P143_B'],['P100_B','P217_E'],\n",
+    "                        ['P143_E','P217_B'],['P143_B','P353_E'],['P217_E','P353_B'],['BK15_95_E','BK15_220_E'],\n",
+    "                        ['BK15_95_B','BK15_220_B'],['BK15_150_E','W023_E'],['BK15_150_B','W023_B'],\n",
+    "                        ['BK15_220_E','P030_E'],['BK15_220_B','P030_B'],['W023_E','W033_E'],['W023_B','W033_B'],\n",
+    "                        ['P030_E','P044_E'],['P030_B','P044_B'],['W033_E','P070_E'],['W033_B','P070_B'],\n",
+    "                        ['P044_E','P100_E'],['P044_B','P100_B'],['P070_E','P143_E'],['P070_B','P143_B'],\n",
+    "                        ['P100_E','P217_E'],['P100_B','P217_B'],['P143_E','P353_E'],['P143_B','P353_B'],\n",
+    "                        ['BK15_95_E','BK15_220_B'],['BK15_95_B','W023_E'],['BK15_150_E','W023_B'],\n",
+    "                        ['BK15_150_B','P030_E'],['BK15_220_E','P030_B'],['BK15_220_B','W033_E'],\n",
+    "                        ['W023_E','W033_B'],['W023_B','P044_E'],['P030_E','P044_B'],['P030_B','P070_E'],\n",
+    "                        ['W033_E','P070_B'],['W033_B','P100_E'],['P044_E','P100_B'],['P044_B','P143_E'],\n",
+    "                        ['P070_E','P143_B'],['P070_B','P217_E'],['P100_E','P217_B'],['P100_B','P353_E'],\n",
+    "                        ['P143_E','P353_B'],['BK15_95_E','W023_E'],['BK15_95_B','W023_B'],\n",
+    "                        ['BK15_150_E','P030_E'],['BK15_150_B','P030_B'],['BK15_220_E','W033_E'],\n",
+    "                        ['BK15_220_B','W033_B'],['W023_E','P044_E'],['W023_B','P044_B'],['P030_E','P070_E'],\n",
+    "                        ['P030_B','P070_B'],['W033_E','P100_E'],['W033_B','P100_B'],['P044_E','P143_E'],\n",
+    "                        ['P044_B','P143_B'],['P070_E','P217_E'],['P070_B','P217_B'],['P100_E','P353_E'],\n",
+    "                        ['P100_B','P353_B'],['BK15_95_E','W023_B'],['BK15_95_B','P030_E'],\n",
+    "                        ['BK15_150_E','P030_B'],['BK15_150_B','W033_E'],['BK15_220_E','W033_B'],\n",
+    "                        ['BK15_220_B','P044_E'],['W023_E','P044_B'],['W023_B','P070_E'],['P030_E','P070_B'],\n",
+    "                        ['P030_B','P100_E'],['W033_E','P100_B'],['W033_B','P143_E'],['P044_E','P143_B'],\n",
+    "                        ['P044_B','P217_E'],['P070_E','P217_B'],['P070_B','P353_E'],['P100_E','P353_B'],\n",
+    "                        ['BK15_95_E','P030_E'],['BK15_95_B','P030_B'],['BK15_150_E','W033_E'],\n",
+    "                        ['BK15_150_B','W033_B'],['BK15_220_E','P044_E'],['BK15_220_B','P044_B'],\n",
+    "                        ['W023_E','P070_E'],['W023_B','P070_B'],['P030_E','P100_E'],['P030_B','P100_B'],\n",
+    "                        ['W033_E','P143_E'],['W033_B','P143_B'],['P044_E','P217_E'],['P044_B','P217_B'],\n",
+    "                        ['P070_E','P353_E'],['P070_B','P353_B'],['BK15_95_E','P030_B'],['BK15_95_B','W033_E'],\n",
+    "                        ['BK15_150_E','W033_B'],['BK15_150_B','P044_E'],['BK15_220_E','P044_B'],\n",
+    "                        ['BK15_220_B','P070_E'],['W023_E','P070_B'],['W023_B','P100_E'],['P030_E','P100_B'],\n",
+    "                        ['P030_B','P143_E'],['W033_E','P143_B'],['W033_B','P217_E'],['P044_E','P217_B'],\n",
+    "                        ['P044_B','P353_E'],['P070_E','P353_B'],['BK15_95_E','W033_E'],['BK15_95_B','W033_B'],\n",
+    "                        ['BK15_150_E','P044_E'],['BK15_150_B','P044_B'],['BK15_220_E','P070_E'],\n",
+    "                        ['BK15_220_B','P070_B'],['W023_E','P100_E'],['W023_B','P100_B'],['P030_E','P143_E'],\n",
+    "                        ['P030_B','P143_B'],['W033_E','P217_E'],['W033_B','P217_B'],['P044_E','P353_E'],\n",
+    "                        ['P044_B','P353_B'],['BK15_95_E','W033_B'],['BK15_95_B','P044_E'],['BK15_150_E','P044_B'],\n",
+    "                        ['BK15_150_B','P070_E'],['BK15_220_E','P070_B'],['BK15_220_B','P100_E'],\n",
+    "                        ['W023_E','P100_B'],['W023_B','P143_E'],['P030_E','P143_B'],['P030_B','P217_E'],\n",
+    "                        ['W033_E','P217_B'],['W033_B','P353_E'],['P044_E','P353_B'],['BK15_95_E','P044_E'],\n",
+    "                        ['BK15_95_B','P044_B'],['BK15_150_E','P070_E'],['BK15_150_B','P070_B'],\n",
+    "                        ['BK15_220_E','P100_E'],['BK15_220_B','P100_B'],['W023_E','P143_E'],['W023_B','P143_B'],\n",
+    "                        ['P030_E','P217_E'],['P030_B','P217_B'],['W033_E','P353_E'],['W033_B','P353_B'],\n",
+    "                        ['BK15_95_E','P044_B'],['BK15_95_B','P070_E'],['BK15_150_E','P070_B'],\n",
+    "                        ['BK15_150_B','P100_E'],['BK15_220_E','P100_B'],['BK15_220_B','P143_E'],\n",
+    "                        ['W023_E','P143_B'],['W023_B','P217_E'],['P030_E','P217_B'],['P030_B','P353_E'],\n",
+    "                        ['W033_E','P353_B'],['BK15_95_E','P070_E'],['BK15_95_B','P070_B'],['BK15_150_E','P100_E'],\n",
+    "                        ['BK15_150_B','P100_B'],['BK15_220_E','P143_E'],['BK15_220_B','P143_B'],\n",
+    "                        ['W023_E','P217_E'],['W023_B','P217_B'],['P030_E','P353_E'],['P030_B','P353_B'],\n",
+    "                        ['BK15_95_E','P070_B'],['BK15_95_B','P100_E'],['BK15_150_E','P100_B'],\n",
+    "                        ['BK15_150_B','P143_E'],['BK15_220_E','P143_B'],['BK15_220_B','P217_E'],\n",
+    "                        ['W023_E','P217_B'],['W023_B','P353_E'],['P030_E','P353_B'],['BK15_95_E','P100_E'],\n",
+    "                        ['BK15_95_B','P100_B'],['BK15_150_E','P143_E'],['BK15_150_B','P143_B'],\n",
+    "                        ['BK15_220_E','P217_E'],['BK15_220_B','P217_B'],['W023_E','P353_E'],\n",
+    "                        ['W023_B','P353_B'],['BK15_95_E','P100_B'],['BK15_95_B','P143_E'],['BK15_150_E','P143_B'],\n",
+    "                        ['BK15_150_B','P217_E'],['BK15_220_E','P217_B'],['BK15_220_B','P353_E'],\n",
+    "                        ['W023_E','P353_B'],['BK15_95_E','P143_E'],['BK15_95_B','P143_B'],\n",
+    "                        ['BK15_150_E','P217_E'],['BK15_150_B','P217_B'],['BK15_220_E','P353_E'],\n",
+    "                        ['BK15_220_B','P353_B'],['BK15_95_E','P143_B'],['BK15_95_B','P217_E'],\n",
+    "                        ['BK15_150_E','P217_B'],['BK15_150_B','P353_E'],['BK15_220_E','P353_B'],\n",
+    "                        ['BK15_95_E','P217_E'],['BK15_95_B','P217_B'],['BK15_150_E','P353_E'],\n",
+    "                        ['BK15_150_B','P353_B'],['BK15_95_E','P217_B'],['BK15_95_B','P353_E'],\n",
+    "                        ['BK15_150_E','P353_B'],['BK15_95_E','P353_E'],['BK15_95_B','P353_B'],\n",
+    "                        ['BK15_95_E','P353_B']])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating a SACC file\n",
+    "\n",
+    "Now the fun part. Let's start by creating an empty SACC object.                                                                                                                                                  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = sacc.Sacc()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we add all frequency maps as individual `tracers`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for n in map_names:\n",
+    "    # The information about each frequency map will become a 'NuMap' tracer object.\n",
+    "    # These are defined by a bandpass and a beam.\n",
+    "    # Since we don't have beam information, we'll make something up.\n",
+    "    ell = np.linspace(2,1000,10)\n",
+    "    bell = np.ones_like(ell)\n",
+    "    # Bandpass data:\n",
+    "    nu = bandpasses[n][0]\n",
+    "    bnu = bandpasses[n][1]\n",
+    "    # We can also pass additional information, such as bandpass or beam uncertainties.\n",
+    "    # E.g. let's say we have ~1% uncertainties on them.\n",
+    "    bnu_extra = {'error' : 0.01*bnu}\n",
+    "    bell_extra = {'error' : 0.01*bell}\n",
+    "    \n",
+    "    s.add_tracer('NuMap', n,  # Name\n",
+    "                 quantity='cmb_polarization',  # Quantity\n",
+    "                 spin=2,  # Spin\n",
+    "                 nu=nu, bandpass=bnu,  # Bandpass data\n",
+    "                 ell=ell, beam=bell,  # Beam data\n",
+    "                 bandpass_extra=bnu_extra,  # Additional bandpass data\n",
+    "                 beam_extra=bell_extra,  # Additional beam data\n",
+    "                 nu_unit='GHz',  # Frequency units\n",
+    "                 map_unit='uK_CMB')  # Map units"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we add all power spectra one by one"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now we add all power spectra\n",
+    "for ix, xc in enumerate(corr_ordering):\n",
+    "    t1, t2 = xc\n",
+    "    # Possible data types for power spectra:\n",
+    "    # cl_ee, cl_eb, cl_be, cl_bb\n",
+    "    # Additional ones:\n",
+    "    #  - cl_00 (TT-like, mathematically equivalent to cl_ee)\n",
+    "    #  - cl_0e (TE-like, mathematically equivalent to cl_ee)\n",
+    "    #  - cl_0b (TE-like, mathematically equivalent to cl_eb)\n",
+    "    # There are similar types for real-space correlations.\n",
+    "    data_type = 'cl_'+t1[-1].lower()+t2[-1].lower()\n",
+    "\n",
+    "    # Let's compute the effective multipole by averaging over the bandpower\n",
+    "    wins_arr = windows[:, ix, :]\n",
+    "    l_eff = np.sum(wins_arr * ls[None,:], axis=1)/np.sum(wins_arr,axis=1)\n",
+    "\n",
+    "    # Define SACC window functions\n",
+    "    wins = sacc.BandpowerWindow(ls, wins_arr.T)\n",
+    "\n",
+    "    # Add power spectrum\n",
+    "    s.add_ell_cl(data_type,  # Data type\n",
+    "                 t1[:-2],  # 1st tracer's name\n",
+    "                 t2[:-2],  # 2nd tracer's name\n",
+    "                 l_eff,  # Effective multipole\n",
+    "                 dv[ix],  # Power spectrum values\n",
+    "                 window=wins,  # Bandpower windows\n",
+    "                )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we add the covariance matrix.\n",
+    "The covariance must be passed in exactly the same order in which the data vector was added."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.add_covariance(cov)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Alrighty, let's save it!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.save_fits(\"BK15.fits\", overwrite=True)"
+   ]
+  },
+  {
+   "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.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/sacc/__init__.py b/sacc/__init__.py
index 8116f5d..ac72eb0 100644
--- a/sacc/__init__.py
+++ b/sacc/__init__.py
@@ -1,6 +1,6 @@
-from .sacc import Sacc, DataPoint, concatenate_data_sets
-from .windows import Window, TopHatWindow, LogTopHatWindow
-from .data_types import standard_types, parse_data_type_name, build_data_type_name
-from .tracers import BaseTracer
-from .covariance import BaseCovariance
-__version__ = '0.3.0'
+from .sacc import Sacc, DataPoint, concatenate_data_sets  # noqa
+from .windows import Window, BandpowerWindow, TopHatWindow, LogTopHatWindow  # noqa
+from .data_types import standard_types, parse_data_type_name, build_data_type_name  # noqa
+from .tracers import BaseTracer  # noqa
+from .covariance import BaseCovariance  # noqa
+__version__ = '0.4.0'
diff --git a/sacc/covariance.py b/sacc/covariance.py
index 296fe9a..29e4aa5 100644
--- a/sacc/covariance.py
+++ b/sacc/covariance.py
@@ -5,6 +5,7 @@ import numpy as np
 
 from .utils import invert_spd_matrix
 
+
 class BaseCovariance:
     """
     The abstract base class for covariances in different forms.
@@ -13,11 +14,11 @@ class BaseCovariance:
     The three concrete subclasses that are created are:
 
     FullCovariance - for dense matrices
-    
-    BlockDiagonalCovariance - for block diagonal matrices 
+
+    BlockDiagonalCovariance - for block diagonal matrices
         (those in which some sub-blocks are dense but without correlation
         between the blocks
-    
+
     DiagonalCovariance - a covariance where the elements are uncorrelated
 
     Attributes
@@ -71,8 +72,8 @@ class BaseCovariance:
     def make(cls, cov):
         """Make an appropriate covariance object from the matrix info itself.
 
-        You can pass in a list of covariance blocks for a block-diagonal, covariance
-        a 1D array for a diagonal covariance, or a full matrix.
+        You can pass in a list of covariance blocks for a block-diagonal,
+        covariance a 1D array for a diagonal covariance, or a full matrix.
 
         A different subclass is returned for each of these cases.
 
@@ -91,7 +92,8 @@ class BaseCovariance:
             for block in cov:
                 block = np.atleast_2d(block)
                 if (block.ndim != 2) or (block.shape[0] != block.shape[1]):
-                    raise ValueError(f"Covariance block has wrong size or shape {block.shape}")
+                    raise ValueError("Covariance block has wrong size "
+                                     f"or shape {block.shape}")
                 s += block.shape[0]
             return BlockDiagonalCovariance(cov)
         else:
@@ -101,7 +103,8 @@ class BaseCovariance:
             if cov.ndim == 1:
                 return DiagonalCovariance(cov)
             if (cov.ndim != 2) or (cov.shape[0] != cov.shape[1]):
-                raise ValueError(f"Covariance is not a 2D square matrix - shape: {cov.shape}")
+                raise ValueError("Covariance is not a 2D square matrix "
+                                 f"- shape: {cov.shape}")
             return FullCovariance(cov)
 
     @property
@@ -193,7 +196,6 @@ class FullCovariance(BaseCovariance, cov_type='full'):
         C = hdu.data
         return cls(C)
 
-
     def keeping_indices(self, indices):
         """
         Return a new instance with only the specified indices retained.
@@ -245,7 +247,7 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
     but without correlations between the blocks. This feature can be taken
     advantage of when doing matrix operations like multiplication or inversion.
 
-    Attributes
+    Parameters
     ----------
     blocks: list[arrays]
         list of sub-blocks of the matrix
@@ -324,9 +326,9 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
         Parameters
         ----------
         indices: array
-            An array of integer indices, which must be in 
+            An array of integer indices, which must be in
             ascending order
-        
+
         Returns
         -------
         cov: array
@@ -334,14 +336,15 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
         """
         indices = np.array(indices)
 
-        if np.any(np.diff(indices))<0:
-            raise ValueError("Indices passed to BlockDiagonalCovariance.get_block must be in ascending order")
-        n = len(indices)
+        if np.any(np.diff(indices)) < 0:
+            raise ValueError("Indices passed to "
+                             "BlockDiagonalCovariance.get_block "
+                             "must be in ascending order")
         s = 0
         sub_blocks = []
         for block, sz in zip(self.blocks, self.block_sizes):
             e = s + sz
-            m = indices[(indices >= s) & (indices < e)]
+            m = indices[(indices >= s) & (indices < e)] - s
             sub_blocks.append(block[m][:, m])
             s += sz
         return scipy.linalg.block_diag(*sub_blocks)
@@ -391,7 +394,8 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
     def _get_dense_inverse(self):
         # Invert all the blocks individually and then
         # connect them all together
-        return scipy.linalg.block_diag(*[invert_spd_matrix(B) for B in self.blocks])
+        return scipy.linalg.block_diag(*[invert_spd_matrix(B)
+                                         for B in self.blocks])
 
     def _get_dense(self):
         # Internal method to get a dense form of the matrix.
@@ -400,12 +404,11 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
         return scipy.linalg.block_diag(*self.blocks)
 
 
-
 class DiagonalCovariance(BaseCovariance, cov_type='diagonal'):
     """A covariance subclass representing covariances that are
     purely diagonal.
 
-    Attributes
+    Parameters
     ----------
     size: int
         The size of the matrix
@@ -491,10 +494,10 @@ class DiagonalCovariance(BaseCovariance, cov_type='diagonal'):
         Parameters
         ----------
         indices: array
-            An array of integer indices, which should be in 
-            ascending order (for consistency with the 
+            An array of integer indices, which should be in
+            ascending order (for consistency with the
             block diagonal interface)
-        
+
         Returns
         -------
         cov: array
diff --git a/sacc/data_types.py b/sacc/data_types.py
index 136588d..10adf19 100644
--- a/sacc/data_types.py
+++ b/sacc/data_types.py
@@ -1,18 +1,37 @@
 import warnings
 from collections import namedtuple
-
 from astropy.table import Table
 
-from .utils import Namespace, hide_null_values, null_values, camel_case_split_and_lowercase
+from .utils import (Namespace, hide_null_values,
+                    null_values, camel_case_split_and_lowercase)
 
 # The format for a data type name looks like this:
 # {sources}_{properties}_{statistic_type}[_{statistic_subtype}]
 #     sources: type(s) of astrophysical sources to which this applies
-#     properties: feature(s)/characterisic(s) of those sources/fields to which the statistic applies
+#     properties: feature(s)/characterisic(s) of those sources/fields to
+#         which the statistic applies
 #     statistic_type: mathematical type of the statistic
 #     statistic_subtype: optional additional specifier
 
-required_tags = {
+required_tags_concise = {
+    "cl_00": ['ell'],
+    "cl_0e": ['ell'],
+    "cl_0b": ['ell'],
+    "cl_ee": ['ell'],
+    "cl_eb": ['ell'],
+    "cl_be": ['ell'],
+    "cl_bb": ['ell'],
+    "xi_00": ['theta'],
+    "xi_0e": ['theta'],
+    "xi_0b": ['theta'],
+    "xi_plus_re": ['theta'],
+    "xi_plus_im": ['theta'],
+    "xi_minus_re": ['theta'],
+    "xi_minus_im": ['theta'],
+    "count": []
+}
+
+required_tags_verbose = {
     "clusterGalaxy_densityConvergence_cl": ['ell'],
     "clusterGalaxy_densityConvergence_xi": ['theta'],
     "clusterGalaxy_densityShear_cl_b": ['ell'],
@@ -116,15 +135,18 @@ required_tags = {
     "galaxy_shear_xi_imagPlus": ['theta'],
 }
 
-parsedDataTypeName = namedtuple('parsedDataTypeName', 'sources properties statistic subtype')
+required_tags = {**required_tags_concise, **required_tags_verbose}
 
-def parse_data_type_name(name):
-    """Parse a data type name into its component parts
+parsedDataTypeName = namedtuple('parsedDataTypeName',
+                                'sources properties statistic subtype')
 
-    Data type names take the form:
-    {sources}_{properties}_{statistic_type}[_{statistic_subtype}]
 
-    where sources and properties are camel-case if there is more than one of them
+def parse_data_type_name(name):
+    """Parse a verbose data type name into its component parts
+    Verbose data type names take the form:
+    {sources}_{properties}_{statistic_type}[_{statistic_subtype}]
+    where sources and properties are camel-case if there is more
+    than one of them
 
     Parameters
     ----------
@@ -137,7 +159,8 @@ def parse_data_type_name(name):
         type(s) of astrophysical sources to which this applies
 
     properties: list[str]
-        feature(s)/characterisic(s) of those sources/fields to which the statistic applies
+        feature(s)/characterisic(s) of those sources/fields to
+        which the statistic applies
 
     statistic_type: str
         mathematical type of the statistic
@@ -146,28 +169,30 @@ def parse_data_type_name(name):
         optional additional specifier
     """
     parts = name.split("_")
-    if len(parts)==3:
+    if len(parts) == 3:
         sources, properties, statistic = parts
         subtype = None
-    elif len(parts)==4:
+    elif len(parts) == 4:
         sources, properties, statistic, subtype = parts
     else:
-        raise ValueError("The supplied name is not a valid data type name"
-            f"(must have 3 or 4 underscore-sparated parts): {name}")
+        raise ValueError("The supplied name is not a valid "
+                         "verbose data type name (must have "
+                         f"3 or 4 underscore-sparated parts): {name}")
     sources = camel_case_split_and_lowercase(sources)
     properties = camel_case_split_and_lowercase(properties)
     return parsedDataTypeName(sources, properties, statistic, subtype)
 
+
 def build_data_type_name(sources, properties, statistic, subtype=None):
     """
-
     Parameters
     ----------
     sources: str or list[str]
         type(s) of astrophysical sources to which this applies
 
     properties: str or list[str]
-        feature(s)/characterisic(s) of those sources/fields to which the statistic applies
+        feature(s)/characterisic(s) of those sources/fields to
+        which the statistic applies
 
     statistic_type: str
         mathematical type of the statistic
@@ -178,22 +203,24 @@ def build_data_type_name(sources, properties, statistic, subtype=None):
     Returns
     -------
     name: str
-        Type name of the form: {sources}_{properties}_{statistic_type}[_{statistic_subtype}]
+        Type name of the form:
+           {sources}_{properties}_{statistic_type}[_{statistic_subtype}]
     """
     if not isinstance(sources, str):
-        sources = "".join([sources[0]] + [s.lower().capitalize() for s in sources[1:]])
+        sources = "".join([sources[0]] + [s.lower().capitalize()
+                                          for s in sources[1:]])
     if not isinstance(properties, str):
-        properties = "".join([properties[0]] + [s.lower().capitalize() for s in properties[1:]])
+        properties = "".join([properties[0]] + [s.lower().capitalize()
+                                                for s in properties[1:]])
     if subtype:
         return f"{sources}_{properties}_{statistic}_{subtype}"
     else:
         return f"{sources}_{properties}_{statistic}"
 
 
-
 # This makes a namespace object, so you can do:
 # standard_types.ggl_e == "ggl_e"
-# also, for convenience, you can do standard_types.index('ggl_e') 
+# also, for convenience, you can do standard_types.index('ggl_e')
 # and 'ggl_e' in standard_types
 
 standard_types = Namespace(*required_tags.keys())
@@ -210,7 +237,7 @@ class DataPoint:
     Data points can be automatically created and added to a
     Sacc object, so you don't normally nee to manually create them.
 
-    Attributes
+    Parameters
     -----------
     data_type: str
         A string, indicating the type of data point
@@ -222,15 +249,16 @@ class DataPoint:
         Mean value of this statistics
 
     tags: dict
-        Dictionary of further data point metadata, such as binning info, angles, etc.
-
+        Dictionary of further data point metadata, such as binning
+        info, angles, etc.
     """
-    def __init__(self, data_type, tracers, value, ignore_missing_tags=False, **tags):
+    def __init__(self, data_type, tracers, value,
+                 ignore_missing_tags=False, **tags):
         """Create a new data point.
 
         Data points can be automatically created and added to a
         Sacc object, so you don't normally nee to manually create them.
-        
+
         Parameters
         ----------
         data_type: str
@@ -243,11 +271,12 @@ class DataPoint:
             Mean value of this statistics
 
         ignore_missing_tags: bool
-            Optional, default=False.  If True, do not complain if a tracer usually
-            needed for this data type is not present.
+            Optional, default=False.  If True, do not complain if a
+            tracer usually needed for this data type is not present.
 
         **tags: dict[str:any]
-            Dictionary of further data point metadata, such as binning info, angles, etc.
+            Dictionary of further data point metadata, such as binning
+            info, angles, etc.
         """
         self.data_type = data_type
         self.tracers = tracers
@@ -258,18 +287,22 @@ class DataPoint:
         if (data_type in required_tags) and (not ignore_missing_tags):
             for tag in required_tags[data_type]:
                 if tag not in tags:
-                    raise ValueError(f"Tag {tag} required for data type {data_type} (ignore_missing_tags=False)")
-
+                    raise ValueError("Tag {tag} required for data type "
+                                     f"{data_type} "
+                                     "(ignore_missing_tags=False)")
 
-        # We encourage people to use existing type names, and issue a warning if they do
-        # not to prod them in the right direction.
-        # We are removing this warning until we converge on what the data types should be
-        # if data_type not in standard_types:
-        #     warnings.warn(f"Unknown data_type value {data_type}. If possible use a pre-defined type, or add to the list.")
+        # We encourage people to use existing type names, and issue a
+        # warning if they do not to prod them in the right direction.
+        if data_type not in standard_types:
+            warnings.warn(f"Unknown data_type value {data_type}. "
+                          "If possible use a pre-defined type, or "
+                          "add to the list.")
 
     def __repr__(self):
-        t = ", ".join(f'{k}={v}' for (k,v) in self.tags.items())
-        return f"DataPoint(data_type='{self.data_type}', tracers={self.tracers}, value={self.value}, {t})"
+        t = ", ".join(f'{k}={v}' for (k, v) in self.tags.items())
+        st = f"DataPoint(data_type='{self.data_type}', "
+        st += f"tracers={self.tracers}, value={self.value}, {t})"
+        return st
 
     def get_tag(self, tag, default=None):
         """
@@ -398,8 +431,10 @@ class DataPoint:
                 # This is mainly used for Window instances.
                 if k in lookups:
                     tags[k] = lookups[k].get(v, v)
-                # Now delete and null values, as indicated by the sentinel above.
-                if hasattr(tags[k], 'dtype') and v == null_values[tags[k].dtype.kind]:
+                # Now delete and null values, as indicated by the
+                # sentinel above.
+                if ((hasattr(tags[k], 'dtype')) and
+                        (v == null_values[tags[k].dtype.kind])):
                     del tags[k]
             # Finally convert back to a data point and record
             data_point = cls(data_type, tracers, value, **tags)
diff --git a/sacc/sacc.py b/sacc/sacc.py
index 4f51fe0..f875211 100644
--- a/sacc/sacc.py
+++ b/sacc/sacc.py
@@ -6,11 +6,12 @@ from astropy.io import fits
 from astropy.table import Table
 
 from .tracers import BaseTracer
-from .windows import BaseWindow
+from .windows import BaseWindow, BandpowerWindow
 from .covariance import BaseCovariance, concatenate_covariances
 from .utils import unique_list
 from .data_types import standard_types, DataPoint
 
+
 class Sacc:
     """
     A class containing a selection of LSST summary statistic measurements,
@@ -75,7 +76,8 @@ class Sacc:
                 return (dt, row.tracers, 0.0)
         # This from
         # https://stackoverflow.com/questions/6422700/how-to-get-indices-of-a-sorted-array-in-python
-        indices = [i[0] for i in sorted(enumerate(self.data), key=lambda x:order_key(x[1]))]
+        indices = [i[0] for i in sorted(enumerate(self.data),
+                                        key=lambda x:order_key(x[1]))]
 
         # Assign the new order.
         self.reorder(indices)
@@ -101,7 +103,8 @@ class Sacc:
     # Builder methods for building up Sacc data from scratch in memory
     #
 
-    def add_tracer(self, tracer_type, name, *args, **kwargs):
+    def add_tracer(self, tracer_type, name,
+                   *args, **kwargs):
         """
         Add a new tracer
 
@@ -130,7 +133,8 @@ class Sacc:
         None
 
         """
-        tracer = BaseTracer.make(tracer_type, name, *args, **kwargs)
+        tracer = BaseTracer.make(tracer_type, name,
+                                 *args, **kwargs)
         self.add_tracer_object(tracer)
 
     def add_tracer_object(self, tracer):
@@ -146,7 +150,8 @@ class Sacc:
         """
         self.tracers[tracer.name] = tracer
 
-    def add_data_point(self, data_type, tracers, value, tracers_later=False, **tags):
+    def add_data_point(self, data_type, tracers, value,
+                       tracers_later=False, **tags):
         """
         Add a data point to the set.
 
@@ -155,17 +160,19 @@ class Sacc:
         data_type: str
 
         tracers: tuple of str
-            Strings corresponding to zero or more of the tracers in the data set
-            These should either be already set up using the add_tracer method,
-            or you could set tracers_later=True if you want to add them later.
-            e.g. for 2pt measurements the tracers are the names of the two n(z)
-            samples
+            Strings corresponding to zero or more of the tracers
+            in the data set. These should either be already set up
+            using the add_tracer method, or you could set
+            tracers_later=True if you want to add them later.
+            e.g. for 2pt measurements the tracers are the names of
+            the two n(z) samples.
 
         value: float
             A single value for the data point
 
         tracers_later: bool
-            If True, do not complain if the tracers are not know already
+            If True, do not complain if the tracers are not know
+            already.
 
         **tags:
             Tags to apply to this data point.
@@ -177,12 +184,15 @@ class Sacc:
         None
         """
         if self.has_covariance():
-            raise ValueError("You cannot add a data point after setting the covariance")
+            raise ValueError("You cannot add a data point after "
+                             "setting the covariance")
         tracers = tuple(tracers)
         for tracer in tracers:
             if (tracer not in self.tracers) and (not tracers_later):
-                raise ValueError(f"Tracer named '{tracer}' is not in the known list of tracers."
-                                 "Either put it in before adding data points or set tracers_later=True")
+                raise ValueError(f"Tracer named '{tracer}' is not in the "
+                                 "known list of tracers. "
+                                 "Either put it in before adding data "
+                                 "points or set tracers_later=True")
         d = DataPoint(data_type, tracers, value, **tags)
         self.data.append(d)
 
@@ -208,7 +218,8 @@ class Sacc:
 
         expected_size = len(self)
         if not cov.size == expected_size:
-            raise ValueError(f"Covariance has the wrong size.  Should be {expected_size} but is {cov.size}")
+            raise ValueError("Covariance has the wrong size. "
+                             f"Should be {expected_size} but is {cov.size}")
 
         self.covariance = cov
 
@@ -225,7 +236,8 @@ class Sacc:
     def _indices_to_bool(self, indices):
         # Convert an array of indices into a boolean True mask
         if indices.dtype not in [np.int8, np.int16, np.int32, np.int64]:
-            raise ValueError(f"Wrong indices type ({indices.dtype}) - expected integers or boolean")
+            raise ValueError(f"Wrong indices type ({indices.dtype}) - "
+                             "expected integers or boolean")
         m = np.zeros(len(self), dtype=bool)
         for i in indices:
             m[i] = True
@@ -233,21 +245,23 @@ class Sacc:
 
     def keep_indices(self, indices):
         """
-        Select data points, keeping only values where the mask is True or an index is
-        included in it.
+        Select data points, keeping only values where the mask is True or
+        an index is included in it.
 
-        You can use Sacc.remove_indices to do the opposite operation, keeping points where the mask
-        is False.
+        You can use Sacc.remove_indices to do the opposite operation,
+        keeping points where the mask is False.
 
-        You use the Sacc.keep_selection method to find indices and apply this method automatically,
-        or the Sacc.indices method to manually select indices.
+        You use the Sacc.keep_selection method to find indices and apply
+        this method automatically, or the Sacc.indices method to manually
+        select indices.
 
         Parameters
         ----------
         indices: array or list
-            Mask must be either a boolean array or a list/array of integer indices to remove.
-            if boolean then True means to keep a data point and False means to cut it
-            if integers then values indicate data points to keep
+            Mask must be either a boolean array or a list/array of integer
+            indices to remove. If boolean then True means to keep a data
+            point and False means to cut it if integers then values
+            indicate data points to keep.
         """
         indices = np.array(indices)
 
@@ -261,21 +275,23 @@ class Sacc:
 
     def remove_indices(self, indices):
         """
-        Remove data points, getting rid of points where the mask is True or an index is
-        included in it.
+        Remove data points, getting rid of points where the mask is True
+        or an index is included in it.
 
-        You can use Sacc.keep_indices to do the opposite operation, keeping points where the mask
-        is True.
+        You can use Sacc.keep_indices to do the opposite operation,
+        keeping points where the mask is True.
 
-        You use the Sacc.remove_selection method to find indices and apply this method automatically,
-        or the Sacc.indices method to manually select indices.
+        You use the Sacc.remove_selection method to find indices and
+        apply this method automatically, or the Sacc.indices method to
+        manually select indices.
 
         Parameters
         ----------
         indices: array or list
-            Mask must be either a boolean array or a list/array of integer indices to remove.
-            if boolean then True means to cut data point and False means to keep it
-            if integers then values indicate data points to cut out
+            Mask must be either a boolean array or a list/array of
+            integer indices to remove. If boolean then True means
+            to cut data point and False means to keep it if integers
+            then values indicate data points to cut out
         """
         indices = np.array(indices)
 
@@ -345,21 +361,24 @@ class Sacc:
             # Record this index
             if ok:
                 indices.append(i)
-        if len(indices)==0 and warn_empty:
+        if len(indices) == 0 and warn_empty:
             if tracers is None:
                 warnings.warn("Empty index selected")
             else:
-                warnings.warn("Empty index selected - maybe you should check the tracer order?")
+                warnings.warn("Empty index selected - maybe you "
+                              "should check the tracer order?")
         return np.array(indices, dtype=int)
 
-    def remove_selection(self, data_type=None, tracers=None, warn_empty=True, **select):
+    def remove_selection(self, data_type=None, tracers=None,
+                         warn_empty=True, **select):
         """
         Remove data points, getting rid of points matching the given criteria.
 
-        You can use Sacc.keep_selection to do the opposite operation, keeping points where the
-        criteria are matched.
+        You can use Sacc.keep_selection to do the opposite operation, keeping
+        points where the criteria are matched.
 
-        You can manually remove points using the Sacc.indices and Sacc.remove_indices methods.
+        You can manually remove points using the Sacc.indices and
+        Sacc.remove_indices methods.
 
         Parameters
         ----------
@@ -379,17 +398,20 @@ class Sacc:
             less or greater than a threshold
         """
 
-        indices = self.indices(data_type=data_type, tracers=tracers, warn_empty=warn_empty, **select)
+        indices = self.indices(data_type=data_type, tracers=tracers,
+                               warn_empty=warn_empty, **select)
         self.remove_indices(indices)
 
-    def keep_selection(self, data_type=None, tracers=None, warn_empty=True, **select):
+    def keep_selection(self, data_type=None, tracers=None,
+                       warn_empty=True, **select):
         """
         Remove data points, keeping only points matching the given criteria.
 
-        You can use Sacc.remove_selection to do the opposite operation, keeping points where the
-        criteria are not matched.
+        You can use Sacc.remove_selection to do the opposite operation,
+        keeping points where the criteria are not matched.
 
-        You can manually remove points using the Sacc.indices and Sacc.keep_indices methods.
+        You can manually remove points using the Sacc.indices and
+        Sacc.keep_indices methods.
 
         Parameters
         ----------
@@ -408,10 +430,10 @@ class Sacc:
             name__gt=value in the selection to select points
             less or greater than a threshold
         """
-        indices = self.indices(data_type=data_type, tracers=tracers, warn_empty=warn_empty, **select)
+        indices = self.indices(data_type=data_type, tracers=tracers,
+                               warn_empty=warn_empty, **select)
         self.keep_indices(indices)
 
-
     def _get_tags_by_index(self, tags, indices):
         """
         Get the value of a one or more named tags for (a subset of) the data.
@@ -428,13 +450,15 @@ class Sacc:
         Returns
         -------
         values: list of lists
-            For each input tag, a corresponding list of the value of that tag for given
-            selection, in the order the matching data points were added.
+            For each input tag, a corresponding list of the value of that
+            tag for given selection, in the order the matching data points
+            were added.
 
 
         """
         indices = set(indices)
-        values = [[d.get_tag(tag) for i, d in enumerate(self.data) if i in indices]
+        values = [[d.get_tag(tag)
+                   for i, d in enumerate(self.data) if i in indices]
                   for tag in tags]
         return values
 
@@ -466,12 +490,12 @@ class Sacc:
         Returns
         -------
         values: list of lists
-            For each input tag, a corresponding list of the value of that tag for given
-            selection, in the order the matching data points were added.
-
-
+            For each input tag, a corresponding list of the value of
+            that tag for given selection, in the order the matching
+            data points were added.
         """
-        indices = self.indices(data_type=data_type, tracers=tracers, **select)
+        indices = self.indices(data_type=data_type,
+                               tracers=tracers, **select)
         return self._get_tags_by_index(tags, indices)
 
     def get_tag(self, tag, data_type=None, tracers=None, **select):
@@ -503,10 +527,9 @@ class Sacc:
         values: list
             A list of the value of the tag for given selection,
             in the order the matching data points were added.
-
-
         """
-        return self.get_tags([tag], data_type=data_type, tracers=tracers, **select)[0]
+        return self.get_tags([tag], data_type=data_type,
+                             tracers=tracers, **select)[0]
 
     def get_data_points(self, data_type=None, tracers=None, **select):
         """
@@ -641,7 +664,8 @@ class Sacc:
         """
         if not len(mu) == len(self.data):
             raise ValueError("Tried to set mean with thing of length {}"
-                             " but data is length {}".format(len(mu), len(self.data)))
+                             " but data is length {}".format(len(mu),
+                                                             len(self.data)))
         for m, d in zip(mu, self.data):
             d.value = m
 
@@ -700,7 +724,8 @@ class Sacc:
         for i, (k, v) in enumerate(S.metadata.items()):
             hdr[f'KEY{i}'] = k
             hdr[f'VAL{i}'] = v
-        hdus = [fits.PrimaryHDU(header=hdr)] + [fits.table_to_hdu(table) for table in tables]
+        hdus = [fits.PrimaryHDU(header=hdr)] + \
+               [fits.table_to_hdu(table) for table in tables]
 
         # Covariance, if needed.
         # All the other data elements become astropy tables first,
@@ -729,9 +754,14 @@ class Sacc:
         hdu_list = fits.open(filename, "readonly")
 
         # Split the HDU's into the different sacc types
-        tracer_tables = [Table.read(hdu) for hdu in hdu_list if hdu.header.get('SACCTYPE') == 'tracer']
-        window_tables = [Table.read(hdu) for hdu in hdu_list if hdu.header.get('SACCTYPE') == 'window']
-        data_tables = [Table.read(hdu) for hdu in hdu_list if hdu.header.get('SACCTYPE') == 'data']
+        tracer_tables = [Table.read(hdu)
+                         for hdu in hdu_list
+                         if hdu.header.get('SACCTYPE') == 'tracer']
+        window_tables = [Table.read(hdu)
+                         for hdu in hdu_list
+                         if hdu.header.get('SACCTYPE') == 'window']
+        data_tables = [Table.read(hdu) for hdu in hdu_list
+                       if hdu.header.get('SACCTYPE') == 'data']
         cov = [hdu for hdu in hdu_list if hdu.header.get('SACCTYPE') == 'cov']
 
         # Pull out the classes for these components.
@@ -785,7 +815,8 @@ class Sacc:
     #
     #
 
-    def _get_2pt(self, data_type, tracer1, tracer2, return_cov, angle_name):
+    def _get_2pt(self, data_type, tracer1, tracer2, return_cov,
+                 angle_name, return_ind=False):
         # Internal helper method for get_ell_cl and get_theta_xi
         ind = self.indices(data_type, (tracer1, tracer2))
 
@@ -794,13 +825,53 @@ class Sacc:
 
         if return_cov:
             if not self.has_covariance():
-                raise ValueError("This sacc data does not have a covariance attached")
+                raise ValueError("This sacc data does not have "
+                                 "a covariance attached")
             cov_block = self.covariance.get_block(ind)
-            return angle, mu, cov_block
+            if return_ind:
+                return angle, mu, cov_block, ind
+            else:
+                return angle, mu, cov_block
+        else:
+            if return_ind:
+                return angle, mu, ind
+            else:
+                return angle, mu
+
+    def get_bandpower_windows(self, indices):
+        """
+        Returns bandpower window functoins for a given set of datapoints.
+        All datapoints must share the same bandpower window.
+
+        Parameters
+        ----------
+        indices: array
+            indices of the data points you want windows for
+
+        Returns
+        -------
+        windows: BandpowerWindow object containing the bandpower window
+            functions for these indices.
+        """
+        ws = unique_list(self.data[i].tags.get('window') for i in indices)
+        if len(ws) != 1:
+            raise ValueError("You have asked for window functions, "
+                             "however, the points you have selected "
+                             "have different windows associated to them."
+                             "Please narrow down your selection (specify "
+                             "tracers and data type) or get windows "
+                             "later.")
+        ws = ws[0]
+        if not isinstance(ws, BandpowerWindow):
+            warnings.warn("No bandpower windows associated to these data")
+            return None
         else:
-            return angle, mu
+            w_inds = np.array(self._get_tags_by_index(['window_ind'],
+                                                      indices)[0])
+            return ws.get_section(w_inds)
 
-    def get_ell_cl(self, data_type, tracer1, tracer2, return_cov=False):
+    def get_ell_cl(self, data_type, tracer1, tracer2,
+                   return_cov=False, return_ind=False):
         """
         Helper method to extract the ell and C_ell values for a specific
         data type (e.g. 'shear_ee' and pair of tomographic bins)
@@ -820,22 +891,30 @@ class Sacc:
             If True, also return the block of the covariance
             corresponding to these points.  Default=False
 
+        return_ind: bool
+            If True, also return the datapoint indices. Default=False
+
         Returns
         -------
         ell: array
             Ell values for this tracer pair
         mu: array
             Mean values for this tracer pair
-        cov_block: 2x2 array
+        cov_block: 2D array
             (Only if return_cov=True) The block of the covariance for
             these points
+        indices: array
+            (Only if return_ind=True) datapoint indices.
         """
-        return self._get_2pt(data_type, tracer1, tracer2, return_cov, 'ell')
+        return self._get_2pt(data_type, tracer1, tracer2, return_cov,
+                             'ell', return_ind)
 
-    def get_theta_xi(self, data_type, tracer1, tracer2, return_cov=False):
+    def get_theta_xi(self, data_type, tracer1, tracer2,
+                     return_cov=False, return_ind=False):
         """
-        Helper method to extract the theta and correlation function values for a specific
-        data type (e.g. 'shear_xi' and pair of tomographic bins)
+        Helper method to extract the theta and correlation function
+        values for a specific data type (e.g. 'shear_xi' and pair of
+        tomographic bins).
 
         Parameters
         ----------
@@ -853,6 +932,9 @@ class Sacc:
             If True, also return the block of the covariance
             corresponding to these points.  Default=False
 
+        return_ind: bool
+            If True, also return the datapoint indices. Default=False
+
         Returns
         -------
         ell: array
@@ -861,13 +943,17 @@ class Sacc:
         mu: array
             Mean values for this tracer pair
 
-        cov_block: 2x2 array
+        cov_block: 2D array
             (Only if return_cov=True) The block of the covariance for
             these points
+        indices: array
+            (Only if return_ind=True) datapoint indices.
         """
-        return self._get_2pt(data_type, tracer1, tracer2, return_cov, 'theta')
+        return self._get_2pt(data_type, tracer1, tracer2, return_cov,
+                             'theta', return_ind)
 
-    def _add_2pt(self, data_type, tracer1, tracer2, x, tag_val, tag_name, window, tracers_later):
+    def _add_2pt(self, data_type, tracer1, tracer2, x, tag_val, tag_name,
+                 window, tracers_later, tag_extra=None, tag_extra_name=None):
         """
         Internal method for adding 2pt data points.
         Copes with multiple values for the parameters
@@ -875,36 +961,64 @@ class Sacc:
         # single data point case
         if np.isscalar(tag_val):
             t = {tag_name: float(tag_val)}
+            if tag_extra_name is not None:
+                t[tag_extra_name] = tag_extra
             if window is not None:
                 t['window'] = window
-            self.add_data_point(data_type, (tracer1, tracer2), x, tracers_later=tracers_later, **t)
+            self.add_data_point(data_type, (tracer1, tracer2), x,
+                                tracers_later=tracers_later, **t)
             return
         # multiple ell/theta values but same bin
         elif np.isscalar(tracer1):
             n1 = len(x)
             n2 = len(tag_val)
-            if not n1 == n2:
-                raise ValueError(f"Length of inputs do not match in added 2pt data ({n1},{n2})")
+            if tag_extra_name is None:
+                tag_extra = np.zeros(n1)
+                n3 = n1
+            else:
+                n3 = len(tag_extra)
+            if not (n1 == n2 == n3):
+                raise ValueError("Length of inputs do not match in"
+                                 f"added 2pt data ({n1},{n2},{n3})")
             if window is None:
-                for tag_i, x_i in zip(tag_val, x):
-                    self._add_2pt(data_type, tracer1, tracer2, x_i, tag_i, tag_name, window, tracers_later)
+                for tag_i, x_i, te_i in zip(tag_val, x, tag_extra):
+                    self._add_2pt(data_type, tracer1, tracer2, x_i,
+                                  tag_i, tag_name, window,
+                                  tracers_later, te_i, tag_extra_name)
             else:
-                for tag_i, x_i, w_i in zip(tag_val, x, window):
-                    self._add_2pt(data_type, tracer1, tracer2, x_i, tag_i, tag_name, w_i, tracers_later)
+                for tag_i, x_i, w_i, te_i in zip(tag_val, x,
+                                                 window, tag_extra):
+                    self._add_2pt(data_type, tracer1, tracer2, x_i,
+                                  tag_i, tag_name, w_i,
+                                  tracers_later, te_i, tag_extra_name)
         # multiple bin values
         elif np.isscalar(data_type):
             n1 = len(x)
             n2 = len(tag_val)
             n3 = len(tracer1)
             n4 = len(tracer2)
-            if not (n1 == n2 == n3 == n4):
-                raise ValueError(f"Length of inputs do not match in added 2pt data ({n1}, {n2}, {n3}, {n4})")
+            if tag_extra_name is None:
+                tag_extra = np.zeros(n1)
+                n5 = n1
+            else:
+                n5 = len(tag_extra)
+            if not (n1 == n2 == n3 == n4 == n5):
+                raise ValueError("Length of inputs do not match in "
+                                 f"added 2pt data ({n1},{n2},{n3},{n4},{n5})")
             if window is None:
-                for b1, b2, tag_i, x_i in zip(tracer1, tracer2, tag_val, x):
-                    self._add_2pt(data_type, b1, b2, x_i, tag_i, tag_name, window, tracers_later)
+                for b1, b2, tag_i, x_i, te_i in zip(tracer1, tracer2, tag_val,
+                                                    x, tag_extra):
+                    self._add_2pt(data_type, b1, b2, x_i, tag_i, tag_name,
+                                  window, tracers_later, te_i, tag_extra_name)
             else:
-                for b1, b2, tag_i, x_i, w_i in zip(tracer1, tracer2, tag_val, x, window):
-                    self._add_2pt(data_type, b1, x_i, tag_i, tag_name, w_i, tracers_later)
+                for b1, b2, tag_i, x_i, w_i, te_i in zip(tracer1,
+                                                         tracer2,
+                                                         tag_val,
+                                                         x,
+                                                         window,
+                                                         tag_extra):
+                    self._add_2pt(data_type, b1, x_i, tag_i, tag_name,
+                                  w_i, tracers_later, te_i, tag_extra_name)
         # multiple data point values
         else:
             n1 = len(x)
@@ -912,16 +1026,38 @@ class Sacc:
             n3 = len(tracer1)
             n4 = len(tracer2)
             n5 = len(data_type)
-            if not (n1 == n2 == n3 == n4 == n5):
-                raise ValueError(f"Length of inputs do not match in added 2pt data ({n1}, {n2}, {n3}, {n4}, {n5})")
+            if tag_extra_name is None:
+                tag_extra = np.zeros(n1)
+                n6 = n1
+            else:
+                n6 = len(tag_extra)
+            if not (n1 == n2 == n3 == n4 == n5 == n6):
+                raise ValueError("Length of inputs do not match in added "
+                                 f"2pt data ({n1},{n2},{n3},{n4},{n5},{n6})")
             if window is None:
-                for d, b1, b2, tag_i, x_i in zip(data_type, tracer1, tracer2, tag_val, x):
-                    self._add_2pt(d, b1, b2, x_i, tag_i, tag_name, window, tracers_later)
+                for d, b1, b2, tag_i, x_i, te_i in zip(data_type,
+                                                       tracer1,
+                                                       tracer2,
+                                                       tag_val,
+                                                       x,
+                                                       tag_extra):
+                    self._add_2pt(d, b1, b2, x_i, tag_i, tag_name,
+                                  window, tracers_later,
+                                  te_i, tag_extra_name)
             else:
-                for d, b1, b2, tag_i, x_i, w_i in zip(data_type, tracer1, tracer2, tag_val, x, window):
-                    self._add_2pt(d, b1, b2, x_i, tag_i, tag_name, w_i, tracers_later)
-
-    def add_ell_cl(self, data_type, tracer1, tracer2, ell, x, window=None, tracers_later=False):
+                for d, b1, b2, tag_i, x_i, w_i, te_i in zip(data_type,
+                                                            tracer1,
+                                                            tracer2,
+                                                            tag_val,
+                                                            x,
+                                                            window,
+                                                            tag_extra):
+                    self._add_2pt(d, b1, b2, x_i, tag_i, tag_name,
+                                  w_i, tracers_later,
+                                  te_i, tag_extra_name)
+
+    def add_ell_cl(self, data_type, tracer1, tracer2, ell, x,
+                   window=None, tracers_later=False):
         """
         Add a series of 2pt Fourier space data points, either
         individually or as a group.
@@ -948,7 +1084,7 @@ class Sacc:
             of the data point.
 
         tracers_later: bool
-            Optional.  If False (the default), complain if n(z) tracers have 
+            Optional.  If False (the default), complain if n(z) tracers have
             not yet been defined. Otherwise, suppress this warning
 
         Returns
@@ -956,9 +1092,23 @@ class Sacc:
         None
 
         """
-        self._add_2pt(data_type, tracer1, tracer2, x, ell, 'ell', window, tracers_later)
+        if isinstance(window, BandpowerWindow):
+            if len(ell) != window.nv:
+                raise ValueError("Input bandpowers are misshapen")
+            tag_extra = range(window.nv)
+            tag_extra_name = "window_ind"
+            window_use = [window for i in range(window.nv)]
+        else:
+            tag_extra = None
+            tag_extra_name = None
+            window_use = window
+
+        self._add_2pt(data_type, tracer1, tracer2, x, ell, 'ell',
+                      window_use, tracers_later,
+                      tag_extra, tag_extra_name)
 
-    def add_theta_xi(self, data_type, tracer1, tracer2, theta, x, window=None, tracers_later=False):
+    def add_theta_xi(self, data_type, tracer1, tracer2, theta, x,
+                     window=None, tracers_later=False):
         """
         Add a series of 2pt real space data points, either
         individually or as a group.
@@ -985,7 +1135,7 @@ class Sacc:
             of the data point.
 
         tracers_later: bool
-            Optional.  If False (the default), complain if n(z) tracers have 
+            Optional.  If False (the default), complain if n(z) tracers have
             not yet been defined. Otherwise, suppress this warning
 
         Returns
@@ -993,8 +1143,8 @@ class Sacc:
         None
 
         """
-        self._add_2pt(data_type, tracer1, tracer2, x, theta, 'theta', window, tracers_later)
-
+        self._add_2pt(data_type, tracer1, tracer2, x, theta, 'theta',
+                      window, tracers_later)
 
 
 def concatenate_data_sets(*data_sets, labels=None):
@@ -1014,7 +1164,8 @@ def concatenate_data_sets(*data_sets, labels=None):
         The data sets to combined
 
     labels: List[str]
-        Optional list of strings to append to tracer and metadata names, in case of a clash.
+        Optional list of strings to append to tracer and metadata names, in
+        case of a clash.
 
     Returns
     -------
@@ -1028,25 +1179,30 @@ def concatenate_data_sets(*data_sets, labels=None):
 
     # check for wrong number of labels
     if labels is not None:
-        if len(labels)!=len(data_sets):
-            raise ValueError("Wrong number of labels supplied when concatenating data sets")
+        if len(labels) != len(data_sets):
+            raise ValueError("Wrong number of labels supplied when "
+                             "concatenating data sets")
 
     data_0 = data_sets[0]
 
-    # Either all the data sets should have covariances or none of them should.  Concatenating
-    # covariances should be straightforward and should always result in a block-diagonal covariance
+    # Either all the data sets should have covariances or none of
+    # them should.  Concatenating covariances should be
+    # straightforward and should always result in a block-diagonal
+    # covariance
     if data_0.has_covariance():
-        if not all(data_set.has_covariance() for data_set in data_sets):
-            raise ValueError("Either all concatenated data sets must have covariances, "
-                             "or none of them")
+        if not all(data_set.has_covariance()
+                   for data_set in data_sets):
+            raise ValueError("Either all concatenated data sets must "
+                             "have covariances, or none of them")
     else:
-        if any(data_set.has_covariance() for data_set in data_sets):
-            raise ValueError("Either all concatenated data sets must have covariances, "
-                             "or none of them")
+        if any(data_set.has_covariance()
+               for data_set in data_sets):
+            raise ValueError("Either all concatenated data sets must "
+                             "have covariances, or none of them")
 
     output = Sacc()
 
-    # Copy the tracers to the new 
+    # Copy the tracers to the new
     for i, data_set in enumerate(data_sets):
         for tracer in data_set.tracers.values():
 
@@ -1063,12 +1219,15 @@ def concatenate_data_sets(*data_sets, labels=None):
             # happen if they have chosen really really bad labels
             if tracer.name in output.tracers:
                 if labels is None:
-                    raise ValueError("There is a name clash between tracers in the data sets."
-                                     "Use the labels option to give new names to them")
+                    raise ValueError("There is a name clash between "
+                                     "tracers in the data sets. "
+                                     "Use the labels option to give "
+                                     "new names to them")
                 else:
-                    raise ValueError("After applying your labels there is still a name "
-                                     "clash between tracers in your concatenation.  Try "
-                                     "different labels?")
+                    raise ValueError("After applying your labels "
+                                     "there is still a name clash "
+                                     "between tracers in your concatenation."
+                                     " Try different labels?")
             # Build up the combined tracer collection
             output.add_tracer_object(tracer)
 
@@ -1088,7 +1247,8 @@ def concatenate_data_sets(*data_sets, labels=None):
                 # For consistency with the tracers we don't include an
                 # underscore
                 orig_label = d.get_tag('label', '')
-                d.tags['label'] = f'{orig_label}_{label}' if orig_label else label
+                d.tags['label'] = (f'{orig_label}_{label}'
+                                   if orig_label else label)
 
             # And build up the combined data vector
             output.data.append(d)
@@ -1110,9 +1270,9 @@ def concatenate_data_sets(*data_sets, labels=None):
 
             # Check for clashing metadata
             if key in output.metadata:
-                raise ValueError("Metadata in concatenated Saccs have same name. "
-                    "Set the labels parameter to fix this.")
-
-            output.metadata[key] = value
+                raise ValueError("Metadata in concatenated Saccs have "
+                                 "same name. Set the labels parameter "
+                                 "to fix this.")
+            output.metadata[key] = val
 
-    return output
\ No newline at end of file
+    return output
diff --git a/sacc/tracers.py b/sacc/tracers.py
index eee5f4d..43fea79 100644
--- a/sacc/tracers.py
+++ b/sacc/tracers.py
@@ -1,6 +1,23 @@
 import numpy as np
 from astropy.table import Table
-from .utils import Namespace, hide_null_values, remove_dict_null_values, unique_list
+from .utils import (Namespace, hide_null_values,
+                    remove_dict_null_values, unique_list)
+import warnings
+
+standard_quantities = Namespace('galaxy_shear',
+                                'galaxy_density',
+                                'galaxy_convergence',
+                                'cluster_density',
+                                'cmb_temperature',
+                                'cmb_polarization',
+                                'cmb_convergence',
+                                'cmb_tSZ',
+                                'cmb_kSZ',
+                                'cluster_mass_count_wl',
+                                'cluster_mass_count_xray',
+                                'cluster_mass_count_tSZ',
+                                'generic')
+
 
 class BaseTracer:
     """
@@ -20,7 +37,15 @@ class BaseTracer:
     _tracer_classes = {}
 
     def __init__(self, name, **kwargs):
+        # We encourage people to use existing quantity names, and issue a
+        # warning if they do not to prod them in the right direction.
+        quantity = kwargs.pop('quantity', 'generic')
+        if quantity not in standard_quantities:
+            warnings.warn(f"Unknown quantity {quantity}. "
+                          "If possible use a pre-defined quantity, or "
+                          "add to the list.")
         self.name = name
+        self.quantity = quantity
         self.metadata = kwargs.pop('metadata', {})
 
     def __init_subclass__(cls, tracer_type):
@@ -40,8 +65,7 @@ class BaseTracer:
             Must correspond to the tracer_type of a subclass
 
         name: str
-            The name for this specific tracer, e.g. a
-            tomographic bin identifier.
+            The name for this specific tracer.
 
         Returns
         -------
@@ -65,7 +89,7 @@ class BaseTracer:
         Some tracers generate a single table for all of the
         different instances, and others generate one table per
         instance.
-    
+
         Parameters
         ----------
         instance_list: list
@@ -94,8 +118,8 @@ class BaseTracer:
         It is not quite the inverse of the to_tables method, since it
         returns a dict instead of a list.
 
-        Subclasses overrides of this method do the actual work, but should *NOT* call
-        this parent base method.
+        Subclasses overrides of this method do the actual work, but
+        should *NOT* call this parent base method.
 
         Parameters
         ----------
@@ -109,28 +133,30 @@ class BaseTracer:
         """
         tracers = {}
         # Figure out the different subclasses that are present
-        subclass_names = unique_list(table.meta['SACCCLSS'] for table in table_list)
-        subclasses = [cls._tracer_classes[name] for name in subclass_names]
+        subclass_names = unique_list(table.meta['SACCCLSS']
+                                     for table in table_list)
+        subclasses = [cls._tracer_classes[name]
+                      for name in subclass_names]
 
         # For each subclass find the tables representing that subclass.
         # We do it like this because we might want to represent one tracer with
-        # multiple tables, or one table can have multiple tracers - it depends on
-        # the tracers class and how complicated it is.
+        # multiple tables, or one table can have multiple tracers -
+        # it depends on the tracers class and how complicated it is.
         for name, subcls in zip(subclass_names, subclasses):
-            subcls_table_list = [table for table in table_list if table.meta['SACCCLSS']==name]
+            subcls_table_list = [table for table in table_list
+                                 if table.meta['SACCCLSS'] == name]
             # and ask the subclass to read from those tables.
             tracers.update(subcls.from_tables(subcls_table_list))
         return tracers
 
 
-
-class MiscTracer(BaseTracer, tracer_type='misc'):
+class MiscTracer(BaseTracer, tracer_type='Misc'):
     """A Tracer type for miscellaneous other data points.
 
     MiscTracers do not have any attributes except for their
     name, so can be used for tagging external data, for example.
 
-    Attributes
+    Parameters
     ----------
     name: str
         The name of the tracer
@@ -169,11 +195,13 @@ class MiscTracer(BaseTracer, tracer_type='misc'):
             metadata_cols.update(obj.metadata.keys())
         metadata_cols = list(metadata_cols)
 
-        cols = [[obj.name for obj in instance_list]]
+        cols = [[obj.name for obj in instance_list],
+                [obj.quantity for obj in instance_list]]
         for name in metadata_cols:
             cols.append([obj.metadata.get(name) for obj in instance_list])
 
-        table = Table(data=cols, names=['name']+ metadata_cols)
+        table = Table(data=cols,
+                      names=['name', 'quantity'] + metadata_cols)
         table.meta['SACCTYPE'] = 'tracer'
         table.meta['SACCCLSS'] = cls.tracer_type
         table.meta['EXTNAME'] = f'tracer:{cls.tracer_type}'
@@ -184,7 +212,7 @@ class MiscTracer(BaseTracer, tracer_type='misc'):
     def from_tables(cls, table_list):
         """Convert a list of astropy table into a dictionary of MiscTracer instances.
 
-        In general table_list should have a single element in, since all the 
+        In general table_list should have a single element in, since all the
         MiscTracers are stored in a single table during to_tables
 
         Parameters
@@ -198,13 +226,294 @@ class MiscTracer(BaseTracer, tracer_type='misc'):
         tracers = {}
 
         for table in table_list:
-            metadata_cols = [col for col in table.colnames if col != 'name']
-            
+            metadata_cols = [col for col in table.colnames
+                             if col not in ['name', 'quantity']]
+
             for row in table:
                 name = row['name']
+                quantity = row['quantity']
                 metadata = {key: row[key] for key in metadata_cols}
                 remove_dict_null_values(metadata)
-                tracers[name] = cls(name, metadata=metadata)
+                tracers[name] = cls(name, quantity=quantity, metadata=metadata)
+        return tracers
+
+
+class MapTracer(BaseTracer, tracer_type='Map'):
+    """
+    A Tracer type for a sky map.
+
+    Takes at least two arguments, defining the map beam.
+
+    Parameters
+    ----------
+    name: str
+        The name for this specific tracer object.
+    ell: array
+         Array of multipole values at which the beam is defined.
+    beam: array
+         Beam multipoles at each value of ell.
+    beam_extra: array
+         Other beam-related arrays
+         (e.g. uncertainties, principal components,
+         alternative measurements, whatever).
+    map_unit: str
+         Map units (e.g. 'uK_CMB'). 'none' by default.
+    """
+
+    def __init__(self, name, spin, ell, beam,
+                 beam_extra=None, map_unit='none', **kwargs):
+        super().__init__(name, **kwargs)
+        self.spin = spin
+        self.map_unit = map_unit
+        self.ell = np.array(ell)
+        self.beam = np.array(beam)
+        self.beam_extra = {} if beam_extra is None else beam_extra
+
+    @classmethod
+    def to_tables(cls, instance_list):
+        tables = []
+        for tracer in instance_list:
+            # Beams
+            names = ['ell', 'beam']
+            cols = [tracer.ell, tracer.beam]
+            for beam_id, col in tracer.beam_extra.items():
+                names.append(str(beam_id))
+                cols.append(col)
+            table = Table(data=cols, names=names)
+            table.meta['SACCTYPE'] = 'tracer'
+            table.meta['SACCCLSS'] = cls.tracer_type
+            table.meta['SACCNAME'] = tracer.name
+            table.meta['SACCQTTY'] = tracer.quantity
+            extname = f'tracer:{cls.tracer_type}:{tracer.name}:beam'
+            table.meta['EXTNAME'] = extname
+            table.meta['MAP_UNIT'] = tracer.map_unit
+            table.meta['SPIN'] = tracer.spin
+            for key, value in tracer.metadata.items():
+                table.meta['META_'+key] = value
+            remove_dict_null_values(table.meta)
+            tables.append(table)
+        return tables
+
+    @classmethod
+    def from_tables(cls, table_list):
+        tracers = {}
+
+        # Collect beam and bandpass tables describing the same tracer
+        tr_tables = {}
+        for table in table_list:
+            # Read name and table type
+            name = table.meta['SACCNAME']
+            quantity = table.meta['SACCQTTY']
+            tabtyp = table.meta['EXTNAME'].split(':')[-1]
+            if tabtyp not in ['beam']:
+                raise KeyError("Unknown table type " + table.meta['EXTNAME'])
+
+            # If not present yet, create new tracer entry
+            if name not in tr_tables:
+                tr_tables[name] = {}
+            # Add table
+            tr_tables[name][tabtyp] = table
+
+        # Now loop through different tracers and build them from their tables
+        for n, dt in tr_tables.items():
+            quantity = []
+            metadata = {}
+            map_unit = 'none'
+            ell = []
+            beam = []
+            beam_extra = {}
+            spin = 0
+
+            if 'beam' in dt:
+                table = dt['beam']
+                name = table.meta['SACCNAME']
+                quantity = table.meta['SACCQTTY']
+                ell = table['ell']
+                beam = table['beam']
+                for col in table.columns.values():
+                    if col.name not in ['ell', 'beam']:
+                        beam_extra[col.name] = col.data
+                map_unit = table.meta['MAP_UNIT']
+                spin = table.meta['SPIN']
+                for key, value in table.meta.items():
+                    if key.startswith("META_"):
+                        metadata[key[5:]] = value
+
+            tracers[name] = cls(name, spin, ell, beam,
+                                quantity=quantity, beam_extra=beam_extra,
+                                map_unit=map_unit, metadata=metadata)
+        return tracers
+
+
+class NuMapTracer(BaseTracer, tracer_type='NuMap'):
+    """
+    A Tracer type for a sky map at a given frequency.
+
+    Takes at least four arguments, defining the bandpass and beam.
+
+    Parameters
+    ----------
+    name: str
+        The name for this specific tracer, e.g. a frequency band
+        identifier.
+    spin: int
+        Spin for this observable. Either 0 (e.g. intensity)
+        or 2 (e.g. polarization).
+    nu: array
+         Array of frequencies.
+    bandpass: array
+         Bandpass transmission.
+    bandpass_extra: array
+         Other bandpass-related arrays
+         (e.g. uncertainties, principal components,
+         alternative measurements, whatever).
+    ell: array
+         Array of multipole values at which the beam is defined.
+    beam: array
+         Beam.
+    beam_extra: array
+         Other beam-related arrays
+         (e.g. uncertainties, principal components,
+         alternative measurements, whatever).
+    nu_unit: str
+         Frequency units ('GHz' by default).
+    map_unit: str
+         Map units (e.g. 'uK_CMB'). 'none' by default.
+    """
+
+    def __init__(self, name, spin, nu, bandpass,
+                 ell, beam, bandpass_extra=None,
+                 beam_extra=None, nu_unit='GHz',
+                 map_unit='none', **kwargs):
+        super().__init__(name, **kwargs)
+        self.spin = spin
+        self.nu = np.array(nu)
+        self.nu_unit = nu_unit
+        self.map_unit = map_unit
+        self.bandpass = np.array(bandpass)
+        self.bandpass_extra = {} if bandpass_extra is None else bandpass_extra
+        self.ell = np.array(ell)
+        self.beam = np.array(beam)
+        self.beam_extra = {} if beam_extra is None else beam_extra
+
+    @classmethod
+    def to_tables(cls, instance_list):
+        tables = []
+        for tracer in instance_list:
+            # Bandpasses
+            names = ['nu', 'bandpass']
+            cols = [tracer.nu, tracer.bandpass]
+            for bandpass_id, col in tracer.bandpass_extra.items():
+                names.append(str(bandpass_id))
+                cols.append(col)
+            table = Table(data=cols, names=names)
+            table.meta['SACCTYPE'] = 'tracer'
+            table.meta['SACCCLSS'] = cls.tracer_type
+            table.meta['SACCNAME'] = tracer.name
+            table.meta['SACCQTTY'] = tracer.quantity
+            extname = f'tracer:{cls.tracer_type}:{tracer.name}:bandpass'
+            table.meta['EXTNAME'] = extname
+            table.meta['NU_UNIT'] = tracer.nu_unit
+            table.meta['SPIN'] = tracer.spin
+            for key, value in tracer.metadata.items():
+                table.meta['META_'+key] = value
+            remove_dict_null_values(table.meta)
+            tables.append(table)
+
+            # Beams
+            names = ['ell', 'beam']
+            cols = [tracer.ell, tracer.beam]
+            for beam_id, col in tracer.beam_extra.items():
+                names.append(str(beam_id))
+                cols.append(col)
+            table = Table(data=cols, names=names)
+            table.meta['SACCTYPE'] = 'tracer'
+            table.meta['SACCCLSS'] = cls.tracer_type
+            table.meta['SACCNAME'] = tracer.name
+            table.meta['SACCQTTY'] = tracer.quantity
+            extname = f'tracer:{cls.tracer_type}:{tracer.name}:beam'
+            table.meta['EXTNAME'] = extname
+            table.meta['MAP_UNIT'] = tracer.map_unit
+            table.meta['SPIN'] = tracer.spin
+            for key, value in tracer.metadata.items():
+                table.meta['META_'+key] = value
+            remove_dict_null_values(table.meta)
+            tables.append(table)
+        return tables
+
+    @classmethod
+    def from_tables(cls, table_list):
+        tracers = {}
+
+        # Collect beam and bandpass tables describing the same tracer
+        tr_tables = {}
+        for table in table_list:
+            # Read name and table type
+            name = table.meta['SACCNAME']
+            quantity = table.meta['SACCQTTY']
+            tabtyp = table.meta['EXTNAME'].split(':')[-1]
+            if tabtyp not in ['bandpass', 'beam']:
+                raise KeyError("Unknown table type " + table.meta['EXTNAME'])
+
+            # If not present yet, create new tracer entry
+            if name not in tr_tables:
+                tr_tables[name] = {}
+            # Add table
+            tr_tables[name][tabtyp] = table
+
+        # Now loop through different tracers and build them from their tables
+        for n, dt in tr_tables.items():
+            quantity = []
+            metadata = {}
+            nu = []
+            bandpass = []
+            bandpass_extra = {}
+            nu_unit = 'GHz'
+            map_unit = 'none'
+            ell = []
+            beam = []
+            beam_extra = {}
+            spin = 0
+
+            if 'bandpass' in dt:
+                table = dt['bandpass']
+                name = table.meta['SACCNAME']
+                quantity = table.meta['SACCQTTY']
+                nu = table['nu']
+                bandpass = table['bandpass']
+                for col in table.columns.values():
+                    if col.name not in ['nu', 'bandpass']:
+                        bandpass_extra[col.name] = col.data
+                nu_unit = table.meta['NU_UNIT']
+                spin = table.meta['SPIN']
+                for key, value in table.meta.items():
+                    if key.startswith("META_"):
+                        metadata[key[5:]] = value
+
+            if 'beam' in dt:
+                table = dt['beam']
+                name = table.meta['SACCNAME']
+                quantity = table.meta['SACCQTTY']
+                ell = table['ell']
+                beam = table['beam']
+                for col in table.columns.values():
+                    if col.name not in ['ell', 'beam']:
+                        beam_extra[col.name] = col.data
+                map_unit = table.meta['MAP_UNIT']
+                spin = table.meta['SPIN']
+                for key, value in table.meta.items():
+                    if key.startswith("META_"):
+                        metadata[key[5:]] = value
+
+            tracers[name] = cls(name, spin,
+                                nu, bandpass,
+                                ell, beam,
+                                quantity=quantity,
+                                bandpass_extra=bandpass_extra,
+                                beam_extra=beam_extra,
+                                map_unit=map_unit,
+                                nu_unit=nu_unit,
+                                metadata=metadata)
         return tracers
 
 
@@ -214,19 +523,24 @@ class NZTracer(BaseTracer, tracer_type='NZ'):
 
     Takes two arguments arrays of z and n(z)
 
-    Attributes
+    Parameters
     ----------
+    name: str
+        The name for this specific tracer, e.g. a
+        tomographic bin identifier.
+
     z: array
         Redshift sample values
 
     nz: array
         Number density n(z) at redshift sample points.
 
-    extra_columns: dict[str: array] or dict[int:array]
+    extra_columns: dict[str: array] or dict[int: array]
         Additional estimates of the same n(z), by name
     """
 
-    def __init__(self, name, z, nz, extra_columns=None, **kwargs):
+    def __init__(self, name, z, nz,
+                 extra_columns=None, **kwargs):
         """
         Create a tracer corresponding to a distribution in redshift n(z),
         for example of galaxies.
@@ -285,6 +599,7 @@ class NZTracer(BaseTracer, tracer_type='NZ'):
             table.meta['SACCTYPE'] = 'tracer'
             table.meta['SACCCLSS'] = cls.tracer_type
             table.meta['SACCNAME'] = tracer.name
+            table.meta['SACCQTTY'] = tracer.quantity
             table.meta['EXTNAME'] = f'tracer:{cls.tracer_type}:{tracer.name}'
             for key, value in tracer.metadata.items():
                 table.meta['META_'+key] = value
@@ -314,6 +629,7 @@ class NZTracer(BaseTracer, tracer_type='NZ'):
         tracers = {}
         for table in table_list:
             name = table.meta['SACCNAME']
+            quantity = table.meta['SACCQTTY']
             z = table['z']
             nz = table['nz']
             extra_columns = {}
@@ -325,5 +641,8 @@ class NZTracer(BaseTracer, tracer_type='NZ'):
             for key, value in table.meta.items():
                 if key.startswith("META_"):
                     metadata[key[5:]] = value
-            tracers[name] = cls(name, z, nz, extra_columns=extra_columns, metadata=metadata)
+            tracers[name] = cls(name, z, nz,
+                                quantity=quantity,
+                                extra_columns=extra_columns,
+                                metadata=metadata)
         return tracers
diff --git a/sacc/utils.py b/sacc/utils.py
index 8511892..da41ddf 100644
--- a/sacc/utils.py
+++ b/sacc/utils.py
@@ -1,4 +1,3 @@
-from collections import OrderedDict
 import re
 
 from astropy.table import Column
@@ -33,6 +32,7 @@ def hide_null_values(table):
             good_col = np.array([null if x is None else x for x in col])
             table[name] = Column(good_col)
 
+
 def remove_dict_null_values(dictionary):
     """Remove values in a dictionary that
     correspond to the null values above.
@@ -55,7 +55,6 @@ def remove_dict_null_values(dictionary):
         del dictionary[d]
 
 
-
 def unique_list(seq):
     """
     Find the unique elements in a list or other sequence
@@ -80,7 +79,6 @@ def unique_list(seq):
     return [x for x in seq if not (x in seen or seen_add(x))]
 
 
-
 class Namespace:
     """
     This helper class implements a very simple namespace object
@@ -90,9 +88,9 @@ class Namespace:
     N = Namespace('a', 'b', 'c')
 
     assert N.a=='a'
-    
+
     assert N['a']=='a'
-    
+
     assert N.index('b')==1
     """
     def __init__(self, *strings):
@@ -100,11 +98,11 @@ class Namespace:
         Create the object from a list of strings, which will become attributes
         """
         self._index = {}
-        n=0
+        n = 0
         for s in strings:
             self.__dict__[s] = s
             self._index[s] = n
-            n+=1
+            n += 1
 
     def __contains__(self, s):
         return hasattr(self, s)
@@ -119,13 +117,12 @@ class Namespace:
         return self._index[s]
 
 
-
-
 def invert_spd_matrix(M, strict=True):
     """
     Invert a symmetric positive definite matrix.
 
-    SPD matrices (for example, covariance matrices) have only positive eigenvalues.
+    SPD matrices (for example, covariance matrices) have only
+    positive eigenvalues.
 
     Based on:
     https://stackoverflow.com/questions/40703042/more-efficient-way-to-invert-a-matrix-knowing-it-is-symmetric-and-positive-semi
@@ -165,5 +162,7 @@ def invert_spd_matrix(M, strict=True):
 
 
 def camel_case_split_and_lowercase(identifier):
-    matches = re.finditer('.+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)', identifier)
+    matches = re.finditer('.+?(?:(?<=[a-z])(?=[A-Z])'
+                          '|(?<=[A-Z])(?=[A-Z][a-z])|$)',
+                          identifier)
     return [m.group(0).lower() for m in matches]
diff --git a/sacc/windows.py b/sacc/windows.py
index 1bc1db2..de638ab 100644
--- a/sacc/windows.py
+++ b/sacc/windows.py
@@ -89,9 +89,8 @@ class TopHatWindow(BaseWindow, window_type='TopHat'):
     the upper limit should be exclusive, so that you can use
     range(win.min, win.max) to select the right ell values.
 
-    Attributes
+    Parameters
     ----------
-
     min: int/float
         The minimum value where the top-hat function equals 1
 
@@ -100,7 +99,7 @@ class TopHatWindow(BaseWindow, window_type='TopHat'):
     """
     def __init__(self, range_min, range_max):
         """Create a top-hat window
-    
+
         Parameters
         ----------
         range_min: int/float
@@ -120,7 +119,7 @@ class TopHatWindow(BaseWindow, window_type='TopHat'):
         A single table is created for all the windows.
 
         The tables contain an ID column which uniquely identifies the
-        window instance, but only whilst running a given python process - 
+        window instance, but only whilst running a given python process -
         it is not portable.  It should not be used for anythng other than I/O.
 
         Parameters
@@ -160,7 +159,6 @@ class TopHatWindow(BaseWindow, window_type='TopHat'):
         return {row['id']: cls(row['min'], row['max']) for row in table}
 
 
-
 class LogTopHatWindow(TopHatWindow, window_type='LogTopHat'):
     """A window function that is log-constant between two values.
 
@@ -170,16 +168,17 @@ class LogTopHatWindow(TopHatWindow, window_type='LogTopHat'):
     """
     pass
 
+
 class Window(BaseWindow, window_type='Standard'):
     """The Window class defines a tabulated window function.
 
     The class contains tabulated values of the abscissa (e.g. ell or theta) and
     corresponding weights values for each one.
 
-    The function could be integrated or summed depending on the 
+    The function could be integrated or summed depending on the
     context.
 
-    Attributes
+    Parameters
     ----------
     values: array
         The points at which the weights are defines
@@ -198,7 +197,84 @@ class Window(BaseWindow, window_type='Standard'):
         One table is created per window.
 
         The tables contain an ID column which uniquely identifies the
-        window instance, but only whilst running a given python process - 
+        window instance, but only whilst running a given python process -
+        it is not portable.  It should not be used for anythng other than I/O.
+
+        Parameters
+        ----------
+        instance_list: list
+            List of Window instances
+
+        Returns
+        -------
+        table: list
+            List of astropy.table.Table instances
+        """
+        tables = []
+        for w in window_list:
+            cols = [w.values, w.weight]
+            names = ['values', 'weight']
+            t = Table(data=cols, names=names)
+            t.meta['SACCTYPE'] = 'window'
+            t.meta['SACCCLSS'] = cls.window_type
+            t.meta['SACCNAME'] = id(w)
+            t.meta['EXTNAME'] = 'window:' + cls.window_type
+            tables.append(t)
+        return tables
+
+    @classmethod
+    def from_table(cls, table):
+        """Convert an astropy table to a dictionary of Windows
+
+        One window is extracted from the table.
+
+        Parameters
+        ----------
+        table: astropy.table.Table
+
+        Returns
+        -------
+        windows: dict
+            Dictionary of id -> Window instances
+        """
+        return {table.meta['SACCNAME']: cls(table['values'], table['weight'])}
+
+
+class BandpowerWindow(BaseWindow, window_type='Standard'):
+    """The BandpowerWindow class defines a tabulated for power
+    spectrum bandpowers.
+
+    The class contains tabulated values of ell and corresponding weights
+    values for each one. More than one set of weights can be used.
+
+    Parameters
+    ----------
+    values: array
+        An array of dimension (N_ell) containing the ell values at which the
+        weights are defined.
+    weight:
+        An array of dimensions (N_ell, N_weight) containing N_weight sets of
+        weights corresponding to each value.
+
+    """
+    def __init__(self, values, weight):
+        nl, nv = weight.shape
+        nell = len(values)
+        if nl != len(values):
+            raise ValueError(f"Wrong input shapes ${nl}!=${nell}")
+        self.nell = nell
+        self.nv = nv
+        self.values = np.array(values)
+        self.weight = np.array(weight)
+
+    @classmethod
+    def to_tables(cls, window_list):
+        """Convert a list of windows to a list of astropy tables.
+
+        One table is created per window.
+
+        The tables contain an ID column which uniquely identifies the
+        window instance, but only whilst running a given python process -
         it is not portable.  It should not be used for anythng other than I/O.
 
         Parameters
@@ -239,3 +315,19 @@ class Window(BaseWindow, window_type='Standard'):
             Dictionary of id -> Window instances
         """
         return {table.meta['SACCNAME']: cls(table['values'], table['weight'])}
+
+    def get_section(self, indices):
+        """Get part of this window function corresponding to the input
+        indices.
+
+        Parameters
+        ----------
+        indices: int or array_like
+            Indices to return.
+
+        Returns
+        -------
+        window: `Window`
+            A `Window object.
+        """
+        return self.__class__(self.values, self.weight[:, indices])


Test patch:
diff --git a/test/test_sacc2.py b/test/test_sacc2.py
index ce05633..68fc0fb 100644
--- a/test/test_sacc2.py
+++ b/test/test_sacc2.py
@@ -1,8 +1,25 @@
+import tempfile
 import sacc
 import sacc.data_types
 import numpy as np
-import scipy.linalg
 import pytest
+import os
+
+
+def test_quantity_warning():
+    s = sacc.Sacc()
+    with pytest.warns(UserWarning):
+        s.add_tracer('Misc', 'source_0',
+                     quantity='dummy')
+
+
+def test_data_type_warning():
+    s = sacc.Sacc()
+    s.add_tracer('Misc', 'source_0')
+    with pytest.warns(UserWarning):
+        s.add_data_point('cl_wrong', ('source_0', 'source_0'),
+                         0.1, ell=10.)
+
 
 def test_construct():
     s = sacc.Sacc()
@@ -10,12 +27,13 @@ def test_construct():
     # Tracer
     z = np.arange(0., 1.0, 0.01)
     nz = (z-0.5)**2/0.1**2
-    s.add_tracer('NZ', 'source_0', z, nz)
+    s.add_tracer('NZ', 'source_0', z, nz,
+                 quantity='galaxy_density')
 
     for i in range(20):
         ee = 0.1 * i
         tracers = ('source_0', 'source_0')
-        s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0*i)
+        s.add_data_point(sacc.standard_types.cl_00, tracers, ee, ell=10.0*i)
 
 
 def test_tracers_later():
@@ -23,43 +41,49 @@ def test_tracers_later():
 
     with pytest.raises(ValueError):
         tracers = ('source_0', 'source_0')
-        s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, 0.0, ell=1)
+        s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
+                         tracers, 0.0, ell=1)
 
     s = sacc.Sacc()
 
     tracers = ('source_0', 'source_0')
-    s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, 0.0, tracers_later=True, ell=1)
+    s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
+                     tracers, 0.0, tracers_later=True, ell=1)
 
 
 def test_full_cov():
-    covmat = np.random.uniform(size=(100,100))
+    covmat = np.random.uniform(size=(100, 100))
     C = sacc.covariance.BaseCovariance.make(covmat)
     assert C.size == 100
     assert isinstance(C, sacc.covariance.FullCovariance)
-    assert np.all(C.covmat==covmat)
+    assert np.all(C.covmat == covmat)
     hdu = C.to_hdu()
     C2 = sacc.covariance.BaseCovariance.from_hdu(hdu)
     assert np.allclose(C.covmat, C2.covmat)
 
 
 def test_block_cov():
-    covmat = [np.random.uniform(size=(50,50)), np.random.uniform(size=(100,100)), np.random.uniform(size=(150,150))]
+    covmat = [np.random.uniform(size=(50, 50)),
+              np.random.uniform(size=(100, 100)),
+              np.random.uniform(size=(150, 150))]
     C = sacc.covariance.BaseCovariance.make(covmat)
     assert C.size == 300
     assert isinstance(C, sacc.covariance.BlockDiagonalCovariance)
     hdu = C.to_hdu()
     C2 = sacc.covariance.BaseCovariance.from_hdu(hdu)
-    assert len(C2.blocks)==3
+    assert len(C2.blocks) == 3
     assert C.block_sizes == C2.block_sizes
     for i in range(3):
         assert np.allclose(C.blocks[i], C2.blocks[i])
 
 
 def test_misc_tracer():
-    md1 = {'potato': 'if_necessary', 'answer': 42, 'height':1.83}
+    md1 = {'potato': 'if_necessary', 'answer': 42, 'height': 1.83}
     md2 = {'potato': 'never'}
-    T1 = sacc.BaseTracer.make('misc', 'tracer1', metadata=md1)
-    T2 = sacc.BaseTracer.make('misc', 'tracer2', metadata=md2)
+    T1 = sacc.BaseTracer.make('Misc', 'tracer1',
+                              quantity='generic', metadata=md1)
+    T2 = sacc.BaseTracer.make('Misc', 'tracer2',
+                              quantity='generic', metadata=md2)
     assert T1.metadata == md1
     assert T2.metadata == md2
 
@@ -71,23 +95,100 @@ def test_misc_tracer():
     assert T1a.metadata == md1
     assert T2a.metadata == md2
 
+
+def test_numap_tracer():
+    md1 = {'mac': 'yes', 'cheese': 'of_course', 'quantity': 3}
+    md2 = {'mac': 'no', 'cheese': 'no'}
+    ell = np.linspace(2, 1000, 1000)
+    beam = np.exp(-0.1 * ell * (ell + 1))
+    beam_extra = {'err1': np.sin(ell * 0.1)}
+    nu = np.linspace(30., 60., 100)
+    bandpass = np.ones(100)
+    bandpass_extra = {'err1': bandpass * 0.1,
+                      'err2': bandpass * 0.05}
+
+    T1 = sacc.BaseTracer.make('NuMap', 'band1', 0,
+                              nu, bandpass, ell, beam,
+                              quantity='cmb_temperature',
+                              bandpass_extra=bandpass_extra,
+                              beam_extra=beam_extra,
+                              metadata=md2)
+    T2 = sacc.BaseTracer.make('NuMap', 'band2', 0,
+                              nu, bandpass, ell, beam,
+                              quantity='cmb_convergence',
+                              bandpass_extra=bandpass_extra,
+                              beam_extra=beam_extra,
+                              metadata=md1)
+
+    assert T2.metadata == md1
+    assert T1.metadata == md2
+
+    tables = sacc.BaseTracer.to_tables([T1, T2])
+    D = sacc.BaseTracer.from_tables(tables)
+
+    T1a = D['band1']
+    T2a = D['band2']
+    assert T1a.metadata == md2
+    assert T2a.metadata == md1
+    assert np.all(T1a.bandpass_extra['err1'] == 0.1 * bandpass)
+
+
+def test_map_tracer():
+    md1 = {'mac': 'yes', 'cheese': 'of_course', 'quantity': 3}
+    md2 = {'mac': 'no', 'cheese': 'no'}
+    ell = np.linspace(2, 1000, 1000)
+    beam = np.exp(-0.1 * ell * (ell + 1))
+    err = np.sin(ell * 0.1)
+    beam_extra = {'err1': err}
+
+    T1 = sacc.BaseTracer.make('Map', 'y_milca',
+                              0, ell, beam,
+                              quantity='cmb_tSZ',
+                              beam_extra=beam_extra,
+                              metadata=md1)
+    T2 = sacc.BaseTracer.make('Map', 'y_nilc',
+                              0, ell, beam,
+                              quantity='cmb_kSZ',
+                              beam_extra=beam_extra,
+                              metadata=md2)
+
+    assert T1.metadata == md1
+    assert T2.metadata == md2
+
+    tables = sacc.BaseTracer.to_tables([T1, T2])
+    D = sacc.BaseTracer.from_tables(tables)
+
+    T1a = D['y_milca']
+    T2a = D['y_nilc']
+    assert T1a.metadata == md1
+    assert T2a.metadata == md2
+    assert np.all(T1a.beam_extra['err1'] == err)
+
+
 def test_nz_tracer():
-    md1 = {'potato': 'if_necessary', 'answer': 42, 'height':1.83}
+    md1 = {'potato': 'if_necessary', 'answer': 42, 'height': 1.83}
     md2 = {'potato': 'never'}
     z = np.arange(0., 1., 0.01)
-    Nz1 = 1*z # not a sensible N(z)!
-    Nz2 = 2*z # not a sensible N(z)!
+    Nz1 = 1*z  # not a sensible N(z)!
+    Nz2 = 2*z  # not a sensible N(z)!
 
     Nz3 = 3*z
     Nz4 = 4*z
 
-    more_nz = {'v1':Nz3, 'v2':Nz4}
-
-    T1 = sacc.BaseTracer.make('NZ', 'tracer1', z, Nz1, extra_columns=more_nz, metadata=md1)
-    T2 = sacc.BaseTracer.make('NZ', 'tracer2', z, Nz2, metadata=md2)
+    more_nz = {'v1': Nz3, 'v2': Nz4}
+
+    T1 = sacc.BaseTracer.make('NZ', 'tracer1', z, Nz1,
+                              quantity='galaxy_density',
+                              extra_columns=more_nz,
+                              spin=0,
+                              metadata=md1)
+    T2 = sacc.BaseTracer.make('NZ', 'tracer2', z, Nz2,
+                              quantity='galaxy_shear',
+                              spin=2,
+                              metadata=md2)
     assert T1.metadata == md1
     assert T2.metadata == md2
-    
+
     tables = sacc.BaseTracer.to_tables([T1, T2])
     D = sacc.BaseTracer.from_tables(tables)
 
@@ -99,54 +200,59 @@ def test_nz_tracer():
     assert np.all(T1a.extra_columns['v1'] == Nz3)
     assert np.all(T1a.extra_columns['v2'] == Nz4)
 
+
 def test_mixed_tracers():
     md1 = {'potato': 'never'}
     md2 = {'rank': 'duke'}
     md3 = {'rank': 'earl', 'robes': 78}
     z = np.arange(0., 1., 0.01)
-    Nz1 = 1*z # not a sensible N(z)!
+    Nz1 = 1*z  # not a sensible N(z)!
     Nz2 = 2*z
-    T1 = sacc.BaseTracer.make('NZ', 'tracer1', z, Nz1)
-    T2 = sacc.BaseTracer.make('NZ', 'tracer2', z, Nz2, metadata=md1)
+    T1 = sacc.BaseTracer.make('NZ', 'tracer1', z, Nz1,
+                              quantity='galaxy_convergence')
+    T2 = sacc.BaseTracer.make('NZ', 'tracer2', z, Nz2,
+                              quantity='galaxy_shear', metadata=md1)
 
-    M1 = sacc.BaseTracer.make("misc", "sample1", metadata=md2)
-    M2 = sacc.BaseTracer.make("misc", "sample2", metadata=md3)
+    M1 = sacc.BaseTracer.make("Misc", "sample1", metadata=md2)
+    M2 = sacc.BaseTracer.make("Misc", "sample2", metadata=md3)
 
     tables = sacc.BaseTracer.to_tables([T1, M1, T2, M2])
     recovered = sacc.BaseTracer.from_tables(tables)
-    assert recovered['sample1'].metadata['rank']=='duke'
-    assert recovered['sample2'].metadata['robes']==78
+    assert recovered['sample1'].metadata['rank'] == 'duke'
+    assert recovered['sample2'].metadata['robes'] == 78
     assert np.all(recovered['tracer1'].nz == Nz1)
-    assert recovered['tracer2'].metadata['potato']=='never'
+    assert recovered['tracer2'].metadata['potato'] == 'never'
+
 
 def test_inverses():
     N = 25
-    C = np.random.uniform(0,1, size=(N,N))
+    C = np.random.uniform(0, 1, size=(N, N))
     C = (C+C.T) + np.eye(N)*20
     M1 = sacc.BaseCovariance.make(C)
     assert M1.size == N
     invC = M1.inverse
-    I = np.dot(invC, C)
-    assert np.allclose(I, np.eye(N))
+    ii = np.dot(invC, C)
+    assert np.allclose(ii, np.eye(N))
 
-    blocks = [np.random.uniform(0,1, size=(5,5)) for i in range(5)]
+    blocks = [np.random.uniform(0, 1, size=(5, 5))
+              for i in range(5)]
     for b in blocks:
         b += b.T + np.eye(5)*20
 
     M2 = sacc.BaseCovariance.make(blocks)
     assert M2.size == N
-    M2dense = np.zeros((N,N))
+    M2dense = np.zeros((N, N))
     for i in range(5):
-        M2dense[i*5:i*5+5,i*5:i*5+5] = blocks[i]
+        M2dense[i*5:i*5+5, i*5:i*5+5] = blocks[i]
     invC2 = M2.inverse
-    I = np.dot(invC2, M2dense)
-    assert np.allclose(I, np.eye(N))
+    ii = np.dot(invC2, M2dense)
+    assert np.allclose(ii, np.eye(N))
 
-    d = abs(np.random.uniform(0,1,size=N))+1
+    d = abs(np.random.uniform(0, 1, size=N))+1
     M3 = sacc.BaseCovariance.make(d)
     assert M3.size == N
     invC3 = M3.inverse
-    assert np.count_nonzero(invC3 - np.diag(np.diagonal(invC3)))==0
+    assert np.count_nonzero(invC3 - np.diag(np.diagonal(invC3))) == 0
     assert np.allclose(invC3.diagonal() * d, 1)
 
 
@@ -155,7 +261,7 @@ def test_data_point():
     dt = sacc.data_types.standard_types.galaxy_shearDensity_cl_e
     value = 13.4
     tracers = ('aaa', 'bbb')
-    tags = {'ell':12, 'theta':14.3}
+    tags = {'ell': 12, 'theta': 14.3}
     d = DataPoint(dt, tracers, value, **tags)
     s = repr(d)
     d2 = eval(s)
@@ -172,56 +278,64 @@ def test_keep_remove():
     z = np.arange(0., 1.0, 0.01)
     nz = (z-0.5)**2/0.1**2
     s.add_tracer('NZ', 'source_0', z, nz)
-    s.add_tracer('NZ', 'source_1', z, nz)
-    s.add_tracer('NZ', 'source_2', z, nz)
+    s.add_tracer('NZ', 'source_1', z, nz,
+                 quantity='galaxy_shear', spin=2)
+    s.add_tracer('NZ', 'source_2', z, nz,
+                 quantity='cluster_density')
 
     for i in range(20):
         ee = 0.1 * i
         tracers = ('source_0', 'source_0')
-        s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0*i)
+        s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
+                         tracers, ee, ell=10.0*i)
     for i in range(20):
         bb = 0.1 * i
         tracers = ('source_1', 'source_1')
-        s.add_data_point(sacc.standard_types.galaxy_shear_cl_bb, tracers, bb, ell=10.0*i)
+        s.add_data_point(sacc.standard_types.galaxy_shear_cl_bb,
+                         tracers, bb, ell=10.0*i)
     for i in range(20):
         ee = 0.1 * i
         tracers = ('source_2', 'source_2')
-        s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0*i)
+        s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
+                         tracers, ee, ell=10.0*i)
 
     # Select by data type
     s2 = s.copy()
     s2.keep_selection(data_type=sacc.standard_types.galaxy_shear_cl_bb)
-    assert all(d.data_type==sacc.standard_types.galaxy_shear_cl_bb for d in s2.data)
-    assert len(s2)==20
+    assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_bb
+               for d in s2.data)
+    assert len(s2) == 20
 
     # From multiple tracers
     s2 = s.copy()
     s2.keep_selection(data_type=sacc.standard_types.galaxy_shear_cl_ee)
-    assert all(d.data_type==sacc.standard_types.galaxy_shear_cl_ee for d in s2.data)
-    assert len(s2)==40
+    assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_ee
+               for d in s2.data)
+    assert len(s2) == 40
 
     # Test removing a single tracer
     s2 = s.copy()
     s2.remove_selection(tracers=('source_1', 'source_1'))
-    for i,d in enumerate(s2.data):
-        if i<20:
+    for i, d in enumerate(s2.data):
+        if i < 20:
             assert d.tracers == ('source_0', 'source_0')
         else:
             assert d.tracers == ('source_2', 'source_2')
-    assert all(d.data_type==sacc.standard_types.galaxy_shear_cl_ee for d in s2.data)
-    assert len(s2)==40
+    assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_ee
+               for d in s2.data)
+    assert len(s2) == 40
 
     # Test selecting by tag
     s2 = s.copy()
     s2.remove_selection(ell__lt=55)
     ell = s2.get_tag('ell')
     for e in ell:
-        assert e>55
+        assert e > 55
     s2 = s.copy()
     s2.keep_selection(ell__lt=55)
     ell = s2.get_tag('ell')
     for e in ell:
-        assert e<55
+        assert e < 55
 
     # Cutting just by index
     s2 = s.copy()
@@ -231,22 +345,28 @@ def test_keep_remove():
     # multiple selections
     s2 = s.copy()
     ind = s2.indices(tracers=('source_2', 'source_2'), ell__lt=45)
-    assert len(ind)==5
+    assert len(ind) == 5
+
 
 def test_cutting_block_cov():
-    covmat = [np.random.uniform(size=(50,50)), np.random.uniform(size=(100,100)), np.random.uniform(size=(150,150))]
+    covmat = [np.random.uniform(size=(50, 50)),
+              np.random.uniform(size=(100, 100)),
+              np.random.uniform(size=(150, 150))]
     C = sacc.covariance.BaseCovariance.make(covmat)
     ind = list(range(50))
     C2 = C.keeping_indices(np.arange(50))
     assert C2.size == len(ind)
     assert np.allclose(C2.get_block(ind), covmat[0])
 
+
 def test_cutting_full_cov():
-    covmat = np.random.uniform(size=(100,100))
+    covmat = np.random.uniform(size=(100, 100))
     C = sacc.covariance.BaseCovariance.make(covmat)
     ind = np.arange(10, dtype=int)
     C2 = C.keeping_indices(ind)
-    assert np.allclose(C2.get_block(ind), covmat[:10,:10])
+    assert np.allclose(C2.get_block(ind),
+                       covmat[:10, :10])
+
 
 def test_cutting_diag_cov():
     diag = np.random.uniform(size=(100,))
@@ -255,46 +375,68 @@ def test_cutting_diag_cov():
     C2 = C.keeping_indices(ind)
     assert np.allclose(C2.get_block(ind).diagonal(), diag[:20])
 
+
 def test_parse_data_names():
-    for name in sacc.data_types.required_tags:
+    for name in sacc.data_types.required_tags_verbose:
         sources, props, stat, sub = sacc.parse_data_type_name(name)
         name2 = sacc.build_data_type_name(sources, props, stat, sub)
         assert name == name2
 
-def test_window():
-    W1 = []
-    for i in range(10):
-        w = sacc.TopHatWindow(i*10, (i+1)*10)
-        W1.append(w)
+
+def test_bandpower_window():
+    nb = 20
+    nl = 200
+    dl = nl // nb
+    ells = np.arange(nl)
+    w = np.zeros([nb, nl])
+    for i in range(nb):
+        w[i, i*dl: (i+1)*dl] = 1./dl
+
+    W1 = [sacc.BandpowerWindow(ells, w.T)]
+
+    tables = sacc.BandpowerWindow.to_tables(W1)
+    W2 = sacc.BandpowerWindow.from_tables(tables)
+    for w1 in W1:
+        w2 = W2[id(w1)]
+        assert np.all(w1.values == w2.values)
+        assert np.all(w1.weight.flatten() == w2.weight.flatten())
+
+
+def test_tophat_window():
+    edges = np.arange(10) * 10
+    W1 = [sacc.TopHatWindow(edges[:-1], edges[1:])]
+
     tables = sacc.TopHatWindow.to_tables(W1)
     W2 = sacc.TopHatWindow.from_tables(tables)
     for w1 in W1:
         w2 = W2[id(w1)]
-        assert (w1.min, w1.max) == (w2.min, w2.max)
+        assert np.all(w1.min == w2.min)
+        assert np.all(w1.max == w2.max)
+
 
 def test_log_window():
-    W1 = []
-    for i in range(10):
-        w = sacc.LogTopHatWindow(i*10, (i+1)*10)
-        W1.append(w)
+    edges = (np.arange(10) + 1) * 10
+    W1 = [sacc.LogTopHatWindow(edges[:-1], edges[1:])]
+
     tables = sacc.LogTopHatWindow.to_tables(W1)
     W2 = sacc.LogTopHatWindow.from_tables(tables)
     for w1 in W1:
         w2 = W2[id(w1)]
-        assert (w1.min, w1.max) == (w2.min, w2.max)
+        assert np.all(w1.min == w2.min)
+        assert np.all(w1.max == w2.max)
 
 
 def test_concatenate_covariance():
-    v1 = np.array([1.,2.,3.])
+    v1 = np.array([1., 2., 3.])
     v2 = np.array([4.])
     A = sacc.BaseCovariance.make(v1)
     B = sacc.BaseCovariance.make(v2)
     C = sacc.covariance.concatenate_covariances(A, B)
     assert isinstance(C, sacc.covariance.DiagonalCovariance)
-    assert np.allclose(C.diag, [1,2,3,4])
+    assert np.allclose(C.diag, [1, 2, 3, 4])
 
     v1 = np.array([2.])
-    v2 = np.array([[3., 0.1],[0.1, 3]])
+    v2 = np.array([[3., 0.1], [0.1, 3]])
 
     A = sacc.BaseCovariance.make(v1)
     B = sacc.BaseCovariance.make(v2)
@@ -307,20 +449,14 @@ def test_concatenate_covariance():
         )
     assert np.allclose(C.dense, test_C)
 
-    v1 = np.array([
-        [2.0, 0.2,],
-        [0.2, 3.0,]]
-        )
-    v2 = np.array([
-        [4.0, -0.2,],
-        [-0.2, 5.0,]]
-        )
-    test_C = np.array([
-        [2.0, 0.2, 0.0, 0.0],
-        [0.2, 3.0, 0.0, 0.0],
-        [0.0, 0.0, 4.0,-0.2],
-        [0.0, 0.0,-0.2, 5.0]]
-        )
+    v1 = np.array([[2.0, 0.2, ],
+                   [0.2, 3.0, ]])
+    v2 = np.array([[4.0, -0.2, ],
+                   [-0.2, 5.0, ]])
+    test_C = np.array([[2.0, 0.2, 0.0, 0.0],
+                       [0.2, 3.0, 0.0, 0.0],
+                       [0.0, 0.0, 4.0, -0.2],
+                       [0.0, 0.0, -0.2, 5.0]])
 
     A = sacc.BaseCovariance.make(v1)
     B = sacc.BaseCovariance.make(v2)
@@ -328,6 +464,7 @@ def test_concatenate_covariance():
     assert isinstance(C, sacc.covariance.BlockDiagonalCovariance)
     assert np.allclose(C.dense, test_C)
 
+
 def test_concatenate_data():
     s1 = sacc.Sacc()
 
@@ -339,20 +476,22 @@ def test_concatenate_data():
     for i in range(20):
         ee = 0.1 * i
         tracers = ('source_0', 'source_0')
-        s1.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0*i)
-
+        s1.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
+                          tracers, ee, ell=10.0*i)
 
     s2 = sacc.Sacc()
 
     # Tracer
     z = np.arange(0., 1.0, 0.01)
     nz = (z-0.5)**2/0.1**2
-    s2.add_tracer('NZ', 'source_0', z, nz)
+    s2.add_tracer('NZ', 'source_0', z, nz,
+                  quantity='galaxy_shear', spin=2)
 
     for i in range(20):
         ee = 0.1 * i
         tracers = ('source_0', 'source_0')
-        s2.add_data_point(sacc.standard_types.galaxy_shear_cl_ee, tracers, ee, ell=10.0*i, label='xxx')
+        s2.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
+                          tracers, ee, ell=10.0*i, label='xxx')
 
     # name clash
     with pytest.raises(ValueError):
@@ -375,3 +514,71 @@ def test_concatenate_data():
         assert t2 == 'source_0_2'
         s3.get_tracer(t1)
         s3.get_tracer(t2)
+
+
+def test_io():
+    s = sacc.Sacc()
+
+    # Tracer
+    z = np.arange(0., 1.0, 0.01)
+    nz = (z-0.5)**2/0.1**2
+    s.add_tracer('NZ', 'source_0', z, nz)
+
+    for i in range(20):
+        ee = 0.1 * i
+        tracers = ('source_0', 'source_0')
+        s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
+                         tracers, ee, ell=10.0*i)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        filename = os.path.join(tmpdir, 'test.sacc')
+        s.save_fits(filename)
+        s2 = sacc.Sacc.load_fits(filename)
+
+    assert len(s2) == 20
+    mu = s2.get_mean(sacc.standard_types.galaxy_shear_cl_ee)
+    for i in range(20):
+        assert mu[i] == 0.1 * i
+
+
+def test_io_maps_bpws():
+    s = sacc.Sacc()
+
+    n_ell = 10
+    d_ell = 100
+    n_ell_large = n_ell * d_ell
+    ell = np.linspace(2, 1000, n_ell)
+    c_ell = 1./(ell+1)**3
+    beam = np.exp(-0.1 * ell * (ell+1))
+    nu = np.linspace(30., 60., 100)
+    bandpass = np.ones(100)
+    z = np.arange(0., 1.0, 0.01)
+    nz = (z-0.5)**2/0.1**2
+
+    # Tracer
+    s.add_tracer('NZ', 'gc', z, nz)
+    s.add_tracer('NuMap', 'cmbp', 2, nu, bandpass, ell, beam)
+    s.add_tracer('Map', 'sz', 0, ell, beam)
+
+    # Window
+    ells_large = np.arange(n_ell_large)
+    window_single = np.zeros([n_ell, n_ell_large])
+    for i in range(n_ell):
+        window_single[i, i * d_ell: (i + 1) * d_ell] = 1.
+    wins = sacc.BandpowerWindow(ells_large, window_single.T)
+
+    s.add_ell_cl('cl_00', 'gc', 'gc', ell, c_ell, window=wins)
+    s.add_ell_cl('cl_0e', 'gc', 'cmbp', ell, c_ell, window=wins)
+    s.add_ell_cl('cl_00', 'gc', 'sz', ell, c_ell, window=wins)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        filename = os.path.join(tmpdir, 'test.sacc')
+        s.save_fits(filename)
+        s2 = sacc.Sacc.load_fits(filename)
+
+    assert len(s2) == 30
+    l, cl, ind = s2.get_ell_cl('cl_00', 'gc', 'sz',
+                               return_ind=True)
+    w = s2.get_bandpower_windows(ind)
+    assert np.all(cl == c_ell)
+    assert w.weight.shape == (n_ell_large, n_ell)