<< ncdisp sciNetCDF

sciNetCDF >> sciNetCDF > Interface bas niveau

Interface bas niveau

Décrit l'interface bas niveau de sciNetCDF

Introduction

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.

Fonctions

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 CFonction 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 CFonction 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 CFonction 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 CFunction 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);

Constantes

Les constantes ont le même nom qu'en C. Pour les rendre disponibles, une fonction d'initialisation doit être exécutée:

libscinetcdf_Init()

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);

Types

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 CPréfixe de fonction
*doubleDoubleArray
*floatFloatArray
*intIntArray
*unsigned intUIntArray
*signed shortShortArray
*unsigned shortUShortArray
*signed charCharArray
*unsigned charUCharArray

Pour chaque type <Type> on trouve 4 fonctions:

Un exemple de cela, pour les pointeurs d'entier:

p = new_IntArray(10);
IntArray_setitem(p, 0, 3);
IntArray_getitem(p, 0);
delete_IntArray(p);

Voir aussi


Report an issue
<< ncdisp sciNetCDF