Passer la navigation

GOES-16

SatelliteImagery EarthObservation AIforEarth NOAA

Images météorologiques provenant du satellite GOES-16.

La série de satellites GOES-R (« Geostationary Operational Environmental Satellites », ou « Satellite géostationnaire opérationnel d’étude de l’environnement » en français) est conçue pour fournir des images de phénomènes météorologiques depuis une orbite géostationnaire. Le satellite GOES-16 est le premier des quatre satellites de cette série. Son orbite lui permet d’enregistrer des images de tout le continent américain.

Ce jeu de données inclut le produit ABI-L2-MCMIPF (Advanced Baseline Imager, Level 2, Cloud and Moisture Imagery, Full-disk, ou « Imageur de ligne de base avancé, niveau 2, Images de nuages et de l’humidité, disque complet ») et le produit ABI-L1b-RadF (AdvancedBaseline Imager, Level 1b, Full-disk). Nous intègrerons peut-être d’autres résultats des satellites GOES-16 et GOES-17, à la demande. Si l’utilisation d’autres données GOES avec Azure vous intéresse, veuillez contacter aiforearthdatasets@microsoft.com.

Ce jeu de données est disponible sur Azure grâce au programme NOAA Big Data.

Ressources de stockage

Les données sont stockées au format NetCDF dans des blobs (un blob par image) situés dans le centre de données USA Est, dans le conteneur de blob suivant :

https://goes.blob.core.windows.net/noaa-goes16

Dans ce conteneur, les données sont nommées comme suit :

[product]/[year]/[day]/[hour]/[filename]

  • product est un nom de produit. Actuellement, ABI-L2-MCMIPF et ABI-L1b-RadF sont disponibles sur Azure
  • year est une année à quatre chiffres
  • day est un code à trois chiffres correspondant au jour de l’année, à partir de 001
  • hour est un code à deux chiffres correspondant à l’heure de la journée, à partir de 00
  • filename encode les données product, date et time. Plus d’informations sont disponibles dans le document GOES Users’ Guide (« Guide de l’utilisateur de GOES », uniquement disponible en anglais)

Par exemple, ce fichier :

https://goes.blob.core.windows.net/noaa-goes16/ABI-L2-MCMIPF/2020/003/00/OR_ABI-L2-MCMIPF-M6_G16_s20200030000215_e20200030009534_c20200030010031.nc

Contient les données récoltées du 3 janvier 2020, entre minuit et 1 heure du matin UTC (heure 00).

Les canaux de données et les longueurs d’onde sont décrits ici.

Un exemple Python complet d’accès et de traçage d’une image GOES-16 est disponible dans le notebook fourni sous “accès aux données”.

Nous fournissons également un jeton SAP (signature d’accès partagé) en lecture seule pour permettre l’accès aux données GOES-16 via, par exemple, BlobFuse, ce qui vous permet de monter des conteneurs de blob en tant que lecteurs :

st=2020-04-11T23%3A55%3A25Z&se=2032-04-12T23%3A55%3A00Z&sp=rl&sv=2018-03-28&sr=c&sig=IVSoHKVscKyu8K99I7xfman%2Bzp0ISkFbnbAqE6wkv6A%3D

Les instructions de montage pour Linux sont disponibles ici.

Le traitement à grande échelle à l’aide de ce jeu de données est plus efficace dans le centre de données Azure USA Est où les données sont stockées. Si vous utilisez des données GOES pour des applications en sciences de l’environnement, nous vous recommandons de demander une subvention AI for Earth afin de répondre à vos besoins de calcul.

Citation

Si vous utilisez ces données dans une publication, veuillez inclure les références suivantes :

Programme de la série GOES-R (GOES-R Series Program), (2019) : Données de niveau 0 de l’imageur de ligne de base avancé de la série GOES-R de la NOAA (NOAA GOES-R Series Advanced Baseline Imager). [Indiquez le sous-ensemble utilisé]. NOAA National Centers for Environmental Information. doi:10.25921/tvws-w071.

Belle image


Images de l’humidité dans les Amériques le 2 janvier 2020.

Contact

Pour toute question sur ce jeu de données, contactez aiforearthdatasets@microsoft.com.

Remarques

MICROSOFT FOURNIT AZURE OPEN DATASETS “EN L’ÉTAT”. MICROSOFT N’OFFRE AUCUNE GARANTIE, EXPRESSE OU IMPLICITE, DE GARANTIE NI DE CONDITIONS RELATIVES À VOTRE UTILISATION DES JEUX DE DONNÉES. DANS LA MESURE AUTORISÉE PAR VOTRE DROIT LOCAL, MICROSOFT DÉCLINE TOUTE RESPONSABILITÉ POUR TOUT DOMMAGE OU PERTES, Y COMPRIS LES DIRECTIVES, CONSEQUENTIELLES, SPÉCIALES, INDIRECTES OU PUNITIVES, RÉSULTANT DE VOTRE UTILISATION DES JEUX DE DONNÉES.

Ce jeu de données est fourni selon les conditions initiales par lesquelles Microsoft a reçu les données sources. Le jeu de données peut inclure des données provenant de Microsoft.

Access

Available inWhen to use
Azure Notebooks

Quickly explore the dataset with Jupyter notebooks hosted on Azure or your local machine.

Select your preferred service:

Azure Notebooks

Azure Notebooks

Package: Language: Python

Demo notebook for accessing GOES-16 data on Azure

This notebook provides an example of accessing GOES-16 data from blob storage on Azure, including (1) finding the data file corresponding to a date and time, (2) retrieving that file from blob storage, and (3) opening the downloaded file using the xarray library, and (4) rendering the image.

GOES-16 data are stored in the East US data center, so this notebook will run most efficiently on Azure compute located in East US. We recommend that substantial computation depending on GOES-16 data also be situated in East US. If you are using GOES-16 data for environmental science applications, consider applying for an AI for Earth grant to support your compute requirements.

Imports and environment

In [1]:
# Mostly-standard imports
import os
import tempfile
import numpy as np
import shutil
import urllib
import matplotlib.pyplot as plt

# Less-common-but-still-pip-installable imports
import xarray
from azure.storage.blob import ContainerClient

# pip install progressbar2, not progressbar
import progressbar

# Storage locations are documented at http://aka.ms/ai4edata-goes16
goes_account_name = 'goes'
goes_container_name = 'noaa-goes16'
goes_account_url = 'https://' + goes_account_name + '.blob.core.windows.net'
goes_blob_root = goes_account_url + '/' + goes_container_name + '/'

# Create a ContainerClient to enumerate blobs
goes_container_client = ContainerClient(account_url=goes_account_url, 
                                         container_name=goes_container_name,
                                         credential=None)

temp_dir = os.path.join(tempfile.gettempdir(),'goes')
os.makedirs(temp_dir,exist_ok=True)

%matplotlib inline

Functions

In [3]:
class DownloadProgressBar():
    """
    https://stackoverflow.com/questions/37748105/how-to-use-progressbar-module-with-urlretrieve
    """
    
    def __init__(self):
        self.pbar = None

    def __call__(self, block_num, block_size, total_size):
        if not self.pbar:
            self.pbar = progressbar.ProgressBar(max_value=total_size)
            self.pbar.start()
            
        downloaded = block_num * block_size
        if downloaded < total_size:
            self.pbar.update(downloaded)
        else:
            self.pbar.finish()
            

def download_url(url, destination_filename=None, progress_updater=None, force_download=False):
    """
    Download a URL to a temporary file
    """
    
    # This is not intended to guarantee uniqueness, we just know it happens to guarantee
    # uniqueness for this application.
    if destination_filename is None:
        url_as_filename = url.replace('://', '_').replace('/', '_')    
        destination_filename = \
            os.path.join(temp_dir,url_as_filename)
    if (not force_download) and (os.path.isfile(destination_filename)):
        print('Bypassing download of already-downloaded file {}'.format(
            os.path.basename(url)))
        return destination_filename
    print('Downloading file {} to {}'.format(os.path.basename(url),
                                             destination_filename),end='')
    urllib.request.urlretrieve(url, destination_filename, progress_updater)  
    assert(os.path.isfile(destination_filename))
    nBytes = os.path.getsize(destination_filename)
    print('...done, {} bytes.'.format(nBytes))
    return destination_filename

Choose a GOES data file for a known time

In [5]:
# Data are stored as product/year/day/hour/filename
product = 'ABI-L2-MCMIPF'
syear = '2020'; sday = '002'; shour = '14';

# There will be several scans this hour, we'll take the first
scan_index = 0

prefix = product + '/' + syear + '/' + sday + '/' + shour + '/'
print('Finding blobs matching prefix: {}'.format(prefix))
generator = goes_container_client.list_blobs(name_starts_with=prefix)
blobs = []
for blob in generator:
    blobs.append(blob.name)
print('Found {} scans'.format(len(blobs)))

scan_url = goes_blob_root + blobs[scan_index]
Finding blobs matching prefix: ABI-L2-MCMIPF/2020/002/14/
Found 6 scans

Load the image

In [7]:
# GOES-16 MCMIPF files are ~300MB.  Not too big to fit in memory, so sometimes it may be 
# preferable to download to file first, sometimes it will be better to load straight to 
# memory.
download_to_file = True

if download_to_file:
    
    filename = download_url(scan_url,progress_updater=DownloadProgressBar())
    from datetime import datetime
    dataset = xarray.open_dataset(filename)    

else:
    
    import netCDF4
    import requests
    
    # If you know of a good way to show a progress bar with requests.get (i.e., without writing
    # to file), we're all ears, email aiforearthdatasets@microsoft.com!
    print('Downloading {} to memory...'.format(os.path.basename(scan_url)))
    response = requests.get(scan_url)
    print('Finished downloading')
    nc4_ds = netCDF4.Dataset(os.path.basename(scan_url), memory = response.content)
    store = xarray.backends.NetCDF4DataStore(nc4_ds)
    dataset = xarray.open_dataset(store)
Bypassing download of already-downloaded file OR_ABI-L2-MCMIPF-M6_G16_s20200021400218_e20200021409537_c20200021410039.nc

Explore the xarray dataset and prepare to plot the image

In [8]:
print('Scan starts at: {}'.format(dataset.time_coverage_start))
print('Scan ends at: {}'.format(dataset.time_coverage_end))

# Bands are documented at:
#
# https://www.ncdc.noaa.gov/data-access/satellite-data/goes-r-series-satellites/glossary
#
# We'll use the red/"veggie"/blue bands with wavelengths 0.64, 0.86, and 0.47, respectively.
#
# This is close enough to RGB for today, but there's a great tutorial on getting closer to
# true color (and doing other fancy rendering tricks with GOES data!) here:
#
# https://unidata.github.io/python-gallery/examples/mapping_GOES16_TrueColor.html
#
r = dataset['CMI_C02'].data; r = np.clip(r, 0, 1)
g = dataset['CMI_C03'].data; g = np.clip(g, 0, 1)
b = dataset['CMI_C01'].data; b = np.clip(r, 0, 1)

# Brighten the image a bit for to look more stylish
gamma = 2.5; r = np.power(r, 1/gamma); g = np.power(g, 1/gamma); b = np.power(b, 1/gamma)

# Create a single RGB image for plotting
rgb = np.dstack((r, g, b))
Scan starts at: 2020-01-02T14:00:21.8Z
Scan ends at: 2020-01-02T14:09:53.7Z

Plot the image

In [10]:
fig = plt.figure(figsize=(7.5, 7.5), dpi=100)

# This definitely looks slicker with fancy borders on, at the cost of some extra
# imports.
show_fancy_borders = True

if not show_fancy_borders:
    
    plt.imshow(rgb); ax = plt.gca(); ax.axis('off');

else:
    
    import metpy
    import cartopy.crs as ccrs

    # Pick an arbitrary channel to get the x/y coordinates and projection information 
    # associated with the scan
    dummy_channel = dataset.metpy.parse_cf('CMI_C01')
    x = dummy_channel.x; y = dummy_channel.y

    ax = fig.add_subplot(1, 1, 1, projection=dummy_channel.metpy.cartopy_crs)
    ax.imshow(rgb, origin='upper', extent=(x.min(), x.max(), y.min(), y.max()))
    ax.coastlines(resolution='50m', color='black')
    ax.add_feature(ccrs.cartopy.feature.BORDERS);

Clean up temporary files

In [ ]:
shutil.rmtree(temp_dir)