From c10d7307e58f1ddb1382bc267736fad8c6960a0f Mon Sep 17 00:00:00 2001 From: Elaine Snyder Date: Mon, 11 Dec 2023 12:16:25 -0500 Subject: [PATCH] first commit of three tutorial notebooks --- notebooks/ullyses-coadd.ipynb | 889 ++++++++++++++++++++ notebooks/ullyses-getrawdata.ipynb | 1042 +++++++++++++++++++++++ notebooks/ullyses-walkthrough.ipynb | 1194 +++++++++++++++++++++++++++ 3 files changed, 3125 insertions(+) create mode 100644 notebooks/ullyses-coadd.ipynb create mode 100644 notebooks/ullyses-getrawdata.ipynb create mode 100644 notebooks/ullyses-walkthrough.ipynb diff --git a/notebooks/ullyses-coadd.ipynb b/notebooks/ullyses-coadd.ipynb new file mode 100644 index 0000000..aa0f229 --- /dev/null +++ b/notebooks/ullyses-coadd.ipynb @@ -0,0 +1,889 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "\n", + "# Using the ULLYSES coaddition algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Goals\n", + "\n", + "**NOTE**: It is recommended that you read/work through the `ullyses-walkthrough.ipynb` first before running this notebook.\n", + "\n", + "By the end of this tutorial, you will:\n", + "\n", + "- learn how to create ULLYSES coadded and abutted products\n", + "- learn how to create coadded and abutted products for non-ULLYSES data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "**0. [Introduction](#introduction)**\n", + "\n", + "**1. [Obtain Data](#sec1)**\n", + "\n", + "**2. [Coadding and abutting ULLYSES data](#sec2)**\n", + "\n", + "\\- 2.1 [Coadding data in a directory](#sec21)\n", + "\n", + "\\- 2.2 [Coadding a list of data files](#sec22) \n", + "\n", + "\\- 2.2 [Inspect output products](#sec23)\n", + "\n", + "**3. [Coadding non-ULLYESS data](#sec3)**\n", + "\n", + "\\- 3.1 [Inspect output products](#sec31)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "\n", + "## Introduction\n", + "\n", + "The Hubble Space Telescope’s (HST) Ultraviolet Legacy Library of Young Stars as Essential Standards ([ULLYSES](https://ullyses.stsci.edu/index.html) program has devoted approximately 1,000 HST orbits to the production of an ultraviolet spectroscopic library of young high- and low-mass stars in the local universe. \n", + "\n", + "The ULLYSES team produces several types of High Level Science Products (HLSPs). Products are made using both archival HST/FUSE data and new HST observations obtained through the ULLYSES program. Data of the same target and same grating are coadded, as described [here](https://ullyses.stsci.edu/ullyses-data-description.html#CoaddSpectra). Data of the same target, but different gratings and/or instruments, are abutted as described [here](https://ullyses.stsci.edu/ullyses-data-description.html#AbutSpectra).\n", + "\n", + "In this notebook we will show how to create coadded and abutted spectral products for ULLYSES data, and coadded products for non-ULLYSES data." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Imports\n", + "We need only access to basic python packages, astropy for reading FITS files, matplotlib for plotting, and the ullyses package to coadd and abut data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import os\n", + "import glob\n", + "from astropy.io import fits\n", + "\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "plt.rcParams['figure.figsize']=13,6\n", + "plt.style.use('seaborn-v0_8-notebook')\n", + "\n", + "from ullyses.ullyses_coadd_abut_wrapper import main, coadd_and_abut_files\n", + "from ullyses.generic_coadd_wrapper import coadd_files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Obtain Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To download data, we will retrieve it directly from MAST. For this example, we will simply download the ULLYSES observations of target AV-175. This includes three COS/G130M cenwave 1291 datasets and five COS/G160M cenwave 1611 datasets.\n", + "\n", + "These datasets will download into a new folder in your current working directory, called `notebook_download/`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 3310k 0 3310k 0 0 2379k 0 --:--:-- 0:00:01 --:--:-- 2383k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 3310k 0 3310k 0 0 3611k 0 --:--:-- --:--:-- --:--:-- 3629k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 3310k 0 3310k 0 0 3453k 0 --:--:-- --:--:-- --:--:-- 3466k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 3310k 0 3310k 0 0 3876k 0 --:--:-- --:--:-- --:--:-- 13620 0 --:--:-- --:--:-- --:--:-- 3885k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 3310k 0 3310k 0 0 3357k 0 --:--:-- --:--:-- --:--:-- 3370k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 3310k 0 3310k 0 0 4588k 0 --:--:-- --:--:-- --:--:-- 4616k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 3310k 0 3310k 0 0 3567k 0 --:--:-- --:--:-- --:--:-- 3582k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 3310k 0 3310k 0 0 0 0 --:--:-- --:--:-- --:--:-- 0 4813k 0 --:--:-- --:--:-- --:--:-- 4846k\n" + ] + } + ], + "source": [ + "!curl -L -X GET \"https://mast.stsci.edu/search/hst/api/v0.1/retrieve_product?product_name=LEEY3C010%2Fleey3ce5q_x1d.fits\" --output \"notebook_download/leey3ce5q_x1d.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/search/hst/api/v0.1/retrieve_product?product_name=LEEY3C010%2Fleey3ce8q_x1d.fits\" --output \"notebook_download/leey3ce8q_x1d.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/search/hst/api/v0.1/retrieve_product?product_name=LEEY3C010%2Fleey3cefq_x1d.fits\" --output \"notebook_download/leey3cefq_x1d.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/search/hst/api/v0.1/retrieve_product?product_name=LEEY3C020%2Fleey3cejq_x1d.fits\" --output \"notebook_download/leey3cejq_x1d.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/search/hst/api/v0.1/retrieve_product?product_name=LEEY3C020%2Fleey3cemq_x1d.fits\" --output \"notebook_download/leey3cemq_x1d.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/search/hst/api/v0.1/retrieve_product?product_name=LEEY3C020%2Fleey3cepq_x1d.fits\" --output \"notebook_download/leey3cepq_x1d.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/search/hst/api/v0.1/retrieve_product?product_name=LEEY3C020%2Fleey3cesq_x1d.fits\" --output \"notebook_download/leey3cesq_x1d.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/search/hst/api/v0.1/retrieve_product?product_name=LEEY3C020%2Fleey3ceyq_x1d.fits\" --output \"notebook_download/leey3ceyq_x1d.fits\" --fail --create-dirs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Coadd and abut ULLYSES data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To create coadded and abutted products for ULLYSES data, specific information about the ULLYSES target is looked up on-the-fly during processing. This includes the officially designated target name and coordinates, which are stored in the output header.\n", + "\n", + "Data can be coadded and abutted by either specifying:\n", + "1. An input directory, or\n", + "2. A list of input files (which could be located across different directories)\n", + "\n", + "Additionally, you must supply an output directory. Optional arguments include: a version number for the output filenames and specifying whether existing products should be overwritten.\n", + "\n", + "Output filenames have the form:\n", + "\n", + "`hlsp_ullyses______`\n", + "\n", + "where\n", + "\n", + "`` is the target name\n", + "\n", + "`` is the data release identifier (dr1, dr2, etc.)\n", + "\n", + "``, ``, ``, and `` are populated as specified [here](https://ullyses.stsci.edu/ullyses-data-description.html#productDescrip)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Coadding data in a directory" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# First define the input and output directories\n", + "indir = \"notebook_download\"\n", + "indir_method_outdir = \"coadd_ullyses_indir\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "notebook_download\n", + " notebook_download\n", + "notebook_download/leey3cepq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3ceyq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cejq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cemq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cesq_x1d.fits added to file list for instrument/grating COS/G160M\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jotaylor/miniconda3/envs/ullyses_dr7/lib/python3.9/site-packages/ullyses/coadd.py:563: RuntimeWarning: invalid value encountered in divide\n", + " thru_nans = segment.data['net'] / segment.data['flux']\n", + "WARNING: VerifyWarning: Card is too long, comment will be truncated. [astropy.io.fits.card]\n", + "/Users/jotaylor/miniconda3/envs/ullyses_dr7/lib/python3.9/site-packages/ullyses/coadd.py:563: RuntimeWarning: invalid value encountered in divide\n", + " thru_nans = segment.data['net'] / segment.data['flux']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Wrote coadd_ullyses_indir/hlsp_ullyses_hst_cos_av-224_g160m_dr7_cspec.fits\n", + "notebook_download/leey3ce5q_x1d.fits added to file list for instrument/grating COS/G130M\n", + "notebook_download/leey3ce8q_x1d.fits added to file list for instrument/grating COS/G130M\n", + "notebook_download/leey3cefq_x1d.fits added to file list for instrument/grating COS/G130M\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: VerifyWarning: Card is too long, comment will be truncated. [astropy.io.fits.card]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Wrote coadd_ullyses_indir/hlsp_ullyses_hst_cos_av-224_g130m_dr7_cspec.fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: VerifyWarning: Card is too long, comment will be truncated. [astropy.io.fits.card]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Wrote coadd_ullyses_indir/hlsp_ullyses_hst_cos_av-224_g130m-g160m_dr7_aspec.fits\n", + "Making a product from these gratings\n", + "COS/G130M 900-1470 (Actual: 1131.3-1428.4)\n", + "COS/G160M 1342-1800 (Actual: 1418.4-1789.6)\n", + "Transition wavelengths tweaked\n", + "Transition wavelengths tweaked\n", + "Starting at the short wavelength end with grating COS/G130M\n", + "Abutting COS/G160M product to current result\n", + "With a transition wavelength of 1428.4016896086262\n", + "Truncating current grating at 1789.5522227060096\n", + " Wrote coadd_ullyses_indir/hlsp_ullyses_hst_cos_av-224_uv_dr7_preview-spec.fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: VerifyWarning: Card is too long, comment will be truncated. [astropy.io.fits.card]\n" + ] + } + ], + "source": [ + "main(indir, indir_method_outdir, version=\"dr7\", clobber=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Coadding a list of data files" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# First define the input and output directories\n", + "indir = \"notebook_download\"\n", + "infiles_method_outdir = \"coadd_ullyses_infiles\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jotaylor/miniconda3/envs/ullyses_dr7/lib/python3.9/site-packages/ullyses/coadd.py:563: RuntimeWarning: invalid value encountered in divide\n", + " thru_nans = segment.data['net'] / segment.data['flux']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "notebook_download/leey3cepq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3ceyq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cejq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cemq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cesq_x1d.fits added to file list for instrument/grating COS/G160M\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: VerifyWarning: Card is too long, comment will be truncated. [astropy.io.fits.card]\n", + "/Users/jotaylor/miniconda3/envs/ullyses_dr7/lib/python3.9/site-packages/ullyses/coadd.py:563: RuntimeWarning: invalid value encountered in divide\n", + " thru_nans = segment.data['net'] / segment.data['flux']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Wrote coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_g160m_dr7_cspec.fits\n", + "notebook_download/leey3ce5q_x1d.fits added to file list for instrument/grating COS/G130M\n", + "notebook_download/leey3ce8q_x1d.fits added to file list for instrument/grating COS/G130M\n", + "notebook_download/leey3cefq_x1d.fits added to file list for instrument/grating COS/G130M\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: VerifyWarning: Card is too long, comment will be truncated. [astropy.io.fits.card]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Wrote coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_g130m_dr7_cspec.fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: VerifyWarning: Card is too long, comment will be truncated. [astropy.io.fits.card]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Wrote coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_g130m-g160m_dr7_aspec.fits\n", + "Making a product from these gratings\n", + "COS/G130M 900-1470 (Actual: 1131.3-1428.4)\n", + "COS/G160M 1342-1800 (Actual: 1418.4-1789.6)\n", + "Transition wavelengths tweaked\n", + "Transition wavelengths tweaked\n", + "Starting at the short wavelength end with grating COS/G130M\n", + "Abutting COS/G160M product to current result\n", + "With a transition wavelength of 1428.4016896086262\n", + "Truncating current grating at 1789.5522227060096\n", + " Wrote coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_uv_dr7_preview-spec.fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: VerifyWarning: Card is too long, comment will be truncated. [astropy.io.fits.card]\n" + ] + } + ], + "source": [ + "# Determine list of input files on the fly, or you could specify a specific list\n", + "infiles = glob.glob(os.path.join(indir, \"*fits\"))\n", + "coadd_and_abut_files(infiles, infiles_method_outdir, version=\"dr7\", clobber=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Inspect output products" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, let's ensure that the products created using both methods above are identical." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " fitsdiff: 6.0.0\n", + " a: coadd_ullyses_indir/hlsp_ullyses_hst_cos_av-224_uv_dr7_preview-spec.fits\n", + " b: coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_uv_dr7_preview-spec.fits\n", + " Maximum number of different data values to be reported: 10\n", + " Relative tolerance: 0.0, Absolute tolerance: 0.0\n", + "\n", + "No differences found.\n", + "\n", + "\n", + " fitsdiff: 6.0.0\n", + " a: coadd_ullyses_indir/hlsp_ullyses_hst_cos_av-224_g130m_dr7_cspec.fits\n", + " b: coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_g130m_dr7_cspec.fits\n", + " Maximum number of different data values to be reported: 10\n", + " Relative tolerance: 0.0, Absolute tolerance: 0.0\n", + "\n", + "No differences found.\n", + "\n", + "\n", + " fitsdiff: 6.0.0\n", + " a: coadd_ullyses_indir/hlsp_ullyses_hst_cos_av-224_g130m-g160m_dr7_aspec.fits\n", + " b: coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_g130m-g160m_dr7_aspec.fits\n", + " Maximum number of different data values to be reported: 10\n", + " Relative tolerance: 0.0, Absolute tolerance: 0.0\n", + "\n", + "No differences found.\n", + "\n", + "\n", + " fitsdiff: 6.0.0\n", + " a: coadd_ullyses_indir/hlsp_ullyses_hst_cos_av-224_g160m_dr7_cspec.fits\n", + " b: coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_g160m_dr7_cspec.fits\n", + " Maximum number of different data values to be reported: 10\n", + " Relative tolerance: 0.0, Absolute tolerance: 0.0\n", + "\n", + "No differences found.\n", + "\n" + ] + } + ], + "source": [ + "indir_products = glob.glob(os.path.join(indir_method_outdir, \"*fits\"))\n", + "for indir_item in indir_products:\n", + " infiles_item = os.path.join(infiles_method_outdir, os.path.basename(indir_item))\n", + " fd = fits.FITSDiff(indir_item, infiles_item)\n", + " print(fd.report())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's compare the input x1d files to the output coadded and abutted products. We can find the files that contributed to product in the `PROVENANCE`, or 2nd, extension." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Let's look at the two level2 products (coadds), and the level4 product (all modes, abutted) product.\n", + "products = glob.glob(os.path.join(indir_method_outdir, \"*fits\"))\n", + "for prod in products:\n", + " if fits.getval(prod, \"HLSP_LVL\") not in [2, 4]:\n", + " continue\n", + " fig,ax = plt.subplots(1, 1, figsize=(13,6))\n", + " prodname = os.path.basename(prod)\n", + " prov = fits.getdata(prod, 2)\n", + " prod_data = fits.getdata(prod)\n", + " input_files = prov[\"filename\"]\n", + " # This just gives us the basename of the input files, we need to add the directory ourselves.\n", + " for infile in input_files:\n", + " infile_path = os.path.join(indir, infile)\n", + " infile_data = fits.getdata(infile_path)\n", + " grating = fits.getval(infile_path, \"opt_elem\")\n", + " plt.plot(infile_data[\"wavelength\"].flatten(), infile_data[\"flux\"].flatten(), alpha=.6, label=f\"{infile}, {grating}\")\n", + " ax.plot(prod_data[\"wavelength\"].flatten(), prod_data[\"flux\"].flatten(), alpha=.6, color=\"black\", label=prodname)\n", + " ax.set_xlabel(\"Wavelength [A]\")\n", + " ax.set_ylabel(\"Flux [erg/s/cm**2/A]\")\n", + " ax.legend()\n", + " ax.set_title(prodname)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Coadd non-ULLYSES data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Creating coadded and abutted products for non-ULLYSES data is similar, but only supports supplying an input list of files, rather than an input directory. You must supply an output directory. \n", + "\n", + "Optional arguments include: an output filename, and specifying whether existing products should be overwritten. **NOTE**: If an output filename is provided, all input files to be coadded must be of a single grating. If an output filename is not specified, or is set to `None`, one will be constructed on-the-fly of the format `__coadd.fits`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# First define the input and output directories\n", + "indir = \"notebook_download\"\n", + "generic_outdir = \"coadd_generic_infiles\"" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "notebook_download/leey3cepq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3ceyq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cejq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cemq_x1d.fits added to file list for instrument/grating COS/G160M\n", + "notebook_download/leey3cesq_x1d.fits added to file list for instrument/grating COS/G160M\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jotaylor/miniconda3/envs/ullyses_dr7/lib/python3.9/site-packages/ullyses/coadd.py:563: RuntimeWarning: invalid value encountered in divide\n", + " thru_nans = segment.data['net'] / segment.data['flux']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wrote coadd_generic_infiles/cos_g160m_coadd.fits\n", + "notebook_download/leey3ce5q_x1d.fits added to file list for instrument/grating COS/G130M\n", + "notebook_download/leey3ce8q_x1d.fits added to file list for instrument/grating COS/G130M\n", + "notebook_download/leey3cefq_x1d.fits added to file list for instrument/grating COS/G130M\n", + "Wrote coadd_generic_infiles/cos_g130m_coadd.fits\n" + ] + } + ], + "source": [ + "# Determine list of input files on the fly, or you could specify a specific list\n", + "infiles = glob.glob(os.path.join(indir, \"*fits\"))\n", + "coadd_files(infiles, generic_outdir, outfile=None, clobber=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Inspect output products" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the output filename is different when using the generic coadd method, e.g. `cos_g130m_coadd.fits` vs. `hlsp_ullyses_hst_cos_av-224_g130m_dr7_cspec.fits`. \n", + "\n", + "Let's see how the G130M output file differs from the one we made using the ULLYSES coadd method." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " fitsdiff: 6.0.0\n", + " a: coadd_generic_infiles/cos_g130m_coadd.fits\n", + " b: coadd_ullyses_infiles/hlsp_ullyses_hst_cos_av-224_g130m_dr7_cspec.fits\n", + " Maximum number of different data values to be reported: 10\n", + " Relative tolerance: 0.0, Absolute tolerance: 0.0\n", + "\n", + "Primary HDU:\n", + "\n", + " Headers contain differences:\n", + " Headers have different number of cards:\n", + " a: 34\n", + " b: 40\n", + " Extra keyword 'CAL_VER' in b: 'ULLYSES Cal 4.0.0'\n", + " Extra keyword 'HLSPID' in b: 'ULLYSES'\n", + " Extra keyword 'HLSPLEAD' in b: 'Julia Roman-Duval'\n", + " Extra keyword 'HLSP_LVL' in b: 2\n", + " Extra keyword 'HLSP_VER' in b: 'dr7'\n", + " Extra keyword 'HSLPNAME' in b: 'Hubble UV Legacy Library of Young Stars as Essential Standards'\n", + " Keyword EPOCH has different values:\n", + " (str) a> 'UNKNOWN'\n", + " (float) b> 2016.0\n", + " Keyword FILENAME has different values:\n", + " a> cos_g130m_coadd.fits\n", + " b> hlsp_ullyses_hst_cos_av-224_g130m_dr7_cspec.fits\n", + " Keyword S_REGION has different values:\n", + " a> CIRCLE 14.816844207883333 -72.07903852799 0.00034722222222222224\n", + " ? ^^ -- ^^ ^ ^^ ^\n", + " b> CIRCLE 14.816840457334816 -72.07903654693436 0.00034722222222222224\n", + " ? + ^ ^^^^ ^ ^^ ^^^^\n", + " Keyword S_REGION has different comments:\n", + " a> R\n", + " Keyword TARGNAME has different values:\n", + " a> AV224\n", + " b> AV 224\n", + " ? +\n", + " Keyword TARG_DEC has different values:\n", + " a> -72.07903852799\n", + " b> -72.07903654693436\n", + " Keyword TARG_DEC has different comments:\n", + " a> [deg] Averaged target declination\n", + " ? ^^^^^^^^^^\n", + " b> [deg] Target declination\n", + " ? ^\n", + " Keyword TARG_RA has different values:\n", + " a> 14.816844207883333\n", + " b> 14.816840457334816\n", + " Keyword TARG_RA has different comments:\n", + " a> [deg] Averaged target right ascension\n", + " ? ^^^^^^^^^^\n", + " b> [deg] Target right ascension\n", + " ? ^\n", + "\n" + ] + } + ], + "source": [ + "generic_coadd = \"coadd_generic_infiles/cos_g130m_coadd.fits\"\n", + "ullyses_coadd = os.path.join(infiles_method_outdir, \"hlsp_ullyses_hst_cos_av-224_g130m_dr7_cspec.fits\")\n", + "fd = fits.FITSDiff(generic_coadd, ullyses_coadd)\n", + "print(fd.report())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As mentioned before, some metadata information is looked up on-the-fly for ULLYSES data. This includes 'official' coordinates and target name of the input target, as can be seen in the differences above. Additionally, keywords specific to the ULLYSES HLSPs are missing in the generic coadded product.\n", + "\n", + "Let's look at the data itself though. It should be identical." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Difference between G130M coadds')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "generic_data = fits.getdata(generic_coadd)\n", + "ullyses_data = fits.getdata(ullyses_coadd)\n", + "fig,axes = plt.subplots(2, 1, figsize=(13,12))\n", + "axes = axes.flatten()\n", + "axes[0].plot(generic_data[\"wavelength\"].flatten(), generic_data[\"flux\"].flatten(), alpha=.6, color=\"red\", label=\"Generic G130M coadd\")\n", + "axes[0].plot(ullyses_data[\"wavelength\"].flatten(), ullyses_data[\"flux\"].flatten(), alpha=.6, color=\"black\", label=\"ULLYSES G130M coadd\")\n", + "axes[0].legend()\n", + "axes[0].set_xlabel(\"Wavelength [A]\")\n", + "axes[0].set_ylabel(\"Flux [erg/s/cm**2/A]\")\n", + "axes[0].set_title(\"G130M Coadds\")\n", + "\n", + "diff = generic_data[\"flux\"].flatten() - ullyses_data[\"flux\"].flatten()\n", + "axes[1].plot(diff)\n", + "axes[1].set_ylabel(\"Difference between coadds\")\n", + "axes[1].set_title(\"Difference between G130M coadds\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The difference between the two coadds is identically zero!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Additional Resources\n", + "\n", + "- [ULLYSES](https://ullyses.stsci.edu)\n", + "- [MAST API](https://mast.stsci.edu/api/v0/index.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## About this Notebook\n", + "For support, contact us at the [ULLYSES Helpdesk](https://stsci.service-now.com/hst?id=sc_cat_item&sys_id=a3b8ec5edbb7985033b55dd5ce961990&sysparm_category=ac85189bdb4683c033b55dd5ce96199c).\n", + "\n", + "**Author:** Jo Taylor and Elaine M Frazer \\\n", + "**Updated On:** Dec. 11 2023" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citations\n", + "* See the [ULLYSES website](https://ullyses.stsci.edu/ullyses-cite.html) for citation guidelines.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Top of Page](#top)\n", + "\"Space " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/ullyses-getrawdata.ipynb b/notebooks/ullyses-getrawdata.ipynb new file mode 100644 index 0000000..4b7e526 --- /dev/null +++ b/notebooks/ullyses-getrawdata.ipynb @@ -0,0 +1,1042 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "\n", + "# ULLYSES Data Download Tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Goals\n", + "\n", + "By the end of this tutorial, you will:\n", + "\n", + "- Know how to use Astroquery to download ULLYSES HLSPs\n", + "- Be able to use ullyses-utils.select_pids to get PIDs for desired subsets of ULLYSES programs, and know how to download those datasets\n", + "- Understand where to find and how to download the files that went into a ULLYSES HLSP\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "**0. [Introduction](#introduction)**\n", + "\n", + "**1. [Downloading HLSP Files Using Astroquery](#astroquery)**\n", + "\n", + "**2. [Using ullyses_utils.select_pids](#selectpids)**\n", + "\n", + "**3. [Downloading HLSP Constiuent Raw Data Files](#constiuent)**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Introduction\n", + "The Hubble Space Telescope’s (HST) Ultraviolet Legacy Library of Young Stars as Essential Standards ([ULLYSES](https://ullyses.stsci.edu/index.html) program has devoted approximately 1,000 HST orbits to the production of an ultraviolet spectroscopic library of young high- and low-mass stars in the local universe. This Director’s Discretionary program has been designed to take advantage of HST’s unique UV capabilities, as both high- and low-mass stars feature different complex UV emission processes that strongly impact their surroundings, but are difficult to model. The UV emission from star formation is central to a wide range of vital astrophysical issues, ranging from cosmic reionization to the formation of planets.\n", + "\n", + "The ULLYSES program has uniformly sampled the fundamental astrophysical parameter space for each mass regime — including spectral type, luminosity class, and metallicity for massive OB stars (in the Magellanic Clouds and two other lower-metallicity nearby galaxies) and the mass, age, and disk accretion rate for low-mass T Tauri stars (in eight young Galactic associations). The data were gathered over a three-year period, from Cycle 27 through Cycle 29 (2020-2022).\n", + "\n", + "The ULLYSES team produces several types of High Level Science Products (HLSPs). Products are made using both archival data and new HST observations obtained through the ULLYSES program. Data products are available from the [ULLYSES website](https://ullyses.stsci.edu/ullyses-download.html) (HLSPs and contributing data), the [MAST Data Discovery Portal](https://mast.stsci.edu/) (HLSPs and contributing data), directly as a High-Level Science Product collection using the [DOI](https://archive.stsci.edu/hlsp/ullyses) (HLSPs only), or using the Python package [Astroquery](https://astroquery.readthedocs.io/en/latest/) to search for and download files from Python scripts you write.\n", + "\n", + "This notebook will guide users through downloading HLSPs and raw ULLYSES data through various means using Astroquery." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Imports\n", + "\n", + "- *astropy.table Table* for creating tidy tables of the data\n", + "\n", + "- *Path* to create product and data directories\n", + "- *shutil* to perform directory and file operations\n", + "- *glob* to work with multiple files in our directories\n", + "\n", + "\n", + "- *astroquery* to download HLSPs and raw data files" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "# %matplotlib inline\n", + "# import numpy as np\n", + "# from astropy.io import fits\n", + "# from astropy.wcs import WCS\n", + "from astropy.table import Table\n", + "# import matplotlib.pyplot as plt\n", + "# plt.rcParams['figure.figsize']=10,6\n", + "# plt.style.use('seaborn-v0_8-notebook')\n", + "# import os\n", + "# from pathlib import Path\n", + "import shutil\n", + "import glob\n", + "from astroquery.mast import Observations\n", + "\n", + "# add some text to intro about how to install ullyses and ullyses utils!!\n", + "\n", + "from ullyses_utils.select_pids import select_all_pids, select_pids" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Downloading HLSP Files Using Astroquery" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `Observations` Class in Astroquery.mast has several different useful functions for searching and downloading data products from MAST. We can use the `query_criteria` function to first search out all ULLYSES HLSP data that is available on MAST using the search criteria `provenance_name='ULLYSES'` as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [], + "source": [ + "search = Observations.query_criteria(provenance_name='ULLYSES')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above cell returns `search` which is an Astropy.Table that holds our search results. We can print the results next:" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " instrument_name filters target_name s_ra s_dec proposal_id \n", + "-------------------------------------------------- ---------------------------------- ----------------------- ------------------ ------------------- -------------------------------\n", + " COS/FUV G130M;G160M 2DFS-163 9.2426666667 -73.3925519167 16100\n", + " COS/FUV G130M;G160M 2DFS-2266 16.8094758333 -72.2298698889 16370\n", + " COS/FUV | STIS/FUV-MAMA E140M;G130M 2DFS-2553 17.34146875 -73.2616487222 15629_16803\n", + " COS/FUV G130M;G160M 2DFS-3689 21.1322654167 -73.3636851944 16373\n", + " COS/FUV G130M;G160M 2DFS-3694 21.1435383333 -73.1524739444 16101\n", + " COS/FUV | STIS/FUV-MAMA E140M;G130M 2DFS-3780 21.6470383333 -73.2545277222 16809\n", + " COS/FUV G130M;G160M 2DFS-3947 22.65494125 -73.4206643056 16373\n", + " COS/FUV G130M;G160M 2DFS-3954 22.6796166667 -73.4178175278 16370\n", + " COS/FUV G160M 2DFS-5066 13.3035416667 -72.6166555556 15837\n", + " COS/FUV | FUV G130M;G160M 2DFS-999 13.6339920833 -72.743233 16370_G039\n", + " COS/FUV | STIS/NUV-MAMA E230M;G130M;G160M 2MASS-J04390163+2336029 69.75681960086999 23.600790274128336 11616\n", + " COS/FUV G130M 2MASS-J15570234-1950419 239.2597229231 -19.84513046713 15310\n", + " STIS/CCD | STIS/NUV-MAMA G230L;G430L;G750L 2MASSJ04383885+1546045 69.66188501 15.76792325 16593\n", + "COS/FUV | SBIG-STL-6303 | STIS/CCD | STIS/NUV-MAMA G130M;G160M;G230L;G430L;G750L;V;ip 2MASSJ11432669-7804454 175.8612083333 -78.0792777778 DDT2021A-001_16481\n", + " FUV | STIS/FUV-MAMA | STIS/NUV-MAMA E140M;E230M AV104 12.9101270833 -72.8016946667 9116_D162\n", + " COS/NUV | FUV | STIS/FUV-MAMA E140M;G185M AV14 11.6359458333 -73.10157 13004_15629_P117\n", + " COS/FUV G130M;G160M AV148 13.4259783333 -72.7098053333 11625_16372\n", + " FUV | STIS/FUV-MAMA E140M AV15 11.675670416700001 -73.4154201944 7437_P115\n", + " FUV | STIS/FUV-MAMA E140M AV16 11.72930125 -73.1428215833 14712_E511\n", + " FUV | STIS/FUV-MAMA E140M AV170 13.92675 -73.2918111111 7437_P217\n", + " ... ... ... ... ... ...\n", + "COS/FUV | SBIG-STL-6303 | STIS/CCD | STIS/NUV-MAMA G130M;G160M;G230L;G430L;G750L;V;ip V-XX-CHA 167.9152083333 -76.3375555556 DDT2021A-001_16481\n", + "COS/FUV | SBIG-STL-6303 | STIS/CCD | STIS/NUV-MAMA G230L;G430L;G750L;V;ip V505-ORI 84.6135833333 -2.7526944444 16113_DDT2020B-001_DDT2021A-001\n", + "COS/FUV | SBIG-STL-6303 | STIS/CCD | STIS/NUV-MAMA G130M;G160M;G230L;G430L;G750L;V;ip V510-ORI 84.9159583333 -2.5227500000000003 16113_DDT2020B-001_DDT2021A-001\n", + " COS/FUV G130M;G160M VFTS-169 84.45801125 -69.1744088889 16810\n", + " COS/FUV G130M;G160M VFTS-190 84.4720758333 -69.2158960556 16818\n", + " COS/FUV G130M;G160M VFTS-267 84.5581925 -69.1299223333 16369\n", + " COS/FUV G130M;G160M VFTS-355 84.6214633333 -68.96092125 16814\n", + " COS/FUV G130M;G160M VFTS-404 84.640975 -69.1658510278 16369\n", + " COS/FUV G130M;G160M VFTS-406 84.64157 -69.072533 16815\n", + " COS/FUV G130M;G160M VFTS-482 84.6679166667 -69.0998888889 16093\n", + " COS/FUV G130M;G160M VFTS-506 84.67315125 -69.0887461111 16810\n", + " COS/FUV G130M;G160M VFTS-542 84.67965 -69.096329 16812\n", + " COS/FUV G130M;G160M VFTS-66 84.3878870833 -69.076202 16096\n", + " COS/FUV G130M;G160M VFTS352 84.6185833333 -69.1886472222 13806\n", + " STIS/FUV-MAMA E140M VFTS440 84.6571666667 -69.0891583333 15629\n", + " COS/FUV G130M;G160M VFTS586 84.6891466667 -69.0476217778 16814\n", + " COS/FUV | FUV | STIS/NUV-MAMA E230M;G130M;G160M VFTS72 84.3935983333 -69.0194908333 14675_C002\n", + " STIS/FUV-MAMA E140M VFTS87 84.40275 -69.1255083333 15629\n", + " COS/FUV G130M;G160M W61-28-23 83.70899875 -69.7757061944 16369\n", + " COS/FUV G130M;G160M W61-28-5 83.61862625 -69.7324519167 16093\n", + "Length = 410 rows\n" + ] + } + ], + "source": [ + "# This down-selects the number of columns printed to just a few, which makes it easier to read\n", + "search.pprint_include_names = ('target_name', 's_ra', 's_dec', 'proposal_id', 'instrument_name', 'filters')\n", + "\n", + "search.pprint()\n", + "\n", + "# To print all columns use:\n", + "# search.pprint_all()\n", + "\n", + "# Or to print a single column use:\n", + "# search['target_name'].pprint()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, there are several results returned for the initial search. We can down-select our search by adding the name of the target we want, using the criteria `target_name='V505-ORI'`." + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [], + "source": [ + "search_target = Observations.query_criteria(target_name='V505-ORI', provenance_name='ULLYSES')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we use the function `get_product_list` with the input of the observation IDs that are returned from the query in the previous cell to get a table of all the data products that are available in MAST for these observations." + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " productFilename \n", + "---------------------------------------------------------------\n", + "hlsp_ullyses_hst_cos-stis_v505-ori_uv-opt_dr6_preview-spec.fits\n", + " hlsp_ullyses_hst_cos_v505-ori_g130m-g160m_dr6_cspec.fits\n", + " hlsp_ullyses_hst_cos_v505-ori_g130m_dr6_cspec.fits\n", + " hlsp_ullyses_hst_cos_v505-ori_g160m_dr6_cspec.fits\n", + "hlsp_ullyses_hst_stis_v505-ori_g230l-g430l-g750l_dr6_cspec.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g230l_dr6_cspec.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g230l_dr6_spec.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g230l_dr6_spec.yaml\n", + " hlsp_ullyses_hst_stis_v505-ori_g430l_dr6_cspec.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g430l_dr6_spec.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g430l_dr6_spec.yaml\n", + " hlsp_ullyses_hst_stis_v505-ori_g750l_dr6_cspec.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g750l_dr6_spec.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g750l_dr6_spec.yaml\n", + " hlsp_ullyses_hst_stis_v505-ori_g230l_dr6_spec.yaml\n", + " hlsp_ullyses_hst_stis_v505-ori_g230l_dr6_tss.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g430l_dr6_spec.yaml\n", + " hlsp_ullyses_hst_stis_v505-ori_g430l_dr6_tss.fits\n", + " hlsp_ullyses_hst_stis_v505-ori_g750l_dr6_spec.yaml\n", + " hlsp_ullyses_hst_stis_v505-ori_g750l_dr6_tss.fits\n", + " ...\n", + " oe9i3s020_sx2.fits\n", + " oe9i3s030_asn.fits\n", + " oe9i3s030_crj.fits\n", + " oe9i3sg7j_epc.fits\n", + " oe9i3sg8j_epc.fits\n", + " oe9i3sg9j_epc.fits\n", + " oe9i3s030_jif.fits\n", + " oe9i3s030_jit.fits\n", + " oe9i3s030_jwf.fits\n", + " oe9i3s030_jwt.fits\n", + " oe9i3s030_spt.fits\n", + " oe9i3s030_trl.fits\n", + " oe9i3s030_wav.fits\n", + " oe9i3s030_wsp.fits\n", + " oe9i3s030_log.txt\n", + " oe9i3s030_sx1.png\n", + " oe9i3s030_flt.fits\n", + " oe9i3s030_raw.fits\n", + " oe9i3s030_sx1.fits\n", + " oe9i3s030_sx2.fits\n", + "Length = 214 rows\n" + ] + } + ], + "source": [ + "data_products = Observations.get_product_list(search_target['obsid'])\n", + "print(data_products['productFilename'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we can use the function `download_products` to download all the files from our search. The user can specify where to download the data products with `download_dir`. Note that we specify `extension=['fits']`; there are also `yaml` files that may be downloaded. You can add those by adding 'yaml' to the extension list. Note also that we must specify `obs_collection=['HLSP']` so that we only get the high level science products, and not the constiuent data. If you want both, you can delete the `obs_collection` specification altogether. " + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading URL https://mast.stsci.edu/api/v0.1/Download/file?uri=mast:HLSP/ullyses/ngc1818-rob-d1/dr6/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m_dr6_cspec.fits to ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m_dr6_cspec.fits ... [Done]\n", + "Downloading URL https://mast.stsci.edu/api/v0.1/Download/file?uri=mast:HLSP/ullyses/ngc1818-rob-d1/dr6/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m_dr6_cspec.fits to ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m_dr6_cspec.fits ... [Done]\n", + "Downloading URL https://mast.stsci.edu/api/v0.1/Download/file?uri=mast:HLSP/ullyses/ngc1818-rob-d1/dr6/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g160m_dr6_cspec.fits to ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g160m_dr6_cspec.fits ... [Done]\n", + "Downloading URL https://mast.stsci.edu/api/v0.1/Download/file?uri=mast:HLSP/ullyses/ngc1818-rob-d1/dr6/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g185m_dr6_cspec.fits to ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g185m_dr6_cspec.fits ... [Done]\n", + "Downloading URL https://mast.stsci.edu/api/v0.1/Download/file?uri=mast:HLSP/ullyses/ngc1818-rob-d1/dr6/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g225m_dr6_cspec.fits to ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g225m_dr6_cspec.fits ... [Done]\n" + ] + }, + { + "data": { + "text/html": [ + "
Table length=5\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Local PathStatusMessageURL
str151str8objectobject
./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m_dr6_cspec.fitsCOMPLETENoneNone
./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m_dr6_cspec.fitsCOMPLETENoneNone
./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g160m_dr6_cspec.fitsCOMPLETENoneNone
./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g185m_dr6_cspec.fitsCOMPLETENoneNone
./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g225m_dr6_cspec.fitsCOMPLETENoneNone
" + ], + "text/plain": [ + "\n", + " Local Path Status Message URL \n", + " str151 str8 object object\n", + "------------------------------------------------------------------------------------------------------------------------------------------------------- -------- ------- ------\n", + "./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m_dr6_cspec.fits COMPLETE None None\n", + " ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m_dr6_cspec.fits COMPLETE None None\n", + " ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g160m_dr6_cspec.fits COMPLETE None None\n", + " ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g185m_dr6_cspec.fits COMPLETE None None\n", + " ./v505-ori/mastDownload/HLSP/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m/hlsp_ullyses_hst_cos_ngc1818-rob-d1_g225m_dr6_cspec.fits COMPLETE None None" + ] + }, + "execution_count": 144, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output_dir = './v505-ori/'\n", + "Observations.download_products(data_products, download_dir=output_dir, extension=['fits'], obs_collection=['HLSP'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All ULLYSES HLSP data products are now downloaded to your `download_dir` in the sub-directories starting with `mastDownload`. We can move these into a better folder structure using the following function." + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [], + "source": [ + "def mv_downloads(output_path):\n", + " # Specify the path to where the downloads were placed\n", + " mast_path = os.path.join(output_path, 'mastDownload/')\n", + " \n", + " # Get a list of all obs_id folders. Each folder contains the FITS files\n", + " obs_id_dirs = glob.glob(os.path.join(mast_path, '*', '*'))\n", + " \n", + " # Iterate through each of the sub-folders to change the path of each FITS file\n", + " for subdir in obs_id_dirs: \n", + " \n", + " # Get a list of all FITS files in the current ./mastDownload/*/ folder\n", + " sub_files = glob.glob(subdir + '/*fits')\n", + " \n", + " # Iterating through each of these files to change their path individually:\n", + " # We will be moving them to the top level, ./v505-ori/ in this example\n", + " for file in sub_files: \n", + " original_path = os.path.join(obs_id_path, file)\n", + " new_path = os.path.join(output_path, file.split('/')[-1])\n", + " shutil.move(file, new_path)\n", + " \n", + " # Last, remove the mastDownload directory\n", + " shutil.rmtree(os.path.join(output_path, 'mastDownload/'))\n", + "\n", + "mv_downloads(output_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, all your HLSP files should be nice and tidy in your output directory!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Using ullyses_utils.select_pids" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `select_pids` script in `ullyses_utils` has two functions that allow users to select the PIDS of both ULLYSES-orbserved and archival datasets for specific sub-sets of data. For example, one can select a specific region or target type. We will show some examples of these selections next.\n", + "\n", + "The function `select_all_pids()` is useful for selecting out different target types across many regions. We can see more information in the functions docstring by typing the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mselect_all_pids\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmassive\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mextra\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmonitoring\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msingle_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Use this function if you want to select more than one region's PIDs at once.\n", + "The logic behind writing this is:\n", + "1) if you want massive stars (LMC, SMC, lowz), specify massive=True. If you\n", + "do not want the \"extra\" stars included in the ULLYSES sample (i.e. stars\n", + "that were added after the original sample was created to fill the\n", + "luminosity/class bins), then specify extra=False.\n", + " -> Original sample + Extra sample: pids = select_all_pids(massive=True)\n", + " -> Original sample only: pids = select_all_pids(massive=True, extra=False)\n", + "2) if you want all regions of the t-tauri star sample, including the monitoring\n", + "stars, specify tts=True. If you do not want the monitoring stars in the sample\n", + "then specify monitoring=False.\n", + " -> All TTS: pids = select_all_pids(tts=True)\n", + " -> All TTS but the monitoring: pids = select_all_pids(tts=True, monitoring=False)\n", + "3) You want the entire sample of everything.\n", + " -> pids = select_all_pids()\n", + "4) If you want some combination of massive stars without the extra sample\n", + "*and* the TTS without the monitoring (or some combination), you can specify\n", + "a combination of the above keywords. For example:\n", + " -> pids = select_all_pids(massive=True, tts=True, extra=False)\n", + "There is an additional keyword \"single_list\" that is set to True by default,\n", + "which means you get a list of PIDs for both ULLYSES observed and archival\n", + "datasets. If you would like those separated out, specify single_list=False,\n", + "and the function will return a dictionary with the two lists separated out\n", + "with the keys \"ULLYSES\" and \"ARCHIVAL\".\n", + "\n", + "Inputs\n", + "-------\n", + "massive : Boolean (default=False)\n", + " Get massive stars (LMC, SMC, & Low-Z)\n", + "tts : Boolean (default=False)\n", + " Get all t-tauri stars\n", + "extra : Boolean (default=True)\n", + " should be used exclusively with \"massive\". Use to get the stars not\n", + " originally included in the core ULLYSES sample.\n", + "monitoring : Boolean (default=True)\n", + " should be used exclusively with \"tts\". Use to get the monitoring stars.\n", + "single_list : Boolean (default=True)\n", + " By default, return both ULLYSES observed and archival samples together.\n", + " If False, this will return a dictionary instead with the two lists of\n", + " PIDs separated out under the keys \"ULLYSES\" and \"ARCHIVAL\"\n", + "\n", + "Outputs\n", + "-------\n", + "all_pids : list (single_list=True) or dict (single_list=False)\n", + "\u001b[0;31mFile:\u001b[0m ~/miniconda3/envs/ullyses/lib/python3.8/site-packages/ullyses_utils-0.0.1-py3.8.egg/ullyses_utils/select_pids.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "select_all_pids?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function `select_pids` gives all the PIDs of a certain region regardless of target type. See the options in the docstring below:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mselect_pids\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mselected_region\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msingle_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "This function returns pids given a region. \"Extra\" regions are separated\n", + "out as these include datasets that were not originally in the ULLYSES sample.\n", + "The TTS regions are separated by their host cluster. Low metallicity stars\n", + "are separated by imaging and spectroscopic observations.\n", + "\n", + "Inputs\n", + "------\n", + "selected_region : str\n", + " Accepted regions:\n", + " - \"smc-extra\", \"smc\", \"lmc-extra\", \"lmc\",\n", + " \"lowz-extra\", \"lowz-image\", \"lowz\",\n", + " \"monitoring_tts\",\n", + " \"cha i\", \"cra\", \"eps cha\", \"eta cha\", \"lupus\", \"ori ob\", \"sigma ori\",\n", + " \"taurus\", \"twa\", \"lower centaurus\", \"upper scorpius\", \"other\", \"lambda ori\"\n", + "single_list : Boolean\n", + " True by default. If true, a list of pids for the specified region is returned.\n", + " If false, two lists of pids are returned; one is only the ULLYSES observed\n", + " PIDs (those the team made Phase 2s for from 2020-2023), and then other is\n", + " only the archival data used in the HLSP creation and delivered to MAST.\n", + "\n", + "Outputs\n", + "-------\n", + "if single_list = True --\n", + " ull_pids + ar_pids : list\n", + " combined ULLYSES observed PIDs and archival data. ULLYSES observed\n", + " PIDs are first.\n", + "if single_list == False --\n", + " ull_pids : list\n", + " ULLYSES observed PIDs (those the team made Phase 2s for from 2020-2023)\n", + " ar_pids : list\n", + " archival observed PIDs (used in the HLSP creation)\n", + "\u001b[0;31mFile:\u001b[0m ~/miniconda3/envs/ullyses/lib/python3.8/site-packages/ullyses_utils-0.0.1-py3.8.egg/ullyses_utils/select_pids.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "select_pids?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Example 1: select all ULLYSES PIDs" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['11487', '11489', '11531', '11533', '11608', '11616', '11623', '11625', '11660', '11692', '11828', '11997', '12010', '12036', '12161', '12199', '12218', '12315', '12425', '12581', '12587', '12717', '12805', '12867', '12876', '12907', '12978', '12996', '13004', '13032', '13122', '13363', '13372', '13373', '13522', '13714', '13766', '13775', '13778', '13780', '13781', '13806', '13931', '13969', '14048', '14081', '14177', '14193', '14245', '14246', '14437', '14469', '14476', '14503', '14604', '14675', '14683', '14690', '14703', '14712', '14855', '14909', '15070', '15128', '15156', '15165', '15204', '15210', '15310', '15366', '15385', '15536', '15629', '15774', '15824', '15837', '15880', '15921', '15967', '16010', '16090', '16091', '16092', '16093', '16094', '16095', '16096', '16097', '16098', '16099', '16100', '16101', '16102', '16103', '16104', '16107', '16108', '16109', '16110', '16113', '16114', '16115', '16230', '16272', '16290', '16304', '16364', '16365', '16366', '16367', '16368', '16369', '16370', '16371', '16372', '16373', '16374', '16375', '16476', '16477', '16478', '16479', '16480', '16481', '16482', '16511', '16589', '16590', '16591', '16592', '16593', '16594', '16595', '16596', '16597', '16598', '16599', '16647', '16717', '16767', '16802', '16803', '16805', '16806', '16807', '16808', '16809', '16810', '16811', '16812', '16813', '16814', '16815', '16816', '16817', '16818', '16819', '16820', '16821', '16822', '16823', '16824', '16825', '16826', '16853', '16854', '16855', '16856', '16857', '16858', '16859', '16920', '16930', '17074', '17176', '17279', '17295', '17296', '7299', '7392', '7437', '7480', '7565', '7718', '8041', '8145', '8157', '8205', '8206', '8238', '8316', '8317', '8320', '8566', '8627', '8662', '8801', '9081', '9093', '9094', '9116', '9241', '9374', '9383', '9412', '9434', '9435', '9757', '9785', '9790', '9807', '9841']\n" + ] + } + ], + "source": [ + "all_ullyses_pids = select_all_pids()\n", + "print(all_ullyses_pids)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Example 2: select all SMC and LMC targets and their extras" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['16098', '16099', '16100', '16101', '16102', '16103', '16368', '16370', '16371', '16372', '16373', '16375', '16802', '16803', '16805', '16806', '16807', '16808', '16809', '17295', '7437', '7480', '8145', '8566', '9094', '9116', '9383', '9434', '11487', '11489', '11623', '11625', '11997', '12010', '12425', '12581', '12717', '12805', '13004', '13122', '13373', '13522', '13778', '13931', '13969', '14081', '14437', '14476', '14503', '14712', '14855', '14909', '15366', '15385', '15536', '15629', '15774', '15837', '16230', '16090', '16091', '16092', '16093', '16094', '16095', '16096', '16097', '16364', '16365', '16366', '16367', '16369', '16374', '16810', '16811', '16812', '16813', '16814', '16815', '16816', '16817', '16818', '16819', '16820', '16821', '16822', '16823', '16824', '16825', '16826', '17296', '7299', '7392', '8320', '8662', '9434', '9757', '12218', '12581', '12978', '14675', '14683', '15629', '15824', '16304', '16230']\n" + ] + } + ], + "source": [ + "all_smc_lmc_pids = select_pids('smc') + select_pids('lmc')\n", + "print(all_smc_lmc_pids)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Example 3: select all massive stars without the extras, and return a list separated by ULLYSES PIDs vs Archival PIDS" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['16090', '16091', '16092', '16093', '16094', '16095', '16096', '16097', '16098', '16099', '16100', '16101', '16102', '16103', '16104', '16364', '16365', '16366', '16367', '16368', '16369', '16370', '16371', '16372', '16373', '16374', '16375', '16511', '16802', '16803', '16805', '16806', '16807', '16808', '16809', '16810', '16811', '16812', '16813', '16814', '16815', '16816', '16817', '16818', '16819', '16820', '16821', '16822', '16823', '16824', '16825', '16826', '16930', '17295', '17296']\n", + "['11487', '11489', '11623', '11625', '11997', '12010', '12218', '12425', '12581', '12717', '12805', '12978', '13004', '13122', '13373', '13522', '13778', '13931', '13969', '14081', '14437', '14476', '14503', '14675', '14683', '14712', '14855', '14909', '15366', '15385', '15536', '15629', '15774', '15824', '15837', '16230', '16304', '7299', '7392', '7437', '7480', '8145', '8320', '8566', '8662', '9094', '9116', '9383', '9434', '9757']\n" + ] + } + ], + "source": [ + "massive_pids = select_all_pids(massive=True, extra=False, single_list=False)\n", + "print(massive_pids['ULLYSES'])\n", + "print(massive_pids['ARCHIVAL'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can again use Astroquery to download the HLSPs from these selected PIDs. The following example is for our second selection on all SMC and LMC targets and their extras." + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intentType obs_collection provenance_name instrument_name project filters wavelength_region target_name ... jpegURL dataURL dataRights mtFlag srcDen obsid objID \n", + "---------- -------------- --------------- --------------------------------- ------- ----------------------- ----------------- -------------- ... ------- ------- ---------- ------ ------ --------- ---------\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV 2DFS-163 ... -- -- PUBLIC False nan 118405126 219472731\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV 2DFS-2266 ... -- -- PUBLIC False nan 118405127 219472738\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV 2DFS-3689 ... -- -- PUBLIC False nan 118405129 219472750\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV 2DFS-3694 ... -- -- PUBLIC False nan 118405130 219472756\n", + " science HLSP ULLYSES COS/FUV | STIS/FUV-MAMA HST E140M;G130M UV 2DFS-3780 ... -- -- PUBLIC False nan 118405131 219472762\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV 2DFS-3947 ... -- -- PUBLIC False nan 118405132 219472765\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV 2DFS-3954 ... -- -- PUBLIC False nan 118405133 219472767\n", + " science HLSP ULLYSES COS/FUV HST G160M UV 2DFS-5066 ... -- -- PUBLIC False nan 118405134 219472769\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV AV186 ... -- -- PUBLIC False nan 118405149 219472837\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV AV189 ... -- -- PUBLIC False nan 118405151 219472845\n", + " science HLSP ULLYSES COS/FUV | COS/NUV | STIS/NUV-MAMA HST E230M;G130M;G160M;G185M UV AV200 ... -- -- PUBLIC False nan 118405152 219472849\n", + " science HLSP ULLYSES STIS/FUV-MAMA | STIS/NUV-MAMA HST E140M;E230M UV AV22 ... -- -- PUBLIC False nan 118405157 219472864\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV AV224 ... -- -- PUBLIC False nan 118405159 219472869\n", + " science HLSP ULLYSES COS/FUV | STIS/NUV-MAMA HST E230M;G130M;G160M UV AV234 ... -- -- PUBLIC False nan 118405161 219472876\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV AV251 ... -- -- PUBLIC False nan 118405165 219472884\n", + " science HLSP ULLYSES STIS/FUV-MAMA HST E140M UV AV258 ... -- -- PUBLIC False nan 118405166 219472886\n", + " science HLSP ULLYSES STIS/FUV-MAMA HST E140M UV AV287 ... -- -- PUBLIC False nan 118405172 219472900\n", + " science HLSP ULLYSES COS/FUV | COS/NUV | STIS/NUV-MAMA HST E230M;G130M;G160M;G185M UV AV314 ... -- -- PUBLIC False nan 118405176 219472907\n", + " science HLSP ULLYSES STIS/FUV-MAMA HST E140M UV AV317 ... -- -- PUBLIC False nan 118405177 219472908\n", + " science HLSP ULLYSES COS/FUV | COS/NUV | STIS/NUV-MAMA HST E230M;G130M;G160M;G185M UV AV324 ... -- -- PUBLIC False nan 118405179 219472912\n", + " ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV ST92-4-18 ... -- -- PUBLIC False nan 118405446 219475066\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV ST92-5-27 ... -- -- PUBLIC False nan 118405447 219475067\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV ST92-5-31 ... -- -- PUBLIC False nan 118405448 219475068\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV UCAC3-42-30814 ... -- -- PUBLIC False nan 118405478 219475668\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV UCAC3-42-33014 ... -- -- PUBLIC False nan 118405479 219475689\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-169 ... -- -- PUBLIC False nan 118405521 219476296\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-190 ... -- -- PUBLIC False nan 118405522 219476310\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-267 ... -- -- PUBLIC False nan 118405523 219476319\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-355 ... -- -- PUBLIC False nan 118405524 219476333\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-404 ... -- -- PUBLIC False nan 118405525 219476343\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-406 ... -- -- PUBLIC False nan 118405526 219476362\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-482 ... -- -- PUBLIC False nan 118405527 219476395\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-506 ... -- -- PUBLIC False nan 118405528 219476413\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-542 ... -- -- PUBLIC False nan 118405529 219476425\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS-66 ... -- -- PUBLIC False nan 118405530 219476434\n", + " science HLSP ULLYSES STIS/FUV-MAMA HST E140M UV VFTS440 ... -- -- PUBLIC False nan 118405532 219476505\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV VFTS586 ... -- -- PUBLIC False nan 118405533 219476524\n", + " science HLSP ULLYSES STIS/FUV-MAMA HST E140M UV VFTS87 ... -- -- PUBLIC False nan 118405535 219476565\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV W61-28-23 ... -- -- PUBLIC False nan 118405536 219476577\n", + " science HLSP ULLYSES COS/FUV HST G130M;G160M UV W61-28-5 ... -- -- PUBLIC False nan 118405537 219476593\n", + "Length = 92 rows\n" + ] + } + ], + "source": [ + "search_pids = Observations.query_criteria(proposal_id=all_smc_lmc_pids, provenance_name='ULLYSES')\n", + "search_pids.pprint()\n", + "\n", + "data_products_pids = Observations.get_product_list(search_pids['obsid'])\n", + "\n", + "output_dir_smc_lmc = './all_smc_lmc'\n", + "\n", + "Observations.download_products(data_products_pids, download_dir=output_dir_smc_lmc, extension=['fits'], obs_collection=['HLSP'])\n", + "\n", + "mv_downloads(output_dir_smc_lmc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Downloading HLSP Constiuent Raw Data Files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the last example, we'll show how to download the raw data files that made up a HLSP. We will use one of the data sets that we downloaded in the last example here. Our HLSP will be the file `hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m_dr6_cspec.fits`, which is a level 4 product for the target NGC1818-ROB-D1. We can look at the provenance table in this file to find the constiuent spectra." + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [], + "source": [ + "hlsp_file_path = os.path.join(output_dir_smc_lmc, 'hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m_dr6_cspec.fits')" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " FILENAME PROPOSID INSTRUMENT DETECTOR DISPERSER APERTURE XPOSURE\n", + "------------------ -------- ---------- -------- --------- -------- -------\n", + "lcyid1acq_x1d.fits 14081 COS FUV G130M PSA 521.024\n", + "lcyid1anq_x1d.fits 14081 COS FUV G130M PSA 570.016\n", + "lcyid1agq_x1d.fits 14081 COS FUV G130M PSA 570.016\n", + "lcyid1ayq_x1d.fits 14081 COS FUV G130M PSA 570.048\n", + "lcyid1aaq_x1d.fits 14081 COS FUV G130M PSA 521.024\n", + "lcyid1arq_x1d.fits 14081 COS FUV G130M PSA 570.016\n", + "lcyid1aeq_x1d.fits 14081 COS FUV G130M PSA 521.024\n", + "lcyid1a8q_x1d.fits 14081 COS FUV G130M PSA 521.024\n", + "lcyid1crq_x1d.fits 14081 COS FUV G160M PSA 2003.2\n", + "lcyid1cjq_x1d.fits 14081 COS FUV G160M PSA 2003.2\n", + "lcyid1b6q_x1d.fits 14081 COS FUV G160M PSA 1735.2\n", + "lcyid1c9q_x1d.fits 14081 COS FUV G160M PSA 2003.2\n", + "lcyid1bsq_x1d.fits 14081 COS FUV G160M PSA 1735.2\n", + "lcyid1b1q_x1d.fits 14081 COS FUV G160M PSA 1735.2\n", + "lcyid1cuq_x1d.fits 14081 COS FUV G160M PSA 2003.2\n", + "lcyid1bzq_x1d.fits 14081 COS FUV G160M PSA 1735.2\n", + "lcyid2peq_x1d.fits 14081 COS NUV G185M PSA 475.008\n", + "lcyid3mtq_x1d.fits 14081 COS NUV G185M PSA 416.0\n", + "lcyid2pgq_x1d.fits 14081 COS NUV G185M PSA 485.024\n", + "lcyid3mnq_x1d.fits 14081 COS NUV G185M PSA 416.0\n", + "lcyid2p8q_x1d.fits 14081 COS NUV G185M PSA 475.008\n", + "lcyid2pmq_x1d.fits 14081 COS NUV G185M PSA 485.024\n", + "lcyid2piq_x1d.fits 14081 COS NUV G185M PSA 484.992\n", + "lcyid2pcq_x1d.fits 14081 COS NUV G185M PSA 475.008\n", + "lcyid2pkq_x1d.fits 14081 COS NUV G185M PSA 485.024\n", + "lcyid3mhq_x1d.fits 14081 COS NUV G185M PSA 394.016\n", + "lcyid3mrq_x1d.fits 14081 COS NUV G185M PSA 416.032\n", + "lcyid3mjq_x1d.fits 14081 COS NUV G185M PSA 394.016\n", + "lcyid3mfq_x1d.fits 14081 COS NUV G185M PSA 394.016\n", + "lcyid2paq_x1d.fits 14081 COS NUV G185M PSA 475.008\n", + "lcyid3mlq_x1d.fits 14081 COS NUV G185M PSA 394.016\n", + "lcyid3mpq_x1d.fits 14081 COS NUV G185M PSA 416.032\n" + ] + } + ], + "source": [ + "prov_table = Table(fits.getdata(hlsp_file_path, ext=2))\n", + "prov_table.pprint_include_names = ('FILENAME', 'PROPOSID', 'INSTRUMENT', 'DETECTOR', 'DISPERSER', 'APERTURE', 'XPOSURE')\n", + "prov_table.pprint()" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a list that is just the constiuent files from the provenance data\n", + "# We will use this for comparison later\n", + "spectra_filenames = prov_table['FILENAME']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we'll run a search using Astroquery on the target name and specifying the provenance name as ULLYSES. Then, we can see the data products associated with this search." + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " productFilename \n", + "--------------------------------------------------------------------\n", + "hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m-g160m-g185m_dr6_cspec.fits\n", + " hlsp_ullyses_hst_cos_ngc1818-rob-d1_g130m_dr6_cspec.fits\n", + " hlsp_ullyses_hst_cos_ngc1818-rob-d1_g160m_dr6_cspec.fits\n", + " hlsp_ullyses_hst_cos_ngc1818-rob-d1_g185m_dr6_cspec.fits\n", + " hlsp_ullyses_hst_cos_ngc1818-rob-d1_g225m_dr6_cspec.fits\n", + " lcyid1010_asn.fits\n", + " lcyid1010_jif.fits\n", + " lcyid1010_jit.fits\n", + " lcyid1010_trl.fits\n", + " lcyid1010_x1dsum1.fits\n", + " lcyid1010_x1dsum2.fits\n", + " lcyid1010_x1dsum3.fits\n", + " lcyid1010_x1dsum4.fits\n", + " lcyid1010_log.txt\n", + " lcyid1010_x1dsum.png\n", + " lcyid1010_x1dsum1.png\n", + " lcyid1010_x1dsum2.png\n", + " lcyid1010_x1dsum3.png\n", + " lcyid1010_x1dsum4.png\n", + " lcyid1010_x1dsum_prev.fits\n", + " ...\n", + " lcyid3mrq_lampflash.fits\n", + " lcyid3mrq_spt.fits\n", + " lcyid3mrq_trl.fits\n", + " lcyid3mrq_log.txt\n", + " lcyid3mrq_x1d.png\n", + " lcyid3mrq_x1d_prev.fits\n", + " lcyid3mrq_flt.fits\n", + " lcyid3mrq_rawtag.fits\n", + " lcyid3mrq_x1d.fits\n", + " lcyid3mtq_corrtag.fits\n", + " lcyid3mtq_counts.fits\n", + " lcyid3mtq_lampflash.fits\n", + " lcyid3mtq_spt.fits\n", + " lcyid3mtq_trl.fits\n", + " lcyid3mtq_log.txt\n", + " lcyid3mtq_x1d.png\n", + " lcyid3mtq_x1d_prev.fits\n", + " lcyid3mtq_flt.fits\n", + " lcyid3mtq_rawtag.fits\n", + " lcyid3mtq_x1d.fits\n", + "Length = 581 rows\n" + ] + } + ], + "source": [ + "search_target = Observations.query_criteria(target_name='ngc1818-rob-d1', provenance_name='ULLYSES')\n", + "\n", + "data_products = Observations.get_product_list(search_target['obsid'])\n", + "print(data_products['productFilename'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use a for-loop to compare the constiuent filenames from the provenance table to the data products returned from our query. We'll only save the observation IDs of the matching data products for later downloading." + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [], + "source": [ + "to_download = []\n", + "for assocfile, obsid in zip(data_products['productFilename'], data_products['obsID']):\n", + " if assocfile in filenames:\n", + " to_download.append(obsid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Last, we can download the products that we saved in `to_download`. In the call to `download_products` in the following cell, not that we must specify the `obs_collection=['HST']`, which ensures we will not download any HLSPs, as well as `productSubGroupDescription=['X1D', 'SX1']`, otherwise all the other COS or STIS data products will be downloaded as well. One may change these parameters if more data products are desired." + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1a8q/lcyid1a8q_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1aaq/lcyid1aaq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1acq/lcyid1acq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1aeq/lcyid1aeq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1agq/lcyid1agq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1anq/lcyid1anq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1arq/lcyid1arq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1ayq/lcyid1ayq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1b1q/lcyid1b1q_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1b6q/lcyid1b6q_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1bsq/lcyid1bsq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1bzq/lcyid1bzq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1c9q/lcyid1c9q_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1cjq/lcyid1cjq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1crq/lcyid1crq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid1cuq/lcyid1cuq_x1d.fits with expected size 3389760. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid2p8q/lcyid2p8q_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid2paq/lcyid2paq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid2pcq/lcyid2pcq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid2peq/lcyid2peq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid2pgq/lcyid2pgq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid2piq/lcyid2piq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid2pkq/lcyid2pkq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid2pmq/lcyid2pmq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid3mfq/lcyid3mfq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid3mhq/lcyid3mhq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid3mjq/lcyid3mjq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid3mlq/lcyid3mlq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid3mnq/lcyid3mnq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid3mpq/lcyid3mpq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid3mrq/lcyid3mrq_x1d.fits with expected size 429120. [astroquery.query]\n", + "INFO: Found cached file ./ngc1818-rob-d1/mastDownload/HST/lcyid3mtq/lcyid3mtq_x1d.fits with expected size 429120. [astroquery.query]\n" + ] + } + ], + "source": [ + "output_dir = './ngc1818-rob-d1/'\n", + "Observations.download_products(to_download, download_dir=output_dir, extension=['fits'], obs_collection=['HST'], productSubGroupDescription=['X1D', 'SX1'])\n", + "mv_downloads(output_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Now, go forth and download and make beautiful discoveries with our ULLYSES products!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Additional Resources\n", + "\n", + "- [ULLYSES](https://ullyses.stsci.edu)\n", + "- [MAST API](https://mast.stsci.edu/api/v0/index.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## About this Notebook\n", + "For support, contact us at the [ULLYSES Helpdesk](https://stsci.service-now.com/hst?id=sc_cat_item&sys_id=a3b8ec5edbb7985033b55dd5ce961990&sysparm_category=ac85189bdb4683c033b55dd5ce96199c).\n", + "\n", + "**Author:** Elaine M Frazer\n", + "\n", + "**Updated On:** 2023-12-07" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citations\n", + "* See the [ULLYSES website](https://ullyses.stsci.edu/ullyses-cite.html) for citation guidelines." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Top of Page](#top)\n", + "\"Space " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/ullyses-walkthrough.ipynb b/notebooks/ullyses-walkthrough.ipynb new file mode 100644 index 0000000..be7d40b --- /dev/null +++ b/notebooks/ullyses-walkthrough.ipynb @@ -0,0 +1,1194 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "\n", + "# ULLYSES Data Walkthrough Notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Goals\n", + "\n", + "By the end of this tutorial, you will:\n", + "\n", + "- Know the different types of high level science products (HLSPs) offered by the ULLYSES team.\n", + "- Be able to open each file and view its contents and metadata.\n", + "- Understand how to use each type of HSLP." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "**0. [Introduction](#introduction)**\n", + "\n", + "**1. [HLSP Descriptions and Filename Convention](#hlspdescrip)**\n", + "\n", + "**2. [HLSP File Exploration](#hlspformats)**\n", + "\n", + "\\- 2.1 [Single-epoch Spectra](#single)\n", + "\n", + "\\- 2.2 [Time-series Spectra](#tss)\n", + "\n", + "\\- 2.3 [WFC3 Drizzled Images](#drizzle)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "\n", + "## Introduction\n", + "\n", + "The Hubble Space Telescope’s (HST) Ultraviolet Legacy Library of Young Stars as Essential Standards ([ULLYSES](https://ullyses.stsci.edu/index.html) program has devoted approximately 1,000 HST orbits to the production of an ultraviolet spectroscopic library of young high- and low-mass stars in the local universe. This Director’s Discretionary program was designed to take advantage of HST’s unique UV capabilities, as both high- and low-mass stars feature different complex UV emission processes that strongly impact their surroundings, but are difficult to model. The UV emission from star formation is central to a wide range of vital astrophysical issues, ranging from cosmic reionization to the formation of planets.\n", + "\n", + "The ULLYSES program uniformly sampled the fundamental astrophysical parameter space for each mass regime — including spectral type, luminosity class, and metallicity for massive OB stars (in the Magellanic Clouds and two other lower-metallicity nearby galaxies) and the mass, age, and disk accretion rate for low-mass T Tauri stars (in eight young Galactic associations). The data were gathered over a three-year period, from Cycle 27 through Cycle 29 (2020-2022). The design and targets of these observations were determined in partnership with the astronomical community, allowing researchers from around the world to help develop the final program and to plan coordinated observations with other space- and ground-based telescopes.\n", + "\n", + "The ULLYSES team produces several types of High Level Science Products (HLSPs), which we will walk through in this notebook. Products are made using both archival data and new HST observations obtained through the ULLYSES program. Data products are available from the [ULLYSES website](https://ullyses.stsci.edu/ullyses-download.html) (HLSPs and contributing data), the [MAST Data Discovery Portal](https://mast.stsci.edu/) (HLSPs and contributing data), or directly as a High-Level Science Product collection using the [DOI](https://archive.stsci.edu/hlsp/ullyses) (HLSPs only)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Imports\n", + "Describe the libraries we're using here. If there's something unusual, explain what the library is, and why we need it.\n", + "- *numpy* to handle array functions\n", + "- *astropy.io fits* for accessing FITS files\n", + "- *astroy.wcs WCS* to create world coordinate system objects for plotting WFC3 images\n", + "- *astropy.table Table* for creating tidy tables of the data\n", + "- *matplotlib.pyplot* for plotting data\n", + "- *Path* to create product and data directories\n", + "- *shutil* to perform directory and file operations\n", + "- *os* to interact with the operating system" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "from astropy.io import fits\n", + "from astropy.wcs import WCS\n", + "from astropy.table import Table\n", + "import matplotlib.pyplot as plt\n", + "plt.rcParams['figure.figsize']=10,6\n", + "plt.style.use('seaborn-notebook')\n", + "import os\n", + "from pathlib import Path\n", + "import shutil" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## HLSP Descriptions and Filename Convention" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The file names for ULLYSES science data products follow a naming scheme which encodes the target designation and the instruments and observing configuration(s) that contribute to the product. However, not all products will appear in the early releases. File names have the form:\n", + "\n", + "`hlsp_ullyses______`\n", + "\n", + "where\n", + "\n", + "`` is the target name\n", + "`` is the data release identifier (dr1, dr2, etc.)\n", + "\n", + "The ``, ``, ``, and `` templates take names from the following table:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "| Description | Telescope | Instrument | Opt-Elem | Product-Type | Level |\n", + "|--------------------------------------------------------------------------------------------------------------|-----------|---------------|-------------------------------------------------|-------------------|-------|\n", + "| Custom calibrated STIS 1D spectra | hst | stis | g230l, g430l, or g750l | spec.fits | 0 |\n", + "| STIS custom calibration parameter files | hst | stis | g230l, g430l, or g750l | spec.yaml | 0 |\n", + "| STIS echelle single grating, where the orders have been extracted and merged. | hst | stis | e140l, e230h, e140m, or e230m | mspec.fits | 1 |\n", + "| Combined spectra, with common instrument and grating, and in some cases with different cenwave settings. | hst | cos | g130m, g160m, g185m, or g230l | cpsec.fits | 2 |\n", + "| | | stis | e140l, e230h, e140m, e230m, g230l, g430l, or g750l | | |\n", + "| Combined spectra, with common instrument, different gratings and cenwave settings, and grouped by resolution | fuse | fuv | lwrs or mdrs | cspec.fits | 3 |\n", + "| | hst | cos | g130m-g160m-g185m | | |\n", + "| | | stis | e140h-e230h, g140m-e230m or g230l-g430l-g750l | | |\n", + "| All instruments and settings abutted together* | hst | cos-stis | uv or uv-opt | preview-spec.fits | 4 |\n", + "| | hst-fuse | fuse-cos-stis | uv-opt | | |\n", + "| Exposure-level time-series spectra | hst | cos | g130m or g160m | tss.fits | 5 |\n", + "| | lcogt | 04m | v-ip | | |\n", + "| Subexposure-level time-series spectra | hst | cos | g130m or g160m | split-tss.fits | 5 |\n", + "| WFC3 drizzled images | hst | wfc3 | f225w, f275w, f336w, f475w or f814w | drc.fits | 6 |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## HLSP File Formats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Most High Level Science Products are in FITS format. The organization of each FITS file depends on the HLSP type. There are three broad categories of HLSPs: single-epoch spectra, time-series spectra, and drizzled images." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Single Epoch Spectra" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### FITS File Structure\n", + "\n", + "Spectral data and information is stored in two BINTABLE extensions:\n", + "- a Science extension for the combined product, and\n", + "- a matching Provenance extension to record attributes of each spectrum that contributed to the combined product\n", + "\n", + "Let's start by downloading the available data products for a target taken in a single epoch and look around." + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 1662k 100 1662k 0 0 79880 0 0:00:21 0:00:09 0:00:12 799300 176k 0 0:00:09 0:00:09 --:--:-- 176k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 1338k 100 1338k 0 0 1672k 0 --:--:-- --:--:-- --:--:-- 1384k83k 0 --:--:-- --:--:-- --:--:-- 1692k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 641k 100 641k 0 0 1256k 0 --:--:-- --:--:-- --:--:-- 1267k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 641k 100 641k 0 0 0 0 --:--:-- --:--:-- --:--:-- 00 0 1415k 0 --:--:-- --:--:-- --:--:-- 1431k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 168k 100 168k 0 0 618k 0 --:--:-- --:--:-- --:--:-- 632k\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 345k 100 345k 0 0 973k 0 --:--:-- --:--:-- --:--:-- 985k\n" + ] + } + ], + "source": [ + "# Use curl to download the files -- these are the level 2, 3, and 4 data products for the target SK-67 195\n", + "!curl -L -X GET \"https://mast.stsci.edu/api/v0.1/Download/file?uri=mast%3AHLSP%2Fullyses%2Fsk-67d195%2Fdr6%2Fhlsp_ullyses_hst_cos-stis_sk-67d195_uv_dr6_preview-spec.fits\" --output \"hlsp_ullyses_hst_cos-stis_sk-67d195_uv_dr6_preview-spec.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/api/v0.1/Download/file?uri=mast%3AHLSP%2Fullyses%2Fsk-67d195%2Fdr6%2Fhlsp_ullyses_hst_cos_sk-67d195_g130m-g160m-g185m_dr6_cspec.fits\" --output \"hlsp_ullyses_hst_cos_sk-67d195_g130m-g160m-g185m_dr6_cspec.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/api/v0.1/Download/file?uri=mast%3AHLSP%2Fullyses%2Fsk-67d195%2Fdr6%2Fhlsp_ullyses_hst_cos_sk-67d195_g130m_dr6_cspec.fits\" --output \"hlsp_ullyses_hst_cos_sk-67d195_g130m_dr6_cspec.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/api/v0.1/Download/file?uri=mast%3AHLSP%2Fullyses%2Fsk-67d195%2Fdr6%2Fhlsp_ullyses_hst_cos_sk-67d195_g160m_dr6_cspec.fits\" --output \"hlsp_ullyses_hst_cos_sk-67d195_g160m_dr6_cspec.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/api/v0.1/Download/file?uri=mast%3AHLSP%2Fullyses%2Fsk-67d195%2Fdr6%2Fhlsp_ullyses_hst_cos_sk-67d195_g185m_dr6_cspec.fits\" --output \"hlsp_ullyses_hst_cos_sk-67d195_g185m_dr6_cspec.fits\" --fail --create-dirs\n", + "\n", + "!curl -L -X GET \"https://mast.stsci.edu/api/v0.1/Download/file?uri=mast%3AHLSP%2Fullyses%2Fsk-67d195%2Fdr6%2Fhlsp_ullyses_hst_stis_sk-67d195_e230m_dr6_cspec.fits\" --output \"hlsp_ullyses_hst_stis_sk-67d195_e230m_dr6_cspec.fits\" --fail --create-dirs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\\n", + "Six datasets were just downloaded. They include:\n", + "\n", + "Level 2\n", + "- hlsp_ullyses_hst_cos_sk-67d195_g130m_dr6_cspec.fits\n", + "- hlsp_ullyses_hst_cos_sk-67d195_g160m_dr6_cspec.fits\n", + "- hlsp_ullyses_hst_cos_sk-67d195_g185m_dr6_cspec.fits\n", + "- hlsp_ullyses_hst_stis_sk-67d195_e230m_dr6_cspec.fits\n", + "\n", + "Level 3\n", + "- hlsp_ullyses_hst_cos_sk-67d195_g130m-g160m-g185m_dr6_cspec.fits\n", + "\n", + "Level 4\n", + "- hlsp_ullyses_hst_cos-stis_sk-67d195_uv_dr6_preview-spec.fits\n", + "\n", + "We will first go through the level 4 file, which is the data product with all instruments and settings abutted together." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filename: hlsp_ullyses_hst_cos-stis_sk-67d195_uv_dr6_preview-spec.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 43 () \n", + " 1 SCIENCE 1 BinTableHDU 33 1R x 5C [84033E, 84033E, 84033E, 84033E, 84033E] \n", + " 2 PROVENANCE 1 BinTableHDU 47 14R x 16C [64A, 32A, 32A, 32A, 32A, 32A, 32A, 32A, D, 32A, D, D, D, D, D, D] \n", + "None\n" + ] + } + ], + "source": [ + "# Create a variable to point to the file we just downloaded\n", + "spec_file = Path('./hlsp_ullyses_hst_cos-stis_sk-67d195_uv_dr6_preview-spec.fits')\n", + "\n", + "# Use Astropy.fits to open the fits file and create a header data unit (HDU)\n", + "# More info on fits files and HDUs can be found at: https://docs.astropy.org/en/stable/io/fits/\n", + "spec_hdu = fits.open(spec_file)\n", + "\n", + "# Print out some information about the format and data in this HDU\n", + "print(spec_hdu.info())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\\n", + "From the filename, we can see:\n", + "- the telescope used is HST (add link here)\n", + "- the instrument used are COS and STIS\n", + "- the optical element is UV (in this case, many optical elements made up this data product)\n", + "- this file was created for data release 6\n", + "\n", + "Now we'll look at the science and provenance extensions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single-epoch Science Table\n", + "\n", + "Various elements of a single spectrum of M wavelength bins are stored in a single table row; each element is stored in a separate field (i.e., column). The table extension headers also contain informative metadata." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ColDefs(\n", + " name = 'WAVELENGTH'; format = '84033E'; unit = 'Angstrom'\n", + " name = 'FLUX'; format = '84033E'; unit = 'erg /s /cm**2 /Angstrom'\n", + " name = 'ERROR'; format = '84033E'; unit = 'erg /s /cm**2 /Angstrom'\n", + " name = 'SNR'; format = '84033E'\n", + " name = 'EFF_EXPTIME'; format = '84033E'; unit = 's'\n", + ")\n" + ] + } + ], + "source": [ + "# Print the columns in the science extension of the HDU - the science extension is index 1\n", + "print(spec_hdu[1].columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now let's plot the flux, error, wavelength, and SNR for this dataset\n", + "# To get these values we use \".data\" to access the data in the science extension of the HDU\n", + "# To access the header of this extension instead, we would use \".header\"\n", + "\n", + "wavelength = spec_hdu[1].data['WAVELENGTH'][0]\n", + "flux = spec_hdu[1].data['FLUX'][0]\n", + "snr = spec_hdu[1].data['SNR'][0]\n", + "error = spec_hdu[1].data['ERROR'][0]\n", + "\n", + "# Set up a quick function to bin the spectra\n", + "def downsample_1d(myarr,factor):\n", + " \"\"\"\n", + " Downsample a 1D array by averaging over *factor* pixels.\n", + " Crops right side if the shape is not a multiple of factor.\n", + " Got this specific function from \"Adam Ginsburg's python codes\" on agpy\n", + "\n", + " myarr : numpy array\n", + "\n", + " factor : how much you want to rebin the array by\n", + " \"\"\"\n", + " xs = myarr.shape[0]\n", + " crarr = myarr[:xs-(xs % int(factor))]\n", + " dsarr = np.mean(np.concatenate(\n", + " [[crarr[i::factor] for i in range(factor)]]\n", + " ), axis=0)\n", + "\n", + " return dsarr\n", + "\n", + "# Set up the plot\n", + "fig = plt.figure()\n", + "gs = fig.add_gridspec(3, hspace=0)\n", + "axs = gs.subplots(sharex=True, sharey=False)\n", + "axs[0].plot(downsample_1d(wavelength, 10), downsample_1d(flux, 10))\n", + "axs[1].plot(downsample_1d(wavelength, 10), downsample_1d(error, 10))\n", + "axs[2].plot(downsample_1d(wavelength, 10), downsample_1d(snr, 10))\n", + "\n", + "plt.suptitle('SK-67 195 Single Epoch COS+STIS Abutted Data Product')\n", + "axs[0].set_ylabel('Flux')\n", + "axs[1].set_ylabel('Error')\n", + "axs[2].set_ylabel('SNR')\n", + "plt.xlabel('Wavelength')\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single-epoch Provenance Table\n", + "\n", + "Select metadata for each spectrum that contributes to the combined spectrum in the SCIENCE extension will populate a row in the provenance table. The fields in the table are metadata harvested from the headers of the contributing spectra." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ColDefs(\n", + " name = 'FILENAME'; format = '64A'\n", + " name = 'PROPOSID'; format = '32A'\n", + " name = 'TELESCOPE'; format = '32A'\n", + " name = 'INSTRUMENT'; format = '32A'\n", + " name = 'DETECTOR'; format = '32A'\n", + " name = 'DISPERSER'; format = '32A'\n", + " name = 'CENWAVE'; format = '32A'\n", + " name = 'APERTURE'; format = '32A'\n", + " name = 'SPECRES'; format = 'D'\n", + " name = 'CAL_VER'; format = '32A'\n", + " name = 'MJD_BEG'; format = 'D'; unit = 'd'\n", + " name = 'MJD_MID'; format = 'D'; unit = 'd'\n", + " name = 'MJD_END'; format = 'D'; unit = 'd'\n", + " name = 'XPOSURE'; format = 'D'; unit = 's'\n", + " name = 'MINWAVE'; format = 'D'; unit = 'Angstrom'\n", + " name = 'MAXWAVE'; format = 'D'; unit = 'Angstrom'\n", + ")\n" + ] + } + ], + "source": [ + "# Print the columns in the provenance extension, which is index 2\n", + "print(spec_hdu[2].columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " FILENAME PROPOSID INSTRUMENT DETECTOR DISPERSER APERTURE XPOSURE \n", + "------------------ -------- ---------- -------- --------- -------- ---------\n", + "lekh2cffq_x1d.fits 16374 COS FUV G130M PSA 564.992\n", + "lekh2cfdq_x1d.fits 16374 COS FUV G130M PSA 1500.192\n", + "lekh2cfhq_x1d.fits 16374 COS FUV G130M PSA 935.2\n", + "lekh2cfnq_x1d.fits 16374 COS FUV G160M PSA 162.016\n", + "lekh2cflq_x1d.fits 16374 COS FUV G160M PSA 465.024\n", + "lekh2cfrq_x1d.fits 16374 COS FUV G160M PSA 465.024\n", + "lekh2cfjq_x1d.fits 16374 COS FUV G160M PSA 465.024\n", + "lekh2cfpq_x1d.fits 16374 COS FUV G160M PSA 303.008\n", + "lekh2cfzq_x1d.fits 16374 COS NUV G185M PSA 821.184\n", + "lekh2cg1q_x1d.fits 16374 COS NUV G185M PSA 821.216\n", + "lekh2cfvq_x1d.fits 16374 COS NUV G185M PSA 199.008\n", + "lekh2cftq_x1d.fits 16374 COS NUV G185M PSA 880.192\n", + "lekh2cfxq_x1d.fits 16374 COS NUV G185M PSA 681.184\n", + "oekh2s010_x1d.fits 16374 STIS NUV-MAMA E230M 0.2X0.2 2162.1995\n" + ] + } + ], + "source": [ + "# We'll use Astropy Tables to print out a few of the columns listed above in a neat way\n", + "\n", + "prov_table = Table(spec_hdu[2].data)\n", + "prov_table.pprint_include_names = ('FILENAME', 'PROPOSID', 'INSTRUMENT', 'DETECTOR', 'DISPERSER', 'APERTURE', 'XPOSURE')\n", + "\n", + "prov_table.pprint()\n", + "\n", + "# To print all columns use:\n", + "# prov_table.pprint_all()\n", + "\n", + "# Or to print a single column use:\n", + "# prov_table['FILENAME'].pprint()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we know what the level 4 product looks like, let's see how the spectraa compare to the level 2 datasets." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Make an array to hold the level 2 filenames\n", + "level2 = ['hlsp_ullyses_hst_cos_sk-67d195_g130m_dr6_cspec.fits', 'hlsp_ullyses_hst_cos_sk-67d195_g160m_dr6_cspec.fits',\n", + " 'hlsp_ullyses_hst_cos_sk-67d195_g185m_dr6_cspec.fits', 'hlsp_ullyses_hst_stis_sk-67d195_e230m_dr6_cspec.fits']\n", + "\n", + "# Set up the plot - start with the level 4 products\n", + "fig = plt.figure()\n", + "gs = fig.add_gridspec(3, hspace=0)\n", + "axs = gs.subplots(sharex=True, sharey=False)\n", + "axs[0].plot(downsample_1d(wavelength, 10), downsample_1d(flux, 10))\n", + "axs[1].plot(downsample_1d(wavelength, 10), downsample_1d(error, 10))\n", + "axs[2].plot(downsample_1d(wavelength, 10), downsample_1d(snr, 10))\n", + "\n", + "# Then use a for loop to add the level 2 products on top\n", + "for prod in level2:\n", + " with fits.open(prod) as prod_hdu:\n", + " prod_wavelength = prod_hdu[1].data['wavelength']\n", + " prod_flux = prod_hdu[1].data['flux'] \n", + " prod_error = prod_hdu[1].data['error']\n", + " prod_snr = prod_hdu[1].data['snr']\n", + " axs[0].plot(downsample_1d(prod_wavelength, 10), downsample_1d(prod_flux, 10), 'b')\n", + " axs[1].plot(downsample_1d(prod_wavelength, 10), downsample_1d(prod_error, 10), 'c')\n", + " axs[2].plot(downsample_1d(prod_wavelength, 10), downsample_1d(prod_snr, 10), 'r') \n", + "\n", + "# Add all the labels\n", + "plt.suptitle('SK-67 195 Single Epoch')\n", + "axs[0].set_ylabel('Flux')\n", + "axs[1].set_ylabel('Error')\n", + "axs[2].set_ylabel('SNR')\n", + "plt.xlabel('Wavelength')\n", + "plt.show()\n", + "\n", + "\n", + "# Note this isn't plotting correctly right now.... :(" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above we can see how the constuent level 2 products compare to the coadded and abutted level 4 product for this target." + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": {}, + "outputs": [], + "source": [ + "# Be sure to close the HDU at the end :)\n", + "spec_hdu.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Timeseries Spectra" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### FITS File Structure\n", + "\n", + "Like the single epoch spectra, the time series spectral (TSS) data and information is stored in two BINTABLE extensions:\n", + "- a Science extension for the combined product, and\n", + "- a matching Provenance extension to record attributes of each spectrum that contributed to the combined product\n", + "\n", + "Next, let's download a TTS file and explore." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 54720 100 54720 0 0 269k 0 --:--:-- --:--:-- --:--:-- 276k\n" + ] + } + ], + "source": [ + "# Use curl to download a TSS data product for the target Hn5 (GX Cha)\n", + "!curl -L -X GET \"https://mast.stsci.edu/api/v0.1/Download/file?uri=mast%3AHLSP%2Fullyses%2Fhn5%2Fdr6%2Fhlsp_ullyses_lcogt_04m_hn5_v-iprime_dr6_tss.fits\" --output \"hlsp_ullyses_lcogt_04m_hn5_v-iprime_dr6_tss.fits\" --fail --create-dirs" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filename: hlsp_ullyses_lcogt_04m_hn5_v-iprime_dr6_tss.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 36 () \n", + " 1 SCIENCE 1 BinTableHDU 36 1R x 5C [100D, 100D, 2E, 200E, 200E] \n", + " 2 PROVENANCE 1 BinTableHDU 37 100R x 12C [40A, 32A, 32A, 32A, 32A, 32A, 32A, 32A, D, D, D, D] \n", + "None\n" + ] + } + ], + "source": [ + "# Create a variable to point to the file we just downloaded, then open the file, and print the HDU info\n", + "tss_file = Path('./hlsp_ullyses_lcogt_04m_hn5_v-iprime_dr6_tss.fits')\n", + "tss_hdu = fits.open(tss_file)\n", + "print(tss_hdu.info())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\\n", + "From the filename, we can see:\n", + "- the telescope used is LCOGT (add link here)\n", + "- the instrument used is the 0.4 meter\n", + "- the optical element is v-iprime\n", + "- this file was created for data release 6\n", + "\n", + "Now we'll look at the science and provenance extensions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Time-series Spectra Science Table\n", + "The TSS products have slightly different table columns compared to single-epoch spectra. The FLUX and ERROR arrays are 2D arrays with wavelength increasing X, and time increasing along Y. The wavelength values for each column of the 2D data are stored in the WAVELENGTH array, while the MJDSTART and MJDEND columns store the start and end times for each row of the FLUX and ERROR arrays." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ColDefs(\n", + " name = 'MJDSTART'; format = '100D'; unit = 'Day'\n", + " name = 'MJDEND'; format = '100D'; unit = 'Day'\n", + " name = 'WAVELENGTH'; format = '2E'; unit = 'Angstrom'\n", + " name = 'FLUX'; format = '200E'; unit = 'erg /s /cm**2 /Angstrom'; dim = '(2, 100)'\n", + " name = 'ERROR'; format = '200E'; unit = 'erg /s /cm**2 /Angstrom'; dim = '(2, 100)'\n", + ")\n", + "Number of time bins: 100\n", + "Number of spectral bins: 2\n" + ] + } + ], + "source": [ + "# Print the columns in the science extension\n", + "print(tss_hdu[1].columns)\n", + "\n", + "# Print the shape of the FLUX array\n", + "print('Number of time bins: {}'.format(tss_hdu[1].data['FLUX'][0].shape[0]))\n", + "print('Number of spectral bins: {}'.format(tss_hdu[1].data['FLUX'][0].shape[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the flux vs time for each wavelength bin\n", + "\n", + "wavelength = tss_hdu[1].data['WAVELENGTH'][0]\n", + "flux = tss_hdu[1].data['FLUX'][0]\n", + "time = tss_hdu[1].data['MJDSTART'][0]\n", + "flux_wave1 = np.array([x[0] for x in flux]) # this list comprehension selects the first entry in each row, which is the flux at the first wavelength bin\n", + "flux_wave2 = np.array([x[1] for x in flux]) # this does the same, but for the flux of the second wavelength bin\n", + "\n", + "# Filter out the data points that have 0 flux \n", + "filter1 = np.where(flux_wave1 != 0.0)[0]\n", + "filter2 = np.where(flux_wave2 != 0.0)[0]\n", + "\n", + "# Set up the plot\n", + "plt.scatter(time[filter1], flux_wave1[filter1], label=r'$\\lambda$={}'.format(wavelength[0]))\n", + "plt.scatter(time[filter2], flux_wave2[filter2], label=r'$\\lambda$={}'.format(wavelength[1]))\n", + "\n", + "plt.title('Hn5 timeseries')\n", + "plt.ylim(0,5e-15)\n", + "plt.ylabel('Flux')\n", + "plt.xlabel('MJD Start')\n", + "plt.legend() \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Time-series Spectra Provenance Table\n", + "Select metadata for each spectrum that contributes to the time-series product will populate a row in the provenance table. The fields in the table are metadata harvested from the headers of the contributing spectra. Some columns are only present for HST data or LCOGT data." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ColDefs(\n", + " name = 'FILENAME'; format = '40A'\n", + " name = 'PROPOSID'; format = '32A'\n", + " name = 'TELESCOPE'; format = '32A'\n", + " name = 'INSTRUMENT'; format = '32A'\n", + " name = 'DETECTOR'; format = '32A'\n", + " name = 'FILTER'; format = '32A'\n", + " name = 'APERTURE'; format = '32A'\n", + " name = 'CAL_VER'; format = '32A'\n", + " name = 'MJD_BEG'; format = 'D'; unit = 'd'\n", + " name = 'MJD_MID'; format = 'D'; unit = 'd'\n", + " name = 'MJD_END'; format = 'D'; unit = 'd'\n", + " name = 'XPOSURE'; format = 'D'; unit = 's'\n", + ")\n" + ] + } + ], + "source": [ + "# Print the columns in the provenance extension\n", + "print(tss_hdu[2].columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " FILENAME PROPOSID ... APERTURE XPOSURE\n", + "--------------------------------------- ------------ ... -------- -------\n", + "coj0m405-kb88-20210307-0098-e91.fits.fz DDT2021A-001 ... LCOGT 10.282\n", + "lsc0m409-kb29-20210310-0115-e91.fits.fz DDT2021A-001 ... LCOGT 10.285\n", + "coj0m403-kb24-20210312-0079-e91.fits.fz DDT2021A-001 ... LCOGT 10.23\n", + "lsc0m409-kb29-20210314-0117-e91.fits.fz DDT2021A-001 ... LCOGT 10.286\n", + "coj0m403-kb24-20210315-0118-e91.fits.fz DDT2021A-001 ... LCOGT 10.237\n", + "coj0m403-kb24-20210316-0099-e91.fits.fz DDT2021A-001 ... LCOGT 10.236\n", + "coj0m403-kb24-20210521-0080-e91.fits.fz DDT2021A-001 ... LCOGT 20.229\n", + " ... ... ... ... ...\n", + "cpt1m012-fa06-20220730-0066-e91.fits.fz DDT2021A-001 ... LCOGT 7.976\n", + "cpt1m012-fa06-20220730-0067-e91.fits.fz DDT2021A-001 ... LCOGT 3.976\n", + "lsc1m009-fa04-20220731-0058-e91.fits.fz DDT2021A-001 ... LCOGT 7.972\n", + "lsc1m009-fa04-20220731-0059-e91.fits.fz DDT2021A-001 ... LCOGT 3.972\n", + "lsc1m005-fa15-20220802-0059-e91.fits.fz DDT2021A-001 ... LCOGT 3.972\n", + "lsc1m009-fa04-20220803-0058-e91.fits.fz DDT2021A-001 ... LCOGT 7.976\n", + "lsc1m009-fa04-20220803-0059-e91.fits.fz DDT2021A-001 ... LCOGT 3.972\n", + "Length = 100 rows\n" + ] + } + ], + "source": [ + "# We'll use Astropy Tables to make it print out a few of the columns listed above in a neat way\n", + "\n", + "prov_table = Table(tss_hdu[2].data)\n", + "prov_table.pprint_include_names = ('FILENAME', 'PROPOSID', 'INSTRUMENT', 'DETECTOR', 'FILTER', 'APERTURE', 'XPOSURE')\n", + "\n", + "prov_table.pprint()\n", + "\n", + "# To print all columns use:\n", + "# prov_table.pprint_all()\n", + "\n", + "# Or to print a single column use:\n", + "# prov_table['FILENAME'].pprint()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Be sure to close the HDU when we are finished exploring!\n", + "tss_hdu.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### WFC3 Drizzled Images" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### FITS File Structure\n", + "\n", + "Drizzled and weight images are stored in two IMAGEHDU extensions, and PROVENANCE information stored in a BINTABLE extension:\n", + "- a Science extension for the drizzled science image\n", + "- a Weight extension for the weight map image\n", + "- a matching Provenance extension to record attributes of each image that contributed to the combined product\n", + "\n", + "Last, we'll explore a drizzled image of Sextans A observed with WFC3 with the F336W filter." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 140M 100 140M 0 0 4263k 0 0:00:33 0:00:33 --:--:-- 4730k5k 0 0 1223k 0 0:01:57 --:--:-- 0:01:57 1234k38.3M 0 0 3509k 0 0:00:40 0:00:11 0:00:29 3529k 0 4045k 0 0:00:35 0:00:23 0:00:12 4306k\n" + ] + } + ], + "source": [ + "# Download the data product\n", + "!curl -L -X GET \"https://mast.stsci.edu/api/v0.1/Download/file?uri=mast%3AHLSP%2Fullyses%2Fsextans-a%2Fdr6%2Fhlsp_ullyses_hst_wfc3_sextans-a_f336w_dr6_drc.fits\" --output \"hlsp_ullyses_hst_wfc3_sextans-a_f336w_dr6_drc.fits\" --fail --create-dirs" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filename: hlsp_ullyses_hst_wfc3_sextans-a_f336w_dr6_drc.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 42 () \n", + " 1 SCI 1 ImageHDU 95 (4130, 4447) float32 \n", + " 2 WHT 1 ImageHDU 46 (4130, 4447) float32 \n", + " 3 PROVENANCE 1 BinTableHDU 37 2R x 12C [40A, 32A, 32A, 32A, 32A, 32A, 32A, 32A, D, D, D, D] \n", + "None\n" + ] + } + ], + "source": [ + "# Create a variable to point to the file we just downloaded, open the file, and print the HDU info\n", + "drz_file = Path('./hlsp_ullyses_hst_wfc3_sextans-a_f336w_dr6_drc.fits')\n", + "drz_hdu = fits.open(drz_file)\n", + "print(drz_hdu.info())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\\n", + "From the filename, we can see:\n", + "- the telescope used is HST\n", + "- the instrument used is WFC3\n", + "- the optical element is F336W\n", + "- this file was created for data release 6\n", + "\n", + "Now we'll look at the science, weight, and provenance extensions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Drizzled Image Science Extension\n", + "\n", + "This extension is an image array that contains the drizzled image data." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4447, 4130)\n" + ] + } + ], + "source": [ + "# Print the size of the drizzled image that's in the science extension\n", + "print(drz_hdu[1].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the drizzled image\n", + "drz_data = drz_hdu[1].data\n", + "wcs = WCS(drz_hdu[1].header) # this creates a WCS object from the image header coordinate information\n", + "\n", + "plt.subplot(projection=wcs)\n", + "plt.imshow(drz_data, vmin=0, vmax=0.03)\n", + "\n", + "plt.title('Sextans A - F336W')\n", + "plt.grid(color='white', ls=':', alpha=0.7)\n", + "plt.xlabel('Right Ascension')\n", + "plt.ylabel('Declination')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Drizzled Image Weight Map Extension\n", + "\n", + "This extension is another image array that contains the weight map data. The weight map is ..." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4447, 4130)\n" + ] + } + ], + "source": [ + "# Print the size of the weight map, which is the second extension. This should be the same as the drizzled image\n", + "print(drz_hdu[2].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the weight map\n", + "wgt_data = drz_hdu[2].data\n", + "wcs = WCS(drz_hdu[2].header)\n", + "\n", + "plt.subplot(projection=wcs)\n", + "plt.imshow(wgt_data, vmin=0, vmax=1)\n", + "\n", + "plt.title('Sextans A - F336W - weight map')\n", + "plt.grid(color='white', ls=':')\n", + "plt.xlabel('Right Ascension')\n", + "plt.ylabel('Declination')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Drizzled Image Provenance Table\n", + "\n", + "Select metadata for each image that contributes to the drizzled image in will populate a row in the provenance table. The fields in the table are metadata harvested from the headers of the contributing images." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ColDefs(\n", + " name = 'FILENAME'; format = '40A'\n", + " name = 'PROPOSID'; format = '32A'\n", + " name = 'TELESCOPE'; format = '32A'\n", + " name = 'INSTRUMENT'; format = '32A'\n", + " name = 'DETECTOR'; format = '32A'\n", + " name = 'FILTER'; format = '32A'\n", + " name = 'APERTURE'; format = '32A'\n", + " name = 'CAL_VER'; format = '32A'\n", + " name = 'MJD_BEG'; format = 'D'; unit = 'd'\n", + " name = 'MJD_MID'; format = 'D'; unit = 'd'\n", + " name = 'MJD_END'; format = 'D'; unit = 'd'\n", + " name = 'XPOSURE'; format = 'D'; unit = 's'\n", + ")\n" + ] + } + ], + "source": [ + "# Print the columns in the provenance extension\n", + "print(drz_hdu[3].columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " FILENAME PROPOSID INSTRUMENT DETECTOR FILTER APERTURE XPOSURE\n", + "------------------ -------- ---------- -------- ------ ----------- -------\n", + "iegx03y6q_flc.fits 16104 WFC3 UVIS F336W UVIS-CENTER 451.0\n", + "iegx03xyq_flc.fits 16104 WFC3 UVIS F336W UVIS-CENTER 451.0\n" + ] + } + ], + "source": [ + "# We'll again use Astropy Tables to make it print out a few of the columns listed above in a neat way\n", + "\n", + "prov_table = Table(drz_hdu[3].data)\n", + "prov_table.pprint_include_names = ('FILENAME', 'PROPOSID', 'INSTRUMENT', 'DETECTOR', 'FILTER', 'APERTURE', 'XPOSURE')\n", + "\n", + "prov_table.pprint()\n", + "\n", + "# To print all columns use:\n", + "# prov_table.pprint_all()\n", + "\n", + "# Or to print a single column use:\n", + "# prov_table['FILENAME'].pprint()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# Close the DRZ HDU!\n", + "drz_hdu.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Additional Resources\n", + "\n", + "- [ULLYSES](https://ullyses.stsci.edu)\n", + "- [MAST API](https://mast.stsci.edu/api/v0/index.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## About this Notebook\n", + "For support, contact us at the [ULLYSES Helpdesk](https://stsci.service-now.com/hst?id=sc_cat_item&sys_id=a3b8ec5edbb7985033b55dd5ce961990&sysparm_category=ac85189bdb4683c033b55dd5ce96199c).\n", + "\n", + "**Author:** Elaine M Frazer \\\n", + "**Updated On:** 2023-11-17" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citations\n", + "* See the [ULLYSES website](https://ullyses.stsci.edu/ullyses-cite.html) for citation guidelines.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Top of Page](#top)\n", + "\"Space " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}