From c154718bbd8209dcf605e734c6125e09e87b2a1e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maximilian=20N=C3=B6the?= Date: Wed, 5 Jun 2019 16:38:17 +0200 Subject: [PATCH] Coordinates notebook pr (#1075) * Notebook created for the LST bootcamp. * Camera calibrator corrected. * Notebook modified to take into account major coordinates PR. * Frames created in an array (more compact with many telescopes). * Fix coordinates notebook * Move coordinates notebook to tutorials * Remove unnecessary Angle * Add notebook to index.rst --- docs/tutorials/coordinates_example.ipynb | 667 +++++++++++++++++++++++ docs/tutorials/index.rst | 3 +- 2 files changed, 669 insertions(+), 1 deletion(-) create mode 100644 docs/tutorials/coordinates_example.ipynb diff --git a/docs/tutorials/coordinates_example.ipynb b/docs/tutorials/coordinates_example.ipynb new file mode 100644 index 00000000000..02143274361 --- /dev/null +++ b/docs/tutorials/coordinates_example.ipynb @@ -0,0 +1,667 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Coordinates usage in ctapipe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "import astropy.units as u\n", + "import copy\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from ctapipe.io import event_source\n", + "from ctapipe.calib import CameraCalibrator\n", + "from ctapipe.utils import get_dataset_path\n", + "\n", + "from ctapipe.visualization import ArrayDisplay\n", + "\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from astropy.coordinates import SkyCoord, AltAz\n", + "\n", + "from ctapipe.coordinates import (\n", + " GroundFrame,\n", + " TiltedGroundFrame,\n", + " NominalFrame,\n", + " TelescopeFrame,\n", + " CameraFrame,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# make plots and fonts larger\n", + "plt.rcParams['figure.figsize'] = (12, 8)\n", + "plt.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Open test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false, + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "filename = get_dataset_path(\"gamma_test_large.simtel.gz\")\n", + "source = event_source(filename, max_events=4)\n", + "\n", + "events = [copy.deepcopy(event) for event in source]\n", + "event = events[3]\n", + "\n", + "layout = set(event.inst.subarray.tel_ids) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Choose event with LST" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This ensures that the telescope is not \"parked\" (as it would be in an event where it is not triggered) but is actually pointing to a source." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "print(f'Telescope with data: {event.r0.tels_with_data}')\n", + "tel_id = 2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## AltAz\n", + "\n", + "See [Astropy Docs on AltAz](http://docs.astropy.org/en/stable/api/astropy.coordinates.AltAz.html). \n", + "\n", + "Pointing direction of telescopes or the origin of a simulated shower are described in the `AltAz` frame.\n", + "This is a local, angular coordinate frame, with angles `altitude` and `azimuth`.\n", + "Altitude is the measured from the Horizon (0°) to the Zenith (90°).\n", + "For the azimuth, there are different conventions. In Astropy und thus ctapipe, Azimuth is oriented East of North (i.e., N=0°, E=90°)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from astropy.time import Time\n", + "from astropy.coordinates import EarthLocation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "obstime = Time('2013-11-01T03:00')\n", + "location = EarthLocation.of_site('Roque de los Muchachos')\n", + "\n", + "altaz = AltAz(location=location, obstime=obstime)\n", + "\n", + "array_pointing = SkyCoord(\n", + " alt=event.mcheader.run_array_direction[1],\n", + " az=event.mcheader.run_array_direction[0], \n", + " frame=altaz,\n", + ")\n", + "\n", + "print(array_pointing)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## CameraFrame\n", + "\n", + "Camera coordinate frame.\n", + "\n", + "The camera frame is a 2d cartesian frame, describing position of objects in the focal plane of the telescope.\n", + "\n", + "The frame is defined as in H.E.S.S., starting at the horizon, the telescope is pointed to magnetic north in azimuth and then up to zenith.\n", + "\n", + "Now, x points north and y points west, so in this orientation, the camera coordinates line up with the CORSIKA ground coordinate system.\n", + "\n", + "MAGIC and FACT use a different camera coordinate system: Standing at the dish, looking at the camera, x points right, y points up.\n", + "To transform MAGIC/FACT to ctapipe, do x' = -y, y' = -x.\n", + "\n", + "**Typical usage**: Position of pixels in the focal plane." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "camera = event.inst.subarray.tel[tel_id].camera\n", + "pix_x = camera.pix_x \n", + "pix_y = camera.pix_y\n", + "focal_length = event.inst.subarray.tel[tel_id].optics.equivalent_focal_length " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "telescope_pointing = SkyCoord(\n", + " alt=event.mc.tel[tel_id].altitude_raw * u.rad, \n", + " az=event.mc.tel[tel_id].azimuth_raw * u.rad, \n", + " frame=altaz,\n", + ")\n", + "\n", + "camera_frame = CameraFrame(\n", + " focal_length=focal_length,\n", + " rotation=0 * u.deg,\n", + " telescope_pointing=telescope_pointing,\n", + ")\n", + "\n", + "cam_coords = SkyCoord(x=pix_x, y=pix_y, frame=camera_frame)\n", + "\n", + "print(cam_coords)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false, + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "plt.scatter(cam_coords.x, cam_coords.y)\n", + "plt.title(f'Camera type: {camera.cam_id}')\n", + "plt.xlabel(f'x / {cam_coords.x.unit}')\n", + "plt.ylabel(f'y / {cam_coords.y.unit}')\n", + "plt.axis('square');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The implementation of the coordinate system with astropy makes it easier to use time of the observation and location of the observing site, to understand, for example which stars are visible during a certain night and how they might be visible in the camera.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from ctapipe.visualization import CameraDisplay\n", + "from ctapipe.instrument import CameraGeometry\n", + "\n", + "location = EarthLocation.of_site('Roque de los Muchachos')\n", + "obstime = Time('2018-11-01T04:00')\n", + "\n", + "crab = SkyCoord.from_name(\"crab nebula\")\n", + "\n", + "altaz = AltAz(location=location, obstime=obstime)\n", + "\n", + "pointing = crab.transform_to(altaz)\n", + "\n", + "camera_frame = CameraFrame(\n", + " telescope_pointing=pointing,\n", + " focal_length=focal_length,\n", + " obstime=obstime,\n", + " location=location,\n", + ")\n", + "\n", + "cam = CameraGeometry.from_name('LSTCam')\n", + "fig, ax = plt.subplots()\n", + "display = CameraDisplay(cam, ax=ax)\n", + "\n", + "ax.set_title(\n", + " f'La Palma, {obstime}, az={pointing.az.deg:.1f}°, zenith={pointing.zen.deg:.1f}°, camera={camera.cam_id}'\n", + ")\n", + "\n", + "for i, name in enumerate(['crab nebula', 'o tau', 'zet tau']):\n", + " star = SkyCoord.from_name(name)\n", + " star_cam = star.transform_to(camera_frame)\n", + "\n", + " x = star_cam.x.to_value(u.m)\n", + " y = star_cam.y.to_value(u.m)\n", + "\n", + " ax.plot(x, y, marker='*', color=f'C{i}')\n", + " ax.annotate(\n", + " s=name, xy=(x, y), xytext=(5, 5),\n", + " textcoords='offset points', color=f'C{i}',\n", + " )\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## TelescopeFrame\n", + "\n", + "Telescope coordinate frame.\n", + "A `Frame` using a `UnitSphericalRepresentation`.\n", + "\n", + "This is basically the same as a `HorizonCoordinate`, but the origin is at the telescope's pointing direction.\n", + "This is what astropy calls a `SkyOffsetFrame`.\n", + "\n", + "Pointing corrections should applied to the transformation between this frame and the camera frame." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "telescope_frame = TelescopeFrame(telescope_pointing=telescope_pointing)\n", + "telescope_coords = cam_coords.transform_to(telescope_frame)\n", + "print(telescope_coords)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "wrap_angle = telescope_pointing.az + 180* u.deg\n", + "\n", + "plt.axis('equal')\n", + "plt.scatter(\n", + " telescope_coords.altaz.az.wrap_at(wrap_angle).deg, \n", + " telescope_coords.altaz.alt.deg\n", + ")\n", + "\n", + "plt.title(f'Camera type: {camera.cam_id}')\n", + "plt.xlabel('x / {}'.format(telescope_coords.altaz.az.unit))\n", + "plt.ylabel('y / {}'.format(telescope_coords.altaz.alt.unit))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## NominalFrame\n", + "\n", + "Nominal coordinate frame.\n", + "A Frame using a `UnitSphericalRepresentation`.\n", + "This is basically the same as a `HorizonCoordinate`, but the\n", + "origin is at an arbitray position in the sky.\n", + "This is what astropy calls a `SkyOffsetFrame`\n", + "If the telescopes are in divergent pointing, this `Frame` can be\n", + "used to transform to a common system.\n", + "- 2D reconstruction (`HillasIntersector`) is performed in this frame \n", + "- 3D reconstruction (`HillasReconstructor`) doesn't need this frame\n", + "\n", + "NOTE: here I'm explicitely transforming:\n", + "\n", + "**Camera --> Telescope --> Nominal**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Let's play a bit with 3 MSTs with divergent pointing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "location = EarthLocation.of_site('Roque de los Muchachos')\n", + "obstime = Time('2018-11-01T02:00')\n", + "\n", + "crab = SkyCoord.from_name(\"crab nebula\")\n", + "\n", + "altaz = AltAz(location=location, obstime=obstime)\n", + "\n", + "array_pointing = crab.transform_to(altaz)\n", + "\n", + "tel_pointings = SkyCoord(\n", + " alt=array_pointing.alt + [1, -1, -1] * u.deg, \n", + " az=array_pointing.az + [0, -2, +2] * u.deg, \n", + " frame=altaz,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "camera_frames = CameraFrame(\n", + " telescope_pointing=tel_pointings, # multiple pointings, so we get multiple frames\n", + " focal_length=focal_length,\n", + " obstime=obstime,\n", + " location=location,\n", + ")\n", + "\n", + "nom_frame = NominalFrame(origin=array_pointing)\n", + "\n", + "cam_coords_1 = SkyCoord(x=pix_x, y=pix_y, frame=camera_frames[0])\n", + "cam_coords_2 = SkyCoord(x=pix_x, y=pix_y, frame=camera_frames[1])\n", + "cam_coords_3 = SkyCoord(x=pix_x, y=pix_y, frame=camera_frames[2])\n", + "\n", + "nom_coords_1 = cam_coords_1.transform_to(nom_frame)#.transform_to(horizon_frame)\n", + "nom_coords_2 = cam_coords_2.transform_to(nom_frame)#.transform_to(horizon_frame)\n", + "nom_coords_3 = cam_coords_3.transform_to(nom_frame)#.transform_to(horizon_frame)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the transformation is done up to the horizon frame then the coordinates are just called with `coord.az` and `coord.alt`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false, + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(15, 10))\n", + "\n", + "wrap_angle = array_pointing.az + 180* u.deg\n", + "\n", + "for i, coord in enumerate([nom_coords_1, nom_coords_2, nom_coords_3], start = 1):\n", + " ax.scatter(\n", + " x=coord.altaz.az.wrap_at(wrap_angle).deg,\n", + " y=coord.altaz.alt.deg,\n", + " label=str(i),\n", + " s=30,\n", + " alpha=0.15,\n", + " )\n", + " \n", + "ax.scatter(nom_frame.origin.az, \n", + " nom_frame.origin.alt,\n", + " label = \"nominal center\",\n", + " c = \"red\",\n", + " marker = '*',\n", + " s = 500\n", + " ) \n", + "\n", + "for i, name in enumerate(['crab nebula', 'o tau', 'zet tau']):\n", + " star = SkyCoord.from_name(name)\n", + "\n", + " for j, camera_frame in enumerate([camera_frames[0], camera_frames[1], camera_frames[2]]):\n", + " star_cam = star.transform_to(camera_frame)\n", + " altaz_Star = star_cam.transform_to(nom_frame)\n", + " az_plt = altaz_Star.altaz.az.wrap_at(wrap_angle)\n", + " alt_plt = altaz_Star.altaz.alt\n", + " \n", + " ax.scatter(\n", + " x=az_plt, y=alt_plt,\n", + " marker='x', s=30,\n", + " color=f'C{j}',\n", + " )\n", + "\n", + " ax.annotate(\n", + " s=f\"tel #{j}, src: {name}\", xy=(az_plt.value, alt_plt.value), xytext=(5, 15*(j-1)),\n", + " textcoords='offset points', color=f'C{j}',\n", + " )\n", + "\n", + "ax.set_xlabel(f'az / {nom_frame.origin.az.unit}')\n", + "ax.set_ylabel(f'alt / {nom_frame.origin.alt.unit}')\n", + " \n", + "ax.legend(fontsize=\"small\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## GroundFrame\n", + "\n", + "\n", + "Ground coordinate frame. The ground coordinate frame is a simple\n", + " cartesian frame describing the 3 dimensional position of objects\n", + " compared to the array ground level in relation to the nomial\n", + " centre of the array. Typically this frame will be used for\n", + " describing the position on telescopes and equipment\n", + " \n", + "**Typical usage**: positions of telescopes on the ground (x, y, z)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "event.inst.subarray.peek()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "In case a layout is selected, the following line will produce a different output from the picture above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "event.inst.subarray.select_subarray(\"Prod3b layout\", layout).peek()" + ] + }, + { + "attachments": { + "ground_frame.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![ground_frame.png](attachment:ground_frame.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this image all the telescope from the `gamma_test.simtel.gz` file are plotted as spheres in the GroundFrame." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## TiltedGroundFrame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tilted ground coordinate frame. \n", + "\n", + "The tilted ground coordinate frame is a cartesian system describing the 2 dimensional projected positions of objects in a tilted plane described by pointing_direction. The plane is rotated along the z_axis by the azimuth of the `pointing_direction` and then it is inclined with an angle equal to the zenith angle of the `pointing_direction`.\n", + "\n", + "This frame is used for the reconstruction of the shower core position." + ] + }, + { + "attachments": { + "ground_tilted_frame.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![ground_tilted_frame.png](attachment:ground_tilted_frame.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This image picture both the telescopes in the GroundFrame (red) and in the TiltedGroundFrame (green) are displayed: in this case since the azimuth of the `pointing_direction` is 0 degrees, then the plane is just tilted according to the zenith angle. \n", + "\n", + "For playing with these and with more 3D models of the telescopes themselves, have a look at the [CREED_VTK](https://github.com/thomasgas/CREED_VTK) library. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/tutorials/index.rst b/docs/tutorials/index.rst index 44290b0914d..475ff06698d 100644 --- a/docs/tutorials/index.rst +++ b/docs/tutorials/index.rst @@ -7,8 +7,9 @@ Tutorials .. toctree:: ctapipe_handson + coordinates_example raw_data_exploration calibrated_data_exploration theta_square lst_analysis_bootcamp_2018 - \ No newline at end of file +