From 426c8150a77c25e6a35e190a54829d6be47c6aa3 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 18 Nov 2024 18:43:07 +0000 Subject: [PATCH 01/99] New notebook 16 on galaxy photometry --- DP02_16_Galaxy_Photometry.ipynb | 269 ++++++++++++++++++++++++++++++++ 1 file changed, 269 insertions(+) create mode 100644 DP02_16_Galaxy_Photometry.ipynb diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb new file mode 100644 index 0000000..443a1fc --- /dev/null +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -0,0 +1,269 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "749b0ddf", + "metadata": { + "tags": [] + }, + "source": [ + "# DP0.2 Notebook 16 Galaxy Photometry\n", + "\n", + "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", + "<br>\n", + "Contact author(s): <i>Christina Williams</i> <br>\n", + "Last verified to run: <i>2024-11-18</i> <br>\n", + "LSST Science Pipelines version: Weekly <i>2024_24</i> <br>\n", + "Container Size: <i>medium</i> <br>\n", + "Targeted learning level: <i>beginner</i> <br>" + ] + }, + { + "cell_type": "markdown", + "id": "2d9cd09b-d5c4-4610-993b-711bdc9bd80e", + "metadata": {}, + "source": [ + "_In this template, text in italics are examples or instructions that should be: \n", + "(a) removed if it is not applicable to the notebook; \n", + "or (b) replaced with text that is appropriate for the notebook. \n", + "But bold or regular text should appear pretty much as-is in all CET notebooks._\n", + "\n", + "_Remember to use the [CST's Guidelines for Tutorial Notebooks](rtn-045.lsst.io)._" + ] + }, + { + "cell_type": "markdown", + "id": "582ab507-a7ae-4024-95c9-38aabeb602a6", + "metadata": {}, + "source": [ + "_While developing, use the following code cell to check that the code conforms to standards, but then delete the cell and \"Kernel --> Restart Kernel and Clear All Outputs\" before saving and committing._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext pycodestyle_magic\n", + "%flake8_on\n", + "import logging\n", + "logging.getLogger(\"flake8\").setLevel(logging.FATAL)" + ] + }, + { + "cell_type": "markdown", + "id": "482777d8-0a8d-432e-ba53-2da536700407", + "metadata": {}, + "source": [ + "_The six cells below are considered the extended header of the notebook. The first four will be used, verbatim, to create the table of notebook metadata in the README.md file for the repository._" + ] + }, + { + "cell_type": "markdown", + "id": "9da1a210-d858-42fe-8591-570965b8be1a", + "metadata": {}, + "source": [ + "**Description:** _Very brief description of notebook._" + ] + }, + { + "cell_type": "markdown", + "id": "80a0baf5-51ad-40ec-8991-060a7b27c289", + "metadata": {}, + "source": [ + "**Skills:** _Brief list of skills to match the README.md file for the repository._" + ] + }, + { + "cell_type": "markdown", + "id": "393da88f-7978-4920-aa4a-a9830df6eed9", + "metadata": {}, + "source": [ + "**LSST Data Products:** _List the all of the types of LSST catalogs and images used._" + ] + }, + { + "cell_type": "markdown", + "id": "5c67fab9-136a-4adc-bb42-142b91ab69dd", + "metadata": {}, + "source": [ + "**Packages:** _List the python packages used._ (_List the packages being taught first, e.g., afwDisplay for a notebook about displaying images. Then supporting packages, e.g., lsst.daf.butler for a notebook about displaying images. It is OK to leave out basic support packages like os or glob.)_" + ] + }, + { + "cell_type": "markdown", + "id": "8f72b27f", + "metadata": {}, + "source": [ + "**Credit:**\n", + "_E.g., \"Originally developed by\" or \"Based on notebooks developed by\" and then people's names, including journal article or software release citations if appropriate._\n", + "Please consider acknowledging them if this notebook is used for the preparation of journal articles, software releases, or other notebooks." + ] + }, + { + "cell_type": "markdown", + "id": "28e91cbf-ab7f-4e26-9276-b00299d6065e", + "metadata": {}, + "source": [ + "**Get Support:**\n", + "Find DP0-related documentation and resources at <a href=\"https://dp0.lsst.io\">dp0.lsst.io</a>.\n", + "Questions are welcome as new topics in the \n", + "<a href=\"https://community.lsst.org/c/support/dp0\">Support - Data Preview 0 Category</a> \n", + "of the Rubin Community Forum. \n", + "Rubin staff will respond to all questions posted there." + ] + }, + { + "cell_type": "markdown", + "id": "cfc73be0", + "metadata": {}, + "source": [ + "## 1. Introduction\n", + "\n", + "_Provide a light narrative about this notebook, e.g., \"This notebook will teach the user...\"._\n", + "\n", + "_Cite or link to any external information or documentation, and cross-reference to other notebooks._\n", + "\n", + "> **Notice:** *use indented text preceded with* **Notice** *or* **Warning** *to attract attention to particular information.*\n", + "\n", + "_Embedded images or generated figures should be captioned in a markdown cell, like this._" + ] + }, + { + "cell_type": "markdown", + "id": "1cb7977c-8faa-4c34-8296-7ba014056a97", + "metadata": {}, + "source": [ + "<img align=\"center\" src='example.png' width=350 alt=\"A plot of value 2 versus value 1 for case A and case B, showing the cases are different power laws.\"><br>" + ] + }, + { + "cell_type": "markdown", + "id": "69ec20dd-47fc-43f1-9cd7-c265e493b31f", + "metadata": {}, + "source": [ + "> **Figure 1:** Value 2 as a function of Value 1 for Case A as black open circles and Case B as grey open triangles, showing that in Case B the power law has a higher exponent." + ] + }, + { + "cell_type": "markdown", + "id": "dc36f107", + "metadata": {}, + "source": [ + "### 1.1 Import packages\n", + "\n", + "_All package imports should be done in the first code cell._\n", + "\n", + "_Do not import packages unless they are used._\n", + "\n", + "_Provide explanation or external links to package documentation, where appropriate._\n", + "\n", + "_Describe the packages being imported, as is done below for commonly-imported packages._" + ] + }, + { + "cell_type": "markdown", + "id": "ccb4fe61-835a-47ac-a691-e086ce766e79", + "metadata": {}, + "source": [ + "`numpy` is a fundamental package for scientific computing with arrays in Python\n", + "(<a href=\"https://numpy.org\">numpy.org</a>).\n", + "\n", + "`matplotlib` is a comprehensive library for creating static, animated, and\n", + "interactive visualizations in Python \n", + "(<a href=\"https://matplotlib.org/\">matplotlib.org</a>; \n", + "<a href=\"https://matplotlib.org/stable/gallery/index.html\">matplotlib gallery</a>).\n", + "\n", + "From the `lsst` package, modules for accessing the TAP service, the butler, and image display functions are imported (<a href=\"https://pipelines.lsst.io/\">pipelines.lsst.io</a>)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cddc1458", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from lsst.rsp import get_tap_service, retrieve_query\n", + "import lsst.daf.butler as dafButler\n", + "import lsst.afw.display as afwDisplay" + ] + }, + { + "cell_type": "markdown", + "id": "c217adff-25ed-4fce-95e7-8aa04630f6cc", + "metadata": {}, + "source": [ + "### 1.2 Define functions and parameters\n", + "\n", + "_If your notebook defines functions or parameters to use later or throughout, do it here in sub-section 1.2._\n", + "\n", + "_It is OK to rename the subsection to be more specific to the notebook, and/or to use sub-sub-sections like \"1.2.1 Define global cosmological parameter values\" or \"1.2.2 Define a function to make an image cutout\"._\n", + "\n", + "_It is OK to remove this sub-section if it is not being used._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", + "metadata": {}, + "outputs": [], + "source": [ + "plt.style.use('tableau-colorblind10')" + ] + }, + { + "cell_type": "markdown", + "id": "ec51ac0b", + "metadata": { + "tags": [] + }, + "source": [ + "## 2. Section heading\n", + "\n", + "_Use numbers for sections, sub-sections, and sub-sub-sections to enable referencing, e.g., \"I'm having trouble with the second code cell in Section 2.3.\"_\n", + "\n", + "_Use section titles that actively describe what is being done, e.g., \"Create a color-magnitude diagram\" instead of \"Plot\", so that the auto-generated table of contents is easy to navigate._\n", + "\n", + "### 2.1 Section sub-heading\n", + "\n", + "#### 2.1.1 Section sub-sub-heading" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5d02e77b-875a-4638-b345-33e2f31cf772", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "LSST", + "language": "python", + "name": "lsst" + }, + "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.11.9" + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 8ca2f65f87fca428323b73325bacf6a5e76a24ce Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 19 Nov 2024 20:40:51 +0000 Subject: [PATCH 02/99] random --- DP02_16_Galaxy_Photometry.ipynb | 8 -------- 1 file changed, 8 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 443a1fc..147a58b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -31,14 +31,6 @@ "_Remember to use the [CST's Guidelines for Tutorial Notebooks](rtn-045.lsst.io)._" ] }, - { - "cell_type": "markdown", - "id": "582ab507-a7ae-4024-95c9-38aabeb602a6", - "metadata": {}, - "source": [ - "_While developing, use the following code cell to check that the code conforms to standards, but then delete the cell and \"Kernel --> Restart Kernel and Clear All Outputs\" before saving and committing._" - ] - }, { "cell_type": "code", "execution_count": null, From 6e5c175880d461da564a33dc2e5c3f5a0778d422 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 19 Nov 2024 21:33:11 +0000 Subject: [PATCH 03/99] fixing crash --- DP02_16_Galaxy_Photometry.ipynb | 114 +++++++++++++++++++++++++++++++- 1 file changed, 113 insertions(+), 1 deletion(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 147a58b..4d7fa02 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -182,7 +182,20 @@ "import matplotlib.pyplot as plt\n", "from lsst.rsp import get_tap_service, retrieve_query\n", "import lsst.daf.butler as dafButler\n", - "import lsst.afw.display as afwDisplay" + "import lsst.afw.display as afwDisplay\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from astropy.wcs import WCS\n", + "from astropy.visualization import make_lupton_rgb\n", + "from astropy import units as u\n", + "from astropy.coordinates import SkyCoord\n", + "import gc\n", + "\n", + "import lsst.afw.display as afwDisplay\n", + "from lsst.afw.image import MultibandExposure\n", + "from lsst.daf.butler import Butler\n", + "from lsst.rsp import get_tap_service\n", + "import lsst.geom as geom" ] }, { @@ -227,12 +240,111 @@ "#### 2.1.1 Section sub-sub-heading" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT column_name, datatype, description, unit \" \\\n", + " \"FROM tap_schema.columns \" \\\n", + " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", + "\n", + "results = service.search(query).to_table()\n", + "results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", + "metadata": {}, + "outputs": [], + "source": [ + "search_string = 'Flux'\n", + "band = 'i_'\n", + "for cname in results['column_name']:\n", + " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", + " print(cname)" + ] + }, { "cell_type": "code", "execution_count": null, "id": "5d02e77b-875a-4638-b345-33e2f31cf772", "metadata": {}, "outputs": [], + "source": [ + "\n", + "butler = Butler('dp02', collections='2.2i/runs/DP0.2')\n", + "\n", + "dataId = {'tract': 4431, 'patch': 17, 'band': 'i'}\n", + "datasetType = 'deepCoadd'\n", + "coadd = butler.get(datasetType, **dataId)\n", + "\n", + "cutout_image = coadd\n", + "\n", + "wcs = cutout_image.getWcs()\n", + "\n", + "x0 = float(cutout_image.getX0())\n", + "y0 = float(cutout_image.getY0())\n", + "width = cutout_image.getWidth()\n", + "height = cutout_image.getHeight()\n", + "\n", + "xcorners = [x0, x0+width, x0+width, x0]\n", + "ycorners = [y0, y0, y0+width, y0+width]\n", + "\n", + "ra_corners = []\n", + "dec_corners = []\n", + "\n", + "for i in range(len(xcorners)):\n", + " radec = wcs.pixelToSky(xcorners[i], ycorners[i])\n", + " ra_corners.append(radec.getRa().asDegrees())\n", + " dec_corners.append(radec.getDec().asDegrees())\n", + "\n", + "\n", + "service = get_tap_service(\"tap\")\n", + "\n", + "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch \" + \\\n", + " \"FROM dp02_dc2_catalogs.Object \" + \\\n", + " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" +\\\n", + " \"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" +\\\n", + " str(ra_corners[1]) + \", \" + str(dec_corners[1]) + \", \" +\\\n", + " str(ra_corners[2]) + \", \" + str(dec_corners[2]) + \", \" +\\\n", + " str(ra_corners[3]) + \", \" + str(dec_corners[3]) + \")) = 1 AND \" +\\\n", + " \"tract = \" + str(dataId['tract']) + \" AND patch = \" + str(dataId['patch'])\n", + "print(query)\n", + "\n", + "job = service.submit_job(query)\n", + "job.run()\n", + "job.wait(phases=['COMPLETED', 'ERROR'])\n", + "print('Job phase is', job.phase)\n", + "\n", + "results = job.fetch_result()\n", + "print(len(results))\n", + "\n", + "tab = results.to_table()\n", + "tab\n", + "\n", + "fig, ax = plt.subplots()\n", + "display = afwDisplay.Display(frame=fig)\n", + "display.scale('asinh', 'zscale')\n", + "display.mtv(cutout_image.image)\n", + "with display.Buffering():\n", + " for i in range(len(tab)):\n", + " display.dot('+', tab[i]['x'], tab[i]['y'], ctype=afwDisplay.RED)\n", + " display.dot('o', tab[i]['x'], tab[i]['y'], size=20, ctype='orange')\n", + "plt.show()\n", + "remove_figure(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f52232f-8e56-4118-8454-66593a552ddc", + "metadata": {}, + "outputs": [], "source": [] } ], From 50d4207fcd1f4a3fad0d7fd641bfa3f5cd63d340 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 19 Nov 2024 22:24:12 +0000 Subject: [PATCH 04/99] fixing crash --- DP02_16_Galaxy_Photometry.ipynb | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 4d7fa02..b04d526 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -222,6 +222,16 @@ "plt.style.use('tableau-colorblind10')" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", + "metadata": {}, + "outputs": [], + "source": [ + "service = get_tap_service(\"tap\")" + ] + }, { "cell_type": "markdown", "id": "ec51ac0b", @@ -304,7 +314,7 @@ " dec_corners.append(radec.getDec().asDegrees())\n", "\n", "\n", - "service = get_tap_service(\"tap\")\n", + "\n", "\n", "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch \" + \\\n", " \"FROM dp02_dc2_catalogs.Object \" + \\\n", @@ -330,7 +340,7 @@ "fig, ax = plt.subplots()\n", "display = afwDisplay.Display(frame=fig)\n", "display.scale('asinh', 'zscale')\n", - "display.mtv(cutout_image.image)\n", + "display.mtv(coadd.image)\n", "with display.Buffering():\n", " for i in range(len(tab)):\n", " display.dot('+', tab[i]['x'], tab[i]['y'], ctype=afwDisplay.RED)\n", From d7ad02ae54e8610a275a8cd9f81060152c517c50 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 20 Nov 2024 21:53:06 +0000 Subject: [PATCH 05/99] fixing crash --- DP02_16_Galaxy_Photometry.ipynb | 131 +++++++++++++++++++++----------- 1 file changed, 87 insertions(+), 44 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index b04d526..4473df5 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -174,16 +174,10 @@ { "cell_type": "code", "execution_count": null, - "id": "cddc1458", + "id": "2dbc75bd-a802-4576-8628-4e0088942303", "metadata": {}, "outputs": [], "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from lsst.rsp import get_tap_service, retrieve_query\n", - "import lsst.daf.butler as dafButler\n", - "import lsst.afw.display as afwDisplay\n", - "\n", "import matplotlib.pyplot as plt\n", "from astropy.wcs import WCS\n", "from astropy.visualization import make_lupton_rgb\n", @@ -219,7 +213,8 @@ "metadata": {}, "outputs": [], "source": [ - "plt.style.use('tableau-colorblind10')" + "plt.style.use('tableau-colorblind10')\n", + "afwDisplay.setDefaultBackend('matplotlib')" ] }, { @@ -253,46 +248,39 @@ { "cell_type": "code", "execution_count": null, - "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", + "id": "6ad9a3ea-5d4c-4247-b0ff-712fafa00bb3", "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT column_name, datatype, description, unit \" \\\n", - " \"FROM tap_schema.columns \" \\\n", - " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", + "butler = Butler('dp02', collections='2.2i/runs/DP0.2')\n", "\n", - "results = service.search(query).to_table()\n", - "results" + "dataId = {'tract': 4431, 'patch': 17, 'band': 'i'}\n", + "datasetType = 'deepCoadd'\n", + "coadd = butler.get(datasetType, **dataId)" ] }, { "cell_type": "code", "execution_count": null, - "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", + "id": "a59e517d-e7e9-4371-9904-174fc6bf1f4f", "metadata": {}, "outputs": [], "source": [ - "search_string = 'Flux'\n", - "band = 'i_'\n", - "for cname in results['column_name']:\n", - " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", - " print(cname)" + "fig, ax = plt.subplots()\n", + "display = afwDisplay.Display(frame=fig)\n", + "display.scale('asinh', 'zscale')\n", + "display.mtv(coadd.image)\n", + "plt.show()\n", + "remove_figure(fig)" ] }, { "cell_type": "code", "execution_count": null, - "id": "5d02e77b-875a-4638-b345-33e2f31cf772", + "id": "7006a12e-5631-4b55-9eba-6f5fd7f73bac", "metadata": {}, "outputs": [], "source": [ - "\n", - "butler = Butler('dp02', collections='2.2i/runs/DP0.2')\n", - "\n", - "dataId = {'tract': 4431, 'patch': 17, 'band': 'i'}\n", - "datasetType = 'deepCoadd'\n", - "coadd = butler.get(datasetType, **dataId)\n", - "\n", "cutout_image = coadd\n", "\n", "wcs = cutout_image.getWcs()\n", @@ -311,11 +299,16 @@ "for i in range(len(xcorners)):\n", " radec = wcs.pixelToSky(xcorners[i], ycorners[i])\n", " ra_corners.append(radec.getRa().asDegrees())\n", - " dec_corners.append(radec.getDec().asDegrees())\n", - "\n", - "\n", - "\n", - "\n", + " dec_corners.append(radec.getDec().asDegrees())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "decab323-5735-4e6a-af11-cabb3cc7bdc3", + "metadata": {}, + "outputs": [], + "source": [ "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch \" + \\\n", " \"FROM dp02_dc2_catalogs.Object \" + \\\n", " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" +\\\n", @@ -324,29 +317,79 @@ " str(ra_corners[2]) + \", \" + str(dec_corners[2]) + \", \" +\\\n", " str(ra_corners[3]) + \", \" + str(dec_corners[3]) + \")) = 1 AND \" +\\\n", " \"tract = \" + str(dataId['tract']) + \" AND patch = \" + str(dataId['patch'])\n", - "print(query)\n", - "\n", + "print(query)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", + "metadata": {}, + "outputs": [], + "source": [ "job = service.submit_job(query)\n", "job.run()\n", "job.wait(phases=['COMPLETED', 'ERROR'])\n", - "print('Job phase is', job.phase)\n", - "\n", + "print('Job phase is', job.phase)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", + "metadata": {}, + "outputs": [], + "source": [ "results = job.fetch_result()\n", "print(len(results))\n", - "\n", - "tab = results.to_table()\n", - "tab\n", - "\n", + "tab = results.to_table()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", + "metadata": {}, + "outputs": [], + "source": [ "fig, ax = plt.subplots()\n", "display = afwDisplay.Display(frame=fig)\n", "display.scale('asinh', 'zscale')\n", - "display.mtv(coadd.image)\n", + "display.mtv(cutout_image.image)\n", "with display.Buffering():\n", " for i in range(len(tab)):\n", " display.dot('+', tab[i]['x'], tab[i]['y'], ctype=afwDisplay.RED)\n", " display.dot('o', tab[i]['x'], tab[i]['y'], size=20, ctype='orange')\n", - "plt.show()\n", - "remove_figure(fig)" + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT column_name, datatype, description, unit \" \\\n", + " \"FROM tap_schema.columns \" \\\n", + " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", + "\n", + "results = service.search(query).to_table()\n", + "results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", + "metadata": {}, + "outputs": [], + "source": [ + "search_string = 'Flux'\n", + "band = 'i_'\n", + "for cname in results['column_name']:\n", + " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", + " print(cname)" ] }, { From b6b9cdf670b012bc54e47e13c52d285b4b29d9ac Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 22 Nov 2024 19:26:12 +0000 Subject: [PATCH 06/99] fixing crash --- DP02_16_Galaxy_Photometry.ipynb | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 4473df5..336a7b4 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -271,7 +271,26 @@ "display.scale('asinh', 'zscale')\n", "display.mtv(coadd.image)\n", "plt.show()\n", - "remove_figure(fig)" + "#remove_figure(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "914e6572-fcac-415a-a4de-fb526d198483", + "metadata": {}, + "outputs": [], + "source": [ + "skymap = butler.get('skyMap')\n", + "dataId = {'skymap': skymap, 'tract': 4431, 'patch': 17}\n", + "#objects = butler.get('Object', dataId=dataId)\n", + "objects = butler.registry.queryDataIds('objectTable', dataId=dataId)\n", + "\n", + "\n", + "#butler.registry.queryDataIds(\n", + "# dataId,\n", + " #datasets=\"deepCoadd\",\n", + "# collections='2.2i/runs/DP0.2').limit(10)" ] }, { From 495318b8c663eaa5a96540035328e10be79761f8 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 2 Dec 2024 22:15:55 +0000 Subject: [PATCH 07/99] updates --- DP02_16_Galaxy_Photometry.ipynb | 58 ++++++++++++++++++++++++++------- 1 file changed, 46 insertions(+), 12 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 336a7b4..0e9e29f 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -184,6 +184,7 @@ "from astropy import units as u\n", "from astropy.coordinates import SkyCoord\n", "import gc\n", + "import numpy as np\n", "\n", "import lsst.afw.display as afwDisplay\n", "from lsst.afw.image import MultibandExposure\n", @@ -284,7 +285,9 @@ "skymap = butler.get('skyMap')\n", "dataId = {'skymap': skymap, 'tract': 4431, 'patch': 17}\n", "#objects = butler.get('Object', dataId=dataId)\n", - "objects = butler.registry.queryDataIds('objectTable', dataId=dataId)\n", + "\n", + "# this doens't work:\n", + "#objects = butler.registry.queryDataIds('objectTable', dataId=dataId)\n", "\n", "\n", "#butler.registry.queryDataIds(\n", @@ -328,13 +331,15 @@ "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch \" + \\\n", + "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, \" + \\\n", + " \"i_ap09Flux, i_ap12Flux, i_cModelFlux, i_free_cModelFlux, i_gaap3p0Flux, i_gaap1p0Flux, i_kronRad \" + \\\n", " \"FROM dp02_dc2_catalogs.Object \" + \\\n", " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" +\\\n", " \"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" +\\\n", " str(ra_corners[1]) + \", \" + str(dec_corners[1]) + \", \" +\\\n", " str(ra_corners[2]) + \", \" + str(dec_corners[2]) + \", \" +\\\n", " str(ra_corners[3]) + \", \" + str(dec_corners[3]) + \")) = 1 AND \" +\\\n", + " \"detect_isPrimary = 1 AND \" +\\\n", " \"tract = \" + str(dataId['tract']) + \" AND patch = \" + str(dataId['patch'])\n", "print(query)" ] @@ -361,7 +366,8 @@ "source": [ "results = job.fetch_result()\n", "print(len(results))\n", - "tab = results.to_table()\n" + "tab = results.to_table()\n", + "tab" ] }, { @@ -371,15 +377,17 @@ "metadata": {}, "outputs": [], "source": [ - "fig, ax = plt.subplots()\n", - "display = afwDisplay.Display(frame=fig)\n", - "display.scale('asinh', 'zscale')\n", - "display.mtv(cutout_image.image)\n", - "with display.Buffering():\n", - " for i in range(len(tab)):\n", - " display.dot('+', tab[i]['x'], tab[i]['y'], ctype=afwDisplay.RED)\n", - " display.dot('o', tab[i]['x'], tab[i]['y'], size=20, ctype='orange')\n", - "plt.show()" + "# this messes up memory, already validated that it finds the galaxies\n", + "\n", + "#fig, ax = plt.subplots()\n", + "#display = afwDisplay.Display(frame=fig)\n", + "#display.scale('asinh', 'zscale')\n", + "#display.mtv(cutout_image.image)\n", + "#with display.Buffering():\n", + "# for i in range(len(tab)):\n", + "# display.dot('+', tab[i]['x'], tab[i]['y'], ctype=afwDisplay.RED)\n", + "# display.dot('o', tab[i]['x'], tab[i]['y'], size=20, ctype='orange')\n", + "#plt.show()" ] }, { @@ -417,6 +425,32 @@ "id": "2f52232f-8e56-4118-8454-66593a552ddc", "metadata": {}, "outputs": [], + "source": [ + "tab" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "whbright = np.where(tab['i_ap12Flux'] > 0.05e6)[0]\n", + "plt.scatter(tab['i_cModelFlux'][whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", + " c=tab['i_kronRad'][whbright], marker='o', alpha=.5)\n", + "plt.colorbar(label='Kron Radius [pixels]')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "253d0d24-6393-4494-ac2e-a7003a6138fe", + "metadata": {}, + "outputs": [], "source": [] } ], From 6026fb58c11141808e81d1aeeeb132aecf73f945 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 2 Dec 2024 23:02:07 +0000 Subject: [PATCH 08/99] updates --- DP02_16_Galaxy_Photometry.ipynb | 135 ++++++++++++++++++++++++++------ 1 file changed, 112 insertions(+), 23 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 0e9e29f..b7c4a71 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -125,18 +125,112 @@ }, { "cell_type": "markdown", - "id": "1cb7977c-8faa-4c34-8296-7ba014056a97", - "metadata": {}, - "source": [ - "<img align=\"center\" src='example.png' width=350 alt=\"A plot of value 2 versus value 1 for case A and case B, showing the cases are different power laws.\"><br>" - ] - }, - { - "cell_type": "markdown", - "id": "69ec20dd-47fc-43f1-9cd7-c265e493b31f", - "metadata": {}, + "id": "7eb3ba1f-659f-4cb0-acad-52690f60a485", + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-02T22:37:09.704845Z", + "iopub.status.busy": "2024-12-02T22:37:09.704072Z", + "iopub.status.idle": "2024-12-02T22:37:10.367698Z", + "shell.execute_reply": "2024-12-02T22:37:10.366983Z", + "shell.execute_reply.started": "2024-12-02T22:37:09.704824Z" + } + }, "source": [ - "> **Figure 1:** Value 2 as a function of Value 1 for Case A as black open circles and Case B as grey open triangles, showing that in Case B the power law has a higher exponent." + "### 1.0 Selected text grabbed from Melissa's photo-z notebook (for now)\n", + "#### Schema: types of fluxes measured\n", + "\n", + "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", + "\n", + "For photometric redshifts, since accurate colors are important, it is the GaaP fluxes that should be used.\n", + "\n", + "### Aperture fluxes\n", + "Fixed aperture diameter size in pixels.\n", + "\n", + "```\n", + "<f>_ap<pix>Flux : Flux within <pix>-pixel aperture. Forced on <f>-band.\n", + "<f>_ap<pix>FluxErr : Uncertainty of <f>_ap<pix>Flux.\n", + "<f>_ap<pix>FluxFlag : Failure flag for <f>_ap<pix>Flux.\n", + "```\n", + "\n", + "For DP0.2, the apertures are 3, 6, 9, 12, 17, 25, 35, 50, and 70 pixels.\n", + "\n", + "In the column name, apertures are `03`, `06`, `09`, `12`, and so on.\n", + "\n", + "### Composite Model (CModel) fluxes\n", + "\n", + "Similar in nature to those measured for SDSS: \n", + "https://www.sdss3.org/dr8/algorithms/magnitudes.php#cmodel\n", + "\n", + "In short, it is the linear combination of the best fit exponential and de Vaucouleurs profiles.\n", + "\n", + "```\n", + "<f>_cModelFlux :\tFlux from the final cmodel fit. Forced on <f>-band.\n", + "<f>_cModelFluxErr : Uncertainty of <f>_cModelFlux\n", + "<f>_cModel_flag : Failure flag for <f>_cModelFlux\n", + "```\n", + "\n", + "Fluxes fit to the individual model components.\n", + "\n", + "```\n", + "<f>_bdFluxB : Flux from the de Vaucouleurs fit. Measured on <f>-band.\n", + "<f>_bdFluxD : Flux from the exponential fit. Measured on <f>-band.\n", + "<f>_bdFluxBErr : Uncertainty of <f>_bdFluxB\n", + "<f>_bdFluxDErr : Uncertainty of <f>_bdFluxD\n", + "```\n", + "\n", + "The fit sizes are also available (half-light radii, ellipse axes).\n", + "\n", + "### GaaP fluxes\n", + "\n", + "The Gaussian-aperture-and-PSF flux from <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>.\n", + "\n", + "**Optimal**\n", + "\n", + "```\n", + "<f>_gaapOptimalFlux : GaaP flux with optimal aperture after multiplying the seeing by 1.15. Forced on <f>-band.\n", + "<f>_gaapOptimalFluxErr : Uncertainty of <f>_gaapOptimalFlux.\n", + "```\n", + "\n", + "**PSF**\n", + "\n", + "```\n", + "<f>_gaapPsfFlux : GaaP flux with PSF aperture after multiplying the seeing by 1.15. Forced on <f>-band.\n", + "<f>_gaapPsfFluxErr : Uncertainty of <f>_gaapPsfFlux.\n", + "```\n", + "\n", + "**Aperture**\n", + "\n", + "```\n", + "<f>_gaap<ap>Flux : GaaP flux with <ap> aperture after multiplying the seeing by 1.15. Forced on <f>-band.\n", + "<f>_gaap<ap>FluxErr : Uncertainty of <f>_gaap<ap>Flux.\n", + "```\n", + "\n", + "Where the apertures are 0.5, 0.7, 1.0, 1.5, 2.5, and 3.0.\n", + "In the column name `<ap>` appears as `0p5`, `0p7`, etc.\n", + "\n", + "\n", + "### Kron fluxes\n", + "\n", + "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>.\n", + "\n", + "```\n", + "<f>_kronFlux : Flux from Kron Flux algorithm. Measured on <f> g-band.\n", + "<f>_kronFluxErr : Uncertainty of <f>_kronFlux.\n", + "<f>_kronFlux_flag : Failure flag for <f>_kronFlux.\n", + "```\n", + "\n", + "The Kron radius, `<f>_kronRad`, is also available.\n", + "\n", + "### PSF fluxes\n", + "\n", + "Fluxes derived using the model point-spread function (PSF) of the image. The focus here should be static sky (calexp, deepCoadd) and extended objects (i.e. not PSF fluxes). Connect where relevant to the PSF tutorial and to the tutorial developed for SP-910 (is this Notebook 12a/b or 5?).\n", + "\n", + "```\n", + "<f>_psfFlux : Flux derived from linear least-squares fit of PSF model. Forced on <f>-band.\n", + "<f>_psfFluxErr : Uncertainty of <f>_psfFlux.\n", + "<f>_psfFlux_flag : Failure flag for <f>_psfFlux.\n", + "\n", + "```\n" ] }, { @@ -144,15 +238,7 @@ "id": "dc36f107", "metadata": {}, "source": [ - "### 1.1 Import packages\n", - "\n", - "_All package imports should be done in the first code cell._\n", - "\n", - "_Do not import packages unless they are used._\n", - "\n", - "_Provide explanation or external links to package documentation, where appropriate._\n", - "\n", - "_Describe the packages being imported, as is done below for commonly-imported packages._" + "### 1.1 Import packages\n" ] }, { @@ -332,7 +418,8 @@ "outputs": [], "source": [ "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, \" + \\\n", - " \"i_ap09Flux, i_ap12Flux, i_cModelFlux, i_free_cModelFlux, i_gaap3p0Flux, i_gaap1p0Flux, i_kronRad \" + \\\n", + " \"i_ap09Flux, i_ap12Flux, i_cModelFlux, i_free_cModelFlux, i_gaap3p0Flux, i_gaap1p0Flux, i_kronRad, \" + \\\n", + " \"i_kronFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object \" + \\\n", " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" +\\\n", " \"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" +\\\n", @@ -438,10 +525,12 @@ "source": [ "import numpy as np\n", "whbright = np.where(tab['i_ap12Flux'] > 0.05e6)[0]\n", - "plt.scatter(tab['i_cModelFlux'][whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", + "\n", + "mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "plt.scatter(mag[whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", " c=tab['i_kronRad'][whbright], marker='o', alpha=.5)\n", "plt.colorbar(label='Kron Radius [pixels]')\n", - "\n", + "plt.xlabel('AB Magnitude [i-band]')\n", "plt.show()" ] }, From ebfee6e3f27c49c70f182723f0d0e31b9890cec2 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 3 Dec 2024 19:15:23 +0000 Subject: [PATCH 09/99] updates --- DP02_16_Galaxy_Photometry.ipynb | 53 ++++++++++++++++++++++++++++++--- 1 file changed, 49 insertions(+), 4 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index b7c4a71..20b6db8 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -419,7 +419,7 @@ "source": [ "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, \" + \\\n", " \"i_ap09Flux, i_ap12Flux, i_cModelFlux, i_free_cModelFlux, i_gaap3p0Flux, i_gaap1p0Flux, i_kronRad, \" + \\\n", - " \"i_kronFlux \" + \\\n", + " \"i_kronFlux, i_ap17Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object \" + \\\n", " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" +\\\n", " \"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" +\\\n", @@ -516,6 +516,33 @@ "tab" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "whbright = np.where(tab['i_kronFlux'] > 0.0001e6)[0]\n", + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "\n", + "plt.scatter(cmodel_mag,kron_mag,\n", + " c=tab['i_kronRad'], marker='.', alpha=.5)\n", + "\n", + "#plt.scatter(cmodel_mag[whbright],kron_mag[whbright],\n", + "# c=tab['i_kronRad'][whbright], marker='.', alpha=.5)\n", + "plt.axhline(26.4,linestyle='--',label='10-yr 5sig depth')\n", + "\n", + "plt.colorbar(label='Kron Radius [pixels]')\n", + "plt.xlabel('cModel AB Magnitude [i-band]')\n", + "plt.ylabel('kron AB Magnitude [i-band]')\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -523,10 +550,10 @@ "metadata": {}, "outputs": [], "source": [ - "import numpy as np\n", - "whbright = np.where(tab['i_ap12Flux'] > 0.05e6)[0]\n", "\n", - "mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "whbright = np.where(tab['i_kronFlux'] > 0.01e6)[0]\n", + "\n", + "mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "plt.scatter(mag[whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", " c=tab['i_kronRad'][whbright], marker='o', alpha=.5)\n", "plt.colorbar(label='Kron Radius [pixels]')\n", @@ -540,6 +567,24 @@ "id": "253d0d24-6393-4494-ac2e-a7003a6138fe", "metadata": {}, "outputs": [], + "source": [ + "\n", + "whbright = np.where(tab['i_cModelFlux'] > 0.01e6)[0]\n", + "\n", + "mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "plt.scatter(mag[whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", + " c=tab['i_kronRad'][whbright], marker='o', alpha=.5)\n", + "plt.colorbar(label='Kron Radius [pixels]')\n", + "plt.xlabel('AB Magnitude [i-band]')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11263c1d-e9a0-4402-bafd-6595c60faeb6", + "metadata": {}, + "outputs": [], "source": [] } ], From 311ee3c2b4211ee821332798365d5c325b490cb5 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 4 Dec 2024 18:02:59 +0000 Subject: [PATCH 10/99] updates --- DP02_16_Galaxy_Photometry.ipynb | 87 ++++++++++++++++++++++++++++++--- 1 file changed, 79 insertions(+), 8 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 20b6db8..0c3ff79 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -418,8 +418,10 @@ "outputs": [], "source": [ "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, \" + \\\n", - " \"i_ap09Flux, i_ap12Flux, i_cModelFlux, i_free_cModelFlux, i_gaap3p0Flux, i_gaap1p0Flux, i_kronRad, \" + \\\n", - " \"i_kronFlux, i_ap17Flux \" + \\\n", + " \"i_ap09Flux, i_ap12Flux, i_ap17Flux, i_ap25Flux, i_ap35Flux, \" + \\\n", + " \"i_cModelFlux, i_free_cModelFlux, \" + \\\n", + " \"i_gaap3p0Flux, i_gaap1p5Flux, i_gaapOptimalFlux, \" + \\\n", + " \"i_kronFlux, i_kronRad, i_kronFlux_flag \" + \\\n", " \"FROM dp02_dc2_catalogs.Object \" + \\\n", " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" +\\\n", " \"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" +\\\n", @@ -523,8 +525,10 @@ "metadata": {}, "outputs": [], "source": [ + "# compare kron mag to cmodel mag\n", "\n", - "whbright = np.where(tab['i_kronFlux'] > 0.0001e6)[0]\n", + "#whbright = np.where(tab['i_kronFlux'] > 0.0001e6)[0]\n", + "whbright = np.where((tab['i_kronFlux'] > 0.01e6) & (tab['i_kronFlux_flag'] == 0))[0]\n", "\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", @@ -543,6 +547,56 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "\n", + "plt.scatter(cmodel_mag,kron_mag,\n", + " c=tab['i_kronRad'], marker='.', alpha=.5, vmin=1, vmax=50)\n", + "\n", + "#plt.scatter(cmodel_mag[whbright],kron_mag[whbright],\n", + "# c=tab['i_kronRad'][whbright], marker='.', alpha=.5)\n", + "plt.axhline(26.4,linestyle='--',label='10-yr 5sig depth')\n", + "\n", + "plt.colorbar(label='Kron Radius [pixels]')\n", + "plt.xlabel('GaaP optimal AB Magnitude [i-band]')\n", + "plt.ylabel('kron AB Magnitude [i-band]')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_gaap1p5Flux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "\n", + "plt.scatter(cmodel_mag,kron_mag,\n", + " c=tab['i_kronRad'], marker='.', alpha=.5, vmin=1, vmax=50)\n", + "\n", + "#plt.scatter(cmodel_mag[whbright],kron_mag[whbright],\n", + "# c=tab['i_kronRad'][whbright], marker='.', alpha=.5)\n", + "plt.axhline(26.4,linestyle='--',label='10-yr 5sig depth')\n", + "\n", + "plt.colorbar(label='Kron Radius [pixels]')\n", + "plt.xlabel('GaaP AB Magnitude 1.5 aperture [i-band]')\n", + "plt.ylabel('kron AB Magnitude [i-band]')\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -551,13 +605,31 @@ "outputs": [], "source": [ "\n", - "whbright = np.where(tab['i_kronFlux'] > 0.01e6)[0]\n", + "whbright = np.where((tab['i_kronFlux'] > 0.01e6) & (tab['i_kronFlux_flag'] == 0))[0]\n", "\n", "mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "plt.scatter(mag[whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", - " c=tab['i_kronRad'][whbright], marker='o', alpha=.5)\n", + "plt.scatter(mag[whbright],tab['i_ap17Flux'][whbright]/tab['i_ap35Flux'][whbright],\n", + " c=tab['i_kronRad'][whbright], marker='o', alpha=.5, vmin=1, vmax=50)\n", "plt.colorbar(label='Kron Radius [pixels]')\n", - "plt.xlabel('AB Magnitude [i-band]')\n", + "plt.axhline(1,linestyle='--')\n", + "plt.xlabel('Kron AB Magnitude [i-band]')\n", + "plt.ylabel('aperture [9 pix] flux / [17 pix] Flux')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(tab['i_kronRad'][whbright],tab['i_ap09Flux'][whbright]/tab['i_ap25Flux'][whbright],\n", + " c=mag[whbright], marker='o', alpha=.5)\n", + "plt.xlabel('Kron Radius [pix]')\n", + "plt.ylabel('aperture [9 pix] flux / aperture [25 pix] Flux')\n", + "plt.colorbar(label='Kron Mag [ABmag]')\n", + "plt.xlim([0,30])\n", "plt.show()" ] }, @@ -569,7 +641,6 @@ "outputs": [], "source": [ "\n", - "whbright = np.where(tab['i_cModelFlux'] > 0.01e6)[0]\n", "\n", "mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "plt.scatter(mag[whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", From 68d30af85e474caf20ba257625ec11ab9d0d2a24 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 4 Dec 2024 18:57:11 +0000 Subject: [PATCH 11/99] updates --- DP02_16_Galaxy_Photometry.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 0c3ff79..13d295e 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -144,7 +144,7 @@ "For photometric redshifts, since accurate colors are important, it is the GaaP fluxes that should be used.\n", "\n", "### Aperture fluxes\n", - "Fixed aperture diameter size in pixels.\n", + "This contains the enclosed flux inside a given aperture (these are raw fluxes, meaning, they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture using the PSF). Fixed aperture diameter size in pixels.\n", "\n", "```\n", "<f>_ap<pix>Flux : Flux within <pix>-pixel aperture. Forced on <f>-band.\n", From 1da56a7a53257530a8b3d1e62e87e701f46a4efb Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 6 Dec 2024 20:20:59 +0000 Subject: [PATCH 12/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 13d295e..9bc23a3 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -605,15 +605,16 @@ "outputs": [], "source": [ "\n", - "whbright = np.where((tab['i_kronFlux'] > 0.01e6) & (tab['i_kronFlux_flag'] == 0))[0]\n", + "whbright = np.where((tab['i_kronFlux'] > 0.001e6) & (tab['i_kronFlux_flag'] == 0))[0]\n", "\n", "mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "plt.scatter(mag[whbright],tab['i_ap17Flux'][whbright]/tab['i_ap35Flux'][whbright],\n", + "plt.scatter(mag[whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", " c=tab['i_kronRad'][whbright], marker='o', alpha=.5, vmin=1, vmax=50)\n", "plt.colorbar(label='Kron Radius [pixels]')\n", "plt.axhline(1,linestyle='--')\n", "plt.xlabel('Kron AB Magnitude [i-band]')\n", - "plt.ylabel('aperture [9 pix] flux / [17 pix] Flux')\n", + "plt.yscale('log')\n", + "plt.ylabel('Kron flux / cModel Flux')\n", "plt.show()" ] }, @@ -624,12 +625,30 @@ "metadata": {}, "outputs": [], "source": [ - "plt.scatter(tab['i_kronRad'][whbright],tab['i_ap09Flux'][whbright]/tab['i_ap25Flux'][whbright],\n", + "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_gaapOptimalFlux'][whbright],\n", + " c=mag[whbright], marker='o', alpha=.5)\n", + "plt.xlabel('Kron Radius [pix]')\n", + "plt.ylabel('Kron flux / GaaP Optimal Flux')\n", + "plt.colorbar(label='Kron Mag [ABmag]')\n", + "plt.xlim([0,50])\n", + "plt.ylim([-1,30])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", " c=mag[whbright], marker='o', alpha=.5)\n", "plt.xlabel('Kron Radius [pix]')\n", - "plt.ylabel('aperture [9 pix] flux / aperture [25 pix] Flux')\n", + "plt.ylabel('Kron flux / cModel Flux')\n", "plt.colorbar(label='Kron Mag [ABmag]')\n", - "plt.xlim([0,30])\n", + "plt.xlim([0,50])\n", + "plt.ylim([-1,30])\n", "plt.show()" ] }, @@ -642,7 +661,7 @@ "source": [ "\n", "\n", - "mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "#mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "plt.scatter(mag[whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", " c=tab['i_kronRad'][whbright], marker='o', alpha=.5)\n", "plt.colorbar(label='Kron Radius [pixels]')\n", From b1c8a5ed68e1d0b780dbbda146a24509d940c3db Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 11 Dec 2024 23:32:50 +0000 Subject: [PATCH 13/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 116 ++++++++++++++++++++++++-------- 1 file changed, 89 insertions(+), 27 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 9bc23a3..0524907 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -421,18 +421,68 @@ " \"i_ap09Flux, i_ap12Flux, i_ap17Flux, i_ap25Flux, i_ap35Flux, \" + \\\n", " \"i_cModelFlux, i_free_cModelFlux, \" + \\\n", " \"i_gaap3p0Flux, i_gaap1p5Flux, i_gaapOptimalFlux, \" + \\\n", - " \"i_kronFlux, i_kronRad, i_kronFlux_flag \" + \\\n", + " \"i_kronFlux, i_kronRad, i_kronFlux_flag, \" + \\\n", + " \"detect_fromBlend \" + \\\n", " \"FROM dp02_dc2_catalogs.Object \" + \\\n", - " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" +\\\n", - " \"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" +\\\n", - " str(ra_corners[1]) + \", \" + str(dec_corners[1]) + \", \" +\\\n", - " str(ra_corners[2]) + \", \" + str(dec_corners[2]) + \", \" +\\\n", - " str(ra_corners[3]) + \", \" + str(dec_corners[3]) + \")) = 1 AND \" +\\\n", - " \"detect_isPrimary = 1 AND \" +\\\n", + " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" + \\\n", + " \"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" + \\\n", + " str(ra_corners[1]) + \", \" + str(dec_corners[1]) + \", \" + \\\n", + " str(ra_corners[2]) + \", \" + str(dec_corners[2]) + \", \" + \\\n", + " str(ra_corners[3]) + \", \" + str(dec_corners[3]) + \")) = 1 AND \" + \\\n", + " \"detect_isPrimary = 1 AND \" + \\\n", " \"tract = \" + str(dataId['tract']) + \" AND patch = \" + str(dataId['patch'])\n", "print(query)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b1fb7e3-b2f3-49d5-8991-aaa0a39d2b83", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, \"\\\n", + " \"obj.coord_ra, obj.coord_dec \"\\\n", + " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, \" + \\\n", + " \"obj.i_cModelFlux, obj.i_free_cModelFlux, \" + \\\n", + " \"obj.i_gaap3p0Flux, obj.i_gaap1p5Flux, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.detect_fromBlend \" + \\\n", + " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", + " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", + " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", + " \"WHERE CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1\"\n", + "\n", + "\n", + "#\"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" + \\\n", + "# str(ra_corners[1]) + \", \" + str(dec_corners[1]) + \", \" + \\\n", + "# str(ra_corners[2]) + \", \" + str(dec_corners[2]) + \", \" + \\\n", + "# str(ra_corners[3]) + \", \" + str(dec_corners[3]) + \")) = 1\" \n", + " #, CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\" \n", + "# AND \" + \\\n", + " #\"obj.detect_isPrimary = 1 AND \" + \\\n", + " #\"obj.tract = \" + str(dataId['tract']) + \" AND obj.patch = \" + str(dataId['patch'])\n", + "\n", + "#CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\n", + "print(query)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d28a6ad-4436-410c-9b9d-e995140be304", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, \"\\\n", + " \"obj.coord_ra, obj.coord_dec, \"\\\n", + " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux \" + \\\n", + " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", + " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", + " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", + " \"WHERE CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\n", + "print(query)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -466,17 +516,22 @@ "metadata": {}, "outputs": [], "source": [ - "# this messes up memory, already validated that it finds the galaxies\n", + "# this is where you are working here:\n", + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", + "\n", + "plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", "\n", - "#fig, ax = plt.subplots()\n", - "#display = afwDisplay.Display(frame=fig)\n", - "#display.scale('asinh', 'zscale')\n", - "#display.mtv(cutout_image.image)\n", - "#with display.Buffering():\n", - "# for i in range(len(tab)):\n", - "# display.dot('+', tab[i]['x'], tab[i]['y'], ctype=afwDisplay.RED)\n", - "# display.dot('o', tab[i]['x'], tab[i]['y'], size=20, ctype='orange')\n", - "#plt.show()" + "\n", + "plt.scatter(truth_mag,kron_mag,\n", + " c=tab['i_kronRad'], marker='+', alpha=.5)\n", + "\n", + "\n", + "x = np.arange(14,30,.1)\n", + "plt.plot(x,x,linestyle='--')\n", + "plt.show()" ] }, { @@ -615,9 +670,25 @@ "plt.xlabel('Kron AB Magnitude [i-band]')\n", "plt.yscale('log')\n", "plt.ylabel('Kron flux / cModel Flux')\n", + "\n", + "\n", + "#whbad = np.where( (np.abs(tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright]) > 2) & (mag[whbright] < 22))[0]\n", + "whblend = np.where( tab['detect_fromBlend'][whbright] == True)[0]\n", + "\n", + "print(tab['detect_fromBlend'][whbright][whbad])\n", + "plt.plot(mag[whbright][whblend],tab['i_kronFlux'][whbright][whblend]/tab['i_cModelFlux'][whbright][whblend],'k+')\n", + "\n", "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d35fa45-3cc2-47c3-8e47-a29d3c7ec440", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, @@ -658,16 +729,7 @@ "id": "253d0d24-6393-4494-ac2e-a7003a6138fe", "metadata": {}, "outputs": [], - "source": [ - "\n", - "\n", - "#mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "plt.scatter(mag[whbright],tab['i_ap09Flux'][whbright]/tab['i_ap12Flux'][whbright],\n", - " c=tab['i_kronRad'][whbright], marker='o', alpha=.5)\n", - "plt.colorbar(label='Kron Radius [pixels]')\n", - "plt.xlabel('AB Magnitude [i-band]')\n", - "plt.show()" - ] + "source": [] }, { "cell_type": "code", From 29f8be290b244fe083b49e0ea83ac7d75c00b41b Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 16 Dec 2024 19:32:04 +0000 Subject: [PATCH 14/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 1577 +++++++++++++++++++++++++++++-- 1 file changed, 1503 insertions(+), 74 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 0524907..41a9593 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -33,9 +33,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:00.845473Z", + "iopub.status.busy": "2024-12-16T19:26:00.845330Z", + "iopub.status.idle": "2024-12-16T19:26:00.872992Z", + "shell.execute_reply": "2024-12-16T19:26:00.872589Z", + "shell.execute_reply.started": "2024-12-16T19:26:00.845459Z" + } + }, "outputs": [], "source": [ "%load_ext pycodestyle_magic\n", @@ -259,9 +267,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "2dbc75bd-a802-4576-8628-4e0088942303", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:00.873696Z", + "iopub.status.busy": "2024-12-16T19:26:00.873546Z", + "iopub.status.idle": "2024-12-16T19:26:03.127233Z", + "shell.execute_reply": "2024-12-16T19:26:03.126652Z", + "shell.execute_reply.started": "2024-12-16T19:26:00.873683Z" + } + }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -295,9 +311,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:03.128540Z", + "iopub.status.busy": "2024-12-16T19:26:03.127914Z", + "iopub.status.idle": "2024-12-16T19:26:03.233902Z", + "shell.execute_reply": "2024-12-16T19:26:03.233332Z", + "shell.execute_reply.started": "2024-12-16T19:26:03.128517Z" + } + }, "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", @@ -306,9 +330,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:03.235020Z", + "iopub.status.busy": "2024-12-16T19:26:03.234603Z", + "iopub.status.idle": "2024-12-16T19:26:03.351442Z", + "shell.execute_reply": "2024-12-16T19:26:03.350915Z", + "shell.execute_reply.started": "2024-12-16T19:26:03.234998Z" + } + }, "outputs": [], "source": [ "service = get_tap_service(\"tap\")" @@ -334,9 +366,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "6ad9a3ea-5d4c-4247-b0ff-712fafa00bb3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:03.352325Z", + "iopub.status.busy": "2024-12-16T19:26:03.352122Z", + "iopub.status.idle": "2024-12-16T19:26:07.787878Z", + "shell.execute_reply": "2024-12-16T19:26:07.787244Z", + "shell.execute_reply.started": "2024-12-16T19:26:03.352309Z" + } + }, "outputs": [], "source": [ "butler = Butler('dp02', collections='2.2i/runs/DP0.2')\n", @@ -348,45 +388,168 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "a59e517d-e7e9-4371-9904-174fc6bf1f4f", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:07.789226Z", + "iopub.status.busy": "2024-12-16T19:26:07.788509Z", + "iopub.status.idle": "2024-12-16T19:26:07.865191Z", + "shell.execute_reply": "2024-12-16T19:26:07.864666Z", + "shell.execute_reply.started": "2024-12-16T19:26:07.789207Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 1:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 2:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 3:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 4:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 5:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 6:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "fig, ax = plt.subplots()\n", - "display = afwDisplay.Display(frame=fig)\n", - "display.scale('asinh', 'zscale')\n", - "display.mtv(coadd.image)\n", - "plt.show()\n", + "#fig, ax = plt.subplots()\n", + "#display = afwDisplay.Display(frame=fig)\n", + "#display.scale('asinh', 'zscale')\n", + "#display.mtv(coadd.image)\n", + "#plt.show()\n", "#remove_figure(fig)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "914e6572-fcac-415a-a4de-fb526d198483", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:07.866268Z", + "iopub.status.busy": "2024-12-16T19:26:07.866094Z", + "iopub.status.idle": "2024-12-16T19:26:08.234782Z", + "shell.execute_reply": "2024-12-16T19:26:08.234197Z", + "shell.execute_reply.started": "2024-12-16T19:26:07.866252Z" + } + }, "outputs": [], "source": [ "skymap = butler.get('skyMap')\n", - "dataId = {'skymap': skymap, 'tract': 4431, 'patch': 17}\n", - "#objects = butler.get('Object', dataId=dataId)\n", - "\n", - "# this doens't work:\n", - "#objects = butler.registry.queryDataIds('objectTable', dataId=dataId)\n", - "\n", - "\n", - "#butler.registry.queryDataIds(\n", - "# dataId,\n", - " #datasets=\"deepCoadd\",\n", - "# collections='2.2i/runs/DP0.2').limit(10)" + "dataId = {'skymap': skymap, 'tract': 4431, 'patch': 17}\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "7006a12e-5631-4b55-9eba-6f5fd7f73bac", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:08.235632Z", + "iopub.status.busy": "2024-12-16T19:26:08.235461Z", + "iopub.status.idle": "2024-12-16T19:26:08.317057Z", + "shell.execute_reply": "2024-12-16T19:26:08.316205Z", + "shell.execute_reply.started": "2024-12-16T19:26:08.235616Z" + } + }, "outputs": [], "source": [ "cutout_image = coadd\n", @@ -412,10 +575,62 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "decab323-5735-4e6a-af11-cabb3cc7bdc3", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:08.317964Z", + "iopub.status.busy": "2024-12-16T19:26:08.317779Z", + "iopub.status.idle": "2024-12-16T19:26:08.400569Z", + "shell.execute_reply": "2024-12-16T19:26:08.399947Z", + "shell.execute_reply.started": "2024-12-16T19:26:08.317949Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:80: E501 line too long (87 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 14:80: E501 line too long (82 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, i_ap09Flux, i_ap12Flux, i_ap17Flux, i_ap25Flux, i_ap35Flux, i_cModelFlux, i_free_cModelFlux, i_gaap3p0Flux, i_gaap1p5Flux, i_gaapOptimalFlux, i_kronFlux, i_kronRad, i_kronFlux_flag, detect_fromBlend FROM dp02_dc2_catalogs.Object WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), POLYGON('ICRS', 55.79016376401875, -32.322225378380246, 55.5140525810614, -32.32222523523597, 55.51440424131911, -32.088896406426095, 55.78981243851229, -32.088896548288034)) = 1 AND detect_isPrimary = 1 AND tract = 4431 AND patch = 17\n" + ] + } + ], "source": [ "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, \" + \\\n", " \"i_ap09Flux, i_ap12Flux, i_ap17Flux, i_ap25Flux, i_ap35Flux, \" + \\\n", @@ -436,10 +651,332 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "8b1fb7e3-b2f3-49d5-8991-aaa0a39d2b83", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:08.401331Z", + "iopub.status.busy": "2024-12-16T19:26:08.401177Z", + "iopub.status.idle": "2024-12-16T19:26:08.492752Z", + "shell.execute_reply": "2024-12-16T19:26:08.492250Z", + "shell.execute_reply.started": "2024-12-16T19:26:08.401317Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 1:80: E501 line too long (85 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 3:80: E501 line too long (84 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 8:80: E501 line too long (92 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:80: E501 line too long (84 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 10:80: E501 line too long (107 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 13:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 13:80: E501 line too long (80 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 16:68: W291 trailing whitespace</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 17:9: E116 unexpected indentation (comment)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 17:9: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 17:53: W291 trailing whitespace</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 19:9: E116 unexpected indentation (comment)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 19:9: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 20:9: E116 unexpected indentation (comment)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 20:9: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 20:80: E501 line too long (91 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 22:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, obj.coord_ra, obj.coord_dec obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_cModelFlux, obj.i_free_cModelFlux, obj.i_gaap3p0Flux, obj.i_gaap1p5Flux, obj.i_gaapOptimalFlux, obj.detect_fromBlend FROM dp02_dc2_catalogs.MatchesTruth AS mt JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId WHERE CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1\n" + ] + } + ], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, \"\\\n", " \"obj.coord_ra, obj.coord_dec \"\\\n", @@ -468,10 +1005,116 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "0d28a6ad-4436-410c-9b9d-e995140be304", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:08.493522Z", + "iopub.status.busy": "2024-12-16T19:26:08.493353Z", + "iopub.status.idle": "2024-12-16T19:26:08.577965Z", + "shell.execute_reply": "2024-12-16T19:26:08.577466Z", + "shell.execute_reply.started": "2024-12-16T19:26:08.493508Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, obj.coord_ra, obj.coord_dec, obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux FROM dp02_dc2_catalogs.MatchesTruth AS mt JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId WHERE CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \n" + ] + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 1:80: E501 line too long (96 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 3:80: E501 line too long (83 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 5:80: E501 line too long (92 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 6:80: E501 line too long (84 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 7:80: E501 line too long (108 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, \"\\\n", " \"obj.coord_ra, obj.coord_dec, \"\\\n", @@ -485,10 +1128,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:26:08.578754Z", + "iopub.status.busy": "2024-12-16T19:26:08.578602Z", + "iopub.status.idle": "2024-12-16T19:27:17.104865Z", + "shell.execute_reply": "2024-12-16T19:27:17.104239Z", + "shell.execute_reply.started": "2024-12-16T19:26:08.578740Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job phase is COMPLETED\n" + ] + } + ], "source": [ "job = service.submit_job(query)\n", "job.run()\n", @@ -498,10 +1157,86 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:27:17.105762Z", + "iopub.status.busy": "2024-12-16T19:27:17.105581Z", + "iopub.status.idle": "2024-12-16T19:27:17.617123Z", + "shell.execute_reply": "2024-12-16T19:27:17.616490Z", + "shell.execute_reply.started": "2024-12-16T19:27:17.105740Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14850\n" + ] + }, + { + "data": { + "text/html": [ + "<div><i>Table length=14850</i>\n", + "<table id=\"table133286381979664\" class=\"table-striped table-bordered table-condensed\">\n", + "<thead><tr><th>id_truth_type</th><th>match_objectId</th><th>ra</th><th>dec</th><th>truth_type</th><th>flux_i</th><th>coord_ra</th><th>coord_dec</th><th>i_kronFlux</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th></tr></thead>\n", + "<thead><tr><th></th><th></th><th>deg</th><th>deg</th><th></th><th>nJy</th><th>deg</th><th>deg</th><th>nJy</th><th></th><th></th><th>nJy</th></tr></thead>\n", + "<thead><tr><th>str18</th><th>int64</th><th>float64</th><th>float64</th><th>int64</th><th>float32</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th></tr></thead>\n", + "<tr><td>7945422126_1</td><td>1651220174314970042</td><td>62.0098537</td><td>-37.0901136</td><td>1</td><td>80.1357</td><td>62.0097847</td><td>-37.0901294</td><td>165.209455</td><td>3.96143</td><td>False</td><td>144.8895812</td></tr>\n", + "<tr><td>7945243448_1</td><td>1651220174314969053</td><td>62.0123662</td><td>-37.0958262</td><td>1</td><td>29.3619</td><td>62.0122497</td><td>-37.095827</td><td>26.3455006</td><td>3.35127</td><td>False</td><td>26.4549883</td></tr>\n", + "<tr><td>7943980583_1</td><td>1651220174314973031</td><td>62.0804319</td><td>-37.0599329</td><td>1</td><td>85.0716</td><td>62.0804585</td><td>-37.0599007</td><td>162.519251</td><td>5.77871</td><td>False</td><td>94.6220978</td></tr>\n", + "<tr><td>7945989161_1</td><td>1651220174314971178</td><td>62.0564371</td><td>-37.0798811</td><td>1</td><td>19.3238</td><td>62.0564774</td><td>-37.0798535</td><td>302.4945923</td><td>6.34324</td><td>False</td><td>26.7677409</td></tr>\n", + "<tr><td>7943914894_1</td><td>1651220174314972468</td><td>62.0265776</td><td>-37.0665263</td><td>1</td><td>97.0441</td><td>62.0265816</td><td>-37.0666442</td><td>88.0578177</td><td>2.17656</td><td>False</td><td>92.9627681</td></tr>\n", + "<tr><td>7945857828_1</td><td>1651220174314944411</td><td>62.0235745</td><td>-37.09605</td><td>1</td><td>17.5286</td><td>62.0237049</td><td>-37.0960033</td><td>894.5515387</td><td>7.43073</td><td>True</td><td>46.6692541</td></tr>\n", + "<tr><td>7952673851_1</td><td>1651220174314942424</td><td>62.0192451</td><td>-37.0681484</td><td>1</td><td>21.9923</td><td>62.0192534</td><td>-37.0680369</td><td>235.4698083</td><td>6.75986</td><td>True</td><td>16.5300362</td></tr>\n", + "<tr><td>7944426799_1</td><td>1651220174314944029</td><td>62.0598167</td><td>-37.078065</td><td>1</td><td>71.2611</td><td>62.0596735</td><td>-37.0780034</td><td>--</td><td>--</td><td>True</td><td>51.5588324</td></tr>\n", + "<tr><td>7950583914_1</td><td>1651220174314971134</td><td>62.0263471</td><td>-37.0806093</td><td>1</td><td>225.01</td><td>62.0264767</td><td>-37.080598</td><td>154.3405117</td><td>3.28615</td><td>False</td><td>150.5482851</td></tr>\n", + "<tr><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n", + "<tr><td>7941947856_1</td><td>1651220174314938116</td><td>62.0738491</td><td>-37.0527351</td><td>1</td><td>101.294</td><td>62.0738721</td><td>-37.0527186</td><td>582.997383</td><td>10.4693</td><td>True</td><td>126.1897222</td></tr>\n", + "<tr><td>7940592997_1</td><td>1651220174314938114</td><td>62.002132</td><td>-37.0526555</td><td>1</td><td>206.925</td><td>62.0021215</td><td>-37.0526411</td><td>436.3974334</td><td>6.11094</td><td>False</td><td>174.7833985</td></tr>\n", + "<tr><td>7941544592_1</td><td>1651220174314938119</td><td>62.077169</td><td>-37.0524956</td><td>1</td><td>269.445</td><td>62.0771789</td><td>-37.0525201</td><td>331.2637501</td><td>2.76985</td><td>False</td><td>302.0123595</td></tr>\n", + "<tr><td>7939674321_1</td><td>1651281746966117442</td><td>62.0134859</td><td>-36.9668543</td><td>1</td><td>247.05</td><td>62.0135091</td><td>-36.966804</td><td>246.8713545</td><td>3.19171</td><td>False</td><td>243.6787974</td></tr>\n", + "<tr><td>7939694560_1</td><td>1651281746966118922</td><td>62.0979825</td><td>-36.9472682</td><td>1</td><td>106.092</td><td>62.0978588</td><td>-36.9472224</td><td>244.5113481</td><td>2.96379</td><td>False</td><td>244.874761</td></tr>\n", + "<tr><td>7939674319_1</td><td>1651281746966116931</td><td>62.015545</td><td>-36.9700529</td><td>1</td><td>99.9993</td><td>62.0155967</td><td>-36.9699778</td><td>113.0465834</td><td>2.5054</td><td>False</td><td>118.1390177</td></tr>\n", + "<tr><td>7939674328_1</td><td>1651281746966117956</td><td>62.0059488</td><td>-36.9589215</td><td>1</td><td>104.76</td><td>62.0059801</td><td>-36.9588153</td><td>544.2527922</td><td>9.1372</td><td>False</td><td>228.9871482</td></tr>\n", + "<tr><td>7939699200_1</td><td>1651281746966119021</td><td>62.0115523</td><td>-36.9472928</td><td>1</td><td>156.38</td><td>62.011636</td><td>-36.9472674</td><td>10.962813</td><td>2.81807</td><td>False</td><td>11.0785882</td></tr>\n", + "<tr><td>7939698330_1</td><td>1651220174314939597</td><td>62.0242245</td><td>-37.0181435</td><td>1</td><td>87.0308</td><td>62.0243168</td><td>-37.0180876</td><td>477.8553625</td><td>6.65687</td><td>False</td><td>213.6284599</td></tr>\n", + "</table></div>" + ], + "text/plain": [ + "<Table length=14850>\n", + "id_truth_type match_objectId ra ... i_kronFlux_flag i_cModelFlux\n", + " deg ... nJy \n", + " str18 int64 float64 ... bool float64 \n", + "------------- ------------------- ---------- ... --------------- ------------\n", + " 7945422126_1 1651220174314970042 62.0098537 ... False 144.8895812\n", + " 7945243448_1 1651220174314969053 62.0123662 ... False 26.4549883\n", + " 7943980583_1 1651220174314973031 62.0804319 ... False 94.6220978\n", + " 7945989161_1 1651220174314971178 62.0564371 ... False 26.7677409\n", + " 7943914894_1 1651220174314972468 62.0265776 ... False 92.9627681\n", + " 7945857828_1 1651220174314944411 62.0235745 ... True 46.6692541\n", + " 7952673851_1 1651220174314942424 62.0192451 ... True 16.5300362\n", + " 7944426799_1 1651220174314944029 62.0598167 ... True 51.5588324\n", + " 7950583914_1 1651220174314971134 62.0263471 ... False 150.5482851\n", + " ... ... ... ... ... ...\n", + " 7941947856_1 1651220174314938116 62.0738491 ... True 126.1897222\n", + " 7940592997_1 1651220174314938114 62.002132 ... False 174.7833985\n", + " 7941544592_1 1651220174314938119 62.077169 ... False 302.0123595\n", + " 7939674321_1 1651281746966117442 62.0134859 ... False 243.6787974\n", + " 7939694560_1 1651281746966118922 62.0979825 ... False 244.874761\n", + " 7939674319_1 1651281746966116931 62.015545 ... False 118.1390177\n", + " 7939674328_1 1651281746966117956 62.0059488 ... False 228.9871482\n", + " 7939699200_1 1651281746966119021 62.0115523 ... False 11.0785882\n", + " 7939698330_1 1651220174314939597 62.0242245 ... False 213.6284599" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "results = job.fetch_result()\n", "print(len(results))\n", @@ -511,10 +1246,259 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:31:40.773779Z", + "iopub.status.busy": "2024-12-16T19:31:40.773086Z", + "iopub.status.idle": "2024-12-16T19:31:41.062591Z", + "shell.execute_reply": "2024-12-16T19:31:41.062101Z", + "shell.execute_reply.started": "2024-12-16T19:31:40.773757Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_9284/1456611101.py:3: RuntimeWarning: divide by zero encountered in log10\n", + " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "/tmp/ipykernel_9284/1456611101.py:3: RuntimeWarning: invalid value encountered in log10\n", + " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "/tmp/ipykernel_9284/1456611101.py:4: RuntimeWarning: divide by zero encountered in log10\n", + " kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "/tmp/ipykernel_9284/1456611101.py:4: RuntimeWarning: invalid value encountered in log10\n", + " kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 5:12: E222 multiple spaces after operator</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 7:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:77: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:80: E501 line too long (90 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:81: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 11:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 13:17: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 15:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 16:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 17:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 18:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 20:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# this is where you are working here:\n", "\n", @@ -522,16 +1506,20 @@ "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", "\n", - "plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", - "\n", + "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", + "fig, ax = plt.subplots()\n", + "ax.plot(truth_mag, 1+np.abs(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.5)\n", "\n", - "plt.scatter(truth_mag,kron_mag,\n", - " c=tab['i_kronRad'], marker='+', alpha=.5)\n", + "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", + "ax.set_ylim([0.5,25])\n", + "ax.set_yscale('log')\n", + "#plt.ylim(15,20)\n", + "#x = np.arange(14,30,.1)\n", + "#plt.plot(x,x,linestyle='--')\n", + "#plt.axhline(1,linestyle='--')\n", "\n", - "x = np.arange(14,30,.1)\n", - "plt.plot(x,x,linestyle='--')\n", - "plt.show()" + "#plt.show()" ] }, { @@ -551,10 +1539,119 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:27:18.073929Z", + "iopub.status.busy": "2024-12-16T19:27:18.073762Z", + "iopub.status.idle": "2024-12-16T19:27:18.174086Z", + "shell.execute_reply": "2024-12-16T19:27:18.173381Z", + "shell.execute_reply.started": "2024-12-16T19:27:18.073914Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i_ap03Flux\n", + "i_ap03Flux_flag\n", + "i_ap03FluxErr\n", + "i_ap06Flux\n", + "i_ap06Flux_flag\n", + "i_ap06FluxErr\n", + "i_ap09Flux\n", + "i_ap09Flux_flag\n", + "i_ap09FluxErr\n", + "i_ap12Flux\n", + "i_ap12Flux_flag\n", + "i_ap12FluxErr\n", + "i_ap17Flux\n", + "i_ap17Flux_flag\n", + "i_ap17FluxErr\n", + "i_ap25Flux\n", + "i_ap25Flux_flag\n", + "i_ap25FluxErr\n", + "i_ap35Flux\n", + "i_ap35Flux_flag\n", + "i_ap35FluxErr\n", + "i_ap50Flux\n", + "i_ap50Flux_flag\n", + "i_ap50FluxErr\n", + "i_ap70Flux\n", + "i_ap70Flux_flag\n", + "i_ap70FluxErr\n", + "i_apFlux_flag\n", + "i_apFlux_flag_apertureTruncated\n", + "i_apFlux_flag_sincCoeffsTruncated\n", + "i_bdFluxB\n", + "i_bdFluxBErr\n", + "i_bdFluxD\n", + "i_bdFluxDErr\n", + "i_calibFlux\n", + "i_calibFlux_flag\n", + "i_calibFlux_flag_apertureTruncated\n", + "i_calibFlux_flag_sincCoeffsTruncated\n", + "i_calibFluxErr\n", + "i_cModelFlux\n", + "i_cModelFlux_inner\n", + "i_cModelFluxErr\n", + "i_free_cModelFlux\n", + "i_free_cModelFlux_flag\n", + "i_free_cModelFlux_inner\n", + "i_free_cModelFluxErr\n", + "i_free_psfFlux\n", + "i_free_psfFlux_flag\n", + "i_free_psfFluxErr\n", + "i_gaap0p5Flux\n", + "i_gaap0p5Flux_flag_bigPsf\n", + "i_gaap0p5FluxErr\n", + "i_gaap0p7Flux\n", + "i_gaap0p7Flux_flag_bigPsf\n", + "i_gaap0p7FluxErr\n", + "i_gaap1p0Flux\n", + "i_gaap1p0Flux_flag_bigPsf\n", + "i_gaap1p0FluxErr\n", + "i_gaap1p5Flux\n", + "i_gaap1p5Flux_flag_bigPsf\n", + "i_gaap1p5FluxErr\n", + "i_gaap2p5Flux\n", + "i_gaap2p5Flux_flag_bigPsf\n", + "i_gaap2p5FluxErr\n", + "i_gaap3p0Flux\n", + "i_gaap3p0Flux_flag_bigPsf\n", + "i_gaap3p0FluxErr\n", + "i_gaapFlux_flag\n", + "i_gaapFlux_flag_edge\n", + "i_gaapFlux_flag_gaussianization\n", + "i_gaapOptimalFlux\n", + "i_gaapOptimalFlux_flag_bigPsf\n", + "i_gaapOptimalFluxErr\n", + "i_gaapPsfFlux\n", + "i_gaapPsfFluxErr\n", + "i_kronFlux\n", + "i_kronFlux_flag\n", + "i_kronFlux_flag_bad_radius\n", + "i_kronFlux_flag_bad_shape\n", + "i_kronFlux_flag_bad_shape_no_psf\n", + "i_kronFlux_flag_edge\n", + "i_kronFlux_flag_no_fallback_radius\n", + "i_kronFlux_flag_no_minimum_radius\n", + "i_kronFlux_flag_small_radius\n", + "i_kronFlux_flag_used_minimum_radius\n", + "i_kronFlux_flag_used_psf_radius\n", + "i_kronFluxErr\n", + "i_psfFlux\n", + "i_psfFlux_area\n", + "i_psfFlux_flag\n", + "i_psfFlux_flag_apCorr\n", + "i_psfFlux_flag_edge\n", + "i_psfFlux_flag_noGoodPixels\n", + "i_psfFluxErr\n" + ] + } + ], "source": [ "search_string = 'Flux'\n", "band = 'i_'\n", @@ -565,20 +1662,230 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "2f52232f-8e56-4118-8454-66593a552ddc", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:27:18.175203Z", + "iopub.status.busy": "2024-12-16T19:27:18.174745Z", + "iopub.status.idle": "2024-12-16T19:27:18.268087Z", + "shell.execute_reply": "2024-12-16T19:27:18.267505Z", + "shell.execute_reply.started": "2024-12-16T19:27:18.175178Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "<div><i>Table length=14850</i>\n", + "<table id=\"table133286381979664\" class=\"table-striped table-bordered table-condensed\">\n", + "<thead><tr><th>id_truth_type</th><th>match_objectId</th><th>ra</th><th>dec</th><th>truth_type</th><th>flux_i</th><th>coord_ra</th><th>coord_dec</th><th>i_kronFlux</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th></tr></thead>\n", + "<thead><tr><th></th><th></th><th>deg</th><th>deg</th><th></th><th>nJy</th><th>deg</th><th>deg</th><th>nJy</th><th></th><th></th><th>nJy</th></tr></thead>\n", + "<thead><tr><th>str18</th><th>int64</th><th>float64</th><th>float64</th><th>int64</th><th>float32</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th></tr></thead>\n", + "<tr><td>7945422126_1</td><td>1651220174314970042</td><td>62.0098537</td><td>-37.0901136</td><td>1</td><td>80.1357</td><td>62.0097847</td><td>-37.0901294</td><td>165.209455</td><td>3.96143</td><td>False</td><td>144.8895812</td></tr>\n", + "<tr><td>7945243448_1</td><td>1651220174314969053</td><td>62.0123662</td><td>-37.0958262</td><td>1</td><td>29.3619</td><td>62.0122497</td><td>-37.095827</td><td>26.3455006</td><td>3.35127</td><td>False</td><td>26.4549883</td></tr>\n", + "<tr><td>7943980583_1</td><td>1651220174314973031</td><td>62.0804319</td><td>-37.0599329</td><td>1</td><td>85.0716</td><td>62.0804585</td><td>-37.0599007</td><td>162.519251</td><td>5.77871</td><td>False</td><td>94.6220978</td></tr>\n", + "<tr><td>7945989161_1</td><td>1651220174314971178</td><td>62.0564371</td><td>-37.0798811</td><td>1</td><td>19.3238</td><td>62.0564774</td><td>-37.0798535</td><td>302.4945923</td><td>6.34324</td><td>False</td><td>26.7677409</td></tr>\n", + "<tr><td>7943914894_1</td><td>1651220174314972468</td><td>62.0265776</td><td>-37.0665263</td><td>1</td><td>97.0441</td><td>62.0265816</td><td>-37.0666442</td><td>88.0578177</td><td>2.17656</td><td>False</td><td>92.9627681</td></tr>\n", + "<tr><td>7945857828_1</td><td>1651220174314944411</td><td>62.0235745</td><td>-37.09605</td><td>1</td><td>17.5286</td><td>62.0237049</td><td>-37.0960033</td><td>894.5515387</td><td>7.43073</td><td>True</td><td>46.6692541</td></tr>\n", + "<tr><td>7952673851_1</td><td>1651220174314942424</td><td>62.0192451</td><td>-37.0681484</td><td>1</td><td>21.9923</td><td>62.0192534</td><td>-37.0680369</td><td>235.4698083</td><td>6.75986</td><td>True</td><td>16.5300362</td></tr>\n", + "<tr><td>7944426799_1</td><td>1651220174314944029</td><td>62.0598167</td><td>-37.078065</td><td>1</td><td>71.2611</td><td>62.0596735</td><td>-37.0780034</td><td>--</td><td>--</td><td>True</td><td>51.5588324</td></tr>\n", + "<tr><td>7950583914_1</td><td>1651220174314971134</td><td>62.0263471</td><td>-37.0806093</td><td>1</td><td>225.01</td><td>62.0264767</td><td>-37.080598</td><td>154.3405117</td><td>3.28615</td><td>False</td><td>150.5482851</td></tr>\n", + "<tr><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n", + "<tr><td>7941947856_1</td><td>1651220174314938116</td><td>62.0738491</td><td>-37.0527351</td><td>1</td><td>101.294</td><td>62.0738721</td><td>-37.0527186</td><td>582.997383</td><td>10.4693</td><td>True</td><td>126.1897222</td></tr>\n", + "<tr><td>7940592997_1</td><td>1651220174314938114</td><td>62.002132</td><td>-37.0526555</td><td>1</td><td>206.925</td><td>62.0021215</td><td>-37.0526411</td><td>436.3974334</td><td>6.11094</td><td>False</td><td>174.7833985</td></tr>\n", + "<tr><td>7941544592_1</td><td>1651220174314938119</td><td>62.077169</td><td>-37.0524956</td><td>1</td><td>269.445</td><td>62.0771789</td><td>-37.0525201</td><td>331.2637501</td><td>2.76985</td><td>False</td><td>302.0123595</td></tr>\n", + "<tr><td>7939674321_1</td><td>1651281746966117442</td><td>62.0134859</td><td>-36.9668543</td><td>1</td><td>247.05</td><td>62.0135091</td><td>-36.966804</td><td>246.8713545</td><td>3.19171</td><td>False</td><td>243.6787974</td></tr>\n", + "<tr><td>7939694560_1</td><td>1651281746966118922</td><td>62.0979825</td><td>-36.9472682</td><td>1</td><td>106.092</td><td>62.0978588</td><td>-36.9472224</td><td>244.5113481</td><td>2.96379</td><td>False</td><td>244.874761</td></tr>\n", + "<tr><td>7939674319_1</td><td>1651281746966116931</td><td>62.015545</td><td>-36.9700529</td><td>1</td><td>99.9993</td><td>62.0155967</td><td>-36.9699778</td><td>113.0465834</td><td>2.5054</td><td>False</td><td>118.1390177</td></tr>\n", + "<tr><td>7939674328_1</td><td>1651281746966117956</td><td>62.0059488</td><td>-36.9589215</td><td>1</td><td>104.76</td><td>62.0059801</td><td>-36.9588153</td><td>544.2527922</td><td>9.1372</td><td>False</td><td>228.9871482</td></tr>\n", + "<tr><td>7939699200_1</td><td>1651281746966119021</td><td>62.0115523</td><td>-36.9472928</td><td>1</td><td>156.38</td><td>62.011636</td><td>-36.9472674</td><td>10.962813</td><td>2.81807</td><td>False</td><td>11.0785882</td></tr>\n", + "<tr><td>7939698330_1</td><td>1651220174314939597</td><td>62.0242245</td><td>-37.0181435</td><td>1</td><td>87.0308</td><td>62.0243168</td><td>-37.0180876</td><td>477.8553625</td><td>6.65687</td><td>False</td><td>213.6284599</td></tr>\n", + "</table></div>" + ], + "text/plain": [ + "<Table length=14850>\n", + "id_truth_type match_objectId ra ... i_kronFlux_flag i_cModelFlux\n", + " deg ... nJy \n", + " str18 int64 float64 ... bool float64 \n", + "------------- ------------------- ---------- ... --------------- ------------\n", + " 7945422126_1 1651220174314970042 62.0098537 ... False 144.8895812\n", + " 7945243448_1 1651220174314969053 62.0123662 ... False 26.4549883\n", + " 7943980583_1 1651220174314973031 62.0804319 ... False 94.6220978\n", + " 7945989161_1 1651220174314971178 62.0564371 ... False 26.7677409\n", + " 7943914894_1 1651220174314972468 62.0265776 ... False 92.9627681\n", + " 7945857828_1 1651220174314944411 62.0235745 ... True 46.6692541\n", + " 7952673851_1 1651220174314942424 62.0192451 ... True 16.5300362\n", + " 7944426799_1 1651220174314944029 62.0598167 ... True 51.5588324\n", + " 7950583914_1 1651220174314971134 62.0263471 ... False 150.5482851\n", + " ... ... ... ... ... ...\n", + " 7941947856_1 1651220174314938116 62.0738491 ... True 126.1897222\n", + " 7940592997_1 1651220174314938114 62.002132 ... False 174.7833985\n", + " 7941544592_1 1651220174314938119 62.077169 ... False 302.0123595\n", + " 7939674321_1 1651281746966117442 62.0134859 ... False 243.6787974\n", + " 7939694560_1 1651281746966118922 62.0979825 ... False 244.874761\n", + " 7939674319_1 1651281746966116931 62.015545 ... False 118.1390177\n", + " 7939674328_1 1651281746966117956 62.0059488 ... False 228.9871482\n", + " 7939699200_1 1651281746966119021 62.0115523 ... False 11.0785882\n", + " 7939698330_1 1651220174314939597 62.0242245 ... False 213.6284599" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "tab" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:27:18.268752Z", + "iopub.status.busy": "2024-12-16T19:27:18.268603Z", + "iopub.status.idle": "2024-12-16T19:27:18.675021Z", + "shell.execute_reply": "2024-12-16T19:27:18.674484Z", + "shell.execute_reply.started": "2024-12-16T19:27:18.268738Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_9284/2103441182.py:6: RuntimeWarning: divide by zero encountered in log10\n", + " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "/tmp/ipykernel_9284/2103441182.py:6: RuntimeWarning: invalid value encountered in log10\n", + " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "/tmp/ipykernel_9284/2103441182.py:7: RuntimeWarning: divide by zero encountered in log10\n", + " kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "/tmp/ipykernel_9284/2103441182.py:7: RuntimeWarning: invalid value encountered in log10\n", + " kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 3:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 4:80: E501 line too long (84 > 79 characters)</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:23: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 12:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 14:17: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 14:32: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# compare kron mag to cmodel mag\n", "\n", @@ -604,10 +1911,104 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-16T19:27:18.675850Z", + "iopub.status.busy": "2024-12-16T19:27:18.675684Z", + "iopub.status.idle": "2024-12-16T19:27:19.257839Z", + "shell.execute_reply": "2024-12-16T19:27:19.256931Z", + "shell.execute_reply.started": "2024-12-16T19:27:18.675835Z" + } + }, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'i_gaapOptimalFlux'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[19], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m cmodel_mag \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2.50\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mlog10(\u001b[43mtab\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mi_gaapOptimalFlux\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m31.4\u001b[39m\n\u001b[1;32m 2\u001b[0m kron_mag \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2.50\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mlog10(tab[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mi_kronFlux\u001b[39m\u001b[38;5;124m'\u001b[39m]) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m31.4\u001b[39m\n\u001b[1;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mscatter(cmodel_mag,kron_mag,\n\u001b[1;32m 5\u001b[0m c\u001b[38;5;241m=\u001b[39mtab[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mi_kronRad\u001b[39m\u001b[38;5;124m'\u001b[39m], marker\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m'\u001b[39m, alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.5\u001b[39m, vmin\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, vmax\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m50\u001b[39m)\n", + "File \u001b[0;32m/opt/lsst/software/stack/conda/envs/lsst-scipipe-9.0.0/lib/python3.11/site-packages/astropy/table/table.py:2093\u001b[0m, in \u001b[0;36mTable.__getitem__\u001b[0;34m(self, item)\u001b[0m\n\u001b[1;32m 2091\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m, item):\n\u001b[1;32m 2092\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(item, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m-> 2093\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[43m[\u001b[49m\u001b[43mitem\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 2094\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(item, (\u001b[38;5;28mint\u001b[39m, np\u001b[38;5;241m.\u001b[39minteger)):\n\u001b[1;32m 2095\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mRow(\u001b[38;5;28mself\u001b[39m, item)\n", + "File \u001b[0;32m/opt/lsst/software/stack/conda/envs/lsst-scipipe-9.0.0/lib/python3.11/site-packages/astropy/table/table.py:267\u001b[0m, in \u001b[0;36mTableColumns.__getitem__\u001b[0;34m(self, item)\u001b[0m\n\u001b[1;32m 256\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Get items from a TableColumns object.\u001b[39;00m\n\u001b[1;32m 257\u001b[0m \n\u001b[1;32m 258\u001b[0m \u001b[38;5;124;03m::\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 264\u001b[0m \u001b[38;5;124;03m tc[1:3] # <TableColumns names=('b', 'c')>\u001b[39;00m\n\u001b[1;32m 265\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(item, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m--> 267\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mOrderedDict\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__getitem__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mitem\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(item, (\u001b[38;5;28mint\u001b[39m, np\u001b[38;5;241m.\u001b[39minteger)):\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvalues())[item]\n", + "\u001b[0;31mKeyError\u001b[0m: 'i_gaapOptimalFlux'" + ] + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 5:23: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 8:1: E265 block comment should start with '# '</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 10:17: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<pre style=\"margin: 0.1em;\n", + "padding-left: 0.25em;\n", + "border-left-style: solid;\n", + "font-family: var(--jp-code-font-family);\n", + "font-size: var(--jp-code-font-size);\n", + "line-height: var(--jp-code-line-height);\n", + "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 10:32: E231 missing whitespace after ','</pre>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "\n", "cmodel_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", @@ -631,7 +2032,14 @@ "cell_type": "code", "execution_count": null, "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2024-12-16T19:27:19.258345Z", + "iopub.status.idle": "2024-12-16T19:27:19.258568Z", + "shell.execute_reply": "2024-12-16T19:27:19.258479Z", + "shell.execute_reply.started": "2024-12-16T19:27:19.258470Z" + } + }, "outputs": [], "source": [ "\n", @@ -656,7 +2064,14 @@ "cell_type": "code", "execution_count": null, "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2024-12-16T19:27:19.259095Z", + "iopub.status.idle": "2024-12-16T19:27:19.259261Z", + "shell.execute_reply": "2024-12-16T19:27:19.259190Z", + "shell.execute_reply.started": "2024-12-16T19:27:19.259183Z" + } + }, "outputs": [], "source": [ "\n", @@ -693,7 +2108,14 @@ "cell_type": "code", "execution_count": null, "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2024-12-16T19:27:19.259716Z", + "iopub.status.idle": "2024-12-16T19:27:19.259898Z", + "shell.execute_reply": "2024-12-16T19:27:19.259829Z", + "shell.execute_reply.started": "2024-12-16T19:27:19.259822Z" + } + }, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_gaapOptimalFlux'][whbright],\n", @@ -710,7 +2132,14 @@ "cell_type": "code", "execution_count": null, "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2024-12-16T19:27:19.260772Z", + "iopub.status.idle": "2024-12-16T19:27:19.260944Z", + "shell.execute_reply": "2024-12-16T19:27:19.260866Z", + "shell.execute_reply.started": "2024-12-16T19:27:19.260859Z" + } + }, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", From 7dedfb62a9fc6c51730f531b446684d92c1449fe Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 16 Dec 2024 22:23:37 +0000 Subject: [PATCH 15/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 1555 ++----------------------------- 1 file changed, 65 insertions(+), 1490 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 41a9593..751857d 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -33,17 +33,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:00.845473Z", - "iopub.status.busy": "2024-12-16T19:26:00.845330Z", - "iopub.status.idle": "2024-12-16T19:26:00.872992Z", - "shell.execute_reply": "2024-12-16T19:26:00.872589Z", - "shell.execute_reply.started": "2024-12-16T19:26:00.845459Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "%load_ext pycodestyle_magic\n", @@ -267,17 +259,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "2dbc75bd-a802-4576-8628-4e0088942303", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:00.873696Z", - "iopub.status.busy": "2024-12-16T19:26:00.873546Z", - "iopub.status.idle": "2024-12-16T19:26:03.127233Z", - "shell.execute_reply": "2024-12-16T19:26:03.126652Z", - "shell.execute_reply.started": "2024-12-16T19:26:00.873683Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -311,17 +295,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:03.128540Z", - "iopub.status.busy": "2024-12-16T19:26:03.127914Z", - "iopub.status.idle": "2024-12-16T19:26:03.233902Z", - "shell.execute_reply": "2024-12-16T19:26:03.233332Z", - "shell.execute_reply.started": "2024-12-16T19:26:03.128517Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", @@ -330,17 +306,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:03.235020Z", - "iopub.status.busy": "2024-12-16T19:26:03.234603Z", - "iopub.status.idle": "2024-12-16T19:26:03.351442Z", - "shell.execute_reply": "2024-12-16T19:26:03.350915Z", - "shell.execute_reply.started": "2024-12-16T19:26:03.234998Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "service = get_tap_service(\"tap\")" @@ -366,17 +334,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "6ad9a3ea-5d4c-4247-b0ff-712fafa00bb3", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:03.352325Z", - "iopub.status.busy": "2024-12-16T19:26:03.352122Z", - "iopub.status.idle": "2024-12-16T19:26:07.787878Z", - "shell.execute_reply": "2024-12-16T19:26:07.787244Z", - "shell.execute_reply.started": "2024-12-16T19:26:03.352309Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "butler = Butler('dp02', collections='2.2i/runs/DP0.2')\n", @@ -388,127 +348,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "a59e517d-e7e9-4371-9904-174fc6bf1f4f", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:07.789226Z", - "iopub.status.busy": "2024-12-16T19:26:07.788509Z", - "iopub.status.idle": "2024-12-16T19:26:07.865191Z", - "shell.execute_reply": "2024-12-16T19:26:07.864666Z", - "shell.execute_reply.started": "2024-12-16T19:26:07.789207Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 1:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 2:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 3:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 4:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 5:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 6:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "metadata": {}, + "outputs": [], "source": [ "#fig, ax = plt.subplots()\n", "#display = afwDisplay.Display(frame=fig)\n", @@ -520,17 +363,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "914e6572-fcac-415a-a4de-fb526d198483", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:07.866268Z", - "iopub.status.busy": "2024-12-16T19:26:07.866094Z", - "iopub.status.idle": "2024-12-16T19:26:08.234782Z", - "shell.execute_reply": "2024-12-16T19:26:08.234197Z", - "shell.execute_reply.started": "2024-12-16T19:26:07.866252Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "skymap = butler.get('skyMap')\n", @@ -539,17 +374,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "7006a12e-5631-4b55-9eba-6f5fd7f73bac", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:08.235632Z", - "iopub.status.busy": "2024-12-16T19:26:08.235461Z", - "iopub.status.idle": "2024-12-16T19:26:08.317057Z", - "shell.execute_reply": "2024-12-16T19:26:08.316205Z", - "shell.execute_reply.started": "2024-12-16T19:26:08.235616Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "cutout_image = coadd\n", @@ -575,62 +402,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "decab323-5735-4e6a-af11-cabb3cc7bdc3", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:08.317964Z", - "iopub.status.busy": "2024-12-16T19:26:08.317779Z", - "iopub.status.idle": "2024-12-16T19:26:08.400569Z", - "shell.execute_reply": "2024-12-16T19:26:08.399947Z", - "shell.execute_reply.started": "2024-12-16T19:26:08.317949Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:80: E501 line too long (87 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 14:80: E501 line too long (82 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, i_ap09Flux, i_ap12Flux, i_ap17Flux, i_ap25Flux, i_ap35Flux, i_cModelFlux, i_free_cModelFlux, i_gaap3p0Flux, i_gaap1p5Flux, i_gaapOptimalFlux, i_kronFlux, i_kronRad, i_kronFlux_flag, detect_fromBlend FROM dp02_dc2_catalogs.Object WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), POLYGON('ICRS', 55.79016376401875, -32.322225378380246, 55.5140525810614, -32.32222523523597, 55.51440424131911, -32.088896406426095, 55.78981243851229, -32.088896548288034)) = 1 AND detect_isPrimary = 1 AND tract = 4431 AND patch = 17\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, \" + \\\n", " \"i_ap09Flux, i_ap12Flux, i_ap17Flux, i_ap25Flux, i_ap35Flux, \" + \\\n", @@ -651,332 +426,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "8b1fb7e3-b2f3-49d5-8991-aaa0a39d2b83", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:08.401331Z", - "iopub.status.busy": "2024-12-16T19:26:08.401177Z", - "iopub.status.idle": "2024-12-16T19:26:08.492752Z", - "shell.execute_reply": "2024-12-16T19:26:08.492250Z", - "shell.execute_reply.started": "2024-12-16T19:26:08.401317Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 1:80: E501 line too long (85 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 3:80: E501 line too long (84 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 8:80: E501 line too long (92 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:80: E501 line too long (84 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 10:80: E501 line too long (107 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 13:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 13:80: E501 line too long (80 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 16:68: W291 trailing whitespace</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 17:9: E116 unexpected indentation (comment)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 17:9: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 17:53: W291 trailing whitespace</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 19:9: E116 unexpected indentation (comment)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 19:9: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 20:9: E116 unexpected indentation (comment)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 20:9: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 20:80: E501 line too long (91 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 22:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, obj.coord_ra, obj.coord_dec obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_cModelFlux, obj.i_free_cModelFlux, obj.i_gaap3p0Flux, obj.i_gaap1p5Flux, obj.i_gaapOptimalFlux, obj.detect_fromBlend FROM dp02_dc2_catalogs.MatchesTruth AS mt JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId WHERE CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, \"\\\n", " \"obj.coord_ra, obj.coord_dec \"\\\n", @@ -1005,120 +458,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "0d28a6ad-4436-410c-9b9d-e995140be304", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:08.493522Z", - "iopub.status.busy": "2024-12-16T19:26:08.493353Z", - "iopub.status.idle": "2024-12-16T19:26:08.577965Z", - "shell.execute_reply": "2024-12-16T19:26:08.577466Z", - "shell.execute_reply.started": "2024-12-16T19:26:08.493508Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, obj.coord_ra, obj.coord_dec, obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux FROM dp02_dc2_catalogs.MatchesTruth AS mt JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId WHERE CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \n" - ] - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 1:80: E501 line too long (96 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 3:80: E501 line too long (83 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 5:80: E501 line too long (92 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 6:80: E501 line too long (84 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 7:80: E501 line too long (108 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "metadata": {}, + "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, \"\\\n", " \"obj.coord_ra, obj.coord_dec, \"\\\n", - " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux \" + \\\n", + " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", @@ -1128,26 +475,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:26:08.578754Z", - "iopub.status.busy": "2024-12-16T19:26:08.578602Z", - "iopub.status.idle": "2024-12-16T19:27:17.104865Z", - "shell.execute_reply": "2024-12-16T19:27:17.104239Z", - "shell.execute_reply.started": "2024-12-16T19:26:08.578740Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job phase is COMPLETED\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "job = service.submit_job(query)\n", "job.run()\n", @@ -1157,86 +488,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:27:17.105762Z", - "iopub.status.busy": "2024-12-16T19:27:17.105581Z", - "iopub.status.idle": "2024-12-16T19:27:17.617123Z", - "shell.execute_reply": "2024-12-16T19:27:17.616490Z", - "shell.execute_reply.started": "2024-12-16T19:27:17.105740Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "14850\n" - ] - }, - { - "data": { - "text/html": [ - "<div><i>Table length=14850</i>\n", - "<table id=\"table133286381979664\" class=\"table-striped table-bordered table-condensed\">\n", - "<thead><tr><th>id_truth_type</th><th>match_objectId</th><th>ra</th><th>dec</th><th>truth_type</th><th>flux_i</th><th>coord_ra</th><th>coord_dec</th><th>i_kronFlux</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th></tr></thead>\n", - "<thead><tr><th></th><th></th><th>deg</th><th>deg</th><th></th><th>nJy</th><th>deg</th><th>deg</th><th>nJy</th><th></th><th></th><th>nJy</th></tr></thead>\n", - "<thead><tr><th>str18</th><th>int64</th><th>float64</th><th>float64</th><th>int64</th><th>float32</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th></tr></thead>\n", - "<tr><td>7945422126_1</td><td>1651220174314970042</td><td>62.0098537</td><td>-37.0901136</td><td>1</td><td>80.1357</td><td>62.0097847</td><td>-37.0901294</td><td>165.209455</td><td>3.96143</td><td>False</td><td>144.8895812</td></tr>\n", - "<tr><td>7945243448_1</td><td>1651220174314969053</td><td>62.0123662</td><td>-37.0958262</td><td>1</td><td>29.3619</td><td>62.0122497</td><td>-37.095827</td><td>26.3455006</td><td>3.35127</td><td>False</td><td>26.4549883</td></tr>\n", - "<tr><td>7943980583_1</td><td>1651220174314973031</td><td>62.0804319</td><td>-37.0599329</td><td>1</td><td>85.0716</td><td>62.0804585</td><td>-37.0599007</td><td>162.519251</td><td>5.77871</td><td>False</td><td>94.6220978</td></tr>\n", - "<tr><td>7945989161_1</td><td>1651220174314971178</td><td>62.0564371</td><td>-37.0798811</td><td>1</td><td>19.3238</td><td>62.0564774</td><td>-37.0798535</td><td>302.4945923</td><td>6.34324</td><td>False</td><td>26.7677409</td></tr>\n", - "<tr><td>7943914894_1</td><td>1651220174314972468</td><td>62.0265776</td><td>-37.0665263</td><td>1</td><td>97.0441</td><td>62.0265816</td><td>-37.0666442</td><td>88.0578177</td><td>2.17656</td><td>False</td><td>92.9627681</td></tr>\n", - "<tr><td>7945857828_1</td><td>1651220174314944411</td><td>62.0235745</td><td>-37.09605</td><td>1</td><td>17.5286</td><td>62.0237049</td><td>-37.0960033</td><td>894.5515387</td><td>7.43073</td><td>True</td><td>46.6692541</td></tr>\n", - "<tr><td>7952673851_1</td><td>1651220174314942424</td><td>62.0192451</td><td>-37.0681484</td><td>1</td><td>21.9923</td><td>62.0192534</td><td>-37.0680369</td><td>235.4698083</td><td>6.75986</td><td>True</td><td>16.5300362</td></tr>\n", - "<tr><td>7944426799_1</td><td>1651220174314944029</td><td>62.0598167</td><td>-37.078065</td><td>1</td><td>71.2611</td><td>62.0596735</td><td>-37.0780034</td><td>--</td><td>--</td><td>True</td><td>51.5588324</td></tr>\n", - "<tr><td>7950583914_1</td><td>1651220174314971134</td><td>62.0263471</td><td>-37.0806093</td><td>1</td><td>225.01</td><td>62.0264767</td><td>-37.080598</td><td>154.3405117</td><td>3.28615</td><td>False</td><td>150.5482851</td></tr>\n", - "<tr><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n", - "<tr><td>7941947856_1</td><td>1651220174314938116</td><td>62.0738491</td><td>-37.0527351</td><td>1</td><td>101.294</td><td>62.0738721</td><td>-37.0527186</td><td>582.997383</td><td>10.4693</td><td>True</td><td>126.1897222</td></tr>\n", - "<tr><td>7940592997_1</td><td>1651220174314938114</td><td>62.002132</td><td>-37.0526555</td><td>1</td><td>206.925</td><td>62.0021215</td><td>-37.0526411</td><td>436.3974334</td><td>6.11094</td><td>False</td><td>174.7833985</td></tr>\n", - "<tr><td>7941544592_1</td><td>1651220174314938119</td><td>62.077169</td><td>-37.0524956</td><td>1</td><td>269.445</td><td>62.0771789</td><td>-37.0525201</td><td>331.2637501</td><td>2.76985</td><td>False</td><td>302.0123595</td></tr>\n", - "<tr><td>7939674321_1</td><td>1651281746966117442</td><td>62.0134859</td><td>-36.9668543</td><td>1</td><td>247.05</td><td>62.0135091</td><td>-36.966804</td><td>246.8713545</td><td>3.19171</td><td>False</td><td>243.6787974</td></tr>\n", - "<tr><td>7939694560_1</td><td>1651281746966118922</td><td>62.0979825</td><td>-36.9472682</td><td>1</td><td>106.092</td><td>62.0978588</td><td>-36.9472224</td><td>244.5113481</td><td>2.96379</td><td>False</td><td>244.874761</td></tr>\n", - "<tr><td>7939674319_1</td><td>1651281746966116931</td><td>62.015545</td><td>-36.9700529</td><td>1</td><td>99.9993</td><td>62.0155967</td><td>-36.9699778</td><td>113.0465834</td><td>2.5054</td><td>False</td><td>118.1390177</td></tr>\n", - "<tr><td>7939674328_1</td><td>1651281746966117956</td><td>62.0059488</td><td>-36.9589215</td><td>1</td><td>104.76</td><td>62.0059801</td><td>-36.9588153</td><td>544.2527922</td><td>9.1372</td><td>False</td><td>228.9871482</td></tr>\n", - "<tr><td>7939699200_1</td><td>1651281746966119021</td><td>62.0115523</td><td>-36.9472928</td><td>1</td><td>156.38</td><td>62.011636</td><td>-36.9472674</td><td>10.962813</td><td>2.81807</td><td>False</td><td>11.0785882</td></tr>\n", - "<tr><td>7939698330_1</td><td>1651220174314939597</td><td>62.0242245</td><td>-37.0181435</td><td>1</td><td>87.0308</td><td>62.0243168</td><td>-37.0180876</td><td>477.8553625</td><td>6.65687</td><td>False</td><td>213.6284599</td></tr>\n", - "</table></div>" - ], - "text/plain": [ - "<Table length=14850>\n", - "id_truth_type match_objectId ra ... i_kronFlux_flag i_cModelFlux\n", - " deg ... nJy \n", - " str18 int64 float64 ... bool float64 \n", - "------------- ------------------- ---------- ... --------------- ------------\n", - " 7945422126_1 1651220174314970042 62.0098537 ... False 144.8895812\n", - " 7945243448_1 1651220174314969053 62.0123662 ... False 26.4549883\n", - " 7943980583_1 1651220174314973031 62.0804319 ... False 94.6220978\n", - " 7945989161_1 1651220174314971178 62.0564371 ... False 26.7677409\n", - " 7943914894_1 1651220174314972468 62.0265776 ... False 92.9627681\n", - " 7945857828_1 1651220174314944411 62.0235745 ... True 46.6692541\n", - " 7952673851_1 1651220174314942424 62.0192451 ... True 16.5300362\n", - " 7944426799_1 1651220174314944029 62.0598167 ... True 51.5588324\n", - " 7950583914_1 1651220174314971134 62.0263471 ... False 150.5482851\n", - " ... ... ... ... ... ...\n", - " 7941947856_1 1651220174314938116 62.0738491 ... True 126.1897222\n", - " 7940592997_1 1651220174314938114 62.002132 ... False 174.7833985\n", - " 7941544592_1 1651220174314938119 62.077169 ... False 302.0123595\n", - " 7939674321_1 1651281746966117442 62.0134859 ... False 243.6787974\n", - " 7939694560_1 1651281746966118922 62.0979825 ... False 244.874761\n", - " 7939674319_1 1651281746966116931 62.015545 ... False 118.1390177\n", - " 7939674328_1 1651281746966117956 62.0059488 ... False 228.9871482\n", - " 7939699200_1 1651281746966119021 62.0115523 ... False 11.0785882\n", - " 7939698330_1 1651220174314939597 62.0242245 ... False 213.6284599" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, + "outputs": [], "source": [ "results = job.fetch_result()\n", "print(len(results))\n", @@ -1246,259 +501,10 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:31:40.773779Z", - "iopub.status.busy": "2024-12-16T19:31:40.773086Z", - "iopub.status.idle": "2024-12-16T19:31:41.062591Z", - "shell.execute_reply": "2024-12-16T19:31:41.062101Z", - "shell.execute_reply.started": "2024-12-16T19:31:40.773757Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_9284/1456611101.py:3: RuntimeWarning: divide by zero encountered in log10\n", - " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "/tmp/ipykernel_9284/1456611101.py:3: RuntimeWarning: invalid value encountered in log10\n", - " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "/tmp/ipykernel_9284/1456611101.py:4: RuntimeWarning: divide by zero encountered in log10\n", - " kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "/tmp/ipykernel_9284/1456611101.py:4: RuntimeWarning: invalid value encountered in log10\n", - " kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 5:12: E222 multiple spaces after operator</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 7:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:77: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:80: E501 line too long (90 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:81: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 11:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 13:17: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 15:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 16:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 17:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 18:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 20:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "metadata": {}, + "outputs": [], "source": [ "# this is where you are working here:\n", "\n", @@ -1508,12 +514,22 @@ "\n", "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", "fig, ax = plt.subplots()\n", - "ax.plot(truth_mag, 1+np.abs(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.5)\n", + "\n", + "scale = 0\n", + "\n", + "ax.axhline(scale,linestyle='--')\n", + "\n", + "ax.plot(truth_mag, scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1,label='cModel')\n", + "ax.plot(truth_mag, scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1,label='Kron')\n", + "ax.plot(truth_mag, scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1, label='gaapOptimal')\n", "\n", "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", - "ax.set_ylim([0.5,25])\n", - "ax.set_yscale('log')\n", + "ax.set_xlabel('True i-band Magnitude')\n", + "ax.set_ylabel('Flux Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", + "ax.set_ylim([-5,5])\n", + "#ax.set_yscale('log')\n", + "plt.legend()\n", "#plt.ylim(15,20)\n", "#x = np.arange(14,30,.1)\n", "#plt.plot(x,x,linestyle='--')\n", @@ -1539,119 +555,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:27:18.073929Z", - "iopub.status.busy": "2024-12-16T19:27:18.073762Z", - "iopub.status.idle": "2024-12-16T19:27:18.174086Z", - "shell.execute_reply": "2024-12-16T19:27:18.173381Z", - "shell.execute_reply.started": "2024-12-16T19:27:18.073914Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "i_ap03Flux\n", - "i_ap03Flux_flag\n", - "i_ap03FluxErr\n", - "i_ap06Flux\n", - "i_ap06Flux_flag\n", - "i_ap06FluxErr\n", - "i_ap09Flux\n", - "i_ap09Flux_flag\n", - "i_ap09FluxErr\n", - "i_ap12Flux\n", - "i_ap12Flux_flag\n", - "i_ap12FluxErr\n", - "i_ap17Flux\n", - "i_ap17Flux_flag\n", - "i_ap17FluxErr\n", - "i_ap25Flux\n", - "i_ap25Flux_flag\n", - "i_ap25FluxErr\n", - "i_ap35Flux\n", - "i_ap35Flux_flag\n", - "i_ap35FluxErr\n", - "i_ap50Flux\n", - "i_ap50Flux_flag\n", - "i_ap50FluxErr\n", - "i_ap70Flux\n", - "i_ap70Flux_flag\n", - "i_ap70FluxErr\n", - "i_apFlux_flag\n", - "i_apFlux_flag_apertureTruncated\n", - "i_apFlux_flag_sincCoeffsTruncated\n", - "i_bdFluxB\n", - "i_bdFluxBErr\n", - "i_bdFluxD\n", - "i_bdFluxDErr\n", - "i_calibFlux\n", - "i_calibFlux_flag\n", - "i_calibFlux_flag_apertureTruncated\n", - "i_calibFlux_flag_sincCoeffsTruncated\n", - "i_calibFluxErr\n", - "i_cModelFlux\n", - "i_cModelFlux_inner\n", - "i_cModelFluxErr\n", - "i_free_cModelFlux\n", - "i_free_cModelFlux_flag\n", - "i_free_cModelFlux_inner\n", - "i_free_cModelFluxErr\n", - "i_free_psfFlux\n", - "i_free_psfFlux_flag\n", - "i_free_psfFluxErr\n", - "i_gaap0p5Flux\n", - "i_gaap0p5Flux_flag_bigPsf\n", - "i_gaap0p5FluxErr\n", - "i_gaap0p7Flux\n", - "i_gaap0p7Flux_flag_bigPsf\n", - "i_gaap0p7FluxErr\n", - "i_gaap1p0Flux\n", - "i_gaap1p0Flux_flag_bigPsf\n", - "i_gaap1p0FluxErr\n", - "i_gaap1p5Flux\n", - "i_gaap1p5Flux_flag_bigPsf\n", - "i_gaap1p5FluxErr\n", - "i_gaap2p5Flux\n", - "i_gaap2p5Flux_flag_bigPsf\n", - "i_gaap2p5FluxErr\n", - "i_gaap3p0Flux\n", - "i_gaap3p0Flux_flag_bigPsf\n", - "i_gaap3p0FluxErr\n", - "i_gaapFlux_flag\n", - "i_gaapFlux_flag_edge\n", - "i_gaapFlux_flag_gaussianization\n", - "i_gaapOptimalFlux\n", - "i_gaapOptimalFlux_flag_bigPsf\n", - "i_gaapOptimalFluxErr\n", - "i_gaapPsfFlux\n", - "i_gaapPsfFluxErr\n", - "i_kronFlux\n", - "i_kronFlux_flag\n", - "i_kronFlux_flag_bad_radius\n", - "i_kronFlux_flag_bad_shape\n", - "i_kronFlux_flag_bad_shape_no_psf\n", - "i_kronFlux_flag_edge\n", - "i_kronFlux_flag_no_fallback_radius\n", - "i_kronFlux_flag_no_minimum_radius\n", - "i_kronFlux_flag_small_radius\n", - "i_kronFlux_flag_used_minimum_radius\n", - "i_kronFlux_flag_used_psf_radius\n", - "i_kronFluxErr\n", - "i_psfFlux\n", - "i_psfFlux_area\n", - "i_psfFlux_flag\n", - "i_psfFlux_flag_apCorr\n", - "i_psfFlux_flag_edge\n", - "i_psfFlux_flag_noGoodPixels\n", - "i_psfFluxErr\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "search_string = 'Flux'\n", "band = 'i_'\n", @@ -1662,230 +569,20 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "2f52232f-8e56-4118-8454-66593a552ddc", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:27:18.175203Z", - "iopub.status.busy": "2024-12-16T19:27:18.174745Z", - "iopub.status.idle": "2024-12-16T19:27:18.268087Z", - "shell.execute_reply": "2024-12-16T19:27:18.267505Z", - "shell.execute_reply.started": "2024-12-16T19:27:18.175178Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "<div><i>Table length=14850</i>\n", - "<table id=\"table133286381979664\" class=\"table-striped table-bordered table-condensed\">\n", - "<thead><tr><th>id_truth_type</th><th>match_objectId</th><th>ra</th><th>dec</th><th>truth_type</th><th>flux_i</th><th>coord_ra</th><th>coord_dec</th><th>i_kronFlux</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th></tr></thead>\n", - "<thead><tr><th></th><th></th><th>deg</th><th>deg</th><th></th><th>nJy</th><th>deg</th><th>deg</th><th>nJy</th><th></th><th></th><th>nJy</th></tr></thead>\n", - "<thead><tr><th>str18</th><th>int64</th><th>float64</th><th>float64</th><th>int64</th><th>float32</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th></tr></thead>\n", - "<tr><td>7945422126_1</td><td>1651220174314970042</td><td>62.0098537</td><td>-37.0901136</td><td>1</td><td>80.1357</td><td>62.0097847</td><td>-37.0901294</td><td>165.209455</td><td>3.96143</td><td>False</td><td>144.8895812</td></tr>\n", - "<tr><td>7945243448_1</td><td>1651220174314969053</td><td>62.0123662</td><td>-37.0958262</td><td>1</td><td>29.3619</td><td>62.0122497</td><td>-37.095827</td><td>26.3455006</td><td>3.35127</td><td>False</td><td>26.4549883</td></tr>\n", - "<tr><td>7943980583_1</td><td>1651220174314973031</td><td>62.0804319</td><td>-37.0599329</td><td>1</td><td>85.0716</td><td>62.0804585</td><td>-37.0599007</td><td>162.519251</td><td>5.77871</td><td>False</td><td>94.6220978</td></tr>\n", - "<tr><td>7945989161_1</td><td>1651220174314971178</td><td>62.0564371</td><td>-37.0798811</td><td>1</td><td>19.3238</td><td>62.0564774</td><td>-37.0798535</td><td>302.4945923</td><td>6.34324</td><td>False</td><td>26.7677409</td></tr>\n", - "<tr><td>7943914894_1</td><td>1651220174314972468</td><td>62.0265776</td><td>-37.0665263</td><td>1</td><td>97.0441</td><td>62.0265816</td><td>-37.0666442</td><td>88.0578177</td><td>2.17656</td><td>False</td><td>92.9627681</td></tr>\n", - "<tr><td>7945857828_1</td><td>1651220174314944411</td><td>62.0235745</td><td>-37.09605</td><td>1</td><td>17.5286</td><td>62.0237049</td><td>-37.0960033</td><td>894.5515387</td><td>7.43073</td><td>True</td><td>46.6692541</td></tr>\n", - "<tr><td>7952673851_1</td><td>1651220174314942424</td><td>62.0192451</td><td>-37.0681484</td><td>1</td><td>21.9923</td><td>62.0192534</td><td>-37.0680369</td><td>235.4698083</td><td>6.75986</td><td>True</td><td>16.5300362</td></tr>\n", - "<tr><td>7944426799_1</td><td>1651220174314944029</td><td>62.0598167</td><td>-37.078065</td><td>1</td><td>71.2611</td><td>62.0596735</td><td>-37.0780034</td><td>--</td><td>--</td><td>True</td><td>51.5588324</td></tr>\n", - "<tr><td>7950583914_1</td><td>1651220174314971134</td><td>62.0263471</td><td>-37.0806093</td><td>1</td><td>225.01</td><td>62.0264767</td><td>-37.080598</td><td>154.3405117</td><td>3.28615</td><td>False</td><td>150.5482851</td></tr>\n", - "<tr><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n", - "<tr><td>7941947856_1</td><td>1651220174314938116</td><td>62.0738491</td><td>-37.0527351</td><td>1</td><td>101.294</td><td>62.0738721</td><td>-37.0527186</td><td>582.997383</td><td>10.4693</td><td>True</td><td>126.1897222</td></tr>\n", - "<tr><td>7940592997_1</td><td>1651220174314938114</td><td>62.002132</td><td>-37.0526555</td><td>1</td><td>206.925</td><td>62.0021215</td><td>-37.0526411</td><td>436.3974334</td><td>6.11094</td><td>False</td><td>174.7833985</td></tr>\n", - "<tr><td>7941544592_1</td><td>1651220174314938119</td><td>62.077169</td><td>-37.0524956</td><td>1</td><td>269.445</td><td>62.0771789</td><td>-37.0525201</td><td>331.2637501</td><td>2.76985</td><td>False</td><td>302.0123595</td></tr>\n", - "<tr><td>7939674321_1</td><td>1651281746966117442</td><td>62.0134859</td><td>-36.9668543</td><td>1</td><td>247.05</td><td>62.0135091</td><td>-36.966804</td><td>246.8713545</td><td>3.19171</td><td>False</td><td>243.6787974</td></tr>\n", - "<tr><td>7939694560_1</td><td>1651281746966118922</td><td>62.0979825</td><td>-36.9472682</td><td>1</td><td>106.092</td><td>62.0978588</td><td>-36.9472224</td><td>244.5113481</td><td>2.96379</td><td>False</td><td>244.874761</td></tr>\n", - "<tr><td>7939674319_1</td><td>1651281746966116931</td><td>62.015545</td><td>-36.9700529</td><td>1</td><td>99.9993</td><td>62.0155967</td><td>-36.9699778</td><td>113.0465834</td><td>2.5054</td><td>False</td><td>118.1390177</td></tr>\n", - "<tr><td>7939674328_1</td><td>1651281746966117956</td><td>62.0059488</td><td>-36.9589215</td><td>1</td><td>104.76</td><td>62.0059801</td><td>-36.9588153</td><td>544.2527922</td><td>9.1372</td><td>False</td><td>228.9871482</td></tr>\n", - "<tr><td>7939699200_1</td><td>1651281746966119021</td><td>62.0115523</td><td>-36.9472928</td><td>1</td><td>156.38</td><td>62.011636</td><td>-36.9472674</td><td>10.962813</td><td>2.81807</td><td>False</td><td>11.0785882</td></tr>\n", - "<tr><td>7939698330_1</td><td>1651220174314939597</td><td>62.0242245</td><td>-37.0181435</td><td>1</td><td>87.0308</td><td>62.0243168</td><td>-37.0180876</td><td>477.8553625</td><td>6.65687</td><td>False</td><td>213.6284599</td></tr>\n", - "</table></div>" - ], - "text/plain": [ - "<Table length=14850>\n", - "id_truth_type match_objectId ra ... i_kronFlux_flag i_cModelFlux\n", - " deg ... nJy \n", - " str18 int64 float64 ... bool float64 \n", - "------------- ------------------- ---------- ... --------------- ------------\n", - " 7945422126_1 1651220174314970042 62.0098537 ... False 144.8895812\n", - " 7945243448_1 1651220174314969053 62.0123662 ... False 26.4549883\n", - " 7943980583_1 1651220174314973031 62.0804319 ... False 94.6220978\n", - " 7945989161_1 1651220174314971178 62.0564371 ... False 26.7677409\n", - " 7943914894_1 1651220174314972468 62.0265776 ... False 92.9627681\n", - " 7945857828_1 1651220174314944411 62.0235745 ... True 46.6692541\n", - " 7952673851_1 1651220174314942424 62.0192451 ... True 16.5300362\n", - " 7944426799_1 1651220174314944029 62.0598167 ... True 51.5588324\n", - " 7950583914_1 1651220174314971134 62.0263471 ... False 150.5482851\n", - " ... ... ... ... ... ...\n", - " 7941947856_1 1651220174314938116 62.0738491 ... True 126.1897222\n", - " 7940592997_1 1651220174314938114 62.002132 ... False 174.7833985\n", - " 7941544592_1 1651220174314938119 62.077169 ... False 302.0123595\n", - " 7939674321_1 1651281746966117442 62.0134859 ... False 243.6787974\n", - " 7939694560_1 1651281746966118922 62.0979825 ... False 244.874761\n", - " 7939674319_1 1651281746966116931 62.015545 ... False 118.1390177\n", - " 7939674328_1 1651281746966117956 62.0059488 ... False 228.9871482\n", - " 7939699200_1 1651281746966119021 62.0115523 ... False 11.0785882\n", - " 7939698330_1 1651220174314939597 62.0242245 ... False 213.6284599" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, + "outputs": [], "source": [ "tab" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:27:18.268752Z", - "iopub.status.busy": "2024-12-16T19:27:18.268603Z", - "iopub.status.idle": "2024-12-16T19:27:18.675021Z", - "shell.execute_reply": "2024-12-16T19:27:18.674484Z", - "shell.execute_reply.started": "2024-12-16T19:27:18.268738Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_9284/2103441182.py:6: RuntimeWarning: divide by zero encountered in log10\n", - " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "/tmp/ipykernel_9284/2103441182.py:6: RuntimeWarning: invalid value encountered in log10\n", - " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "/tmp/ipykernel_9284/2103441182.py:7: RuntimeWarning: divide by zero encountered in log10\n", - " kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "/tmp/ipykernel_9284/2103441182.py:7: RuntimeWarning: invalid value encountered in log10\n", - " kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 2 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 3:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 4:80: E501 line too long (84 > 79 characters)</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 9:23: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 12:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 14:17: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 14:32: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "metadata": {}, + "outputs": [], "source": [ "# compare kron mag to cmodel mag\n", "\n", @@ -1911,104 +608,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-16T19:27:18.675850Z", - "iopub.status.busy": "2024-12-16T19:27:18.675684Z", - "iopub.status.idle": "2024-12-16T19:27:19.257839Z", - "shell.execute_reply": "2024-12-16T19:27:19.256931Z", - "shell.execute_reply.started": "2024-12-16T19:27:18.675835Z" - } - }, - "outputs": [ - { - "ename": "KeyError", - "evalue": "'i_gaapOptimalFlux'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[19], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m cmodel_mag \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2.50\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mlog10(\u001b[43mtab\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mi_gaapOptimalFlux\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m31.4\u001b[39m\n\u001b[1;32m 2\u001b[0m kron_mag \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2.50\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mlog10(tab[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mi_kronFlux\u001b[39m\u001b[38;5;124m'\u001b[39m]) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m31.4\u001b[39m\n\u001b[1;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mscatter(cmodel_mag,kron_mag,\n\u001b[1;32m 5\u001b[0m c\u001b[38;5;241m=\u001b[39mtab[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mi_kronRad\u001b[39m\u001b[38;5;124m'\u001b[39m], marker\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m'\u001b[39m, alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.5\u001b[39m, vmin\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, vmax\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m50\u001b[39m)\n", - "File \u001b[0;32m/opt/lsst/software/stack/conda/envs/lsst-scipipe-9.0.0/lib/python3.11/site-packages/astropy/table/table.py:2093\u001b[0m, in \u001b[0;36mTable.__getitem__\u001b[0;34m(self, item)\u001b[0m\n\u001b[1;32m 2091\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m, item):\n\u001b[1;32m 2092\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(item, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m-> 2093\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[43m[\u001b[49m\u001b[43mitem\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 2094\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(item, (\u001b[38;5;28mint\u001b[39m, np\u001b[38;5;241m.\u001b[39minteger)):\n\u001b[1;32m 2095\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mRow(\u001b[38;5;28mself\u001b[39m, item)\n", - "File \u001b[0;32m/opt/lsst/software/stack/conda/envs/lsst-scipipe-9.0.0/lib/python3.11/site-packages/astropy/table/table.py:267\u001b[0m, in \u001b[0;36mTableColumns.__getitem__\u001b[0;34m(self, item)\u001b[0m\n\u001b[1;32m 256\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Get items from a TableColumns object.\u001b[39;00m\n\u001b[1;32m 257\u001b[0m \n\u001b[1;32m 258\u001b[0m \u001b[38;5;124;03m::\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 264\u001b[0m \u001b[38;5;124;03m tc[1:3] # <TableColumns names=('b', 'c')>\u001b[39;00m\n\u001b[1;32m 265\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(item, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m--> 267\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mOrderedDict\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__getitem__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mitem\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(item, (\u001b[38;5;28mint\u001b[39m, np\u001b[38;5;241m.\u001b[39minteger)):\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvalues())[item]\n", - "\u001b[0;31mKeyError\u001b[0m: 'i_gaapOptimalFlux'" - ] - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 5:23: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 8:1: E265 block comment should start with '# '</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 10:17: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<pre style=\"margin: 0.1em;\n", - "padding-left: 0.25em;\n", - "border-left-style: solid;\n", - "font-family: var(--jp-code-font-family);\n", - "font-size: var(--jp-code-font-size);\n", - "line-height: var(--jp-code-line-height);\n", - "\"><span style=\"color: var(--jp-warn-color2)\">pycodestyle</span> <span style=\"color: var(--jp-info-color0)\">INFO</span>: 10:32: E231 missing whitespace after ','</pre>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "metadata": {}, + "outputs": [], "source": [ "\n", "cmodel_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", @@ -2032,14 +635,7 @@ "cell_type": "code", "execution_count": null, "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", - "metadata": { - "execution": { - "iopub.status.busy": "2024-12-16T19:27:19.258345Z", - "iopub.status.idle": "2024-12-16T19:27:19.258568Z", - "shell.execute_reply": "2024-12-16T19:27:19.258479Z", - "shell.execute_reply.started": "2024-12-16T19:27:19.258470Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -2064,14 +660,7 @@ "cell_type": "code", "execution_count": null, "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", - "metadata": { - "execution": { - "iopub.status.busy": "2024-12-16T19:27:19.259095Z", - "iopub.status.idle": "2024-12-16T19:27:19.259261Z", - "shell.execute_reply": "2024-12-16T19:27:19.259190Z", - "shell.execute_reply.started": "2024-12-16T19:27:19.259183Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -2108,14 +697,7 @@ "cell_type": "code", "execution_count": null, "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", - "metadata": { - "execution": { - "iopub.status.busy": "2024-12-16T19:27:19.259716Z", - "iopub.status.idle": "2024-12-16T19:27:19.259898Z", - "shell.execute_reply": "2024-12-16T19:27:19.259829Z", - "shell.execute_reply.started": "2024-12-16T19:27:19.259822Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_gaapOptimalFlux'][whbright],\n", @@ -2132,14 +714,7 @@ "cell_type": "code", "execution_count": null, "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", - "metadata": { - "execution": { - "iopub.status.busy": "2024-12-16T19:27:19.260772Z", - "iopub.status.idle": "2024-12-16T19:27:19.260944Z", - "shell.execute_reply": "2024-12-16T19:27:19.260866Z", - "shell.execute_reply.started": "2024-12-16T19:27:19.260859Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", From dbadecb57d767ed53e9b07cd99f983e630dae836 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 16 Dec 2024 22:52:48 +0000 Subject: [PATCH 16/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 41 ++++++++++++++++++++++++++++----- 1 file changed, 35 insertions(+), 6 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 751857d..69e511b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -507,6 +507,8 @@ "outputs": [], "source": [ "# this is where you are working here:\n", + "from scipy import stats#.binned_statistic\n", + "from scipy.stats import sigmaclip\n", "\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", @@ -515,20 +517,47 @@ "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", "fig, ax = plt.subplots()\n", "\n", - "scale = 0\n", + "scale = 1\n", "\n", "ax.axhline(scale,linestyle='--')\n", "\n", - "ax.plot(truth_mag, scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1,label='cModel')\n", - "ax.plot(truth_mag, scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1,label='Kron')\n", - "ax.plot(truth_mag, scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1, label='gaapOptimal')\n", + "ax.plot(truth_mag, scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1,label='cModel',color='r')\n", + "ax.plot(truth_mag, scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(truth_mag, scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1, label='gaapOptimal',color='green')\n", + "\n", + "\n", + "x = truth_mag\n", + "y = scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i']\n", + "bins=np.arange(16,30,1)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "\n", + "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "\n", + "y = scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i']\n", + "\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "\n", + "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "\n", + "y = scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i']\n", + "\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "\n", + "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", "\n", "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Flux Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", - "ax.set_ylim([-5,5])\n", - "#ax.set_yscale('log')\n", + "#ax.set_ylim([-5,5])\n", + "ax.set_ylim([.5,5])\n", + "ax.set_yscale('log')\n", "plt.legend()\n", "#plt.ylim(15,20)\n", "#x = np.arange(14,30,.1)\n", From cf33b0fb33fdbedef348bd0df884677e67cd329e Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 17 Dec 2024 01:51:13 +0000 Subject: [PATCH 17/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 66 +++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 69e511b..384158a 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -567,6 +567,72 @@ "#plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "8bbb1505-5e91-49d2-b94e-045ff9f482e2", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", + "\n", + "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", + "fig, ax = plt.subplots()\n", + "\n", + "scale = 1\n", + "\n", + "ax.axhline(scale,linestyle='--')\n", + "\n", + "ax.plot(truth_mag, (cmodel_mag-truth_mag)/truth_mag,'.',alpha=.1,label='cModel',color='r')\n", + "ax.plot(truth_mag, (kron_mag-truth_mag)/truth_mag,'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(truth_mag, (cmodel_mag-truth_mag)/truth_mag,'.',alpha=.1, label='gaapOptimal',color='green')\n", + "\n", + "\n", + "x = truth_mag\n", + "y = scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i']\n", + "bins=np.arange(16,30,1)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "\n", + "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "\n", + "y = scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i']\n", + "\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "\n", + "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "\n", + "y = scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i']\n", + "\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "\n", + "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", + "\n", + "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", + "\n", + "ax.set_xlabel('True i-band Magnitude')\n", + "ax.set_ylabel('Flux Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", + "#ax.set_ylim([-5,5])\n", + "ax.set_ylim([.5,5])\n", + "ax.set_yscale('log')\n", + "plt.legend()\n", + "#plt.ylim(15,20)\n", + "#x = np.arange(14,30,.1)\n", + "#plt.plot(x,x,linestyle='--')\n", + "#plt.axhline(1,linestyle='--')\n", + "\n", + "#plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, From 17055f2ae0f7138aa46e9d8c46a442e41dff2f11 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 17 Dec 2024 17:56:37 +0000 Subject: [PATCH 18/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 125 +++++++++++++++----------------- 1 file changed, 57 insertions(+), 68 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 384158a..5b75f2e 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -276,7 +276,10 @@ "from lsst.afw.image import MultibandExposure\n", "from lsst.daf.butler import Butler\n", "from lsst.rsp import get_tap_service\n", - "import lsst.geom as geom" + "import lsst.geom as geom\n", + "\n", + "from scipy import stats#.binned_statistic\n", + "from scipy.stats import sigmaclip\n" ] }, { @@ -400,62 +403,6 @@ " dec_corners.append(radec.getDec().asDegrees())" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "decab323-5735-4e6a-af11-cabb3cc7bdc3", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT objectId, coord_ra, coord_dec, x, y, tract, patch, \" + \\\n", - " \"i_ap09Flux, i_ap12Flux, i_ap17Flux, i_ap25Flux, i_ap35Flux, \" + \\\n", - " \"i_cModelFlux, i_free_cModelFlux, \" + \\\n", - " \"i_gaap3p0Flux, i_gaap1p5Flux, i_gaapOptimalFlux, \" + \\\n", - " \"i_kronFlux, i_kronRad, i_kronFlux_flag, \" + \\\n", - " \"detect_fromBlend \" + \\\n", - " \"FROM dp02_dc2_catalogs.Object \" + \\\n", - " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), \" + \\\n", - " \"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" + \\\n", - " str(ra_corners[1]) + \", \" + str(dec_corners[1]) + \", \" + \\\n", - " str(ra_corners[2]) + \", \" + str(dec_corners[2]) + \", \" + \\\n", - " str(ra_corners[3]) + \", \" + str(dec_corners[3]) + \")) = 1 AND \" + \\\n", - " \"detect_isPrimary = 1 AND \" + \\\n", - " \"tract = \" + str(dataId['tract']) + \" AND patch = \" + str(dataId['patch'])\n", - "print(query)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8b1fb7e3-b2f3-49d5-8991-aaa0a39d2b83", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, \"\\\n", - " \"obj.coord_ra, obj.coord_dec \"\\\n", - " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, \" + \\\n", - " \"obj.i_cModelFlux, obj.i_free_cModelFlux, \" + \\\n", - " \"obj.i_gaap3p0Flux, obj.i_gaap1p5Flux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.detect_fromBlend \" + \\\n", - " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", - " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", - " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1\"\n", - "\n", - "\n", - "#\"POLYGON('ICRS', \" + str(ra_corners[0]) + \", \" + str(dec_corners[0]) + \", \" + \\\n", - "# str(ra_corners[1]) + \", \" + str(dec_corners[1]) + \", \" + \\\n", - "# str(ra_corners[2]) + \", \" + str(dec_corners[2]) + \", \" + \\\n", - "# str(ra_corners[3]) + \", \" + str(dec_corners[3]) + \")) = 1\" \n", - " #, CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\" \n", - "# AND \" + \\\n", - " #\"obj.detect_isPrimary = 1 AND \" + \\\n", - " #\"obj.tract = \" + str(dataId['tract']) + \" AND obj.patch = \" + str(dataId['patch'])\n", - "\n", - "#CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\n", - "print(query)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -464,7 +411,7 @@ "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, \"\\\n", - " \"obj.coord_ra, obj.coord_dec, \"\\\n", + " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, \"\\\n", " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", @@ -507,8 +454,6 @@ "outputs": [], "source": [ "# this is where you are working here:\n", - "from scipy import stats#.binned_statistic\n", - "from scipy.stats import sigmaclip\n", "\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", @@ -583,17 +528,17 @@ "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", "fig, ax = plt.subplots()\n", "\n", - "scale = 1\n", + "scale = 0\n", "\n", "ax.axhline(scale,linestyle='--')\n", "\n", "ax.plot(truth_mag, (cmodel_mag-truth_mag)/truth_mag,'.',alpha=.1,label='cModel',color='r')\n", "ax.plot(truth_mag, (kron_mag-truth_mag)/truth_mag,'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag, (cmodel_mag-truth_mag)/truth_mag,'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax.plot(truth_mag, (gaap_mag-truth_mag)/truth_mag,'.',alpha=.1, label='gaapOptimal',color='green')\n", "\n", "\n", "x = truth_mag\n", - "y = scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i']\n", + "y = (cmodel_mag-truth_mag)/truth_mag\n", "bins=np.arange(16,30,1)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", @@ -601,7 +546,7 @@ "\n", "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "\n", - "y = scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i']\n", + "y = (kron_mag-truth_mag)/truth_mag\n", "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", @@ -609,7 +554,7 @@ "\n", "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", - "y = scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i']\n", + "y = (gaap_mag-truth_mag)/truth_mag\n", "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", @@ -620,10 +565,10 @@ "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Flux Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", + "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", "#ax.set_ylim([-5,5])\n", - "ax.set_ylim([.5,5])\n", - "ax.set_yscale('log')\n", + "ax.set_ylim([-.2,.2])\n", + "#ax.set_yscale('log')\n", "plt.legend()\n", "#plt.ylim(15,20)\n", "#x = np.arange(14,30,.1)\n", @@ -633,6 +578,50 @@ "#plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f5073a8-7c3d-4361-92b7-e1fa05c5dcde", + "metadata": {}, + "outputs": [], + "source": [ + "#\n", + "#fig, ax = plt.subplots()\n", + "fig,(ax, ax2) = plt.subplots(1, 2)\n", + "#whblend = np.where( tab['detect_fromBlend'][whbright] == True)[0]\n", + "\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0)& (tab['detect_fromBlend'] == 1) )[0]\n", + "\n", + "ax.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "\n", + "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=tab['i_kronRad'][whgood], marker='.', alpha=.5,vmin=0,vmax=20)\n", + "\n", + "\n", + "ax.set_xlabel('truth AB Magnitude [i-band]')\n", + "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "ax.set_ylim([-.2,.2])\n", + "\n", + "\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0)& (tab['detect_isIsolated'] == 1) )[0]\n", + "\n", + "ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "\n", + "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=tab['i_kronRad'][whgood], marker='.', alpha=.5,vmin=0,vmax=20)\n", + "\n", + "#ax2.colorbar(label='Kron Radius [pixels]')\n", + "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", + "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "ax2.set_ylim([-.2,.2])\n", + "\n", + "#fig.colorbar(label='Kron Radius [pixels]')\n", + "fig.subplots_adjust(right=0.8)\n", + "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", + "fig.colorbar(im, cax=cbar_ax,label='Kron Radius [pixels]')\n", + "\n", + "#figim, ax=axes.ravel().tolist()\n", + "plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, From db5daf618f1281a94ec136b8761f3514679351b9 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 17 Dec 2024 19:09:18 +0000 Subject: [PATCH 19/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 124 +++++++++----------------------- 1 file changed, 34 insertions(+), 90 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 5b75f2e..41c3a3a 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -343,25 +343,22 @@ "outputs": [], "source": [ "butler = Butler('dp02', collections='2.2i/runs/DP0.2')\n", - "\n", - "dataId = {'tract': 4431, 'patch': 17, 'band': 'i'}\n", - "datasetType = 'deepCoadd'\n", - "coadd = butler.get(datasetType, **dataId)" + "\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "a59e517d-e7e9-4371-9904-174fc6bf1f4f", + "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", "metadata": {}, "outputs": [], "source": [ - "#fig, ax = plt.subplots()\n", - "#display = afwDisplay.Display(frame=fig)\n", - "#display.scale('asinh', 'zscale')\n", - "#display.mtv(coadd.image)\n", - "#plt.show()\n", - "#remove_figure(fig)" + "query = \"SELECT column_name, datatype, description, unit \" \\\n", + " \"FROM tap_schema.columns \" \\\n", + " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", + "\n", + "results = service.search(query).to_table()\n", + "results" ] }, { @@ -370,10 +367,7 @@ "id": "914e6572-fcac-415a-a4de-fb526d198483", "metadata": {}, "outputs": [], - "source": [ - "skymap = butler.get('skyMap')\n", - "dataId = {'skymap': skymap, 'tract': 4431, 'patch': 17}\n" - ] + "source": [] }, { "cell_type": "code", @@ -381,26 +375,20 @@ "id": "7006a12e-5631-4b55-9eba-6f5fd7f73bac", "metadata": {}, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", + "metadata": {}, + "outputs": [], "source": [ - "cutout_image = coadd\n", - "\n", - "wcs = cutout_image.getWcs()\n", - "\n", - "x0 = float(cutout_image.getX0())\n", - "y0 = float(cutout_image.getY0())\n", - "width = cutout_image.getWidth()\n", - "height = cutout_image.getHeight()\n", - "\n", - "xcorners = [x0, x0+width, x0+width, x0]\n", - "ycorners = [y0, y0, y0+width, y0+width]\n", - "\n", - "ra_corners = []\n", - "dec_corners = []\n", - "\n", - "for i in range(len(xcorners)):\n", - " radec = wcs.pixelToSky(xcorners[i], ycorners[i])\n", - " ra_corners.append(radec.getRa().asDegrees())\n", - " dec_corners.append(radec.getDec().asDegrees())" + "search_string = 'Flux'\n", + "band = 'i_'\n", + "for cname in results['column_name']:\n", + " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", + " print(cname)" ] }, { @@ -411,7 +399,7 @@ "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, \"\\\n", - " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, \"\\\n", + " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", @@ -477,39 +465,28 @@ "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "\n", "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "\n", "y = scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i']\n", - "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "\n", "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", "y = scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i']\n", - "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "\n", "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", "\n", "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Flux Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", - "#ax.set_ylim([-5,5])\n", + "\n", "ax.set_ylim([.5,5])\n", "ax.set_yscale('log')\n", - "plt.legend()\n", - "#plt.ylim(15,20)\n", - "#x = np.arange(14,30,.1)\n", - "#plt.plot(x,x,linestyle='--')\n", - "#plt.axhline(1,linestyle='--')\n", - "\n", - "#plt.show()" + "plt.legend()\n" ] }, { @@ -543,23 +520,18 @@ "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "\n", "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "\n", "y = (kron_mag-truth_mag)/truth_mag\n", - "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "\n", "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", "y = (gaap_mag-truth_mag)/truth_mag\n", - "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "\n", "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", "\n", "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", @@ -586,15 +558,18 @@ "outputs": [], "source": [ "#\n", - "#fig, ax = plt.subplots()\n", "fig,(ax, ax2) = plt.subplots(1, 2)\n", "#whblend = np.where( tab['detect_fromBlend'][whbright] == True)[0]\n", "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0)& (tab['detect_fromBlend'] == 1) )[0]\n", "\n", + "#cmap = tab['i_blendedness'][whgood] only saw things blended with 1 neighbor is this acutally boolean?\n", + "\n", + "cmap = tab['i_kronRad'][whgood]\n", + "\n", "ax.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", "\n", - "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=tab['i_kronRad'][whgood], marker='.', alpha=.5,vmin=0,vmax=20)\n", + "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=2)\n", "\n", "\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", @@ -603,54 +578,23 @@ "\n", "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0)& (tab['detect_isIsolated'] == 1) )[0]\n", + "cmap = tab['i_blendedness'][whgood] #tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] #\n", "\n", - "ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", "\n", - "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=tab['i_kronRad'][whgood], marker='.', alpha=.5,vmin=0,vmax=20)\n", - "\n", - "#ax2.colorbar(label='Kron Radius [pixels]')\n", + "ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=20)\n", "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", "ax2.set_ylim([-.2,.2])\n", "\n", - "#fig.colorbar(label='Kron Radius [pixels]')\n", + "\n", "fig.subplots_adjust(right=0.8)\n", "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", "fig.colorbar(im, cax=cbar_ax,label='Kron Radius [pixels]')\n", "\n", - "#figim, ax=axes.ravel().tolist()\n", "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT column_name, datatype, description, unit \" \\\n", - " \"FROM tap_schema.columns \" \\\n", - " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", - "\n", - "results = service.search(query).to_table()\n", - "results" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", - "metadata": {}, - "outputs": [], - "source": [ - "search_string = 'Flux'\n", - "band = 'i_'\n", - "for cname in results['column_name']:\n", - " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", - " print(cname)" - ] - }, { "cell_type": "code", "execution_count": null, From 1f52ef2e9439ab67c9c5d641b9b5284918a65a21 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 17 Dec 2024 21:22:17 +0000 Subject: [PATCH 20/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 96 ++++++++++++++++++++++++++++----- 1 file changed, 82 insertions(+), 14 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 41c3a3a..97ea3b8 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -399,7 +399,7 @@ "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, \"\\\n", - " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, \"\\\n", + " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", @@ -550,6 +550,24 @@ "#plt.show()" ] }, + { + "cell_type": "markdown", + "id": "8a3c30b3-721e-4cbc-abfd-8d4c9b216de8", + "metadata": {}, + "source": [ + "Below, compare the Kron magnitudes to truth under various circumstances. 2 basic paramters are set: extendedness = 1 means its a galaxy. Kronflag = 0 means there were no problems flagged in the flux measurement. \n", + "\n", + "Then we test whether blending impacts the photometry:\n", + "\n", + "1) detect_fromBlend = 1 means some deblending happened prior to flux measurement. this is responsible for some under-estimated magnitude (over-estimated flux) perhaps because neighbors were not removed at the bright end?\n", + "\n", + "2) The increased scatter at faint mags is due to increased fraction of flux contaminated by neighbors i_blendedness: (1 - child_flux/parent_flux)\n", + " \n", + "3) detect_isIsolated = 1 means no deblending and the galaxy has no blended neighbors. The upturn at bright mags is not there among isolated galaxies\n", + "\n", + "4) Not sure i understand the tail to negative flux difference (i.e. underestimated flux) at bright mags" + ] + }, { "cell_type": "code", "execution_count": null, @@ -559,17 +577,21 @@ "source": [ "#\n", "fig,(ax, ax2) = plt.subplots(1, 2)\n", - "#whblend = np.where( tab['detect_fromBlend'][whbright] == True)[0]\n", + "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", "\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0)& (tab['detect_fromBlend'] == 1) )[0]\n", + "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", "\n", - "#cmap = tab['i_blendedness'][whgood] only saw things blended with 1 neighbor is this acutally boolean?\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & ( tab['detect_fromBlend'] == 1))[0] #(tab['detect_fromBlend'] == 0) )[0]\n", "\n", - "cmap = tab['i_kronRad'][whgood]\n", + "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", + "vmax = 1\n", + "colmaplabel='Fraction of flux contaminated by neighbors'\n", + "#cmap = tab['i_kronRad'][whgood]\n", + "#vmax = 20\n", + "#colmaplabel='Kron Radius [pixels]'\n", "\n", "ax.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "\n", - "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=2)\n", + "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", "\n", "\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", @@ -577,12 +599,12 @@ "ax.set_ylim([-.2,.2])\n", "\n", "\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0)& (tab['detect_isIsolated'] == 1) )[0]\n", - "cmap = tab['i_blendedness'][whgood] #tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] #\n", - "\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", + "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", + "cmap = tab['i_blendedness'][whgood]\n", "\n", "ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=20)\n", + "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", "ax2.set_ylim([-.2,.2])\n", @@ -590,7 +612,7 @@ "\n", "fig.subplots_adjust(right=0.8)\n", "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", - "fig.colorbar(im, cax=cbar_ax,label='Kron Radius [pixels]')\n", + "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n", "\n", "plt.show()" ] @@ -598,13 +620,59 @@ { "cell_type": "code", "execution_count": null, - "id": "2f52232f-8e56-4118-8454-66593a552ddc", + "id": "94c2ecc1-5760-4872-b01d-e6d48b145201", "metadata": {}, "outputs": [], "source": [ - "tab" + "# now do the outlier fraction. histogram up the delta_M / M > 0.1 as function of magnitude for the 3\n", + "\n", + "x = truth_mag\n", + "y = (cmodel_mag-truth_mag)/truth_mag\n", + "bins=np.arange(16,30,1)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic=lambda sigmaz: float(len(np.where(y > 0.01)[0]))/len(y) ,bins=bins)\n", + "\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "#plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "plt.hist(bins[:-1],bins,weights=bin_means,color='r',alpha=.5,edgecolor='black', linewidth=1.2)\n", + "\n", + "y = (kron_mag-truth_mag)/truth_mag\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic=lambda sigmaz: float(len(np.where(y > 0.01)[0]))/len(y) ,bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "#plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "#plt.hist(bins[:-1],bins,weights=bin_means,color='b',alpha=.5,edgecolor='black', linewidth=1.2)\n", + "\n", + "y = (gaap_mag-truth_mag)/truth_mag\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic=lambda sigmaz: float(len(np.where(y > 0.01)[0]))/len(y) ,bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "#plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", + "#plt.hist(bins[:-1],bins,weights=bin_means,color='g',alpha=.5,edgecolor='black', linewidth=1.2)\n", + "\n", + "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", + "\n", + "#plt.set_xlabel('True i-band Magnitude')\n", + "#plt.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "#ax.set_ylim([-5,5])\n", + "#plt.ylim([0,1000])\n", + "#ax.set_yscale('log')\n", + "plt.legend()\n", + "\n", + "\n", + "#bin_means, bin_edges, binnumber = stats.binned_statistic(F150mag,sigmaz, statistic=lambda sigmaz: float(len(np.where(sigmaz > 0.15)[0]))/len(sigmaz) ,bins=bins)\n", + "\n", + "print(bin_means)\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f52232f-8e56-4118-8454-66593a552ddc", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, From 6f0e4532eaf5709c0456c7489c472ae2bdc279a6 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 17 Dec 2024 22:56:36 +0000 Subject: [PATCH 21/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 135 +++++++++++++++++++++++++------- 1 file changed, 105 insertions(+), 30 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 97ea3b8..0704126 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -324,15 +324,15 @@ "tags": [] }, "source": [ - "## 2. Section heading\n", + "## 2. Photometry measurements from the LSST pipeline\n", "\n", "_Use numbers for sections, sub-sections, and sub-sub-sections to enable referencing, e.g., \"I'm having trouble with the second code cell in Section 2.3.\"_\n", "\n", "_Use section titles that actively describe what is being done, e.g., \"Create a color-magnitude diagram\" instead of \"Plot\", so that the auto-generated table of contents is easy to navigate._\n", "\n", - "### 2.1 Section sub-heading\n", + "### 2.1 Object table photometry measurements\n", "\n", - "#### 2.1.1 Section sub-sub-heading" + "First see what is available in the object catalog." ] }, { @@ -362,20 +362,12 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "914e6572-fcac-415a-a4de-fb526d198483", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7006a12e-5631-4b55-9eba-6f5fd7f73bac", + "cell_type": "markdown", + "id": "586716d7-7f95-4ad2-8c3a-88c9052a32fa", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "Below are all the parameters available related to \"Flux\" measured in the i-band " + ] }, { "cell_type": "code", @@ -391,6 +383,18 @@ " print(cname)" ] }, + { + "cell_type": "markdown", + "id": "ff2fc2b3-fb3b-4d92-a325-ace4dfa059dc", + "metadata": {}, + "source": [ + "# 3. Compare simulated photometry measured with the LSST pipelines to their input values\n", + "\n", + "Here use the truth tables to get a sense of how good the various photometry measurement methods are, and in what regimes they perform well vs poorly.\n", + "\n", + "Grab the truth values for i-band mag, measured i-band mag values from the catalog, and a number of flags that may help understand whats going on" + ] + }, { "cell_type": "code", "execution_count": null, @@ -404,7 +408,7 @@ " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\n", + " \"WHERE (obj.detect_isPrimary = 1) AND CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\n", "print(query)" ] }, @@ -434,6 +438,16 @@ "tab" ] }, + { + "cell_type": "markdown", + "id": "1d22c355-0953-46e7-8e40-6614f088c607", + "metadata": {}, + "source": [ + "## 2.2 Exploring the input vs output photometry\n", + "\n", + "Explore 3 measurements relevant for galaxies: cModel, Kron and GaaP" + ] + }, { "cell_type": "code", "execution_count": null, @@ -509,9 +523,9 @@ "\n", "ax.axhline(scale,linestyle='--')\n", "\n", - "ax.plot(truth_mag, (cmodel_mag-truth_mag)/truth_mag,'.',alpha=.1,label='cModel',color='r')\n", "ax.plot(truth_mag, (kron_mag-truth_mag)/truth_mag,'.',alpha=.1,label='Kron',color='blue')\n", "ax.plot(truth_mag, (gaap_mag-truth_mag)/truth_mag,'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax.plot(truth_mag, (cmodel_mag-truth_mag)/truth_mag,'.',alpha=.1,label='cModel',color='r')\n", "\n", "\n", "x = truth_mag\n", @@ -595,7 +609,7 @@ "\n", "\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", - "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "ax.set_ylabel('Mag Fractional Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", "ax.set_ylim([-.2,.2])\n", "\n", "\n", @@ -617,6 +631,55 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e525f6f-5521-4a67-9abb-b96e4a198043", + "metadata": {}, + "outputs": [], + "source": [ + "#\n", + "fig,(ax, ax2) = plt.subplots(1, 2)\n", + "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", + "\n", + "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", + "\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & ( tab['detect_fromBlend'] == 1))[0] #(tab['detect_fromBlend'] == 0) )[0]\n", + "\n", + "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", + "vmax = 1\n", + "colmaplabel='Fraction of flux contaminated by neighbors'\n", + "#cmap = tab['i_kronRad'][whgood]\n", + "#vmax = 20\n", + "#colmaplabel='Kron Radius [pixels]'\n", + "\n", + "ax.scatter(truth_mag,(cmodel_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "im = ax.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", + "\n", + "\n", + "ax.set_xlabel('truth AB Magnitude [i-band]')\n", + "ax.set_ylabel('Mag Fractional Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "ax.set_ylim([-.2,.2])\n", + "\n", + "\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", + "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", + "cmap = tab['i_blendedness'][whgood]\n", + "\n", + "ax2.scatter(truth_mag,(cmodel_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "ax2.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", + "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", + "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "ax2.set_ylim([-.2,.2])\n", + "\n", + "\n", + "fig.subplots_adjust(right=0.8)\n", + "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", + "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n", + "\n", + "plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -627,23 +690,23 @@ "# now do the outlier fraction. histogram up the delta_M / M > 0.1 as function of magnitude for the 3\n", "\n", "x = truth_mag\n", - "y = (cmodel_mag-truth_mag)/truth_mag\n", + "y = (cmodel_mag-truth_mag)#/truth_mag\n", "bins=np.arange(16,30,1)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic=lambda sigmaz: float(len(np.where(y > 0.01)[0]))/len(y) ,bins=bins)\n", + " y, statistic=lambda sigmaz: float(len(np.where(np.abs(y) > 0.01)[0]))/len(y) ,bins=bins)\n", "\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "#plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "plt.hist(bins[:-1],bins,weights=bin_means,color='r',alpha=.5,edgecolor='black', linewidth=1.2)\n", + "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "#plt.hist(bins[:-1],bins,weights=bin_means,color='r',alpha=.5,edgecolor='black', linewidth=1.2)\n", "\n", - "y = (kron_mag-truth_mag)/truth_mag\n", + "y = (kron_mag-truth_mag)#/truth_mag\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic=lambda sigmaz: float(len(np.where(y > 0.01)[0]))/len(y) ,bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "#plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "#plt.hist(bins[:-1],bins,weights=bin_means,color='b',alpha=.5,edgecolor='black', linewidth=1.2)\n", "\n", - "y = (gaap_mag-truth_mag)/truth_mag\n", + "y = (gaap_mag-truth_mag)#/truth_mag\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic=lambda sigmaz: float(len(np.where(y > 0.01)[0]))/len(y) ,bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", @@ -832,12 +895,24 @@ "source": [] }, { - "cell_type": "code", - "execution_count": null, - "id": "11263c1d-e9a0-4402-bafd-6595c60faeb6", + "cell_type": "markdown", + "id": "2e364b4b-7cfd-4bfd-af48-8f08e0af2481", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "easier for someone to correct something i've done wrong than to tell me the right way to do it (so, try to write it up and take af irst stab at it and then ask if thats what they were going for). \n", + "\n", + "for DP1: here is literal interpretation of measurement (these should be short)\n", + "\n", + "then one for low-z galaxies and nuances of measuring photometry\n", + "\n", + "then one for high-z galaxies \n", + "\n", + "AGN: point source right in the center thats a better science case than the SN contamination one. there will be more of these and stacking doesn't take it out.\n", + "\n", + "can we think of a science case we would want to use galaxy photometry from a calexp? this is probably a different science case. lets exclude calexp photometry form this notebook. \n", + "\n", + "when you're ready for input from DM make a list of what i want help with (so Yusra can find someone for help and then help them respond to specific questions" + ] } ], "metadata": { From baceecb0331fbfa0a1cd0431cac1ec0d7f52e4fb Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 19 Dec 2024 20:55:22 +0000 Subject: [PATCH 22/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 0704126..bcb60bd 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -12,7 +12,7 @@ "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", "<br>\n", "Contact author(s): <i>Christina Williams</i> <br>\n", - "Last verified to run: <i>2024-11-18</i> <br>\n", + "Last verified to run: <i>2024-12-19</i> <br>\n", "LSST Science Pipelines version: Weekly <i>2024_24</i> <br>\n", "Container Size: <i>medium</i> <br>\n", "Targeted learning level: <i>beginner</i> <br>" @@ -324,7 +324,7 @@ "tags": [] }, "source": [ - "## 2. Photometry measurements from the LSST pipeline\n", + "## 2. Integrated photometry of galaxies using the LSST pipeline\n", "\n", "_Use numbers for sections, sub-sections, and sub-sub-sections to enable referencing, e.g., \"I'm having trouble with the second code cell in Section 2.3.\"_\n", "\n", @@ -388,7 +388,7 @@ "id": "ff2fc2b3-fb3b-4d92-a325-ace4dfa059dc", "metadata": {}, "source": [ - "# 3. Compare simulated photometry measured with the LSST pipelines to their input values\n", + "### 2.2 Compare simulated photometry measured with the LSST pipelines to their input values\n", "\n", "Here use the truth tables to get a sense of how good the various photometry measurement methods are, and in what regimes they perform well vs poorly.\n", "\n", @@ -443,7 +443,7 @@ "id": "1d22c355-0953-46e7-8e40-6614f088c607", "metadata": {}, "source": [ - "## 2.2 Exploring the input vs output photometry\n", + "### 2.3 Exploring the input vs output photometry\n", "\n", "Explore 3 measurements relevant for galaxies: cModel, Kron and GaaP" ] @@ -798,7 +798,7 @@ "outputs": [], "source": [ "\n", - "cmodel_mag = -2.50 * np.log10(tab['i_gaap1p5Flux']) + 31.4\n", + "#cmodel_mag = -2.50 * np.log10(tab['i_gaap1p5Flux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "\n", "plt.scatter(cmodel_mag,kron_mag,\n", @@ -887,12 +887,20 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "253d0d24-6393-4494-ac2e-a7003a6138fe", + "cell_type": "markdown", + "id": "b16c2ecf-c99e-4b30-8d0c-1655c1cb7f92", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "# 3. Integrated photometry for high-redshift galaxies" + ] + }, + { + "cell_type": "markdown", + "id": "6cc1a4dc-5256-48f5-a4d1-8100458c058b", + "metadata": {}, + "source": [ + "# 4. Science application for aperture fluxes" + ] }, { "cell_type": "markdown", From 3e166a4db88a3e9b890f3ee002078e6ac878efbd Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 19 Dec 2024 20:56:17 +0000 Subject: [PATCH 23/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index bcb60bd..234ae40 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -894,12 +894,20 @@ "# 3. Integrated photometry for high-redshift galaxies" ] }, + { + "cell_type": "markdown", + "id": "b7ec87d9-8f56-4974-a9c4-052af0fec039", + "metadata": {}, + "source": [ + "# 4. AGN and host photometry" + ] + }, { "cell_type": "markdown", "id": "6cc1a4dc-5256-48f5-a4d1-8100458c058b", "metadata": {}, "source": [ - "# 4. Science application for aperture fluxes" + "# 5. Science application for aperture fluxes" ] }, { From 8aae2318af833951e45664cd8b0c27068c1b8d29 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 20 Dec 2024 20:22:18 +0000 Subject: [PATCH 24/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 77 ++++++++++++++++++++++++++++++--- 1 file changed, 72 insertions(+), 5 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 234ae40..8fcd92b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -114,7 +114,7 @@ "source": [ "## 1. Introduction\n", "\n", - "_Provide a light narrative about this notebook, e.g., \"This notebook will teach the user...\"._\n", + "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebook 12a/b about the PSF photometry (CHECK/LINK). \n", "\n", "_Cite or link to any external information or documentation, and cross-reference to other notebooks._\n", "\n", @@ -136,8 +136,7 @@ } }, "source": [ - "### 1.0 Selected text grabbed from Melissa's photo-z notebook (for now)\n", - "#### Schema: types of fluxes measured\n", + "### 1.1 Types of photometry measurements that exist in the Object Table\n", "\n", "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", "\n", @@ -223,7 +222,7 @@ "\n", "### PSF fluxes\n", "\n", - "Fluxes derived using the model point-spread function (PSF) of the image. The focus here should be static sky (calexp, deepCoadd) and extended objects (i.e. not PSF fluxes). Connect where relevant to the PSF tutorial and to the tutorial developed for SP-910 (is this Notebook 12a/b or 5?).\n", + "Fluxes derived using the model point-spread function (PSF) of the image. Since PSF fluxes are designed for unresolved sources (not the majority of galaxies) this notebook will not explore science applications for this type of photometry. Interested users can find more information in the PSF tutorial and to the tutorial developed for SP-910 (is this Notebook 12a/b or 5?).\n", "\n", "```\n", "<f>_psfFlux : Flux derived from linear least-squares fit of PSF model. Forced on <f>-band.\n", @@ -402,7 +401,7 @@ "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, \"\\\n", + "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", @@ -564,6 +563,74 @@ "#plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", + "\n", + "whz = np.where(results['redshift'] < 1)[0]\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "scale = 0\n", + "\n", + "ax.axhline(scale,linestyle='--')\n", + "\n", + "ax.plot(truth_mag[whz], (kron_mag[whz]-truth_mag[whz])/truth_mag[whz],'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz])/truth_mag[whz],'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax.plot(truth_mag[whz], (cmodel_mag[whz]-truth_mag[whz])/truth_mag[whz],'.',alpha=.1,label='cModel',color='r')\n", + "\n", + "\n", + "x = truth_mag[whz]\n", + "y = (cmodel_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", + "bins=np.arange(16,30,1)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "\n", + "y = (kron_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "\n", + "y = (gaap_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", + "\n", + "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", + "\n", + "ax.set_xlabel('True i-band Magnitude')\n", + "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "#ax.set_ylim([-5,5])\n", + "ax.set_ylim([-.2,.2])\n", + "#ax.set_yscale('log')\n", + "plt.legend()\n", + "#plt.ylim(15,20)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b29401a5-28df-4d93-88ec-4282ff467f06", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(tab['i_gaapOptimalFlux'][whz], tab['i_gaapOptimalFlux'][whz]/tab['i_cModelFlux'][whz],'.',alpha=.2)\n", + "#plt.plot(gaap_mag[whz], gaap_mag[whz]/cmodel_mag[whz],'.',alpha=.2)" + ] + }, { "cell_type": "markdown", "id": "8a3c30b3-721e-4cbc-abfd-8d4c9b216de8", From 364d9f48628f07fc75742b3a7c69f53e3fcabbc9 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 20 Dec 2024 21:02:40 +0000 Subject: [PATCH 25/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 62 +++++++++++++++++++++++++-------- 1 file changed, 47 insertions(+), 15 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 8fcd92b..e42c645 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -403,11 +403,11 @@ "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", - " \"obj.i_kronFlux, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", + " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 5) AND CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\n", "print(query)" ] }, @@ -509,7 +509,7 @@ "metadata": {}, "outputs": [], "source": [ - "\n", + "# MAYBE: should we impose a S/N limit for this exploration so we're not looking at noise?\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", @@ -577,10 +577,10 @@ "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", "\n", "whz = np.where(results['redshift'] < 1)[0]\n", + "whighz = np.where(results['redshift'] > 1)[0]\n", "\n", - "fig, ax = plt.subplots()\n", - "\n", - "scale = 0\n", + "#fig, ax = plt.subplots()\n", + "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", "\n", "ax.axhline(scale,linestyle='--')\n", "\n", @@ -588,36 +588,65 @@ "ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz])/truth_mag[whz],'.',alpha=.1, label='gaapOptimal',color='green')\n", "ax.plot(truth_mag[whz], (cmodel_mag[whz]-truth_mag[whz])/truth_mag[whz],'.',alpha=.1,label='cModel',color='r')\n", "\n", - "\n", "x = truth_mag[whz]\n", "y = (cmodel_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", "bins=np.arange(16,30,1)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "\n", "y = (kron_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", "y = (gaap_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", - "\n", + "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "#ax.set_ylim([-5,5])\n", "ax.set_ylim([-.2,.2])\n", - "#ax.set_yscale('log')\n", - "plt.legend()\n", - "#plt.ylim(15,20)" + "ax.set_title('Low redshift z<1')\n", + "#plt.legend()\n", + "\n", + "ax2.axhline(scale,linestyle='--')\n", + "\n", + "ax2.plot(truth_mag[whighz], (kron_mag[whighz]-truth_mag[whighz])/truth_mag[whighz],'.',alpha=.1,label='Kron',color='blue')\n", + "ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz])/truth_mag[whighz],'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax2.plot(truth_mag[whighz], (cmodel_mag[whighz]-truth_mag[whighz])/truth_mag[whighz],'.',alpha=.1,label='cModel',color='r')\n", + "\n", + "x = truth_mag[whighz]\n", + "y = (cmodel_mag[whighz]-truth_mag[whighz])/truth_mag[whighz]\n", + "bins=np.arange(16,30,1)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax2.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "\n", + "y = (kron_mag[whighz]-truth_mag[whighz])/truth_mag[whighz]\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax2.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "\n", + "y = (gaap_mag[whighz]-truth_mag[whighz])/truth_mag[whighz]\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax2.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", + "#ax2.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", + "\n", + "ax2.set_xlabel('True i-band Magnitude')\n", + "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "ax2.set_ylim([-.2,.2])\n", + "ax2.set_title('High redshift z>1')\n", + "plt.legend()" ] }, { @@ -628,6 +657,9 @@ "outputs": [], "source": [ "plt.plot(tab['i_gaapOptimalFlux'][whz], tab['i_gaapOptimalFlux'][whz]/tab['i_cModelFlux'][whz],'.',alpha=.2)\n", + "\n", + "plt.ylim([0,2.5])\n", + "\n", "#plt.plot(gaap_mag[whz], gaap_mag[whz]/cmodel_mag[whz],'.',alpha=.2)" ] }, From be1818dd92117ef5b77fde90a83c4e8dc11ba0fa Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 20 Dec 2024 21:35:50 +0000 Subject: [PATCH 26/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index e42c645..1771010 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -38,10 +38,10 @@ "metadata": {}, "outputs": [], "source": [ - "%load_ext pycodestyle_magic\n", - "%flake8_on\n", - "import logging\n", - "logging.getLogger(\"flake8\").setLevel(logging.FATAL)" + "#%load_ext pycodestyle_magic\n", + "#%flake8_on\n", + "#import logging\n", + "#logging.getLogger(\"flake8\").setLevel(logging.FATAL)" ] }, { From 9989163d0e1ee73243befcf68de1c3330ba161a5 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 2 Jan 2025 23:44:04 +0000 Subject: [PATCH 27/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 1771010..4a4dfa9 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -689,7 +689,7 @@ "outputs": [], "source": [ "#\n", - "fig,(ax, ax2) = plt.subplots(1, 2)\n", + "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", "\n", "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", @@ -704,24 +704,24 @@ "#colmaplabel='Kron Radius [pixels]'\n", "\n", "ax.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", + "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='fromBlend')\n", "\n", "\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", - "ax.set_ylabel('Mag Fractional Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", + "ax.set_ylabel('Mag Percent Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", "ax.set_ylim([-.2,.2])\n", - "\n", + "ax.legend()\n", "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", "cmap = tab['i_blendedness'][whgood]\n", "\n", "ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", + "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='isIsolated')\n", "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", "ax2.set_ylim([-.2,.2])\n", - "\n", + "ax2.legend()\n", "\n", "fig.subplots_adjust(right=0.8)\n", "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", @@ -748,6 +748,7 @@ "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", "vmax = 1\n", "colmaplabel='Fraction of flux contaminated by neighbors'\n", + "\n", "#cmap = tab['i_kronRad'][whgood]\n", "#vmax = 20\n", "#colmaplabel='Kron Radius [pixels]'\n", @@ -934,7 +935,7 @@ "plt.ylabel('Kron flux / cModel Flux')\n", "\n", "\n", - "#whbad = np.where( (np.abs(tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright]) > 2) & (mag[whbright] < 22))[0]\n", + "whbad = np.where( (np.abs(tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright]) > 2) & (mag[whbright] < 22))[0]\n", "whblend = np.where( tab['detect_fromBlend'][whbright] == True)[0]\n", "\n", "print(tab['detect_fromBlend'][whbright][whbad])\n", From ee3ede38f206847919d39808d5c6afc31268da70 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 6 Jan 2025 19:24:22 +0000 Subject: [PATCH 28/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 85 +++++++++++++++++++++------------ 1 file changed, 55 insertions(+), 30 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 4a4dfa9..c04a51c 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -222,7 +222,7 @@ "\n", "### PSF fluxes\n", "\n", - "Fluxes derived using the model point-spread function (PSF) of the image. Since PSF fluxes are designed for unresolved sources (not the majority of galaxies) this notebook will not explore science applications for this type of photometry. Interested users can find more information in the PSF tutorial and to the tutorial developed for SP-910 (is this Notebook 12a/b or 5?).\n", + "Fluxes derived using the model point-spread function (PSF) of the image. Since PSF fluxes are designed for unresolved sources (not the majority of galaxies) this notebook will not explore science applications for this type of photometry. Interested users can find more information in the PSF Tutorial notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a>.\n", "\n", "```\n", "<f>_psfFlux : Flux derived from linear least-squares fit of PSF model. Forced on <f>-band.\n", @@ -389,9 +389,11 @@ "source": [ "### 2.2 Compare simulated photometry measured with the LSST pipelines to their input values\n", "\n", - "Here use the truth tables to get a sense of how good the various photometry measurement methods are, and in what regimes they perform well vs poorly.\n", + "The following cells will query the truth tables to get the input fluxes in the DP0.2 simulated objects, matched to those measured from the simulated images using the LSST pipelines. This comparison provides a sense of how good the various photometry measurement methods are by comparing input flux to measured flux. This provides some insight into what regimes they may perform well vs poorly.\n", "\n", - "Grab the truth values for i-band mag, measured i-band mag values from the catalog, and a number of flags that may help understand whats going on" + "The below cells query the truth values for i-band mag, measured i-band mag values from the catalog, and a number of flags that are relevant to the quality of the galaxy photometric measurements. Specifically, request `fromBlend`, `detect_isIsolated`, `i_blendedness` and `i_extendedness` which will indicate how much blending may have occurred, how large the galaxies are, to help provide insight in cases of catastrophic outliers.\n", + "\n", + "Further, to ensure good measurements, restrict to objects which are detected at S/N > 5 and where `detect_isPrimary` is true, to ensure unique objects are returned (for more information on the use of the `detect_isPrimary` flag, see <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_10_Deblender_Data_Products.html\">Tutorial Notebook 10</a> about deblender data products. To expedite the search we will limit to a 0.1 degree region on the sky." ] }, { @@ -407,8 +409,8 @@ " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 5) AND CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"\n", - "print(query)" + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND \"\\\n", + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" ] }, { @@ -424,6 +426,14 @@ "print('Job phase is', job.phase)" ] }, + { + "cell_type": "markdown", + "id": "80ebe401-5124-40f1-8806-fa86850c75f4", + "metadata": {}, + "source": [ + "Print the results of the search query." + ] + }, { "cell_type": "code", "execution_count": null, @@ -444,7 +454,7 @@ "source": [ "### 2.3 Exploring the input vs output photometry\n", "\n", - "Explore 3 measurements relevant for galaxies: cModel, Kron and GaaP" + "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). " ] }, { @@ -454,8 +464,6 @@ "metadata": {}, "outputs": [], "source": [ - "# this is where you are working here:\n", - "\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", @@ -463,30 +471,30 @@ "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", "fig, ax = plt.subplots()\n", "\n", - "scale = 1\n", + "scale = 0\n", "\n", "ax.axhline(scale,linestyle='--')\n", "\n", - "ax.plot(truth_mag, scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1,label='cModel',color='r')\n", - "ax.plot(truth_mag, scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag, scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'],'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax.plot(truth_mag, scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='cModel',color='r')\n", + "ax.plot(truth_mag, scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(truth_mag, scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1, label='gaapOptimal',color='green')\n", "\n", "\n", "x = truth_mag\n", - "y = scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i']\n", - "bins=np.arange(16,30,1)\n", + "y = scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] *100\n", + "bins=np.arange(16,27,1)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "\n", - "y = scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i']\n", + "y = scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] *100\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", - "y = scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i']\n", + "y = scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", @@ -495,10 +503,11 @@ "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Flux Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", + "ax.set_ylabel('Flux Percent Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", "\n", - "ax.set_ylim([.5,5])\n", - "ax.set_yscale('log')\n", + "ax.set_ylim([-100,100])\n", + "ax.set_xlim([14,27])\n", + "#ax.set_yscale('log')\n", "plt.legend()\n" ] }, @@ -509,7 +518,7 @@ "metadata": {}, "outputs": [], "source": [ - "# MAYBE: should we impose a S/N limit for this exploration so we're not looking at noise?\n", + "\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", @@ -522,26 +531,31 @@ "\n", "ax.axhline(scale,linestyle='--')\n", "\n", - "ax.plot(truth_mag, (kron_mag-truth_mag)/truth_mag,'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag, (gaap_mag-truth_mag)/truth_mag,'.',alpha=.1, label='gaapOptimal',color='green')\n", - "ax.plot(truth_mag, (cmodel_mag-truth_mag)/truth_mag,'.',alpha=.1,label='cModel',color='r')\n", + "ax.plot(truth_mag, (kron_mag-truth_mag),'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(truth_mag, (gaap_mag-truth_mag),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", "\n", "\n", "x = truth_mag\n", - "y = (cmodel_mag-truth_mag)/truth_mag\n", + "y = (cmodel_mag-truth_mag)\n", "bins=np.arange(16,30,1)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "for i in range(len(bin_means)):\n", + " print(binctr[i],bin_means[i])\n", "\n", - "y = (kron_mag-truth_mag)/truth_mag\n", + " \n", + "y = (kron_mag-truth_mag)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "for i in range(len(bin_means)):\n", + " print(binctr[i],bin_means[i])\n", "\n", - "y = (gaap_mag-truth_mag)/truth_mag\n", + "y = (gaap_mag-truth_mag)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", @@ -550,9 +564,9 @@ "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "#ax.set_ylim([-5,5])\n", - "ax.set_ylim([-.2,.2])\n", + "ax.set_ylabel('Magnitude difference (M$_{obs}$ - M$_{true}$)')\n", + "ax.set_xlim([14,27])\n", + "ax.set_ylim([-1.2,1.2])\n", "#ax.set_yscale('log')\n", "plt.legend()\n", "#plt.ylim(15,20)\n", @@ -560,7 +574,18 @@ "#plt.plot(x,x,linestyle='--')\n", "#plt.axhline(1,linestyle='--')\n", "\n", - "#plt.show()" + "#plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "ea330668-f260-4e95-a3a1-8a028ac4c0f2", + "metadata": {}, + "source": [ + "These two plots indicate that there is excellent agreement between the cModel measurements and the input, at the level of < 0.1 magnitude at ABmag of < 25. Kron is also adequate although exhibits a slight underestimate of flux (overestimate in magnitude of order 0.03) compared to the input at intermediate magnitudes (ABmag ~ 18-22). \n", + "\n", + "Note that the input light profiles of simulated galaxies in DP0.2 are sersic profiles; thus it is perhaps not unexpected that modeling the light as sersic profiles by the LSST pipelines to produce cModel fluxes would perform the best." ] }, { From c1888c634533613f1c12617c2b7dacf337138d9a Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 6 Jan 2025 20:10:49 +0000 Subject: [PATCH 29/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index c04a51c..e457188 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -464,8 +464,6 @@ "metadata": {}, "outputs": [], "source": [ - "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", "\n", "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", @@ -507,7 +505,7 @@ "\n", "ax.set_ylim([-100,100])\n", "ax.set_xlim([14,27])\n", - "#ax.set_yscale('log')\n", + "\n", "plt.legend()\n" ] }, @@ -527,8 +525,6 @@ "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", "fig, ax = plt.subplots()\n", "\n", - "scale = 0\n", - "\n", "ax.axhline(scale,linestyle='--')\n", "\n", "ax.plot(truth_mag, (kron_mag-truth_mag),'.',alpha=.1,label='Kron',color='blue')\n", @@ -538,7 +534,7 @@ "\n", "x = truth_mag\n", "y = (cmodel_mag-truth_mag)\n", - "bins=np.arange(16,30,1)\n", + "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", @@ -604,7 +600,6 @@ "whz = np.where(results['redshift'] < 1)[0]\n", "whighz = np.where(results['redshift'] > 1)[0]\n", "\n", - "#fig, ax = plt.subplots()\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", "\n", "ax.axhline(scale,linestyle='--')\n", @@ -615,7 +610,7 @@ "\n", "x = truth_mag[whz]\n", "y = (cmodel_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", - "bins=np.arange(16,30,1)\n", + "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", @@ -638,7 +633,6 @@ "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", "ax.set_ylim([-.2,.2])\n", "ax.set_title('Low redshift z<1')\n", - "#plt.legend()\n", "\n", "ax2.axhline(scale,linestyle='--')\n", "\n", From 88eb358ce373e304ed2d70173fcf5b8009aabf5d Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 7 Jan 2025 18:19:41 +0000 Subject: [PATCH 30/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 68 +++++++++------------------------ 1 file changed, 19 insertions(+), 49 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index e457188..0e93156 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -454,19 +454,32 @@ "source": [ "### 2.3 Exploring the input vs output photometry\n", "\n", - "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). " + "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", + "\n", + "First, store the AB magnitudes to go with the fluxes extracted from the objectTable." ] }, { "cell_type": "code", "execution_count": null, - "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", + "id": "7a8000f6-a914-4073-8130-67d912f52b09", "metadata": {}, "outputs": [], "source": [ "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", "\n", - "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", + "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", + "metadata": {}, + "outputs": [], + "source": [ "fig, ax = plt.subplots()\n", "\n", "scale = 0\n", @@ -477,7 +490,6 @@ "ax.plot(truth_mag, scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='Kron',color='blue')\n", "ax.plot(truth_mag, scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1, label='gaapOptimal',color='green')\n", "\n", - "\n", "x = truth_mag\n", "y = scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] *100\n", "bins=np.arange(16,27,1)\n", @@ -498,8 +510,6 @@ "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", "\n", - "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", - "\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Flux Percent Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", "\n", @@ -516,13 +526,6 @@ "metadata": {}, "outputs": [], "source": [ - "\n", - "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", - "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", - "\n", - "#plt.scatter(truth_mag,cmodel_mag,c=tab['i_kronRad'], marker='.', alpha=.5)\n", "fig, ax = plt.subplots()\n", "\n", "ax.axhline(scale,linestyle='--')\n", @@ -557,21 +560,11 @@ "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", "\n", - "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", - "\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Magnitude difference (M$_{obs}$ - M$_{true}$)')\n", "ax.set_xlim([14,27])\n", "ax.set_ylim([-1.2,1.2])\n", - "#ax.set_yscale('log')\n", - "plt.legend()\n", - "#plt.ylim(15,20)\n", - "#x = np.arange(14,30,.1)\n", - "#plt.plot(x,x,linestyle='--')\n", - "#plt.axhline(1,linestyle='--')\n", - "\n", - "#plt.show()\n", - "\n" + "plt.legend()\n" ] }, { @@ -591,12 +584,6 @@ "metadata": {}, "outputs": [], "source": [ - "\n", - "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", - "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", - "\n", "whz = np.where(results['redshift'] < 1)[0]\n", "whighz = np.where(results['redshift'] > 1)[0]\n", "\n", @@ -627,7 +614,6 @@ " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", - "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", @@ -659,29 +645,13 @@ " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax2.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", - "#ax2.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", "\n", "ax2.set_xlabel('True i-band Magnitude')\n", - "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", "ax2.set_ylim([-.2,.2])\n", "ax2.set_title('High redshift z>1')\n", "plt.legend()" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "b29401a5-28df-4d93-88ec-4282ff467f06", - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(tab['i_gaapOptimalFlux'][whz], tab['i_gaapOptimalFlux'][whz]/tab['i_cModelFlux'][whz],'.',alpha=.2)\n", - "\n", - "plt.ylim([0,2.5])\n", - "\n", - "#plt.plot(gaap_mag[whz], gaap_mag[whz]/cmodel_mag[whz],'.',alpha=.2)" - ] - }, { "cell_type": "markdown", "id": "8a3c30b3-721e-4cbc-abfd-8d4c9b216de8", @@ -708,7 +678,7 @@ "outputs": [], "source": [ "#\n", - "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", + "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", "\n", "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", @@ -757,7 +727,7 @@ "outputs": [], "source": [ "#\n", - "fig,(ax, ax2) = plt.subplots(1, 2)\n", + "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", "\n", "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", From 1bbd43220dd5bf5a8a0db3f105a4771f2d981469 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 7 Jan 2025 20:13:32 +0000 Subject: [PATCH 31/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 77 ++++++++++++++++++++++----------- 1 file changed, 52 insertions(+), 25 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 0e93156..7895ce7 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -140,22 +140,24 @@ "\n", "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", "\n", - "For photometric redshifts, since accurate colors are important, it is the GaaP fluxes that should be used.\n", + "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there: The first are total fluxes are those that integrate the total light coming from objects, corrected for loss due to the blurring effects of PSF or seeing, including \"Composite Model\" (`cModel`) fluxes and \"Kron Fluxes\". The second category characterize the relative brightness of objects for specific regions of objects (i.e. are not corrected to be total fluxes) but can be useful for measuring accurate light profiles or accurate colors.\n", "\n", - "### Aperture fluxes\n", - "This contains the enclosed flux inside a given aperture (these are raw fluxes, meaning, they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture using the PSF). Fixed aperture diameter size in pixels.\n", + "### 1.1.1 Total fluxes\n", + "\n", + "#### Kron fluxes\n", + "\n", + "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>.\n", "\n", "```\n", - "<f>_ap<pix>Flux : Flux within <pix>-pixel aperture. Forced on <f>-band.\n", - "<f>_ap<pix>FluxErr : Uncertainty of <f>_ap<pix>Flux.\n", - "<f>_ap<pix>FluxFlag : Failure flag for <f>_ap<pix>Flux.\n", + "<f>_kronFlux : Flux from Kron Flux algorithm. Measured on <f> g-band.\n", + "<f>_kronFluxErr : Uncertainty of <f>_kronFlux.\n", + "<f>_kronFlux_flag : Failure flag for <f>_kronFlux.\n", "```\n", "\n", - "For DP0.2, the apertures are 3, 6, 9, 12, 17, 25, 35, 50, and 70 pixels.\n", + "The Kron radius, `<f>_kronRad`, is also available.\n", "\n", - "In the column name, apertures are `03`, `06`, `09`, `12`, and so on.\n", "\n", - "### Composite Model (CModel) fluxes\n", + "#### Composite Model (CModel) fluxes\n", "\n", "Similar in nature to those measured for SDSS: \n", "https://www.sdss3.org/dr8/algorithms/magnitudes.php#cmodel\n", @@ -179,9 +181,24 @@ "\n", "The fit sizes are also available (half-light radii, ellipse axes).\n", "\n", - "### GaaP fluxes\n", + "### 1.1.2 Regional fluxes\n", "\n", - "The Gaussian-aperture-and-PSF flux from <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>.\n", + "#### Aperture fluxes\n", + "This contains the enclosed flux inside a given aperture (these are raw fluxes, meaning, they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture using the PSF). Fixed aperture diameter size in pixels.\n", + "\n", + "```\n", + "<f>_ap<pix>Flux : Flux within <pix>-pixel aperture. Forced on <f>-band.\n", + "<f>_ap<pix>FluxErr : Uncertainty of <f>_ap<pix>Flux.\n", + "<f>_ap<pix>FluxFlag : Failure flag for <f>_ap<pix>Flux.\n", + "```\n", + "\n", + "For DP0.2, the apertures are 3, 6, 9, 12, 17, 25, 35, 50, and 70 pixels.\n", + "\n", + "In the column name, apertures are `03`, `06`, `09`, `12`, and so on.\n", + "\n", + "#### GaaP fluxes\n", + "\n", + "The Gaussian-aperture-and-PSF flux from <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>. The main goal of this method is to measure accurate colors while accounting for the different spatial resolution between filters. This is sometimes done by convolving all images to the largest PSF, but this process is computationally very time consuming for large images. It is not a measure of total flux in a filter. For photometric redshifts, since accurate colors are important, it is the GaaP fluxes that should be used.\n", "\n", "**Optimal**\n", "\n", @@ -208,19 +225,7 @@ "In the column name `<ap>` appears as `0p5`, `0p7`, etc.\n", "\n", "\n", - "### Kron fluxes\n", - "\n", - "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>.\n", - "\n", - "```\n", - "<f>_kronFlux : Flux from Kron Flux algorithm. Measured on <f> g-band.\n", - "<f>_kronFluxErr : Uncertainty of <f>_kronFlux.\n", - "<f>_kronFlux_flag : Failure flag for <f>_kronFlux.\n", - "```\n", - "\n", - "The Kron radius, `<f>_kronRad`, is also available.\n", - "\n", - "### PSF fluxes\n", + "#### PSF fluxes\n", "\n", "Fluxes derived using the model point-spread function (PSF) of the image. Since PSF fluxes are designed for unresolved sources (not the majority of galaxies) this notebook will not explore science applications for this type of photometry. Interested users can find more information in the PSF Tutorial notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a>.\n", "\n", @@ -628,7 +633,7 @@ "\n", "x = truth_mag[whighz]\n", "y = (cmodel_mag[whighz]-truth_mag[whighz])/truth_mag[whighz]\n", - "bins=np.arange(16,30,1)\n", + "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", @@ -769,6 +774,26 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "b6bc05d8-2f63-4b24-a123-4dd6620ac98a", + "metadata": {}, + "source": [ + "### 3. Photometry for colors\n", + "\n", + "Here we show observed vs intrinsic colors to demonstrate that GaaP is good for that." + ] + }, + { + "cell_type": "markdown", + "id": "f00bea4c-b9cb-40e5-8e5d-23110210a3f3", + "metadata": {}, + "source": [ + "### 4. Photometry for light profiles (i.e. how to use aperture photometry)\n", + "\n", + "Not sure how to do this yet" + ] + }, { "cell_type": "code", "execution_count": null, @@ -776,6 +801,8 @@ "metadata": {}, "outputs": [], "source": [ + "#junk that doens't work yet:\n", + "\n", "# now do the outlier fraction. histogram up the delta_M / M > 0.1 as function of magnitude for the 3\n", "\n", "x = truth_mag\n", From 5931d40f51add1df363b86437c7e7a5be48755d6 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 7 Jan 2025 22:04:44 +0000 Subject: [PATCH 32/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 54 ++++++++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 4 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 7895ce7..6aae6b1 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -242,7 +242,7 @@ "id": "dc36f107", "metadata": {}, "source": [ - "### 1.1 Import packages\n" + "### 1.2 Import packages\n" ] }, { @@ -291,7 +291,7 @@ "id": "c217adff-25ed-4fce-95e7-8aa04630f6cc", "metadata": {}, "source": [ - "### 1.2 Define functions and parameters\n", + "### 1.3 Define functions and parameters\n", "\n", "_If your notebook defines functions or parameters to use later or throughout, do it here in sub-section 1.2._\n", "\n", @@ -392,7 +392,7 @@ "id": "ff2fc2b3-fb3b-4d92-a325-ace4dfa059dc", "metadata": {}, "source": [ - "### 2.2 Compare simulated photometry measured with the LSST pipelines to their input values\n", + "### 2.2 Compare (total) simulated photometry measured with the LSST pipelines to their input values\n", "\n", "The following cells will query the truth tables to get the input fluxes in the DP0.2 simulated objects, matched to those measured from the simulated images using the LSST pipelines. This comparison provides a sense of how good the various photometry measurement methods are by comparing input flux to measured flux. This provides some insight into what regimes they may perform well vs poorly.\n", "\n", @@ -781,7 +781,53 @@ "source": [ "### 3. Photometry for colors\n", "\n", - "Here we show observed vs intrinsic colors to demonstrate that GaaP is good for that." + "Here we show observed vs intrinsic colors to demonstrate that GaaP is good for that.\n", + "\n", + "Lets get multi-filter photometry and compare colors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd7e6ebb-f348-4df9-9859-9d4febb51238", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", + " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", + " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.g_kronFlux, obj.g_kronFluxErr, obj.g_kronRad, obj.g_kronFlux_flag, obj.g_cModelFlux, obj.g_gaapOptimalFlux \" + \\\n", + " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", + " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", + " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND \"\\\n", + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baec0660-1125-43de-9f21-cc5ccef958f0", + "metadata": {}, + "outputs": [], + "source": [ + "job = service.submit_job(query)\n", + "job.run()\n", + "job.wait(phases=['COMPLETED', 'ERROR'])\n", + "print('Job phase is', job.phase)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f0d67e0-93f6-40ff-a099-b30f5e6f8739", + "metadata": {}, + "outputs": [], + "source": [ + "results = job.fetch_result()\n", + "print(len(results))\n", + "tab = results.to_table()\n", + "tab" ] }, { From 36e650f1e2f08fb4aa3b44688338897edfb83f07 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 7 Jan 2025 22:27:27 +0000 Subject: [PATCH 33/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 36 ++++++++++++++++++++++++++++++++- 1 file changed, 35 insertions(+), 1 deletion(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 6aae6b1..6c2559b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -793,7 +793,7 @@ "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", + "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.flux_g, ts.redshift, \"\\\n", " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", " \"obj.g_kronFlux, obj.g_kronFluxErr, obj.g_kronRad, obj.g_kronFlux_flag, obj.g_cModelFlux, obj.g_gaapOptimalFlux \" + \\\n", @@ -830,6 +830,40 @@ "tab" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d97291d-2043-40a6-859c-db391565a9da", + "metadata": {}, + "outputs": [], + "source": [ + "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4\n", + "g_kron_mag = -2.50 * np.log10(tab['g_kronFlux']) + 31.4\n", + "g_gaap_mag = -2.50 * np.log10(tab['g_gaapOptimalFlux']) + 31.4\n", + "g_truth_mag = -2.50 * np.log10(tab['flux_g']) + 31.4\n", + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", + "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59afd145-cc34-4671-82ac-616ba6f28882", + "metadata": {}, + "outputs": [], + "source": [ + "# very confused about why these colors line up so perfectly when the mags do not...\n", + "\n", + "plt.plot(g_truth_mag - truth_mag, g_kron_mag - kron_mag, '.',alpha=.5, label='Kron')\n", + "plt.plot(g_truth_mag - truth_mag, g_gaap_mag - gaap_mag, '.',alpha=.5, label='GaaP optimal')\n", + "x = np.arange(-.1,3,.1)\n", + "plt.plot(x,x,linestyle='--')\n", + "plt.legend()" + ] + }, { "cell_type": "markdown", "id": "f00bea4c-b9cb-40e5-8e5d-23110210a3f3", From 3de1ff3cdc0503cf7ca963c2f4e95f773c4009fa Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 7 Jan 2025 22:48:43 +0000 Subject: [PATCH 34/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 35 ++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 6c2559b..433c5f2 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -793,14 +793,14 @@ "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.flux_g, ts.redshift, \"\\\n", + "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_u, ts.flux_y, ts.redshift, \"\\\n", " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", - " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.g_kronFlux, obj.g_kronFluxErr, obj.g_kronRad, obj.g_kronFlux_flag, obj.g_cModelFlux, obj.g_gaapOptimalFlux \" + \\\n", + " \"obj.u_kronFlux, obj.u_kronFluxErr, obj.u_kronRad, obj.u_kronFlux_flag, obj.u_cModelFlux, obj.u_gaapOptimalFlux, \" + \\\n", + " \"obj.y_kronFlux, obj.y_kronFluxErr, obj.y_kronRad, obj.y_kronFlux_flag, obj.y_cModelFlux, obj.y_gaapOptimalFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.u_kronFlux/obj.u_kronFluxErr > 10) AND \"\\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" ] }, @@ -837,15 +837,15 @@ "metadata": {}, "outputs": [], "source": [ - "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4\n", - "g_kron_mag = -2.50 * np.log10(tab['g_kronFlux']) + 31.4\n", - "g_gaap_mag = -2.50 * np.log10(tab['g_gaapOptimalFlux']) + 31.4\n", - "g_truth_mag = -2.50 * np.log10(tab['flux_g']) + 31.4\n", - "\n", - "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", - "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n" + "u_cmodel_mag = -2.50 * np.log10(tab['u_cModelFlux']) + 31.4\n", + "u_kron_mag = -2.50 * np.log10(tab['u_kronFlux']) + 31.4\n", + "u_gaap_mag = -2.50 * np.log10(tab['u_gaapOptimalFlux']) + 31.4\n", + "u_truth_mag = -2.50 * np.log10(tab['flux_u']) + 31.4\n", + "\n", + "y_cmodel_mag = -2.50 * np.log10(tab['y_cModelFlux']) + 31.4\n", + "y_kron_mag = -2.50 * np.log10(tab['y_kronFlux']) + 31.4\n", + "y_gaap_mag = -2.50 * np.log10(tab['y_gaapOptimalFlux']) + 31.4\n", + "y_truth_mag = -2.50 * np.log10(tab['flux_y']) + 31.4\n" ] }, { @@ -857,10 +857,13 @@ "source": [ "# very confused about why these colors line up so perfectly when the mags do not...\n", "\n", - "plt.plot(g_truth_mag - truth_mag, g_kron_mag - kron_mag, '.',alpha=.5, label='Kron')\n", - "plt.plot(g_truth_mag - truth_mag, g_gaap_mag - gaap_mag, '.',alpha=.5, label='GaaP optimal')\n", - "x = np.arange(-.1,3,.1)\n", + "plt.plot(u_truth_mag - y_truth_mag, u_kron_mag - y_kron_mag, '.',alpha=.5, label='Kron')\n", + "plt.plot(u_truth_mag - y_truth_mag, u_gaap_mag - y_gaap_mag, '.',alpha=.5, label='GaaP optimal')\n", + "x = np.arange(-.1,6,.1)\n", "plt.plot(x,x,linestyle='--')\n", + "plt.plot(x+.1,x+.1,linestyle='--')\n", + "plt.plot(x-.1,x-.1,linestyle='--')\n", + "\n", "plt.legend()" ] }, From e852d7cce6706b673e53d644e00568f18411548a Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 8 Jan 2025 18:24:02 +0000 Subject: [PATCH 35/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 89 ++++++++++++++++----------------- 1 file changed, 43 insertions(+), 46 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 433c5f2..ef2aa7e 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -311,16 +311,6 @@ "afwDisplay.setDefaultBackend('matplotlib')" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": {}, - "outputs": [], - "source": [ - "service = get_tap_service(\"tap\")" - ] - }, { "cell_type": "markdown", "id": "ec51ac0b", @@ -330,47 +320,59 @@ "source": [ "## 2. Integrated photometry of galaxies using the LSST pipeline\n", "\n", - "_Use numbers for sections, sub-sections, and sub-sub-sections to enable referencing, e.g., \"I'm having trouble with the second code cell in Section 2.3.\"_\n", - "\n", - "_Use section titles that actively describe what is being done, e.g., \"Create a color-magnitude diagram\" instead of \"Plot\", so that the auto-generated table of contents is easy to navigate._\n", - "\n", - "### 2.1 Object table photometry measurements\n", - "\n", - "First see what is available in the object catalog." + "This section will explore the total, integrated photometry measurements, and provide some guidance for which are optimal for certain science applications using galaxies. \n" + ] + }, + { + "cell_type": "markdown", + "id": "45c86ed0-aebe-4d74-af42-619c0f6b0705", + "metadata": {}, + "source": [ + "### 2.1 Initialize the TAP service, and istantiate the Butler (may not need; TBD delete)" ] }, { "cell_type": "code", "execution_count": null, - "id": "6ad9a3ea-5d4c-4247-b0ff-712fafa00bb3", + "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", "metadata": {}, "outputs": [], "source": [ - "butler = Butler('dp02', collections='2.2i/runs/DP0.2')\n", - "\n" + "service = get_tap_service(\"tap\")" ] }, { "cell_type": "code", "execution_count": null, - "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", + "id": "6ad9a3ea-5d4c-4247-b0ff-712fafa00bb3", "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT column_name, datatype, description, unit \" \\\n", - " \"FROM tap_schema.columns \" \\\n", - " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", - "\n", - "results = service.search(query).to_table()\n", - "results" + "butler = Butler('dp02', collections='2.2i/runs/DP0.2')" ] }, { "cell_type": "markdown", - "id": "586716d7-7f95-4ad2-8c3a-88c9052a32fa", + "id": "9547e659-fd0e-432c-af25-968cc9ebea9d", "metadata": {}, "source": [ - "Below are all the parameters available related to \"Flux\" measured in the i-band " + "### 2.2 Object table photometry measurements\n", + "\n", + "First see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT column_name, datatype, description, unit \" \\\n", + " \"FROM tap_schema.columns \" \\\n", + " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", + "\n", + "results = service.search(query).to_table()" ] }, { @@ -392,13 +394,13 @@ "id": "ff2fc2b3-fb3b-4d92-a325-ace4dfa059dc", "metadata": {}, "source": [ - "### 2.2 Compare (total) simulated photometry measured with the LSST pipelines to their input values\n", + "### 2.3 Compare (total) simulated photometry measured with the LSST pipelines to their input values\n", "\n", "The following cells will query the truth tables to get the input fluxes in the DP0.2 simulated objects, matched to those measured from the simulated images using the LSST pipelines. This comparison provides a sense of how good the various photometry measurement methods are by comparing input flux to measured flux. This provides some insight into what regimes they may perform well vs poorly.\n", "\n", - "The below cells query the truth values for i-band mag, measured i-band mag values from the catalog, and a number of flags that are relevant to the quality of the galaxy photometric measurements. Specifically, request `fromBlend`, `detect_isIsolated`, `i_blendedness` and `i_extendedness` which will indicate how much blending may have occurred, how large the galaxies are, to help provide insight in cases of catastrophic outliers.\n", + "The below cells query the truth values for i-band mag, measured i-band mag values from the catalog, and a number of flags that are relevant to the quality of the galaxy photometric measurements. Specifically, request `fromBlend`, `detect_isIsolated`, and `i_blendedness` which will indicate how much blending may have occurred, how large the galaxies are, to help provide insight in cases of catastrophic outliers.\n", "\n", - "Further, to ensure good measurements, restrict to objects which are detected at S/N > 5 and where `detect_isPrimary` is true, to ensure unique objects are returned (for more information on the use of the `detect_isPrimary` flag, see <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_10_Deblender_Data_Products.html\">Tutorial Notebook 10</a> about deblender data products. To expedite the search we will limit to a 0.1 degree region on the sky." + "Further, to ensure good measurements, restrict to objects which are detected at S/N > 5 and where `detect_isPrimary` is true, to ensure unique objects are returned (for more information on the use of the `detect_isPrimary` flag, see <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_10_Deblender_Data_Products.html\">Tutorial Notebook 10</a> about deblender data products. Also, set the condition that `i_extendedness` = 1 in order to return a population of galaxies (i.e. remove stars as point sources). To expedite the search we will limit to a 0.1 degree region on the sky." ] }, { @@ -414,7 +416,7 @@ " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" ] }, @@ -457,7 +459,7 @@ "id": "1d22c355-0953-46e7-8e40-6614f088c607", "metadata": {}, "source": [ - "### 2.3 Exploring the input vs output photometry\n", + "### 2.4 Exploring the input vs output photometry\n", "\n", "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", "\n", @@ -688,6 +690,8 @@ "\n", "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", "\n", + "# Remove i_extendedness, you put it directly into the query instead\n", + "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & ( tab['detect_fromBlend'] == 1))[0] #(tab['detect_fromBlend'] == 0) )[0]\n", "\n", "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", @@ -719,9 +723,7 @@ "\n", "fig.subplots_adjust(right=0.8)\n", "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", - "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n", - "\n", - "plt.show()" + "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n" ] }, { @@ -731,7 +733,6 @@ "metadata": {}, "outputs": [], "source": [ - "#\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", "\n", @@ -756,7 +757,6 @@ "ax.set_ylim([-.2,.2])\n", "\n", "\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", "cmap = tab['i_blendedness'][whgood]\n", "\n", @@ -769,9 +769,7 @@ "\n", "fig.subplots_adjust(right=0.8)\n", "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", - "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n", - "\n", - "plt.show()" + "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n" ] }, { @@ -800,7 +798,7 @@ " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.u_kronFlux/obj.u_kronFluxErr > 10) AND \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.u_kronFlux/obj.u_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" ] }, @@ -825,9 +823,7 @@ "outputs": [], "source": [ "results = job.fetch_result()\n", - "print(len(results))\n", - "tab = results.to_table()\n", - "tab" + "tab = results.to_table()" ] }, { @@ -858,6 +854,7 @@ "# very confused about why these colors line up so perfectly when the mags do not...\n", "\n", "plt.plot(u_truth_mag - y_truth_mag, u_kron_mag - y_kron_mag, '.',alpha=.5, label='Kron')\n", + "plt.plot(u_truth_mag - y_truth_mag, u_cmodel_mag - y_cmodel_mag, '.',alpha=.5, label='Kron')\n", "plt.plot(u_truth_mag - y_truth_mag, u_gaap_mag - y_gaap_mag, '.',alpha=.5, label='GaaP optimal')\n", "x = np.arange(-.1,6,.1)\n", "plt.plot(x,x,linestyle='--')\n", From b99f7679c24304cbfa1828a658b812edd84abb1b Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 8 Jan 2025 22:03:02 +0000 Subject: [PATCH 36/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 129 +++++++++++++++++++++++--------- 1 file changed, 92 insertions(+), 37 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index ef2aa7e..e8d767d 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -591,71 +591,72 @@ "metadata": {}, "outputs": [], "source": [ - "whz = np.where(results['redshift'] < 1)[0]\n", - "whighz = np.where(results['redshift'] > 1)[0]\n", + "zlim = 0.5\n", + "whz = np.where(results['redshift'] < zlim)[0]\n", + "whighz = np.where(results['redshift'] > zlim)[0]\n", "\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", "\n", "ax.axhline(scale,linestyle='--')\n", "\n", - "ax.plot(truth_mag[whz], (kron_mag[whz]-truth_mag[whz])/truth_mag[whz],'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz])/truth_mag[whz],'.',alpha=.1, label='gaapOptimal',color='green')\n", - "ax.plot(truth_mag[whz], (cmodel_mag[whz]-truth_mag[whz])/truth_mag[whz],'.',alpha=.1,label='cModel',color='r')\n", + "ax.plot(truth_mag[whz], (kron_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax.plot(truth_mag[whz], (cmodel_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='cModel',color='r')\n", "\n", "x = truth_mag[whz]\n", - "y = (cmodel_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", - "\n", + "y = (cmodel_mag[whz]-truth_mag[whz])\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "\n", - "y = (kron_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", + "y = (kron_mag[whz]-truth_mag[whz])\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", - "y = (gaap_mag[whz]-truth_mag[whz])/truth_mag[whz]\n", + "y = (gaap_mag[whz]-truth_mag[whz])\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "ax.set_ylim([-.2,.2])\n", - "ax.set_title('Low redshift z<1')\n", + "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", + "#ax.set_ylim([-.2,.2])\n", + "ax.set_title('Low redshift z<'+str(zlim))\n", "\n", "ax2.axhline(scale,linestyle='--')\n", "\n", - "ax2.plot(truth_mag[whighz], (kron_mag[whighz]-truth_mag[whighz])/truth_mag[whighz],'.',alpha=.1,label='Kron',color='blue')\n", - "ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz])/truth_mag[whighz],'.',alpha=.1, label='gaapOptimal',color='green')\n", - "ax2.plot(truth_mag[whighz], (cmodel_mag[whighz]-truth_mag[whighz])/truth_mag[whighz],'.',alpha=.1,label='cModel',color='r')\n", + "ax2.plot(truth_mag[whighz], (kron_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='Kron',color='blue')\n", + "ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax2.plot(truth_mag[whighz], (cmodel_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='cModel',color='r')\n", "\n", "x = truth_mag[whighz]\n", - "y = (cmodel_mag[whighz]-truth_mag[whighz])/truth_mag[whighz]\n", + "y = (cmodel_mag[whighz]-truth_mag[whighz])\n", "\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax2.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "\n", - "y = (kron_mag[whighz]-truth_mag[whighz])/truth_mag[whighz]\n", + "y = (kron_mag[whighz]-truth_mag[whighz])\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax2.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", - "y = (gaap_mag[whighz]-truth_mag[whighz])/truth_mag[whighz]\n", + "y = (gaap_mag[whighz]-truth_mag[whighz])\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax2.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", "\n", "ax2.set_xlabel('True i-band Magnitude')\n", - "ax2.set_ylim([-.2,.2])\n", - "ax2.set_title('High redshift z>1')\n", + "ax2.set_ylim([-2,2])\n", + "ax2.set_xlim([19,26])\n", + "ax2.set_title('High redshift z>'+str(zlim))\n", "plt.legend()" ] }, @@ -701,24 +702,24 @@ "#vmax = 20\n", "#colmaplabel='Kron Radius [pixels]'\n", "\n", - "ax.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='fromBlend')\n", + "#ax.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='fromBlend')\n", "\n", "\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", - "ax.set_ylabel('Mag Percent Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "ax.set_ylim([-.2,.2])\n", + "ax.set_ylabel('Mag Percent Accuracy (M$_{obs}$ - M$_{true}$) ')\n", + "#ax.set_ylim([-.2,.2])\n", "ax.legend()\n", "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", "cmap = tab['i_blendedness'][whgood]\n", "\n", - "ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='isIsolated')\n", + "#ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='isIsolated')\n", "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", - "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "ax2.set_ylim([-.2,.2])\n", + "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", + "#ax2.set_ylim([-.2,.2])\n", "ax2.legend()\n", "\n", "fig.subplots_adjust(right=0.8)\n", @@ -748,28 +749,31 @@ "#vmax = 20\n", "#colmaplabel='Kron Radius [pixels]'\n", "\n", - "ax.scatter(truth_mag,(cmodel_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "im = ax.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", + "#ax.scatter(truth_mag,(cmodel_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "im = ax.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", "\n", "\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", - "ax.set_ylabel('Mag Fractional Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "ax.set_ylim([-.2,.2])\n", + "ax.set_ylabel('Mag Fractional Accuracy (M$_{obs}$ - M$_{true}$) ')\n", + "ax.set_ylim([-1.5,1.5])\n", "\n", "\n", "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", "cmap = tab['i_blendedness'][whgood]\n", "\n", - "ax2.scatter(truth_mag,(cmodel_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "ax2.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood])/truth_mag[whgood],c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", + "#ax2.scatter(truth_mag,(cmodel_mag-truth_mag),color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", + "ax2.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "ax2.set_ylim([-.2,.2])\n", + "ax2.set_ylim([-1.5,1.5])\n", "\n", "\n", "fig.subplots_adjust(right=0.8)\n", "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", - "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n" + "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n", + "\n", + "import sys\n", + "sys.exit()" ] }, { @@ -854,7 +858,7 @@ "# very confused about why these colors line up so perfectly when the mags do not...\n", "\n", "plt.plot(u_truth_mag - y_truth_mag, u_kron_mag - y_kron_mag, '.',alpha=.5, label='Kron')\n", - "plt.plot(u_truth_mag - y_truth_mag, u_cmodel_mag - y_cmodel_mag, '.',alpha=.5, label='Kron')\n", + "plt.plot(u_truth_mag - y_truth_mag, u_cmodel_mag - y_cmodel_mag, '.',alpha=.5, label='cModel')\n", "plt.plot(u_truth_mag - y_truth_mag, u_gaap_mag - y_gaap_mag, '.',alpha=.5, label='GaaP optimal')\n", "x = np.arange(-.1,6,.1)\n", "plt.plot(x,x,linestyle='--')\n", @@ -874,6 +878,57 @@ "Not sure how to do this yet" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "8575a64b-f166-453b-aebd-dd09d728a259", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", + " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", + " \"obj.i_ap12Flux, obj.i_ap17Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_kronRad, obj.i_kronFlux_flag \" + \\\n", + " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", + " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", + " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24718446-033d-4b3d-b11f-a94c708c6d1e", + "metadata": {}, + "outputs": [], + "source": [ + "job = service.submit_job(query)\n", + "job.run()\n", + "job.wait(phases=['COMPLETED', 'ERROR'])\n", + "print('Job phase is', job.phase)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ddc4e98-1151-4aba-806a-b9097d2edfd0", + "metadata": {}, + "outputs": [], + "source": [ + "results = job.fetch_result()\n", + "tab = results.to_table()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b26042c-c234-4885-819b-a05dfba2bc31", + "metadata": {}, + "outputs": [], + "source": [ + "# pick an object that has large size\n" + ] + }, { "cell_type": "code", "execution_count": null, From 5df7d5509c788d9f86fae233ffa978a0568647cc Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 8 Jan 2025 22:30:32 +0000 Subject: [PATCH 37/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index e8d767d..f5cee57 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -887,7 +887,7 @@ "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", - " \"obj.i_ap12Flux, obj.i_ap17Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_kronRad, obj.i_kronFlux_flag \" + \\\n", + " \"obj.i_ap03Flux, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap12Flux, obj.i_ap17Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux, obj.i_kronRad, obj.i_kronFlux_flag \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", @@ -926,7 +926,26 @@ "metadata": {}, "outputs": [], "source": [ - "# pick an object that has large size\n" + "# pick an object that has large size\n", + "wh = np.where(tab['i_kronRad'] > 10)[0]\n", + "print(len(wh), tab['i_kronRad'][wh])\n", + "\n", + "rad = np.array([3,6,9,12,17,25,35,50])\n", + "light_profile = np.array([tab['i_ap03Flux'][wh][0],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][0],tab['i_ap12Flux'][wh][0],tab['i_ap17Flux'][wh][0],\n", + " tab['i_ap25Flux'][wh][0],tab['i_ap35Flux'][wh][0],tab['i_ap50Flux'][wh][0]])\n", + "plt.plot(rad, light_profile, label='Large Radius R='+str(tab['i_kronRad'][wh][0]))\n", + "plt.xlabel('Aperture Radius [pixels]')\n", + "plt.ylabel('Flux density [nJy]')\n", + "\n", + "# pick an object that has large size\n", + "wh = np.where(tab['i_kronRad'] < 5)[0]\n", + "print(len(wh), tab['i_kronRad'][wh])\n", + "\n", + "rad = np.array([3,6,9,12,17,25,35,50])\n", + "light_profile = np.array([tab['i_ap03Flux'][wh][0],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][0],tab['i_ap12Flux'][wh][0],tab['i_ap17Flux'][wh][0],\n", + " tab['i_ap25Flux'][wh][0],tab['i_ap35Flux'][wh][0],tab['i_ap50Flux'][wh][0]])\n", + "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh][0]))\n", + "plt.legend()\n" ] }, { From 9d5418eb0be7010d203f6d8f6243cdb6739705ef Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 8 Jan 2025 23:40:09 +0000 Subject: [PATCH 38/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 53 +++++++++++++++++++++++++-------- 1 file changed, 40 insertions(+), 13 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index f5cee57..ad55697 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -275,6 +275,7 @@ "from astropy.coordinates import SkyCoord\n", "import gc\n", "import numpy as np\n", + "import sys\n", "\n", "import lsst.afw.display as afwDisplay\n", "from lsst.afw.image import MultibandExposure\n", @@ -417,7 +418,7 @@ " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"" ] }, { @@ -626,6 +627,7 @@ "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", "#ax.set_ylim([-.2,.2])\n", "ax.set_title('Low redshift z<'+str(zlim))\n", + "ax.set_ylim([-2,2])\n", "\n", "ax2.axhline(scale,linestyle='--')\n", "\n", @@ -704,11 +706,13 @@ "\n", "#ax.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='fromBlend')\n", - "\n", + "ax.axhline(scale,linestyle='--')\n", + "ax.set_title('Kron Photometry')\n", "\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", "ax.set_ylabel('Mag Percent Accuracy (M$_{obs}$ - M$_{true}$) ')\n", - "#ax.set_ylim([-.2,.2])\n", + "ax.set_xlim([16,26])\n", + "ax.set_ylim([-1,1])\n", "ax.legend()\n", "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", @@ -717,10 +721,14 @@ "\n", "#ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='isIsolated')\n", + "print(len(whgood))\n", "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", - "#ax2.set_ylim([-.2,.2])\n", + "ax2.set_ylim([-1,1])\n", + "ax2.set_xlim([16,26])\n", "ax2.legend()\n", + "ax2.axhline(scale,linestyle='--')\n", + "ax2.set_title('Kron Photometry')\n", "\n", "fig.subplots_adjust(right=0.8)\n", "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", @@ -734,6 +742,9 @@ "metadata": {}, "outputs": [], "source": [ + "# the following plots are identical, consider a different comparison that is informative\n", + "\n", + "\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", "\n", @@ -750,30 +761,36 @@ "#colmaplabel='Kron Radius [pixels]'\n", "\n", "#ax.scatter(truth_mag,(cmodel_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "im = ax.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", + "im = ax.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='fromBlend')\n", "\n", "\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", "ax.set_ylabel('Mag Fractional Accuracy (M$_{obs}$ - M$_{true}$) ')\n", - "ax.set_ylim([-1.5,1.5])\n", - "\n", - "\n", + "ax.set_ylim([-1,1])\n", + "ax.set_xlim([16,26])\n", + "ax.axhline(scale,linestyle='--')\n", + "ax.set_title('cModel Photometry')\n", + "ax.legend()\n", "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", "cmap = tab['i_blendedness'][whgood]\n", "\n", "#ax2.scatter(truth_mag,(cmodel_mag-truth_mag),color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "ax2.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax)\n", + "ax2.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='isIsolated')\n", "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "ax2.set_ylim([-1.5,1.5])\n", - "\n", + "#ax2.set_ylim([-1.5,1.5])\n", + "ax2.set_ylim([-1,1])\n", + "ax2.set_xlim([16,26])\n", + "ax2.axhline(scale,linestyle='--')\n", + "print(len(whgood))\n", "\n", "fig.subplots_adjust(right=0.8)\n", "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n", "\n", - "import sys\n", - "sys.exit()" + "ax2.set_title('cModel Photometry')\n", + "ax2.legend()" ] }, { @@ -948,6 +965,16 @@ "plt.legend()\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "12f5be0d-7816-4622-8523-aff5e6b9a028", + "metadata": {}, + "outputs": [], + "source": [ + "sys.exit()" + ] + }, { "cell_type": "code", "execution_count": null, From c1c016fe197dc27f347caafa975f31cee6f9a555 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 10 Jan 2025 21:19:45 +0000 Subject: [PATCH 39/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index ad55697..3251a09 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -54,10 +54,10 @@ }, { "cell_type": "markdown", - "id": "9da1a210-d858-42fe-8591-570965b8be1a", + "id": "2963cbac-4ecd-4694-bea3-c111f527e51b", "metadata": {}, "source": [ - "**Description:** _Very brief description of notebook._" + "**Description:** Explore the available measurements of galaxy photometry produced by the LSST pipelines and their applications." ] }, { @@ -73,7 +73,7 @@ "id": "393da88f-7978-4920-aa4a-a9830df6eed9", "metadata": {}, "source": [ - "**LSST Data Products:** _List the all of the types of LSST catalogs and images used._" + "**LSST Data Products:** objectTable" ] }, { @@ -269,19 +269,19 @@ "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", - "from astropy.wcs import WCS\n", - "from astropy.visualization import make_lupton_rgb\n", + "#from astropy.wcs import WCS\n", + "#from astropy.visualization import make_lupton_rgb\n", "from astropy import units as u\n", "from astropy.coordinates import SkyCoord\n", "import gc\n", "import numpy as np\n", "import sys\n", "\n", - "import lsst.afw.display as afwDisplay\n", - "from lsst.afw.image import MultibandExposure\n", + "#import lsst.afw.display as afwDisplay\n", + "#from lsst.afw.image import MultibandExposure\n", "from lsst.daf.butler import Butler\n", "from lsst.rsp import get_tap_service\n", - "import lsst.geom as geom\n", + "#import lsst.geom as geom\n", "\n", "from scipy import stats#.binned_statistic\n", "from scipy.stats import sigmaclip\n" @@ -309,7 +309,7 @@ "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", - "afwDisplay.setDefaultBackend('matplotlib')" + "#afwDisplay.setDefaultBackend('matplotlib')" ] }, { @@ -349,7 +349,7 @@ "metadata": {}, "outputs": [], "source": [ - "butler = Butler('dp02', collections='2.2i/runs/DP0.2')" + "#butler = Butler('dp02', collections='2.2i/runs/DP0.2')" ] }, { @@ -499,20 +499,20 @@ "ax.plot(truth_mag, scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1, label='gaapOptimal',color='green')\n", "\n", "x = truth_mag\n", - "y = scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] *100\n", + "y = (tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] *100\n", "bins=np.arange(16,27,1)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "\n", - "y = scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] *100\n", + "y = (tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] *100\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", - "y = scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100\n", + "y = (tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", From 38210ee0a7c1e1531ac192a751d7422b0ebbf499 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 10 Jan 2025 21:38:58 +0000 Subject: [PATCH 40/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 3251a09..715ca55 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -534,7 +534,7 @@ "metadata": {}, "outputs": [], "source": [ - "fig, ax = plt.subplots()\n", + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(12, 12))\n", "\n", "ax.axhline(scale,linestyle='--')\n", "\n", @@ -542,6 +542,7 @@ "ax.plot(truth_mag, (gaap_mag-truth_mag),'.',alpha=.1, label='gaapOptimal',color='green')\n", "ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", "\n", + "ax2.hist((kron_mag-truth_mag),color='blue')\n", "\n", "x = truth_mag\n", "y = (cmodel_mag-truth_mag)\n", @@ -572,7 +573,9 @@ "ax.set_ylabel('Magnitude difference (M$_{obs}$ - M$_{true}$)')\n", "ax.set_xlim([14,27])\n", "ax.set_ylim([-1.2,1.2])\n", - "plt.legend()\n" + "plt.legend()\n", + "\n", + "\n" ] }, { From 7a1ed5255e9a514a801dbb0dac62c297cbb72075 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 10 Jan 2025 22:41:30 +0000 Subject: [PATCH 41/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 83 +++++++++++++++++++++------------ 1 file changed, 52 insertions(+), 31 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 715ca55..5dd82c6 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -534,15 +534,18 @@ "metadata": {}, "outputs": [], "source": [ - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(12, 12))\n", - "\n", + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "ylims = [-1.2,1.2]\n", "ax.axhline(scale,linestyle='--')\n", "\n", "ax.plot(truth_mag, (kron_mag-truth_mag),'.',alpha=.1,label='Kron',color='blue')\n", "ax.plot(truth_mag, (gaap_mag-truth_mag),'.',alpha=.1, label='gaapOptimal',color='green')\n", "ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", "\n", - "ax2.hist((kron_mag-truth_mag),color='blue')\n", + "ax2.hist((kron_mag-truth_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist((gaap_mag-truth_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist((cmodel_mag-truth_mag),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.axhline(0,linestyle='--')\n", "\n", "x = truth_mag\n", "y = (cmodel_mag-truth_mag)\n", @@ -550,7 +553,7 @@ "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", "for i in range(len(bin_means)):\n", " print(binctr[i],bin_means[i])\n", "\n", @@ -559,7 +562,7 @@ "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "for i in range(len(bin_means)):\n", " print(binctr[i],bin_means[i])\n", "\n", @@ -567,13 +570,13 @@ "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", + "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Magnitude difference (M$_{obs}$ - M$_{true}$)')\n", "ax.set_xlim([14,27])\n", - "ax.set_ylim([-1.2,1.2])\n", - "plt.legend()\n", + "ax.set_ylim(ylims)\n", + "ax.legend()\n", "\n", "\n" ] @@ -698,7 +701,7 @@ "\n", "# Remove i_extendedness, you put it directly into the query instead\n", "\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & ( tab['detect_fromBlend'] == 1))[0] #(tab['detect_fromBlend'] == 0) )[0]\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", "\n", "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", "vmax = 1\n", @@ -753,7 +756,7 @@ "\n", "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", "\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & ( tab['detect_fromBlend'] == 1))[0] #(tab['detect_fromBlend'] == 0) )[0]\n", + "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", "\n", "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", "vmax = 1\n", @@ -815,15 +818,15 @@ "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_u, ts.flux_y, ts.redshift, \"\\\n", + "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_g, ts.flux_z, ts.redshift, \"\\\n", " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", - " \"obj.u_kronFlux, obj.u_kronFluxErr, obj.u_kronRad, obj.u_kronFlux_flag, obj.u_cModelFlux, obj.u_gaapOptimalFlux, \" + \\\n", - " \"obj.y_kronFlux, obj.y_kronFluxErr, obj.y_kronRad, obj.y_kronFlux_flag, obj.y_cModelFlux, obj.y_gaapOptimalFlux \" + \\\n", + " \"obj.g_kronFlux, obj.g_kronFluxErr, obj.g_kronRad, obj.g_kronFlux_flag, obj.g_cModelFlux, obj.g_gaapOptimalFlux, \" + \\\n", + " \"obj.z_kronFlux, obj.z_kronFluxErr, obj.z_kronRad, obj.z_kronFlux_flag, obj.z_cModelFlux, obj.z_gaapOptimalFlux \" + \\\n", " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.u_kronFlux/obj.u_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"" ] }, { @@ -857,15 +860,15 @@ "metadata": {}, "outputs": [], "source": [ - "u_cmodel_mag = -2.50 * np.log10(tab['u_cModelFlux']) + 31.4\n", - "u_kron_mag = -2.50 * np.log10(tab['u_kronFlux']) + 31.4\n", - "u_gaap_mag = -2.50 * np.log10(tab['u_gaapOptimalFlux']) + 31.4\n", - "u_truth_mag = -2.50 * np.log10(tab['flux_u']) + 31.4\n", - "\n", - "y_cmodel_mag = -2.50 * np.log10(tab['y_cModelFlux']) + 31.4\n", - "y_kron_mag = -2.50 * np.log10(tab['y_kronFlux']) + 31.4\n", - "y_gaap_mag = -2.50 * np.log10(tab['y_gaapOptimalFlux']) + 31.4\n", - "y_truth_mag = -2.50 * np.log10(tab['flux_y']) + 31.4\n" + "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4\n", + "g_kron_mag = -2.50 * np.log10(tab['g_kronFlux']) + 31.4\n", + "g_gaap_mag = -2.50 * np.log10(tab['g_gaapOptimalFlux']) + 31.4\n", + "g_truth_mag = -2.50 * np.log10(tab['flux_g']) + 31.4\n", + "\n", + "z_cmodel_mag = -2.50 * np.log10(tab['z_cModelFlux']) + 31.4\n", + "z_kron_mag = -2.50 * np.log10(tab['z_kronFlux']) + 31.4\n", + "z_gaap_mag = -2.50 * np.log10(tab['z_gaapOptimalFlux']) + 31.4\n", + "z_truth_mag = -2.50 * np.log10(tab['flux_z']) + 31.4\n" ] }, { @@ -877,15 +880,33 @@ "source": [ "# very confused about why these colors line up so perfectly when the mags do not...\n", "\n", - "plt.plot(u_truth_mag - y_truth_mag, u_kron_mag - y_kron_mag, '.',alpha=.5, label='Kron')\n", - "plt.plot(u_truth_mag - y_truth_mag, u_cmodel_mag - y_cmodel_mag, '.',alpha=.5, label='cModel')\n", - "plt.plot(u_truth_mag - y_truth_mag, u_gaap_mag - y_gaap_mag, '.',alpha=.5, label='GaaP optimal')\n", - "x = np.arange(-.1,6,.1)\n", - "plt.plot(x,x,linestyle='--')\n", - "plt.plot(x+.1,x+.1,linestyle='--')\n", - "plt.plot(x-.1,x-.1,linestyle='--')\n", + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "ylims = [-0.2,0.2]\n", "\n", - "plt.legend()" + "truth_color = g_truth_mag - z_truth_mag\n", + "kron_color = g_kron_mag - z_kron_mag\n", + "cmodel_color = g_cmodel_mag - z_cmodel_mag\n", + "gaap_color = g_gaap_mag - z_gaap_mag\n", + "\n", + "ax.plot(z_kron_mag, kron_color-truth_color, '.',alpha=.5, label='Kron',color='b')\n", + "ax.plot(z_cmodel_mag, cmodel_color-truth_color, '.',alpha=.5, label='cModel',color='r')\n", + "ax.plot(z_gaap_mag, gaap_color-truth_color, '.',alpha=.5, label='GaaP optimal',color='g')\n", + "\n", + "ax2.hist((kron_color-truth_color),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 80),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist((gaap_color-truth_color),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 80),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist((cmodel_color-truth_color),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 80),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.axhline(0,linestyle='--')\n", + "\n", + "\n", + "x = np.arange(-.1,6,.1)\n", + "#plt.plot(x,x,linestyle='--')\n", + "#plt.plot(x+.1,x+.1,linestyle='--')\n", + "#plt.plot(x-.1,x-.1,linestyle='--')\n", + "ylims = [-1,1]\n", + "ax.axhline(0)\n", + "ax.set_ylim(ylims)\n", + "ax.set_xlim([16,26])\n", + "ax.legend()" ] }, { From 0d452baa9fc147d4f035e713a13425109402f68d Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Sat, 11 Jan 2025 00:06:08 +0000 Subject: [PATCH 42/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 241 +++++++++++++++----------------- 1 file changed, 112 insertions(+), 129 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 5dd82c6..5ce2f95 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -12,7 +12,7 @@ "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", "<br>\n", "Contact author(s): <i>Christina Williams</i> <br>\n", - "Last verified to run: <i>2024-12-19</i> <br>\n", + "Last verified to run: <i>2024-01-10</i> <br>\n", "LSST Science Pipelines version: Weekly <i>2024_24</i> <br>\n", "Container Size: <i>medium</i> <br>\n", "Targeted learning level: <i>beginner</i> <br>" @@ -44,14 +44,6 @@ "#logging.getLogger(\"flake8\").setLevel(logging.FATAL)" ] }, - { - "cell_type": "markdown", - "id": "482777d8-0a8d-432e-ba53-2da536700407", - "metadata": {}, - "source": [ - "_The six cells below are considered the extended header of the notebook. The first four will be used, verbatim, to create the table of notebook metadata in the README.md file for the repository._" - ] - }, { "cell_type": "markdown", "id": "2963cbac-4ecd-4694-bea3-c111f527e51b", @@ -65,7 +57,7 @@ "id": "80a0baf5-51ad-40ec-8991-060a7b27c289", "metadata": {}, "source": [ - "**Skills:** _Brief list of skills to match the README.md file for the repository._" + "**Skills:** Basic understanding of photometric measurement methods typically used to characterize galaxies." ] }, { @@ -81,7 +73,7 @@ "id": "5c67fab9-136a-4adc-bb42-142b91ab69dd", "metadata": {}, "source": [ - "**Packages:** _List the python packages used._ (_List the packages being taught first, e.g., afwDisplay for a notebook about displaying images. Then supporting packages, e.g., lsst.daf.butler for a notebook about displaying images. It is OK to leave out basic support packages like os or glob.)_" + "**Packages:** No new LSST packages are introduced here. The notebook will make use of the TAP service from the `lsst.rsp` package." ] }, { @@ -90,7 +82,7 @@ "metadata": {}, "source": [ "**Credit:**\n", - "_E.g., \"Originally developed by\" or \"Based on notebooks developed by\" and then people's names, including journal article or software release citations if appropriate._\n", + "\"This notebook benefitted from earlier exploration of simulated data and notebook development by Melissa Graham and Dan Taranu. _E.g., \"Originally developed by\" or \"Based on notebooks developed by\" and then people's names, including journal article or software release citations if appropriate._\n", "Please consider acknowledging them if this notebook is used for the preparation of journal articles, software releases, or other notebooks." ] }, @@ -114,13 +106,7 @@ "source": [ "## 1. Introduction\n", "\n", - "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebook 12a/b about the PSF photometry (CHECK/LINK). \n", - "\n", - "_Cite or link to any external information or documentation, and cross-reference to other notebooks._\n", - "\n", - "> **Notice:** *use indented text preceded with* **Notice** *or* **Warning** *to attract attention to particular information.*\n", - "\n", - "_Embedded images or generated figures should be captioned in a markdown cell, like this._" + "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebook 12a/b about the PSF photometry (CHECK/LINK). \n" ] }, { @@ -279,7 +265,7 @@ "\n", "#import lsst.afw.display as afwDisplay\n", "#from lsst.afw.image import MultibandExposure\n", - "from lsst.daf.butler import Butler\n", + "#from lsst.daf.butler import Butler\n", "from lsst.rsp import get_tap_service\n", "#import lsst.geom as geom\n", "\n", @@ -554,8 +540,8 @@ " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "for i in range(len(bin_means)):\n", - " print(binctr[i],bin_means[i])\n", + "#for i in range(len(bin_means)):\n", + " #print(binctr[i],bin_means[i])\n", "\n", " \n", "y = (kron_mag-truth_mag)\n", @@ -591,83 +577,6 @@ "Note that the input light profiles of simulated galaxies in DP0.2 are sersic profiles; thus it is perhaps not unexpected that modeling the light as sersic profiles by the LSST pipelines to produce cModel fluxes would perform the best." ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", - "metadata": {}, - "outputs": [], - "source": [ - "zlim = 0.5\n", - "whz = np.where(results['redshift'] < zlim)[0]\n", - "whighz = np.where(results['redshift'] > zlim)[0]\n", - "\n", - "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", - "\n", - "ax.axhline(scale,linestyle='--')\n", - "\n", - "ax.plot(truth_mag[whz], (kron_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", - "ax.plot(truth_mag[whz], (cmodel_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='cModel',color='r')\n", - "\n", - "x = truth_mag[whz]\n", - "y = (cmodel_mag[whz]-truth_mag[whz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "\n", - "y = (kron_mag[whz]-truth_mag[whz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", - "\n", - "y = (gaap_mag[whz]-truth_mag[whz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", - "\n", - "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", - "#ax.set_ylim([-.2,.2])\n", - "ax.set_title('Low redshift z<'+str(zlim))\n", - "ax.set_ylim([-2,2])\n", - "\n", - "ax2.axhline(scale,linestyle='--')\n", - "\n", - "ax2.plot(truth_mag[whighz], (kron_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='Kron',color='blue')\n", - "ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", - "ax2.plot(truth_mag[whighz], (cmodel_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='cModel',color='r')\n", - "\n", - "x = truth_mag[whighz]\n", - "y = (cmodel_mag[whighz]-truth_mag[whighz])\n", - "\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax2.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "\n", - "y = (kron_mag[whighz]-truth_mag[whighz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax2.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", - "\n", - "y = (gaap_mag[whighz]-truth_mag[whighz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax2.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", - "\n", - "ax2.set_xlabel('True i-band Magnitude')\n", - "ax2.set_ylim([-2,2])\n", - "ax2.set_xlim([19,26])\n", - "ax2.set_title('High redshift z>'+str(zlim))\n", - "plt.legend()" - ] - }, { "cell_type": "markdown", "id": "8a3c30b3-721e-4cbc-abfd-8d4c9b216de8", @@ -693,7 +602,9 @@ "metadata": {}, "outputs": [], "source": [ - "#\n", + "# here add a second set of panels to try to understand the small bias at bright end of kron (is it kron radius-dependent? since its not deblending dependent?\n", + "\n", + "\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", "\n", @@ -704,7 +615,7 @@ "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", "\n", "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", - "vmax = 1\n", + "vmax = 0.2\n", "colmaplabel='Fraction of flux contaminated by neighbors'\n", "#cmap = tab['i_kronRad'][whgood]\n", "#vmax = 20\n", @@ -799,16 +710,103 @@ "ax2.legend()" ] }, + { + "cell_type": "markdown", + "id": "b16c2ecf-c99e-4b30-8d0c-1655c1cb7f92", + "metadata": {}, + "source": [ + "### 2.5 Integrated photometry for high-redshift galaxies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", + "metadata": {}, + "outputs": [], + "source": [ + "# perhaps move this to the redshift section 3\n", + "\n", + "zlim = 0.5\n", + "whz = np.where(results['redshift'] < zlim)[0]\n", + "whighz = np.where(results['redshift'] > zlim)[0]\n", + "\n", + "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", + "\n", + "ax.axhline(scale,linestyle='--')\n", + "\n", + "ax.plot(truth_mag[whz], (kron_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax.plot(truth_mag[whz], (cmodel_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='cModel',color='r')\n", + "\n", + "x = truth_mag[whz]\n", + "y = (cmodel_mag[whz]-truth_mag[whz])\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "\n", + "y = (kron_mag[whz]-truth_mag[whz])\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "\n", + "y = (gaap_mag[whz]-truth_mag[whz])\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", + "\n", + "ax.set_xlabel('True i-band Magnitude')\n", + "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", + "#ax.set_ylim([-.2,.2])\n", + "ax.set_title('Low redshift z<'+str(zlim))\n", + "ax.set_ylim([-2,2])\n", + "\n", + "ax2.axhline(scale,linestyle='--')\n", + "\n", + "ax2.plot(truth_mag[whighz], (kron_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='Kron',color='blue')\n", + "ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax2.plot(truth_mag[whighz], (cmodel_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='cModel',color='r')\n", + "\n", + "x = truth_mag[whighz]\n", + "y = (cmodel_mag[whighz]-truth_mag[whighz])\n", + "\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax2.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "\n", + "y = (kron_mag[whighz]-truth_mag[whighz])\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax2.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "\n", + "y = (gaap_mag[whighz]-truth_mag[whighz])\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax2.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", + "\n", + "ax2.set_xlabel('True i-band Magnitude')\n", + "ax2.set_ylim([-2,2])\n", + "ax2.set_xlim([19,26])\n", + "ax2.set_title('High redshift z>'+str(zlim))\n", + "plt.legend()" + ] + }, { "cell_type": "markdown", "id": "b6bc05d8-2f63-4b24-a123-4dd6620ac98a", "metadata": {}, "source": [ - "### 3. Photometry for colors\n", + "## 3. Photometry for colors\n", "\n", - "Here we show observed vs intrinsic colors to demonstrate that GaaP is good for that.\n", + "Here we show observed vs intrinsic colors to demonstrate that GaaP is good for that. Except all 3 measurements are decent and actually cModel has hte least bias (reason, and purpose of GaaP is still TBD).\n", "\n", - "Lets get multi-filter photometry and compare colors" + "First, query for the photometry in g and z bands (which will have a large difference in spatial resolution given their relatively large difference wavelengths). u and y band would have an even larger wavelength baseline for comparison, but g and z have better throughput and thus S/N are typically higher. Like earlier sections, also retrieve the truth table input fluxes as a baseline for assessing accuracy in color between the different measurements." ] }, { @@ -839,16 +837,8 @@ "job = service.submit_job(query)\n", "job.run()\n", "job.wait(phases=['COMPLETED', 'ERROR'])\n", - "print('Job phase is', job.phase)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9f0d67e0-93f6-40ff-a099-b30f5e6f8739", - "metadata": {}, - "outputs": [], - "source": [ + "print('Job phase is', job.phase)\n", + "\n", "results = job.fetch_result()\n", "tab = results.to_table()" ] @@ -888,9 +878,9 @@ "cmodel_color = g_cmodel_mag - z_cmodel_mag\n", "gaap_color = g_gaap_mag - z_gaap_mag\n", "\n", - "ax.plot(z_kron_mag, kron_color-truth_color, '.',alpha=.5, label='Kron',color='b')\n", - "ax.plot(z_cmodel_mag, cmodel_color-truth_color, '.',alpha=.5, label='cModel',color='r')\n", - "ax.plot(z_gaap_mag, gaap_color-truth_color, '.',alpha=.5, label='GaaP optimal',color='g')\n", + "ax.plot(z_kron_mag, kron_color-truth_color, '.',alpha=.5, label='Kron '+str(np.median(kron_color-truth_color)),color='b')\n", + "ax.plot(z_cmodel_mag, cmodel_color-truth_color, '.',alpha=.5, label='cModel '+str(np.median(cmodel_color-truth_color)),color='r')\n", + "ax.plot(z_gaap_mag, gaap_color-truth_color, '.',alpha=.5, label='GaaP optimal '+str(np.median(gaap_color-truth_color)),color='g')\n", "\n", "ax2.hist((kron_color-truth_color),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 80),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "ax2.hist((gaap_color-truth_color),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 80),align='mid',histtype=\"step\",stacked=True,fill=False)\n", @@ -906,6 +896,9 @@ "ax.axhline(0)\n", "ax.set_ylim(ylims)\n", "ax.set_xlim([16,26])\n", + "ax.set_xlabel('Observed g-band Magnitude')\n", + "ax.set_ylabel('Observed g-z color - True g-z color')\n", + "#ax2.set_ylabel('Observed g-z color - True g-z color')\n", "ax.legend()" ] }, @@ -915,7 +908,7 @@ "metadata": {}, "source": [ "### 4. Photometry for light profiles (i.e. how to use aperture photometry)\n", - "\n", + "Science application for aperture fluxes\n", "Not sure how to do this yet" ] }, @@ -1207,14 +1200,6 @@ "plt.show()" ] }, - { - "cell_type": "markdown", - "id": "b16c2ecf-c99e-4b30-8d0c-1655c1cb7f92", - "metadata": {}, - "source": [ - "# 3. Integrated photometry for high-redshift galaxies" - ] - }, { "cell_type": "markdown", "id": "b7ec87d9-8f56-4974-a9c4-052af0fec039", @@ -1227,9 +1212,7 @@ "cell_type": "markdown", "id": "6cc1a4dc-5256-48f5-a4d1-8100458c058b", "metadata": {}, - "source": [ - "# 5. Science application for aperture fluxes" - ] + "source": [] }, { "cell_type": "markdown", From f996f8704815e5ecb4f043befc3e1df3462c93f7 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 13 Jan 2025 23:24:02 +0000 Subject: [PATCH 43/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 94 +++++++++++++-------------------- 1 file changed, 36 insertions(+), 58 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 5ce2f95..e53651b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -18,19 +18,6 @@ "Targeted learning level: <i>beginner</i> <br>" ] }, - { - "cell_type": "markdown", - "id": "2d9cd09b-d5c4-4610-993b-711bdc9bd80e", - "metadata": {}, - "source": [ - "_In this template, text in italics are examples or instructions that should be: \n", - "(a) removed if it is not applicable to the notebook; \n", - "or (b) replaced with text that is appropriate for the notebook. \n", - "But bold or regular text should appear pretty much as-is in all CET notebooks._\n", - "\n", - "_Remember to use the [CST's Guidelines for Tutorial Notebooks](rtn-045.lsst.io)._" - ] - }, { "cell_type": "code", "execution_count": null, @@ -184,7 +171,7 @@ "\n", "#### GaaP fluxes\n", "\n", - "The Gaussian-aperture-and-PSF flux from <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>. The main goal of this method is to measure accurate colors while accounting for the different spatial resolution between filters. This is sometimes done by convolving all images to the largest PSF, but this process is computationally very time consuming for large images. It is not a measure of total flux in a filter. For photometric redshifts, since accurate colors are important, it is the GaaP fluxes that should be used.\n", + "These are the Gaussian-aperture-and-PSF flux from <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>. The main goal of this method is to measure accurate colors while accounting for the different spatial resolution between filters. This is sometimes done by convolving all images to the largest PSF, but this process is computationally very time consuming for large images. It is not a measure of total flux in a filter. For photometric redshifts, since accurate colors are important, it is the GaaP fluxes that should be used. Several apertures are available (TBD: what is optimal aperture based on?)\n", "\n", "**Optimal**\n", "\n", @@ -280,7 +267,7 @@ "source": [ "### 1.3 Define functions and parameters\n", "\n", - "_If your notebook defines functions or parameters to use later or throughout, do it here in sub-section 1.2._\n", + "_TBD if we can remove this_\n", "\n", "_It is OK to rename the subsection to be more specific to the notebook, and/or to use sub-sub-sections like \"1.2.1 Define global cosmological parameter values\" or \"1.2.2 Define a function to make an image cutout\"._\n", "\n", @@ -315,7 +302,7 @@ "id": "45c86ed0-aebe-4d74-af42-619c0f6b0705", "metadata": {}, "source": [ - "### 2.1 Initialize the TAP service, and istantiate the Butler (may not need; TBD delete)" + "### 2.1 Initialize the TAP service" ] }, { @@ -328,16 +315,6 @@ "service = get_tap_service(\"tap\")" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "6ad9a3ea-5d4c-4247-b0ff-712fafa00bb3", - "metadata": {}, - "outputs": [], - "source": [ - "#butler = Butler('dp02', collections='2.2i/runs/DP0.2')" - ] - }, { "cell_type": "markdown", "id": "9547e659-fd0e-432c-af25-968cc9ebea9d", @@ -345,7 +322,7 @@ "source": [ "### 2.2 Object table photometry measurements\n", "\n", - "First see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band " + "First see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " ] }, { @@ -467,6 +444,14 @@ "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" ] }, + { + "cell_type": "markdown", + "id": "4f28e9cf-fd39-4281-8c56-e4f1040475df", + "metadata": {}, + "source": [ + "The next cell will compare the percent difference between the three different photometric measurements with the input (truth). Additionally a running median is calculated to help interpret the typical accuracy of the different methods. The median has the best overall percent accuracy for cModel. Additionally, the Gaussian and PSF photometry is highly inaccurate, as explained in Section 1.1 this is not meant to measure the total flux of galaxies, but rather to measure accurate colors using a sub-region of each galaxy. Deviation from truth for this measurement is thus expected." + ] + }, { "cell_type": "code", "execution_count": null, @@ -476,13 +461,9 @@ "source": [ "fig, ax = plt.subplots()\n", "\n", - "scale = 0\n", - "\n", - "ax.axhline(scale,linestyle='--')\n", - "\n", - "ax.plot(truth_mag, scale+(tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='cModel',color='r')\n", - "ax.plot(truth_mag, scale+(tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag, scale+(tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1, label='gaapOptimal',color='green')\n", + "ax.plot(truth_mag, (tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='cModel',color='r')\n", + "ax.plot(truth_mag, (tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(truth_mag, (tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1, label='gaapOptimal',color='green')\n", "\n", "x = truth_mag\n", "y = (tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] *100\n", @@ -504,15 +485,24 @@ "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", "\n", + "ax.axhline(0,linestyle='--')\n", "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Flux Percent Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$')\n", - "\n", + "ax.set_ylabel('Flux Percent Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$ x 100%')\n", "ax.set_ylim([-100,100])\n", "ax.set_xlim([14,27])\n", - "\n", "plt.legend()\n" ] }, + { + "cell_type": "markdown", + "id": "0d55a187-ccc9-4975-9868-a716e1106559", + "metadata": {}, + "source": [ + "Below, take a closer look at the differences in AB magnitude and how the overall distributions compare. While the systematic offset of GaaP is clear, the medians of Kron and cModel both compare well. These two plots indicate that there is excellent agreement between the cModel measurements and the input, at the level of < 0.03 magnitude at ABmag of < 25. Kron is also adequate overall, although at intermediate magnitudes (ABmag ~ 18-22) exhibits a slight underestimate of flux (overestimate in magnitude of order 0.1-0.2). \n", + "\n", + "Note that the input light profiles of simulated galaxies in DP0.2 are sersic profiles; thus it is perhaps not unexpected that modeling the light as sersic profiles by the LSST pipelines to produce cModel fluxes would perform the best." + ] + }, { "cell_type": "code", "execution_count": null, @@ -522,7 +512,6 @@ "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-1.2,1.2]\n", - "ax.axhline(scale,linestyle='--')\n", "\n", "ax.plot(truth_mag, (kron_mag-truth_mag),'.',alpha=.1,label='Kron',color='blue')\n", "ax.plot(truth_mag, (gaap_mag-truth_mag),'.',alpha=.1, label='gaapOptimal',color='green')\n", @@ -540,8 +529,8 @@ " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "#for i in range(len(bin_means)):\n", - " #print(binctr[i],bin_means[i])\n", + "for i in range(len(bin_means)):\n", + " print(binctr[i],bin_means[i],'cModel')\n", "\n", " \n", "y = (kron_mag-truth_mag)\n", @@ -550,7 +539,7 @@ "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "for i in range(len(bin_means)):\n", - " print(binctr[i],bin_means[i])\n", + " print(binctr[i],bin_means[i],'kron')\n", "\n", "y = (gaap_mag-truth_mag)\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", @@ -558,23 +547,12 @@ "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", "\n", + "ax.axhline(0,linestyle='--')\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Magnitude difference (M$_{obs}$ - M$_{true}$)')\n", "ax.set_xlim([14,27])\n", "ax.set_ylim(ylims)\n", - "ax.legend()\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "ea330668-f260-4e95-a3a1-8a028ac4c0f2", - "metadata": {}, - "source": [ - "These two plots indicate that there is excellent agreement between the cModel measurements and the input, at the level of < 0.1 magnitude at ABmag of < 25. Kron is also adequate although exhibits a slight underestimate of flux (overestimate in magnitude of order 0.03) compared to the input at intermediate magnitudes (ABmag ~ 18-22). \n", - "\n", - "Note that the input light profiles of simulated galaxies in DP0.2 are sersic profiles; thus it is perhaps not unexpected that modeling the light as sersic profiles by the LSST pipelines to produce cModel fluxes would perform the best." + "ax.legend()\n" ] }, { @@ -582,13 +560,13 @@ "id": "8a3c30b3-721e-4cbc-abfd-8d4c9b216de8", "metadata": {}, "source": [ - "Below, compare the Kron magnitudes to truth under various circumstances. 2 basic paramters are set: extendedness = 1 means its a galaxy. Kronflag = 0 means there were no problems flagged in the flux measurement. \n", + "The next cells will explore and compare the Kron magnitudes to truth under various circumstances. 2 basic paramters are set: extendedness = 1 means the source is a galaxy; kronFlag = 0 identifies galaxies for which there were no problems flagged in the Kron flux measurement. \n", "\n", - "Then we test whether blending impacts the photometry:\n", + "Test whether the following blending parameters indicate that blending contributes to the inaccurate measurement of the photometry:\n", "\n", - "1) detect_fromBlend = 1 means some deblending happened prior to flux measurement. this is responsible for some under-estimated magnitude (over-estimated flux) perhaps because neighbors were not removed at the bright end?\n", + "1) detect_fromBlend = 1 means some deblending happened prior to flux measurement. This is responsible for some under-estimated magnitude (over-estimated flux) perhaps because neighbors were not removed at the bright end?\n", "\n", - "2) The increased scatter at faint mags is due to increased fraction of flux contaminated by neighbors i_blendedness: (1 - child_flux/parent_flux)\n", + "2) The increased scatter at faint magnitudes is due to increased fraction of flux contaminated by neighbors i_blendedness: (1 - child_flux/parent_flux)\n", " \n", "3) detect_isIsolated = 1 means no deblending and the galaxy has no blended neighbors. The upturn at bright mags is not there among isolated galaxies\n", "\n", From daf3a0e114b5f33c6d5e6df1303906f98cd15734 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 13 Jan 2025 23:47:44 +0000 Subject: [PATCH 44/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 54 +++++++++++++++++---------------- 1 file changed, 28 insertions(+), 26 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index e53651b..c8afb49 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -582,28 +582,22 @@ "source": [ "# here add a second set of panels to try to understand the small bias at bright end of kron (is it kron radius-dependent? since its not deblending dependent?\n", "\n", - "\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", - "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", - "\n", - "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", - "\n", - "# Remove i_extendedness, you put it directly into the query instead\n", "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", "\n", + "# color scale by blendedness, or by kron radius to see dependence\n", "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", "vmax = 0.2\n", "colmaplabel='Fraction of flux contaminated by neighbors'\n", - "#cmap = tab['i_kronRad'][whgood]\n", - "#vmax = 20\n", - "#colmaplabel='Kron Radius [pixels]'\n", + "cmap = tab['i_kronRad'][whgood]\n", + "vmax = 12\n", + "colmaplabel='Kron Radius [pixels]'\n", "\n", - "#ax.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='fromBlend')\n", - "ax.axhline(scale,linestyle='--')\n", - "ax.set_title('Kron Photometry')\n", "\n", + "ax.axhline(0,linestyle='--')\n", + "ax.set_title('Kron Photometry')\n", "ax.set_xlabel('truth AB Magnitude [i-band]')\n", "ax.set_ylabel('Mag Percent Accuracy (M$_{obs}$ - M$_{true}$) ')\n", "ax.set_xlim([16,26])\n", @@ -611,18 +605,23 @@ "ax.legend()\n", "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", - "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", + "\n", + "# color scale by blendedness, or by kron radius to see dependence\n", "cmap = tab['i_blendedness'][whgood]\n", + "vmax = 0.2\n", + "colmaplabel='Fraction of flux contaminated by neighbors'\n", + "cmap = tab['i_kronRad'][whgood]\n", + "vmax = 12\n", + "colmaplabel='Kron Radius [pixels]'\n", "\n", - "#ax2.scatter(truth_mag,(kron_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='isIsolated')\n", "print(len(whgood))\n", "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", - "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", + "ax2.set_ylabel('Magnitude offset (M$_{obs}$ - M$_{true}$) ')\n", "ax2.set_ylim([-1,1])\n", "ax2.set_xlim([16,26])\n", "ax2.legend()\n", - "ax2.axhline(scale,linestyle='--')\n", + "ax2.axhline(0,linestyle='--')\n", "ax2.set_title('Kron Photometry')\n", "\n", "fig.subplots_adjust(right=0.8)\n", @@ -630,6 +629,14 @@ "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n" ] }, + { + "cell_type": "markdown", + "id": "947bfd05-2762-4525-bac4-83745a230999", + "metadata": {}, + "source": [ + "The above plots show that blending and contamination of flux by neighbors can result in inaccurate flux among the strong outliers, but does not cause the systematic overestimate in magnitude by Kron measurements at intermediate magnitudes. However, it is also the case that nearly none of these overestimated sources are isolated (they are blended with neibors). Large galaxy radius does increase with brightness but otherwise does not seem to give rise to the offset. (TBD: otherwise perhaps its the case that kron is not a good measure of multi-component light profiles, and the sum of 2 sersic models does a better job? Not sure how to test that)." + ] + }, { "cell_type": "code", "execution_count": null, @@ -638,17 +645,12 @@ "outputs": [], "source": [ "# the following plots are identical, consider a different comparison that is informative\n", - "\n", - "\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", - "#whblend = np.where( tab['detect_fromBlend'][whbright] == False)[0]\n", - "\n", - "# Pick things where there was no flagged error in the Kron meausrement, and things that are extended (i.e. galaxies)\n", "\n", "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", "\n", "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", - "vmax = 1\n", + "vmax = 0.2\n", "colmaplabel='Fraction of flux contaminated by neighbors'\n", "\n", "#cmap = tab['i_kronRad'][whgood]\n", @@ -663,7 +665,7 @@ "ax.set_ylabel('Mag Fractional Accuracy (M$_{obs}$ - M$_{true}$) ')\n", "ax.set_ylim([-1,1])\n", "ax.set_xlim([16,26])\n", - "ax.axhline(scale,linestyle='--')\n", + "ax.axhline(0,linestyle='--')\n", "ax.set_title('cModel Photometry')\n", "ax.legend()\n", "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", @@ -677,7 +679,7 @@ "#ax2.set_ylim([-1.5,1.5])\n", "ax2.set_ylim([-1,1])\n", "ax2.set_xlim([16,26])\n", - "ax2.axhline(scale,linestyle='--')\n", + "ax2.axhline(0,linestyle='--')\n", "print(len(whgood))\n", "\n", "fig.subplots_adjust(right=0.8)\n", @@ -711,7 +713,7 @@ "\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", "\n", - "ax.axhline(scale,linestyle='--')\n", + "ax.axhline(0,linestyle='--')\n", "\n", "ax.plot(truth_mag[whz], (kron_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='Kron',color='blue')\n", "ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", @@ -742,7 +744,7 @@ "ax.set_title('Low redshift z<'+str(zlim))\n", "ax.set_ylim([-2,2])\n", "\n", - "ax2.axhline(scale,linestyle='--')\n", + "ax2.axhline(0,linestyle='--')\n", "\n", "ax2.plot(truth_mag[whighz], (kron_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='Kron',color='blue')\n", "ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", From fd2cef6487cbd0448070ea3a19f1260392372920 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 14 Jan 2025 20:37:20 +0000 Subject: [PATCH 45/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 54 ++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 24 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index c8afb49..5991308 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -449,7 +449,7 @@ "id": "4f28e9cf-fd39-4281-8c56-e4f1040475df", "metadata": {}, "source": [ - "The next cell will compare the percent difference between the three different photometric measurements with the input (truth). Additionally a running median is calculated to help interpret the typical accuracy of the different methods. The median has the best overall percent accuracy for cModel. Additionally, the Gaussian and PSF photometry is highly inaccurate, as explained in Section 1.1 this is not meant to measure the total flux of galaxies, but rather to measure accurate colors using a sub-region of each galaxy. Deviation from truth for this measurement is thus expected." + "The next cell will compare the percent difference between the three different photometric measurements with the input (truth). Additionally a running median is calculated to help interpret the typical accuracy of the different methods. The median has the best overall percent accuracy for cModel, which is has < 3.5% median deviation for all magnitudes < 24 ABmag. Additionally, the Gaussian and PSF photometry is highly inaccurate, as explained in Section 1.1 this is not meant to measure the total flux of galaxies, but rather to measure accurate colors using a sub-region of each galaxy. Deviation from truth for this measurement is thus expected." ] }, { @@ -472,12 +472,16 @@ " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", + "for i in range(len(bin_means)):\n", + " print(binctr[i],bin_means[i],'cModel')\n", "\n", "y = (tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] *100\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", " y, statistic='median', bins=bins)\n", "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", + "for i in range(len(bin_means)):\n", + " print(binctr[i],bin_means[i],'kron')\n", "\n", "y = (tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100\n", "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", @@ -709,14 +713,15 @@ "\n", "zlim = 0.5\n", "whz = np.where(results['redshift'] < zlim)[0]\n", - "whighz = np.where(results['redshift'] > zlim)[0]\n", + "whighz = np.where(results['redshift'] >= zlim)[0]\n", + "print(len(results['redshift']),len(whz),len(whighz))\n", "\n", "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", "\n", "ax.axhline(0,linestyle='--')\n", "\n", "ax.plot(truth_mag[whz], (kron_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "#ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", "ax.plot(truth_mag[whz], (cmodel_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='cModel',color='r')\n", "\n", "x = truth_mag[whz]\n", @@ -732,22 +737,23 @@ "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", - "y = (gaap_mag[whz]-truth_mag[whz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", + "#y = (gaap_mag[whz]-truth_mag[whz])\n", + "#bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + "# y, statistic='median', bins=bins)\n", + "#binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "#ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", "\n", "ax.set_xlabel('True i-band Magnitude')\n", "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", "#ax.set_ylim([-.2,.2])\n", + "ax.set_xlim([16,26])\n", "ax.set_title('Low redshift z<'+str(zlim))\n", - "ax.set_ylim([-2,2])\n", + "ax.set_ylim([-1,1])\n", "\n", "ax2.axhline(0,linestyle='--')\n", "\n", "ax2.plot(truth_mag[whighz], (kron_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='Kron',color='blue')\n", - "ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "#ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", "ax2.plot(truth_mag[whighz], (cmodel_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='cModel',color='r')\n", "\n", "x = truth_mag[whighz]\n", @@ -764,15 +770,15 @@ "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", "ax2.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", "\n", - "y = (gaap_mag[whighz]-truth_mag[whighz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax2.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", + "#y = (gaap_mag[whighz]-truth_mag[whighz])\n", + "#bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + "# y, statistic='median', bins=bins)\n", + "#binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "#ax2.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", "\n", "ax2.set_xlabel('True i-band Magnitude')\n", - "ax2.set_ylim([-2,2])\n", - "ax2.set_xlim([19,26])\n", + "ax2.set_ylim([-1,1])\n", + "ax2.set_xlim([16,26])\n", "ax2.set_title('High redshift z>'+str(zlim))\n", "plt.legend()" ] @@ -906,7 +912,7 @@ " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.10)) = 1 \"" + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"" ] }, { @@ -942,7 +948,7 @@ "source": [ "# pick an object that has large size\n", "wh = np.where(tab['i_kronRad'] > 10)[0]\n", - "print(len(wh), tab['i_kronRad'][wh])\n", + "#print(len(wh), tab['i_kronRad'][wh])\n", "\n", "rad = np.array([3,6,9,12,17,25,35,50])\n", "light_profile = np.array([tab['i_ap03Flux'][wh][0],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][0],tab['i_ap12Flux'][wh][0],tab['i_ap17Flux'][wh][0],\n", @@ -953,12 +959,12 @@ "\n", "# pick an object that has large size\n", "wh = np.where(tab['i_kronRad'] < 5)[0]\n", - "print(len(wh), tab['i_kronRad'][wh])\n", - "\n", + "#print(len(wh), tab['i_kronRad'][wh])\n", + "indx = 10\n", "rad = np.array([3,6,9,12,17,25,35,50])\n", - "light_profile = np.array([tab['i_ap03Flux'][wh][0],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][0],tab['i_ap12Flux'][wh][0],tab['i_ap17Flux'][wh][0],\n", - " tab['i_ap25Flux'][wh][0],tab['i_ap35Flux'][wh][0],tab['i_ap50Flux'][wh][0]])\n", - "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh][0]))\n", + "light_profile = np.array([tab['i_ap03Flux'][wh][indx],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][indx],tab['i_ap12Flux'][wh][indx],tab['i_ap17Flux'][wh][indx],\n", + " tab['i_ap25Flux'][wh][indx],tab['i_ap35Flux'][wh][indx],tab['i_ap50Flux'][wh][indx]])\n", + "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh][indx]))\n", "plt.legend()\n" ] }, From 1c07af72a33c0fa2b74cfdfbbc0b790cf1e4dabe Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 14 Jan 2025 23:13:04 +0000 Subject: [PATCH 46/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 268 ++++++++++++++++++++++++++++++-- 1 file changed, 253 insertions(+), 15 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 5991308..6ee41ec 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -257,7 +257,37 @@ "#import lsst.geom as geom\n", "\n", "from scipy import stats#.binned_statistic\n", - "from scipy.stats import sigmaclip\n" + "from scipy.stats import sigmaclip\n", + "\n", + "\n", + "# stuff for cutout\n", + "import time\n", + "import numpy as np\n", + "import uuid\n", + "import os\n", + "import glob\n", + "import math\n", + "import pandas\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "from IPython.display import Image as dimg\n", + "\n", + "import lsst.geom as geom\n", + "import lsst.resources\n", + "import lsst.afw.display as afwDisplay\n", + "from lsst.afw.image import Exposure, ExposureF\n", + "from lsst.pipe.tasks.registerImage import RegisterConfig, RegisterTask\n", + "from lsst.rsp import get_tap_service\n", + "from lsst.rsp.utils import get_access_token\n", + "from lsst.afw.fits import MemFileManager\n", + "\n", + "import pyvo\n", + "from pyvo.dal.adhoc import DatalinkResults, SodaQuery\n", + "\n", + "from astropy import units as u\n", + "from astropy.coordinates import SkyCoord, Angle\n", + "from astropy.io import fits\n", + "from astropy.wcs import WCS\n" ] }, { @@ -282,7 +312,157 @@ "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", - "#afwDisplay.setDefaultBackend('matplotlib')" + "#afwDisplay.setDefaultBackend('matplotlib')\n", + "afwDisplay.setDefaultBackend('matplotlib')\n", + "\n", + "params = {'axes.labelsize': 18,\n", + " 'font.size': 18,\n", + " 'legend.fontsize': 12,\n", + " 'xtick.major.width': 2,\n", + " 'xtick.minor.width': 1,\n", + " 'xtick.major.size': 10,\n", + " 'xtick.minor.size': 4,\n", + " 'xtick.direction': 'in',\n", + " 'xtick.top': True,\n", + " 'lines.linewidth': 2,\n", + " 'axes.linewidth': 2,\n", + " 'axes.labelweight': 2,\n", + " 'axes.titleweight': 2,\n", + " 'ytick.major.width': 2,\n", + " 'ytick.minor.width': 1,\n", + " 'ytick.major.size': 10,\n", + " 'ytick.minor.size': 4,\n", + " 'ytick.direction': 'in',\n", + " 'ytick.right': True,\n", + " 'figure.figsize': [6, 6],\n", + " 'figure.facecolor': 'White'\n", + " }\n", + "plt.style.use('tableau-colorblind10')\n", + "\n", + "plt.rcParams.update(params)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f19f3b6-7357-4848-a2b4-5597aa8c8e15", + "metadata": {}, + "outputs": [], + "source": [ + "def plotImage(exposure: ExposureF):\n", + " \"\"\"Plot and image using lsst.awf.image package\n", + "\n", + " Parameters\n", + " ----------\n", + " exposure : `ExposureF`\n", + " the image to plot from file in LSST awf image exposure class format\n", + "\n", + " Returns\n", + " -------\n", + " image for notebook display\n", + " \"\"\"\n", + "\n", + " fig, ax = plt.subplots()\n", + " display = afwDisplay.Display(frame=fig)\n", + " display.scale('asinh', 'zscale')\n", + " display.mtv(exposure.image)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da81a645-947e-4ca2-82f7-905de4ef79da", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "def make_image_cutout(tap_service, ra, dec, dataId, cutout_size=0.01,\n", + " imtype=None, filename=None):\n", + " \"\"\"Wrapper function to generate a cutout using the cutout tool\n", + "\n", + " Parameters\n", + " ----------\n", + " tap_service : an instance of the TAP service\n", + " ra, dec : 'float'\n", + " the ra and dec of the cutout center\n", + " dataId : 'dict'\n", + " the dataId of the image to make a cutout from. The format\n", + " must correspond to that provided for parameter 'imtype'\n", + " cutout_size : 'float', optional\n", + " edge length in degrees of the cutout\n", + " imtype : 'string', optional\n", + " string containing the type of LSST image to generate\n", + " a cutout of (e.g. deepCoadd, calexp). If imtype=None,\n", + " the function will assume a deepCoadd.\n", + " filename : 'string', optional\n", + " filename of the resulting cutout (which has fits format)\n", + "\n", + " Returns\n", + " -------\n", + " sodaCutout : 'string'\n", + " filename of the cutout in fits format (including\n", + " full directory path; for now by default it is saved\n", + " in /home/dp02_13a_temp/\n", + " \"\"\"\n", + "\n", + " spherePoint = geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", + "\n", + " if imtype == 'calexp':\n", + "\n", + " query = \"SELECT access_format, access_url, dataproduct_subtype, \" + \\\n", + " \"lsst_visit, lsst_detector, lsst_band, s_ra, s_dec \" + \\\n", + " \"FROM ivoa.ObsCore WHERE dataproduct_type = 'image' \" + \\\n", + " \"AND obs_collection = 'LSST.DP02' \" + \\\n", + " \"AND dataproduct_subtype = 'lsst.calexp' \" + \\\n", + " \"AND lsst_visit = \" + str(dataId[\"visit\"]) + \" \" + \\\n", + " \"AND lsst_detector = \" + str(dataId[\"detector\"])\n", + " results = tap_service.search(query)\n", + "\n", + " else:\n", + " # Find the tract and patch that contain this point\n", + " tract = dataId[\"tract\"]\n", + " patch = dataId[\"patch\"]\n", + "\n", + " # add optional default band if it is not contained in the dataId\n", + " band = dataId[\"band\"]\n", + "\n", + " query = \"SELECT access_format, access_url, dataproduct_subtype, \" + \\\n", + " \"lsst_patch, lsst_tract, lsst_band, s_ra, s_dec \" + \\\n", + " \"FROM ivoa.ObsCore WHERE dataproduct_type = 'image' \" + \\\n", + " \"AND obs_collection = 'LSST.DP02' \" + \\\n", + " \"AND dataproduct_subtype = 'lsst.deepCoadd_calexp' \" + \\\n", + " \"AND lsst_tract = \" + str(tract) + \" \" + \\\n", + " \"AND lsst_patch = \" + str(patch) + \" \" + \\\n", + " \"AND lsst_band = \" + \"'\" + str(band) + \"' \"\n", + " results = tap_service.search(query)\n", + "\n", + " # Get datalink\n", + " dataLinkUrl = results[0].getdataurl()\n", + " auth_session = service._session\n", + " dl = DatalinkResults.from_result_url(dataLinkUrl,\n", + " session=auth_session)\n", + "\n", + " # from_resource: creates a instance from\n", + " # a number of records and a Datalink Resource.\n", + " sq = SodaQuery.from_resource(dl,\n", + " dl.get_adhocservice_by_id(\"cutout-sync\"),\n", + " session=auth_session)\n", + "\n", + " sq.circle = (spherePoint.getRa().asDegrees() * u.deg,\n", + " spherePoint.getDec().asDegrees() * u.deg,\n", + " cutout_size * u.deg)\n", + "\n", + " if filename:\n", + " sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/'+filename)\n", + " else:\n", + " sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/soda-cutout.fits')\n", + "\n", + " with open(sodaCutout, 'bw') as f:\n", + " f.write(sq.execute_stream().read())\n", + "\n", + " return sodaCutout\n" ] }, { @@ -638,7 +818,63 @@ "id": "947bfd05-2762-4525-bac4-83745a230999", "metadata": {}, "source": [ - "The above plots show that blending and contamination of flux by neighbors can result in inaccurate flux among the strong outliers, but does not cause the systematic overestimate in magnitude by Kron measurements at intermediate magnitudes. However, it is also the case that nearly none of these overestimated sources are isolated (they are blended with neibors). Large galaxy radius does increase with brightness but otherwise does not seem to give rise to the offset. (TBD: otherwise perhaps its the case that kron is not a good measure of multi-component light profiles, and the sum of 2 sersic models does a better job? Not sure how to test that)." + "The above plots show that blending and contamination of flux by neighbors can result in inaccurate flux among the strong outliers, but does not cause the systematic overestimate in magnitude by Kron measurements at intermediate magnitudes. However, it is also the case that nearly none of these overestimated sources are isolated (they are blended with neibors). Large galaxy radius does increase with brightness but otherwise does not seem to give rise to the offset. (TBD: otherwise perhaps its the case that kron is not a good measure of multi-component light profiles, and the sum of 2 sersic models does a better job? Not sure how to test that. Andreon et al. 2002 says \"the 2MASS isophotal mag misses some 0.1 mag with respect the Kron–like mag listed in the 2MASS database, which in turn misses about 0.15 mag with respect the true Kron mag (because computed on a too small object region), which in turn misses 5 to 10% of the total flux.).\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6fdf7c38-0c80-4351-856d-8390d22ad375", + "metadata": {}, + "outputs": [], + "source": [ + "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", + "\n", + "whtest = np.where((truth_mag[whgood] < 20) & \n", + " ((kron_mag[whgood]-truth_mag[whgood]) > 0.15) & \n", + " ((kron_mag[whgood]-truth_mag[whgood]) < 0.25))[0]\n", + "\n", + "print(whtest)\n", + "for i in range(len(whtest)):\n", + " ra = results['ra'][whgood][whtest][i]\n", + " dec = results['dec'][whgood][whtest][i]\n", + " coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree, frame='icrs')\n", + " radius = .1 * u.deg\n", + "\n", + " spherePoint = lsst.geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", + "\n", + " query = \"SELECT lsst_patch, lsst_tract, s_region, \" + \\\n", + " \"access_format, access_url, dataproduct_subtype \" + \\\n", + " \"FROM ivoa.ObsCore \" + \\\n", + " \"WHERE dataproduct_type = 'image' \" + \\\n", + " \"AND obs_collection = 'LSST.DP02' \" + \\\n", + " \"AND dataproduct_subtype = 'lsst.deepCoadd_calexp' \" + \\\n", + " \"AND lsst_band = 'i' \" + \\\n", + " \"AND CONTAINS(POINT('ICRS', \" + str(coord.ra.value) + \\\n", + " \", \" + str(coord.dec.value) + \"), \" + \\\n", + " \"s_region) = 1\"\n", + "\n", + " job = service.submit_job(query)\n", + " job.run()\n", + " job.wait(phases=['COMPLETED', 'ERROR'])\n", + " print('Job phase is', job.phase)\n", + " assert job.phase == 'COMPLETED'\n", + " results2 = job.fetch_result()\n", + " results2.to_table()\n", + "\n", + " tract = results2['lsst_tract'][0]\n", + " patch = results2['lsst_patch'][0]\n", + "\n", + " dataId = {'band': 'i', 'tract': tract,\n", + " 'patch': patch}\n", + "\n", + " print(dataId, ra, dec, patch, tract)\n", + " imtype = 'deepCoadd'\n", + " sodaCutout = make_image_cutout(service, ra, dec, dataId=dataId,\n", + " imtype=imtype, cutout_size=0.005)\n", + " plotImage(ExposureF(sodaCutout))\n", + "\n", + "sys.exit()" ] }, { @@ -699,7 +935,9 @@ "id": "b16c2ecf-c99e-4b30-8d0c-1655c1cb7f92", "metadata": {}, "source": [ - "### 2.5 Integrated photometry for high-redshift galaxies" + "### 2.5 Integrated photometry for high-redshift galaxies\n", + "\n", + "This section compares the photometry measurements for both low redshift and high redshift galaxies to see if one performs better for larger or smaller galaxies. In both cases it seems that while `kron` and `cModel` are both adequate, like the previous section, on average `cModel` has slightly better performance, in particular at bright magnitudes." ] }, { @@ -709,7 +947,6 @@ "metadata": {}, "outputs": [], "source": [ - "# perhaps move this to the redshift section 3\n", "\n", "zlim = 0.5\n", "whz = np.where(results['redshift'] < zlim)[0]\n", @@ -809,7 +1046,7 @@ " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.u_kronFlux/obj.u_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.g_kronFlux/obj.g_kronFluxErr > 10) AND (obj.g_extendedness = 1) AND \"\\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"" ] }, @@ -855,6 +1092,7 @@ "outputs": [], "source": [ "# very confused about why these colors line up so perfectly when the mags do not...\n", + "# maybe on the fainter end (S/N ~ 5) the colors differ more? Check.\n", "\n", "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-0.2,0.2]\n", @@ -1028,14 +1266,6 @@ "print(bin_means)\n" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "2f52232f-8e56-4118-8454-66593a552ddc", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, @@ -1217,7 +1447,15 @@ "\n", "can we think of a science case we would want to use galaxy photometry from a calexp? this is probably a different science case. lets exclude calexp photometry form this notebook. \n", "\n", - "when you're ready for input from DM make a list of what i want help with (so Yusra can find someone for help and then help them respond to specific questions" + "when you're ready for input from DM make a list of what i want help with (so Yusra can find someone for help and then help them respond to specific questions\n", + "\n", + "pull out a minimum (short) version of htis that is just hte stuff i'm sure about (descriptive) minimal on science demo. try to compare one measurement to the other (problem with truth is that people may remember forever that cmodel is best however it could just be that cmodel recovered with cmodel performed well.\n", + "\n", + "find a galaxy and show difference size of apertures on there as a demo. upper undergrad level. \n", + "\n", + "we are def going to have object catalogs for DP1 so we iwll need a tutorial for that. \n", + "\n", + "have shenming review (does weak lensing and. first talk to melissa to let her know then she will see hwat shenming is up to." ] } ], From 1cd852fc1bd12a78072c2c2d7b548671410bd259 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 14 Jan 2025 23:57:28 +0000 Subject: [PATCH 47/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 674 +++++++++++++++++++++++++++++--- 1 file changed, 629 insertions(+), 45 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 6ee41ec..258e38c 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -20,9 +20,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:03.459964Z", + "iopub.status.busy": "2025-01-14T23:31:03.459809Z", + "iopub.status.idle": "2025-01-14T23:31:03.462357Z", + "shell.execute_reply": "2025-01-14T23:31:03.461815Z", + "shell.execute_reply.started": "2025-01-14T23:31:03.459949Z" + } + }, "outputs": [], "source": [ "#%load_ext pycodestyle_magic\n", @@ -236,9 +244,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "2dbc75bd-a802-4576-8628-4e0088942303", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:03.462996Z", + "iopub.status.busy": "2025-01-14T23:31:03.462856Z", + "iopub.status.idle": "2025-01-14T23:31:07.257542Z", + "shell.execute_reply": "2025-01-14T23:31:07.257026Z", + "shell.execute_reply.started": "2025-01-14T23:31:03.462982Z" + } + }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -306,9 +322,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:07.258678Z", + "iopub.status.busy": "2025-01-14T23:31:07.258111Z", + "iopub.status.idle": "2025-01-14T23:31:07.285337Z", + "shell.execute_reply": "2025-01-14T23:31:07.284744Z", + "shell.execute_reply.started": "2025-01-14T23:31:07.258659Z" + } + }, "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", @@ -344,9 +368,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "2f19f3b6-7357-4848-a2b4-5597aa8c8e15", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:07.286246Z", + "iopub.status.busy": "2025-01-14T23:31:07.286076Z", + "iopub.status.idle": "2025-01-14T23:31:07.289532Z", + "shell.execute_reply": "2025-01-14T23:31:07.289103Z", + "shell.execute_reply.started": "2025-01-14T23:31:07.286232Z" + } + }, "outputs": [], "source": [ "def plotImage(exposure: ExposureF):\n", @@ -371,9 +403,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "da81a645-947e-4ca2-82f7-905de4ef79da", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:07.290488Z", + "iopub.status.busy": "2025-01-14T23:31:07.290283Z", + "iopub.status.idle": "2025-01-14T23:31:07.304911Z", + "shell.execute_reply": "2025-01-14T23:31:07.304306Z", + "shell.execute_reply.started": "2025-01-14T23:31:07.290472Z" + } + }, "outputs": [], "source": [ "\n", @@ -487,9 +527,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:07.305692Z", + "iopub.status.busy": "2025-01-14T23:31:07.305519Z", + "iopub.status.idle": "2025-01-14T23:31:07.342647Z", + "shell.execute_reply": "2025-01-14T23:31:07.342031Z", + "shell.execute_reply.started": "2025-01-14T23:31:07.305679Z" + } + }, "outputs": [], "source": [ "service = get_tap_service(\"tap\")" @@ -507,9 +555,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:07.343368Z", + "iopub.status.busy": "2025-01-14T23:31:07.343215Z", + "iopub.status.idle": "2025-01-14T23:31:07.440092Z", + "shell.execute_reply": "2025-01-14T23:31:07.439618Z", + "shell.execute_reply.started": "2025-01-14T23:31:07.343354Z" + } + }, "outputs": [], "source": [ "query = \"SELECT column_name, datatype, description, unit \" \\\n", @@ -521,10 +577,119 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:07.440810Z", + "iopub.status.busy": "2025-01-14T23:31:07.440667Z", + "iopub.status.idle": "2025-01-14T23:31:07.455412Z", + "shell.execute_reply": "2025-01-14T23:31:07.454968Z", + "shell.execute_reply.started": "2025-01-14T23:31:07.440796Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i_ap03Flux\n", + "i_ap03Flux_flag\n", + "i_ap03FluxErr\n", + "i_ap06Flux\n", + "i_ap06Flux_flag\n", + "i_ap06FluxErr\n", + "i_ap09Flux\n", + "i_ap09Flux_flag\n", + "i_ap09FluxErr\n", + "i_ap12Flux\n", + "i_ap12Flux_flag\n", + "i_ap12FluxErr\n", + "i_ap17Flux\n", + "i_ap17Flux_flag\n", + "i_ap17FluxErr\n", + "i_ap25Flux\n", + "i_ap25Flux_flag\n", + "i_ap25FluxErr\n", + "i_ap35Flux\n", + "i_ap35Flux_flag\n", + "i_ap35FluxErr\n", + "i_ap50Flux\n", + "i_ap50Flux_flag\n", + "i_ap50FluxErr\n", + "i_ap70Flux\n", + "i_ap70Flux_flag\n", + "i_ap70FluxErr\n", + "i_apFlux_flag\n", + "i_apFlux_flag_apertureTruncated\n", + "i_apFlux_flag_sincCoeffsTruncated\n", + "i_bdFluxB\n", + "i_bdFluxBErr\n", + "i_bdFluxD\n", + "i_bdFluxDErr\n", + "i_calibFlux\n", + "i_calibFlux_flag\n", + "i_calibFlux_flag_apertureTruncated\n", + "i_calibFlux_flag_sincCoeffsTruncated\n", + "i_calibFluxErr\n", + "i_cModelFlux\n", + "i_cModelFlux_inner\n", + "i_cModelFluxErr\n", + "i_free_cModelFlux\n", + "i_free_cModelFlux_flag\n", + "i_free_cModelFlux_inner\n", + "i_free_cModelFluxErr\n", + "i_free_psfFlux\n", + "i_free_psfFlux_flag\n", + "i_free_psfFluxErr\n", + "i_gaap0p5Flux\n", + "i_gaap0p5Flux_flag_bigPsf\n", + "i_gaap0p5FluxErr\n", + "i_gaap0p7Flux\n", + "i_gaap0p7Flux_flag_bigPsf\n", + "i_gaap0p7FluxErr\n", + "i_gaap1p0Flux\n", + "i_gaap1p0Flux_flag_bigPsf\n", + "i_gaap1p0FluxErr\n", + "i_gaap1p5Flux\n", + "i_gaap1p5Flux_flag_bigPsf\n", + "i_gaap1p5FluxErr\n", + "i_gaap2p5Flux\n", + "i_gaap2p5Flux_flag_bigPsf\n", + "i_gaap2p5FluxErr\n", + "i_gaap3p0Flux\n", + "i_gaap3p0Flux_flag_bigPsf\n", + "i_gaap3p0FluxErr\n", + "i_gaapFlux_flag\n", + "i_gaapFlux_flag_edge\n", + "i_gaapFlux_flag_gaussianization\n", + "i_gaapOptimalFlux\n", + "i_gaapOptimalFlux_flag_bigPsf\n", + "i_gaapOptimalFluxErr\n", + "i_gaapPsfFlux\n", + "i_gaapPsfFluxErr\n", + "i_kronFlux\n", + "i_kronFlux_flag\n", + "i_kronFlux_flag_bad_radius\n", + "i_kronFlux_flag_bad_shape\n", + "i_kronFlux_flag_bad_shape_no_psf\n", + "i_kronFlux_flag_edge\n", + "i_kronFlux_flag_no_fallback_radius\n", + "i_kronFlux_flag_no_minimum_radius\n", + "i_kronFlux_flag_small_radius\n", + "i_kronFlux_flag_used_minimum_radius\n", + "i_kronFlux_flag_used_psf_radius\n", + "i_kronFluxErr\n", + "i_psfFlux\n", + "i_psfFlux_area\n", + "i_psfFlux_flag\n", + "i_psfFlux_flag_apCorr\n", + "i_psfFlux_flag_edge\n", + "i_psfFlux_flag_noGoodPixels\n", + "i_psfFluxErr\n" + ] + } + ], "source": [ "search_string = 'Flux'\n", "band = 'i_'\n", @@ -533,6 +698,241 @@ " print(cname)" ] }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0d82dd79-a4d7-4428-a77c-1ed2bb717486", + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:07.456087Z", + "iopub.status.busy": "2025-01-14T23:31:07.455933Z", + "iopub.status.idle": "2025-01-14T23:31:07.463717Z", + "shell.execute_reply": "2025-01-14T23:31:07.463109Z", + "shell.execute_reply.started": "2025-01-14T23:31:07.456074Z" + } + }, + "outputs": [], + "source": [ + "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", + " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", + " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e75ee4db-e4b9-4ff2-ba07-1f7f34a8d44b", + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:07.464404Z", + "iopub.status.busy": "2025-01-14T23:31:07.464251Z", + "iopub.status.idle": "2025-01-14T23:31:10.635052Z", + "shell.execute_reply": "2025-01-14T23:31:10.634605Z", + "shell.execute_reply.started": "2025-01-14T23:31:07.464391Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job phase is COMPLETED\n" + ] + } + ], + "source": [ + "job = service.submit_job(query)\n", + "job.run()\n", + "job.wait(phases=['COMPLETED', 'ERROR'])\n", + "print('Job phase is', job.phase)" + ] + }, + { + "cell_type": "markdown", + "id": "6d90ce60-2dc7-432d-bf12-1679cd43c3f3", + "metadata": {}, + "source": [ + "Print the results of the search query." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "02ea5eb7-bac9-4c9f-90e4-626a69340b41", + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:10.635848Z", + "iopub.status.busy": "2025-01-14T23:31:10.635680Z", + "iopub.status.idle": "2025-01-14T23:31:11.095550Z", + "shell.execute_reply": "2025-01-14T23:31:11.095061Z", + "shell.execute_reply.started": "2025-01-14T23:31:10.635834Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "13699\n" + ] + }, + { + "data": { + "text/html": [ + "<div><i>Table length=13699</i>\n", + "<table id=\"table134598543082512\" class=\"table-striped table-bordered table-condensed\">\n", + "<thead><tr><th>coord_ra</th><th>coord_dec</th><th>detect_fromBlend</th><th>detect_isIsolated</th><th>i_blendedness_flag</th><th>i_blendedness</th><th>i_extendedness</th><th>i_kronFlux</th><th>i_kronFluxErr</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th><th>i_gaapOptimalFlux</th></tr></thead>\n", + "<thead><tr><th>deg</th><th>deg</th><th></th><th></th><th></th><th></th><th></th><th>nJy</th><th>nJy</th><th></th><th></th><th>nJy</th><th>nJy</th></tr></thead>\n", + "<thead><tr><th>float64</th><th>float64</th><th>bool</th><th>bool</th><th>bool</th><th>float64</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th><th>float64</th></tr></thead>\n", + "<tr><td>61.7706493</td><td>-36.9697356</td><td>True</td><td>False</td><td>False</td><td>-0.007827</td><td>1.0</td><td>739.8429047</td><td>59.4996204</td><td>3.79338</td><td>False</td><td>673.0858612</td><td>553.2206068</td></tr>\n", + "<tr><td>61.7549646</td><td>-36.9680703</td><td>True</td><td>False</td><td>False</td><td>0.0991178</td><td>1.0</td><td>619.0834886</td><td>55.5849972</td><td>3.49558</td><td>False</td><td>619.6897725</td><td>473.4394404</td></tr>\n", + "<tr><td>61.7657586</td><td>-36.9495165</td><td>True</td><td>False</td><td>False</td><td>-0.016065</td><td>1.0</td><td>1966.7031092</td><td>55.1067734</td><td>3.45856</td><td>False</td><td>1813.335798</td><td>1560.6365686</td></tr>\n", + "<tr><td>61.7667836</td><td>-36.9492381</td><td>True</td><td>False</td><td>False</td><td>0.0050871</td><td>1.0</td><td>1353.4824791</td><td>53.8404146</td><td>3.38249</td><td>False</td><td>1353.7914025</td><td>1088.3605684</td></tr>\n", + "<tr><td>61.7701176</td><td>-36.9304069</td><td>True</td><td>False</td><td>False</td><td>0.0354649</td><td>1.0</td><td>522.2245085</td><td>48.759376</td><td>3.07855</td><td>False</td><td>540.6289795</td><td>427.367894</td></tr>\n", + "<tr><td>61.7695731</td><td>-36.9300678</td><td>True</td><td>False</td><td>False</td><td>-0.0034611</td><td>1.0</td><td>717.8192689</td><td>48.8100869</td><td>3.08925</td><td>False</td><td>711.583578</td><td>616.9401011</td></tr>\n", + "<tr><td>61.7640363</td><td>-36.9488123</td><td>True</td><td>False</td><td>False</td><td>-0.0031328</td><td>1.0</td><td>3530.9923422</td><td>60.9319949</td><td>3.82088</td><td>False</td><td>3444.861802</td><td>2568.7314356</td></tr>\n", + "<tr><td>61.7633748</td><td>-36.9475632</td><td>True</td><td>False</td><td>False</td><td>0.0798863</td><td>1.0</td><td>767.3396102</td><td>58.7878928</td><td>3.72145</td><td>False</td><td>767.5660595</td><td>583.1319233</td></tr>\n", + "<tr><td>61.769842</td><td>-36.9507726</td><td>True</td><td>False</td><td>False</td><td>-0.0285192</td><td>1.0</td><td>1393.0031465</td><td>52.4085023</td><td>3.33254</td><td>False</td><td>1317.2676753</td><td>1160.0142166</td></tr>\n", + "<tr><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n", + "<tr><td>62.2340701</td><td>-37.0589707</td><td>True</td><td>False</td><td>False</td><td>0.017393</td><td>1.0</td><td>5475.2581198</td><td>106.5125488</td><td>6.51392</td><td>False</td><td>7968.7930086</td><td>2812.270571</td></tr>\n", + "<tr><td>62.238679</td><td>-37.0598473</td><td>True</td><td>False</td><td>False</td><td>0.002246</td><td>1.0</td><td>656.6051349</td><td>53.4197209</td><td>3.30962</td><td>False</td><td>646.5235391</td><td>512.0469676</td></tr>\n", + "<tr><td>62.2379366</td><td>-37.0608993</td><td>True</td><td>False</td><td>False</td><td>0.0243649</td><td>1.0</td><td>3448.5360492</td><td>60.0880805</td><td>3.71268</td><td>False</td><td>3390.7405566</td><td>2514.2672709</td></tr>\n", + "<tr><td>62.2347859</td><td>-37.0630304</td><td>True</td><td>False</td><td>False</td><td>-0.0123865</td><td>1.0</td><td>2758.118914</td><td>43.642257</td><td>2.69446</td><td>False</td><td>2795.1106328</td><td>2595.641324</td></tr>\n", + "<tr><td>62.2320894</td><td>-37.0631907</td><td>True</td><td>False</td><td>False</td><td>-0.0024702</td><td>1.0</td><td>3348.8860869</td><td>74.5423706</td><td>4.53893</td><td>False</td><td>3404.9391468</td><td>2013.9016243</td></tr>\n", + "<tr><td>62.2374752</td><td>-37.063016</td><td>True</td><td>False</td><td>False</td><td>-0.0445366</td><td>1.0</td><td>1474.240171</td><td>42.3870591</td><td>2.62527</td><td>False</td><td>1484.0448861</td><td>1422.4822653</td></tr>\n", + "<tr><td>62.2346703</td><td>-37.0661891</td><td>True</td><td>False</td><td>False</td><td>0.061405</td><td>1.0</td><td>777.2332956</td><td>65.4523749</td><td>4.02862</td><td>False</td><td>777.261764</td><td>537.0907481</td></tr>\n", + "<tr><td>62.2339994</td><td>-37.0649774</td><td>True</td><td>False</td><td>False</td><td>-0.0043305</td><td>1.0</td><td>2170.4946541</td><td>47.0723022</td><td>2.8639</td><td>False</td><td>2130.9356269</td><td>1949.1903224</td></tr>\n", + "<tr><td>62.23306</td><td>-37.0618854</td><td>True</td><td>False</td><td>False</td><td>-0.003919</td><td>1.0</td><td>1128.0548814</td><td>71.7575598</td><td>4.39139</td><td>False</td><td>1162.450445</td><td>765.2318206</td></tr>\n", + "</table></div>" + ], + "text/plain": [ + "<Table length=13699>\n", + " coord_ra coord_dec detect_fromBlend ... i_cModelFlux i_gaapOptimalFlux\n", + " deg deg ... nJy nJy \n", + " float64 float64 bool ... float64 float64 \n", + "---------- ----------- ---------------- ... ------------ -----------------\n", + "61.7706493 -36.9697356 True ... 673.0858612 553.2206068\n", + "61.7549646 -36.9680703 True ... 619.6897725 473.4394404\n", + "61.7657586 -36.9495165 True ... 1813.335798 1560.6365686\n", + "61.7667836 -36.9492381 True ... 1353.7914025 1088.3605684\n", + "61.7701176 -36.9304069 True ... 540.6289795 427.367894\n", + "61.7695731 -36.9300678 True ... 711.583578 616.9401011\n", + "61.7640363 -36.9488123 True ... 3444.861802 2568.7314356\n", + "61.7633748 -36.9475632 True ... 767.5660595 583.1319233\n", + " 61.769842 -36.9507726 True ... 1317.2676753 1160.0142166\n", + " ... ... ... ... ... ...\n", + "62.2340701 -37.0589707 True ... 7968.7930086 2812.270571\n", + " 62.238679 -37.0598473 True ... 646.5235391 512.0469676\n", + "62.2379366 -37.0608993 True ... 3390.7405566 2514.2672709\n", + "62.2347859 -37.0630304 True ... 2795.1106328 2595.641324\n", + "62.2320894 -37.0631907 True ... 3404.9391468 2013.9016243\n", + "62.2374752 -37.063016 True ... 1484.0448861 1422.4822653\n", + "62.2346703 -37.0661891 True ... 777.261764 537.0907481\n", + "62.2339994 -37.0649774 True ... 2130.9356269 1949.1903224\n", + " 62.23306 -37.0618854 True ... 1162.450445 765.2318206" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results = job.fetch_result()\n", + "print(len(results))\n", + "tab = results.to_table()\n", + "tab" + ] + }, + { + "cell_type": "markdown", + "id": "e6a27a39-ed2b-49fe-ac6d-51ae4c300bfc", + "metadata": {}, + "source": [ + "### 2.4 Exploring the input vs output photometry\n", + "\n", + "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", + "\n", + "First, store the AB magnitudes to go with the fluxes extracted from the objectTable." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e8b4a64a-6565-4d7d-ae48-0a666c41101e", + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:11.096168Z", + "iopub.status.busy": "2025-01-14T23:31:11.096021Z", + "iopub.status.idle": "2025-01-14T23:31:11.101889Z", + "shell.execute_reply": "2025-01-14T23:31:11.101264Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.096155Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_75576/1658089687.py:3: RuntimeWarning: divide by zero encountered in log10\n", + " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n" + ] + } + ], + "source": [ + "#truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "432db690-be7e-43bf-a640-a80af727652b", + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-14T23:31:11.102641Z", + "iopub.status.busy": "2025-01-14T23:31:11.102485Z", + "iopub.status.idle": "2025-01-14T23:31:11.113679Z", + "shell.execute_reply": "2025-01-14T23:31:11.112314Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.102627Z" + } + }, + "outputs": [ + { + "ename": "SystemExit", + "evalue": "", + "output_type": "error", + "traceback": [ + "An exception has occurred, use %tb to see the full traceback.\n", + "\u001b[0;31mSystemExit\u001b[0m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/lsst/software/stack/conda/envs/lsst-scipipe-9.0.0/lib/python3.11/site-packages/IPython/core/interactiveshell.py:3585: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n", + " warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n" + ] + } + ], + "source": [ + "sys.exit()" + ] + }, + { + "cell_type": "markdown", + "id": "52267cd8-1041-4e09-bda1-248468b21971", + "metadata": {}, + "source": [ + " OLD STUFF BELOW: (see notes from Melissa 1/14 at the end for the plan)" + ] + }, { "cell_type": "markdown", "id": "ff2fc2b3-fb3b-4d92-a325-ace4dfa059dc", @@ -551,7 +951,14 @@ "cell_type": "code", "execution_count": null, "id": "0d28a6ad-4436-410c-9b9d-e995140be304", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.114149Z", + "iopub.status.idle": "2025-01-14T23:31:11.114353Z", + "shell.execute_reply": "2025-01-14T23:31:11.114260Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.114252Z" + } + }, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", @@ -568,7 +975,14 @@ "cell_type": "code", "execution_count": null, "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.115193Z", + "iopub.status.idle": "2025-01-14T23:31:11.115394Z", + "shell.execute_reply": "2025-01-14T23:31:11.115315Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.115305Z" + } + }, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -589,7 +1003,14 @@ "cell_type": "code", "execution_count": null, "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.116082Z", + "iopub.status.idle": "2025-01-14T23:31:11.116253Z", + "shell.execute_reply": "2025-01-14T23:31:11.116181Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.116174Z" + } + }, "outputs": [], "source": [ "results = job.fetch_result()\n", @@ -614,7 +1035,14 @@ "cell_type": "code", "execution_count": null, "id": "7a8000f6-a914-4073-8130-67d912f52b09", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.117122Z", + "iopub.status.idle": "2025-01-14T23:31:11.117313Z", + "shell.execute_reply": "2025-01-14T23:31:11.117228Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.117220Z" + } + }, "outputs": [], "source": [ "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", @@ -636,7 +1064,14 @@ "cell_type": "code", "execution_count": null, "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.117937Z", + "iopub.status.idle": "2025-01-14T23:31:11.118103Z", + "shell.execute_reply": "2025-01-14T23:31:11.118029Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.118023Z" + } + }, "outputs": [], "source": [ "fig, ax = plt.subplots()\n", @@ -691,7 +1126,14 @@ "cell_type": "code", "execution_count": null, "id": "8bbb1505-5e91-49d2-b94e-045ff9f482e2", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.118690Z", + "iopub.status.idle": "2025-01-14T23:31:11.118876Z", + "shell.execute_reply": "2025-01-14T23:31:11.118793Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.118783Z" + } + }, "outputs": [], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", @@ -761,7 +1203,14 @@ "cell_type": "code", "execution_count": null, "id": "3f5073a8-7c3d-4361-92b7-e1fa05c5dcde", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.119497Z", + "iopub.status.idle": "2025-01-14T23:31:11.119668Z", + "shell.execute_reply": "2025-01-14T23:31:11.119596Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.119589Z" + } + }, "outputs": [], "source": [ "# here add a second set of panels to try to understand the small bias at bright end of kron (is it kron radius-dependent? since its not deblending dependent?\n", @@ -825,7 +1274,14 @@ "cell_type": "code", "execution_count": null, "id": "6fdf7c38-0c80-4351-856d-8390d22ad375", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.120408Z", + "iopub.status.idle": "2025-01-14T23:31:11.120613Z", + "shell.execute_reply": "2025-01-14T23:31:11.120529Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.120518Z" + } + }, "outputs": [], "source": [ "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", @@ -835,7 +1291,7 @@ " ((kron_mag[whgood]-truth_mag[whgood]) < 0.25))[0]\n", "\n", "print(whtest)\n", - "for i in range(len(whtest)):\n", + "for i in range(2):\n", " ra = results['ra'][whgood][whtest][i]\n", " dec = results['dec'][whgood][whtest][i]\n", " coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree, frame='icrs')\n", @@ -881,7 +1337,14 @@ "cell_type": "code", "execution_count": null, "id": "1e525f6f-5521-4a67-9abb-b96e4a198043", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.121410Z", + "iopub.status.idle": "2025-01-14T23:31:11.121602Z", + "shell.execute_reply": "2025-01-14T23:31:11.121521Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.121513Z" + } + }, "outputs": [], "source": [ "# the following plots are identical, consider a different comparison that is informative\n", @@ -944,7 +1407,14 @@ "cell_type": "code", "execution_count": null, "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.122379Z", + "iopub.status.idle": "2025-01-14T23:31:11.122570Z", + "shell.execute_reply": "2025-01-14T23:31:11.122493Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.122485Z" + } + }, "outputs": [], "source": [ "\n", @@ -1036,7 +1506,14 @@ "cell_type": "code", "execution_count": null, "id": "fd7e6ebb-f348-4df9-9859-9d4febb51238", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.123193Z", + "iopub.status.idle": "2025-01-14T23:31:11.123355Z", + "shell.execute_reply": "2025-01-14T23:31:11.123280Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.123274Z" + } + }, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_g, ts.flux_z, ts.redshift, \"\\\n", @@ -1054,7 +1531,14 @@ "cell_type": "code", "execution_count": null, "id": "baec0660-1125-43de-9f21-cc5ccef958f0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.123942Z", + "iopub.status.idle": "2025-01-14T23:31:11.124124Z", + "shell.execute_reply": "2025-01-14T23:31:11.124039Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.124030Z" + } + }, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1070,7 +1554,14 @@ "cell_type": "code", "execution_count": null, "id": "8d97291d-2043-40a6-859c-db391565a9da", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.124758Z", + "iopub.status.idle": "2025-01-14T23:31:11.124917Z", + "shell.execute_reply": "2025-01-14T23:31:11.124850Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.124843Z" + } + }, "outputs": [], "source": [ "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4\n", @@ -1088,7 +1579,14 @@ "cell_type": "code", "execution_count": null, "id": "59afd145-cc34-4671-82ac-616ba6f28882", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.125662Z", + "iopub.status.idle": "2025-01-14T23:31:11.125821Z", + "shell.execute_reply": "2025-01-14T23:31:11.125751Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.125745Z" + } + }, "outputs": [], "source": [ "# very confused about why these colors line up so perfectly when the mags do not...\n", @@ -1140,7 +1638,14 @@ "cell_type": "code", "execution_count": null, "id": "8575a64b-f166-453b-aebd-dd09d728a259", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.126152Z", + "iopub.status.idle": "2025-01-14T23:31:11.126317Z", + "shell.execute_reply": "2025-01-14T23:31:11.126237Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.126231Z" + } + }, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", @@ -1157,7 +1662,14 @@ "cell_type": "code", "execution_count": null, "id": "24718446-033d-4b3d-b11f-a94c708c6d1e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.127061Z", + "iopub.status.idle": "2025-01-14T23:31:11.127217Z", + "shell.execute_reply": "2025-01-14T23:31:11.127149Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.127142Z" + } + }, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1170,7 +1682,14 @@ "cell_type": "code", "execution_count": null, "id": "1ddc4e98-1151-4aba-806a-b9097d2edfd0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.127806Z", + "iopub.status.idle": "2025-01-14T23:31:11.127983Z", + "shell.execute_reply": "2025-01-14T23:31:11.127902Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.127892Z" + } + }, "outputs": [], "source": [ "results = job.fetch_result()\n", @@ -1181,7 +1700,14 @@ "cell_type": "code", "execution_count": null, "id": "0b26042c-c234-4885-819b-a05dfba2bc31", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.128854Z", + "iopub.status.idle": "2025-01-14T23:31:11.129007Z", + "shell.execute_reply": "2025-01-14T23:31:11.128940Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.128934Z" + } + }, "outputs": [], "source": [ "# pick an object that has large size\n", @@ -1210,7 +1736,14 @@ "cell_type": "code", "execution_count": null, "id": "12f5be0d-7816-4622-8523-aff5e6b9a028", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.130039Z", + "iopub.status.idle": "2025-01-14T23:31:11.130263Z", + "shell.execute_reply": "2025-01-14T23:31:11.130171Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.130163Z" + } + }, "outputs": [], "source": [ "sys.exit()" @@ -1220,7 +1753,14 @@ "cell_type": "code", "execution_count": null, "id": "94c2ecc1-5760-4872-b01d-e6d48b145201", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.131017Z", + "iopub.status.idle": "2025-01-14T23:31:11.131201Z", + "shell.execute_reply": "2025-01-14T23:31:11.131117Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.131108Z" + } + }, "outputs": [], "source": [ "#junk that doens't work yet:\n", @@ -1270,7 +1810,14 @@ "cell_type": "code", "execution_count": null, "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.131790Z", + "iopub.status.idle": "2025-01-14T23:31:11.131959Z", + "shell.execute_reply": "2025-01-14T23:31:11.131886Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.131879Z" + } + }, "outputs": [], "source": [ "# compare kron mag to cmodel mag\n", @@ -1299,7 +1846,14 @@ "cell_type": "code", "execution_count": null, "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.132448Z", + "iopub.status.idle": "2025-01-14T23:31:11.132667Z", + "shell.execute_reply": "2025-01-14T23:31:11.132583Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.132574Z" + } + }, "outputs": [], "source": [ "\n", @@ -1324,7 +1878,14 @@ "cell_type": "code", "execution_count": null, "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.133544Z", + "iopub.status.idle": "2025-01-14T23:31:11.133720Z", + "shell.execute_reply": "2025-01-14T23:31:11.133642Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.133635Z" + } + }, "outputs": [], "source": [ "\n", @@ -1349,7 +1910,14 @@ "cell_type": "code", "execution_count": null, "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.134445Z", + "iopub.status.idle": "2025-01-14T23:31:11.134639Z", + "shell.execute_reply": "2025-01-14T23:31:11.134569Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.134562Z" + } + }, "outputs": [], "source": [ "\n", @@ -1386,7 +1954,14 @@ "cell_type": "code", "execution_count": null, "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.136113Z", + "iopub.status.idle": "2025-01-14T23:31:11.136313Z", + "shell.execute_reply": "2025-01-14T23:31:11.136225Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.136217Z" + } + }, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_gaapOptimalFlux'][whbright],\n", @@ -1403,7 +1978,14 @@ "cell_type": "code", "execution_count": null, "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-14T23:31:11.137071Z", + "iopub.status.idle": "2025-01-14T23:31:11.137243Z", + "shell.execute_reply": "2025-01-14T23:31:11.137165Z", + "shell.execute_reply.started": "2025-01-14T23:31:11.137158Z" + } + }, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", @@ -1449,11 +2031,13 @@ "\n", "when you're ready for input from DM make a list of what i want help with (so Yusra can find someone for help and then help them respond to specific questions\n", "\n", + "1/14/24 meeting with melissa:\n", + "\n", "pull out a minimum (short) version of htis that is just hte stuff i'm sure about (descriptive) minimal on science demo. try to compare one measurement to the other (problem with truth is that people may remember forever that cmodel is best however it could just be that cmodel recovered with cmodel performed well.\n", "\n", "find a galaxy and show difference size of apertures on there as a demo. upper undergrad level. \n", "\n", - "we are def going to have object catalogs for DP1 so we iwll need a tutorial for that. \n", + "we are def going to have object catalogs for DP1 so we will need a tutorial for that. \n", "\n", "have shenming review (does weak lensing and. first talk to melissa to let her know then she will see hwat shenming is up to." ] From 424558606d3cc6ebc9a56f9690480acdbfce37a6 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Sat, 18 Jan 2025 19:47:12 +0000 Subject: [PATCH 48/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 258e38c..f8c7f39 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -12,7 +12,7 @@ "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", "<br>\n", "Contact author(s): <i>Christina Williams</i> <br>\n", - "Last verified to run: <i>2024-01-10</i> <br>\n", + "Last verified to run: <i>2024-01-18</i> <br>\n", "LSST Science Pipelines version: Weekly <i>2024_24</i> <br>\n", "Container Size: <i>medium</i> <br>\n", "Targeted learning level: <i>beginner</i> <br>" @@ -303,7 +303,9 @@ "from astropy import units as u\n", "from astropy.coordinates import SkyCoord, Angle\n", "from astropy.io import fits\n", - "from astropy.wcs import WCS\n" + "from astropy.wcs import WCS\n", + "\n", + "from photutils.aperture import SkyCircularAperture\n" ] }, { @@ -2039,7 +2041,9 @@ "\n", "we are def going to have object catalogs for DP1 so we will need a tutorial for that. \n", "\n", - "have shenming review (does weak lensing and. first talk to melissa to let her know then she will see hwat shenming is up to." + "have shenming review (does weak lensing and. first talk to melissa to let her know then she will see hwat shenming is up to.\n", + "\n", + "Dan has thoughts about the sersic model photometry, talk to him at some point. He's been experimenting with single sersic photometry from multiprofit" ] } ], From d439337855dff8c997eb007110ae1646f25121b9 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Sun, 19 Jan 2025 10:43:14 +0000 Subject: [PATCH 49/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 606 +++----------------------------- 1 file changed, 58 insertions(+), 548 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index f8c7f39..324e1c9 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -20,17 +20,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:03.459964Z", - "iopub.status.busy": "2025-01-14T23:31:03.459809Z", - "iopub.status.idle": "2025-01-14T23:31:03.462357Z", - "shell.execute_reply": "2025-01-14T23:31:03.461815Z", - "shell.execute_reply.started": "2025-01-14T23:31:03.459949Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "#%load_ext pycodestyle_magic\n", @@ -244,17 +236,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "2dbc75bd-a802-4576-8628-4e0088942303", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:03.462996Z", - "iopub.status.busy": "2025-01-14T23:31:03.462856Z", - "iopub.status.idle": "2025-01-14T23:31:07.257542Z", - "shell.execute_reply": "2025-01-14T23:31:07.257026Z", - "shell.execute_reply.started": "2025-01-14T23:31:03.462982Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -324,17 +308,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:07.258678Z", - "iopub.status.busy": "2025-01-14T23:31:07.258111Z", - "iopub.status.idle": "2025-01-14T23:31:07.285337Z", - "shell.execute_reply": "2025-01-14T23:31:07.284744Z", - "shell.execute_reply.started": "2025-01-14T23:31:07.258659Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", @@ -370,17 +346,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "2f19f3b6-7357-4848-a2b4-5597aa8c8e15", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:07.286246Z", - "iopub.status.busy": "2025-01-14T23:31:07.286076Z", - "iopub.status.idle": "2025-01-14T23:31:07.289532Z", - "shell.execute_reply": "2025-01-14T23:31:07.289103Z", - "shell.execute_reply.started": "2025-01-14T23:31:07.286232Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "def plotImage(exposure: ExposureF):\n", @@ -405,17 +373,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "da81a645-947e-4ca2-82f7-905de4ef79da", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:07.290488Z", - "iopub.status.busy": "2025-01-14T23:31:07.290283Z", - "iopub.status.idle": "2025-01-14T23:31:07.304911Z", - "shell.execute_reply": "2025-01-14T23:31:07.304306Z", - "shell.execute_reply.started": "2025-01-14T23:31:07.290472Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -529,17 +489,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:07.305692Z", - "iopub.status.busy": "2025-01-14T23:31:07.305519Z", - "iopub.status.idle": "2025-01-14T23:31:07.342647Z", - "shell.execute_reply": "2025-01-14T23:31:07.342031Z", - "shell.execute_reply.started": "2025-01-14T23:31:07.305679Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "service = get_tap_service(\"tap\")" @@ -557,17 +509,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:07.343368Z", - "iopub.status.busy": "2025-01-14T23:31:07.343215Z", - "iopub.status.idle": "2025-01-14T23:31:07.440092Z", - "shell.execute_reply": "2025-01-14T23:31:07.439618Z", - "shell.execute_reply.started": "2025-01-14T23:31:07.343354Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT column_name, datatype, description, unit \" \\\n", @@ -579,119 +523,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:07.440810Z", - "iopub.status.busy": "2025-01-14T23:31:07.440667Z", - "iopub.status.idle": "2025-01-14T23:31:07.455412Z", - "shell.execute_reply": "2025-01-14T23:31:07.454968Z", - "shell.execute_reply.started": "2025-01-14T23:31:07.440796Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "i_ap03Flux\n", - "i_ap03Flux_flag\n", - "i_ap03FluxErr\n", - "i_ap06Flux\n", - "i_ap06Flux_flag\n", - "i_ap06FluxErr\n", - "i_ap09Flux\n", - "i_ap09Flux_flag\n", - "i_ap09FluxErr\n", - "i_ap12Flux\n", - "i_ap12Flux_flag\n", - "i_ap12FluxErr\n", - "i_ap17Flux\n", - "i_ap17Flux_flag\n", - "i_ap17FluxErr\n", - "i_ap25Flux\n", - "i_ap25Flux_flag\n", - "i_ap25FluxErr\n", - "i_ap35Flux\n", - "i_ap35Flux_flag\n", - "i_ap35FluxErr\n", - "i_ap50Flux\n", - "i_ap50Flux_flag\n", - "i_ap50FluxErr\n", - "i_ap70Flux\n", - "i_ap70Flux_flag\n", - "i_ap70FluxErr\n", - "i_apFlux_flag\n", - "i_apFlux_flag_apertureTruncated\n", - "i_apFlux_flag_sincCoeffsTruncated\n", - "i_bdFluxB\n", - "i_bdFluxBErr\n", - "i_bdFluxD\n", - "i_bdFluxDErr\n", - "i_calibFlux\n", - "i_calibFlux_flag\n", - "i_calibFlux_flag_apertureTruncated\n", - "i_calibFlux_flag_sincCoeffsTruncated\n", - "i_calibFluxErr\n", - "i_cModelFlux\n", - "i_cModelFlux_inner\n", - "i_cModelFluxErr\n", - "i_free_cModelFlux\n", - "i_free_cModelFlux_flag\n", - "i_free_cModelFlux_inner\n", - "i_free_cModelFluxErr\n", - "i_free_psfFlux\n", - "i_free_psfFlux_flag\n", - "i_free_psfFluxErr\n", - "i_gaap0p5Flux\n", - "i_gaap0p5Flux_flag_bigPsf\n", - "i_gaap0p5FluxErr\n", - "i_gaap0p7Flux\n", - "i_gaap0p7Flux_flag_bigPsf\n", - "i_gaap0p7FluxErr\n", - "i_gaap1p0Flux\n", - "i_gaap1p0Flux_flag_bigPsf\n", - "i_gaap1p0FluxErr\n", - "i_gaap1p5Flux\n", - "i_gaap1p5Flux_flag_bigPsf\n", - "i_gaap1p5FluxErr\n", - "i_gaap2p5Flux\n", - "i_gaap2p5Flux_flag_bigPsf\n", - "i_gaap2p5FluxErr\n", - "i_gaap3p0Flux\n", - "i_gaap3p0Flux_flag_bigPsf\n", - "i_gaap3p0FluxErr\n", - "i_gaapFlux_flag\n", - "i_gaapFlux_flag_edge\n", - "i_gaapFlux_flag_gaussianization\n", - "i_gaapOptimalFlux\n", - "i_gaapOptimalFlux_flag_bigPsf\n", - "i_gaapOptimalFluxErr\n", - "i_gaapPsfFlux\n", - "i_gaapPsfFluxErr\n", - "i_kronFlux\n", - "i_kronFlux_flag\n", - "i_kronFlux_flag_bad_radius\n", - "i_kronFlux_flag_bad_shape\n", - "i_kronFlux_flag_bad_shape_no_psf\n", - "i_kronFlux_flag_edge\n", - "i_kronFlux_flag_no_fallback_radius\n", - "i_kronFlux_flag_no_minimum_radius\n", - "i_kronFlux_flag_small_radius\n", - "i_kronFlux_flag_used_minimum_radius\n", - "i_kronFlux_flag_used_psf_radius\n", - "i_kronFluxErr\n", - "i_psfFlux\n", - "i_psfFlux_area\n", - "i_psfFlux_flag\n", - "i_psfFlux_flag_apCorr\n", - "i_psfFlux_flag_edge\n", - "i_psfFlux_flag_noGoodPixels\n", - "i_psfFluxErr\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "search_string = 'Flux'\n", "band = 'i_'\n", @@ -702,17 +537,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "0d82dd79-a4d7-4428-a77c-1ed2bb717486", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:07.456087Z", - "iopub.status.busy": "2025-01-14T23:31:07.455933Z", - "iopub.status.idle": "2025-01-14T23:31:07.463717Z", - "shell.execute_reply": "2025-01-14T23:31:07.463109Z", - "shell.execute_reply.started": "2025-01-14T23:31:07.456074Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", @@ -724,26 +551,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "e75ee4db-e4b9-4ff2-ba07-1f7f34a8d44b", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:07.464404Z", - "iopub.status.busy": "2025-01-14T23:31:07.464251Z", - "iopub.status.idle": "2025-01-14T23:31:10.635052Z", - "shell.execute_reply": "2025-01-14T23:31:10.634605Z", - "shell.execute_reply.started": "2025-01-14T23:31:07.464391Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job phase is COMPLETED\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "job = service.submit_job(query)\n", "job.run()\n", @@ -761,86 +572,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "02ea5eb7-bac9-4c9f-90e4-626a69340b41", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:10.635848Z", - "iopub.status.busy": "2025-01-14T23:31:10.635680Z", - "iopub.status.idle": "2025-01-14T23:31:11.095550Z", - "shell.execute_reply": "2025-01-14T23:31:11.095061Z", - "shell.execute_reply.started": "2025-01-14T23:31:10.635834Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "13699\n" - ] - }, - { - "data": { - "text/html": [ - "<div><i>Table length=13699</i>\n", - "<table id=\"table134598543082512\" class=\"table-striped table-bordered table-condensed\">\n", - "<thead><tr><th>coord_ra</th><th>coord_dec</th><th>detect_fromBlend</th><th>detect_isIsolated</th><th>i_blendedness_flag</th><th>i_blendedness</th><th>i_extendedness</th><th>i_kronFlux</th><th>i_kronFluxErr</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th><th>i_gaapOptimalFlux</th></tr></thead>\n", - "<thead><tr><th>deg</th><th>deg</th><th></th><th></th><th></th><th></th><th></th><th>nJy</th><th>nJy</th><th></th><th></th><th>nJy</th><th>nJy</th></tr></thead>\n", - "<thead><tr><th>float64</th><th>float64</th><th>bool</th><th>bool</th><th>bool</th><th>float64</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th><th>float64</th></tr></thead>\n", - "<tr><td>61.7706493</td><td>-36.9697356</td><td>True</td><td>False</td><td>False</td><td>-0.007827</td><td>1.0</td><td>739.8429047</td><td>59.4996204</td><td>3.79338</td><td>False</td><td>673.0858612</td><td>553.2206068</td></tr>\n", - "<tr><td>61.7549646</td><td>-36.9680703</td><td>True</td><td>False</td><td>False</td><td>0.0991178</td><td>1.0</td><td>619.0834886</td><td>55.5849972</td><td>3.49558</td><td>False</td><td>619.6897725</td><td>473.4394404</td></tr>\n", - "<tr><td>61.7657586</td><td>-36.9495165</td><td>True</td><td>False</td><td>False</td><td>-0.016065</td><td>1.0</td><td>1966.7031092</td><td>55.1067734</td><td>3.45856</td><td>False</td><td>1813.335798</td><td>1560.6365686</td></tr>\n", - "<tr><td>61.7667836</td><td>-36.9492381</td><td>True</td><td>False</td><td>False</td><td>0.0050871</td><td>1.0</td><td>1353.4824791</td><td>53.8404146</td><td>3.38249</td><td>False</td><td>1353.7914025</td><td>1088.3605684</td></tr>\n", - "<tr><td>61.7701176</td><td>-36.9304069</td><td>True</td><td>False</td><td>False</td><td>0.0354649</td><td>1.0</td><td>522.2245085</td><td>48.759376</td><td>3.07855</td><td>False</td><td>540.6289795</td><td>427.367894</td></tr>\n", - "<tr><td>61.7695731</td><td>-36.9300678</td><td>True</td><td>False</td><td>False</td><td>-0.0034611</td><td>1.0</td><td>717.8192689</td><td>48.8100869</td><td>3.08925</td><td>False</td><td>711.583578</td><td>616.9401011</td></tr>\n", - "<tr><td>61.7640363</td><td>-36.9488123</td><td>True</td><td>False</td><td>False</td><td>-0.0031328</td><td>1.0</td><td>3530.9923422</td><td>60.9319949</td><td>3.82088</td><td>False</td><td>3444.861802</td><td>2568.7314356</td></tr>\n", - "<tr><td>61.7633748</td><td>-36.9475632</td><td>True</td><td>False</td><td>False</td><td>0.0798863</td><td>1.0</td><td>767.3396102</td><td>58.7878928</td><td>3.72145</td><td>False</td><td>767.5660595</td><td>583.1319233</td></tr>\n", - "<tr><td>61.769842</td><td>-36.9507726</td><td>True</td><td>False</td><td>False</td><td>-0.0285192</td><td>1.0</td><td>1393.0031465</td><td>52.4085023</td><td>3.33254</td><td>False</td><td>1317.2676753</td><td>1160.0142166</td></tr>\n", - "<tr><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n", - "<tr><td>62.2340701</td><td>-37.0589707</td><td>True</td><td>False</td><td>False</td><td>0.017393</td><td>1.0</td><td>5475.2581198</td><td>106.5125488</td><td>6.51392</td><td>False</td><td>7968.7930086</td><td>2812.270571</td></tr>\n", - "<tr><td>62.238679</td><td>-37.0598473</td><td>True</td><td>False</td><td>False</td><td>0.002246</td><td>1.0</td><td>656.6051349</td><td>53.4197209</td><td>3.30962</td><td>False</td><td>646.5235391</td><td>512.0469676</td></tr>\n", - "<tr><td>62.2379366</td><td>-37.0608993</td><td>True</td><td>False</td><td>False</td><td>0.0243649</td><td>1.0</td><td>3448.5360492</td><td>60.0880805</td><td>3.71268</td><td>False</td><td>3390.7405566</td><td>2514.2672709</td></tr>\n", - "<tr><td>62.2347859</td><td>-37.0630304</td><td>True</td><td>False</td><td>False</td><td>-0.0123865</td><td>1.0</td><td>2758.118914</td><td>43.642257</td><td>2.69446</td><td>False</td><td>2795.1106328</td><td>2595.641324</td></tr>\n", - "<tr><td>62.2320894</td><td>-37.0631907</td><td>True</td><td>False</td><td>False</td><td>-0.0024702</td><td>1.0</td><td>3348.8860869</td><td>74.5423706</td><td>4.53893</td><td>False</td><td>3404.9391468</td><td>2013.9016243</td></tr>\n", - "<tr><td>62.2374752</td><td>-37.063016</td><td>True</td><td>False</td><td>False</td><td>-0.0445366</td><td>1.0</td><td>1474.240171</td><td>42.3870591</td><td>2.62527</td><td>False</td><td>1484.0448861</td><td>1422.4822653</td></tr>\n", - "<tr><td>62.2346703</td><td>-37.0661891</td><td>True</td><td>False</td><td>False</td><td>0.061405</td><td>1.0</td><td>777.2332956</td><td>65.4523749</td><td>4.02862</td><td>False</td><td>777.261764</td><td>537.0907481</td></tr>\n", - "<tr><td>62.2339994</td><td>-37.0649774</td><td>True</td><td>False</td><td>False</td><td>-0.0043305</td><td>1.0</td><td>2170.4946541</td><td>47.0723022</td><td>2.8639</td><td>False</td><td>2130.9356269</td><td>1949.1903224</td></tr>\n", - "<tr><td>62.23306</td><td>-37.0618854</td><td>True</td><td>False</td><td>False</td><td>-0.003919</td><td>1.0</td><td>1128.0548814</td><td>71.7575598</td><td>4.39139</td><td>False</td><td>1162.450445</td><td>765.2318206</td></tr>\n", - "</table></div>" - ], - "text/plain": [ - "<Table length=13699>\n", - " coord_ra coord_dec detect_fromBlend ... i_cModelFlux i_gaapOptimalFlux\n", - " deg deg ... nJy nJy \n", - " float64 float64 bool ... float64 float64 \n", - "---------- ----------- ---------------- ... ------------ -----------------\n", - "61.7706493 -36.9697356 True ... 673.0858612 553.2206068\n", - "61.7549646 -36.9680703 True ... 619.6897725 473.4394404\n", - "61.7657586 -36.9495165 True ... 1813.335798 1560.6365686\n", - "61.7667836 -36.9492381 True ... 1353.7914025 1088.3605684\n", - "61.7701176 -36.9304069 True ... 540.6289795 427.367894\n", - "61.7695731 -36.9300678 True ... 711.583578 616.9401011\n", - "61.7640363 -36.9488123 True ... 3444.861802 2568.7314356\n", - "61.7633748 -36.9475632 True ... 767.5660595 583.1319233\n", - " 61.769842 -36.9507726 True ... 1317.2676753 1160.0142166\n", - " ... ... ... ... ... ...\n", - "62.2340701 -37.0589707 True ... 7968.7930086 2812.270571\n", - " 62.238679 -37.0598473 True ... 646.5235391 512.0469676\n", - "62.2379366 -37.0608993 True ... 3390.7405566 2514.2672709\n", - "62.2347859 -37.0630304 True ... 2795.1106328 2595.641324\n", - "62.2320894 -37.0631907 True ... 3404.9391468 2013.9016243\n", - "62.2374752 -37.063016 True ... 1484.0448861 1422.4822653\n", - "62.2346703 -37.0661891 True ... 777.261764 537.0907481\n", - "62.2339994 -37.0649774 True ... 2130.9356269 1949.1903224\n", - " 62.23306 -37.0618854 True ... 1162.450445 765.2318206" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, + "outputs": [], "source": [ "results = job.fetch_result()\n", "print(len(results))\n", @@ -862,27 +597,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "e8b4a64a-6565-4d7d-ae48-0a666c41101e", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:11.096168Z", - "iopub.status.busy": "2025-01-14T23:31:11.096021Z", - "iopub.status.idle": "2025-01-14T23:31:11.101889Z", - "shell.execute_reply": "2025-01-14T23:31:11.101264Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.096155Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_75576/1658089687.py:3: RuntimeWarning: divide by zero encountered in log10\n", - " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "#truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", "\n", @@ -893,38 +611,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "432db690-be7e-43bf-a640-a80af727652b", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-14T23:31:11.102641Z", - "iopub.status.busy": "2025-01-14T23:31:11.102485Z", - "iopub.status.idle": "2025-01-14T23:31:11.113679Z", - "shell.execute_reply": "2025-01-14T23:31:11.112314Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.102627Z" - } - }, - "outputs": [ - { - "ename": "SystemExit", - "evalue": "", - "output_type": "error", - "traceback": [ - "An exception has occurred, use %tb to see the full traceback.\n", - "\u001b[0;31mSystemExit\u001b[0m\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/lsst/software/stack/conda/envs/lsst-scipipe-9.0.0/lib/python3.11/site-packages/IPython/core/interactiveshell.py:3585: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n", - " warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ - "sys.exit()" + "#sys.exit()" ] }, { @@ -953,14 +645,7 @@ "cell_type": "code", "execution_count": null, "id": "0d28a6ad-4436-410c-9b9d-e995140be304", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.114149Z", - "iopub.status.idle": "2025-01-14T23:31:11.114353Z", - "shell.execute_reply": "2025-01-14T23:31:11.114260Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.114252Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", @@ -977,14 +662,7 @@ "cell_type": "code", "execution_count": null, "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.115193Z", - "iopub.status.idle": "2025-01-14T23:31:11.115394Z", - "shell.execute_reply": "2025-01-14T23:31:11.115315Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.115305Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1005,14 +683,7 @@ "cell_type": "code", "execution_count": null, "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.116082Z", - "iopub.status.idle": "2025-01-14T23:31:11.116253Z", - "shell.execute_reply": "2025-01-14T23:31:11.116181Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.116174Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "results = job.fetch_result()\n", @@ -1037,14 +708,7 @@ "cell_type": "code", "execution_count": null, "id": "7a8000f6-a914-4073-8130-67d912f52b09", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.117122Z", - "iopub.status.idle": "2025-01-14T23:31:11.117313Z", - "shell.execute_reply": "2025-01-14T23:31:11.117228Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.117220Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", @@ -1066,14 +730,7 @@ "cell_type": "code", "execution_count": null, "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.117937Z", - "iopub.status.idle": "2025-01-14T23:31:11.118103Z", - "shell.execute_reply": "2025-01-14T23:31:11.118029Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.118023Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "fig, ax = plt.subplots()\n", @@ -1128,14 +785,7 @@ "cell_type": "code", "execution_count": null, "id": "8bbb1505-5e91-49d2-b94e-045ff9f482e2", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.118690Z", - "iopub.status.idle": "2025-01-14T23:31:11.118876Z", - "shell.execute_reply": "2025-01-14T23:31:11.118793Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.118783Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", @@ -1205,14 +855,7 @@ "cell_type": "code", "execution_count": null, "id": "3f5073a8-7c3d-4361-92b7-e1fa05c5dcde", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.119497Z", - "iopub.status.idle": "2025-01-14T23:31:11.119668Z", - "shell.execute_reply": "2025-01-14T23:31:11.119596Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.119589Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# here add a second set of panels to try to understand the small bias at bright end of kron (is it kron radius-dependent? since its not deblending dependent?\n", @@ -1276,14 +919,7 @@ "cell_type": "code", "execution_count": null, "id": "6fdf7c38-0c80-4351-856d-8390d22ad375", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.120408Z", - "iopub.status.idle": "2025-01-14T23:31:11.120613Z", - "shell.execute_reply": "2025-01-14T23:31:11.120529Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.120518Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", @@ -1339,14 +975,7 @@ "cell_type": "code", "execution_count": null, "id": "1e525f6f-5521-4a67-9abb-b96e4a198043", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.121410Z", - "iopub.status.idle": "2025-01-14T23:31:11.121602Z", - "shell.execute_reply": "2025-01-14T23:31:11.121521Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.121513Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# the following plots are identical, consider a different comparison that is informative\n", @@ -1409,14 +1038,7 @@ "cell_type": "code", "execution_count": null, "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.122379Z", - "iopub.status.idle": "2025-01-14T23:31:11.122570Z", - "shell.execute_reply": "2025-01-14T23:31:11.122493Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.122485Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -1508,14 +1130,7 @@ "cell_type": "code", "execution_count": null, "id": "fd7e6ebb-f348-4df9-9859-9d4febb51238", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.123193Z", - "iopub.status.idle": "2025-01-14T23:31:11.123355Z", - "shell.execute_reply": "2025-01-14T23:31:11.123280Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.123274Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_g, ts.flux_z, ts.redshift, \"\\\n", @@ -1533,14 +1148,7 @@ "cell_type": "code", "execution_count": null, "id": "baec0660-1125-43de-9f21-cc5ccef958f0", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.123942Z", - "iopub.status.idle": "2025-01-14T23:31:11.124124Z", - "shell.execute_reply": "2025-01-14T23:31:11.124039Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.124030Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1556,14 +1164,7 @@ "cell_type": "code", "execution_count": null, "id": "8d97291d-2043-40a6-859c-db391565a9da", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.124758Z", - "iopub.status.idle": "2025-01-14T23:31:11.124917Z", - "shell.execute_reply": "2025-01-14T23:31:11.124850Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.124843Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4\n", @@ -1581,14 +1182,7 @@ "cell_type": "code", "execution_count": null, "id": "59afd145-cc34-4671-82ac-616ba6f28882", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.125662Z", - "iopub.status.idle": "2025-01-14T23:31:11.125821Z", - "shell.execute_reply": "2025-01-14T23:31:11.125751Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.125745Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# very confused about why these colors line up so perfectly when the mags do not...\n", @@ -1640,14 +1234,7 @@ "cell_type": "code", "execution_count": null, "id": "8575a64b-f166-453b-aebd-dd09d728a259", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.126152Z", - "iopub.status.idle": "2025-01-14T23:31:11.126317Z", - "shell.execute_reply": "2025-01-14T23:31:11.126237Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.126231Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", @@ -1664,14 +1251,7 @@ "cell_type": "code", "execution_count": null, "id": "24718446-033d-4b3d-b11f-a94c708c6d1e", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.127061Z", - "iopub.status.idle": "2025-01-14T23:31:11.127217Z", - "shell.execute_reply": "2025-01-14T23:31:11.127149Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.127142Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1684,14 +1264,7 @@ "cell_type": "code", "execution_count": null, "id": "1ddc4e98-1151-4aba-806a-b9097d2edfd0", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.127806Z", - "iopub.status.idle": "2025-01-14T23:31:11.127983Z", - "shell.execute_reply": "2025-01-14T23:31:11.127902Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.127892Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "results = job.fetch_result()\n", @@ -1702,14 +1275,7 @@ "cell_type": "code", "execution_count": null, "id": "0b26042c-c234-4885-819b-a05dfba2bc31", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.128854Z", - "iopub.status.idle": "2025-01-14T23:31:11.129007Z", - "shell.execute_reply": "2025-01-14T23:31:11.128940Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.128934Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# pick an object that has large size\n", @@ -1738,14 +1304,7 @@ "cell_type": "code", "execution_count": null, "id": "12f5be0d-7816-4622-8523-aff5e6b9a028", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.130039Z", - "iopub.status.idle": "2025-01-14T23:31:11.130263Z", - "shell.execute_reply": "2025-01-14T23:31:11.130171Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.130163Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "sys.exit()" @@ -1755,14 +1314,7 @@ "cell_type": "code", "execution_count": null, "id": "94c2ecc1-5760-4872-b01d-e6d48b145201", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.131017Z", - "iopub.status.idle": "2025-01-14T23:31:11.131201Z", - "shell.execute_reply": "2025-01-14T23:31:11.131117Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.131108Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "#junk that doens't work yet:\n", @@ -1812,14 +1364,7 @@ "cell_type": "code", "execution_count": null, "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.131790Z", - "iopub.status.idle": "2025-01-14T23:31:11.131959Z", - "shell.execute_reply": "2025-01-14T23:31:11.131886Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.131879Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# compare kron mag to cmodel mag\n", @@ -1848,14 +1393,7 @@ "cell_type": "code", "execution_count": null, "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.132448Z", - "iopub.status.idle": "2025-01-14T23:31:11.132667Z", - "shell.execute_reply": "2025-01-14T23:31:11.132583Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.132574Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -1880,14 +1418,7 @@ "cell_type": "code", "execution_count": null, "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.133544Z", - "iopub.status.idle": "2025-01-14T23:31:11.133720Z", - "shell.execute_reply": "2025-01-14T23:31:11.133642Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.133635Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -1912,14 +1443,7 @@ "cell_type": "code", "execution_count": null, "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.134445Z", - "iopub.status.idle": "2025-01-14T23:31:11.134639Z", - "shell.execute_reply": "2025-01-14T23:31:11.134569Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.134562Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -1956,14 +1480,7 @@ "cell_type": "code", "execution_count": null, "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.136113Z", - "iopub.status.idle": "2025-01-14T23:31:11.136313Z", - "shell.execute_reply": "2025-01-14T23:31:11.136225Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.136217Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_gaapOptimalFlux'][whbright],\n", @@ -1980,14 +1497,7 @@ "cell_type": "code", "execution_count": null, "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-14T23:31:11.137071Z", - "iopub.status.idle": "2025-01-14T23:31:11.137243Z", - "shell.execute_reply": "2025-01-14T23:31:11.137165Z", - "shell.execute_reply.started": "2025-01-14T23:31:11.137158Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", From 65d3b98646ad8c7988a164cb41d1e81873d8b023 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 28 Jan 2025 22:17:22 +0000 Subject: [PATCH 50/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 97 ++++++++++++++++++++++++++++++++- 1 file changed, 95 insertions(+), 2 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 324e1c9..c2d2c3b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -603,12 +603,56 @@ "outputs": [], "source": [ "#truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", - "\n", + "i_kronRad = tab['i_kronRad']\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", + "metadata": {}, + "outputs": [], + "source": [ + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "ylims = [-1.2,1.2]\n", + "\n", + "ax.plot(i_kronRad, (cmodel_mag-kron_mag),'.',alpha=.1,label='Kron',color='blue')\n", + "ax.plot(i_kronRad, (cmodel_mag-gaap_mag),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "#ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", + "\n", + "ax2.hist((cmodel_mag-kron_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist((cmodel_mag-gaap_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.set_ylim([-1,1])\n", + "#ax.axhline(0,linestyle='--')\n", + "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", + "ax.set_ylabel('cModel mag - Other mag')\n", + "ax.set_ylim([-1,1])\n", + "ax.set_xlim([0,15])\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca225554-ed54-4934-a656-89ac1cc9ad76", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT column_name, datatype, description, unit \" \\\n", + " \"FROM tap_schema.columns \" \\\n", + " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", + "\n", + "schema_results = service.search(query).to_table()\n", + "search_string = 'kron'\n", + "band = 'i_'\n", + "for cname in schema_results['column_name']:\n", + " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", + " print(cname)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -616,7 +660,7 @@ "metadata": {}, "outputs": [], "source": [ - "#sys.exit()" + "sys.exit()" ] }, { @@ -1555,6 +1599,55 @@ "\n", "Dan has thoughts about the sersic model photometry, talk to him at some point. He's been experimenting with single sersic photometry from multiprofit" ] + }, + { + "cell_type": "markdown", + "id": "9872892a-18d7-4f6f-a82a-cbe970f1f60f", + "metadata": {}, + "source": [ + "Dan:\n", + "Jim: algorithms workshop maybe there are some slides somewhere. lsst algorithms workshop project.lsst.org/meetings/log\n", + "thursday morning plans for galaxy photometry\n", + "\n", + "Gaap is supposed to be more consistent in colors not more accurate. it sounds like people have not looked at whehter or not the different measures are better. Photo-z team \n", + "\n", + "ellipse parameters are probably from sdss shape: \n", + "\n", + "we think that xx yy and xy are related to kron and you can reconstruct the PA from that.\n", + "most moment measurements are on un-PSF-convolved (not corrected for PSF) \n", + "\n", + "cmodel and alos cmodel_free (which have separate free params per band) without _free has fixed to some detection or ref band (and there's a separate column for that called ref)\n", + "\n", + "cmodel does fit its own ellipse params but they are not in the schema\n", + "\n", + "cmodel for galaxies because they are total fluxes\n", + "psf mags for stars.\n", + "consider using Gaap colors for photo-z and stellar pops modeling\n", + "\n", + "kron or aperture photometry: but we don't need to provide recommendations on if to use them or not. Perhaps in situations where you don't \n", + "\n", + "they are curious to know what is the performance\n", + "\n", + "https://www.sdss4.org/dr17/algorithms/magnitudes/\n", + "radial profiles is the purpose of the aperture photometry\n", + "\n", + "Jim explains that applying aperture corrections for galaxies is basically impossible (??)\n", + "\n", + "The backgrounds for LSST are brighter / and harder to subtract than space based, which is why these dont' have aperture corrections done?\n", + "\n", + "A random galaxy person should just use sersic fluxes (i.e. cModel). In DP1 one can expect that there will be a single sersic model (multiprofit) photometry included.\n", + "\n", + "our fixed aperture radius photometry is not done in PSF homogenized images\n", + "\n", + "COSMOS2020 corrects to total fluxes using method of Lake et al.\n", + "\n", + "can compute from kron parameters what the missing flux outside the aperture is. for an object htat is considerably bigger than the PSF yes.\n", + "\n", + "pick a typical SFG and a typical elliptical and show the different apertures and compare the flux measurements then this would be useful\n", + "\n", + "sci-unit: \n", + "https://rubinobs.atlassian.net/browse/LVV-508\n" + ] } ], "metadata": { From 4eab95455e406806432de5cb3a6db53d5f628d7d Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 29 Jan 2025 17:40:37 +0000 Subject: [PATCH 51/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 684 +++++++++++++++++++++++++++++--- 1 file changed, 619 insertions(+), 65 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index c2d2c3b..7417d74 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -20,9 +20,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:35.849959Z", + "iopub.status.busy": "2025-01-28T22:17:35.849795Z", + "iopub.status.idle": "2025-01-28T22:17:35.852384Z", + "shell.execute_reply": "2025-01-28T22:17:35.851898Z", + "shell.execute_reply.started": "2025-01-28T22:17:35.849945Z" + } + }, "outputs": [], "source": [ "#%load_ext pycodestyle_magic\n", @@ -236,9 +244,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "2dbc75bd-a802-4576-8628-4e0088942303", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:35.853122Z", + "iopub.status.busy": "2025-01-28T22:17:35.852963Z", + "iopub.status.idle": "2025-01-28T22:17:41.219083Z", + "shell.execute_reply": "2025-01-28T22:17:41.218391Z", + "shell.execute_reply.started": "2025-01-28T22:17:35.853108Z" + } + }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -308,9 +324,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:41.220255Z", + "iopub.status.busy": "2025-01-28T22:17:41.219641Z", + "iopub.status.idle": "2025-01-28T22:17:41.247902Z", + "shell.execute_reply": "2025-01-28T22:17:41.247239Z", + "shell.execute_reply.started": "2025-01-28T22:17:41.220234Z" + } + }, "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", @@ -346,9 +370,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "2f19f3b6-7357-4848-a2b4-5597aa8c8e15", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:41.249111Z", + "iopub.status.busy": "2025-01-28T22:17:41.248900Z", + "iopub.status.idle": "2025-01-28T22:17:41.252550Z", + "shell.execute_reply": "2025-01-28T22:17:41.252001Z", + "shell.execute_reply.started": "2025-01-28T22:17:41.249094Z" + } + }, "outputs": [], "source": [ "def plotImage(exposure: ExposureF):\n", @@ -373,9 +405,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "da81a645-947e-4ca2-82f7-905de4ef79da", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:41.253284Z", + "iopub.status.busy": "2025-01-28T22:17:41.253121Z", + "iopub.status.idle": "2025-01-28T22:17:41.268724Z", + "shell.execute_reply": "2025-01-28T22:17:41.268013Z", + "shell.execute_reply.started": "2025-01-28T22:17:41.253269Z" + } + }, "outputs": [], "source": [ "\n", @@ -489,9 +529,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:41.269489Z", + "iopub.status.busy": "2025-01-28T22:17:41.269297Z", + "iopub.status.idle": "2025-01-28T22:17:41.321845Z", + "shell.execute_reply": "2025-01-28T22:17:41.321293Z", + "shell.execute_reply.started": "2025-01-28T22:17:41.269450Z" + } + }, "outputs": [], "source": [ "service = get_tap_service(\"tap\")" @@ -509,9 +557,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:41.322632Z", + "iopub.status.busy": "2025-01-28T22:17:41.322436Z", + "iopub.status.idle": "2025-01-28T22:17:41.504399Z", + "shell.execute_reply": "2025-01-28T22:17:41.503783Z", + "shell.execute_reply.started": "2025-01-28T22:17:41.322617Z" + } + }, "outputs": [], "source": [ "query = \"SELECT column_name, datatype, description, unit \" \\\n", @@ -523,10 +579,119 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:41.505261Z", + "iopub.status.busy": "2025-01-28T22:17:41.505073Z", + "iopub.status.idle": "2025-01-28T22:17:41.520628Z", + "shell.execute_reply": "2025-01-28T22:17:41.520084Z", + "shell.execute_reply.started": "2025-01-28T22:17:41.505245Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i_ap03Flux\n", + "i_ap03Flux_flag\n", + "i_ap03FluxErr\n", + "i_ap06Flux\n", + "i_ap06Flux_flag\n", + "i_ap06FluxErr\n", + "i_ap09Flux\n", + "i_ap09Flux_flag\n", + "i_ap09FluxErr\n", + "i_ap12Flux\n", + "i_ap12Flux_flag\n", + "i_ap12FluxErr\n", + "i_ap17Flux\n", + "i_ap17Flux_flag\n", + "i_ap17FluxErr\n", + "i_ap25Flux\n", + "i_ap25Flux_flag\n", + "i_ap25FluxErr\n", + "i_ap35Flux\n", + "i_ap35Flux_flag\n", + "i_ap35FluxErr\n", + "i_ap50Flux\n", + "i_ap50Flux_flag\n", + "i_ap50FluxErr\n", + "i_ap70Flux\n", + "i_ap70Flux_flag\n", + "i_ap70FluxErr\n", + "i_apFlux_flag\n", + "i_apFlux_flag_apertureTruncated\n", + "i_apFlux_flag_sincCoeffsTruncated\n", + "i_bdFluxB\n", + "i_bdFluxBErr\n", + "i_bdFluxD\n", + "i_bdFluxDErr\n", + "i_calibFlux\n", + "i_calibFlux_flag\n", + "i_calibFlux_flag_apertureTruncated\n", + "i_calibFlux_flag_sincCoeffsTruncated\n", + "i_calibFluxErr\n", + "i_cModelFlux\n", + "i_cModelFlux_inner\n", + "i_cModelFluxErr\n", + "i_free_cModelFlux\n", + "i_free_cModelFlux_flag\n", + "i_free_cModelFlux_inner\n", + "i_free_cModelFluxErr\n", + "i_free_psfFlux\n", + "i_free_psfFlux_flag\n", + "i_free_psfFluxErr\n", + "i_gaap0p5Flux\n", + "i_gaap0p5Flux_flag_bigPsf\n", + "i_gaap0p5FluxErr\n", + "i_gaap0p7Flux\n", + "i_gaap0p7Flux_flag_bigPsf\n", + "i_gaap0p7FluxErr\n", + "i_gaap1p0Flux\n", + "i_gaap1p0Flux_flag_bigPsf\n", + "i_gaap1p0FluxErr\n", + "i_gaap1p5Flux\n", + "i_gaap1p5Flux_flag_bigPsf\n", + "i_gaap1p5FluxErr\n", + "i_gaap2p5Flux\n", + "i_gaap2p5Flux_flag_bigPsf\n", + "i_gaap2p5FluxErr\n", + "i_gaap3p0Flux\n", + "i_gaap3p0Flux_flag_bigPsf\n", + "i_gaap3p0FluxErr\n", + "i_gaapFlux_flag\n", + "i_gaapFlux_flag_edge\n", + "i_gaapFlux_flag_gaussianization\n", + "i_gaapOptimalFlux\n", + "i_gaapOptimalFlux_flag_bigPsf\n", + "i_gaapOptimalFluxErr\n", + "i_gaapPsfFlux\n", + "i_gaapPsfFluxErr\n", + "i_kronFlux\n", + "i_kronFlux_flag\n", + "i_kronFlux_flag_bad_radius\n", + "i_kronFlux_flag_bad_shape\n", + "i_kronFlux_flag_bad_shape_no_psf\n", + "i_kronFlux_flag_edge\n", + "i_kronFlux_flag_no_fallback_radius\n", + "i_kronFlux_flag_no_minimum_radius\n", + "i_kronFlux_flag_small_radius\n", + "i_kronFlux_flag_used_minimum_radius\n", + "i_kronFlux_flag_used_psf_radius\n", + "i_kronFluxErr\n", + "i_psfFlux\n", + "i_psfFlux_area\n", + "i_psfFlux_flag\n", + "i_psfFlux_flag_apCorr\n", + "i_psfFlux_flag_edge\n", + "i_psfFlux_flag_noGoodPixels\n", + "i_psfFluxErr\n" + ] + } + ], "source": [ "search_string = 'Flux'\n", "band = 'i_'\n", @@ -537,9 +702,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "0d82dd79-a4d7-4428-a77c-1ed2bb717486", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:41.521399Z", + "iopub.status.busy": "2025-01-28T22:17:41.521220Z", + "iopub.status.idle": "2025-01-28T22:17:41.536124Z", + "shell.execute_reply": "2025-01-28T22:17:41.535516Z", + "shell.execute_reply.started": "2025-01-28T22:17:41.521384Z" + } + }, "outputs": [], "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", @@ -551,10 +724,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "e75ee4db-e4b9-4ff2-ba07-1f7f34a8d44b", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:41.536966Z", + "iopub.status.busy": "2025-01-28T22:17:41.536793Z", + "iopub.status.idle": "2025-01-28T22:17:44.722686Z", + "shell.execute_reply": "2025-01-28T22:17:44.722079Z", + "shell.execute_reply.started": "2025-01-28T22:17:41.536952Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job phase is COMPLETED\n" + ] + } + ], "source": [ "job = service.submit_job(query)\n", "job.run()\n", @@ -572,10 +761,86 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "02ea5eb7-bac9-4c9f-90e4-626a69340b41", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:44.723465Z", + "iopub.status.busy": "2025-01-28T22:17:44.723289Z", + "iopub.status.idle": "2025-01-28T22:17:45.194527Z", + "shell.execute_reply": "2025-01-28T22:17:45.193957Z", + "shell.execute_reply.started": "2025-01-28T22:17:44.723436Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "13699\n" + ] + }, + { + "data": { + "text/html": [ + "<div><i>Table length=13699</i>\n", + "<table id=\"table139486025584144\" class=\"table-striped table-bordered table-condensed\">\n", + "<thead><tr><th>coord_ra</th><th>coord_dec</th><th>detect_fromBlend</th><th>detect_isIsolated</th><th>i_blendedness_flag</th><th>i_blendedness</th><th>i_extendedness</th><th>i_kronFlux</th><th>i_kronFluxErr</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th><th>i_gaapOptimalFlux</th></tr></thead>\n", + "<thead><tr><th>deg</th><th>deg</th><th></th><th></th><th></th><th></th><th></th><th>nJy</th><th>nJy</th><th></th><th></th><th>nJy</th><th>nJy</th></tr></thead>\n", + "<thead><tr><th>float64</th><th>float64</th><th>bool</th><th>bool</th><th>bool</th><th>float64</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th><th>float64</th></tr></thead>\n", + "<tr><td>62.0067968</td><td>-36.9020816</td><td>True</td><td>False</td><td>False</td><td>0.0049983</td><td>1.0</td><td>10922.7229643</td><td>85.9962967</td><td>5.04477</td><td>False</td><td>12304.6727035</td><td>6460.0525305</td></tr>\n", + "<tr><td>62.0037681</td><td>-36.9024377</td><td>True</td><td>False</td><td>False</td><td>-7e-06</td><td>1.0</td><td>1182.0265062</td><td>53.1780048</td><td>3.20611</td><td>False</td><td>1181.785426</td><td>910.9258521</td></tr>\n", + "<tr><td>62.0085719</td><td>-36.9024176</td><td>True</td><td>False</td><td>False</td><td>0.0726756</td><td>1.0</td><td>1266.9036015</td><td>82.3860448</td><td>4.84711</td><td>False</td><td>1372.3096197</td><td>756.726213</td></tr>\n", + "<tr><td>62.005342</td><td>-36.903529</td><td>True</td><td>False</td><td>False</td><td>0.0069281</td><td>1.0</td><td>909.234224</td><td>75.7142907</td><td>4.51312</td><td>False</td><td>886.0944003</td><td>607.4636703</td></tr>\n", + "<tr><td>62.0045637</td><td>-36.902735</td><td>True</td><td>False</td><td>False</td><td>-0.0154942</td><td>1.0</td><td>604.4002275</td><td>51.3669159</td><td>3.07866</td><td>False</td><td>616.7654328</td><td>507.5349915</td></tr>\n", + "<tr><td>62.0423854</td><td>-36.9036671</td><td>True</td><td>False</td><td>False</td><td>-0.0023311</td><td>1.0</td><td>13512.3935231</td><td>71.4485953</td><td>4.36286</td><td>False</td><td>13351.4881963</td><td>8748.3736732</td></tr>\n", + "<tr><td>62.1962173</td><td>-36.9037948</td><td>True</td><td>False</td><td>False</td><td>0.041724</td><td>1.0</td><td>661.3043447</td><td>53.564723</td><td>3.22397</td><td>False</td><td>656.9081063</td><td>539.9425927</td></tr>\n", + "<tr><td>62.1956541</td><td>-36.9046139</td><td>True</td><td>False</td><td>False</td><td>-0.0236929</td><td>1.0</td><td>802.0931369</td><td>67.3860517</td><td>4.07341</td><td>False</td><td>789.6351291</td><td>551.6344401</td></tr>\n", + "<tr><td>62.0184482</td><td>-36.9029098</td><td>True</td><td>False</td><td>False</td><td>-0.0024643</td><td>1.0</td><td>3610.8459627</td><td>60.6887248</td><td>3.67457</td><td>False</td><td>3703.5324696</td><td>2622.7699794</td></tr>\n", + "<tr><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n", + "<tr><td>62.2340701</td><td>-37.0589707</td><td>True</td><td>False</td><td>False</td><td>0.017393</td><td>1.0</td><td>5475.2581198</td><td>106.5125488</td><td>6.51392</td><td>False</td><td>7968.7930086</td><td>2812.270571</td></tr>\n", + "<tr><td>62.238679</td><td>-37.0598473</td><td>True</td><td>False</td><td>False</td><td>0.002246</td><td>1.0</td><td>656.6051349</td><td>53.4197209</td><td>3.30962</td><td>False</td><td>646.5235391</td><td>512.0469676</td></tr>\n", + "<tr><td>62.2379366</td><td>-37.0608993</td><td>True</td><td>False</td><td>False</td><td>0.0243649</td><td>1.0</td><td>3448.5360492</td><td>60.0880805</td><td>3.71268</td><td>False</td><td>3390.7405566</td><td>2514.2672709</td></tr>\n", + "<tr><td>62.2347859</td><td>-37.0630304</td><td>True</td><td>False</td><td>False</td><td>-0.0123865</td><td>1.0</td><td>2758.118914</td><td>43.642257</td><td>2.69446</td><td>False</td><td>2795.1106328</td><td>2595.641324</td></tr>\n", + "<tr><td>62.2320894</td><td>-37.0631907</td><td>True</td><td>False</td><td>False</td><td>-0.0024702</td><td>1.0</td><td>3348.8860869</td><td>74.5423706</td><td>4.53893</td><td>False</td><td>3404.9391468</td><td>2013.9016243</td></tr>\n", + "<tr><td>62.2374752</td><td>-37.063016</td><td>True</td><td>False</td><td>False</td><td>-0.0445366</td><td>1.0</td><td>1474.240171</td><td>42.3870591</td><td>2.62527</td><td>False</td><td>1484.0448861</td><td>1422.4822653</td></tr>\n", + "<tr><td>62.2346703</td><td>-37.0661891</td><td>True</td><td>False</td><td>False</td><td>0.061405</td><td>1.0</td><td>777.2332956</td><td>65.4523749</td><td>4.02862</td><td>False</td><td>777.261764</td><td>537.0907481</td></tr>\n", + "<tr><td>62.2339994</td><td>-37.0649774</td><td>True</td><td>False</td><td>False</td><td>-0.0043305</td><td>1.0</td><td>2170.4946541</td><td>47.0723022</td><td>2.8639</td><td>False</td><td>2130.9356269</td><td>1949.1903224</td></tr>\n", + "<tr><td>62.23306</td><td>-37.0618854</td><td>True</td><td>False</td><td>False</td><td>-0.003919</td><td>1.0</td><td>1128.0548814</td><td>71.7575598</td><td>4.39139</td><td>False</td><td>1162.450445</td><td>765.2318206</td></tr>\n", + "</table></div>" + ], + "text/plain": [ + "<Table length=13699>\n", + " coord_ra coord_dec detect_fromBlend ... i_cModelFlux i_gaapOptimalFlux\n", + " deg deg ... nJy nJy \n", + " float64 float64 bool ... float64 float64 \n", + "---------- ----------- ---------------- ... ------------- -----------------\n", + "62.0067968 -36.9020816 True ... 12304.6727035 6460.0525305\n", + "62.0037681 -36.9024377 True ... 1181.785426 910.9258521\n", + "62.0085719 -36.9024176 True ... 1372.3096197 756.726213\n", + " 62.005342 -36.903529 True ... 886.0944003 607.4636703\n", + "62.0045637 -36.902735 True ... 616.7654328 507.5349915\n", + "62.0423854 -36.9036671 True ... 13351.4881963 8748.3736732\n", + "62.1962173 -36.9037948 True ... 656.9081063 539.9425927\n", + "62.1956541 -36.9046139 True ... 789.6351291 551.6344401\n", + "62.0184482 -36.9029098 True ... 3703.5324696 2622.7699794\n", + " ... ... ... ... ... ...\n", + "62.2340701 -37.0589707 True ... 7968.7930086 2812.270571\n", + " 62.238679 -37.0598473 True ... 646.5235391 512.0469676\n", + "62.2379366 -37.0608993 True ... 3390.7405566 2514.2672709\n", + "62.2347859 -37.0630304 True ... 2795.1106328 2595.641324\n", + "62.2320894 -37.0631907 True ... 3404.9391468 2013.9016243\n", + "62.2374752 -37.063016 True ... 1484.0448861 1422.4822653\n", + "62.2346703 -37.0661891 True ... 777.261764 537.0907481\n", + "62.2339994 -37.0649774 True ... 2130.9356269 1949.1903224\n", + " 62.23306 -37.0618854 True ... 1162.450445 765.2318206" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "results = job.fetch_result()\n", "print(len(results))\n", @@ -597,10 +862,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "e8b4a64a-6565-4d7d-ae48-0a666c41101e", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:45.195220Z", + "iopub.status.busy": "2025-01-28T22:17:45.195060Z", + "iopub.status.idle": "2025-01-28T22:17:45.201446Z", + "shell.execute_reply": "2025-01-28T22:17:45.200876Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.195206Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_6782/4090871.py:3: RuntimeWarning: divide by zero encountered in log10\n", + " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n" + ] + } + ], "source": [ "#truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", "i_kronRad = tab['i_kronRad']\n", @@ -611,10 +893,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:45.202224Z", + "iopub.status.busy": "2025-01-28T22:17:45.202066Z", + "iopub.status.idle": "2025-01-28T22:17:45.507923Z", + "shell.execute_reply": "2025-01-28T22:17:45.507151Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.202209Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7edc9ee16650>" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1000x600 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-1.2,1.2]\n", @@ -636,10 +947,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "ca225554-ed54-4934-a656-89ac1cc9ad76", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:45.508910Z", + "iopub.status.busy": "2025-01-28T22:17:45.508699Z", + "iopub.status.idle": "2025-01-28T22:17:45.629636Z", + "shell.execute_reply": "2025-01-28T22:17:45.629014Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.508893Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i_kronFlux\n", + "i_kronFlux_flag\n", + "i_kronFlux_flag_bad_radius\n", + "i_kronFlux_flag_bad_shape\n", + "i_kronFlux_flag_bad_shape_no_psf\n", + "i_kronFlux_flag_edge\n", + "i_kronFlux_flag_no_fallback_radius\n", + "i_kronFlux_flag_no_minimum_radius\n", + "i_kronFlux_flag_small_radius\n", + "i_kronFlux_flag_used_minimum_radius\n", + "i_kronFlux_flag_used_psf_radius\n", + "i_kronFluxErr\n", + "i_kronRad\n" + ] + } + ], "source": [ "query = \"SELECT column_name, datatype, description, unit \" \\\n", " \"FROM tap_schema.columns \" \\\n", @@ -655,10 +994,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "432db690-be7e-43bf-a640-a80af727652b", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2025-01-28T22:17:45.630368Z", + "iopub.status.busy": "2025-01-28T22:17:45.630205Z", + "iopub.status.idle": "2025-01-28T22:17:45.637651Z", + "shell.execute_reply": "2025-01-28T22:17:45.635126Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.630354Z" + } + }, + "outputs": [ + { + "ename": "SystemExit", + "evalue": "", + "output_type": "error", + "traceback": [ + "An exception has occurred, use %tb to see the full traceback.\n", + "\u001b[0;31mSystemExit\u001b[0m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/lsst/software/stack/conda/envs/lsst-scipipe-9.0.0/lib/python3.11/site-packages/IPython/core/interactiveshell.py:3585: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n", + " warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n" + ] + } + ], "source": [ "sys.exit()" ] @@ -689,7 +1054,14 @@ "cell_type": "code", "execution_count": null, "id": "0d28a6ad-4436-410c-9b9d-e995140be304", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.638051Z", + "iopub.status.idle": "2025-01-28T22:17:45.638259Z", + "shell.execute_reply": "2025-01-28T22:17:45.638172Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.638162Z" + } + }, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", @@ -706,7 +1078,14 @@ "cell_type": "code", "execution_count": null, "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.638968Z", + "iopub.status.idle": "2025-01-28T22:17:45.639148Z", + "shell.execute_reply": "2025-01-28T22:17:45.639072Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.639065Z" + } + }, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -727,7 +1106,14 @@ "cell_type": "code", "execution_count": null, "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.639841Z", + "iopub.status.idle": "2025-01-28T22:17:45.640004Z", + "shell.execute_reply": "2025-01-28T22:17:45.639932Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.639924Z" + } + }, "outputs": [], "source": [ "results = job.fetch_result()\n", @@ -752,7 +1138,14 @@ "cell_type": "code", "execution_count": null, "id": "7a8000f6-a914-4073-8130-67d912f52b09", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.640475Z", + "iopub.status.idle": "2025-01-28T22:17:45.640706Z", + "shell.execute_reply": "2025-01-28T22:17:45.640628Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.640621Z" + } + }, "outputs": [], "source": [ "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", @@ -774,7 +1167,14 @@ "cell_type": "code", "execution_count": null, "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.641381Z", + "iopub.status.idle": "2025-01-28T22:17:45.641548Z", + "shell.execute_reply": "2025-01-28T22:17:45.641474Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.641467Z" + } + }, "outputs": [], "source": [ "fig, ax = plt.subplots()\n", @@ -829,7 +1229,14 @@ "cell_type": "code", "execution_count": null, "id": "8bbb1505-5e91-49d2-b94e-045ff9f482e2", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.641902Z", + "iopub.status.idle": "2025-01-28T22:17:45.642057Z", + "shell.execute_reply": "2025-01-28T22:17:45.641982Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.641975Z" + } + }, "outputs": [], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", @@ -899,7 +1306,14 @@ "cell_type": "code", "execution_count": null, "id": "3f5073a8-7c3d-4361-92b7-e1fa05c5dcde", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.642739Z", + "iopub.status.idle": "2025-01-28T22:17:45.642927Z", + "shell.execute_reply": "2025-01-28T22:17:45.642843Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.642833Z" + } + }, "outputs": [], "source": [ "# here add a second set of panels to try to understand the small bias at bright end of kron (is it kron radius-dependent? since its not deblending dependent?\n", @@ -963,7 +1377,14 @@ "cell_type": "code", "execution_count": null, "id": "6fdf7c38-0c80-4351-856d-8390d22ad375", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.643513Z", + "iopub.status.idle": "2025-01-28T22:17:45.643677Z", + "shell.execute_reply": "2025-01-28T22:17:45.643603Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.643596Z" + } + }, "outputs": [], "source": [ "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", @@ -1019,7 +1440,14 @@ "cell_type": "code", "execution_count": null, "id": "1e525f6f-5521-4a67-9abb-b96e4a198043", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.644144Z", + "iopub.status.idle": "2025-01-28T22:17:45.644292Z", + "shell.execute_reply": "2025-01-28T22:17:45.644224Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.644218Z" + } + }, "outputs": [], "source": [ "# the following plots are identical, consider a different comparison that is informative\n", @@ -1082,7 +1510,14 @@ "cell_type": "code", "execution_count": null, "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.644842Z", + "iopub.status.idle": "2025-01-28T22:17:45.644994Z", + "shell.execute_reply": "2025-01-28T22:17:45.644924Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.644917Z" + } + }, "outputs": [], "source": [ "\n", @@ -1174,7 +1609,14 @@ "cell_type": "code", "execution_count": null, "id": "fd7e6ebb-f348-4df9-9859-9d4febb51238", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.645403Z", + "iopub.status.idle": "2025-01-28T22:17:45.645576Z", + "shell.execute_reply": "2025-01-28T22:17:45.645502Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.645496Z" + } + }, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_g, ts.flux_z, ts.redshift, \"\\\n", @@ -1192,7 +1634,14 @@ "cell_type": "code", "execution_count": null, "id": "baec0660-1125-43de-9f21-cc5ccef958f0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.646125Z", + "iopub.status.idle": "2025-01-28T22:17:45.646276Z", + "shell.execute_reply": "2025-01-28T22:17:45.646210Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.646203Z" + } + }, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1208,7 +1657,14 @@ "cell_type": "code", "execution_count": null, "id": "8d97291d-2043-40a6-859c-db391565a9da", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.646746Z", + "iopub.status.idle": "2025-01-28T22:17:45.646901Z", + "shell.execute_reply": "2025-01-28T22:17:45.646830Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.646823Z" + } + }, "outputs": [], "source": [ "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4\n", @@ -1226,7 +1682,14 @@ "cell_type": "code", "execution_count": null, "id": "59afd145-cc34-4671-82ac-616ba6f28882", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.647404Z", + "iopub.status.idle": "2025-01-28T22:17:45.647566Z", + "shell.execute_reply": "2025-01-28T22:17:45.647496Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.647490Z" + } + }, "outputs": [], "source": [ "# very confused about why these colors line up so perfectly when the mags do not...\n", @@ -1278,7 +1741,14 @@ "cell_type": "code", "execution_count": null, "id": "8575a64b-f166-453b-aebd-dd09d728a259", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.648116Z", + "iopub.status.idle": "2025-01-28T22:17:45.648268Z", + "shell.execute_reply": "2025-01-28T22:17:45.648197Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.648190Z" + } + }, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", @@ -1295,7 +1765,14 @@ "cell_type": "code", "execution_count": null, "id": "24718446-033d-4b3d-b11f-a94c708c6d1e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.648662Z", + "iopub.status.idle": "2025-01-28T22:17:45.648817Z", + "shell.execute_reply": "2025-01-28T22:17:45.648749Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.648742Z" + } + }, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1308,7 +1785,14 @@ "cell_type": "code", "execution_count": null, "id": "1ddc4e98-1151-4aba-806a-b9097d2edfd0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.649491Z", + "iopub.status.idle": "2025-01-28T22:17:45.649652Z", + "shell.execute_reply": "2025-01-28T22:17:45.649582Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.649575Z" + } + }, "outputs": [], "source": [ "results = job.fetch_result()\n", @@ -1319,7 +1803,14 @@ "cell_type": "code", "execution_count": null, "id": "0b26042c-c234-4885-819b-a05dfba2bc31", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.650468Z", + "iopub.status.idle": "2025-01-28T22:17:45.650625Z", + "shell.execute_reply": "2025-01-28T22:17:45.650554Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.650547Z" + } + }, "outputs": [], "source": [ "# pick an object that has large size\n", @@ -1348,7 +1839,14 @@ "cell_type": "code", "execution_count": null, "id": "12f5be0d-7816-4622-8523-aff5e6b9a028", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.650924Z", + "iopub.status.idle": "2025-01-28T22:17:45.651078Z", + "shell.execute_reply": "2025-01-28T22:17:45.651001Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.650995Z" + } + }, "outputs": [], "source": [ "sys.exit()" @@ -1358,7 +1856,14 @@ "cell_type": "code", "execution_count": null, "id": "94c2ecc1-5760-4872-b01d-e6d48b145201", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.651554Z", + "iopub.status.idle": "2025-01-28T22:17:45.651709Z", + "shell.execute_reply": "2025-01-28T22:17:45.651642Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.651635Z" + } + }, "outputs": [], "source": [ "#junk that doens't work yet:\n", @@ -1408,7 +1913,14 @@ "cell_type": "code", "execution_count": null, "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.652405Z", + "iopub.status.idle": "2025-01-28T22:17:45.652570Z", + "shell.execute_reply": "2025-01-28T22:17:45.652501Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.652494Z" + } + }, "outputs": [], "source": [ "# compare kron mag to cmodel mag\n", @@ -1437,7 +1949,14 @@ "cell_type": "code", "execution_count": null, "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.653104Z", + "iopub.status.idle": "2025-01-28T22:17:45.653253Z", + "shell.execute_reply": "2025-01-28T22:17:45.653183Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.653177Z" + } + }, "outputs": [], "source": [ "\n", @@ -1462,7 +1981,14 @@ "cell_type": "code", "execution_count": null, "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.653643Z", + "iopub.status.idle": "2025-01-28T22:17:45.653794Z", + "shell.execute_reply": "2025-01-28T22:17:45.653727Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.653720Z" + } + }, "outputs": [], "source": [ "\n", @@ -1487,7 +2013,14 @@ "cell_type": "code", "execution_count": null, "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.655622Z", + "iopub.status.idle": "2025-01-28T22:17:45.655847Z", + "shell.execute_reply": "2025-01-28T22:17:45.655756Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.655748Z" + } + }, "outputs": [], "source": [ "\n", @@ -1524,7 +2057,14 @@ "cell_type": "code", "execution_count": null, "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.656482Z", + "iopub.status.idle": "2025-01-28T22:17:45.656648Z", + "shell.execute_reply": "2025-01-28T22:17:45.656574Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.656566Z" + } + }, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_gaapOptimalFlux'][whbright],\n", @@ -1541,7 +2081,14 @@ "cell_type": "code", "execution_count": null, "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.status.busy": "2025-01-28T22:17:45.657434Z", + "iopub.status.idle": "2025-01-28T22:17:45.657607Z", + "shell.execute_reply": "2025-01-28T22:17:45.657534Z", + "shell.execute_reply.started": "2025-01-28T22:17:45.657528Z" + } + }, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", @@ -1614,7 +2161,7 @@ "ellipse parameters are probably from sdss shape: \n", "\n", "we think that xx yy and xy are related to kron and you can reconstruct the PA from that.\n", - "most moment measurements are on un-PSF-convolved (not corrected for PSF) \n", + "most moment measurements are on un-PSF-convolved (not corrected for PSF) ASK JIM ABOUT THIS they are doing a deep dive overhaul of the schema. if there are things that have fallen out of the schema tell him\n", "\n", "cmodel and alos cmodel_free (which have separate free params per band) without _free has fixed to some detection or ref band (and there's a separate column for that called ref)\n", "\n", @@ -1646,7 +2193,14 @@ "pick a typical SFG and a typical elliptical and show the different apertures and compare the flux measurements then this would be useful\n", "\n", "sci-unit: \n", - "https://rubinobs.atlassian.net/browse/LVV-508\n" + "https://rubinobs.atlassian.net/browse/LVV-508\n", + "\n", + "Notes from Jim Bosch presentations on galaxy photometry:\n", + "CModel: fit an exp profile, fit a de vaucouleurs profile, fit a linear combo of both while holding ellipse params fixed. This is basically what SDSS did and it doesn't do well with LSST data with one difference: LSST version approximates profiles as sums of gaussians (Hogg & Lang 2012) and PSFs as sums of shapelets for speed. This has worked well and whatever we do with galaxy photometry will include this.\n", + "\n", + "However they think CMOdel is a placeholder for something else. It worked well for SDSS but never had good performance with HSC.\n", + "\n", + "Dan developed multiprofit which we think we will use: not as fast but is better and can run on multiple bands.\n" ] } ], From 9170888d02c3a1312bf86ed25d3d768cafbd2ab5 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 29 Jan 2025 20:03:14 +0000 Subject: [PATCH 52/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 30 +++++++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 7417d74..caf0260 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -2195,12 +2195,36 @@ "sci-unit: \n", "https://rubinobs.atlassian.net/browse/LVV-508\n", "\n", - "Notes from Jim Bosch presentations on galaxy photometry:\n", + "Notes from Jim Bosch presentations on galaxy photometry (4 years ago):\n", "CModel: fit an exp profile, fit a de vaucouleurs profile, fit a linear combo of both while holding ellipse params fixed. This is basically what SDSS did and it doesn't do well with LSST data with one difference: LSST version approximates profiles as sums of gaussians (Hogg & Lang 2012) and PSFs as sums of shapelets for speed. This has worked well and whatever we do with galaxy photometry will include this.\n", "\n", - "However they think CMOdel is a placeholder for something else. It worked well for SDSS but never had good performance with HSC.\n", + "However they think CMOdel is a placeholder for something else. It worked well for SDSS but never had good performance with HSC. Bad with background estimation and deblending.\n", "\n", - "Dan developed multiprofit which we think we will use: not as fast but is better and can run on multiple bands.\n" + "Dan developed multiprofit which we think we will use: not as fast but is better and can run on multiple bands.\n", + "\n", + "To do: simutlaneously constrain structural params using all the bands.\n", + "\n", + "Model photometry is the ones that provide total fluxes.\n", + "\n", + "See Konrad's talk for GAaP?\n", + "\n", + "Scarlet provides total fluxes (robust? not sure; also not sure its in the catalog)\n", + "\n", + "other codes for photometry include ngmix (bd = bulge disk; a constrained bulge disk model with a fixed size-ration between bulge and disk; used in real models like HSC with some success. Aaron?\n", + "\n", + "Hopefully there will be multiple different measurements by the time we get to DR1\n", + "\n", + "Robust total fluxes look bad. Hard to know what parts of hte pipeline to blame.\n", + "\n", + "Robust consistent colors: we dont' have the right metrics for this yet\n", + "\n", + "Dan's talk:\n", + "\n", + "cModel is not so good for galaxies. (fine for stars)\n", + "\n", + "2 things improve colors: going from single band to multi-band with cmodel. also moving to cmodel to a sersic model improves the colors (only for multi-band fits; not the single band fits, these are always bad).\n", + "\n", + "ngmix has same performance as cmodel\n" ] } ], From 3f39dc2e797b5c8b495e4acf1dc19e0a81ff41a1 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 31 Jan 2025 16:46:41 +0000 Subject: [PATCH 53/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 385 +++++++++++++++++--------------- 1 file changed, 201 insertions(+), 184 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index caf0260..ea7e77f 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -24,11 +24,11 @@ "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:35.849959Z", - "iopub.status.busy": "2025-01-28T22:17:35.849795Z", - "iopub.status.idle": "2025-01-28T22:17:35.852384Z", - "shell.execute_reply": "2025-01-28T22:17:35.851898Z", - "shell.execute_reply.started": "2025-01-28T22:17:35.849945Z" + "iopub.execute_input": "2025-01-29T20:11:59.330712Z", + "iopub.status.busy": "2025-01-29T20:11:59.330563Z", + "iopub.status.idle": "2025-01-29T20:11:59.333342Z", + "shell.execute_reply": "2025-01-29T20:11:59.332833Z", + "shell.execute_reply.started": "2025-01-29T20:11:59.330697Z" } }, "outputs": [], @@ -248,11 +248,11 @@ "id": "2dbc75bd-a802-4576-8628-4e0088942303", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:35.853122Z", - "iopub.status.busy": "2025-01-28T22:17:35.852963Z", - "iopub.status.idle": "2025-01-28T22:17:41.219083Z", - "shell.execute_reply": "2025-01-28T22:17:41.218391Z", - "shell.execute_reply.started": "2025-01-28T22:17:35.853108Z" + "iopub.execute_input": "2025-01-29T20:11:59.334006Z", + "iopub.status.busy": "2025-01-29T20:11:59.333870Z", + "iopub.status.idle": "2025-01-29T20:12:04.284729Z", + "shell.execute_reply": "2025-01-29T20:12:04.283934Z", + "shell.execute_reply.started": "2025-01-29T20:11:59.333992Z" } }, "outputs": [], @@ -328,11 +328,11 @@ "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:41.220255Z", - "iopub.status.busy": "2025-01-28T22:17:41.219641Z", - "iopub.status.idle": "2025-01-28T22:17:41.247902Z", - "shell.execute_reply": "2025-01-28T22:17:41.247239Z", - "shell.execute_reply.started": "2025-01-28T22:17:41.220234Z" + "iopub.execute_input": "2025-01-29T20:12:04.286087Z", + "iopub.status.busy": "2025-01-29T20:12:04.285424Z", + "iopub.status.idle": "2025-01-29T20:12:04.312470Z", + "shell.execute_reply": "2025-01-29T20:12:04.311774Z", + "shell.execute_reply.started": "2025-01-29T20:12:04.286065Z" } }, "outputs": [], @@ -374,11 +374,11 @@ "id": "2f19f3b6-7357-4848-a2b4-5597aa8c8e15", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:41.249111Z", - "iopub.status.busy": "2025-01-28T22:17:41.248900Z", - "iopub.status.idle": "2025-01-28T22:17:41.252550Z", - "shell.execute_reply": "2025-01-28T22:17:41.252001Z", - "shell.execute_reply.started": "2025-01-28T22:17:41.249094Z" + "iopub.execute_input": "2025-01-29T20:12:04.313368Z", + "iopub.status.busy": "2025-01-29T20:12:04.313172Z", + "iopub.status.idle": "2025-01-29T20:12:04.317178Z", + "shell.execute_reply": "2025-01-29T20:12:04.316520Z", + "shell.execute_reply.started": "2025-01-29T20:12:04.313351Z" } }, "outputs": [], @@ -409,11 +409,11 @@ "id": "da81a645-947e-4ca2-82f7-905de4ef79da", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:41.253284Z", - "iopub.status.busy": "2025-01-28T22:17:41.253121Z", - "iopub.status.idle": "2025-01-28T22:17:41.268724Z", - "shell.execute_reply": "2025-01-28T22:17:41.268013Z", - "shell.execute_reply.started": "2025-01-28T22:17:41.253269Z" + "iopub.execute_input": "2025-01-29T20:12:04.318122Z", + "iopub.status.busy": "2025-01-29T20:12:04.317927Z", + "iopub.status.idle": "2025-01-29T20:12:04.334529Z", + "shell.execute_reply": "2025-01-29T20:12:04.333850Z", + "shell.execute_reply.started": "2025-01-29T20:12:04.318107Z" } }, "outputs": [], @@ -533,11 +533,11 @@ "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:41.269489Z", - "iopub.status.busy": "2025-01-28T22:17:41.269297Z", - "iopub.status.idle": "2025-01-28T22:17:41.321845Z", - "shell.execute_reply": "2025-01-28T22:17:41.321293Z", - "shell.execute_reply.started": "2025-01-28T22:17:41.269450Z" + "iopub.execute_input": "2025-01-29T20:12:04.335711Z", + "iopub.status.busy": "2025-01-29T20:12:04.335309Z", + "iopub.status.idle": "2025-01-29T20:12:04.385081Z", + "shell.execute_reply": "2025-01-29T20:12:04.384500Z", + "shell.execute_reply.started": "2025-01-29T20:12:04.335694Z" } }, "outputs": [], @@ -561,11 +561,11 @@ "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:41.322632Z", - "iopub.status.busy": "2025-01-28T22:17:41.322436Z", - "iopub.status.idle": "2025-01-28T22:17:41.504399Z", - "shell.execute_reply": "2025-01-28T22:17:41.503783Z", - "shell.execute_reply.started": "2025-01-28T22:17:41.322617Z" + "iopub.execute_input": "2025-01-29T20:12:04.385901Z", + "iopub.status.busy": "2025-01-29T20:12:04.385732Z", + "iopub.status.idle": "2025-01-29T20:12:04.509168Z", + "shell.execute_reply": "2025-01-29T20:12:04.508583Z", + "shell.execute_reply.started": "2025-01-29T20:12:04.385886Z" } }, "outputs": [], @@ -583,11 +583,11 @@ "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:41.505261Z", - "iopub.status.busy": "2025-01-28T22:17:41.505073Z", - "iopub.status.idle": "2025-01-28T22:17:41.520628Z", - "shell.execute_reply": "2025-01-28T22:17:41.520084Z", - "shell.execute_reply.started": "2025-01-28T22:17:41.505245Z" + "iopub.execute_input": "2025-01-29T20:12:04.509973Z", + "iopub.status.busy": "2025-01-29T20:12:04.509809Z", + "iopub.status.idle": "2025-01-29T20:12:04.524905Z", + "shell.execute_reply": "2025-01-29T20:12:04.524247Z", + "shell.execute_reply.started": "2025-01-29T20:12:04.509957Z" } }, "outputs": [ @@ -706,11 +706,11 @@ "id": "0d82dd79-a4d7-4428-a77c-1ed2bb717486", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:41.521399Z", - "iopub.status.busy": "2025-01-28T22:17:41.521220Z", - "iopub.status.idle": "2025-01-28T22:17:41.536124Z", - "shell.execute_reply": "2025-01-28T22:17:41.535516Z", - "shell.execute_reply.started": "2025-01-28T22:17:41.521384Z" + "iopub.execute_input": "2025-01-29T20:12:04.525686Z", + "iopub.status.busy": "2025-01-29T20:12:04.525525Z", + "iopub.status.idle": "2025-01-29T20:12:04.534053Z", + "shell.execute_reply": "2025-01-29T20:12:04.533497Z", + "shell.execute_reply.started": "2025-01-29T20:12:04.525671Z" } }, "outputs": [], @@ -728,11 +728,11 @@ "id": "e75ee4db-e4b9-4ff2-ba07-1f7f34a8d44b", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:41.536966Z", - "iopub.status.busy": "2025-01-28T22:17:41.536793Z", - "iopub.status.idle": "2025-01-28T22:17:44.722686Z", - "shell.execute_reply": "2025-01-28T22:17:44.722079Z", - "shell.execute_reply.started": "2025-01-28T22:17:41.536952Z" + "iopub.execute_input": "2025-01-29T20:12:04.535013Z", + "iopub.status.busy": "2025-01-29T20:12:04.534845Z", + "iopub.status.idle": "2025-01-29T20:12:11.738935Z", + "shell.execute_reply": "2025-01-29T20:12:11.738290Z", + "shell.execute_reply.started": "2025-01-29T20:12:04.534997Z" } }, "outputs": [ @@ -765,11 +765,11 @@ "id": "02ea5eb7-bac9-4c9f-90e4-626a69340b41", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:44.723465Z", - "iopub.status.busy": "2025-01-28T22:17:44.723289Z", - "iopub.status.idle": "2025-01-28T22:17:45.194527Z", - "shell.execute_reply": "2025-01-28T22:17:45.193957Z", - "shell.execute_reply.started": "2025-01-28T22:17:44.723436Z" + "iopub.execute_input": "2025-01-29T20:12:11.739899Z", + "iopub.status.busy": "2025-01-29T20:12:11.739730Z", + "iopub.status.idle": "2025-01-29T20:12:12.186605Z", + "shell.execute_reply": "2025-01-29T20:12:12.186192Z", + "shell.execute_reply.started": "2025-01-29T20:12:11.739884Z" } }, "outputs": [ @@ -784,7 +784,7 @@ "data": { "text/html": [ "<div><i>Table length=13699</i>\n", - "<table id=\"table139486025584144\" class=\"table-striped table-bordered table-condensed\">\n", + "<table id=\"table137791546509840\" class=\"table-striped table-bordered table-condensed\">\n", "<thead><tr><th>coord_ra</th><th>coord_dec</th><th>detect_fromBlend</th><th>detect_isIsolated</th><th>i_blendedness_flag</th><th>i_blendedness</th><th>i_extendedness</th><th>i_kronFlux</th><th>i_kronFluxErr</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th><th>i_gaapOptimalFlux</th></tr></thead>\n", "<thead><tr><th>deg</th><th>deg</th><th></th><th></th><th></th><th></th><th></th><th>nJy</th><th>nJy</th><th></th><th></th><th>nJy</th><th>nJy</th></tr></thead>\n", "<thead><tr><th>float64</th><th>float64</th><th>bool</th><th>bool</th><th>bool</th><th>float64</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th><th>float64</th></tr></thead>\n", @@ -866,11 +866,11 @@ "id": "e8b4a64a-6565-4d7d-ae48-0a666c41101e", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:45.195220Z", - "iopub.status.busy": "2025-01-28T22:17:45.195060Z", - "iopub.status.idle": "2025-01-28T22:17:45.201446Z", - "shell.execute_reply": "2025-01-28T22:17:45.200876Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.195206Z" + "iopub.execute_input": "2025-01-29T20:12:12.187262Z", + "iopub.status.busy": "2025-01-29T20:12:12.187106Z", + "iopub.status.idle": "2025-01-29T20:12:12.193424Z", + "shell.execute_reply": "2025-01-29T20:12:12.192798Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.187248Z" } }, "outputs": [ @@ -878,7 +878,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_6782/4090871.py:3: RuntimeWarning: divide by zero encountered in log10\n", + "/tmp/ipykernel_9186/4090871.py:3: RuntimeWarning: divide by zero encountered in log10\n", " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n" ] } @@ -897,18 +897,18 @@ "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:45.202224Z", - "iopub.status.busy": "2025-01-28T22:17:45.202066Z", - "iopub.status.idle": "2025-01-28T22:17:45.507923Z", - "shell.execute_reply": "2025-01-28T22:17:45.507151Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.202209Z" + "iopub.execute_input": "2025-01-29T20:12:12.194097Z", + "iopub.status.busy": "2025-01-29T20:12:12.193962Z", + "iopub.status.idle": "2025-01-29T20:12:12.479242Z", + "shell.execute_reply": "2025-01-29T20:12:12.478818Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.194085Z" } }, "outputs": [ { "data": { "text/plain": [ - "<matplotlib.legend.Legend at 0x7edc9ee16650>" + "<matplotlib.legend.Legend at 0x7d5217dd6bd0>" ] }, "execution_count": 13, @@ -951,11 +951,11 @@ "id": "ca225554-ed54-4934-a656-89ac1cc9ad76", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:45.508910Z", - "iopub.status.busy": "2025-01-28T22:17:45.508699Z", - "iopub.status.idle": "2025-01-28T22:17:45.629636Z", - "shell.execute_reply": "2025-01-28T22:17:45.629014Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.508893Z" + "iopub.execute_input": "2025-01-29T20:12:12.479902Z", + "iopub.status.busy": "2025-01-29T20:12:12.479760Z", + "iopub.status.idle": "2025-01-29T20:12:12.588502Z", + "shell.execute_reply": "2025-01-29T20:12:12.588047Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.479889Z" } }, "outputs": [ @@ -998,11 +998,11 @@ "id": "432db690-be7e-43bf-a640-a80af727652b", "metadata": { "execution": { - "iopub.execute_input": "2025-01-28T22:17:45.630368Z", - "iopub.status.busy": "2025-01-28T22:17:45.630205Z", - "iopub.status.idle": "2025-01-28T22:17:45.637651Z", - "shell.execute_reply": "2025-01-28T22:17:45.635126Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.630354Z" + "iopub.execute_input": "2025-01-29T20:12:12.589156Z", + "iopub.status.busy": "2025-01-29T20:12:12.589004Z", + "iopub.status.idle": "2025-01-29T20:12:12.594128Z", + "shell.execute_reply": "2025-01-29T20:12:12.592661Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.589143Z" } }, "outputs": [ @@ -1056,10 +1056,10 @@ "id": "0d28a6ad-4436-410c-9b9d-e995140be304", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.638051Z", - "iopub.status.idle": "2025-01-28T22:17:45.638259Z", - "shell.execute_reply": "2025-01-28T22:17:45.638172Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.638162Z" + "iopub.status.busy": "2025-01-29T20:12:12.594517Z", + "iopub.status.idle": "2025-01-29T20:12:12.594698Z", + "shell.execute_reply": "2025-01-29T20:12:12.594615Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.594607Z" } }, "outputs": [], @@ -1080,10 +1080,10 @@ "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.638968Z", - "iopub.status.idle": "2025-01-28T22:17:45.639148Z", - "shell.execute_reply": "2025-01-28T22:17:45.639072Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.639065Z" + "iopub.status.busy": "2025-01-29T20:12:12.595216Z", + "iopub.status.idle": "2025-01-29T20:12:12.595425Z", + "shell.execute_reply": "2025-01-29T20:12:12.595350Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.595343Z" } }, "outputs": [], @@ -1108,10 +1108,10 @@ "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.639841Z", - "iopub.status.idle": "2025-01-28T22:17:45.640004Z", - "shell.execute_reply": "2025-01-28T22:17:45.639932Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.639924Z" + "iopub.status.busy": "2025-01-29T20:12:12.596176Z", + "iopub.status.idle": "2025-01-29T20:12:12.596340Z", + "shell.execute_reply": "2025-01-29T20:12:12.596270Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.596263Z" } }, "outputs": [], @@ -1140,10 +1140,10 @@ "id": "7a8000f6-a914-4073-8130-67d912f52b09", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.640475Z", - "iopub.status.idle": "2025-01-28T22:17:45.640706Z", - "shell.execute_reply": "2025-01-28T22:17:45.640628Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.640621Z" + "iopub.status.busy": "2025-01-29T20:12:12.596935Z", + "iopub.status.idle": "2025-01-29T20:12:12.597103Z", + "shell.execute_reply": "2025-01-29T20:12:12.597023Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.597016Z" } }, "outputs": [], @@ -1169,10 +1169,10 @@ "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.641381Z", - "iopub.status.idle": "2025-01-28T22:17:45.641548Z", - "shell.execute_reply": "2025-01-28T22:17:45.641474Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.641467Z" + "iopub.status.busy": "2025-01-29T20:12:12.597580Z", + "iopub.status.idle": "2025-01-29T20:12:12.597733Z", + "shell.execute_reply": "2025-01-29T20:12:12.597665Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.597658Z" } }, "outputs": [], @@ -1231,10 +1231,10 @@ "id": "8bbb1505-5e91-49d2-b94e-045ff9f482e2", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.641902Z", - "iopub.status.idle": "2025-01-28T22:17:45.642057Z", - "shell.execute_reply": "2025-01-28T22:17:45.641982Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.641975Z" + "iopub.status.busy": "2025-01-29T20:12:12.598542Z", + "iopub.status.idle": "2025-01-29T20:12:12.598690Z", + "shell.execute_reply": "2025-01-29T20:12:12.598624Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.598617Z" } }, "outputs": [], @@ -1308,10 +1308,10 @@ "id": "3f5073a8-7c3d-4361-92b7-e1fa05c5dcde", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.642739Z", - "iopub.status.idle": "2025-01-28T22:17:45.642927Z", - "shell.execute_reply": "2025-01-28T22:17:45.642843Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.642833Z" + "iopub.status.busy": "2025-01-29T20:12:12.599249Z", + "iopub.status.idle": "2025-01-29T20:12:12.599397Z", + "shell.execute_reply": "2025-01-29T20:12:12.599331Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.599325Z" } }, "outputs": [], @@ -1379,10 +1379,10 @@ "id": "6fdf7c38-0c80-4351-856d-8390d22ad375", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.643513Z", - "iopub.status.idle": "2025-01-28T22:17:45.643677Z", - "shell.execute_reply": "2025-01-28T22:17:45.643603Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.643596Z" + "iopub.status.busy": "2025-01-29T20:12:12.599983Z", + "iopub.status.idle": "2025-01-29T20:12:12.600134Z", + "shell.execute_reply": "2025-01-29T20:12:12.600067Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.600060Z" } }, "outputs": [], @@ -1442,10 +1442,10 @@ "id": "1e525f6f-5521-4a67-9abb-b96e4a198043", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.644144Z", - "iopub.status.idle": "2025-01-28T22:17:45.644292Z", - "shell.execute_reply": "2025-01-28T22:17:45.644224Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.644218Z" + "iopub.status.busy": "2025-01-29T20:12:12.600609Z", + "iopub.status.idle": "2025-01-29T20:12:12.600765Z", + "shell.execute_reply": "2025-01-29T20:12:12.600692Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.600685Z" } }, "outputs": [], @@ -1512,10 +1512,10 @@ "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.644842Z", - "iopub.status.idle": "2025-01-28T22:17:45.644994Z", - "shell.execute_reply": "2025-01-28T22:17:45.644924Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.644917Z" + "iopub.status.busy": "2025-01-29T20:12:12.601619Z", + "iopub.status.idle": "2025-01-29T20:12:12.601776Z", + "shell.execute_reply": "2025-01-29T20:12:12.601706Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.601699Z" } }, "outputs": [], @@ -1611,10 +1611,10 @@ "id": "fd7e6ebb-f348-4df9-9859-9d4febb51238", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.645403Z", - "iopub.status.idle": "2025-01-28T22:17:45.645576Z", - "shell.execute_reply": "2025-01-28T22:17:45.645502Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.645496Z" + "iopub.status.busy": "2025-01-29T20:12:12.602385Z", + "iopub.status.idle": "2025-01-29T20:12:12.602547Z", + "shell.execute_reply": "2025-01-29T20:12:12.602478Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.602471Z" } }, "outputs": [], @@ -1636,10 +1636,10 @@ "id": "baec0660-1125-43de-9f21-cc5ccef958f0", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.646125Z", - "iopub.status.idle": "2025-01-28T22:17:45.646276Z", - "shell.execute_reply": "2025-01-28T22:17:45.646210Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.646203Z" + "iopub.status.busy": "2025-01-29T20:12:12.602943Z", + "iopub.status.idle": "2025-01-29T20:12:12.603088Z", + "shell.execute_reply": "2025-01-29T20:12:12.603023Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.603016Z" } }, "outputs": [], @@ -1659,10 +1659,10 @@ "id": "8d97291d-2043-40a6-859c-db391565a9da", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.646746Z", - "iopub.status.idle": "2025-01-28T22:17:45.646901Z", - "shell.execute_reply": "2025-01-28T22:17:45.646830Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.646823Z" + "iopub.status.busy": "2025-01-29T20:12:12.603694Z", + "iopub.status.idle": "2025-01-29T20:12:12.603843Z", + "shell.execute_reply": "2025-01-29T20:12:12.603773Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.603767Z" } }, "outputs": [], @@ -1684,10 +1684,10 @@ "id": "59afd145-cc34-4671-82ac-616ba6f28882", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.647404Z", - "iopub.status.idle": "2025-01-28T22:17:45.647566Z", - "shell.execute_reply": "2025-01-28T22:17:45.647496Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.647490Z" + "iopub.status.busy": "2025-01-29T20:12:12.604256Z", + "iopub.status.idle": "2025-01-29T20:12:12.604395Z", + "shell.execute_reply": "2025-01-29T20:12:12.604332Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.604325Z" } }, "outputs": [], @@ -1743,10 +1743,10 @@ "id": "8575a64b-f166-453b-aebd-dd09d728a259", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.648116Z", - "iopub.status.idle": "2025-01-28T22:17:45.648268Z", - "shell.execute_reply": "2025-01-28T22:17:45.648197Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.648190Z" + "iopub.status.busy": "2025-01-29T20:12:12.604861Z", + "iopub.status.idle": "2025-01-29T20:12:12.605009Z", + "shell.execute_reply": "2025-01-29T20:12:12.604942Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.604936Z" } }, "outputs": [], @@ -1767,10 +1767,10 @@ "id": "24718446-033d-4b3d-b11f-a94c708c6d1e", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.648662Z", - "iopub.status.idle": "2025-01-28T22:17:45.648817Z", - "shell.execute_reply": "2025-01-28T22:17:45.648749Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.648742Z" + "iopub.status.busy": "2025-01-29T20:12:12.605554Z", + "iopub.status.idle": "2025-01-29T20:12:12.605702Z", + "shell.execute_reply": "2025-01-29T20:12:12.605635Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.605629Z" } }, "outputs": [], @@ -1787,10 +1787,10 @@ "id": "1ddc4e98-1151-4aba-806a-b9097d2edfd0", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.649491Z", - "iopub.status.idle": "2025-01-28T22:17:45.649652Z", - "shell.execute_reply": "2025-01-28T22:17:45.649582Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.649575Z" + "iopub.status.busy": "2025-01-29T20:12:12.606275Z", + "iopub.status.idle": "2025-01-29T20:12:12.606419Z", + "shell.execute_reply": "2025-01-29T20:12:12.606353Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.606346Z" } }, "outputs": [], @@ -1805,10 +1805,10 @@ "id": "0b26042c-c234-4885-819b-a05dfba2bc31", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.650468Z", - "iopub.status.idle": "2025-01-28T22:17:45.650625Z", - "shell.execute_reply": "2025-01-28T22:17:45.650554Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.650547Z" + "iopub.status.busy": "2025-01-29T20:12:12.606966Z", + "iopub.status.idle": "2025-01-29T20:12:12.607132Z", + "shell.execute_reply": "2025-01-29T20:12:12.607058Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.607052Z" } }, "outputs": [], @@ -1841,10 +1841,10 @@ "id": "12f5be0d-7816-4622-8523-aff5e6b9a028", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.650924Z", - "iopub.status.idle": "2025-01-28T22:17:45.651078Z", - "shell.execute_reply": "2025-01-28T22:17:45.651001Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.650995Z" + "iopub.status.busy": "2025-01-29T20:12:12.607678Z", + "iopub.status.idle": "2025-01-29T20:12:12.607820Z", + "shell.execute_reply": "2025-01-29T20:12:12.607756Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.607750Z" } }, "outputs": [], @@ -1858,10 +1858,10 @@ "id": "94c2ecc1-5760-4872-b01d-e6d48b145201", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.651554Z", - "iopub.status.idle": "2025-01-28T22:17:45.651709Z", - "shell.execute_reply": "2025-01-28T22:17:45.651642Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.651635Z" + "iopub.status.busy": "2025-01-29T20:12:12.608246Z", + "iopub.status.idle": "2025-01-29T20:12:12.608388Z", + "shell.execute_reply": "2025-01-29T20:12:12.608323Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.608316Z" } }, "outputs": [], @@ -1915,10 +1915,10 @@ "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.652405Z", - "iopub.status.idle": "2025-01-28T22:17:45.652570Z", - "shell.execute_reply": "2025-01-28T22:17:45.652501Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.652494Z" + "iopub.status.busy": "2025-01-29T20:12:12.608918Z", + "iopub.status.idle": "2025-01-29T20:12:12.609080Z", + "shell.execute_reply": "2025-01-29T20:12:12.609004Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.608997Z" } }, "outputs": [], @@ -1951,10 +1951,10 @@ "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.653104Z", - "iopub.status.idle": "2025-01-28T22:17:45.653253Z", - "shell.execute_reply": "2025-01-28T22:17:45.653183Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.653177Z" + "iopub.status.busy": "2025-01-29T20:12:12.609570Z", + "iopub.status.idle": "2025-01-29T20:12:12.609716Z", + "shell.execute_reply": "2025-01-29T20:12:12.609651Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.609645Z" } }, "outputs": [], @@ -1983,10 +1983,10 @@ "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.653643Z", - "iopub.status.idle": "2025-01-28T22:17:45.653794Z", - "shell.execute_reply": "2025-01-28T22:17:45.653727Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.653720Z" + "iopub.status.busy": "2025-01-29T20:12:12.610094Z", + "iopub.status.idle": "2025-01-29T20:12:12.610243Z", + "shell.execute_reply": "2025-01-29T20:12:12.610170Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.610164Z" } }, "outputs": [], @@ -2015,10 +2015,10 @@ "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.655622Z", - "iopub.status.idle": "2025-01-28T22:17:45.655847Z", - "shell.execute_reply": "2025-01-28T22:17:45.655756Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.655748Z" + "iopub.status.busy": "2025-01-29T20:12:12.610776Z", + "iopub.status.idle": "2025-01-29T20:12:12.610919Z", + "shell.execute_reply": "2025-01-29T20:12:12.610854Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.610848Z" } }, "outputs": [], @@ -2059,10 +2059,10 @@ "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.656482Z", - "iopub.status.idle": "2025-01-28T22:17:45.656648Z", - "shell.execute_reply": "2025-01-28T22:17:45.656574Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.656566Z" + "iopub.status.busy": "2025-01-29T20:12:12.611298Z", + "iopub.status.idle": "2025-01-29T20:12:12.612751Z", + "shell.execute_reply": "2025-01-29T20:12:12.611374Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.611368Z" } }, "outputs": [], @@ -2083,10 +2083,10 @@ "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", "metadata": { "execution": { - "iopub.status.busy": "2025-01-28T22:17:45.657434Z", - "iopub.status.idle": "2025-01-28T22:17:45.657607Z", - "shell.execute_reply": "2025-01-28T22:17:45.657534Z", - "shell.execute_reply.started": "2025-01-28T22:17:45.657528Z" + "iopub.status.busy": "2025-01-29T20:12:12.613302Z", + "iopub.status.idle": "2025-01-29T20:12:12.613488Z", + "shell.execute_reply": "2025-01-29T20:12:12.613396Z", + "shell.execute_reply.started": "2025-01-29T20:12:12.613389Z" } }, "outputs": [], @@ -2222,9 +2222,26 @@ "\n", "cModel is not so good for galaxies. (fine for stars)\n", "\n", - "2 things improve colors: going from single band to multi-band with cmodel. also moving to cmodel to a sersic model improves the colors (only for multi-band fits; not the single band fits, these are always bad).\n", + "2 things improve colors: going from single band to multi-band modeling with cmodel. also moving from cmodel to a sersic model improves the colors (only for multi-band fits; not the single band fits, these are always bad).\n", "\n", - "ngmix has same performance as cmodel\n" + "ngmix has same performance as cmodel\n", + "\n", + "multi-band fitting has significant improvements for colors but not fluxes.\n", + "\n", + "Konrad: total magnitudes are hard / impossible / ill-defined quantitiy\n", + "they are model dependent and observation dependent and so this is bad.\n", + "A thing you often think you want but you actually dont want. And, which you think you have measured but in fact you have not.\n", + "\n", + "Proxies:\n", + "petrosian\n", + "aperture + corrections\n", + "isophotial + extrapoation (segmentation maps, see Robotham+2018, better than sextractor)\n", + "sersic bulge + disk\n", + "all require taking PSF into account.\n", + "\n", + "What we actually want: colors. you can focus on the part of galaxy above the noise and avoid extrapolation errors\n", + "\n", + "GAaP useful for many-band surveys with a standardized PSF to a gaussian. use \n" ] } ], From ab3bebd9f43e93c479a17ee6de39c8aae412177e Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 31 Jan 2025 20:44:45 +0000 Subject: [PATCH 54/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 702 ++++---------------------------- 1 file changed, 78 insertions(+), 624 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index ea7e77f..dd81ab3 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -20,17 +20,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:11:59.330712Z", - "iopub.status.busy": "2025-01-29T20:11:59.330563Z", - "iopub.status.idle": "2025-01-29T20:11:59.333342Z", - "shell.execute_reply": "2025-01-29T20:11:59.332833Z", - "shell.execute_reply.started": "2025-01-29T20:11:59.330697Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "#%load_ext pycodestyle_magic\n", @@ -101,7 +93,7 @@ "source": [ "## 1. Introduction\n", "\n", - "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebook 12a/b about the PSF photometry (CHECK/LINK). \n" + "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a> about the PSF photometry. \n" ] }, { @@ -125,18 +117,6 @@ "\n", "### 1.1.1 Total fluxes\n", "\n", - "#### Kron fluxes\n", - "\n", - "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>.\n", - "\n", - "```\n", - "<f>_kronFlux : Flux from Kron Flux algorithm. Measured on <f> g-band.\n", - "<f>_kronFluxErr : Uncertainty of <f>_kronFlux.\n", - "<f>_kronFlux_flag : Failure flag for <f>_kronFlux.\n", - "```\n", - "\n", - "The Kron radius, `<f>_kronRad`, is also available.\n", - "\n", "\n", "#### Composite Model (CModel) fluxes\n", "\n", @@ -160,10 +140,23 @@ "<f>_bdFluxDErr : Uncertainty of <f>_bdFluxD\n", "```\n", "\n", - "The fit sizes are also available (half-light radii, ellipse axes).\n", + "The fit sizes are also available (half-light radii, ellipse axes) for both bulge (de Vaucouleurs) and disk (exponential) components.\n", "\n", "### 1.1.2 Regional fluxes\n", "\n", + "#### Kron fluxes\n", + "\n", + "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>. \n", + "\n", + "```\n", + "<f>_kronFlux : Flux from Kron Flux algorithm. Measured on <f> g-band.\n", + "<f>_kronFluxErr : Uncertainty of <f>_kronFlux.\n", + "<f>_kronFlux_flag : Failure flag for <f>_kronFlux.\n", + "```\n", + "\n", + "The Kron radius, `<f>_kronRad`, is also available. In this case of LSST pipeline output, the Kron flux is not corrected for light that is emitted outside of the Kron aperture. \n", + "\n", + "\n", "#### Aperture fluxes\n", "This contains the enclosed flux inside a given aperture (these are raw fluxes, meaning, they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture using the PSF). Fixed aperture diameter size in pixels.\n", "\n", @@ -244,17 +237,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "2dbc75bd-a802-4576-8628-4e0088942303", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:11:59.334006Z", - "iopub.status.busy": "2025-01-29T20:11:59.333870Z", - "iopub.status.idle": "2025-01-29T20:12:04.284729Z", - "shell.execute_reply": "2025-01-29T20:12:04.283934Z", - "shell.execute_reply.started": "2025-01-29T20:11:59.333992Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -324,17 +309,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:04.286087Z", - "iopub.status.busy": "2025-01-29T20:12:04.285424Z", - "iopub.status.idle": "2025-01-29T20:12:04.312470Z", - "shell.execute_reply": "2025-01-29T20:12:04.311774Z", - "shell.execute_reply.started": "2025-01-29T20:12:04.286065Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", @@ -370,17 +347,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "2f19f3b6-7357-4848-a2b4-5597aa8c8e15", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:04.313368Z", - "iopub.status.busy": "2025-01-29T20:12:04.313172Z", - "iopub.status.idle": "2025-01-29T20:12:04.317178Z", - "shell.execute_reply": "2025-01-29T20:12:04.316520Z", - "shell.execute_reply.started": "2025-01-29T20:12:04.313351Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "def plotImage(exposure: ExposureF):\n", @@ -405,17 +374,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "da81a645-947e-4ca2-82f7-905de4ef79da", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:04.318122Z", - "iopub.status.busy": "2025-01-29T20:12:04.317927Z", - "iopub.status.idle": "2025-01-29T20:12:04.334529Z", - "shell.execute_reply": "2025-01-29T20:12:04.333850Z", - "shell.execute_reply.started": "2025-01-29T20:12:04.318107Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -529,17 +490,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:04.335711Z", - "iopub.status.busy": "2025-01-29T20:12:04.335309Z", - "iopub.status.idle": "2025-01-29T20:12:04.385081Z", - "shell.execute_reply": "2025-01-29T20:12:04.384500Z", - "shell.execute_reply.started": "2025-01-29T20:12:04.335694Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "service = get_tap_service(\"tap\")" @@ -557,17 +510,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:04.385901Z", - "iopub.status.busy": "2025-01-29T20:12:04.385732Z", - "iopub.status.idle": "2025-01-29T20:12:04.509168Z", - "shell.execute_reply": "2025-01-29T20:12:04.508583Z", - "shell.execute_reply.started": "2025-01-29T20:12:04.385886Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT column_name, datatype, description, unit \" \\\n", @@ -579,119 +524,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:04.509973Z", - "iopub.status.busy": "2025-01-29T20:12:04.509809Z", - "iopub.status.idle": "2025-01-29T20:12:04.524905Z", - "shell.execute_reply": "2025-01-29T20:12:04.524247Z", - "shell.execute_reply.started": "2025-01-29T20:12:04.509957Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "i_ap03Flux\n", - "i_ap03Flux_flag\n", - "i_ap03FluxErr\n", - "i_ap06Flux\n", - "i_ap06Flux_flag\n", - "i_ap06FluxErr\n", - "i_ap09Flux\n", - "i_ap09Flux_flag\n", - "i_ap09FluxErr\n", - "i_ap12Flux\n", - "i_ap12Flux_flag\n", - "i_ap12FluxErr\n", - "i_ap17Flux\n", - "i_ap17Flux_flag\n", - "i_ap17FluxErr\n", - "i_ap25Flux\n", - "i_ap25Flux_flag\n", - "i_ap25FluxErr\n", - "i_ap35Flux\n", - "i_ap35Flux_flag\n", - "i_ap35FluxErr\n", - "i_ap50Flux\n", - "i_ap50Flux_flag\n", - "i_ap50FluxErr\n", - "i_ap70Flux\n", - "i_ap70Flux_flag\n", - "i_ap70FluxErr\n", - "i_apFlux_flag\n", - "i_apFlux_flag_apertureTruncated\n", - "i_apFlux_flag_sincCoeffsTruncated\n", - "i_bdFluxB\n", - "i_bdFluxBErr\n", - "i_bdFluxD\n", - "i_bdFluxDErr\n", - "i_calibFlux\n", - "i_calibFlux_flag\n", - "i_calibFlux_flag_apertureTruncated\n", - "i_calibFlux_flag_sincCoeffsTruncated\n", - "i_calibFluxErr\n", - "i_cModelFlux\n", - "i_cModelFlux_inner\n", - "i_cModelFluxErr\n", - "i_free_cModelFlux\n", - "i_free_cModelFlux_flag\n", - "i_free_cModelFlux_inner\n", - "i_free_cModelFluxErr\n", - "i_free_psfFlux\n", - "i_free_psfFlux_flag\n", - "i_free_psfFluxErr\n", - "i_gaap0p5Flux\n", - "i_gaap0p5Flux_flag_bigPsf\n", - "i_gaap0p5FluxErr\n", - "i_gaap0p7Flux\n", - "i_gaap0p7Flux_flag_bigPsf\n", - "i_gaap0p7FluxErr\n", - "i_gaap1p0Flux\n", - "i_gaap1p0Flux_flag_bigPsf\n", - "i_gaap1p0FluxErr\n", - "i_gaap1p5Flux\n", - "i_gaap1p5Flux_flag_bigPsf\n", - "i_gaap1p5FluxErr\n", - "i_gaap2p5Flux\n", - "i_gaap2p5Flux_flag_bigPsf\n", - "i_gaap2p5FluxErr\n", - "i_gaap3p0Flux\n", - "i_gaap3p0Flux_flag_bigPsf\n", - "i_gaap3p0FluxErr\n", - "i_gaapFlux_flag\n", - "i_gaapFlux_flag_edge\n", - "i_gaapFlux_flag_gaussianization\n", - "i_gaapOptimalFlux\n", - "i_gaapOptimalFlux_flag_bigPsf\n", - "i_gaapOptimalFluxErr\n", - "i_gaapPsfFlux\n", - "i_gaapPsfFluxErr\n", - "i_kronFlux\n", - "i_kronFlux_flag\n", - "i_kronFlux_flag_bad_radius\n", - "i_kronFlux_flag_bad_shape\n", - "i_kronFlux_flag_bad_shape_no_psf\n", - "i_kronFlux_flag_edge\n", - "i_kronFlux_flag_no_fallback_radius\n", - "i_kronFlux_flag_no_minimum_radius\n", - "i_kronFlux_flag_small_radius\n", - "i_kronFlux_flag_used_minimum_radius\n", - "i_kronFlux_flag_used_psf_radius\n", - "i_kronFluxErr\n", - "i_psfFlux\n", - "i_psfFlux_area\n", - "i_psfFlux_flag\n", - "i_psfFlux_flag_apCorr\n", - "i_psfFlux_flag_edge\n", - "i_psfFlux_flag_noGoodPixels\n", - "i_psfFluxErr\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "search_string = 'Flux'\n", "band = 'i_'\n", @@ -702,17 +538,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "0d82dd79-a4d7-4428-a77c-1ed2bb717486", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:04.525686Z", - "iopub.status.busy": "2025-01-29T20:12:04.525525Z", - "iopub.status.idle": "2025-01-29T20:12:04.534053Z", - "shell.execute_reply": "2025-01-29T20:12:04.533497Z", - "shell.execute_reply.started": "2025-01-29T20:12:04.525671Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", @@ -724,26 +552,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "e75ee4db-e4b9-4ff2-ba07-1f7f34a8d44b", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:04.535013Z", - "iopub.status.busy": "2025-01-29T20:12:04.534845Z", - "iopub.status.idle": "2025-01-29T20:12:11.738935Z", - "shell.execute_reply": "2025-01-29T20:12:11.738290Z", - "shell.execute_reply.started": "2025-01-29T20:12:04.534997Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job phase is COMPLETED\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "job = service.submit_job(query)\n", "job.run()\n", @@ -761,86 +573,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "02ea5eb7-bac9-4c9f-90e4-626a69340b41", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:11.739899Z", - "iopub.status.busy": "2025-01-29T20:12:11.739730Z", - "iopub.status.idle": "2025-01-29T20:12:12.186605Z", - "shell.execute_reply": "2025-01-29T20:12:12.186192Z", - "shell.execute_reply.started": "2025-01-29T20:12:11.739884Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "13699\n" - ] - }, - { - "data": { - "text/html": [ - "<div><i>Table length=13699</i>\n", - "<table id=\"table137791546509840\" class=\"table-striped table-bordered table-condensed\">\n", - "<thead><tr><th>coord_ra</th><th>coord_dec</th><th>detect_fromBlend</th><th>detect_isIsolated</th><th>i_blendedness_flag</th><th>i_blendedness</th><th>i_extendedness</th><th>i_kronFlux</th><th>i_kronFluxErr</th><th>i_kronRad</th><th>i_kronFlux_flag</th><th>i_cModelFlux</th><th>i_gaapOptimalFlux</th></tr></thead>\n", - "<thead><tr><th>deg</th><th>deg</th><th></th><th></th><th></th><th></th><th></th><th>nJy</th><th>nJy</th><th></th><th></th><th>nJy</th><th>nJy</th></tr></thead>\n", - "<thead><tr><th>float64</th><th>float64</th><th>bool</th><th>bool</th><th>bool</th><th>float64</th><th>float64</th><th>float64</th><th>float64</th><th>float32</th><th>bool</th><th>float64</th><th>float64</th></tr></thead>\n", - "<tr><td>62.0067968</td><td>-36.9020816</td><td>True</td><td>False</td><td>False</td><td>0.0049983</td><td>1.0</td><td>10922.7229643</td><td>85.9962967</td><td>5.04477</td><td>False</td><td>12304.6727035</td><td>6460.0525305</td></tr>\n", - "<tr><td>62.0037681</td><td>-36.9024377</td><td>True</td><td>False</td><td>False</td><td>-7e-06</td><td>1.0</td><td>1182.0265062</td><td>53.1780048</td><td>3.20611</td><td>False</td><td>1181.785426</td><td>910.9258521</td></tr>\n", - "<tr><td>62.0085719</td><td>-36.9024176</td><td>True</td><td>False</td><td>False</td><td>0.0726756</td><td>1.0</td><td>1266.9036015</td><td>82.3860448</td><td>4.84711</td><td>False</td><td>1372.3096197</td><td>756.726213</td></tr>\n", - "<tr><td>62.005342</td><td>-36.903529</td><td>True</td><td>False</td><td>False</td><td>0.0069281</td><td>1.0</td><td>909.234224</td><td>75.7142907</td><td>4.51312</td><td>False</td><td>886.0944003</td><td>607.4636703</td></tr>\n", - "<tr><td>62.0045637</td><td>-36.902735</td><td>True</td><td>False</td><td>False</td><td>-0.0154942</td><td>1.0</td><td>604.4002275</td><td>51.3669159</td><td>3.07866</td><td>False</td><td>616.7654328</td><td>507.5349915</td></tr>\n", - "<tr><td>62.0423854</td><td>-36.9036671</td><td>True</td><td>False</td><td>False</td><td>-0.0023311</td><td>1.0</td><td>13512.3935231</td><td>71.4485953</td><td>4.36286</td><td>False</td><td>13351.4881963</td><td>8748.3736732</td></tr>\n", - "<tr><td>62.1962173</td><td>-36.9037948</td><td>True</td><td>False</td><td>False</td><td>0.041724</td><td>1.0</td><td>661.3043447</td><td>53.564723</td><td>3.22397</td><td>False</td><td>656.9081063</td><td>539.9425927</td></tr>\n", - "<tr><td>62.1956541</td><td>-36.9046139</td><td>True</td><td>False</td><td>False</td><td>-0.0236929</td><td>1.0</td><td>802.0931369</td><td>67.3860517</td><td>4.07341</td><td>False</td><td>789.6351291</td><td>551.6344401</td></tr>\n", - "<tr><td>62.0184482</td><td>-36.9029098</td><td>True</td><td>False</td><td>False</td><td>-0.0024643</td><td>1.0</td><td>3610.8459627</td><td>60.6887248</td><td>3.67457</td><td>False</td><td>3703.5324696</td><td>2622.7699794</td></tr>\n", - "<tr><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n", - "<tr><td>62.2340701</td><td>-37.0589707</td><td>True</td><td>False</td><td>False</td><td>0.017393</td><td>1.0</td><td>5475.2581198</td><td>106.5125488</td><td>6.51392</td><td>False</td><td>7968.7930086</td><td>2812.270571</td></tr>\n", - "<tr><td>62.238679</td><td>-37.0598473</td><td>True</td><td>False</td><td>False</td><td>0.002246</td><td>1.0</td><td>656.6051349</td><td>53.4197209</td><td>3.30962</td><td>False</td><td>646.5235391</td><td>512.0469676</td></tr>\n", - "<tr><td>62.2379366</td><td>-37.0608993</td><td>True</td><td>False</td><td>False</td><td>0.0243649</td><td>1.0</td><td>3448.5360492</td><td>60.0880805</td><td>3.71268</td><td>False</td><td>3390.7405566</td><td>2514.2672709</td></tr>\n", - "<tr><td>62.2347859</td><td>-37.0630304</td><td>True</td><td>False</td><td>False</td><td>-0.0123865</td><td>1.0</td><td>2758.118914</td><td>43.642257</td><td>2.69446</td><td>False</td><td>2795.1106328</td><td>2595.641324</td></tr>\n", - "<tr><td>62.2320894</td><td>-37.0631907</td><td>True</td><td>False</td><td>False</td><td>-0.0024702</td><td>1.0</td><td>3348.8860869</td><td>74.5423706</td><td>4.53893</td><td>False</td><td>3404.9391468</td><td>2013.9016243</td></tr>\n", - "<tr><td>62.2374752</td><td>-37.063016</td><td>True</td><td>False</td><td>False</td><td>-0.0445366</td><td>1.0</td><td>1474.240171</td><td>42.3870591</td><td>2.62527</td><td>False</td><td>1484.0448861</td><td>1422.4822653</td></tr>\n", - "<tr><td>62.2346703</td><td>-37.0661891</td><td>True</td><td>False</td><td>False</td><td>0.061405</td><td>1.0</td><td>777.2332956</td><td>65.4523749</td><td>4.02862</td><td>False</td><td>777.261764</td><td>537.0907481</td></tr>\n", - "<tr><td>62.2339994</td><td>-37.0649774</td><td>True</td><td>False</td><td>False</td><td>-0.0043305</td><td>1.0</td><td>2170.4946541</td><td>47.0723022</td><td>2.8639</td><td>False</td><td>2130.9356269</td><td>1949.1903224</td></tr>\n", - "<tr><td>62.23306</td><td>-37.0618854</td><td>True</td><td>False</td><td>False</td><td>-0.003919</td><td>1.0</td><td>1128.0548814</td><td>71.7575598</td><td>4.39139</td><td>False</td><td>1162.450445</td><td>765.2318206</td></tr>\n", - "</table></div>" - ], - "text/plain": [ - "<Table length=13699>\n", - " coord_ra coord_dec detect_fromBlend ... i_cModelFlux i_gaapOptimalFlux\n", - " deg deg ... nJy nJy \n", - " float64 float64 bool ... float64 float64 \n", - "---------- ----------- ---------------- ... ------------- -----------------\n", - "62.0067968 -36.9020816 True ... 12304.6727035 6460.0525305\n", - "62.0037681 -36.9024377 True ... 1181.785426 910.9258521\n", - "62.0085719 -36.9024176 True ... 1372.3096197 756.726213\n", - " 62.005342 -36.903529 True ... 886.0944003 607.4636703\n", - "62.0045637 -36.902735 True ... 616.7654328 507.5349915\n", - "62.0423854 -36.9036671 True ... 13351.4881963 8748.3736732\n", - "62.1962173 -36.9037948 True ... 656.9081063 539.9425927\n", - "62.1956541 -36.9046139 True ... 789.6351291 551.6344401\n", - "62.0184482 -36.9029098 True ... 3703.5324696 2622.7699794\n", - " ... ... ... ... ... ...\n", - "62.2340701 -37.0589707 True ... 7968.7930086 2812.270571\n", - " 62.238679 -37.0598473 True ... 646.5235391 512.0469676\n", - "62.2379366 -37.0608993 True ... 3390.7405566 2514.2672709\n", - "62.2347859 -37.0630304 True ... 2795.1106328 2595.641324\n", - "62.2320894 -37.0631907 True ... 3404.9391468 2013.9016243\n", - "62.2374752 -37.063016 True ... 1484.0448861 1422.4822653\n", - "62.2346703 -37.0661891 True ... 777.261764 537.0907481\n", - "62.2339994 -37.0649774 True ... 2130.9356269 1949.1903224\n", - " 62.23306 -37.0618854 True ... 1162.450445 765.2318206" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, + "outputs": [], "source": [ "results = job.fetch_result()\n", "print(len(results))\n", @@ -862,27 +598,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "e8b4a64a-6565-4d7d-ae48-0a666c41101e", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:12.187262Z", - "iopub.status.busy": "2025-01-29T20:12:12.187106Z", - "iopub.status.idle": "2025-01-29T20:12:12.193424Z", - "shell.execute_reply": "2025-01-29T20:12:12.192798Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.187248Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_9186/4090871.py:3: RuntimeWarning: divide by zero encountered in log10\n", - " cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "#truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", "i_kronRad = tab['i_kronRad']\n", @@ -893,39 +612,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:12.194097Z", - "iopub.status.busy": "2025-01-29T20:12:12.193962Z", - "iopub.status.idle": "2025-01-29T20:12:12.479242Z", - "shell.execute_reply": "2025-01-29T20:12:12.478818Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.194085Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.legend.Legend at 0x7d5217dd6bd0>" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1000x600 with 2 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "metadata": {}, + "outputs": [], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-1.2,1.2]\n", @@ -947,38 +637,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "ca225554-ed54-4934-a656-89ac1cc9ad76", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:12.479902Z", - "iopub.status.busy": "2025-01-29T20:12:12.479760Z", - "iopub.status.idle": "2025-01-29T20:12:12.588502Z", - "shell.execute_reply": "2025-01-29T20:12:12.588047Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.479889Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "i_kronFlux\n", - "i_kronFlux_flag\n", - "i_kronFlux_flag_bad_radius\n", - "i_kronFlux_flag_bad_shape\n", - "i_kronFlux_flag_bad_shape_no_psf\n", - "i_kronFlux_flag_edge\n", - "i_kronFlux_flag_no_fallback_radius\n", - "i_kronFlux_flag_no_minimum_radius\n", - "i_kronFlux_flag_small_radius\n", - "i_kronFlux_flag_used_minimum_radius\n", - "i_kronFlux_flag_used_psf_radius\n", - "i_kronFluxErr\n", - "i_kronRad\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "query = \"SELECT column_name, datatype, description, unit \" \\\n", " \"FROM tap_schema.columns \" \\\n", @@ -994,36 +656,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "432db690-be7e-43bf-a640-a80af727652b", - "metadata": { - "execution": { - "iopub.execute_input": "2025-01-29T20:12:12.589156Z", - "iopub.status.busy": "2025-01-29T20:12:12.589004Z", - "iopub.status.idle": "2025-01-29T20:12:12.594128Z", - "shell.execute_reply": "2025-01-29T20:12:12.592661Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.589143Z" - } - }, - "outputs": [ - { - "ename": "SystemExit", - "evalue": "", - "output_type": "error", - "traceback": [ - "An exception has occurred, use %tb to see the full traceback.\n", - "\u001b[0;31mSystemExit\u001b[0m\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/lsst/software/stack/conda/envs/lsst-scipipe-9.0.0/lib/python3.11/site-packages/IPython/core/interactiveshell.py:3585: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n", - " warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "sys.exit()" ] @@ -1054,14 +690,7 @@ "cell_type": "code", "execution_count": null, "id": "0d28a6ad-4436-410c-9b9d-e995140be304", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.594517Z", - "iopub.status.idle": "2025-01-29T20:12:12.594698Z", - "shell.execute_reply": "2025-01-29T20:12:12.594615Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.594607Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", @@ -1078,14 +707,7 @@ "cell_type": "code", "execution_count": null, "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.595216Z", - "iopub.status.idle": "2025-01-29T20:12:12.595425Z", - "shell.execute_reply": "2025-01-29T20:12:12.595350Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.595343Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1106,14 +728,7 @@ "cell_type": "code", "execution_count": null, "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.596176Z", - "iopub.status.idle": "2025-01-29T20:12:12.596340Z", - "shell.execute_reply": "2025-01-29T20:12:12.596270Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.596263Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "results = job.fetch_result()\n", @@ -1138,14 +753,7 @@ "cell_type": "code", "execution_count": null, "id": "7a8000f6-a914-4073-8130-67d912f52b09", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.596935Z", - "iopub.status.idle": "2025-01-29T20:12:12.597103Z", - "shell.execute_reply": "2025-01-29T20:12:12.597023Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.597016Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", @@ -1167,14 +775,7 @@ "cell_type": "code", "execution_count": null, "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.597580Z", - "iopub.status.idle": "2025-01-29T20:12:12.597733Z", - "shell.execute_reply": "2025-01-29T20:12:12.597665Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.597658Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "fig, ax = plt.subplots()\n", @@ -1229,14 +830,7 @@ "cell_type": "code", "execution_count": null, "id": "8bbb1505-5e91-49d2-b94e-045ff9f482e2", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.598542Z", - "iopub.status.idle": "2025-01-29T20:12:12.598690Z", - "shell.execute_reply": "2025-01-29T20:12:12.598624Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.598617Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", @@ -1306,14 +900,7 @@ "cell_type": "code", "execution_count": null, "id": "3f5073a8-7c3d-4361-92b7-e1fa05c5dcde", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.599249Z", - "iopub.status.idle": "2025-01-29T20:12:12.599397Z", - "shell.execute_reply": "2025-01-29T20:12:12.599331Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.599325Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# here add a second set of panels to try to understand the small bias at bright end of kron (is it kron radius-dependent? since its not deblending dependent?\n", @@ -1377,14 +964,7 @@ "cell_type": "code", "execution_count": null, "id": "6fdf7c38-0c80-4351-856d-8390d22ad375", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.599983Z", - "iopub.status.idle": "2025-01-29T20:12:12.600134Z", - "shell.execute_reply": "2025-01-29T20:12:12.600067Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.600060Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", @@ -1440,14 +1020,7 @@ "cell_type": "code", "execution_count": null, "id": "1e525f6f-5521-4a67-9abb-b96e4a198043", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.600609Z", - "iopub.status.idle": "2025-01-29T20:12:12.600765Z", - "shell.execute_reply": "2025-01-29T20:12:12.600692Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.600685Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# the following plots are identical, consider a different comparison that is informative\n", @@ -1510,14 +1083,7 @@ "cell_type": "code", "execution_count": null, "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.601619Z", - "iopub.status.idle": "2025-01-29T20:12:12.601776Z", - "shell.execute_reply": "2025-01-29T20:12:12.601706Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.601699Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -1609,14 +1175,7 @@ "cell_type": "code", "execution_count": null, "id": "fd7e6ebb-f348-4df9-9859-9d4febb51238", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.602385Z", - "iopub.status.idle": "2025-01-29T20:12:12.602547Z", - "shell.execute_reply": "2025-01-29T20:12:12.602478Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.602471Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_g, ts.flux_z, ts.redshift, \"\\\n", @@ -1634,14 +1193,7 @@ "cell_type": "code", "execution_count": null, "id": "baec0660-1125-43de-9f21-cc5ccef958f0", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.602943Z", - "iopub.status.idle": "2025-01-29T20:12:12.603088Z", - "shell.execute_reply": "2025-01-29T20:12:12.603023Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.603016Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1657,14 +1209,7 @@ "cell_type": "code", "execution_count": null, "id": "8d97291d-2043-40a6-859c-db391565a9da", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.603694Z", - "iopub.status.idle": "2025-01-29T20:12:12.603843Z", - "shell.execute_reply": "2025-01-29T20:12:12.603773Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.603767Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4\n", @@ -1682,14 +1227,7 @@ "cell_type": "code", "execution_count": null, "id": "59afd145-cc34-4671-82ac-616ba6f28882", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.604256Z", - "iopub.status.idle": "2025-01-29T20:12:12.604395Z", - "shell.execute_reply": "2025-01-29T20:12:12.604332Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.604325Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# very confused about why these colors line up so perfectly when the mags do not...\n", @@ -1741,14 +1279,7 @@ "cell_type": "code", "execution_count": null, "id": "8575a64b-f166-453b-aebd-dd09d728a259", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.604861Z", - "iopub.status.idle": "2025-01-29T20:12:12.605009Z", - "shell.execute_reply": "2025-01-29T20:12:12.604942Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.604936Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", @@ -1765,14 +1296,7 @@ "cell_type": "code", "execution_count": null, "id": "24718446-033d-4b3d-b11f-a94c708c6d1e", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.605554Z", - "iopub.status.idle": "2025-01-29T20:12:12.605702Z", - "shell.execute_reply": "2025-01-29T20:12:12.605635Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.605629Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "job = service.submit_job(query)\n", @@ -1785,14 +1309,7 @@ "cell_type": "code", "execution_count": null, "id": "1ddc4e98-1151-4aba-806a-b9097d2edfd0", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.606275Z", - "iopub.status.idle": "2025-01-29T20:12:12.606419Z", - "shell.execute_reply": "2025-01-29T20:12:12.606353Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.606346Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "results = job.fetch_result()\n", @@ -1803,14 +1320,7 @@ "cell_type": "code", "execution_count": null, "id": "0b26042c-c234-4885-819b-a05dfba2bc31", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.606966Z", - "iopub.status.idle": "2025-01-29T20:12:12.607132Z", - "shell.execute_reply": "2025-01-29T20:12:12.607058Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.607052Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# pick an object that has large size\n", @@ -1839,14 +1349,7 @@ "cell_type": "code", "execution_count": null, "id": "12f5be0d-7816-4622-8523-aff5e6b9a028", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.607678Z", - "iopub.status.idle": "2025-01-29T20:12:12.607820Z", - "shell.execute_reply": "2025-01-29T20:12:12.607756Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.607750Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "sys.exit()" @@ -1856,14 +1359,7 @@ "cell_type": "code", "execution_count": null, "id": "94c2ecc1-5760-4872-b01d-e6d48b145201", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.608246Z", - "iopub.status.idle": "2025-01-29T20:12:12.608388Z", - "shell.execute_reply": "2025-01-29T20:12:12.608323Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.608316Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "#junk that doens't work yet:\n", @@ -1913,14 +1409,7 @@ "cell_type": "code", "execution_count": null, "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.608918Z", - "iopub.status.idle": "2025-01-29T20:12:12.609080Z", - "shell.execute_reply": "2025-01-29T20:12:12.609004Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.608997Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# compare kron mag to cmodel mag\n", @@ -1949,14 +1438,7 @@ "cell_type": "code", "execution_count": null, "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.609570Z", - "iopub.status.idle": "2025-01-29T20:12:12.609716Z", - "shell.execute_reply": "2025-01-29T20:12:12.609651Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.609645Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -1981,14 +1463,7 @@ "cell_type": "code", "execution_count": null, "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.610094Z", - "iopub.status.idle": "2025-01-29T20:12:12.610243Z", - "shell.execute_reply": "2025-01-29T20:12:12.610170Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.610164Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -2013,14 +1488,7 @@ "cell_type": "code", "execution_count": null, "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.610776Z", - "iopub.status.idle": "2025-01-29T20:12:12.610919Z", - "shell.execute_reply": "2025-01-29T20:12:12.610854Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.610848Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -2057,14 +1525,7 @@ "cell_type": "code", "execution_count": null, "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.611298Z", - "iopub.status.idle": "2025-01-29T20:12:12.612751Z", - "shell.execute_reply": "2025-01-29T20:12:12.611374Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.611368Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_gaapOptimalFlux'][whbright],\n", @@ -2081,14 +1542,7 @@ "cell_type": "code", "execution_count": null, "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", - "metadata": { - "execution": { - "iopub.status.busy": "2025-01-29T20:12:12.613302Z", - "iopub.status.idle": "2025-01-29T20:12:12.613488Z", - "shell.execute_reply": "2025-01-29T20:12:12.613396Z", - "shell.execute_reply.started": "2025-01-29T20:12:12.613389Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", From 51dadca665acc2f73a098220213298082854c607 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 31 Jan 2025 22:31:29 +0000 Subject: [PATCH 55/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index dd81ab3..eebb19b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -123,7 +123,7 @@ "Similar in nature to those measured for SDSS: \n", "https://www.sdss3.org/dr8/algorithms/magnitudes.php#cmodel\n", "\n", - "In short, it is the linear combination of the best fit exponential and de Vaucouleurs profiles.\n", + "In short, it is the linear combination of the best fit exponential (disk or D) and de Vaucouleurs (bulge or B) profiles.\n", "\n", "```\n", "<f>_cModelFlux :\tFlux from the final cmodel fit. Forced on <f>-band.\n", @@ -142,8 +142,8 @@ "\n", "The fit sizes are also available (half-light radii, ellipse axes) for both bulge (de Vaucouleurs) and disk (exponential) components.\n", "\n", - "### 1.1.2 Regional fluxes\n", - "\n", + "### 1.1.2 Apparent fluxes (i.e. those not corrected to the total flux)\n", + " \n", "#### Kron fluxes\n", "\n", "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>. \n", @@ -158,7 +158,7 @@ "\n", "\n", "#### Aperture fluxes\n", - "This contains the enclosed flux inside a given aperture (these are raw fluxes, meaning, they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture using the PSF). Fixed aperture diameter size in pixels.\n", + "This contains the enclosed flux inside a given aperture (they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture). Fixed aperture diameter size in pixels.\n", "\n", "```\n", "<f>_ap<pix>Flux : Flux within <pix>-pixel aperture. Forced on <f>-band.\n", @@ -544,7 +544,8 @@ "outputs": [], "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", - " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", + " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.i_bdFluxD, obj.i_bdFluxB, obj.i_bdE1, obj.i_bdE2 \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"\n" @@ -635,6 +636,21 @@ "ax.legend()\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f1b0710-fb8b-4e60-90f8-8b4ef87283ce", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdFluxD']),'.')\n", + "plt.show()\n", + "\n", + "# Why isnt' flux from bulge + flux from disk = flux from cmodel? Should there be a FracDev value that #\n", + "# scales the relative contribution of bulge and disk?\n", + "# cmodel flux is Fcomposite = fracDeV FdeV + (1 - fracDeV) Fexp where Fexp is FluxD and FdeV is FluxB" + ] + }, { "cell_type": "code", "execution_count": null, From 87622952434d8715a215030da95c81e789be9eb2 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 31 Jan 2025 22:52:09 +0000 Subject: [PATCH 56/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 36 +++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 15 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index eebb19b..a7efa90 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -636,21 +636,6 @@ "ax.legend()\n" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "3f1b0710-fb8b-4e60-90f8-8b4ef87283ce", - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdFluxD']),'.')\n", - "plt.show()\n", - "\n", - "# Why isnt' flux from bulge + flux from disk = flux from cmodel? Should there be a FracDev value that #\n", - "# scales the relative contribution of bulge and disk?\n", - "# cmodel flux is Fcomposite = fracDeV FdeV + (1 - fracDeV) Fexp where Fexp is FluxD and FdeV is FluxB" - ] - }, { "cell_type": "code", "execution_count": null, @@ -680,6 +665,27 @@ "sys.exit()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f1b0710-fb8b-4e60-90f8-8b4ef87283ce", + "metadata": {}, + "outputs": [], + "source": [ + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "ylims=[-.0001*1e8,.0001*1e8]\n", + "ax.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdE2']*tab['i_bdFluxD']),'.')\n", + "ax.set_ylim(ylims)\n", + "#ax.set_xlim([0,15])\n", + "ax2.hist(tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdE2']*tab['i_bdFluxD']),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 400),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "\n", + "plt.show()\n", + "\n", + "# Why isnt' flux from bulge + flux from disk = flux from cmodel? Should there be a FracDev value that #\n", + "# scales the relative contribution of bulge and disk?\n", + "# cmodel flux is Fcomposite = fracDeV FdeV + (1 - fracDeV) Fexp where Fexp is FluxD and FdeV is FluxB" + ] + }, { "cell_type": "markdown", "id": "52267cd8-1041-4e09-bda1-248468b21971", From ee53fa142e1a616ec8270441eabad7294216032e Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 3 Feb 2025 21:50:25 +0000 Subject: [PATCH 57/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 38 ++++++++++++--------------------- 1 file changed, 14 insertions(+), 24 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index a7efa90..3ae63f4 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -142,7 +142,7 @@ "\n", "The fit sizes are also available (half-light radii, ellipse axes) for both bulge (de Vaucouleurs) and disk (exponential) components.\n", "\n", - "### 1.1.2 Apparent fluxes (i.e. those not corrected to the total flux)\n", + "### 1.1.2 Apparent fluxes (i.e. not corrected to the total flux)\n", " \n", "#### Kron fluxes\n", "\n", @@ -191,11 +191,11 @@ "**Aperture**\n", "\n", "```\n", - "<f>_gaap<ap>Flux : GaaP flux with <ap> aperture after multiplying the seeing by 1.15. Forced on <f>-band.\n", + "<f>_gaap<ap>Flux : GaaP flux with <ap> aperture after multiplying the seeing aperture. Forced on <f>-band.\n", "<f>_gaap<ap>FluxErr : Uncertainty of <f>_gaap<ap>Flux.\n", "```\n", "\n", - "Where the apertures are 0.5, 0.7, 1.0, 1.5, 2.5, and 3.0.\n", + "Where the seeing apertures are 0.5, 0.7, 1.0, 1.5, 2.5, and 3.0 arcseconds.\n", "In the column name `<ap>` appears as `0p5`, `0p7`, etc.\n", "\n", "\n", @@ -636,25 +636,6 @@ "ax.legend()\n" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "ca225554-ed54-4934-a656-89ac1cc9ad76", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT column_name, datatype, description, unit \" \\\n", - " \"FROM tap_schema.columns \" \\\n", - " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", - "\n", - "schema_results = service.search(query).to_table()\n", - "search_string = 'kron'\n", - "band = 'i_'\n", - "for cname in schema_results['column_name']:\n", - " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", - " print(cname)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -674,13 +655,22 @@ "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims=[-.0001*1e8,.0001*1e8]\n", - "ax.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdE2']*tab['i_bdFluxD']),'.')\n", + "#ax.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdE2']*tab['i_bdFluxD']),'.')\n", + "ax.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdFluxD']),'r.', alpha=.1)\n", + "ax.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdFluxB']),'b.', alpha=.1)\n", + "\n", "ax.set_ylim(ylims)\n", "#ax.set_xlim([0,15])\n", - "ax2.hist(tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdE2']*tab['i_bdFluxD']),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 400),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "#ax2.hist(tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdE2']*tab['i_bdFluxD']),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 400),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist(tab['i_cModelFlux']-(tab['i_bdFluxB']),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 400),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist(tab['i_cModelFlux']-(tab['i_bdFluxD']),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 400),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "\n", "plt.show()\n", "\n", + "x = np.arange(0,1e6,1)\n", + "plt.plot(x,x)\n", + "plt.plot(tab['i_cModelFlux'], (tab['i_bdFluxD']),'.',alpha=.1,zorder=10)\n", + "plt.show()\n", "# Why isnt' flux from bulge + flux from disk = flux from cmodel? Should there be a FracDev value that #\n", "# scales the relative contribution of bulge and disk?\n", "# cmodel flux is Fcomposite = fracDeV FdeV + (1 - fracDeV) Fexp where Fexp is FluxD and FdeV is FluxB" From 4f3db9f6455ef09acfee236db0241f4483d70523 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 4 Feb 2025 17:14:58 +0000 Subject: [PATCH 58/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 3ae63f4..0a2150e 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -636,6 +636,18 @@ "ax.legend()\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "49387e7a-9e0d-4e00-a2b9-8767ab667929", + "metadata": {}, + "outputs": [], + "source": [ + "# pick an object that has large size\n", + "wh = np.where(tab['i_kronRad'] > 10)[0]\n", + "\n" + ] + }, { "cell_type": "code", "execution_count": null, From 7bbf171c1316fe6b716051b55be5e03be6c56e80 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 4 Feb 2025 18:26:45 +0000 Subject: [PATCH 59/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 128 ++++++++++++++++++++++++++++++-- 1 file changed, 122 insertions(+), 6 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 0a2150e..d523cd0 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -146,7 +146,7 @@ " \n", "#### Kron fluxes\n", "\n", - "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>. \n", + "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>. The aperture used for the fluxes is 2.5 x R1 where R1 is the luminosity weighted radius (also called \"first moment\"; which extends to where the flux reaches 1% of the sky background; Kron et al. 1980).\n", "\n", "```\n", "<f>_kronFlux : Flux from Kron Flux algorithm. Measured on <f> g-band.\n", @@ -468,6 +468,90 @@ " return sodaCutout\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "07bba696-f49c-46e3-b867-61063195be99", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def make_image_cutout_new(tap_service, ra, dec, cutout_size=0.01,\n", + " filename=None):\n", + " \"\"\"Wrapper function to generate a cutout using the cutout tool\n", + "\n", + " Parameters\n", + " ----------\n", + " tap_service : an instance of the TAP service\n", + " ra, dec : 'float'\n", + " the ra and dec of the cutout center\n", + " dataId : 'dict'\n", + " the dataId of the image to make a cutout from. The format\n", + " must correspond to that provided for parameter 'imtype'\n", + " cutout_size : 'float', optional\n", + " edge length in degrees of the cutout\n", + " imtype : 'string', optional\n", + " string containing the type of LSST image to generate\n", + " a cutout of (e.g. deepCoadd, calexp). If imtype=None,\n", + " the function will assume a deepCoadd.\n", + " filename : 'string', optional\n", + " filename of the resulting cutout (which has fits format)\n", + "\n", + " Returns\n", + " -------\n", + " sodaCutout : 'string'\n", + " filename of the cutout in fits format (including\n", + " full directory path; for now by default it is saved\n", + " in /home/dp02_13a_temp/\n", + " \"\"\"\n", + "\n", + " spherePoint = geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", + " coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree, frame='icrs')\n", + "\n", + "\n", + "\n", + " # add optional default band if it is not contained in the dataId\n", + " band = 'i' #dataId[\"band\"]\n", + "\n", + " query = \"SELECT access_format, access_url, dataproduct_subtype, \" + \\\n", + " \"lsst_patch, lsst_tract, lsst_band, s_ra, s_dec \" + \\\n", + " \"FROM ivoa.ObsCore WHERE dataproduct_type = 'image' \" + \\\n", + " \"AND obs_collection = 'LSST.DP02' \" + \\\n", + " \"AND dataproduct_subtype = 'lsst.deepCoadd_calexp' \" + \\\n", + " \"AND lsst_band = \" + \"'\" + str(band) + \"' \" + \\\n", + " \"AND CONTAINS(POINT('ICRS', \" + str(coord.ra.value) + \\\n", + " \", \" + str(coord.dec.value) + \"), \" + \\\n", + " \"s_region) = 1\"\n", + "\n", + " results = tap_service.search(query)\n", + "\n", + " # Get datalink\n", + " dataLinkUrl = results[0].getdataurl()\n", + " auth_session = service._session\n", + " dl = DatalinkResults.from_result_url(dataLinkUrl,\n", + " session=auth_session)\n", + "\n", + " # from_resource: creates a instance from\n", + " # a number of records and a Datalink Resource.\n", + " sq = SodaQuery.from_resource(dl,\n", + " dl.get_adhocservice_by_id(\"cutout-sync\"),\n", + " session=auth_session)\n", + "\n", + " sq.circle = (spherePoint.getRa().asDegrees() * u.deg,\n", + " spherePoint.getDec().asDegrees() * u.deg,\n", + " cutout_size * u.deg)\n", + "\n", + " if filename:\n", + " sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/'+filename)\n", + " else:\n", + " sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/soda-cutout.fits')\n", + "\n", + " with open(sodaCutout, 'bw') as f:\n", + " f.write(sq.execute_stream().read())\n", + "\n", + " return sodaCutout\n" + ] + }, { "cell_type": "markdown", "id": "ec51ac0b", @@ -508,6 +592,17 @@ "First see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "14450d07-0c29-4342-91f2-72ccc4cecfb0", + "metadata": {}, + "outputs": [], + "source": [ + "cluster_RA = 55.7506834813934\n", + "cluster_dec = -32.28892993702273\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -545,10 +640,11 @@ "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.g_cModelFlux, obj.r_cModelFlux, \" + \\\n", " \"obj.i_bdFluxD, obj.i_bdFluxB, obj.i_bdE1, obj.i_bdE2 \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"\n" + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 20) AND (obj.i_extendedness = 1) AND \"\\\n", + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.05)) = 1 \"\n" ] }, { @@ -608,7 +704,9 @@ "i_kronRad = tab['i_kronRad']\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", + "\n", + "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4" ] }, { @@ -636,6 +734,20 @@ "ax.legend()\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "d39eb321-42f1-4a1c-9b5b-3561d51c81f8", + "metadata": {}, + "outputs": [], + "source": [ + "# plot color mag diagram of red sequence around cluster. This doesn't work if you want\n", + "# to avoid using the truth table because absolute mag requires redshift\n", + "\n", + "#plt.plot(cmodel_mag, (g_cmodel_mag-cmodel_mag),'.',alpha=.1,label='objects',color='blue')\n", + "#plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -644,8 +756,12 @@ "outputs": [], "source": [ "# pick an object that has large size\n", - "wh = np.where(tab['i_kronRad'] > 10)[0]\n", - "\n" + "wh = np.where((tab['i_kronRad'] > 10) & (cmodel_mag < 22))[0]\n", + "\n", + "print(tab['i_kronRad'][wh])\n", + "\n", + "test = make_image_cutout_new(service, tab['coord_ra'][wh][1], tab['coord_dec'][wh][1], cutout_size=0.005)\n", + "plotImage(ExposureF(test))" ] }, { From 243160bc6f62054103caf8580ab9f3ac89ccb619 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 4 Feb 2025 19:38:08 +0000 Subject: [PATCH 60/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index d523cd0..d26631b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -760,8 +760,22 @@ "\n", "print(tab['i_kronRad'][wh])\n", "\n", - "test = make_image_cutout_new(service, tab['coord_ra'][wh][1], tab['coord_dec'][wh][1], cutout_size=0.005)\n", - "plotImage(ExposureF(test))" + "indx = 2\n", + "test = make_image_cutout_new(service, tab['coord_ra'][wh][indx], tab['coord_dec'][wh][indx], cutout_size=0.005)\n", + "#plotImage(ExposureF(test))\n", + "anchor_image = ExposureF(test)\n", + "plt.subplot(projection=WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "extent = (anchor_image.getBBox().beginX, anchor_image.getBBox().endX,\n", + " anchor_image.getBBox().beginY, anchor_image.getBBox().endY)\n", + "\n", + "plt.imshow(anchor_image.image.array, vmin=.1, vmax=10, extent=extent,\n", + " origin='lower', cmap='gray')\n", + "\n", + "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree, dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", + "\n", + "aperture = SkyCircularAperture(coord, r=2.5 * tab['i_kronRad'][wh][indx]*.2* u.arcsec)\n", + "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='r', lw=3)" ] }, { From 1c60146dd6d02058c94de857d0a7ddd8e053ff40 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 4 Feb 2025 21:33:15 +0000 Subject: [PATCH 61/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 211 +++++++++++++------------------- 1 file changed, 83 insertions(+), 128 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index d26631b..8a02983 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -123,7 +123,7 @@ "Similar in nature to those measured for SDSS: \n", "https://www.sdss3.org/dr8/algorithms/magnitudes.php#cmodel\n", "\n", - "In short, it is the linear combination of the best fit exponential (disk or D) and de Vaucouleurs (bulge or B) profiles.\n", + "In short, it is the linear combination of the best fit exponential (disk or D) and de Vaucouleurs (bulge or B) profiles. \n", "\n", "```\n", "<f>_cModelFlux :\tFlux from the final cmodel fit. Forced on <f>-band.\n", @@ -131,6 +131,8 @@ "<f>_cModel_flag : Failure flag for <f>_cModelFlux\n", "```\n", "\n", + "For most cases the fixed cModel photometry are preferred to that with more degrees of freedom labeled `<f>_free_cModelFlux`.\n", + "\n", "Fluxes fit to the individual model components.\n", "\n", "```\n", @@ -372,102 +374,6 @@ " plt.show()" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "da81a645-947e-4ca2-82f7-905de4ef79da", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "\n", - "def make_image_cutout(tap_service, ra, dec, dataId, cutout_size=0.01,\n", - " imtype=None, filename=None):\n", - " \"\"\"Wrapper function to generate a cutout using the cutout tool\n", - "\n", - " Parameters\n", - " ----------\n", - " tap_service : an instance of the TAP service\n", - " ra, dec : 'float'\n", - " the ra and dec of the cutout center\n", - " dataId : 'dict'\n", - " the dataId of the image to make a cutout from. The format\n", - " must correspond to that provided for parameter 'imtype'\n", - " cutout_size : 'float', optional\n", - " edge length in degrees of the cutout\n", - " imtype : 'string', optional\n", - " string containing the type of LSST image to generate\n", - " a cutout of (e.g. deepCoadd, calexp). If imtype=None,\n", - " the function will assume a deepCoadd.\n", - " filename : 'string', optional\n", - " filename of the resulting cutout (which has fits format)\n", - "\n", - " Returns\n", - " -------\n", - " sodaCutout : 'string'\n", - " filename of the cutout in fits format (including\n", - " full directory path; for now by default it is saved\n", - " in /home/dp02_13a_temp/\n", - " \"\"\"\n", - "\n", - " spherePoint = geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", - "\n", - " if imtype == 'calexp':\n", - "\n", - " query = \"SELECT access_format, access_url, dataproduct_subtype, \" + \\\n", - " \"lsst_visit, lsst_detector, lsst_band, s_ra, s_dec \" + \\\n", - " \"FROM ivoa.ObsCore WHERE dataproduct_type = 'image' \" + \\\n", - " \"AND obs_collection = 'LSST.DP02' \" + \\\n", - " \"AND dataproduct_subtype = 'lsst.calexp' \" + \\\n", - " \"AND lsst_visit = \" + str(dataId[\"visit\"]) + \" \" + \\\n", - " \"AND lsst_detector = \" + str(dataId[\"detector\"])\n", - " results = tap_service.search(query)\n", - "\n", - " else:\n", - " # Find the tract and patch that contain this point\n", - " tract = dataId[\"tract\"]\n", - " patch = dataId[\"patch\"]\n", - "\n", - " # add optional default band if it is not contained in the dataId\n", - " band = dataId[\"band\"]\n", - "\n", - " query = \"SELECT access_format, access_url, dataproduct_subtype, \" + \\\n", - " \"lsst_patch, lsst_tract, lsst_band, s_ra, s_dec \" + \\\n", - " \"FROM ivoa.ObsCore WHERE dataproduct_type = 'image' \" + \\\n", - " \"AND obs_collection = 'LSST.DP02' \" + \\\n", - " \"AND dataproduct_subtype = 'lsst.deepCoadd_calexp' \" + \\\n", - " \"AND lsst_tract = \" + str(tract) + \" \" + \\\n", - " \"AND lsst_patch = \" + str(patch) + \" \" + \\\n", - " \"AND lsst_band = \" + \"'\" + str(band) + \"' \"\n", - " results = tap_service.search(query)\n", - "\n", - " # Get datalink\n", - " dataLinkUrl = results[0].getdataurl()\n", - " auth_session = service._session\n", - " dl = DatalinkResults.from_result_url(dataLinkUrl,\n", - " session=auth_session)\n", - "\n", - " # from_resource: creates a instance from\n", - " # a number of records and a Datalink Resource.\n", - " sq = SodaQuery.from_resource(dl,\n", - " dl.get_adhocservice_by_id(\"cutout-sync\"),\n", - " session=auth_session)\n", - "\n", - " sq.circle = (spherePoint.getRa().asDegrees() * u.deg,\n", - " spherePoint.getDec().asDegrees() * u.deg,\n", - " cutout_size * u.deg)\n", - "\n", - " if filename:\n", - " sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/'+filename)\n", - " else:\n", - " sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/soda-cutout.fits')\n", - "\n", - " with open(sodaCutout, 'bw') as f:\n", - " f.write(sq.execute_stream().read())\n", - "\n", - " return sodaCutout\n" - ] - }, { "cell_type": "code", "execution_count": null, @@ -540,16 +446,20 @@ " sq.circle = (spherePoint.getRa().asDegrees() * u.deg,\n", " spherePoint.getDec().asDegrees() * u.deg,\n", " cutout_size * u.deg)\n", + " cutout_bytes = sq.execute_stream().read()\n", + " mem = MemFileManager(len(cutout_bytes))\n", + " mem.setData(cutout_bytes, len(cutout_bytes))\n", "\n", - " if filename:\n", - " sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/'+filename)\n", - " else:\n", - " sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/soda-cutout.fits')\n", + " return mem\n", + " #if filename:\n", + " # sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/'+filename)\n", + " #else:\n", + " # sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/soda-cutout.fits')\n", "\n", - " with open(sodaCutout, 'bw') as f:\n", - " f.write(sq.execute_stream().read())\n", + " #with open(sodaCutout, 'bw') as f:\n", + " # f.write(sq.execute_stream().read())\n", "\n", - " return sodaCutout\n" + " #return sodaCutout\n" ] }, { @@ -592,17 +502,6 @@ "First see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "14450d07-0c29-4342-91f2-72ccc4cecfb0", - "metadata": {}, - "outputs": [], - "source": [ - "cluster_RA = 55.7506834813934\n", - "cluster_dec = -32.28892993702273\n" - ] - }, { "cell_type": "code", "execution_count": null, @@ -631,6 +530,29 @@ " print(cname)" ] }, + { + "cell_type": "markdown", + "id": "caf9008d-e3aa-4908-bf32-a27cbe890a4f", + "metadata": {}, + "source": [ + "## 2.3 Compare photometric measurements\n", + "\n", + "Below, query the DP0.2 objectTable for a selection of photometric measurements. This section will focus on 3 measurements: total flux from cModel (sum of bulge and disk sersic compoents fitted to the galaxy); and apparent fluxes measured as Kron (typically includes more than 90% of intrinsic light) and GaaP (which is optimized for measuring accurate colors between bands).\n", + "\n", + "First, focus on a known part of the simulation to contain a galaxy cluster (also seen in DP0.2 notebook tutorial 03a). Search for all galaxies (the `i_extendedness` flag will exclude point sources) that are unique in the objectTable (`detect_isPrimary` = True). Further, identify objects which have been detected at high signal to noise > 10 and whose photometric measurements have not been flagged as having an issue (`i_kronFlux_flag` or `i_cModel_flag` = 0 means the photometry is ok). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14450d07-0c29-4342-91f2-72ccc4cecfb0", + "metadata": {}, + "outputs": [], + "source": [ + "cluster_RA = 55.7506834813934\n", + "cluster_dec = -32.28892993702273\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -640,10 +562,11 @@ "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.g_cModelFlux, obj.r_cModelFlux, \" + \\\n", + " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, \" + \\\n", " \"obj.i_bdFluxD, obj.i_bdFluxB, obj.i_bdE1, obj.i_bdE2 \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 20) AND (obj.i_extendedness = 1) AND \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", + " \"(obj.i_kronFlux_flag = 0) AND (obj.i_kronFlux_flag = 0) AND \"\\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.05)) = 1 \"\n" ] }, @@ -686,7 +609,6 @@ "id": "e6a27a39-ed2b-49fe-ac6d-51ae4c300bfc", "metadata": {}, "source": [ - "### 2.4 Exploring the input vs output photometry\n", "\n", "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", "\n", @@ -700,13 +622,16 @@ "metadata": {}, "outputs": [], "source": [ - "#truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", + "# do we want to select by things whose cmodel or kron flags are bad?\n", + "\n", + "\n", "i_kronRad = tab['i_kronRad']\n", + "\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", - "\n", - "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4" + "\n" ] }, { @@ -719,14 +644,15 @@ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-1.2,1.2]\n", "\n", - "ax.plot(i_kronRad, (cmodel_mag-kron_mag),'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(i_kronRad, (cmodel_mag-gaap_mag),'.',alpha=.1, label='gaapOptimal',color='green')\n", + "#ax.plot(i_kronRad, (cmodel_mag_inner-kron_mag),'.',alpha=.1,label='cmodelInner-Kron',color='red')\n", + "ax.plot(i_kronRad, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", + "ax.plot(i_kronRad, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", "#ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", "\n", "ax2.hist((cmodel_mag-kron_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "ax2.hist((cmodel_mag-gaap_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "ax2.set_ylim([-1,1])\n", - "#ax.axhline(0,linestyle='--')\n", + "ax.axhline(0,linestyle='--')\n", "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", "ax.set_ylabel('cModel mag - Other mag')\n", "ax.set_ylim([-1,1])\n", @@ -743,11 +669,31 @@ "source": [ "# plot color mag diagram of red sequence around cluster. This doesn't work if you want\n", "# to avoid using the truth table because absolute mag requires redshift\n", + "plt.hist(cmodel_mag,bins=50,label='cModel',color='r',alpha=.5)\n", + "plt.hist(kron_mag,bins=50,label='Kron',color='b',alpha=.5)\n", + "plt.axvline(np.median(kron_mag),color='b')\n", + "plt.axvline(np.median(cmodel_mag),color='r')\n", + "plt.legend()\n", + "plt.xlabel('Magnitude')\n", + "plt.ylabel('N')\n", + "plt.title('detect_isPrimary = 1 AND i_extendedness = 1')\n", + "plt.show()\n", + "print(np.median(kron_mag), np.median(cmodel_mag))\n", "\n", "#plt.plot(cmodel_mag, (g_cmodel_mag-cmodel_mag),'.',alpha=.1,label='objects',color='blue')\n", "#plt.show()" ] }, + { + "cell_type": "markdown", + "id": "48d5bfb6-dc27-4ed8-b615-78216710912e", + "metadata": {}, + "source": [ + "### 3. Visualize photometric measurements\n", + "\n", + "Here make a cutout of a large galaxy in the cluster and compare the aperture sizes of the different photometric measurements" + ] + }, { "cell_type": "code", "execution_count": null, @@ -758,17 +704,26 @@ "# pick an object that has large size\n", "wh = np.where((tab['i_kronRad'] > 10) & (cmodel_mag < 22))[0]\n", "\n", - "print(tab['i_kronRad'][wh])\n", + "#print(tab['i_kronRad'][wh])\n", "\n", "indx = 2\n", - "test = make_image_cutout_new(service, tab['coord_ra'][wh][indx], tab['coord_dec'][wh][indx], cutout_size=0.005)\n", + "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx], tab['coord_dec'][wh][indx], cutout_size=0.005)\n", + "\n", "#plotImage(ExposureF(test))\n", - "anchor_image = ExposureF(test)\n", + "\n", + "#cutout_bytes = sq.execute_stream().read()\n", + "#mem = MemFileManager(len(cutout_bytes))\n", + "#mem.setData(cutout_bytes, len(cutout_bytes))\n", + "anchor_image = ExposureF(mem)\n", + "# plotImage(exposure)\n", + "\n", + "#anchor_image = ExposureF(test)\n", "plt.subplot(projection=WCS(anchor_image.getWcs().getFitsMetadata()))\n", "extent = (anchor_image.getBBox().beginX, anchor_image.getBBox().endX,\n", " anchor_image.getBBox().beginY, anchor_image.getBBox().endY)\n", "\n", - "plt.imshow(anchor_image.image.array, vmin=.1, vmax=10, extent=extent,\n", + "plt.imshow(anchor_image.image.array, vmin=.1, vmax=10, \n", + " extent=extent,\n", " origin='lower', cmap='gray')\n", "\n", "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree, dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", From 787eb175e611a6d0a7d60e832c139ee9911bb9fa Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 4 Feb 2025 22:06:01 +0000 Subject: [PATCH 62/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 83 ++++++++++++++++++++++++++++----- 1 file changed, 72 insertions(+), 11 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 8a02983..1c097b6 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -133,17 +133,6 @@ "\n", "For most cases the fixed cModel photometry are preferred to that with more degrees of freedom labeled `<f>_free_cModelFlux`.\n", "\n", - "Fluxes fit to the individual model components.\n", - "\n", - "```\n", - "<f>_bdFluxB : Flux from the de Vaucouleurs fit. Measured on <f>-band.\n", - "<f>_bdFluxD : Flux from the exponential fit. Measured on <f>-band.\n", - "<f>_bdFluxBErr : Uncertainty of <f>_bdFluxB\n", - "<f>_bdFluxDErr : Uncertainty of <f>_bdFluxD\n", - "```\n", - "\n", - "The fit sizes are also available (half-light radii, ellipse axes) for both bulge (de Vaucouleurs) and disk (exponential) components.\n", - "\n", "### 1.1.2 Apparent fluxes (i.e. not corrected to the total flux)\n", " \n", "#### Kron fluxes\n", @@ -743,6 +732,78 @@ "sys.exit()" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "47272d59-a513-469a-9642-9acd724da50d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e40789c3-29b2-4f17-a687-a604c828c9b2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a9fbb040-3d5a-4af7-93fd-5038c28e49a8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ca25705-3ad4-40ec-bc18-32c2b08eccc8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "55aa98dc-0528-44e6-8d6f-279fe5eb1ebd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad0628a-0620-462d-9668-5433ec8f2ebf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa875434-44f7-4f70-bc24-b3685f770134", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f4f4cf8-a4ca-46b7-ba42-d0034cd94238", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a647aa1e-bb8a-4f64-aff9-670b13997d87", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, From cf5d7c2bef6acac031c9561105a972d035618056 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 4 Feb 2025 22:55:20 +0000 Subject: [PATCH 63/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 35 ++++++++++++++++++++++++++++----- 1 file changed, 30 insertions(+), 5 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 1c097b6..6f53996 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -556,7 +556,7 @@ " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", " \"(obj.i_kronFlux_flag = 0) AND (obj.i_kronFlux_flag = 0) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.05)) = 1 \"\n" + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"\n" ] }, { @@ -598,10 +598,9 @@ "id": "e6a27a39-ed2b-49fe-ac6d-51ae4c300bfc", "metadata": {}, "source": [ - "\n", "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", "\n", - "First, store the AB magnitudes to go with the fluxes extracted from the objectTable." + "First, store the Kron Radius, which is a good proxy for the size of the galaxy light profile, and the AB magnitudes to go with the fluxes extracted from the objectTable." ] }, { @@ -611,8 +610,6 @@ "metadata": {}, "outputs": [], "source": [ - "# do we want to select by things whose cmodel or kron flags are bad?\n", - "\n", "\n", "i_kronRad = tab['i_kronRad']\n", "\n", @@ -623,6 +620,16 @@ "\n" ] }, + { + "cell_type": "markdown", + "id": "85f65eb7-c0c6-45bf-8ff4-4e73b5e9e075", + "metadata": {}, + "source": [ + "Make a plot that shows how the different photometric measurements compare. Note that cModel is the total flux integrated from a model fit to the galaxy light profile, while Kron and GaaP are both measures of light within a fixed aperture. \n", + "\n", + "Generally GaaP magnitudes are larger (fainter) than that measured from cModel so " + ] + }, { "cell_type": "code", "execution_count": null, @@ -646,6 +653,24 @@ "ax.set_ylabel('cModel mag - Other mag')\n", "ax.set_ylim([-1,1])\n", "ax.set_xlim([0,15])\n", + "ax.legend()\n", + "\n", + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "ylims = [-1.2,1.2]\n", + "\n", + "#ax.plot(i_kronRad, (cmodel_mag_inner-kron_mag),'.',alpha=.1,label='cmodelInner-Kron',color='red')\n", + "ax.plot(cmodel_mag, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", + "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", + "#ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", + "\n", + "#ax2.hist((cmodel_mag-kron_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "#ax2.hist((cmodel_mag-gaap_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "#ax2.set_ylim([-1,1])\n", + "ax.axhline(0,linestyle='--')\n", + "ax.set_xlabel('cModel Magnitude')\n", + "ax.set_ylabel('cModel mag - Other mag')\n", + "ax.set_ylim([-1,1])\n", + "#ax.set_xlim([0,15])\n", "ax.legend()\n" ] }, From 7d1231735d8906162a4b71ac8cac0e8a10bbd028 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 4 Feb 2025 23:40:18 +0000 Subject: [PATCH 64/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 6f53996..707863d 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -610,14 +610,11 @@ "metadata": {}, "outputs": [], "source": [ - "\n", "i_kronRad = tab['i_kronRad']\n", "\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", - "\n" + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" ] }, { @@ -640,10 +637,8 @@ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-1.2,1.2]\n", "\n", - "#ax.plot(i_kronRad, (cmodel_mag_inner-kron_mag),'.',alpha=.1,label='cmodelInner-Kron',color='red')\n", "ax.plot(i_kronRad, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", "ax.plot(i_kronRad, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", - "#ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", "\n", "ax2.hist((cmodel_mag-kron_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "ax2.hist((cmodel_mag-gaap_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", @@ -681,8 +676,7 @@ "metadata": {}, "outputs": [], "source": [ - "# plot color mag diagram of red sequence around cluster. This doesn't work if you want\n", - "# to avoid using the truth table because absolute mag requires redshift\n", + "\n", "plt.hist(cmodel_mag,bins=50,label='cModel',color='r',alpha=.5)\n", "plt.hist(kron_mag,bins=50,label='Kron',color='b',alpha=.5)\n", "plt.axvline(np.median(kron_mag),color='b')\n", From 85459293db9e4598bdbf9fb5bc9343e096ae21f3 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 5 Feb 2025 00:00:42 +0000 Subject: [PATCH 65/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 40 ++++++++++++++------------------- 1 file changed, 17 insertions(+), 23 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 707863d..2025137 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -251,7 +251,6 @@ "from scipy import stats#.binned_statistic\n", "from scipy.stats import sigmaclip\n", "\n", - "\n", "# stuff for cutout\n", "import time\n", "import numpy as np\n", @@ -403,10 +402,7 @@ " spherePoint = geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", " coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree, frame='icrs')\n", "\n", - "\n", - "\n", - " # add optional default band if it is not contained in the dataId\n", - " band = 'i' #dataId[\"band\"]\n", + " band = 'i'\n", "\n", " query = \"SELECT access_format, access_url, dataproduct_subtype, \" + \\\n", " \"lsst_patch, lsst_tract, lsst_band, s_ra, s_dec \" + \\\n", @@ -439,16 +435,7 @@ " mem = MemFileManager(len(cutout_bytes))\n", " mem.setData(cutout_bytes, len(cutout_bytes))\n", "\n", - " return mem\n", - " #if filename:\n", - " # sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/'+filename)\n", - " #else:\n", - " # sodaCutout = os.path.join(os.getenv('HOME'), 'dp02_13a_temp/soda-cutout.fits')\n", - "\n", - " #with open(sodaCutout, 'bw') as f:\n", - " # f.write(sq.execute_stream().read())\n", - "\n", - " #return sodaCutout\n" + " return mem" ] }, { @@ -551,11 +538,11 @@ "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, \" + \\\n", + " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap09Flux, \" + \\\n", " \"obj.i_bdFluxD, obj.i_bdFluxB, obj.i_bdE1, obj.i_bdE2 \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", - " \"(obj.i_kronFlux_flag = 0) AND (obj.i_kronFlux_flag = 0) AND \"\\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \"\\\n", + " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \"\\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"\n" ] }, @@ -612,6 +599,7 @@ "source": [ "i_kronRad = tab['i_kronRad']\n", "\n", + "ap12_mag = -2.50 * np.log10(tab['i_ap09Flux']) + 31.4\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" @@ -624,35 +612,41 @@ "source": [ "Make a plot that shows how the different photometric measurements compare. Note that cModel is the total flux integrated from a model fit to the galaxy light profile, while Kron and GaaP are both measures of light within a fixed aperture. \n", "\n", - "Generally GaaP magnitudes are larger (fainter) than that measured from cModel so " + "Generally GaaP magnitudes are larger (fainter) than that measured from cModel, becuase the fixed aperture systematically underestimates the flux in the galaxy wings (and the lost flux increases as the intrinsic size of the galaxy increases, e.g. as traced by the Kron radius)." ] }, { "cell_type": "code", "execution_count": null, "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", - "ylims = [-1.2,1.2]\n", + "ylims = [-2,2]\n", "\n", + "ax.plot(i_kronRad, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel-12-pix aperture',color='red')\n", "ax.plot(i_kronRad, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", "ax.plot(i_kronRad, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", "\n", + "ax2.hist((cmodel_mag-ap12_mag),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "\n", "ax2.hist((cmodel_mag-kron_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "ax2.hist((cmodel_mag-gaap_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.set_ylim([-1,1])\n", + "ax2.set_ylim(ylims)\n", "ax.axhline(0,linestyle='--')\n", "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", "ax.set_ylabel('cModel mag - Other mag')\n", - "ax.set_ylim([-1,1])\n", + "ax.set_ylim(ylims)\n", "ax.set_xlim([0,15])\n", "ax.legend()\n", "\n", "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-1.2,1.2]\n", "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel-12-pix aperture',color='red')\n", "#ax.plot(i_kronRad, (cmodel_mag_inner-kron_mag),'.',alpha=.1,label='cmodelInner-Kron',color='red')\n", "ax.plot(cmodel_mag, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", From 3474b09938f62a5f1c2f5b9b589d642d525ba9b5 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 6 Feb 2025 00:13:50 +0000 Subject: [PATCH 66/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 2025137..9b62d01 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -131,7 +131,7 @@ "<f>_cModel_flag : Failure flag for <f>_cModelFlux\n", "```\n", "\n", - "For most cases the fixed cModel photometry are preferred to that with more degrees of freedom labeled `<f>_free_cModelFlux`.\n", + "For most cases the fixed cModel photometry are preferred to that with more degrees of freedom labeled `<f>_free_cModelFlux`. The difference is that the default uses a reference band where the galaxy is well detected to determine the other parameters, which are then fixed when fitting for the flux in the other bands. The `_free_cModelFlux` measurement allows all parameters to be free independent in each filter. The fixed `_cModelFlux` measurements are generally recommended.\n", "\n", "### 1.1.2 Apparent fluxes (i.e. not corrected to the total flux)\n", " \n", @@ -538,7 +538,7 @@ "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap09Flux, \" + \\\n", + " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap09Flux, obj.i_ap17Flux, \" + \\\n", " \"obj.i_bdFluxD, obj.i_bdFluxB, obj.i_bdE1, obj.i_bdE2 \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \"\\\n", @@ -600,6 +600,7 @@ "i_kronRad = tab['i_kronRad']\n", "\n", "ap12_mag = -2.50 * np.log10(tab['i_ap09Flux']) + 31.4\n", + "ap17_mag = -2.50 * np.log10(tab['i_ap17Flux']) + 31.4\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" @@ -619,9 +620,7 @@ "cell_type": "code", "execution_count": null, "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", - "metadata": { - "scrolled": true - }, + "metadata": {}, "outputs": [], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", @@ -630,6 +629,7 @@ "ax.plot(i_kronRad, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel-12-pix aperture',color='red')\n", "ax.plot(i_kronRad, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", "ax.plot(i_kronRad, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap17_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='cyan')\n", "\n", "ax2.hist((cmodel_mag-ap12_mag),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "\n", @@ -674,7 +674,7 @@ "plt.hist(cmodel_mag,bins=50,label='cModel',color='r',alpha=.5)\n", "plt.hist(kron_mag,bins=50,label='Kron',color='b',alpha=.5)\n", "plt.axvline(np.median(kron_mag),color='b')\n", - "plt.axvline(np.median(cmodel_mag),color='r')\n", + "plt.axvline(np.median(cmodel_mag),color='r',linestyle='--')\n", "plt.legend()\n", "plt.xlabel('Magnitude')\n", "plt.ylabel('N')\n", From 3b70271c1019ff64a7e4e40426fc8cdc94ee40f2 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 6 Feb 2025 01:04:31 +0000 Subject: [PATCH 67/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 9b62d01..a29f14d 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -113,7 +113,7 @@ "\n", "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", "\n", - "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there: The first are total fluxes are those that integrate the total light coming from objects, corrected for loss due to the blurring effects of PSF or seeing, including \"Composite Model\" (`cModel`) fluxes and \"Kron Fluxes\". The second category characterize the relative brightness of objects for specific regions of objects (i.e. are not corrected to be total fluxes) but can be useful for measuring accurate light profiles or accurate colors.\n", + "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there: The first are total fluxes are those that integrate the total light coming from objects, corrected for loss due to the blurring effects of PSF or seeing, including \"Composite Model\" (`cModel`) fluxes. The second category characterize the relative brightness of objects for specific regions of objects (i.e. are not corrected to be total fluxes) but can be useful for measuring accurate light profiles or accurate colors.\n", "\n", "### 1.1.1 Total fluxes\n", "\n", From 46502c3c5a57214abd742e6a88e112e55071abd4 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 6 Feb 2025 16:33:40 +0000 Subject: [PATCH 68/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index a29f14d..2de5e7b 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -126,12 +126,12 @@ "In short, it is the linear combination of the best fit exponential (disk or D) and de Vaucouleurs (bulge or B) profiles. \n", "\n", "```\n", - "<f>_cModelFlux :\tFlux from the final cmodel fit. Forced on <f>-band.\n", + "<f>_cModelFlux : Flux from the final cmodel fit. Forced on <f>-band.\n", "<f>_cModelFluxErr : Uncertainty of <f>_cModelFlux\n", "<f>_cModel_flag : Failure flag for <f>_cModelFlux\n", "```\n", "\n", - "For most cases the fixed cModel photometry are preferred to that with more degrees of freedom labeled `<f>_free_cModelFlux`. The difference is that the default uses a reference band where the galaxy is well detected to determine the other parameters, which are then fixed when fitting for the flux in the other bands. The `_free_cModelFlux` measurement allows all parameters to be free independent in each filter. The fixed `_cModelFlux` measurements are generally recommended.\n", + "For most cases the fixed cModel photometry are preferred to that with more degrees of freedom labeled `<f>_free_cModelFlux`. The difference is that the default uses a reference band where the galaxy is well detected to determine the other parameters, which are then fixed when fitting for the flux in the other bands. The `_free_cModelFlux` measurement allows all parameters to be free independent in each filter. The fixed `_cModelFlux` measurements are generally recommended for galaxy science applications where total flux measurements are needed (e.g. for intrinsic luminosity or mass).\n", "\n", "### 1.1.2 Apparent fluxes (i.e. not corrected to the total flux)\n", " \n", @@ -145,7 +145,7 @@ "<f>_kronFlux_flag : Failure flag for <f>_kronFlux.\n", "```\n", "\n", - "The Kron radius, `<f>_kronRad`, is also available. In this case of LSST pipeline output, the Kron flux is not corrected for light that is emitted outside of the Kron aperture. \n", + "The Kron radius, `<f>_kronRad`, is also available. In this case of LSST pipeline output, the Kron flux is not corrected for light that is emitted outside of the Kron aperture. While in many cases it will collect the majority of light, it will not be as accurate as the cModel for science cases requiring total flux.\n", "\n", "\n", "#### Aperture fluxes\n", @@ -157,13 +157,11 @@ "<f>_ap<pix>FluxFlag : Failure flag for <f>_ap<pix>Flux.\n", "```\n", "\n", - "For DP0.2, the apertures are 3, 6, 9, 12, 17, 25, 35, 50, and 70 pixels.\n", - "\n", - "In the column name, apertures are `03`, `06`, `09`, `12`, and so on.\n", + "For DP0.2, the apertures are 3, 6, 9, 12, 17, 25, 35, 50, and 70 pixels. In the column name, apertures are `03`, `06`, `09`, `12`, and so on. While aperture fluxes are not corrected for the loss outside the aperture, if the aperture size is much larger than the galaxy size then it will approximate the total flux of the galaxy. The general application of these measurements are for measuring radial profiles (see Section XX).\n", "\n", "#### GaaP fluxes\n", "\n", - "These are the Gaussian-aperture-and-PSF flux from <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>. The main goal of this method is to measure accurate colors while accounting for the different spatial resolution between filters. This is sometimes done by convolving all images to the largest PSF, but this process is computationally very time consuming for large images. It is not a measure of total flux in a filter. For photometric redshifts, since accurate colors are important, it is the GaaP fluxes that should be used. Several apertures are available (TBD: what is optimal aperture based on?)\n", + "These are the Gaussian-aperture-and-PSF flux from <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>. The main goal of this method is to measure accurate colors while accounting for the different spatial resolution between filters. This is sometimes done by convolving all images to the largest PSF, but this process is computationally very time consuming for large images. It is not a measure of total flux in a filter. Several apertures are available. For photometric redshifts, and other analysis where accurate colors are important, it is the GaaP fluxes with optimal aperture that should be used. \n", "\n", "**Optimal**\n", "\n", @@ -186,8 +184,7 @@ "<f>_gaap<ap>FluxErr : Uncertainty of <f>_gaap<ap>Flux.\n", "```\n", "\n", - "Where the seeing apertures are 0.5, 0.7, 1.0, 1.5, 2.5, and 3.0 arcseconds.\n", - "In the column name `<ap>` appears as `0p5`, `0p7`, etc.\n", + "Where the seeing apertures are 0.5, 0.7, 1.0, 1.5, 2.5, and 3.0 arcseconds. In the column name `<ap>` appears as `0p5`, `0p7`, etc.\n", "\n", "\n", "#### PSF fluxes\n", From 994aac3e59342a2e9d60171fd233b05e5d01d53d Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 6 Feb 2025 19:22:13 +0000 Subject: [PATCH 69/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 218 ++++++++++++++++++++++++-------- 1 file changed, 168 insertions(+), 50 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 2de5e7b..5142017 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -69,8 +69,7 @@ "metadata": {}, "source": [ "**Credit:**\n", - "\"This notebook benefitted from earlier exploration of simulated data and notebook development by Melissa Graham and Dan Taranu. _E.g., \"Originally developed by\" or \"Based on notebooks developed by\" and then people's names, including journal article or software release citations if appropriate._\n", - "Please consider acknowledging them if this notebook is used for the preparation of journal articles, software releases, or other notebooks." + "\"This notebook benefitted from earlier exploration of simulated data and notebook development by Melissa Graham and Dan Taranu. " ] }, { @@ -93,7 +92,9 @@ "source": [ "## 1. Introduction\n", "\n", - "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a> about the PSF photometry. \n" + "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a> about the PSF photometry. \n", + "\n", + "Please note that these explanations are specific to DP0.2: the objectTable contents and definitions are still subject to change for DP1. \n" ] }, { @@ -149,7 +150,7 @@ "\n", "\n", "#### Aperture fluxes\n", - "This contains the enclosed flux inside a given aperture (they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture). Fixed aperture diameter size in pixels.\n", + "This contains the enclosed flux inside a given aperture (they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture). Fixed aperture size refers to the aperture radius in pixels.\n", "\n", "```\n", "<f>_ap<pix>Flux : Flux within <pix>-pixel aperture. Forced on <f>-band.\n", @@ -287,11 +288,8 @@ "source": [ "### 1.3 Define functions and parameters\n", "\n", - "_TBD if we can remove this_\n", - "\n", - "_It is OK to rename the subsection to be more specific to the notebook, and/or to use sub-sub-sections like \"1.2.1 Define global cosmological parameter values\" or \"1.2.2 Define a function to make an image cutout\"._\n", "\n", - "_It is OK to remove this sub-section if it is not being used._" + "#### 1.3.1 Define some aesthetic plotting defaults" ] }, { @@ -332,6 +330,14 @@ "plt.rcParams.update(params)" ] }, + { + "cell_type": "markdown", + "id": "b234b23f-d81a-4666-b108-8035e4e094c3", + "metadata": {}, + "source": [ + "#### 1.3.2 Define a shortcut to plotting images" + ] + }, { "cell_type": "code", "execution_count": null, @@ -359,6 +365,15 @@ " plt.show()" ] }, + { + "cell_type": "markdown", + "id": "5e6352ac-09dd-4be0-bff3-379860c12a69", + "metadata": {}, + "source": [ + "#### 1.3.3 Define a shortcut function to generate an image cutout using the cutout tool\n", + "Further information about the cutout tool can be found in tutorial notebook 13a." + ] + }, { "cell_type": "code", "execution_count": null, @@ -535,8 +550,8 @@ "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap09Flux, obj.i_ap17Flux, \" + \\\n", - " \"obj.i_bdFluxD, obj.i_bdFluxB, obj.i_bdE1, obj.i_bdE2 \" + \\\n", + " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux, \" + \\\n", + " \"obj.i_ap12Flux, obj.i_ap17Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \"\\\n", " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \"\\\n", @@ -596,11 +611,15 @@ "source": [ "i_kronRad = tab['i_kronRad']\n", "\n", - "ap12_mag = -2.50 * np.log10(tab['i_ap09Flux']) + 31.4\n", - "ap17_mag = -2.50 * np.log10(tab['i_ap17Flux']) + 31.4\n", "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", + "\n", + "ap06_mag = -2.50 * np.log10(tab['i_ap06Flux']) + 31.4\n", + "ap12_mag = -2.50 * np.log10(tab['i_ap12Flux']) + 31.4\n", + "\n", + "ap09_mag = -2.50 * np.log10(tab['i_ap09Flux']) + 31.4\n", + "ap17_mag = -2.50 * np.log10(tab['i_ap17Flux']) + 31.4\n" ] }, { @@ -608,6 +627,8 @@ "id": "85f65eb7-c0c6-45bf-8ff4-4e73b5e9e075", "metadata": {}, "source": [ + "### 2.3.1 Compare aperture photometry to cModel total fluxes\n", + "\n", "Make a plot that shows how the different photometric measurements compare. Note that cModel is the total flux integrated from a model fit to the galaxy light profile, while Kron and GaaP are both measures of light within a fixed aperture. \n", "\n", "Generally GaaP magnitudes are larger (fainter) than that measured from cModel, becuase the fixed aperture systematically underestimates the flux in the galaxy wings (and the lost flux increases as the intrinsic size of the galaxy increases, e.g. as traced by the Kron radius)." @@ -619,19 +640,106 @@ "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", "metadata": {}, "outputs": [], + "source": [ + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "ylims = [-1.5,1.5]\n", + "\n", + "ax.plot(i_kronRad, (cmodel_mag-ap17_mag),'.',alpha=.1, label='cModel - 17-pix aperture',color='blue')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel 12-pix aperture',color='green')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap09_mag),'.',alpha=.1,label='cModel 9-pix aperture',color='orange')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap06_mag),'.',alpha=.1,label='cModel 6-pix aperture',color='red')\n", + "\n", + "ax2.hist((cmodel_mag-ap17_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist((cmodel_mag-ap12_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist((cmodel_mag-ap09_mag),edgecolor='orange',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "ax2.hist((cmodel_mag-ap06_mag),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "\n", + "ax2.set_ylim(ylims)\n", + "ax.axhline(0,linestyle='--')\n", + "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", + "ax.set_ylabel('cModel mag - Aperture mag')\n", + "ax.set_ylim(ylims)\n", + "ax.set_xlim([0,15])\n", + "ax.legend()\n", + "\n", + "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", + "ylims = [-1.2,1.2]\n", + "bins=np.arange(16,27,1)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap06_mag),'.',alpha=.1,label='cModel 6-pix aperture',color='red')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-ap06_mag)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='red', lw=2, label='bin median',zorder=10)\n", + "\n", + "\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap09_mag),'.',alpha=.1,label='cModel 9-pix aperture',color='orange')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-ap09_mag)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='orange', lw=2, label='bin median',zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel 12-pix aperture',color='green')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-ap12_mag)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='green', lw=2, label='bin median',zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap17_mag),'.',alpha=.1,label='cModel 17-pix aperture',color='blue')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-ap17_mag)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='blue', lw=2, label='bin median',zorder=10)\n", + "\n", + "\n", + "\n", + "\n", + "ax.axhline(0,linestyle='--')\n", + "ax.set_xlabel('cModel Magnitude')\n", + "ax.set_ylabel('cModel mag - Aperture mag')\n", + "ax.set_ylim([-1,1])\n", + "#ax.set_xlim([2,15])\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "cef81cea-b352-4196-a4d0-c5b4ad80bd00", + "metadata": {}, + "source": [ + "These two figures show that the aperture photometry typically under-estimates the flux relative to the total flux estimated using cModel. As expected, there is a general trend for larger apertures to get closer to the total flux from cModel for large galaxies (i.e. whose Kron Radius is larger). There is also a general trend for the aperture photometry to be less discrepant at fainter magnitudes, since faint galaxies tend to be small.\n", + "\n", + "\n", + "### 2.3.2 Compare Kron and GaaP photometry to cModel\n", + "\n", + "In the next cell, compare the cModel to the Kron and GaaP measures." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05e30151-1346-425a-a86f-f2a7c945a45c", + "metadata": {}, + "outputs": [], "source": [ "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-2,2]\n", "\n", - "ax.plot(i_kronRad, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel-12-pix aperture',color='red')\n", "ax.plot(i_kronRad, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", "ax.plot(i_kronRad, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap17_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='cyan')\n", - "\n", - "ax2.hist((cmodel_mag-ap12_mag),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "\n", "ax2.hist((cmodel_mag-kron_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", "ax2.hist((cmodel_mag-gaap_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "\n", "ax2.set_ylim(ylims)\n", "ax.axhline(0,linestyle='--')\n", "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", @@ -640,47 +748,40 @@ "ax.set_xlim([0,15])\n", "ax.legend()\n", "\n", - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", "ylims = [-1.2,1.2]\n", "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel-12-pix aperture',color='red')\n", - "#ax.plot(i_kronRad, (cmodel_mag_inner-kron_mag),'.',alpha=.1,label='cmodelInner-Kron',color='red')\n", "ax.plot(cmodel_mag, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-kron_mag)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='blue', lw=2, label='bin median',zorder=10)\n", + "\n", "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", - "#ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-gaap_mag)\n", + "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", + " y, statistic='median', bins=bins)\n", + "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", + "ax.plot(binctr, bin_means, color='green', lw=2, label='bin median',zorder=10)\n", "\n", - "#ax2.hist((cmodel_mag-kron_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "#ax2.hist((cmodel_mag-gaap_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "#ax2.set_ylim([-1,1])\n", "ax.axhline(0,linestyle='--')\n", "ax.set_xlabel('cModel Magnitude')\n", "ax.set_ylabel('cModel mag - Other mag')\n", "ax.set_ylim([-1,1])\n", - "#ax.set_xlim([0,15])\n", - "ax.legend()\n" + "ax.legend()" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "d39eb321-42f1-4a1c-9b5b-3561d51c81f8", + "cell_type": "markdown", + "id": "9aec6b4b-ada8-429d-a65f-c076d8d26872", "metadata": {}, - "outputs": [], "source": [ + "The above plots show the parameter space where Kron fluxes do not correspond well with total fluxes (as measured by cModel). This indcates that Kron fluxes will underestimate the total fluxes in the regime of bright magnitudes and large Kron radius. Generally, cModel is recommended over Kron.\n", "\n", - "plt.hist(cmodel_mag,bins=50,label='cModel',color='r',alpha=.5)\n", - "plt.hist(kron_mag,bins=50,label='Kron',color='b',alpha=.5)\n", - "plt.axvline(np.median(kron_mag),color='b')\n", - "plt.axvline(np.median(cmodel_mag),color='r',linestyle='--')\n", - "plt.legend()\n", - "plt.xlabel('Magnitude')\n", - "plt.ylabel('N')\n", - "plt.title('detect_isPrimary = 1 AND i_extendedness = 1')\n", - "plt.show()\n", - "print(np.median(kron_mag), np.median(cmodel_mag))\n", - "\n", - "#plt.plot(cmodel_mag, (g_cmodel_mag-cmodel_mag),'.',alpha=.1,label='objects',color='blue')\n", - "#plt.show()" + "The GaaP fluxes are not meant to measure total fluxes (from these plots it is clear there is a strong discrepancy with cModel) but GaaP measurements are the best and most robust for measuring robust integrated colors between different filters." ] }, { @@ -703,16 +804,9 @@ "# pick an object that has large size\n", "wh = np.where((tab['i_kronRad'] > 10) & (cmodel_mag < 22))[0]\n", "\n", - "#print(tab['i_kronRad'][wh])\n", - "\n", "indx = 2\n", "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx], tab['coord_dec'][wh][indx], cutout_size=0.005)\n", "\n", - "#plotImage(ExposureF(test))\n", - "\n", - "#cutout_bytes = sq.execute_stream().read()\n", - "#mem = MemFileManager(len(cutout_bytes))\n", - "#mem.setData(cutout_bytes, len(cutout_bytes))\n", "anchor_image = ExposureF(mem)\n", "# plotImage(exposure)\n", "\n", @@ -782,6 +876,30 @@ "outputs": [], "source": [] }, + { + "cell_type": "code", + "execution_count": null, + "id": "d39eb321-42f1-4a1c-9b5b-3561d51c81f8", + "metadata": {}, + "outputs": [], + "source": [ + "# random testing of depths compared to Prakruth\n", + "\n", + "plt.hist(cmodel_mag,bins=50,label='cModel',color='r',alpha=.5)\n", + "plt.hist(kron_mag,bins=50,label='Kron',color='b',alpha=.5)\n", + "plt.axvline(np.median(kron_mag),color='b')\n", + "plt.axvline(np.median(cmodel_mag),color='r',linestyle='--')\n", + "plt.legend()\n", + "plt.xlabel('Magnitude')\n", + "plt.ylabel('N')\n", + "plt.title('detect_isPrimary = 1 AND i_extendedness = 1')\n", + "plt.show()\n", + "print(np.median(kron_mag), np.median(cmodel_mag))\n", + "\n", + "#plt.plot(cmodel_mag, (g_cmodel_mag-cmodel_mag),'.',alpha=.1,label='objects',color='blue')\n", + "#plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, From 3f5a74d5bb6dfff68f62e5286ca427734fcd6b94 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 6 Feb 2025 20:41:24 +0000 Subject: [PATCH 70/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 36 +++++++++++++++++++++++++++------ 1 file changed, 30 insertions(+), 6 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 5142017..9cf8c73 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -278,7 +278,7 @@ "from astropy.io import fits\n", "from astropy.wcs import WCS\n", "\n", - "from photutils.aperture import SkyCircularAperture\n" + "from photutils.aperture import SkyCircularAperture, SkyEllipticalAperture\n" ] }, { @@ -511,6 +511,7 @@ "metadata": {}, "outputs": [], "source": [ + "#search_string = 'Flux'\n", "search_string = 'Flux'\n", "band = 'i_'\n", "for cname in results['column_name']:\n", @@ -550,7 +551,7 @@ "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux, \" + \\\n", + " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ixx, obj.i_ixy, obj.i_iyy, \" + \\\n", " \"obj.i_ap12Flux, obj.i_ap17Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \"\\\n", @@ -802,7 +803,9 @@ "outputs": [], "source": [ "# pick an object that has large size\n", - "wh = np.where((tab['i_kronRad'] > 10) & (cmodel_mag < 22))[0]\n", + "import lsst.afw.geom\n", + "\n", + "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]# & (tab['detect_isIsolated'] == True))[0]\n", "\n", "indx = 2\n", "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx], tab['coord_dec'][wh][indx], cutout_size=0.005)\n", @@ -810,7 +813,13 @@ "anchor_image = ExposureF(mem)\n", "# plotImage(exposure)\n", "\n", - "#anchor_image = ExposureF(test)\n", + "axes = lsst.afw.geom.ellipses.Axes(lsst.afw.geom.ellipses.Quadrupole(tab['i_ixx'][wh][indx], tab['i_iyy'][wh][indx], tab['i_ixy'][wh][indx]))\n", + "semi_maj_rad = axes.getA()\n", + "semi_min_rad = axes.getB()\n", + "theta = axes.getTheta()\n", + "\n", + "print(semi_maj_rad, semi_min_rad, theta )\n", + "\n", "plt.subplot(projection=WCS(anchor_image.getWcs().getFitsMetadata()))\n", "extent = (anchor_image.getBBox().beginX, anchor_image.getBBox().endX,\n", " anchor_image.getBBox().beginY, anchor_image.getBBox().endY)\n", @@ -821,9 +830,24 @@ "\n", "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree, dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", "\n", - "aperture = SkyCircularAperture(coord, r=2.5 * tab['i_kronRad'][wh][indx]*.2* u.arcsec)\n", + "aperture = SkyCircularAperture(coord, r=9*.2* u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='r', lw=3)" + "#pix_aperture.plot(color='r', lw=3)\n", + "\n", + "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec, 2.5 * semi_min_rad * 0.2 * u.arcsec, theta = (np.pi - theta) * u.rad)\n", + "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='b', lw=3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2e7d9eb-e669-4888-a67a-981640ab6c98", + "metadata": {}, + "outputs": [], + "source": [ + "print(semi_maj_rad, semi_min_rad, theta)\n", + "\n" ] }, { From ca52c2626de6d4809bcc50793392663601f57e93 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 6 Feb 2025 22:01:55 +0000 Subject: [PATCH 71/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 40 ++++++++++++++++++++++++++++----- 1 file changed, 34 insertions(+), 6 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 9cf8c73..8f878e4 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -269,6 +269,7 @@ "from lsst.rsp import get_tap_service\n", "from lsst.rsp.utils import get_access_token\n", "from lsst.afw.fits import MemFileManager\n", + "import lsst.afw.geom\n", "\n", "import pyvo\n", "from pyvo.dal.adhoc import DatalinkResults, SodaQuery\n", @@ -549,12 +550,13 @@ "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", + "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ixx, obj.i_ixy, obj.i_iyy, \" + \\\n", + " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux, \" + \\\n", + " \"obj.i_ixx, obj.i_ixy, obj.i_iyy, \" + \\\n", " \"obj.i_ap12Flux, obj.i_ap17Flux \" + \\\n", - " \"FROM dp02_dc2_catalogs.Object AS obj \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \"\\\n", + " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \" + \\\n", " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \"\\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"\n" ] @@ -803,11 +805,12 @@ "outputs": [], "source": [ "# pick an object that has large size\n", - "import lsst.afw.geom\n", + "\n", "\n", "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]# & (tab['detect_isIsolated'] == True))[0]\n", "\n", "indx = 2\n", + "print(\"id = \",tab['objectId'][wh][indx])\n", "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx], tab['coord_dec'][wh][indx], cutout_size=0.005)\n", "\n", "anchor_image = ExposureF(mem)\n", @@ -846,7 +849,32 @@ "metadata": {}, "outputs": [], "source": [ - "print(semi_maj_rad, semi_min_rad, theta)\n", + "\n", + "plt.subplot(projection=WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "extent = (anchor_image.getBBox().beginX, anchor_image.getBBox().endX,\n", + " anchor_image.getBBox().beginY, anchor_image.getBBox().endY)\n", + "\n", + "plt.imshow(anchor_image.image.array, vmin=.1, vmax=10, \n", + " extent=extent,\n", + " origin='lower', cmap='gray')\n", + "\n", + "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree, dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", + "\n", + "aperture = SkyCircularAperture(coord, r=6*.2* u.arcsec)\n", + "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='r', lw=3)\n", + "\n", + "aperture = SkyCircularAperture(coord, r=9*.2* u.arcsec)\n", + "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='orange', lw=3)\n", + "\n", + "aperture = SkyCircularAperture(coord, r=12*.2* u.arcsec)\n", + "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='green', lw=3)\n", + "\n", + "aperture = SkyCircularAperture(coord, r=17*.2* u.arcsec)\n", + "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='blue', lw=3)\n", "\n" ] }, From 6d96e1a3eb4f333da7dc9a03db90157c7694eb29 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 7 Feb 2025 00:04:59 +0000 Subject: [PATCH 72/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 8f878e4..a422add 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -552,13 +552,13 @@ "source": [ "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.g_cModelFlux, obj.r_cModelFlux, g_free_cModelFlux_inner, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux, \" + \\\n", - " \"obj.i_ixx, obj.i_ixy, obj.i_iyy, \" + \\\n", - " \"obj.i_ap12Flux, obj.i_ap17Flux \" + \\\n", + " \"obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \" + \\\n", - " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"\n" + " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"\n", + "\n", + "# \"obj.i_ixx, obj.i_ixy, obj.i_iyy, obj.i_ap12Flux, obj.i_ap17Flux \" + \\\n" ] }, { From da1581ce14868c50048631de6d23f6d42d513ed5 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 7 Feb 2025 17:03:06 +0000 Subject: [PATCH 73/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index a422add..e89367a 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -550,15 +550,15 @@ "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", + "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, \" + \\\n", " \"obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \" + \\\n", " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"\n", - "\n", - "# \"obj.i_ixx, obj.i_ixy, obj.i_iyy, obj.i_ap12Flux, obj.i_ap17Flux \" + \\\n" + "\n" ] }, { @@ -794,7 +794,7 @@ "source": [ "### 3. Visualize photometric measurements\n", "\n", - "Here make a cutout of a large galaxy in the cluster and compare the aperture sizes of the different photometric measurements" + "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the objectTable. The position angle `theta` is defined in radians counterclockwise from the x-axis." ] }, { @@ -816,7 +816,7 @@ "anchor_image = ExposureF(mem)\n", "# plotImage(exposure)\n", "\n", - "axes = lsst.afw.geom.ellipses.Axes(lsst.afw.geom.ellipses.Quadrupole(tab['i_ixx'][wh][indx], tab['i_iyy'][wh][indx], tab['i_ixy'][wh][indx]))\n", + "axes = lsst.afw.geom.ellipses.Axes(lsst.afw.geom.ellipses.Quadrupole(tab['shape_xx'][wh][indx], tab['shape_yy'][wh][indx], tab['shape_xy'][wh][indx]))\n", "semi_maj_rad = axes.getA()\n", "semi_min_rad = axes.getB()\n", "theta = axes.getTheta()\n", @@ -837,7 +837,7 @@ "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", "#pix_aperture.plot(color='r', lw=3)\n", "\n", - "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec, 2.5 * semi_min_rad * 0.2 * u.arcsec, theta = (np.pi - theta) * u.rad)\n", + "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec, 2.5 * semi_min_rad * 0.2 * u.arcsec, theta = (np.pi/2 + theta) * u.rad)\n", "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", "pix_aperture.plot(color='b', lw=3)" ] From 649266d0199e16a28f602610b86e02e0ba36ee37 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 7 Feb 2025 17:22:13 +0000 Subject: [PATCH 74/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 67 +++++---------------------------- 1 file changed, 9 insertions(+), 58 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index e89367a..5932d50 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -805,8 +805,6 @@ "outputs": [], "source": [ "# pick an object that has large size\n", - "\n", - "\n", "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]# & (tab['detect_isIsolated'] == True))[0]\n", "\n", "indx = 2\n", @@ -814,7 +812,6 @@ "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx], tab['coord_dec'][wh][indx], cutout_size=0.005)\n", "\n", "anchor_image = ExposureF(mem)\n", - "# plotImage(exposure)\n", "\n", "axes = lsst.afw.geom.ellipses.Axes(lsst.afw.geom.ellipses.Quadrupole(tab['shape_xx'][wh][indx], tab['shape_yy'][wh][indx], tab['shape_xy'][wh][indx]))\n", "semi_maj_rad = axes.getA()\n", @@ -835,7 +832,7 @@ "\n", "aperture = SkyCircularAperture(coord, r=9*.2* u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "#pix_aperture.plot(color='r', lw=3)\n", + "pix_aperture.plot(color='r', lw=3)\n", "\n", "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec, 2.5 * semi_min_rad * 0.2 * u.arcsec, theta = (np.pi/2 + theta) * u.rad)\n", "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", @@ -878,6 +875,14 @@ "\n" ] }, + { + "cell_type": "markdown", + "id": "714badaa-834d-4050-82a6-ffcac245ae5c", + "metadata": {}, + "source": [ + "Maybe below demonstrate how to do the radial profile using the aperture photometry" + ] + }, { "cell_type": "code", "execution_count": null, @@ -928,30 +933,6 @@ "outputs": [], "source": [] }, - { - "cell_type": "code", - "execution_count": null, - "id": "d39eb321-42f1-4a1c-9b5b-3561d51c81f8", - "metadata": {}, - "outputs": [], - "source": [ - "# random testing of depths compared to Prakruth\n", - "\n", - "plt.hist(cmodel_mag,bins=50,label='cModel',color='r',alpha=.5)\n", - "plt.hist(kron_mag,bins=50,label='Kron',color='b',alpha=.5)\n", - "plt.axvline(np.median(kron_mag),color='b')\n", - "plt.axvline(np.median(cmodel_mag),color='r',linestyle='--')\n", - "plt.legend()\n", - "plt.xlabel('Magnitude')\n", - "plt.ylabel('N')\n", - "plt.title('detect_isPrimary = 1 AND i_extendedness = 1')\n", - "plt.show()\n", - "print(np.median(kron_mag), np.median(cmodel_mag))\n", - "\n", - "#plt.plot(cmodel_mag, (g_cmodel_mag-cmodel_mag),'.',alpha=.1,label='objects',color='blue')\n", - "#plt.show()" - ] - }, { "cell_type": "code", "execution_count": null, @@ -984,36 +965,6 @@ "outputs": [], "source": [] }, - { - "cell_type": "code", - "execution_count": null, - "id": "3f1b0710-fb8b-4e60-90f8-8b4ef87283ce", - "metadata": {}, - "outputs": [], - "source": [ - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", - "ylims=[-.0001*1e8,.0001*1e8]\n", - "#ax.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdE2']*tab['i_bdFluxD']),'.')\n", - "ax.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdFluxD']),'r.', alpha=.1)\n", - "ax.plot(cmodel_mag,tab['i_cModelFlux']-(tab['i_bdFluxB']),'b.', alpha=.1)\n", - "\n", - "ax.set_ylim(ylims)\n", - "#ax.set_xlim([0,15])\n", - "#ax2.hist(tab['i_cModelFlux']-(tab['i_bdE1']*tab['i_bdFluxB']+tab['i_bdE2']*tab['i_bdFluxD']),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 400),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist(tab['i_cModelFlux']-(tab['i_bdFluxB']),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 400),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist(tab['i_cModelFlux']-(tab['i_bdFluxD']),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 400),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "\n", - "plt.show()\n", - "\n", - "x = np.arange(0,1e6,1)\n", - "plt.plot(x,x)\n", - "plt.plot(tab['i_cModelFlux'], (tab['i_bdFluxD']),'.',alpha=.1,zorder=10)\n", - "plt.show()\n", - "# Why isnt' flux from bulge + flux from disk = flux from cmodel? Should there be a FracDev value that #\n", - "# scales the relative contribution of bulge and disk?\n", - "# cmodel flux is Fcomposite = fracDeV FdeV + (1 - fracDeV) Fexp where Fexp is FluxD and FdeV is FluxB" - ] - }, { "cell_type": "markdown", "id": "52267cd8-1041-4e09-bda1-248468b21971", From a91250d9eb3f28649fece1bd83da4dcb29799334 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 7 Feb 2025 18:55:57 +0000 Subject: [PATCH 75/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 43 ++++++++++++++++++--------------- 1 file changed, 24 insertions(+), 19 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 5932d50..d65ba00 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -552,7 +552,7 @@ "source": [ "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, \" + \\\n", + " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, obj.i_ap03Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux,\" + \\\n", " \"obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \" + \\\n", @@ -890,7 +890,25 @@ "metadata": {}, "outputs": [], "source": [ - "sys.exit()" + "rad = np.array([3,6,9,12,17,25,35,50]) * 0.2 # convert pix to arcsec\n", + "surf_area = np.pi * rad**2\n", + "light_profile = np.array([tab['i_ap03Flux'][wh][0],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][0],tab['i_ap12Flux'][wh][0],tab['i_ap17Flux'][wh][0],\n", + " tab['i_ap25Flux'][wh][0],tab['i_ap35Flux'][wh][0],tab['i_ap50Flux'][wh][0]])/surf_area\n", + "\n", + "plt.plot(rad, light_profile, label='Large Radius R='+str(tab['i_kronRad'][wh][0]))\n", + "plt.xlabel('Aperture Radius [pixels]')\n", + "plt.ylabel('Flux density [nJy]')\n", + "\n", + "sys.exit()\n", + "# pick an object that has large size\n", + "wh = np.where(tab['i_kronRad'] < 5)[0]\n", + "#print(len(wh), tab['i_kronRad'][wh])\n", + "indx = 10\n", + "rad = np.array([3,6,9,12,17,25,35,50])\n", + "light_profile = np.array([tab['i_ap03Flux'][wh][indx],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][indx],tab['i_ap12Flux'][wh][indx],tab['i_ap17Flux'][wh][indx],\n", + " tab['i_ap25Flux'][wh][indx],tab['i_ap35Flux'][wh][indx],tab['i_ap50Flux'][wh][indx]])\n", + "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh][indx]))\n", + "plt.legend()" ] }, { @@ -915,7 +933,9 @@ "id": "a9fbb040-3d5a-4af7-93fd-5038c28e49a8", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "sys.exit()" + ] }, { "cell_type": "code", @@ -1628,22 +1648,7 @@ "wh = np.where(tab['i_kronRad'] > 10)[0]\n", "#print(len(wh), tab['i_kronRad'][wh])\n", "\n", - "rad = np.array([3,6,9,12,17,25,35,50])\n", - "light_profile = np.array([tab['i_ap03Flux'][wh][0],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][0],tab['i_ap12Flux'][wh][0],tab['i_ap17Flux'][wh][0],\n", - " tab['i_ap25Flux'][wh][0],tab['i_ap35Flux'][wh][0],tab['i_ap50Flux'][wh][0]])\n", - "plt.plot(rad, light_profile, label='Large Radius R='+str(tab['i_kronRad'][wh][0]))\n", - "plt.xlabel('Aperture Radius [pixels]')\n", - "plt.ylabel('Flux density [nJy]')\n", - "\n", - "# pick an object that has large size\n", - "wh = np.where(tab['i_kronRad'] < 5)[0]\n", - "#print(len(wh), tab['i_kronRad'][wh])\n", - "indx = 10\n", - "rad = np.array([3,6,9,12,17,25,35,50])\n", - "light_profile = np.array([tab['i_ap03Flux'][wh][indx],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][indx],tab['i_ap12Flux'][wh][indx],tab['i_ap17Flux'][wh][indx],\n", - " tab['i_ap25Flux'][wh][indx],tab['i_ap35Flux'][wh][indx],tab['i_ap50Flux'][wh][indx]])\n", - "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh][indx]))\n", - "plt.legend()\n" + "\n" ] }, { From 14633760f0d107452164bb946b1efd5d1e495cdd Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 7 Feb 2025 23:06:45 +0000 Subject: [PATCH 76/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index d65ba00..281e89a 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -552,9 +552,9 @@ "source": [ "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, obj.i_ap03Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux,\" + \\\n", + " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, \" + \\\n", " \"obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux \" + \\\n", - " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", + " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \" + \\\n", " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"\n", From 919d60e67bcde69886d06b8a63017dbbd1b57417 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 7 Feb 2025 23:34:27 +0000 Subject: [PATCH 77/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 281e89a..0b59b7e 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -551,14 +551,24 @@ "outputs": [], "source": [ "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", - " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, \" + \\\n", - " \"obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux \" + \\\n", + " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \" + \\\n", " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"\n", - "\n" + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47c44596-7785-4311-a9b8-b98d15269a3f", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT coord_ra, coord_dec \" + \\\n", + " \"FROM dp02_dc2_catalogs.Object \" + \\\n", + " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"" ] }, { From 9425f439f6a08c6abe56541c2e1cae6422efd0a4 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Sat, 8 Feb 2025 01:00:54 +0000 Subject: [PATCH 78/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 914 +------------------------------- 1 file changed, 10 insertions(+), 904 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 0b59b7e..f13a298 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -552,25 +552,13 @@ "source": [ "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux \" + \\\n", + " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap03Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \" + \\\n", " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "47c44596-7785-4311-a9b8-b98d15269a3f", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT coord_ra, coord_dec \" + \\\n", - " \"FROM dp02_dc2_catalogs.Object \" + \\\n", - " \"WHERE CONTAINS(POINT('ICRS', coord_ra, coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"" - ] - }, { "cell_type": "code", "execution_count": null, @@ -834,13 +822,13 @@ "extent = (anchor_image.getBBox().beginX, anchor_image.getBBox().endX,\n", " anchor_image.getBBox().beginY, anchor_image.getBBox().endY)\n", "\n", - "plt.imshow(anchor_image.image.array, vmin=.1, vmax=10, \n", + "plt.imshow(anchor_image.image.array, vmin=.1, vmax=1, \n", " extent=extent,\n", " origin='lower', cmap='gray')\n", "\n", "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree, dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", "\n", - "aperture = SkyCircularAperture(coord, r=9*.2* u.arcsec)\n", + "aperture = SkyCircularAperture(coord, r=17*.2* u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", "pix_aperture.plot(color='r', lw=3)\n", "\n", @@ -905,16 +893,16 @@ "light_profile = np.array([tab['i_ap03Flux'][wh][0],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][0],tab['i_ap12Flux'][wh][0],tab['i_ap17Flux'][wh][0],\n", " tab['i_ap25Flux'][wh][0],tab['i_ap35Flux'][wh][0],tab['i_ap50Flux'][wh][0]])/surf_area\n", "\n", - "plt.plot(rad, light_profile, label='Large Radius R='+str(tab['i_kronRad'][wh][0]))\n", - "plt.xlabel('Aperture Radius [pixels]')\n", - "plt.ylabel('Flux density [nJy]')\n", + "plt.plot(rad, light_profile, label='Kron Radius R='+str(tab['i_kronRad'][wh][0]))\n", + "plt.xlabel('Aperture Radius [arcsec]')\n", + "plt.ylabel(r'Surface Brightness [nJy arcsec$^{-2}$]')\n", "\n", - "sys.exit()\n", + "#sys.exit()\n", "# pick an object that has large size\n", - "wh = np.where(tab['i_kronRad'] < 5)[0]\n", + "wh = np.where((tab['i_kronRad'] < 8) & (tab['i_kronRad'] > 5))[0]\n", "#print(len(wh), tab['i_kronRad'][wh])\n", - "indx = 10\n", - "rad = np.array([3,6,9,12,17,25,35,50])\n", + "indx = 1\n", + "\n", "light_profile = np.array([tab['i_ap03Flux'][wh][indx],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][indx],tab['i_ap12Flux'][wh][indx],tab['i_ap17Flux'][wh][indx],\n", " tab['i_ap25Flux'][wh][indx],tab['i_ap35Flux'][wh][indx],tab['i_ap50Flux'][wh][indx]])\n", "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh][indx]))\n", @@ -1003,888 +991,6 @@ " OLD STUFF BELOW: (see notes from Melissa 1/14 at the end for the plan)" ] }, - { - "cell_type": "markdown", - "id": "ff2fc2b3-fb3b-4d92-a325-ace4dfa059dc", - "metadata": {}, - "source": [ - "### 2.3 Compare (total) simulated photometry measured with the LSST pipelines to their input values\n", - "\n", - "The following cells will query the truth tables to get the input fluxes in the DP0.2 simulated objects, matched to those measured from the simulated images using the LSST pipelines. This comparison provides a sense of how good the various photometry measurement methods are by comparing input flux to measured flux. This provides some insight into what regimes they may perform well vs poorly.\n", - "\n", - "The below cells query the truth values for i-band mag, measured i-band mag values from the catalog, and a number of flags that are relevant to the quality of the galaxy photometric measurements. Specifically, request `fromBlend`, `detect_isIsolated`, and `i_blendedness` which will indicate how much blending may have occurred, how large the galaxies are, to help provide insight in cases of catastrophic outliers.\n", - "\n", - "Further, to ensure good measurements, restrict to objects which are detected at S/N > 5 and where `detect_isPrimary` is true, to ensure unique objects are returned (for more information on the use of the `detect_isPrimary` flag, see <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_10_Deblender_Data_Products.html\">Tutorial Notebook 10</a> about deblender data products. Also, set the condition that `i_extendedness` = 1 in order to return a population of galaxies (i.e. remove stars as point sources). To expedite the search we will limit to a 0.1 degree region on the sky." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0d28a6ad-4436-410c-9b9d-e995140be304", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", - " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", - " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_gaapOptimalFlux \" + \\\n", - " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", - " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", - " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1b10f993-c750-49a3-82c0-1c5a5112884a", - "metadata": {}, - "outputs": [], - "source": [ - "job = service.submit_job(query)\n", - "job.run()\n", - "job.wait(phases=['COMPLETED', 'ERROR'])\n", - "print('Job phase is', job.phase)" - ] - }, - { - "cell_type": "markdown", - "id": "80ebe401-5124-40f1-8806-fa86850c75f4", - "metadata": {}, - "source": [ - "Print the results of the search query." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6b0938c2-0724-459c-b560-56e0b4f2a330", - "metadata": {}, - "outputs": [], - "source": [ - "results = job.fetch_result()\n", - "print(len(results))\n", - "tab = results.to_table()\n", - "tab" - ] - }, - { - "cell_type": "markdown", - "id": "1d22c355-0953-46e7-8e40-6614f088c607", - "metadata": {}, - "source": [ - "### 2.4 Exploring the input vs output photometry\n", - "\n", - "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", - "\n", - "First, store the AB magnitudes to go with the fluxes extracted from the objectTable." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7a8000f6-a914-4073-8130-67d912f52b09", - "metadata": {}, - "outputs": [], - "source": [ - "truth_mag = -2.50 * np.log10(tab['flux_i']) + 31.4\n", - "\n", - "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" - ] - }, - { - "cell_type": "markdown", - "id": "4f28e9cf-fd39-4281-8c56-e4f1040475df", - "metadata": {}, - "source": [ - "The next cell will compare the percent difference between the three different photometric measurements with the input (truth). Additionally a running median is calculated to help interpret the typical accuracy of the different methods. The median has the best overall percent accuracy for cModel, which is has < 3.5% median deviation for all magnitudes < 24 ABmag. Additionally, the Gaussian and PSF photometry is highly inaccurate, as explained in Section 1.1 this is not meant to measure the total flux of galaxies, but rather to measure accurate colors using a sub-region of each galaxy. Deviation from truth for this measurement is thus expected." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "14124486-2f17-4fc2-8b17-ff62e91028e3", - "metadata": {}, - "outputs": [], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "ax.plot(truth_mag, (tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='cModel',color='r')\n", - "ax.plot(truth_mag, (tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag, (tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100,'.',alpha=.1, label='gaapOptimal',color='green')\n", - "\n", - "x = truth_mag\n", - "y = (tab['i_cModelFlux']-tab['flux_i'])/tab['flux_i'] *100\n", - "bins=np.arange(16,27,1)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "for i in range(len(bin_means)):\n", - " print(binctr[i],bin_means[i],'cModel')\n", - "\n", - "y = (tab['i_kronFlux']-tab['flux_i'])/tab['flux_i'] *100\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", - "for i in range(len(bin_means)):\n", - " print(binctr[i],bin_means[i],'kron')\n", - "\n", - "y = (tab['i_gaapOptimalFlux']-tab['flux_i'])/tab['flux_i'] * 100\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", - "\n", - "ax.axhline(0,linestyle='--')\n", - "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Flux Percent Accuracy (F$_{obs}$ - F$_{true}$) / F$_{true}$ x 100%')\n", - "ax.set_ylim([-100,100])\n", - "ax.set_xlim([14,27])\n", - "plt.legend()\n" - ] - }, - { - "cell_type": "markdown", - "id": "0d55a187-ccc9-4975-9868-a716e1106559", - "metadata": {}, - "source": [ - "Below, take a closer look at the differences in AB magnitude and how the overall distributions compare. While the systematic offset of GaaP is clear, the medians of Kron and cModel both compare well. These two plots indicate that there is excellent agreement between the cModel measurements and the input, at the level of < 0.03 magnitude at ABmag of < 25. Kron is also adequate overall, although at intermediate magnitudes (ABmag ~ 18-22) exhibits a slight underestimate of flux (overestimate in magnitude of order 0.1-0.2). \n", - "\n", - "Note that the input light profiles of simulated galaxies in DP0.2 are sersic profiles; thus it is perhaps not unexpected that modeling the light as sersic profiles by the LSST pipelines to produce cModel fluxes would perform the best." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8bbb1505-5e91-49d2-b94e-045ff9f482e2", - "metadata": {}, - "outputs": [], - "source": [ - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", - "ylims = [-1.2,1.2]\n", - "\n", - "ax.plot(truth_mag, (kron_mag-truth_mag),'.',alpha=.1,label='Kron',color='blue')\n", - "ax.plot(truth_mag, (gaap_mag-truth_mag),'.',alpha=.1, label='gaapOptimal',color='green')\n", - "ax.plot(truth_mag, (cmodel_mag-truth_mag),'.',alpha=.1,label='cModel',color='r')\n", - "\n", - "ax2.hist((kron_mag-truth_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist((gaap_mag-truth_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist((cmodel_mag-truth_mag),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.axhline(0,linestyle='--')\n", - "\n", - "x = truth_mag\n", - "y = (cmodel_mag-truth_mag)\n", - "\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "for i in range(len(bin_means)):\n", - " print(binctr[i],bin_means[i],'cModel')\n", - "\n", - " \n", - "y = (kron_mag-truth_mag)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", - "for i in range(len(bin_means)):\n", - " print(binctr[i],bin_means[i],'kron')\n", - "\n", - "y = (gaap_mag-truth_mag)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", - "\n", - "ax.axhline(0,linestyle='--')\n", - "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Magnitude difference (M$_{obs}$ - M$_{true}$)')\n", - "ax.set_xlim([14,27])\n", - "ax.set_ylim(ylims)\n", - "ax.legend()\n" - ] - }, - { - "cell_type": "markdown", - "id": "8a3c30b3-721e-4cbc-abfd-8d4c9b216de8", - "metadata": {}, - "source": [ - "The next cells will explore and compare the Kron magnitudes to truth under various circumstances. 2 basic paramters are set: extendedness = 1 means the source is a galaxy; kronFlag = 0 identifies galaxies for which there were no problems flagged in the Kron flux measurement. \n", - "\n", - "Test whether the following blending parameters indicate that blending contributes to the inaccurate measurement of the photometry:\n", - "\n", - "1) detect_fromBlend = 1 means some deblending happened prior to flux measurement. This is responsible for some under-estimated magnitude (over-estimated flux) perhaps because neighbors were not removed at the bright end?\n", - "\n", - "2) The increased scatter at faint magnitudes is due to increased fraction of flux contaminated by neighbors i_blendedness: (1 - child_flux/parent_flux)\n", - " \n", - "3) detect_isIsolated = 1 means no deblending and the galaxy has no blended neighbors. The upturn at bright mags is not there among isolated galaxies\n", - "\n", - "4) Not sure i understand the tail to negative flux difference (i.e. underestimated flux) at bright mags" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3f5073a8-7c3d-4361-92b7-e1fa05c5dcde", - "metadata": {}, - "outputs": [], - "source": [ - "# here add a second set of panels to try to understand the small bias at bright end of kron (is it kron radius-dependent? since its not deblending dependent?\n", - "\n", - "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", - "\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", - "\n", - "# color scale by blendedness, or by kron radius to see dependence\n", - "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", - "vmax = 0.2\n", - "colmaplabel='Fraction of flux contaminated by neighbors'\n", - "cmap = tab['i_kronRad'][whgood]\n", - "vmax = 12\n", - "colmaplabel='Kron Radius [pixels]'\n", - "\n", - "im = ax.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='fromBlend')\n", - "\n", - "ax.axhline(0,linestyle='--')\n", - "ax.set_title('Kron Photometry')\n", - "ax.set_xlabel('truth AB Magnitude [i-band]')\n", - "ax.set_ylabel('Mag Percent Accuracy (M$_{obs}$ - M$_{true}$) ')\n", - "ax.set_xlim([16,26])\n", - "ax.set_ylim([-1,1])\n", - "ax.legend()\n", - "\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", - "\n", - "# color scale by blendedness, or by kron radius to see dependence\n", - "cmap = tab['i_blendedness'][whgood]\n", - "vmax = 0.2\n", - "colmaplabel='Fraction of flux contaminated by neighbors'\n", - "cmap = tab['i_kronRad'][whgood]\n", - "vmax = 12\n", - "colmaplabel='Kron Radius [pixels]'\n", - "\n", - "ax2.scatter(truth_mag[whgood],(kron_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='isIsolated')\n", - "print(len(whgood))\n", - "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", - "ax2.set_ylabel('Magnitude offset (M$_{obs}$ - M$_{true}$) ')\n", - "ax2.set_ylim([-1,1])\n", - "ax2.set_xlim([16,26])\n", - "ax2.legend()\n", - "ax2.axhline(0,linestyle='--')\n", - "ax2.set_title('Kron Photometry')\n", - "\n", - "fig.subplots_adjust(right=0.8)\n", - "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", - "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n" - ] - }, - { - "cell_type": "markdown", - "id": "947bfd05-2762-4525-bac4-83745a230999", - "metadata": {}, - "source": [ - "The above plots show that blending and contamination of flux by neighbors can result in inaccurate flux among the strong outliers, but does not cause the systematic overestimate in magnitude by Kron measurements at intermediate magnitudes. However, it is also the case that nearly none of these overestimated sources are isolated (they are blended with neibors). Large galaxy radius does increase with brightness but otherwise does not seem to give rise to the offset. (TBD: otherwise perhaps its the case that kron is not a good measure of multi-component light profiles, and the sum of 2 sersic models does a better job? Not sure how to test that. Andreon et al. 2002 says \"the 2MASS isophotal mag misses some 0.1 mag with respect the Kron–like mag listed in the 2MASS database, which in turn misses about 0.15 mag with respect the true Kron mag (because computed on a too small object region), which in turn misses 5 to 10% of the total flux.).\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6fdf7c38-0c80-4351-856d-8390d22ad375", - "metadata": {}, - "outputs": [], - "source": [ - "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", - "\n", - "whtest = np.where((truth_mag[whgood] < 20) & \n", - " ((kron_mag[whgood]-truth_mag[whgood]) > 0.15) & \n", - " ((kron_mag[whgood]-truth_mag[whgood]) < 0.25))[0]\n", - "\n", - "print(whtest)\n", - "for i in range(2):\n", - " ra = results['ra'][whgood][whtest][i]\n", - " dec = results['dec'][whgood][whtest][i]\n", - " coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree, frame='icrs')\n", - " radius = .1 * u.deg\n", - "\n", - " spherePoint = lsst.geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", - "\n", - " query = \"SELECT lsst_patch, lsst_tract, s_region, \" + \\\n", - " \"access_format, access_url, dataproduct_subtype \" + \\\n", - " \"FROM ivoa.ObsCore \" + \\\n", - " \"WHERE dataproduct_type = 'image' \" + \\\n", - " \"AND obs_collection = 'LSST.DP02' \" + \\\n", - " \"AND dataproduct_subtype = 'lsst.deepCoadd_calexp' \" + \\\n", - " \"AND lsst_band = 'i' \" + \\\n", - " \"AND CONTAINS(POINT('ICRS', \" + str(coord.ra.value) + \\\n", - " \", \" + str(coord.dec.value) + \"), \" + \\\n", - " \"s_region) = 1\"\n", - "\n", - " job = service.submit_job(query)\n", - " job.run()\n", - " job.wait(phases=['COMPLETED', 'ERROR'])\n", - " print('Job phase is', job.phase)\n", - " assert job.phase == 'COMPLETED'\n", - " results2 = job.fetch_result()\n", - " results2.to_table()\n", - "\n", - " tract = results2['lsst_tract'][0]\n", - " patch = results2['lsst_patch'][0]\n", - "\n", - " dataId = {'band': 'i', 'tract': tract,\n", - " 'patch': patch}\n", - "\n", - " print(dataId, ra, dec, patch, tract)\n", - " imtype = 'deepCoadd'\n", - " sodaCutout = make_image_cutout(service, ra, dec, dataId=dataId,\n", - " imtype=imtype, cutout_size=0.005)\n", - " plotImage(ExposureF(sodaCutout))\n", - "\n", - "sys.exit()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1e525f6f-5521-4a67-9abb-b96e4a198043", - "metadata": {}, - "outputs": [], - "source": [ - "# the following plots are identical, consider a different comparison that is informative\n", - "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(12,5))\n", - "\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0) & ( tab['detect_fromBlend'] == 1))[0]\n", - "\n", - "cmap = tab['i_blendedness'][whgood] #only saw things blended with 1 neighbor is this acutally boolean?\n", - "vmax = 0.2\n", - "colmaplabel='Fraction of flux contaminated by neighbors'\n", - "\n", - "#cmap = tab['i_kronRad'][whgood]\n", - "#vmax = 20\n", - "#colmaplabel='Kron Radius [pixels]'\n", - "\n", - "#ax.scatter(truth_mag,(cmodel_mag-truth_mag)/truth_mag,color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "im = ax.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='fromBlend')\n", - "\n", - "\n", - "ax.set_xlabel('truth AB Magnitude [i-band]')\n", - "ax.set_ylabel('Mag Fractional Accuracy (M$_{obs}$ - M$_{true}$) ')\n", - "ax.set_ylim([-1,1])\n", - "ax.set_xlim([16,26])\n", - "ax.axhline(0,linestyle='--')\n", - "ax.set_title('cModel Photometry')\n", - "ax.legend()\n", - "#cmap = tab['i_kronRad'][whgood] #tab['i_blendedness'][whgood] # #tab['i_blendedness'][whgood] #\n", - "whgood = np.where((tab['i_kronFlux_flag'] == 0) & (tab['i_extendedness'] == 1) & (tab['detect_isIsolated'] == 1) )[0]\n", - "cmap = tab['i_blendedness'][whgood]\n", - "\n", - "#ax2.scatter(truth_mag,(cmodel_mag-truth_mag),color='k', marker='.', alpha=.5)#,vmin=0,vmax=20)\n", - "ax2.scatter(truth_mag[whgood],(cmodel_mag[whgood]-truth_mag[whgood]),c=cmap, marker='.', alpha=.5,vmin=0,vmax=vmax,label='isIsolated')\n", - "ax2.set_xlabel('truth AB Magnitude [i-band]')\n", - "#ax2.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "#ax2.set_ylim([-1.5,1.5])\n", - "ax2.set_ylim([-1,1])\n", - "ax2.set_xlim([16,26])\n", - "ax2.axhline(0,linestyle='--')\n", - "print(len(whgood))\n", - "\n", - "fig.subplots_adjust(right=0.8)\n", - "cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", - "fig.colorbar(im, cax=cbar_ax,label=colmaplabel)\n", - "\n", - "ax2.set_title('cModel Photometry')\n", - "ax2.legend()" - ] - }, - { - "cell_type": "markdown", - "id": "b16c2ecf-c99e-4b30-8d0c-1655c1cb7f92", - "metadata": {}, - "source": [ - "### 2.5 Integrated photometry for high-redshift galaxies\n", - "\n", - "This section compares the photometry measurements for both low redshift and high redshift galaxies to see if one performs better for larger or smaller galaxies. In both cases it seems that while `kron` and `cModel` are both adequate, like the previous section, on average `cModel` has slightly better performance, in particular at bright magnitudes." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "09d48509-bf5d-4e1b-a136-2c0bb4c03084", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "zlim = 0.5\n", - "whz = np.where(results['redshift'] < zlim)[0]\n", - "whighz = np.where(results['redshift'] >= zlim)[0]\n", - "print(len(results['redshift']),len(whz),len(whighz))\n", - "\n", - "fig,(ax, ax2) = plt.subplots(1, 2,figsize=(10,5))\n", - "\n", - "ax.axhline(0,linestyle='--')\n", - "\n", - "ax.plot(truth_mag[whz], (kron_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='Kron',color='blue')\n", - "#ax.plot(truth_mag[whz], (gaap_mag[whz]-truth_mag[whz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", - "ax.plot(truth_mag[whz], (cmodel_mag[whz]-truth_mag[whz]),'.',alpha=.1,label='cModel',color='r')\n", - "\n", - "x = truth_mag[whz]\n", - "y = (cmodel_mag[whz]-truth_mag[whz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "\n", - "y = (kron_mag[whz]-truth_mag[whz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", - "\n", - "#y = (gaap_mag[whz]-truth_mag[whz])\n", - "#bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - "# y, statistic='median', bins=bins)\n", - "#binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "#ax.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", - "\n", - "ax.set_xlabel('True i-band Magnitude')\n", - "ax.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) ')\n", - "#ax.set_ylim([-.2,.2])\n", - "ax.set_xlim([16,26])\n", - "ax.set_title('Low redshift z<'+str(zlim))\n", - "ax.set_ylim([-1,1])\n", - "\n", - "ax2.axhline(0,linestyle='--')\n", - "\n", - "ax2.plot(truth_mag[whighz], (kron_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='Kron',color='blue')\n", - "#ax2.plot(truth_mag[whighz], (gaap_mag[whighz]-truth_mag[whighz]),'.',alpha=.1, label='gaapOptimal',color='green')\n", - "ax2.plot(truth_mag[whighz], (cmodel_mag[whighz]-truth_mag[whighz]),'.',alpha=.1,label='cModel',color='r')\n", - "\n", - "x = truth_mag[whighz]\n", - "y = (cmodel_mag[whighz]-truth_mag[whighz])\n", - "\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax2.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "\n", - "y = (kron_mag[whighz]-truth_mag[whighz])\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax2.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", - "\n", - "#y = (gaap_mag[whighz]-truth_mag[whighz])\n", - "#bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - "# y, statistic='median', bins=bins)\n", - "#binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "#ax2.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10,linestyle='--')#,color='green')\n", - "\n", - "ax2.set_xlabel('True i-band Magnitude')\n", - "ax2.set_ylim([-1,1])\n", - "ax2.set_xlim([16,26])\n", - "ax2.set_title('High redshift z>'+str(zlim))\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "id": "b6bc05d8-2f63-4b24-a123-4dd6620ac98a", - "metadata": {}, - "source": [ - "## 3. Photometry for colors\n", - "\n", - "Here we show observed vs intrinsic colors to demonstrate that GaaP is good for that. Except all 3 measurements are decent and actually cModel has hte least bias (reason, and purpose of GaaP is still TBD).\n", - "\n", - "First, query for the photometry in g and z bands (which will have a large difference in spatial resolution given their relatively large difference wavelengths). u and y band would have an even larger wavelength baseline for comparison, but g and z have better throughput and thus S/N are typically higher. Like earlier sections, also retrieve the truth table input fluxes as a baseline for assessing accuracy in color between the different measurements." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fd7e6ebb-f348-4df9-9859-9d4febb51238", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_g, ts.flux_z, ts.redshift, \"\\\n", - " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", - " \"obj.g_kronFlux, obj.g_kronFluxErr, obj.g_kronRad, obj.g_kronFlux_flag, obj.g_cModelFlux, obj.g_gaapOptimalFlux, \" + \\\n", - " \"obj.z_kronFlux, obj.z_kronFluxErr, obj.z_kronRad, obj.z_kronFlux_flag, obj.z_cModelFlux, obj.z_gaapOptimalFlux \" + \\\n", - " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", - " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", - " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.g_kronFlux/obj.g_kronFluxErr > 10) AND (obj.g_extendedness = 1) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "baec0660-1125-43de-9f21-cc5ccef958f0", - "metadata": {}, - "outputs": [], - "source": [ - "job = service.submit_job(query)\n", - "job.run()\n", - "job.wait(phases=['COMPLETED', 'ERROR'])\n", - "print('Job phase is', job.phase)\n", - "\n", - "results = job.fetch_result()\n", - "tab = results.to_table()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8d97291d-2043-40a6-859c-db391565a9da", - "metadata": {}, - "outputs": [], - "source": [ - "g_cmodel_mag = -2.50 * np.log10(tab['g_cModelFlux']) + 31.4\n", - "g_kron_mag = -2.50 * np.log10(tab['g_kronFlux']) + 31.4\n", - "g_gaap_mag = -2.50 * np.log10(tab['g_gaapOptimalFlux']) + 31.4\n", - "g_truth_mag = -2.50 * np.log10(tab['flux_g']) + 31.4\n", - "\n", - "z_cmodel_mag = -2.50 * np.log10(tab['z_cModelFlux']) + 31.4\n", - "z_kron_mag = -2.50 * np.log10(tab['z_kronFlux']) + 31.4\n", - "z_gaap_mag = -2.50 * np.log10(tab['z_gaapOptimalFlux']) + 31.4\n", - "z_truth_mag = -2.50 * np.log10(tab['flux_z']) + 31.4\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "59afd145-cc34-4671-82ac-616ba6f28882", - "metadata": {}, - "outputs": [], - "source": [ - "# very confused about why these colors line up so perfectly when the mags do not...\n", - "# maybe on the fainter end (S/N ~ 5) the colors differ more? Check.\n", - "\n", - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", - "ylims = [-0.2,0.2]\n", - "\n", - "truth_color = g_truth_mag - z_truth_mag\n", - "kron_color = g_kron_mag - z_kron_mag\n", - "cmodel_color = g_cmodel_mag - z_cmodel_mag\n", - "gaap_color = g_gaap_mag - z_gaap_mag\n", - "\n", - "ax.plot(z_kron_mag, kron_color-truth_color, '.',alpha=.5, label='Kron '+str(np.median(kron_color-truth_color)),color='b')\n", - "ax.plot(z_cmodel_mag, cmodel_color-truth_color, '.',alpha=.5, label='cModel '+str(np.median(cmodel_color-truth_color)),color='r')\n", - "ax.plot(z_gaap_mag, gaap_color-truth_color, '.',alpha=.5, label='GaaP optimal '+str(np.median(gaap_color-truth_color)),color='g')\n", - "\n", - "ax2.hist((kron_color-truth_color),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 80),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist((gaap_color-truth_color),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 80),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist((cmodel_color-truth_color),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 80),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.axhline(0,linestyle='--')\n", - "\n", - "\n", - "x = np.arange(-.1,6,.1)\n", - "#plt.plot(x,x,linestyle='--')\n", - "#plt.plot(x+.1,x+.1,linestyle='--')\n", - "#plt.plot(x-.1,x-.1,linestyle='--')\n", - "ylims = [-1,1]\n", - "ax.axhline(0)\n", - "ax.set_ylim(ylims)\n", - "ax.set_xlim([16,26])\n", - "ax.set_xlabel('Observed g-band Magnitude')\n", - "ax.set_ylabel('Observed g-z color - True g-z color')\n", - "#ax2.set_ylabel('Observed g-z color - True g-z color')\n", - "ax.legend()" - ] - }, - { - "cell_type": "markdown", - "id": "f00bea4c-b9cb-40e5-8e5d-23110210a3f3", - "metadata": {}, - "source": [ - "### 4. Photometry for light profiles (i.e. how to use aperture photometry)\n", - "Science application for aperture fluxes\n", - "Not sure how to do this yet" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8575a64b-f166-453b-aebd-dd09d728a259", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT mt.id_truth_type, mt.match_objectId, ts.ra, ts.dec, ts.truth_type, ts.flux_i, ts.redshift, \"\\\n", - " \"obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \"\\\n", - " \"obj.i_ap03Flux, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap12Flux, obj.i_ap17Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux, obj.i_kronRad, obj.i_kronFlux_flag \" + \\\n", - " \"FROM dp02_dc2_catalogs.MatchesTruth AS mt \"\\\n", - " \"JOIN dp02_dc2_catalogs.TruthSummary AS ts ON mt.id_truth_type = ts.id_truth_type \"\\\n", - " \"JOIN dp02_dc2_catalogs.Object AS obj ON mt.match_objectId = obj.objectId \"\\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_kronFlux/obj.i_kronFluxErr > 10) AND (obj.i_extendedness = 1) AND \"\\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS', 62.0, -37.0, 0.20)) = 1 \"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "24718446-033d-4b3d-b11f-a94c708c6d1e", - "metadata": {}, - "outputs": [], - "source": [ - "job = service.submit_job(query)\n", - "job.run()\n", - "job.wait(phases=['COMPLETED', 'ERROR'])\n", - "print('Job phase is', job.phase)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1ddc4e98-1151-4aba-806a-b9097d2edfd0", - "metadata": {}, - "outputs": [], - "source": [ - "results = job.fetch_result()\n", - "tab = results.to_table()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0b26042c-c234-4885-819b-a05dfba2bc31", - "metadata": {}, - "outputs": [], - "source": [ - "# pick an object that has large size\n", - "wh = np.where(tab['i_kronRad'] > 10)[0]\n", - "#print(len(wh), tab['i_kronRad'][wh])\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "12f5be0d-7816-4622-8523-aff5e6b9a028", - "metadata": {}, - "outputs": [], - "source": [ - "sys.exit()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "94c2ecc1-5760-4872-b01d-e6d48b145201", - "metadata": {}, - "outputs": [], - "source": [ - "#junk that doens't work yet:\n", - "\n", - "# now do the outlier fraction. histogram up the delta_M / M > 0.1 as function of magnitude for the 3\n", - "\n", - "x = truth_mag\n", - "y = (cmodel_mag-truth_mag)#/truth_mag\n", - "bins=np.arange(16,30,1)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic=lambda sigmaz: float(len(np.where(np.abs(y) > 0.01)[0]))/len(y) ,bins=bins)\n", - "\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "plt.plot(binctr, bin_means, color='red', lw=2, label='cModel bin median',zorder=10)\n", - "#plt.hist(bins[:-1],bins,weights=bin_means,color='r',alpha=.5,edgecolor='black', linewidth=1.2)\n", - "\n", - "y = (kron_mag-truth_mag)#/truth_mag\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic=lambda sigmaz: float(len(np.where(y > 0.01)[0]))/len(y) ,bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "#plt.plot(binctr, bin_means, color='blue', lw=2, label='kron bin median',zorder=10)\n", - "#plt.hist(bins[:-1],bins,weights=bin_means,color='b',alpha=.5,edgecolor='black', linewidth=1.2)\n", - "\n", - "y = (gaap_mag-truth_mag)#/truth_mag\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic=lambda sigmaz: float(len(np.where(y > 0.01)[0]))/len(y) ,bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "#plt.plot(binctr, bin_means, color='green', lw=2, label='GaaP Optimal bin median',zorder=10)#,color='green')\n", - "#plt.hist(bins[:-1],bins,weights=bin_means,color='g',alpha=.5,edgecolor='black', linewidth=1.2)\n", - "\n", - "#ax.scatter(truth_mag,kron_mag,c=tab['i_kronRad'], marker='+', alpha=.5)\n", - "\n", - "#plt.set_xlabel('True i-band Magnitude')\n", - "#plt.set_ylabel('Mag Accuracy (M$_{obs}$ - M$_{true}$) / M$_{true}$')\n", - "#ax.set_ylim([-5,5])\n", - "#plt.ylim([0,1000])\n", - "#ax.set_yscale('log')\n", - "plt.legend()\n", - "\n", - "\n", - "#bin_means, bin_edges, binnumber = stats.binned_statistic(F150mag,sigmaz, statistic=lambda sigmaz: float(len(np.where(sigmaz > 0.15)[0]))/len(sigmaz) ,bins=bins)\n", - "\n", - "print(bin_means)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "20443fe8-caa8-4f32-97a9-e19cc2ff8079", - "metadata": {}, - "outputs": [], - "source": [ - "# compare kron mag to cmodel mag\n", - "\n", - "#whbright = np.where(tab['i_kronFlux'] > 0.0001e6)[0]\n", - "whbright = np.where((tab['i_kronFlux'] > 0.01e6) & (tab['i_kronFlux_flag'] == 0))[0]\n", - "\n", - "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "\n", - "plt.scatter(cmodel_mag,kron_mag,\n", - " c=tab['i_kronRad'], marker='.', alpha=.5)\n", - "\n", - "#plt.scatter(cmodel_mag[whbright],kron_mag[whbright],\n", - "# c=tab['i_kronRad'][whbright], marker='.', alpha=.5)\n", - "plt.axhline(26.4,linestyle='--',label='10-yr 5sig depth')\n", - "\n", - "plt.colorbar(label='Kron Radius [pixels]')\n", - "plt.xlabel('cModel AB Magnitude [i-band]')\n", - "plt.ylabel('kron AB Magnitude [i-band]')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c80af7f5-a048-4169-b7e7-61fb479b6df8", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "cmodel_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "\n", - "plt.scatter(cmodel_mag,kron_mag,\n", - " c=tab['i_kronRad'], marker='.', alpha=.5, vmin=1, vmax=50)\n", - "\n", - "#plt.scatter(cmodel_mag[whbright],kron_mag[whbright],\n", - "# c=tab['i_kronRad'][whbright], marker='.', alpha=.5)\n", - "plt.axhline(26.4,linestyle='--',label='10-yr 5sig depth')\n", - "\n", - "plt.colorbar(label='Kron Radius [pixels]')\n", - "plt.xlabel('GaaP optimal AB Magnitude [i-band]')\n", - "plt.ylabel('kron AB Magnitude [i-band]')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6553101d-d9fa-45b5-9d68-6242bd9ae28d", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "#cmodel_mag = -2.50 * np.log10(tab['i_gaap1p5Flux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "\n", - "plt.scatter(cmodel_mag,kron_mag,\n", - " c=tab['i_kronRad'], marker='.', alpha=.5, vmin=1, vmax=50)\n", - "\n", - "#plt.scatter(cmodel_mag[whbright],kron_mag[whbright],\n", - "# c=tab['i_kronRad'][whbright], marker='.', alpha=.5)\n", - "plt.axhline(26.4,linestyle='--',label='10-yr 5sig depth')\n", - "\n", - "plt.colorbar(label='Kron Radius [pixels]')\n", - "plt.xlabel('GaaP AB Magnitude 1.5 aperture [i-band]')\n", - "plt.ylabel('kron AB Magnitude [i-band]')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ed161a44-81df-4b9e-9563-e7431e2dce89", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "whbright = np.where((tab['i_kronFlux'] > 0.001e6) & (tab['i_kronFlux_flag'] == 0))[0]\n", - "\n", - "mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "plt.scatter(mag[whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", - " c=tab['i_kronRad'][whbright], marker='o', alpha=.5, vmin=1, vmax=50)\n", - "plt.colorbar(label='Kron Radius [pixels]')\n", - "plt.axhline(1,linestyle='--')\n", - "plt.xlabel('Kron AB Magnitude [i-band]')\n", - "plt.yscale('log')\n", - "plt.ylabel('Kron flux / cModel Flux')\n", - "\n", - "\n", - "whbad = np.where( (np.abs(tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright]) > 2) & (mag[whbright] < 22))[0]\n", - "whblend = np.where( tab['detect_fromBlend'][whbright] == True)[0]\n", - "\n", - "print(tab['detect_fromBlend'][whbright][whbad])\n", - "plt.plot(mag[whbright][whblend],tab['i_kronFlux'][whbright][whblend]/tab['i_cModelFlux'][whbright][whblend],'k+')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4d35fa45-3cc2-47c3-8e47-a29d3c7ec440", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f5c9bc62-6bbd-4e5c-8603-519427970caf", - "metadata": {}, - "outputs": [], - "source": [ - "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_gaapOptimalFlux'][whbright],\n", - " c=mag[whbright], marker='o', alpha=.5)\n", - "plt.xlabel('Kron Radius [pix]')\n", - "plt.ylabel('Kron flux / GaaP Optimal Flux')\n", - "plt.colorbar(label='Kron Mag [ABmag]')\n", - "plt.xlim([0,50])\n", - "plt.ylim([-1,30])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c1487f21-af5c-48ee-9a7a-6cf0aa56185c", - "metadata": {}, - "outputs": [], - "source": [ - "plt.scatter(tab['i_kronRad'][whbright],tab['i_kronFlux'][whbright]/tab['i_cModelFlux'][whbright],\n", - " c=mag[whbright], marker='o', alpha=.5)\n", - "plt.xlabel('Kron Radius [pix]')\n", - "plt.ylabel('Kron flux / cModel Flux')\n", - "plt.colorbar(label='Kron Mag [ABmag]')\n", - "plt.xlim([0,50])\n", - "plt.ylim([-1,30])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "b7ec87d9-8f56-4974-a9c4-052af0fec039", - "metadata": {}, - "source": [ - "# 4. AGN and host photometry" - ] - }, - { - "cell_type": "markdown", - "id": "6cc1a4dc-5256-48f5-a4d1-8100458c058b", - "metadata": {}, - "source": [] - }, { "cell_type": "markdown", "id": "2e364b4b-7cfd-4bfd-af48-8f08e0af2481", From 69ee5aa810dbaf246777af723cf78677ef56248f Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Sat, 8 Feb 2025 22:25:12 +0000 Subject: [PATCH 79/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 82 +++++++++++++++++---------------- 1 file changed, 43 insertions(+), 39 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index f13a298..028746a 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -7,7 +7,7 @@ "tags": [] }, "source": [ - "# DP0.2 Notebook 16 Galaxy Photometry\n", + "# DP0.2 Notebook 17 Galaxy Photometry\n", "\n", "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", "<br>\n", @@ -25,10 +25,10 @@ "metadata": {}, "outputs": [], "source": [ - "#%load_ext pycodestyle_magic\n", - "#%flake8_on\n", - "#import logging\n", - "#logging.getLogger(\"flake8\").setLevel(logging.FATAL)" + "%load_ext pycodestyle_magic\n", + "%flake8_on\n", + "import logging\n", + "logging.getLogger(\"flake8\").setLevel(logging.FATAL)" ] }, { @@ -232,34 +232,22 @@ "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", - "#from astropy.wcs import WCS\n", - "#from astropy.visualization import make_lupton_rgb\n", - "from astropy import units as u\n", - "from astropy.coordinates import SkyCoord\n", "import gc\n", "import numpy as np\n", "import sys\n", "\n", - "#import lsst.afw.display as afwDisplay\n", - "#from lsst.afw.image import MultibandExposure\n", - "#from lsst.daf.butler import Butler\n", - "from lsst.rsp import get_tap_service\n", - "#import lsst.geom as geom\n", "\n", - "from scipy import stats#.binned_statistic\n", + "from scipy import stats\n", "from scipy.stats import sigmaclip\n", "\n", - "# stuff for cutout\n", - "import time\n", - "import numpy as np\n", + "#import time\n", "import uuid\n", "import os\n", "import glob\n", - "import math\n", - "import pandas\n", - "import matplotlib.pyplot as plt\n", - "from PIL import Image\n", - "from IPython.display import Image as dimg\n", + "#import math\n", + "#import pandas\n", + "#from PIL import Image\n", + "#from IPython.display import Image as dimg\n", "\n", "import lsst.geom as geom\n", "import lsst.resources\n", @@ -512,7 +500,6 @@ "metadata": {}, "outputs": [], "source": [ - "#search_string = 'Flux'\n", "search_string = 'Flux'\n", "band = 'i_'\n", "for cname in results['column_name']:\n", @@ -550,13 +537,22 @@ "metadata": {}, "outputs": [], "source": [ - "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, obj.detect_fromBlend, obj.detect_isIsolated, obj.i_blendedness_flag, obj.i_blendedness, obj.i_extendedness, \" + \\\n", - " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, obj.i_kronFlux_flag, obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, obj.i_ap12Flux, obj.i_ap17Flux, obj.i_cModel_flag, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap03Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux \" + \\\n", + "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, \" + \\\n", + " \"obj.detect_fromBlend, obj.detect_isIsolated, \" + \\\n", + " \"obj.i_blendedness, obj.i_extendedness, \" + \\\n", + " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, \" + \\\n", + " \"obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.i_kronFlux_flag, obj.i_cModel_flag, \" + \\\n", + " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, \" + \\\n", + " \"obj.i_ap03Flux, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap12Flux, \" + \\\n", + " \"obj.i_ap17Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND (obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND (obj.i_extendedness = 1) AND \" + \\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND \" + \\\n", + " \"(obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND \" + \\\n", + " \"(obj.i_extendedness = 1) AND \" + \\\n", " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"" + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), \" + \\\n", + " \"CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"" ] }, { @@ -832,6 +828,10 @@ "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", "pix_aperture.plot(color='r', lw=3)\n", "\n", + "aperture = SkyCircularAperture(coord, r=35*.2* u.arcsec)\n", + "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='g', lw=3)\n", + "\n", "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec, 2.5 * semi_min_rad * 0.2 * u.arcsec, theta = (np.pi/2 + theta) * u.rad)\n", "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", "pix_aperture.plot(color='b', lw=3)" @@ -888,25 +888,29 @@ "metadata": {}, "outputs": [], "source": [ + "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]# & (tab['detect_isIsolated'] == True))[0]\n", + "\n", + "indx = 2\n", + "\n", "rad = np.array([3,6,9,12,17,25,35,50]) * 0.2 # convert pix to arcsec\n", "surf_area = np.pi * rad**2\n", - "light_profile = np.array([tab['i_ap03Flux'][wh][0],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][0],tab['i_ap12Flux'][wh][0],tab['i_ap17Flux'][wh][0],\n", - " tab['i_ap25Flux'][wh][0],tab['i_ap35Flux'][wh][0],tab['i_ap50Flux'][wh][0]])/surf_area\n", + "light_profile = np.array([tab['i_ap03Flux'][wh][indx],tab['i_ap06Flux'][wh][indx],tab['i_ap09Flux'][wh][indx],tab['i_ap12Flux'][wh][indx],tab['i_ap17Flux'][wh][indx],\n", + " tab['i_ap25Flux'][wh][indx],tab['i_ap35Flux'][wh][indx],tab['i_ap50Flux'][wh][indx]])/surf_area\n", "\n", - "plt.plot(rad, light_profile, label='Kron Radius R='+str(tab['i_kronRad'][wh][0]))\n", + "plt.plot(rad, light_profile, label='Kron Radius R='+str(tab['i_kronRad'][wh][indx]*.2))\n", "plt.xlabel('Aperture Radius [arcsec]')\n", "plt.ylabel(r'Surface Brightness [nJy arcsec$^{-2}$]')\n", "\n", - "#sys.exit()\n", "# pick an object that has large size\n", - "wh = np.where((tab['i_kronRad'] < 8) & (tab['i_kronRad'] > 5))[0]\n", - "#print(len(wh), tab['i_kronRad'][wh])\n", + "wh2 = np.where((tab['i_kronRad'] < 8) & (tab['i_kronRad'] > 5))[0]\n", + "\n", "indx = 1\n", "\n", - "light_profile = np.array([tab['i_ap03Flux'][wh][indx],tab['i_ap06Flux'][wh][0],tab['i_ap09Flux'][wh][indx],tab['i_ap12Flux'][wh][indx],tab['i_ap17Flux'][wh][indx],\n", - " tab['i_ap25Flux'][wh][indx],tab['i_ap35Flux'][wh][indx],tab['i_ap50Flux'][wh][indx]])\n", - "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh][indx]))\n", - "plt.legend()" + "light_profile = np.array([tab['i_ap03Flux'][wh2][indx],tab['i_ap06Flux'][wh2][indx],tab['i_ap09Flux'][wh2][indx],tab['i_ap12Flux'][wh2][indx],tab['i_ap17Flux'][wh2][indx],\n", + " tab['i_ap25Flux'][wh2][indx],tab['i_ap35Flux'][wh2][indx],tab['i_ap50Flux'][wh2][indx]])/surf_area\n", + "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh2][indx]*.2))\n", + "plt.legend()\n", + "plt.yscale('log')" ] }, { From 4d8d9231719aea3927fa50a9d20d635577e30551 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Sat, 8 Feb 2025 22:53:08 +0000 Subject: [PATCH 80/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 273 ++++++++++++++++---------------- 1 file changed, 138 insertions(+), 135 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index 028746a..db9ada9 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -236,18 +236,12 @@ "import numpy as np\n", "import sys\n", "\n", + "from scipy.stats import binned_statistic, sigmaclip\n", + "#from scipy.stats import sigmaclip\n", "\n", - "from scipy import stats\n", - "from scipy.stats import sigmaclip\n", - "\n", - "#import time\n", "import uuid\n", "import os\n", "import glob\n", - "#import math\n", - "#import pandas\n", - "#from PIL import Image\n", - "#from IPython.display import Image as dimg\n", "\n", "import lsst.geom as geom\n", "import lsst.resources\n", @@ -289,7 +283,6 @@ "outputs": [], "source": [ "plt.style.use('tableau-colorblind10')\n", - "#afwDisplay.setDefaultBackend('matplotlib')\n", "afwDisplay.setDefaultBackend('matplotlib')\n", "\n", "params = {'axes.labelsize': 18,\n", @@ -638,73 +631,96 @@ "metadata": {}, "outputs": [], "source": [ - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", - "ylims = [-1.5,1.5]\n", - "\n", - "ax.plot(i_kronRad, (cmodel_mag-ap17_mag),'.',alpha=.1, label='cModel - 17-pix aperture',color='blue')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel 12-pix aperture',color='green')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap09_mag),'.',alpha=.1,label='cModel 9-pix aperture',color='orange')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap06_mag),'.',alpha=.1,label='cModel 6-pix aperture',color='red')\n", - "\n", - "ax2.hist((cmodel_mag-ap17_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist((cmodel_mag-ap12_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist((cmodel_mag-ap09_mag),edgecolor='orange',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist((cmodel_mag-ap06_mag),edgecolor='red',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1,\n", + " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "\n", + "ylims = [-1.5, 1.5]\n", + "\n", + "ax.plot(i_kronRad, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", + " label='cModel - 17-pix aperture', color='blue')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", + " label='cModel 12-pix aperture', color='green')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", + " label='cModel 9-pix aperture', color='orange')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", + " label='cModel 6-pix aperture', color='red')\n", + "\n", + "ax2.hist((cmodel_mag-ap17_mag), edgecolor='blue', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "ax2.hist((cmodel_mag-ap12_mag), edgecolor='green', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "ax2.hist((cmodel_mag-ap09_mag), edgecolor='orange', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "ax2.hist((cmodel_mag-ap06_mag), edgecolor='red', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", "\n", "ax2.set_ylim(ylims)\n", - "ax.axhline(0,linestyle='--')\n", + "ax.axhline(0, linestyle='--')\n", "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", "ax.set_ylabel('cModel mag - Aperture mag')\n", "ax.set_ylim(ylims)\n", - "ax.set_xlim([0,15])\n", - "ax.legend()\n", - "\n", + "ax.set_xlim([0, 15])\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "709a40cf-df65-42ff-8a30-c787bcd79499", + "metadata": {}, + "outputs": [], + "source": [ "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", - "ylims = [-1.2,1.2]\n", - "bins=np.arange(16,27,1)\n", + "ylims = [-1.2, 1.2]\n", + "bins = np.arange(16, 27, 1)\n", "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap06_mag),'.',alpha=.1,label='cModel 6-pix aperture',color='red')\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", + " label='cModel 6-pix aperture', color='red')\n", "x = cmodel_mag\n", "y = (cmodel_mag-ap06_mag)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='red', lw=2, label='bin median',zorder=10)\n", - "\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='red', lw=2, label='bin median', zorder=10)\n", "\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap09_mag),'.',alpha=.1,label='cModel 9-pix aperture',color='orange')\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", + " label='cModel 9-pix aperture', color='orange')\n", "x = cmodel_mag\n", "y = (cmodel_mag-ap09_mag)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='orange', lw=2, label='bin median',zorder=10)\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag),'.',alpha=.1,label='cModel 12-pix aperture',color='green')\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='orange', lw=2,\n", + " label='bin median', zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", + " label='cModel 12-pix aperture', color='green')\n", "x = cmodel_mag\n", "y = (cmodel_mag-ap12_mag)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='green', lw=2, label='bin median',zorder=10)\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap17_mag),'.',alpha=.1,label='cModel 17-pix aperture',color='blue')\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='green', lw=2,\n", + " label='bin median', zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", + " label='cModel 17-pix aperture', color='blue')\n", "x = cmodel_mag\n", "y = (cmodel_mag-ap17_mag)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='blue', lw=2, label='bin median',zorder=10)\n", - "\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='blue', lw=2,\n", + " label='bin median', zorder=10)\n", "\n", - "\n", - "\n", - "ax.axhline(0,linestyle='--')\n", + "ax.axhline(0, linestyle='--')\n", "ax.set_xlabel('cModel Magnitude')\n", "ax.set_ylabel('cModel mag - Aperture mag')\n", - "ax.set_ylim([-1,1])\n", - "#ax.set_xlim([2,15])\n", + "ax.set_ylim([-1, 1])\n", "ax.legend()\n" ] }, @@ -728,46 +744,65 @@ "metadata": {}, "outputs": [], "source": [ - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1, width_ratios=[0.8, 0.2], figsize=(10, 6))\n", - "ylims = [-2,2]\n", - "\n", - "ax.plot(i_kronRad, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", - "ax.plot(i_kronRad, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", - "\n", - "ax2.hist((cmodel_mag-kron_mag),edgecolor='blue',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", - "ax2.hist((cmodel_mag-gaap_mag),edgecolor='green',orientation=\"horizontal\", bins=np.linspace(ylims[0], ylims[1], 40),align='mid',histtype=\"step\",stacked=True,fill=False)\n", + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1,\n", + " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "ylims = [-2, 2]\n", + "\n", + "ax.plot(i_kronRad, (cmodel_mag-kron_mag), '.', alpha=.1,\n", + " label='cModel-Kron', color='blue')\n", + "ax.plot(i_kronRad, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", + " label='cModel - gaapOptimal', color='green')\n", + "\n", + "ax2.hist((cmodel_mag-kron_mag), edgecolor='blue', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "ax2.hist((cmodel_mag-gaap_mag), edgecolor='green', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", "\n", "ax2.set_ylim(ylims)\n", - "ax.axhline(0,linestyle='--')\n", + "ax.axhline(0, linestyle='--')\n", "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", "ax.set_ylabel('cModel mag - Other mag')\n", "ax.set_ylim(ylims)\n", - "ax.set_xlim([0,15])\n", + "ax.set_xlim([0, 15])\n", "ax.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4539933a-3cf9-46e7-b39a-60101ff97b2a", + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", + "ylims = [-1.2, 1.2]\n", "\n", - "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", - "ylims = [-1.2,1.2]\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-kron_mag),'.',alpha=.1,label='cModel-Kron',color='blue')\n", + "ax.plot(cmodel_mag, (cmodel_mag-kron_mag), '.', alpha=.1,\n", + " label='cModel-Kron', color='blue')\n", "x = cmodel_mag\n", "y = (cmodel_mag-kron_mag)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='blue', lw=2, label='bin median',zorder=10)\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='blue', lw=2, label='bin median', zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", + " label='cModel - gaapOptimal', color='green')\n", "\n", - "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag),'.',alpha=.1, label='cModel - gaapOptimal',color='green')\n", "x = cmodel_mag\n", "y = (cmodel_mag-gaap_mag)\n", - "bin_means, bin_edges, binnumber = stats.binned_statistic(x,\n", - " y, statistic='median', bins=bins)\n", - "binctr = bin_edges[:-1] + (bin_edges[1:]-bin_edges[:-1])/2\n", - "ax.plot(binctr, bin_means, color='green', lw=2, label='bin median',zorder=10)\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='green', lw=2, label='bin median', zorder=10)\n", "\n", - "ax.axhline(0,linestyle='--')\n", + "ax.axhline(0, linestyle='--')\n", "ax.set_xlabel('cModel Magnitude')\n", "ax.set_ylabel('cModel mag - Other mag')\n", - "ax.set_ylim([-1,1])\n", + "ax.set_ylim([-1, 1])\n", "ax.legend()" ] }, @@ -799,78 +834,46 @@ "outputs": [], "source": [ "# pick an object that has large size\n", - "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]# & (tab['detect_isIsolated'] == True))[0]\n", - "\n", - "indx = 2\n", + "#wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]# & (tab['detect_isIsolated'] == True))[0]\n", + "wh = np.where((tab['objectId'] == 1909948454470183768))[0]\n", + "indx = 0\n", "print(\"id = \",tab['objectId'][wh][indx])\n", - "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx], tab['coord_dec'][wh][indx], cutout_size=0.005)\n", + "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx],\n", + " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", "\n", - "anchor_image = ExposureF(mem)\n", + "cutout = ExposureF(mem)\n", "\n", "axes = lsst.afw.geom.ellipses.Axes(lsst.afw.geom.ellipses.Quadrupole(tab['shape_xx'][wh][indx], tab['shape_yy'][wh][indx], tab['shape_xy'][wh][indx]))\n", "semi_maj_rad = axes.getA()\n", "semi_min_rad = axes.getB()\n", "theta = axes.getTheta()\n", "\n", - "print(semi_maj_rad, semi_min_rad, theta )\n", + "print(tab['i_kronRad'][wh][indx],semi_maj_rad, semi_min_rad, theta)\n", "\n", - "plt.subplot(projection=WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "extent = (anchor_image.getBBox().beginX, anchor_image.getBBox().endX,\n", - " anchor_image.getBBox().beginY, anchor_image.getBBox().endY)\n", + "plt.subplot(projection=WCS(cutout.getWcs().getFitsMetadata()))\n", + "extent = (cutout.getBBox().beginX, cutout.getBBox().endX,\n", + " cutout.getBBox().beginY, cutout.getBBox().endY)\n", "\n", - "plt.imshow(anchor_image.image.array, vmin=.1, vmax=1, \n", - " extent=extent,\n", - " origin='lower', cmap='gray')\n", + "plt.imshow(cutout.image.array, vmin=.1, vmax=1, \n", + " extent=extent, origin='lower', cmap='gray')\n", "\n", - "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree, dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", + "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree,\n", + " dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", "\n", "aperture = SkyCircularAperture(coord, r=17*.2* u.arcsec)\n", - "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", "pix_aperture.plot(color='r', lw=3)\n", "\n", "aperture = SkyCircularAperture(coord, r=35*.2* u.arcsec)\n", - "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", + "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", "pix_aperture.plot(color='g', lw=3)\n", "\n", - "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec, 2.5 * semi_min_rad * 0.2 * u.arcsec, theta = (np.pi/2 + theta) * u.rad)\n", - "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='b', lw=3)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b2e7d9eb-e669-4888-a67a-981640ab6c98", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "plt.subplot(projection=WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "extent = (anchor_image.getBBox().beginX, anchor_image.getBBox().endX,\n", - " anchor_image.getBBox().beginY, anchor_image.getBBox().endY)\n", - "\n", - "plt.imshow(anchor_image.image.array, vmin=.1, vmax=10, \n", - " extent=extent,\n", - " origin='lower', cmap='gray')\n", - "\n", - "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree, dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", + "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec,\n", + " 2.5 * semi_min_rad * 0.2 * u.arcsec,\n", + " theta=(np.pi/2 + theta) * u.rad)\n", "\n", - "aperture = SkyCircularAperture(coord, r=6*.2* u.arcsec)\n", - "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='r', lw=3)\n", - "\n", - "aperture = SkyCircularAperture(coord, r=9*.2* u.arcsec)\n", - "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='orange', lw=3)\n", - "\n", - "aperture = SkyCircularAperture(coord, r=12*.2* u.arcsec)\n", - "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='green', lw=3)\n", - "\n", - "aperture = SkyCircularAperture(coord, r=17*.2* u.arcsec)\n", - "pix_aperture = aperture.to_pixel(WCS(anchor_image.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='blue', lw=3)\n", - "\n" + "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='b', lw=3)" ] }, { From 67ad3d8cf0cdd6ce6abc600d8ae3a16f341e7b91 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Sat, 8 Feb 2025 23:07:52 +0000 Subject: [PATCH 81/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 107 ++++++++------------------------ 1 file changed, 26 insertions(+), 81 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index db9ada9..e56c376 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -854,7 +854,7 @@ "extent = (cutout.getBBox().beginX, cutout.getBBox().endX,\n", " cutout.getBBox().beginY, cutout.getBBox().endY)\n", "\n", - "plt.imshow(cutout.image.array, vmin=.1, vmax=1, \n", + "plt.imshow(cutout.image.array, vmin=.1, vmax=5, \n", " extent=extent, origin='lower', cmap='gray')\n", "\n", "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree,\n", @@ -862,18 +862,19 @@ "\n", "aperture = SkyCircularAperture(coord, r=17*.2* u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='r', lw=3)\n", + "pix_aperture.plot(color='r', lw=3, label='17 pix aperture')\n", "\n", "aperture = SkyCircularAperture(coord, r=35*.2* u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='g', lw=3)\n", + "pix_aperture.plot(color='g', lw=3, label='35 pix aperture')\n", "\n", "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec,\n", " 2.5 * semi_min_rad * 0.2 * u.arcsec,\n", " theta=(np.pi/2 + theta) * u.rad)\n", "\n", "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='b', lw=3)" + "pix_aperture.plot(color='b', lw=3, label='Kron')\n", + "plt.legend()" ] }, { @@ -891,97 +892,41 @@ "metadata": {}, "outputs": [], "source": [ - "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]# & (tab['detect_isIsolated'] == True))[0]\n", - "\n", + "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag > 19.9)\n", + " & (cmodel_mag < 20.1))[0]\n", "indx = 2\n", "\n", - "rad = np.array([3,6,9,12,17,25,35,50]) * 0.2 # convert pix to arcsec\n", - "surf_area = np.pi * rad**2\n", - "light_profile = np.array([tab['i_ap03Flux'][wh][indx],tab['i_ap06Flux'][wh][indx],tab['i_ap09Flux'][wh][indx],tab['i_ap12Flux'][wh][indx],tab['i_ap17Flux'][wh][indx],\n", - " tab['i_ap25Flux'][wh][indx],tab['i_ap35Flux'][wh][indx],tab['i_ap50Flux'][wh][indx]])/surf_area\n", + "rad = np.array([3, 6, 9, 12, 17, 25, 35, 50]) * 0.2 # convert pix to arcsec\n", + "area = np.pi * rad**2\n", + "profile = np.array([tab['i_ap03Flux'][wh][indx], tab['i_ap06Flux'][wh][indx],\n", + " tab['i_ap09Flux'][wh][indx], tab['i_ap12Flux'][wh][indx],\n", + " tab['i_ap17Flux'][wh][indx], tab['i_ap25Flux'][wh][indx],\n", + " tab['i_ap35Flux'][wh][indx],\n", + " tab['i_ap50Flux'][wh][indx]]) / area\n", "\n", - "plt.plot(rad, light_profile, label='Kron Radius R='+str(tab['i_kronRad'][wh][indx]*.2))\n", + "plt.plot(rad, profile,\n", + " label='Large Kron Radius R='+str(tab['i_kronRad'][wh][indx]*.2))\n", "plt.xlabel('Aperture Radius [arcsec]')\n", "plt.ylabel(r'Surface Brightness [nJy arcsec$^{-2}$]')\n", "\n", "# pick an object that has large size\n", - "wh2 = np.where((tab['i_kronRad'] < 8) & (tab['i_kronRad'] > 5))[0]\n", + "wh2 = np.where((tab['i_kronRad'] < 8) & (tab['i_kronRad'] > 5)\n", + " & (cmodel_mag > 19.9) & (cmodel_mag < 20.1))[0]\n", "\n", "indx = 1\n", "\n", - "light_profile = np.array([tab['i_ap03Flux'][wh2][indx],tab['i_ap06Flux'][wh2][indx],tab['i_ap09Flux'][wh2][indx],tab['i_ap12Flux'][wh2][indx],tab['i_ap17Flux'][wh2][indx],\n", - " tab['i_ap25Flux'][wh2][indx],tab['i_ap35Flux'][wh2][indx],tab['i_ap50Flux'][wh2][indx]])/surf_area\n", - "plt.plot(rad, light_profile, label='Small Radius R='+str(tab['i_kronRad'][wh2][indx]*.2))\n", + "profile = np.array([tab['i_ap03Flux'][wh2][indx], tab['i_ap06Flux'][wh2][indx],\n", + " tab['i_ap09Flux'][wh2][indx], tab['i_ap12Flux'][wh2][indx],\n", + " tab['i_ap17Flux'][wh2][indx], tab['i_ap25Flux'][wh2][indx],\n", + " tab['i_ap35Flux'][wh2][indx],\n", + " tab['i_ap50Flux'][wh2][indx]])/area\n", + "\n", + "plt.plot(rad, profile,\n", + " label='Small Kron Radius R='+str(tab['i_kronRad'][wh2][indx]*.2))\n", "plt.legend()\n", "plt.yscale('log')" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "47272d59-a513-469a-9642-9acd724da50d", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e40789c3-29b2-4f17-a687-a604c828c9b2", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a9fbb040-3d5a-4af7-93fd-5038c28e49a8", - "metadata": {}, - "outputs": [], - "source": [ - "sys.exit()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9ca25705-3ad4-40ec-bc18-32c2b08eccc8", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "55aa98dc-0528-44e6-8d6f-279fe5eb1ebd", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "aad0628a-0620-462d-9668-5433ec8f2ebf", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fa875434-44f7-4f70-bc24-b3685f770134", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2f4f4cf8-a4ca-46b7-ba42-d0034cd94238", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, From c2969bd06cf797a709e5b01f193d90a11c43c44e Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Sat, 8 Feb 2025 23:23:42 +0000 Subject: [PATCH 82/99] updating --- DP02_16_Galaxy_Photometry.ipynb | 85 ++++++++------------------------- 1 file changed, 20 insertions(+), 65 deletions(-) diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb index e56c376..4de9182 100644 --- a/DP02_16_Galaxy_Photometry.ipynb +++ b/DP02_16_Galaxy_Photometry.ipynb @@ -237,7 +237,6 @@ "import sys\n", "\n", "from scipy.stats import binned_statistic, sigmaclip\n", - "#from scipy.stats import sigmaclip\n", "\n", "import uuid\n", "import os\n", @@ -251,7 +250,8 @@ "from lsst.rsp import get_tap_service\n", "from lsst.rsp.utils import get_access_token\n", "from lsst.afw.fits import MemFileManager\n", - "import lsst.afw.geom\n", + "import lsst.afw.geom.ellipses as ellipses\n", + "\n", "\n", "import pyvo\n", "from pyvo.dal.adhoc import DatalinkResults, SodaQuery\n", @@ -312,47 +312,12 @@ "plt.rcParams.update(params)" ] }, - { - "cell_type": "markdown", - "id": "b234b23f-d81a-4666-b108-8035e4e094c3", - "metadata": {}, - "source": [ - "#### 1.3.2 Define a shortcut to plotting images" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2f19f3b6-7357-4848-a2b4-5597aa8c8e15", - "metadata": {}, - "outputs": [], - "source": [ - "def plotImage(exposure: ExposureF):\n", - " \"\"\"Plot and image using lsst.awf.image package\n", - "\n", - " Parameters\n", - " ----------\n", - " exposure : `ExposureF`\n", - " the image to plot from file in LSST awf image exposure class format\n", - "\n", - " Returns\n", - " -------\n", - " image for notebook display\n", - " \"\"\"\n", - "\n", - " fig, ax = plt.subplots()\n", - " display = afwDisplay.Display(frame=fig)\n", - " display.scale('asinh', 'zscale')\n", - " display.mtv(exposure.image)\n", - " plt.show()" - ] - }, { "cell_type": "markdown", "id": "5e6352ac-09dd-4be0-bff3-379860c12a69", "metadata": {}, "source": [ - "#### 1.3.3 Define a shortcut function to generate an image cutout using the cutout tool\n", + "#### 1.3.2 Define a shortcut function to generate an image cutout using the cutout tool\n", "Further information about the cutout tool can be found in tutorial notebook 13a." ] }, @@ -363,9 +328,7 @@ "metadata": {}, "outputs": [], "source": [ - "\n", - "def make_image_cutout_new(tap_service, ra, dec, cutout_size=0.01,\n", - " filename=None):\n", + "def make_image_cutout_new(tap_service, ra, dec, cutout_size=0.01):\n", " \"\"\"Wrapper function to generate a cutout using the cutout tool\n", "\n", " Parameters\n", @@ -373,24 +336,14 @@ " tap_service : an instance of the TAP service\n", " ra, dec : 'float'\n", " the ra and dec of the cutout center\n", - " dataId : 'dict'\n", - " the dataId of the image to make a cutout from. The format\n", - " must correspond to that provided for parameter 'imtype'\n", " cutout_size : 'float', optional\n", " edge length in degrees of the cutout\n", - " imtype : 'string', optional\n", - " string containing the type of LSST image to generate\n", - " a cutout of (e.g. deepCoadd, calexp). If imtype=None,\n", - " the function will assume a deepCoadd.\n", - " filename : 'string', optional\n", - " filename of the resulting cutout (which has fits format)\n", "\n", " Returns\n", " -------\n", - " sodaCutout : 'string'\n", - " filename of the cutout in fits format (including\n", - " full directory path; for now by default it is saved\n", - " in /home/dp02_13a_temp/\n", + " mem : 'object'\n", + " An lsst.afw.fits._fits.MemFileManager object containing the\n", + " cutout image bytes returned by the cutout tool\n", " \"\"\"\n", "\n", " spherePoint = geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", @@ -766,8 +719,7 @@ "ax.set_ylabel('cModel mag - Other mag')\n", "ax.set_ylim(ylims)\n", "ax.set_xlim([0, 15])\n", - "ax.legend()\n", - "\n" + "ax.legend()\n" ] }, { @@ -834,37 +786,38 @@ "outputs": [], "source": [ "# pick an object that has large size\n", - "#wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]# & (tab['detect_isIsolated'] == True))[0]\n", + "# wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]\n", + "\n", "wh = np.where((tab['objectId'] == 1909948454470183768))[0]\n", "indx = 0\n", - "print(\"id = \",tab['objectId'][wh][indx])\n", + "\n", "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx],\n", " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", "\n", "cutout = ExposureF(mem)\n", "\n", - "axes = lsst.afw.geom.ellipses.Axes(lsst.afw.geom.ellipses.Quadrupole(tab['shape_xx'][wh][indx], tab['shape_yy'][wh][indx], tab['shape_xy'][wh][indx]))\n", + "axes = ellipses.Axes(ellipses.Quadrupole(tab['shape_xx'][wh][indx],\n", + " tab['shape_yy'][wh][indx],\n", + " tab['shape_xy'][wh][indx]))\n", "semi_maj_rad = axes.getA()\n", "semi_min_rad = axes.getB()\n", "theta = axes.getTheta()\n", "\n", - "print(tab['i_kronRad'][wh][indx],semi_maj_rad, semi_min_rad, theta)\n", - "\n", "plt.subplot(projection=WCS(cutout.getWcs().getFitsMetadata()))\n", "extent = (cutout.getBBox().beginX, cutout.getBBox().endX,\n", " cutout.getBBox().beginY, cutout.getBBox().endY)\n", "\n", - "plt.imshow(cutout.image.array, vmin=.1, vmax=5, \n", + "plt.imshow(cutout.image.array, vmin=.1, vmax=3,\n", " extent=extent, origin='lower', cmap='gray')\n", "\n", "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree,\n", " dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", "\n", - "aperture = SkyCircularAperture(coord, r=17*.2* u.arcsec)\n", + "aperture = SkyCircularAperture(coord, r=17 * 0.2 * u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", "pix_aperture.plot(color='r', lw=3, label='17 pix aperture')\n", "\n", - "aperture = SkyCircularAperture(coord, r=35*.2* u.arcsec)\n", + "aperture = SkyCircularAperture(coord, r=35 * 0.2 * u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", "pix_aperture.plot(color='g', lw=3, label='35 pix aperture')\n", "\n", @@ -882,7 +835,9 @@ "id": "714badaa-834d-4050-82a6-ffcac245ae5c", "metadata": {}, "source": [ - "Maybe below demonstrate how to do the radial profile using the aperture photometry" + "## 4 Application of aperture photometry: radial profile\n", + "\n", + "A science application for the aperture photometry is easy visualization of the radial profile of the galaxy. In the cell below, make this plot for both a large galaxy and a small galaxy (of similar brightness, cModel magnitude ~ 20). Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." ] }, { From 371c9b9436a9fff8b04d125bc56365ade58075d0 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 10 Feb 2025 17:43:21 +0000 Subject: [PATCH 83/99] finalizing --- DP02_17_Galaxy_Photometry.ipynb | 915 ++++++++++++++++++++++++++++++++ 1 file changed, 915 insertions(+) create mode 100644 DP02_17_Galaxy_Photometry.ipynb diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb new file mode 100644 index 0000000..f6f41df --- /dev/null +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -0,0 +1,915 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "749b0ddf", + "metadata": { + "tags": [] + }, + "source": [ + "# DP0.2 Notebook 17 Galaxy Photometry\n", + "\n", + "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", + "<br>\n", + "Contact author(s): <i>Christina Williams</i> <br>\n", + "Last verified to run: <i>2024-02-10</i> <br>\n", + "LSST Science Pipelines version: Weekly <i>2024_50</i> <br>\n", + "Container Size: <i>medium</i> <br>\n", + "Targeted learning level: <i>beginner</i> <br>" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext pycodestyle_magic\n", + "%flake8_on\n", + "import logging\n", + "logging.getLogger(\"flake8\").setLevel(logging.FATAL)" + ] + }, + { + "cell_type": "markdown", + "id": "2963cbac-4ecd-4694-bea3-c111f527e51b", + "metadata": {}, + "source": [ + "**Description:** Explore the available measurements of galaxy photometry produced by the LSST pipelines and their applications." + ] + }, + { + "cell_type": "markdown", + "id": "80a0baf5-51ad-40ec-8991-060a7b27c289", + "metadata": {}, + "source": [ + "**Skills:** Basic understanding of photometric measurement methods typically used to characterize galaxies." + ] + }, + { + "cell_type": "markdown", + "id": "393da88f-7978-4920-aa4a-a9830df6eed9", + "metadata": {}, + "source": [ + "**LSST Data Products:** objectTable" + ] + }, + { + "cell_type": "markdown", + "id": "5c67fab9-136a-4adc-bb42-142b91ab69dd", + "metadata": {}, + "source": [ + "**Packages:** No new LSST packages are introduced here. The notebook will make use of the TAP service from the `lsst.rsp` package." + ] + }, + { + "cell_type": "markdown", + "id": "8f72b27f", + "metadata": {}, + "source": [ + "**Credit:**\n", + "This notebook benefitted from earlier exploration of simulated data and notebook development by Melissa Graham and Dan Taranu, and helpful discussions with Jim Bosch. " + ] + }, + { + "cell_type": "markdown", + "id": "28e91cbf-ab7f-4e26-9276-b00299d6065e", + "metadata": {}, + "source": [ + "**Get Support:**\n", + "Find DP0-related documentation and resources at <a href=\"https://dp0.lsst.io\">dp0.lsst.io</a>.\n", + "Questions are welcome as new topics in the \n", + "<a href=\"https://community.lsst.org/c/support/dp0\">Support - Data Preview 0 Category</a> \n", + "of the Rubin Community Forum. \n", + "Rubin staff will respond to all questions posted there." + ] + }, + { + "cell_type": "markdown", + "id": "cfc73be0", + "metadata": {}, + "source": [ + "## 1. Introduction\n", + "\n", + "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a> about the PSF photometry.) \n", + "\n", + "Please note that these explanations are specific to DP0.2: the objectTable contents and definitions are still subject to change for DP1. \n" + ] + }, + { + "cell_type": "markdown", + "id": "7eb3ba1f-659f-4cb0-acad-52690f60a485", + "metadata": { + "execution": { + "iopub.execute_input": "2024-12-02T22:37:09.704845Z", + "iopub.status.busy": "2024-12-02T22:37:09.704072Z", + "iopub.status.idle": "2024-12-02T22:37:10.367698Z", + "shell.execute_reply": "2024-12-02T22:37:10.366983Z", + "shell.execute_reply.started": "2024-12-02T22:37:09.704824Z" + } + }, + "source": [ + "### 1.1 Types of photometry measurements that exist in the Object Table\n", + "\n", + "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", + "\n", + "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there: The first are total fluxes are those that integrate the total light coming from objects, corrected for loss due to the blurring effects of PSF or seeing, including \"Composite Model\" (`cModel`) fluxes. The second category characterize the relative brightness of objects for specific regions of objects (i.e. are not corrected to be total fluxes) but can be useful for measuring accurate light profiles or accurate colors.\n", + "\n", + "### 1.1.1 Total fluxes\n", + "\n", + "\n", + "#### Composite Model (CModel) fluxes\n", + "\n", + "Similar in nature to those measured for SDSS: \n", + "https://www.sdss3.org/dr8/algorithms/magnitudes.php#cmodel\n", + "\n", + "In short, it is the linear combination of the best fit exponential (disk or D) and de Vaucouleurs (bulge or B) profiles. \n", + "\n", + "```\n", + "<f>_cModelFlux : Flux from the final cmodel fit. Forced on <f>-band.\n", + "<f>_cModelFluxErr : Uncertainty of <f>_cModelFlux\n", + "<f>_cModel_flag : Failure flag for <f>_cModelFlux\n", + "```\n", + "\n", + "For most cases the \"fixed\" cModel photometry (as listed above) are preferred to that measured with more degrees of freedom labeled `<f>_free_cModelFlux`. The difference is that the fixed ones above uses a reference band (recorded as `refBand` in the schema) where the galaxy is well detected to determine the other parameters, which are then fixed when fitting for the flux in the other bands. The `_free_cModelFlux` measurement allows all parameters to be free and independent in each filter. The fixed `_cModelFlux` measurements are generally recommended for galaxy science applications where total flux measurements are needed (e.g. for intrinsic luminosity or mass).\n", + "\n", + "### 1.1.2 Apparent fluxes (i.e. not corrected to the total flux)\n", + " \n", + "#### Kron fluxes\n", + "\n", + "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>. The aperture used for the fluxes is 2.5 x R1 where R1 is the luminosity weighted radius (also called \"first moment\"; Kron et al. 1980).\n", + "\n", + "```\n", + "<f>_kronFlux : Flux from Kron Flux algorithm. Measured on <f> g-band.\n", + "<f>_kronFluxErr : Uncertainty of <f>_kronFlux.\n", + "<f>_kronFlux_flag : Failure flag for <f>_kronFlux.\n", + "```\n", + "\n", + "The Kron radius, `<f>_kronRad`, is also available. In this case of LSST pipeline output, the Kron flux is not corrected for light that is emitted outside of the Kron aperture. While in many cases it will collect the majority of light, it will not be as accurate as the cModel for science cases requiring total flux.\n", + "\n", + "\n", + "#### Aperture fluxes\n", + "This contains the enclosed flux inside a given aperture (they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture). Fixed aperture size refers to the aperture radius in pixels.\n", + "\n", + "```\n", + "<f>_ap<pix>Flux : Flux within <pix>-pixel aperture. Forced on <f>-band.\n", + "<f>_ap<pix>FluxErr : Uncertainty of <f>_ap<pix>Flux.\n", + "<f>_ap<pix>FluxFlag : Failure flag for <f>_ap<pix>Flux.\n", + "```\n", + "\n", + "For DP0.2, the apertures are 3, 6, 9, 12, 17, 25, 35, 50, and 70 pixels. In the column name, apertures are `03`, `06`, `09`, `12`, and so on. While aperture fluxes are not corrected for the loss outside the aperture, if the aperture size is much larger than the galaxy size then it will approximate the total flux of the galaxy. The general application of these measurements are for measuring radial profiles (see Section 4 below).\n", + "\n", + "#### GaaP fluxes\n", + "\n", + "These are the Gaussian-aperture-and-PSF flux that is defined in <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>. The main goal of this method is to measure accurate colors while accounting for the different spatial resolution between filters. This is sometimes achieved in other datasets by convolving all images to the largest PSF, but this process of PSF-matching is computationally very time consuming for large images, thus motivating GaaP as a faster alternative. It is not a measure of total flux in a filter. Several apertures are available. For photometric redshifts, and other analysis where accurate colors are important, it is the GaaP fluxes with optimal aperture that should be used. \n", + "\n", + "**Optimal**\n", + "\n", + "```\n", + "<f>_gaapOptimalFlux : GaaP flux with optimal aperture after multiplying the seeing by 1.15. Forced on <f>-band.\n", + "<f>_gaapOptimalFluxErr : Uncertainty of <f>_gaapOptimalFlux.\n", + "```\n", + "\n", + "**PSF**\n", + "\n", + "```\n", + "<f>_gaapPsfFlux : GaaP flux with PSF aperture after multiplying the seeing by 1.15. Forced on <f>-band.\n", + "<f>_gaapPsfFluxErr : Uncertainty of <f>_gaapPsfFlux.\n", + "```\n", + "\n", + "**Aperture**\n", + "\n", + "```\n", + "<f>_gaap<ap>Flux : GaaP flux with <ap> aperture after multiplying the seeing aperture. Forced on <f>-band.\n", + "<f>_gaap<ap>FluxErr : Uncertainty of <f>_gaap<ap>Flux.\n", + "```\n", + "\n", + "Where the seeing apertures are 0.5, 0.7, 1.0, 1.5, 2.5, and 3.0 arcseconds. In the column name `<ap>` appears as `0p5`, `0p7`, etc.\n", + "\n", + "\n", + "#### PSF fluxes\n", + "\n", + "Fluxes derived using the model point-spread function (PSF) of the image. Since PSF fluxes are designed for unresolved sources (not the majority of galaxies) this notebook will not explore science applications for this type of photometry. Interested users can find more information in the PSF Tutorial notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a>.\n", + "\n", + "```\n", + "<f>_psfFlux : Flux derived from linear least-squares fit of PSF model. Forced on <f>-band.\n", + "<f>_psfFluxErr : Uncertainty of <f>_psfFlux.\n", + "<f>_psfFlux_flag : Failure flag for <f>_psfFlux.\n", + "\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "id": "dc36f107", + "metadata": {}, + "source": [ + "### 1.2 Import packages\n" + ] + }, + { + "cell_type": "markdown", + "id": "ccb4fe61-835a-47ac-a691-e086ce766e79", + "metadata": {}, + "source": [ + "`numpy` is a fundamental package for scientific computing with arrays in Python\n", + "(<a href=\"https://numpy.org\">numpy.org</a>).\n", + "\n", + "`matplotlib` is a comprehensive library for creating static, animated, and\n", + "interactive visualizations in Python \n", + "(<a href=\"https://matplotlib.org/\">matplotlib.org</a>; \n", + "<a href=\"https://matplotlib.org/stable/gallery/index.html\">matplotlib gallery</a>).\n", + "\n", + "From the `lsst` package, modules for accessing the TAP service, the butler, and image display functions are imported (<a href=\"https://pipelines.lsst.io/\">pipelines.lsst.io</a>)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dbc75bd-a802-4576-8628-4e0088942303", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from scipy.stats import binned_statistic\n", + "\n", + "import uuid\n", + "\n", + "import lsst.geom as geom\n", + "import lsst.resources\n", + "import lsst.afw.display as afwDisplay\n", + "from lsst.afw.image import ExposureF\n", + "from lsst.rsp import get_tap_service\n", + "#from lsst.rsp.utils import get_access_token\n", + "from lsst.afw.fits import MemFileManager\n", + "import lsst.afw.geom.ellipses as ellipses\n", + "\n", + "from pyvo.dal.adhoc import DatalinkResults, SodaQuery\n", + "\n", + "from astropy import units as u\n", + "from astropy.coordinates import SkyCoord #, Angle\n", + "from astropy.wcs import WCS\n", + "\n", + "from photutils.aperture import SkyCircularAperture, SkyEllipticalAperture\n" + ] + }, + { + "cell_type": "markdown", + "id": "c217adff-25ed-4fce-95e7-8aa04630f6cc", + "metadata": {}, + "source": [ + "### 1.3 Define functions and parameters\n", + "\n", + "\n", + "#### 1.3.1 Define some aesthetic plotting defaults" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", + "metadata": {}, + "outputs": [], + "source": [ + "plt.style.use('tableau-colorblind10')\n", + "afwDisplay.setDefaultBackend('matplotlib')\n", + "\n", + "params = {'axes.labelsize': 18,\n", + " 'font.size': 18,\n", + " 'legend.fontsize': 12,\n", + " 'xtick.major.width': 2,\n", + " 'xtick.minor.width': 1,\n", + " 'xtick.major.size': 10,\n", + " 'xtick.minor.size': 4,\n", + " 'xtick.direction': 'in',\n", + " 'xtick.top': True,\n", + " 'lines.linewidth': 2,\n", + " 'axes.linewidth': 2,\n", + " 'axes.labelweight': 2,\n", + " 'axes.titleweight': 2,\n", + " 'ytick.major.width': 2,\n", + " 'ytick.minor.width': 1,\n", + " 'ytick.major.size': 10,\n", + " 'ytick.minor.size': 4,\n", + " 'ytick.direction': 'in',\n", + " 'ytick.right': True,\n", + " 'figure.figsize': [6, 6],\n", + " 'figure.facecolor': 'White'\n", + " }\n", + "\n", + "plt.rcParams.update(params)" + ] + }, + { + "cell_type": "markdown", + "id": "5e6352ac-09dd-4be0-bff3-379860c12a69", + "metadata": {}, + "source": [ + "#### 1.3.2 Define a shortcut function to generate an image cutout using the cutout tool\n", + "Further information about the cutout tool can be found in tutorial notebook 13a." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "07bba696-f49c-46e3-b867-61063195be99", + "metadata": {}, + "outputs": [], + "source": [ + "def make_image_cutout_new(tap_service, ra, dec, cutout_size=0.01):\n", + " \"\"\"Wrapper function to generate a cutout using the cutout tool\n", + "\n", + " Parameters\n", + " ----------\n", + " tap_service : an instance of the TAP service\n", + " ra, dec : 'float'\n", + " the ra and dec of the cutout center\n", + " cutout_size : 'float', optional\n", + " edge length in degrees of the cutout\n", + "\n", + " Returns\n", + " -------\n", + " mem : 'object'\n", + " An lsst.afw.fits._fits.MemFileManager object containing the\n", + " cutout image bytes returned by the cutout tool\n", + " \"\"\"\n", + "\n", + " spherePoint = geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", + " coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree, frame='icrs')\n", + "\n", + " band = 'i'\n", + "\n", + " query = \"SELECT access_format, access_url, dataproduct_subtype, \" + \\\n", + " \"lsst_patch, lsst_tract, lsst_band, s_ra, s_dec \" + \\\n", + " \"FROM ivoa.ObsCore WHERE dataproduct_type = 'image' \" + \\\n", + " \"AND obs_collection = 'LSST.DP02' \" + \\\n", + " \"AND dataproduct_subtype = 'lsst.deepCoadd_calexp' \" + \\\n", + " \"AND lsst_band = \" + \"'\" + str(band) + \"' \" + \\\n", + " \"AND CONTAINS(POINT('ICRS', \" + str(coord.ra.value) + \\\n", + " \", \" + str(coord.dec.value) + \"), \" + \\\n", + " \"s_region) = 1\"\n", + "\n", + " results = tap_service.search(query)\n", + "\n", + " # Get datalink\n", + " dataLinkUrl = results[0].getdataurl()\n", + " auth_session = service._session\n", + " dl = DatalinkResults.from_result_url(dataLinkUrl,\n", + " session=auth_session)\n", + "\n", + " # from_resource: creates a instance from\n", + " # a number of records and a Datalink Resource.\n", + " sq = SodaQuery.from_resource(dl,\n", + " dl.get_adhocservice_by_id(\"cutout-sync\"),\n", + " session=auth_session)\n", + "\n", + " sq.circle = (spherePoint.getRa().asDegrees() * u.deg,\n", + " spherePoint.getDec().asDegrees() * u.deg,\n", + " cutout_size * u.deg)\n", + " cutout_bytes = sq.execute_stream().read()\n", + " mem = MemFileManager(len(cutout_bytes))\n", + " mem.setData(cutout_bytes, len(cutout_bytes))\n", + "\n", + " return mem" + ] + }, + { + "cell_type": "markdown", + "id": "ec51ac0b", + "metadata": { + "tags": [] + }, + "source": [ + "## 2. Integrated photometry of galaxies using the LSST pipeline\n", + "\n", + "This section will explore the total, integrated photometry measurements, and provide some guidance for which are optimal for certain science applications using galaxies. \n" + ] + }, + { + "cell_type": "markdown", + "id": "45c86ed0-aebe-4d74-af42-619c0f6b0705", + "metadata": {}, + "source": [ + "### 2.1 Initialize the TAP service" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", + "metadata": {}, + "outputs": [], + "source": [ + "service = get_tap_service(\"tap\")" + ] + }, + { + "cell_type": "markdown", + "id": "9547e659-fd0e-432c-af25-968cc9ebea9d", + "metadata": {}, + "source": [ + "### 2.2 Object table photometry measurements\n", + "\n", + "First see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT column_name, datatype, description, unit \" \\\n", + " \"FROM tap_schema.columns \" \\\n", + " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", + "\n", + "results = service.search(query).to_table()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", + "metadata": {}, + "outputs": [], + "source": [ + "search_string = 'Flux'\n", + "band = 'i_'\n", + "for cname in results['column_name']:\n", + " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", + " print(cname)" + ] + }, + { + "cell_type": "markdown", + "id": "caf9008d-e3aa-4908-bf32-a27cbe890a4f", + "metadata": {}, + "source": [ + "## 2.3 Compare photometric measurements\n", + "\n", + "Below, query the DP0.2 objectTable for a selection of photometric measurements. This section will focus on 3 measurements: total flux from cModel (sum of bulge and disk sersic compoents fitted to the galaxy); and apparent fluxes measured as Kron (typically includes more than 90% of intrinsic light) and GaaP (which is optimized for measuring accurate colors between bands).\n", + "\n", + "First, focus on a known part of the simulation to contain a galaxy cluster (also seen in DP0.2 notebook tutorial 03a). Search for all galaxies (the `i_extendedness` flag will exclude point sources) that are unique in the objectTable (`detect_isPrimary` = True). Further, identify objects which have been detected at high signal to noise > 10 and whose photometric measurements have not been flagged as having an issue (`i_kronFlux_flag` or `i_cModel_flag` = 0 means the photometry is ok). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14450d07-0c29-4342-91f2-72ccc4cecfb0", + "metadata": {}, + "outputs": [], + "source": [ + "cluster_RA = 55.7506834813934\n", + "cluster_dec = -32.28892993702273\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d82dd79-a4d7-4428-a77c-1ed2bb717486", + "metadata": {}, + "outputs": [], + "source": [ + "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, \" + \\\n", + " \"obj.detect_fromBlend, obj.detect_isIsolated, \" + \\\n", + " \"obj.i_blendedness, obj.i_extendedness, \" + \\\n", + " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, \" + \\\n", + " \"obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.i_kronFlux_flag, obj.i_cModel_flag, \" + \\\n", + " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, \" + \\\n", + " \"obj.i_ap03Flux, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap12Flux, \" + \\\n", + " \"obj.i_ap17Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux \" + \\\n", + " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND \" + \\\n", + " \"(obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND \" + \\\n", + " \"(obj.i_extendedness = 1) AND \" + \\\n", + " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), \" + \\\n", + " \"CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e75ee4db-e4b9-4ff2-ba07-1f7f34a8d44b", + "metadata": {}, + "outputs": [], + "source": [ + "job = service.submit_job(query)\n", + "job.run()\n", + "job.wait(phases=['COMPLETED', 'ERROR'])\n", + "print('Job phase is', job.phase)" + ] + }, + { + "cell_type": "markdown", + "id": "6d90ce60-2dc7-432d-bf12-1679cd43c3f3", + "metadata": {}, + "source": [ + "Print the results of the search query." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02ea5eb7-bac9-4c9f-90e4-626a69340b41", + "metadata": {}, + "outputs": [], + "source": [ + "results = job.fetch_result()\n", + "print(len(results))\n", + "tab = results.to_table()\n", + "tab" + ] + }, + { + "cell_type": "markdown", + "id": "e6a27a39-ed2b-49fe-ac6d-51ae4c300bfc", + "metadata": {}, + "source": [ + "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", + "\n", + "First, store the Kron Radius, which is a good proxy for the size of the galaxy light profile, and the AB magnitudes to go with the fluxes extracted from the objectTable." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8b4a64a-6565-4d7d-ae48-0a666c41101e", + "metadata": {}, + "outputs": [], + "source": [ + "i_kronRad = tab['i_kronRad']\n", + "\n", + "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", + "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", + "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", + "\n", + "ap06_mag = -2.50 * np.log10(tab['i_ap06Flux']) + 31.4\n", + "ap09_mag = -2.50 * np.log10(tab['i_ap09Flux']) + 31.4\n", + "ap17_mag = -2.50 * np.log10(tab['i_ap17Flux']) + 31.4\n", + "ap12_mag = -2.50 * np.log10(tab['i_ap12Flux']) + 31.4\n", + "ap35_mag = -2.50 * np.log10(tab['i_ap35Flux']) + 31.4" + ] + }, + { + "cell_type": "markdown", + "id": "85f65eb7-c0c6-45bf-8ff4-4e73b5e9e075", + "metadata": {}, + "source": [ + "### 2.3.1 Compare aperture photometry to cModel total fluxes\n", + "\n", + "Make a plot that shows how the different photometric measurements compare. Note that cModel is the total flux integrated from a model fit to the galaxy light profile, while Kron and GaaP are both measures of light within a fixed aperture. \n", + "\n", + "Generally GaaP magnitudes are larger (fainter) than that measured from cModel, becuase the fixed aperture systematically underestimates the flux in the galaxy wings (and the lost flux increases as the intrinsic size of the galaxy increases, e.g. as traced by the Kron radius)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", + "metadata": {}, + "outputs": [], + "source": [ + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1,\n", + " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "\n", + "ylims = [-1.5, 1.5]\n", + "\n", + "ax.plot(i_kronRad, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", + " label='cModel - 17-pix aperture', color='blue')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", + " label='cModel 12-pix aperture', color='green')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", + " label='cModel 9-pix aperture', color='orange')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", + " label='cModel 6-pix aperture', color='red')\n", + "\n", + "ax2.hist((cmodel_mag-ap17_mag), edgecolor='blue', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "ax2.hist((cmodel_mag-ap12_mag), edgecolor='green', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "ax2.hist((cmodel_mag-ap09_mag), edgecolor='orange', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "ax2.hist((cmodel_mag-ap06_mag), edgecolor='red', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "\n", + "ax2.set_ylim(ylims)\n", + "ax.axhline(0, linestyle='--')\n", + "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", + "ax.set_ylabel('cModel mag - Aperture mag')\n", + "ax.set_ylim(ylims)\n", + "ax.set_xlim([0, 15])\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "709a40cf-df65-42ff-8a30-c787bcd79499", + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", + "ylims = [-1.2, 1.2]\n", + "bins = np.arange(16, 27, 1)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", + " label='cModel 6-pix aperture', color='red')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-ap06_mag)\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='red', lw=2, label='bin median', zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", + " label='cModel 9-pix aperture', color='orange')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-ap09_mag)\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='orange', lw=2,\n", + " label='bin median', zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", + " label='cModel 12-pix aperture', color='green')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-ap12_mag)\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='green', lw=2,\n", + " label='bin median', zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", + " label='cModel 17-pix aperture', color='blue')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-ap17_mag)\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='blue', lw=2,\n", + " label='bin median', zorder=10)\n", + "\n", + "ax.axhline(0, linestyle='--')\n", + "ax.set_xlabel('cModel Magnitude')\n", + "ax.set_ylabel('cModel mag - Aperture mag')\n", + "ax.set_ylim([-1, 1])\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "cef81cea-b352-4196-a4d0-c5b4ad80bd00", + "metadata": {}, + "source": [ + "These two figures show that the aperture photometry typically under-estimates the flux relative to the total flux estimated using cModel. As expected, there is a general trend for larger apertures to get closer to the total flux from cModel for large galaxies (i.e. whose Kron Radius is larger). There is also a general trend for the aperture photometry to be less discrepant at fainter magnitudes, since faint galaxies tend to be small.\n", + "\n", + "\n", + "### 2.3.2 Compare Kron and GaaP photometry to cModel\n", + "\n", + "In the next cell, compare the cModel to the Kron and GaaP measures." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05e30151-1346-425a-a86f-f2a7c945a45c", + "metadata": {}, + "outputs": [], + "source": [ + "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1,\n", + " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", + "ylims = [-2, 2]\n", + "\n", + "ax.plot(i_kronRad, (cmodel_mag-kron_mag), '.', alpha=.1,\n", + " label='cModel-Kron', color='blue')\n", + "ax.plot(i_kronRad, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", + " label='cModel - gaapOptimal', color='green')\n", + "\n", + "ax2.hist((cmodel_mag-kron_mag), edgecolor='blue', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "ax2.hist((cmodel_mag-gaap_mag), edgecolor='green', orientation=\"horizontal\",\n", + " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", + " histtype=\"step\", stacked=True, fill=False)\n", + "\n", + "ax2.set_ylim(ylims)\n", + "ax.axhline(0, linestyle='--')\n", + "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", + "ax.set_ylabel('cModel mag - Other mag')\n", + "ax.set_ylim(ylims)\n", + "ax.set_xlim([0, 15])\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4539933a-3cf9-46e7-b39a-60101ff97b2a", + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", + "ylims = [-1.2, 1.2]\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-kron_mag), '.', alpha=.1,\n", + " label='cModel-Kron', color='blue')\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-kron_mag)\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='blue', lw=2, label='bin median', zorder=10)\n", + "\n", + "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", + " label='cModel - gaapOptimal', color='green')\n", + "\n", + "x = cmodel_mag\n", + "y = (cmodel_mag-gaap_mag)\n", + "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", + " statistic='median', bins=bins)\n", + "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", + "ax.plot(binctr, bin_mean, color='green', lw=2, label='bin median', zorder=10)\n", + "\n", + "ax.axhline(0, linestyle='--')\n", + "ax.set_xlabel('cModel Magnitude')\n", + "ax.set_ylabel('cModel mag - Other mag')\n", + "ax.set_ylim([-1, 1])\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "9aec6b4b-ada8-429d-a65f-c076d8d26872", + "metadata": {}, + "source": [ + "The above plots show the parameter space where Kron fluxes do not correspond well with total fluxes (as measured by cModel). This indcates that Kron fluxes will underestimate the total fluxes in the regime of bright magnitudes and large Kron radius. Generally, cModel is recommended over Kron.\n", + "\n", + "The GaaP fluxes are not meant to measure total fluxes (from these plots it is clear there is a strong discrepancy with cModel) but GaaP measurements are the best and most robust for measuring robust integrated colors between different filters." + ] + }, + { + "cell_type": "markdown", + "id": "48d5bfb6-dc27-4ed8-b615-78216710912e", + "metadata": {}, + "source": [ + "### 3. Visualize photometric measurements\n", + "\n", + "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the objectTable. The position angle `theta` is defined in radians counterclockwise from the x-axis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "49387e7a-9e0d-4e00-a2b9-8767ab667929", + "metadata": {}, + "outputs": [], + "source": [ + "# Alternatively, pick a different bright object that has large size\n", + "# wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]\n", + "\n", + "wh = np.where((tab['objectId'] == 1909948454470183768))[0]\n", + "indx = 0\n", + "\n", + "arcsec_per_pix = 0.2 # this is the pixel scale\n", + "\n", + "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx],\n", + " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", + "\n", + "cutout = ExposureF(mem)\n", + "\n", + "axes = ellipses.Axes(ellipses.Quadrupole(tab['shape_xx'][wh][indx],\n", + " tab['shape_yy'][wh][indx],\n", + " tab['shape_xy'][wh][indx]))\n", + "Rmaj = axes.getA()\n", + "Rmin = axes.getB()\n", + "theta = axes.getTheta()\n", + "\n", + "plt.subplot(projection=WCS(cutout.getWcs().getFitsMetadata()))\n", + "extent = (cutout.getBBox().beginX, cutout.getBBox().endX,\n", + " cutout.getBBox().beginY, cutout.getBBox().endY)\n", + "\n", + "plt.imshow(cutout.image.array, vmin=.1, vmax=0.8,\n", + " extent=extent, origin='lower', cmap='gray')\n", + "\n", + "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree,\n", + " dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", + "\n", + "aperture = SkyCircularAperture(coord, r=17 * arcsec_per_pix * u.arcsec)\n", + "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='r', lw=3, label='17 pix aperture')\n", + "\n", + "aperture = SkyCircularAperture(coord, r=35 * arcsec_per_pix * u.arcsec)\n", + "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='g', lw=3, label='35 pix aperture')\n", + "\n", + "aperture = SkyEllipticalAperture(coord,\n", + " 2.5 * Rmaj * arcsec_per_pix * u.arcsec,\n", + " 2.5 * Rmin * arcsec_per_pix * u.arcsec,\n", + " theta=(np.pi/2 + theta) * u.rad)\n", + "\n", + "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", + "pix_aperture.plot(color='b', lw=3, label='Kron')\n", + "plt.legend()\n", + "\n", + "print(\"Kron magnitude = \", kron_mag[wh][indx])\n", + "print(\"17-pix Aperture mag = \", ap17_mag[wh][indx])\n", + "print(\"35-pix Aperture mag = \", ap35_mag[wh][indx])\n", + "print(\"cModel mag = \", cmodel_mag[wh][indx])\n" + ] + }, + { + "cell_type": "markdown", + "id": "125bf616-aad9-4291-85fe-503b68f0d539", + "metadata": {}, + "source": [ + "The above figure shows more clearly that there is some fraction of the galaxy's light excluded by each of these photometric apertures (compared to cModel, which approximates the total magnitude using sersic models for the light profile, and indicates the source has brighter magnitude than any of the aperture photometry). " + ] + }, + { + "cell_type": "markdown", + "id": "714badaa-834d-4050-82a6-ffcac245ae5c", + "metadata": {}, + "source": [ + "## 4. Application of aperture photometry: radial profile\n", + "\n", + "A science application for the aperture photometry is easy visualization of the radial profile of the galaxy. In the cell below, make this plot for both a large galaxy and a small galaxy (of similar brightness, cModel magnitude ~ 20). Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "432db690-be7e-43bf-a640-a80af727652b", + "metadata": {}, + "outputs": [], + "source": [ + "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag > 19.9)\n", + " & (cmodel_mag < 20.1))[0]\n", + "indx = 2\n", + "\n", + "rad = np.array([3, 6, 9, 12, 17, 25, 35, 50]) * arcsec_per_pix # convert pix to arcsec\n", + "area = np.pi * rad**2\n", + "profile = np.array([tab['i_ap03Flux'][wh][indx], tab['i_ap06Flux'][wh][indx],\n", + " tab['i_ap09Flux'][wh][indx], tab['i_ap12Flux'][wh][indx],\n", + " tab['i_ap17Flux'][wh][indx], tab['i_ap25Flux'][wh][indx],\n", + " tab['i_ap35Flux'][wh][indx],\n", + " tab['i_ap50Flux'][wh][indx]]) / area\n", + "\n", + "plt.plot(rad, profile,\n", + " label='Large Kron Radius R='+str(tab['i_kronRad'][wh][indx]*arcsec_per_pix))\n", + "plt.xlabel('Aperture Radius [arcsec]')\n", + "plt.ylabel(r'Surface Brightness [nJy arcsec$^{-2}$]')\n", + "\n", + "# pick an object of similar magnitude that has a smaller size\n", + "wh2 = np.where((tab['i_kronRad'] < 8) & (tab['i_kronRad'] > 5)\n", + " & (cmodel_mag > 19.9) & (cmodel_mag < 20.1))[0]\n", + "\n", + "indx = 1\n", + "\n", + "profile = np.array([tab['i_ap03Flux'][wh2][indx], tab['i_ap06Flux'][wh2][indx],\n", + " tab['i_ap09Flux'][wh2][indx], tab['i_ap12Flux'][wh2][indx],\n", + " tab['i_ap17Flux'][wh2][indx], tab['i_ap25Flux'][wh2][indx],\n", + " tab['i_ap35Flux'][wh2][indx],\n", + " tab['i_ap50Flux'][wh2][indx]])/area\n", + "\n", + "plt.plot(rad, profile,\n", + " label='Small Kron Radius R='+str(tab['i_kronRad'][wh2][indx]*arcsec_per_pix))\n", + "plt.legend()\n", + "plt.yscale('log')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "LSST", + "language": "python", + "name": "lsst" + }, + "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.11.9" + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 30712e341960c7c68ffb16f2e5f6495330e263ed Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 10 Feb 2025 18:27:05 +0000 Subject: [PATCH 84/99] finalizing --- DP02_17_Galaxy_Photometry.ipynb | 94 +++++++++++++++++++-------------- 1 file changed, 55 insertions(+), 39 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index f6f41df..8aa967a 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -221,7 +221,13 @@ "(<a href=\"https://matplotlib.org/\">matplotlib.org</a>; \n", "<a href=\"https://matplotlib.org/stable/gallery/index.html\">matplotlib gallery</a>).\n", "\n", - "From the `lsst` package, modules for accessing the TAP service, the butler, and image display functions are imported (<a href=\"https://pipelines.lsst.io/\">pipelines.lsst.io</a>)." + "`scipy.stats` contains statistical packages, this notebook will use binned_statistic to calculate running medians.\n", + "\n", + "From the `lsst` package, modules for accessing the TAP service, and image display functions from `afw` are imported (<a href=\"https://pipelines.lsst.io/\">pipelines.lsst.io</a>). Also import some geometric functions to help plot photometric apertures.\n", + "\n", + "From the `pyvo` package, import some functions that will enable using the image cutout tool.\n", + "\n", + "Finally, from `astropy` and `photutils` import packages to enable plotting images and drawing shapes on images with WCS information." ] }, { @@ -231,28 +237,24 @@ "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "\n", + "import matplotlib.pyplot as plt\n", "from scipy.stats import binned_statistic\n", "\n", - "import uuid\n", - "\n", "import lsst.geom as geom\n", "import lsst.resources\n", "import lsst.afw.display as afwDisplay\n", "from lsst.afw.image import ExposureF\n", "from lsst.rsp import get_tap_service\n", - "#from lsst.rsp.utils import get_access_token\n", "from lsst.afw.fits import MemFileManager\n", "import lsst.afw.geom.ellipses as ellipses\n", "\n", "from pyvo.dal.adhoc import DatalinkResults, SodaQuery\n", + "import uuid\n", "\n", "from astropy import units as u\n", - "from astropy.coordinates import SkyCoord #, Angle\n", + "from astropy.coordinates import SkyCoord\n", "from astropy.wcs import WCS\n", - "\n", "from photutils.aperture import SkyCircularAperture, SkyEllipticalAperture\n" ] }, @@ -274,7 +276,6 @@ "metadata": {}, "outputs": [], "source": [ - "plt.style.use('tableau-colorblind10')\n", "afwDisplay.setDefaultBackend('matplotlib')\n", "\n", "params = {'axes.labelsize': 18,\n", @@ -299,6 +300,7 @@ " 'figure.figsize': [6, 6],\n", " 'figure.facecolor': 'White'\n", " }\n", + "plt.style.use('tableau-colorblind10')\n", "\n", "plt.rcParams.update(params)" ] @@ -309,7 +311,7 @@ "metadata": {}, "source": [ "#### 1.3.2 Define a shortcut function to generate an image cutout using the cutout tool\n", - "Further information about the cutout tool can be found in tutorial notebook 13a." + "Further information about the cutout tool can be found in <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_13a_Image_Cutout_SciDemo.html\">tutorial notebook 13a</a>." ] }, { @@ -385,7 +387,7 @@ "source": [ "## 2. Integrated photometry of galaxies using the LSST pipeline\n", "\n", - "This section will explore the total, integrated photometry measurements, and provide some guidance for which are optimal for certain science applications using galaxies. \n" + "This section will explore integrated photometry measurements, and provide some guidance for which are optimal for certain science applications using galaxies. \n" ] }, { @@ -413,7 +415,7 @@ "source": [ "### 2.2 Object table photometry measurements\n", "\n", - "First see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " + "First, see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " ] }, { @@ -449,11 +451,13 @@ "id": "caf9008d-e3aa-4908-bf32-a27cbe890a4f", "metadata": {}, "source": [ - "## 2.3 Compare photometric measurements\n", + "#### 2.3 Compare photometric measurements\n", "\n", - "Below, query the DP0.2 objectTable for a selection of photometric measurements. This section will focus on 3 measurements: total flux from cModel (sum of bulge and disk sersic compoents fitted to the galaxy); and apparent fluxes measured as Kron (typically includes more than 90% of intrinsic light) and GaaP (which is optimized for measuring accurate colors between bands).\n", + "### 2.3.1 Identify a galaxy sample to investigate photometry\n", "\n", - "First, focus on a known part of the simulation to contain a galaxy cluster (also seen in DP0.2 notebook tutorial 03a). Search for all galaxies (the `i_extendedness` flag will exclude point sources) that are unique in the objectTable (`detect_isPrimary` = True). Further, identify objects which have been detected at high signal to noise > 10 and whose photometric measurements have not been flagged as having an issue (`i_kronFlux_flag` or `i_cModel_flag` = 0 means the photometry is ok). " + "Below, query the DP0.2 objectTable for a selection of photometric measurements. This section will focus on 4 measurements: total flux from cModel (sum of bulge and disk sersic compoents fitted to the galaxy); and apparent fluxes measured as Kron (typically includes more than 90% of intrinsic light), GaaP (which is optimized for measuring accurate colors between bands), and aperture photometry (flux measured inside circles of varying size).\n", + "\n", + "First, focus on a known part of the simulation to contain a galaxy cluster (also seen in DP0.2 notebook tutorial 03a). Limit the search to contain galaxies using the `i_extendedness` flag (which will exclude point sources), and to those objects that are unique in the objectTable (by setting `detect_isPrimary` = True). Further, identify objects which have been detected at high signal to noise > 20 and whose photometric measurements have not been flagged as having an issue (`i_kronFlux_flag` or `i_cModel_flag` = 0 means the photometry is ok). " ] }, { @@ -531,9 +535,7 @@ "id": "e6a27a39-ed2b-49fe-ac6d-51ae4c300bfc", "metadata": {}, "source": [ - "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", - "\n", - "First, store the Kron Radius, which is a good proxy for the size of the galaxy light profile, and the AB magnitudes to go with the fluxes extracted from the objectTable." + "Below, store the Kron Radius, which is a good proxy for the size of the galaxy light profile. Then convert the fluxes extracted from the objectTable into AB magnitudes." ] }, { @@ -561,11 +563,14 @@ "id": "85f65eb7-c0c6-45bf-8ff4-4e73b5e9e075", "metadata": {}, "source": [ - "### 2.3.1 Compare aperture photometry to cModel total fluxes\n", + "### 2.3.2 Compare aperture photometry to cModel total fluxes\n", + "\n", + "This section will make several plots that shows how the different photometric measurements compare. Note that cModel is the total flux integrated from a model fit to the galaxy light profile, while Kron, GaaP, and aperture photometry are all measures of light within a fixed aperture. \n", "\n", - "Make a plot that shows how the different photometric measurements compare. Note that cModel is the total flux integrated from a model fit to the galaxy light profile, while Kron and GaaP are both measures of light within a fixed aperture. \n", "\n", - "Generally GaaP magnitudes are larger (fainter) than that measured from cModel, becuase the fixed aperture systematically underestimates the flux in the galaxy wings (and the lost flux increases as the intrinsic size of the galaxy increases, e.g. as traced by the Kron radius)." + "#### 2.3.2.1 Aperture photometry\n", + "\n", + "Generally, magnitudes measured using aperture photometry in the LSST pipeline are larger (i.e. fainter) than those measured from cModel, becuase the fixed circular aperture systematically underestimates the flux in the galaxy wings (and the lost flux increases as the intrinsic size of the galaxy increases, e.g. as traced by the Kron radius)." ] }, { @@ -678,7 +683,7 @@ "\n", "### 2.3.2 Compare Kron and GaaP photometry to cModel\n", "\n", - "In the next cell, compare the cModel to the Kron and GaaP measures." + "In the next cell, compare the cModel instead to the Kron and GaaP measures." ] }, { @@ -693,14 +698,14 @@ "ylims = [-2, 2]\n", "\n", "ax.plot(i_kronRad, (cmodel_mag-kron_mag), '.', alpha=.1,\n", - " label='cModel-Kron', color='blue')\n", + " label='cModel-Kron')\n", "ax.plot(i_kronRad, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", - " label='cModel - gaapOptimal', color='green')\n", + " label='cModel - gaapOptimal')\n", "\n", - "ax2.hist((cmodel_mag-kron_mag), edgecolor='blue', orientation=\"horizontal\",\n", + "ax2.hist((cmodel_mag-kron_mag), orientation=\"horizontal\",\n", " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", " histtype=\"step\", stacked=True, fill=False)\n", - "ax2.hist((cmodel_mag-gaap_mag), edgecolor='green', orientation=\"horizontal\",\n", + "ax2.hist((cmodel_mag-gaap_mag), orientation=\"horizontal\",\n", " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", " histtype=\"step\", stacked=True, fill=False)\n", "\n", @@ -733,14 +738,14 @@ "ax.plot(binctr, bin_mean, color='blue', lw=2, label='bin median', zorder=10)\n", "\n", "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", - " label='cModel - gaapOptimal', color='green')\n", + " label='cModel - gaapOptimal', color='orange')\n", "\n", "x = cmodel_mag\n", "y = (cmodel_mag-gaap_mag)\n", "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", " statistic='median', bins=bins)\n", "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", - "ax.plot(binctr, bin_mean, color='green', lw=2, label='bin median', zorder=10)\n", + "ax.plot(binctr, bin_mean, color='orange', lw=2, label='bin median', zorder=10)\n", "\n", "ax.axhline(0, linestyle='--')\n", "ax.set_xlabel('cModel Magnitude')\n", @@ -756,7 +761,7 @@ "source": [ "The above plots show the parameter space where Kron fluxes do not correspond well with total fluxes (as measured by cModel). This indcates that Kron fluxes will underestimate the total fluxes in the regime of bright magnitudes and large Kron radius. Generally, cModel is recommended over Kron.\n", "\n", - "The GaaP fluxes are not meant to measure total fluxes (from these plots it is clear there is a strong discrepancy with cModel) but GaaP measurements are the best and most robust for measuring robust integrated colors between different filters." + "As explained in Section 1, GaaP fluxes are not meant to measure total fluxes (from these plots it is clear there is a strong discrepancy with cModel) but GaaP measurements are the best and most robust for measuring robust integrated colors between different filters. Thus GaaP measurements should be used for Spectral Energy Distribution (SED) or photometric redshift modeling, or for color selections." ] }, { @@ -766,7 +771,7 @@ "source": [ "### 3. Visualize photometric measurements\n", "\n", - "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the objectTable. The position angle `theta` is defined in radians counterclockwise from the x-axis." + "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the objectTable. The position angle `theta` is defined in radians counterclockwise from the x-axis. This cell will plot for an elongated edge-on galaxy (`objectId` of 1909948454470183768) to ensure that the visualization emphasizes the difference between the elliptical Kron aperture to the circular aperture. " ] }, { @@ -776,13 +781,13 @@ "metadata": {}, "outputs": [], "source": [ - "# Alternatively, pick a different bright object that has large size\n", - "# wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]\n", - "\n", "wh = np.where((tab['objectId'] == 1909948454470183768))[0]\n", "indx = 0\n", "\n", - "arcsec_per_pix = 0.2 # this is the pixel scale\n", + "# Alternatively, pick a different bright object that has large size\n", + "# wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]\n", + "\n", + "arcsec_per_pix = 0.2 # this is the pixel scale\n", "\n", "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx],\n", " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", @@ -834,7 +839,7 @@ "id": "125bf616-aad9-4291-85fe-503b68f0d539", "metadata": {}, "source": [ - "The above figure shows more clearly that there is some fraction of the galaxy's light excluded by each of these photometric apertures (compared to cModel, which approximates the total magnitude using sersic models for the light profile, and indicates the source has brighter magnitude than any of the aperture photometry). " + "The above figure shows more clearly that there is some fraction of the galaxy's light excluded by each of these photometric apertures. Further, printing the different photometry measurements illustrates how these assumed apertures will change the measured flux (compared to the total flux measured by cModel, which approximates the total magnitude using sersic models for the light profile). " ] }, { @@ -844,7 +849,7 @@ "source": [ "## 4. Application of aperture photometry: radial profile\n", "\n", - "A science application for the aperture photometry is easy visualization of the radial profile of the galaxy. In the cell below, make this plot for both a large galaxy and a small galaxy (of similar brightness, cModel magnitude ~ 20). Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." + "A science application for the aperture photometry is easy visualization of the radial profile of galaxies. In the cell below, make this plot for both a large galaxy and a small galaxy (of similar brightness, cModel magnitude ~ 20). Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." ] }, { @@ -854,11 +859,12 @@ "metadata": {}, "outputs": [], "source": [ + "# pick a bright object with large size\n", "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag > 19.9)\n", " & (cmodel_mag < 20.1))[0]\n", "indx = 2\n", "\n", - "rad = np.array([3, 6, 9, 12, 17, 25, 35, 50]) * arcsec_per_pix # convert pix to arcsec\n", + "rad = np.array([3, 6, 9, 12, 17, 25, 35, 50]) * arcsec_per_pix\n", "area = np.pi * rad**2\n", "profile = np.array([tab['i_ap03Flux'][wh][indx], tab['i_ap06Flux'][wh][indx],\n", " tab['i_ap09Flux'][wh][indx], tab['i_ap12Flux'][wh][indx],\n", @@ -867,7 +873,7 @@ " tab['i_ap50Flux'][wh][indx]]) / area\n", "\n", "plt.plot(rad, profile,\n", - " label='Large Kron Radius R='+str(tab['i_kronRad'][wh][indx]*arcsec_per_pix))\n", + " label='Large Kron Radius R='+str(i_kronRad[wh][indx]*arcsec_per_pix))\n", "plt.xlabel('Aperture Radius [arcsec]')\n", "plt.ylabel(r'Surface Brightness [nJy arcsec$^{-2}$]')\n", "\n", @@ -884,10 +890,20 @@ " tab['i_ap50Flux'][wh2][indx]])/area\n", "\n", "plt.plot(rad, profile,\n", - " label='Small Kron Radius R='+str(tab['i_kronRad'][wh2][indx]*arcsec_per_pix))\n", + " label='Small Kron Radius R='+str(i_kronRad[wh2][indx]*arcsec_per_pix))\n", "plt.legend()\n", "plt.yscale('log')" ] + }, + { + "cell_type": "markdown", + "id": "6f271dc2-4d44-41b2-b620-062750deb7b3", + "metadata": {}, + "source": [ + "## 5. Exercise for the learner\n", + "\n", + "Compare the `<f>_free_cModelFlux` measurements to `<f>_cModelFlux` in the filters that are not the reference band where the `<f>_cModelFlux` was measured (i.e. `refBand`). Investigate how leaving the cModel measurements free differs from the one measured with parameters fixed to the `refBand`, as a function of decreasing signal to noise. " + ] } ], "metadata": { From 594243cd5468c92de52d63a19453dfa5cefc2e5f Mon Sep 17 00:00:00 2001 From: Christina Williams <christinawilliams@users.noreply.github.com> Date: Mon, 10 Feb 2025 11:29:27 -0700 Subject: [PATCH 85/99] Delete DP02_16_Galaxy_Photometry.ipynb delete v 16 --- DP02_16_Galaxy_Photometry.ipynb | 1053 ------------------------------- 1 file changed, 1053 deletions(-) delete mode 100644 DP02_16_Galaxy_Photometry.ipynb diff --git a/DP02_16_Galaxy_Photometry.ipynb b/DP02_16_Galaxy_Photometry.ipynb deleted file mode 100644 index 4de9182..0000000 --- a/DP02_16_Galaxy_Photometry.ipynb +++ /dev/null @@ -1,1053 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "749b0ddf", - "metadata": { - "tags": [] - }, - "source": [ - "# DP0.2 Notebook 17 Galaxy Photometry\n", - "\n", - "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", - "<br>\n", - "Contact author(s): <i>Christina Williams</i> <br>\n", - "Last verified to run: <i>2024-01-18</i> <br>\n", - "LSST Science Pipelines version: Weekly <i>2024_24</i> <br>\n", - "Container Size: <i>medium</i> <br>\n", - "Targeted learning level: <i>beginner</i> <br>" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7acc79a4-8530-42d9-96e5-b7acb4397864", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext pycodestyle_magic\n", - "%flake8_on\n", - "import logging\n", - "logging.getLogger(\"flake8\").setLevel(logging.FATAL)" - ] - }, - { - "cell_type": "markdown", - "id": "2963cbac-4ecd-4694-bea3-c111f527e51b", - "metadata": {}, - "source": [ - "**Description:** Explore the available measurements of galaxy photometry produced by the LSST pipelines and their applications." - ] - }, - { - "cell_type": "markdown", - "id": "80a0baf5-51ad-40ec-8991-060a7b27c289", - "metadata": {}, - "source": [ - "**Skills:** Basic understanding of photometric measurement methods typically used to characterize galaxies." - ] - }, - { - "cell_type": "markdown", - "id": "393da88f-7978-4920-aa4a-a9830df6eed9", - "metadata": {}, - "source": [ - "**LSST Data Products:** objectTable" - ] - }, - { - "cell_type": "markdown", - "id": "5c67fab9-136a-4adc-bb42-142b91ab69dd", - "metadata": {}, - "source": [ - "**Packages:** No new LSST packages are introduced here. The notebook will make use of the TAP service from the `lsst.rsp` package." - ] - }, - { - "cell_type": "markdown", - "id": "8f72b27f", - "metadata": {}, - "source": [ - "**Credit:**\n", - "\"This notebook benefitted from earlier exploration of simulated data and notebook development by Melissa Graham and Dan Taranu. " - ] - }, - { - "cell_type": "markdown", - "id": "28e91cbf-ab7f-4e26-9276-b00299d6065e", - "metadata": {}, - "source": [ - "**Get Support:**\n", - "Find DP0-related documentation and resources at <a href=\"https://dp0.lsst.io\">dp0.lsst.io</a>.\n", - "Questions are welcome as new topics in the \n", - "<a href=\"https://community.lsst.org/c/support/dp0\">Support - Data Preview 0 Category</a> \n", - "of the Rubin Community Forum. \n", - "Rubin staff will respond to all questions posted there." - ] - }, - { - "cell_type": "markdown", - "id": "cfc73be0", - "metadata": {}, - "source": [ - "## 1. Introduction\n", - "\n", - "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a> about the PSF photometry. \n", - "\n", - "Please note that these explanations are specific to DP0.2: the objectTable contents and definitions are still subject to change for DP1. \n" - ] - }, - { - "cell_type": "markdown", - "id": "7eb3ba1f-659f-4cb0-acad-52690f60a485", - "metadata": { - "execution": { - "iopub.execute_input": "2024-12-02T22:37:09.704845Z", - "iopub.status.busy": "2024-12-02T22:37:09.704072Z", - "iopub.status.idle": "2024-12-02T22:37:10.367698Z", - "shell.execute_reply": "2024-12-02T22:37:10.366983Z", - "shell.execute_reply.started": "2024-12-02T22:37:09.704824Z" - } - }, - "source": [ - "### 1.1 Types of photometry measurements that exist in the Object Table\n", - "\n", - "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", - "\n", - "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there: The first are total fluxes are those that integrate the total light coming from objects, corrected for loss due to the blurring effects of PSF or seeing, including \"Composite Model\" (`cModel`) fluxes. The second category characterize the relative brightness of objects for specific regions of objects (i.e. are not corrected to be total fluxes) but can be useful for measuring accurate light profiles or accurate colors.\n", - "\n", - "### 1.1.1 Total fluxes\n", - "\n", - "\n", - "#### Composite Model (CModel) fluxes\n", - "\n", - "Similar in nature to those measured for SDSS: \n", - "https://www.sdss3.org/dr8/algorithms/magnitudes.php#cmodel\n", - "\n", - "In short, it is the linear combination of the best fit exponential (disk or D) and de Vaucouleurs (bulge or B) profiles. \n", - "\n", - "```\n", - "<f>_cModelFlux : Flux from the final cmodel fit. Forced on <f>-band.\n", - "<f>_cModelFluxErr : Uncertainty of <f>_cModelFlux\n", - "<f>_cModel_flag : Failure flag for <f>_cModelFlux\n", - "```\n", - "\n", - "For most cases the fixed cModel photometry are preferred to that with more degrees of freedom labeled `<f>_free_cModelFlux`. The difference is that the default uses a reference band where the galaxy is well detected to determine the other parameters, which are then fixed when fitting for the flux in the other bands. The `_free_cModelFlux` measurement allows all parameters to be free independent in each filter. The fixed `_cModelFlux` measurements are generally recommended for galaxy science applications where total flux measurements are needed (e.g. for intrinsic luminosity or mass).\n", - "\n", - "### 1.1.2 Apparent fluxes (i.e. not corrected to the total flux)\n", - " \n", - "#### Kron fluxes\n", - "\n", - "A decent summary of Kron fluxes <a href=\"https://ned.ipac.caltech.edu/level5/March05/Graham/Graham2_6.html\">in the NED documentation</a>. The aperture used for the fluxes is 2.5 x R1 where R1 is the luminosity weighted radius (also called \"first moment\"; which extends to where the flux reaches 1% of the sky background; Kron et al. 1980).\n", - "\n", - "```\n", - "<f>_kronFlux : Flux from Kron Flux algorithm. Measured on <f> g-band.\n", - "<f>_kronFluxErr : Uncertainty of <f>_kronFlux.\n", - "<f>_kronFlux_flag : Failure flag for <f>_kronFlux.\n", - "```\n", - "\n", - "The Kron radius, `<f>_kronRad`, is also available. In this case of LSST pipeline output, the Kron flux is not corrected for light that is emitted outside of the Kron aperture. While in many cases it will collect the majority of light, it will not be as accurate as the cModel for science cases requiring total flux.\n", - "\n", - "\n", - "#### Aperture fluxes\n", - "This contains the enclosed flux inside a given aperture (they are not corrected to total fluxes using an aperture correction that accounts for the flux falling outside the aperture). Fixed aperture size refers to the aperture radius in pixels.\n", - "\n", - "```\n", - "<f>_ap<pix>Flux : Flux within <pix>-pixel aperture. Forced on <f>-band.\n", - "<f>_ap<pix>FluxErr : Uncertainty of <f>_ap<pix>Flux.\n", - "<f>_ap<pix>FluxFlag : Failure flag for <f>_ap<pix>Flux.\n", - "```\n", - "\n", - "For DP0.2, the apertures are 3, 6, 9, 12, 17, 25, 35, 50, and 70 pixels. In the column name, apertures are `03`, `06`, `09`, `12`, and so on. While aperture fluxes are not corrected for the loss outside the aperture, if the aperture size is much larger than the galaxy size then it will approximate the total flux of the galaxy. The general application of these measurements are for measuring radial profiles (see Section XX).\n", - "\n", - "#### GaaP fluxes\n", - "\n", - "These are the Gaussian-aperture-and-PSF flux from <a href=\"https://ui.adsabs.harvard.edu/abs/2008A%26A...482.1053K/abstract\">Kuijken et al. 2008</a>. The main goal of this method is to measure accurate colors while accounting for the different spatial resolution between filters. This is sometimes done by convolving all images to the largest PSF, but this process is computationally very time consuming for large images. It is not a measure of total flux in a filter. Several apertures are available. For photometric redshifts, and other analysis where accurate colors are important, it is the GaaP fluxes with optimal aperture that should be used. \n", - "\n", - "**Optimal**\n", - "\n", - "```\n", - "<f>_gaapOptimalFlux : GaaP flux with optimal aperture after multiplying the seeing by 1.15. Forced on <f>-band.\n", - "<f>_gaapOptimalFluxErr : Uncertainty of <f>_gaapOptimalFlux.\n", - "```\n", - "\n", - "**PSF**\n", - "\n", - "```\n", - "<f>_gaapPsfFlux : GaaP flux with PSF aperture after multiplying the seeing by 1.15. Forced on <f>-band.\n", - "<f>_gaapPsfFluxErr : Uncertainty of <f>_gaapPsfFlux.\n", - "```\n", - "\n", - "**Aperture**\n", - "\n", - "```\n", - "<f>_gaap<ap>Flux : GaaP flux with <ap> aperture after multiplying the seeing aperture. Forced on <f>-band.\n", - "<f>_gaap<ap>FluxErr : Uncertainty of <f>_gaap<ap>Flux.\n", - "```\n", - "\n", - "Where the seeing apertures are 0.5, 0.7, 1.0, 1.5, 2.5, and 3.0 arcseconds. In the column name `<ap>` appears as `0p5`, `0p7`, etc.\n", - "\n", - "\n", - "#### PSF fluxes\n", - "\n", - "Fluxes derived using the model point-spread function (PSF) of the image. Since PSF fluxes are designed for unresolved sources (not the majority of galaxies) this notebook will not explore science applications for this type of photometry. Interested users can find more information in the PSF Tutorial notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a>.\n", - "\n", - "```\n", - "<f>_psfFlux : Flux derived from linear least-squares fit of PSF model. Forced on <f>-band.\n", - "<f>_psfFluxErr : Uncertainty of <f>_psfFlux.\n", - "<f>_psfFlux_flag : Failure flag for <f>_psfFlux.\n", - "\n", - "```\n" - ] - }, - { - "cell_type": "markdown", - "id": "dc36f107", - "metadata": {}, - "source": [ - "### 1.2 Import packages\n" - ] - }, - { - "cell_type": "markdown", - "id": "ccb4fe61-835a-47ac-a691-e086ce766e79", - "metadata": {}, - "source": [ - "`numpy` is a fundamental package for scientific computing with arrays in Python\n", - "(<a href=\"https://numpy.org\">numpy.org</a>).\n", - "\n", - "`matplotlib` is a comprehensive library for creating static, animated, and\n", - "interactive visualizations in Python \n", - "(<a href=\"https://matplotlib.org/\">matplotlib.org</a>; \n", - "<a href=\"https://matplotlib.org/stable/gallery/index.html\">matplotlib gallery</a>).\n", - "\n", - "From the `lsst` package, modules for accessing the TAP service, the butler, and image display functions are imported (<a href=\"https://pipelines.lsst.io/\">pipelines.lsst.io</a>)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2dbc75bd-a802-4576-8628-4e0088942303", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import gc\n", - "import numpy as np\n", - "import sys\n", - "\n", - "from scipy.stats import binned_statistic, sigmaclip\n", - "\n", - "import uuid\n", - "import os\n", - "import glob\n", - "\n", - "import lsst.geom as geom\n", - "import lsst.resources\n", - "import lsst.afw.display as afwDisplay\n", - "from lsst.afw.image import Exposure, ExposureF\n", - "from lsst.pipe.tasks.registerImage import RegisterConfig, RegisterTask\n", - "from lsst.rsp import get_tap_service\n", - "from lsst.rsp.utils import get_access_token\n", - "from lsst.afw.fits import MemFileManager\n", - "import lsst.afw.geom.ellipses as ellipses\n", - "\n", - "\n", - "import pyvo\n", - "from pyvo.dal.adhoc import DatalinkResults, SodaQuery\n", - "\n", - "from astropy import units as u\n", - "from astropy.coordinates import SkyCoord, Angle\n", - "from astropy.io import fits\n", - "from astropy.wcs import WCS\n", - "\n", - "from photutils.aperture import SkyCircularAperture, SkyEllipticalAperture\n" - ] - }, - { - "cell_type": "markdown", - "id": "c217adff-25ed-4fce-95e7-8aa04630f6cc", - "metadata": {}, - "source": [ - "### 1.3 Define functions and parameters\n", - "\n", - "\n", - "#### 1.3.1 Define some aesthetic plotting defaults" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0d2ecffa-a837-4d10-be95-616c95fda15f", - "metadata": {}, - "outputs": [], - "source": [ - "plt.style.use('tableau-colorblind10')\n", - "afwDisplay.setDefaultBackend('matplotlib')\n", - "\n", - "params = {'axes.labelsize': 18,\n", - " 'font.size': 18,\n", - " 'legend.fontsize': 12,\n", - " 'xtick.major.width': 2,\n", - " 'xtick.minor.width': 1,\n", - " 'xtick.major.size': 10,\n", - " 'xtick.minor.size': 4,\n", - " 'xtick.direction': 'in',\n", - " 'xtick.top': True,\n", - " 'lines.linewidth': 2,\n", - " 'axes.linewidth': 2,\n", - " 'axes.labelweight': 2,\n", - " 'axes.titleweight': 2,\n", - " 'ytick.major.width': 2,\n", - " 'ytick.minor.width': 1,\n", - " 'ytick.major.size': 10,\n", - " 'ytick.minor.size': 4,\n", - " 'ytick.direction': 'in',\n", - " 'ytick.right': True,\n", - " 'figure.figsize': [6, 6],\n", - " 'figure.facecolor': 'White'\n", - " }\n", - "plt.style.use('tableau-colorblind10')\n", - "\n", - "plt.rcParams.update(params)" - ] - }, - { - "cell_type": "markdown", - "id": "5e6352ac-09dd-4be0-bff3-379860c12a69", - "metadata": {}, - "source": [ - "#### 1.3.2 Define a shortcut function to generate an image cutout using the cutout tool\n", - "Further information about the cutout tool can be found in tutorial notebook 13a." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "07bba696-f49c-46e3-b867-61063195be99", - "metadata": {}, - "outputs": [], - "source": [ - "def make_image_cutout_new(tap_service, ra, dec, cutout_size=0.01):\n", - " \"\"\"Wrapper function to generate a cutout using the cutout tool\n", - "\n", - " Parameters\n", - " ----------\n", - " tap_service : an instance of the TAP service\n", - " ra, dec : 'float'\n", - " the ra and dec of the cutout center\n", - " cutout_size : 'float', optional\n", - " edge length in degrees of the cutout\n", - "\n", - " Returns\n", - " -------\n", - " mem : 'object'\n", - " An lsst.afw.fits._fits.MemFileManager object containing the\n", - " cutout image bytes returned by the cutout tool\n", - " \"\"\"\n", - "\n", - " spherePoint = geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)\n", - " coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree, frame='icrs')\n", - "\n", - " band = 'i'\n", - "\n", - " query = \"SELECT access_format, access_url, dataproduct_subtype, \" + \\\n", - " \"lsst_patch, lsst_tract, lsst_band, s_ra, s_dec \" + \\\n", - " \"FROM ivoa.ObsCore WHERE dataproduct_type = 'image' \" + \\\n", - " \"AND obs_collection = 'LSST.DP02' \" + \\\n", - " \"AND dataproduct_subtype = 'lsst.deepCoadd_calexp' \" + \\\n", - " \"AND lsst_band = \" + \"'\" + str(band) + \"' \" + \\\n", - " \"AND CONTAINS(POINT('ICRS', \" + str(coord.ra.value) + \\\n", - " \", \" + str(coord.dec.value) + \"), \" + \\\n", - " \"s_region) = 1\"\n", - "\n", - " results = tap_service.search(query)\n", - "\n", - " # Get datalink\n", - " dataLinkUrl = results[0].getdataurl()\n", - " auth_session = service._session\n", - " dl = DatalinkResults.from_result_url(dataLinkUrl,\n", - " session=auth_session)\n", - "\n", - " # from_resource: creates a instance from\n", - " # a number of records and a Datalink Resource.\n", - " sq = SodaQuery.from_resource(dl,\n", - " dl.get_adhocservice_by_id(\"cutout-sync\"),\n", - " session=auth_session)\n", - "\n", - " sq.circle = (spherePoint.getRa().asDegrees() * u.deg,\n", - " spherePoint.getDec().asDegrees() * u.deg,\n", - " cutout_size * u.deg)\n", - " cutout_bytes = sq.execute_stream().read()\n", - " mem = MemFileManager(len(cutout_bytes))\n", - " mem.setData(cutout_bytes, len(cutout_bytes))\n", - "\n", - " return mem" - ] - }, - { - "cell_type": "markdown", - "id": "ec51ac0b", - "metadata": { - "tags": [] - }, - "source": [ - "## 2. Integrated photometry of galaxies using the LSST pipeline\n", - "\n", - "This section will explore the total, integrated photometry measurements, and provide some guidance for which are optimal for certain science applications using galaxies. \n" - ] - }, - { - "cell_type": "markdown", - "id": "45c86ed0-aebe-4d74-af42-619c0f6b0705", - "metadata": {}, - "source": [ - "### 2.1 Initialize the TAP service" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": {}, - "outputs": [], - "source": [ - "service = get_tap_service(\"tap\")" - ] - }, - { - "cell_type": "markdown", - "id": "9547e659-fd0e-432c-af25-968cc9ebea9d", - "metadata": {}, - "source": [ - "### 2.2 Object table photometry measurements\n", - "\n", - "First see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "999d12f2-b84b-4a80-a7fd-f7f111674470", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT column_name, datatype, description, unit \" \\\n", - " \"FROM tap_schema.columns \" \\\n", - " \"WHERE table_name = 'dp02_dc2_catalogs.Object'\"\n", - "\n", - "results = service.search(query).to_table()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3c0a793b-f6b1-4e39-99a2-1fd5b26fe4ae", - "metadata": {}, - "outputs": [], - "source": [ - "search_string = 'Flux'\n", - "band = 'i_'\n", - "for cname in results['column_name']:\n", - " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", - " print(cname)" - ] - }, - { - "cell_type": "markdown", - "id": "caf9008d-e3aa-4908-bf32-a27cbe890a4f", - "metadata": {}, - "source": [ - "## 2.3 Compare photometric measurements\n", - "\n", - "Below, query the DP0.2 objectTable for a selection of photometric measurements. This section will focus on 3 measurements: total flux from cModel (sum of bulge and disk sersic compoents fitted to the galaxy); and apparent fluxes measured as Kron (typically includes more than 90% of intrinsic light) and GaaP (which is optimized for measuring accurate colors between bands).\n", - "\n", - "First, focus on a known part of the simulation to contain a galaxy cluster (also seen in DP0.2 notebook tutorial 03a). Search for all galaxies (the `i_extendedness` flag will exclude point sources) that are unique in the objectTable (`detect_isPrimary` = True). Further, identify objects which have been detected at high signal to noise > 10 and whose photometric measurements have not been flagged as having an issue (`i_kronFlux_flag` or `i_cModel_flag` = 0 means the photometry is ok). " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "14450d07-0c29-4342-91f2-72ccc4cecfb0", - "metadata": {}, - "outputs": [], - "source": [ - "cluster_RA = 55.7506834813934\n", - "cluster_dec = -32.28892993702273\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0d82dd79-a4d7-4428-a77c-1ed2bb717486", - "metadata": {}, - "outputs": [], - "source": [ - "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, \" + \\\n", - " \"obj.detect_fromBlend, obj.detect_isIsolated, \" + \\\n", - " \"obj.i_blendedness, obj.i_extendedness, \" + \\\n", - " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, \" + \\\n", - " \"obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.i_kronFlux_flag, obj.i_cModel_flag, \" + \\\n", - " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, \" + \\\n", - " \"obj.i_ap03Flux, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap12Flux, \" + \\\n", - " \"obj.i_ap17Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux \" + \\\n", - " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", - " \"WHERE (obj.detect_isPrimary = 1) AND \" + \\\n", - " \"(obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND \" + \\\n", - " \"(obj.i_extendedness = 1) AND \" + \\\n", - " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", - " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), \" + \\\n", - " \"CIRCLE('ICRS',\"+str(cluster_RA)+\",\"+str(cluster_dec)+\", 0.1)) = 1 \"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e75ee4db-e4b9-4ff2-ba07-1f7f34a8d44b", - "metadata": {}, - "outputs": [], - "source": [ - "job = service.submit_job(query)\n", - "job.run()\n", - "job.wait(phases=['COMPLETED', 'ERROR'])\n", - "print('Job phase is', job.phase)" - ] - }, - { - "cell_type": "markdown", - "id": "6d90ce60-2dc7-432d-bf12-1679cd43c3f3", - "metadata": {}, - "source": [ - "Print the results of the search query." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "02ea5eb7-bac9-4c9f-90e4-626a69340b41", - "metadata": {}, - "outputs": [], - "source": [ - "results = job.fetch_result()\n", - "print(len(results))\n", - "tab = results.to_table()\n", - "tab" - ] - }, - { - "cell_type": "markdown", - "id": "e6a27a39-ed2b-49fe-ac6d-51ae4c300bfc", - "metadata": {}, - "source": [ - "This section will explore 3 photometric measurements that are relevant for galaxies: cModel, Kron and GaaP (as defined in Section 2.1). \n", - "\n", - "First, store the Kron Radius, which is a good proxy for the size of the galaxy light profile, and the AB magnitudes to go with the fluxes extracted from the objectTable." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e8b4a64a-6565-4d7d-ae48-0a666c41101e", - "metadata": {}, - "outputs": [], - "source": [ - "i_kronRad = tab['i_kronRad']\n", - "\n", - "cmodel_mag = -2.50 * np.log10(tab['i_cModelFlux']) + 31.4\n", - "kron_mag = -2.50 * np.log10(tab['i_kronFlux']) + 31.4\n", - "gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n", - "\n", - "ap06_mag = -2.50 * np.log10(tab['i_ap06Flux']) + 31.4\n", - "ap12_mag = -2.50 * np.log10(tab['i_ap12Flux']) + 31.4\n", - "\n", - "ap09_mag = -2.50 * np.log10(tab['i_ap09Flux']) + 31.4\n", - "ap17_mag = -2.50 * np.log10(tab['i_ap17Flux']) + 31.4\n" - ] - }, - { - "cell_type": "markdown", - "id": "85f65eb7-c0c6-45bf-8ff4-4e73b5e9e075", - "metadata": {}, - "source": [ - "### 2.3.1 Compare aperture photometry to cModel total fluxes\n", - "\n", - "Make a plot that shows how the different photometric measurements compare. Note that cModel is the total flux integrated from a model fit to the galaxy light profile, while Kron and GaaP are both measures of light within a fixed aperture. \n", - "\n", - "Generally GaaP magnitudes are larger (fainter) than that measured from cModel, becuase the fixed aperture systematically underestimates the flux in the galaxy wings (and the lost flux increases as the intrinsic size of the galaxy increases, e.g. as traced by the Kron radius)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d72bd736-3fb0-40b6-a607-a583ab4773ea", - "metadata": {}, - "outputs": [], - "source": [ - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1,\n", - " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", - "\n", - "ylims = [-1.5, 1.5]\n", - "\n", - "ax.plot(i_kronRad, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", - " label='cModel - 17-pix aperture', color='blue')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", - " label='cModel 12-pix aperture', color='green')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", - " label='cModel 9-pix aperture', color='orange')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", - " label='cModel 6-pix aperture', color='red')\n", - "\n", - "ax2.hist((cmodel_mag-ap17_mag), edgecolor='blue', orientation=\"horizontal\",\n", - " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", - " histtype=\"step\", stacked=True, fill=False)\n", - "ax2.hist((cmodel_mag-ap12_mag), edgecolor='green', orientation=\"horizontal\",\n", - " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", - " histtype=\"step\", stacked=True, fill=False)\n", - "ax2.hist((cmodel_mag-ap09_mag), edgecolor='orange', orientation=\"horizontal\",\n", - " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", - " histtype=\"step\", stacked=True, fill=False)\n", - "ax2.hist((cmodel_mag-ap06_mag), edgecolor='red', orientation=\"horizontal\",\n", - " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", - " histtype=\"step\", stacked=True, fill=False)\n", - "\n", - "ax2.set_ylim(ylims)\n", - "ax.axhline(0, linestyle='--')\n", - "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", - "ax.set_ylabel('cModel mag - Aperture mag')\n", - "ax.set_ylim(ylims)\n", - "ax.set_xlim([0, 15])\n", - "ax.legend()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "709a40cf-df65-42ff-8a30-c787bcd79499", - "metadata": {}, - "outputs": [], - "source": [ - "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", - "ylims = [-1.2, 1.2]\n", - "bins = np.arange(16, 27, 1)\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", - " label='cModel 6-pix aperture', color='red')\n", - "x = cmodel_mag\n", - "y = (cmodel_mag-ap06_mag)\n", - "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", - " statistic='median', bins=bins)\n", - "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", - "ax.plot(binctr, bin_mean, color='red', lw=2, label='bin median', zorder=10)\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", - " label='cModel 9-pix aperture', color='orange')\n", - "x = cmodel_mag\n", - "y = (cmodel_mag-ap09_mag)\n", - "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", - " statistic='median', bins=bins)\n", - "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", - "ax.plot(binctr, bin_mean, color='orange', lw=2,\n", - " label='bin median', zorder=10)\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", - " label='cModel 12-pix aperture', color='green')\n", - "x = cmodel_mag\n", - "y = (cmodel_mag-ap12_mag)\n", - "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", - " statistic='median', bins=bins)\n", - "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", - "ax.plot(binctr, bin_mean, color='green', lw=2,\n", - " label='bin median', zorder=10)\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", - " label='cModel 17-pix aperture', color='blue')\n", - "x = cmodel_mag\n", - "y = (cmodel_mag-ap17_mag)\n", - "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", - " statistic='median', bins=bins)\n", - "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", - "ax.plot(binctr, bin_mean, color='blue', lw=2,\n", - " label='bin median', zorder=10)\n", - "\n", - "ax.axhline(0, linestyle='--')\n", - "ax.set_xlabel('cModel Magnitude')\n", - "ax.set_ylabel('cModel mag - Aperture mag')\n", - "ax.set_ylim([-1, 1])\n", - "ax.legend()\n" - ] - }, - { - "cell_type": "markdown", - "id": "cef81cea-b352-4196-a4d0-c5b4ad80bd00", - "metadata": {}, - "source": [ - "These two figures show that the aperture photometry typically under-estimates the flux relative to the total flux estimated using cModel. As expected, there is a general trend for larger apertures to get closer to the total flux from cModel for large galaxies (i.e. whose Kron Radius is larger). There is also a general trend for the aperture photometry to be less discrepant at fainter magnitudes, since faint galaxies tend to be small.\n", - "\n", - "\n", - "### 2.3.2 Compare Kron and GaaP photometry to cModel\n", - "\n", - "In the next cell, compare the cModel to the Kron and GaaP measures." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "05e30151-1346-425a-a86f-f2a7c945a45c", - "metadata": {}, - "outputs": [], - "source": [ - "fig, (ax, ax2) = plt.subplots(ncols=2, nrows=1,\n", - " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", - "ylims = [-2, 2]\n", - "\n", - "ax.plot(i_kronRad, (cmodel_mag-kron_mag), '.', alpha=.1,\n", - " label='cModel-Kron', color='blue')\n", - "ax.plot(i_kronRad, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", - " label='cModel - gaapOptimal', color='green')\n", - "\n", - "ax2.hist((cmodel_mag-kron_mag), edgecolor='blue', orientation=\"horizontal\",\n", - " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", - " histtype=\"step\", stacked=True, fill=False)\n", - "ax2.hist((cmodel_mag-gaap_mag), edgecolor='green', orientation=\"horizontal\",\n", - " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", - " histtype=\"step\", stacked=True, fill=False)\n", - "\n", - "ax2.set_ylim(ylims)\n", - "ax.axhline(0, linestyle='--')\n", - "ax.set_xlabel('Kron Radius [i-band; pixels]')\n", - "ax.set_ylabel('cModel mag - Other mag')\n", - "ax.set_ylim(ylims)\n", - "ax.set_xlim([0, 15])\n", - "ax.legend()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4539933a-3cf9-46e7-b39a-60101ff97b2a", - "metadata": {}, - "outputs": [], - "source": [ - "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", - "ylims = [-1.2, 1.2]\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-kron_mag), '.', alpha=.1,\n", - " label='cModel-Kron', color='blue')\n", - "x = cmodel_mag\n", - "y = (cmodel_mag-kron_mag)\n", - "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", - " statistic='median', bins=bins)\n", - "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", - "ax.plot(binctr, bin_mean, color='blue', lw=2, label='bin median', zorder=10)\n", - "\n", - "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", - " label='cModel - gaapOptimal', color='green')\n", - "\n", - "x = cmodel_mag\n", - "y = (cmodel_mag-gaap_mag)\n", - "bin_mean, bin_edge, binnum = binned_statistic(x, y,\n", - " statistic='median', bins=bins)\n", - "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", - "ax.plot(binctr, bin_mean, color='green', lw=2, label='bin median', zorder=10)\n", - "\n", - "ax.axhline(0, linestyle='--')\n", - "ax.set_xlabel('cModel Magnitude')\n", - "ax.set_ylabel('cModel mag - Other mag')\n", - "ax.set_ylim([-1, 1])\n", - "ax.legend()" - ] - }, - { - "cell_type": "markdown", - "id": "9aec6b4b-ada8-429d-a65f-c076d8d26872", - "metadata": {}, - "source": [ - "The above plots show the parameter space where Kron fluxes do not correspond well with total fluxes (as measured by cModel). This indcates that Kron fluxes will underestimate the total fluxes in the regime of bright magnitudes and large Kron radius. Generally, cModel is recommended over Kron.\n", - "\n", - "The GaaP fluxes are not meant to measure total fluxes (from these plots it is clear there is a strong discrepancy with cModel) but GaaP measurements are the best and most robust for measuring robust integrated colors between different filters." - ] - }, - { - "cell_type": "markdown", - "id": "48d5bfb6-dc27-4ed8-b615-78216710912e", - "metadata": {}, - "source": [ - "### 3. Visualize photometric measurements\n", - "\n", - "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the objectTable. The position angle `theta` is defined in radians counterclockwise from the x-axis." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "49387e7a-9e0d-4e00-a2b9-8767ab667929", - "metadata": {}, - "outputs": [], - "source": [ - "# pick an object that has large size\n", - "# wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]\n", - "\n", - "wh = np.where((tab['objectId'] == 1909948454470183768))[0]\n", - "indx = 0\n", - "\n", - "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx],\n", - " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", - "\n", - "cutout = ExposureF(mem)\n", - "\n", - "axes = ellipses.Axes(ellipses.Quadrupole(tab['shape_xx'][wh][indx],\n", - " tab['shape_yy'][wh][indx],\n", - " tab['shape_xy'][wh][indx]))\n", - "semi_maj_rad = axes.getA()\n", - "semi_min_rad = axes.getB()\n", - "theta = axes.getTheta()\n", - "\n", - "plt.subplot(projection=WCS(cutout.getWcs().getFitsMetadata()))\n", - "extent = (cutout.getBBox().beginX, cutout.getBBox().endX,\n", - " cutout.getBBox().beginY, cutout.getBBox().endY)\n", - "\n", - "plt.imshow(cutout.image.array, vmin=.1, vmax=3,\n", - " extent=extent, origin='lower', cmap='gray')\n", - "\n", - "coord = SkyCoord(ra=tab['coord_ra'][wh][indx]*u.degree,\n", - " dec=tab['coord_dec'][wh][indx]*u.degree, frame='icrs')\n", - "\n", - "aperture = SkyCircularAperture(coord, r=17 * 0.2 * u.arcsec)\n", - "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='r', lw=3, label='17 pix aperture')\n", - "\n", - "aperture = SkyCircularAperture(coord, r=35 * 0.2 * u.arcsec)\n", - "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='g', lw=3, label='35 pix aperture')\n", - "\n", - "aperture = SkyEllipticalAperture(coord, 2.5 * semi_maj_rad * 0.2 * u.arcsec,\n", - " 2.5 * semi_min_rad * 0.2 * u.arcsec,\n", - " theta=(np.pi/2 + theta) * u.rad)\n", - "\n", - "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='b', lw=3, label='Kron')\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "id": "714badaa-834d-4050-82a6-ffcac245ae5c", - "metadata": {}, - "source": [ - "## 4 Application of aperture photometry: radial profile\n", - "\n", - "A science application for the aperture photometry is easy visualization of the radial profile of the galaxy. In the cell below, make this plot for both a large galaxy and a small galaxy (of similar brightness, cModel magnitude ~ 20). Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "432db690-be7e-43bf-a640-a80af727652b", - "metadata": {}, - "outputs": [], - "source": [ - "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag > 19.9)\n", - " & (cmodel_mag < 20.1))[0]\n", - "indx = 2\n", - "\n", - "rad = np.array([3, 6, 9, 12, 17, 25, 35, 50]) * 0.2 # convert pix to arcsec\n", - "area = np.pi * rad**2\n", - "profile = np.array([tab['i_ap03Flux'][wh][indx], tab['i_ap06Flux'][wh][indx],\n", - " tab['i_ap09Flux'][wh][indx], tab['i_ap12Flux'][wh][indx],\n", - " tab['i_ap17Flux'][wh][indx], tab['i_ap25Flux'][wh][indx],\n", - " tab['i_ap35Flux'][wh][indx],\n", - " tab['i_ap50Flux'][wh][indx]]) / area\n", - "\n", - "plt.plot(rad, profile,\n", - " label='Large Kron Radius R='+str(tab['i_kronRad'][wh][indx]*.2))\n", - "plt.xlabel('Aperture Radius [arcsec]')\n", - "plt.ylabel(r'Surface Brightness [nJy arcsec$^{-2}$]')\n", - "\n", - "# pick an object that has large size\n", - "wh2 = np.where((tab['i_kronRad'] < 8) & (tab['i_kronRad'] > 5)\n", - " & (cmodel_mag > 19.9) & (cmodel_mag < 20.1))[0]\n", - "\n", - "indx = 1\n", - "\n", - "profile = np.array([tab['i_ap03Flux'][wh2][indx], tab['i_ap06Flux'][wh2][indx],\n", - " tab['i_ap09Flux'][wh2][indx], tab['i_ap12Flux'][wh2][indx],\n", - " tab['i_ap17Flux'][wh2][indx], tab['i_ap25Flux'][wh2][indx],\n", - " tab['i_ap35Flux'][wh2][indx],\n", - " tab['i_ap50Flux'][wh2][indx]])/area\n", - "\n", - "plt.plot(rad, profile,\n", - " label='Small Kron Radius R='+str(tab['i_kronRad'][wh2][indx]*.2))\n", - "plt.legend()\n", - "plt.yscale('log')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a647aa1e-bb8a-4f64-aff9-670b13997d87", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "52267cd8-1041-4e09-bda1-248468b21971", - "metadata": {}, - "source": [ - " OLD STUFF BELOW: (see notes from Melissa 1/14 at the end for the plan)" - ] - }, - { - "cell_type": "markdown", - "id": "2e364b4b-7cfd-4bfd-af48-8f08e0af2481", - "metadata": {}, - "source": [ - "easier for someone to correct something i've done wrong than to tell me the right way to do it (so, try to write it up and take af irst stab at it and then ask if thats what they were going for). \n", - "\n", - "for DP1: here is literal interpretation of measurement (these should be short)\n", - "\n", - "then one for low-z galaxies and nuances of measuring photometry\n", - "\n", - "then one for high-z galaxies \n", - "\n", - "AGN: point source right in the center thats a better science case than the SN contamination one. there will be more of these and stacking doesn't take it out.\n", - "\n", - "can we think of a science case we would want to use galaxy photometry from a calexp? this is probably a different science case. lets exclude calexp photometry form this notebook. \n", - "\n", - "when you're ready for input from DM make a list of what i want help with (so Yusra can find someone for help and then help them respond to specific questions\n", - "\n", - "1/14/24 meeting with melissa:\n", - "\n", - "pull out a minimum (short) version of htis that is just hte stuff i'm sure about (descriptive) minimal on science demo. try to compare one measurement to the other (problem with truth is that people may remember forever that cmodel is best however it could just be that cmodel recovered with cmodel performed well.\n", - "\n", - "find a galaxy and show difference size of apertures on there as a demo. upper undergrad level. \n", - "\n", - "we are def going to have object catalogs for DP1 so we will need a tutorial for that. \n", - "\n", - "have shenming review (does weak lensing and. first talk to melissa to let her know then she will see hwat shenming is up to.\n", - "\n", - "Dan has thoughts about the sersic model photometry, talk to him at some point. He's been experimenting with single sersic photometry from multiprofit" - ] - }, - { - "cell_type": "markdown", - "id": "9872892a-18d7-4f6f-a82a-cbe970f1f60f", - "metadata": {}, - "source": [ - "Dan:\n", - "Jim: algorithms workshop maybe there are some slides somewhere. lsst algorithms workshop project.lsst.org/meetings/log\n", - "thursday morning plans for galaxy photometry\n", - "\n", - "Gaap is supposed to be more consistent in colors not more accurate. it sounds like people have not looked at whehter or not the different measures are better. Photo-z team \n", - "\n", - "ellipse parameters are probably from sdss shape: \n", - "\n", - "we think that xx yy and xy are related to kron and you can reconstruct the PA from that.\n", - "most moment measurements are on un-PSF-convolved (not corrected for PSF) ASK JIM ABOUT THIS they are doing a deep dive overhaul of the schema. if there are things that have fallen out of the schema tell him\n", - "\n", - "cmodel and alos cmodel_free (which have separate free params per band) without _free has fixed to some detection or ref band (and there's a separate column for that called ref)\n", - "\n", - "cmodel does fit its own ellipse params but they are not in the schema\n", - "\n", - "cmodel for galaxies because they are total fluxes\n", - "psf mags for stars.\n", - "consider using Gaap colors for photo-z and stellar pops modeling\n", - "\n", - "kron or aperture photometry: but we don't need to provide recommendations on if to use them or not. Perhaps in situations where you don't \n", - "\n", - "they are curious to know what is the performance\n", - "\n", - "https://www.sdss4.org/dr17/algorithms/magnitudes/\n", - "radial profiles is the purpose of the aperture photometry\n", - "\n", - "Jim explains that applying aperture corrections for galaxies is basically impossible (??)\n", - "\n", - "The backgrounds for LSST are brighter / and harder to subtract than space based, which is why these dont' have aperture corrections done?\n", - "\n", - "A random galaxy person should just use sersic fluxes (i.e. cModel). In DP1 one can expect that there will be a single sersic model (multiprofit) photometry included.\n", - "\n", - "our fixed aperture radius photometry is not done in PSF homogenized images\n", - "\n", - "COSMOS2020 corrects to total fluxes using method of Lake et al.\n", - "\n", - "can compute from kron parameters what the missing flux outside the aperture is. for an object htat is considerably bigger than the PSF yes.\n", - "\n", - "pick a typical SFG and a typical elliptical and show the different apertures and compare the flux measurements then this would be useful\n", - "\n", - "sci-unit: \n", - "https://rubinobs.atlassian.net/browse/LVV-508\n", - "\n", - "Notes from Jim Bosch presentations on galaxy photometry (4 years ago):\n", - "CModel: fit an exp profile, fit a de vaucouleurs profile, fit a linear combo of both while holding ellipse params fixed. This is basically what SDSS did and it doesn't do well with LSST data with one difference: LSST version approximates profiles as sums of gaussians (Hogg & Lang 2012) and PSFs as sums of shapelets for speed. This has worked well and whatever we do with galaxy photometry will include this.\n", - "\n", - "However they think CMOdel is a placeholder for something else. It worked well for SDSS but never had good performance with HSC. Bad with background estimation and deblending.\n", - "\n", - "Dan developed multiprofit which we think we will use: not as fast but is better and can run on multiple bands.\n", - "\n", - "To do: simutlaneously constrain structural params using all the bands.\n", - "\n", - "Model photometry is the ones that provide total fluxes.\n", - "\n", - "See Konrad's talk for GAaP?\n", - "\n", - "Scarlet provides total fluxes (robust? not sure; also not sure its in the catalog)\n", - "\n", - "other codes for photometry include ngmix (bd = bulge disk; a constrained bulge disk model with a fixed size-ration between bulge and disk; used in real models like HSC with some success. Aaron?\n", - "\n", - "Hopefully there will be multiple different measurements by the time we get to DR1\n", - "\n", - "Robust total fluxes look bad. Hard to know what parts of hte pipeline to blame.\n", - "\n", - "Robust consistent colors: we dont' have the right metrics for this yet\n", - "\n", - "Dan's talk:\n", - "\n", - "cModel is not so good for galaxies. (fine for stars)\n", - "\n", - "2 things improve colors: going from single band to multi-band modeling with cmodel. also moving from cmodel to a sersic model improves the colors (only for multi-band fits; not the single band fits, these are always bad).\n", - "\n", - "ngmix has same performance as cmodel\n", - "\n", - "multi-band fitting has significant improvements for colors but not fluxes.\n", - "\n", - "Konrad: total magnitudes are hard / impossible / ill-defined quantitiy\n", - "they are model dependent and observation dependent and so this is bad.\n", - "A thing you often think you want but you actually dont want. And, which you think you have measured but in fact you have not.\n", - "\n", - "Proxies:\n", - "petrosian\n", - "aperture + corrections\n", - "isophotial + extrapoation (segmentation maps, see Robotham+2018, better than sextractor)\n", - "sersic bulge + disk\n", - "all require taking PSF into account.\n", - "\n", - "What we actually want: colors. you can focus on the part of galaxy above the noise and avoid extrapolation errors\n", - "\n", - "GAaP useful for many-band surveys with a standardized PSF to a gaussian. use \n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "LSST", - "language": "python", - "name": "lsst" - }, - "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.11.9" - }, - "toc-autonumbering": false - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 695d916426aef3befe1e0a951cafc07f30380af8 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 10 Feb 2025 18:34:24 +0000 Subject: [PATCH 86/99] finalizing --- DP02_17_Galaxy_Photometry.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 8aa967a..fb3af7c 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -25,10 +25,10 @@ "metadata": {}, "outputs": [], "source": [ - "%load_ext pycodestyle_magic\n", - "%flake8_on\n", - "import logging\n", - "logging.getLogger(\"flake8\").setLevel(logging.FATAL)" + "#%load_ext pycodestyle_magic\n", + "#%flake8_on\n", + "#import logging\n", + "#logging.getLogger(\"flake8\").setLevel(logging.FATAL)" ] }, { @@ -60,7 +60,7 @@ "id": "5c67fab9-136a-4adc-bb42-142b91ab69dd", "metadata": {}, "source": [ - "**Packages:** No new LSST packages are introduced here. The notebook will make use of the TAP service from the `lsst.rsp` package." + "**Packages:** No new LSST packages are introduced here. The notebook will make use of various `lsst` packages introduced in earlier tutorial notebooks." ] }, { From c6ca096ffc7da99899fc85e16bcb609578a0dea4 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 11 Feb 2025 00:18:03 +0000 Subject: [PATCH 87/99] new updates --- DP02_17_Galaxy_Photometry.ipynb | 104 +++++++++++++++++++++++++++++++- 1 file changed, 101 insertions(+), 3 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index fb3af7c..dc6be40 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -69,7 +69,7 @@ "metadata": {}, "source": [ "**Credit:**\n", - "This notebook benefitted from earlier exploration of simulated data and notebook development by Melissa Graham and Dan Taranu, and helpful discussions with Jim Bosch. " + "This notebook benefitted from earlier exploration of simulated data and notebook development by Melissa Graham and Dan Taranu, helpful discussions with Jim Bosch, and ideas from Douglas Tucker. " ] }, { @@ -483,6 +483,7 @@ " \"obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, \" + \\\n", " \"obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.r_gaapOptimalFlux, obj.g_gaapOptimalFlux, obj.u_gaapOptimalFlux, \" + \\\n", " \"obj.i_kronFlux_flag, obj.i_cModel_flag, \" + \\\n", " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, \" + \\\n", " \"obj.i_ap03Flux, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap12Flux, \" + \\\n", @@ -842,12 +843,109 @@ "The above figure shows more clearly that there is some fraction of the galaxy's light excluded by each of these photometric apertures. Further, printing the different photometry measurements illustrates how these assumed apertures will change the measured flux (compared to the total flux measured by cModel, which approximates the total magnitude using sersic models for the light profile). " ] }, + { + "cell_type": "markdown", + "id": "ec25172d-0f22-41c0-8b40-5bd1bc4133eb", + "metadata": {}, + "source": [ + "## 4. Application of GaaP Photometry: galaxy colors\n", + "\n", + "This section demonstrates using GaaP photometry to calculate accurate galaxy colors to identify different types of galaxies. First, define magnitudes from u, g, r, and i band photometry. The second cell will then compare the colors of galaxies that overlap the galaxy cluster with that in the field. In clusters, galaxies tend to be old, red elliptical galaxies and thus exhibit a well defined red sequence in color space. \n", + "\n", + "For comparison, search for and plot galaxies from a random location that will be dominated by bluer star forming galaxies\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2526bac6-67a5-4836-b910-6f64052fa205", + "metadata": {}, + "outputs": [], + "source": [ + "random_RA = 56.7506834813934\n", + "random_dec = -31.28892993702273\n", + "\n", + "query = \"SELECT obj.objectId, obj.coord_ra, obj.coord_dec, \" + \\\n", + " \"obj.detect_fromBlend, obj.detect_isIsolated, \" + \\\n", + " \"obj.i_blendedness, obj.i_extendedness, \" + \\\n", + " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, \" + \\\n", + " \"obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", + " \"obj.r_gaapOptimalFlux, obj.g_gaapOptimalFlux, obj.u_gaapOptimalFlux, \" + \\\n", + " \"obj.i_kronFlux_flag, obj.i_cModel_flag \" + \\\n", + " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", + " \"WHERE (obj.detect_isPrimary = 1) AND \" + \\\n", + " \"(obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND \" + \\\n", + " \"(obj.i_extendedness = 1) AND \" + \\\n", + " \"(obj.i_kronFlux_flag = 0) AND (obj.i_cModel_flag = 0) AND \" + \\\n", + " \"CONTAINS(POINT('ICRS', obj.coord_ra, obj.coord_dec), \" + \\\n", + " \"CIRCLE('ICRS',\"+str(random_RA)+\",\"+str(random_dec)+\", 0.1)) = 1 \"\n", + "\n", + "job = service.submit_job(query)\n", + "job.run()\n", + "job.wait(phases=['COMPLETED', 'ERROR'])\n", + "print('Job phase is', job.phase)\n", + "\n", + "results = job.fetch_result()\n", + "tab2 = results.to_table()\n", + "\n", + "i_random_gaap_mag = -2.50 * np.log10(tab2['i_gaapOptimalFlux']) + 31.4\n", + "r_random_gaap_mag = -2.50 * np.log10(tab2['r_gaapOptimalFlux']) + 31.4\n", + "g_random_gaap_mag = -2.50 * np.log10(tab2['g_gaapOptimalFlux']) + 31.4\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e1be2f4-74b1-4d73-87bd-fb6d08d2a6c2", + "metadata": {}, + "outputs": [], + "source": [ + "# cluster galaxies from Section 2\n", + "\n", + "u_cluster_gaap_mag = -2.50 * np.log10(tab['u_gaapOptimalFlux']) + 31.4\n", + "g_cluster_gaap_mag = -2.50 * np.log10(tab['g_gaapOptimalFlux']) + 31.4\n", + "r_cluster_gaap_mag = -2.50 * np.log10(tab['r_gaapOptimalFlux']) + 31.4\n", + "i_cluster_gaap_mag = -2.50 * np.log10(tab['i_gaapOptimalFlux']) + 31.4\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d53c736-3a5a-4390-9aaf-0c748e4fa08a", + "metadata": {}, + "outputs": [], + "source": [ + "fig, (ax, ax1) = plt.subplots(ncols=1, nrows=2, figsize=(10, 6))\n", + "\n", + "ax.plot(i_random_gaap_mag, (g_random_gaap_mag-i_random_gaap_mag),\n", + " '.', alpha=.1, color='blue', label='Field Galaxies')\n", + "ax.set_xlabel('i-band Magnitude [GaaP]')\n", + "ax.set_ylabel('g-i color')\n", + "ax.set_ylim([-1,4])\n", + "ax.legend()\n", + "\n", + "ax1.plot(i_cluster_gaap_mag, (g_cluster_gaap_mag-i_cluster_gaap_mag),\n", + " '.', alpha=.1, color='red', label='Cluster Galaxies')\n", + "ax1.set_xlabel('i-band Magnitude [GaaP]')\n", + "ax1.set_ylabel('g-i color')\n", + "ax1.set_ylim([-1,4])\n", + "ax1.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "69a95a3b-09c7-4ab8-939a-1816d33c8578", + "metadata": {}, + "source": [ + "A very nice red sequence appears from the red, old galaxies in the cluster! " + ] + }, { "cell_type": "markdown", "id": "714badaa-834d-4050-82a6-ffcac245ae5c", "metadata": {}, "source": [ - "## 4. Application of aperture photometry: radial profile\n", + "## 5. Application of aperture photometry: radial profile\n", "\n", "A science application for the aperture photometry is easy visualization of the radial profile of galaxies. In the cell below, make this plot for both a large galaxy and a small galaxy (of similar brightness, cModel magnitude ~ 20). Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." ] @@ -900,7 +998,7 @@ "id": "6f271dc2-4d44-41b2-b620-062750deb7b3", "metadata": {}, "source": [ - "## 5. Exercise for the learner\n", + "## 6. Exercise for the learner\n", "\n", "Compare the `<f>_free_cModelFlux` measurements to `<f>_cModelFlux` in the filters that are not the reference band where the `<f>_cModelFlux` was measured (i.e. `refBand`). Investigate how leaving the cModel measurements free differs from the one measured with parameters fixed to the `refBand`, as a function of decreasing signal to noise. " ] From 3c2f8c130b123e99611970dcea8315174f33f09e Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 11 Feb 2025 16:09:00 +0000 Subject: [PATCH 88/99] new updates --- DP02_17_Galaxy_Photometry.ipynb | 44 +++++++++++++++++---------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index dc6be40..1e154b7 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -11,11 +11,11 @@ "\n", "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", "<br>\n", - "Contact author(s): <i>Christina Williams</i> <br>\n", - "Last verified to run: <i>2024-02-10</i> <br>\n", - "LSST Science Pipelines version: Weekly <i>2024_50</i> <br>\n", - "Container Size: <i>medium</i> <br>\n", - "Targeted learning level: <i>beginner</i> <br>" + "Contact author(s): Christina Williams <br>\n", + "Last verified to run: 2024-02-10 <br>\n", + "LSST Science Pipelines version: Weekly 2024_50 <br>\n", + "Container Size: medium <br>\n", + "Targeted learning level: beginner <br>" ] }, { @@ -90,9 +90,9 @@ "id": "cfc73be0", "metadata": {}, "source": [ - "## 1. Introduction\n", + "# 1. Introduction\n", "\n", - "This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a> about the PSF photometry.) \n", + "The LSST Science Pipelines makes a variety of photometric measurements for point-like and extended sources. This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a> about the PSF photometry.) \n", "\n", "Please note that these explanations are specific to DP0.2: the objectTable contents and definitions are still subject to change for DP1. \n" ] @@ -110,7 +110,7 @@ } }, "source": [ - "### 1.1 Types of photometry measurements that exist in the Object Table\n", + "## 1.1 Types of photometry measurements that exist in the Object Table\n", "\n", "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", "\n", @@ -205,7 +205,7 @@ "id": "dc36f107", "metadata": {}, "source": [ - "### 1.2 Import packages\n" + "## 1.2 Import packages\n" ] }, { @@ -263,10 +263,10 @@ "id": "c217adff-25ed-4fce-95e7-8aa04630f6cc", "metadata": {}, "source": [ - "### 1.3 Define functions and parameters\n", + "## 1.3 Define functions and parameters\n", "\n", "\n", - "#### 1.3.1 Define some aesthetic plotting defaults" + "### 1.3.1 Define some aesthetic plotting defaults" ] }, { @@ -310,7 +310,7 @@ "id": "5e6352ac-09dd-4be0-bff3-379860c12a69", "metadata": {}, "source": [ - "#### 1.3.2 Define a shortcut function to generate an image cutout using the cutout tool\n", + "### 1.3.2 Define a shortcut function to generate an image cutout using the cutout tool\n", "Further information about the cutout tool can be found in <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_13a_Image_Cutout_SciDemo.html\">tutorial notebook 13a</a>." ] }, @@ -385,7 +385,7 @@ "tags": [] }, "source": [ - "## 2. Integrated photometry of galaxies using the LSST pipeline\n", + "# 2. Integrated photometry of galaxies using the LSST pipeline\n", "\n", "This section will explore integrated photometry measurements, and provide some guidance for which are optimal for certain science applications using galaxies. \n" ] @@ -413,7 +413,7 @@ "id": "9547e659-fd0e-432c-af25-968cc9ebea9d", "metadata": {}, "source": [ - "### 2.2 Object table photometry measurements\n", + "## 2.2 Photometry measurements in objectTable\n", "\n", "First, see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " ] @@ -451,7 +451,7 @@ "id": "caf9008d-e3aa-4908-bf32-a27cbe890a4f", "metadata": {}, "source": [ - "#### 2.3 Compare photometric measurements\n", + "## 2.3 Compare photometric measurements\n", "\n", "### 2.3.1 Identify a galaxy sample to investigate photometry\n", "\n", @@ -682,7 +682,7 @@ "These two figures show that the aperture photometry typically under-estimates the flux relative to the total flux estimated using cModel. As expected, there is a general trend for larger apertures to get closer to the total flux from cModel for large galaxies (i.e. whose Kron Radius is larger). There is also a general trend for the aperture photometry to be less discrepant at fainter magnitudes, since faint galaxies tend to be small.\n", "\n", "\n", - "### 2.3.2 Compare Kron and GaaP photometry to cModel\n", + "### 2.3.3 Compare Kron and GaaP photometry to cModel\n", "\n", "In the next cell, compare the cModel instead to the Kron and GaaP measures." ] @@ -770,7 +770,7 @@ "id": "48d5bfb6-dc27-4ed8-b615-78216710912e", "metadata": {}, "source": [ - "### 3. Visualize photometric measurements\n", + "# 3. Visualize photometric measurements\n", "\n", "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the objectTable. The position angle `theta` is defined in radians counterclockwise from the x-axis. This cell will plot for an elongated edge-on galaxy (`objectId` of 1909948454470183768) to ensure that the visualization emphasizes the difference between the elliptical Kron aperture to the circular aperture. " ] @@ -848,7 +848,7 @@ "id": "ec25172d-0f22-41c0-8b40-5bd1bc4133eb", "metadata": {}, "source": [ - "## 4. Application of GaaP Photometry: galaxy colors\n", + "# 4. Application of GaaP Photometry: galaxy colors\n", "\n", "This section demonstrates using GaaP photometry to calculate accurate galaxy colors to identify different types of galaxies. First, define magnitudes from u, g, r, and i band photometry. The second cell will then compare the colors of galaxies that overlap the galaxy cluster with that in the field. In clusters, galaxies tend to be old, red elliptical galaxies and thus exhibit a well defined red sequence in color space. \n", "\n", @@ -945,7 +945,7 @@ "id": "714badaa-834d-4050-82a6-ffcac245ae5c", "metadata": {}, "source": [ - "## 5. Application of aperture photometry: radial profile\n", + "# 5. Application of aperture photometry: radial profile\n", "\n", "A science application for the aperture photometry is easy visualization of the radial profile of galaxies. In the cell below, make this plot for both a large galaxy and a small galaxy (of similar brightness, cModel magnitude ~ 20). Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." ] @@ -996,9 +996,11 @@ { "cell_type": "markdown", "id": "6f271dc2-4d44-41b2-b620-062750deb7b3", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ - "## 6. Exercise for the learner\n", + "# 6. Exercise for the learner\n", "\n", "Compare the `<f>_free_cModelFlux` measurements to `<f>_cModelFlux` in the filters that are not the reference band where the `<f>_cModelFlux` was measured (i.e. `refBand`). Investigate how leaving the cModel measurements free differs from the one measured with parameters fixed to the `refBand`, as a function of decreasing signal to noise. " ] From 5d194af2edcab0c7b229039edc8d6c9c689c0a18 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 11 Feb 2025 16:23:21 +0000 Subject: [PATCH 89/99] new updates --- DP02_17_Galaxy_Photometry.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 1e154b7..925dd2d 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -60,7 +60,7 @@ "id": "5c67fab9-136a-4adc-bb42-142b91ab69dd", "metadata": {}, "source": [ - "**Packages:** No new LSST packages are introduced here. The notebook will make use of various `lsst` packages introduced in earlier tutorial notebooks." + "**Packages:** `lsst.afw`, `astropy`, `photutils`, `scipy.stats`" ] }, { @@ -321,7 +321,7 @@ "metadata": {}, "outputs": [], "source": [ - "def make_image_cutout_new(tap_service, ra, dec, cutout_size=0.01):\n", + "def make_image_cutout(tap_service, ra, dec, cutout_size=0.01):\n", " \"\"\"Wrapper function to generate a cutout using the cutout tool\n", "\n", " Parameters\n", @@ -790,7 +790,7 @@ "\n", "arcsec_per_pix = 0.2 # this is the pixel scale\n", "\n", - "mem = make_image_cutout_new(service, tab['coord_ra'][wh][indx],\n", + "mem = make_image_cutout(service, tab['coord_ra'][wh][indx],\n", " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", "\n", "cutout = ExposureF(mem)\n", From e50c1a285af7acf1d3f2bc07ef887d153028fd61 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 11 Feb 2025 22:23:57 +0000 Subject: [PATCH 90/99] finalizing --- DP02_17_Galaxy_Photometry.ipynb | 59 ++++++++++++++++----------------- 1 file changed, 28 insertions(+), 31 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 925dd2d..e33ec3b 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -92,7 +92,7 @@ "source": [ "# 1. Introduction\n", "\n", - "The LSST Science Pipelines makes a variety of photometric measurements for point-like and extended sources. This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in Tutorial Notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a> about the PSF photometry.) \n", + "The LSST Science Pipelines makes a variety of photometric measurements for point-like and extended sources. This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in DP0.2 Tutorial Notebooks 12a (about PSF data products) and 12b (a PSF science demo).\n", "\n", "Please note that these explanations are specific to DP0.2: the objectTable contents and definitions are still subject to change for DP1. \n" ] @@ -110,11 +110,11 @@ } }, "source": [ - "## 1.1 Types of photometry measurements that exist in the Object Table\n", + "## 1.1 Types of photometry measurements in the Object Table\n", "\n", "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", "\n", - "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there: The first are total fluxes are those that integrate the total light coming from objects, corrected for loss due to the blurring effects of PSF or seeing, including \"Composite Model\" (`cModel`) fluxes. The second category characterize the relative brightness of objects for specific regions of objects (i.e. are not corrected to be total fluxes) but can be useful for measuring accurate light profiles or accurate colors.\n", + "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there. The first are total fluxes (see Section 1.1.1), which aim to approximate (or model) all of the light coming from objects. Measurements that approximate total flux are \"Composite Model\" (`cModel`) fluxes. The second class of fluxes are measured inside an on-sky aperture but not corrected for flux that may fall outside: thus they are apparent fluxes but do not recover the intrisic (total) flux (see Section 1.1.2). The apparent fluxes are optimized for other purposes, such as for measuring accurate light profiles or accurate colors.\n", "\n", "### 1.1.1 Total fluxes\n", "\n", @@ -190,7 +190,7 @@ "\n", "#### PSF fluxes\n", "\n", - "Fluxes derived using the model point-spread function (PSF) of the image. Since PSF fluxes are designed for unresolved sources (not the majority of galaxies) this notebook will not explore science applications for this type of photometry. Interested users can find more information in the PSF Tutorial notebooks <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12a_PSF_Data_Products.html\">12a</a> and <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_12b_PSF_Science_Demo.html\">12b</a>.\n", + "Fluxes derived using the model point-spread function (PSF) of the image. Since PSF fluxes are designed for unresolved sources (not the majority of galaxies) this notebook will not explore science applications for this type of photometry. Interested users can find more information in the PSF Tutorial notebooks 12a and 12b. \n", "\n", "```\n", "<f>_psfFlux : Flux derived from linear least-squares fit of PSF model. Forced on <f>-band.\n", @@ -305,13 +305,31 @@ "plt.rcParams.update(params)" ] }, + { + "cell_type": "markdown", + "id": "30e18bb8-9839-4961-b4f5-fa9d76a0cf7e", + "metadata": {}, + "source": [ + "### 1.3.2 Initialize the TAP service" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61fe2c71-2684-483f-aa0d-5cb0d77bd758", + "metadata": {}, + "outputs": [], + "source": [ + "service = get_tap_service(\"tap\")" + ] + }, { "cell_type": "markdown", "id": "5e6352ac-09dd-4be0-bff3-379860c12a69", "metadata": {}, "source": [ - "### 1.3.2 Define a shortcut function to generate an image cutout using the cutout tool\n", - "Further information about the cutout tool can be found in <a href=\"https://dp0-2.lsst.io/_static/nb_html/DP02_13a_Image_Cutout_SciDemo.html\">tutorial notebook 13a</a>." + "### 1.3.3 Define a shortcut function to generate an image cutout using the cutout tool\n", + "Further information about the cutout tool can be found in DP0.2 tutorial notebook 13a that demonstrates the Rubin image cutout service. " ] }, { @@ -356,14 +374,11 @@ "\n", " results = tap_service.search(query)\n", "\n", - " # Get datalink\n", " dataLinkUrl = results[0].getdataurl()\n", " auth_session = service._session\n", " dl = DatalinkResults.from_result_url(dataLinkUrl,\n", " session=auth_session)\n", "\n", - " # from_resource: creates a instance from\n", - " # a number of records and a Datalink Resource.\n", " sq = SodaQuery.from_resource(dl,\n", " dl.get_adhocservice_by_id(\"cutout-sync\"),\n", " session=auth_session)\n", @@ -390,24 +405,6 @@ "This section will explore integrated photometry measurements, and provide some guidance for which are optimal for certain science applications using galaxies. \n" ] }, - { - "cell_type": "markdown", - "id": "45c86ed0-aebe-4d74-af42-619c0f6b0705", - "metadata": {}, - "source": [ - "### 2.1 Initialize the TAP service" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4fabe755-cb34-4d50-bbbc-99d8db7980c4", - "metadata": {}, - "outputs": [], - "source": [ - "service = get_tap_service(\"tap\")" - ] - }, { "cell_type": "markdown", "id": "9547e659-fd0e-432c-af25-968cc9ebea9d", @@ -455,9 +452,9 @@ "\n", "### 2.3.1 Identify a galaxy sample to investigate photometry\n", "\n", - "Below, query the DP0.2 objectTable for a selection of photometric measurements. This section will focus on 4 measurements: total flux from cModel (sum of bulge and disk sersic compoents fitted to the galaxy); and apparent fluxes measured as Kron (typically includes more than 90% of intrinsic light), GaaP (which is optimized for measuring accurate colors between bands), and aperture photometry (flux measured inside circles of varying size).\n", + "Below, query the DP0.2 `objectTable` for a selection of photometric measurements. This section will focus on 4 measurements: total flux from cModel (sum of bulge and disk sersic compoents fitted to the galaxy); and apparent fluxes measured as Kron (typically includes more than 90% of intrinsic light), GaaP (which is optimized for measuring accurate colors between bands), and aperture photometry (flux measured inside circles of varying size).\n", "\n", - "First, focus on a known part of the simulation to contain a galaxy cluster (also seen in DP0.2 notebook tutorial 03a). Limit the search to contain galaxies using the `i_extendedness` flag (which will exclude point sources), and to those objects that are unique in the objectTable (by setting `detect_isPrimary` = True). Further, identify objects which have been detected at high signal to noise > 20 and whose photometric measurements have not been flagged as having an issue (`i_kronFlux_flag` or `i_cModel_flag` = 0 means the photometry is ok). " + "First, focus on a known part of the simulation to contain a galaxy cluster (also seen in DP0.2 notebook tutorial 03a). Limit the search to contain galaxies using the `i_extendedness` flag (which will exclude point sources), and to those objects that are unique in the `objectTable` (by setting `detect_isPrimary` = True). Further, identify objects which have been detected at high signal to noise > 20 and whose photometric measurements have not been flagged as having an issue (`i_kronFlux_flag` or `i_cModel_flag` = 0 means the photometry is ok). " ] }, { @@ -536,7 +533,7 @@ "id": "e6a27a39-ed2b-49fe-ac6d-51ae4c300bfc", "metadata": {}, "source": [ - "Below, store the Kron Radius, which is a good proxy for the size of the galaxy light profile. Then convert the fluxes extracted from the objectTable into AB magnitudes." + "Below, store the Kron Radius, which is a good proxy for the size of the galaxy light profile. Then convert the fluxes extracted from the `objectTable` into AB magnitudes." ] }, { @@ -772,7 +769,7 @@ "source": [ "# 3. Visualize photometric measurements\n", "\n", - "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the objectTable. The position angle `theta` is defined in radians counterclockwise from the x-axis. This cell will plot for an elongated edge-on galaxy (`objectId` of 1909948454470183768) to ensure that the visualization emphasizes the difference between the elliptical Kron aperture to the circular aperture. " + "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the `objectTable`. The position angle `theta` is defined in radians counterclockwise from the x-axis. This cell will plot for an elongated edge-on galaxy (`objectId` of 1909948454470183768) to ensure that the visualization emphasizes the difference between the elliptical Kron aperture to the circular aperture. " ] }, { From 95bf06a903b8b1cdcaa31da763b32eb8b7460feb Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Tue, 11 Feb 2025 22:29:13 +0000 Subject: [PATCH 91/99] finalizing --- DP02_17_Galaxy_Photometry.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index e33ec3b..099a201 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -94,7 +94,7 @@ "\n", "The LSST Science Pipelines makes a variety of photometric measurements for point-like and extended sources. This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in DP0.2 Tutorial Notebooks 12a (about PSF data products) and 12b (a PSF science demo).\n", "\n", - "Please note that these explanations are specific to DP0.2: the objectTable contents and definitions are still subject to change for DP1. \n" + "Please note that these explanations are specific to DP0.2: the `objectTable` contents and definitions are still subject to change for DP1. \n" ] }, { @@ -114,7 +114,7 @@ "\n", "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", "\n", - "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there. The first are total fluxes (see Section 1.1.1), which aim to approximate (or model) all of the light coming from objects. Measurements that approximate total flux are \"Composite Model\" (`cModel`) fluxes. The second class of fluxes are measured inside an on-sky aperture but not corrected for flux that may fall outside: thus they are apparent fluxes but do not recover the intrisic (total) flux (see Section 1.1.2). The apparent fluxes are optimized for other purposes, such as for measuring accurate light profiles or accurate colors.\n", + "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there. The first are total fluxes (see Section 1.1.1), which aim to approximate (or model) all of the light coming from objects. Measurements that approximate total flux are \"Composite Model\" (cModel) fluxes. The second class of fluxes are measured inside an on-sky aperture but not corrected for flux that may fall outside: thus they are apparent fluxes but do not recover the intrisic (total) flux (see Section 1.1.2). The apparent fluxes are optimized for other purposes, such as for measuring accurate light profiles or accurate colors.\n", "\n", "### 1.1.1 Total fluxes\n", "\n", From 98f6dab8d84d073212819d1fc86c4318e6d0963e Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Thu, 13 Feb 2025 17:00:43 +0000 Subject: [PATCH 92/99] finalizing --- DP02_17_Galaxy_Photometry.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 099a201..8d9f19d 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -112,7 +112,7 @@ "source": [ "## 1.1 Types of photometry measurements in the Object Table\n", "\n", - "Schema for the object catalog for DP0.2: https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\n", + "Schema for the object catalog for DP0.2 <a href=\"https://dm.lsst.org/sdm_schemas/browser/dp02.html#Object\">is available here</a>.\n", "\n", "Numerous photometry measurements are produced by the LSST Pipelines. Two types of photometry are there. The first are total fluxes (see Section 1.1.1), which aim to approximate (or model) all of the light coming from objects. Measurements that approximate total flux are \"Composite Model\" (cModel) fluxes. The second class of fluxes are measured inside an on-sky aperture but not corrected for flux that may fall outside: thus they are apparent fluxes but do not recover the intrisic (total) flux (see Section 1.1.2). The apparent fluxes are optimized for other purposes, such as for measuring accurate light profiles or accurate colors.\n", "\n", @@ -121,8 +121,8 @@ "\n", "#### Composite Model (CModel) fluxes\n", "\n", - "Similar in nature to those measured for SDSS: \n", - "https://www.sdss3.org/dr8/algorithms/magnitudes.php#cmodel\n", + "Similar in nature to those measured for SDSS (information <a href=\"https://www.sdss3.org/dr8/algorithms/magnitudes.php#cmodel\">available here</a>). \n", + "\n", "\n", "In short, it is the linear combination of the best fit exponential (disk or D) and de Vaucouleurs (bulge or B) profiles. \n", "\n", From a37f2978da45766b77a373f4a2833ee87c2a85a9 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 14 Feb 2025 20:08:31 +0000 Subject: [PATCH 93/99] finalinzing --- DP02_17_Galaxy_Photometry.ipynb | 70 +++++++++++++++++++++++++++++---- 1 file changed, 63 insertions(+), 7 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 8d9f19d..8ce40c2 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -25,10 +25,10 @@ "metadata": {}, "outputs": [], "source": [ - "#%load_ext pycodestyle_magic\n", - "#%flake8_on\n", - "#import logging\n", - "#logging.getLogger(\"flake8\").setLevel(logging.FATAL)" + "%load_ext pycodestyle_magic\n", + "%flake8_on\n", + "import logging\n", + "logging.getLogger(\"flake8\").setLevel(logging.FATAL)" ] }, { @@ -412,7 +412,7 @@ "source": [ "## 2.2 Photometry measurements in objectTable\n", "\n", - "First, see what is available in the object catalog by querying the tap_schema columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " + "First, see what is available in the object catalog by querying the `tap_schema` columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " ] }, { @@ -614,6 +614,14 @@ "ax.legend()\n" ] }, + { + "cell_type": "markdown", + "id": "0e6cc869-a275-48b0-9ac8-febec0428e07", + "metadata": {}, + "source": [ + "> Figure 1: A comparison of the difference between cModel photometry and aperture photometry measured by the LSST pipelines for four different aperture sizes as a function of galaxy size (as measured using the Kron radius). The left panel shows the scatter plot of difference in photometry vs Kron radius, and the right panel shows a histogram of these values that demonstrate that larger aperture sizes have photometry that is closer to the cModel." + ] + }, { "cell_type": "code", "execution_count": null, @@ -671,6 +679,14 @@ "ax.legend()\n" ] }, + { + "cell_type": "markdown", + "id": "eca1c28b-ac37-43b3-965d-1d03210b0b65", + "metadata": {}, + "source": [ + "> Figure 2: A similar comparison of the difference between cModel photometry and aperture photometry measured by the LSST pipelines for four different aperture sizes, this time as a function of cModel magnitude. Running median is included." + ] + }, { "cell_type": "markdown", "id": "cef81cea-b352-4196-a4d0-c5b4ad80bd00", @@ -716,6 +732,14 @@ "ax.legend()\n" ] }, + { + "cell_type": "markdown", + "id": "e9db247f-8fa8-4f59-97f0-d6076a3e9295", + "metadata": {}, + "source": [ + "> Figure 3: " + ] + }, { "cell_type": "code", "execution_count": null, @@ -752,6 +776,14 @@ "ax.legend()" ] }, + { + "cell_type": "markdown", + "id": "b30953c9-2c2d-4569-a96b-3b558b0b672f", + "metadata": {}, + "source": [ + "> Figure 4: " + ] + }, { "cell_type": "markdown", "id": "9aec6b4b-ada8-429d-a65f-c076d8d26872", @@ -832,6 +864,14 @@ "print(\"cModel mag = \", cmodel_mag[wh][indx])\n" ] }, + { + "cell_type": "markdown", + "id": "7476643c-50e3-418e-9d31-704e3f060bc9", + "metadata": {}, + "source": [ + "> Figure 5: " + ] + }, { "cell_type": "markdown", "id": "125bf616-aad9-4291-85fe-503b68f0d539", @@ -929,6 +969,14 @@ "ax1.legend()" ] }, + { + "cell_type": "markdown", + "id": "07a4487a-b8d6-4e1c-bbb7-045175c2928a", + "metadata": {}, + "source": [ + "> Figure 6: " + ] + }, { "cell_type": "markdown", "id": "69a95a3b-09c7-4ab8-939a-1816d33c8578", @@ -968,7 +1016,7 @@ " tab['i_ap50Flux'][wh][indx]]) / area\n", "\n", "plt.plot(rad, profile,\n", - " label='Large Kron Radius R='+str(i_kronRad[wh][indx]*arcsec_per_pix))\n", + " label='Large Kron Radius R='+str(round(i_kronRad[wh][indx]*arcsec_per_pix,2)))\n", "plt.xlabel('Aperture Radius [arcsec]')\n", "plt.ylabel(r'Surface Brightness [nJy arcsec$^{-2}$]')\n", "\n", @@ -985,11 +1033,19 @@ " tab['i_ap50Flux'][wh2][indx]])/area\n", "\n", "plt.plot(rad, profile,\n", - " label='Small Kron Radius R='+str(i_kronRad[wh2][indx]*arcsec_per_pix))\n", + " label='Small Kron Radius R='+str(round(i_kronRad[wh2][indx]*arcsec_per_pix,2)))\n", "plt.legend()\n", "plt.yscale('log')" ] }, + { + "cell_type": "markdown", + "id": "81f960b3-0661-4a57-8e39-05c403b77afd", + "metadata": {}, + "source": [ + "> Figure 7: " + ] + }, { "cell_type": "markdown", "id": "6f271dc2-4d44-41b2-b620-062750deb7b3", From f00af45aca9650eb2fba5ea56d30136bb2f3d663 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 14 Feb 2025 20:32:24 +0000 Subject: [PATCH 94/99] finalinzing --- DP02_17_Galaxy_Photometry.ipynb | 81 ++++++++++++++------------------- 1 file changed, 33 insertions(+), 48 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 8ce40c2..6214241 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -278,31 +278,8 @@ "source": [ "afwDisplay.setDefaultBackend('matplotlib')\n", "\n", - "params = {'axes.labelsize': 18,\n", - " 'font.size': 18,\n", - " 'legend.fontsize': 12,\n", - " 'xtick.major.width': 2,\n", - " 'xtick.minor.width': 1,\n", - " 'xtick.major.size': 10,\n", - " 'xtick.minor.size': 4,\n", - " 'xtick.direction': 'in',\n", - " 'xtick.top': True,\n", - " 'lines.linewidth': 2,\n", - " 'axes.linewidth': 2,\n", - " 'axes.labelweight': 2,\n", - " 'axes.titleweight': 2,\n", - " 'ytick.major.width': 2,\n", - " 'ytick.minor.width': 1,\n", - " 'ytick.major.size': 10,\n", - " 'ytick.minor.size': 4,\n", - " 'ytick.direction': 'in',\n", - " 'ytick.right': True,\n", - " 'figure.figsize': [6, 6],\n", - " 'figure.facecolor': 'White'\n", - " }\n", - "plt.style.use('tableau-colorblind10')\n", - "\n", - "plt.rcParams.update(params)" + "\n", + "plt.style.use('tableau-colorblind10')\n" ] }, { @@ -582,15 +559,15 @@ " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "\n", "ylims = [-1.5, 1.5]\n", + "ax.plot(i_kronRad, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", + " label='cModel 6-pix aperture', color='red')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", + " label='cModel 9-pix aperture', color='orange')\n", + "ax.plot(i_kronRad, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", + " label='cModel 12-pix aperture', color='green')\n", "\n", "ax.plot(i_kronRad, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", " label='cModel - 17-pix aperture', color='blue')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", - " label='cModel 12-pix aperture', color='green')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", - " label='cModel 9-pix aperture', color='orange')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", - " label='cModel 6-pix aperture', color='red')\n", "\n", "ax2.hist((cmodel_mag-ap17_mag), edgecolor='blue', orientation=\"horizontal\",\n", " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", @@ -712,9 +689,9 @@ "ylims = [-2, 2]\n", "\n", "ax.plot(i_kronRad, (cmodel_mag-kron_mag), '.', alpha=.1,\n", - " label='cModel-Kron')\n", + " label='Kron')\n", "ax.plot(i_kronRad, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", - " label='cModel - gaapOptimal')\n", + " label='gaapOptimal')\n", "\n", "ax2.hist((cmodel_mag-kron_mag), orientation=\"horizontal\",\n", " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", @@ -801,7 +778,12 @@ "source": [ "# 3. Visualize photometric measurements\n", "\n", - "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the `objectTable`. The position angle `theta` is defined in radians counterclockwise from the x-axis. This cell will plot for an elongated edge-on galaxy (`objectId` of 1909948454470183768) to ensure that the visualization emphasizes the difference between the elliptical Kron aperture to the circular aperture. " + "Here make a cutout of a large galaxy in the cluster and compare the photometric aperture sizes of the different photometric measurements. The cell below also demonstrates how to reconstruct the Kron aperture using the corresponding shape parameters in the `objectTable`. The position angle `theta` is defined in radians counterclockwise from the x-axis. This cell will plot for an elongated edge-on galaxy (`objectId` of 1909948454470183768) to ensure that the visualization emphasizes the difference between the elliptical Kron aperture to the circular aperture. \n", + "\n", + "Alternatively, it is possible to pick a different bright object that has large size using the command\n", + "\n", + "`wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]`\n", + "\n" ] }, { @@ -814,9 +796,6 @@ "wh = np.where((tab['objectId'] == 1909948454470183768))[0]\n", "indx = 0\n", "\n", - "# Alternatively, pick a different bright object that has large size\n", - "# wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]\n", - "\n", "arcsec_per_pix = 0.2 # this is the pixel scale\n", "\n", "mem = make_image_cutout(service, tab['coord_ra'][wh][indx],\n", @@ -907,8 +886,8 @@ " \"obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, \" + \\\n", " \"obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.r_gaapOptimalFlux, obj.g_gaapOptimalFlux, obj.u_gaapOptimalFlux, \" + \\\n", - " \"obj.i_kronFlux_flag, obj.i_cModel_flag \" + \\\n", + " \"obj.r_gaapOptimalFlux, obj.g_gaapOptimalFlux, \" + \\\n", + " \"obj.u_gaapOptimalFlux, obj.i_kronFlux_flag, obj.i_cModel_flag \" + \\\n", " \"FROM dp02_dc2_catalogs.Object AS obj \" + \\\n", " \"WHERE (obj.detect_isPrimary = 1) AND \" + \\\n", " \"(obj.i_cModelFlux/obj.i_cModelFluxErr > 20) AND \" + \\\n", @@ -930,6 +909,14 @@ "g_random_gaap_mag = -2.50 * np.log10(tab2['g_gaapOptimalFlux']) + 31.4\n" ] }, + { + "cell_type": "markdown", + "id": "f5bcc8d3-3607-492f-93d2-79f239321307", + "metadata": {}, + "source": [ + "First, calculate the magnitudes of galaxies in the other filters near the galaxy cluster from the query performed in Section 2. This will enable plotting their colors." + ] + }, { "cell_type": "code", "execution_count": null, @@ -937,8 +924,6 @@ "metadata": {}, "outputs": [], "source": [ - "# cluster galaxies from Section 2\n", - "\n", "u_cluster_gaap_mag = -2.50 * np.log10(tab['u_gaapOptimalFlux']) + 31.4\n", "g_cluster_gaap_mag = -2.50 * np.log10(tab['g_gaapOptimalFlux']) + 31.4\n", "r_cluster_gaap_mag = -2.50 * np.log10(tab['r_gaapOptimalFlux']) + 31.4\n", @@ -958,14 +943,14 @@ " '.', alpha=.1, color='blue', label='Field Galaxies')\n", "ax.set_xlabel('i-band Magnitude [GaaP]')\n", "ax.set_ylabel('g-i color')\n", - "ax.set_ylim([-1,4])\n", + "ax.set_ylim([-1, 4])\n", "ax.legend()\n", "\n", "ax1.plot(i_cluster_gaap_mag, (g_cluster_gaap_mag-i_cluster_gaap_mag),\n", " '.', alpha=.1, color='red', label='Cluster Galaxies')\n", "ax1.set_xlabel('i-band Magnitude [GaaP]')\n", "ax1.set_ylabel('g-i color')\n", - "ax1.set_ylim([-1,4])\n", + "ax1.set_ylim([-1, 4])\n", "ax1.legend()" ] }, @@ -992,7 +977,7 @@ "source": [ "# 5. Application of aperture photometry: radial profile\n", "\n", - "A science application for the aperture photometry is easy visualization of the radial profile of galaxies. In the cell below, make this plot for both a large galaxy and a small galaxy (of similar brightness, cModel magnitude ~ 20). Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." + "A science application for the aperture photometry is easy visualization of the radial profile of galaxies. In the cell below, make this plot for both a large galaxy (first) and a smaller galaxy of similar brightness (second). The query looks for bright galaxies whose cModel magnitude ~ 20. Dividing the aperture flux by the surface area of the aperture yields the surface brightness, which can be plotted as a function of radius from the center of the galaxy to compare radial light profiles." ] }, { @@ -1002,7 +987,6 @@ "metadata": {}, "outputs": [], "source": [ - "# pick a bright object with large size\n", "wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag > 19.9)\n", " & (cmodel_mag < 20.1))[0]\n", "indx = 2\n", @@ -1016,11 +1000,11 @@ " tab['i_ap50Flux'][wh][indx]]) / area\n", "\n", "plt.plot(rad, profile,\n", - " label='Large Kron Radius R='+str(round(i_kronRad[wh][indx]*arcsec_per_pix,2)))\n", + " label='Large Radius R='\n", + " + str(round(i_kronRad[wh][indx]*arcsec_per_pix, 2)))\n", "plt.xlabel('Aperture Radius [arcsec]')\n", "plt.ylabel(r'Surface Brightness [nJy arcsec$^{-2}$]')\n", "\n", - "# pick an object of similar magnitude that has a smaller size\n", "wh2 = np.where((tab['i_kronRad'] < 8) & (tab['i_kronRad'] > 5)\n", " & (cmodel_mag > 19.9) & (cmodel_mag < 20.1))[0]\n", "\n", @@ -1033,7 +1017,8 @@ " tab['i_ap50Flux'][wh2][indx]])/area\n", "\n", "plt.plot(rad, profile,\n", - " label='Small Kron Radius R='+str(round(i_kronRad[wh2][indx]*arcsec_per_pix,2)))\n", + " label='Small Radius R='\n", + " + str(round(i_kronRad[wh2][indx]*arcsec_per_pix, 2)))\n", "plt.legend()\n", "plt.yscale('log')" ] From 15013aaff4b07587ff47f93f4341e130a20a0828 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 14 Feb 2025 22:50:19 +0000 Subject: [PATCH 95/99] finalinzing --- DP02_17_Galaxy_Photometry.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 6214241..7ed5f70 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -266,7 +266,7 @@ "## 1.3 Define functions and parameters\n", "\n", "\n", - "### 1.3.1 Define some aesthetic plotting defaults" + "### 1.3.1 Define some plotting defaults" ] }, { @@ -278,7 +278,6 @@ "source": [ "afwDisplay.setDefaultBackend('matplotlib')\n", "\n", - "\n", "plt.style.use('tableau-colorblind10')\n" ] }, @@ -783,7 +782,8 @@ "Alternatively, it is possible to pick a different bright object that has large size using the command\n", "\n", "`wh = np.where((tab['i_kronRad'] > 8) & (cmodel_mag < 20))[0]`\n", - "\n" + "\n", + "Note that the pixel scale of the LSST data is 0.2 arcseconds per pixel." ] }, { @@ -796,7 +796,7 @@ "wh = np.where((tab['objectId'] == 1909948454470183768))[0]\n", "indx = 0\n", "\n", - "arcsec_per_pix = 0.2 # this is the pixel scale\n", + "arcsec_per_pix = 0.2\n", "\n", "mem = make_image_cutout(service, tab['coord_ra'][wh][indx],\n", " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", From b07365973d67f7b43fdf7a55593f34a1364dba12 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 14 Feb 2025 23:16:48 +0000 Subject: [PATCH 96/99] finalinzing --- DP02_17_Galaxy_Photometry.ipynb | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 7ed5f70..eb1fb4d 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -388,7 +388,7 @@ "source": [ "## 2.2 Photometry measurements in objectTable\n", "\n", - "First, see what is available in the object catalog by querying the `tap_schema` columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). The return shows also errors and flags associated with the photometric measurements outlined in section 1.1. " + "First, see what is available in the object catalog by querying the `tap_schema` columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). For clarity, the return omits the errors and flags associated with the photometric measurements outlined in section 1.1. " ] }, { @@ -414,8 +414,12 @@ "source": [ "search_string = 'Flux'\n", "band = 'i_'\n", + "exclude1 = 'Err'\n", + "exclude2 = 'flag'\n", "for cname in results['column_name']:\n", - " if (cname.find(search_string) > -1) and (cname.find(band) > -1):\n", + " if cname.find(search_string) > -1 and cname.find(band) > -1 and \\\n", + " cname.find(exclude1) == -1 and cname.find(exclude2) == -1:\n", + "\n", " print(cname)" ] }, @@ -456,8 +460,8 @@ " \"obj.i_blendedness, obj.i_extendedness, \" + \\\n", " \"obj.i_kronFlux, obj.i_kronFluxErr, obj.i_kronRad, \" + \\\n", " \"obj.i_cModelFlux, obj.i_cModelFluxErr, obj.i_gaapOptimalFlux, \" + \\\n", - " \"obj.r_gaapOptimalFlux, obj.g_gaapOptimalFlux, obj.u_gaapOptimalFlux, \" + \\\n", - " \"obj.i_kronFlux_flag, obj.i_cModel_flag, \" + \\\n", + " \"obj.r_gaapOptimalFlux, obj.g_gaapOptimalFlux, \" + \\\n", + " \"obj.u_gaapOptimalFlux, obj.i_kronFlux_flag, obj.i_cModel_flag, \" + \\\n", " \"obj.shape_xx, obj.shape_xy, obj.shape_yy, \" + \\\n", " \"obj.i_ap03Flux, obj.i_ap06Flux, obj.i_ap09Flux, obj.i_ap12Flux, \" + \\\n", " \"obj.i_ap17Flux, obj.i_ap25Flux, obj.i_ap35Flux, obj.i_ap50Flux \" + \\\n", From 1961dcc7bb5523aeff8231d42cd5296149d44880 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Fri, 14 Feb 2025 23:44:08 +0000 Subject: [PATCH 97/99] finalinzing --- DP02_17_Galaxy_Photometry.ipynb | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index eb1fb4d..6b6014a 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -388,7 +388,7 @@ "source": [ "## 2.2 Photometry measurements in objectTable\n", "\n", - "First, see what is available in the object catalog by querying the `tap_schema` columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). For clarity, the return omits the errors and flags associated with the photometric measurements outlined in section 1.1. " + "First, see what is available in the object catalog by querying the `tap_schema` columns, and printing all the parameters available related to \"Flux\" measured in the i-band (as an example). For clarity, the return also omits errors and flags associated with the photometric measurements outlined in section 1.1. " ] }, { @@ -513,7 +513,9 @@ "id": "e6a27a39-ed2b-49fe-ac6d-51ae4c300bfc", "metadata": {}, "source": [ - "Below, store the Kron Radius, which is a good proxy for the size of the galaxy light profile. Then convert the fluxes extracted from the `objectTable` into AB magnitudes." + "Below, store the Kron Radius, which is a good proxy for the size of the galaxy light profile. Then convert the fluxes extracted from the `objectTable` into AB magnitudes\n", + "\n", + "> **Warning:** The following cell will produce warnings for invalid value encountered in log10, which happens if the source flux is negative. This occasionally happens from aperture photometry if the included pixels inside the aperture have negative values and can be safely ignored for this example." ] }, { @@ -563,14 +565,14 @@ "\n", "ylims = [-1.5, 1.5]\n", "ax.plot(i_kronRad, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", - " label='cModel 6-pix aperture', color='red')\n", + " label='6-pixel aperture', color='red')\n", "ax.plot(i_kronRad, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", - " label='cModel 9-pix aperture', color='orange')\n", + " label='9-pixel aperture', color='orange')\n", "ax.plot(i_kronRad, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", - " label='cModel 12-pix aperture', color='green')\n", + " label='12-pixel aperture', color='green')\n", "\n", "ax.plot(i_kronRad, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", - " label='cModel - 17-pix aperture', color='blue')\n", + " label='17-pixel aperture', color='blue')\n", "\n", "ax2.hist((cmodel_mag-ap17_mag), edgecolor='blue', orientation=\"horizontal\",\n", " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", @@ -717,7 +719,7 @@ "id": "e9db247f-8fa8-4f59-97f0-d6076a3e9295", "metadata": {}, "source": [ - "> Figure 3: " + "> Figure 3: The left panel figure shows the i-band magnitude difference between cModel and Kron (blue) and between cModel and gaapOptimal (orange) vs the Kron radius (a proxy for galaxy size) for the galaxies in the query. The dashed line indicates where the two magnitudes would have the same value. The gaapOptimal magnitude always underestimates the flux, while the Kron magnitude approaches the cModel magnitude for fainter galaxies. The right panel shows the histogram of the magnitude differences in the left panel, illustrating that while cModel - Kron magnitudes are similar on average (blue histogram) the gaapOptimal systematically underestimates the flux relative to cModel (orange histogram). " ] }, { @@ -761,7 +763,7 @@ "id": "b30953c9-2c2d-4569-a96b-3b558b0b672f", "metadata": {}, "source": [ - "> Figure 4: " + "> Figure 4: The figure shows the i-band magnitude difference between cModel and Kron (blue) and between cModel and gaapOptimal (orange) vs the cModel magnitude for the galaxies in the query. The lines correspond to the running median in magnitude bins to illustrate the trend. The dashed line indicates where the two magnitudes would have the same value. The gaapOptimal magnitude always underestimates the flux, while the Kron magnitude approaches the cModel magnitude for fainter galaxies." ] }, { @@ -803,7 +805,7 @@ "arcsec_per_pix = 0.2\n", "\n", "mem = make_image_cutout(service, tab['coord_ra'][wh][indx],\n", - " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", + " tab['coord_dec'][wh][indx], cutout_size=0.005)\n", "\n", "cutout = ExposureF(mem)\n", "\n", @@ -826,11 +828,11 @@ "\n", "aperture = SkyCircularAperture(coord, r=17 * arcsec_per_pix * u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='r', lw=3, label='17 pix aperture')\n", + "pix_aperture.plot(color='r', lw=3, label='17 pixel aperture')\n", "\n", "aperture = SkyCircularAperture(coord, r=35 * arcsec_per_pix * u.arcsec)\n", "pix_aperture = aperture.to_pixel(WCS(cutout.getWcs().getFitsMetadata()))\n", - "pix_aperture.plot(color='g', lw=3, label='35 pix aperture')\n", + "pix_aperture.plot(color='g', lw=3, label='35 pixel aperture')\n", "\n", "aperture = SkyEllipticalAperture(coord,\n", " 2.5 * Rmaj * arcsec_per_pix * u.arcsec,\n", @@ -852,7 +854,7 @@ "id": "7476643c-50e3-418e-9d31-704e3f060bc9", "metadata": {}, "source": [ - "> Figure 5: " + "> Figure 5: An i-band image cutout of an example galaxy (grayscale). The photometric apertures are overplotted including Kron (blue), the 17 pixel aperture (red) and the 35 pixel aperture (green). None of the apertures enclose all of the flux visible from the galaxy, which is why the photometry measures less flux than the total flux from cModel." ] }, { From 4353f8eb2a0972bdfa6a52426338976ae6221206 Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Mon, 17 Feb 2025 17:15:45 +0000 Subject: [PATCH 98/99] finalizing --- DP02_17_Galaxy_Photometry.ipynb | 49 +++++++++++++++++---------------- 1 file changed, 26 insertions(+), 23 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 6b6014a..37ce0ce 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -92,9 +92,11 @@ "source": [ "# 1. Introduction\n", "\n", + "Photometry is the measurement of how much light is apparent from astronomical sources. The amount of light arriving on the telescope from the object is typically referred to as the flux density, or apparent magnitude (depending on units). Flux density is defined as the amount of energy arriving on the telescope per unit area, per unit time, per unit frequency (or wavelength) of the light.\n", + "\n", "The LSST Science Pipelines makes a variety of photometric measurements for point-like and extended sources. This notebook will teach the user about the automated photometry measurements that are measured on the deepCoadd images and appear in the Object Catalog as part of the LSST pipelines data products. The focus will be on galaxies (and thus is distinct from the demonstrations in DP0.2 Tutorial Notebooks 12a (about PSF data products) and 12b (a PSF science demo).\n", "\n", - "Please note that these explanations are specific to DP0.2: the `objectTable` contents and definitions are still subject to change for DP1. \n" + "Please note that these explanations are specific to DP0.2: the `objectTable` contents and definitions are still subject to change for DP1. The photometry in the catalog are flux densities in units of nano-Jansky [nJy]. 1 Jy = 10^{-23} ergs/s/cm^2/Hz.\n" ] }, { @@ -503,7 +505,6 @@ "outputs": [], "source": [ "results = job.fetch_result()\n", - "print(len(results))\n", "tab = results.to_table()\n", "tab" ] @@ -564,14 +565,13 @@ " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "\n", "ylims = [-1.5, 1.5]\n", - "ax.plot(i_kronRad, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", + "ax.plot(i_kronRad, (cmodel_mag-ap06_mag), '^', alpha=.3,\n", " label='6-pixel aperture', color='red')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", + "ax.plot(i_kronRad, (cmodel_mag-ap09_mag), 's', alpha=.3,\n", " label='9-pixel aperture', color='orange')\n", - "ax.plot(i_kronRad, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", + "ax.plot(i_kronRad, (cmodel_mag-ap12_mag), 'o', alpha=.3,\n", " label='12-pixel aperture', color='green')\n", - "\n", - "ax.plot(i_kronRad, (cmodel_mag-ap17_mag), '.', alpha=.1,\n", + "ax.plot(i_kronRad, (cmodel_mag-ap17_mag), '.', alpha=.3,\n", " label='17-pixel aperture', color='blue')\n", "\n", "ax2.hist((cmodel_mag-ap17_mag), edgecolor='blue', orientation=\"horizontal\",\n", @@ -615,7 +615,7 @@ "ylims = [-1.2, 1.2]\n", "bins = np.arange(16, 27, 1)\n", "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap06_mag), '.', alpha=.1,\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap06_mag), '^', alpha=.1,\n", " label='cModel 6-pix aperture', color='red')\n", "x = cmodel_mag\n", "y = (cmodel_mag-ap06_mag)\n", @@ -624,7 +624,7 @@ "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", "ax.plot(binctr, bin_mean, color='red', lw=2, label='bin median', zorder=10)\n", "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap09_mag), '.', alpha=.1,\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap09_mag), 's', alpha=.1,\n", " label='cModel 9-pix aperture', color='orange')\n", "x = cmodel_mag\n", "y = (cmodel_mag-ap09_mag)\n", @@ -634,7 +634,7 @@ "ax.plot(binctr, bin_mean, color='orange', lw=2,\n", " label='bin median', zorder=10)\n", "\n", - "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag), '.', alpha=.1,\n", + "ax.plot(cmodel_mag, (cmodel_mag-ap12_mag), 'o', alpha=.1,\n", " label='cModel 12-pix aperture', color='green')\n", "x = cmodel_mag\n", "y = (cmodel_mag-ap12_mag)\n", @@ -693,11 +693,12 @@ " width_ratios=[0.8, 0.2], figsize=(10, 6))\n", "ylims = [-2, 2]\n", "\n", - "ax.plot(i_kronRad, (cmodel_mag-kron_mag), '.', alpha=.1,\n", - " label='Kron')\n", - "ax.plot(i_kronRad, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", + "ax.plot(i_kronRad, (cmodel_mag-gaap_mag), 's', alpha=.3,\n", " label='gaapOptimal')\n", "\n", + "ax.plot(i_kronRad, (cmodel_mag-kron_mag), 'o', alpha=.3,\n", + " label='Kron')\n", + "\n", "ax2.hist((cmodel_mag-kron_mag), orientation=\"horizontal\",\n", " bins=np.linspace(ylims[0], ylims[1], 40), align='mid',\n", " histtype=\"step\", stacked=True, fill=False)\n", @@ -719,7 +720,7 @@ "id": "e9db247f-8fa8-4f59-97f0-d6076a3e9295", "metadata": {}, "source": [ - "> Figure 3: The left panel figure shows the i-band magnitude difference between cModel and Kron (blue) and between cModel and gaapOptimal (orange) vs the Kron radius (a proxy for galaxy size) for the galaxies in the query. The dashed line indicates where the two magnitudes would have the same value. The gaapOptimal magnitude always underestimates the flux, while the Kron magnitude approaches the cModel magnitude for fainter galaxies. The right panel shows the histogram of the magnitude differences in the left panel, illustrating that while cModel - Kron magnitudes are similar on average (blue histogram) the gaapOptimal systematically underestimates the flux relative to cModel (orange histogram). " + "> Figure 3: The left panel figure shows the i-band magnitude difference between cModel and Kron (blue squares) and between cModel and gaapOptimal (orange circles) vs the Kron radius (a proxy for galaxy size) for the galaxies in the query. The dashed line indicates where the two magnitudes would have the same value. The gaapOptimal magnitude always underestimates the flux, while the Kron magnitude approaches the cModel magnitude for fainter galaxies. The right panel shows the histogram of the magnitude differences in the left panel, illustrating that while cModel - Kron magnitudes are similar on average (blue histogram) the gaapOptimal systematically underestimates the flux relative to cModel (orange histogram). " ] }, { @@ -732,7 +733,7 @@ "fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(7, 6))\n", "ylims = [-1.2, 1.2]\n", "\n", - "ax.plot(cmodel_mag, (cmodel_mag-kron_mag), '.', alpha=.1,\n", + "ax.plot(cmodel_mag, (cmodel_mag-kron_mag), 's', alpha=.3,\n", " label='cModel-Kron', color='blue')\n", "x = cmodel_mag\n", "y = (cmodel_mag-kron_mag)\n", @@ -741,7 +742,7 @@ "binctr = bin_edge[:-1] + (bin_edge[1:]-bin_edge[:-1])/2\n", "ax.plot(binctr, bin_mean, color='blue', lw=2, label='bin median', zorder=10)\n", "\n", - "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag), '.', alpha=.1,\n", + "ax.plot(cmodel_mag, (cmodel_mag-gaap_mag), 'o', alpha=.3,\n", " label='cModel - gaapOptimal', color='orange')\n", "\n", "x = cmodel_mag\n", @@ -763,7 +764,7 @@ "id": "b30953c9-2c2d-4569-a96b-3b558b0b672f", "metadata": {}, "source": [ - "> Figure 4: The figure shows the i-band magnitude difference between cModel and Kron (blue) and between cModel and gaapOptimal (orange) vs the cModel magnitude for the galaxies in the query. The lines correspond to the running median in magnitude bins to illustrate the trend. The dashed line indicates where the two magnitudes would have the same value. The gaapOptimal magnitude always underestimates the flux, while the Kron magnitude approaches the cModel magnitude for fainter galaxies." + "> Figure 4: The figure shows the i-band magnitude difference between cModel and Kron (blue squares) and between cModel and gaapOptimal (orange circles) vs the cModel magnitude for the galaxies in the query. The lines correspond to the running median in magnitude bins to illustrate the trend. The dashed line indicates where the two magnitudes would have the same value. The gaapOptimal magnitude always underestimates the flux, while the Kron magnitude approaches the cModel magnitude for fainter galaxies." ] }, { @@ -908,11 +909,7 @@ "print('Job phase is', job.phase)\n", "\n", "results = job.fetch_result()\n", - "tab2 = results.to_table()\n", - "\n", - "i_random_gaap_mag = -2.50 * np.log10(tab2['i_gaapOptimalFlux']) + 31.4\n", - "r_random_gaap_mag = -2.50 * np.log10(tab2['r_gaapOptimalFlux']) + 31.4\n", - "g_random_gaap_mag = -2.50 * np.log10(tab2['g_gaapOptimalFlux']) + 31.4\n" + "tab2 = results.to_table()\n" ] }, { @@ -920,7 +917,9 @@ "id": "f5bcc8d3-3607-492f-93d2-79f239321307", "metadata": {}, "source": [ - "First, calculate the magnitudes of galaxies in the other filters near the galaxy cluster from the query performed in Section 2. This will enable plotting their colors." + "First, calculate the magnitudes of galaxies in the 'random' location (outside the galaxy cluster) and also the magnitudes for the other filters near the galaxy cluster from the query performed in Section 2. This will enable plotting their colors.\n", + "\n", + "> **Warning:** Like in Section 2.3, the following cell will produce warnings for invalid value encountered in log10, which happens if the source flux is negative. This happens for a small number of objects and since the goal of the plot is to see the distribution of the majority of sources, the warning can be safely ignored. " ] }, { @@ -930,6 +929,10 @@ "metadata": {}, "outputs": [], "source": [ + "i_random_gaap_mag = -2.50 * np.log10(tab2['i_gaapOptimalFlux']) + 31.4\n", + "r_random_gaap_mag = -2.50 * np.log10(tab2['r_gaapOptimalFlux']) + 31.4\n", + "g_random_gaap_mag = -2.50 * np.log10(tab2['g_gaapOptimalFlux']) + 31.4\n", + "\n", "u_cluster_gaap_mag = -2.50 * np.log10(tab['u_gaapOptimalFlux']) + 31.4\n", "g_cluster_gaap_mag = -2.50 * np.log10(tab['g_gaapOptimalFlux']) + 31.4\n", "r_cluster_gaap_mag = -2.50 * np.log10(tab['r_gaapOptimalFlux']) + 31.4\n", From a9cef9e23e45779de99e95ca9567cca8b002207a Mon Sep 17 00:00:00 2001 From: christinawilliams <christina.c.williams@gmail.com> Date: Wed, 19 Feb 2025 17:55:20 +0000 Subject: [PATCH 99/99] finalizing --- DP02_17_Galaxy_Photometry.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/DP02_17_Galaxy_Photometry.ipynb b/DP02_17_Galaxy_Photometry.ipynb index 37ce0ce..83407c7 100644 --- a/DP02_17_Galaxy_Photometry.ipynb +++ b/DP02_17_Galaxy_Photometry.ipynb @@ -8,8 +8,7 @@ }, "source": [ "# DP0.2 Notebook 17 Galaxy Photometry\n", - "\n", - "<img align=\"left\" src = https://project.lsst.org/sites/default/files/Rubin-O-Logo_0.png width=250 style=\"padding: 10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", + "<img align=\"left\" src = https://noirlab.edu/public/media/archives/logos/svg/logo250.svg width=250 style=\"background-color:white; padding:10px\" alt=\"Rubin Observatory logo, a graphical representation of turning stars into data.\">\n", "<br>\n", "Contact author(s): Christina Williams <br>\n", "Last verified to run: 2024-02-10 <br>\n",