Original_vizier_jmnras390466.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6eaeebf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access astronomical databases\n",
    "from pyvo import registry  # version >=1.6\n",
    "\n",
    "# Moc and HEALPix tools\n",
    "from mocpy import MOC\n",
    "\n",
    "# Coordinates manipulation\n",
    "from astropy.coordinates import SkyCoord\n",
    "\n",
    "# Sky visualization\n",
    "from ipyaladin import Aladin  # version >=0.4.0\n",
    "\n",
    "# For plots\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ad7861f",
   "metadata": {},
   "source": [
    "# Welcome to VizieR example workflow\n",
    "\n",
    "[![Vizier](https://custom-icon-badges.demolab.com/badge/Vizier-gray.svg?logo=vizier&logoColor=orange&logoWidth=20)](https://vizier.cds.unistra.fr/viz-bin/VizieR \"https://vizier.cds.unistra.fr/viz-bin/VizieR\")\n",
    "\n",
    "**Notes:** \n",
    "\n",
    "It is a generic notebook, highlighting what can be done once you chose a catalog. This workflow is suggested by [CDS](https://cdsweb.unistra.fr/) (Strasbourg Astronomical Data Center, house of [VizieR](https://vizier.cds.unistra.fr/viz-bin/VizieR)).\n",
    "\n",
    "The notebook exploits [pyVO](https://pyvo.readthedocs.io/en/latest/), an advanced library  of The [Virtual Observatory](https://ivoa.net/).\n",
    "\n",
    "[Astroquery](https://astroquery.readthedocs.io/en/latest/vizier/vizier.html) (not used here) is a well-documented, user-friendly alternative.\n",
    "\n",
    "--------------------------------------------------------\n",
    "\n",
    "## 1. Setup\n",
    "\n",
    "This example notebook has the following dependencies: \n",
    "\n",
    "**Required**\n",
    "- pyvo : this library facilitates the access to the Virtual Observatory (VO) resources. VizieR is part of the VO.\n",
    "This notebook needs version >=1.4.1\n",
    "**Optional, for visualization**\n",
    "- ipyaladin : this is the Aladin-lite sky viewer, bundled as a jupyter widget. It allows to plot catalogs and multi-order coverages (MOC)\n",
    "- matplotlib : an other option to see catalog points and MOCs\n",
    "\n",
    "## 2. Metadata exploration with the Virtual Observatory registry\n",
    "\n",
    "This part uses [pyvo](https://pyvo.readthedocs.io/en) to connect to the VO registry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95888801",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the catalogue name in VizieR\n",
    "CATALOGUE = \"J/MNRAS/390/466\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26ad3c69",
   "metadata": {},
   "source": [
    "We first retrieve the catalogue information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6db57e6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the catalogue name in VizieR\n",
    "CATALOGUE = \"J/MNRAS/390/466\"\n",
    "# each resource in the VO has an identifier, called ivoid. For vizier catalogs,\n",
    "# the VO ids can be constructed like this:\n",
    "catalogue_ivoid = f\"ivo://CDS.VizieR/{CATALOGUE}\"\n",
    "# the actual query to the registry\n",
    "voresource = registry.search(ivoid=catalogue_ivoid)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3e975e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can print metadata information about the catalogue\n",
    "voresource.describe(verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd2a7ae3",
   "metadata": {},
   "source": [
    "We can also inspect in details the `resource` object and access the attributes not provided by the describe method. See for example, the first author of a resource: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5a53605",
   "metadata": {},
   "outputs": [],
   "source": [
    "voresource.creators[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a457510",
   "metadata": {},
   "source": [
    "## 3. Access the tabular data of this catalog\n",
    "\n",
    "We can have a look at the tables available in the catalogue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92ebe10f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tables = voresource.get_tables()\n",
    "print(f\"In this catalogue, we have {len(tables)} tables.\")\n",
    "for table_name, table in tables.items():\n",
    "    print(f\"{table_name}: {table.description}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81514878",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also extract the tables names for later use\n",
    "tables_names = list(tables.keys())\n",
    "tables_names"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eedac527",
   "metadata": {},
   "source": [
    "The actual data can then be accessed using any of the ``access_modes`` of the voresource."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32db444e",
   "metadata": {},
   "outputs": [],
   "source": [
    "voresource.access_modes()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a7dd42f",
   "metadata": {},
   "source": [
    "The web access is found by following the ``reference_url``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "545f9bf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "voresource.reference_url"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abee6ce7",
   "metadata": {},
   "source": [
    "### 3.1 Execute a SQL/ADQL query\n",
    "\n",
    "The ``tap#aux`` in the ``access_mode`` response indicates that we can also do a SQL/ADQL query for these VizieR tables.\n",
    "\n",
    "On the first table of the catalogue, we execute an <a href='https://www.ivoa.net/documents/latest/ADQL.html'>ADQL</a> query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a8b8d60",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the first table of the catalogue\n",
    "first_table_name = tables_names[0]\n",
    "\n",
    "# execute a synchronous ADQL query\n",
    "tap_service = voresource.get_service(\"tap\")\n",
    "tap_records = tap_service.search(\n",
    "    f'select TOP 10 * from \"{first_table_name}\"',\n",
    ")\n",
    "tap_records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14518ff0-6af4-4693-b4dc-ee23461118e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "tap_records.table.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca4119ef-ebe1-4dac-acf1-e812b3f867b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "tables_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdf4bd4a-f93f-4353-bb59-fdd79a66c421",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "80157f1b",
   "metadata": {},
   "source": [
    "<!-- section position -->\n",
    "\n",
    "We will explore the other access modes here.\n",
    "\n",
    "### 3.2. Execute a cone search query\n",
    "\n",
    "We use the Simple Cone Search (<a href='https://www.ivoa.net/documents/latest/ConeSearch.html'>SCS</a>) protocol of the virtual observatory (only available for tables with positions).\n",
    "\n",
    "Finding the conesearch service that you want to use (there is usually one per table):"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f11fb741",
   "metadata": {},
   "source": [
    "Let's use the first one for this example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4515d133",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we get the conesearch  service associated to the first table\n",
    "conesearch_interface = voresource.get_interface(service_type='conesearch', \n",
    "                                                keyword='J/MNRAS/390/466/galaxies',\n",
    "                                                lax=True)\n",
    "conesearch_service = conesearch_interface.to_service()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceaefcb5",
   "metadata": {},
   "source": [
    "We adapt the radius and position of the center to our needs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39b1153b",
   "metadata": {},
   "outputs": [],
   "source": [
    "conesearch_radius = 1 / 60.0  # in degrees\n",
    "conesearch_center = (27.817383, 22.366755)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f34d3fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "conesearch_records = conesearch_service.search(\n",
    "    pos=conesearch_center,\n",
    "    sr=conesearch_radius,\n",
    ")\n",
    "conesearch_records"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1df2200",
   "metadata": {},
   "source": [
    "## 4. Get the catalogue coverage\n",
    "\n",
    "VizieR also provides the coverage of each catalogue with Multiple Order Coverage (<a href='https://ivoa.net/documents/MOC/'>MOC</a>) at order 10 -- meaning with a 0.001 rad spacial resolution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b532da7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# retrieve the MOC\n",
    "catalogue_coverage = MOC.from_vizier_table(CATALOGUE)\n",
    "catalogue_coverage.display_preview()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8273b53",
   "metadata": {},
   "source": [
    "The quick preview is the whole sky in equatorial coordinates. Red represent zones where the catalog has data, black areas are empty zones.\n",
    "\n",
    "We can also plot the coverage with ``matplotlib``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f47e09e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(5, 5))\n",
    "wcs = catalogue_coverage.wcs(fig)\n",
    "ax = fig.add_subplot(projection=wcs)\n",
    "catalogue_coverage.fill(ax=ax, wcs=wcs, alpha=0.5, color=\"blue\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adad9fc7",
   "metadata": {},
   "source": [
    "or with [ipyaladin](https://github.com/cds-astro/ipyaladin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53840a2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "aladin = Aladin()\n",
    "aladin"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17465387",
   "metadata": {},
   "source": [
    "We switch the target to the center of the conesearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d550ccf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "aladin.target = \"27.817383 +22.366755\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de738e90-b34b-4818-a6e6-2d07c9b4c2c2",
   "metadata": {},
   "source": [
    "We can add the tables and coverage in this ipyaladin widget:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52e6635c-2500-4c49-930b-35a08b36caa0",
   "metadata": {},
   "outputs": [],
   "source": [
    "aladin.add_table(conesearch_records.to_table(), color=\"lightskyblue\", shape=\"plus\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f39955a",
   "metadata": {},
   "source": [
    "If you don't see the points from the conesearch result, try zooming in the widget with your mouse wheel.\n",
    "\n",
    "We can also add the result of the TAP query:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f55e7d1-bf38-4b7d-a73b-567f9b256f85",
   "metadata": {},
   "outputs": [],
   "source": [
    "aladin.add_table(tap_records.to_table())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "097a4505-5417-4dd3-9032-d75a76fa7c5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "aladin.add_moc(\n",
    "    catalogue_coverage,\n",
    "    fill=True, opacity=0.5, color=\"pink\", edge=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "065588dd",
   "metadata": {},
   "source": [
    "For more information about manipulating multi-order coverages, see [MOCpy documentation](https://cds-astro.github.io/mocpy/), and about using the `ipyaladin` widget, see [its documentation](https://cds-astro.github.io/ipyaladin/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8b35046-96fd-461f-9fe7-8423451db009",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyvo as vo\n",
    "\n",
    "# Set up the TAP service\n",
    "service = vo.dal.TAPService(\"http://tapvizier.cds.unistra.fr/TAPVizieR/tap\")\n",
    "\n",
    "\n",
    "# Define the query to extract mass (or luminosity) and maximum velocity\n",
    "query = \"\"\"\n",
    "SELECT TOP 10 *\n",
    "FROM \"J/MNRAS/390/466/galaxies\"\n",
    "\"\"\"\n",
    "# Execute the query\n",
    "result = service.search(query)\n",
    "\n",
    "# Convert the result to a pandas DataFrame\n",
    "galaxy_data_10 = result.to_table().to_pandas()\n",
    "galaxy_data_10.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72f4fb64-97c0-424b-b769-4efca716e1e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyvo as vo\n",
    "import numpy as np\n",
    "\n",
    "R0=14.01E9 # 4D radius of the Universe in lyr\n",
    "# Set up the TAP service\n",
    "service = vo.dal.TAPService(\"http://tapvizier.cds.unistra.fr/TAPVizieR/tap\")\n",
    "\n",
    "\n",
    "# Define the query to extract mass (or luminosity) and maximum velocity\n",
    "query = \"\"\"\n",
    "SELECT\n",
    "    Name, \n",
    "    BMAG,  -- Absolute B magnitude, can be converted to mass or used as a luminosity proxy\n",
    "    Vmax,   -- Maximum rotation velocity km/s\n",
    "    Dist   -- Distance Mpc\n",
    "FROM\n",
    "    \"J/MNRAS/390/466/galaxies\"\n",
    "WHERE\n",
    "    BMAG IS NOT NULL AND\n",
    "    Vmax IS NOT NULL\n",
    "\"\"\"\n",
    "\n",
    "# Execute the query\n",
    "result = service.search(query)\n",
    "\n",
    "# Convert the result to a pandas DataFrame\n",
    "galaxy_data = result.to_table().to_pandas()\n",
    "\n",
    "# Constants\n",
    "M_sun = 5.48  # Solar absolute magnitude in the B-band\n",
    "ML_ratio = 5  # Example M/L ratio, adjust based on your data or literature\n",
    "\n",
    "# Calculate luminosity relative to the Sun\n",
    "galaxy_data[\"Dist_lyr\"]= 3_261_563* galaxy_data[\"Dist\"]/R0\n",
    "galaxy_data['z'] = galaxy_data.Dist_lyr/(1-galaxy_data.Dist_lyr)\n",
    "galaxy_data['Luminosity'] = 10**(-0.4 * (galaxy_data['BMAG'] - M_sun))\n",
    "\n",
    "# Estimate mass\n",
    "galaxy_data['Mass'] = galaxy_data['Luminosity'] * ML_ratio\n",
    "\n",
    "# Check the first few entries\n",
    "print(galaxy_data[['Name', 'BMAG', 'Luminosity', 'Mass', 'Vmax', 'Dist_lyr', 'z' ]].head())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "448f3343-a76e-401a-a99c-c7e65751be7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Assuming 'galaxy_data' is the DataFrame with your data\n",
    "galaxy_data['BMAG'] = galaxy_data['BMAG']  # Using -log10 because brighter galaxies have smaller magnitude values\n",
    "galaxy_data['LogVmax'] = np.log10(galaxy_data['Vmax'])\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(galaxy_data['LogVmax'], galaxy_data['BMAG'], c='blue', edgecolor='black')\n",
    "plt.title('B-band Magnitude vs. log10 of Maximum Velocity')\n",
    "plt.xlabel('log10(Vmax [km/s])')\n",
    "plt.ylabel('BMAG')\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00801bb6-659f-459d-8da0-994c4c4cbf63",
   "metadata": {},
   "source": [
    "To derive a proxy for mass using distance, you'll need to adjust the luminosity values you've calculated from the B-band magnitudes. The luminosity \\( L \\) in terms of the absolute magnitude \\( M \\) can be expressed by the formula:\n",
    "\n",
    "$ L = 10^{-0.4(M - M_{\\text{sun}})} $\n",
    "\n",
    "where $ M_{\\text{sun}} $ is the absolute magnitude of the Sun in the B-band (about 5.48).\n",
    "\n",
    "However, to calculate luminosity directly from the apparent magnitude and distance, you can use the distance modulus:\n",
    "\n",
    "$ M = m - 5 \\log_{10}(d) + 5 $\n",
    "\n",
    "where:\n",
    "-  M is the absolute magnitude,\n",
    "-  m is the apparent magnitude,\n",
    "-  d is the distance in parsecs.\n",
    "\n",
    "If you already have the distance or can calculate it from the redshift (using a cosmological model or approximation if the redshift \\( z \\) values are available), you can calculate the absolute magnitude and then the luminosity.\n",
    "\n",
    "Do you have the distances available, or would you need help deriving them from redshift or another method? If you have distances or redshifts in any of your data files, please let me know how you'd like to proceed!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78a5ad4e-1f50-4e0d-8397-f0d917b82f09",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Assuming 'galaxy_data' is the DataFrame with your data\n",
    "galaxy_data['LogMass'] = np.log10( galaxy_data['Mass'])  # Using -log10 because brighter galaxies have smaller magnitude values\n",
    "galaxy_data['LogVmax'] = np.log10(galaxy_data['Vmax'])\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(galaxy_data['LogVmax'], galaxy_data['LogMass'], c='blue', edgecolor='black')\n",
    "plt.title('Log10 Mass vs. log10 of Maximum Velocity')\n",
    "plt.xlabel('log10(Vmax [km/s])')\n",
    "plt.ylabel('log10 Mass')\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6143e5f6-a816-4b43-ba8c-bdd16b212a63",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Generating some example data for demonstration\n",
    "np.random.seed(0)\n",
    "vmax = galaxy_data[\"LogVmax\"]\n",
    "mass = galaxy_data[\"LogMass\"]\n",
    "\n",
    "# Performing a linear regression to find the Tully-Fisher Coefficient\n",
    "coefficients = np.polyfit(vmax, mass, 1)\n",
    "tully_fisher_coefficient = coefficients[0]\n",
    "\n",
    "# Using the fitted line to calculate predicted values\n",
    "predicted_mass = np.polyval(coefficients, vmax)\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(vmax, mass, c='blue', edgecolor='black', label='Data')\n",
    "plt.plot(vmax, predicted_mass, 'r-', label=f'Fit Line: slope = {tully_fisher_coefficient:.2f}')\n",
    "plt.title(f'Log10 Mass vs. log10 of Maximum Velocity\\nTully-Fisher Coefficient: {tully_fisher_coefficient:.2f}')\n",
    "plt.xlabel('log10(Vmax [km/s])')\n",
    "plt.ylabel('log10 Mass')\n",
    "plt.text(2.3, 9.1, 'vizier_jmnras390466', fontsize=12, color='red')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.savefig(\"./Drawing_For_Publications/GHasp_TullyFisher_M_vs_Vmax.png\")\n",
    "plt.show()\n",
    "\n",
    "tully_fisher_coefficient\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "184b7b4e-2a89-4283-b291-43b7964b1a1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sum([ \"7831\" in galaxy_data.Name])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66eb122d-910d-490a-9ccf-00e7895cd5d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "galaxy_data.Name\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43d4b4dd-6fce-4451-8b08-5816203c08c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.sdss import SDSS\n",
    "from astropy import coordinates as coords\n",
    "import astropy \n",
    "\n",
    "galaxy_names = [x for x in galaxy_data.Name ]\n",
    "\n",
    "for name in galaxy_names:\n",
    "    # Get coordinates for the object\n",
    "    obj_coords = coords.SkyCoord.from_name(name) \n",
    "    # print(obj_coords)\n",
    "\n",
    "    # Use coordinates for cross-identification\n",
    "    sdss_obj = SDSS.query_crossid(obj_coords) \n",
    "    print(name, sdss_obj)\n",
    "    if sdss_obj is None:\n",
    "        print(name, \" not found\")\n",
    "        continue\n",
    "    # objid = sdss_obj['objID'][0] \n",
    "\n",
    "    # # Construct the SQL query with the objID (same as before)\n",
    "    # query = f\"\"\"SELECT p.objID, p.ra, p.dec, s.z, s.zErr, \n",
    "    #               p.modelMag_u, p.modelMag_g, p.modelMag_r, \n",
    "    #               p.modelMag_i, p.modelMag_z \n",
    "    #               FROM PhotoObj AS p JOIN SpecObj AS s ON s.bestobjid = p.objid \n",
    "    #               WHERE p.objid = {objid}\"\"\" \n",
    "\n",
    "    # result = SDSS.query_sql(query)\n",
    "    # galaxy_sdss = result.to_pandas()\n",
    "    # print(galaxy_sdss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1e04786-9664-411f-8a30-aec37e327a29",
   "metadata": {},
   "outputs": [],
   "source": [
    "z = result[\"z\"]\n",
    "distance = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5019eb65-2791-4091-84aa-d702950a361f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7290147c-7e22-4385-92fb-35dad03b4aaf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c846747-ae31-4ec4-ada5-6c57bbb2671b",
   "metadata": {},
   "outputs": [],
   "source": [
    "result.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d864ad23-4fe3-4ce2-b1d3-b870b5eb312c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.utils.tap.core import TapPlus\n",
    "\n",
    "# Connect to an appropriate TAP service\n",
    "url = 'http://tapvizier.u-strasbg.fr/TAPVizieR/tap'\n",
    "tap_service = TapPlus(url=url)\n",
    "\n",
    "# Construct a query to retrieve data\n",
    "query = \"\"\"\n",
    "SELECT TOP 10\n",
    "  p.objID, p.ra, p.dec, s.z, s.zErr, p.modelMag_u, p.modelMag_g, p.modelMag_r, p.modelMag_i, p.modelMag_z\n",
    "FROM\n",
    "  sdss_dr16.PhotoObj AS p\n",
    "JOIN\n",
    "  sdss_dr16.SpecObj AS s ON s.bestobjid = p.objid\n",
    "WHERE\n",
    "  p.objid IN ('UGC 12893', 'UGC 00089', 'UGC 00094', 'UGC 00508', 'UGC 00528')\n",
    "\"\"\"\n",
    "\n",
    "result = tap_service.search(query)\n",
    "print(result.to_table())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2d5897d-78f1-48b3-a5b8-41ab0d0c76ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.sdss import SDSS\n",
    "import pandas as pd\n",
    "\n",
    "galaxy_names = [\n",
    "    'UGC 12893', 'UGC 00089', 'UGC 00094', 'UGC 00508', 'UGC 00528',  # truncated for brevity\n",
    "]\n",
    "\n",
    "results = []\n",
    "\n",
    "for name in galaxy_names:\n",
    "    query = f\"\"\"\n",
    "    SELECT\n",
    "        p.objID, p.ra, p.dec, s.z, s.zErr,\n",
    "        p.modelMag_u, p.modelMag_g, p.modelMag_r, p.modelMag_i, p.modelMag_z\n",
    "    FROM\n",
    "        PhotoObj AS p\n",
    "        JOIN SpecObj AS s ON s.bestobjid = p.objid\n",
    "    WHERE\n",
    "        p.objid = '{name.strip()}'\n",
    "    \"\"\"\n",
    "    try:\n",
    "        result = SDSS.query_sql(query)\n",
    "        if result is not None:\n",
    "            results.append(result.to_pandas())\n",
    "    except Exception as e:\n",
    "        print(f\"Failed to retrieve or parse data for {name}: {str(e)}\")\n",
    "\n",
    "# Combine all results into a single DataFrame\n",
    "full_results = pd.concat(results, ignore_index=True)\n",
    "\n",
    "# Display the combined results\n",
    "print(full_results.head())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e91cfdc-3e9a-4ae0-9c93-ad37b926bdb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.utils.tap.core import TapPlus\n",
    "vizier_tap_url = \"http://tapvizier.u-strasbg.fr/TAPVizieR/tap\"\n",
    "tap_service = TapPlus(url=vizier_tap_url)\n",
    "\n",
    "# Construct an ADQL query\n",
    "query = \"\"\"\n",
    "SELECT TOP 10\n",
    "    p.objID, p.ra, p.dec, s.z, s.zErr,\n",
    "    p.modelMag_u, p.modelMag_g, p.modelMag_r, p.modelMag_i, p.modelMag_z\n",
    "FROM\n",
    "    sdss_dr16.PhotoObj AS p\n",
    "JOIN\n",
    "    sdss_dr16.SpecObj AS s ON s.bestobjid = p.objid\n",
    "WHERE\n",
    "    p.objid IN ('UGC 12893', 'UGC 00089', 'UGC 00094', 'UGC 00508', 'UGC 00528')\n",
    "\"\"\"\n",
    "\n",
    "# Execute the query using query_adql or query_job\n",
    "job = tap_service.launch_job_async(query)\n",
    "result = job.get_results()\n",
    "\n",
    "# Show the results\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "673353b4-e2c4-489b-b6b5-edf7f271fa25",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.utils.tap.core import TapPlus\n",
    "\n",
    "# Connect to VizieR TAP service\n",
    "vizier_tap_url = \"http://tapvizier.u-strasbg.fr/TAPVizieR/tap\"\n",
    "tap_service = TapPlus(url=vizier_tap_url)\n",
    "\n",
    "# Construct an ADQL query\n",
    "query = \"\"\"\n",
    "SELECT TOP 10\n",
    "    *\n",
    "FROM\n",
    "    \"V/147/sdss12\"\n",
    "WHERE\n",
    "    1=1\n",
    "\"\"\"\n",
    "\n",
    "# Execute the query using query_adql or query_job\n",
    "job = tap_service.launch_job_async(query)\n",
    "result = job.get_results()\n",
    "\n",
    "# Show the results\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ffd92ab2-3a89-4129-a8f3-5838b2ce99d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.sdss import SDSS\n",
    "\n",
    "# Define your query\n",
    "query = \"\"\"\n",
    "SELECT TOP 10\n",
    "p.*\n",
    "FROM PhotoObj as p\n",
    "where \n",
    "p.objid = 'UGC 12893'\n",
    "\"\"\"\n",
    "\n",
    "# Execute the query\n",
    "result = SDSS.query_sql(query)\n",
    "\n",
    "# Print the results\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7996c8cd-248b-4e0d-87b3-e8c58a57a14b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.skyview import SkyView\n",
    "from astroquery.sdss import SDSS\n",
    "from astropy import coordinates as coords\n",
    "import astropy.units as u\n",
    "\n",
    "# Resolve the object name to coordinates\n",
    "pos = SkyView.get_image_list(position='UGC 12893', survey=['SDSS'], pixels=0)\n",
    "\n",
    "# If position resolution is successful, query around that position\n",
    "if pos:\n",
    "    coord = coords.SkyCoord.from_name('UGC 12893')\n",
    "    result = SDSS.query_region(coord, radius=2*u.arcmin, photoobj_fields=['objid', 'ra', 'dec', 'u', 'g', 'r', 'i', 'z'])\n",
    "\n",
    "    # Print the results\n",
    "    print(result)\n",
    "else:\n",
    "    print(\"Failed to resolve the name to coordinates.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17848252-eb4c-4583-8b96-b0484bd47b1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.skyview import SkyView\n",
    "\n",
    "# List all available surveys\n",
    "surveys = SkyView.list_surveys()\n",
    "print(\"Available Surveys:\", surveys)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03c975b7-499a-4068-9968-c1c7d5960405",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astroquery.skyview import SkyView\n",
    "from astropy.coordinates import SkyCoord\n",
    "\n",
    "# Resolve the object name to coordinates\n",
    "coord = SkyCoord.from_name('UGC 12893')\n",
    "\n",
    "# Fetch the image\n",
    "image_paths = SkyView.get_image_list(position=coord, survey=['SDSSdr7g'])\n",
    "\n",
    "# Download the first image to view it\n",
    "images = SkyView.get_images(position=coord, survey=['SDSSdr7g'], radius=0.1 * u.deg)\n",
    "\n",
    "# Printing image paths and display the image if needed\n",
    "print(\"Image URLs:\", image_paths)\n",
    "print(\"Fetched Images:\", images)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "521d8331-1e4f-412e-813d-7b3ad447f20b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6d892cc-e788-4f90-93fa-dfd651621d82",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "733e8aae-f320-414c-b783-5ee3c3ce31f6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e47cb48-9452-4fc2-b97e-c673d2c03dea",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:Cosmos3020]",
   "language": "python",
   "name": "conda-env-Cosmos3020-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}