We’d love to hear what you think of data latency requirements to be considered by the GEO-XO (Geostationary and Extended Orbits – operational 2030-2050 timeframe) Program.
Please fill out this short survey [link to Google Form] to give us your feedback. Please take the time to complete it prior to the close of business on November 5, 2020.
Caro usuário GNC-A,
Gostaríamos de saber sua opinião sobre os requisitos de latência de dados a serem considerados pelo programa GEO-XO (órbitas geoestacionárias e estendidas – período operacional 2030-2050).
Preencha esta breve pesquisa [link para o Formulário Google] para nos enviar seus comentários. Reserve um tempo para concluí-lo antes do término do horário comercial de 5 de novembro de 2020.
Estimado usuario de GNC-A,
Nos encantaría conocer su opinión sobre los requisitos de latencia de datos que debe considerar el programa GEO-XO (órbitas geoestacionarias y extendidas – período operativo 2030-2050).
Complete esta breve encuesta [enlace al formulario de Google] para enviarnos sus comentarios. Tómese el tiempo para completarlo antes del termino del horario comercial del 5 de noviembre de 2020.
William Abarca, from MARN – El Salvador, kindly shared the video below where he shows some Python scripts to process satellite imagery in great detail. Also, in the end he shows the steps followed to use Python scripts operationally using SHOWCast. Thanks William!
Escuela Superior Politécnica del Litoral (ESPOL) and the Instuto Nacional de Meteorología e Hidrología (INAMHI) in Ecuador are hosng a virtual satellite workshop in Spanish for parcipants from the World Meteorological Organizaon (WMO) South America Region III in November 2020. The training will be on Tuesday, November 10th, Thursday 12th, and Tuesday, Wednesday, and Thursday November 17, 18 and 19.
The workshop will cover both GOES-R and JPSS satellite capabilies and data access to support AmeriGEO Societal Benefit Areas (SBA’s) and the WMO’s Region III forecast challenges. This is a Spanish language only event with no simultaneous interpretaon available.
Daily sessions will have an overview of GOES-R and JPSS satellites, their instruments, data, products and tools, and opportunies for hands-on exercises involving local case studies, for parcipants to use the satellite data for understanding environmental scenarios and making forecasts.
Each day will begin 09:00 AM Ecuador me (ECT) (14:00 UTC) and end 16:45 ECT (21:45 UTC). Because of COVID-19, this is a virtual training workshop. Parcipants will be required to provide their own computing accommodations.
Registration is required. Because of the virtual nature of the training, there will be a pre-orientation training session to confirm parcipation, data access, and provide the atendees with case studies and materials ahead of ti me. Please note that space will be limited and if the number of people registered exceeds the capacity of the webinar, we may implement a selection process to ensure that all South American countries are represented. There is no registration fee for the workshop.
The link to register for the workshop is here. Deadline to register for the workshop is 23 October 2020 . The link to the current agenda is here on the Workshop information page.
It is strongly recommended that parcipants complete the following online modules in advance to prepare for the workshop: ● GOES-R Satellites Orientaon Course (Curso de orientación sobre los satélites GOES-R) . Only three modules are suggested. The Spanish tles of these modules are: ○ GOES-R: beneficios de la observación ambiental de próxima generación ○ El ABI del GOES-R: la próxima generación de imágenes satelitales ○ El GLM del GOES-R: introducción al sensor de rayos geoestacionario
● Satellite Foundaon Course for JPSS (Curso básico de satélites para el JPSS) . Only four modules are suggested. The Spanish titles of these modules are: ○ Introducción a la teledetección por microondas ○ Bandas de absorción del oxígeno y del vapor de agua ○ Emisividad superficial de microondas ○ Influencia de las nubes y la precipitación.
By the end of the workshop, parcipants will have a working knowledge of the GOES-R Series and JPSS key instruments as well as develop competency in working with the data and products for weather forecasting, prediction, monitoring or research through hands-on exercises and case studies. A cerficate of parcipation will be provided to participants actively engaged in all sessions.
La Escuela Superior Politécnica del Litoral (ESPOL) y el Instuto Nacional de Meteorología e Hidrología (INAMHI) en Ecuador están conduciendo un taller virtual en español para parcipantes de la Asociación Regional III (Suramérica) de la Organización Meteorológica Mundial (OMM), en noviembre de 2020. El entrenamiento se conducirá los días martes 10, jueves 12, martes 17, miércoles 18 y jueves 19 de noviembre.
El taller cubrirá las capacidades de los satélites del GOES-R and JPSS y el acceso a datos para el apoyo de Áreas de Beneficio para la Sociedad (SBA, por sus siglas en inglés); y los retos del pronósco para la Región III de la OMM. El taller será conducido en español.
Las sesiones diarias cubrirán los satélites GOES-R y JPSS, sus instrumentos, productos de datos y herramientas y oportunidades para ejercicios interacvos ulizando casos de estudio, para que los parcipantes del taller puedan opmizar el uso de información de satélites para comprender mejor escenarios ambientales y producir pronósticos.
Cada día, los entrenamientos iniciarán a las 09:00 AM hora de Ecuador (ECT) (14:00 UTC) y culminarán a las 16:45 ECT (21:45 UTC). Debido al COVID-19, este será un entrenamiento virtual. Se requiere que los parcipantes trabajen con sus propias computadoras.
Registro en el taller es requerido. Se conducirá una sesión de orientación antes del taller para confirmar la parcipación, el acceso a datos y para proporcionar a los parcipantes materiales y casos de estudio con ancipación. Note que el espacio será limitado y si el número de parcipantes registrado excede la capacidad del taller, podríamos implementar un proceso de selección para asegurar que todos los países de Suramérica sean representados apropiadamente. La parcipación es gratuita.
El enlace para registrarse está aquí . La fecha límite para registrarse es el 23 de octubre del 2020 . El enlace para la agenda actual está aquí y la página informava del taller aquí .
Se recomienda enfáticamente que los parcipantes del taller completen los siguientes módulos. No es necesario entregarnos los cerficados al completar cada uno:
Para el final del taller, los parcipantes habrán adquirido conocimiento sobre la serie GOES-R y JPSS, sus instrumentos clave; y habrán desarrollado competencias sobre cómo trabajar e interpretar los datos y productos para pronóscos del tiempo, monitoreo e invesgación, a través de los ejercicios y casos de estudio. Se otorgará un cerficado a los asistentes que parcipen activamente en todas las sesiones.
O nosso próximo webinar será sobre “Introdução ao Mapeador de Raios (GLM – Geostationary Lightning Mapper) dos satélites GOES-16/17 e suas aplicações”, com a Profa. Dra. Rachel Ifanger Albrecht (USP), na sexta feira, 09 de outubro de 2020, das 14-15:00 BRT.
Seguem os detalhes do webinar:
Webinar: Introdução ao Mapeador de Raios (GLM – Geostationary Lightning Mapper) dos satélites GOES-16/17 e suas aplicações
Conteúdo: Este webinar apresentará a base física da eletrificação das nuvens e da formação dos raios, mostrando a necessidade das informações de raios totais em tempo real e como o Mapeador de Raios GLM dos satélites GOES-16/17 atende a essas necessidades. Também serão abordados os princípios de detecção de raios no solo e no espaço, e quais são os métodos de detecção e definições das variáveis observadas pelo GLM. São mostrados alguns produtos derivados das observações do GLM e algumas das muitas áreas de aplicação, como a previsão imediata de convecção e tempo severo, avisos de riscos iminentes de descargas nuvem-solo, a aviação, os estudos de química atmosférica, a estimativa quantitativa de precipitação, ciclones tropicais, incêndios florestais, previsão numérica de tempo e clima e estudos climáticos e globais
A Profa. Dra. Rachel Ifanger Albrecht é docente do Departamento de Ciências Atmosféricas da Universidade de São Paulo nas áreas de física de nuvens, eletricidade atmosférica e previsão imediata de tempo severo. Ela é membro do time científico do GOES-R GLM (Geostationary Lightning Mapper) e também está envolvida nas atividades de pesquisa dos satélites Tropical Rainfall Measurement Mission (TRMM) e Global Precipitation Measurement (GPM) da NASA. É membro do Nowcasting and Mesoscale Research Working Group e Inter-Programme Expert Team on Satellite Utilization and Products da Organização Meteorológica Mundial (OMM) e membro do IAMAS International Commission on Clouds and Precipitation. Recebeu títulos de Bacharel (2000), Mestre (2004) e Doutor (2008) em Meteorologia pela Universidade de São Paulo. Antes de se juntar ao corpo docente da Universidade de São Paulo em 2014, ela foi Pesquisadora Associada do Cooperative Institute for Climate and Satellites (CICS) da NOAA na Universidade de Maryland, E.U.A. (2008 a 2010), e Pesquisadora do Centro de Previsão de Tempo e Estudos Climáticos (CPTEC) do Instituto Nacional de Pesquisas Espaciais (INPE) (2010 a 2014).
Lectura de archivos NetCDF de la serie GOES-R (GOES-16 o 17)
Hacer un plot básico de GOES-R y visualizar los valores de los píxeles (temperaturas de brillo / reflectancias)
Cambiar las escalas de colores, leer la fecha, añadir un título y una barra de colores al plot
Agregar mapas de países, estados / provincias (y otros shapefiles)
Crear un plot recortado de alta resolución
Crear una composición RGB
Leer datos del sensor GLM
Duración: 2:00 h, incluyendo la instalación
Prerrequisitos:
Para este ejercicio, necesitaremos lo siguiente:
Python 3.8 (nuestro lenguaje de programación)
Un “Administrador de paquetes” (para instalar librerías)
Un “Administrador de ‘Entornos Virtuales Python'” (para separar nuestros proyectos)
Un editor de texto (para escribir nuestro código)
Muestras de imágenes del GOES-R (los datos a manipular)
Para los primeros tres (“Python 3.8”, “Administrador de Paquetes” y “Administrador de ‘Entornos Virtuales Python'”), la herramienta “Miniconda” será suficiente.
En cuanto al editor de texto, hay muchas opciones disponibles (Visual Studio Code, Spyder, PyCharm, Atom, Jupyter Notebooks, etc.), pero por simplicidad, en este procedimineto usaremos “Notepad ++” (o “Notepadqq” en Linux).
Para las muestras de imágenes GOES-R, las descargaremos de la nube (Amazon en este caso). También puede obtenerlos de otros mecanismos de recepción (GRB, GNC-A, UNIDATA, etc.).
Pasos de la instalación:
1) Descargue e instale el Miniconda para Python 3.8 en el siguiente enlace (solo 60 MB):
Encuentre instrucciones sobre cómo instalar Miniconda para Windows y Linux.
Notas (instalador Windows):
Durante la instalación, no es necesario marcar “Add Anaconda to my Path environment variable”.
Puede marcar “Register Anaconda as my default Python 3.7”
Notas (instalador Linux):
En la instalación Linux, puedes elegir donde deseas instalarlo con el parametro “-p”:
workshop: el nombre de su entorno virtual Python. Podría ser cualquier cosa, como “satellite”, “goes”, etc.
matplotlib netcdf4 cartopy: las librerias que queremos instalar
Notas:
Durante la instalación, escriba “y” + Enter para continuar, cuando se le solicite.
Este procedimiento debería tomar aproximadamente 10 minutos.
Finalmente, active el entorno virtual Python recién creado con el siguiente comando:
conda activate workshop
Nota: Si está utilizando Linux, puedes usar también el comando “source activate workshop”
Informaciones adicionales: aunque los siguientes comandos no son necesarios para los ejercicios de hoy, es muy interesante conocerlos para el futuro:
Desactivar un entorno virtual Python: conda deactivate (en el entorno activado) Visualización de la lista de entornos virtuales: conda env list Ver una lista de paquetes (bibliotecas, etc.) instalados en un entorno: conda list
Puede encontrar más información sobre la gestión de entornos en este enlace.
Estamos listos para comenzar a usar Python, sin embargo, necesitamos un editor para escribir nuestro código y también, necesitamos algunas imágenes de GOES-R de muestra.
Descargando un Editor de Textos:
3)Windows: Descargue e instale Notepad++ en el siguiente enlace (solo 4 MB):
Linux: Puedes instalar el Notepadqq con el siguiente comando:
# sudo apt-get install notepadqq
Nota:
Puede usar cualquier editor de texto o IDE que desee (Gedit, Visual Studio Code, Spyder, PyCharm, Atom, Jupyter Notebooks, etc.), guardando el archivo de código usando la extensión “.py”.
Descargando muestras NetCDF de GOES-R:
4) Crea una carpeta llamada VLAB\Python\ en su máquina (por ejemplo: C:\VLAB\Python\). Esta será nuestra carpeta de trabajo.
Satellite: Puedes elegir “GOES-16/East” o “GOES-17/West”
Domain: Full Disk
Product: ABI L2 Cloud and Moisture Imagery
Date and Hour (UTC): ¡Cualquier fecha y hora que desee!
Haga clic en “Submit” y luego descargue un archivo para la Banda 13, haciendo clic en los cuadros azules con los minutos de esa hora (elija el minuto que desee).
Nota: Para los pantallazos de esta página, hemos descargado archivos del GOES-16 para el 17 de julio de 2019 a las 12:00 UTC.
El NetCDF será descargado.
Ponga el NetCDF en la carpeta que acaba de crear (por ejemplo: C:\VLAB\Python\)
¡Estamos listos para comenzar!
PRÁCTICA 1: PRIMER PLOT Y OBTENCIÓN DE VALORES DE PIXEL
6) Abra su editor de texto (en nuestro ejemplo, “Notepad ++”), inserte el código a continuación y guárdelo como “Script_01.py”, dentro de la carpeta C:\VLAB\Python\ (el mismo directorio donde tiene su muestra NetCDF):
Importante: en la línea 8, inserte el nombre del archivo NetCDF que acaba de descargar en el paso anterior.
# Costa Rica Training: Python and GOES-R Imagery: Script 1 - Basic Plot / Extracting Pixel Values
# Required modules
from netCDF4 import Dataset # Read / Write NetCDF4 files
import matplotlib.pyplot as plt # Plotting library
# Open the GOES-R image
file = Dataset("OR_ABI-L2-CMIPF-M6C13_G16_s20191981200396_e20191981210116_c20191981210189.nc")
#Get the pixel values
data = file.variables['CMI'][:]
# Choose the plot size (width x height, in inches)
plt.figure(figsize=(7,7))
# Plot the image
plt.imshow(data, vmin=193, vmax=313, cmap='Greys')
# Save the image
plt.savefig('Image_01.png')
#Show the image
plt.show()
PUEDES DESCARGAR EL SCRIPT ARRIBA (Script_01.py) EN ESTE ENLACE
La imagen abajo muestra el script abierto en Notepad ++:
En el “Anaconda Prompt”, con el entorno virtual Python “workshop” activado, acceda al directorio C:\VLAB\Python\ (o tu directório de trabajo):
cd C:\VLAB\Python
Ejecute el script “Script_01.py” con el siguiente comando:
python Script_01.py
Aparecerá una nueva ventana y deberías ver tu primer plot GOES-R hecho con Python:
Viendo las temperaturas de brillo:
Mueva el puntero del mouse sobre el plot y verá los valores de píxeles de la Banda 13 en Temperaturas de brillo (K) en la parte inferior izquierda de la pantalla. En la imagen de ejemplo a continuación, esta temperatura superior de la nube en particular es 227 K:
Zoom en una región específica
Para hacer zoom en una región determinada, simplemente haga clic en el icono de lupa en la parte superior de la pantalla y seleccione la región que desea acercar.
Para volver a la vista completa, haga clic en el icono “Home”.
Además de la pantalla de visualización, se ha guardado una imagen PNG llamada ‘Image_01.png’ en su directorio de trabajo (C:\VLAB\Python\ en este ejemplo).
¿Qué puedes cambiar rápidamente en este script?
La imagen a leer: Intente descargar otras imágenes de Amazon (otras horas, fechas y bandas) y haga un nuevo plot.
El tamaño final de la imagen: Intenta generar imágenes con otras dimensiones. Qué cambiarías para elegir el tamaño en cm al inves de pulgadas?
Los valores mínimos y máximos: Intente cambiar los valores mínimos y máximos de Kelvin para ver diferentes contrastes.
PRÁCTICA 2: CONVERTIR A CELSIUS, LEER LA FECHA, AGREGAR UNA BARRA DE COLOR Y UN TÍTULO
Creemos nuestro segundo script. Guarde un archivo llamado “Script_02.py”.
Para convertir los píxeles a Celsius, simplemente agregue la siguiente resta a la línea 11:
# Get the pixel values
data = file.variables['CMI'][:] - 273.15
Al hacer esto, tenemos que cambiar los valores mínimos y máximos de nuestro mapa de colores, de 193 ~ 313 K a -80 ~ 40 ° C:
# Plot the image
plt.imshow(data, vmin=-80, vmax=40, cmap='Greys')
Para añadir una barra de colores, simplemente agregue la siguiente línea al script:
Para leer la fecha, agregue las siguientes líneas al script:
from datetime import datetime # Basic Dates and time types
# Extract date
date = (datetime.strptime(file.time_coverage_start, '%Y-%m-%dT%H:%M:%S.%fZ'))
Para añadir un Título, agregue las siguientes líneas al script:
# Add a title
plt.title('GOES-16 Band 13 ' + date.strftime('%Y-%m-%d %H:%M') + ' UTC', fontweight='bold', fontsize=10, loc='left')
plt.title('Full Disk', fontsize=10, loc='right')
Este debería ser tu script completo por ahora:
# Training: Python and GOES-R Imagery: Script 2 - Basic Operation / Colorbar / Title / Date
# Required modules
from netCDF4 import Dataset # Read / Write NetCDF4 files
import matplotlib.pyplot as plt # Plotting library
from datetime import datetime # Basic Dates and time types
# Open the GOES-R image
file = Dataset("OR_ABI-L2-CMIPF-M6C13_G16_s20191981200396_e20191981210116_c20191981210189.nc")
# Get the pixel values
data = file.variables['CMI'][:] - 273.15
# Choose the plot size (width x height, in inches)
plt.figure(figsize=(7,7))
Plot the image
plt.imshow(data, vmin=-80, vmax=40, cmap='Greys')
# Add a colorbar
plt.colorbar(label='Brightness Temperature (°C)', extend='both', orientation='horizontal', pad=0.05, fraction=0.05)
# Extract date
date = (datetime.strptime(file.time_coverage_start, '%Y-%m-%dT%H:%M:%S.%fZ'))
# Add a title
plt.title('GOES-16 Band 13 ' + date.strftime('%Y-%m-%d %H:%M') + ' UTC', fontweight='bold', fontsize=10, loc='left')
plt.title('Full Disk', fontsize=10, loc='right')
# Save the image
plt.savefig('Image_02.png')
# Show the image
plt.show()
PUEDES DESCARGAR EL SCRIPT ARRIBA (Script_02.py) EN ESTE ENLACE
Ejecute el script “Script_02.py” con el siguiente comando:
python Script_02.py
Deberías ver la siguiente trama:
Cambiar el mapa de colores (cmap):
Ahora, en la línea 18, cambie el cmap de ‘Greys’ a ‘jet’.
# Plot the image
plt.imshow(data, vmin=-80, vmax=40, cmap='jet')
Busque en el siguiente enlace los mapas de color disponibles en Python (nuevos pueden ser añadidos, pero no vamos a ver en este tutorial):
Además de la pantalla de visualización, se ha guardado una imagen PNG llamada ‘Image_02.png’ en su directorio de trabajo (C:\VLAB\Python\).
¿Qué puedes cambiar rápidamente en este script?
El mapa de colores. Intente hacer plots con diferentes mapas de colores del enlace arriba.
El título de la imagen. Intenta cambiar el tamaño del texto.
La apariencia de la barra de colores. Intente cambiar la orientación a “vertical” y el tamaño de la barra de colores cambiando el valor de “fraction”
PRÁCTICA 3: AGREGANDO MAPAS CON CARTOPY
Creemos nuestro tercer script. Guarde un archivo llamado “Script_03.py”.
Para usar cartopy en nuestro plot, este es el script que usaremos:
# Training: Python and GOES-R Imagery: Script 3 - Adding a Map with Cartopy
# Required modules
from netCDF4 import Dataset # Read / Write NetCDF4 files
import matplotlib.pyplot as plt # Plotting library
import cartopy, cartopy.crs as ccrs # Plot maps
from datetime import datetime # Basic Dates and time types
# Open the GOES-R image
file = Dataset("OR_ABI-L2-CMIPF-M6C13_G16_s20191981200396_e20191981210116_c20191981210189.nc")
# Get the pixel values
data = file.variables['CMI'][:] - 273.15
# Choose the plot size (width x height, in inches)
plt.figure(figsize=(7,7))
# Use the Geostationary projection in cartopy
ax = plt.axes(projection=ccrs.Geostationary(central_longitude=-75.0, satellite_height=35786023.0))
img_extent = (-5434894.67527,5434894.67527,-5434894.67527,5434894.67527)
# Add coastlines, borders and gridlines
ax.coastlines(resolution='10m', color='white', linewidth=0.8)
ax.add_feature(cartopy.feature.BORDERS, edgecolor='white', linewidth=0.5)
ax.gridlines(color='white', alpha=0.5, linestyle='--', linewidth=0.5)
# Plot the image
img = ax.imshow(data, vmin=-80, vmax=40, origin='upper', extent=img_extent, cmap='Greys')
# Add a colorbar
plt.colorbar(img, label='Brightness Temperatures (°C)', extend='both', orientation='horizontal', pad=0.05, fraction=0.05)
# Extract date
date = (datetime.strptime(file.time_coverage_start, '%Y-%m-%dT%H:%M:%S.%fZ'))
# Add a title
plt.title('GOES-16 Band 13 ' + date.strftime('%Y-%m-%d %H:%M') + ' UTC', fontweight='bold', fontsize=10, loc='left')
plt.title('Full Disk', fontsize=10, loc='right')
# Save the image
plt.savefig('Image_03.png')
# Show the image
plt.show()
PUEDES DESCARGAR EL SCRIPT ARRIBA (Script_03.py) EN ESTE ENLACE
Ejecute el script “Script_03.py” con el siguiente comando:
python Script_03.py
El siguiente plot será creado:
Viendo las latitudes, longitudes y temperaturas de brillo:
Mueva el puntero del mouse sobre el plot y, aparte de los valores de píxeles de la Banda 13 en Temperaturas de brillo (° C), verá las coordenadas de los píxeles:
Además de la pantalla de visualización, se ha guardado una imagen PNG llamada ‘Image_03.png’ en su directorio de trabajo (C:\VLAB\Python\).
¿Qué puedes cambiar rápidamente en este script?
Los colores del mapa (en las variables “color” y “edgecolor”).
Los anchos de las lineas (en las variables “linewidth”).
En este enlace, encuentre una lista de colores con los nombres de cada color, que pueden ser especificados en el código.
PRÁCTICA 4: AGREGANDO SHAPEFILES
Creemos nuestro cuarto script. Guarde un archivo llamado “Script_04.py”.
Descargue un shapefile de muestra, con los estados y provincias del mundo en este enlace. Extraiga el erchivo zip en su directorio de trabajo (por ejemplo, C:\VLAB\Python\), donde tiene sus scripts e imágenes de muestra.
Esto es lo que debería tener en su directorio ahora:
Para agregar un shapefile, necesitamos importar el “shapereader” de Cartopy:
import cartopy.io.shapereader as shpreader # Import shapefiles
Y agregar el shapefile a la visualización con los siguientes comandos:
# Training: Python and GOES-R Imagery: Script 4 - Adding a Shapefile
# Required modules
from netCDF4 import Dataset # Read / Write NetCDF4 files
import matplotlib.pyplot as plt # Plotting library
import cartopy, cartopy.crs as ccrs # Plot maps
import cartopy.io.shapereader as shpreader # Import shapefiles
from datetime import datetime # Basic Dates and time types
# Open the GOES-R image
file = Dataset("OR_ABI-L2-CMIPF-M6C13_G16_s20191981200396_e20191981210116_c20191981210189.nc")
# Get the pixel values, and convert to Celsius
data = file.variables['CMI'][:] - 273.15
# Choose the plot size (width x height, in inches)
plt.figure(figsize=(7,7))
# Use the Geostationary projection in cartopy
ax = plt.axes(projection=ccrs.Geostationary(central_longitude=-75.0, satellite_height=35786023.0))
img_extent = (-5434894.67527,5434894.67527,-5434894.67527,5434894.67527)
# Add a shapefile
shapefile = list(shpreader.Reader('ne_10m_admin_1_states_provinces.shp').geometries())
ax.add_geometries(shapefile, ccrs.PlateCarree(), edgecolor='gold',facecolor='none', linewidth=0.3)
# Add coastlines, borders and gridlines
ax.coastlines(resolution='10m', color='white', linewidth=0.8)
ax.add_feature(cartopy.feature.BORDERS, edgecolor='white', linewidth=0.8)
ax.gridlines(color='white', alpha=0.5, linestyle='--', linewidth=0.5)
# Plot the image
img = ax.imshow(data, vmin=-80, vmax=40, origin='upper', extent=img_extent, cmap='Greys')
# Add a colorbar
plt.colorbar(img, label='Brightness Temperature (°C)', extend='both', orientation='horizontal', pad=0.05, fraction=0.05)
# Extract date
date = (datetime.strptime(file.time_coverage_start, '%Y-%m-%dT%H:%M:%S.%fZ'))
# Add a title
plt.title('GOES-16 Band 13 ' + date.strftime('%Y-%m-%d %H:%M') + ' UTC', fontweight='bold', fontsize=10, loc='left')
plt.title('Full Disk', fontsize=10, loc='right')
# Save the image
plt.savefig('Image_04.png')
# Show the image
plt.show()
PUEDES DESCARGAR EL SCRIPT ARRIBA (Script_04.py) EN ESTE ENLACE
Ejecute el script “Script_04.py” con el siguiente comando:
python Script_04.py
Importante: este archivo de forma particular tiene un tamaño considerable. El script puede tardar un tiempo en ejecutarse.
El siguiente plot será creado:
Además de la pantalla de visualización, se ha guardado una imagen PNG llamada ‘Image_04.png’ en su directorio de trabajo (C:\VLAB\Python\ en este ejemplo).
¿Qué puedes cambiar rápidamente en este script?
El shapefile para ser leído. Intente agregar otros shapefiles de su preferencia (por ejemplo: ríos o las ciudades de tu región).
Mira el ejemplo abajo, una empresa de energía en Brasil agregó un shapefile de sus lineas de transmisión. Muy interesante!
PRÁCTICA 5: PLOT DE ALTA RESOLUCIÓN– RECORTE POR LAT LONS
Creemos nuestro quinto script. Guarde un archivo llamado “Script_05.py”.
Vamos a bajar algun archivo del canal 2 (u otros visibles de 1 km por ejemplo), desde la interfaz de descarga de datos de la nube:
Hasta ahora, hemos estado trabajando con archivos del Canal 13, de 2 km de resolución. El sensor ABI posee 12 canales de 2 km (canales 4, 6, 7, 8, 9, 10, 11, 12, 13, 14 ,15 y 16), 3 canales de 1 km (canales 1, 3 y 5) y 1 canal de 0.5 km (canal 2). Para crear imagenes Full Disk de los canales de alta resolución (por ejemplo, el canal 2, de 0.5 km), es necesario un poder computcional considerable.
Una alternativa para crear imagenes de los canales de alta resolución en ordenadores menos potentes, es elegir solamente una región para la creación de las imagenes. El script abajo muestra como hacerlo.
Note preocupes con lel extenso código, es necesario cambiar solamente dos cosas para esta prueba:
Variable “extent” : la región que deseas procesar [min_lon, min_lat, max_lon, max_lat]
Variable “file” : el archivo que deseas leer.
# Training: Python and GOES-R Imagery: Script 5 - Cropping Full Disk Regions Using Lat Longs
# Required modules
from netCDF4 import Dataset # Read / Write NetCDF4 files
import matplotlib.pyplot as plt # Plotting library
import math # Mathematical functions
import cartopy, cartopy.crs as ccrs # Plot maps
import cartopy.io.shapereader as shpreader # Import shapefiles
from datetime import datetime # Basic Dates and time types
def geo2grid(lat, lon, xscale, xoffset, yscale, yoffset):
x, y = latlon2xy(lat, lon)
col = (x - xoffset)/xscale
lin = (y - yoffset)/yscale
return int(lin), int(col)
def latlon2xy(lat, lon):
# goes_imagery_projection:semi_major_axis
req = 6378137 # meters
# goes_imagery_projection:inverse_flattening
invf = 298.257222096
# goes_imagery_projection:semi_minor_axis
rpol = 6356752.31414 # meters
e = 0.0818191910435
# goes_imagery_projection:perspective_point_height + goes_imagery_projection:semi_major_axis
H = 42164160 # meters
# goes_imagery_projection: longitude_of_projection_origin
lambda0 = -1.308996939
# Convert to radians
latRad = lat * (math.pi/180)
lonRad = lon * (math.pi/180)
#(1) geocentric latitude
Phi_c = math.atan(((rpol * rpol)/(req * req)) * math.tan(latRad))
#(2) geocentric distance to the point on the ellipsoid
rc = rpol/(math.sqrt(1 - ((e * e) * (math.cos(Phi_c) * math.cos(Phi_c)))))
#(3) sx
sx = H - (rc * math.cos(Phi_c) * math.cos(lonRad - lambda0))
#(4) sy
sy = -rc * math.cos(Phi_c) * math.sin(lonRad - lambda0)
#(5)
sz = rc * math.sin(Phi_c)
x,y
x = math.asin((-sy)/math.sqrt((sx<em>sx) + (sy</em>sy) + (sz*sz)))
y = math.atan(sz/sx)
return x, y
def getScaleOffset(var, nc):
return nc.variables[var].scale_factor, nc.variables[var].add_offset
def convertExtent2GOESProjection(extent):
# GOES-16 viewing point (satellite position) height above the earth
GOES16_HEIGHT = 35786023.0
# GOES-16 longitude position
GOES16_LONGITUDE = -75.0
<code>a, b = latlon2xy(extent[1], extent[0]) c, d = latlon2xy(extent[3], extent[2]) return (a * GOES16_HEIGHT, c * GOES16_HEIGHT, b * GOES16_HEIGHT, d * GOES16_HEIGHT)</code>
# Select the region to plot
extent = [-90.00, 5.00, -78.00, 15.00]
# Open the GOES-R image
file = Dataset("Samples//OR_ABI-L2-CMIPF-M6C02_G16_s20202121500190_e20202121509498_c20202121509567.nc")
# Get scale and offset informations of fixed-grid projection
xscale, xoffset = getScaleOffset('x', file)
yscale, yoffset = getScaleOffset('y', file)
# Convert lat/lon to grid-coordinates
lly, llx = geo2grid(extent[1], extent[0], xscale, xoffset, yscale, yoffset)
ury, urx = geo2grid(extent[3], extent[2], xscale, xoffset, yscale, yoffset)
# Crop full-disk
data = file.variables['CMI'][ury:lly, llx:urx]
# Compute data-extent in GOES projection-coordinates
geos_extent = convertExtent2GOESProjection(extent)
# Region-Of-Interest (ROI) cartopy formatted
cartopy_extent = (extent[0], extent[2], extent[1], extent[3])
# Choose the plot size (width x height, in inches)
plt.figure(figsize=(7,7))
# Use the Geostationary projection in cartopy
ax = plt.axes(projection=ccrs.Geostationary(central_longitude=-75.0, satellite_height=35786023.0))
# Crop plot
ax.set_extent(cartopy_extent)
# Add coastlines, borders and gridlines
ax.coastlines(resolution='10m', color='white', linewidth=0.8)
ax.add_feature(cartopy.feature.BORDERS, edgecolor='white', linewidth=0.5)
ax.gridlines(color='white', alpha=0.5, linestyle='--', linewidth=0.5)
# Plot cropped-data
img = ax.imshow(data, vmin=0, vmax=1, origin='upper', cmap='gray', extent=geos_extent, interpolation=None)
# Add a colorbar
plt.colorbar(img, label='Reflectance', extend='both', orientation='horizontal', pad=0.05, fraction=0.05)
# Extract date
date = (datetime.strptime(file.time_coverage_start, '%Y-%m-%dT%H:%M:%S.%fZ'))
# Add a title
plt.title('GOES-16 Band 02 ' + date.strftime('%Y-%m-%d %H:%M') + ' UTC', fontweight='bold', fontsize=10, loc='left')
plt.title('Costa Rica', fontsize=10, loc='right')
# Save the image
plt.savefig('Image_05.png')
Show the image
plt.show()
PUEDES DESCARGAR EL SCRIPT ARRIBA (Script_05.py) EN ESTE ENLACE
Ejecute el script “Script_05.py” con el siguiente comando:
python Script_05.py
Después de la ejecución del script, debe tener el siguiente plot de la región de Costa Rica:
Zoom en una región específica:
Para darle un realze más nitido a la imagen de los canales visibles, podemos usar la raiz cuadrada de los valores. Este realze es conocido como “Square Root Visible Enhancement”:
# Crop full-disk
data = file.variables['CMI'][ury:lly, llx:urx]
# Visible Square Root Enhancement
import numpy as np
data = np.sqrt(data)
Este es el resultado:
PRÁCTICA 6: CREANDO UNA COMPOSICIÓN RGB (ROJO, VERDE, AZUL)
Creemos una composición RGB Airmass con Python. Considere la receta de Airmass que se encuentra en la Guía rápida de RAMMB:
Paso 1) Primeramente, de acuerdo con la receta, necesitamos leer cuatro Bandas GOES-R:
Banda 08 (6.2 um)
Banda 10 (7.3 um)
Banda 12 (9.6 um)
Banda 13 (10.3 um)
Acceda a la página web de descarga de Amazon del comienzo de este tutorial y descargue los NetCDF’s para la misma fecha y hora para los 4 canales arriba.
Creemos nuestro sexto script. Guarde un archivo llamado “Script_06.py”.
Ya sabemos cómo leer los archivos GOES-R, ¿verdad?
# Open the GOES-R image
file1 = Dataset("OR_ABI-L2-CMIPF-M6C08_G16_s20191981200396_e20191981210104_c20191981210182.nc")
# Get the pixel values, and convert to Celsius
data1 = file1.variables['CMI'][:] - 273.15
# Open the GOES-R image
file2 = Dataset("OR_ABI-L2-CMIPF-M6C10_G16_s20191981200396_e20191981210116_c20191981210188.nc")
# Get the pixel values, and convert to Celsius
data2 = file2.variables['CMI'][:] - 273.15
# Open the GOES-R image
file3 = Dataset("OR_ABI-L2-CMIPF-M6C12_G16_s20191981200396_e20191981210111_c20191981210185.nc")
# Get the pixel values, and convert to Celsius
data3 = file3.variables['CMI'][:] - 273.15
# Open the GOES-R image
file4 = Dataset("OR_ABI-L2-CMIPF-M6C13_G16_s20191981200396_e20191981210116_c20191981210189.nc")
# Get the pixel values, and convert to Celsius
data4 = file4.variables['CMI'][:] - 273.15
Paso 2) Luego, debemos realizar las operaciones que se ven en la receta (columna central):
# RGB Components
R = data1 - data2
G = data3 - data4
B = data1
Paso 3) Y necesitamos establecer los mínimos, máximos y valores gamma, de acuerdo con la receta:
# Choose the plot size (width x height, in inches)
plt.figure(figsize=(7,7))
# Use the Geostationary projection in cartopy
ax = plt.axes(projection=ccrs.Geostationary(central_longitude=-75.0, satellite_height=35786023.0))
img_extent = (-5434894.67527,5434894.67527,-5434894.67527,5434894.67527)
# Add coastlines, borders and gridlines
ax.coastlines(resolution='10m', color='white', linewidth=0.8)
ax.add_feature(cartopy.feature.BORDERS, edgecolor='white', linewidth=0.8)
ax.gridlines(color='white', alpha=0.5, linestyle='--', linewidth=0.5)
# Plot the image
img = ax.imshow(RGB, origin='upper', extent=img_extent)
# Extract date
date = (datetime.strptime(file1.time_coverage_start, '%Y-%m-%dT%H:%M:%S.%fZ'))
# Add a title
plt.title('GOES-16 Airmass RGB ' + date.strftime('%Y-%m-%d %H:%M') + ' UTC', fontweight='bold', fontsize=10, loc='left')
plt.title('Full Disk', fontsize=10, loc='right')
# Save the image
plt.savefig('Image_06.png')
# Show the image
plt.show()
Este debería ser tu script completo por ahora:
# Training: Python and GOES-R Imagery: Script 6 - RGB Creation
# Required modules
from netCDF4 import Dataset # Read / Write NetCDF4 files
import matplotlib.pyplot as plt # Plotting library
import cartopy, cartopy.crs as ccrs # Plot maps
import numpy as np # Import the Numpy packag
from datetime import datetime # Basic Dates and time types
# Open the GOES-R image
file1 = Dataset("OR_ABI-L2-CMIPF-M6C08_G16_s20191981200396_e20191981210104_c20191981210182.nc")
# Get the pixel values, and convert to Celsius
data1 = file1.variables['CMI'][:,:][::4 ,::4] - 273.15
# Open the GOES-R image
file2 = Dataset("OR_ABI-L2-CMIPF-M6C10_G16_s20191981200396_e20191981210116_c20191981210188.nc")
# Get the pixel values, and convert to Celsius
data2 = file2.variables['CMI'][:,:][::4 ,::4] - 273.15
# Open the GOES-R image
file3 = Dataset("OR_ABI-L2-CMIPF-M6C12_G16_s20191981200396_e20191981210111_c20191981210185.nc")
Get the pixel values, and convert to Celsius
data3 = file3.variables['CMI'][:,:][::4 ,::4] - 273.15
# Open the GOES-R image
file4 = Dataset("OR_ABI-L2-CMIPF-M6C13_G16_s20191981200396_e20191981210116_c20191981210189.nc")
# Get the pixel values, and convert to Celsius
data4 = file4.variables['CMI'][:,:][::4 ,::4] - 273.15
# RGB Components
R = data1 - data2
G = data3 - data4
B = data1
# Minimuns, Maximuns and Gamma
Rmin = -26.2
Rmax = 0.6
Gmin = -43.2
Gmax = 6.7
Bmin = -29.25
Bmax = -64.65
R[R > Rmax] = Rmax
R[R < Rmin] = Rmin
G[G > Gmax] = Gmax
G[G < Gmin] = Gmin
B[B < Bmax] = Bmax
B[B > Bmin] = Bmin
gamma_R = 1
gamma_G = 1
gamma_B = 1
# Normalize the data
R = ((R - Rmin) / (Rmax - Rmin)) ** (1/gamma_R)
G = ((G - Gmin) / (Gmax - Gmin)) ** (1/gamma_G)
B = ((B - Bmin) / (Bmax - Bmin)) ** (1/gamma_B)
# Create the RGB
RGB = np.stack([R, G, B], axis=2)
# Eliminate values outside the globe
mask = (RGB == [R[0,0],G[0,0],B[0,0]]).all(axis=2)
RGB[mask] = np.nan
# Choose the plot size (width x height, in inches)
plt.figure(figsize=(7,7))
# Use the Geostationary projection in cartopy
ax = plt.axes(projection=ccrs.Geostationary(central_longitude=-75.0, satellite_height=35786023.0))
img_extent = (-5434894.67527,5434894.67527,-5434894.67527,5434894.67527)
# Add coastlines, borders and gridlines
ax.coastlines(resolution='10m', color='white', linewidth=0.8)
ax.add_feature(cartopy.feature.BORDERS, edgecolor='white', linewidth=0.8)
ax.gridlines(color='white', alpha=0.5, linestyle='--', linewidth=0.5)
# Plot the image
img = ax.imshow(RGB, origin='upper', extent=img_extent)
# Extract date
date = (datetime.strptime(file1.time_coverage_start, '%Y-%m-%dT%H:%M:%S.%fZ'))
# Add a title
plt.title('GOES-16 Airmass RGB ' + date.strftime('%Y-%m-%d %H:%M') + ' UTC', fontweight='bold', fontsize=10, loc='left')
plt.title('Full Disk', fontsize=10, loc='right')
# Save the image
plt.savefig('Image_06.png')
Show the image
plt.show()
PUEDES DESCARGAR EL SCRIPT ARRIBA (Script_06.py) EN ESTE ENLACE
Ejecute el script “Script_06.py” con el siguiente comando:
python Script_06.py
El siguiente plot será creado:
¿Qué puedes cambiar rápidamente en este script?
Agregar shapefiles estados y provincias. Intente agregar shapefiles de estados y provincias como lo hicimos en el ejercicio 5.
Crea otros RGB. Consulte las Guías Rápidas de RAMMB e intente crear otras RGB. ¡El método de creación DUST RGB es muy similar! ¡Pruébalo! Nota: ¡El canal azul no está invertido!
PRÁCTICA 7: GLM + ABI
En este ultimo ejemplo de la practica, vamos a bajar de la pagina de descargas de la nube del principio del procedimiento una muestra de archivo del sensor GLM, como en el ejemplo abajo:
Creemos nuestro septimo script. Guarde un archivo llamado “Script_07.py”.
Para leer los eventos, grupos y flashes de un archivo GLM, podemos utilizar el codigo ejemplo:
GNC-A Blog 