diff --git a/docs/source/getting_started/SWIFTGalaxy_demo.ipynb b/docs/source/getting_started/SWIFTGalaxy_demo.ipynb new file mode 100644 index 0000000..01635ab --- /dev/null +++ b/docs/source/getting_started/SWIFTGalaxy_demo.ipynb @@ -0,0 +1,1244 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "https://bit.ly/3caUN7n" + ], + "metadata": { + "id": "a-kbTfJMJxSl" + } + }, + { + "cell_type": "markdown", + "source": [ + "#Install dependencies" + ], + "metadata": { + "id": "XXO3-USURrxy" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install swiftgalaxy[velociraptor]" + ], + "metadata": { + "id": "Ea7vQkv0MaVn", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d66455a2-41fe-4089-c66f-c6a15c21f869" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting swiftgalaxy[velociraptor]\n", + " Downloading swiftgalaxy-1.0.5-py3-none-any.whl (36 kB)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from swiftgalaxy[velociraptor]) (1.25.2)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from swiftgalaxy[velociraptor]) (1.11.4)\n", + "Requirement already satisfied: h5py in /usr/local/lib/python3.10/dist-packages (from swiftgalaxy[velociraptor]) (3.9.0)\n", + "Collecting unyt (from swiftgalaxy[velociraptor])\n", + " Downloading unyt-3.0.2-py3-none-any.whl (138 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m138.6/138.6 kB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting swiftsimio (from swiftgalaxy[velociraptor])\n", + " Downloading swiftsimio-7.0.1-py3-none-any.whl (112 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m112.4/112.4 kB\u001b[0m \u001b[31m9.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting velociraptor (from swiftgalaxy[velociraptor])\n", + " Downloading velociraptor-0.16.1-py3-none-any.whl (96 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m96.2/96.2 kB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numba>=0.50.0 in /usr/local/lib/python3.10/dist-packages (from swiftsimio->swiftgalaxy[velociraptor]) (0.58.1)\n", + "Requirement already satisfied: sympy>=1.7 in /usr/local/lib/python3.10/dist-packages (from unyt->swiftgalaxy[velociraptor]) (1.12)\n", + "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.10/dist-packages (from unyt->swiftgalaxy[velociraptor]) (24.0)\n", + "Requirement already satisfied: astropy in /usr/local/lib/python3.10/dist-packages (from velociraptor->swiftgalaxy[velociraptor]) (5.3.4)\n", + "Requirement already satisfied: llvmlite<0.42,>=0.41.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba>=0.50.0->swiftsimio->swiftgalaxy[velociraptor]) (0.41.1)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.7->unyt->swiftgalaxy[velociraptor]) (1.3.0)\n", + "Requirement already satisfied: pyerfa>=2.0 in /usr/local/lib/python3.10/dist-packages (from astropy->velociraptor->swiftgalaxy[velociraptor]) (2.0.1.1)\n", + "Requirement already satisfied: PyYAML>=3.13 in /usr/local/lib/python3.10/dist-packages (from astropy->velociraptor->swiftgalaxy[velociraptor]) (6.0.1)\n", + "Installing collected packages: unyt, velociraptor, swiftsimio, swiftgalaxy\n", + "Successfully installed swiftgalaxy-1.0.5 swiftsimio-7.0.1 unyt-3.0.2 velociraptor-0.16.1\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "May need to restart runtime after installation!" + ], + "metadata": { + "id": "S7LGlp9xSiJk" + } + }, + { + "cell_type": "markdown", + "source": [ + "#Create a simple toy-model snapshot and halo finder output\n", + "\n", + "The following long block of code defines a couple of functions to create a sample snapshot and velociraptor output \"by hand\"; these are run in the next block to give us some lightweight data to experiment with.\n", + "\n", + "The sample snapshot is a periodic simulation volume with a uniform background density of dark matter and gas. The box has a side length of 10 Mpc. At coordinates (2, 2, 2) Mpc is a very crude \"galaxy\" composed of:\n", + " - a gas disc 10 kpc in radius and 2 kpc thick with 1/R surface density scaling and vertically uniform density\n", + " - a spherical dark matter halo 100 kpc in radius with 1/r^2 density scaling\n", + " - a stellar disc 5 kpc in radius and 1 kpc thick with 1/R surface density scaling and vertically uniform density\n", + " - a central black hole" + ], + "metadata": { + "id": "kWk2xCcVR-2W" + } + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "import h5py\n", + "import numpy as np\n", + "import unyt as u\n", + "from swiftsimio import Writer\n", + "from swiftsimio.units import cosmo_units\n", + "\n", + "toysnap_filename = \"toysnap.hdf5\"\n", + "toyvr_filebase = \"toyvr\"\n", + "present_particle_types = {0: \"gas\", 1: \"dark_matter\", 4: \"stars\", 5: \"black_holes\"}\n", + "boxsize = 10.0\n", + "n_g_all = 32**3\n", + "n_g = 10000\n", + "n_g_b = n_g_all - n_g\n", + "n_dm_all = 32**3\n", + "n_dm = 10000\n", + "n_dm_b = n_dm_all - n_dm\n", + "n_s = 10000\n", + "n_bh = 1\n", + "\n", + "\n", + "def create_toysnap(\n", + " snapfile=toysnap_filename, alt_coord_name=None, alt_vel_name=None, alt_id_name=None\n", + "):\n", + " \"\"\"\n", + " Creates a sample dataset of a toy galaxy.\n", + " \"\"\"\n", + "\n", + " sd = Writer(cosmo_units, np.ones(3, dtype=float) * boxsize * u.Mpc)\n", + "\n", + " # Insert a uniform gas background plus a galaxy disc\n", + " phi = np.random.rand(n_g, 1) * 2 * np.pi\n", + " R = np.random.rand(n_g, 1)\n", + " getattr(sd, present_particle_types[0]).particle_ids = np.arange(n_g_all)\n", + " getattr(sd, present_particle_types[0]).coordinates = (\n", + " np.vstack(\n", + " (\n", + " np.random.rand(n_g_b, 3) * 10,\n", + " np.hstack(\n", + " (\n", + " # 10 kpc disc radius, offcentred in box\n", + " 2 + R * np.cos(phi) * 0.01,\n", + " 2 + R * np.sin(phi) * 0.01,\n", + " 2 + (np.random.rand(n_g, 1) * 2 - 1) * 0.001, # 1 kpc height\n", + " )\n", + " ),\n", + " )\n", + " )\n", + " * u.Mpc\n", + " )\n", + " getattr(sd, present_particle_types[0]).velocities = (\n", + " np.vstack(\n", + " (\n", + " np.random.rand(n_g_b, 3) * 2 - 1, # 1 km/s for background\n", + " np.hstack(\n", + " (\n", + " # solid body, 100 km/s at edge\n", + " 200 + R * np.sin(phi) * 100,\n", + " 200 + R * np.cos(phi) * 100,\n", + " 200 + np.random.rand(n_g, 1) * 20 - 10, # 10 km/s vertical\n", + " )\n", + " ),\n", + " )\n", + " )\n", + " * u.km\n", + " / u.s\n", + " )\n", + " getattr(sd, present_particle_types[0]).masses = (\n", + " np.concatenate((np.ones(n_g_b, dtype=float), np.ones(n_g, dtype=float)))\n", + " * 1e3\n", + " * u.msun\n", + " )\n", + " getattr(sd, present_particle_types[0]).internal_energy = (\n", + " np.concatenate(\n", + " (\n", + " np.ones(n_g_b, dtype=float), # 1e4 K\n", + " np.ones(n_g, dtype=float) / 10, # 1e3 K\n", + " )\n", + " )\n", + " * 1e4\n", + " * u.kb\n", + " * u.K\n", + " / (1e3 * u.msun)\n", + " )\n", + " getattr(sd, present_particle_types[0]).generate_smoothing_lengths(\n", + " boxsize=boxsize * u.Mpc, dimension=3\n", + " )\n", + " # Auto smoothing lengths ok for uniform background, reduce for disc particles\n", + " getattr(sd, present_particle_types[0]).smoothing_length[n_g_b:] = 0.0001 # 100 pc\n", + "\n", + " # Insert a uniform DM background plus a galaxy halo\n", + " phi = np.random.rand(n_dm, 1) * 2 * np.pi\n", + " theta = np.arccos(np.random.rand(n_dm, 1) * 2 - 1)\n", + " r = np.random.rand(n_dm, 1)\n", + " getattr(sd, present_particle_types[1]).particle_ids = np.arange(\n", + " n_g_all, n_g_all + n_dm_all\n", + " )\n", + " getattr(sd, present_particle_types[1]).coordinates = (\n", + " np.vstack(\n", + " (\n", + " np.random.rand(n_dm_b, 3) * 10,\n", + " np.hstack(\n", + " (\n", + " # 100 kpc halo radius, offcentred in box\n", + " 2 + r * np.cos(phi) * np.sin(theta) * 0.1,\n", + " 2 + r * np.sin(phi) * np.sin(theta) * 0.1,\n", + " 2 + r * np.cos(theta) * 0.1,\n", + " )\n", + " ),\n", + " )\n", + " )\n", + " * u.Mpc\n", + " )\n", + " getattr(sd, present_particle_types[1]).velocities = (\n", + " np.vstack(\n", + " (\n", + " # 1 km/s background, 100 km/s halo\n", + " np.random.rand(n_dm_b, 3) * 2 - 1,\n", + " 200 + (np.random.rand(n_dm, 3) * 2 - 1) * 100,\n", + " )\n", + " )\n", + " * u.km\n", + " / u.s\n", + " )\n", + " getattr(sd, present_particle_types[1]).masses = (\n", + " np.concatenate((np.ones(n_dm_b, dtype=float), np.ones(n_dm, dtype=float)))\n", + " * 1e4\n", + " * u.msun\n", + " )\n", + " getattr(sd, present_particle_types[1]).generate_smoothing_lengths(\n", + " boxsize=boxsize * u.Mpc, dimension=3\n", + " )\n", + "\n", + " # Insert a galaxy stellar disc\n", + " phi = np.random.rand(n_s, 1) * 2 * np.pi\n", + " R = np.random.rand(n_s, 1)\n", + " getattr(sd, present_particle_types[4]).particle_ids = np.arange(\n", + " n_g_all + n_dm_all, n_g_all + n_dm_all + n_s\n", + " )\n", + " getattr(sd, present_particle_types[4]).coordinates = (\n", + " np.hstack(\n", + " (\n", + " # 5 kpc disc radius, offcentred in box\n", + " 2 + R * np.cos(phi) * 0.005,\n", + " 2 + R * np.sin(phi) * 0.005,\n", + " 2 + (np.random.rand(n_s, 1) * 2 - 1) * 0.0005, # 500 pc height\n", + " )\n", + " )\n", + " * u.Mpc\n", + " )\n", + " getattr(sd, present_particle_types[4]).velocities = (\n", + " np.hstack(\n", + " (\n", + " # solid body, 50 km/s at edge\n", + " 200 + R * np.sin(phi) * 50,\n", + " 200 + R * np.cos(phi) * 50,\n", + " 200 + np.random.rand(n_g, 1) * 20 - 10, # 10 km/s vertical motions\n", + " )\n", + " )\n", + " * u.km\n", + " / u.s\n", + " )\n", + " getattr(sd, present_particle_types[4]).masses = (\n", + " np.ones(n_g, dtype=float) * 1e3 * u.msun\n", + " )\n", + " getattr(sd, present_particle_types[4]).generate_smoothing_lengths(\n", + " boxsize=boxsize * u.Mpc, dimension=3\n", + " )\n", + " getattr(sd, present_particle_types[5]).particle_ids = np.arange(\n", + " n_g_all + n_dm_all + n_s, n_g_all + n_dm_all + n_s + n_bh\n", + " )\n", + " getattr(sd, present_particle_types[5]).coordinates = (\n", + " 2 + np.zeros((n_bh, 3), dtype=float)\n", + " ) * u.Mpc\n", + " getattr(sd, present_particle_types[5]).velocities = (\n", + " (200 + np.zeros((n_bh, 3), dtype=float)) * u.km / u.s\n", + " )\n", + " getattr(sd, present_particle_types[5]).masses = (\n", + " np.ones(n_bh, dtype=float) * 1e6 * u.msun\n", + " )\n", + " getattr(sd, present_particle_types[5]).generate_smoothing_lengths(\n", + " boxsize=boxsize * u.Mpc, dimension=3\n", + " )\n", + "\n", + " sd.write(snapfile) # IDs auto-generated\n", + "\n", + " with h5py.File(snapfile, \"r+\") as f:\n", + " g = f.create_group(\"Cells\")\n", + " g.create_dataset(\"Centres\", data=np.array([[5, 5, 5]], dtype=float))\n", + " cg = g.create_group(\"Counts\")\n", + " cg.create_dataset(\"PartType0\", data=np.array([n_g_all]), dtype=int)\n", + " cg.create_dataset(\"PartType1\", data=np.array([n_dm_all]), dtype=int)\n", + " cg.create_dataset(\"PartType4\", data=np.array([n_s]), dtype=int)\n", + " cg.create_dataset(\"PartType5\", data=np.array([n_bh]), dtype=int)\n", + " fg = g.create_group(\"Files\")\n", + " fg.create_dataset(\"PartType0\", data=np.array([0], dtype=int))\n", + " fg.create_dataset(\"PartType1\", data=np.array([0], dtype=int))\n", + " fg.create_dataset(\"PartType4\", data=np.array([0], dtype=int))\n", + " fg.create_dataset(\"PartType5\", data=np.array([0], dtype=int))\n", + " mdg = g.create_group(\"Meta-data\")\n", + " mdg.attrs[\"dimension\"] = np.array([[1, 1, 1]], dtype=int)\n", + " mdg.attrs[\"nr_cells\"] = np.array([1], dtype=int)\n", + " mdg.attrs[\"size\"] = np.array([boxsize, boxsize, boxsize], dtype=int)\n", + " og = g.create_group(\"OffsetsInFile\")\n", + " og.create_dataset(\"PartType0\", data=np.array([0], dtype=int))\n", + " og.create_dataset(\"PartType1\", data=np.array([0], dtype=int))\n", + " og.create_dataset(\"PartType4\", data=np.array([0], dtype=int))\n", + " og.create_dataset(\"PartType5\", data=np.array([0], dtype=int))\n", + " hsg = f.create_group(\"HydroScheme\")\n", + " hsg.attrs[\"Adiabatic index\"] = 5.0 / 3.0\n", + "\n", + " for pt in (0, 1, 4, 5):\n", + " g = f[f\"PartType{pt}\"]\n", + " g[\"ExtraCoordinates\"] = g[\"Coordinates\"]\n", + " g[\"ExtraVelocities\"] = g[\"Velocities\"]\n", + " if alt_id_name is not None:\n", + " g[alt_id_name] = g[\"ParticleIDs\"]\n", + " del g[\"ParticleIDs\"]\n", + " if alt_coord_name is not None:\n", + " g[alt_coord_name] = g[\"Coordinates\"]\n", + " del g[\"Coordinates\"]\n", + " if alt_vel_name is not None:\n", + " g[alt_vel_name] = g[\"Velocities\"]\n", + " del g[\"Velocities\"]\n", + "\n", + " ssg = f.create_group(\"SubgridScheme\")\n", + " ncg = ssg.create_group(\"NamedColumns\")\n", + " ncg.create_dataset(\n", + " \"HydrogenIonizationFractions\",\n", + " data=np.array([b\"Neutral\", b\"Ionized\"], dtype=\"|S32\"),\n", + " )\n", + " g = f[\"PartType0\"]\n", + " f_neutral = np.random.rand(n_g_all)\n", + " f_ion = 1 - f_neutral\n", + " hifd = g.create_dataset(\n", + " \"HydrogenIonizationFractions\",\n", + " data=np.array([f_neutral, f_ion], dtype=float).T,\n", + " )\n", + " hifd.attrs[\n", + " \"Conversion factor to CGS\" \" (not including cosmological corrections)\"\n", + " ] = np.array([1.0], dtype=float)\n", + " hifd.attrs[\n", + " \"Conversion factor to physical CGS\" \" (including cosmological corrections)\"\n", + " ] = np.array([1.0], dtype=float)\n", + " hifd.attrs[\"U_I exponent\"] = np.array([0.0], dtype=float)\n", + " hifd.attrs[\"U_L exponent\"] = np.array([0.0], dtype=float)\n", + " hifd.attrs[\"U_M exponent\"] = np.array([0.0], dtype=float)\n", + " hifd.attrs[\"U_T exponent\"] = np.array([0.0], dtype=float)\n", + " hifd.attrs[\"U_t exponent\"] = np.array([0.0], dtype=float)\n", + " hifd.attrs[\"a-scale exponent\"] = np.array([0.0], dtype=float)\n", + " hifd.attrs[\"h-scale exponent\"] = np.array([0.0], dtype=float)\n", + "\n", + " return\n", + "\n", + "\n", + "def remove_toysnap(snapfile=toysnap_filename):\n", + " os.remove(snapfile)\n", + " return\n", + "\n", + "\n", + "def create_toyvr(filebase=toyvr_filebase):\n", + " with h5py.File(f\"{toyvr_filebase}.properties\", \"w\") as f:\n", + " f.create_group(\"SimulationInfo\")\n", + " f[\"SimulationInfo\"].attrs[\"ScaleFactor\"] = 1.0\n", + " f[\"SimulationInfo\"].attrs[\"Cosmological_Sim\"] = 1\n", + " for coord in \"XYZ\":\n", + " f.create_dataset(f\"{coord}c\", data=np.array([2.001], dtype=float))\n", + " f.create_dataset(f\"{coord}cminpot\", data=np.array([2.0], dtype=float))\n", + " f.create_dataset(f\"{coord}cmbp\", data=np.array([2.002], dtype=float))\n", + " f.create_dataset(f\"{coord}c_gas\", data=np.array([0.003], dtype=float))\n", + " f.create_dataset(f\"{coord}c_stars\", data=np.array([0.004], dtype=float))\n", + " f.create_dataset(f\"V{coord}c\", data=np.array([201.0], dtype=float))\n", + " f.create_dataset(f\"V{coord}cminpot\", data=np.array([200.0], dtype=float))\n", + " f.create_dataset(f\"V{coord}cmbp\", data=np.array([202.0], dtype=float))\n", + " f.create_dataset(f\"V{coord}c_gas\", data=np.array([3.0], dtype=float))\n", + " f.create_dataset(f\"V{coord}c_stars\", data=np.array([4.0], dtype=float))\n", + " for ct in (\"c\", \"cminpot\", \"cmbp\", \"c_gas\", \"c_stars\"):\n", + " f[f\"{coord}{ct}\"].attrs[\"Dimension_Length\"] = 1.0\n", + " f[f\"{coord}{ct}\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[f\"{coord}{ct}\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[f\"{coord}{ct}\"].attrs[\"Dimension_Velocity\"] = 0.0\n", + " f[f\"V{coord}{ct}\"].attrs[\"Dimension_Length\"] = 0.0\n", + " f[f\"V{coord}{ct}\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[f\"V{coord}{ct}\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[f\"V{coord}{ct}\"].attrs[\"Dimension_Velocity\"] = 1.0\n", + " f.create_group(\"Configuration\")\n", + " f[\"Configuration\"].attrs[\"h_val\"] = 0.7\n", + " f[\"Configuration\"].attrs[\"w_of_DE\"] = -1.0\n", + " f[\"Configuration\"].attrs[\"Omega_DE\"] = 0.7\n", + " f[\"Configuration\"].attrs[\"Omega_b\"] = 0.05\n", + " f[\"Configuration\"].attrs[\"Omega_m\"] = 0.3\n", + " f[\"Configuration\"].attrs[\"Period\"] = boxsize\n", + " f.create_dataset(\"File_id\", data=np.array([0], dtype=int))\n", + " f.create_dataset(\"ID\", data=np.array([1], dtype=int))\n", + " f[\"ID\"].attrs[\"Dimension_Length\"] = 0.0\n", + " f[\"ID\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[\"ID\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[\"ID\"].attrs[\"Dimension_Velocity\"] = 0.0\n", + " # pick arbitrary particle in the galaxy to be most bound\n", + " f.create_dataset(\"ID_mbp\", data=np.array([32**3 - 9999], dtype=int))\n", + " f[\"ID_mbp\"].attrs[\"Dimension_Length\"] = 0.0\n", + " f[\"ID_mbp\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[\"ID_mbp\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[\"ID_mbp\"].attrs[\"Dimension_Velocity\"] = 0.0\n", + " # pick arbitrary particle in the galaxy to be potential minimum\n", + " f.create_dataset(\"ID_minpot\", data=np.array([32**3 - 9998], dtype=int))\n", + " f[\"ID_minpot\"].attrs[\"Dimension_Length\"] = 0.0\n", + " f[\"ID_minpot\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[\"ID_minpot\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[\"ID_minpot\"].attrs[\"Dimension_Velocity\"] = 0.0\n", + " f.create_dataset(\"Mvir\", data=np.array([100.0], dtype=float))\n", + " f.create_dataset(\"Mass_200crit\", data=np.array([100.0], dtype=float))\n", + " f.create_dataset(\"Mass_200mean\", data=np.array([100.0], dtype=float))\n", + " f.create_dataset(\"Mass_BN98\", data=np.array([100.0], dtype=float))\n", + " f.create_dataset(\"Mass_FOF\", data=np.array([100.0], dtype=float))\n", + " for field in (\"Mvir\", \"Mass_200crit\", \"Mass_200mean\", \"Mass_BN98\", \"Mass_FOF\"):\n", + " f[field].attrs[\"Dimension_Length\"] = 0.0\n", + " f[field].attrs[\"Dimension_Mass\"] = 1.0\n", + " f[field].attrs[\"Dimension_Time\"] = 0.0\n", + " f[field].attrs[\"Dimension_Velocity\"] = 0.0\n", + " f.create_dataset(\"R_200crit\", data=np.array([0.3], dtype=float))\n", + " f.create_dataset(\"R_200mean\", data=np.array([0.3], dtype=float))\n", + " f.create_dataset(\"R_BN98\", data=np.array([0.3], dtype=float))\n", + " f.create_dataset(\"R_size\", data=np.array([0.3], dtype=float))\n", + " f.create_dataset(\"Rmax\", data=np.array([0.3], dtype=float))\n", + " f.create_dataset(\"Rvir\", data=np.array([0.3], dtype=float))\n", + " for field in (\"R_200crit\", \"R_200mean\", \"R_BN98\", \"R_size\", \"Rmax\", \"Rvir\"):\n", + " f[field].attrs[\"Dimension_Length\"] = 1.0\n", + " f[field].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[field].attrs[\"Dimension_Time\"] = 0.0\n", + " f[field].attrs[\"Dimension_Velocity\"] = 0.0\n", + " f.create_dataset(\"Num_of_files\", data=np.array([1], dtype=int))\n", + " f.create_dataset(\"Num_of_groups\", data=np.array([1], dtype=int))\n", + " f.create_dataset(\"Structuretype\", data=np.array([10], dtype=int))\n", + " f[\"Structuretype\"].attrs[\"Dimension_Length\"] = 0.0\n", + " f[\"Structuretype\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[\"Structuretype\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[\"Structuretype\"].attrs[\"Dimension_Velocity\"] = 0.0\n", + " f.create_dataset(\"Total_num_of_groups\", data=np.array([1], dtype=int))\n", + " f.create_group(\"UnitInfo\")\n", + " # have not checked UnitInfo in detail\n", + " f[\"UnitInfo\"].attrs[\"Comoving_or_Physical\"] = b\"0\"\n", + " f[\"UnitInfo\"].attrs[\"Cosmological_Sim\"] = b\"1\"\n", + " f[\"UnitInfo\"].attrs[\"Length_unit_to_kpc\"] = b\"1000.000000\"\n", + " f[\"UnitInfo\"].attrs[\"Mass_unit_to_solarmass\"] = b\"10000000000.000000\"\n", + " f[\"UnitInfo\"].attrs[\"Metallicity_unit_to_solar\"] = b\"83.330000\"\n", + " f[\"UnitInfo\"].attrs[\"SFR_unit_to_solarmassperyear\"] = b\"97.780000\"\n", + " f[\"UnitInfo\"].attrs[\"Stellar_age_unit_to_yr\"] = b\"977813413600.000000\"\n", + " f[\"UnitInfo\"].attrs[\"Velocity_unit_to_kms\"] = b\"1.000000\"\n", + " f.attrs[\"Comoving_or_Physical\"] = 0\n", + " f.attrs[\"Cosmological_Sim\"] = 1\n", + " f.attrs[\"Length_unit_to_kpc\"] = 1000.000000\n", + " f.attrs[\"Mass_unit_to_solarmass\"] = 10000000000.000000\n", + " f.attrs[\"Metallicity_unit_to_solar\"] = 83.330000\n", + " f.attrs[\"Period\"] = boxsize\n", + " f.attrs[\"SFR_unit_to_solarmassperyear\"] = 97.780000\n", + " f.attrs[\"Stellar_age_unit_to_yr\"] = 977813413600.000000\n", + " f.attrs[\"Time\"] = 1.0\n", + " f.attrs[\"Velocity_to_kms\"] = 1.000000\n", + " f.create_dataset(\"hostHaloID\", data=np.array([-1], dtype=int))\n", + " f[\"hostHaloID\"].attrs[\"Dimension_Length\"] = 0.0\n", + " f[\"hostHaloID\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[\"hostHaloID\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[\"hostHaloID\"].attrs[\"Dimension_Velocity\"] = 0.0\n", + " f.create_dataset(\"n_bh\", data=np.array([n_bh], dtype=int))\n", + " f.create_dataset(\"n_gas\", data=np.array([n_g], dtype=int))\n", + " f.create_dataset(\"n_star\", data=np.array([n_s], dtype=int))\n", + " f.create_dataset(\"npart\", data=np.array([n_g + n_dm + n_s + n_bh], dtype=int))\n", + " for pt in (\"_bh\", \"_gas\", \"_star\", \"part\"):\n", + " f[f\"n{pt}\"].attrs[\"Dimension_Length\"] = 0.0\n", + " f[f\"n{pt}\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[f\"n{pt}\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[f\"n{pt}\"].attrs[\"Dimension_Velocity\"] = 0.0\n", + " f.create_dataset(\"numSubStruct\", data=np.array([0], dtype=int))\n", + " f[\"numSubStruct\"].attrs[\"Dimension_Length\"] = 0.0\n", + " f[\"numSubStruct\"].attrs[\"Dimension_Mass\"] = 0.0\n", + " f[\"numSubStruct\"].attrs[\"Dimension_Time\"] = 0.0\n", + " f[\"numSubStruct\"].attrs[\"Dimension_Velocity\"] = 0.0\n", + " with h5py.File(f\"{toyvr_filebase}.catalog_groups\", \"w\") as f:\n", + " f.create_dataset(\"File_id\", data=np.array([0], dtype=int))\n", + " f.create_dataset(\n", + " \"Group_Size\", data=np.array([n_g_all + n_dm_all + n_s + n_bh], dtype=int)\n", + " )\n", + " f.create_dataset(\"Num_of_files\", data=np.array([1], dtype=int))\n", + " f.create_dataset(\"Num_of_groups\", data=np.array([1], dtype=int))\n", + " f.create_dataset(\n", + " \"Number_of_substructures_in_halo\", data=np.array([0], dtype=int)\n", + " )\n", + " f.create_dataset(\"Offset\", data=np.array([0], dtype=int))\n", + " f.create_dataset(\"Offset_unbound\", data=np.array([0], dtype=int))\n", + " f.create_dataset(\"Parent_halo_ID\", data=np.array([-1], dtype=int))\n", + " f.create_dataset(\"Total_num_of_groups\", data=np.array([1], dtype=int))\n", + " with h5py.File(f\"{toyvr_filebase}.catalog_particles\", \"w\") as f:\n", + " f.create_dataset(\"File_id\", data=np.array([0], dtype=int))\n", + " f.create_dataset(\"Num_of_files\", data=np.array([1], dtype=int))\n", + " f.create_dataset(\n", + " \"Num_of_particles_in_groups\",\n", + " data=np.array([n_g + n_dm + n_s + n_bh], dtype=int),\n", + " )\n", + " f.create_dataset(\n", + " \"Particle_IDs\",\n", + " data=np.concatenate(\n", + " (\n", + " np.arange(n_g_b, n_g_all, dtype=int),\n", + " np.arange(n_g_all + n_dm_b, n_g_all + n_dm_all, dtype=int),\n", + " np.arange(n_g_all + n_dm_all, n_g_all + n_dm_all + n_s, dtype=int),\n", + " np.arange(\n", + " n_g_all + n_dm_all + n_s,\n", + " n_g_all + n_dm_all + n_s + n_bh,\n", + " dtype=int,\n", + " ),\n", + " )\n", + " ),\n", + " )\n", + " f.create_dataset(\n", + " \"Total_num_of_particles_in_all_groups\",\n", + " data=np.array([n_g + n_dm + n_s + n_bh], dtype=int),\n", + " )\n", + " with h5py.File(f\"{toyvr_filebase}.catalog_particles.unbound\", \"w\") as f:\n", + " f.create_dataset(\"File_id\", data=np.array([0], dtype=int))\n", + " f.create_dataset(\"Num_of_files\", data=np.array([1], dtype=int))\n", + " f.create_dataset(\n", + " \"Num_of_particles_in_groups\", data=np.array([n_g_b + n_dm_b], dtype=int)\n", + " )\n", + " f.create_dataset(\n", + " \"Particle_IDs\",\n", + " data=np.concatenate(\n", + " (\n", + " np.arange(n_g_b, dtype=int),\n", + " np.arange(n_g_all, n_g_all + n_dm_b, dtype=int),\n", + " )\n", + " ),\n", + " )\n", + " f.create_dataset(\n", + " \"Total_num_of_particles_in_all_groups\",\n", + " data=np.array([n_g_b + n_dm_b], dtype=int),\n", + " )\n", + " with h5py.File(f\"{toyvr_filebase}.catalog_parttypes\", \"w\") as f:\n", + " f.create_dataset(\"File_id\", data=np.array([0], dtype=int))\n", + " f.create_dataset(\"Num_of_files\", data=np.array([1], dtype=int))\n", + " f.create_dataset(\n", + " \"Num_of_particles_in_groups\",\n", + " data=np.array([n_g + n_dm, +n_s + n_bh], dtype=int),\n", + " )\n", + " f.create_dataset(\n", + " \"Particle_types\",\n", + " data=np.concatenate(\n", + " (\n", + " 0 * np.ones(n_g, dtype=int),\n", + " 1 * np.ones(n_dm, dtype=int),\n", + " 4 * np.ones(n_s, dtype=int),\n", + " 5 * np.ones(n_bh, dtype=int),\n", + " )\n", + " ),\n", + " )\n", + " f.create_dataset(\n", + " \"Total_num_of_particles_in_all_groups\",\n", + " data=np.array([n_g + n_dm + n_s + n_bh], dtype=int),\n", + " )\n", + " with h5py.File(f\"{toyvr_filebase}.catalog_parttypes.unbound\", \"w\") as f:\n", + " f.create_dataset(\"File_id\", data=np.array([0], dtype=int))\n", + " f.create_dataset(\"Num_of_files\", data=np.array([1], dtype=int))\n", + " f.create_dataset(\n", + " \"Num_of_particles_in_groups\", data=np.array([n_g_b + n_dm_b], dtype=int)\n", + " )\n", + " f.create_dataset(\n", + " \"Particle_types\",\n", + " data=np.concatenate(\n", + " (0 * np.ones(n_g_b, dtype=int), 1 * np.ones(n_dm_b, dtype=int))\n", + " ),\n", + " )\n", + " f.create_dataset(\n", + " \"Total_num_of_particles_in_all_groups\",\n", + " data=np.array([n_g_b + n_dm_b], dtype=int),\n", + " )\n", + " return\n", + "\n", + "\n", + "def remove_toyvr(filebase=toyvr_filebase):\n", + " os.remove(f\"{toyvr_filebase}.properties\")\n", + " os.remove(f\"{toyvr_filebase}.catalog_groups\")\n", + " os.remove(f\"{toyvr_filebase}.catalog_particles\")\n", + " os.remove(f\"{toyvr_filebase}.catalog_particles.unbound\")\n", + " os.remove(f\"{toyvr_filebase}.catalog_parttypes\")\n", + " os.remove(f\"{toyvr_filebase}.catalog_parttypes.unbound\")\n", + " return" + ], + "metadata": { + "id": "-GFlGjSSQ3L7" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "create_toysnap()\n", + "create_toyvr()" + ], + "metadata": { + "id": "4gpRhj7YSHHy" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#Start tutorial" + ], + "metadata": { + "id": "lM0bjUqJSNX1" + } + }, + { + "cell_type": "markdown", + "source": [ + "##Initial setup\n", + "\n", + "In this section we import required modules, and make a quick visualisation (using `swiftsimio`) of the snapshot where our galaxy lives." + ], + "metadata": { + "id": "dG7Vqg4peWpj" + } + }, + { + "cell_type": "markdown", + "source": [ + "First let's import the two basic pieces needed to set up a `SWIFTGalaxy`: the `SWIFTGalaxy` class itself, and a halo finder class from `swiftgalaxy`, in this case `Velociraptor`." + ], + "metadata": { + "id": "x3J6_uNofbMz" + } + }, + { + "cell_type": "code", + "source": [ + "from swiftgalaxy import SWIFTGalaxy, Velociraptor" + ], + "metadata": { + "id": "wAQ5muyfPk2h" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "We'll also import some `swiftsimio` and `matplotlib` things for visualisation purposes." + ], + "metadata": { + "id": "-ZQJQcqjepR6" + } + }, + { + "cell_type": "code", + "source": [ + "from swiftsimio import SWIFTDataset\n", + "from swiftsimio.visualisation.projection import project_gas, project_pixel_grid\n", + "from swiftsimio.visualisation.smoothing_length_generation import generate_smoothing_lengths # if not found try `from swiftsimio.visualisation import generate_smoothing_lengths`\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors" + ], + "metadata": { + "id": "DV3jcKNbeT1m" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Let's load up our snapshot file in a `SWIFTDataset` (from swiftsimio) so that we can have a quick look at the contents." + ], + "metadata": { + "id": "4zdbXSfzf5JE" + } + }, + { + "cell_type": "code", + "source": [ + "sd = SWIFTDataset(toysnap_filename)" + ], + "metadata": { + "id": "RumTT5-DSUKl" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "We can use the `swiftsimio` visualisation tools to make `x-y`, `y-z` and `x-z` projections of the snapshot, and plot them." + ], + "metadata": { + "id": "yIQ4SbPsgN6B" + } + }, + { + "cell_type": "code", + "source": [ + "boxsize = sd.metadata.boxsize\n", + "img_extent = [0, boxsize[0], 0, boxsize[0]]\n", + "box_centre = boxsize / 2\n", + "\n", + "mass_map_xy = project_gas(\n", + " sd,\n", + " resolution=256,\n", + " project=\"masses\",\n", + " parallel=True,\n", + ")\n", + "mass_map_xz = project_gas(\n", + " sd,\n", + " resolution=256,\n", + " project=\"masses\",\n", + " parallel=True,\n", + " rotation_matrix=[[0, 0, 1], [0, 1, 0], [-1, 0, 0]],\n", + " rotation_center=box_centre,\n", + ")\n", + "mass_map_yz = project_gas(\n", + " sd,\n", + " resolution=256,\n", + " project=\"masses\",\n", + " parallel=True,\n", + " rotation_matrix=[[1, 0, 0], [0, 0, 1], [0, -1, 0]],\n", + " rotation_center=box_centre,\n", + ")\n", + "for mass_map in mass_map_xy, mass_map_xz, mass_map_yz:\n", + " mass_map.convert_to_units(u.Msun / u.kpc ** 2)\n", + "\n", + "fig = plt.figure(1, figsize=(10, 3))\n", + "sp1, sp2, sp3 = [fig.add_subplot(1, 3, i) for i in range(1, 4)]\n", + "sp1.imshow(\n", + " matplotlib.colors.LogNorm()(mass_map_xy.value),\n", + " cmap=\"viridis\",\n", + " extent=img_extent,\n", + " origin='lower',\n", + ")\n", + "sp1.set_xlabel(f'x [{boxsize.units}]')\n", + "sp1.set_ylabel(f'y [{boxsize.units}]')\n", + "sp2.imshow(\n", + " matplotlib.colors.LogNorm()(mass_map_xz.value),\n", + " cmap=\"viridis\",\n", + " extent=img_extent,\n", + " origin='lower',\n", + ")\n", + "sp2.set_xlabel(f'x [{boxsize.units}]')\n", + "sp2.set_ylabel(f'z [{boxsize.units}]')\n", + "sp3.imshow(\n", + " matplotlib.colors.LogNorm()(mass_map_yz.value),\n", + " cmap=\"viridis\",\n", + " extent=img_extent,\n", + " origin='lower',\n", + ")\n", + "sp3.set_xlabel(f'y [{boxsize.units}]')\n", + "sp3.set_ylabel(f'z [{boxsize.units}]')\n", + "fig.subplots_adjust(wspace=.25)\n", + "fig.suptitle(\"gas density\")" + ], + "metadata": { + "id": "Q17bQZLI5upG", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 353 + }, + "outputId": "b68a146a-caf8-4f65-9255-ef2f02437e13" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'gas density')" + ] + }, + "metadata": {}, + "execution_count": 8 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We can just barely make out a dot at (2, 2, 2) Mpc in the figure: the one galaxy in the snapshot.\n", + "\n", + "Let's also define a function accepting a `SWIFTGalaxy` that we can use below to quickly plot a visualisation of the galaxy." + ], + "metadata": { + "id": "13j7RMFJgS7Z" + } + }, + { + "cell_type": "code", + "source": [ + "def myvis(sg):\n", + " disc_radius = 15 * u.kpc\n", + " disc_region = [-disc_radius, disc_radius, -disc_radius, disc_radius]\n", + " halo_radius = 200 * u.kpc\n", + " halo_region = [-halo_radius, halo_radius, -halo_radius, halo_radius]\n", + " gas_map = project_gas(\n", + " sg,\n", + " resolution=256,\n", + " project=\"masses\",\n", + " parallel=True,\n", + " region=disc_region,\n", + " )\n", + " dm_map = project_pixel_grid(\n", + " data=sg.dark_matter,\n", + " boxsize=sg.metadata.boxsize,\n", + " resolution=256,\n", + " project=\"masses\",\n", + " parallel=True,\n", + " region=halo_region,\n", + " )\n", + " star_map = project_pixel_grid(\n", + " data=sg.stars,\n", + " boxsize=sg.metadata.boxsize,\n", + " resolution=256,\n", + " project=\"masses\",\n", + " parallel=True,\n", + " region=disc_region,\n", + " )\n", + "\n", + " fig = plt.figure(1, figsize=(10, 3))\n", + " sp1, sp2, sp3 = [fig.add_subplot(1, 3, i) for i in range(1, 4)]\n", + " sp1.imshow(\n", + " matplotlib.colors.LogNorm()(gas_map.value),\n", + " cmap=\"viridis\",\n", + " extent=disc_region\n", + " )\n", + " sp1.set_xlabel(f\"x' [{disc_radius.units}]\")\n", + " sp1.set_ylabel(f\"y' [{disc_radius.units}]\")\n", + " sp1.text(.9, .9, 'gas', ha='right', va='top', transform=sp1.transAxes)\n", + " sp2.imshow(\n", + " matplotlib.colors.LogNorm()(dm_map),\n", + " cmap=\"inferno\",\n", + " extent=halo_region,\n", + " )\n", + " sp2.plot(\n", + " [-disc_radius, -disc_radius, disc_radius, disc_radius, -disc_radius],\n", + " [-disc_radius, disc_radius, disc_radius, -disc_radius, -disc_radius],\n", + " '-k'\n", + " )\n", + " sp2.set_xlabel(f\"x' [{halo_radius.units}]\")\n", + " sp2.set_ylabel(f\"y' [{halo_radius.units}]\")\n", + " sp2.text(.9, .9, 'DM', ha='right', va='top', transform=sp2.transAxes)\n", + " sp3.imshow(\n", + " matplotlib.colors.LogNorm()(star_map),\n", + " cmap=\"magma\",\n", + " extent=disc_region,\n", + " )\n", + " sp3.set_xlabel(f\"x' [{disc_radius.units}]\")\n", + " sp3.set_ylabel(f\"y' [{disc_radius.units}]\")\n", + " sp3.text(.9, .9, 'stars', ha='right', va='top', transform=sp3.transAxes)\n", + " fig.subplots_adjust(wspace=.4)" + ], + "metadata": { + "id": "xGJM6dkJ2cqb" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## `SWIFTGalaxy` creation\n", + "\n", + "Creating a `SWIFTGalaxy` is simple: we just provide the snapshot filename, and an initialised halo finder class. In this case, `Velociraptor` simply needs to know the location of the output files to read, and the position of the galaxy we're interested in within the catalogue." + ], + "metadata": { + "id": "dSCZ0dRbg7y-" + } + }, + { + "cell_type": "code", + "source": [ + "sg = SWIFTGalaxy(toysnap_filename, Velociraptor(toyvr_filebase, halo_index=0))" + ], + "metadata": { + "id": "sirZjSw-3YV8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Before visualising the galaxy, we need to initialise some smoothing lengths for the particles (this is taken from the `swiftsimio` visualisation documentation)." + ], + "metadata": { + "id": "kzHuITcEhaBP" + } + }, + { + "cell_type": "code", + "source": [ + "from swiftsimio.objects import cosmo_array, cosmo_factor, a\n", + "\n", + "for ptype in \"gas\", \"dark_matter\", \"stars\":\n", + " getattr(sg, ptype).smoothing_length = generate_smoothing_lengths(\n", + " getattr(sg, ptype).coordinates + sg.centre,\n", + " sg.metadata.boxsize,\n", + " kernel_gamma=1.8,\n", + " neighbours=57,\n", + " speedup_fac=2,\n", + " dimension=3,\n", + " )" + ], + "metadata": { + "id": "Sv4KD0dWhi9-" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now we can run our visualisation function to have a look at the galaxy:" + ], + "metadata": { + "id": "2i9DJaS_hq8J" + } + }, + { + "cell_type": "code", + "source": [ + "myvis(sg)" + ], + "metadata": { + "id": "SA_jttQchtoZ", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 289 + }, + "outputId": "d1ab4477-022f-477f-b75e-19815d49a2aa" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##Overview of features" + ], + "metadata": { + "id": "0GAuYvuWh1JQ" + } + }, + { + "cell_type": "markdown", + "source": [ + "###`SWIFTDataset` features\n", + "\n", + "`SWIFTGalaxy` is built upon `swiftsimio` and takes advantage of all the features of the `SWIFTDataset` class, notably \"lazy loading\" of particle data. A `SWIFTGalaxy` inherits from the `SWIFTDataset` class, and should therefore in principle be accepted by functions expecting a `SWIFTDataset` (in practice there still some work to do on this front, e.g. some adjustments needed for some functions from the `swiftsimio.visualisation` module)." + ], + "metadata": { + "id": "Aa1A6Bq6g9yK" + } + }, + { + "cell_type": "markdown", + "source": [ + "###Automatic recentering\n", + "\n", + "When the `SWIFTGalaxy` is created, the coordinates are automatically centred on the position and velocity (according to the halo finder) of the galaxy of interest. In case there are multiple centres defined, as with `Velociraptor` (minimum potential, centre of mass, etc.), which one to use is configurable. The automatic recentering can also be disabled entirely, or the centre of another `SWIFTGalaxy` can be used (can be useful e.g. for putting a satellite in the coordinate frame of its central)." + ], + "metadata": { + "id": "PALAhf8HfyjF" + } + }, + { + "cell_type": "markdown", + "source": [ + "###Rotation & other coordinate transformations\n", + "\n", + "The particles in a `SWIFTGalaxy` always occupy a common coordinate frame, such that e.g. all particles rotate together. Rotations, translations (in position) and boosts (translations in velocity) are all supported. As an example, we can rotate our galaxy. To specify a rotation, the [`scipy.spatial.transform.Rotation`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.from_euler.html) class is used. This accepts rotation matrices, Euler angles, and more." + ], + "metadata": { + "id": "buiUhWPkiAlX" + } + }, + { + "cell_type": "code", + "source": [ + "from scipy.spatial.transform import Rotation\n", + "sg.rotate(Rotation.from_euler('xy', [60, 30], degrees=True))\n", + "myvis(sg)" + ], + "metadata": { + "id": "tDwKMNazLqe8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 289 + }, + "outputId": "58c0ca7d-6a84-4942-f266-2da08e327461" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Let's reverse the rotation before continuing with the examples." + ], + "metadata": { + "id": "Vvzw9MA5ifg4" + } + }, + { + "cell_type": "code", + "source": [ + "sg.rotate(Rotation.from_euler('yx', [-30, -60], degrees=True))" + ], + "metadata": { + "id": "dsD38Zreiftx" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Additional coordinates\n", + "\n", + "When working with a galaxy it is often convenient to work in spherical or cylindircal coordinates. These are built into a `SWIFTGalaxy` and are evaluated lazily as and when needed. Their consistency when the coordinate frame is transformed is also ensured. As an illustrative example, we can plot the azimuthal velocity against the radial velocity - the figure in which the Gaia-Enceladus (or \"sausage\") structure in the Milky Way was identified. Of course our crude model galaxy won't have any such interesting structure - indeed the disc isn't even actually rotating!" + ], + "metadata": { + "id": "VG4T2Xh5h84P" + } + }, + { + "cell_type": "code", + "source": [ + "plt.plot(\n", + " sg.stars.spherical_velocities.r.to_value(u.km / u.s),\n", + " sg.stars.spherical_velocities.phi.to_value(u.km / u.s),\n", + " \".k\",\n", + " rasterized=True\n", + ")\n", + "plt.xlabel(r\"$v_r$ [km/s]\")\n", + "plt.ylabel(r\"$v_\\phi$ [km/s]\")\n", + "plt.gca().set_aspect(\"equal\")" + ], + "metadata": { + "id": "GXLgaWpGjSLp", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 452 + }, + "outputId": "bfd3dfc8-606f-4174-8d3f-8428857a2cd5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###Particle masking\n", + "\n", + "`SWIFTGalaxy` enables selecting subsets of particles in intuitive, syntactically simply ways (beyond what's supported by `swiftsimio`, actually). As an example, we can chop a hole out of the centre of the stellar and gas discs:" + ], + "metadata": { + "id": "DTz_il-Bkt6h" + } + }, + { + "cell_type": "code", + "source": [ + "from swiftgalaxy import MaskCollection\n", + "\n", + "sg.mask_particles(\n", + " MaskCollection(\n", + " gas=sg.gas.cylindrical_coordinates.R > 2 * u.kpc,\n", + " stars=sg.stars.cylindrical_coordinates.R > 2 * u.kpc,\n", + " )\n", + ")\n", + "myvis(sg)" + ], + "metadata": { + "id": "gmwfMmUlmeL3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 344 + }, + "outputId": "5c43219d-74bf-4b25-b175-133104987eda" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/swiftsimio/objects.py:261: RuntimeWarning: Mixing ufunc arguments with and without cosmo_factors, continuing assuming provided cosmo_factor ((a**2)**0.5 at a=1.0) for all arguments.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "The mask applies to all particle properties, e.g. if we next loaded the gas temperatures they would be masked to match. It's also possible to obtain masked particle datasets (copies!) with `sg.gas[...]`, amongst other options." + ], + "metadata": { + "id": "q72v0mVknOIS" + } + }, + { + "cell_type": "markdown", + "source": [ + "###Halo finders & integrated properties\n", + "\n", + "For now only `Velociraptor` is supported, but I plan on adding `SOAP` and possibly others on request.\n", + "\n", + "The [velociraptor-python](https://velociraptor-python.readthedocs.io/en/latest/) halo catalogue is exposed through the `halo_finder` attribute of a `SWIFTGalaxy`, and only the properties of the particular galaxy of interest are loaded. This makes accessing integrated properties particularly convenient:" + ], + "metadata": { + "id": "nC_0PN2Unszw" + } + }, + { + "cell_type": "code", + "source": [ + "print(sg.halo_finder)\n", + "print(sg.halo_finder.radii)\n", + "print('R200c =', sg.halo_finder.radii.r_200crit.to(u.kpc))" + ], + "metadata": { + "id": "OqQvCVd4oXIS", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "0a1639fd-5175-4fcc-f9e3-f34f95aa1664" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Masked velociraptor catalogue at toyvr.properties. Contains the following field collections: snia_rates, metallicity, ids, energies, stellar_age, spherical_overdensities, rotational_support, star_formation_rate, masses, eigenvectors, radii, temperature, veldisp, structure_type, velocities, positions, concentration, rvmax_quantities, angular_momentum, projected_apertures, apertures, element_mass_fractions, dust_mass_fractions, number, hydrogen_phase_fractions, black_hole_masses, stellar_birth_densities, snii_thermal_feedback_densities, species_fractions, gas_hydrogen_species_masses, gas_H_and_He_masses, gas_diffuse_element_masses, dust_masses_from_table, dust_masses, stellar_luminosities, cold_dense_gas_properties, log_element_ratios_times_masses, lin_element_ratios_times_masses, element_masses_in_stars, fail_all\n", + "Contains the following fields: r_200crit, r_200mean, r_bn98, r_size, rmax, rvir\n", + "R200c = 300.0 kpc\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###Documentation\n", + "\n", + "Detailed documentation for `swiftgalaxy` is [hosted on readthedocs](https://swiftgalaxy.readthedocs.io/en/latest/halo_finders/index.html)." + ], + "metadata": { + "id": "B9_tNuKYo4KO" + } + }, + { + "cell_type": "markdown", + "source": [ + "#Cleanup sample snapshot and halo finder output" + ], + "metadata": { + "id": "g8t7YNCNSVt1" + } + }, + { + "cell_type": "code", + "source": [ + "remove_toysnap()\n", + "remove_toyvr()" + ], + "metadata": { + "id": "zKD8EBJDSaov" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/examples/README.rst b/examples/README.rst new file mode 100644 index 0000000..3c91d8e --- /dev/null +++ b/examples/README.rst @@ -0,0 +1,8 @@ +Examples +======== + +You can view the example notebooks online using nbviewer_. + +.. _nbviewer: https://nbviewer.jupyter.org/ + +-