i/netcdf

yorick banner

Home

Manual

Packages

Global Index

Keywords

Quick Reference


/*
   NETCDF.I

   Yorick procedures to open a netCDF file

   The definitive reference for netCDF files is:
   Anonymous FTP site: unidata.ucar.edu [128.117.140.3]

   File:               pub/netcdf/netcdf.tar.Z

   $Id: netcdf.i,v 1.1 1993/08/27 18:50:06 munro Exp $
 */
/*    Copyright (c) 1994.  The Regents of the University of California.
                    All rights reserved.  */

/* Note: I don't use netCDF files, so there are probably still some
         bugs in this code (DHM).  */


local netcdf ;

/* DOCUMENT nc_open, nc_create, nc_vardef, nc_enddef, nc_addrec

     are the main routines to read and write netCDF files.


     The ordinary openb function will also open netCDF files.

     Writing a netCDF file is more problematic in Yorick, since

     you must define the entire file structure before you write

     any data.  Therefore, the nc_create call returns only a

     "token" for nc_vardef, which you use to declare variables
     in the file.  When you are done declaring variables, you

     call nc_enddef, which returns an ordinary Yorick file object.

     You can then write data to the file (with f.var=value or

     save,f,var).  To add a record, you must use nc_addrec instead

     of add_record (nc_addrec updates the record count in the file).
 */

/* ------------- netCDF interface --------------------------------- */


func nc_open (_nc_open_filename, mode)

/* DOCUMENT f= nc_open(filename, mode)
     opens a netCDF file FILENAME for reading or update as specified
     by MODE, which defaults to "rb".  Attributes and dimension names

     can be found in the three external variables nc_dims (an array of

     type NC_dim), nc_attrs (an array of type NC_attr), and nc_vars

     (an array of type NC_var) after this call.
     MODE should be either "rb" or "r+b"; nothing else makes sense.

     If FILENAME is an array of strings, exactly those files will be

     opened as a family (if possible).  Note that nc_open("myfile00")

     potentially opens myfile01, myfile02, and so on, as for openb,

     but that nc_open(["myfile00"]) opens myfile00 only.

   SEE ALSO: nc_create, nc_enddef, nc_attribute, nc_dimsof
 */
{
  if (is_void(mode)) mode= "rb";
  f= open(_nc_open_filename(1), mode);

  if (raw_not_cdf(f)) return [];
  return f;
}


func raw_not_cdf (f)
{
  i= array(char, 4);
  _read, f, 0, i;
  if (string(&i)!="CDF\001") return 1;  /* test magic number */

  xdr_primitives, f;

  numrecs= long(0);
  _read, f, 4, numrecs;

  /* Each of the major components of a netCDF file contains information
     not used by Yorick.  Specifically, dimensions are named, the file
     may have attributes, and any variable contained in the file may

     have attributes.  After a call to nc_open, this additional
     information is stored in the external variable nc_file.  */
  extern nc_file;

  pf= print(f);
  name= dir= "";

  sread, pf(where(strmatch(pf,"binary stream:"))), dir, name,
    format= "%s binary stream: %s";

  sread, pf(where(strmatch(pf,"In directory:"))), dir,
    format= " In directory: %s";

  address= 8;

  nc_dims= NC_ReadArray(f, address);

  nc_attrs= NC_ReadArray(f, address);

  nc_vars= NC_ReadArray(f, address);

  nc_file= NC_file(numrecs=numrecs, dims=&nc_dims, attrs=&nc_attrs,
		   vars=&nc_vars, filename=dir+name);


  if (_nc_declare(f, nc_file)) {
    /* check for presence of a file family */
    dims= dimsof(_nc_open_filename);

    ifile= (!is_void(dims) && dims(1));

    while (!_nc_add_next_file(f, ifile)) {
      i= array(char, 4);
      _read, f, 0, i;
      if (string(&i)!="CDF\001") break;  /* test magic number */
      _read, f, 4, numrecs;
      if (!numrecs) continue;
      nc_file.numrecs= numrecs;
      address= 8;

      dims= NC_ReadArray(f, address);

      attrs= NC_ReadArray(f, address);

      vars= NC_ReadArray(f, address);

      if (numberof(dims)!=numberof(nc_dims) ||
	  anyof(dims.size!=nc_dims.size) ||

	  !_nc_declare(f, nc_file, vars))

        error, "File '"+_nc_open_filename(ifile)+"' has different structure";
    }
  }

  jr, f, 1;
  return 0;
}


func _nc_add_next_file (f, &ifile)
{

  /* modified add_next file checks whether nc_open has been called
   * with an explicit list of file names

   * -- eventually this should be installed in openb generally
   */

  if (!ifile) return add_next_file(f);
  ifile+= 1;

  if (ifile>numberof(_nc_open_filename)) return 1;

  if (add_next_file(f, _nc_open_filename(ifile), 0))

    error, "File '"+_nc_open_filename(ifile)+"' not found";
  return 0;
}


func _nc_declare (f, ncf, check_vars)
{
  nc_dims= *ncf.dims;
  nc_vars= *ncf.vars;
  numrecs= ncf.numrecs;

  if (!is_void(check_vars)) {

    if (numberof(nc_vars)!=numberof(check_vars) ||
	anyof(nc_vars.name!=check_vars.name) ||
	anyof(nc_vars.type!=check_vars.type) ||
	anyof(nc_vars.len!=check_vars.len) ||
	anyof(nc_vars.address!=check_vars.address)) return 0;
  }

  /* check whether there is an unlimited (history) dimension */

  if (is_void(nc_dims)) unlimited= -1;
  else {
    unlimited= (nc_dims.size==0);

    if (noneof(unlimited)) unlimited= -1;

    else unlimited= where(unlimited)(0);
  }

  /* first pass sets non-history variables */
  type_names= ["char", "char", "short", "long", "float", "double"];
  nvars= numberof(nc_vars);

  if (nvars) nonRecord= array(int, nvars);
  else nonRecord= 1;
  for (i=1 ; i<=nvars ; ++i) {
    var= nc_vars(i);
    dimlist= *var.dimlist;
    if (numberof(dimlist)) {
      dimlist+= 1;
      if (dimlist(1)==unlimited) continue;  /* record variable */

      dimlist= grow([numberof(dimlist)], nc_dims.size(dimlist(0:1:-1)));
    } else {
      dimlist= [0];
    }
    nonRecord(i)= 1;
    if (is_void(check_vars))

      add_variable, f, var.address, var.name, type_names(var.type), dimlist;
  }


  /* second pass sets history variables */
  if (nallof(nonRecord)) {
    if (is_void(check_vars))
      add_record, f;
    recList= where(!nonRecord);
    ha= min(nc_vars.address(recList));
    time_address= 0;
    time_type= 0;
    for (i=1 ; i<=nvars ; ++i) {
      if (nonRecord(i)) continue;
      var= nc_vars(i);
      dimlist= *var.dimlist;
      ++dimlist;

      if (numberof(dimlist) > 1) {

	dimlist= grow([numberof(dimlist)-1], nc_dims.size(dimlist(0:2:-1)));
      } else {
	dimlist= [0];
	if (var.name=="time" && (var.type==5 || var.type==6)) {
	  time_address= var.address;
	  time_type= var.type;
	}
      }
      if (is_void(check_vars))
	add_variable, f, var.address-ha,
	                 var.name, type_names(var.type), dimlist;
    }

    /* Note: If there is exactly one record variable, then the records
       need not begin on a 4-byte boundary.  This is only an issue for

       a single record variable of type char or short.  */


    if (numberof(recList)>1 || var.type>3) {
      hs= sum(nc_vars.len(recList));
    } else {
      hs= (var.type==3? 2 : 1);
      for (i=2 ; i<=1+dimlist(1) ; ++i) hs*= dimlist(i);
    }
    if (numrecs) {
      if (time_address) {
	if (time_type==6) time= 0.0;
	else time= 0.0f;
	times= array(0.0, numrecs);
	for (i=1 ; i<=numrecs ; ++i) {
	  _read, f, time_address, time;
	  time_address+= hs;
	  times(i)= time;
	}

	add_record, f, times, , ha+hs*indgen(0:numrecs-1);
      } else {

	add_record, f, , , ha+hs*indgen(0:numrecs-1);
      }
    }

    return 1;
  }

  return 0;
}


func nc_create (filename)

/* DOCUMENT ncf= nc_create(filename)
     creates a netCDF file FILENAME.

     After this call, use nc_vardef to declare the netCDF variables.

     Then use nc_enddef to write the netCDF self-descriptive

     information.  Only after this are you free to actually write data.


   SEE ALSO: nc_open, nc_vardef, nc_attrdef, nc_enddef, nc_addrec,

             nc_attribute, nc_dimsof
 */
{

  return NC_file(filename=filename);
}


func nc_vardef (ncf, name, type, dims, template=, record=, dimnames=)

/* DOCUMENT nc_vardef, ncf, name, type, dims, record=0/1

       -or- nc_vardef, ncf, name, type, record=0/1

       -or- nc_vardef, ncf, name, template=template, record=0/1

     define a variable in the NCF (returned by nc_create) with name

     NAME, type TYPE (as returned by typeof or structof), and dimensions

     DIMS (as returned by dimsof).  The template= keyword may be used

     instead of type and dims; the type and dims will be those of the

     TEMPLATE.  If dims is not specified, a scalar is assumed.  If the
     record= keyword is present and non-zero, the variable is a record
     variable; otherwise it is a non-record variable.


     You can use the dimnames= keyword to write specific dimension
     names into the netCDF file.  These are not useful to Yorick, but

     other codes may require them.  If two variables share a dimension
     name, the corresponding dimension must have the same length.  For
     example:

       nc_vardef, ncf, "theta", double, [1,nlat], dimnames=["latitude"]

       nc_vardef, ncf, "phi", double, [1,nlong], dimnames=["longitude"]

       nc_vardef, ncf, "elevation", double,
                  dimnames=["latitude","longitude"]
     A dimension name of "" lets Yorick invent a fake dimension name,
     as it does by default.  If dimnames= is present and the lengths
     of the dimensions have previously been defined, then the DIMS

     parameter is unnecessary, as in the "elevation" array in the example.

     You can use the nc_dimdef function to define a named dimension size
     before you define any variables with that dimension.


   SEE ALSO: nc_create, nc_attrdef, nc_enddef, nc_addrec, nc_dimdef
 */
{
  nc_vars= *ncf.vars;
  if (!is_void(nc_vars) &&

      anyof(nc_vars.name==name)) error, "duplicate netCDF name: "+name;

  if (!is_void(template)) {

    type= typeof(template);
    dims= dimsof(template);
  } else {

    if (!is_array(type)) {

      if (type==char) type= "char";

      else if (type==short) type= "short";

      else if (type==long || type==int) type= "long";

      else if (type==float) type= "float";

      else if (type==double) type= "double";
      else type= "illegal";
    }

    if (is_void(dims) && is_void(dimnames)) dims= [0];
  }

  if (type=="int") type= "long";

  list= where(type==["char","char","short","long","float","double"]);

  if (!numberof(list)) error, "illegal netCDF data type: "+type;
  type= list(1);
  len= [1, 1, 2, 4, 4, 8](type);

  if (record && numberof(dims)) {

    if (numberof(dimnames) && numberof(dimnames)==dims(1))
      grow, dimnames, "";
    grow, dims, [0];
    dims(1)+= 1;
  }


  if (numberof(dimnames) && numberof(dims) &&
      numberof(dimnames)!=dims(1))

    error, "dimnames= keyword does not match variable: "+name;


  if (!numberof(dims) && numberof(dimnames)) {
    /* use existing named dimensions */
    eq_nocopy, nc_dims, *ncf.dims;

    if (is_void(nc_dims)) error, "no dimensions yet defined";
    ncnames= nc_dims.name;

    dims= array(0, numberof(dimnames));

    for (i=1 ; i<=numberof(dims) ; ++i) {

      list= where(ncnames==dimnames(i));

      if (!numberof(list)) error, "dimension not yet defined: "+dimnames(i);

      dims(numberof(dims)-i+1)= list(1)-1;
      size= nc_dims(list(1)).size;
      if (size) len*= size;
    }

  } else if (numberof(dims)>1) {
    eq_nocopy, nc_dims, *ncf.dims;
    ndims= dims(1);
    for (i=2 ; i<=1+ndims ; ++i) {
      size= dims(i);
      if (size) len*= size;

      if (numberof(dimnames) && strlen((dimname= dimnames(i-1)))) {
	if (changed) ncf.dims= &nc_dims;

	dims(i)= nc_dimdef(ncf, dimname, size);
	eq_nocopy, nc_dims, *ncf.dims;
	continue;

      } else if (numberof(nc_dims)) {
	list= where((size==nc_dims.size) &

		    (strpart(nc_dims.name,1:2)=="D_"));
	if (numberof(list)) {
	  dims(i)= list(1);
	  continue;
	}
	dimname= "D_"+pr1(size);
      } else {
	dimname= "D_"+pr1(size);
      }

      grow, nc_dims, [NC_dim(name=dimname,size=size)];
      dims(i)= numberof(nc_dims);
      ncf.dims= &nc_dims;
    }
    dims= dims(0:2:-1)-1;

  } else {
    dims= [];
  }


  grow, nc_vars, [NC_var(name= name, dimlist= &dims, type= type, len= len)];
  ncf.vars= &nc_vars;
}


func nc_dimdef (ncf, dimname, size)

/* DOCUMENT nc_dimdef, ncf, dim_name, size

       -or- nc_dimdef, ncf, dim_name, "unlimited"
     define a named dimension.  The SIZE parameter is the length of
     the dimension, or the string "unlimited" for the unlimited
     dimension.  (The numerical value 0 is the same as "unlimited".)
     You can also define named dimensions implicitly using nc_vardef.
   SEE ALSO: nc_vardef
 */
{
  if (size=="unlimited") size= 0;
  nc_dims= *ncf.dims;

  list= numberof(nc_dims)? where(nc_dims.name==dimname) : [];
  if (numberof(list)) {
    list= list(1);
    if (nc_dims(list).size!=size)

      error, "different sizes sepcified for dimension "+dimname;
    return list;

  } else if (size || !numberof(nc_dims) || allof(nc_dims.size)) {

      grow, nc_dims, [NC_dim(name=dimname,size=size)];
      ncf.dims= &nc_dims;
      return numberof(nc_dims);
  } else {

    error, "only one unlimited dimension is allowed";
  }
}


func nc_attrdef (ncf, attr_name, var_name, value)

/* DOCUMENT nc_attrdef, ncf, attr_name, var_name, value
     sets the value of the netCDF attribute ATTR_NAME associated

     with variable VAR_NAME to VALUE (note that the data type of VALUE

     becomes the data type of the attribute).

     The NCF is the structure returned by nc_create; nc_attrdef

     must be called prior to nc_enddef, which actually writes the
     attribute data to the file.
     If VAR_NAME is omitted, ATTR_NAME refers to the whole file.


   SEE ALSO: nc_open, nc_dimsof, nc_create, nc_enddef, nc_attribute
 */
{
  attr= [NC_attr(name=attr_name, data=&value(*))];
  if (is_void(var_name)) {
    ncf.attrs= &grow(*ncf.attrs, attr);
  } else {
    local vars;
    eq_nocopy, vars, *ncf.vars;
    if (is_void(vars) ||
	!numberof((

		   attrs= where(vars.name==var_name))))

      error, "file has no such variable: "+var_name;
    attrs= attrs(0);

    vars(attrs).attrs= &grow(*vars(attrs).attrs, attr);

    /* *ncf.vars already updated, since eq_nocopy used above */
  }
}


func nc_enddef (ncf)
/* DOCUMENT f= nc_enddef(ncf)

     creates netCDF file NCF (returned by nc_create), and writes the self-
     descriptive information.  Returns the ordinary Yorick file object

     corresponding to the new file.  You are then free to write variables,

     or use the save or nc_addrec functions.


   SEE ALSO: nc_create, nc_addrec, nc_open, nc_attrdef, nc_dimsof
 */
{
  /* first, need to fill in addresses */
  vars= *ncf.vars;
  dims= *ncf.dims;

  rec= array(0, numberof(vars));
  if (!is_void(dims)) {
    list= where(dims.size==0);
    if (numberof(list)) {
      /* record variables need to be sorted separately */
      list= list(1)-1;

      for (i=1 ; i<=numberof(vars) ; ++i) {
	dimlist= *vars(i).dimlist;

	if (!is_void(dimlist) && dimlist(1)==list) rec(i)= 1;
      }
    }
  }
  lens= vars.len;
  lens= 4*((lens+3)/4);
  list= where(!rec);
  if (numberof(list)) {
    addrs= lens(list)(cum);
    lens(list)= addrs(1:-1);
    rec_addr= addrs(0);
  } else {
    rec_addr= 0;
  }
  list= where(rec);

  if (numberof(list)) lens(list)= rec_addr + lens(list)(cum)(1:-1);

  rec_addr= _nc_desc_len(ncf);  /* actually address of 1st datum */
  vars.address= rec_addr + lens;
  ncf.vars= &vars;

  f= open(ncf.filename, "w+b");
  xdr_primitives, f;


  if (!numberof(where(!rec))) {

    /* work around laziness of not computing address in nc_addrec */

    add_variable, f, rec_addr-1, "?ignore_me?", char;
  }

  _nc_declare, f, ncf;


  _write, f, 0, (*pointer("CDF\001"))(1:4);
  _write, f, 4, 0;

  address= 8;

  NC_WriteArray, f, address, dims;

  NC_WriteArray, f, address, *ncf.attrs;

  NC_WriteArray, f, address, vars;

  return f;
}


func _nc_desc_len (ncf)
{

  _write= _dummy_write;  /* overlay _write with noop */
  address= 8;

  NC_WriteArray, f, address, *ncf.dims;

  NC_WriteArray, f, address, *ncf.attrs;

  NC_WriteArray, f, address, *ncf.vars;
  return address;
}


func _dummy_write (f, a, v)
{
  return sizeof(v);
}


func nc_addrec (f, time)
/* DOCUMENT nc_addrec, f, time
       -or- nc_addrec, f
     adds a new record to the netCDF file F at time TIME.


   SEE ALSO: nc_create, nc_vardef, nc_enddef
 */
{
  add_record, f, time, , -1;
  files= *get_addrs(f)(4);

  _write,f,4, sum(files==files(0));
}


func nc_attribute (attr_name, var_name)

/* DOCUMENT value= nc_attribute(attr_name, var_name)
     gets the value of the netCDF attribute ATTR_NAME associated
     with variable VAR_NAME, or nil if none.  Uses the external
     variable nc_file set by nc_open.
     If VAR_NAME is omitted, ATTR_NAME refers to the whole file,
     and is retrieved (if present) from the nc_file.attrs variable.


   SEE ALSO: nc_open, nc_attrdef, nc_dimsof, nc_create, nc_enddef
 */
{

  if (is_void(var_name)) attrs= *nc_file.attrs;
  else {

    attrs= where(nc_file.vars->name==var_name);

    if (!numberof(attrs)) return [];
    attrs= *(nc_file.vars->attrs(attrs(0)));
  }
  if (is_void(attrs)) return [];
  value= where(attrs.name==attr_name);
  if (!numberof(value)) return [];
  data= *attrs(value(0)).data;

  if (numberof(data)==1) return data(1);
  else return data;
}


func nc_dimsof (var_name)

/* DOCUMENT def_string= nc_dimsof(var_name)
     returns the dimension list of a netCDF variable VAR_NAME in symbolic
     form, i.e.- using the netCDF dimension names.  This requires the
     nc_file external variable set by nc_open.


   SEE ALSO: nc_open, nc_dimsof, nc_create, nc_enddef
 */
{
  dims= (nc_file.vars.name==var_name);
  if (noneof(dims)) return [];

  dims= *nc_file.vars(where(dims)(0)).dimlist;
  result= "(";
  n= numberof(dims);
  for (i=n ; i>0 ; --i) {

    result+= swrite(format="%ld", nc_file.dims(dims(i)).size);
    if (i) result+= ",";
  }
  return result+")";
}

/* ------------- data structures --------------------------------- */


/* nc_dims is an array of NC_dim */
struct NC_dim {
  string name;  /* represented as NC_string in file */
  long size;  /* length of dimension */
}


/* nc_attrs is an array of NC_attr */
struct NC_attr {
  string name;    /* represented as NC_string in file */
  pointer data;   /* represented as NC_array in file */
}


/* nc_vars is an array of NC_var */
struct NC_var {
  string name;         /* represented as NC_string in file */
  pointer dimlist;     /* represented as NC_iarray in file, dims index */
  pointer attrs;       /* represented as NC_array in file */

  int type;   /* netCDF data type number */
  long len;   /* bytes */
  long address;
}

struct NC_file {
  string filename;     /* for later creation */
  long numrecs;
  pointer dims, attrs, vars;
}


/* ------------- object read routines --------------------------------- */


func NC_ReadDim (f, &address)
{

  name= NC_ReadString(f, address);
  size= long(0);
  _read, f, address, size;
  address+= 4;

  return NC_dim(name=name, size=size);
}


func NC_ReadAttr (f, &address)
{

  name= NC_ReadString(f, address);

  data= &(NC_ReadArray(f, address));

  return NC_attr(name= name, data= data);
}


func NC_ReadString (f, &address)
{
  count= long(0);
  _read, f, address, count;
  address+= 4;
  if (count<=0) return string();
  result= array(char, count);
  _read, f, address, result;
  address+= 4*((count+3)/4);
  return string(&result);
}


func NC_ReadInts (f, &address)
{
  count= long(0);
  _read, f, address, count;
  address+= 4;
  if (count<=0) return &[];
  result= array(int, count);
  _read, f, address, result;
  address+= 4*count;
  return &result;
}


func NC_ReadVar (f, &address)
{

  name= NC_ReadString(f, address);

  dimlist= NC_ReadInts(f, address);

  attrs= &(NC_ReadArray(f, address));   /* must be type NC_attr */
  type= int(0);

  _read, f, address, type;
  address+= 4;
  len= addr= long(0);
  _read, f, address, len;
  address+= 4;
  _read, f, address, addr;
  address+= 4;

  return NC_var(name= name, dimlist= dimlist, attrs= attrs, type= type,
		len= len, address= addr);
}


func NC_ReadArray (f, &address)
{
  type= int(0);

  _read, f, address, type;
  address+= 4;
  count= long(0);
  _read, f, address, count;
  address+= 4;


  if (type<=0 || type>12 || count<=0)
    return [];

  else if (type<=2)     /* byte (1) or char (2) */

    result= NC_ReadPrim(f, address, char, 1, count);
  else if (type==3)     /* short */

    result= NC_ReadPrim(f, address, short, 2, count);
  else if (type==4)     /* long */

    result= NC_ReadPrim(f, address, long, 4, count);
  else if (type==5)     /* float */

    result= NC_ReadPrim(f, address, float, 4, count);
  else if (type==6)     /* double */

    result= NC_ReadPrim(f, address, double, 8, count);

  else if (type==7)     /* bitfield */
    return [];
  else if (type==8)     /* string */

    result= NC_ReadMulti(f, address, string, count, NC_ReadString);
  else if (type==9)     /* iarray */

    result= NC_ReadMulti(f, address, pointer, count, NC_ReadInts);

  else if (type==10)    /* dimension */

    result= NC_ReadMulti(f, address, NC_dim, count, NC_ReadDim);

  else if (type==11)    /* variable */

    result= NC_ReadMulti(f, address, NC_var, count, NC_ReadVar);

  else if (type==12)    /* attribute */

    result= NC_ReadMulti(f, address, NC_attr, count, NC_ReadAttr);


  /* presume that type char means a string */

  if (type==2) result= string(&result);

  return result;
}


func NC_ReadPrim (f, &address, type, size, count)
{

  result= array(type, count);
  _read, f, address, result;
  address+= 4*((size*count+3)/4);
  return result;
}


func NC_ReadMulti (f, &address, type, count, Reader)
{

  result= array(type, count);
  for (i=1 ; i<=count ; ++i) result(i)= Reader(f, address);
  return result;
}


/* ------------- object write routines --------------------------------- */


func NC_WriteDim (f, &address, dim)
{

  NC_WriteString, f, address, dim.name;
  size= long(0);
  _write, f, address, dim.size;
  address+= 4;
}


func NC_WriteAttr (f, &address, attr)
{

  NC_WriteString, f, address, attr.name;

  NC_WriteArray, f, address, *attr.data;
}


func NC_WriteString (f, &address, text)
{

  _write, f, address, strlen(text);
  address+= 4;
  if (strlen(text)<=0) return;

  _write, f, address, (*pointer(text))(1:-1);
  address+= 4*((strlen(text)+3)/4);
}


func NC_WriteInts (f, &address, vals)
{
  vals= *vals;

  _write, f, address, numberof(vals);
  address+= 4;
  if (numberof(vals)<=0) return;
  _write, f, address, long(vals);
  address+= 4*numberof(vals);
}


func NC_WriteVar (f, &address, var)
{

  NC_WriteString, f, address, var.name;

  NC_WriteInts, f, address, var.dimlist;

  NC_WriteArray, f, address, *var.attrs;   /* must be type NC_attr */
  _write, f, address, var.type;
  address+= 4;
  _write, f, address, var.len;
  address+= 4;
  _write, f, address, var.address;
  address+= 4;
}


func NC_WriteArray (f, &address, ary)
{

  type= nameof(structof(ary));
  if (type=="int") {
    ary= long(ary);
    type= "long";
  }

  type= where(type==["char","char","short","long","float","double", "",
		     "NC_string", "NC_iarray", "NC_dim", "NC_var", "NC_attr"]);

  if (!numberof(type)) {
    if (is_void(ary))
      type= 0;

    else if (structof(ary)==string && numberof(ary)==1)

      { ary= *pointer(ary(1));  type= 2; }
    else

      error, "illegal netCDF data type: "+nameof(structof(ary));
  } else {

    type= type(1);
  }

  _write, f, address, type;
  address+= 4;
  count= long(0);

  _write, f, address, numberof(ary);
  address+= 4;


  if (type<=0 || type>12 || !numberof(ary))
    return;

  else if (type<=2)     /* byte (1) or char (2) */

    NC_WritePrim, f, address, char, 1, ary;
  else if (type==3)     /* short */

    NC_WritePrim, f, address, short, 2, ary;
  else if (type==4)     /* long */

    NC_WritePrim, f, address, long, 4, ary;
  else if (type==5)     /* float */

    NC_WritePrim, f, address, float, 4, ary;
  else if (type==6)     /* double */

    NC_WritePrim, f, address, double, 8, ary;

  else if (type==7)     /* bitfield */

    error, "netCDF bitfield data not supported";
  else if (type==8)     /* string */

    NC_WriteMulti, f, address, string, NC_WriteString, ary;
  else if (type==9)     /* iarray */

    NC_WriteMulti, f, address, pointer, NC_WriteInts, ary;

  else if (type==10)    /* dimension */

    NC_WriteMulti, f, address, NC_dim, NC_WriteDim, ary;

  else if (type==11)    /* variable */

    NC_WriteMulti, f, address, NC_var, NC_WriteVar, ary;

  else if (type==12)    /* attribute */

    NC_WriteMulti, f, address, NC_attr, NC_WriteAttr, ary;
}


func NC_WritePrim (f, &address, type, size, data)
{
  _write, f, address, data;

  address+= 4*((size*numberof(data)+3)/4);
}


func NC_WriteMulti (f, &address, type, Writer, data)
{
  count= numberof(data);
  for (i=1 ; i<=count ; ++i) Writer, f, address, data(i);
}

/* ------------- end of netCDF routines --------------------------------- */