Introduction of Reading and Writing NetCDF files_fr
Please find the English version of this page here.
Veuillez trouver la version anglaise de cette page ici.
Il s'agit d'une introduction à la création de fichiers NetCDF avec Matlab, Octave et Python. L'accent est mis ici sur la définition des dimensions, des variables et des attributs de manière à ce qu'ils respectent la norme NetCDF appelée convention CF. Les fichiers suivant cette convention sont pris en charge par la plupart des outils pour visualiser et perturber les fichiers NetCDF.
Les outils pour visualiser les fichiers NetCDF sont, par exemple, Panoply (tous les OS), NcView (uniquement UNIX), QGIS (tous les systèmes d'exploitation), ArcGIS (uniquement Windows). Les possibilités de lire, d'écrire et de perturber les fichiers NetCDF sont Matlab, Octave, Python, Fortran, C, etc. Il existe également des boîtes à outils de ligne de commande utiles qui permettent de modifier les fichiers NetCDF tels que CDO et NCO.
Pour des scripts plus utiles sur NetCDF et des fichiers de forme, consultez également la bibliothèque Candex développée par Shervan Gharari (Université de Saskatchewan).
Structure de cet article :
- Scripts utilisés pour les exemples
- Exemple
- Écrire des fichiers NetCDF dans Matlab ou Octave
- Écrire des fichiers NetCDF en Python
- Lire les fichiers NetCDF dans Matlab ou Octave
- Lire les fichiers NetCDF en Python
- Lire les fichiers NetCDF dans R
- Vérifiez le fichier NetCDF par rapport à la convention CF
Tous les scripts qui seront utilisés pour les exemples ci-dessous sont disponibles dans les scripts utilitaires. Les sections suivantes les expliqueront étape par étape.
- écrire avec:
- Matlab (lien ou télécharger)
- Python (lien ou télécharger)
- lire avec :
- Matlab (lien ou télécharger)
- Python (lien ou télécharger)
- R (lien ou télécharger)
Supposons un champ de données de précipitations appelé pre. Notre domaine est X=4 (colonnes) par Y=2 (lignes) représentant 8 cellules de grille. La série chronologique des précipitations contient T=3 points temporels:
pre = [ % timestep t=1: 2018-01-01 00:00:00
[ [ -9999.0, 1.0, 2.0, 1.0 ],
[ 1.0, 1.0, 0.0, 0.0 ] ],
% timestep t=2: 2018-01-01 06:00:00
[ [ -9999.0, 0.0, 0.0, 0.0 ],
[ 0.0, 0.0, 0.0, 0.0 ] ],
% timestep t=3: 2018-01-01 18:00:00
[ [ -9999.0, 4.0, 4.0, 1.0 ],
[ 1.0, 1.0, -9999.0, 0.0 ] ] ]
Outre les données, dans notre cas pre, d'autres variables connexes peuvent être définies dans un NetCDF. Par exemple, la latitude et la longitude des domaines pour "pre" peuvent être spécifiées comme suit:
lat = [ [ 50.0, 50.0, 50.0, 50.0 ],
[ 49.0, 49.0, 49.0, 49.0 ] ]
lon = [ [ -110.0, -109.0, -108.0, -107.0 ],
[ -110.0, -109.0, -108.0, -107.0 ] ]
Les valeurs de latitude et de longitude n'ont pas nécessairement besoin d'être au format normal comme le montre cet exemple.
D'autres variables liées aux cellules telles que grid_ID peuvent être spécifiées dans le fichier NetCDF.
grid_ID = [ [ 120.0, 121.0, 125.0, 130.0 ],
[ 122.0, 124.0, 140.0, 131.0 ] ]
Ici, nous fournissons un script simple pour écrire un NetCDF avec les exemples mentionnés ci-dessus. Les lecteurs peuvent simplement copier les scripts partie par partie dans Matlab Workspace et suivre la progression.
Les commandes sont toutes pour Matlab mais peuvent également être utilisées dans Octave. Dans Octave, vous devez remplacer toutes les commandes netcdf.<fonction> par netcdf_<fonction>.
Le script complet est disponible sous lien ou télécharger. Nous allons maintenant parcourir ce script étape par étape.
Tout d'abord, nous devons charger certains modules et initialiser les variables dans Matlab/Octave.
close all;
clear all;
clc;
pkg load io; % only in Octave
pkg load netcdf; % only in Octave
T_data = [ 0; 6; 18];
lat_data = [ 50.0, 50.0, 50.0, 50.0 ;
49.0, 49.0, 49.0, 49.0 ];
lon_data = [ -110.0, -109.0, -108.0, -107.0;
-110.0, -109.0, -108.0, -107.0 ];
% timestep t=1: 2018-01-01 00:00:00
pre (:,:,1) = [ -9999.0, 1.0, 2.0, 1.0;
1.0, 1.0, 0.0, 0.0 ];
% timestep t=2: 2018-01-01 06:00:00
pre (:,:,2) = [ -9999.0, 0.0, 0.0, 0.0 ;
0.0, 0.0, 0.0, 0.0 ];
% timestep t=3: 2018-01-01 18:00:00
pre (:,:,3) = [ -9999.0, 4.0, 4.0, 1.0 ;
1.0, 1.0, -9999.0, 0.0 ];
grid_ID = [ 120.0, 121.0, 125.0, 130.0 ;
122.0, 124.0, 140.0, 131.0 ];Nous devons maintenant créer un nouveau fichier NetCDF :
ncid = netcdf.create('NetCDF_Matlab.nc','NETCDF4'); % Matlab
ncid = netcdf_create('NetCDF_Octave.nc','NETCDF4'); % OctaveL'étape suivante consiste à créer des dimensions qui spécifient le nombre et la taille des variables temporelles, des variables spatiales et de toutes les autres variables. Dans notre exemple, les dimensions sont X=2, Y=4 et T=3. Sachez que vous devez remplacer netcdf.defDim par netcdf_defDim si vous utilisez Octave.
dimid_X = netcdf.defDim(ncid,'nlon',2);
dimid_Y = netcdf.defDim(ncid,'nlat',4);
dimid_T = netcdf.defDim(ncid,'time',3);Habituellement, la dimension temporelle est définie sur "illimité", de sorte qu'il est plus facile d'ajouter des données supplémentaires ultérieurement. Une dimension illimitée est créée comme ceci (au lieu de la commande ci-dessus) :
dimid_T = netcdf.defDim(ncid,'time', netcdf.getConstant('NC_UNLIMITED'));La variable de temps est exprimée en pas de temps depuis un point de départ du temps. La date de référence est spécifiée dans l'attribut units pour le temps suivant le modèle standard [secondes/heures/jours] depuis AAAA-MM-JJ HH:MM:SS. Il n'y a aucune flexibilité dans la définition des unités de la variable de temps. Si vous y apportez des modifications ou décidez de ne pas suivre cette norme, vous aurez des problèmes pour utiliser ce fichier NetCDF dans les applications. Dans notre exemple, les pas de temps sont les suivants :
% timestep t=1: 2018-01-01 00:00:00
% timestep t=2: 2018-01-01 06:00:00
% timestep t=3: 2018-01-01 18:00:00
Il existe un nombre illimité de possibilités pour régler l'heure. Les exemples suivants donnent tous les mêmes résultats :
hours since 2018-01-01 00:00:00 --> T_data = [ 0; 6; 18]
days since 2018-01-01 00:00:00 --> T_data = [ 0.0; 0.25; 0.75]
days since 2017-01-01 00:00:00 --> T_data = [365.0; 365.25; 365.75]
Une bonne règle sinon le pouce est réglé sur l'unité de sorte que la variable de temps ne contienne que des entiers. Par conséquent, personnellement, je préférerais la première option, mais c'est à vous de décider.
Le code pour définir la variable de temps est :
% variables
time_varid = netcdf.defVar(ncid,'time','NC_INT', dimid_T);
T_data = [ 0; 6; 18];
% Les attributs
netcdf.putAtt(ncid,time_varid ,'long_name','time');
netcdf.putAtt(ncid,time_varid ,'units','hours since 2018-01-01 00:00:00');
netcdf.putAtt(ncid,time_varid ,'calendar','gregorian');
netcdf.putAtt(ncid,time_varid ,'standard_name','time');
netcdf.putAtt(ncid,time_varid ,'axis','T');
% Écrire des données
netcdf.endDef(ncid);
% if dimid_T = netcdf.defDim(ncid,'time',3); is used
netcdf.putVar(ncid,time_varid,T_data)
% if dimid_T = netcdf.defDim(ncid,'time', netcdf.getConstant('NC_UNLIMITED')); is used
netcdf.putVar(ncid,time_varid,[0],[3],T_data)Ici, nous travaillons sur des variables qui identifient l'étendue spatiale des données. Il est recommandé d'ajouter des informations spatiales à toutes les données dont vous disposez. Même , par exemple, les données de débit montrent être géoréférencées puisque le garage de débit a une localisation spatiale. Dans notre exemple, les données correspondent à des valeurs de latitude et de longitude spécifiques. La manière d'encoder les informations spatiales dans NetCDF est bien décrite dans la norme. Comme pour le temps, il est fortement recommandé d'utiliser les attributs décrits ci-dessous. Vous êtes théoriquement autorisé à définir les attributs comme vous le souhaitez, mais il est très probable que ces NetCDF ne soient pas pris en charge par divers logiciels et programmes. L'attribut long_name est l'endroit où vous pouvez mettre ce que vous voulez et ajouter toutes les informations nécessaires. Vous pouvez également ajouter des attributs supplémentaires si nécessaire.
% variables
netcdf.reDef(ncid);
lat_varid = netcdf.defVar(ncid,'lat','NC_DOUBLE',[dimid_X dimid_Y]);
lon_varid = netcdf.defVar(ncid,'lon','NC_DOUBLE',[dimid_X dimid_Y]);
% Les attributs
netcdf.putAtt(ncid,lat_varid,'long_name', 'latitude');
netcdf.putAtt(ncid,lon_varid,'long_name', 'longitude');
netcdf.putAtt(ncid,lat_varid,'units', 'degrees_north');
netcdf.putAtt(ncid,lon_varid,'units', 'degrees_east');
netcdf.putAtt(ncid,lat_varid,'standard_name','latitude');
netcdf.putAtt(ncid,lon_varid,'standard_name','longitude');
% Écrire des données
netcdf.endDef(ncid);
netcdf.putVar(ncid,lat_varid,lat_data)
netcdf.putVar(ncid,lon_varid,lon_data)L'étape suivante consiste à former les variables une par une en utilisant toutes les dimensions spécifiées à l'étape précédente. La création de variables comprend trois étapes :
- créer la structure variable avec des dimensions,
- définir les attributs et les métadonnées d'une variable (la bonne pratique consiste à définir au moins les attributs
long_nameetunits), et - définir les valeurs réelles des variables.
Pour notre cas, nous n'avons que les deux variables pre(x,y,t) et
grid_ID(x,y).
% variables
netcdf.reDef(ncid);
pre_varid = netcdf.defVar(ncid,'pre', 'NC_DOUBLE',[dimid_X dimid_Y dimid_T]);
grid_ID_varid = netcdf.defVar(ncid,'grid_ID','NC_DOUBLE',[dimid_X dimid_Y]);
% Les attributs
netcdf.putAtt(ncid,pre_varid, 'long_name', 'Precipitation');
netcdf.putAtt(ncid,grid_ID_varid, 'long_name', 'Grid ID (numbering grid cells from 1 to N)');
netcdf.putAtt(ncid,pre_varid, 'units', 'mm');
netcdf.putAtt(ncid,grid_ID_varid, 'units', '1');
netcdf.putAtt(ncid,pre_varid, 'coordinates','lon lat');
netcdf.putAtt(ncid,grid_ID_varid, 'coordinates','lon lat');
% Écrire des données
netcdf.endDef(ncid);
netcdf.putVar(ncid,pre_varid, pre)
netcdf.putVar(ncid,grid_ID_varid,grid_ID)Enfin, nous définissons des attributs globaux pour le fichier NetCDF.
netcdf.reDef(ncid);
netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'Conventions','CF-1.6');
netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'License', 'The data were written by me. They are under GPL.');
netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'history', ['Created ',datestr(datetime('now'))]);
netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'source', 'Written by CaSPAr test script (https://github.com/julemai/CaSPAr).');
netcdf.endDef(ncid);Pour vous assurer que toutes les modifications sont correctement enregistrées dans le fichier NetCDF, vous pouvez fermer l'écriture des fichiers :
netcdf.close(ncid)Le script complet est disponible sous lien ou télécharger. Nous allons maintenant parcourir ce script étape par étape.
Chargez d'abord les packages nécessaires :
import netCDF4 as nc4 # to work with netCDFs
import numpy as np # to perform numerics
import timeNous préparons ensuite les données. Les valeurs définies sont juste à des fins de démonstration. Vous pouvez les obtenir en sortie de modèle ou les lire à partir d'un autre fichier :
pre = np.array([ [ [ -9999.0, 1.0, 2.0, 1.0 ],
[ 1.0, 1.0, 0.0, 0.0 ] ],
[ [ -9999.0, 0.0, 0.0, 0.0 ],
[ 0.0, 0.0, 0.0, 0.0 ] ],
[ [ -9999.0, 4.0, 4.0, 1.0 ],
[ 1.0, 1.0, -9999.0, 0.0 ] ] ])
lat_data = np.array( [ [ 50.0, 50.0, 50.0, 50.0 ],
[ 49.0, 49.0, 49.0, 49.0 ] ])
lon_data = np.array( [ [ -110.0, -109.0, -108.0, -107.0 ],
[ -110.0, -109.0, -108.0, -107.0 ] ])
grid_ID = np.array( [ [ 120.0, 121.0, 125.0, 130.0 ],
[ 122.0, 124.0, 140.0, 131.0 ] ])
T_data = np.array( [ 0,6,18 ])Nous devons maintenant créer un nouveau fichier NetCDF :
ncid = nc4.Dataset("NetCDF_Python.nc", "w", format="NETCDF4")L'étape suivante consiste à créer des dimensions qui spécifient le nombre et la taille des variables temporelles, des variables spatiales et de toutes les autres variables. Dans notre exemple, les dimensions sont X=2, Y=4 et T=3.
dimid_X = ncid.createDimension('nlon',2)
dimid_Y = ncid.createDimension('nlat',4)
dimid_T = ncid.createDimension('time',3)Habituellement, la dimension temporelle est définie sur "illimité", de sorte qu'il est plus facile d'ajouter des données supplémentaires ultérieurement. Une dimension illimitée est créée comme ceci (au lieu de la commande ci-dessus) :
dimid_T = ncid.createDimension('time',None)Quelques détails sur les variables de temps dans NetCDF sont donnés dans la section Matlab.
Le code pour définir la variable de temps en Python est :
# variables
time_varid = ncid.createVariable('time','i4',('time',),zlib=True)
# Les attributs
time_varid.long_name = 'time'
time_varid.units = 'hours since 2018-01-01 00:00:00'
time_varid.calendar = 'gregorian'
time_varid.standard_name = 'time'
time_varid.axis = 'T'
# Écrire des données
time_varid[:] = T_dataDes détails sur les variables spatiales peuvent être trouvés dans la section Matlab. Sachez simplement que les modifications apportées à la configuration ci-dessous (même le changement des minuscules aux majuscules) peuvent entraîner la situation dans laquelle vos fichiers NetCDF ne sont plus pris en charge par d'autres applications.
# variables
lat_varid = ncid.createVariable('lat','f8',('nlon','nlat',),zlib=True)
lon_varid = ncid.createVariable('lon','f8',('nlon','nlat',),zlib=True)
# Les attributs
lat_varid.long_name = 'latitude'
lon_varid.long_name = 'longitude'
lat_varid.units = 'degrees_north'
lon_varid.units = 'degrees_east'
lat_varid.standard_name = 'latitude'
lon_varid.standard_name = 'longitude'
# Écrire des données
lat_varid[:] = lat_data
lon_varid[:] = lon_dataEnfin, nous pouvons créer les autres variables (ici grid_ID(x,y) et pre(time,x,y)). La création de variables comprend trois étapes :
- créer la structure variable avec des dimensions,
- définir les attributs et les métadonnées d'une variable (la bonne pratique consiste à définir au moins les attributs
long_nameetunits), et - définir les valeurs réelles des variables.
L'attribut zlib active la compression de fichier interne NetCDF et produit des fichiers beaucoup plus petits que sans l'attribut. netcdf.defVarDeflate est similaire à zlib dans Matlab.
# variable
pre_varid = ncid.createVariable('pre', 'f8',('time','nlon','nlat',),zlib=True)
grid_ID_varid = ncid.createVariable('grid_ID','f8',( 'nlon','nlat',),zlib=True)
# Les attributs
pre_varid.long_name = 'Precipitation'
grid_ID_varid.long_name = 'Grid ID (numbering grid cells from 1 to N)'
pre_varid.units = 'mm'
grid_ID_varid.units = '1'
pre_varid.coordinates = 'lon lat'
grid_ID_varid.coordinates = 'lon lat'
# Écrire des données
pre_varid[:] = pre
grid_ID_varid[:] = grid_IDEnfin, nous définissons des attributs globaux pour le fichier NetCDF.
ncid.Conventions = 'CF-1.6'
ncid.License = 'The data were written by me. They are under GPL.'
ncid.history = 'Created ' + time.ctime(time.time())
ncid.source = 'Written by CaSPAr test script (https://github.com/julemai/CaSPAr).'ncid.close()Le script complet est disponible sous lien ou télécharger. Nous allons maintenant parcourir ce script étape par étape.
Pour lire un fichier NetCDF dans Matlab ou Octave, il faut d'abord connaître les variables NetCDF et leur attribut. Pour ce faire, nous pouvons utiliser la commande ncdisp pour le fichier NetCDF que nous avons créé (il peut s'agir de n'importe quel fichier NetCDF) :
ncdisp('NetCDF_Matlab.nc'); % in Matlab and OctaveLa fonction renvoie les attributs globaux, les dimensions, les variables et leurs attributs comme suit :
Format:
netcdf4
Global Attributes:
Conventions = 'CF-1.6'
License = 'The data were written by me. They are under GPL.'
history = 'Created 24-Oct-2018 10:09:06'
source = 'Written by CaSPAr test script (https://github.com/julemai/CaSPAr).'
Dimensions:
nlon = 2
nlat = 4
time = 3
Variables:
time
Size: 3x1
Dimensions: time
Datatype: int32
Attributes:
long_name = 'time'
units = 'hours since 2018-01-01 00:00:00'
calendar = 'gregorian'
standard_name = 'time'
axis = 'T'
lat
Size: 2x4
Dimensions: nlon,nlat
Datatype: double
Attributes:
long_name = 'latitude'
units = 'degrees_north'
standard_name = 'latitude'
lon
Size: 2x4
Dimensions: nlon,nlat
Datatype: double
Attributes:
long_name = 'longitude'
units = 'degrees_east'
standard_name = 'longitude'
pre
Size: 2x4x3
Dimensions: nlon,nlat,time
Datatype: double
Attributes:
long_name = 'Precipitation'
units = 'mm'
coordinates = 'lon lat'
grid_ID
Size: 2x4
Dimensions: nlon,nlat
Datatype: double
Attributes:
long_name = 'Grid ID (numbering grid cells from 1 to N)'
units = '1'
coordinates = 'lon lat'
Comme vous pouvez le voir, ce NetCDF a quatre variables pre, lat, lon et grid_ID qui sont définies au début de l'exemple décrit au début de cette page.
Pour lire l'une des variables, nous utilisons ncread :
lat = ncread('NetCDF_Matlab.nc','lat') % in Matlab and OctaveCela devrait retourner :
lat =
50 50 50 50
49 49 49 49
Le format NetCDF permet à l'utilisateur de lire une partie particulière du fichier NetCDF sans lire la variable entière. Par exemple, disons que nous aimerions avoir la variable pre pour le lat=50.0 et lon=-108.0 pour tous les pas de temps. Tout d'abord, nous devons trouver l'emplacement des lat et lon souhaités. Cet emplacement dans Matlab est [1 3]. Pour lire la variable, nous pouvons utiliser le ncread :
pre_lat_lon = ncread('NetCDF_Matlab.nc','pre',[1 3 1],[1 1 3]);dans lequel [1 3 1] est l'index où ncread commence la lecture et [1 1 3] est les étapes de la lecture, ce qui signifie que la fonction lira une étape dans lat (le même lat ), un lon (le même lon) et trois étapes en temps. Cela se traduit par :
pre_lat_lon(:,:,1) =
2
pre_lat_lon(:,:,2) =
0
pre_lat_lon(:,:,3) =
4
qui peut être converti en tableau par la fonction squeeze :
pre_lat_lon_time_series = squeeze (pre_lat_lon)
qui se traduit par :
pre_lat_lon_time_series =
2
0
4
Dans Matlab, le temps est lu de la même manière que les autres variables décrites ci-dessus. Pour lire l'heure on peut utiliser :
time = ncread('NetCDF_Matlab.nc','time');Cette fonction restitue les minutes, heures, jours depuis le début du temps décrit dans le fichier NetCDF. Once peut trouver le début de l'heure dans le fichier NetCDF en examinant les attributs de la variable time. Dans notre exemple, les incréments de temps sont en heures et l'heure "0" est définie comme "2018-01-01 00:00:00". Pour avoir tous les pas de temps dans un format vectoriel on peut écrire :
start_time = [2018 1 1 0 0 0]; % defining [year month day hour minute second]
date_num = datenum(start_time); % changing the start_time to days from [1 1 1 0 0 0]
date_all_num = date_num + double(time)./24; % hours to days
date_all_vec = datevec (date_all_num)cela devrait se traduire par :
date_all_vec =
2018 1 1 0 0 0
2018 1 1 6 0 0
2018 1 1 18 0 0
Le script complet est disponible sous lien ou télécharger. Nous allons maintenant parcourir ce script étape par étape.
Pour lire un fichier NetCDF en Python, nous pouvons utiliser les commandes suivantes (nous nous assurons que les packages nécessaires sont chargés) :
import netCDF4 as nc4 # to work with netCDFs
import numpy as np # to perform numerics
import time
ncid = nc4.Dataset('NetCDF_Python.nc', 'r')
print(ncid)la commande renvoie les attributs généraux ainsi que les informations générales sur les variables.
<class 'netCDF4._netCDF4.Dataset'>
root group (NETCDF4 data model, file format HDF5):
Conventions: CF-1.6
License: The data were written by me. They are under GPL.
history: Created Wed Oct 24 13:21:50 2018
source: Written by CaSPAr test script (https://github.com/julemai/CaSPAr).
dimensions(sizes): nlon(2), nlat(4), time(3)
variables(dimensions): int32 time(time), float64 lat(nlon,nlat), float64 lon(nlon,nlat), float64 pre(time,nlon,nlat), float64 grid_ID(nlon,nlat)
groups:
Pour accéder aux attributs d'une variable nous pouvons utiliser :
print(ncid.variables['lat'])qui renvoie :
<class 'netCDF4._netCDF4.Variable'>
float64 lat(nlon, nlat)
long_name: latitude
units: degrees_north
standard_name: latitude
unlimited dimensions:
current shape = (2, 4)
filling on, default _FillValue of 9.969209968386869e+36 used
Pour lire la variable lat, nous pouvons ajouter un [:] à la fin de la commande mentionnée ci-dessus :
lat = ncid.variables['lat'][:]
print(lat)qui revient
[[50. 50. 50. 50.]
[49. 49. 49. 49.]]
Comme le format NetCDF permet à l'utilisateur de lire une partie particulière du fichier NetCDF sans lire la variable entière et similaire à l'exemple mentionné ci-dessus pour Matlab, nous lisons ici le vairbale pre pour le lat=50.0 et lon= -108.0 pour tous les pas de temps. Tout d'abord, nous devons trouver l'emplacement des lat et lon souhaités. Cet emplacement dans Python est [0 2]. Veuillez noter que l'indexation pour Python commence à partir de 0 contrairement à Matlab qui commence à partir de 1. Pour lire la variable, nous pouvons utiliser le ncid.variables[] :
pre_lat_lon = ncid.variables['pre'][:, 0, 2]
print(pre_lat_lon)qui renvoie :
[2. 0. 4.]
Les deux-points : dans la première dimension de [:, 0, 2] indiquent que nous voulons lire les pas de temps entiers. '0' est l'index du 'lat' et '2' est l'index du 'lon'.
Le script complet est disponible sous lien ou télécharger. Nous allons maintenant parcourir ce script étape par étape.
Pour lire un fichier NetCDF dans R, nous pouvons utiliser les commandes suivantes (nous nous assurons que les packages nécessaires sont chargés) :
library(ncdf4) # to work with netCDFs
ncin <- nc_open("NetCDF_R.nc") # open file
ncid # view header (no data!)la commande renvoie les attributs généraux ainsi que les informations générales sur les variables.
File NetCDF_R.nc (NC_FORMAT_NETCDF4):
4 variables (excluding dimension variables):
double lat[Y,X] (Chunking: [4,2]) (Compression: shuffle,level 4)
long_name: latitude
units: degrees_north
standard_name: latitude
double lon[Y,X] (Chunking: [4,2]) (Compression: shuffle,level 4)
long_name: longitude
units: degrees_east
standard_name: longitude
double pre[Y,X,time] (Chunking: [4,2,1]) (Compression: shuffle,level 4)
long_name: Precipitation
units: mm
coordinates: lon lat
double grid_ID[Y,X] (Chunking: [4,2]) (Compression: shuffle,level 4)
long_name: Grid ID (numbering grid cells from 1 to N)
units: 1
coordinates: lon lat
3 dimensions:
X Size:2
Y Size:4
time Size:3 *** is unlimited ***
long_name: time
units: hours since 2018-01-01 00:00:00
calendar: gregorian
standard_name: time
axis: T
4 global attributes:
Conventions: CF-1.6
License: The data were written by me. They are under GPL.
history: Created Fri Jun 21 15:10:36 2019
source: Written by CaSPAr test script (https://github.com/julemai/CaSPAr).Pour accéder aux attributs d'une variable nous pouvons utiliser :
ncatt_get(ncin,"lat")qui renvoie :
$long_name
[1] "latitude"
$units
[1] "degrees_north"
$standard_name
[1] "latitude"Pour lire la variable lat nous pouvons utiliser la commande :
lat = ncvar_get(ncin,"lat")
latqui renvoie :
[,1] [,2]
[1,] 50 49
[2,] 50 49
[3,] 50 49
[4,] 50 49Comme le format NetCDF permet à l'utilisateur de lire une partie particulière du fichier NetCDF sans lire la variable entière et similaire à l'exemple mentionné ci-dessus pour Matlab, nous lisons ici la variable pre pour le lat=50.0 et lon= -108.0 pour tous les pas de temps. Tout d'abord, nous devons trouver l'emplacement des lat et lon souhaités. Cet emplacement en Python est [3,1]. Veuillez noter que l'indexation pour R commence à partir de 1 contrairement à Python qui commence à partir de 0. Pour lire la variable, nous pouvons utiliser le ncvar_get() :
pre_lat_lon = ncvar_get(ncin,"pre")[3, 1, ]
pre_lat_lonqui renvoie :
[1] 2 0 4Le blanc dans la troisième dimension de [3, 1, ] indique que nous voulons lire les pas de temps entiers. '1' est l'index du 'lat' et '3' est l'index du 'lon'.
Pour vérifier si un fichier NetCDF écrit respecte ou non la convention de métadonnées sur le climat et les prévisions (CF), vous pouvez consulter ce [site Web] (http://puma.nerc.ac.uk/cgi-bin/cf-checker.pl ) téléchargez le fichier NetCDF et vérifiez les erreurs et les avertissements.
© 2017-2023 - Canadian Surface Prediction Archive - caspar.data@uwaterloo.ca
Funded under the Floodnet program.
Table of Contents: