From db99eba86c24e44bf5b2a6ec40afce006383902a Mon Sep 17 00:00:00 2001 From: Bee Lamsma Date: Thu, 24 Jul 2025 16:52:07 -0400 Subject: [PATCH 1/3] Please enter the commit message for your changes. Lines starting --- examples/SuperLMA.ipynb | 437 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 437 insertions(+) create mode 100644 examples/SuperLMA.ipynb diff --git a/examples/SuperLMA.ipynb b/examples/SuperLMA.ipynb new file mode 100644 index 0000000..66abb69 --- /dev/null +++ b/examples/SuperLMA.ipynb @@ -0,0 +1,437 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 55, + "id": "81019028-040f-4f3e-94c5-d1471645a464", + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import datetime as dt\n", + "import matplotlib.colors as mcolors\n", + "import matplotlib.pyplot as plt\n", + "from metpy.plots import USCOUNTIES\n", + "import nexradaws\n", + "conn = nexradaws.NexradAwsInterface()\n", + "import numpy as np\n", + "import numpy.ma as ma\n", + "norm = np.linalg.norm\n", + "import os\n", + "import pandas as pd\n", + "import pickle\n", + "from PIL import Image\n", + "import pyart\n", + "import pymap3d as pm\n", + "import pyxlma.lmalib.flash.properties\n", + "from pyxlma.lmalib.io import read as lma_read\n", + "from pyxlma.plot.interactive import InteractiveLMAPlot\n", + "import pyxlma.plot.xlma_super_plot_feature\n", + "import pyxlma.plot.radar as lmarad\n", + "from pypalettes import load_cmap\n", + "from scipy import stats\n", + "from scipy import spatial\n", + "from scipy.spatial import ConvexHull, convex_hull_plot_2d\n", + "import gc\n", + "import glob\n", + "import urllib.request\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import xarray as xr\n", + "import zipfile\n", + "try:\n", + " from metpy.plots import USCOUNTIES\n", + " county_scales = ['20m', '5m', '500k']\n", + " COUNTIES = USCOUNTIES.with_scale(county_scales[0])\n", + "except ImportError:\n", + " COUNTIES = None" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9dd19590-1d6e-41ef-8099-9cd88a24e2e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "36-NY.Dat\n", + "46-SD.Dat\n" + ] + } + ], + "source": [ + "#Bee's\n", + "obsticles = \"https://aeronav.faa.gov/Obst_Data/DOF_250511.zip\"\n", + "urllib.request.urlretrieve(obsticles, \"DOF_250511.zip\")\n", + "\n", + "zipdata = zipfile.ZipFile('DOF_250511.zip')\n", + "zipinfos = zipdata.infolist()\n", + "\n", + "entln_data = lma_read.entln('LEE_ENTLN_Sample.csv')\n", + "\n", + "# iterate through each file\n", + "for zipinfo in zipinfos:\n", + " # This will do the renaming\n", + " if '.csv' in zipinfo.filename:\n", + " print(\"Found \", zipinfo.filename)\n", + " # We can override the filename. Neat!\\n\",\n", + " zipinfo.filename = 'turbine_locations.csv'\n", + " zipdata.extract(zipinfo)\n", + "\n", + "\n", + "def haversine(lat1, lon1, lat2, lon2):\n", + "\n", + " R = 6378.137e3 # this is in meters. For Earth radius in kilometers use 6372.8 km\n", + "\n", + " dLat = radians(lat2 - lat1)\n", + " dLon = radians(lon2 - lon1)\n", + " lat1 = radians(lat1)\n", + " lat2 = radians(lat2)\n", + "\n", + " a = sin(dLat/2)**2 + cos(lat1)*cos(lat2)*sin(dLon/2)**2\n", + " c = 2*asin(sqrt(a))\n", + "\n", + " return R * c \n", + "\n", + "#Bee's\n", + "data = zipfile.ZipFile('DOF_250511.zip')\n", + "infos = data.infolist()\n", + "\n", + "for info in infos:\n", + " if '36-NY' in info.filename:\n", + " print(info.filename)\n", + " info.filename = 'NewYork_Obsticles.Dat'\n", + " data.extract(info)\n", + " \n", + "for info in infos:\n", + " if '46-SD' in info.filename:\n", + " print(info.filename)\n", + " info.filename = 'SouthDakota_Obsticles.Dat'\n", + " data.extract(info)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4c3358ce-95b5-4e2f-bf60-dda4e40979c9", + "metadata": {}, + "outputs": [], + "source": [ + "#May need to change the file path to match wherever this file is saved\n", + "ds = xr.open_dataset('./lmaworkshop/LEE-2023/LYLOUT_221120_070000_28800_map4000.nc')\n", + "starttime, endtime = ds.grid_time_edge[0].data, ds.grid_time_edge[-1].data\n", + "\n", + "lma_ctr_lon, lma_ctr_lat = ds.network_center_longitude.data, ds.network_center_latitude.data\n", + "\n", + "OSW_lat, OSW_lon = 43.454722, -76.506667\n", + "Lowville_lat, Lowville_lon = 43.786667, -75.492222\n", + "KTYX_lat, KTYX_lon, KTYX_alt = 43.7558, -75.68, 562.0\n", + "Smokestack_lat, Smokestack_lon = 43.4592, -76.5312\n", + "\n", + "station_lons = [OSW_lon, Lowville_lon, KTYX_lon, Smokestack_lon]\n", + "station_lats = [OSW_lat, Lowville_lat, KTYX_lat, Smokestack_lat]\n", + "station_labels = ['Oswego', 'Lowville', 'KTYX', 'Smokestack']\n", + "\n", + "# Manually set the encoding because someone didn't use UTF-8 like they should have.\n", + "#turbines = pd.read_csv('/Users/BenLa/.spyder-py3/turbine_locations.csv', encoding = \"ISO-8859-1\")\n", + "#nearby_turbines = ((turbines.xlong > lma_ctr_lon - 3.0) & (turbines.xlong < lma_ctr_lon + 3.0) & (turbines.ylat > lma_ctr_lat - 3.0) & (turbines.ylat < lma_ctr_lat + 3.0))\n", + "#turbines = turbines[nearby_turbines]\n", + "\n", + "DOF = 'NewYork_Obsticles.Dat'\n", + "#DOF = '/Users/BenLa/.spyder-py3/SouthDakota_Obsticles.Dat'\n", + "\n", + "#Bee's\\n\",\n", + "#identify different columns within NewYork_Obsticles.Dat and set them to the corresponding variables\n", + "#also skip the first 9000-ish rows as those are all downstate and not apart of our area of interest\n", + "specs = [(35, 37), (37, 41), (41, 46), (48, 52), (52, 55), (55, 60), (82, 88), (62, 74)]\n", + "StateObs2 = pd.read_fwf(DOF, colspecs = specs, skiprows=4, names=('ylatdeg', 'ylatmin', 'ylatsec', 'xlongdeg', 'xlongmin', 'xlongsec', 'Elevation (ft)', 'Obsticle'))\n", + "#NYObs2 = pd.read_fwf('D:/NewYork_Obsticles.Dat', colspecs = specs, skiprows=9209, skipfooter =1, names=('ylatdeg', 'ylatmin', 'ylatsec', 'xlongdeg', 'xlongmin', 'xlongsec', 'Elevation (ft)', 'Obsticle'))\n", + "\n", + "#Bee's\n", + "#convert the deg/min/sec for lat and long to decimal format\n", + "StateObs2['ylat']=StateObs2['ylatdeg']+StateObs2['ylatmin']/60+StateObs2['ylatsec']/3600\n", + "StateObs2['xlong']=(StateObs2['xlongdeg']+StateObs2['xlongmin']/60+StateObs2['xlongsec']/3600)*-1\n", + "\n", + "#Bee's\n", + "#get rid of the deg/min/sec columns and send it to a csv file\n", + "StateObs2.drop(columns=['ylatdeg', 'ylatmin', 'ylatsec', 'xlongdeg', 'xlongmin', 'xlongsec']).to_csv(r'/Users/BenLa/.spyder-py3/State_Obsticles.csv')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "983ba44e-b665-4198-bdbc-de9ac7bc7266", + "metadata": {}, + "outputs": [], + "source": [ + "class SuperLMAPlot(InteractiveLMAPlot):\n", + " def make_super_plot(self):\n", + " super(SuperLMAPlot, self).make_super_plot()\n", + " # Add our own title\n", + " tlim = self.bounds['t']\n", + " tlim_sub = pd.to_datetime(tlim[0]), pd.to_datetime(tlim[1])\n", + " title = tlim_sub[0].strftime('%Y%m%d %H%M%S') + ' to ' + tlim_sub[1].strftime('%Y%m%d %H%M%S') + ' UTC'\n", + " self.lma_plot.ax_th.set_title(title)\n", + " \n", + " # Add the station positions we defined above, and label them. We only need to add them to the plan-view plot.\n", + " # The other axes are self.lma_plot.ax_th, .ax_lon, and .ax_lat.\n", + " new_artists = []\n", + " art = self.lma_plot.ax_plan.scatter(station_lons, station_lats, s = 1, color='k', zorder=-10, mouseover = True)\n", + " new_artists.append(art)\n", + " for slon,slat,slabel in zip(station_lons, station_lats, station_labels):\n", + " txt_art = self.lma_plot.ax_plan.text(slon, slat, slabel)\n", + " new_artists.append(txt_art)\n", + " \n", + " #Bee's\n", + " #Add all the other obstacles and turbines from the NewYork_Obsticles File\n", + " obs_colour = (0.0,1.0,0.2,0.3)\n", + " art = self.lma_plot.ax_plan.scatter(StateObs2.xlong, StateObs2.ylat, color = obs_colour, marker = '1', zorder=-10)\n", + " new_artists.append(art)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "9ba5ea07-f96d-4f8c-85df-1b57e4f1c392", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 46 scans available between 2022-11-20 08:50:00 and 2022-11-20 13:00:00\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n", + " exists\n" + ] + } + ], + "source": [ + "#Set the radar time to a desired start\n", + "radar_id = 'KTYX'\n", + "begin = dt.datetime(2022,11,20,9)\n", + "#Spacing is how many minutes on respective sides of the begin time to download the radar files for\n", + "spacing = [10, 60*4]\n", + "\n", + "start=begin - dt.timedelta(minutes=spacing[0])\n", + "end = begin + dt.timedelta(minutes=spacing[1])\n", + "\n", + "# Create a folder to store the data\n", + "downloadloc = f'{start:%Y%m%d%H}_{radar_id}'\n", + "\n", + "# Determine What scans are avaiable for the radar site and times listed\n", + "scans = conn.get_avail_scans_in_range(start, end, radar_id)\n", + "\n", + "print(\"There are {} scans available between {} and {}\".format(len(scans), start, end))\n", + "#print(scans[0:4])\n", + "\n", + "#download the data\n", + "for scan in scans:\n", + " #print(scan)\n", + " path = str(scan)[39:63]\n", + " #print(f'./{downloadloc}{path}')\n", + " #2022112008_KTYX/KTYX20221120_125532_V06\n", + " #print(os.path.exists(f'./{downloadloc}{path}'))\n", + " if os.path.exists(f'./{downloadloc}{path}'):\n", + " print(str(scan) + ' exists')\n", + " else:\n", + " results = conn.download(scan, downloadloc)\n", + "\n", + "files = []\n", + "files = sorted(glob.glob(f'{downloadloc}/*V06'))\n", + "\n", + "#Create your own list of radar files\n", + "#files = []\n", + "\n", + "#It does take a while to read the radar data, but each selection of data should only need to be run once\n", + "#So if you make any changes to the time it'll need to be rerun, but no changes will just pass through\n", + "#It took this time period +25 minues so a smaller selection is suggested, but one of this size is recommended to show the capabilities\n", + "#print(files)\n", + "radar_data, start_times = lmarad.ReadRadar(files)\n", + "#print(radar_data)\n", + "#Start and end points for the cross section through radar grid \n", + "xsecLatLonAlt = [-76.132206, 44.133103, -75.264611, 43.477363, 10] #start lon, start lat, end lon, end lat, maxz" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "7d661198-4a53-41ea-afaa-87a53da14da3", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0cc3190517594e108fc6f48c390018d8", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tlim = pd.to_datetime(starttime).to_pydatetime()-pd.Timedelta(hours=1), pd.to_datetime(endtime).to_pydatetime()-pd.Timedelta(hours=1)\n", + "\n", + "#interactive_lma = AnnotatedLMAPlot(ds, clon=lma_ctr_lon, clat=lma_ctr_lat, tlim=tlim) #, network_data = entln_data)\n", + "\n", + "#Instead of creating a regular LMA plot, this will create the 11 panel version with radar, network data, and a leader speed plot\n", + "%matplotlib widget\n", + "interactive_lma = SuperLMAPlot(ds, clon=lma_ctr_lon, clat=lma_ctr_lat,tlim=tlim, network_data = entln_data, radar_data = radar_data, points = xsecLatLonAlt)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "e6c469a9-7c2a-4dec-967f-29aa28319392", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizontal Flash Area: \n" + ] + }, + { + "ename": "NameError", + "evalue": "name 'radians' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[56], line 16\u001b[0m\n\u001b[0;32m 14\u001b[0m verticies \u001b[38;5;241m=\u001b[39m points\u001b[38;5;241m.\u001b[39mvertices\n\u001b[0;32m 15\u001b[0m np\u001b[38;5;241m.\u001b[39mappend(verticies, points\u001b[38;5;241m.\u001b[39mvertices[\u001b[38;5;241m0\u001b[39m])\n\u001b[1;32m---> 16\u001b[0m area \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[43mhaversine\u001b[49m\u001b[43m(\u001b[49m\u001b[43minteractive_lma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthis_lma_lat\u001b[49m\u001b[43m[\u001b[49m\u001b[43mpoints\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvertices\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minteractive_lma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthis_lma_lon\u001b[49m\u001b[43m[\u001b[49m\u001b[43mpoints\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvertices\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minteractive_lma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthis_lma_lat\u001b[49m\u001b[43m[\u001b[49m\u001b[43mpoints\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvertices\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minteractive_lma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthis_lma_lon\u001b[49m\u001b[43m[\u001b[49m\u001b[43mpoints\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvertices\u001b[49m\u001b[43m[\u001b[49m\u001b[43mk\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m1e3\u001b[39m\n\u001b[0;32m 17\u001b[0m \u001b[38;5;66;03m#print(area)\u001b[39;00m\n\u001b[0;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(area\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m0.5\u001b[39m)\n", + "Cell \u001b[1;32mIn[2], line 24\u001b[0m, in \u001b[0;36mhaversine\u001b[1;34m(lat1, lon1, lat2, lon2)\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mhaversine\u001b[39m(lat1, lon1, lat2, lon2):\n\u001b[0;32m 22\u001b[0m R \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m6378.137e3\u001b[39m \u001b[38;5;66;03m# this is in meters. For Earth radius in kilometers use 6372.8 km\u001b[39;00m\n\u001b[1;32m---> 24\u001b[0m dLat \u001b[38;5;241m=\u001b[39m \u001b[43mradians\u001b[49m(lat2 \u001b[38;5;241m-\u001b[39m lat1)\n\u001b[0;32m 25\u001b[0m dLon \u001b[38;5;241m=\u001b[39m radians(lon2 \u001b[38;5;241m-\u001b[39m lon1)\n\u001b[0;32m 26\u001b[0m lat1 \u001b[38;5;241m=\u001b[39m radians(lat1)\n", + "\u001b[1;31mNameError\u001b[0m: name 'radians' is not defined" + ] + } + ], + "source": [ + "point_1 = np.where(interactive_lma.this_lma_lon == interactive_lma.this_lma_lon.min())[0]\n", + "point_2 = np.where(interactive_lma.this_lma_lon == interactive_lma.this_lma_lon.max())[0]\n", + "\n", + "point_3 = np.where(interactive_lma.this_lma_lat == interactive_lma.this_lma_lat.min())[0]\n", + "point_4 = np.where(interactive_lma.this_lma_lat == interactive_lma.this_lma_lat.max())[0]\n", + "\n", + "xy = [[a,b] for (a,b) in zip(interactive_lma.this_lma_lon, interactive_lma.this_lma_lat)]\n", + "\n", + "print(\"Horizontal Flash Area: \")\n", + "points = ConvexHull(xy)\n", + "area = 1\n", + "for k in range(len(points.vertices)-1): \n", + " #print(k)\n", + " verticies = points.vertices\n", + " np.append(verticies, points.vertices[0])\n", + " area *= haversine(interactive_lma.this_lma_lat[points.vertices[k]], interactive_lma.this_lma_lon[points.vertices[k]], interactive_lma.this_lma_lat[points.vertices[k+1]], interactive_lma.this_lma_lon[points.vertices[k+1]])/1e3\n", + " #print(area)\n", + "print(area**0.5)\n", + "#print(points.volume)\n", + "\n", + "#print(haversine(interactive_lma.this_lma_lat[point_1], interactive_lma.this_lma_lon[point_1], interactive_lma.this_lma_lat[point_2], interactive_lma.this_lma_lon[point_2]) * (haversine(interactive_lma.this_lma_lat[point_3], interactive_lma.this_lma_lon[point_3], interactive_lma.this_lma_lat[point_4], interactive_lma.this_lma_lon[point_4]))/1000)\n", + "\n", + "print(\"Vertical Flash Extent: \")\n", + "print(interactive_lma.this_lma_alt.max()-interactive_lma.this_lma_alt.min())\n", + "\n", + "print(\"Flash Duration: \")\n", + "print((float(interactive_lma.this_lma_time[interactive_lma.this_lma_time.index[0]].strftime('%S.%f'))-float(interactive_lma.this_lma_time[interactive_lma.this_lma_time.index[-1]].strftime('%S.%f')))*-1)\n", + "#print(interactive_lma.this_lma_time[interactive_lma.this_lma_time.index[0]])\n", + "#print(interactive_lma.this_lma_time[interactive_lma.this_lma_time.index[-1]])\n", + "print(\"Mean Altitude: \")\n", + "print(np.mean((interactive_lma.this_lma_alt)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70207abe-7804-4e6e-9f87-a9ddd68c6efb", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "FlashAnalyis2", + "language": "python", + "name": "flashanalyis2" + }, + "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.9.21" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 542bef90ac9a613579700e0d3ec4278586ed2bd2 Mon Sep 17 00:00:00 2001 From: Bee Lamsma Date: Thu, 24 Jul 2025 16:55:07 -0400 Subject: [PATCH 2/3] Add superLMA functionality to interactive --- pyxlma/plot/interactive.py | 208 ++++++++++++++++++++++++++++++------- 1 file changed, 170 insertions(+), 38 deletions(-) diff --git a/pyxlma/plot/interactive.py b/pyxlma/plot/interactive.py index c8038d0..b54d0ff 100644 --- a/pyxlma/plot/interactive.py +++ b/pyxlma/plot/interactive.py @@ -4,9 +4,11 @@ import pandas as pd from matplotlib.dates import num2date - -from pyxlma.plot.xlma_plot_feature import color_by_time, plot_points, setup_hist, plot_3d_grid, subset +from pyxlma.plot.xlma_plot_feature import color_by_time, plot_points, setup_hist, plot_3d_grid, subset, plot_2d_network_points from pyxlma.plot.xlma_base_plot import subplot_labels, inset_view, BlankPlot +from pyxlma.plot.xlma_super_base_plot import SuperBlankPlot +from pyxlma.plot.xlma_super_plot_feature import plot_super_points, plot_super_2d_network_points + from ipywidgets import Output output = Output() @@ -126,11 +128,12 @@ def event_space_time_limits(ds): class InteractiveLMAPlot(object): def __init__(self, ds, chimax=1.0, stationmin=6, - plot_cmap='plasma', point_size=5, clon=-101.5, clat=33.5, - xlim=None, ylim=None, zlim=None, tlim=None): + plot_cmap='plasma', point_size=10, clon=-101.5, clat=33.5, + xlim=None, ylim=None, zlim=None, tlim=None, network_data=None, radar_data=None, points=None): """ lma_plot is as returned by pyxlma's BlankPlot xlim, ylim, zlim, and tlim are initial limits to use with the dataset; + network_data is the data for network_data points to use alongside the dataset; otherwise, the limits are taken from the limits of the data in ds. """ xlim_ds, ylim_ds, zlim_ds, tlim_ds = event_space_time_limits(ds) @@ -139,8 +142,11 @@ def __init__(self, ds, chimax=1.0, stationmin=6, if ylim is None: ylim = ylim_ds if zlim is None: zlim = zlim_ds if tlim is None: tlim = tlim_ds + #print(tlim) + #if network_data is None: print(network_data) + #else: print(network_data) # tlim = pd.to_datetime('2022-06-04T22:15'), pd.to_datetime('2022-06-04T22:20') - + self.stationmin = stationmin self.chimax = chimax self.plot_cmap = plot_cmap @@ -149,13 +155,16 @@ def __init__(self, ds, chimax=1.0, stationmin=6, self.clat = clat self.widget_output = output - # list of all artists in the plot that change when the view subset changes self.data_artists = [] self._accumulator = Accumulator(self.limits_changed) self._managers = {} self.ds = ds + self.network_data = network_data + self.radar_data = radar_data + self.points = points + #print(network_data) self.bounds = { 'x': xlim, @@ -166,7 +175,8 @@ def __init__(self, ds, chimax=1.0, stationmin=6, self.lma_plot = None self.inset_ax = None - self.make_plot() + if isinstance(network_data, pd.core.frame.DataFrame): self.make_super_plot() + else: self.make_plot() self.make_plot_interactive() @output.capture() @@ -234,10 +244,156 @@ def limits_changed(self, axes): self.bounds['t'] = tlim self.make_plot() + self.make_super_plot() self.make_plot_interactive() @output.capture() + + def make_super_plot(self): + # pull out relevant plot params from object attributes + ds = self.ds + network_data = self.network_data + if isinstance(network_data, type(None)): + return + radar_data = self.radar_data + points = self.points + #print('super plot stuff') + #print(network_data) + plot_s = self.point_size + plot_cmap = self.plot_cmap + xlim, ylim = self.bounds['x'], self.bounds['y'] + zlim, tlim = self.bounds['z'], self.bounds['t'] + xchi = self.chimax + stationmin = self.stationmin + + # Regularize time limits to the right datetime type. + tlim_sub = pd.to_datetime(tlim[0]), pd.to_datetime(tlim[1]) + + alt_data = ds.event_altitude.values/1000.0 + lon_data = ds.event_longitude.values + lat_data = ds.event_latitude.values + time_data = pd.Series(ds.event_time) # because time comparisons + chi_data = ds.event_chi2.values + station_data = ds.event_stations.values.astype(int) + + network_data_alt = np.array((network_data['ic height'].apply(pd.to_numeric).astype(float)/1000).tolist()) + + network_data_lon = np.array(network_data['longitude'].tolist()) + network_data_lat = np.array(network_data['latitude'].tolist()) + network_data_time = (network_data['datetime']) + + network_data_type = (network_data['type']) + network_data_current = (network_data['peak_current_kA']) + network_data_chi = np.array([xchi] * len(network_data_alt)) + + network_data_station = np.array([stationmin] * len(network_data_alt)) + + network_data_lon_set, network_data_lat_set, network_data_alt_set, network_data_time_set, network_data_selection = subset( + network_data_lon, network_data_lat, network_data_alt, network_data_time, network_data_chi, network_data_station, + xlim, ylim, zlim, tlim_sub, xchi, stationmin) + + network_data_type_set = [] + for l in network_data_time_set.index: + #print(l) + #print(entln_type.iloc[l]) + network_data_type_set.append(network_data_type.iloc[l]) + #print('hi', entln_type_set) + + network_data_current_set = [] + for j in network_data_time_set.index: + network_data_current_set.append(network_data_current.iloc[j]) + + dict = {'longitude': network_data_lon_set, 'latitude': network_data_lat_set, 'height': network_data_alt_set, 'peak_current_kA': network_data_current_set, 'datetime': network_data_time_set, 'type': network_data_type_set} + network_data_adjusted = pd.DataFrame(dict) + #print(network_data_adjusted) + + tstring = 'LMA {}-{}'.format(tlim_sub[0].strftime('%H%M'), + tlim_sub[1].strftime('%H%M UTC %d %B %Y ')) + + lon_set, lat_set, alt_set, time_set, selection = subset( + lon_data, lat_data, alt_data, time_data, chi_data, station_data, + xlim, ylim, zlim, tlim_sub, xchi, stationmin) + + self.this_lma_lon = lon_set + self.this_lma_lat = lat_set + self.this_lma_alt = alt_set + self.this_lma_time = time_set + self.this_lma_sel = selection + + + #if self.lma_plot is not None: + # fig = self.lma_plot.fig + #else: + # fig = None + if self.lma_plot is None: + self.lma_plot = SuperBlankPlot(pd.to_datetime(tlim_sub[0]), bkgmap=True, #fig=fig, + xlim=xlim, ylim=ylim, zlim=zlim, tlim=tlim, title=tstring, + radar_data=radar_data, points=points) + # Add some subplot labels + label_art = subplot_labels(self.lma_plot) + else: + # clear all the old plots of data + #print(self.data_artist) + for a in self.data_artists: + #print("removing", a) + if a in self.data_artists: + try: + a.remove() + except ValueError: + pass + # reset the list of data artists. + self.data_artists = [] + self.lma_plot.ax_th.set_title(tstring) + + + # Add a view of where the subset is + # Not plotting this because removing the inset_ax created by this funcion does not + # clean up the callbacks created by GeoAxes._boundary, causing "None" to be + # passed as the axes to _trigger_patch_reclip" + + # Add a range ring + ring_art = self.lma_plot.ax_plan.tissot(rad_km=40.0, lons=self.clon, lats=self.clat, n_samples=80, + facecolor='none',edgecolor='k') + self.data_artists.append(ring_art) + + # Add the station locations + stn_art = self.lma_plot.ax_plan.plot(ds['station_longitude'], + ds['station_latitude'], 'wD', mec='k', ms=5) + self.data_artists.extend(stn_art) + + # Plot the LMA data points + if len(lon_set)==0: + #print('ERROR') + no_src_art = self.lma_plot.ax_hist.text(0.02,1,'No Sources',fontsize=12) + self.data_artists.append(no_src_art) + else: + plot_vmin, plot_vmax, plot_c = color_by_time(time_set, tlim_sub) + #print('Correct') + src_art2 = (plot_super_2d_network_points(self.lma_plot, network_data_adjusted, color_by='polarity', + actual_height=network_data_adjusted['height']/1000, points = points)) + + src_art = (plot_super_points(self.lma_plot, lon_set, lat_set, alt_set, time_set, + plot_cmap, plot_s, plot_vmin, plot_vmax, plot_c, radar_data = radar_data, points = points)) + + self.data_artists.extend(src_art) + self.data_artists.extend(src_art2) + + + self.lma_plot.ax_plan.set_aspect('auto') + + # Zoom all the axes to the same limits. Don't emit a callback event, + # so that we don't have an infinite loop. + self.lma_plot.ax_lon.axis(xlim+zlim, emit=False) + self.lma_plot.ax_lat.axis(zlim+ylim, emit=False) + self.lma_plot.ax_th.axis(tlim+zlim, emit=False) + + self.lma_plot.ax_plan.set_xticks(self.lma_plot.ax_lon.get_xticks()) + self.lma_plot.ax_plan.set_yticks(self.lma_plot.ax_lat.get_yticks()) + + self.lma_plot.ax_plan.axis(xlim+ylim, emit=False) + + def make_plot(self): # pull out relevant plot params from object attributes ds = self.ds @@ -285,24 +441,16 @@ def make_plot(self): else: # clear all the old plots of data for a in self.data_artists: - # print("removing", a) - a.remove() + #print("removing", a) + if a in self.data_artists: + try: + a.remove() + except ValueError: + pass # reset the list of data artists. self.data_artists = [] self.lma_plot.ax_th.set_title(tstring) - - # Add a view of where the subset is - # Not plotting this because removing the inset_ax created by this funcion does not - # clean up the callbacks created by GeoAxes._boundary, causing "None" to be - # passed as the axes to _trigger_patch_reclip - # if self.inset_ax is not None: - # print(self.inset_ax.callbacks) - # self.inset_ax.remove() - # xdiv = ydiv = 0.1 - # self.inset_ax = inset_view(self.lma_plot, lon_data, lat_data, xlim, ylim, xdiv, ydiv, - # buffer=0.5, inset_size=0.15, plot_cmap = 'plasma', bkgmap = True) - # Add a range ring ring_art = self.lma_plot.ax_plan.tissot(rad_km=40.0, lons=self.clon, lats=self.clat, n_samples=80, facecolor='none',edgecolor='k') @@ -331,14 +479,7 @@ def make_plot(self): self.lma_plot.ax_lon.axis(xlim+zlim, emit=False) self.lma_plot.ax_lat.axis(zlim+ylim, emit=False) self.lma_plot.ax_th.axis(tlim+zlim, emit=False) - # print(self.lma_plot.ax_plan.get_position()) - # print(self.lma_plot.ax_lat.get_position()) - # print(self.lma_plot.ax_lon.get_position()) - - # Refresh the ticks from the non-Cartopy plot that knows how to - # generate ticks. If this goes after the ax_plan.axis() below, - # it causes the proportion of the Cartopy axes frame - # to change within the figure. + self.lma_plot.ax_plan.set_xticks(self.lma_plot.ax_lon.get_xticks()) self.lma_plot.ax_plan.set_yticks(self.lma_plot.ax_lat.get_yticks()) @@ -347,13 +488,4 @@ def make_plot(self): - # Refresh the ticks from the non-Cartopy plot that knows how to - # generate ticks. - # self.lma_plot.ax_plan.set_xticks(self.lma_plot.ax_lon.get_xticks()) - # self.lma_plot.ax_plan.set_yticks(self.lma_plot.ax_lat.get_yticks()) - # This line does runs the above two lines, and then a set_extent, and - # promptly crashes the iPy kernel. - # self.lma_plot.set_ax_plan_labels() - - From 62f52e7c8fd75a9f44e04d2033eab36b92c11e72 Mon Sep 17 00:00:00 2001 From: Bee Lamsma Date: Thu, 24 Jul 2025 16:58:26 -0400 Subject: [PATCH 3/3] Add superLMA functionality and radar reading code --- pyxlma/plot/radar.py | 225 +++++++++++++ pyxlma/plot/xlma_super_base_plot.py | 334 +++++++++++++++++++ pyxlma/plot/xlma_super_plot_feature.py | 440 +++++++++++++++++++++++++ 3 files changed, 999 insertions(+) create mode 100644 pyxlma/plot/radar.py create mode 100644 pyxlma/plot/xlma_super_base_plot.py create mode 100644 pyxlma/plot/xlma_super_plot_feature.py diff --git a/pyxlma/plot/radar.py b/pyxlma/plot/radar.py new file mode 100644 index 0000000..8659a5c --- /dev/null +++ b/pyxlma/plot/radar.py @@ -0,0 +1,225 @@ +import os +import pyart +import pickle +import numpy as np +import pandas as pd +import datetime as dt +from datetime import datetime, timedelta +from scipy import spatial +import matplotlib.pyplot as plt +import matplotlib.colors as mcolors +import cartopy.crs as ccrs +from math import radians, cos, sin, asin, sqrt, degrees, atan +import cartopy.feature as cfeature +import gc + +try: + from metpy.plots import USCOUNTIES + county_scales = ['20m', '5m', '500k'] + COUNTIES = USCOUNTIES.with_scale(county_scales[0]) +except ImportError: + COUNTIES = None + +def negativeaxis(position, radar): + + if position < 0: + if position < radar[0].radar_longitude['data'][0]: + return True + else: + if position < radar[0].radar_latitude['data'][0]: + return True + return False + +def haversine(lat1, lon1, lat2, lon2): + + R = 6378.137e3 # this is in meters. For Earth radius in kilometers use 6372.8 km + + dLat = radians(lat2 - lat1) + dLon = radians(lon2 - lon1) + lat1 = radians(lat1) + lat2 = radians(lat2) + + a = sin(dLat/2)**2 + cos(lat1)*cos(lat2)*sin(dLon/2)**2 + c = 2*asin(sqrt(a)) + + return R * c + +def ReadRadar(radar_file): + radar_pickle = radar_file[0]+str(len(radar_file))+'.pickle' + if os.path.exists(radar_pickle): + with open(radar_pickle, 'rb') as pickle_file: + grided_radar = pickle.load(pickle_file) + start_times = pickle.load(pickle_file) + else: + radar_list = [] + start_times = [] + radar_file.sort() + for files in radar_file: + print('Reading: ' + files) + radar = pyart.io.read(files) + radar_list.append(radar) + radar_name = radar.metadata['instrument_name'] + try: + start = dt.datetime.strptime(files.split('/')[-1], radar_name + "%Y%m%d_%H%M%S_V06")#.strftime('%d/%m/%Y %H%M.%S') + except ValueError: + start = dt.datetime.strptime(files.split('\\')[-1], radar_name + "%Y%m%d_%H%M%S_V06") + start_times.append(start) + if int(start.strftime('%M')) >= 50: + gc.collect() + #print(start_times) + grided_radar = GridRadar(radar_list) + with open(radar_pickle, 'wb') as pickle_file: + pickle.dump(grided_radar, pickle_file) + pickle.dump(start_times, pickle_file) + start_times.sort() + grided_radar.append(start_times) + + return grided_radar, start_times + +def GridRadar(radar_objs): + grided = [] + for radars in radar_objs: + print("Griding: " + str(radars)) + grided.append(pyart.map.grid_from_radars(radars, grid_shape=(20, 181, 181), grid_limits=((100, 15000), (-175000, 175000), (-155000, 155000)), grid_origin=(pyart.graph.RadarMapDisplay(radars).loc[0], pyart.graph.RadarMapDisplay(radars).loc[1]), fields=["reflectivity", 'spectrum_width', 'differential_reflectivity', 'cross_correlation_ratio', 'velocity', 'differential_phase'])) + return grided + +def kdpData(trad_sweep): + #run this function only once!! + kdpdata = pyart.retrieve.kdp_vulpiani(trad_sweep, phidp_field ='differential_phase', band ='S' , windsize = 34) + kdpdata = kdpdata[0]['data'] #Retreive the kdp 'data' from the the kdpdata that was calculated using the Vulpiani method + mask = np.logical_and(kdpdata > -0.01, kdpdata < 0.01) #mask the values from -0.01 to 0.01 so they do not plot + kdpdata = np.where(mask, np.nan, kdpdata) #Apply the mask to kdpdata + trad_sweep.add_field('specific_differential_phase_hv', {'data': kdpdata.data}) #Add a new field to the radar data dictionary with the kdp data + return kdpdata + +def xsecPoints(mlon, mlat, xlon, xlat, maxz, radar_data, spacing = 0.1): + + radarx = radar_data[0].radar_longitude['data'][0] + radary = radar_data[0].radar_latitude['data'][0] + + mlon_rad, xlon_rad = haversine(mlat, mlon, mlat, radarx)/1e3, haversine(xlat, xlon, xlat, radarx)/1e3 + mlat_rad, xlat_rad = haversine(radary, mlon, mlat, mlon)/1e3, haversine(radary, xlon, xlat, xlon)/1e3 + + if negativeaxis(mlon, radar_data): mlon_rad = mlon_rad*-1 + if negativeaxis(mlat, radar_data): mlat_rad = mlat_rad*-1 + if negativeaxis(xlon, radar_data): xlon_rad = xlon_rad*-1 + if negativeaxis(xlat, radar_data): xlat_rad = xlat_rad*-1 + + nn = int(((xlon_rad-mlon_rad)**2+(xlat_rad-mlat_rad)**2)**0.5/spacing) + des_x = np.linspace(mlon_rad,xlon_rad,nn)*1e3 + des_y = np.linspace(mlat_rad,xlat_rad,nn)*1e3 + des_z = np.arange(0,maxz+spacing,spacing)*1e3 + + desx_grid,desz_grid = np.meshgrid(des_x,des_z) + desy_grid,desz_grid = np.meshgrid(des_y,des_z) + new_x = np.arange(0,np.shape(des_x)[0]*spacing ,spacing)*1e3 + _new_x = new_x + return desx_grid, desy_grid, desz_grid, new_x + +def keepSweep(radar_data): + #Must be a list of radar objects + radar_pol=[] + radar_trad=[] + for radar in radar_data: + keep_sweeps_pol=[] + keep_sweeps_trad=[] + for sweep in radar.sweep_number['data']: + if not (np.size(radar.extract_sweeps([sweep]).fields['differential_reflectivity']['data'].mask)- + np.sum(radar.extract_sweeps([sweep]).fields['differential_reflectivity']['data'].mask))==0: + #print ('Keeping polarimetric sweep number: ', sweep) + keep_sweeps_pol+=[sweep] + if not (np.size(radar.extract_sweeps([sweep]).fields['velocity']['data'].mask)- + np.sum(radar.extract_sweeps([sweep]).fields['velocity']['data'].mask))==0: + #print ('Keeping traditional sweep number: ', sweep) + keep_sweeps_trad+=[sweep] + + # Keep only the good sweeps for each set of radar variables + radar_pol.append(radar.extract_sweeps(keep_sweeps_pol)) + radar_trad.append(radar.extract_sweeps(keep_sweeps_trad)) + return radar_pol, radar_trad + +def plotRadar(radar_data, variable, mlon=0, mlat=0, xlon=0, xlat=0): + fig = plt.figure(figsize = (15, 10)) + ax = plt.subplot(projection = ccrs.PlateCarree()) + #ax = fig.add_subplot() + display = pyart.graph.RadarMapDisplay(radar_data) + #variable must be a pyart defined radar variable + #can be found by using radar.into(fields) + display.plot_ppi_map(variable, sweep = 1, vmin = -20, vmax=60, cmap='pyart_HomeyerRainbow', + min_lat=radar_data.latitude['data'][0]-2, + max_lat=radar_data.latitude['data'][0]+2, + min_lon=radar_data.longitude['data'][0]-2, + max_lon=radar_data.longitude['data'][0]+2, + lat_lines = [40, 41, 42, 43, 44, 45], lon_lines = [-74, -75, -76, -77], + ax = ax) + + ax.add_feature(COUNTIES, facecolor='none', edgecolor='gray') + ax.add_feature(cfeature.BORDERS) + plt.plot([mlon, xlon], [mlat, xlat], color = '#6a8f9c', linewidth = 2) + + +def plotRadarxsec(radar_data, pol_sweep, trad_sweep, desx_grid, desy_grid, desz_grid, new_x, kdpdata, _maxz = 10): + + des_tree_pol = spatial.KDTree(np.array([pol_sweep.gate_x['data'].ravel(),pol_sweep.gate_y['data'].ravel(), pol_sweep.gate_z['data'].ravel()]).T) + + des_tree_trad = spatial.KDTree(np.array([trad_sweep.gate_x['data'].ravel(),trad_sweep.gate_y['data'].ravel(), trad_sweep.gate_z['data'].ravel()]).T) + # Find the radar gate closest to the cross-section grid + dists_pol, indext_pol = des_tree_pol.query(np.array([desx_grid.ravel(), desy_grid.ravel(), desz_grid.ravel()]).T) + + # Find the radar gate closest to the cross-section grid + dists_trad, indext_trad = des_tree_trad.query(np.array([desx_grid.ravel(), desy_grid.ravel(), desz_grid.ravel()]).T) + + # Get the x,y,z locations of the radar gates for later + # Theoretically these should match, but let's not make any assumptions + rx_pol, ry_pol, rz_pol = pol_sweep.get_gate_x_y_z(0) + rx_trad,ry_trad,rz_trad = trad_sweep.get_gate_x_y_z(0) + + fig = plt.figure(figsize=(28,16)) + #Reflectivity + ax1 = fig.add_subplot(321) + plt.contourf(new_x/1e3, desz_grid[:,0]/1e3, trad_sweep.fields['reflectivity']['data'].ravel()[indext_trad].reshape(np.shape(desz_grid)),levels = np.arange(-20,72,1),cmap='pyart_HomeyerRainbow') + plt.colorbar(label='Reflectivity (dBZ)') + plt.xlim(0, np.max(new_x)/1e3) + plt.ylim(0, _maxz) + #Velocity + ax2 = fig.add_subplot(322) + plt.contourf(new_x/1e3, desz_grid[:,0]/1e3, trad_sweep.fields['velocity']['data'].ravel()[indext_trad].reshape(np.shape(desz_grid)),levels = np.arange(-40,40,1),cmap='NWSVel') + plt.colorbar(label='Velocity (m/s)') + plt.xlim(0, np.max(new_x)/1e3) + plt.ylim(0, _maxz) + #Spectrum Width + ax3 = fig.add_subplot(323) + colors1 = plt.cm.binary_r(np.linspace(0.2,0.8,33)) + colors2 = plt.cm.gnuplot_r(np.linspace(0.,0.7,100)) + colors = np.vstack((colors1, colors2[10:121])) + swcolours = mcolors.LinearSegmentedColormap.from_list('my_colormap', colors) + plt.contourf(new_x/1e3, desz_grid[:,0]/1e3, trad_sweep.fields['spectrum_width']['data'].ravel()[indext_trad].reshape(np.shape(desz_grid)),levels = np.arange(0,14,0.1),cmap='NWS_SPW') + plt.colorbar(label='Spectrum Width') + plt.xlim(0, np.max(new_x)/1e3) + #Differential Reflectivity + ax4 = fig.add_subplot(324) + plt.contourf(new_x/1e3, desz_grid[:,0]/1e3, pol_sweep.fields['differential_reflectivity']['data'].ravel()[indext_pol].reshape(np.shape(desz_grid)),levels = np.arange(-4,8,0.1),cmap='ChaseSpectral') + plt.colorbar(label='Differential Reflectivity (ZDR)') + plt.xlim(0, np.max(new_x)/1e3) + plt.ylim(0, _maxz) + #Correlation Coefficient + ax5 = fig.add_subplot(325) + plt.contourf(new_x/1e3, desz_grid[:,0]/1e3, pol_sweep.fields['cross_correlation_ratio']['data'].ravel()[indext_pol].reshape(np.shape(desz_grid)),levels = np.arange(0,1.1,0.01),cmap='SCook18') + plt.colorbar(label='Correlation Coefficient') + plt.xlim(0, np.max(new_x)/1e3) + plt.ylim(0, _maxz) + #Specific Differential Phase + ax6 = fig.add_subplot(326) + plt.contourf(new_x/1e3, desz_grid[:,0]/1e3, kdpdata.ravel()[indext_pol].reshape(np.shape(desz_grid)),np.arange(-1,4.1,0.1),cmap=swcolours) + plt.colorbar(label='Specific Differential Phase (KDP)') + plt.xlim(0, np.max(new_x)/1e3) + plt.ylim(0, _maxz) + + + plt.ylabel('Altitude (km AGL)') + plt.xlabel('Distance (km)') + plt.tight_layout() + + + + \ No newline at end of file diff --git a/pyxlma/plot/xlma_super_base_plot.py b/pyxlma/plot/xlma_super_base_plot.py new file mode 100644 index 0000000..d346ec1 --- /dev/null +++ b/pyxlma/plot/xlma_super_base_plot.py @@ -0,0 +1,334 @@ +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.dates as md +import datetime as dt +import pyart +import os +import glob +from pathlib import Path +import pandas as pd +import h5py +from matplotlib.ticker import Formatter, FormatStrFormatter, MaxNLocator +from matplotlib.dates import AutoDateLocator +import matplotlib.cm as cm +from scipy import spatial +import matplotlib.colors as mcolors +import wradlib +from geopy import distance + +import pyxlma.plot.radar as lmarad + +import cartopy +import cartopy.crs as ccrs +import cartopy.feature as cfeature +import cartopy.io.shapereader as shpreader +from matplotlib.axes import Axes +from cartopy.mpl.geoaxes import GeoAxes +from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter + +GeoAxes._pcolormesh_patched = Axes.pcolormesh + +windows_os = True +file_type = 'h5' +file_suffix = 'flash.h5' +tbuffer = 1*60 +max_chi = 1 +min_stations = 6 +max_dist = 2.5e3 +m = -10 + +# proj_cart = ccrs.PlateCarree(central_longitude=-95) + +# # Add a note about plotting counties by default if metpy is available in docs, and how to add your own map data without relying on built-ins. +# reader = shpreader.Reader('UScounties/UScounties.shp') +# counties = list(reader.geometries()) +# COUNTIES = cfeature.ShapelyFeature(counties, ccrs.PlateCarree()) +try: + from metpy.plots import USCOUNTIES + county_scales = ['20m', '5m', '500k'] + COUNTIES = USCOUNTIES.with_scale(county_scales[0]) +except ImportError: + COUNTIES = None + +COORD_TH = [0.05, 0.8, 0.415, 0.1] #Time-Height +COORD_PLAN = [0.05, 0.1, 0.325, 0.5] #LMA Plan +COORD_LON = [0.05, 0.65, 0.325, 0.1] #Longitude-Height +COORD_LAT = [0.4, 0.1, 0.065, 0.5] #Latitude-Height +COORD_HIST = [0.4, 0.65, 0.065, 0.1] #Histogram-Height +COORD_RAD = [0.51, 0.535, 0.26, 0.405] #Radar Plan +COORD_VEL = [0.51, 0.1, 0.26, 0.385] #Leader Speed Plot +COORD_RCS = [0.82, 0.85, 0.17, 0.1] #Radar Cross Section +COORD_VCS = [0.82, 0.7, 0.17, 0.1] #Velocity Cross Section +COORD_SWCS = [0.82, 0.55, 0.17, 0.1] #Spectrum Width Cross Section +COORD_DRCS = [0.82, 0.4, 0.17, 0.1] #Differential Reflectivity Cross Section +COORD_SDPCS = [0.82, 0.25, 0.17, 0.1] #Specific Differential Phase Cross Section +COORD_CCCS = [0.82, 0.1, 0.17, 0.1] #Correlation Coefficient Cross Section + +LMA_dir = '/Users/BenLa/.spyder-py3' + +class FractionalSecondFormatter(Formatter): + def __init__(self, axis): + self._axis = axis + + def __call__(self, x, pos=None): + """ Formats seconds of the day to HHMM:SS.SSSSSS, with the fractional + part varying in length based on the total interval. + Maximum resolution is 1 microsecond, due to limitation in datetime. + """ + + tick_date = md.num2date(x) + interval = [md.num2date(d) for d in self._axis.get_xlim()] + delta_sec = (interval[1] - interval[0]).total_seconds() + if (delta_sec < 30): + fmt = '%S' + else: + fmt = '%H%M:%S' + + # for most plots, it seems like pos=1 is the first label, even though pos=0 is also requested. + # some plots do in fact plot the label for both pos=0 and pos=1, so go with 1 for safety + if pos == 1: + fmt = '%H%M:%S' + + # This could be generated algorithmically - the pattern is obvious. + frac_fmt = '%.6f' + if delta_sec > 0.00005: + frac_fmt = '%.5f' + if delta_sec > 0.0005: + frac_fmt = '%.4f' + if delta_sec > 0.005: + frac_fmt = '%.3f' + if delta_sec > 0.05: + frac_fmt = '%.2f' + if delta_sec > 0.5: + frac_fmt = '%.1f' + if delta_sec > 5: + frac_fmt = '%.0f' + + if pos is None: + # Be verbose for the status readout + fmt = '%H%M:%S' + frac_fmt = '%.6f' + + # if pos is not None: + # print x, delta_sec, frac_fmt, frac_fmt % (tick_date.microsecond/1.0e6) + + time_str = tick_date.strftime(fmt) + frac_str = frac_fmt % (tick_date.microsecond/1.0e6) + return time_str + frac_str[1:] + + +class SuperBlankPlot(object): + """ + Generate a matching plot setup with no data + + Requires: + stime = starting time + xlim, ylim = bounds of the domain + title = title string + tlim = list of start and end times + + Will include map information if bkgmap==True + """ + + def __init__(self, stime, bkgmap=True, **kwargs): + self.zlim = kwargs['zlim'] + self.tlim = kwargs['tlim'] + self.ylim = kwargs['ylim'] + self.xlim = kwargs['xlim'] + self.bkgmap = bkgmap + self.stime = stime + self.majorFormatter = FormatStrFormatter('%.2f') + self.dt_init = dt.datetime( + self.stime.year, self.stime.month, self.stime.day) + self.radar_data = kwargs['radar_data'] + self.points = kwargs['points'] + self.plot(**kwargs) + + def set_ax_plan_labels(self): + self.ax_plan.set_xticks(self.ax_lon.get_xticks()) + self.ax_plan.set_yticks(self.ax_lat.get_yticks()) + if self.bkgmap==True: + self.ax_plan.set_extent([self.xlim[0], self.xlim[1], + self.ylim[0], self.ylim[1]]) +# + def plot(self, **kwargs): + self.fig = plt.figure(figsize=(19, 11)) + self.ax_th = self.fig.add_axes(COORD_TH) + if self.bkgmap == True: + self.ax_plan = self.fig.add_axes(COORD_PLAN,projection=ccrs.PlateCarree()) + else: + self.ax_plan = self.fig.add_axes(COORD_PLAN) + self.ax_lon = self.fig.add_axes(COORD_LON) + self.ax_lat = self.fig.add_axes(COORD_LAT) + self.ax_hist = self.fig.add_axes(COORD_HIST) + #if self.bkgmap == True: + self.ax_rad = self.fig.add_axes(COORD_RAD, projection=ccrs.PlateCarree()) + radar_data = self.radar_data + points = self.points + + closest_time = {abs(self.tlim[0].timestamp() - date.timestamp()) : date for date in radar_data[-1]} + result = closest_time[min(closest_time.keys())] + display = pyart.graph.GridMapDisplay(radar_data[radar_data[-1].index(result)]) + + self.ax_vel = self.fig.add_axes(COORD_VEL) + self.ax_rcs = self.fig.add_axes(COORD_RCS)#, self.fig.colorbar(cm.ScalarMappable(norm = mcolors.Normalize(-32, 65, 'False'), cmap='pyart_HomeyerRainbow'), label='Reflectivity (dBZ)', cax = plt.axes((0.96, 0.85, 0.007, 0.1))) + self.ax_vcs = self.fig.add_axes(COORD_VCS)#, self.fig.colorbar(cm.ScalarMappable(norm = mcolors.Normalize(-40, 40, 'False'), cmap='pyart_NWSVel'), label='Velocity (m/s)', cax = plt.axes((0.96, 0.7, 0.007, 0.1))) + self.ax_swcs = self.fig.add_axes(COORD_SWCS)#, self.fig.colorbar(cm.ScalarMappable(norm = mcolors.Normalize(0, 14.1, 'False'), cmap='pyart_NWS_SPW'), label='Spectrum Width (m/s)', cax = plt.axes((0.96, 0.55, 0.007, 0.1))) + self.ax_drcs = self.fig.add_axes(COORD_DRCS)#, self.fig.colorbar(cm.ScalarMappable(norm = mcolors.Normalize(-2, 6, 'False'), cmap='pyart_RefDiff'), label='ZDR (DB)', cax = plt.axes((0.96, 0.4, 0.007, 0.1))) + self.ax_sdpcs = self.fig.add_axes(COORD_SDPCS)#, self.fig.colorbar(cm.ScalarMappable(norm = mcolors.Normalize(-1, 4.1, 'False'), cmap='pyart_SCook18'), label='Specific Differential \n Phase (degrees)', cax = plt.axes((0.96, 0.25, 0.007, 0.1))) + self.ax_cccs = self.fig.add_axes(COORD_CCCS)#, self.fig.colorbar(cm.ScalarMappable(norm = mcolors.Normalize(0.7, 1.03, 'False'), cmap='pyart_SCook18'), label='Correlation Coefficient', cax = plt.axes((0.96, 0.1, 0.007, 0.1))) + self.yticks = 5 * np.arange(6) + self.title = kwargs['title'] + + + # Time altitude panel [OK] + self.ax_th.set_xlabel('Time (UTC)') + self.ax_th.set_ylabel('Altitude (km)') + self.ax_th.set_yticks(self.yticks) + self.ax_th.set_ylim(self.zlim) + self.ax_th.set_title(self.title) + self.ax_th.minorticks_on() + tstep = int(1e6*(self.tlim[1] - self.tlim[0]).total_seconds()/5) + if tstep < 5000000: + tfmt = '%H:%M:%S.%f' + else: + tfmt = '%H:%M:%S000' + self.ax_th.set_xlim(self.tlim[0], self.tlim[1]) + self.ax_th.xaxis.set_major_formatter(FractionalSecondFormatter(self.ax_th)) + # Importing pandas results in it overriding Matplotlib default AutoDateLocator, + # which in turn prevents more than one tick displaying for short time intervals. + # See this blog entry for details. + # https://notebook.community/azjps/matplotlib-tick-formatters/ notebooks/microsecond_precision At small time intervals, + # So, restore Matplotlib's AutoDateLocator, which as of version >3.3 correctly + # handles smaller time intervals. 3.2 did not! + self.ax_th.xaxis.set_major_locator(AutoDateLocator()) + + # Longitude-Altitue [OK] + self.ax_lon.set_ylabel('Altitude (km MSL)') + self.ax_lon.set_yticks(self.yticks) + self.ax_lon.set_ylim(self.zlim) + self.ax_lon.set_xlim(self.xlim) + self.ax_lon.minorticks_on() + for xlabel_i in self.ax_lon.get_xticklabels(): + xlabel_i.set_fontsize(0.0) + xlabel_i.set_visible(False) + + # Height-VHF count [OK] + self.ax_hist.set_xticks([0, 0.1, 0.2, 0.3]) + self.ax_hist.set_yticks(self.yticks) + self.ax_hist.set_ylim(self.zlim) + self.ax_hist.set_xlim(0, 0.3) + self.ax_hist.set_xlabel('Freq') + self.ax_hist.minorticks_on() + + # Altitude-Latitude [OK] + self.ax_lat.set_xlabel('Altitude (km MSL)') + self.ax_lat.set_xticks(self.yticks) + self.ax_lat.set_xlim(self.zlim) + self.ax_lat.set_ylim(self.ylim) + self.ax_lat.minorticks_on() + for xlabel_i in self.ax_lat.get_yticklabels(): + xlabel_i.set_fontsize(0.0) + xlabel_i.set_visible(False) + + # Plan view [OK] + if self.bkgmap==True: + self.ax_plan.add_feature(COUNTIES, facecolor='none', edgecolor='gray') + self.ax_plan.add_feature(cfeature.BORDERS) + self.ax_plan.add_feature(cfeature.STATES.with_scale('10m')) + self.ax_plan.set_xlabel('Longitude (degrees)') + self.ax_plan.set_ylabel('Latitude (degrees)') + self.ax_plan.set_xlim(self.xlim) + self.ax_plan.set_ylim(self.ylim) + self.ax_plan.set_aspect('auto') + + # Radar plan view + plt.colorbar(cm.ScalarMappable(norm=mcolors.Normalize(vmin=-20, vmax=60), cmap = 'HomeyerRainbow'), ax = self.ax_rad) + + # Leader speed plot + self.ax_vel.set_ylabel('Distance From Origin (m)') + self.ax_vel.set_xlabel('Time From Origin (s)') + self.ax_vel.set_title('Lightning Leader Speed') + norm = mcolors.Normalize(vmin=0, vmax=6) + plt.colorbar(cm.ScalarMappable(norm=norm, cmap='cool'), ax=self.ax_vel, label='Altitude (km)', spacing='proportional') + + steps = ((distance.geodesic((points[1], points[0]), (points[3], points[2])).km)+((distance.geodesic((points[1], points[0]), (points[3], points[2])).km)/10)) + #print((points[1], points[0]), (points[3], points[2])) + + # Reflectivity Cross Section + display.plot_cross_section("reflectivity", [points[1], points[0]], [points[3], points[2]], steps = steps, cmap = 'pyart_HomeyerRainbow', title = '', axislabels = ('', 'Height above \n Radar (km)'), colorbar_label = 'Reflectivity (dbZ)', vmin = -20, vmax = 70, ax = self.ax_rcs) + + # Velocity Cross Section + display.plot_cross_section('velocity', [points[1], points[0]], [points[3], points[2]], steps = steps, cmap = 'pyart_NWSVel', title = '', axislabels = ('', 'Height above \n Radar (km)'), colorbar_label = 'Velocity (m/s)', vmin = -40, vmax = 40, ax = self.ax_vcs) + + # Spectrum Width Cross Section + display.plot_cross_section("spectrum_width", [points[1], points[0]], [points[3], points[2]], steps = steps, cmap = 'pyart_NWS_SPW', title = '', axislabels = ('', 'Height above \n Radar (km)'), colorbar_label = 'Spectrum Width (m/s)', vmin = 0, vmax = 14.1, ax = self.ax_swcs) + + # Differential Reflectivity Cross Section + display.plot_cross_section("differential_reflectivity", [points[1], points[0]], [points[3], points[2]], steps = steps, cmap = 'pyart_RefDiff', title = '', axislabels = ('', 'Height above \n Radar (km)'), colorbar_label = 'ZDR (DB)', vmin = -2, vmax = 6, ax = self.ax_drcs) + + # Specific Differential Phase Cross Section + display.plot_cross_section('differential_phase', [points[1], points[0]], [points[3], points[2]], steps = steps, cmap = 'pyart_SCook18', title = '', axislabels = ('', 'Height above \n Radar (km)'), colorbar_label = 'Specific Differential \n Phase (degrees)', vmin = -1, vmax = 4.1, ax = self.ax_sdpcs) + + # Correlation Coefficient Cross Section + display.plot_cross_section("cross_correlation_ratio", [points[1], points[0]], [points[3], points[2]], steps = steps, cmap = 'pyart_SCook18', title = '', axislabels = ('Distance Across Cross Section (km)', 'Height above \n Radar (km)'), colorbar_label = 'Correlation Coefficient', vmin = 0.7, vmax = 1.03, ax = self.ax_cccs) + + self.ax_plan.minorticks_on() + self.ax_plan.xaxis.set_major_formatter(self.majorFormatter) + self.ax_plan.yaxis.set_major_formatter(self.majorFormatter) + self.set_ax_plan_labels() + +def subplot_labels(plot): + """ + Place letters on each subplot panel. + + Returns a list of matplotlib text artists + """ + a = plt.text(0.05, 0.8, '(a)', fontsize='x-large', weight='bold', + horizontalalignment='center', verticalalignment='center', + transform=plot.ax_th.transAxes) + b = plt.text(0.065, 0.80, '(b)', fontsize='x-large', weight='bold', + horizontalalignment='center', verticalalignment='center', + transform=plot.ax_lon.transAxes) + c = plt.text(0.30, 0.80, '(c)', fontsize='x-large', weight='bold', + horizontalalignment='center', verticalalignment='center', + transform=plot.ax_hist.transAxes) + d = plt.text(0.065, 0.95, '(d)', fontsize='x-large', weight='bold', + horizontalalignment='center', verticalalignment='center', + transform=plot.ax_plan.transAxes) + e = plt.text(0.30, 0.95, '(e)', fontsize='x-large', weight='bold', + horizontalalignment='center', verticalalignment='center', + transform=plot.ax_lat.transAxes) + return [a,b,c,d,e] + + +def inset_view(plot, lon_data, lat_data, xlim, ylim, xdiv, ydiv, + buffer=0.5, inset_size=0.15, plot_cmap = 'magma', bkgmap = True): + + + """ + Overlay an inset panel of size 'inset_size' showing a plan-view histogram + of sources at xdiv, ydiv intervals and outlining a box over xlim and ylim + with buffer of 'buffer' lat/lon degrees in the image. + + Add background map features if 'bkgmap' == True + """ + inset = plot.fig.add_axes([0.02, 0.01, 0.02+inset_size, + 0.01+inset_size],projection=ccrs.PlateCarree()) + + inset.hist2d(lon_data, lat_data, + bins=[np.arange(xlim[0]-buffer, xlim[1]+buffer+xdiv, xdiv), + np.arange(ylim[0]-buffer, ylim[1]+buffer+ydiv, ydiv)], + density=True, cmap=plot_cmap, + cmin=0.00001) + + if bkgmap == True: + if COUNTIES is not None: + inset.add_feature(COUNTIES, facecolor='none', edgecolor='gray') + inset.add_feature(cfeature.BORDERS) + inset.add_feature(cfeature.STATES.with_scale('10m')) + inset.set_extent([xlim[0]-buffer, xlim[1]+buffer, + ylim[0]-buffer, ylim[1]+buffer]) + inset.plot([xlim[0],xlim[0],xlim[1],xlim[1],xlim[0]], + [ylim[0],ylim[1],ylim[1],ylim[0],ylim[0]],'k') + return inset \ No newline at end of file diff --git a/pyxlma/plot/xlma_super_plot_feature.py b/pyxlma/plot/xlma_super_plot_feature.py new file mode 100644 index 0000000..264778c --- /dev/null +++ b/pyxlma/plot/xlma_super_plot_feature.py @@ -0,0 +1,440 @@ +import matplotlib.pyplot as plt +import numpy as np +import xarray as xr +import xradar as xd +import matplotlib.dates as md +from math import radians, cos, sin, asin, sqrt +from matplotlib.patches import Polygon +from matplotlib.collections import PatchCollection +from matplotlib.colors import LinearSegmentedColormap +import pandas as pd +import pyart +import datetime as dt +from datetime import datetime, timedelta +import pickle +import os +import cartopy +import cartopy.crs as ccrs +import cartopy.feature as cfeature +from pyxlma.plot.leader_speed import get_time_distance, time_distance_plot +import pyxlma.plot.radar as lmarad +#from pyxlma.plot.xlma_super_base_plot import SuperBlankPlot +from geopy import distance +import matplotlib.cm as cm +import matplotlib.colors as mcolors +from metpy.interpolate import cross_section + +from scipy import spatial + +try: + from metpy.plots import USCOUNTIES + county_scales = ['20m', '5m', '500k'] + COUNTIES = USCOUNTIES.with_scale(county_scales[0]) +except ImportError: + COUNTIES = None + + +def subset(lon_data, lat_data, alt_data, time_data, chi_data, station_data, + xlim, ylim, zlim, tlim, xchi, stationmin): + """ + Generate a subset of x,y,z,t of sources based on maximum + reduced chi squared and given x,y,z,t bounds + + Returns: longitude, latitude, altitude, time and boolean arrays + """ + + selection = ((alt_data>zlim[0])&(alt_dataxlim[0])&(lon_dataylim[0])&(lat_datatlim[0])&(time_data=stationmin) + ) + + alt_data = alt_data[selection] + #print(alt_data) + lon_data = lon_data[selection] + #print(lon_data) + lat_data = lat_data[selection] + #print(lat_data) + time_data = time_data[selection] + #print(time_data) + return lon_data, lat_data, alt_data, time_data, selection + + +def color_by_time(time_array, tlim): + """ + Generates colormap values for plotting VHF sources by time in a + given time window + + Returns: min, max values, array by time + """ + vmax = (tlim[1] - time_array.min()).total_seconds() + ldiff = time_array - time_array.min() + ldf = [] + for df in ldiff: + ldf.append(df.total_seconds()) + c = np.array(ldf) + vmin = 0 + + return vmin, vmax, c + + +def setup_hist(lon_data, lat_data, alt_data, time_data, + xbins, ybins, zbins, tbins): + """ + Create 2D VHF historgrams for combinations of x,y,z,t + in specified intervals + """ + alt_lon, _, _ = np.histogram2d(lon_data, alt_data, [xbins,zbins]) + alt_lat, _, _ = np.histogram2d(alt_data, lat_data, [zbins,ybins]) + alt_time, _, _ = np.histogram2d(md.date2num(time_data), alt_data, [tbins,zbins]) + lat_lon, _, _ = np.histogram2d(lon_data, lat_data, [xbins,ybins]) + return alt_lon, alt_lat, alt_time, lat_lon + + +def plot_super_points(bk_plot, lon_data, lat_data, alt_data, time_data, + plot_cmap=None, plot_s=40, plot_vmin=None, plot_vmax=None, plot_c=None, edge_color='face', + edge_width=0, add_to_histogram=True, marker='o', radar_data = None, points = None, **kwargs): + """ + Plot scatter points on an existing bk_plot object given x,y,z,t for each + and defined plotting colormaps and ranges + """ + colour_map = LinearSegmentedColormap.from_list('mycmap', ['black', 'black', 'black']) + start = dt.datetime(2022, 11, 16) + flash_events = pd.DataFrame({'lon': lon_data, 'lat': lat_data, 'alt': alt_data, 'time': time_data}) + flash_events = flash_events.sort_values(by='time') + + #if radar_data != None: print(list(flash_events['time'])[0]) + mx, my, xx, xy, max_z = points[0], points[1], points[2], points[3], points[4] + max_dist = 2.5e3 + + if radar_data != None: + closest_time = min(radar_data[-1], key=lambda sub: abs(sub-list(flash_events['time'])[0])) + start = closest_time + + end = start+dt.timedelta(seconds=7.5*60) + flash_event_time = pd.Series(flash_events.time) + selection_event = (flash_event_time>=start-dt.timedelta(seconds=1*60))&(flash_event_time-max_dist))>0: + cs_x = new_lma_r[(new_dists-max_dist)] + cs_x = cs_x*100 + #print('x', cs_x) + cs_z = lma_z_ktyx[(new_dists-max_dist)] + #print('z', cs_z) + NewC = [plot_c[0]]*len(cs_z) + #print('c', NewC) + steps = ((distance.geodesic((points[1], points[0]), (points[3], points[2])).km)+((distance.geodesic((points[1], points[0]), (points[3], points[2])).km)/10)) + #print('Beginning') + # before **kwargs was added to the function call, the following arguments + # were specified as keywords separately. This allows backwards compatibility: + if plot_cmap is None: + plot_cmap = kwargs.pop('cmap', plot_cmap) + if plot_s is None: + plot_s = kwargs.pop('s', plot_s) + if plot_vmin is None: + plot_vmin = kwargs.pop('vmin', plot_vmin) + if plot_vmax is None: + plot_vmax = kwargs.pop('vmax', plot_vmax) + if plot_c is None: + plot_c = kwargs.pop('c', plot_c) + if edge_color == 'face': + edge_color = kwargs.pop('edgecolors', edge_color) + if edge_width == 0: + edge_width = kwargs.pop('linewidths', edge_width) + + art_plan = bk_plot.ax_plan.scatter(lon_data, lat_data, + c=plot_c, vmin=plot_vmin, vmax=plot_vmax, cmap=plot_cmap, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + #print('plan', alt_data) + art_th = bk_plot.ax_th.scatter(time_data, alt_data, + c=plot_c, vmin=plot_vmin, vmax=plot_vmax, cmap=plot_cmap, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + #print('th', alt_data) + art_lon = bk_plot.ax_lon.scatter(lon_data, alt_data, + c=plot_c, vmin=plot_vmin, vmax=plot_vmax, cmap=plot_cmap, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + #print('lon', alt_data) + art_lat = bk_plot.ax_lat.scatter(alt_data, lat_data, + c=plot_c, vmin=plot_vmin, vmax=plot_vmax, cmap=plot_cmap, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + #print('lat', alt_data) + cnt, bins, art_hist = bk_plot.ax_hist.hist(alt_data, orientation='horizontal', + density=True, bins=80, range=(0, 20), color='black') + + if radar_data != None: + bk_plot.ax_rad.add_feature(COUNTIES, facecolor='none', edgecolor='gray') + bk_plot.ax_rad.add_feature(cfeature.BORDERS) + bk_plot.ax_rad.add_feature(cfeature.STATES.with_scale('10m')) + bk_plot.ax_rad.set_title(f'{start} UTC \n Equivelent Reflectivity Factor', loc = 'center') + grid = bk_plot.ax_rad.gridlines(crs=ccrs.PlateCarree(), draw_labels=True, linestyle='--', color='gray') + radar_display = pyart.graph.GridMapDisplay(radar_data[radar_data[-1].index(start)], debug=True) + data = radar_display.grid.fields['reflectivity']['data'][1] + radar = bk_plot.ax_rad.pcolormesh(radar_display.grid.point_longitude['data'][0], radar_display.grid.point_latitude['data'][0], data, cmap = 'HomeyerRainbow', vmin = -20, vmax = 60) + grid.xlabels_top = False + grid.ylabels_right = False + #print(radar_display) + bk_plot.ax_rad.plot([points[0], points[2]], [points[1], points[3]], color = '#6a8f9c', linewidth = 2) + #print(radar_art_display) + #else: + #radar_art_display = bk_plot.ax_rad.scatter(lon_data[0], lat_data[0], alpha = 0, marker = '.') + #if radar_art_display != None: radar_art_display.show() + art_rad = bk_plot.ax_rad.scatter(lon_data, lat_data, + c=plot_c, vmin=plot_vmin, vmax=plot_vmax, cmap=colour_map, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + #print(art_rad) + if (len(flash_events['alt'])==0): + art_vel = None + print(" ") + else: + if(type(lat_data) == pd.core.series.Series): + lat_data = lat_data.to_numpy() + if(type(lon_data) == pd.core.series.Series): + lon_data = lon_data.to_numpy() + if(type(time_data) == pd.core.series.Series): + time_data = time_data.to_numpy() + + first = np.nanargmin(time_data) + + distance_from_origin, time_from_origin = get_time_distance(lat_data, lon_data, time_data, + lat_data[first], lon_data[first], time_data[first]) + + print('Num Points: ', len(distance_from_origin)) + + art_vel = time_distance_plot(bk_plot.ax_vel, time_from_origin, distance_from_origin, + c=alt_data, vmin=0, vmax=6, cmap='cool', + s=plot_s, marker='o', linewidths=edge_width, edgecolors=edge_color) + + if radar_data != None: + proj_params = radar_display.grid.get_projparams() + radar_crs = ccrs.AzimuthalEquidistant(central_longitude=proj_params['lon_0'], central_latitude=proj_params['lat_0']) + projection_info = radar_crs.to_cf() + ds = radar_display.grid.to_xarray().metpy.assign_crs(projection_info) + ds = cross_section(ds, [points[1], points[0]], [points[3], points[2]], steps, 'linear').set_coords(('lat', 'lon')) + ds['z'] = ds['z']/1000 + ds['reflectivity'].plot(y='z', vmin=-20, vmax=60, ax=bk_plot.ax_rcs, cmap='HomeyerRainbow', add_colorbar=False) + ds['velocity'].plot(y='z', vmin=-40, vmax=40, ax=bk_plot.ax_vcs, cmap='NWSVel', add_colorbar=False) + ds['spectrum_width'].plot(y='z', vmin=0, vmax=14.1, ax=bk_plot.ax_swcs, cmap='NWS_SPW', add_colorbar=False) + ds['differential_reflectivity'].plot(y='z', vmin=-2, vmax=6, ax=bk_plot.ax_drcs, cmap='RefDiff', add_colorbar=False) + ds['differential_phase'].plot(y='z', vmin=-1, vmax=4.1, ax=bk_plot.ax_sdpcs, cmap='SCook18', add_colorbar=False) + ds['cross_correlation_ratio'].plot(y='z', vmin=0.7, vmax=1.03, ax=bk_plot.ax_cccs, cmap='SCook18', add_colorbar=False) + #radar_display.mappables.append(plot) + bk_plot.ax_rcs.set_ylabel('') + bk_plot.ax_rcs.set_xlabel('') + bk_plot.ax_rcs.set_title('') + bk_plot.ax_rcs.set_ylim(top=max_z) + bk_plot.ax_vcs.set_ylabel('') + bk_plot.ax_vcs.set_xlabel('') + bk_plot.ax_vcs.set_title('') + bk_plot.ax_vcs.set_ylim(top=max_z) + bk_plot.ax_swcs.set_ylabel('') + bk_plot.ax_swcs.set_xlabel('') + bk_plot.ax_swcs.set_title('') + bk_plot.ax_swcs.set_ylim(top=max_z) + bk_plot.ax_drcs.set_ylabel('') + bk_plot.ax_drcs.set_xlabel('') + bk_plot.ax_drcs.set_title('') + bk_plot.ax_drcs.set_ylim(top=max_z) + bk_plot.ax_sdpcs.set_ylabel('') + bk_plot.ax_sdpcs.set_xlabel('') + bk_plot.ax_sdpcs.set_title('') + bk_plot.ax_sdpcs.set_ylim(top=max_z) + bk_plot.ax_cccs.set_ylabel('') + bk_plot.ax_cccs.set_xlabel('') + bk_plot.ax_cccs.set_title('') + bk_plot.ax_cccs.set_ylim(top=max_z) + + art_rcs = bk_plot.ax_rcs.scatter(cs_x, cs_z, + c=NewC, vmin=plot_vmin, vmax=plot_vmax, cmap = colour_map, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + art_vcs = bk_plot.ax_vcs.scatter(cs_x, cs_z, + c=NewC, vmin=plot_vmin, vmax=plot_vmax, cmap = colour_map, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + art_swcs = bk_plot.ax_swcs.scatter(cs_x, cs_z, + c=NewC, vmin=plot_vmin, vmax=plot_vmax, cmap = colour_map, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + art_drcs = bk_plot.ax_drcs.scatter(cs_x, cs_z, + c=NewC, vmin=plot_vmin, vmax=plot_vmax, cmap = colour_map, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + art_sdpcs = bk_plot.ax_sdpcs.scatter(cs_x, cs_z, + c=NewC, vmin=plot_vmin, vmax=plot_vmax, cmap = colour_map, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + art_cccs = bk_plot.ax_cccs.scatter(cs_x, cs_z, + c=NewC, vmin=plot_vmin, vmax=plot_vmax, cmap = colour_map, + s=plot_s, marker=marker, linewidths=edge_width, edgecolors=edge_color, **kwargs) + + art_txt = plt.text(0.25, 0.10, str(len(alt_data)) + ' src', + fontsize='small', horizontalalignment='left', + verticalalignment='center',transform=bk_plot.ax_hist.transAxes) + #print(display_rad) + art_out = [art_plan, art_th, art_lon, art_lat, art_rad, art_rcs, art_vcs, art_swcs, art_drcs, art_sdpcs, art_cccs] + if art_vel is not None: + art_out.extend(art_vel) + if radar_data != None: + for lists in bk_plot.ax_rad.collections: + art_out.insert(-1, lists) + for lists2 in bk_plot.ax_rcs.collections: + art_out.insert(-1, lists2) + for lists3 in bk_plot.ax_vcs.collections: + art_out.insert(-1, lists3) + for lists4 in bk_plot.ax_swcs.collections: + art_out.insert(-1, lists4) + for lists5 in bk_plot.ax_drcs.collections: + art_out.insert(-1, lists5) + for lists6 in bk_plot.ax_sdpcs.collections: + art_out.insert(-1, lists6) + for lists7 in bk_plot.ax_cccs.collections: + art_out.insert(-1, lists7) + #art_out.extend(radar_art_display) + + if add_to_histogram: + cnt, bins, art_hist = bk_plot.ax_hist.hist(alt_data, orientation='horizontal', + density=True, bins=80, range=(0, 20), color='black') + art_txt = plt.text(0.25, 0.10, str(len(alt_data)) + ' src', + fontsize='small', horizontalalignment='left', + verticalalignment='center',transform=bk_plot.ax_hist.transAxes) + # art_hist is a tuple of patch objects. Make it a flat list of artists + art_out.append(art_txt) + art_out.append(art_hist) + #print(art_out) + return art_out + +def plot_3d_grid(bk_plot, xedges, yedges, zedges, tedges, + alt_lon, alt_lat, alt_time, lat_lon, + alt_data, plot_cmap): + """ + Plot gridded fields on an existing bk_plot given x,y,z,t grids and + respective grid edges + """ + alt_lon[alt_lon==0]=np.nan + alt_lat[alt_lat==0]=np.nan + lat_lon[lat_lon==0]=np.nan + alt_time[alt_time==0]=np.nan + bk_plot.ax_lon.pcolormesh( xedges, zedges, alt_lon.T, cmap=plot_cmap, vmin=0) + bk_plot.ax_lat.pcolormesh( zedges, yedges, alt_lat.T, cmap=plot_cmap, vmin=0) + bk_plot.ax_plan.pcolormesh(xedges, yedges, lat_lon.T, cmap=plot_cmap, vmin=0) + bk_plot.ax_th.pcolormesh( tedges, zedges, alt_time.T, cmap=plot_cmap, vmin=0) + bk_plot.ax_hist.hist(alt_data, orientation='horizontal', + density=True, bins=80, range=(0, 20)) + plt.text(0.25, 0.10, str(len(alt_data)) + ' src', + fontsize='small', horizontalalignment='left', + verticalalignment='center',transform=bk_plot.ax_hist.transAxes) + +def plot_super_2d_network_points(bk_plot, netw_data, actual_height=None, fake_ic_height=18, fake_cg_height=1, + color_by='time', pos_color='blue', neg_color='red', **kwargs): + """ + Plot points from a 2D lightning mapping neworks (ie, NLDN, ENTLN, etc) + + Parameters + ---------- + bk_plot : `pyxlma.plot.xlma_base_plot.BlankPlot` + A BlankPlot object to plot the data on + netw_data : `pandas.DataFrame` or `xarray.Dataset` + data object with columns/variables 'longitude', 'latitude', 'type' (CG/IC), and 'datetime' + actual_height : `numpy.ndarray` or `pandas.Series` or `xarray.DataArray` + the hieghts of the events to be plotted (default None, fake_ic_height and fake_cg_height used) + fake_ic_height : float + the altitude to plot IC points (default 18 km) + fake_cg_height : float + the altitude to plot CG points (default 1 km) + color_by : ['time', 'polarity'] + Whether to color the points by time or polarity. Default 'time'. Ignored if **kwargs contains 'c'. + pos_color : str + color for positive points (default 'red') if color_by='polarity' + neg_color : str + color for negative points (default 'blue') if color_by='polarity' + **kwargs + additional keyword arguments to pass to plt.scatter + + Returns + ------- + art_out2 : list + nested lists of artists created by plot_points (first list CG, second list IC) + + """ + + plot_c = kwargs.pop('c', None) + vmin = kwargs.pop('vmin', None) + vmax = kwargs.pop('vmax', None) + marker = kwargs.pop('marker', '^') + marker2 = kwargs.pop('marker', 'v') + if actual_height is not None: + netw_data['height'] = actual_height + + if plot_c is not None: + netw_data['plot_c'] = color_by_time(netw_data.datetime, bk_plot.tlim)[2] + elif color_by == 'polarity': + netw_data['plot_c'] = plot_c + elif color_by == 'time': + pass + else: + raise ValueError("color_by must be 'time' or 'polarity'") + + cgs = netw_data[netw_data['type']==0].copy() + #print(netw_data['type']==0) + #print(cgs) + ics = netw_data[netw_data['type']==1].copy() + #print(ics) + + if actual_height is None: + cgs['height'] = np.full_like(cgs.longitude, fake_cg_height) + ics['height'] = np.full_like(ics.longitude, fake_ic_height) + art_out2 = [] + if color_by == 'polarity': + cgpos = cgs[cgs.peak_current_kA>0] + cgneg = cgs[cgs.peak_current_kA<0] + icpos = ics[ics.peak_current_kA>0] + icneg = ics[ics.peak_current_kA<0] + #Negative CG plotting + print("Negative CG") + if not cgneg.empty: + art_out2.extend(plot_super_points(bk_plot, cgneg.longitude, cgneg.latitude, cgneg.height*1000, + cgneg.datetime, plot_c=neg_color, marker=marker2, add_to_histogram=False, **kwargs)) + else: print('empty') + #Positive CG plotting + print('Positive CG') + if not cgpos.empty: + art_out2.extend(plot_super_points(bk_plot, cgpos.longitude, cgpos.latitude, cgpos.height*1000, + cgpos.datetime, plot_c=pos_color, marker=marker2, add_to_histogram=False, **kwargs)) + else: print('empty') + #Negative IC plotting + print('Negative IC') + if not icneg.empty: + art_out2.extend(plot_super_points(bk_plot, icneg.longitude, icneg.latitude, icneg.height*1000, + icneg.datetime, plot_c=neg_color, marker=marker, add_to_histogram=False, **kwargs)) + else: print('empty') + #Positive IC plotting + print('Positive IC') + if not icpos.empty: + art_out2.extend(plot_super_points(bk_plot, icpos.longitude, icpos.latitude, icpos.height*1000, + icpos.datetime, plot_c=pos_color, marker=marker, add_to_histogram=False, **kwargs)) + else: print('empty') + else: + art_out2.extend(plot_super_points(bk_plot, cgs.longitude, cgs.latitude, cgs.height*1000, + cgs.datetime, c=cgs.plot_c, vmin=vmin, vmax=vmax, marker=marker2, add_to_histogram=False, **kwargs)) + art_out2.extend(plot_super_points(bk_plot, ics.longitude, ics.latitude, ics.height*1000, + ics.datetime, c=ics.plot_c, vmin=vmin, vmax=vmax, marker=marker, add_to_histogram=False, **kwargs)) + return art_out2