ncgen - En ligne dans le Cloud

PROGRAMME:

Nom

ncgen - À partir d'un fichier CDL, générez un fichier netCDF-3, un fichier netCDF-4 ou un programme C

SYNOPSIS

ncgen [-b] [-c] [-f] [-k nom_format] [-format_code] [-l sortie langue] [-non
nom_fichier netcdf] [-X] [fichier_entrée]

DESCRIPTION

ngen génère soit un fichier .nc binaire netCDF-3 (ie classique), soit un netCDF-4 (ie
amélioré) fichier binaire .nc ou un fichier dans une langue source qui, une fois exécuté,
construire le fichier binaire .nc correspondant. L'entrée à ngen est une description d'un
netCDF dans un petit langage appelé CDL (Network Common Data form Language),
décrit ci-dessous. L'entrée est lue à partir de l'entrée standard si aucun fichier_entrée n'est spécifié. Sinon
les options sont spécifiées lors de l'appel ngen, il vérifie simplement la syntaxe du CDL d'entrée
fichier, produisant des messages d'erreur pour toute violation de la syntaxe CDL. D'autres options peuvent être
utilisé, par exemple, pour créer le fichier netCDF correspondant, ou pour générer un programme C
qui utilise l'interface netCDF C pour créer le fichier netCDF.

Notez que cette version de ncgen s'appelait à l'origine ncgen4. L'ancien programme ncgen a
a été renommé en ncgen3.

ngen peut être utilisé avec le programme compagnon cdump pour effectuer quelques opérations simples sur
fichiers netCDF. Par exemple, pour renommer une dimension dans un fichier netCDF, utilisez cdump pour obtenir un
Version CDL du fichier netCDF, éditez le fichier CDL pour changer le nom des dimensions,
et utilise ngen pour générer le fichier netCDF correspondant à partir du fichier CDL édité.

OPTIONS

-b Créez un fichier netCDF (binaire). Si la -o l'option est absente, un nom de fichier par défaut
sera construit à partir du nom de base du fichier CDL, avec tout suffixe remplacé par
l'extension '.nc'. Si un fichier existe déjà avec le nom spécifié, il sera
écrasé.

-c « Générer » C code source qui créera un fichier netCDF correspondant au netCDF
spécification. Le code source C est écrit sur la sortie standard ; équivalent à -lc.

-f « Générer » Fortran 77 code source qui créera un fichier netCDF correspondant au netCDF
spécification. Le code source est écrit sur la sortie standard ; équivalent à -lf77.

-o fichier_netcdf
Nom du fichier à passer aux appels à "nc_create()". Si cette option est spécifiée, elle
implique (en l'absence de tout indicateur -l explicite) le "-b". Cette option est
nécessaire car les fichiers netCDF ne peuvent pas être écrits directement sur la sortie standard, car
la sortie standard n'est pas recherchable.

-k nom_format

-format_code
L'indicateur -k spécifie le format du fichier à créer et, par inférence, le
modèle de données accepté par ncgen (ie netcdf-3 (classique) versus netcdf-4 vs netcdf-5).
Comme raccourci, un nombre format_code peut être spécifié à la place. Le possible
nom_format les valeurs de l'option -k sont :

'classic' ou 'nc3' => format classique netCDF

'64-bit offset' ou 'nc6' => format netCDF 64-bit

'données 64 bits ou 'nc5' => format netCDF-5 (données 64 bits)

'netCDF-4' 0r 'nc4' => format netCDF-4 (modèle de données amélioré)

'netCDF-4 classic model' ou 'nc7' => format de modèle netCDF-4 classic
Acceptée numéro_format les arguments, juste des raccourcis pour format_names, sont :

3 => format classique netcdf

5 => format netcdf 5

6 => format netCDF 64 bits

4 => format netCDF-4 (modèle de données amélioré)

7 => format de modèle classique netCDF-4
Le code numérique "7" est utilisé car "7=3+4", un mnémonique pour le format qui utilise le
modèle de données netCDF-3 pour la compatibilité avec le format de stockage netCDF-4 pour les performances.
Le crédit est dû à NCO pour l'utilisation de ces codes numériques au lieu de l'ancien et déroutant
formater les nombres.

Remarque : les anciens numéros de format de version '1', '2', '3', '4', équivalents aux noms de format
'nc3', 'nc6', 'nc4' ou 'nc7' respectivement, sont également toujours acceptés mais obsolètes, en raison de
confusion facile entre les numéros de format et les noms de format. Divers alias de nom ancien format
sont également acceptés mais déconseillés, par exemple 'hdf5', 'enhanced-nc3', etc. Notez également que -v est
accepté pour signifier la même chose que -k pour la compatibilité descendante.

-x N'initialisez pas les données avec des valeurs de remplissage. Cela peut accélérer la création de grands netCDF
fichiers considérablement, mais tente plus tard de lire les données non écrites du fichier généré
ne sera pas facilement détectable.

-l langue_de_sortie
L'indicateur -l spécifie le langage de sortie à utiliser lors de la génération du code source qui
créera ou définira un fichier netCDF correspondant à la spécification netCDF. Le résultat
est écrit sur la sortie standard. Les langues actuellement prises en charge ont le
drapeaux suivants.

c|C' => sortie en langage C.

f77|fortran77' => sortie en langage FORTRAN 77
; notez qu'actuellement, seul le modèle classique est pris en charge.

j|java' => (expérimental) sortie en langage Java
; cible l'interface Java Unidata existante, ce qui signifie que seule
le modèle classique est pris en charge.

Choisir le sortie le format

Le choix du format de sortie est déterminé par trois drapeaux.

-k drapeau.

_Format attribuer (voir ci-dessous).

Apparition of CDF-5 (64 bits Les données) or
netcdf-4 construit dans le CDL d'entrée." Le terme "netCDF-4 construit" veux dire
constructions à partir de le améliorée données, modèle, pas juste pour un spécial liés à la performance
attributs tel as
_Tailles des morceaux, _Dégonfler le niveau, _Endianité, et ainsi de suite Le terme "CDF-5 construit" veux dire
prolongé non signé int types permis in le 64-bits données, .

Notez qu'il existe une ambiguïté entre le cas netCDF-4 et le cas CDF-5 n'est qu'un
le type non signé est vu dans l'entrée.

Les règles sont les suivantes, par ordre d'application.

1. Si la sortie Fortran ou Java est spécifiée, alors -k valeur d'indicateur de 1 (classique
modèle) sera utilisé. Les conflits avec l'utilisation de constructions améliorées dans le CDL
signaler une erreur.

2. Si à la fois l'indicateur -k et l'attribut _Format sont spécifiés, l'indicateur _Format sera
ignoré. Si aucun indicateur -k n'est spécifié et qu'une valeur d'attribut _Format est spécifiée,
alors la valeur de l'indicateur -k sera définie sur celle de l'attribut _Format. Sinon le
-k indicateur n'est pas défini.

3. Si l'option -k est définie et est cohérente avec le CDL, ncgen affichera un
fichier sous la forme demandée, sinon une erreur sera signalée.

4. Si l'indicateur -k n'est pas défini, et s'il existe des constructions CDF-5, seul, dans le CDL, un
La valeur de l'indicateur -k de 5 (modèle de données 64 bits) sera utilisée. S'il y a de vrais netCDF-4
constructions dans le CDL, une valeur d'indicateur -k de 3 (modèle amélioré) sera utilisée.

5. Si des attributs spéciaux liés aux performances sont spécifiés dans le CDL, une valeur d'indicateur -k
de 4 (modèle netCDF-4 classic) sera utilisé.

6. Sinon, ncgen définira l'indicateur -k sur 1 (modèle classique).

EXEMPLES

Vérifiez la syntaxe du fichier CDL `foo.cdl':

ncgen foo.cdl

À partir du fichier CDL `foo.cdl', génère un fichier netCDF binaire équivalent nommé `x.nc':

ncgen -o x.nc foo.cdl

À partir du fichier CDL `foo.cdl', génère un programme C contenant la fonction netCDF
appels nécessaires pour créer un fichier netCDF binaire équivalent nommé `x.nc':

ncgen -lc foo.cdl >xc

UTILISATION

CDL Syntaxe Vue d'ensemble
Vous trouverez ci-dessous un exemple de syntaxe CDL, décrivant un fichier netCDF avec plusieurs dimensions nommées
(lat, lon et time), variables (Z, t, p, rh, lat, lon, time), attributs de variables (unités,
long_name, valid_range, _FillValue) et quelques données. Les mots-clés CDL sont en gras. (Cette
exemple est destiné à illustrer la syntaxe ; un vrai fichier CDL aurait un fichier plus complet
ensemble d'attributs afin que les données soient plus complètement autodescriptives.)
netcdf foo { // un exemple de spécification netCDF dans CDL

types:
uoctet enum enum_t {Clear = 0, Cumulonimbus = 1, Stratus = 2} ;
opaque(11) opaque_t;
int(*) vlen_t ;

dimensions:
lat = 10, lon = 5, temps = illimité ;

les variables:
Long lat(lat), lon(lon), heure(heure);
flotter Z(heure,lat,lon), t(heure,lat,lon);
double p(heure,lat,long);
Long rh(heure,lat,long);

string pays(heure,lat,lon);
uoctet étiqueter;

// attributs variables
lat:nom_long = "latitude" ;
lat:unités = "degrés_nord" ;
lon:nom_long = "longitude" ;
lon:units = "degrés_est" ;
time:units = "secondes depuis 1992-1-1 00:00:00" ;

// attributs de variables typées
string Z:unités = "compteurs géopotentiels" ;
flotter Z:plage_valide = 0., 5000.;
double p:_FillValue = -9999.;
Long rh:_FillValue = -1 ;
vlen_t :globalatt = {17, 18, 19} ;
données,:
latitude = 0, 10, 20, 30, 40, 50, 60, 70, 80, 90 ;
lon = -140, -118, -96, -84, -52 ;
groupe: g {
types:
composé cmpd_t { vlen_t f1 ; enum_t f2;};
} // groupe g
groupe: h {
les variables:
/ g /cmpd_t var composé ;
données,:
variablecomposée = { {3,4,5}, enum_t.Stratus } ;
} // groupe h
}

Toutes les instructions CDL se terminent par un point-virgule. Les espaces, les tabulations et les sauts de ligne peuvent être utilisés
librement pour la lisibilité. Les commentaires peuvent suivre les caractères `//' sur n'importe quelle ligne.

Une description CDL se compose de cinq parties facultatives : types, dimensions, les variables, données,,
commençant par le mot-clé `type :', `dimensions :', `variables :'et `données :',
respectivement. Notez plusieurs choses : (1) le mot-clé inclut les deux-points de fin, donc il
ne doit pas être un espace avant le caractère deux-points, et (2) les mots-clés doivent être
minuscule.

Le variables: la section peut contenir variable déclarations et attribuer missions. Tous
les sections peuvent contenir des affectations d'attributs globales.

De plus, après la données: section, l'utilisateur peut définir une série de groupes (voir la
exemple ci-dessus). Les groupes eux-mêmes peuvent contenir des types, des dimensions, des variables, des données et
d'autres groupes (emboîtés).

Le netCDF les types: La section déclare les types définis par l'utilisateur. Ceux-ci peuvent être construits en utilisant
l'un des types suivants : enum, vlen, opaque, ou composé.

Un netCDF dimension est utilisé pour définir la forme d'un ou plusieurs des éléments multidimensionnels
variables contenues dans le fichier netCDF. Une dimension netCDF a un nom et une taille. UNE
dimension peut avoir la illimité taille, ce qui signifie qu'une variable utilisant cette dimension peut
croître à n'importe quelle longueur dans cette dimension.

A variable représente un tableau multidimensionnel de valeurs du même type. Une variable a
un nom, un type de données et une forme décrite par sa liste de dimensions. Chaque variable peut
ont également associé attributs (voir ci-dessous) ainsi que les valeurs des données. Le nom, le type de données,
et la forme d'une variable sont spécifiés par sa déclaration dans le variable section d'un CDL
la description. Une variable peut avoir le même nom qu'une dimension ; par convention un tel
La variable est unidimensionnelle et contient les coordonnées de la dimension qu'elle nomme.
Les dimensions n'ont pas besoin d'avoir des variables correspondantes.

Un netCDF attribuer contient des informations sur une variable netCDF ou sur l'ensemble du netCDF
base de données. Les attributs sont utilisés pour spécifier des propriétés telles que les unités, les valeurs spéciales, le maximum
et les valeurs valides minimales, les facteurs d'échelle, les décalages et les paramètres. Informations sur les attributs
est représenté par des valeurs uniques ou des tableaux de valeurs. Par exemple, « unités » est un attribut
représenté par un tableau de caractères tel que "celsius". Un attribut a un associé
variable, un nom, un type de données, une longueur et une valeur. Contrairement aux variables qui sont
destinés aux données, les attributs sont destinés aux métadonnées (données sur les données). contrairement à
netCDF-3, les types d'attributs peuvent être n'importe quel type défini par l'utilisateur ainsi que l'habituel
les types.

En CDL, un attribut est désigné par un type, une variable, un ':', puis un attribut
Nom. Le type est facultatif et s'il est manquant, il sera déduit des valeurs attribuées
à l'attribut. Il est possible d'attribuer de défis attributs non associés à aucun
variable au netCDF dans son ensemble en omettant le nom de la variable dans l'attribut
déclaration. Notez qu'il existe une ambiguïté potentielle dans une spécification telle que
x : un = ...
Dans cette situation, x peut être soit un type pour un attribut global, soit le nom de la variable
pour un attribut. Puisqu'il pourrait y avoir à la fois un type nommé x et une variable nommée x, il
est une ambiguïté. La règle est que dans cette situation, x sera interprété comme un type si
possible, et sinon en tant que variable.

S'il n'est pas spécifié, le type de données d'un attribut dans CDL est dérivé du type du
valeur(s) qui lui sont attribuées. La longueur d'un attribut est le nombre de valeurs de données attribuées
ou le nombre de caractères de la chaîne de caractères qui lui est affectée. Plusieurs
les valeurs sont affectées à des attributs autres que des caractères en séparant les valeurs par des virgules. Tous
les valeurs affectées à un attribut doivent être du même type.

Les noms des dimensions, variables, attributs, types et groupes CDL peuvent contenir
caractère utf-8 sans contrôle, à l'exception du caractère barre oblique (`/'). Cependant, certains
les caractères doivent échapper s'ils sont utilisés dans un nom, où le caractère d'échappement est le
barre oblique inverse '\'. En particulier, si le premier caractère du nom est un chiffre
(0-9), alors il doit être précédé du caractère d'échappement. De plus, les caractères `
!"#$%&()*,:;<=>?[]^`´{}|~\' doivent être échappés s'ils apparaissent n'importe où dans un nom. Notez également
que les noms d'attributs commençant par un trait de soulignement (`_') sont réservés à l'utilisation de
Unidata et ne doit pas être utilisé dans les attributs définis par l'utilisateur.

Notez également que les mots 'variable', 'dimension', 'data', 'group' et 'types' sont légaux
Noms CDL, mais attention à ce qu'il y ait un espace entre eux et les deux-points suivants
caractère lorsqu'il est utilisé comme nom de variable. C'est principalement un problème avec l'attribut
déclarations. Par exemple, considérez ceci.

netcdf ... {
...
variables:
dimensions int;
dimensions : attribut=0 ; // cela provoquera une erreur
dimensions : attribut=0 ; // C'est acceptable.
...
}

Le facultatif données: section d'une spécification CDL est l'endroit où les variables netCDF peuvent être
initialisé. La syntaxe d'une initialisation est simple : un nom de variable, un signe égal,
et une liste de constantes délimitées par des virgules (éventuellement séparées par des espaces, des tabulations et des sauts de ligne)
terminé par un point-virgule. Pour les tableaux multidimensionnels, la dernière dimension varie
le plus rapide. Ainsi, l'ordre des lignes plutôt que l'ordre des colonnes est utilisé pour les matrices. Si moins de valeurs
sont fournis que ce qui est nécessaire pour remplir une variable, il est étendu avec un type dépendant
« valeur de remplissage », qui peut être remplacée en fournissant une valeur pour une variable distincte
attribut nommé '_FillValue'. Les types de constantes n'ont pas besoin de correspondre au type déclaré pour
une variable; des coercitions sont faites pour convertir des entiers en virgule flottante, par exemple. Les
La constante `_' peut être utilisée pour désigner la valeur de remplissage d'une variable. Si le type de
variable est explicitement « chaîne », alors la constante spéciale « NIL » peut être utilisée pour représenter
une chaîne nulle, qui n'est pas la même chose qu'une chaîne de longueur nulle.

Primitif Date Types
carboniser caractères
octet 8 bits de données
court Entiers signés 16 bits
int Entiers signés 32 bits
Long (synonyme de int)
int64 Entiers signés 64 bits
flotter Virgule flottante simple précision IEEE (32 bits)
réal (synonyme de flotter)
double Virgule flottante double précision IEEE (64 bits)
uoctet données 8 bits non signées
ucourt entiers 16 bits non signés
uint entiers 32 bits non signés
uint64 entiers 64 bits non signés
string chaînes de longueur arbitraire

CDL prend en charge un sur-ensemble des types de données primitifs de C. Les noms de la primitive
les types de données sont des mots réservés dans CDL, donc les noms de variables, de dimensions et
les attributs ne doivent pas être des noms de type primitif. Dans les déclarations, les noms de type peuvent être spécifiés
en majuscule ou en minuscule.

Les octets sont destinés à contenir huit bits complets de données, et l'octet zéro n'a pas de
importance, comme cela peut être le cas pour les données de caractère. ngen convertis octet déclarations à carboniser
déclarations dans le code C de sortie et au non standard BYTE déclaration en sortie
Code Fortran.

Les shorts peuvent contenir des valeurs comprises entre -32768 et 32767. ngen convertis court déclarations à
court déclarations dans le code C de sortie et au non standard ENTIER*2 déclaration dans
sortie du code Fortran.

Les entiers peuvent contenir des valeurs comprises entre -2147483648 et 2147483647. ngen convertis int déclarations
à int déclarations dans le code C de sortie et à INTEGER déclarations en sortie Fortran
code. Long est accepté comme synonyme de int dans les déclarations CDL, mais est obsolète car
il existe maintenant des plates-formes avec des représentations 64 bits pour les C longs.

Int64 peut contenir des valeurs comprises entre -9223372036854775808 et 9223372036854775807. ngen
convertis int64 déclarations à longlong déclarations dans le code C de sortie.

Les flottants peuvent contenir des valeurs comprises entre environ -3.4+38 et 3.4+38. Leur représentation extérieure est
sous forme de nombres à virgule flottante simple précision normalisés IEEE 32 bits. ngen convertis flotter
déclarations à flotter déclarations dans le code C de sortie et à REAL déclarations en sortie
Code Fortran. réal est accepté comme synonyme de flotter dans les déclarations CDL.

Les doubles peuvent contenir des valeurs comprises entre environ -1.7+308 et 1.7+308. Leur représentation extérieure
est sous forme de nombres à virgule flottante double précision normalisés IEEE 64 bits. ngen
convertis double déclarations à double déclarations dans le code C de sortie et à DOUBLE
PRÉCISION déclarations dans le code Fortran de sortie.

Les contreparties non signées des types entiers ci-dessus sont mappées sur le
types C non signés. Leurs plages sont convenablement modifiées pour démarrer à zéro.

L'interprétation technique du type char est qu'il s'agit d'une valeur de 8 bits non signée. Les
l'encodage des 256 valeurs possibles n'est pas spécifié par défaut. Une variable de type char peut
être marqué d'un attribut "_Encoding" pour indiquer le jeu de caractères à utiliser : US-
ASCII, ISO-8859-1, etc. Notez que spécifier l'encodage UTF-8 équivaut à
spécifiant US-ASCII Ceci est dû au fait que les caractères UTF-8 multi-octets ne peuvent pas être stockés dans un
caractère 8 bits. Les seules valeurs UTF-8 d'un seul octet légales sont par définition les valeurs US- à 7 bits.
Codage ASCII avec le bit supérieur mis à zéro.

Les chaînes sont supposées par défaut être codées en UTF-8. Notez que cela signifie que
des codages UTF-8 multi-octets peuvent être présents dans la chaîne, il est donc possible que le nombre
de caractères UTF-8 distincts dans une chaîne est inférieur au nombre d'octets de 8 bits utilisés pour
stocker la chaîne.

CDL Constants
Les constantes affectées aux attributs ou aux variables peuvent être de n'importe quel type netCDF de base.
La syntaxe des constantes est similaire à la syntaxe C, sauf que les suffixes de type doivent être
ajoutés aux shorts et aux flotteurs pour les distinguer des longs et des doubles.

A octet constante est représentée par une constante entière avec un « b » (ou « B ») ajouté. Dans
l'ancienne API netCDF-2, les constantes d'octets pouvaient également être représentées à l'aide de caractères uniques ou
séquences d'échappement de caractères C standard telles que « a » ou « 0. Ceci est toujours pris en charge pour
compatibilité descendante, mais obsolète pour faire la distinction entre le numérique
type d'octet et le type de caractère textuel. Exemples de constantes d'octet :
0b // un octet nul
-1b // -1 comme octet de 8 bits
255b // également -1 en tant qu'octet 8 bits signé

court les constantes entières sont destinées à représenter des quantités signées de 16 bits. La forme
d'un court constante est une constante entière avec un « s » ou « S » ajouté. Si un court
constante commence par '0', elle est interprétée comme octale, sauf que si elle commence par '0x',
elle est interprétée comme une constante hexadécimale. Par exemple:
-2s // un court -2
0123s // octale
0x7ffs //hexadécimal

int les constantes entières sont destinées à représenter des quantités signées de 32 bits. La forme de
an int constante est une constante entière ordinaire, bien qu'il soit acceptable d'éventuellement
ajouter un seul « l » ou « L » (encore une fois, obsolète). Attention cependant, le suffixe L est
interprété comme un entier 32 bits, et jamais comme un entier 64 bits. Cela peut être déroutant
puisque le type C long peut être de manière ambiguë 32 bits ou 64 bits.

Si une int constante commence par '0', elle est interprétée comme octale, sauf que si elle commence
avec `0x', il est interprété comme une constante hexadécimale (mais voir les constantes opaques ci-dessous).
Exemples de valides int les constantes comprennent :
-2
1234567890L
0123 // octale
0x7ff // hexadécimal

int64 les constantes entières sont destinées à représenter des quantités signées de 64 bits. La forme
d'un int64 constante est une constante entière avec un « ll » ou « LL » ajouté. Si un int64
constante commence par '0', elle est interprétée comme octale, sauf que si elle commence par '0x',
elle est interprétée comme une constante hexadécimale. Par exemple:
-2ll // un -2 non signé
0123LL // octale
0x7ffLL //hexadécimal

Constantes à virgule flottante de type flotter sont appropriés pour représenter la virgule flottante
données avec environ sept chiffres significatifs de précision. La forme d'un flotter constante est
identique à une constante à virgule flottante C avec un "f" ou un "F" ajouté. Par exemple le
suivants sont tous acceptables flotter constantes :
-2.0f
3.14159265358979f // sera tronqué avec moins de précision
xnumx.f

Constantes à virgule flottante de type double sont appropriés pour représenter la virgule flottante
données avec environ seize chiffres significatifs de précision. La forme d'un double constante est
identique à une constante à virgule flottante C. Un « d » ou « D » facultatif peut être ajouté. Pour
exemple, les éléments suivants sont tous acceptables double constantes :
- 2.0
3.141592653589793
1.0e-20
1.d

Les constantes entières non signées peuvent être créées en ajoutant le caractère « U » ou « u » entre
la constante et tout spécificateur de taille de fin, ou immédiatement à la fin de la taille
spécificateur. Ainsi on pourrait dire par exemple 10U, 100su, 100000ul ou 1000000llu.

Les constantes à caractère unique peuvent être entourées de guillemets simples. Si une séquence d'un ou plusieurs
caractères est entouré de guillemets, alors son interprétation doit être déduite de la
le contexte. Si l'ensemble de données est créé à l'aide du modèle classique netCDF, alors toutes ces constantes
sont interprétés comme un tableau de caractères, de sorte que chaque caractère de la constante est interprété comme
s'il s'agissait d'un seul personnage. Si l'ensemble de données est netCDF étendu, la constante peut
être interprété comme pour le modèle classique ou comme une vraie chaîne (voir ci-dessous) selon le
type de l'attribut ou de la variable dans lequel la chaîne est contenue.

L'interprétation des constantes de caractères est que celles qui sont dans la plage ASCII imprimable
(' '..'~') sont supposés être codés comme le sous-ensemble de 1 octet de l'UTF-8, ce qui équivaut à
US-ASCII. Dans tous les cas, les conventions d'échappement de chaîne C habituelles sont respectées pour les valeurs de
0 à 127. Les valeurs supérieures à 127 sont autorisées, mais leur codage n'est pas défini. Pour
netCDF étendu, l'utilisation du type char est déconseillée au profit du type string.

Voici quelques exemples de constantes de caractère.
'a' // ASCII 'a'
"a" // équivalent à 'a'
"Deux\nlignes\n" // une chaîne de 10 caractères avec deux nouvelles lignes intégrées
"a bell:\007" // une chaîne contenant une cloche ASCII
Notez que le tableau de caractères netCDF "a" tiendrait dans une variable à un élément, car aucun
Le caractère NULL de fin est supposé. Cependant, un octet de zéro dans un tableau de caractères est
interprétée comme la fin des personnages significatifs par le cdump programme, à la suite de
C convention. Par conséquent, un octet NULL ne doit pas être incorporé dans une chaîne de caractères à moins que
à la fin : utilisez le octet type de données à la place pour les tableaux d'octets qui contiennent l'octet zéro.

Chaîne les constantes sont, comme les constantes de caractère, représentées par des guillemets doubles. Cette
représente une ambiguïté potentielle puisqu'une chaîne de plusieurs caractères peut également indiquer une
valeur de caractère dimensionnée. La désambiguïsation se produit généralement en fonction du contexte, mais il faut faire attention
prises pour préciser lestring type pour assurer le bon choix. Les constantes de chaîne sont supposées
être toujours encodé en UTF-8. Cela signifie spécifiquement que la constante de chaîne peut en fait
contiennent des caractères UTF-8 multi-octets. La constante spéciale 'NIL' peut être utilisée pour représenter
une chaîne nulle, qui n'est pas la même chose qu'une chaîne de longueur nulle.

Opaque les constantes sont représentées par des séquences de chiffres hexadécimaux précédés de 0X ou 0x :
0xaa34ffff, par exemple. Ces constantes peuvent toujours être utilisées comme constantes entières et
être soit tronqué, soit étendu si nécessaire.

Composant Constante Expressions
Afin d'affecter des valeurs aux variables (ou attributs) dont le type est de type défini par l'utilisateur,
la notation constante a été étendue pour inclure des séquences de constantes incluses dans
accolades (par exemple "{"..."}"). Une telle constante est appelée constante composée, et
les constantes composées peuvent être imbriquées.

Étant donné un type "T(*) vlen_t", où T est un autre type de base arbitraire, les constantes pour ce
doit être spécifié comme suit.
vlen_t var[2] = {t11,t12,...t1N}, {t21,t22,...t2m} ;
Les valeurs tij, sont supposées être des constantes de type T.

Étant donné un type "compound cmpd_t {T1 f1; T2 f2...Tn fn}", où les Ti sont d'autres arbitraires
types de base, les constantes pour cela doivent être spécifiées comme suit.
cmpd_t var[2] = {t11,t12,...t1N}, {t21,t22,...t2n} ;
Les valeurs tij, sont supposées être des constantes de type Ti. Si les champs sont manquants, alors
ils seront définis à l'aide de toute valeur de remplissage spécifiée ou par défaut pour le type de base du champ.

L'ensemble général des règles d'utilisation des accolades est défini dans le Spécification Listes de données
ci-dessous.

Scoping Règles
Avec l'ajout de groupes, l'espace de nom pour les objets définis n'est plus plat.
Les références (noms) de tout type, dimension ou variable peuvent être précédées de l'absolu
chemin spécifiant une déclaration spécifique. Ainsi pourrait-on dire
variables:
/g1/g2/t1 v1 ;
Le type référencé (t1) est celui du groupe g2, qui à son tour est imbriqué dans
groupe g1. La similitude de cette notation avec les chemins de fichiers Unix est délibérée, et on peut
considérer les groupes comme une forme de structure de répertoire.

Lorsque le nom n'est pas préfixé, les règles de portée sont appliquées pour localiser le
déclaration. Actuellement, il existe trois règles : une pour les dimensions, une pour les types et
constantes d'énumération et une pour toutes les autres.

Lorsqu'un nom non préfixé d'une dimension est utilisé (comme dans une déclaration de variable), ncgen d'abord
recherche dans le groupe immédiatement englobant la dimension. S'il n'est pas trouvé
là, alors il regarde dans le groupe renfermant ce groupe. Cela continue jusqu'à la
hiérarchie de groupes jusqu'à ce que la dimension soit trouvée, ou qu'il n'y ait plus de groupes à
chercher.

2. Lorsqu'un nom non préfixé d'un type ou une constante d'énumération est utilisé, ncgen recherche
l'arborescence des groupes en utilisant une recherche en profondeur d'abord en précommande. Cela signifie essentiellement qu'il
trouvera la déclaration correspondante qui précède textuellement la référence dans le cdl
fichier et qui est "le plus élevé" dans la hiérarchie du groupe.

3. Pour tous les autres noms, seul le groupe immédiatement englobant est recherché.

Une dernière remarque. Les références directes ne sont pas autorisées. Cela signifie que spécifier, pour
Par exemple, /g1/g2/t1 échouera si cette référence se produit avant que g1 et/ou g2 soient définis.

Spécification Énumération Constants
Les références aux constantes d'énumération (dans les listes de données) peuvent être ambiguës car le même
Le nom de la constante d'énumération peut être défini dans plusieurs énumérations. Si un fichier cdl
spécifié une constante ambiguë, alors ncgen signalera une erreur. De telles constantes peuvent être
désambiguïsé de deux manières.

1. Préfixez la constante d'énumération avec le nom de l'énumération séparé par un
point: enum.econt, Par exemple.

2. Si un cas n'est pas suffisant pour lever l'ambiguïté de la constante d'énumération, alors on
doit spécifier le type d'énumération précis à l'aide d'un chemin de groupe : /g1/g2/enum.econst,
par exemple.

Spécial Attributs
Des attributs spéciaux, virtuels, peuvent être spécifiés pour fournir des informations relatives aux performances
sur le format de fichier et sur les propriétés des variables. Le fichier doit être un fichier netCDF-4 pour
ceux-ci pour prendre effet.

Ces attributs virtuels spéciaux ne font pas réellement partie du fichier, ils sont simplement un
moyen pratique de définir diverses propriétés des données dans CDL

Les attributs spéciaux actuellement pris en charge sont les suivants : `_Format', `_Fletcher32,
`_ChunkSizes', `_Endianness', `_DeflateLevel', `_Shuffle' et `_Storage'.

`_Format' est un attribut global spécifiant la variante de format netCDF. Sa valeur doit être un
chaîne unique correspondant à l'un des éléments `classic', `64-bit offset', '64-bit data', `netCDF-4', ou
« modèle classique netCDF-4 ».

Les autres attributs spéciaux sont tous des attributs variables. Essentiellement tout alors
mapper à une fonction `nc_def_var_XXX' correspondante telle que définie dans l'API netCDF-4. Pour
les attributs qui sont essentiellement booléens (_Fletcher32, _Shuffle et _NOFILL), le
la valeur true peut être spécifiée en utilisant les chaînes 'true' ou '1', ou en utilisant l'entier 1.
La valeur false attend soit `false', `0', soit l'entier 0. Les actions associées
avec ces attributs sont les suivants.

1. `_Fletcher32 définit la propriété `fletcher32' pour une variable.

2. « _Endianness » est soit « petit » ou « grand », selon la façon dont la variable est stockée lorsque
d'abord écrit.

3. `_DeflateLevel' est un entier compris entre 0 et 9 inclus si la compression a été
spécifié pour la variable.

4. `_Shuffle' spécifie si le filtre aléatoire doit être utilisé.

5. `_Storage' est `contiguë' ou `chunked'.

6. `_ChunkSizes' est une liste de tailles de morceaux pour chaque dimension de la variable

Notez que les attributs tels que "add_offset" ou "scale_factor" n'ont pas de signification particulière pour
ncgen. Ces attributs sont actuellement des conventions, gérées au-dessus de la couche bibliothèque par
d'autres packages d'utilitaires, par exemple NCO.

Spécification Listes de données
Spécifier des listes de données pour les variables dans la section `data:` peut être quelque peu compliqué.
Certaines règles doivent être suivies pour garantir que les listes de données sont correctement analysées
par ncgen.

Premièrement, le niveau supérieur est automatiquement supposé être une liste d'éléments, il ne devrait donc pas être
à l'intérieur {...}. Cela signifie que si la variable est un scalaire, il y aura un seul top-
élément de niveau et si la variable est un tableau, il y aura N éléments de niveau supérieur. Pour
chaque élément de la liste de niveau supérieur, les règles suivantes doivent être appliquées.

1. Les instances de dimensions ILLIMITÉES (autres que la première dimension) doivent être entourées
par {...} afin de spécifier la taille.

2. Les instances composées doivent être intégrées dans {...}

3. Les champs non scalaires des instances composées doivent être intégrés dans {...}.

4. Les instances de vlens doivent être entourées de {...} afin de spécifier la taille.

Les listes de données associées aux attributs sont implicitement un vecteur (c'est-à-dire une liste) de valeurs de
le type de l'attribut et les règles ci-dessus doivent s'appliquer dans cet esprit.

7. Aucune autre utilisation d'appareils orthodontiques n'est autorisée.

Notez qu'une conséquence de ces règles est que les tableaux de valeurs ne peuvent pas avoir de sous-tableaux
entre accolades. Considérons, par exemple, int var(d1)(d2)...(dn), où aucun de d2...dn n'est
illimité. Une liste de données pour cette variable doit être une liste unique d'entiers, où le
le nombre d'entiers n'est pas supérieur à D=d1*d2*...dn valeurs ; notez que la liste peut être moins
que D, auquel cas les valeurs de remplissage seront utilisées pour remplir la liste.

La règle 6 concernant la liste de données d'attributs a la conséquence suivante. Si le type de
l'attribut est un type composé (ou vlen), et si le nombre d'entrées dans la liste est un,
alors les instances composées doivent être mises entre accolades.

Spécification Personnage Listes de données
La spécification de listes de données pour les variables de type char présente également quelques complications. considérer, pour
(ici)
dimensions : u=ILLIMITÉ ; d1=1 ; d2=2 ; d3=3 ;
d4=4; d5=5; u2=UNLIMITED;
variables : car var(d4,d5) ;
liste de données : var="1", "deux", "trois" ;

Nous avons vingt éléments de var à remplir (d5 X d4) et nous avons trois chaînes de longueur 1, 3,
5. Comment assignons-nous les caractères des chaînes aux vingt éléments ?

C'est un défi car il est souhaitable d'imiter le ncgen d'origine (ncgen3). Les
L'algorithme de base est théoriquement le suivant.

1. Supposons que nous ayons un ensemble de dimensions D1..Dn, où D1 peut éventuellement être un Illimité
dimension. On suppose que les tailles du Di sont toutes connues (y compris illimitées
dimensions).

2. Étant donné une séquence de constantes de chaîne ou de caractère C1..Cm, notre objectif est de construire un
chaîne unique dont la longueur est le produit croisé de D1 à Dn. Notez qu'à des fins
de cet algorithme, les constantes de caractères sont traitées comme des chaînes de taille 1.

3. Construire Dx = produit croisé de D1 à D(n-1).

4. Pour chaque constante Ci, ajoutez des caractères de remplissage au besoin de sorte que sa longueur soit un multiple de
Dn.

5. Concaténez le C1..Cm modifié pour produire la chaîne S.

6. Ajoutez des caractères de remplissage à S pour que sa longueur soit un multiple de Dn.

8. Si S est plus long que Dx * Dn, alors tronquez et générez un avertissement.

Il y a trois autres cas à noter.

1. S'il n'y a qu'une seule dimension illimitée, alors toutes les constantes sont
des caractères concaténés et de remplissage sont ajoutés à la fin de la chaîne résultante pour faire
sa longueur soit celle de la dimension illimitée. Si la longueur est supérieure à la
dimension illimitée, puis il est tronqué avec un avertissement.

2. Pour le cas du caractère tapé vlen, "char(*) vlen_t" par exemple. nous avons simplement
concaténer toutes les constantes sans aucun remplissage.

3. Pour le cas d'un attribut typé caractère, nous concaténons simplement toutes les constantes.

Dans netcdf-4, les dimensions autres que la première peuvent être illimitées. Bien sûr par les règles
ci-dessus, les instances intérieures illimitées doivent être délimitées par {...}. Par exemple.
variables : car var(u,u2) ;
liste de données : var={"1", "deux"}, {"trois"} ;
Dans ce cas, u aura la longueur effective de deux. Dans chaque instance de u2, le
les règles ci-dessus s'appliqueront, conduisant à cela.
liste de données : var={"1","t","w","o"}, {"t","h","r","e","e"} ;
La taille effective de u2 sera le maximum des deux longueurs d'instance (cinq dans ce cas)
et le plus court sera rembourré pour produire cela.
liste de données : var={"1","t","w","o","\0"}, {"t","h","r","e","e"} ;

Prenons un cas encore plus compliqué.
variables : car var(u,u2,u3) ;
liste de données : var={{"1", "deux"}}, {{"trois"},{"quatre","xy"}} ;
Dans ce cas, u aura à nouveau la longueur effective de deux. Les dimensions u2 auront un
taille = max(1,2) = 2 ; Dans chaque instance de u2, les règles ci-dessus s'appliqueront, conduisant à
ce.
liste de données : var={{"1","t","w","o"}}, {{"t","h","r","e","e"},{"f ","o","u","r","x","y"}} ;
La taille effective de u3 sera le maximum des deux longueurs d'instance (six dans ce cas)
et les plus courts seront rembourrés pour produire cela.
liste de données : var={{"1","t","w","o"," "," "}}, {{"t","h","r","e","e "," "},{"f","o","u","r","x","y"}} ;
Notez cependant que la première instance de u2 est inférieure à la longueur maximale de u2, nous avons donc besoin
pour ajouter un remplissage pour une autre instance de u2, produisant ceci.
liste de données : var={{"1","t","w","o"," "," "},{" "," "," "," "," "," "}}, {{"t","h","r","e","e"," "},{"f","o","u","r","x","y" }} ;

Utiliser ncgen en ligne à l'aide des services onworks.net