AAA_Final_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 * 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": [
    "# get the first table of the catalogue\n",
    "first_table_name = tables_names[1]\n",
    "\n",
    "# execute a synchronous ADQL query\n",
    "tap_service = voresource.get_service(\"tap\")\n",
    "tap_records = tap_service.search(\n",
    "    f'select  * from \"{first_table_name}\"',\n",
    ")\n",
    "tap_records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c372e259-82f8-4b1e-96c4-1cbd04cf3f95",
   "metadata": {},
   "outputs": [],
   "source": [
    "tap_records.table.columns"
   ]
  },
  {
   "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": "b61915f1-16e6-4d78-acf4-605e345958c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "galaxy_data.to_csv('galaxy_data.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17c43259-b6e2-4ae1-a867-79716531df93",
   "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": "448f3343-a76e-401a-a99c-c7e65751be7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from astropy.cosmology import FlatLambdaCDM, z_at_value\n",
    "import astropy.units as u\n",
    "\n",
    "# Define the cosmological model\n",
    "cosmo = FlatLambdaCDM(H0=70 * u.km / u.s / u.Mpc, Om0=0.3)\n",
    "\n",
    "# Define the distance you have\n",
    "distance = 100 * u.Mpc  # Example distance\n",
    "\n",
    "# Calculate the redshift corresponding to the luminosity distance\n",
    "galaxy_data['z'] = [z_at_value(cosmo.luminosity_distance, x*u.Mpc ).value for x in galaxy_data.Dist]\n",
    "galaxy_data['log1p_z'] = np.log10(galaxy_data.z +1)\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",
    "\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",
    "# PLOT\n",
    "\n",
    "\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e569758d-7383-4a39-bd97-5da690bd2efd",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(galaxy_data.iloc[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f6d80b9-ae9e-4d28-90e6-554157d8f858",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import linregress\n",
    "\n",
    "# Example: Fitting logMass vs. log(1+z)\n",
    "slopeLogMass, intercept, r_value, p_value, std_err = linregress(galaxy_data['log1p_z'], galaxy_data['logMass'])\n",
    "print(f\"slopeLogMass: {slopeLogMass}, Intercept: {intercept}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "907a0bb0-5e84-4bd3-91ef-2ef367c89946",
   "metadata": {},
   "outputs": [],
   "source": [
    "slopeVMax, intercept, r_value, p_value, std_err = linregress(galaxy_data['log1p_z'], galaxy_data['logVmax'])\n",
    "print(f\"slopeVMax: {slopeVMax}, Intercept: {intercept}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06472d2e-1fbb-4862-bed9-35eb3b957df0",
   "metadata": {},
   "outputs": [],
   "source": [
    "slopeBMAG, intercept, r_value, p_value, std_err = linregress(galaxy_data['log1p_z'], galaxy_data['BMAG'])\n",
    "print(f\"slopeBMAG: {slopeBMAG}, Intercept: {intercept}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5da7326-1c99-4ac5-b9c4-10913d6f5286",
   "metadata": {},
   "outputs": [],
   "source": [
    "slopeLogMass/slopeVMax , slopeLogMass/slopeBMAG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec87814e-981e-4386-96ac-fa13642a5321",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assuming galaxy_data is already loaded with logMass and logVmax\n",
    "\n",
    "# Fit and plot directly\n",
    "coefficients = np.polyfit( galaxy_data['log1p_z'], galaxy_data['logMass'], 1)\n",
    "predicted_mass = np.polyval(coefficients, galaxy_data['log1p_z'])\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(galaxy_data['log1p_z'], galaxy_data['logMass'], label='Data Points')\n",
    "plt.plot(galaxy_data['log1p_z'], predicted_mass, 'r-', label=f'Fit Line: slope = {coefficients[0]:.2f}')\n",
    "plt.xlabel('log10(1+z)')\n",
    "plt.ylabel('log10(Mass)')\n",
    "plt.title('Re-Evaluated Tully-Fisher Relationship')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c57c4f2-a2ce-44f9-8930-1fbdb2f1d806",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assuming galaxy_data is already loaded with logMass and logVmax\n",
    "\n",
    "# Fit and plot directly\n",
    "coefficients = np.polyfit(galaxy_data['log1p_z'], galaxy_data['logVmax'], 1)\n",
    "predicted_Vmax = np.polyval(coefficients, galaxy_data['log1p_z'])\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(galaxy_data['log1p_z'], galaxy_data['logVmax'], label='Data Points')\n",
    "plt.plot(galaxy_data['log1p_z'], predicted_Vmax, 'r-', label=f'Fit Line: slope = {coefficients[0]:.2f}')\n",
    "plt.xlabel('log10(1+z)')\n",
    "plt.ylabel('log10(VMax)')\n",
    "plt.title('Re-Evaluated Tully-Fisher Relationship')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a9b45c2-416a-459f-9c21-4133b7a0deb2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5e0c9ef-8e5c-4451-8c1e-5ad584ba5de1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf6038d1-2848-4150-bb1e-65046155d0a9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06bd2fb1-4b52-44e3-be94-a709d4a9b4ec",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e838ca75-8bd5-4c6f-a874-e5b1a44087e5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": "733e8aae-f320-414c-b783-5ee3c3ce31f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simbad\n",
    "import requests\n",
    "\n",
    "def query_simbad(object_name):\n",
    "    url = \"http://simbad.u-strasbg.fr/simbad/sim-script\"\n",
    "    script = f\"format object form1\\nquery id {object_name}\\noutput console=off script=off\\nvotable {{main_id,coordinates,otypes,velocity,redshift,flux(B),dim(maj_axis),dim(min_axis)}}\"\n",
    "    response = requests.post(url, data={'script': script})\n",
    "    \n",
    "    if response.status_code == 200:\n",
    "        return response.text\n",
    "    else:\n",
    "        return \"Failed to retrieve data\"\n",
    "\n",
    "# Example usage\n",
    "object_name = \"UGC 763\"  # Replace with your object of interest\n",
    "result = query_simbad(object_name)\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57c321a5-b702-4e20-a03d-cb839244a460",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astropy.io.votable import parse_single_table\n",
    "\n",
    "# Example function to load and parse VOTable\n",
    "def load_votable(file_path):\n",
    "    table = parse_single_table(file_path).to_table()\n",
    "    return table\n",
    "\n",
    "# Assuming 'data.xml' is your downloaded VOTable file from SIMBAD\n",
    "data_table = load_votable('data.xml')\n",
    "print(data_table)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fd2b377-2710-4ce4-99e1-b84a67cb02e1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75f6b315-0056-4451-9767-faefe7dc227b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "954bf5a0-c64f-4716-a9d4-a6f86c5a4ee2",
   "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
}