Décrit l'interface bas niveau de sciNetCDF
L'interface bas niveau de sciNetCDF repose sur l'interface de la bibliothèque C de NetCDF.
En conséquence, toutes les fonctions de l'interface C sont disponibles dans Scilab (avec quelques exceptions, notamment les fonctions obsoletes). Les noms des fonctions et constantes sont les mêmes que l'interface C.
Aussi, toutes les fonctions bas niveau (environ 200) ne sont pas décrites ici, et sont détaillées dans le lien en bas de page. Ce sont les adaptations nécessaires du langage du C vers Scilab qui sont principalement décrites ici.
Les noms des fonctions sont les mêmes qu'en C, les différences résident dans le passage d'argument.
Quand une fonction C a un paramètre en entrée/sortie de type primitif (comme double*, int*
...), celui est retourné par par la fonction Scilab correspondante:
Fonction C | Fonction Scilab |
int nc_open(const char *path, int mode, int *ncidp) |
[ret, ncid] = nc_open(path, mode) |
int nc_inq_ncid(int ncid, const char *name, int *grp_ncid) |
[ret, grp_ncid] = nc_inq_ncid(ncid, name) |
int nc_inq_natts(int ncid, int *nattsp) |
[ret, natts] = nc_inq_natts(ncid) |
int nc_inq_dimid(int ncid, char *name, int *idp) |
[ret, id] = nc_inq_dimid(ncid, name) |
int nc_get_var1_short(int ncid, int varid, const size_t *indexp, const short *ip) |
[ret, val] = nc_get_var1_short(ncid, varid, index) |
int nc_get_var1_double(int ncid, int varid, const size_t *indexp, const double *ip) |
[ret, val] = nc_get_var1_double(ncid, varid, index) |
On trouve le même méchanisme pour les fonctions qui ont un paramètre en sortie de type chaîne de caractères, ce sont par exemple les fonctions qui 'retournent un nom':
Fonction C | Fonction Scilab |
int nc_inq_grpname(int *ncid, char *name) |
[ret, name] = nc_inq_grpname(ncid) |
int nc_inq_dimname(int ncid, in dimid, char *name) |
[ret, name] = nc_inq_dimname(ncid, dimid) |
int nc_inq_attname(int ncid, in dimid, int attnum, char *name) |
[ret, name] = nc_inq_attname(ncid, varid, attnum) |
Les arguments en entrée/sortie qui sont des tableaux de type size_t
sont automatiquement converties depuis/vers des matrices Scilab:
Fonction C | Fonction Scilab |
int nc_get_var1_short(int ncid, int varid, const size_t *indexp, const short *ip) |
[ret, val] = nc_get_var1_short(ncid, varid, index) |
int nc_put_vara_text(int ncid, int varid, const size_t *startp, count, size_t * countp, const char *op) |
[ret, name] = [ret, name] = nc_put_vara_text(ncid, varid, index, count, op) |
Certaines fonctions prennent en paramètre un buffer en entrée sortie et nécessitent qu'un pointeur leur soit passé comme en C. Les pointeurs ne pouvant être utilisés nativement en Scilab, c'est pourquoi des fonctions dédiées sont fournis dans ce but. Ces fonctions permettent de créer/lire/écrire des pointeurs (voir la section à venir Types pour plus de détails). Voici quelque cas exemples:
Fonction C | Function Scilab |
double *op = (double*) malloc(N * sizeof(double));
nc_get_att_double(ncid, varid, op);
x = op[2]; |
dblArray = new_DoubleArray(N);
nc_get_att_double(ncid, varid, dblArray);
x = DoubleArray_getitem(dblArray, 2); |
int *ip = (int*) malloc(N * sizeof(int));
ip[1] = 3;
nc_put_var_int(ncid, varid, ip); |
intArray = new_IntArray(N);
IntArray_setitem(intArray, 1, 3);
nc_put_var_int(ncid, varid, intArray); |
Les constantes ont le même nom qu'en C. Pour les rendre disponibles, une fonction d'initialisation doit être exécutée:
Une fois l'initialization faite, les constantes sont utilisées comme en C:
filepath = fullfile(TMPDIR, 'test.nc'); [ret, ncid] = nc_create(filepath, NC_NETCDF4 + NC_CLOBBER); ret = nc_close(ncid); [ret, ncid] = nc_open(filepath, NC_NOWRITE); ret = nc_close(ncid); | ![]() | ![]() |
Comme dit dans une section précédente, certaines fonctions Scilab nécessitent la création et manipulation de pointeurs. Pour chaque type primitif, est fourni un jeu de fonctions dédiées pour créer/lire/écrire des pointeurs de ce type. Les fonctions correspondantes sont préfixées d'après le nom du type correspondant, comme suit:
Type pointeur C | Préfixe de fonction |
*double | DoubleArray |
*float | FloatArray |
*int | IntArray |
*unsigned int | UIntArray |
*signed short | ShortArray |
*unsigned short | UShortArray |
*signed char | CharArray |
*unsigned char | UCharArray |
Pour chaque type <Type> on trouve 4 fonctions:
ptr = new_<Type>(size)
value = <Type>_getitem(ptr, index)
value = <Type>_setitem(ptr, index, value)
delete_<Type>_(ptr)
Un exemple de cela, pour les pointeurs d'entier: