{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# PSF normalization\n", "\n", "Let us assume that we have reduced an observation, for which we have determined the PSF by stacking the flux of point-like sources. The PSF we obtain will not be as high S/N as the instrumental PSF that has been determined by the instrument team. Moreover, it is likely to be fattened due to the some small pointing errors. We need to find out what fraction of a point-like flux the PSF we have determined represent. In order to do this, we use the growth curve of the theoretical PSF that has been determine by the instrument team, and compare it to the growth curve we determine from our PSF.\n", "\n", "We will first look at a theoretical case, then go practical with an example drawn from the PACS observation of the the XMM-LSS.\n", "\n", "## 1) Theoretical example. \n", "\n", "Let us suppose we have a perfect telescope, without any central obscuration and spider to support the secondary. Diffraction theory gives us the shape of a PSF in this case, an Airy function. Let's compute it, and assume the resolution is 10\".\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# import what we will need. \n", "%matplotlib inline\n", "import numpy as np\n", "from astropy.io import fits\n", "from astropy.table import Table\n", "from astropy.io import ascii as asciiread\n", "from matplotlib import pyplot as plt\n", "from scipy import interpolate \n", "from scipy import special\n", "from scipy import signal\n", "from scipy import fftpack" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# Let us perform our computation with a 0.1\" resolution on a 5' field of view\n", "resol = 0.1\n", "size = 300.\n", "# wavelength\n", "wavelength = 250e-6\n", "# primary aperture = 3.6 m diameter\n", "aperture = 3.6 / 2." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# Ensure we have an odd number of points \n", "nbpix = np.ceil(size/resol) // 2 * 2 + 1\n", "xcen = int((nbpix - 1) / 2)\n", "ycen = int((nbpix - 1) / 2)\n", "x = y = (np.arange(nbpix) - xcen)*resol\n", "xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')\n", "r = np.sqrt(xv**2+yv**2)\n", "# avoid division by 0 problems in the center\n", "r[xcen,ycen] = 1e-6\n", "# coordinates in fourier\n", "q = 2 * np.pi / wavelength * aperture * np.sin(r/3600.*np.pi/180.)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "psf = (2*special.jn(1, q)/q)**2" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# put back the correct value at center\n", "psf[xcen, ycen] = 1.\n", "# and normalize the PSF\n", "psf = psf/(np.sum(psf)*resol**2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.imshow(np.log10(psf))\n", "print(r'$\\int\\int$ psf dx dy = {}'.format(np.sum(psf)*resol**2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(y[ycen-500:ycen+500], psf[ycen-500:ycen+500, xcen], label='Without obscuration')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us now suppose that we observe a point source, and our image reconstruction has a ...This will shows a a blurring of the image, with a gaussian of 10\" FWHM. Let's generate this blurring" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "fwhm = 10.\n", "sigma = fwhm / 2. / np.sqrt(2. * np.log(fwhm))\n", "sigmasq = sigma**2\n", "kernel_blur = 1./ 2./ np.pi / sigmasq * np.exp(-(r**2/2./sigmasq))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Check our kernel is properly normalized\n", "np.sum(kernel_blur*resol**2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# apply the blur\n", "psfblur = signal.convolve(psf, kernel_blur, mode='same')*resol**2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(y[ycen-500:ycen+500], psf[ycen-500:ycen+500, xcen], label='Original')\n", "plt.plot(y[ycen-500:ycen+500], psfblur[ycen-500:ycen+500, xcen], label='With blurring')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We see the effect of blurring, the, observed PSF is wider, and we have lost some flux in the central core. Suppose now that we observed this psf with sources of unknown fluxes, so that we re unsure of its scaling, and that a background remain in our observation" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "psfobs = psfblur * 2. + 1e-4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The question is now how to recover the PSF that serve for our observation. For this, we will use the PSFs curve of growth. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "radii = np.arange(0, np.max(r), resol)\n", "growth_psf = np.zeros(radii.shape)\n", "growth_psfobs = np.zeros(radii.shape)\n", "nbpix_psfobs = np.zeros(radii.shape)\n", "for i, radius in enumerate(radii):\n", " if ((i % 100) == 0):\n", " print(radius, np.max(radii))\n", " if i == 0:\n", " idj, idi = np.where(r <= radius)\n", " growth_psf[i] = np.sum(psf[idj, idi])*resol**2\n", " growth_psfobs[i] = np.sum(psfobs[idj, idi])*resol**2\n", " nbpix_psfobs[i] =len(idi)\n", " else:\n", " idj, idi = np.where((r > radii[i-1]) & (r <= radius))\n", " growth_psf[i] = growth_psf[i-1]+np.sum(psf[idj, idi])*resol**2\n", " growth_psfobs[i] = growth_psfobs[i-1]+np.sum(psfobs[idj, idi])*resol**2\n", " nbpix_psfobs[i] = nbpix_psfobs[i-1]+len(idi)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(radii, growth_psf, label='PSF')\n", "plt.plot(radii, growth_psfobs, label='Observed PSF')\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Encircled flux')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This strongly rising shape of the observed PSF is a sure sign of an non zero background. Let's determine it. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(nbpix_psfobs, growth_psfobs)\n", "plt.xlabel('Number of pixels')\n", "plt.ylabel('Encircled flux')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When plotted as a function of the intergated area, there is a clear linear relation, that we will fit:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "idx, = np.where(radii > 50)\n", "p = np.polyfit(nbpix_psfobs[idx], growth_psfobs[idx], 1)\n", "bkg = p[0]/resol**2" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# Correct PSF and curve of growth\n", "psfcor = psfobs-bkg\n", "growth_psfcor = growth_psfobs - bkg*nbpix_psfobs*resol**2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(radii, growth_psf, label='PSF')\n", "plt.plot(radii, growth_psfcor, label='Observed PSF')\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Encircled flux')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Let's have a look at the ratio of the two:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(radii[1:], growth_psfcor[1:]/growth_psf[1:])\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Ratio of encircled flux')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Due to the different resolution, the ratio is not constant. Let's note the calibration $C(r)$. Let us assume that our observed PSF encirled energy is of the form:\n", "\n", "$E(r) = \\alpha C(r \\times \\beta)$\n", "\n", "Where $\\beta$ is the fattening of the PSF. If we differentiate as a function of $r$:\n", "\n", "$E'(r) = \\alpha \\beta C'(r \\times \\beta)$\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# compute the derivatives\n", "deriv_growth_psf = (growth_psf[2:]-growth_psf[0:-2])/(radii[2:]-radii[0:-2])\n", "deriv_growth_psfcor = (growth_psfcor[2:]-growth_psfcor[0:-2])/(radii[2:]-radii[0:-2])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(radii[1:-1], deriv_growth_psf)\n", "plt.plot(radii[1:-1], deriv_growth_psfcor)\n", "plt.xlim([0,60])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Compared with the growth curve plot, the derivative show clear maxima and minima that are out of phase. Findind the positions of the these will tell us if our assumption of homothetical variation is correct." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Find the local minima and maxima of the two curves.\n", "# To find a local extremum, we will fit the portion of curve with a degree 3 polynomial, \n", "# extract the roots of its derivative and only retain the one that are between the bounds.\n", "# This is what the following function does.\n", "def local_max(xvalues, yvalues, lower_bound, upper_bound, check_plot=False):\n", " idx,=np.where((xvalues > lower_bound) & (xvalues < upper_bound))\n", " p = np.polyfit(xvalues[idx], yvalues[idx], 3)\n", " delta = (2.*p[1])**2 - 4.*3.*p[0]*p[2]\n", " r1 = (-2*p[1]+np.sqrt(delta))/(2*3*p[0])\n", " r2 = (-2*p[1]-np.sqrt(delta))/(2*3*p[0])\n", " result = r1 if ((r1 > lower_bound) and (r1 < upper_bound)) else r2\n", " if check_plot:\n", " plt.plot(xvalues[idx], yvalues[idx])\n", " plt.plot(xvalues[idx], p[0]*xvalues[idx]**3+p[1]*xvalues[idx]**2+\n", " p[2]*xvalues[idx]+p[3], '--')\n", " plt.plot(np.array([result, result]), np.array([np.min(yvalues), np.max(yvalues)]), '-')\n", " return result\n", " \n", " \n", "max_dpsf_1 = local_max(radii[1:-1], deriv_growth_psf, 3, 10, check_plot=True)\n", "max_dpsfcor_1 = local_max(radii[1:-1], deriv_growth_psfcor, 3, 10, check_plot=True)\n", "\n", "max_dpsf_2 = local_max(radii[1:-1], deriv_growth_psf, 14, 21, check_plot=True)\n", "max_dpsfcor_2 = local_max(radii[1:-1], deriv_growth_psfcor, 14, 21, check_plot=True)\n", "\n", "max_dpsf_3 = local_max(radii[1:-1], deriv_growth_psf, 21, 28, check_plot=True)\n", "max_dpsfcor_3 = local_max(radii[1:-1], deriv_growth_psfcor, 21, 28, check_plot=True)\n", "\n", "max_dpsf_4 = local_max(radii[1:-1], deriv_growth_psf, 28, 35, check_plot=True)\n", "max_dpsfcor_4 = local_max(radii[1:-1], deriv_growth_psfcor, 28, 35, check_plot=True)\n", "\n", "max_dpsf_5 = local_max(radii[1:-1], deriv_growth_psf, 35, 45, check_plot=True)\n", "max_dpsfcor_5 = local_max(radii[1:-1], deriv_growth_psfcor, 35, 45, check_plot=True)\n", "\n", "max_dpsf_6 = local_max(radii[1:-1], deriv_growth_psf, 40, 50, check_plot=True)\n", "max_dpsfcor_6 = local_max(radii[1:-1], deriv_growth_psfcor, 40, 50, check_plot=True)\n", "\n", "plt.xlabel('Radius [arcsec]')\n", "\n", "# Lets pack all of them, adding the r=0 point. \n", "max_dpsf = np.array([0, max_dpsf_1, max_dpsf_2, max_dpsf_3, max_dpsf_4, max_dpsf_5, max_dpsf_6])\n", "max_dpsfcor = np.array([0, max_dpsfcor_1, max_dpsfcor_2, max_dpsfcor_3, max_dpsfcor_4, \n", " max_dpsfcor_5, max_dpsfcor_6])\n", "\n", "print(max_dpsf,max_dpsfcor)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the plot, we can deduce that our homothetical assumption is not perfect: the spacing increases for the first three (don't forget the point at 0, 0, not shown), is very small for the 4th and 6th, and gets narrower for the 5th and 7th...\n", "Let's plot the situation" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "plt.plot(max_dpsf, max_dpsfcor, 'o-')\n", "p = np.polyfit(max_dpsf[0:3], max_dpsfcor[0:3], 1)\n", "plt.plot(max_dpsf, p[0]*max_dpsf+p[1])\n", "plt.xlabel('extremum position of theoretical psf [arcsec]')\n", "plt.ylabel('extremum position of observed blurred psf [arcsec]')\n", "\n", "\n", "print(p)\n", "print((max_dpsfcor[1]-max_dpsfcor[0])/(max_dpsf[1]-max_dpsf[0]))\n", "print((max_dpsfcor[2]-max_dpsfcor[0])/(max_dpsf[2]-max_dpsf[0]))\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lets use the data before 20\", corresponding to the central core\n", "beta = (max_dpsfcor[2]-max_dpsfcor[0])/(max_dpsf[2]-max_dpsf[0])\n", "\n", "# lets interpolate at the scaled radius\n", "tckpsfcor = interpolate.splrep(radii, growth_psfcor, s=0)\n", "interp_growth_psfcor = interpolate.splev(radii*beta, tckpsfcor, der=0)\n", "\n", "# check interpolation\n", "plt.plot(radii*beta, growth_psf)\n", "plt.plot(radii, growth_psfcor)\n", "plt.plot(radii*beta, interp_growth_psfcor)\n", "plt.xlim([0,60])\n", "plt.xlabel('radius [arcsec]')\n", "plt.ylabel('Encircled flux')\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us check the ratio, using the psf with a corrected radius" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "plt.plot(radii[1:]*beta, interp_growth_psfcor[1:]/growth_psf[1:])\n", "plt.xlabel('radius [arcsec]')\n", "plt.ylabel('Ratio of encircled flux')\n", "plt.xlim([0,60])\n", "idx, = np.where(((radii*p[0]) > 0) & ((radii*p[0]) < 60))\n", "scale_factor = np.median(interp_growth_psfcor[idx]/growth_psf[idx])\n", "print(\"alpha = {:.3f}\".format(scale_factor))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We now have a much better looking ratio [compared with the cell where we computed the direct ratio](#the_ratio), and we have a decent determination of the psf scaling. The normalized PSF to use for our observations is then:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "psf_obs_norm = psfcor / scale_factor" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print('\\int \\int psf_obs_norm dx dy = {}'.format(np.sum(psf_obs_norm)*resol**2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Indeed, let's look at the encircled energy in the core of our psf:\n", "In this example, we have used the derivative of the scale factor" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "idj, idi = np.where(r" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "stackhd_im = fits.open('../dmu18_HELP-PACS-maps/data/GAMA-15_PACS100_v0.9.fits')\n", "stackhd = fits.open('./data/output_data/GAMA15-100um-psffromstack_20171002.fits')\n", "psf = stackhd[0].data\n", "hd = stackhd[0].header\n", "plt.imshow(psf)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SIMPLE = T / conforms to FITS standard \n", "BITPIX = -64 / array data type \n", "NAXIS = 2 / number of array dimensions \n", "NAXIS1 = 22 \n", "NAXIS2 = 22 \n", "CTYPE1 = 'RA---TAN' \n", "CTYPE2 = 'DEC--TAN' \n", "CDELT1 = -0.0008333333535 \n", "CDELT2 = 0.0008333333535 " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hd" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Set the resolution of the psf. Because the map is in units of Jy/pixel, this turns out to be:\n", "* =1 if psf at same resolution of map\n", "* otherwise, should be in factor of map pixel size" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": true }, "outputs": [], "source": [ "resol= np.abs(stackhd[0].header['CDELT1'])/np.abs(stackhd_im[1].header['CDELT1'])" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "resol" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's build the growthcurve for our PSF." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# find the brightest pixel, it will be our center.\n", "jmax, imax = np.unravel_index(np.argmax(psf), psf.shape)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# build the array of coordinates\n", "x = np.arange(hd['NAXIS1'])\n", "y = np.arange(hd['NAXIS2'])\n", "xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')\n", "xp = (xv-imax)*np.abs(hd['CDELT1'])*3600.\n", "yp = (yv-jmax)*np.abs(hd['CDELT2'])*3600.\n", "r = np.sqrt(xp**2 + yp**2)\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# build the growth curve\n", "radii = np.unique(r)\n", "encircled_flux = np.zeros(radii.shape)\n", "nbpix = np.zeros(radii.shape)\n", "for i, radius in enumerate(radii):\n", " idj, idi = np.where(r <= radius)\n", " nbpix[i] =len(idi)\n", " #encircled_flux[i] = np.sum(psf[idj, idi])*resol**2\n", " #multiply by ((np.abs(hd['CDELT1'])*3600.)**2)/4.25E10 as map is in units of MJy/sr\n", " encircled_flux[i] = np.sum(psf[idj, idi])*((np.abs(hd['CDELT1'])*3600.)**2)/4.25E10" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-3.0000000726000002" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hd['CDELT1']*3600." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Encircled flux')" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(radii, encircled_flux)\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Encircled flux')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Looking at the shape of the encircled flux, it looks like the background level of our PSF is not zero. Let's check" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0017286449728999287\n", "[[0.00172846 0.00173037 0.001724 0.00172392 0.00172585 0.00172469\n", " 0.0017364 0.00172888 0.00173419 0.00172891 0.00172465 0.00172892\n", " 0.00172572 0.0017317 0.00173145 0.00172948 0.00173462 0.00173757\n", " 0.00172971 0.00171942 0.00172836 0.00172881]\n", " [0.001727 0.00172918 0.00172725 0.00173336 0.0017261 0.00172498\n", " 0.00173059 0.00173382 0.00172474 0.00172698 0.00173042 0.00172809\n", " 0.00172735 0.00173063 0.00172985 0.00173125 0.00172759 0.00172772\n", " 0.00173979 0.00172639 0.00172636 0.00172459]\n", " [0.00172655 0.0017266 0.00172999 0.0017283 0.00172079 0.0017262\n", " 0.00172511 0.0017269 0.0017231 0.00174141 0.00173181 0.00173133\n", " 0.0017262 0.00172633 0.00173799 0.00173683 0.00172813 0.00173129\n", " 0.00173327 0.00172421 0.00172177 0.00173278]\n", " [0.00172409 0.00172807 0.00172873 0.00173004 0.00173205 0.001732\n", " 0.00172637 0.00172855 0.00173515 0.00173177 0.00172662 0.00172353\n", " 0.00173282 0.00172972 0.00172852 0.00173318 0.00172788 0.00172462\n", " 0.00173129 0.00173412 0.00173064 0.00172404]\n", " [0.00172768 0.00172739 0.00172577 0.00172691 0.0017287 0.00173337\n", " 0.00172978 0.00172242 0.00173045 0.00173469 0.00173253 0.00172722\n", " 0.00172859 0.00172917 0.00171927 0.00172761 0.00172905 0.00173305\n", " 0.00172999 0.00173086 0.00173112 0.00172273]\n", " [0.00172668 0.00172966 0.00173237 0.00172574 0.0017371 0.00173956\n", " 0.0017317 0.00172234 0.00171987 0.00172828 0.00173636 0.00173383\n", " 0.00173931 0.00173499 0.00173242 0.00172597 0.00172793 0.00173385\n", " 0.00172803 0.00173189 0.00172616 0.00172517]\n", " [0.00172477 0.00173033 0.00172555 0.00172677 0.00173026 0.00174234\n", " 0.0017385 0.00173394 0.00172559 0.00172968 0.00174184 0.00173476\n", " 0.00173367 0.00173398 0.00173336 0.00173138 0.00173184 0.00173235\n", " 0.00172889 0.00173629 0.00173211 0.00172526]\n", " [0.00172819 0.0017267 0.00172576 0.00172755 0.0017285 0.00173223\n", " 0.00173026 0.00173643 0.00173391 0.00173643 0.00174839 0.00175141\n", " 0.00174205 0.00173524 0.00174415 0.00173445 0.00172356 0.00173165\n", " 0.00172897 0.00172956 0.00172645 0.00172817]\n", " [0.00172461 0.00173134 0.00173148 0.00173104 0.00173516 0.00173257\n", " 0.00173691 0.00173564 0.00173766 0.00175434 0.00176967 0.00176083\n", " 0.00174563 0.00173885 0.0017394 0.00173234 0.00172915 0.00172382\n", " 0.00172621 0.00172869 0.00172933 0.00172898]\n", " [0.00172496 0.00172509 0.00172698 0.0017363 0.00172672 0.0017307\n", " 0.00173584 0.00174213 0.00175415 0.00177001 0.00180306 0.00180228\n", " 0.00177773 0.00175524 0.00174952 0.00174074 0.00172551 0.00172494\n", " 0.00173385 0.00173081 0.00172792 0.00172174]\n", " [0.00172939 0.00173116 0.00173273 0.00173301 0.00173328 0.00172924\n", " 0.00173708 0.00174125 0.00174232 0.00178184 0.00185859 0.00188928\n", " 0.00184707 0.00178446 0.00175693 0.00174353 0.00173213 0.00172914\n", " 0.00173021 0.00173605 0.00173233 0.00173298]\n", " [0.00173097 0.00172277 0.0017311 0.00172805 0.00173073 0.00173356\n", " 0.0017413 0.00174087 0.00174908 0.00180446 0.001897 0.00194575\n", " 0.0019008 0.00180159 0.00175372 0.00174159 0.00174158 0.00174034\n", " 0.00173619 0.00172944 0.00172811 0.001733 ]\n", " [0.00172702 0.00172691 0.00173269 0.00173636 0.00173026 0.00173573\n", " 0.00173846 0.00173933 0.00175348 0.00178502 0.00185532 0.00189814\n", " 0.00186407 0.0017856 0.00175267 0.00174261 0.00174366 0.00174447\n", " 0.0017299 0.00172943 0.00172638 0.00172028]\n", " [0.0017206 0.00172905 0.00173563 0.00172838 0.00173647 0.0017229\n", " 0.00173239 0.00173382 0.00174494 0.00175654 0.00178126 0.00179946\n", " 0.00180049 0.00176285 0.00174161 0.00174575 0.00173097 0.00173637\n", " 0.0017276 0.0017239 0.00172916 0.00172439]\n", " [0.00173177 0.00172875 0.001726 0.00173279 0.00172634 0.00172315\n", " 0.00172576 0.00173415 0.00174157 0.00174405 0.00174677 0.00174935\n", " 0.00175629 0.00174866 0.00173863 0.00174755 0.00173744 0.00172639\n", " 0.00172919 0.00172803 0.00172961 0.00172583]\n", " [0.00172621 0.00172292 0.00172527 0.00173014 0.00172717 0.00172326\n", " 0.00173084 0.00173408 0.00173212 0.00174006 0.00173428 0.00173839\n", " 0.00173994 0.0017276 0.00172949 0.00173405 0.00173162 0.00173546\n", " 0.00172743 0.00172267 0.00172631 0.00172639]\n", " [0.00172529 0.00172477 0.00172467 0.00172706 0.00173349 0.00173092\n", " 0.00173548 0.00173976 0.00173107 0.0017399 0.00173212 0.00174033\n", " 0.00173305 0.00171794 0.00171933 0.00172329 0.00172988 0.0017299\n", " 0.00173585 0.00172788 0.00173608 0.00172424]\n", " [0.0017297 0.0017353 0.00173226 0.00172802 0.00173194 0.00173674\n", " 0.00173189 0.00172545 0.00172573 0.00173574 0.00173765 0.00172931\n", " 0.00173152 0.00173247 0.00172338 0.00172225 0.00172826 0.00173286\n", " 0.00172237 0.00173417 0.00172383 0.00173069]\n", " [0.00173108 0.00172738 0.00173016 0.00172702 0.00173244 0.00172957\n", " 0.0017328 0.00172898 0.00173191 0.00172935 0.00173173 0.00172675\n", " 0.00173241 0.00173415 0.00173265 0.00173297 0.00172987 0.00173117\n", " 0.00172824 0.00173322 0.00173134 0.00172757]\n", " [0.00172867 0.0017291 0.00172841 0.00173209 0.00173243 0.0017329\n", " 0.00172929 0.0017275 0.00172079 0.00173357 0.00173571 0.00173213\n", " 0.00172977 0.00173246 0.00172331 0.00172755 0.00172749 0.00172426\n", " 0.00173292 0.0017298 0.00172848 0.00172783]\n", " [0.00173355 0.00172998 0.00173342 0.00172808 0.0017283 0.00173731\n", " 0.00172373 0.00173293 0.00172503 0.0017247 0.00172412 0.00172636\n", " 0.00172848 0.00173085 0.00172934 0.00172342 0.00172243 0.00172327\n", " 0.0017308 0.00172614 0.00173428 0.00172906]\n", " [0.00173098 0.00173473 0.00172271 0.00172665 0.00173077 0.0017259\n", " 0.00172725 0.0017257 0.00171962 0.00173057 0.00172679 0.00172479\n", " 0.0017287 0.00172797 0.00173176 0.00172937 0.00172693 0.00172265\n", " 0.00172909 0.00173269 0.0017295 0.00173379]]\n" ] } ], "source": [ "# This is clearly. \n", "print(np.median(psf[0:5,:]))\n", "\n", "print(psf)\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Encircled flux')" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(nbpix, encircled_flux)\n", "plt.xlabel('Number of pixels')\n", "plt.ylabel('Encircled flux')" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "75\n" ] } ], "source": [ "print(len(nbpix))" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Lets do a linear fit to the outer part of the curve to determine the backgound\n", "p = np.polyfit(nbpix[30:], encircled_flux[30:], 1)\n", "bkg = p[0]/resol**2\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "193.0" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nbpix[30]" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.660882717056583e-13\n" ] } ], "source": [ "print(bkg)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": true }, "outputs": [], "source": [ "# Lets correct the psf and encircled flux\n", "psf = psf - bkg\n", "encircled_flux = encircled_flux - bkg * nbpix*resol**2" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Encircled flux')" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(radii, encircled_flux)\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Encircled flux')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Our PSF does now behaves correctly.\n", "\n", "Now let us compare our growth curve with the encircled energy curve provided by the instrument team. We use the standard growth curve for 100 µm PACS, taken with 20\"/s scan speed. " ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": true }, "outputs": [], "source": [ "f = open('./data/EEF_grn_20.txt', 'r')\n", "lines = f.readlines()\n", "f.close()\n", "radiuseff = np.zeros(len(lines)-3)\n", "valeff = np.zeros(len(lines)-3)\n", "i = 0\n", "for line in lines:\n", " if line[0] != '#':\n", " bits = line.split()\n", " radiuseff[i] = float(bits[0])\n", " valeff[i] = float(bits[1])\n", " i = i+1" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(radiuseff, valeff, label='Calibration')\n", "plt.plot(radii, encircled_flux/np.max(encircled_flux), label='Our PSF')\n", "plt.xlim([0, 100])\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Encircled flux')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will work below 10\" where our PSF is well behaved" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(radiuseff, valeff, label='Calibration')\n", "plt.plot(radii, encircled_flux/np.max(encircled_flux), label='Our PSF')\n", "plt.xlim([0, 50])\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Encircled flux')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We see that while the calibration curve still rises beyond 30\", our PSF has reached a plateau. Let's note the calibration $C(r)$. Our PSF encirled energy is of the form:\n", "\n", "$E(r) = \\alpha C(r \\times \\beta)$\n", "\n", "Where $\\beta$ is the fattening of the PSF.\n", "\n", "We could take the derivative, but this too noisy. Instead we do a brute force approach" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8VOX1+PHPyb4TIGGRAIEQkD1AEBVlEbW4C1q1VSu2dam12kV/tbV167d+bW1dq7ZordYvWreqWLFu4IYihE3ZCbIkICRkIfs2Ob8/7s1KEsIymZnMeb9e85q5y9w5cyH3zPM8954rqooxxhjTWoivAzDGGOOfLEEYY4xpkyUIY4wxbbIEYYwxpk2WIIwxxrTJEoQxxpg2WYIwxhjTJksQxhhj2mQJwhhjTJvCfB3A4UpKStLU1FRfh2GMMQFl5cqV+1U1+XDeE3AJIjU1laysLF+HYYwxAUVEdh7ue6yLyRhjTJssQRhjjGmTJQhjjDFtsgRhjDGmTZYgjDHGtMlrCUJEnhaRPBFZ185yEZFHRCRbRL4UkYneisUYY8zh82YL4hlgdgfLzwLS3ce1wBNejMUYY8xh8tp1EKr6sYikdrDKBcA/1bnn6TIRSRSR/qr6jbdiMsbvVZdC9geAgoRCiPsnWlkIIeEQEQuRcRAR3+x1LBR+DfuzoXQPpE6DlEk+/Rqme/DlhXIDgJxm07nuvIMShIhci9PKYNCgQV0SnDFdrnQvvPpD2PHJ0W9r+GwYOhPSZkLScBA5+m2aoOPLBNHW/1hta0VVnQ/MB8jMzGxzHWP8Us5yyNsIYZEQGgFhURAWAaHudGUR7F4J2e/DnlXOe6J7wbz/gNZDvcd5ju7pPFeXQk0Z1JS7r8ud6fh+0G+809L48iVne1v+62yv11AYdxmknwF9RkF4FHhqYc9q2P4R5GZBZDz0SHE+58BuqC2H2krn0XsYnHwTxLVRpcFT56wbmWBJqBvyZYLIBQY2m04B9vgoFmOOnaoS2LUMCrfBO792DuwdkRAYMAlO+63zy7/v6KM72A48wXku2gHblsC6V+HDe52HhDoJo/QbJ7EAJB/vJIL1r0F9nXOwj4x3k1kUbHkHlj8JE78HJ9/orLtzKWz/GLYthqoDTsKLTXaSSGwfJ2ElDoSoRIjq0fRo2HbOF1CyB+prnWRVVwW1Vc5zw6O2CqpLoLIYqoqd/RoWCVEJzveQkKZHqNv9Fh4N4THuI7ppXmwfGHkeJPQ/8v0ahMQZAvDSxp0xiP+o6pg2lp0D3AicDUwBHlHVEw61zczMTLVaTMbv1FTA1necg/GWd8FT7cxPPRXOf9RJEnXVzvy6mqbnqB6QPNx59qYDuyF3BexbB/s2OAfwIdOc+GJ7O+vUe5xWSVSPlglqfzZ8+iB8+S8ngTSI7w9ps5z4y/e7jzwoy3MO/hX7Ox9fSLhzIA+LhLCG5ygnGUQlQrSbaOqqnESh9S0fnhrn36C22aOmwm0FVeCM6YQ48Y44y5luaCHVNluv+XtqK533xPd1EpJ6mrXqtNV0vTutTdPNtUj40vH8mb+G1Kmd33edJCIrVTXzcN7jtRaEiLwAzACSRCQXuBMIB1DVvwKLcJJDNlABXO2tWIzxipI9zi/07PedX9m15RDXFzKvhhFnOwe54yY4z77WY4DzGH1h++uEhDoH4taShsGFj8GM22DtC05yGTzVaYl01NJpaAFUlTitjKpid/qA897jJjiJITTc+WxvUYWCbU7sa1+A7PdaLg+NaNbyaP4c7Rzs937lbENCnDglxG3BSKtpd3lIKEgYTYlAW8bSXox+yKstCG+wFoTxuZXPwOePw/7NznRsspMQxl7sHDi9ebAzR6feAwdyndZJQxIIDfd1VF3Cr1oQxgS8+nrY+SkU57hdHpHOL9H374QBmXDG75yzhPqMhhArShAQQkKh52BfRxEwLEEY01rRTljzvPM4sOvg5UOmweWv+EfXkTFeZAnCdH+1Vc6AacIAp9943avOoGtdtTug2DDY6A40ln4DiNM6OP1O5wyjhjNt6uug39ig6ZYwwc0ShOn+3r8LvnjCOeum3zjY+q5zKmnf0QcPMEqI0wUx7jLnNE1jgpglCBMYVGHz2/DZI87pjimZkDIZjpvonArZnspi2PWZcwHY4KnOhWtj5sIFjzkDlMaYdlmCMP6pLA/2rIFv1jQ9l+yGnkOgorDpKmHEudArZZJTn6jhNMqG0ysP5DjT5z0CEy736VcyJtBYgjD+Z/mTsOiWpunew2DQSTB0Boy/zOn/ryx2SlTsXulcALZpUdNVwFEJznNcH0geAZN/2HR1sTGm0yxBGP9SWQSLfweDT3GuKO03tu0upOhEGDbLeRhjvMIShPEvSx9xuoTOus9JDsYYn7EEYfxD4dfOdQfLnoAxF1tyMMYPWIIwXa+6DAqynUfh105V0B2fNBVTO/N3vo7QGL/kqVeqaj1U1XqorPVQVVtPVa2H6rqm143PzeZV13qO6PMsQRjvq6lwyjtv/8hJBntWt6x22TvdKXU9/jtOQTljAoyqUutRKmucA3dFTZ17APdQUeNpnF9Z407Xepqt6x7wazxU1HqoqvFQUVvX4oBf7R7waz1dWzvPEoQ5tqpLIX8L5G+E/E2wezXkLnfKMYeEOTWMTv2Fc8Fa7zTntNWIGF9HbYKAqlJZ66Gsuo6Kag/lNXWUu88tD9x1VNbUOwfpZvMbD/atD+7ugd1Tf3gHbxGICQ8lOsJ9hIcSHRFGdHgIyXGRRIU78yLDQ4kKDyEqPJSosGavG5/dR1jz6ab1I8NDiAwLIeQPh7/PLEGYo1eWD2/9zLle4UCzu8iGRkKfkTDlOhgy3TlVNTLOd3GagKGqVNfVtziYV9TUUVbtoaK6jvIaD+XVdc78xoO9M7+iuunAX1HTkBDqqKj1HFZV7YjQkMYDd0yEc+CNiQglLjKM5LhIoiNazo8Ob3gdRnRECNHhYY3rRIeHHrStyLAQxM/vwmcJwhy9xb+Dzf+F0XOgz9XOhWvJx0PPVCt9HUQaDuqlVXWUVddRVlVHaXUtZQ3T1XUtljVN1zYd0KubDvyd/UEeIhAbGUZsRBgxkc4BPCYilH4JUcREhhEX6Ry0YyNCiYkMc9d15sVFOu+JiQglJjyMqIgQYiLCiAoLISzUKvRagjBHJ38zrH4OTrgWzjqCNqzxC9V1Hg5U1lJSWUdJVbODerODe8sDfG3LaXfduk4c1cNDhfiocOIiwxofyfGRDI6IaXWQDyM2suFAHtpq2kkCsZFhAfFLPFBZgjBH5/27ITwWpt3q60iCWn29UlJVS1FFrXugr6WkqumA3zB9oLKu2bJaSqqc6eq6Q9w3G4gKDyEuMpz4qKYD+8BeMcRHhhEXFebOD3deNxz83XUb3xMVRmSYtSoDhSUIc+TyN8Pmt2DmbyA2ydfRdBuqSll1HUXltRRW1FBUXkNheQ1FFa2emy0vqqjpsEsmLERIiA4nISqMHtHhJESHc1yPaBKiw0iICm9clhDtJIDmv/Djo5xumXDrcgk6liDMkasodJ5TDusuhkFLVSmprGNvSRX7Sqqc5wNV7CutYu+Bava584sqato9nTEsROgZG0GvmAh6xoYzvG8cPWMi6BUbQU93Xo/o8GYH/XASosOIDg+1bhhz2CxBmCNTX+9c5GYalVbVsquwgl0FFewurnSTQNOBf19JFVW1B3fl9IwJp29CFH0TohjZP56kuEh6xUaQGBNBr9jwpgQQG0F8ZJgd6E2XsQRhOq++3rngbcPrsGEhlO6BsGjokeLryLpEfb2yt6SqMQnsKnQeOwsryCmsoLC8psX6kWEh9E2Iol9CFONSEumXENmYCPr1iKJvfBR9Epzz3Y3xR5YgTMfqPbDrc9jwhpMUyvY61zcMOx1G3w3Dv+XcwKcbKSirZmteGdnuY2dBOTsLK8gtrKTG09QCCA0RBiRGM6hXDN8a3Y/BvWMY1Mt5DEiMJjEm3H7tm4BmCcIczFPn3IVt/euw8U0oz4OwKEg/A0Zd6CSFyHhfR3lUVJV9JdVszSslO6/MSQj7ysjOL2vREoiNCCU1KZbj+8Vzxqi+DOoVw+BesQzqFUP/xCgbuDXdmiUI09KBXPi/i51SGWHRMPxMJymknxmQV0HX1yu7iyubEsE+JxlsyyujtLqucb0e0c6A77dG92NYnzjS+8SR3jeOfglR1gowQcsShGmSvxmem+PUU5r7JBx/DkTE+jqqTqmq9bCzoIJt+c7Bf1u+mwjyy1oMDCfFRZLeJ445EweQ3ieOtD5xpPeJJykuwhKBMa1YgjCO3JWw4GKnoN68t6D/OF9HdBBVpbC8hm355S0Swbb8cnKLKlpcB9C/RxTD+sQxZchg0vs6LYJhfeJIjInw3RcwJsBYgjCwbTH86wrnYrfvvQ69hvo0nFpPPTmFFW0mggOVtY3rRYaFMCQplrEpPbhwwgDSkmNJS45jaHIsMRH2X9uYo2V/RcFu45vw8tWQPAKueBXi+3XZR1fU1JGdV8aWfWUtEsHOgooWNX2S4yNJS47l3HH9GZoc15gIBiRGExJi3ULGeIsliGC25V0nORyXAZe/AtGJXvmYqlqPMyawr4zN+0rZuq+ULfvKyCmqaCy/HB4qDO4dy7A+zkBxQ0tgaHIcPaLDvRKXMaZjliCC1dcfwotXQN/RTsvhGF3LUFZdx/rdB/hq9wHW5h5g/e4D7CgobxwfCA8VhiTFMi6lBxdPSmF43zjS+8YzuFeMlVc2xs9YgghGddXw6jXOWMOVrx1Vcigoq2b59kK+2F7Isq8L2LyvtLFVMCAxmjEDEjh3/HGM6BvP8L5xpCbF2rUDxgQISxDBqOHitzlPQEyvw3qrp15ZvauIxZvyWLwpj017SwGnFPSkwT25aXQ6GQMTGTOgB8nxkd6I3hjTRbyaIERkNvAwEAo8par3tVo+CHgWSHTXuU1VF3kzJgOseMq5F/TQ0zq1ep2nnqXbCli4Zg+LN+2jqKKW0BAhc3BPbv3WCE4c2ouxAxKJCLOWgTHdidcShIiEAo8BZwC5wAoRWaiqG5qt9hvgJVV9QkRGAYuAVG/FZIC965zaSmf+D4R0fEBft/sAL2fl8NZX37C/rIb4qDBOH9mXWSP7cGp6sg0eG9PNebMFcQKQrapfA4jIv4ALgOYJQoEE93UPYI8X4zEAWX936iplXN7m4lpPPf9dt5dnPtvByp1FRIaFMGtkH84fP4AZI5Kt8qgxQcSbCWIAkNNsOheY0mqdu4B3ReQnQCxwelsbEpFrgWsBBg0adMwDDRoVhbD2RRhz0UFjD5U1HhZ8sZOnPtnO3pIqBveO4bfnjuLiSSnWUjAmSHkzQbR1BVPr22R9B3hGVf8sIicBz4nIGFVtcVcVVZ0PzAfIzMw89F3RTUv7t8Ly+bDmBairhBOuaVxUUVPHc5/v5MlPvmZ/WQ0nDe3NvXPHMGN4H7sIzZgg580EkQsMbDadwsFdSD8AZgOo6uciEgUkAXlejCs41NfD1ndh+d+cUhqhETB6Lpx4PRw3gfp65d+rd3Pf25vYX1bNqelJ3DQrncmph3dWkzGm+/JmglgBpIvIEGA3cBnw3Vbr7AJmAc+IyEggCsj3YkzdX2UxrP4/WPEkFO2A+P4w8zcwaR7EJQPwVe4B7li4jtW7ipkwKJG/XTmRSYMtMRhjWvJaglDVOhG5EXgH5xTWp1V1vYjcA2Sp6kLgF8CTIvIznO6neapqXUhHavPb8OoPoaYMBp0Es+6EkedBqDOGUF5dx/3vbObZz3fQOzaSP317PHMnDLCuJGNMm7x6HYR7TcOiVvPuaPZ6AzDVmzEEjfWvOcmh31g472HoP77F4o+25PPrf3/FngOVXHVSKj8/czgJUTb4bIxpn11J3R2sfRFevx5SJsPlL7conVFZ4+Ge/6znheU5pCXH8sr1J1l3kjGmUyxBBLpV/4SFN0HqKfCdf7W4LeimvSX85PnVZOeXcf30NH56erpdx2CM6TRLEIFs+ZOw6BZImwWXLYDw6MZFL67YxR1vrCc+Kpznvj+FU9KTfBioMSYQWYIIVJ89Cu/+BoafBZc8C2FOYbxaTz2/+88G/vn5Tk5NT+KBSzKsaJ4x5ohYgghEH98Pi/8HRl0Ac5+CMOc+y4XlNdywYCXLvi7k2mlD+eXs4wm1M5SMMUfIEkQgUYUlv3cSxLhL4YLHIdT5J9y0t4QfPptFXmk1D1wynrkTU3wcrDEm0FmCCBSq8N5vna6lCVc6p7KGOAPO/123l5+/tIa4yDBeuu4kMgZ659ahxpjgYgkiUOxZ7SSHSVfDOQ9ASAj19cqji7N58P0tjB+YyPwrJ9E3IcrXkRpjuglLEIFi67uAwGm/hZAQyqvruOXltby9bi9zJw7g3jlj7RRWY8wxZQkiUGx9DwZMgtje5BRWcM0/s9iyr5TfnDOSH5wyBBEbjDbGHFuWIAJBeQHsXgkzbmPZ1wXcsGAVdZ56/nH1CUwfnuzr6Iwx3ZQliECwbTGgvF01hp889QWDesfw1PcyGZocd8i3GmPMkbIEEQA8W96lKjSRGz5UZoxI4uHvTLBCe8YYr7ME4ecKSisJ3/AOH9SO4brp6dz6rRF28ZsxpkuE+DoA074Ne0r45aPPklB/gIEnXMBtZ9mV0caYrmMJwk+9/dU3XPTEZ0zxrEIRMk+72NchGWOCjHUx+RlV5S+Ls/nze1uYOCiReSFbkVDn9FZjjOlK1oLwI1W1Hn724hr+/N4W5k4YwAtXpBO+dzWkn+Hr0IwxQchaEH5if1k11/4zi1W7irn1WyO4YUYasvo5QGGYJQhjTNc7ZAtCREa1MW+GV6IJUpv2lnDBX5ay4ZsSHr98Ij+eOQypKYMl90K/cXDcBF+HaIwJQp3pYnpJRH4pjmgReRT4X28HFiwWb9rHRY9/Rq2nnpeuO4mzx/Z3Fnz0Ryj9Bs75M4RYT6Axput15sgzBRgIfAasAPYAU70ZVLB4Zul2fvhsFqlJsbxx41TGpbhluvO3wLLHIeMKGHiCb4M0xgStzoxB1AKVQDQQBWxX1XqvRtXNqSoPvb+Vhz/Yyhmj+vLwZRnERIQ1LIS3b4WIWDj9Ll+GaYwJcp1pQazASRCTgVOA74jIK16NqhtTVe5dtJGHP9jKtyel8MTlE5uSA8CGN+DrD2HmbyDOCvEZY3ynMy2IH6hqlvt6L3CBiFzpxZi6tQfe28KTn2xn3smp3HHuKEIaroyur4dVz8B7d0LfsZD5fZ/GaYwxnUkQeSIyqNW8j7wRTHc3/+NtPLo4m8smD+TO80Y13cNh/1Z482bYuRSGTIPz/9J4r2ljjPGVzhyF3gIUEJwxiCHAZmC0F+Pqdl5Yvot7F23inHH9+f2csU5y8NTC0oedM5bCo5zEMOEKsJv/GGP8wCEThKqObT4tIhOB67wWUTf05to9/Pq1r5gxIpkHL8lwCu7tXgkLb4J962DUhXDWHyG+r69DNcaYRofdj6Gqq0RksjeC6Y7W5BTzi5fXMnlwL564fBIR9ZXwzr3OaaxxfeGy5+H4c3wdpjHGHOSQCUJEft5sMgSYCOR7LaJuJK+0iuufW0mf+Ej+euUkonM+gjd/CsU7nUHo0++CqB6+DtMYY9rUmRZEfLPXdThjEq96J5zuQ1X5+YtrKa6s4Y2rR9Hr3Zth7fPQexhc/TYMPtnXIRpjTIc6MwZxd1cE0t28sDyHT7P389QppYx4dRZUFsGpt8C0W50BaWOM8XPtJggReRPn7KU2qer5h9q4iMwGHgZCgadU9b421rkEuMv9rLWq+t1Dh+3f9hRXcu+ijZw0tDezcu6FiDi48nXoN8bXoRljTKd11IL409FsWERCgceAM4BcYIWILFTVDc3WSQd+BUxV1SIR6XM0n+kv7lq4Hk+98oc5o5C/boETf2TJwRgTcDpKEHeo6iwR+YOq/vIItn0CkK2qXwOIyL+AC4ANzda5BnhMVYsAVDXvCD7Hr3ywcR/vbtjHL2cfzyD2gqcG+hxUMd0YY/xeRwmiv4hMB853D+4trt5S1VWH2PYAIKfZdC5OZdjmhgOIyFKcbqi7VPW/nQncH1XVerhz4XrS+8Txg1OGwOaFzoI+I30bmDHGHIEOWxDAbUAK8GdaJggFTjvEttu6HLj1mEYYkA7McD/nExEZo6rFLTYkci1wLcCgQa2rfviPv3+6ndyiSp6/ZgoRYSGQtxEkBJKG+zo0Y4w5bO0mCFV9BXhFRH6rqr87gm3n4txHokEKzr0kWq+zTFVrge0ishknYaxoFct8YD5AZmZmuwPnvpRXWsXjS7I5c1RfTk5LcmdugF5DITzat8EZY8wROGS57yNMDuAc5NNFZIiIRACXAQtbrfM6MBNARJJwupy+PsLP86kH39tKdV09vzq7WXdS3kbrXjLGBCyv3ctSVeuAG4F3gI3AS6q6XkTuEZGGU2TfAQpEZAOwBLhVVQu8FZO37Cqo4OWsHC6fMoghSbHOzNoqKNwGyZYgjDGByas1pVV1EbCo1bw7mr1W4OfuI2A9tiSbkBDhhpnDmmbu3wJaby0IY0zA6uhCuV4dvVFVC499OIEnp7CCV1flcsWJg+mb0OwK6byNzrOd4mqMCVAdtSBW0nQfiEFAkfs6EdiFc1+IoPfcsp0AXD89reWCvA0QEg6909p4lzHG+L92xyBUdYiqDsUZJzhPVZNUtTdwLvDvrgrQn1XVengpK4czR/elX49W9ZXyNzmnt4aG+yY4Y4w5Sp0ZpJ7sjiUAoKpvA9O9F1LgeOvLbyiuqOWKEwcfvDBvg40/GGMCWmcSxH4R+Y2IpIrIYBG5HQi4M428YcEXOxmaHMtJQ3u3XFBdCsW7LEEYYwJaZxLEd4Bk4DX3kezOC2rZeaWs2lXMdyYPcu4v3Vz+ZufZBqiNMQGsM/eDKARuFpE4VS3rgpgCwstZuYSGCBdOGHDwwjy3HqG1IIwxAeyQLQgROdm9kG2DOz1eRB73emR+rM5Tz79X7+a04/uQHB958Ap5GyE8BhLbGJswxpgA0ZkupgeBb+GOO6jqWmCaN4Pydx9tySe/tJpvT0ppe4W8DZA8AkK8dqG6McZ4XaeOYKqa02qWxwuxBIyXsnJIiotg5vHt3N8ob6ONPxhjAl5nEkSOiJwMqIhEiMgtOLWVglJBWTUfbMxjzoQBhIe2sfvKC6Bsn40/GGMCXmcSxPXAj3FuAJQLZLjTQen1NXuoq1e+nTmw7RXyG0psWIIwxgS2zpzFtB+4vAtiCQgL1+xm7IAeDO8b3/YKVoPJGNNNdFSs71EOvgNcI1W9ySsR+bGcwgrW5h7gV2cd3/5KeRshqgfE9++6wIwxxgs6akFkdVkUAeKtr74B4OyxHRz8GwaoW188Z4wxAaajW44+25WBBIJFX33D+JQeDOwV0/YKqs4prmPmdm1gxhjjBZ25UO49EUlsNt1TRN7xblj+Z1dBBV/mHuCccR20Hkr3QlWxjT8YY7qFzpzFlKyqxQ0TqloEtHMBQPfVue4lt8RGcgdjFMYYEyA6kyA8IjKoYUJEBtPB4HV39dZXe8gYmEhKz3a6lwB2r3Ke7RRXY0w30Jl7Ut8OfCoiH7nT04BrvReS/9lVUMG63SXcfnYHB/6inbD0IRgyHWKTui44Y4zxkg4ThDh1rNcDE4ETcW45+jP32oig8eGWPADOGNW37RXq6+H1GwCBC/7SdYEZY4wXdZggVFVF5HVVnQT8p4ti8jsfb9nPwF7RDO7dTvfSF3+FnZ/C+X+BxEFtr2OMMQGmM2MQy0Rkstcj8VO1nnqWfV3AqenJB98YCCB/C3xwNwyfDROu6PoAjTHGSzozBjETuE5EdgLlON1MqqrjvBqZn1iTU0xZdR3T0tsYV/DUwevXQ3g0nPewXRxnjOlWOpMgzvJ6FH7sky35hAiclNZGglj6IOxeCRf/A+L7dX1wxhjjRR3VYkpQ1RKgtAvj8TufZO9n/MBEekSHt1zwzZfw4R9g9Fy7ctoY0y111IJ4HjgXWIlz3UPz/hMFhnoxLr9woKKWtTnF3HhaessFddXw2nUQ0wvO+bNvgjPGGC/rqBbTue7zkK4Lx798tm0/9Qqnth5/+PB/naumv/uSkySMMaYb6kwtpjki0qPZdKKIXOjdsPzDJ9n7iYsMI2NgYtPMXV/A0odhwpUw/Fu+C84YY7ysM6e53qmqBxom3LpMd3ovJP+gqny8JZ+T0no33Vq0ptw5aykhBb51r28DNMYYL+tMgmhrnc6c/RTQdhZUkFtU2fL01vfvgsKv4cLHISrBZ7EZY0xX6EyCyBKRB0QkTUSGisiDOAPX3donW/MBOCU92Znx9YewfD5M+REMOdV3gRljTBfpTIL4CVADvAi8DFQBP+7MxkVktohsFpFsEbmtg/UuFhEVkczObLcrfLJ1Pyk9o0ntHQNVB+D1H0PvdDi92/euGWMM0ImuIlUtB9o9uLdHREKBx4AzgFxghYgsVNUNrdaLB24Cvjjcz/CWWk89n28r4NzxxznlNf77KyjdAz9437lq2hhjgsAhE4SIDAduAVKbr6+qpx3irScA2ar6tbudfwEXABtarfc74I/uZ/iFtTnFlFbXOae3bloEaxbAqbdAyiRfh2aMMV2mM4PNLwN/BZ4CPIex7QFATrPpXGBK8xVEZAIwUFX/IyJ+kyA+2bqfEIGpx4XA0zdBv7Ew/Ze+DssYY7pUZxJEnao+cQTbbqtyXeOd6EQkBHgQmHfIDYlci3uTokGDvF9O+9Ps/YxNSaTHjrehPB+++yKERXj9c40xxp90ZpD6TRG5QUT6i0ivhkcn3pcLDGw2nQLsaTYdD4wBPhSRHTg3JFrY1kC1qs5X1UxVzUxOTu7ERx+5yhoPa3OKOWlob8j+ABIGwHETvfqZxhjjjzrTgrjKfb612bzO1GJaAaSLyBBgN3AZ8N3GDTgX3zVeZCAiHwK3qGpWJ2LymjU5xdTVK1MGx8MbH8Go862MtzEmKHXmLKYjqsWkqnUiciPwDhAKPK2q60XkHiBLVRceyXa9bcWOQkRgcvgOqD4Aw2b5OiRjjPGJdruYROT/NXv97VbLOlVnQlUXqepwVU1T1d+eNY4kAAAWtUlEQVS78+5oKzmo6gxftx7ASRAj+sYTl/sxSAgMneHrkIwxxic6GoO4rNnrX7VaNtsLsfhcnaeeVTuLmJzaC7Z9AAMmQXRPX4dljDE+0VGCkHZetzXdLWz8ppTyGg8nDwh17hSXdqhLPYwxpvvqKEFoO6/bmu4Wlu8oBOBEvgSthzQbfzDGBK+OBqnHi0gJTmsh2n2NOx3l9ch8IGtHISk9o+m5522I7OF0MRljTJDq6I5yoV0ZiK+pKit2FDJtWBJsWwxDp0Not69qbowx7erMhXJBYfv+cvaX1XBaUjGU7LbTW40xQc8ShCtrRxEAU3S1M8MGqI0xQc4ShGv5jkJ6xoSTtG+pc9+HRO/XfDLGGH9mCcK1YkchJw6KQ3Yste4lY4zBEgQAeSVV7Cyo4LzEHVBXaae3GmMMliAAWOGOP2TWrYLQCEid6uOIjDHG9yxB4HQvRYeHkrzvUxh0EkTE+jokY4zxOUsQOAnitAF1SP5GG38wxhhX0CeI0qpaNn5Twvlxm5wZNv5gjDGAJQhW7iyiXmFi7SqI6wt9R/s6JGOM8QtBnyCydhQRHqIk7fvMuTjO7h5njDGAJQiW7yjkvOQ8pKrIupeMMaaZoE4Q1XUe1uQUc17sRkAgbaavQzLGGL8R1Ali3e4D1NTVM756JfQfD7FJvg7JGGP8RlAniOXbi4ingp6Fa+z0VmOMaSWoE8SKHYXMScxG1GPVW40xppWgTRD19UrWjkLOjtkIEXGQcoKvQzLGGL8StAliS14pJVW1jK3MgiHTICzC1yEZY4xfCdoEsWJ7Iamyl9jK3da9ZIwxbQjeBLGjiHNiNjgTNkBtjDEHCcoEoapkbd/Pd0MXQ/JI6DXU1yEZY4zfCfN1AL6QW1TJxLKPGBCxHab93dfhGGOMXwrKFkTWjnx+GvYqVT2Hw+g5vg7HGGP8UlC2IGpWv8KwkD14Zj0LIaG+DscYY/xS8LUgPHVM3f0Uu8KHEjrqfF9HY4wxfivoEkRZ1vOk1O9h3fAbICTovr4xxnRacB0hPbWEfPxHvqpPJWnSXF9HY4wxfi24EsSa54kpz+HR+ksYNzDR19EYY4xf82qCEJHZIrJZRLJF5LY2lv9cRDaIyJci8oGIDPZaMHU18PH9bAkbTsFxM4gKt8FpY4zpiNcShIiEAo8BZwGjgO+IyKhWq60GMlV1HPAK8EdvxcPq5+BADv9bNZfMIb289jHGGNNdeLMFcQKQrapfq2oN8C/gguYrqOoSVa1wJ5cBKV6JpLYKPv4TpX0yWVI3lszBliCMMeZQvJkgBgA5zaZz3Xnt+QHwdlsLRORaEckSkaz8/PzDj2TVs1C6h8X9fwAIkwb3PPxtGGNMkPFmgpA25mmbK4pcAWQC97e1XFXnq2qmqmYmJycfXhS1lfDJn2HwKbxRPIy05Fh6xVppb2OMORRvJohcYGCz6RRgT+uVROR04HbgfFWtPuZRZD0NZfuon34bK3cVW/eSMcZ0kjcTxAogXUSGiEgEcBmwsPkKIjIB+BtOcsg75hHUlMOnD8KQ6WyLzeBAZS2TUq17yRhjOsNrCUJV64AbgXeAjcBLqrpeRO4RkYYaF/cDccDLIrJGRBa2s7kjs/xJKM+HmbezYkcRAJNTrQVhjDGd4dVifaq6CFjUat4dzV6f7rUPry6FpQ/DsNNh0BSylq2hd2wEqb1jvPaRxpiO1dbWkpubS1VVla9D6baioqJISUkhPDz8qLfVfau5fvE3qCyEGb8GYOXOIiYN7olIW2PnxpiukJubS3x8PKmpqfa36AWqSkFBAbm5uQwZMuSot9c9S21UHYDPHoXhsyFlEnklVewsqCDTxh+M8amqqip69+5tycFLRITevXsfsxZa90wQy56AqmKY6bQePttWAMBJQ5N8GZUxBiw5eNmx3L/dL0FUFsHnj8Hx50L/8QB8tm0/PaLDGXVcgo+DM8b42t69e7nssstIS0tj1KhRnH322WzZsqXd9ePi4gDYs2cPF198MQDPPPMMN95441HF8dBDD1FRUdE4ffbZZ1NcXHxU2zzWul+C+PwxqC6BGb8CnD65pdkFnDi0F6Eh9svFmGCmqsyZM4cZM2awbds2NmzYwL333su+ffsO+d7jjjuOV1555bA+q76+vt3lrRPEokWLSEz0ryrT3StBVBQ63UujLoR+YwDIKaxkd3ElU4dZ95IxwW7JkiWEh4dz/fXXN87LyMhgwoQJzJo1i4kTJzJ27FjeeOONg967Y8cOxowZ0zidk5PD7NmzGTFiBHfffXfjOiNHjuSGG25g4sSJ5OTk8KMf/YjMzExGjx7NnXfeCcAjjzzCnj17mDlzJjNnzgQgNTWV/fv3A/DAAw8wZswYxowZw0MPPdRi29dccw2jR4/mzDPPpLKy0js7ytW9zmL67BHn4ji39QCwdJuzw09OswRhjD+5+831bNhTcky3Oeq4BO48b3S7y9etW8ekSZMOmh8VFcVrr71GQkIC+/fv58QTT+T888/vsD9/+fLlrFu3jpiYGCZPnsw555xDUlISmzdv5h//+AePP/44AL///e/p1asXHo+HWbNm8eWXX3LTTTfxwAMPsGTJEpKSWh6bVq5cyT/+8Q+++OILVJUpU6Ywffp0evbsydatW3nhhRd48sknueSSS3j11Ve54oorjnBvHVr3aUGU5Tunto69GPoc3zh7afZ++sRHkpYc68PgjDH+TFX59a9/zbhx4zj99NPZvXv3IbudzjjjDHr37k10dDRz587l008/BWDw4MGceOKJjeu99NJLTJw4kQkTJrB+/Xo2bNjQ4XY//fRT5syZQ2xsLHFxccydO5dPPvkEgCFDhpCRkQHApEmT2LFjx1F860PrPi2IpQ9BXRVM/2XjLFXl820FTBuebGdOGONnOvql7y2jR49ucxxhwYIF5Ofns3LlSsLDw0lNTT3kqaKtjykN07GxTT9Gt2/fzp/+9CdWrFhBz549mTdv3iG3q9pmTVMAIiMjG1+HhoZ6vYupe7QgSvfCiqdg3KWQlN44e/O+UgrKazg5rbcPgzPG+IvTTjuN6upqnnzyycZ5K1asYOfOnfTp04fw8HCWLFnCzp07D7mt9957j8LCQiorK3n99deZOnXqQeuUlJQQGxtLjx492LdvH2+/3XRHg/j4eEpLSw96z7Rp03j99depqKigvLyc1157jVNPPfUIv/HR6R4J4tOHwFML025tMfujzc69I2yA2hgDzq/81157jffee4+0tDRGjx7NXXfdxdlnn01WVhaZmZksWLCA448//pDbOuWUU7jyyivJyMjgoosuIjMz86B1xo8fz4QJExg9ejTf//73WySRa6+9lrPOOqtxkLrBxIkTmTdvHieccAJTpkzhhz/8IRMmTDj6L38EpKPmjD/KzMzUrKysphkHdsMjE2DcJXDBX1qse+nfPudAZS3//em0Lo7SGNOWjRs3MnLkSF+H0e21tZ9FZKWqHpzFOhD4LYhPHwD1HNR6OFBZS9bOIk47vo+PAjPGmMAW2AmiOAdWPgsTroSeg1ss+mRrPp56tQRhjDFHKLATxCd/AhGYdstBixZvyiMxJpwJg6xAnzHGHInATRBFO2D1/8GkedAjpcWi+nrlo835TB+ebOU1jDHmCAVugvjofpBQOOXnBy1am1tMQXmNdS8ZY8xRCMwEUbAN1r4Ak38ACf0PWrxkUx4hAtOHJ/sgOGOM6R4CM0F89EcIjYCpP21z8eLNeUwc1JPEmIguDswY4+9yc3O54IILSE9PJy0tjZtvvpmampqj2ua8efMay2BMnDiRzz//HIBly5YxZcoUMjIyGDlyJHfddRfglAtPTk4mIyODjIwMvve97x3t1/KKwEsQdVXw1UtwwjUQ3/egxXuKK1m3u4TTRlr3kjGmJVVl7ty5XHjhhWzdupUtW7ZQVlbG7bfffljb8Xg8B827//77WbNmDffddx/XXXcdAFdddRXz589nzZo1rFu3jksuuaRx/UsvvZQ1a9awZs0a/vnPfx7dF/OSwEsQpXshLBqm3tzm4kVffQPAWWMO7noyxgS3xYsXExUVxdVXXw049YwefPBBnn76aSoqKg66EdC5557Lhx9+CDg3DrrjjjuYMmVKYwuhLdOmTSM7OxuAvLw8+vfv3/hZo0aN8tI3847AK9ZXWQxTfguxbZfPeHvdXkb2T2BIklVvNcavvX0b7P3q2G6z31g46752F69fv/6gct8JCQkMGjSo8aDenvLycsaMGcM999zT4XpvvvkmY8eOBeBnP/sZI0aMYMaMGcyePZurrrqKqKgoAF588cXGCrA333xzY9LyJ4HXgpAQOPknbS765kAlK3cWcc7Yfl0clDEmEKhqm5Wd25vfXGhoKBdddFG7y2+99VYyMjKYP38+f//73wG44447yMrK4swzz+T5559n9uzZjes372Lyx+QAgdiC6JECMb3aXLToq70AzLbuJWP8Xwe/9L1l9OjRvPrqqy3mlZSUkJOTQ1paGmvXrm1xm9DmpbmjoqIIDQ1td9v3339/4z2rm0tLS+NHP/oR11xzDcnJyRQUFByDb9I1Aq8F0U5yUFVezsphXEoPhvWJ6+KgjDGBYNasWVRUVDQOCns8Hn7xi18wb948YmJiSE1NZc2aNdTX15OTk8Py5cuP6vPeeuutxvs7bN26ldDQUL+773RHAi9BtOPL3ANs2lvKJZkDfR2KMcZPNZT7fvnll0lPT2f48OFERUVx7733AjB16lSGDBnC2LFjueWWW5g4ceJRfd5zzz3HiBEjyMjI4Morr2TBggUdtkL8TeCX+3b9+rWv+PeqXJbffjoJUeE+iMwYcyhW7rtrWLnvVgb3iuGqk1MtORhjzDESeIPU7bhuepqvQzDGmG6l27QgjDHGHFuWIIwxXSrQxj0DzbHcv5YgjDFdJioqioKCAksSXqKqFBQUNF6tfbS8OgYhIrOBh4FQ4ClVva/V8kjgn8AkoAC4VFV3eDMmY4zvpKSkkJubS35+vq9D6baioqJISUk59Iqd4LUEISKhwGPAGUAusEJEFqrqhmar/QAoUtVhInIZ8AfgUm/FZIzxrfDwcIYMGeLrMEwnebOL6QQgW1W/VtUa4F/ABa3WuQB41n39CjBLDlUQxRhjTJfwZoIYAOQ0m85157W5jqrWAQeA3q03JCLXikiWiGRZ09QYY7qGNxNEWy2B1iNTnVkHVZ2vqpmqmpmcbLcRNcaYruDNQepcoHlhpBRgTzvr5IpIGNADKOxooytXriwTkc3HMtAAlgTs93UQfsL2RRPbF01sXzQZcbhv8GaCWAGki8gQYDdwGfDdVussBK4CPgcuBhbroc9/23y49US6KxHJsn3hsH3RxPZFE9sXTUTk4CJ2h+C1BKGqdSJyI/AOzmmuT6vqehG5B8hS1YXA34HnRCQbp+VwmbfiMcYYc3i8eh2Eqi4CFrWad0ez11XAt70ZgzHGmCMTiFdSz/d1AH7E9kUT2xdNbF80sX3R5LD3RcDdD8IYY0zXCMQWhDHGmC4QUAlCRGaLyGYRyRaR23wdT1cSkadFJE9E1jWb10tE3hORre5zT1/G2BVEZKCILBGRjSKyXkRuducH476IEpHlIrLW3Rd3u/OHiMgX7r54UUQifB1rVxGRUBFZLSL/caeDcl+IyA4R+UpE1jScvXQkfyMBkyCa1XY6CxgFfEdERvk2qi71DDC71bzbgA9UNR34wJ3u7uqAX6jqSOBE4Mfu/4Ng3BfVwGmqOh7IAGaLyIk4Nc0edPdFEU7Ns2BxM7Cx2XQw74uZqprR7DTfw/4bCZgEQedqO3VbqvoxB19E2LyW1bPAhV0alA+o6jequsp9XYpzMBhAcO4LVdUydzLcfShwGk5tMwiSfQEgIinAOcBT7rQQpPuiHYf9NxJICaIztZ2CTV9V/QacAyfQx8fxdCkRSQUmAF8QpPvC7VJZA+QB7wHbgGK3thkE19/JQ8D/A+rd6d4E775Q4F0RWSki17rzDvtvJJDuSd2puk0mOIhIHPAq8FNVLQnWIsCq6gEyRCQReA0Y2dZqXRtV1xORc4E8VV0pIjMaZrexarffF66pqrpHRPoA74nIpiPZSCC1IDpT2ynY7BOR/gDuc56P4+kSIhKOkxwWqOq/3dlBuS8aqGox8CHOuEyiW9sMgufvZCpwvojswOl+Pg2nRRGM+wJV3eM+5+H8cDiBI/gbCaQE0VjbyT0T4TKcWk7BrKGWFe7zGz6MpUu4/cp/Bzaq6gPNFgXjvkh2Ww6ISDRwOs6YzBKc2mYQJPtCVX+lqimqmopzbFisqpcThPtCRGJFJL7hNXAmsI4j+BsJqAvlRORsnF8FDbWdfu/jkLqMiLwAzMCpTrkPuBN4HXgJGATsAr6tqh1Www10InIK8AnwFU19zb/GGYcItn0xDmewMRTnx95LqnqPiAzF+RXdC1gNXKGq1b6LtGu5XUy3qOq5wbgv3O/8mjsZBjyvqr8Xkd4c5t9IQCUIY4wxXSeQupiMMcZ0IUsQxhhj2mQJwhhjTJssQRhjjGmTJQhjjDFtsgRhjDGmTZYgTEASEY9bynidiLzZcMHYYbz/LhG5xX19j4icfpTxpIpIpVsXyS+IyKVuafz/+DoWE5gsQZhAVemWMh6DU+X2x0e6IVW9Q1XfPwYxbVPVjMN5g1vG3itU9UXgh97avun+LEGY7uBz3CqdIhInIh+IyCr3himNJeFF5Hb3hlPvAyOazX9GRC52X+8QkST3daaIfOi+nu62WNa4N6SJP1RQIvK6W01zfbOKmohImdtq+QI4SUQmi8hn7o1/lotIvIiMdl+vEZEvRSTdfe8Vzeb/rSHBiHMzrVXuNj44+l1qTGBVczXmIO4BchZOfSaAKmCOW+E1CVgmIguBiTg1eibg/L9fBaw8jI+6Bfixqi51K8lWdeI931fVQrdO0goReVVVC4BYYJ2q3uHWFdsEXKqqK0QkAagErgceVtUF7jqhIjISuBSnUmetiDwOXC4ibwNPAtNUdbuI9DqM72VMuyxBmEAV7fb3p+Ic6N9z5wtwr4hMw6nVNADoC5wKvKaqFQBu0jgcS4EHRGQB8G9Vze3Ee24SkTnu64FAOlAAeHCq0YLTkvlGVVcAqGqJG9/nwO3uTXD+rapbRWQWMAkn2QBE41TkPBH4WFW3u9vo1jWoTNexLiYTqCrd/v7BQARNYxCXA8nAJHf5PiDKXdaZwmN1NP1dNLwPVb0Ppz8/GqdVcnxHG3ELxp0OnOTeEnR1s+1VufdxACehHRSXqj4PnI/TmnhHRE5z133WHXvJUNURqnpXe9sw5mhZgjABTVUPADcBt7j3ieiBc+OYWhGZiZNAAD4G5ohItDt+cF47m9yB8ysd4KKGmSKSpqpfqeofgCygwwThxlGkqhVuMjmxnfU2AceJyGT3c+JFJMytyPm1qj6CU6Z5HM59hC92bwLTcBP6wThjMNNFZEjD/EPEZkynWBeTCXiqulpE1uKMMSwA3hSRLGANzgEYVV0lIi+683bilAxvy93A30WkoYR4g5+6CccDbADePkRY/wWuF5Evgc3AsnZirxGRS4FH3bGKSpyWx6XAFSJSC+wF7nHHM36DcyvJEKAWZ1xkmTsI/m93fh5wxiHiM+aQrNy3MceAOPfH/o972q3faH5vBF/HYgKPdTEZc2x4gB7+dqEc8DhQ5OtYTGCyFoQxxpg2WQvCGGNMmyxBGGOMaZMlCGOMMW2yBGGMMaZNliCMMca06f8DSFVALZTBCaYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(radiuseff, valeff, label='Calibration')\n", "plt.plot(radii, encircled_flux/np.max(encircled_flux), label='Our PSF')\n", "plt.xlim([0, 50])\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Encircled flux')\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "rfactor = np.arange(1.,2., 1e-3)\n", "ffactor = np.arange(1.,2., 1e-3)\n", "# work with the data points between 2 and 10\"\n", "idx, = np.where((radii > 1 ) & (radii < 12))\n", "xv = radii[idx]\n", "yv = encircled_flux[idx]/np.max(encircled_flux)\n", "resid = np.zeros((len(rfactor), len(ffactor)))\n", "for i, rf in enumerate(rfactor):\n", " #print(i, rf)\n", " tck = interpolate.splrep(radiuseff*rf, valeff, s=0)\n", " yfit = interpolate.splev(xv, tck, der=0)\n", " for j, ff in enumerate(ffactor):\n", " resid[i, j] = np.sum((yv-yfit*ff)**2)\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.imshow(np.log(resid))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This shows a minimum, with some degeneracy. " ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rf = 1.195, ff = 1.058, residual = 0.010\n" ] } ], "source": [ "imin = np.argmin(resid)\n", "rmin, fmin = np.unravel_index(imin, resid.shape)\n", "print(\"rf = {:.3f}, ff = {:.3f}, residual = {:.3f}\".format(rfactor[rmin], ffactor[fmin], resid[rmin, fmin]))" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(radiuseff*rfactor[rmin], valeff, label='Calibration')\n", "plt.plot(radii, encircled_flux/np.max(encircled_flux)/ffactor[fmin], label='Our PSF')\n", "plt.xlim([0, 100])\n", "plt.xlabel('Radius [arcsec]')\n", "plt.ylabel('Encircled flux')\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1071358614835.1749" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# The two curve overlap\n", "psfok = psf/np.max(encircled_flux)/ffactor[fmin]\n", "np.sum(psfok)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "psfok is the PSF that a source of flux 1 Jy has in our data, and is to be used for source extraction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### As units of map in MJy/sr, divide by 1E6" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "psfok=psfok/1.0E6" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Validation\n", "To check PSF is reasonable, lets look at a 100 micron source, e.g. `---`. We can see from `GAMA-15_PACS100_v0.9.fit` that it has a flux of -- mJy. Maximum value in our normalised PSF ---- \n" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": true }, "outputs": [], "source": [ "from astropy.table import Table" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "ename": "FileNotFoundError", "evalue": "[Errno 2] No such file or directory: './data/GAMA-15_PACSxID24_v1.fits'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mPACScat\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mTable\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'./data/GAMA-15_PACSxID24_v1.fits'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/astropy/table/table.py\u001b[0m in \u001b[0;36mread\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2548\u001b[0m \u001b[0;31m# RST table and inserts at the end of the docstring. DO NOT REMOVE.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2549\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2550\u001b[0;31m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mio_registry\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2551\u001b[0m \u001b[0;31m# For some readers (e.g., ascii.ecsv), the returned `out` class is not\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2552\u001b[0m \u001b[0;31m# guaranteed to be the same as the desired output `cls`. If so,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/astropy/io/registry.py\u001b[0m in \u001b[0;36mread\u001b[0;34m(cls, format, *args, **kwargs)\u001b[0m\n\u001b[1;32m 500\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 501\u001b[0m \u001b[0mctx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_readable_fileobj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'binary'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 502\u001b[0;31m \u001b[0mfileobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__enter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 503\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mOSError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 504\u001b[0m \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/lib/python3.6/contextlib.py\u001b[0m in \u001b[0;36m__enter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__enter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 81\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 82\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"generator didn't yield\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/astropy/utils/data.py\u001b[0m in \u001b[0;36mget_readable_fileobj\u001b[0;34m(name_or_obj, encoding, cache, show_progress, remote_timeout)\u001b[0m\n\u001b[1;32m 191\u001b[0m \u001b[0mname_or_obj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcache\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshow_progress\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshow_progress\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 192\u001b[0m timeout=remote_timeout)\n\u001b[0;32m--> 193\u001b[0;31m \u001b[0mfileobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFileIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname_or_obj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'r'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 194\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_url\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 195\u001b[0m \u001b[0mdelete_fds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfileobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './data/GAMA-15_PACSxID24_v1.fits'" ] } ], "source": [ "PACScat=Table.read('./data/GAMA-15_PACSxID24_v1.fits')" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'PACScat' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mPACScat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'HELP_ID'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'PACScat' is not defined" ] } ], "source": [ "PACScat['HELP_ID']" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'PACScat' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mPACScat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mPACScat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'HELP_ID'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'GAMA15-PACSxID24-1-69605'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'PACScat' is not defined" ] } ], "source": [ "PACScat[PACScat['HELP_ID']=='GAMA15-PACSxID24-1-69605']" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Max PSF = 63.9919 Jy/sr, off pixel Max PSF = 60.9418 Jy/sr\n" ] } ], "source": [ "cpix=np.int((hd['NAXIS1']+1)/2.0)\n", "\n", "print(\"Max PSF = {:.4f} Jy/sr, off pixel Max PSF = {:.4f} Jy/sr\".format(psfok[cpix-1,cpix-1]*0.027,psfok[cpix-2,cpix-2]*0.027))" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/mc741/anaconda3/lib/python3.6/site-packages/mpl_toolkits/axes_grid/__init__.py:12: MatplotlibDeprecationWarning: \n", "The mpl_toolkits.axes_grid module was deprecated in Matplotlib 2.1 and will be removed two minor releases later. Use mpl_toolkits.axes_grid1 and mpl_toolkits.axisartist, which provide the same functionality instead.\n", " obj_type='module')\n" ] }, { "ename": "OSError", "evalue": "File not found: ./data/input_data/GAMA15_PACS100_v0.9.fits", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_style\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"white\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcubehelix_palette\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrot\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m.75\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mas_cmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mfig\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maplpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFITSFigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'./data/input_data/GAMA15_PACS100_v0.9.fits'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecenter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPACScat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mPACScat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'HELP_ID'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'GAMA15-PACSxID24-1-69605'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'RA'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mPACScat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mPACScat\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'HELP_ID'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'GAMA15-PACSxID24-1-69605'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Dec'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mradius\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.004\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow_colorscale\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/aplpy/core.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data, hdu, figure, subplot, downsample, north, convention, dimensions, slices, auto_refresh, **kwargs)\u001b[0m\n", "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/aplpy/decorators.py\u001b[0m in \u001b[0;36m_auto_refresh\u001b[0;34m(f, *args, **kwargs)\u001b[0m\n\u001b[1;32m 23\u001b[0m \u001b[0mmydata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnesting\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmydata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'nesting'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 26\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[0mmydata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnesting\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/aplpy/core.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data, hdu, figure, subplot, downsample, north, convention, dimensions, slices, auto_refresh, **kwargs)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 216\u001b[0m self._data, self._header, self._wcs = self._get_hdu(data, hdu, north, \\\n\u001b[0;32m--> 217\u001b[0;31m convention=convention, dimensions=dimensions, slices=slices)\n\u001b[0m\u001b[1;32m 218\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_wcs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_header\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'NAXIS%i'\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdimensions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 219\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_wcs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mny\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_header\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'NAXIS%i'\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdimensions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/aplpy/core.py\u001b[0m in \u001b[0;36m_get_hdu\u001b[0;34m(self, data, hdu, north, convention, dimensions, slices)\u001b[0m\n\u001b[1;32m 297\u001b[0m \u001b[0;31m# Check file exists\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexists\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 299\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mIOError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"File not found: \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 300\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 301\u001b[0m \u001b[0;31m# Read in FITS file\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mOSError\u001b[0m: File not found: ./data/input_data/GAMA15_PACS100_v0.9.fits" ] } ], "source": [ "import aplpy\n", "import seaborn as sns\n", "sns.set_style(\"white\")\n", "cmap=sns.cubehelix_palette(8, start=.5, rot=-.75,as_cmap=True)\n", "fig=aplpy.FITSFigure('./data/input_data/GAMA15_PACS100_v0.9.fits')\n", "fig.recenter(PACScat[PACScat['HELP_ID']=='GAMA15-PACSxID24-1-69605']['RA'],PACScat[PACScat['HELP_ID']=='GAMA15-PACSxID24-1-69605']['Dec'], radius=0.004)\n", "fig.show_colorscale(vmin=0.0,vmax=1,cmap=cmap)\n", "fig.add_colorbar()\n", "fig.colorbar.set_location('top')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In summary, the PSF is within 10% of this source, and given noise and shape of source will add additional uncertianty, as well as non-zero background, this seems reasonable.\n" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "rad=1\n", "plt.imshow(psfok[cpix-1-rad:cpix+rad:5,cpix-1-rad:cpix+rad:5]*0.358,vmin=0.0,vmax=0.08 ,cmap=cmap)\n", "plt.colorbar()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Create PSF fits file¶\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "stackhd[0].data=psfok\n", "stackhd.writeto('./data/dmu18_PACS_100_PSF_GAMA15_20190301sr.fits',output_verify='fix+warn', overwrite=True)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2481.2108897751496" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.max(psfok)" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#plt.hist(psfok.flatten(),bins=np.arange(-0.01,0.05,0.0005));\n", "#plt.yscale('log')" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.hist(psfok.flatten(),bins=np.arange(2200,2300,1));\n", "plt.yscale('log')" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "484" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(psfok.flatten())" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.mean(~np.isnan(psf))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python (herschelhelp_internal)", "language": "python", "name": "helpint" }, "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 }