{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Some generic functions and classes" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from math import pi, sqrt\n", "\n", "def deg2rad(deg):\n", " return (deg/180.0)*pi\n", "\n", "def rad2deg(rad):\n", " return (rad/pi)*180\n", "\n", "def posrad(rad):\n", " while rad<0:\n", " rad += 2*pi\n", " while rad>2*pi:\n", " rad -= 2*pi\n", " return(rad)\n", "\n", "def rad2hour(rad):\n", " return (posrad(rad)/2/pi)*24\n", "\n", "# Compute overlapping interval of two intervals (in radians). Seems to work, but probably the wrong approach \n", "# ends up being really complicated later\n", "\n", "def intervalOverlap(rise1, rise2):\n", " # If source never rises at either antenna, it won't rise for baseline\n", " if rise1[0]==None or rise2[0]==None: \n", " return([None, None])\n", " \n", " # Do the interval comparision - complicated because of 24hr (2wrapping\n", " if rise1[0]rise1[1] and rise2[0]rise1[1] and rise2[1]rise2[1] and rise1[0]rise2[1] and rise1[1] rise1[0] and rise2[0] < rise1[0]:\n", " return([rise1[0],rise2[1],rise2[0],rise1[1]])\n", " else: \n", " return([max(rise1[0],rise2[0]), min(rise1[1],rise2[1])])\n", "\n", " \n", "class Cartesian:\n", " def __init__(self, x, y, z):\n", " self.x = x\n", " self.y = y\n", " self.z = z\n", " \n", " def length(self):\n", " return sqrt(self.x**2 + self.y**2 + self.z**2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simple Class for a Telescope" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "from math import pi, cos, sin, acos, asin, atan2, floor\n", "\n", "class Telescope:\n", " def __init__(self, name, longitude, latitude, el_limit, SEFD):\n", " \n", " self.name = name\n", " self.longitude = deg2rad(longitude)\n", " self.latitude = deg2rad(latitude)\n", " self.el_limit = deg2rad(el_limit)\n", " self.sefd = SEFD # Jy\n", " self.maxBandwidth = 128 * 1e6 # MHz\n", " self.rise = None\n", " self.set = None\n", " \n", " def __str__(self):\n", " return \"{0}: {1:.1f} {2:.2f} {3:.1f}\".format(\n", " self.name, rad2deg(self.longitude), rad2deg(self.latitude), rad2deg(self.el_limit))\n", "\n", " # Calculate the rise and set time for the source, and set the class \"rise\" and \"set\" values in the object\n", " def calcrise(self, ra, dec): # Return GST rise and set for a source\n", " z_limit = pi/2-self.el_limit; # Zenith limit\n", "\n", " # Does the source ever rises \n", " z = acos(sin(self.latitude)*sin(dec) + cos(self.latitude)*cos(dec)) # Highest point\n", " if (z > z_limit): \n", " self.rise = None\n", " self.set = None\n", " return\n", " \n", " # or is circumpolar\n", " z = acos(sin(self.latitude)*sin(dec) - cos(self.latitude)*cos(dec)) # Lowest point\n", " if (zself.rise and gstself.rise: # Wrapped case\n", " return True\n", " else: \n", " return False\n", " \n", " # Return a list of times when the source is above the elevation limit, with a fixed step size\n", " def upTimes(self, RA, Dec, step):\n", " # RA Radians\n", " # Dec Radians\n", " # step Step size for GST time calculation *in radians*\n", " \n", " allgst = [x*step for x in range(floor(2*pi/step))]\n", " self.calcrise(RA, Dec)\n", " return [gst for gst in allgst if (self.isUp(gst))]\n", "\n", " # Return the 3D cartesian posiiton of the telescope, in m\n", " def getCartesian(self):\n", " R_EARTH = 6378.137e3\n", " phi = pi/2 - self.latitude\n", "\n", " x = R_EARTH * sin(phi) * cos(self.longitude)\n", " y = R_EARTH * sin(phi) * sin(self.longitude)\n", " z = R_EARTH * cos(phi)\n", "\n", " return (Cartesian(x,y,z))\n", " \n", " # Returns the AzEl of a source at (RA, Dec) , given the passed GST\n", " def AzEl(self, RA, Dec, gst): \n", " lst = posrad(gst + self.longitude)\n", " ha = posrad(lst-RA)\n", " sphi = sin(self.latitude)\n", " cphi = cos(self.latitude)\n", " sha = sin(ha)\n", " cha = cos(ha)\n", " sdec = sin(Dec)\n", " cdec = cos(Dec)\n", " az = atan2(-sha,-cha*sphi+sdec*cphi/cdec)\n", " el= asin(cha*cdec*cphi + sdec*sphi)\n", " \n", " return(az, el)\n", " \n", " # Return two Lists (Az and El) values, for the given set of GST values (passed as a list)\n", " def calcAzEl(self, RA, Dec, gsts):\n", " Az = []\n", " El = []\n", " for gst in gsts:\n", " (Az1, El1) = self.AzEl(RA, Dec, gst)\n", " Az.append(Az1)\n", " El.append(El1)\n", " return(Az, El)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simple Class for Baseline" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "class Baseline:\n", " C = 299792458;\n", " \n", " def __init__(self, ant1, ant2):\n", " self.ant1 = ant1\n", " self.ant2 = ant2\n", "\n", " self.name = ant1.name+\"->\"+ant2.name\n", " self.xyz1 = ant1.getCartesian()\n", " self.xyz2 = ant2.getCartesian()\n", " self.baseline = Cartesian(self.xyz1.x-self.xyz2.x,self.xyz1.y-self.xyz2.y,self.xyz1.z-self.xyz2.z)\n", " self.length = self.baseline.length()\n", " self.gsts = None # List of times souce is up on this baseline\n", " self.u = None\n", " self.v = None\n", " \n", " # Calculate times when source is visible to both telescopes. Set object .gst value for later functions to use\n", " def calcUp(self, RA, Dec, step):\n", " self.ant1.calcrise(RA, Dec)\n", " self.ant2.calcrise(RA, Dec)\n", " \n", " allgst = [x*step for x in range(floor(2*pi/step))] # 24 hours\n", " self.gst = np.array([gst for gst in allgst if (self.ant1.isUp(gst) and self.ant2.isUp(gst))])\n", " \n", " def uv(self, RA, Dec, gst, wavelength):\n", " ha = gst + self.ant1.longitude - RA\n", "\n", " ha = RA - gst # This calculation of Baseline hour angle needs to be checked\n", " sHa = sin(ha)\n", " cHa = cos(ha)\n", "\n", " sDec = sin(Dec)\n", " cDec = cos(Dec)\n", "\n", " u = (-self.baseline.x*sHa + self.baseline.y*cHa)/wavelength\n", " v = (-self.baseline.x*cHa*sDec - self.baseline.y*sHa*sDec + self.baseline.z*cDec)/wavelength\n", " \n", " return(u,v)\n", " \n", " def delay(self, RA, Dec, gst, wavelength):\n", " ha = gst + self.ant1.longitude - RA\n", "\n", " ha = RA - gst # This calculation of Baseline hour angle needs to be checked\n", " sHa = sin(ha)\n", " cHa = cos(ha)\n", " sDec = sin(Dec)\n", " cDec = cos(Dec)\n", " \n", " d = self.baseline.x*cHa*cDec + self.baseline.y*sHa*cDec + self.baseline.z*sDec\n", "\n", " return(d/self.C)\n", " \n", " \n", " # Calculate the UV values and set the object .u and .v values for the last set of GSTS\n", " def UVtrack(self, RA, Dec, gsts, wavelength):\n", " u = []\n", " v = []\n", " for gst in gsts:\n", " (thisu, thisv) = self.uv(RA, Dec, gst, wavelength)\n", " u.append(thisu)\n", " v.append(thisv)\n", " \n", " self.u = np.array(u)\n", " self.v = np.array(v)\n", " \n", " def sensitivity(self, integration, bandwidth, dualpol):\n", " if (dualpol):\n", " polfact = 2\n", " else:\n", " polfact = 1\n", "\n", " bandwidth = min(bandwidth, self.ant1.maxBandwidth, self.ant2.maxBandwidth)\n", " return sqrt(self.ant1.sefd * self.ant2.sefd) / (0.88*sqrt(polfact*bandwidth*integration))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Initialise arrays etc" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import numpy as np\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "\n", "antennas = []\n", "antennas.append(Telescope(\"ATCA\",149.57,-30.31,12,39))\n", "antennas.append(Telescope(\"Mopra\",149.07,-31.3,12,430))\n", "antennas.append(Telescope(\"Parkes\",148.26,-33,30,43))\n", "antennas.append(Telescope(\"Hobart\",147.44,-42.8,16,560))\n", "antennas.append(Telescope(\"Ceduna\",133.81,-31.87,10,600))\n", "\n", "\n", "Dec = deg2rad(-30)\n", "RA = deg2rad(0) # This actually should make no difference at all\n", "step = 1 # Inverval for calculations, in minutes\n", "freq = 8400; # MHz\n", "bandwidth = 64 # MHz\n", "calInt = 60 # Seconds\n", "\n", "step /= (60*24) # Convert to radians\n", "step *= 2*pi\n", "freq *= 1e6;\n", "bandwidth *= 1e6\n", "\n", "wavelength = 2.99792458e8/freq" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Create baselines" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "baselines = []\n", "for i in range(len(antennas)):\n", " for j in range(i+1, len(antennas)):\n", " baselines.append(Baseline(antennas[i], antennas[j]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### For each antenna calculate rise set " ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ATCA : 17.772886646434376 - 6.227113353565625\n", "Mopra : 17.732147030560004 - 6.267852969439996\n", "Parkes : 19.21792085535018 - 4.782079144649818\n", "Hobart : 17.614123493632228 - 6.385876506367769\n", "Ceduna : 17.529579372908337 - 6.470420627091663\n" ] } ], "source": [ "for ant in antennas:\n", " ant.calcrise(RA,Dec)\n", " print(ant.name, ': ', rad2hour(ant.rise+ant.longitude), ' - ', rad2hour(ant.set+ant.longitude))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Baseline lengths" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ATCA->Mopra 120 km\n", "ATCA->Parkes 324 km\n", "ATCA->Hobart 1400 km\n", "ATCA->Ceduna 1508 km\n", "Mopra->Parkes 204 km\n", "Mopra->Hobart 1286 km\n", "Mopra->Ceduna 1444 km\n", "Parkes->Hobart 1092 km\n", "Parkes->Ceduna 1360 km\n", "Hobart->Ceduna 1704 km\n" ] } ], "source": [ "for b in baselines:\n", " print('{0} {1:.0f} km'.format(b.name, b.length/1000))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Calculate/Plot elevation for each telescope\n", "Note this makes no attempt to cope with \"wrap\" issues for simplicity" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots()\n", "\n", "for ant in antennas:\n", " gsts = ant.upTimes(RA, Dec, step)\n", " times = [rad2hour(x) for x in gsts]\n", " \n", " (Az, El) = ant.calcAzEl(RA, Dec, gsts)\n", " degEl = [rad2deg(x) for x in El]\n", " axes.plot(times, degEl)\n", "\n", "axes.set_xlabel('Time (GST)')\n", "axes.set_ylabel('Elevation (Deg)');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Calculate Baseline UV coordinates" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots()\n", "\n", "for b in baselines:\n", " b.calcUp(RA, Dec, step)\n", " b.UVtrack(RA, Dec, b.gst, wavelength) \n", " u = b.u\n", " v = b.v\n", " axes.plot(-u/1000, v/1000, '.', u/1000, -v/1000, '.')\n", " \n", "axes.set_xlabel('U (Km)')\n", "axes.set_ylabel('V (Km)');\n", "axes.axis('equal');\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Baseline Sensitivity" ] }, { "cell_type": "code", "execution_count": 602, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ATCA->Mopra 1.68 mJy\n", "ATCA->Parkes 0.53 mJy\n", "ATCA->Hobart 1.92 mJy\n", "ATCA->Ceduna 1.98 mJy\n", "Mopra->Parkes 1.76 mJy\n", "Mopra->Hobart 6.36 mJy\n", "Mopra->Ceduna 6.59 mJy\n", "Parkes->Hobart 2.01 mJy\n", "Parkes->Ceduna 2.08 mJy\n", "Hobart->Ceduna 7.52 mJy\n" ] } ], "source": [ "for b in baselines:\n", " print('{0} {1:.2f} mJy'.format(b.name, b.sensitivity(bandwidth,calInt,True)*1e3))" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Location: 2\n", "Name= ATCA\n", "SEFD: 100\n" ] } ], "source": [ "def TestIt(name, SEFD, location=[]):\n", " \n", " print(\"Location: \", len(location))\n", " print(\"Name= \", name)\n", " print(\"SEFD: \", SEFD)\n", " \n", "TestIt(\"ATCA\", 100, [10,20])" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "__init__() takes 5 positional arguments but 6 were given", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mTelescope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"ATCA\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m149.57\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m30.31\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m39\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: __init__() takes 5 positional arguments but 6 were given" ] } ], "source": [ "Telescope(\"ATCA\",149.57,-30.31,12,39)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] } ], "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.7.4" } }, "nbformat": 4, "nbformat_minor": 2 }