Suite

Tracer le fichier NetCDF en utilisant lat et lon contenus dans les variables

Tracer le fichier NetCDF en utilisant lat et lon contenus dans les variables


J'essaie de tracer ce fichier NetCDF (et similaire) en tant que carte de contour 2D. Le fichier contient une seule couche d'une variable, "pr".
Le fichier a 413x229 coordonnées de pixels X-Y, et, stockées à l'intérieur des variables "xlon" et "xlat", les coordonnées exactes de chaque point de grille.
Je peux facilement tracer en utilisant les coordonnées X-Y :

nom de fichier <- "file.nc" varname <- "pr" library(raster) variable <- raster(filename, varname=varname) plot(variable)

Hpwever, l'intrigue sort "compressé", et de plus je veux tracer en utilisant les coordonnées lat-lon. Comment puis je faire ça?


Ceci est en quelque sorte similaire, je pense, à cette question:
https://gis.stackexchange.com/questions/48518/how-to-re-project-ease-equal-area-scalable-earth-grid-with-a-25-km-cylindrica?newreg=0eac93c7cbf04b6386d4e62e64e747ef

Cependant, la solution qui y est donnée n'est pas adaptée à mon cas car :

  • Je voudrais éviter d'utiliser lecdf4paquet, je préférerais utiliserrasterseulement car cela me permettrait d'étendre la procédure à des fichiers plus volumineux
  • J'obtiens plusieurs erreurs dans leconvertirGrille()fonction, telles que :
    coordonnées(xp)=~x+y
    Erreur dans .subset(x, j) : seuls les 0 peuvent être mélangés avec des indices négatifs

Je devrais inverser la projection, je pense. Tout ce que je sais de la projection est contenu dans le fichier ncdump :

projection = "LAMCON" grid_size_in_meters = 12000. latitude_of_projection_origin = 39. longitude_of_projection_origin = 14. standard_parallel = 35., 51. grid_factor = 0.684241343018562

Le fichier n'a pas de spécification CRS. Je sais que je devrais pouvoir le faire en utilisant lesp,rasteretrasterVispackages mais jusqu'à présent, je n'ai pas réussi.

Essayer de tracer en tant que data.frame ne fonctionne pas non plus car la grille n'est pas constante.


Je suppose que ma réponse à votre autre question StackOverflow ne vous a pas conduit dans la bonne direction ?

Voici une réponse plus détaillée qui peut vous pousser dans la bonne direction.

Tout d'abord, nous devons connaître la projection de vos données et l'étendue pour pouvoir projeter correctement sur la grille Long/Lat. Malheureusement, nous n'avons pas le PROJ4 CRS ou l'étendue, alors je fais de mon mieux pour les estimer.

# Tout d'abord, estimez l'étendue. # Nous commençons par le lat et le long, puis le projetons dans le fichier d'entrée de la bibliothèque de projection conforme Lambert (raster) <- "pr_averaged_Med_CORDEX_ATM.1980-2008.nc" # Récupérez le lat et le lon à partir des données lat <- raster (inputfile, varname ="xlat") lon <- raster(inputfile, varname="xlon") # Convertir en points et faire correspondre la lat et lons plat <- rasterToPoints(lat) plon <- rasterToPoints(lon) lonlat <- cbind(plon[, 3], plat[,3]) # Spécifiez le lonlat comme points spatiaux avec projection comme long/lat lonlat <- SpatialPoints(lonlat, proj4string = CRS("+proj=longlat +datum=WGS84")) # Besoin du package rgdal pour le projeter dans la bibliothèque du système de coordonnées d'origine ("rgdal") # Ma meilleure estimation de la chaîne proj4 à partir des informations fournies mycrs <- CRS("+proj=lcc +lat_1=35 +lat_2=51 +lat_0=39 +lon_0 =14 +k=0.684241 +units=m +datum=WGS84 +no_defs") plonlat <- spTransform(lonlat, CRSobj = mycrs) # Jetez un oeil plonlat extent(plonlat) # Yay ! Maintenant, nous pouvons définir correctement les informations de coordonnées pour le raster pr <- raster(inputfile, varname="pr") # Fixer la projection et l'étendue projection(pr) <- mycrs extent(pr) <- extent(plonlat) # Prendre un look pr plot(pr) # Projeter sur la grille longue lat r <- projectRaster(pr, crs=CRS("+proj=longlat +datum=WGS84")) # Jeter un coup d'oeil r plot(r) # Ajouter des contours contour(r , add=TRUE) # Ajouter la bibliothèque de lignes de pays ("maps") map(add=TRUE, col="blue")

Je pense que cela semble correct. Les frontières du pays près de l'océan semblent correspondre aux couleurs de l'intrigue. Je pense que vous pouvez le prendre à partir de là. Vous pouvez faire de plus beaux tracés avecrasterVisou alorsggplot.


Parfois, comme un extrait de variable d'un fichier HDF (hdf5), vous n'avez pas l'espacement régulier des cellules. Les extraits lat et lon du fichier, par exemple, sont à espacement irrégulier. Vous allez donc avoir des problèmes pour faire un raster ou une image correcte. Par conséquent, vous pouvez interpoler les données. J'utilise, pour cela, la fonction interp du package akima. C'est ainsi que je résous le problème lorsqu'il existe une matrice ou un ensemble de données avec des valeurs irrégulières de lat et de lon. Je pense que c'est aussi utile pour ggplot2.


1. Introduction

NetCDF est un format largement utilisé pour l'échange ou la distribution de données climatiques, et a également été adopté dans d'autres domaines, en particulier en bioinformatique, et dans d'autres disciplines où de grands tableaux multidimensionnels de données sont générés. Les fichiers NetCDF sont autodescriptif, dans le sens où ils contiennent des métadonnées qui décrivent ce qui est contenu dans un fichier, telles que la disposition en latitude et longitude de la grille, les noms et les unités des variables dans l'ensemble de données et des « attributs » qui décrivent des éléments tels que les codes de valeur manquante , ou des décalages et des facteurs d'échelle qui peuvent avoir été utilisés pour compresser les données. Les fichiers NetCDF sont également indépendant de la machine car peut être transféré entre des serveurs et des ordinateurs exécutant différents systèmes d'exploitation, sans avoir à convertir les fichiers d'une manière ou d'une autre. Développé à l'origine pour stocker et distribuer des données climatiques, telles que celles générées par des modèles de simulation climatique ou de réanalyse, le format et les protocoles peuvent être utilisés pour d'autres ensembles de données maillées. Les bibliothèques NetCDF sont développées et maintenues par Unidata http://www.unidata.ucar.edu/software/netcdf/ et des applications faciles à utiliser pour produire des visualisations simples de fichiers NetCDF existent, telles que Panoply, http://www. giss.nasa.gov/tools/panoply/.

Il existe deux versions de netCDF netCDF3, qui est largement utilisé, mais présente des limitations de taille et de performances, et netCDF4, qui prend en charge des ensembles de données plus volumineux et inclut des fonctionnalités supplémentaires telles que la compression de fichiers.

R a la capacité de lire et d'écrire (et donc d'analyser) des fichiers netCDF, en utilisant les packages ncdf et ncdf4 fournis par David Pierce, et via d'autres packages comme raster , metR1 et RNetCDF . Les packages ncdf4.helpers et easyNCDF fournissent des outils supplémentaires.

Le package ncdf4 est disponible sur Windows et Mac OS X (et Linux), et prend en charge à la fois l'ancien format NetCDF3 ainsi que netCDF4. (Voir la page Web ncdf/ncdf4 à http://cirrus.ucsd.edu/


Tracé du fichier NetCDF en utilisant lat et lon contenus dans les variables - Systèmes d'Information Géographique

Les indices de tableau doivent-ils commencer à 0 ou 1 ? Mon compromis de 0,5 a été rejeté sans, pensais-je, une considération appropriée. --Stan Kelly-Bootle

Introduction

Un logiciel de bibliothèque comme netCDF ou HDF5 permet d'accéder à des données multidimensionnelles par des indices de tableau, mais nous préférons souvent accéder aux données par coordonnées, telles que des points sur la surface de la Terre ou des cadres de délimitation spatio-temporels.

Les conventions de métadonnées sur le climat et les prévisions (FC) fournissent des moyens convenus de représenter les systèmes de coordonnées, mais ne traitent pas de rendre l'accès par coordonnées pratique et efficace. En particulier, l'utilisation de systèmes de coordonnées tels que ceux décrits dans la section Conventions CF "Latitude, longitude, variables de coordonnées bidimensionnelles" peut ne pas fournir un moyen direct de trouver des indices de matrice à partir des coordonnées de latitude et de longitude pour diverses raisons. Des exemples de ces données incluent :

  • utilisation de grilles curvilignes qui suivent les côtes
  • fauchées satellitaires géoréférencées sur des grilles lat-lon
  • systèmes de coordonnées sans attribut CF grid_mapping_name
  • des données de "station" non maillées, telles que des observations ponctuelles et des sondages

En utilisant un monde réel (enfin, d'accord, un sphérique idéalisé Earth), nous verrons plusieurs façons d'accéder aux données par coordonnées, ainsi que comment l'utilisation de logiciels et de structures de données appropriés peut grandement améliorer l'efficacité d'un tel accès.

Un exemple de jeu de données

L'exemple de jeu de données que nous utilisons provient du HYbrid Coordinate Ocean Model (HYCOM).

Cet ensemble de données est un bon exemple pour plusieurs raisons :

  • C'est typique de nombreux produits de données de modèles océaniques, climatiques et prévisionnels, avec plusieurs variables sur la même grille et conformes aux conventions FC pour la représentation d'un système de coordonnées.
  • Il dispose d'un système de coordonnées géospatiales non trivial, représenté par des tableaux de latitude et de longitude 2D qui sont des coordonnées auxiliaires pour d'autres variables. La grille semble être un sous-ensemble d'une grille tripolaire, mais aucun des paramètres nécessaires pour dériver une formule dont les éléments correspondent à une coordonnée spécifiée n'est dans le fichier.

Bien qu'il ne soit pas très pertinent pour le sujet de ce blog, l'exemple de jeu de données fait également bon usage de la compression, avec des valeurs de remplissage sur la terre pour les données océaniques. Le fichier netCDF classic est de 102 Mo, mais le fichier de modèle classique netCDF-4 équivalent avec compression n'est que de 30 Mo. Rien dans cet article n'a quelque chose à voir avec le modèle de données netCDF-4, tout s'applique aux données du modèle classique netCDF-3 ou netCDF-4.

Voici une sortie, pertinente pour le problème que nous allons présenter, de "ncdump -h" appliqué au fichier d'exemple :

Tracer toute la grille latitude-longitude donnerait un gros blob de 600 000 pixels, mais voici une représentation plus clairsemée de la grille, montrant toutes les 25 lignes parallèles aux axes X et Y :

Exemples de requêtes de coordonnées

La variable de température a des coordonnées auxiliaires de longitude et de latitude, et nous souhaitons accéder aux données correspondant à leurs valeurs, plutôt qu'aux indices de tableau X et Y. Pouvons-nous déterminer efficacement des valeurs sur des variables netCDF telles que la température ou la salinité, par exemple au point de grille le plus proche de 50 degrés de latitude nord et de -140 degrés de longitude est ?

Plus généralement, comment pouvons-nous efficacement

  • déterminer la valeur d'une variable la plus proche d'un emplacement et d'une heure spécifiés ?
  • accéder à toutes les données sur une sous-grille définie dans une boîte englobante de coordonnées spatio-temporelles spécifiées ?

Pourquoi utiliser un bloc-notes iPython pour l'exemple ?

Pour cet exemple, le code de lecture des données netCDF et de mappage de l'espace de coordonnées à l'espace d'index de tableau est présenté dans un bloc-notes iPython. Pourquoi pas C, Java, Fortran ou un autre langage supporté directement par Unidata ?

Le point est la clarté. C'est un blog assez long, qui a probablement déjà recueilli plusieurs commentaires "TLDR". L'exemple de code qui l'accompagne doit être court, clair et facile à lire.

Le bloc-notes iPython, issu d'une session sur la lecture de données netCDF dans l'atelier Unidata 2013 TDS-Python, est disponible à partir de l'atelier Unidata TDS-Python 2013, avec lequel vous pouvez exécuter des exemples et effectuer des chronométrages sur votre propre machine et même avec vos propres données !

Si vous choisissez la deuxième méthode, vous pouvez voir les résultats de la modification des exemples ou de la substitution de vos propres données. Pour utiliser le bloc-notes, vous devez avoir installé Python et quelques bibliothèques supplémentaires, comme indiqué au bas de la page README sur le site de l'atelier référencé.

Il suffit de regarder la version HTML pour voir ce qui se passe.

Quatre approches

Dans le notebook, nous implémentons et améliorons progressivement plusieurs façons d'accéder aux données netCDF basées sur des coordonnées au lieu d'indices de tableau :

  • lent, simple et parfois faux
  • rapide, simple et parfois faux
  • pas aussi rapide, mais correct
  • rapide, correct et évolutif pour de nombreuses requêtes sur le même ensemble de points de données

Approche naïve et lente

Puisque notre problème concret est de trouver lequel de plus de 600 000 points est le plus proche du point (lat, lon) (50, -140), nous devons d'abord dire ce que l'on entend par "close".

Une métrique naïve pour la distance au carré entre (lat, lon) et (lat0, lon0) utilise simplement la "norme euclidienne", car elle est facile à calculer :

Il faut donc trouver des indices X et oui tel que le point (Latitude[oui, X], Longitude[oui, X]) est proche du point souhaité (lat0, lon0). La façon naïve de le faire est d'utiliser deux boucles imbriquées, en vérifiant la distance au carré pour les 600 000+ paires de oui et X valeurs, un point à la fois.

Le code de cette version est présenté comme la fonction naïf_lent et quelques lignes suivantes qui appellent la fonction sur notre exemple explicite.

Notez que les exemples de cellules de code ouvrent tous initialement le fichier d'exemple, lisent les données nécessaires pour trouver les valeurs souhaitées et ferment le fichier après avoir imprimé suffisamment d'informations pour vérifier que nous avons obtenu la bonne réponse. Le travail d'ouverture du fichier, de lecture des données et de fermeture du fichier est répété pour chaque fonction afin que les cellules soient indépendantes les unes des autres et puissent être exécutées dans n'importe quel ordre ou réexécutées sans obtenir d'erreurs telles qu'essayer de lire à partir de la fermeture fichiers ou en fermant deux fois le même fichier.

Plus rapide avec NumPy

La première approche utilise des boucles explicites conventionnelles, ce qui la fait ressembler à du code Fortran ou C. Il peut être accéléré par un facteur de plus de 700 en utilisant simplement NumPy, une bibliothèque Python prenant en charge les tableaux multidimensionnels et les opérations et fonctions tableau à la fois qui remplacent souvent les boucles explicites par des instructions de tableau entier. Nous appelons cette version de la fonction naïf_rapide.

Comme naïf_lent, il souffre de défauts dans l'utilisation d'une mesure de proximité "plate".

Distance tunnel : toujours rapide, mais plus correcte

Un problème avec les deux versions précédentes, c'est qu'elles traitent la Terre comme plate, avec un degré de longitude près des pôles aussi grand qu'un degré de longitude sur l'équateur. Il traite également la distance entre les points sur les bords, tels que (0,0, -179,99) et (0,0, +179,99) comme grande, même si ces points se trouvent juste en face de la ligne de date internationale les uns des autres.

Une façon de résoudre ces deux problèmes consiste à utiliser une meilleure métrique, par exemple la longueur d'un tunnel à travers la Terre entre deux points comme distance, ce qui s'avère être facile à calculer en utilisant simplement un peu de trigonométrie.

Cela donne une solution plus correcte qui fonctionne même si les longitudes sont données dans une plage différente, par exemple entre 0 degrés et 360 degrés au lieu de -180 à 180, car nous utilisons simplement des fonctions trigonométriques d'angles pour calculer la distance du tunnel. Wikipedia a les formules de trig simples que nous pouvons utiliser. Cela nous donne également la même réponse que l'approche naïve pour notre exemple de point, mais évite les réponses erronées que nous obtiendrions en traitant la Terre comme plate dans les approches "naives"s.

Chronométrer cette approche, avec la fonction que nous appelons tunnel_rapide, parce que nous utilisons toujours des tableaux et des fonctions NumPy rapides au lieu de boucles explicites, est toujours environ 200 fois plus rapide que l'approche naïve en boucle.

Utilisation des arbres KD pour des accélérations plus évolutives

Enfin, nous utilisons une structure de données spécialement conçue pour trouver rapidement le point le plus proche dans un grand ensemble de points d'un point de requête : l'arbre KD (également appelé "k-d arbre"). L'utilisation d'un arbre KD est un processus en deux étapes.

Tout d'abord, vous chargez l'arbre KD avec l'ensemble de points dans lesquels vous souhaitez rechercher un point le plus proche, généralement les points de grille ou les emplacements d'un ensemble de données non maillées. Le temps que cela prend dépend du nombre de points ainsi que de leur dimensionnalité, mais est similaire au temps qu'il faut pour trier N nombres, à savoir O(N log(N)). Pour l'exemple de jeu de données avec plus de 600 000 points dans la grille, cela prend moins de 3 secondes sur notre plate-forme de test pour ordinateur portable, mais c'est nettement plus long que le temps d'installation pour la recherche de distance de tunnel minimale.

La deuxième étape fournit un point de requête et renvoie le ou les points les plus proches dans l'arbre KD du point de requête, où la façon dont "le plus proche" est défini peut être modifiée. Ici, nous utilisons des points 3D sur une Terre sphérique avec un rayon unitaire. La combinaison de configuration et de requête est initialement implémentée dans un kdtree_fast une fonction.

Bien que vous ne puissiez pas le savoir en exécutant la configuration et la requête ensemble, le kdtree_fast requête est nettement plus rapide que dans le tunnel_rapide chercher. Ainsi, le kdtree_fast l'approche évolue beaucoup mieux lorsque nous avons un seul ensemble, S, de points à rechercher et de nombreux points de requête pour lesquels nous voulons le (ou les) point(s) le plus proche dans S.

Par exemple, nous pouvons vouloir des valeurs variables sur une sous-grille de domaine 100 x 100 (lat, lon), et comme nous le verrons, l'arbre KD fournit une solution beaucoup plus rapide que le tunnel_rapide ou alors naïf_rapide méthodes. Si les emplacements ne changent pas avec les données de plusieurs fichiers, heures ou couches, le temps de configuration de l'arbre KD peut être réutilisé pour de nombreuses requêtes ponctuelles, offrant des avantages significatifs en termes d'efficacité. Pour les jeux de données spatiales populaires côté serveur, le même arbre KD peut être réutilisé pour plusieurs jeux de données utilisant les mêmes coordonnées.

La structure de données KD-tree peut également être utilisée de manière plus flexible pour fournir des requêtes rapides pour les M points les plus proches d'un point de requête spécifié, ce qui est utile pour interpoler des valeurs au lieu d'utiliser simplement la valeur d'une variable à un seul point le plus proche.

La structure de données KD-tree est comme un couteau suisse pour les données de coordonnées, analogue à certains égards aux expressions régulières pour les chaînes. Nous avons montré l'utilisation des arbres KD pour les données de latitude/longitude 2D et pour les coordonnées 3D de points sur une sphère avec une métrique de distance tunnel. Les arbres KD peuvent également être utilisés avec des coordonnées verticales ou temporelles, si vous spécifiez une manière raisonnable de définir "close" entre des points dans l'espace-temps.

Les implémentations des arbres KD sont disponibles gratuitement pour C, Java, Fortran, C++ et d'autres langages que Python. Une implémentation Java KD-tree est utilisée dans ncWMS, le service de carte Web inclus dans les serveurs TDS mais développé à l'Université de Reading. Une implémentation C/C++ de KD-trees est utilisée dans Fimex, une bibliothèque de l'Institut météorologique norvégien qui prend en charge l'interpolation et le sous-ensemble des données géospatiales construites autour du modèle de données commun Unidata. Le module que nous avons utilisé dans l'exemple de bloc-notes iPython, scipy.spatial.cKDTree, est une implémentation C appelable à partir de Python, nettement plus rapide que l'implémentation Python pure dans scipy.spatial.KDTree.

La dernière section du cahier réimplémente nos quatre fonctions sous forme de quatre classes Python orientées objet, avec le code de configuration dans un constructeur de classe et une méthode de requête unique. Cela permet de chronométrer plus facilement les parties d'initialisation et de requête de chaque approche séparément, ce qui conduit à des formules simples pour le temps requis pour N points et à une prédiction du moment où le temps de configuration supplémentaire pour kdtree_fast porte ses fruits.

Et le gagnant est .

L'enveloppe, s'il vous plaît. Et le gagnant est . YMMV !

Les raisons pour lesquelles votre kilométrage peut varier comprennent :

  • nombre de points dans l'ensemble de recherche
  • dimensionnalité de l'ensemble de recherche
  • complexité de la métrique de distance
  • nombre de points de requête
  • nombre de voisins les plus proches nécessaires, par ex. pour interpolation
  • Facteurs d'E/S, y compris les effets de mise en cache, de compression et d'accès à distance
  • tenant compte de la forme non sphérique de la Terre

Nous avons résumé nos résultats de synchronisation pour les quatre approches de l'exemple de problème sur l'exemple de jeu de données à la fin du bloc-notes iPython. Peut-être pourrions-nous examiner certains des facteurs énumérés ci-dessus dans de futurs blogs.

Au cas où vous ne voudriez pas ouvrir le bloc-notes iPython pour voir les résultats, voici quelques fois sur une plate-forme d'ordinateur portable rapide :

Méthode Configuration (ms) Requête (ms) Configuration + 10000
requêtes (secondes)
Naive_slow3.76 7790 77900
Naive_fast3.82.46 24.6
Tunnel_rapide 27.4 5.14 51.4
Kdtree_fast 2520 0.0738 3.3

Déterminer quand cela vaut la peine d'utiliser un arbre KD pour cet exemple a donné lieu à :

  • kd_tree_fast surpasse naive_fast au-dessus de 1050 requêtes
  • kd_tree_fast surpasse tunnel_fast au-dessus de 490 requêtes

L'avantage d'utiliser des arbres KD est beaucoup plus grand pour plus de points de consigne de recherche, car la complexité de la requête KD-tree est O(log(N)), mais les autres algorithmes sont O(N), la même que la différence entre l'utilisation de la recherche binaire par rapport à la recherche linéaire.

Si vous êtes intéressé à en savoir plus sur ce sujet, un bon article court sur les différentes manières de recadrer les données à l'aide d'arbres KD et d'autres méthodes est Regridage rapide de grands ensembles de données géospatiales complexes par Jon Blower et A. Clegg.

Très beau billet ! Juste quelques petits commentaires :


  1. L'article de Blower et Clegg explique pourquoi le point "le plus proche voisin" n'est pas toujours la même chose que "la cellule de grille qui contient le point d'intérêt". Cela peut être une distinction importante lorsque vous essayez de traiter avec précision des grilles curvilignes déformées.
  2. Bien que nous ayons expérimenté un arbre kd dans ncWMS, nous avons constaté qu'une simple approche de "table de recherche" était plus rapide, en particulier si vous êtes capable de mettre en cache la table de recherche et d'éviter de la régénérer à chaque fois. Par conséquent, ncWMS utilise la LUT par défaut.

En gros, ncWMS utilise la LUT pour trouver une cellule de grille proche du point lat-lon requis. Ensuite, il recherche autour de ce point jusqu'à ce qu'il trouve la cellule de grille qui contient réellement ce point (en utilisant la méthode polygon.contains(point) de Java). La méthode contains() peut être coûteuse, il est donc généralement plus rapide de trouver le voisin le plus proche si c'est vraiment ce que vous voulez.

Au fait, j'adore l'utilisation du bloc-notes iPython !

posté par Jon Souffleur le 16 septembre 2013 à 03h28 HAR #

Merci pour les commentaires, Jon.

Depuis que j'ai lu votre approche LUT, j'aimerais l'implémenter dans le même framework Python que j'utilise, et peut-être écrire une autre entrée de blog sur les résultats de cet exemple.

posté par 67.190.4.13 le 16 septembre 2013 à 06h21 HAR #

Génial, il serait très intéressant d'avoir une implémentation Python. Soit dit en passant, ncWMS utilisait un algorithme plutôt brutal pour générer la LUT, ce qui était plutôt lent. Il utilise désormais une méthode beaucoup plus rapide qui consiste à « peindre » les cellules de la grille sur la LUT à l'aide de l'API graphique Java 2D, en traitant efficacement la LUT comme une image. (Dans la terminologie de l'article de Blower et Clegg, la LUT est générée à l'aide d'un algorithme "source-push".) Vous pouvez voir le code sur http://www.resc.rdg.ac.uk/trac/ncWMS/browser /trunk/src/java/uk/ac/rdg/resc/edal/cdm/LookUpTable.java.</p>

Je ne sais pas si Python a des API équivalentes - sinon, le code pourrait être assez difficile à porter !

posté par Jon Souffleur le 17 septembre 2013 à 01h20 HAR #

Je me souviens encore de mon premier projet utilisant CI et google map

et les cartes de bibliothèque de google apportent vraiment une aide précieuse et une configuration simple

posté par Hébergement Web Qwords le 30 novembre 2015 à 02h43 HNR #

Je suis d'accord que j'aimerais l'implémenter dans le même framework Python que j'ai utilisé, et peut-être écrire une autre entrée de blog sur les résultats de cet exemple.

posté par jasa bikin web le 28 mai 2017 à 04:08 MDT #

Vous pouvez utiliser Grid Number Calculator. C'est une API dans Netcdf-Extractor Version 2.0. GNC est gratuit et vous pouvez l'utiliser sur :
https://www.agrimetsoft.com/Netcdf-Extractor.aspx</p></p>

posté par Hasan Sheidaee le 28 avril 2018 à 17:29 HAR #

Vous pouvez utiliser Grid Number Calculator. C'est une API dans Netcdf-Extractor Version 2.0. GNC est gratuit et vous pouvez l'utiliser sur :
https://agrimetsoft.com/Netcdf-Extractor.aspx</p></p>

posté par Hasan Sheidaee le 11 juillet 2018 à 09h34 HAR #

posté par Hasan shedaee le 17 juillet 2018 à 10h09 HAR #

Bonjour! Merci pour l'aide. Je ne peux pas accéder au bloc-notes. Il a été supprimé. Existe-t-il un moyen d'accéder au code. Merci :)

posté par Patricio Fernández le 19 octobre 2018 à 05:44 MDT #

"Open NC File" peut ouvrir et lire des données en utilisant la liste des coordonnées des stations. L'utilisateur nc peut saisir la liste des stations manuellement ou par fichier. "Open NC File" peut lire la liste des stations (constituées de coordonnées) dans un fichier texte ou un fichier excel ou un fichier csv. L'utilisateur nc peut sélectionner tous les fichiers nc et les fusionner dans "Open NC File".

posté par Sohrab Kolsoumi le 19 octobre 2018 à 08:01 MDT #

Toujours déroutant pour moi à propos de cet algorithme de programmation. Mais merci pour le partage

posté par Site Web Jasa Semarang le 14 décembre 2018 à 19:49 HNR #

Bonjour! Merci pour l'aide. Je ne peux pas accéder au bloc-notes. Il a été supprimé. Existe-t-il un moyen d'accéder au code. Merci :)

posté par Site Web Harga Jasa Pembuatan le 16 mars 2019 à 04:29 MDT #


Fonctions de tracé de référence¶

gcpy.benchmark contient plusieurs fonctions pour tracer la sortie de GEOS-Chem dans les formats demandés par le comité de pilotage de GEOS-Chem. L'utilisation principale de ces fonctions est de créer des tracés de la plupart des variables de sortie GEOS-Chem divisées en catégories spécifiques, par ex. catégories d'espèces telles que les aérosols ou le brome pour le diagnostic SpeciesConc. Dans chaque catégorie, ces fonctions créent des PDF à un seul niveau pour la surface et des PDF moyennes à 500 hPa et zonales pour l'ensemble de l'atmosphère et uniquement la stratosphère (définie entre 1 et 100 hPa). Pour make_benchmark_emis_plots() , seuls des tracés à un seul niveau à la surface sont produits. Toutes ces fonctions de traçage incluent des signets dans les PDF générés qui pointent vers les pages contenant chaque quantité tracée. Ainsi, ces fonctions servent d'outils pour créer rapidement des tracés complets comparant deux analyses GEOS-Chem. Ces fonctions sont utilisées pour créer les tracés accessibles au public pour les benchmarks à 1 mois et 1 an des nouvelles versions de GEOS-Chem.

Beaucoup de ces fonctions utilisent des listes de variables prédéfinies (via des fichiers YAML inclus dans GCPy). Si un jeu de données inclut une variable mais pas l'autre jeu de données, les données de cette variable dans ce dernier jeu de données seront considérées comme étant NaN et seront tracées comme telles.

Structure partagée¶

Chacune des fonctions gcpy.benchmark.make_benchmark_*_plots() nécessite 4 arguments pour spécifier les ensembles de données ref et dev.

Arguments:¶

Nom du chemin de l'ensemble de données « Ref » (alias « Référence »).

Une chaîne pour décrire la référence (par exemple, le numéro de version)

Nom du chemin de l'ensemble de données « Dev » (alias « Développement »).

Cet ensemble de données sera comparé à l'ensemble de données « Référence ».

Une chaîne pour décrire dev (par exemple, le numéro de version)

Notez que les arguments ref et dev dans make_benchmark_*_plots() sont les chemins vers les fichiers NetCDF, plutôt que les ensembles de données xarray comme dans compare_single_level() et compare_zonal_mean() . Les fonctions make_benchmark_*_plots() ouvrent en interne ces fichiers en tant qu'ensembles de données xarray et transmettent ces ensembles de données à compare_single_level() et compare_zonal_mean() .

Les fonctions de tracé de référence partagent plusieurs arguments de mot-clé. Les arguments de mots-clés qui ne partagent pas le même objectif entre les fonctions de traçage de référence ont REMARQUE : dans la description.

Arguments de mots clés partagés :¶

Une chaîne désignant le dossier de destination où un fichier PDF contenant des tracés sera écrit.

Une chaîne désignant le sous-répertoire de dst où les fichiers PDF contenant des tracés seront écrits. En pratique, subdst n'est nécessaire que pour la sortie de référence d'un an et désigne une chaîne de date (telle que « Jan2016 ») qui correspond au mois qui est tracé. REMARQUE : non disponible dans wetdep_plots

Définissez cet indicateur sur True pour écraser les fichiers précédemment créés dans le dossier de destination (spécifié par l'argument dst).

Définissez cet indicateur sur True pour imprimer une sortie d'information supplémentaire.

Définissez cet indicateur sur True pour permettre le traçage des données (les deux panneaux supérieurs de chaque tracé, pas les différences) sur une échelle de couleurs de journal.

sigdiff_files : liste de str ¶

Noms de fichiers qui contiendront la liste des quantités ayant des différences significatives entre les ensembles de données. Trois fichiers sont utilisés : un pour la surface, un pour 500hPa et un pour la moyenne zonale. Ces listes sont nécessaires pour remplir les formulaires d'approbation de référence. REMARQUE : non disponible dans wetdep_plots

Répertoire contenant le fichier species_database.yml. Ce fichier est utilisé pour les conversions d'unités en ug/m3. Les répertoires d'exécution de GEOS-Chem incluent une copie de ce fichier qui peut être plus à jour que la version incluse avec GCPy.

Valeur par défaut : chemin du dépôt de code GCPy

weightsdir : str ¶ Répertoire dans lequel placer (et éventuellement réutiliser) les fichiers netCDF du regrideur xESMF. ¶

Définit le nombre de nœuds de calcul simultanés pour le traçage parallèle. Réglez sur 1 pour désactiver le traçage parallèle. La valeur -1 permet à l'application de décider. REMARQUE : dans make_benchmark_conc_plots(), la parallélisation se produit au niveau de la catégorie d'espèce. Dans toutes les autres fonctions, la parallélisation se produit dans les appels à compare_single_level() et compare_zonal_mean().

Valeur par défaut : -1 dans make_benchmark_conc_plots, 1 dans tous les autres

Make_benchmark_aod_plots¶

Mots-clés spécifiques à la fonction args :

Liste des variables AOD à tracer. S'il n'est pas transmis, toutes les variables AOD communes à Dev et Ref seront tracées. Utilisez l'argument varlist pour restreindre le nombre de variables tracées dans le fichier pdf lors du débogage.

Cette fonction crée des tracés de profondeur optique de colonne à l'aide de la sortie de diagnostic Aérosols.

Make_benchmark_conc_plots¶

Mots-clés spécifiques à la fonction args :

Nom de la collection à utiliser pour le traçage.

Valeur par défaut : « SpeciesConc »

Une chaîne indiquant le type de sortie de référence à tracer, soit FullChemBenchmark ou TransportTracersBenchmark.

Valeur par défaut : « FullChemBenchmark »

Définissez cet indicateur sur False pour envoyer les tracés dans un fichier plutôt que dans un fichier séparé par catégorie.

restrict_cats : liste de str ¶

Liste des catégories de référence dans benchmark_categories.yml pour lesquelles créer des graphiques. S'il est vide, des tracés sont créés pour toutes les catégories.

Liste des types de tracés à créer.

Valeur par défaut : [‘sfc’, ‘500hpa’, ‘zonalmean’]

Définissez cet indicateur sur true pour activer la normalisation des données par surface (c'est-à-dire kg s-1 –> kg s-1 m-2).

Liste des catégories de référence à convertir en ug/m3

Valeur par défaut : [« Aerosols », « Secondary_Organic_Aerosols »]

zones : dict de xarray DataArray: ¶

Surfaces des maillages en m2 sur les grilles Réf et Dev.

Nom du chemin pour la météorologie de référence

Nom du chemin pour la météorologie de développement

Nom du chemin d'un deuxième ensemble de données « Ref » (alias « Référence ») pour le traçage diff-of-diffs. Cet ensemble de données doit avoir le même type de modèle et la même grille que la réf.

Nom du chemin d'un deuxième ensemble de données « Ref » (alias « Référence ») pour le traçage diff-of-diffs. Cet ensemble de données doit avoir le même type de modèle et la même grille que la réf.

Cette fonction crée des graphiques de concentration d'espèces à l'aide de la sortie de diagnostic SpeciesConc par défaut. Cette fonction est la seule fonction de traçage de référence qui prend en charge le traçage diff-of-diffs, dans lequel 4 ensembles de données sont transmis et les différences entre deux groupes d'ensembles de données Ref par rapport à deux groupes d'ensembles de données Dev sont tracées (généralement utilisé pour comparer les changements dans GCHP vs. . changements dans GEOS-Chem Classic selon les versions du modèle). C'est également la seule fonction de traçage de référence qui envoie des tracés dans des dossiers séparés en fonction de la catégorie (comme indiqué par l'indicateur plot_by_spc_cat). La liste complète des catégories d'espèces est indiquée dans benchmark_categories.yml (inclus dans GCPy) comme suit :

Make_benchmark_emis_plots¶

Mots-clés spécifiques à la fonction args :

selon les catégories d'espèces de référence (par exemple, Oxydants, Aérosols, Azote, etc.) Ces catégories sont spécifiées dans le fichier YAML benchmark_species.yml.

Définissez cet indicateur sur True pour séparer les tracés dans des fichiers PDF en fonction des catégories d'émissions HEMCO (par exemple, Anthro, Aircraft, Bioburn, etc.)

Définissez cet indicateur sur True pour inverser l'ordre des niveaux verticaux dans le jeu de données « Ref » (au cas où « Ref » commence par le sommet de l'atmosphère au lieu de la surface).

Définissez cet indicateur sur True pour inverser l'ordre des niveaux verticaux dans le jeu de données « Dev » (au cas où « Dev » commence par le haut de l'atmosphère au lieu de la surface).

Cette fonction génère des tracés des émissions totales à l'aide de la sortie de HEMCO_diagnostics (pour GEOS-Chem Classic) et/ou des fichiers de sortie GCHP.Emissions.

Make_benchmark_jvalue_plots¶

Mots-clés spécifiques à la fonction args :

Liste des variables de valeur J à tracer. S'il n'est pas transmis, toutes les variables de valeur J communes à dev et ref seront tracées. L'argument varlist peut être un moyen utile de restreindre le nombre de variables tracées dans le fichier pdf lors du débogage.

Définissez ce drapeau pour tracer les valeurs J locales de midi. Cela divisera toutes les variables de valeur J par le compteur JNoonFrac, qui est la fraction du temps où il était midi local à chaque emplacement.

Liste des types de tracés à créer.

Valeur par défaut : [‘sfc’, ‘500hpa’, ‘zonalmean’]

Définissez cet indicateur sur True pour inverser l'ordre des niveaux verticaux dans le jeu de données « Ref » (au cas où « Ref » commence par le haut de l'atmosphère au lieu de la surface).

Définissez cet indicateur sur True pour inverser l'ordre des niveaux verticaux dans le jeu de données « Dev » (au cas où « Dev » commence par le haut de l'atmosphère au lieu de la surface).

Cette fonction génère des tracés de valeurs J à l'aide des fichiers de sortie JValues ​​GEOS-Chem.

Make_benchmark_wetdep_plots¶

Function-specific keyword args:¶

A string with date information to be included in both the plot pdf filename and as a destination folder subdirectory for writing plots

A string denoting the type of benchmark output to plot, either FullChemBenchmark or TransportTracersBenchmark.


Interpolation Routines¶

Interpolating to a Horizontal Level¶

The wrf.interplevel() function is used to interpolate a 3D field to a specific horizontal level, usually pressure or height.

Vertical Cross Sections¶

The wrf.vertcross() function is used to create vertical cross sections. To define a cross section, a start point and an end point needs to be specified. Alternatively, a pivot point and an angle may be used. The start point, end point, and pivot point are specified using a wrf.CoordPair object, and coordinates can either be in grid (x,y) coordinates or (latitude,longitude) coordinates. When using (latitude,longitude) coordinates, a NetCDF file object or a wrf.WrfProj object must be provided.

The vertical levels can also be specified using the niveaux paramètre. If not specified, then approximately 100 levels will be chosen in 1% increments.

Example Using Start Point and End Point¶

Example Using Pivot Point and Angle¶

Example Using Lat/Lon Coordinates¶

Example Using Specified Vertical Levels¶

Interpolating Two-Dimensional Fields to a Line¶

Two-dimensional fields can be interpolated along a line, in a manner similar to the vertical cross section (see Vertical Cross Sections ), using the wrf.interpline() function. To define the line to interpolate along, a start point and an end point needs to be specified. Alternatively, a pivot point and an angle may be used. The start point, end point, and pivot point are specified using a wrf.CoordPair object, and coordinates can either be in grid (x,y) coordinates or (latitude,longitude) coordinates. When using (latitude,longitude) coordinates, a NetCDF file object or a wrf.WrfProj object must also be provided.

Example Using Start Point and End Point¶

Example Using Pivot Point and Angle¶

Example Using Lat/Lon Coordinates¶

Interpolating a 3D Field to a Surface Type¶

The wrf.vinterp() is used to interpolate a field to a type of surface. The available surfaces are pressure, geopotential height, theta, and theta-e. The surface levels to interpolate also need to be specified.


Preparation¶

Basic knowledge of Python is assumed. For Python beginners, I recommend Python Data Science Handbook par Jake VanderPlas, which is free available online. Skim through Chapter 1, 2 and 4, then you will be good! (Chapter 3 and 5 are important for general data science but not particularly necessary for working with gridded model data.)

It is crucial to pick up the correct tutorial when learning Python, because Python has a wide range of applications other than just science. For scientific research, you should only read data science tutorials. Other famous books such as Fluent Python and The Hitchhiker’s Guide to Python are great for general software development, but not quite useful for scientific research.

Once you manage to use Python in Jupyter Notebook, follow this GCPy page to set up Python environment for Geosciences. Now you should have everything necessary for working with GEOS-Chem data and most of earth science data in general.


5. Coordinate Systems

A data variable’s dimensions are used to locate data values in time and space or as a function of other independent variables. This is accomplished by associating these dimensions with the relevant set of latitude, longitude, vertical, time and any non-spatiotemporal coordinates. This section presents two methods for making that association: the use of coordinate variables, and the use of auxiliary coordinate variables.

Any of a variable’s dimensions that is an independently varying latitude, longitude, vertical, or time dimension (see Section 1.2, "Terminology") and that has a size greater than one must have a corresponding coordinate variable, i.e., a one-dimensional variable with the same name as the dimension (see examples in Chapter 4, Coordinate Types). This is the only method of associating dimensions with coordinates that is supported by [COARDS].

Any longitude, latitude, vertical or time coordinate which depends on more than one spatiotemporal dimension must be identified by the coordinates attribute of the data variable. La valeur de la coordinates l'attribut est a blank separated list of the names of auxiliary coordinate variables. There is no restriction on the order in which the auxiliary coordinate variables appear in the coordinates attribute string. The dimensions of an auxiliary coordinate variable must be a subset of the dimensions of the variable with which the coordinate is associated, with two exceptions. First, string-valued coordinates (Section 6.1, "Labels") will have a dimension for maximum string length if the coordinate variable has a type of char rather than a type of chaîne de caractères . Second, in the ragged array representations of data (Chapter 9, Discrete Sampling Geometries), special methods are needed to connect the data and coordinates

We recommend that the name of a multidimensional coordinate variable should not match the name of any of its dimensions because that precludes supplying a coordinate variable for the dimension. This practice also avoids potential bugs in applications that determine coordinate variables by only checking for a name match between a dimension and a variable and not checking that the variable is one dimensional.

If the longitude, latitude, vertical or time coordinate is multi-valued, varies in only one dimension, and varies independently of other spatiotemporal coordinates, it is not permitted to store it as an auxiliary coordinate variable. This is both to enhance conformance to COARDS and to facilitate the use of generic applications that recognize the NUG convention for coordinate variables. An application that is trying to find the latitude coordinate of a variable should always look first to see if any of the variable’s dimensions correspond to a latitude coordinate variable. If the latitude coordinate is not found this way, then the auxiliary coordinate variables listed by the coordinates attribute should be checked. Note that it is permissible, but optional, to list coordinate variables as well as auxiliary coordinate variables in the coordinates attribut. If the longitude, latitude, vertical or time coordinate is single-valued, it may be stored either as a coordinate variable with a dimension of size one, or as a scalar coordinate variable (Section 5.7, "Scalar Coordinate Variables").

Si un axe attribute is attached to an auxiliary coordinate variable, it can be used by applications in the same way the axe attribute attached to a coordinate variable is used. However, it is not permissible for a data variable to have both a coordinate variable and an auxiliary coordinate variable, or more than one of either type of variable, having an axe attribute with any given value e.g. there must be no more than one axe attribute for X for any data variable. Note that if the axe attribute is not specified for an auxiliary coordinate variable, it may still be possible to determine if it is a spatiotemporal dimension from its own units or standard_name, or from the units and standard_name of the coordinate variable corresponding to its dimensions (see Chapter 4, Coordinate Types). For instance, auxiliary coordinate variables which lie on the horizontal surface can be identified as such by their dimensions being horizontal. Horizontal dimensions are those whose coordinate variables have an axe attribute of X ou alors Oui , ou un units attribute indicating latitude and longitude.

To geo-reference data horizontally with respect to the Earth, a grid mapping variable may be provided by the data variable, using the grid_mapping attribut. If the coordinate variables for a horizontal grid are not longitude and latitude, then a grid_mapping variable provides the information required to derive longitude and latitude values for each grid location. Sinon grid mapping variable is referenced by a data variable, then longitude and latitude coordinate values shall be supplied in addition to the required coordinates. For example, the Cartesian coordinates of a map projection may be supplied as coordinate variables and, in addition, two-dimensional latitude and longitude variables may be supplied via the coordinates attribute on a data variable. The use of the axe attribute with values X et Oui is recommended for the coordinate variables (see Chapter 4, Coordinate Types).

It is sometimes not practical to specify the latitude-longitude location of data which is representative of geographic regions with complex boundaries. For this purpose, provision is made in Section 6.1.1, "Geographic Regions" for indicating the region by a standardized name.

5.1. Independent Latitude, Longitude, Vertical, and Time Axes

When each of a variable’s spatiotemporal dimensions is a latitude, longitude, vertical, or time dimension, then each axis is identified by a coordinate variable.

xwind(n,k,j,i) is associated with the coordinate values lon(i) , lat(j) , pres(k) , et time(n) .

5.2. Two-Dimensional Latitude, Longitude, Coordinate Variables

The latitude and longitude coordinates of a horizontal grid that was not defined as a Cartesian product of latitude and longitude axes, can sometimes be represented using two-dimensional coordinate variables. These variables are identified as coordinates by use of the coordinates attribut.

T(k,j,i) is associated with the coordinate values lon(j,i) , lat(j,i) , et lev(k) . The vertical coordinate is represented by the coordinate variable lev(lev) and the latitude and longitude coordinates are represented by the auxiliary coordinate variables lat(yc,xc) et lon(yc,xc) which are identified by the coordinates attribut.

Note that coordinate variables are also defined for the xc et yc dimensions. This faciliates processing of this data by generic applications that don’t recognize the multidimensional latitude and longitude coordinates.

5.3. Reduced Horizontal Grid

A "reduced" longitude-latitude grid is one in which the points are arranged along constant latitude lines with the number of points on a latitude line decreasing toward the poles. Storing this type of gridded data in two-dimensional arrays wastes space, and results in the presence of missing values in the 2D coordinate variables. We recommend that this type of gridded data be stored using the compression scheme described in Section 8.2, "Compression by Gathering". Compression by gathering preserves structure by storing a set of indices that allows an application to easily scatter the compressed data back to two-dimensional arrays. The compressed latitude and longitude auxiliary coordinate variables are identified by the coordinates attribut.

PS(n) is associated with the coordinate values lon(n) , lat(n) . Compressed grid index (n) would be assigned to 2D index (j,i) (C index conventions) where

Notice that even if an application does not recognize the compresse attribute, the grids stored in this format can still be handled, by an application that recognizes the coordinates attribut.

5.4. Timeseries of Station Data

This section has been superseded by the treatment of time series as a type of discrete sampling geometry in Chapter 9.

5.5. Trajectories

This section has been superseded by the treatment of time series as a type of discrete sampling geometry in Chapter 9.

5.6. Horizontal Coordinate Reference Systems, Grid Mappings, and Projections

UNE grid mapping variable may be referenced by a data variable in order to explicitly declare the coordinate reference system (CRS) used for the horizontal spatial coordinate values. For example, if the horizontal spatial coordinates are latitude and longitude, the grid mapping variable can be used to declare the figure of the earth (WGS84 ellipsoid, sphere, etc.) they are based on. If the horizontal spatial coordinates are easting and northing in a map projection, the grid mapping variable declares the map projection CRS used and provides the information needed to calculate latitude and longitude from easting and northing.

When the horizontal spatial coordinate variables are not longitude and latitude, it is required that further information is provided to geo-locate the horizontal position. UNE grid mapping variable provides this information.

Sinon grid mapping variable is provided and the coordinate variables for a horizontal grid are not longitude and latitude, then it is required that the latitude and longitude coordinates are supplied via the coordinates attribut. Such coordinates may be provided in addition to the provision of a grid mapping variable, but that is not required.

A grid mapping variable provides the description of the mapping via a collection of attached attributes. It is of arbitrary type since it contains no data. Its purpose is to act as a container for the attributes that define the mapping. The one attribute that all grid mapping variables must have is grid_mapping_name, which takes a string value that contains the mapping’s name. The other attributes that define a specific mapping depend on the value of grid_mapping_name. The valid values of grid_mapping_name along with the attributes that provide specific map parameter values are described in Appendix F, Grid Mappings

The grid mapping variables are associated with the data and coordinate variables by the grid_mapping attribut. This attribute is attached to data variables so that variables with different mappings may be present in a single file. The attribute takes a string value with two possible formats. In the first format, it is a single word, which names a grid mapping variable. In the second format, it is a blank-separated list of words "<gridMappingVariable>: <coordinatesVariable> [<coordinatesVariable> …​] [<gridMappingVariable>: <coordinatesVariable>…​]" , which identifies one or more grid mapping variables, and with each grid mapping associates one or more coordinatesVariables, i.e. coordinate variables or auxiliary coordinate variables.

Where an extended "<gridMappingVariable>: <coordinatesVariable> [<coordinatesVariable>]" entity is defined, then the order of the <coordinatesVariable> references within the definition provides an explicit order for these coordinate value variables, which is used if they are to be combined into individual coordinate tuples.

This order is only significant if crs_wkt is also specified within the referenced grid mapping variable. Explicit 'axis order' is important when the grid_mapping_variable contains an attribute crs_wkt as it is mandated by the OGC CRS-WKT standard that coordinate tuples with correct axis order are provided as part of the reference to a Coordinate Reference System.

Using the simple form, where the grid_mapping attribute is only the name of a grid mapping variable, 2D latitude and longitude coordinates for a projected coordinate reference system use the same geographic coordinate reference system (ellipsoid and prime meridian) as the projection is projected from.

The grid_mapping variable may identify datums (such as the reference ellipsoid, the geoid or the prime meridian) for horizontal or vertical coordinates. Therefore a grid mapping variable may be needed when the coordinate variables for a horizontal grid are longitude and latitude. The grid_mapping_name of latitude_longitude should be used in this case.

The expanded form of the grid_mapping attribute is required if one wants to store coordinate information for more than one coordinate reference system. In this case each coordinate or auxiliary coordinate is defined explicitly with respect to no more than one grid_mapping variable. This syntax may be used to explicitly link coordinates and grid mapping variables where only one coordinate reference system is used. In this case, all coordinates and auxiliary coordinates of the data variable not named in the grid_mapping attribute are unrelated to any grid mapping variable. All coordinate names listed in the grid_mapping attribute must be coordinate variables or auxiliary coordinates of the data variable.

In order to make use of a grid mapping to directly calculate latitude and longitude values it is necessary to associate the coordinate variables with the independent variables of the mapping. This is done by assigning a nom_standard to the coordinate variable. The appropriate values of the nom_standard depend on the grid mapping and are given in Appendix F, Grid Mappings.

A CF compliant application can determine that rlon and rlat are longitude and latitude values in the rotated grid by recognizing the standard names grid_longitude et grid_latitude . Note that the units of the rotated longitude and latitude axes are given as degrees . This should prevent a COARDS compliant application from mistaking the variables rlon et rlat to be actual longitude and latitude coordinates. The entries for these names in the standard name table indicate the appropriate sign conventions for the units of degrees .

An application can determine that x and y are the projection coordinates by recognizing the standard names projection_x_coordinate and projection_y_coordinate . The grid mapping variable Lambert_Conformal contains the mapping parameters as attributes, and is associated with the Temperature variable via its grid_mapping attribute.

5.6.1. Use of the CRS Well-known Text Format

An optional grid mapping attribute called crs_wkt may be used to specify multiple coordinate system properties in so-called well-known text format (usually abbreviated to CRS WKT or OGC WKT). The CRS WKT format is widely recognised and used within the geoscience software community. As such it represents a versatile mechanism for encoding information about a variety of coordinate reference system parameters in a highly compact notational form. The translation of CF coordinate variables to/from OGC Well-Known Text (WKT) format is shown in Examples 5.11 and 5.12 below and described in detail in https://github.com/cf-convention/cf-conventions/wiki/Mapping-from-CF-Grid-Mapping-Attributes-to-CRS-WKT-Elements.

Le crs_wkt attribute should comprise a text string that conforms to the WKT syntax as specified in reference [OGC_WKT-CRS]. If desired the text string may contain embedded newline characters to aid human readability. However, any such characters are purely cosmetic and do not alter the meaning of the attribute value. It is envisaged that the value of the crs_wkt attribute typically will be a single line of text, one intended primarily for machine processing. Other than the requirement to be a valid WKT string, the CF convention does not prescribe the content of the crs_wkt attribute since it will necessarily be context-dependent.

Où un crs_wkt attribute is added to a grid_mapping, the extended syntax for the grid_mapping attribute enables the list of variables containing coordinate values being referenced to be explicitly stated and the CRS WKT Axis order to be explicitly defined. The explicit definition of WKT CRS Axis order is expected by the OGC standards for referencing by coordinates. Software implementing these standards are likely to expect to receive coordinate value tuples, with the correct coordinate value order, along with the coordinate reference system definition that those coordinate values are defined with respect to.

The order of the <coordinatesVariable> references within the grid_mapping attribute definition defines the order of elements within a derived coordinate value tuple. This enables an application reading the data from a file to construct an array of coordinate value tuples, where each tuple is ordered to match the specification of the coordinate reference system being used whilst the array of tuples is structured according to the netCDF definition. It is the responsibility of the data producer to ensure that the <coordinatesVariable> list is consistent with the CRS WKT definition of CS AXIS, with the correct number of entries in the correct order (note: this is not a conformance requirement as CF conformance is not dependent on CRS WKT parsing).

For example, a file has two coordinate variables, lon and lat, and a grid mapping variable crs with an associated crs_wkt attribute the WKT definition defines the AXIS order as ["latitude", "longitude"]. The grid_mapping attribute is thus given a value crs:lat lon to define that where coordinate pairs are required, these shall be ordered (lat, lon), to be consistent with the provided crs_wkt string (and not order inverted). A 2-D array of (lat, lon) tuples can then be explicitly derived from the combination of the lat and lon variables.

Le crs_wkt attribute is intended to act as a supplément to other single-property CF grid mapping attributes (as described in Appendix F) it is not intended to replace those attributes. If data producers omit the single-property grid mapping attributes in favour of the compound crs_wkt attribute, software which cannot interpret crs_wkt will be unable to use the grid_mapping information. Therefore the CRS should be described as thoroughly as possible with the single-property attributes as well as by crs_wkt .

There will be occasions when a given CRS property value is duplicated in both a single-property grid mapping attribute and the crs_wkt attribut. In such cases the onus is on data producers to ensure that the property values are consistent. However, in those situations where two values of a given property are different, then the value specified by the single-property attribute shall take precedence. For example, if the semi-major axis length of the ellipsoid is defined by the grid mapping attribute semi_major_axis and also by the crs_wkt attribute (via the WKT SPHEROID[…​] element) then the former, being the more specific attribute, takes precedence. Naturally if the two values are equal then no ambiguity arises.

Likewise, in those cases where the value of a CRS WKT element should be used consistently across the CF-netCDF community (names of projections and projection parameters, for example) then, the values shown in https://github.com/cf-convention/cf-conventions/wiki/Mapping-from-CF-Grid-Mapping-Attributes-to-CRS-WKT-Elements should be preferred these are derived from the OGP/EPSG registry of geodetic parameters, which is considered to represent the definitive authority as regards CRS property names and values.

Examples 5.11 illustrates how the coordinate system properties specified via the crs grid mapping variable in Example 5.9 might be expressed using a crs_wkt attribut. Example 5.12 also illustrates the addition of the crs_wkt attribute, but here the attribute is added to the crs variable of a simplified variant of Example 5.10. For brevity in Example 5.11, only the grid mapping variable and its grid_mapping_name and crs_wkt attributes are included all other elements are as per the Example 5.9. Names of projection PARAMETERs follow the spellings used in the EPSG geodetic parameter registry.

Example 5.12 illustrates how certain WKT elements - all of which are optional - can be used to specify CRS properties not covered by existing CF grid mapping attributes, including:

use of the VERT_DATUM element to specify vertical datum information

use of additional PARAMETER elements (albeit not essential ones in this example) to define the location of the false origin of the projection

use of AUTHORITY elements to specify object identifier codes assigned by an external authority, OGP/EPSG in this instance

Note: To enhance readability of these examples, the WKT value has been split across multiple lines and embedded quotation marks (") left unescaped - in real netCDF files such characters would need to be escaped. In CDL, within the CRS WKT definition string, newlines would need to be encoded within the string as and double quotes as " . Also for readability, we have dropped the quotation marks which would delimit the entire crs_wkt string. This pseudo CDL will not parse directly.

Note: There are unescaped double quotes and newlines and the quotation marks which would delimit the entire crs_wkt string are missing in this example. This is to enhance readability, but it means that this pseudo CDL will not parse directly.

The preceding two example (5.11 and 5.12) may be combined, if the data provider desires to provide explicit latitude and longitude coordinates as well as projection coordinates and to provide CRS WKT referencing for both sets of coordinates. This is demonstrated in example 5.13

Note: There are unescaped double quotes and newlines and the quotation marks which would delimit the entire crs_wkt string are missing in this example. This is to enhance readability, but it means that this pseudo CDL will not parse directly.

5.7. Scalar Coordinate Variables

When a variable has an associated coordinate which is single-valued, that coordinate may be represented as a scalar variable (i.e. a data variable which has no netCDF dimensions). Since there is no associated dimension these scalar coordinate variables should be attached to a data variable via the coordinates attribut.

The use of scalar coordinate variables is a convenience feature which avoids adding size one dimensions to variables. A numeric scalar coordinate variable has the same information content and can be used in the same contexts as a size one numeric coordinate variable. Similarly, a string-valued scalar coordinate variable has the same meaning and purposes as a size one string-valued auxiliary coordinate variable (Section 6.1, "Labels"). Note however that use of this feature with a latitude, longitude, vertical, or time coordinate will inhibit COARDS conforming applications from recognizing them.

Once a name is used for a scalar coordinate variable it can not be used for a 1D coordinate variable. For this reason we strongly recommend against using a name for a scalar coordinate variable that matches the name of any dimension in the file.

If a data variable has two or more scalar coordinate variables, they are regarded as though they were all independent coordinate variables with dimensions of size one. If two or more single-valued coordinates are not independent, but have related values (this might be the case, for instance, for time and forecast period, or vertical coordinate and model level number, Section 6.2, "Alternative Coordinates"), they should be stored as coordinate or auxiliary coordinate variables of the same size one dimension, not as scalar coordinate variables.

In this example both the analysis time and the single pressure level are represented using scalar coordinate variables. The analysis time is identified by the standard name "forecast_reference_time" while the valid time of the forecast is identified by the standard name "time".


AreaDefinition Class Methods¶

There are four class methods available on the AreaDefinition class utilizing create_area_def() providing a simpler interface to the functionality described in the previous section. Hence each argument used below is the same as the create_area_def arguments described above and can be used in the same way (i.e. units). The following functions require area_id et projection along with a few other arguments:

From_extent¶

From_circle¶

From_area_of_interest¶

From_ul_corner¶


Exemples

Display Regular Data Grid as Texture Map

Load elevation data and a geographic cells reference object for the Korean peninsula. Create a set of map axes for the Korean peninsula using worldmap .

Display the elevation data as a texture map. Apply a colormap appropriate for elevation data using demcmap .

Display Polygons on Map Projection

Import a shapefile containing the coastline coordinates of Africa, Asia, and Europe. Verify the data represents a polygon by querying its Geometry field.

Display the polygon on a world map. NaN values in coast separate the external continent boundary from the internal pond and lake boundaries.

Define Face Colors and Set Default Face Colors

Load sample data representing the USA. Set up an empty map axes with projection and limits suitable for displaying all 50 states.

Create a symbolization specification that sets the color of Alaska and Hawaii polygons to red.

Display all the other states, setting the default face color to blue and the default edge color to black.

Create Map and Display NaNs as Transparent

Load elevation data and a geographic cells reference object for the Korean peninsula. Insert a band of null values into the elevation data.

Create a set of map axes for the Korean peninsula using worldmap . Then, display the elevation data as a surface with transparent null values.

Display EGM96 Geoid Heights Masking Out Land Areas

Get geoid heights and a geographic postings reference object from the EGM96 geoid model. Then, display the geoid heights as a surface using an Eckert projection. Ensure the surface appears under the land mask by setting the 'CData' name-value pair to the geoid height data and the 'ZData' name-value pair to a matrix of zeros. Display the frame and grid of the map using framem and gridm .

Create a colorbar and add a text description. Then, mask out all the land.

Display EGM96 Geoid Heights as 3-D Surface

Get geoid heights and a geographic postings reference object from the EGM96 geoid model. Then, display the geoid heights as a surface using an Eckert projection.

Add light and material. Then, view the map as a 3-D surface.

Display Moon Albedo Using Orthographic Projection

Load moon albedo data and a geographic cells reference object.

Then, display the data. To do this, create a map axes object and specify its projection as orthographic. Display the data in the map axes as a texture map using the geoshow function. Then, change the colormap to grayscale and remove the axis lines.


NCO netCDF Operators

I have a NetCDF file structure as below. How can I delete the dimensions & variables such as "Band", "OpticalDepth", "ParticleType"?

I tried "ncks -x -v Band in.nc out.nc". It went thru from the command without any error. but when I ncdump out.nc, I see the variable/dimension "Band" is still in the file. Qu'est-ce qui ne va pas? Any suggestion how to do it?

dimensions:
Band = 1
time = UNLIMITED // (5 currently)
OpticalDepth = 1
ParticleType = 1
variables:
int Band(Band)
Band:long_name = "Band(fake)"
Band:units = "level"
Band:standard_name = "band"
double my_plottable_variable(time, OpticalDepth, Band, ParticleType)
my_plottable_variable:_FillValue = -9999.
my_plottable_variable:coordinates = "time"
my_plottable_variable:long_name = "my plottable variable"
int OpticalDepth(OpticalDepth)
OpticalDepth:long_name = "OpticalDepth(fake)"
OpticalDepth:units = "level"
OpticalDepth:standard_name = "opticaldepth"
int ParticleType(ParticleType)
ParticleType:long_name = "ParticleType(fake)"
ParticleType:units = "level"
ParticleType:standard_name = "particletype"
int time(time)
time:standard_name = "time"
time:units = "seconds since 1970-01-01 00:00:00"

Oups. just tried again, it complains with my command:
$ ncks -O -x -v new_misr.nc mytest.nc
ncks: ERROR mytest.nc neither exists locally nor matches remote filename patterns
$

so , still the same question -- what is the command to delete a dimension and a variable at the same time or separately?

ncks -C -O -x -v Band new_misr.nc mytest.nc

this will not delete the dimension because another variable (my_plottable_variable) needs it.

ncks -O -x -v Band,my_plottable_variable new_misr.nc mytest.nc

do appreciate. I see the problem now.

however, the variables 'my_plottable_variable' and "time" are to be used for a time series plot. so, deleting 'my_plottable_variable" is not a solution in my case. how to remove the "Band" dimension referenced by "my_plottable_variable"?

my final goal is to generate a file like below:

dimensions:
time = UNLIMITED // (5 currently)

variables:
double my_plottable_variable(time)
my_plottable_variable:_FillValue = -9999.
my_plottable_variable:coordinates = "time"
my_plottable_variable:long_name = "my plottable variable"

int time(time)
time:standard_name = "time"
time:units = "seconds since 1970-01-01 00:00:00"