From: Youhei SASAKI Date: Tue, 6 Mar 2012 18:30:47 +0900 Subject: Update directory structure: suitable for Rubygems Style Signed-off-by: Youhei SASAKI --- ext/numru/extconf.rb | 124 ++ ext/numru/netcdfraw.c | 4614 ++++++++++++++++++++++++++++++++++++++++++++++ extconf.rb | 124 -- lib/netcdf.rb | 792 -------- lib/netcdf_miss.rb | 203 -- lib/numru/netcdf.rb | 792 ++++++++ lib/numru/netcdf_miss.rb | 203 ++ netcdfraw.c | 4614 ---------------------------------------------- 8 files changed, 5733 insertions(+), 5733 deletions(-) create mode 100644 ext/numru/extconf.rb create mode 100644 ext/numru/netcdfraw.c delete mode 100644 extconf.rb delete mode 100644 lib/netcdf.rb delete mode 100644 lib/netcdf_miss.rb create mode 100644 lib/numru/netcdf.rb create mode 100644 lib/numru/netcdf_miss.rb delete mode 100644 netcdfraw.c diff --git a/ext/numru/extconf.rb b/ext/numru/extconf.rb new file mode 100644 index 0000000..5e53471 --- /dev/null +++ b/ext/numru/extconf.rb @@ -0,0 +1,124 @@ +require "mkmf" + +dir_config('narray',$vendorarchdir,$vendorarchdir) +dir_config('netcdf','/usr/') + +if ( ! ( have_header("narray.h") && have_header("narray_config.h") ) ) then +print < +#include "ruby.h" +#include "narray.h" +#include +#include + +/* for compatibility with ruby 1.6 */ +#ifndef RSTRING_PTR +#define RSTRING_PTR(s) (RSTRING(s)->ptr) +#endif +#ifndef RSTRING_LEN +#define RSTRING_LEN(s) (RSTRING(s)->len) +#endif +#ifndef RARRAY_PTR +#define RARRAY_PTR(a) (RARRAY(a)->ptr) +#endif +#ifndef RARRAY_LEN +#define RARRAY_LEN(a) (RARRAY(a)->len) +#endif +#ifndef StringValueCStr +#define StringValueCStr(s) STR2CSTR(s) +#endif +#ifndef SafeStringValue +#define SafeStringValue(s) Check_SafeStr(s) +#endif + +/* Data to NArray */ + +/* memcpy(ary->ptr,nc_ptr,na_sizeof[NA_SINT]*ary->total); \ */ + +#define Cbyte_to_NArray(v, rank, shape, up) \ +{ \ + struct NARRAY *ary; \ + v = na_make_object(NA_BYTE, rank, shape, cNArray); \ + GetNArray(v,ary); \ + up = (unsigned char *)ary->ptr; \ +} + +#define Csint_to_NArray(v, rank, shape, sp) \ +{ \ + struct NARRAY *ary; \ + v = na_make_object(NA_SINT, rank, shape, cNArray); \ + GetNArray(v, ary); \ + sp = (short *)ary->ptr; \ +} + +#define Clint_to_NArray(v, rank, shape, lp) \ +{ \ + struct NARRAY *ary; \ + v = na_make_object(NA_LINT, rank, shape, cNArray); \ + GetNArray(v, ary); \ + lp = (int *)ary->ptr; \ +} +#define Cfloat_to_NArray(v, rank, shape, fp) \ +{ \ + struct NARRAY *ary; \ + v = na_make_object(NA_SFLOAT, rank, shape, cNArray); \ + GetNArray(v, ary); \ + fp = (float *)ary->ptr; \ +} +#define Cdouble_to_NArray(v, rank, shape, dp); \ +{ \ + struct NARRAY *ary; \ + v = na_make_object(NA_DFLOAT, rank, shape, cNArray); \ + GetNArray(v, ary); \ + dp = (double *)ary->ptr; \ +} + +/* Array or NArray to pointer and length (with no new allocation) */ + +#define Array_to_Cfloat_len(obj, ptr, len) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_SFLOAT); \ + GetNArray(obj, na); \ + ptr = (float *) NA_PTR(na,0); \ + len = na->total; \ +} + +#define Array_to_Cfloat_len_shape(obj, ptr, len, shape) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_SFLOAT); \ + GetNArray(obj, na); \ + ptr = (float *) NA_PTR(na,0); \ + len = na->total; \ + shape = na->shape; \ +} + +#define Array_to_Cdouble_len(obj, ptr, len) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_DFLOAT); \ + GetNArray(obj, na); \ + ptr = (double *) NA_PTR(na,0); \ + len = na->total; \ +} +#define Array_to_Cdouble_len_shape(obj, ptr, len, shape) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_DFLOAT); \ + GetNArray(obj, na); \ + ptr = (double *) NA_PTR(na,0); \ + len = na->total; \ + shape = na->shape; \ +} + +#define Array_to_Cbyte_len(obj, ptr, len) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_BYTE); \ + GetNArray(obj, na); \ + ptr = (u_int8_t *) NA_PTR(na,0); \ + len = na->total; \ +} + +#define Array_to_Cbyte_len_shape(obj, ptr, len, shape) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_BYTE); \ + GetNArray(obj, na); \ + ptr = (u_int8_t *) NA_PTR(na,0); \ + len = na->total; \ + shape = na->shape; \ +} + +#define Array_to_Csint_len(obj, ptr, len) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_SINT); \ + GetNArray(obj, na); \ + ptr = (int16_t *) NA_PTR(na,0); \ + len = na->total; \ +} + +#define Array_to_Csint_len_shape(obj, ptr, len, shape) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_SINT); \ + GetNArray(obj, na); \ + ptr = (int16_t *) NA_PTR(na,0); \ + len = na->total; \ + shape = na->shape; \ +} + + +#define Array_to_Clint_len(obj, ptr, len) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_LINT); \ + GetNArray(obj, na); \ + ptr = (int32_t *) NA_PTR(na,0); \ + len = na->total; \ +} + +#define Array_to_Clint_len_shape(obj, ptr, len, shape) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_LINT); \ + GetNArray(obj, na); \ + ptr = (int32_t *) NA_PTR(na,0); \ + len = na->total; \ + shape = na->shape; \ +} + + +/* Array or NArray to pointer (with no new allocation) */ + +#define Array_to_Cfloat(obj, ptr) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_SFLOAT); \ + GetNArray(obj, na); \ + ptr = (float *) NA_PTR(na,0); \ +} +#define Array_to_Cdouble(obj, ptr) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_DFLOAT); \ + GetNArray(obj, na); \ + ptr = (double *) NA_PTR(na,0); \ +} +#define Array_to_Cbyte(obj, ptr) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_BYTE); \ + GetNArray(obj, na); \ + ptr = (u_int8_t *) NA_PTR(na,0); \ +} +#define Array_to_Csint(obj, ptr) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_SINT); \ + GetNArray(obj, na); \ + ptr = (int16_t *) NA_PTR(na,0); \ +} +#define Array_to_Clint(obj, ptr) \ +{ \ + struct NARRAY *na; \ + obj = na_cast_object(obj, NA_LINT); \ + GetNArray(obj, na); \ + ptr = (int32_t *) NA_PTR(na,0); \ +} + +#define NC_RAISE(status) rb_raise(err_status2class(status),(nc_strerror(status))) +#define NC_RAISE2(status, str) rb_raise(err_status2class(status),"%s (%s)",nc_strerror(status),(str) ) + +static VALUE mNumRu = 0; +static VALUE cNetCDF; +static VALUE cNetCDFDim; +static VALUE cNetCDFAtt; +static VALUE cNetCDFVar; + +static VALUE rb_eNetcdfError; +static VALUE rb_eNetcdfBadid; +static VALUE rb_eNetcdfNfile; +static VALUE rb_eNetcdfExist; +static VALUE rb_eNetcdfInval; +static VALUE rb_eNetcdfPerm; +static VALUE rb_eNetcdfNotindefine; +static VALUE rb_eNetcdfIndefine; +static VALUE rb_eNetcdfInvalcoords; +static VALUE rb_eNetcdfMaxdims; +static VALUE rb_eNetcdfNameinuse; +static VALUE rb_eNetcdfNotatt; +static VALUE rb_eNetcdfMaxatts; +static VALUE rb_eNetcdfBadtype; +static VALUE rb_eNetcdfBaddim; +static VALUE rb_eNetcdfUnlimpos; +static VALUE rb_eNetcdfMaxvars; +static VALUE rb_eNetcdfNotvar; +static VALUE rb_eNetcdfGlobal; +static VALUE rb_eNetcdfNotnc; +static VALUE rb_eNetcdfSts; +static VALUE rb_eNetcdfMaxname; +static VALUE rb_eNetcdfUnlimit; +static VALUE rb_eNetcdfNorecvars; +static VALUE rb_eNetcdfChar; +static VALUE rb_eNetcdfEdge; +static VALUE rb_eNetcdfStride; +static VALUE rb_eNetcdfBadname; +static VALUE rb_eNetcdfRange; +static VALUE rb_eNetcdfNomem; + +/* Special Error */ +/* Global error status */ + +static VALUE rb_eNetcdfFatal; + +/* Global options variable. Used to determine behavior of error handler. */ + +static VALUE rb_eNetcdfEntool; +static VALUE rb_eNetcdfExdr; +static VALUE rb_eNetcdfSyserr; + + +struct Netcdf{ + int ncid; + char *name; + int closed; +}; + +struct NetCDFDim{ + int dimid; + int ncid; +}; + +struct NetCDFVar{ + int varid; + int ncid; + VALUE file; +}; + +struct NetCDFAtt{ + int varid; + int ncid; + char *name; +}; + +static struct Netcdf * +NetCDF_init(int ncid,char *filename) +{ + struct Netcdf *Netcdffile; + Netcdffile=xmalloc(sizeof(struct Netcdf)); + Netcdffile->ncid=ncid; + Netcdffile->closed=0; + Netcdffile->name=xmalloc((strlen(filename)+1)*sizeof(char)); + strcpy(Netcdffile->name,filename); + return(Netcdffile); +} + +static struct NetCDFDim * +NetCDF_dim_init(int ncid,int dimid) +{ + struct NetCDFDim *Netcdf_dim; + Netcdf_dim=xmalloc(sizeof(struct NetCDFDim)); + Netcdf_dim->dimid=dimid; + Netcdf_dim->ncid=ncid; + return(Netcdf_dim); +} + +static struct NetCDFVar * +NetCDF_var_init(int ncid,int varid,VALUE file) +{ + struct NetCDFVar *Netcdf_var; + Netcdf_var=xmalloc(sizeof(struct NetCDFVar)); + Netcdf_var->varid=varid; + Netcdf_var->ncid=ncid; + Netcdf_var->file=file; + return(Netcdf_var); +} +static struct NetCDFAtt * +NetCDF_att_init(int ncid,int varid,char *attname) +{ + struct NetCDFAtt *Netcdf_att; + Netcdf_att=xmalloc(sizeof(struct NetCDFAtt)); + Netcdf_att->ncid=ncid; + Netcdf_att->varid=varid; + Netcdf_att->name=xmalloc((strlen(attname)+1)*sizeof(char)); + strcpy(Netcdf_att->name,attname); + return(Netcdf_att); +} + +void +Netcdf_att_free(struct NetCDFAtt *Netcdf_att) +{ + free(Netcdf_att->name); + free(Netcdf_att); +} + +void +NetCDF_var_free(struct NetCDFVar *Netcdf_var) +{ + free(Netcdf_var); +} + +void +NetCDF_dim_free(struct NetCDFDim *Netcdf_dim) +{ + free(Netcdf_dim); +} + +void +NetCDF_free(struct Netcdf *Netcdffile) +{ + int status; + if (!Netcdffile->closed){ + status = nc_close(Netcdffile->ncid); /* no error check -- not to stop during GC */ + } + free(Netcdffile->name); + free(Netcdffile); +} + +static VALUE +err_status2class(int status) +{ + if(NC_ISSYSERR(status)){ + return(rb_eNetcdfSyserr); + } + switch(status) + { + case(NC_EBADID): + return(rb_eNetcdfBadid);break; + case(NC_ENFILE): + return(rb_eNetcdfNfile);break; + case(NC_EEXIST): + return(rb_eNetcdfExist);break; + case(NC_EINVAL): + return(rb_eNetcdfInval);break; + case(NC_EPERM): + return(rb_eNetcdfPerm);break; + case(NC_ENOTINDEFINE): + return(rb_eNetcdfNotindefine);break; + case(NC_EINDEFINE): + return(rb_eNetcdfIndefine);break; + case(NC_EINVALCOORDS): + return(rb_eNetcdfInvalcoords);break; + case(NC_EMAXDIMS): + return(rb_eNetcdfMaxdims);break; + case(NC_ENAMEINUSE): + return(rb_eNetcdfNameinuse);break; + case(NC_ENOTATT): + return(rb_eNetcdfNotatt);break; + case(NC_EMAXATTS): + return(rb_eNetcdfMaxatts);break; + case(NC_EBADTYPE): + return(rb_eNetcdfBadtype);break; + case(NC_EBADDIM): + return(rb_eNetcdfBaddim);break; + case(NC_EUNLIMPOS): + return(rb_eNetcdfUnlimpos);break; + case(NC_EMAXVARS): + return(rb_eNetcdfMaxvars);break; + case(NC_ENOTVAR): + return(rb_eNetcdfNotvar);break; + case(NC_EGLOBAL): + return(rb_eNetcdfGlobal);break; + case(NC_ENOTNC): + return(rb_eNetcdfNotnc);break; + case(NC_ESTS): + return(rb_eNetcdfSts);break; + case(NC_EMAXNAME): + return(rb_eNetcdfMaxname);break; + case(NC_EUNLIMIT): + return(rb_eNetcdfUnlimit);break; + case(NC_ENORECVARS): + return(rb_eNetcdfNorecvars);break; + case(NC_ECHAR): + return(rb_eNetcdfChar);break; + case(NC_EEDGE): + return(rb_eNetcdfEdge);break; + case(NC_ESTRIDE): + return(rb_eNetcdfStride);break; + case(NC_EBADNAME): + return(rb_eNetcdfBadname);break; + case(NC_ERANGE): + return(rb_eNetcdfRange);break; + case(NC_ENOMEM): + return(rb_eNetcdfNomem);break; + /* case(NC_ENTOOL): + return(rb_eNetcdfEntool);break; */ + case(NC_EXDR): + return(rb_eNetcdfExdr);break; + case(NC_SYSERR): + return(rb_eNetcdfSyserr);break; + case(NC_FATAL): + return(rb_eNetcdfFatal);break; + } +} + +static const char* +nctype2natype(int nctype){ + switch(nctype){ + case NC_CHAR: + return("char"); + case NC_BYTE: + return("byte"); + case NC_SHORT: + return("sint"); + case NC_INT: + return("int"); + case NC_FLOAT: + return("sfloat"); + case NC_DOUBLE: + return("float"); + default: + rb_raise(rb_eNetcdfError, "No such netcdf type number %d\n",nctype); + } +} + +static int +nctype2natypecode(int nctype){ + switch(nctype){ + case NC_CHAR: + return(NA_BYTE); + case NC_BYTE: + return(NA_BYTE); + case NC_SHORT: + return(NA_SINT); + case NC_INT: + return(NA_LINT); + case NC_FLOAT: + return(NA_SFLOAT); + case NC_DOUBLE: + return(NA_DFLOAT); + default: + rb_raise(rb_eNetcdfError, "No such netcdf type number %d\n",nctype); + } +} + +static int +natype2nctype(char *natype) +{ + if(strcmp(natype,"byte")==0) return(NC_BYTE); + else if(strcmp(natype,"char")==0) return(NC_CHAR); + else if(strcmp(natype,"text")==0) return(NC_CHAR); /* alias of char */ + else if(strcmp(natype,"string")==0) return(NC_CHAR); /* alias of char */ + else if(strcmp(natype,"sint")==0) return(NC_SHORT); + else if(strcmp(natype,"int")==0) return(NC_INT); + else if(strcmp(natype,"sfloat")==0) return(NC_FLOAT); + else if(strcmp(natype,"float")==0) return(NC_DOUBLE); + else rb_raise(rb_eNetcdfError, "No such NArray type '%s'",natype); +} + +static int +natypecode2nctype(int natypecode) +{ + if(natypecode==NA_BYTE) return(NC_BYTE); + else if(natypecode==NA_SINT) return(NC_SHORT); + else if(natypecode==NA_LINT) return(NC_INT); + else if(natypecode==NA_SFLOAT) return(NC_FLOAT); + else if(natypecode==NA_DFLOAT) return(NC_DOUBLE); + else rb_raise(rb_eNetcdfError, "No such NArray typecode '%d'",natypecode); +} + +static void +nc_mark_obj(struct NetCDFVar *netcdf_var) +{ + VALUE ptr; + + ptr = netcdf_var->file; + rb_gc_mark(ptr); +} + + +VALUE +NetCDF_clone(VALUE file) +{ + VALUE clone; + struct Netcdf *nc1, *nc2; + + Data_Get_Struct(file, struct Netcdf, nc1); + nc2 = NetCDF_init(nc1->ncid, nc1->name); + clone = Data_Wrap_Struct(cNetCDF, 0, NetCDF_free, nc2); + CLONESETUP(clone, file); + return clone; +} + +VALUE +NetCDF_dim_clone(VALUE dim) +{ + VALUE clone; + struct NetCDFDim *nd1, *nd2; + + Data_Get_Struct(dim, struct NetCDFDim, nd1); + nd2 = NetCDF_dim_init(nd1->ncid, nd1->dimid); + clone = Data_Wrap_Struct(cNetCDFDim, 0, NetCDF_dim_free, nd2); + CLONESETUP(clone, dim); + return clone; +} + +VALUE +NetCDF_att_clone(VALUE att) +{ + VALUE clone; + struct NetCDFAtt *na1, *na2; + + Data_Get_Struct(att, struct NetCDFAtt, na1); + na2 = NetCDF_att_init(na1->ncid, na1->varid, na1->name); + clone = Data_Wrap_Struct(cNetCDFAtt, 0, Netcdf_att_free, na2); + CLONESETUP(clone, att); + return clone; +} + +VALUE +NetCDF_var_clone(VALUE var) +{ + VALUE clone; + struct NetCDFVar *nv1, *nv2; + + Data_Get_Struct(var, struct NetCDFVar, nv1); + nv2 = NetCDF_var_init(nv1->ncid, nv1->varid, nv1->file); + clone = Data_Wrap_Struct(cNetCDFVar, nc_mark_obj, NetCDF_var_free, nv2); + CLONESETUP(clone, var); + return clone; +} + +VALUE +NetCDF_close(file) + VALUE file; +{ + int status; + int ncid; + struct Netcdf *Netcdffile; + + if (rb_safe_level() >= 4 && !OBJ_TAINTED(file)) { + rb_raise(rb_eSecurityError, "Insecure: can't close"); + } + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid=Netcdffile->ncid; + if(!Netcdffile->closed){ + status = nc_close(ncid); + if(status != NC_NOERR) NC_RAISE(status); + Netcdffile->closed = 1; + } else { + rb_warn("file %s is already closed", Netcdffile->name); + } + return Qnil; +} + +VALUE +NetCDF_def_dim(VALUE file,VALUE dim_name,VALUE length) +{ + char* c_dim_name; + size_t c_length; + int ncid; + int dimidp; + int status; + struct Netcdf *Netcdffile; + struct NetCDFDim *Netcdf_dim; + VALUE Dimension; + + rb_secure(4); + Data_Get_Struct(file,struct Netcdf,Netcdffile); + + Check_Type(dim_name,T_STRING); + c_dim_name=RSTRING_PTR(dim_name); + c_length=NUM2UINT(length); + ncid=Netcdffile->ncid; + + status = nc_def_dim(ncid,c_dim_name,c_length,&dimidp); + if(status !=NC_NOERR) NC_RAISE(status); + + Netcdf_dim = NetCDF_dim_init(ncid,dimidp); + + Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); + return Dimension; +} + + +static VALUE +NetCDF_put_att_char(int ncid, char *name,VALUE value,VALUE atttype, int varid) +{ + int status; + struct NetCDFAtt *ncatt; + + /* check atttype (not necessarily needed but it's better to do it) */ + if (TYPE(atttype) == T_STRING){ + if ( natype2nctype(RSTRING_PTR(atttype)) != NC_CHAR ) { + rb_raise(rb_eNetcdfError, + "attribute type must be 'char' (or nil) for a String value"); + } + } else if (TYPE(atttype) != T_NIL) { + rb_raise(rb_eNetcdfError, + "type specfication must be by a string or nil"); + } + /* put value */ + Check_Type(value,T_STRING); + status = nc_put_att_text(ncid, varid, name, + RSTRING_LEN(value), RSTRING_PTR(value)); + if(status != NC_NOERR) NC_RAISE(status); + + ncatt = NetCDF_att_init(ncid,varid,name); + return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,ncatt)); +} + +static VALUE +NetCDF_put_att_numeric(int ncid, char *name,VALUE value,VALUE atttype, int varid) +{ + VALUE val; + struct NARRAY *na_val; + int na_typecode, status, len; + char *ptr; + struct NetCDFAtt *ncatt; + + /* check atttype and cast to an appropriate NArray if needed */ + + if (TYPE(atttype) != T_NIL){ + na_typecode = na_get_typecode(atttype); + GetNArray( na_cast_object(value, na_typecode), na_val ); + } else { + if (TYPE(value)==T_ARRAY) { + val = RARRAY_PTR(value)[0]; /* to check the 1st elemnt if Array */ + } else { + val = value; + } + switch(TYPE(val)){ + case T_FIXNUM: + case T_BIGNUM: + na_typecode = NA_LINT; + GetNArray( na_cast_object(value, na_typecode), na_val ); + break; + case T_FLOAT: + na_typecode = NA_DFLOAT; + GetNArray( na_cast_object(value, na_typecode), na_val ); + break; + case T_DATA: + if ( IsNArray(value) ){ + GetNArray(value,na_val); + na_typecode = na_val->type; + } else { + rb_raise(rb_eNetcdfError,"value has a wrong data type"); + } + break; + default: + rb_raise(rb_eNetcdfError, + "value (or its first element) has a wrong type"); + } + } + + /* put value */ + + len = na_val->total; + ptr = na_val->ptr; + switch(na_typecode){ + case NA_BYTE: + status = nc_put_att_uchar(ncid,varid,name,NC_BYTE,len,(unsigned char *)ptr); + break; + case NA_SINT: + status = nc_put_att_short(ncid,varid,name,NC_SHORT,len,(short *)ptr); + break; + case NA_LINT: + status = nc_put_att_int(ncid,varid,name,NC_INT,len,(int *)ptr); + break; + case NA_SFLOAT: + status = nc_put_att_float(ncid,varid,name,NC_FLOAT,len,(float *)ptr); + break; + case NA_DFLOAT: + status = nc_put_att_double(ncid,varid,name,NC_DOUBLE,len,(double*)ptr); + break; + default: + rb_raise(rb_eNetcdfError, + "unsupported type. code = %d",na_typecode); + } + if(status != NC_NOERR) NC_RAISE(status); + + ncatt = NetCDF_att_init(ncid,varid,name); + return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,ncatt)); +} + +static VALUE +NetCDF_put_att__(int ncid, char *name, VALUE value, VALUE atttype, int varid) + /* + * atttype: nil or a String ("string","int",etc). If nil, + * the type of attribute is determined from the type of value + */ +{ + switch(TYPE(value)){ + case T_STRING: + return(NetCDF_put_att_char(ncid, name, value, atttype, varid)); + default: + return(NetCDF_put_att_numeric(ncid, name, value, atttype, varid)); + } +} + +VALUE +NetCDF_put_att(VALUE file,VALUE att_name,VALUE value,VALUE atttype) + /* + * atttype: nil or a String ("string","int",etc). If nil, + * the type of attribute is determined from the type of value + */ +{ + struct Netcdf *ncfile; + char *name; + + rb_secure(4); + Data_Get_Struct(file,struct Netcdf,ncfile); + Check_Type(att_name,T_STRING); + name = RSTRING_PTR(att_name); + + return( NetCDF_put_att__(ncfile->ncid, name, value, atttype, NC_GLOBAL) ); +} + +VALUE +NetCDF_put_att_var(VALUE var,VALUE att_name,VALUE value,VALUE atttype) + /* + * atttype: nil or a String ("string","int",etc). If nil, + * the type of attribute is determined from the type of value + */ +{ + struct NetCDFVar *ncvar; + char *name; + + rb_secure(4); + Data_Get_Struct(var,struct NetCDFVar,ncvar); + Check_Type(att_name,T_STRING); + name = RSTRING_PTR(att_name); + + return( NetCDF_put_att__(ncvar->ncid, name, value, atttype, ncvar->varid)); +} + + +VALUE +NetCDF_def_var(VALUE file,VALUE var_name,VALUE vartype,VALUE dimensions) +{ + int ncid; + char *c_var_name; + static int xtype; + long c_ndims; + int varidp; + int dimidp; + int i=0; + int status; + char *c_dim_name; + int c_dimids[NC_MAX_DIMS]; + struct Netcdf *Netcdffile; + struct NetCDFVar *Netcdf_var; + struct NetCDFDim *Netcdf_dim; + VALUE Var; + + rb_secure(4); + Check_Type(var_name,T_STRING); + Check_Type(dimensions,T_ARRAY); + + c_var_name=RSTRING_PTR(var_name); + c_ndims=RARRAY_LEN(dimensions); + + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid=Netcdffile->ncid; + + if (TYPE(vartype) == T_STRING){ + xtype = natype2nctype(RSTRING_PTR(vartype)); + } else if (TYPE(vartype) == T_FIXNUM){ + xtype = natypecode2nctype(NUM2INT(vartype)); + } else { + rb_raise(rb_eNetcdfError, + "type specfication must be by a string or nil"); + } + + for(i=0;idimid; + break; + default: + rb_raise(rb_eNetcdfError, "No such object of the netCDF dimension class."); + } + } + + status = nc_def_var(ncid,c_var_name,xtype,c_ndims,c_dimids,&varidp); + if(status != NC_NOERR) NC_RAISE(status); + + Netcdf_var = NetCDF_var_init(ncid,varidp,file); + + Var=Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var); + return Var; +} + + +VALUE +NetCDF_dim(VALUE file,VALUE dim_name) +{ + int ncid; + char *c_dim_name; + int dimidp; + int status; + struct Netcdf *Netcdffile; + struct NetCDFDim *Netcdf_dim; + VALUE Dimension; + + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid=Netcdffile->ncid; + Check_Type(dim_name,T_STRING); + c_dim_name=RSTRING_PTR(dim_name); + + status = nc_inq_dimid(ncid,c_dim_name,&dimidp); + if(status !=NC_NOERR){ + if(status == NC_EBADDIM){ + return(Qnil); /*2003/08/27 back to orig (from changes on 2003/02/03)*/ + } else{ + NC_RAISE(status); + } + } + + Netcdf_dim=NetCDF_dim_init(ncid,dimidp); + + Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); + return Dimension; +} + +VALUE +NetCDF_var(VALUE file,VALUE var_name) +{ + int ncid; + int status; + int varidp; + char *c_var_name; + struct Netcdf *Netcdffile; + struct NetCDFVar *Netcdf_var; + VALUE Variable; + + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid=Netcdffile->ncid; + Check_Type(var_name,T_STRING); + c_var_name=RSTRING_PTR(var_name); + + status=nc_inq_varid(ncid,c_var_name,&varidp); + if(status != NC_NOERR){ + if(status == NC_ENOTVAR){ + return(Qnil); /*2003/08/27 back to orig (from changes on 2003/02/03)*/ + } else{ + NC_RAISE(status); + } + } + + Netcdf_var = NetCDF_var_init(ncid,varidp,file); + Variable = Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var); + return Variable; +} + +VALUE +NetCDF_att(VALUE file,VALUE att_name) +{ + int ncid; + int status; + int attnump; + char *c_att_name; + struct Netcdf *Netcdffile; + struct NetCDFAtt *Netcdf_att; + VALUE Attribute; + + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid=Netcdffile->ncid; + Check_Type(att_name,T_STRING); + c_att_name=RSTRING_PTR(att_name); + + + status = nc_inq_attid(ncid,NC_GLOBAL,c_att_name,&attnump); + if(status != NC_NOERR){ + if(status == NC_ENOTATT){ + return(Qnil); + } + else{ + NC_RAISE(status); + } + } + + Netcdf_att = NetCDF_att_init(ncid,NC_GLOBAL,c_att_name); + + Attribute = Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att); + + return Attribute; +} +VALUE +NetCDF_fill(VALUE file,VALUE mode) +{ + int ncid; + int status; + struct Netcdf *Netcdffile; + int old_modep; + + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid = Netcdffile->ncid; + if(mode==Qfalse){ + status = nc_set_fill(ncid,NC_NOFILL,&old_modep); + if(status != NC_NOERR) NC_RAISE(status); + } + else if(mode == Qtrue){ + status = nc_set_fill(ncid,NC_FILL,&old_modep); + if(status != NC_NOERR) NC_RAISE(status); + } + else + rb_raise(rb_eNetcdfError,"Usage:self.fill(true) or self.fill(false)"); + return Qnil; +} + +VALUE +NetCDF_redef(VALUE file) +{ + int ncid; + int status; + struct Netcdf *Netcdffile; + + rb_secure(4); + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid=Netcdffile->ncid; + status = nc_redef(ncid); + if(status !=NC_NOERR){ + if(status == NC_EINDEFINE){ + return Qnil; + } + else{ + NC_RAISE(status); + } + } + return Qtrue; +} + +VALUE +NetCDF_enddef(VALUE file) +{ + int ncid; + int status; + struct Netcdf *Netcdffile; + + rb_secure(4); + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid=Netcdffile->ncid; + status = nc_enddef(ncid); + if(status !=NC_NOERR){ + if(status == NC_ENOTINDEFINE){ + return Qnil; + } + else{ + NC_RAISE(status); + } + } + return Qtrue; +} + +VALUE +NetCDF_whether_in_define_mode(VALUE file) +{ + /* returns true if the NetCDF object is currently in the define mode, + false if in the data mode, and + nil if else (possibly the file is read-only, or some other + error occurred) + */ + int ncid; + int status; + struct Netcdf *Netcdffile; + + rb_secure(4); + Data_Get_Struct(file,struct Netcdf,Netcdffile); + ncid=Netcdffile->ncid; + status = nc_redef(ncid); + if(status == NC_EINDEFINE){ + return Qtrue; + } else if(status == NC_NOERR) { + /* was in the data mode --> recover the data mode and report false */ + status = nc_enddef(ncid); + if(status == NC_NOERR) { + return Qfalse; + } else { + return Qnil; + } + } else { + return Qnil; + } +} + +VALUE +NetCDF_open(VALUE mod,VALUE filename,VALUE omode) +{ + int status; + int ncid; + char* c_filename; + int c_omode; + struct Netcdf *ncfile; + VALUE retval; + + Check_Type(filename,T_STRING); + SafeStringValue(filename); + c_filename=RSTRING_PTR(filename); + Check_Type(omode,T_FIXNUM); + c_omode=NUM2INT(omode); + + status = nc_open(c_filename,c_omode,&ncid); + if(status !=NC_NOERR){NC_RAISE2(status,c_filename);} + + ncfile = NetCDF_init(ncid,c_filename); + retval = Data_Wrap_Struct(cNetCDF,0,NetCDF_free,ncfile); + return( retval ); +} + +VALUE +NetCDF_create(VALUE mod,VALUE filename,VALUE cmode) +{ + int ncid; + int status; + char* c_filename; + int c_cmode; + struct Netcdf *ncfile; + + Check_Type(filename,T_STRING); + SafeStringValue(filename); + c_filename=RSTRING_PTR(filename); + Check_Type(cmode,T_FIXNUM); + c_cmode=NUM2INT(cmode); + + status = nc_create(c_filename,c_cmode,&ncid); + if(status != NC_NOERR) NC_RAISE2(status, c_filename); + + ncfile = NetCDF_init(ncid,c_filename); + return( Data_Wrap_Struct(cNetCDF,0,NetCDF_free,ncfile) ); +} + +VALUE +NetCDF_ndims(VALUE file) +{ + int ncid; + int ndimsp; + VALUE Integer; + int status; + struct Netcdf *ncfile; + + Data_Get_Struct(file,struct Netcdf,ncfile); + ncid=ncfile->ncid; + status = nc_inq_ndims(ncid,&ndimsp); + if(status != NC_NOERR) NC_RAISE (status); + Integer = INT2NUM(ndimsp); + return Integer; +} + +VALUE +NetCDF_nvars(VALUE file) +{ + int ncid; + int nvarsp; + int status; + VALUE Integer; + struct Netcdf *ncfile; + Data_Get_Struct(file,struct Netcdf,ncfile); + ncid=ncfile->ncid; + status = nc_inq_nvars(ncid,&nvarsp); + if(status != NC_NOERR) NC_RAISE (status); + Integer = INT2NUM(nvarsp); + return Integer; +} + +VALUE +NetCDF_natts(VALUE file) +{ + int ncid; + int nattsp; + int status; + VALUE Integer; + struct Netcdf *ncfile; + + Data_Get_Struct(file,struct Netcdf,ncfile); + ncid=ncfile->ncid; + status=nc_inq_natts(ncid,&nattsp); + if(status != NC_NOERR) NC_RAISE (status); + Integer = INT2NUM(nattsp); + return Integer; +} + +VALUE +NetCDF_unlimited(VALUE file) +{ + int ncid; + int unlimdimidp; + int status; + struct Netcdf *ncfile; + struct NetCDFDim *Netcdf_dim; + VALUE Dimension; + + Data_Get_Struct(file,struct Netcdf,ncfile); + ncid=ncfile->ncid; + status=nc_inq_unlimdim(ncid,&unlimdimidp); + if(status !=NC_NOERR) NC_RAISE(status); + + Netcdf_dim = NetCDF_dim_init(ncid,unlimdimidp); + + /* If unlimdimidp=-1,No unlimited dimension is defined in the netCDF dataset */ + if(unlimdimidp != -1) + { + Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); + return Dimension; + } + else + { + return Qnil; + } +} + +VALUE +NetCDF_sync(VALUE file) +{ + int ncid; + int status; + struct Netcdf *ncfile; + + rb_secure(4); + Data_Get_Struct(file,struct Netcdf,ncfile); + ncid=ncfile->ncid; + status = nc_sync(ncid); + if(status !=NC_NOERR) NC_RAISE (status); + return Qnil; +} + +VALUE +NetCDF_path(VALUE file) +{ + char *path; + struct Netcdf *ncfile; + + Data_Get_Struct(file,struct Netcdf,ncfile); + path=ncfile->name; + return(rb_str_new2(path)); +} + +VALUE +NetCDF_dim_length(VALUE Dim) +{ + int ncid; + int status; + int dimid; + size_t lengthp; + struct NetCDFDim *Netcdf_dim; + + Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim); + ncid=Netcdf_dim->ncid; + dimid=Netcdf_dim->dimid; + + status = nc_inq_dimlen(ncid,dimid,&lengthp); + if(status != NC_NOERR) NC_RAISE(status); + + return(INT2NUM(lengthp)); +} + +VALUE +NetCDF_dim_name(VALUE Dim,VALUE dimension_newname) +{ + int ncid; + int status; + int dimid; + char *c_dim_name; + struct NetCDFDim *Netcdf_dim; + + rb_secure(4); + Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim); + ncid=Netcdf_dim->ncid; + dimid=Netcdf_dim->dimid; + Check_Type(dimension_newname,T_STRING); + c_dim_name = StringValueCStr(dimension_newname); + + status = nc_rename_dim(ncid,dimid,c_dim_name); + if(status !=NC_NOERR) NC_RAISE(status); + + return Qnil; +} + +VALUE +NetCDF_dim_inqname(VALUE Dim) +{ + int ncid; + int status; + int dimid; + char c_dim_name[NC_MAX_NAME]; + struct NetCDFDim *Netcdf_dim; + VALUE str; + + Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim); + ncid=Netcdf_dim->ncid; + dimid=Netcdf_dim->dimid; + + status = nc_inq_dimname(ncid,dimid,c_dim_name); + if(status !=NC_NOERR) NC_RAISE(status); + + str = rb_str_new2(c_dim_name); + OBJ_TAINT(str); + return(str); +} + +VALUE +NetCDF_dim_whether_unlimited(VALUE Dim) +{ + int status; + int uldid; + struct NetCDFDim *Netcdf_dim; + + Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim); + status=nc_inq_unlimdim(Netcdf_dim->ncid,&uldid); + if(status !=NC_NOERR) NC_RAISE(status); + if(Netcdf_dim->dimid == uldid){ + return(Qtrue); + } else { + return(Qfalse); + } +} + +VALUE +NetCDF_att_inq_name(VALUE Att) +{ + char *c_att_name; + struct NetCDFAtt *Netcdf_att; + VALUE str; + + Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); + c_att_name=Netcdf_att->name; + + str = rb_str_new2(c_att_name); + OBJ_TAINT(str); + return(str); +} + +VALUE +NetCDF_att_rename(VALUE Att,VALUE new_att_name) +{ + int ncid; + int status; + int varid; + char *c_att_name; + char *c_new_att_name; + struct NetCDFAtt *Netcdf_att; + Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); + ncid=Netcdf_att->ncid; + varid=Netcdf_att->varid; + + c_att_name=Netcdf_att->name; + + Check_Type(new_att_name,T_STRING); + SafeStringValue(new_att_name); + c_new_att_name=StringValueCStr(new_att_name); + + status = nc_rename_att(ncid,varid,c_att_name,c_new_att_name); + if(status != NC_NOERR) NC_RAISE(status); + + strcpy(Netcdf_att->name,c_new_att_name); + return Qnil; +} + +VALUE +NetCDF_id2dim(VALUE file,VALUE dimid) +{ + int ncid; + int c_dimid; + struct Netcdf *ncfile; + struct NetCDFDim *Netcdf_dim; + VALUE Dim; + + Data_Get_Struct(file,struct Netcdf,ncfile); + ncid=ncfile->ncid; + Check_Type(dimid,T_FIXNUM); + c_dimid=NUM2INT(dimid); + Netcdf_dim = NetCDF_dim_init(ncid,c_dimid); + Dim=Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); + return(Dim); +} + +VALUE +NetCDF_id2var(VALUE file,VALUE varid) +{ + int ncid; + int c_varid; + struct Netcdf *ncfile; + struct NetCDFVar *Netcdf_var; + VALUE Var; + + Data_Get_Struct(file,struct Netcdf,ncfile); + ncid=ncfile->ncid; + Check_Type(varid,T_FIXNUM); + c_varid=NUM2INT(varid); + Netcdf_var = NetCDF_var_init(ncid,c_varid,file); + Var=Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var); + return(Var); +} + + +VALUE +NetCDF_id2att(VALUE file,VALUE attnum) +{ + int ncid; + int c_attnum; + int status; + struct Netcdf *ncfile; + struct NetCDFAtt *Netcdf_att; + char *c_att_name; + VALUE Att; + c_att_name=ALLOCA_N(char,NC_MAX_NAME); + + Data_Get_Struct(file,struct Netcdf,ncfile); + ncid=ncfile->ncid; + + Check_Type(attnum,T_FIXNUM); + c_attnum=NUM2INT(attnum); + + status = nc_inq_attname(ncid,NC_GLOBAL,c_attnum,c_att_name); + if(status != NC_NOERR) NC_RAISE(status); + + Netcdf_att=NetCDF_att_init(ncid,NC_GLOBAL,c_att_name); + + Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att); + return(Att); + +} + +VALUE +NetCDF_var_id2att(VALUE Var,VALUE attnum) +{ + int ncid; + int c_attnum; + int status; + int c_varid; + struct NetCDFVar *Netcdf_var; + struct NetCDFAtt *Netcdf_att; + char *c_att_name; + VALUE Att; + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + ncid=Netcdf_var->ncid; + c_varid=Netcdf_var->varid; + + Check_Type(attnum,T_FIXNUM); + c_attnum=NUM2INT(attnum); + + c_att_name=ALLOCA_N(char,NC_MAX_NAME); + + status = nc_inq_attname(ncid,c_varid,c_attnum,c_att_name); + if(status != NC_NOERR) NC_RAISE(status); + + Netcdf_att=NetCDF_att_init(ncid,c_varid,c_att_name); + Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att); + return(Att); +} + +VALUE +NetCDF_var_dims(VALUE Var) +{ + int ncid, *dimids, ndims, varid, i, status; + struct NetCDFVar *Netcdf_var; + struct NetCDFDim *Netcdf_dim; + VALUE Dims; + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + ncid = Netcdf_var->ncid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + dimids=ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + Dims = rb_ary_new(); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + if(c_ith < 0 || c_ith >= ndims) { + rb_raise(rb_eNetcdfError, "dimension count less than zero or greater than ndims-1"); + } + dimids=ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + Netcdf_dim = NetCDF_dim_init(ncid,dimids[ndims-1-c_ith]); + Dim = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); + return(Dim); +} + +VALUE +NetCDF_att_copy(VALUE Att,VALUE Var_or_File) +{ + int ncid_in,ncid_out; + int status; + int varid_in,varid_out; + char *att_name; + struct NetCDFAtt *Netcdf_att; + struct NetCDFVar *Netcdf_var; + struct Netcdf *ncfile; + struct NetCDFAtt *Netcdf_att_out; + + rb_secure(4); + Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); + ncid_in=Netcdf_att->ncid; + varid_in=Netcdf_att->varid; + att_name=Netcdf_att->name; + + if( rb_obj_is_kind_of(Var_or_File, cNetCDFVar) ){ + Data_Get_Struct(Var_or_File,struct NetCDFVar, Netcdf_var); + ncid_out=Netcdf_var->ncid; + varid_out=Netcdf_var->varid; + } else if ( rb_obj_is_kind_of(Var_or_File, cNetCDF) ){ + Data_Get_Struct(Var_or_File,struct Netcdf, ncfile); + ncid_out=ncfile->ncid; + varid_out=NC_GLOBAL; + } else { + rb_raise(rb_eNetcdfError,"The argument must be a NetCDFVar or a NetCDF"); + } + + status = nc_copy_att(ncid_in,varid_in,att_name,ncid_out,varid_out); + if(status != NC_NOERR) NC_RAISE(status); + Netcdf_att_out = NetCDF_att_init(ncid_out,varid_out,att_name); + return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att_out)); +} + +VALUE +NetCDF_att_atttype(VALUE Att) +{ + int ncid; + int varid; + int status; + char *att_name; + const char *Attname; + struct NetCDFAtt *Netcdf_att; + nc_type xtypep; + + Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); + ncid = Netcdf_att->ncid; + varid = Netcdf_att->varid; + att_name = Netcdf_att->name; + + status = nc_inq_atttype(ncid,varid,att_name,&xtypep); + if(status != NC_NOERR) NC_RAISE(status); + + Attname = nctype2natype(xtypep); + return(rb_str_new2(Attname)); +} + +VALUE +NetCDF_att_typecode(VALUE Att) +{ + int ncid; + int varid; + int status; + char *att_name; + struct NetCDFAtt *Netcdf_att; + nc_type xtypep; + + Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); + ncid = Netcdf_att->ncid; + varid = Netcdf_att->varid; + att_name = Netcdf_att->name; + + status = nc_inq_atttype(ncid,varid,att_name,&xtypep); + if(status != NC_NOERR) NC_RAISE(status); + + return(INT2NUM(nctype2natypecode(xtypep))); +} + +VALUE +NetCDF_att_delete(VALUE Att) +{ + int ncid; + int status; + int varid; + char *c_att_name; + struct NetCDFAtt *Netcdf_att; + + rb_secure(4); + Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); + + ncid=Netcdf_att->ncid; + varid=Netcdf_att->varid; + c_att_name=Netcdf_att->name; + + status = nc_del_att(ncid,varid,c_att_name); + if(status != NC_NOERR) NC_RAISE(status); + + return Qnil; +} + +VALUE +NetCDF_att_put(VALUE Att,VALUE value,VALUE atttype) + /* + * atttype: nil or a String ("string","int",etc). If nil, + * the type of attribute is determined from the type of value + */ +{ + struct NetCDFAtt *ncatt; + + rb_secure(4); + Data_Get_Struct(Att,struct NetCDFAtt,ncatt); + return( NetCDF_put_att__(ncatt->ncid, ncatt->name, value, + atttype, ncatt->varid) ); +} + +VALUE +NetCDF_att_get(VALUE Att) +{ + int ncid; + int varid; + char *c_attname; + int status; + struct NetCDFAtt *Netcdf_att; + nc_type xtypep; + size_t lenp; + int attlen[1]; /* NArray uses int instead of size_t */ + char *tp; + unsigned char *up; + short *sp; + int *ip; + float *fp; + double *dp; + VALUE NArray; + VALUE str; + + Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); + ncid = Netcdf_att->ncid; + varid = Netcdf_att->varid; + c_attname = Netcdf_att->name; + + status = nc_inq_atttype(ncid,varid,c_attname,&xtypep); + if(status != NC_NOERR) NC_RAISE(status); + + switch(xtypep){ + case NC_CHAR: + status = nc_inq_attlen(ncid,varid,c_attname,&lenp); + if(status != NC_NOERR) NC_RAISE(status); + tp = ALLOCA_N(char,lenp+1); + tp[lenp]= '\0'; + status = nc_get_att_text(ncid,varid,c_attname,tp); + if(status != NC_NOERR) NC_RAISE(status); + str = rb_str_new2(tp); + OBJ_TAINT(str); + return(str); + break; + case NC_BYTE: + status = nc_inq_attlen(ncid,varid,c_attname,&lenp); + if(status != NC_NOERR) NC_RAISE(status); + + attlen[0]=lenp; + Cbyte_to_NArray(NArray,1,attlen,up); + + status = nc_get_att_uchar(ncid,varid,c_attname,up); + if(status != NC_NOERR) NC_RAISE(status); + + OBJ_TAINT(NArray); + return NArray; + break; + case NC_SHORT: + status = nc_inq_attlen(ncid,varid,c_attname,&lenp); + if(status != NC_NOERR) NC_RAISE(status); + + attlen[0]=lenp; + Csint_to_NArray(NArray,1,attlen,sp); + + status = nc_get_att_short(ncid,varid,c_attname,sp); + if(status != NC_NOERR) NC_RAISE(status); + OBJ_TAINT(NArray); + return NArray; + break; + case NC_INT: + status = nc_inq_attlen(ncid,varid,c_attname,&lenp); + if(status != NC_NOERR) NC_RAISE(status); + + attlen[0]=lenp; + Clint_to_NArray(NArray,1,attlen,ip); + + status = nc_get_att_int(ncid,varid,c_attname,ip); + if(status != NC_NOERR) NC_RAISE(status); + + OBJ_TAINT(NArray); + return NArray; + break; + case NC_FLOAT: + status = nc_inq_attlen(ncid,varid,c_attname,&lenp); + if(status != NC_NOERR) NC_RAISE(status); + + attlen[0]=lenp; + Cfloat_to_NArray(NArray,1,attlen,fp); + + status = nc_get_att_float(ncid,varid,c_attname,fp); + if(status != NC_NOERR) NC_RAISE(status); + + OBJ_TAINT(NArray); + return NArray; + break; + case NC_DOUBLE: + status = nc_inq_attlen(ncid,varid,c_attname,&lenp); + if(status != NC_NOERR) NC_RAISE(status); + + attlen[0]=lenp; + Cdouble_to_NArray(NArray,1,attlen,dp); + + status = nc_get_att_double(ncid,varid,c_attname,dp); + if(status != NC_NOERR) NC_RAISE(status); + OBJ_TAINT(NArray); + return NArray; + break; + default: + rb_raise(rb_eNetcdfError,"atttype isn't supported in netCDF"); + } + return Qnil; +} + + +VALUE +NetCDF_var_inq_name(VALUE Var) +{ + int ncid; + int status; + int varid; + char c_var_name[NC_MAX_NAME]; + struct NetCDFVar *Netcdf_var; + VALUE Var_name; + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + + ncid=Netcdf_var->ncid; + varid=Netcdf_var->varid; + status = nc_inq_varname(ncid,varid,c_var_name); + if(status != NC_NOERR) NC_RAISE(status); + + Var_name=rb_str_new2(c_var_name); + OBJ_TAINT(Var_name); + return Var_name; +} + +VALUE +NetCDF_var_ndims(VALUE Var) +{ + int ncid; + int status; + int varid; + int ndimsp; + struct NetCDFVar *Netcdf_var; + VALUE Var_ndims; + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + + ncid=Netcdf_var->ncid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + Var_ndims=INT2FIX(ndimsp); + return Var_ndims; +} + +VALUE +NetCDF_var_vartype(VALUE Var) +{ + int ncid; + int status; + int varid; + nc_type xtypep; + struct NetCDFVar *Netcdf_var; + const char *Vartype; + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + + ncid=Netcdf_var->ncid; + varid=Netcdf_var->varid; + + status = nc_inq_vartype(ncid,varid,&xtypep); + if(status != NC_NOERR) NC_RAISE(status); + + Vartype=nctype2natype(xtypep); + return(rb_str_new2(Vartype)); +} + +VALUE +NetCDF_var_typecode(VALUE Var) +{ + int ncid; + int status; + int varid; + nc_type xtypep; + struct NetCDFVar *Netcdf_var; + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + + ncid=Netcdf_var->ncid; + varid=Netcdf_var->varid; + + status = nc_inq_vartype(ncid,varid,&xtypep); + if(status != NC_NOERR) NC_RAISE(status); + + return(INT2NUM(nctype2natypecode(xtypep))); +} + + +VALUE +NetCDF_var_natts(VALUE Var) +{ + int ncid; + int status; + int varid; + int nattsp; + struct NetCDFVar *Netcdf_var; + VALUE Var_natts; + + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + + ncid=Netcdf_var->ncid; + varid=Netcdf_var->varid; + + status= nc_inq_varnatts(ncid,varid,&nattsp); + if(status !=NC_NOERR) NC_RAISE(status); + + Var_natts=INT2FIX(nattsp); + return Var_natts; +} + +VALUE +NetCDF_var_file(VALUE Var) +{ + struct NetCDFVar *Netcdf_var; + /* VALUE file; */ + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + + return (Netcdf_var->file); +} + +VALUE +NetCDF_var_rename(VALUE Var,VALUE var_new_name) +{ + int ncid; + int status; + int varid; + char *c_var_new_name; + struct NetCDFVar *Netcdf_var; + + rb_secure(4); + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + ncid=Netcdf_var->ncid; + varid=Netcdf_var->varid; + + Check_Type(var_new_name,T_STRING); + c_var_new_name=StringValueCStr(var_new_name); + + status = nc_rename_var(ncid,varid,c_var_new_name); + if(status !=NC_NOERR) NC_RAISE(status); + + return Qnil; +} + +VALUE +NetCDF_var_att(VALUE Var,VALUE att_name) +{ + int ncid; + int status; + int varid; + char *c_att_name; + int c_attnump; + struct NetCDFVar *Netcdf_var; + struct NetCDFAtt *Netcdf_att; + VALUE Att; + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + + ncid=Netcdf_var->ncid; + varid=Netcdf_var->varid; + + Check_Type(att_name,T_STRING); + c_att_name=StringValueCStr(att_name); + + status = nc_inq_attid(ncid,varid,c_att_name,&c_attnump); + if(status == NC_NOERR){ + Netcdf_att=NetCDF_att_init(ncid,varid,c_att_name); + Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att); + return Att; + } + else if(status == NC_ENOTATT){ + return Qnil; + } + else{ + NC_RAISE(status); + return Qnil; + } +} + +/* Redifinition of the "==" and "eql?" methods */ + +VALUE +NetCDF_eql(VALUE filea,VALUE fileb) +{ + struct Netcdf *ncfilea; + struct Netcdf *ncfileb; + + if( rb_obj_is_kind_of(fileb, cNetCDF) ){ + Data_Get_Struct(filea,struct Netcdf,ncfilea); + Data_Get_Struct(fileb,struct Netcdf,ncfileb); + + if(ncfilea->ncid == ncfileb->ncid && + strcmp(ncfilea->name,ncfileb->name)==0){ + return Qtrue; + } else { + return Qfalse; + } + } else { + return Qfalse; + } +} + +VALUE +NetCDF_var_eql(VALUE Vara,VALUE Varb) +{ + struct NetCDFVar *Netcdf_vara; + struct NetCDFVar *Netcdf_varb; + + if( rb_obj_is_kind_of(Varb, cNetCDFVar) ){ + Data_Get_Struct(Vara,struct NetCDFVar,Netcdf_vara); + Data_Get_Struct(Varb,struct NetCDFVar,Netcdf_varb); + + if(Netcdf_vara->ncid == Netcdf_varb->ncid && + Netcdf_vara->varid == Netcdf_varb->varid){ + return Qtrue; + } else { + return Qfalse; + } + } else { + return Qfalse; + } +} + +VALUE +NetCDF_dim_eql(VALUE Dima,VALUE Dimb) +{ + struct NetCDFDim *Netcdf_dima; + struct NetCDFDim *Netcdf_dimb; + + if( rb_obj_is_kind_of(Dimb, cNetCDFDim) ){ + Data_Get_Struct(Dima,struct NetCDFDim,Netcdf_dima); + Data_Get_Struct(Dimb,struct NetCDFDim,Netcdf_dimb); + + if(Netcdf_dima->ncid == Netcdf_dimb->ncid && + Netcdf_dima->dimid == Netcdf_dimb->dimid){ + return Qtrue; + } else { + return Qfalse; + } + } else { + return Qfalse; + } +} + +VALUE +NetCDF_att_eql(VALUE Atta,VALUE Attb) +{ + struct NetCDFAtt *Netcdf_atta; + struct NetCDFAtt *Netcdf_attb; + + if( rb_obj_is_kind_of(Attb, cNetCDFAtt) ){ + Data_Get_Struct(Atta,struct NetCDFAtt,Netcdf_atta); + Data_Get_Struct(Attb,struct NetCDFAtt,Netcdf_attb); + + if(Netcdf_atta->ncid == Netcdf_atta->ncid && + Netcdf_atta->varid == Netcdf_attb->varid && + strcmp(Netcdf_atta->name,Netcdf_attb->name)==0){ + return Qtrue; + } else { + return Qfalse; + } + } else { + return Qfalse; + } +} + +/* Follow methods is to connect "NArray" with "Netcdf" */ +VALUE +NetCDF_get_var_char(VALUE Var) +{ + int ncid; + int varid; + int status; + unsigned char *ptr; + struct NetCDFVar *Netcdf_var; + int i=0; + int ndimsp; + int *dimids; + size_t lengthp; + int *shape; /* NArray uses int instead of size_t */ + VALUE NArray; + + Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); + ncid = Netcdf_var->ncid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + dimids = ALLOCA_N(int,ndimsp); + if (ndimsp != 0){ + shape = ALLOCA_N(int,ndimsp); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + dimids = ALLOCA_N(int,ndimsp); + if (ndimsp != 0){ + shape = ALLOCA_N(int,ndimsp); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + dimids = ALLOCA_N(int,ndimsp); + if (ndimsp != 0){ + shape = ALLOCA_N(int,ndimsp); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + dimids = ALLOCA_N(int,ndimsp); + if (ndimsp != 0){ + shape = ALLOCA_N(int,ndimsp); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + dimids = ALLOCA_N(int,ndimsp); + if (ndimsp != 0){ + shape = ALLOCA_N(int,ndimsp); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + dimids = ALLOCA_N(int,ndimsp); + if (ndimsp != 0){ + shape = ALLOCA_N(int,ndimsp); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR)NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); + } + + c_start=ALLOCA_N(size_t,ndims); + c_count=ALLOCA_N(int,ndims); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR)NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); + } + + c_start=ALLOCA_N(size_t,ndims); + c_count=ALLOCA_N(int,ndims); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR) NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); + } + + c_start=ALLOCA_N(size_t,ndims); + c_count=ALLOCA_N(int,ndims); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR)NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); + } + + c_start=ALLOCA_N(size_t,ndims); + c_count=ALLOCA_N(int,ndims); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR)NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); + } + + c_start=ALLOCA_N(size_t,ndims); + c_count=ALLOCA_N(int,ndims); + for(i=0;incid; + varid = Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR)NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); + } + + c_start=ALLOCA_N(size_t,ndims); + c_count=ALLOCA_N(int,ndims); + for(i=0;incid; + varid = Netcdf_var->varid; + + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims){ + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start = ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid = Netcdf_var->varid; + + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims){ + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start = ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid = Netcdf_var->varid; + + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims){ + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start = ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid = Netcdf_var->varid; + + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims){ + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start = ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid = Netcdf_var->varid; + + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims){ + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start = ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid = Netcdf_var->varid; + + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + if(ndims == 0) { + rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); + } + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims){ + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start = ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid=Netcdf_var->varid; + + Array_to_Cbyte_len(NArray,ptr,len); + + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + for(i=0;incid; + varid=Netcdf_var->varid; + + Array_to_Cbyte_len(NArray,ptr,len); + + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + for(i=0;incid; + varid=Netcdf_var->varid; + Array_to_Csint_len(NArray,ptr,len); + + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + for(i=0;incid; + varid=Netcdf_var->varid; + + Array_to_Clint_len(NArray,ptr,len); + + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + for(i=0;incid; + varid=Netcdf_var->varid; + + Array_to_Cfloat_len(NArray,ptr,len); + + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + for(i=0;incid; + varid=Netcdf_var->varid; + + Array_to_Cdouble_len(NArray,ptr,len); + + status = nc_inq_varndims(ncid,varid,&ndimsp); + if(status != NC_NOERR) NC_RAISE(status); + for(i=0;incid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) ncid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) ncid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) ncid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) ncid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) ncid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid,varid,&ndims); + if(status != NC_NOERR) NC_RAISE(status); + + + dimids = ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid,varid,dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) ncid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR) NC_RAISE(status); + + dimids=ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid, varid, dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start=ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR) NC_RAISE(status); + + dimids=ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid, varid, dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start=ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR) NC_RAISE(status); + + dimids=ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid, varid, dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start=ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR) NC_RAISE(status); + + dimids=ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid, varid, dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start=ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR) NC_RAISE(status); + + dimids=ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid, varid, dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start=ALLOCA_N(size_t,ndims); + for(i=0; incid; + varid=Netcdf_var->varid; + status = nc_inq_varndims(ncid, varid, &ndims); + if(status != NC_NOERR) NC_RAISE(status); + + dimids=ALLOCA_N(int,ndims); + status = nc_inq_vardimid(ncid, varid, dimids); + if(status != NC_NOERR) NC_RAISE(status); + + Check_Type(start,T_ARRAY); + if(RARRAY_LEN(start) < ndims) { + rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); + } + c_start=ALLOCA_N(size_t,ndims); + for(i=0; i nc_open; true->nc_create - case(mode) - when "r","rb" # read only - mode=NC_NOWRITE - when "w","w+","wb","w+b" # overwrite if exits - call_create=true - mode=NC_CLOBBER - when "a","a+","r+","ab","a+b","r+b" # append if exits - if( File.exists?(filename) ) - mode=NC_WRITE - else - call_create=true #(nonexsitent --> create) - mode=NC_CLOBBER - end - else - raise NetcdfError, "Mode #{mode} is not supported" - end - case(share) - when false - share=0 - when true - share=NC_SHARE - else - raise NetcdfError, "We can't use the sharing mode you typed" - end - omode = mode | share - if(!call_create) - nc_open(filename,omode) - else - nc_create(filename,omode) - end - end - - class << NetCDF - alias new open - end - - - def NetCDF.create(filename,noclobber=false,share=false) - case(noclobber) - when false - noclobber=NC_CLOBBER - when true - noclobber=NC_NOCLOBBER - else - raise NetcdfError,"noclobber (2nd argument) must be true or false" - end - case(share) - when false - share=0 - when true - share=NC_SHARE - else - raise NetcdfError,"share (3rd argument) must be true or false" - end - - cmode=noclobber | share - nc_create(filename,cmode) - end - - class << NetCDF - def clean_tmpfile(path) - proc { - print "removing ", path, "..." if $DEBUG - if File.exist?(path) - File.unlink(path) - end - print "done\n" if $DEBUG - } - end - protected :clean_tmpfile - end - - def NetCDF.create_tmp(tmpdir=ENV['TMPDIR']||ENV['TMP']||ENV['TEMP']||'.', - share=false) - basename = 'temp' - if $SAFE > 0 and tmpdir.tainted? - tmpdir = '.' - end - - n = 0 - while true - begin - tmpname = sprintf('%s/%s%d_%d.nc', tmpdir, basename, $$, n) - unless File.exist?(tmpname) - netcdf = NetCDF.create(tmpname, true, share) - ObjectSpace.define_finalizer(netcdf, - NetCDF.clean_tmpfile(tmpname)) - break - end - rescue - raise NetcdfError, "cannot generate tempfile `%s'" % tmpname if n >= Max_Try - end - n += 1 - end - netcdf - end - - - def put_att(attname,val,atttype=nil) - put_attraw(attname,val,atttype) - end - - def def_var_with_dim(name, vartype, shape_ul0, dimnames) - # Same as def_var but defines dimensions first if needed. - # Use zero in shape to define an unlimited dimension. - if (shape_ul0.length != dimnames.length ) then - raise ArgumentError, 'lengths of shape and dimnames do not agree' - end - dims = [] - dimnames.each_index{ |i| - dim = self.dim( dimnames[i] ) - if ( dim != nil ) then - # dim exists --> check the length - if (shape_ul0[i] != dim.length_ul0 ) then - raise ArgumentError, "dimension length do not agree: #{i}th dim: "+\ - "#{shape_ul0[i]} and #{dim.length_ul0}" - end - dims.push(dim) - else - # dim does not exist --> define it - dims.push( def_dim( dimnames[i], shape_ul0[i] ) ) - end - } - def_var(name, vartype, dims) - end - - # Iterators: - def each_dim - num_dim=ndims() - for dimid in 0..num_dim-1 - obj_Dim=id2dim(dimid) - yield(obj_Dim) - end - end - - def each_var - num_var=nvars() - for varid in 0..num_var-1 - obj_Var=id2var(varid) - yield(obj_Var) - end - end - - def each_att - num_att=natts() - for attnum in 0..num_att-1 - obj_Att=id2att(attnum) - yield(obj_Att) - end - end - - def dims( names=nil ) # return all if names==nil - if names == nil - dims = (0..ndims()-1).collect{|dimid| id2dim(dimid)} - else - raise TypeError, "names is not an array" if ! names.is_a?(Array) - dims = names.collect{|name| dim(name)} - raise ArgumentError, "One or more dimensions do not exist" if dims.include?(nil) - end - dims - end - - def vars( names=nil ) # return all if names==nil - if names == nil - vars = (0..nvars()-1).collect{ |varid| id2var(varid) } - else - raise TypeError, "names is not an array" if ! names.is_a?(Array) - vars = names.collect{|name| var(name)} - raise ArgumentError, "One or more variables do not exist" if vars.include?(nil) - end - vars - end - - def dim_names - num_dim=ndims() - names=[] - for dimid in 0..num_dim-1 - obj_Dim=id2dim(dimid) - names=names+[obj_Dim.name] - end - return names - end - - def var_names - num_var=nvars() - names=[] - for varid in 0..num_var-1 - obj_Var=id2var(varid) - names=names+[obj_Var.name] - end - return names - end - - def att_names - num_att=natts() - names=[] - for attnum in 0..num_att-1 - obj_Att=id2att(attnum) - names=names+[obj_Att.name] - end - return names - end - - def inspect - "NetCDF:"+path - end - - end - - #NetCDFVar class $B$K4X$7$F(B - class NetCDFVar - - class << NetCDFVar - def new(file,varname,mode="r",share=false) - if(file.is_a?(String)) - file = NetCDF.open(file,mode,share) - elsif(!file.is_a?(NetCDF)) - raise TypeError, "1st arg must be a NetCDF (file object) or a String (path)" - end - file.var(varname) - end - - alias open new - end - - alias :rank :ndims - - def each_att - num_att=natts() - for attnum in 0..num_att-1 - obj_Att=id2att(attnum) - yield(obj_Att) - end - end - - def dim_names - ary = Array.new() - dims.each{|dim| ary.push(dim.name)} - ary - end - - def att_names - num_att=natts() - names=[] - for attnum in 0..num_att-1 - obj_Att=id2att(attnum) - names=names+[obj_Att.name] - end - return names - end - - def put_att(attname,val,atttype=nil) - put_attraw(attname,val,atttype) - end - - def shape_ul0 - sh = [] - dims.each{|d| - if d.unlimited? then - sh.push(0) - else - sh.push(d.length) - end - } - sh - end - - def shape_current - sh = [] - dims.each{|d| - sh.push(d.length) - } - sh - end - - # The put and get methods in the NetCDFVar class - - def pack(na) - sf = att('scale_factor') - ao = att('add_offset') - if ( sf == nil && ao == nil ) then - na - else - na = NArray.to_na(na) if na.is_a?(Array) - if sf - csf = sf.get - raise NetcdfError,"scale_factor is not a numeric" if csf.is_a?(String) - raise NetcdfError, "scale_factor is not unique" if csf.length != 1 - raise NetcdfError, "zero scale_factor" if csf[0] == 0 - else - csf = nil - end - if ao - cao = ao.get - raise NetcdfError, "add_offset is not a numeric" if cao.is_a?(String) - raise NetcdfError, "add_offset is not unique" if cao.length != 1 - else - cao = nil - end - if csf and cao - packed = (na - cao) / csf - elsif csf - packed = na / csf - elsif cao - packed = na - cao - end - if self.typecode <= NArray::LINT - packed = packed.round - end - packed - end - end - - def scaled_put(var,hash=nil) - simple_put( pack(var), hash) - end - - @@unpack_type = nil - class << NetCDFVar - def unpack_type - @@unpack_type - end - def unpack_type=(na_type) - if [NArray::BYTE, NArray::SINT, NArray::INT, - NArray::SFLOAT, NArray::FLOAT, nil].include?(na_type) - @@unpack_type = na_type - else - raise ArgumentError, "Arg must be one of NArray::BYTE, NArray::SINT, NArray::INT, NArray::SFLOAT, NArray::FLOAT" - end - end - - end - - def unpack(na) - sf = att('scale_factor') - ao = att('add_offset') - if ( sf == nil && ao == nil ) then - na - else - if sf - csf = sf.get - raise NetcdfError,"scale_factor is not a numeric" if csf.is_a?(String) - raise NetcdfError, "scale_factor is not unique" if csf.length != 1 - raise NetcdfError, "zero scale_factor" if csf[0] == 0 - else - csf =nil - end - if ao - cao = ao.get - raise NetcdfError, "add_offset is not a numeric" if cao.is_a?(String) - raise NetcdfError, "add_offset is not unique" if cao.length != 1 - else - cao = nil - end - if csf and cao - una = na * csf + cao # csf & cao are NArray -> coerced to their types - elsif csf - una = na * csf - elsif cao - una = na + cao - end - una = una.to_type(@@unpack_type) if @@unpack_type - una - end - end - - def scaled_get(hash=nil) - unpack( simple_get(hash) ) - end - - def simple_put(var,hash=nil) - if hash==nil - if self.vartype == "char" - put_var_char(var) - elsif self.vartype == "byte" - put_var_byte(var) - elsif self.vartype == "sint" - put_var_sint(var) - elsif self.vartype == "int" - put_var_int(var) - elsif self.vartype == "sfloat" - put_var_sfloat(var) - elsif self.vartype == "float" - put_var_float(var) - else - raise NetcdfError,"variable type isn't supported in netCDF" - end - elsif hash.key?("index")==true - if self.vartype == "char" - put_var1_char(var,hash["index"]) - elsif self.vartype=="byte" - put_var1_byte(var,hash["index"]) - elsif self.vartype=="sint" - put_var1_sint(var,hash["index"]) - elsif self.vartype == "int" - put_var1_int(var,hash["index"]) - elsif self.vartype == "sfloat" - put_var1_sfloat(var,hash["index"]) - elsif self.vartype == "float" - put_var1_float(var,hash["index"]) - else - raise NetcdfError,"variable type isn't supported in netCDF" - end - elsif hash.key?("start")==true - if hash.key?("end")==false && hash.key?("stride")==false - if self.vartype == "char" - put_vars_char(var,hash["start"],nil,nil) - elsif self.vartype=="byte" - put_vars_byte(var,hash["start"],nil,nil) - elsif self.vartype=="sint" - put_vars_sint(var,hash["start"],nil,nil) - elsif self.vartype=="int" - put_vars_int(var,hash["start"],nil,nil) - elsif self.vartype=="sfloat" - put_vars_sfloat(var,hash["start"],nil,nil) - elsif self.vartype=="float" - put_vars_float(var,hash["start"],nil,nil) - else - raise NetcdfError, "variable type isn't supported in netCDF" - end - elsif hash.key?("end")==true && hash.key?("stride") == false - if self.vartype == "char" - put_vars_char(var,hash["start"],hash["end"],nil) - elsif self.vartype=="byte" - put_vars_byte(var,hash["start"],hash["end"],nil) - elsif self.vartype=="sint" - put_vars_sint(var,hash["start"],hash["end"],nil) - elsif self.vartype=="int" - put_vars_int(var,hash["start"],hash["end"],nil) - elsif self.vartype == "sfloat" - put_vars_sfloat(var,hash["start"],hash["end"],nil) - elsif self.vartype =="float" - put_vars_float(var,hash["start"],hash["end"],nil) - else - raise NetcdfError, "variable type isn't supported in netCDF" - end - elsif hash.key?("end")==false && hash.key?("stride")==true - if self.vartype == "char" - put_vars_char(var,hash["start"],nil,hash["stride"]) - elsif self.vartype=="byte" - put_vars_byte(var,hash["start"],nil,hash["stride"]) - elsif self.vartype=="sint" - put_vars_sint(var,hash["start"],nil,hash["stride"]) - elsif self.vartype=="int" - put_vars_int(var,hash["start"],nil,hash["stride"]) - elsif self.vartype=="sfloat" - put_vars_sfloat(var,hash["start"],nil,hash["stride"]) - elsif self.vartype=="float" - put_vars_float(var,hash["start"],nil,hash["stride"]) - else - raise NetcdfError, "variable type isn't supported in netCDF" - end - else hash.key?("end")==true && hash.key?("stride")==true - if self.vartype == "char" - put_vars_char(var,hash["start"],hash["end"],hash["stride"]) - elsif self.vartype=="byte" - put_vars_byte(var,hash["start"],hash["end"],hash["stride"]) - elsif self.vartype=="sint" - put_vars_sint(var,hash["start"],hash["end"],hash["stride"]) - elsif self.vartype=="int" - put_vars_int(var,hash["start"],hash["end"],hash["stride"]) - elsif self.vartype=="sfloat" - put_vars_sfloat(var,hash["start"],hash["end"],hash["stride"]) - elsif self.vartype=="float" - put_vars_float(var,hash["start"],hash["end"],hash["stride"]) - else - raise NetcdfError, "variable type isn't supported in netCDF" - end - end - else - raise ArgumentError,"{'start'}=>[ARRAY] or {'index'}=>[ARRAY] is needed" - end - end - - alias put simple_put - - def simple_get(hash=nil) - t_var = self.vartype - if hash == nil - if t_var == "char" - get_var_char - elsif t_var == "byte" - get_var_byte - elsif t_var == "sint" - get_var_sint - elsif t_var == "int" - get_var_int - elsif t_var == "sfloat" - get_var_sfloat - elsif t_var == "float" - get_var_float - else - raise NetcdfError, "variable type #{t_var} isn't supported in netCDF" - end - elsif hash.key?("index")==true - ind = hash["index"] - if t_var == "char" - get_var1_char(ind) - elsif t_var == "byte" - get_var1_byte(ind) - elsif t_var == "sint" - get_var1_sint(ind) - elsif t_var == "int" - get_var1_int(ind) - elsif t_var == "sfloat" - get_var1_sfloat(ind) - elsif t_var == "float" - get_var1_float(ind) - else - raise NetcdfError,"variable type #{t_var} isn't supported in netCDF" - end - elsif hash.key?("start")==true - h_sta = hash["start"] - endq = hash.key?("end") - strq = hash.key?("stride") - if endq == false && strq == false - if t_var == "char" - get_vars_char(h_sta,nil,nil) - elsif t_var == "byte" - get_vars_byte(h_sta,nil,nil) - elsif t_var == "sint" - get_vars_sint(h_sta,nil,nil) - elsif t_var == "int" - get_vars_int(h_sta,nil,nil) - elsif t_var == "sfloat" - get_vars_sfloat(h_sta,nil,nil) - elsif t_var == "float" - get_vars_float(h_sta,nil,nil) - else - raise NetcdfError, "varialbe type #{t_var} isn't supported in netCDF" - end - elsif endq == true && strq == false - h_end = hash["end"] - if t_var == "char" - get_vars_char(h_sta,h_end,nil) - elsif t_var == "byte" - get_vars_byte(h_sta,h_end,nil) - elsif t_var == "sint" - get_vars_sint(h_sta,h_end,nil) - elsif t_var == "int" - get_vars_int(h_sta,h_end,nil) - elsif t_var == "sfloat" - get_vars_sfloat(h_sta,h_end,nil) - elsif t_var == "float" - get_vars_float(h_sta,h_end,nil) - else - raise NetcdfError, "variable type #{t_var} isn't supported in netCDF" - end - elsif endq == false && strq == true - h_str = hash["stride"] - if t_var == "char" - get_vars_char(h_sta,nil,h_str) - elsif t_var == "byte" - get_vars_byte(h_sta,nil,h_str) - elsif t_var == "sint" - get_vars_sint(h_sta,nil,h_str) - elsif t_var == "int" - get_vars_int(h_sta,nil,h_str) - elsif t_var == "sfloat" - get_vars_sfloat(h_sta,nil,h_str) - elsif t_var == "float" - get_vars_float(h_sta,nil,h_str) - else - raise NetcdfError, "variable type #{t_var} isn't supported in netCDF" - end - else endq == true && strq == true - h_end = hash["end"] - h_str = hash["stride"] - if t_var == "char" - get_vars_char(h_sta,h_end,h_str) - elsif t_var == "byte" - get_vars_byte(h_sta,h_end,h_str) - elsif t_var == "sint" - get_vars_sint(h_sta,h_end,h_str) - elsif t_var == "int" - get_vars_int(h_sta,h_end,h_str) - elsif t_var == "sfloat" - get_vars_sfloat(h_sta,h_end,h_str) - elsif t_var == "float" - get_vars_float(h_sta,h_end,h_str) - else - raise NetcdfError, "variable type #{t_var} isn't supported in netCDF" - end - end - else - raise ArgumentError,"{'start'}=>{ARRAY} or {'index'}=>{ARRAY} is needed" - end - end - - alias get simple_get - - def __rubber_expansion( args ) - if (id = args.index(false)) # substitution into id - # false is incuded - alen = args.length - if args.rindex(false) != id - raise ArguemntError,"only one rubber dimension is permitted" - elsif alen > rank+1 - raise ArgumentError, "too many args" - end - ar = ( id!=0 ? args[0..id-1] : [] ) - args = ar + [true]*(rank-alen+1) + args[id+1..-1] - elsif args.length == 0 # to support empty [], []= - args = [true]*rank - end - args - end - private :__rubber_expansion - - def [](*a) - if a.length == 0 - return self.get - end - a = __rubber_expansion(a) - first = Array.new - last = Array.new - stride = Array.new - set_stride = false - a.each{|i| - if(i.is_a?(Fixnum)) - first.push(i) - last.push(i) - stride.push(1) - elsif(i.is_a?(Range)) - first.push(i.first) - last.push(i.exclude_end? ? i.last-1 : i.last) - stride.push(1) - elsif(i.is_a?(Hash)) - r = (i.to_a[0])[0] - s = (i.to_a[0])[1] - if ( !( r.is_a?(Range) ) || ! ( s.is_a?(Integer) ) ) - raise TypeError, "Hash argument must be {a_Range, step}" - end - first.push(r.first) - last.push(r.exclude_end? ? r.last-1 : r.last) - stride.push(s) - set_stride = true - elsif(i.is_a?(TrueClass)) - first.push(0) - last.push(-1) - stride.push(1) - elsif( i.is_a?(Array) || i.is_a?(NArray)) - a_new = a.dup - at = a.index(i) - i = NArray.to_na(i) if i.is_a?(Array) - for n in 0..i.length-1 - a_new[at] = i[n]..i[n] - na_tmp = self[*a_new] - if n==0 then - k = at - if at > 0 - a[0..at-1].each{|x| if x.is_a?(Fixnum) then k -= 1 end} - end - shape_tmp = na_tmp.shape - shape_tmp[k] = i.length - na = na_tmp.class.new(na_tmp.typecode,*shape_tmp) - index_tmp = Array.new(shape_tmp.length,true) - end - index_tmp[k] = n..n - na[*index_tmp] = na_tmp - end - return na - else - raise TypeError, "argument must be Fixnum, Range, Hash, TrueClass, Array, or NArray" - end - } - - if(set_stride) - na = self.get({"start"=>first, "end"=>last, "stride"=>stride}) - else - na = self.get({"start"=>first, "end"=>last}) - end - shape = na.shape - (a.length-1).downto(0){ |i| - shape.delete_at(i) if a[i].is_a?(Fixnum) - } - na.reshape!( *shape ) - na - end - - def []=(*a) - val = a.pop - a = __rubber_expansion(a) - first = Array.new - last = Array.new - stride = Array.new - set_stride = false - a.each{|i| - if(i.is_a?(Fixnum)) - first.push(i) - last.push(i) - stride.push(1) - elsif(i.is_a?(Range)) - first.push(i.first) - last.push(i.exclude_end? ? i.last-1 : i.last) - stride.push(1) - elsif(i.is_a?(Hash)) - r = (i.to_a[0])[0] - s = (i.to_a[0])[1] - if ( !( r.is_a?(Range) ) || ! ( s.is_a?(Integer) ) ) - raise ArgumentError, "Hash argument must be {first..last, step}" - end - first.push(r.first) - last.push(r.exclude_end? ? r.last-1 : r.last) - stride.push(s) - set_stride = true - elsif(i.is_a?(TrueClass)) - first.push(0) - last.push(-1) - stride.push(1) - elsif(i.is_a?(Array) || i.is_a?(NArray)) - a_new = a.dup - at = a.index(i) - i = NArray.to_na(i) if i.is_a?(Array) - val = NArray.to_na(val) if val.is_a?(Array) - rank_of_subset = a.dup.delete_if{|v| v.is_a?(Fixnum)}.length - if val.rank != rank_of_subset - raise "rank of the rhs (#{val.rank}) is not equal to the rank "+ - "of the subset specified by #{a.inspect} (#{rank_of_subset})" - end - k = at - a[0..at-1].each{|x| if x.is_a?(Fixnum) then k -= 1 end} - if i.length != val.shape[k] - raise "length of the #{k+1}-th dim of rhs is incorrect "+ - "(#{i.length} for #{val.shape[k]})" - end - index_tmp = Array.new(val.rank,true) if !val.is_a?(Numeric) #==>Array-like - for n in 0..i.length-1 - a_new[at] = i[n]..i[n] - if !val.is_a?(Numeric) then - index_tmp[k] = n..n - self[*a_new] = val[*index_tmp] - else - self[*a_new] = val - end - end - return self - else - raise TypeError, "argument must be Fixnum, Range, Hash, TrueClass, Array, or NArray" - end - } - - if(set_stride) - self.put(val, {"start"=>first, "end"=>last, "stride"=>stride}) - else - self.put(val, {"start"=>first, "end"=>last}) - end - end - - def inspect - 'NetCDFVar:'+file.path+'?var='+name - end - - end - - class NetCDFAtt - - def put(val,atttype=nil) - putraw(val,atttype) - end - - def inspect - 'NetCDFAtt:'+name - end - end - - class NetCDFDim - def inspect - 'NetCDFDim:'+name - end - - def length_ul0 - if unlimited? - 0 - else - length - end - end - - end -end diff --git a/lib/netcdf_miss.rb b/lib/netcdf_miss.rb deleted file mode 100644 index 4b168f0..0000000 --- a/lib/netcdf_miss.rb +++ /dev/null @@ -1,203 +0,0 @@ -require "numru/netcdf" -require "narray_miss" - -module NumRu - - class NetCDFVar - - def get_with_miss(*args) - __interpret_missing_params if !defined?(@missval) - data = simple_get(*args) - if @vmin || @vmax - if @vmin - mask = (data >= @vmin) - mask = mask.and(data <= @vmax) if @vmax - else - mask = (data <= @vmax) - end - data = NArrayMiss.to_nam(data, mask) - elsif @missval # only missing_value is present. - mask = (data.ne(@missval)) - data = NArrayMiss.to_nam(data, mask) - end - data - end - - def get_with_miss_and_scaling(*args) - __interpret_missing_params if !defined?(@missval) - data = simple_get(*args) - if @vmin || @vmax - if @vmin - mask = (data >= @vmin) - mask = mask.and(data <= @vmax) if @vmax - else - mask = (data <= @vmax) - end - data = NArrayMiss.to_nam(data, mask) - elsif @missval # only missing_value is present. - mask = (data.ne(@missval)) - data = NArrayMiss.to_nam(data, mask) - end - data = unpack( data ) - data - end - - def put_with_miss(data, *args) - if data.is_a?( NArrayMiss ) - __interpret_missing_params if !defined?(@missval) - if @missval - simple_put(data.to_na(@missval), *args) - else - simple_put(data.to_na, *args) - end - else - simple_put(data, *args) - end - end - - def put_with_miss_and_scaling(data, *args) - if data.is_a?( NArrayMiss ) - __interpret_missing_params if !defined?(@missval) - if @missval - data = pack( data ) - data = data.to_na(@missval) - else - data = pack( data ) - data = data.to_na - end - simple_put(data, *args) - else - scaled_put(data, *args) - end - end - - ######### private ########## - - def __interpret_missing_params - # Interprets the specification of missing data, - # either by valid_range, (valid_min and/or valid_max), or missing_value. - # (unlike the NetCDF User's guide (NUG), missing_value is interpreted, - # but valid_* has a higher precedence.) - # Always sets @missval whether missing_value is defined or not, - # since it will be used as a fill value for data missing. - # - @vmin = att('valid_min') - @vmin = @vmin.get if @vmin # kept in a NArray(size==1) to consv type - @vmax = att('valid_max') - @vmax = @vmax.get if @vmax # kept in a NArray(size==1) to consv type - vrange = att('valid_range') - vrange = vrange.get if vrange - if vrange - vrange.sort! - @vmin = vrange[0..0] # kept in... (same) - @vmax = vrange[-1..-1] # kept in... (same) - end - @missval = att('missing_value') || att('_FillValue') - @missval = @missval.get if @missval # kept in... (same) - - sf = att('scale_factor') - ao = att('add_offset') - if ( sf || ao ) - ## Both NUG & CF conventions requires to specify the valid - ## range with respect to the external (i.e. packed) values. - ## However, some conventions require specification - ## with respect to unpacked values. The following - ## is to support such cases as well: - thres_tp = [ self.typecode, NArray::LINT ].max - @missval = pack(@missval) if @missval && @missval.typecode > thres_tp - @vmin = pack(@vmin) if @vmin && @vmin.typecode > thres_tp - @vmax = pack(@vmax) if @vmax && @vmax.typecode > thres_tp - end - - if @missval - if @vmin && @vmax - if @vmin[0] <= @missval[0] && @missval[0] <= @vmax[0] - warn "WARNING: missing_value #{@missval[0]} is in the valid range #{@vmin[0]}..#{@vmax[0]} --> will be ignored (#{__FILE__}:#{__LINE__})" - end - else - if @vmin && @missval[0] >= @vmin[0] - warn "WARNING: missing_value #{@missval[0]} >= valid min #{@vmin[0]} --> will be ignored (#{__FILE__}:#{__LINE__})" - elsif @vmax && @missval[0] <= @vmax[0] - warn "WARNING: missing_value #{@missval[0]} <= valid min #{@vmin[0]} --> will be ignored (#{__FILE__}:#{__LINE__})" - end - end - else - realtc = NArray::SFLOAT - if @vmin - if @vmin[0] >= 0 - @missval = ( @vmin.typecode>=realtc ? 0.99*@vmin : @vmin-1 ) - else - @missval = ( @vmin.typecode>=realtc ? 1.01*@vmin : @vmin-1 ) - end - elsif @vmax - if @vmax[0] >= 0 - @missval = ( @vmax.typecode>=realtc ? 1.01*@vmax : @vmax+1 ) - else - @missval = ( @vmax.typecode>=realtc ? 0.99*@vmax : @vmax+1 ) - end - end - end - - end - - private :__interpret_missing_params - - end - -end - -if $0 == __FILE__ - include NumRu - - filename = "tmp.nc" - print "creating ",filename,"...\n" - file=NetCDF.create(filename) - nx = 10 - dimx = file.def_dim("x",nx) - xf = file.def_var("xf","sfloat",[dimx]) - xfn = file.def_var("xfn","sfloat",[dimx]) - xf.put_att("valid_range",[-1e12,1e12]) - f = 10 ** (2*NArray.sfloat(nx).indgen!) - xr = file.def_var("xr","sint",[dimx]) - xr.put_att("valid_max",[0.5]) - xr.put_att("scale_factor",1e-4) - xr.put_att("add_offset",0.5) - xr2 = file.def_var("xr2","sint",[dimx]) - xr2.put_att("valid_max",NArray.sint(1).fill!(1000)) - xr2.put_att("scale_factor",1e-4) - xr2.put_att("add_offset",0.5) - r = NArray.sfloat(nx).indgen!/nx - file.enddef - xf.put(f) - xfn.put(f) - xr.scaled_put(r) - file.close - - file = NetCDF.open(filename,'r+') - xf = file.var('xf') - xfn = file.var('xfn') - p "f0" - xf.get.each{|v| print "#{v} "} ; print "\n" - p( 'f1', nam = xf.get_with_miss ) - def xf.get(*args); get_with_miss(*args); end - p( 'f12', xf[2..-3].to_na ) - p( 'fn10', xfn.get_with_miss ) - p( 'fn11', xfn.get_with_miss_and_scaling ) - nam.invalidation([0,1]) - p 'f2', nam - xf.put_with_miss(nam) - p( 'f3', xf.get_with_miss ) - xr = file.var('xr') - p "r0" - xr.simple_get.each{|v| print "#{v} "} ; print "\n" - p( 'r1', xr.get_with_miss_and_scaling ) - def xr.get(*args); get_with_miss_and_scaling(*args); end - def xr.put(*args); put_with_miss_and_scaling(*args); end - #xr[0..3] = xr[0..3]*10 - p( 'r2', xr.get_with_miss_and_scaling ) - p 'r',r - xr2.put_with_miss_and_scaling(r) - p 'xr2',xr2.get_with_miss_and_scaling - file.close - print "** ncdump tmp.nc **\n", `ncdump tmp.nc` -end diff --git a/lib/numru/netcdf.rb b/lib/numru/netcdf.rb new file mode 100644 index 0000000..aaba6d2 --- /dev/null +++ b/lib/numru/netcdf.rb @@ -0,0 +1,792 @@ +require 'narray' +require 'numru/netcdfraw' + +# NetCDF$B%/%i%9$K4X$7$F(B +module NumRu + class NetCDF + + Max_Try = 100 + + def NetCDF.open(filename,mode="r",share=false) + call_create=false # false-> nc_open; true->nc_create + case(mode) + when "r","rb" # read only + mode=NC_NOWRITE + when "w","w+","wb","w+b" # overwrite if exits + call_create=true + mode=NC_CLOBBER + when "a","a+","r+","ab","a+b","r+b" # append if exits + if( File.exists?(filename) ) + mode=NC_WRITE + else + call_create=true #(nonexsitent --> create) + mode=NC_CLOBBER + end + else + raise NetcdfError, "Mode #{mode} is not supported" + end + case(share) + when false + share=0 + when true + share=NC_SHARE + else + raise NetcdfError, "We can't use the sharing mode you typed" + end + omode = mode | share + if(!call_create) + nc_open(filename,omode) + else + nc_create(filename,omode) + end + end + + class << NetCDF + alias new open + end + + + def NetCDF.create(filename,noclobber=false,share=false) + case(noclobber) + when false + noclobber=NC_CLOBBER + when true + noclobber=NC_NOCLOBBER + else + raise NetcdfError,"noclobber (2nd argument) must be true or false" + end + case(share) + when false + share=0 + when true + share=NC_SHARE + else + raise NetcdfError,"share (3rd argument) must be true or false" + end + + cmode=noclobber | share + nc_create(filename,cmode) + end + + class << NetCDF + def clean_tmpfile(path) + proc { + print "removing ", path, "..." if $DEBUG + if File.exist?(path) + File.unlink(path) + end + print "done\n" if $DEBUG + } + end + protected :clean_tmpfile + end + + def NetCDF.create_tmp(tmpdir=ENV['TMPDIR']||ENV['TMP']||ENV['TEMP']||'.', + share=false) + basename = 'temp' + if $SAFE > 0 and tmpdir.tainted? + tmpdir = '.' + end + + n = 0 + while true + begin + tmpname = sprintf('%s/%s%d_%d.nc', tmpdir, basename, $$, n) + unless File.exist?(tmpname) + netcdf = NetCDF.create(tmpname, true, share) + ObjectSpace.define_finalizer(netcdf, + NetCDF.clean_tmpfile(tmpname)) + break + end + rescue + raise NetcdfError, "cannot generate tempfile `%s'" % tmpname if n >= Max_Try + end + n += 1 + end + netcdf + end + + + def put_att(attname,val,atttype=nil) + put_attraw(attname,val,atttype) + end + + def def_var_with_dim(name, vartype, shape_ul0, dimnames) + # Same as def_var but defines dimensions first if needed. + # Use zero in shape to define an unlimited dimension. + if (shape_ul0.length != dimnames.length ) then + raise ArgumentError, 'lengths of shape and dimnames do not agree' + end + dims = [] + dimnames.each_index{ |i| + dim = self.dim( dimnames[i] ) + if ( dim != nil ) then + # dim exists --> check the length + if (shape_ul0[i] != dim.length_ul0 ) then + raise ArgumentError, "dimension length do not agree: #{i}th dim: "+\ + "#{shape_ul0[i]} and #{dim.length_ul0}" + end + dims.push(dim) + else + # dim does not exist --> define it + dims.push( def_dim( dimnames[i], shape_ul0[i] ) ) + end + } + def_var(name, vartype, dims) + end + + # Iterators: + def each_dim + num_dim=ndims() + for dimid in 0..num_dim-1 + obj_Dim=id2dim(dimid) + yield(obj_Dim) + end + end + + def each_var + num_var=nvars() + for varid in 0..num_var-1 + obj_Var=id2var(varid) + yield(obj_Var) + end + end + + def each_att + num_att=natts() + for attnum in 0..num_att-1 + obj_Att=id2att(attnum) + yield(obj_Att) + end + end + + def dims( names=nil ) # return all if names==nil + if names == nil + dims = (0..ndims()-1).collect{|dimid| id2dim(dimid)} + else + raise TypeError, "names is not an array" if ! names.is_a?(Array) + dims = names.collect{|name| dim(name)} + raise ArgumentError, "One or more dimensions do not exist" if dims.include?(nil) + end + dims + end + + def vars( names=nil ) # return all if names==nil + if names == nil + vars = (0..nvars()-1).collect{ |varid| id2var(varid) } + else + raise TypeError, "names is not an array" if ! names.is_a?(Array) + vars = names.collect{|name| var(name)} + raise ArgumentError, "One or more variables do not exist" if vars.include?(nil) + end + vars + end + + def dim_names + num_dim=ndims() + names=[] + for dimid in 0..num_dim-1 + obj_Dim=id2dim(dimid) + names=names+[obj_Dim.name] + end + return names + end + + def var_names + num_var=nvars() + names=[] + for varid in 0..num_var-1 + obj_Var=id2var(varid) + names=names+[obj_Var.name] + end + return names + end + + def att_names + num_att=natts() + names=[] + for attnum in 0..num_att-1 + obj_Att=id2att(attnum) + names=names+[obj_Att.name] + end + return names + end + + def inspect + "NetCDF:"+path + end + + end + + #NetCDFVar class $B$K4X$7$F(B + class NetCDFVar + + class << NetCDFVar + def new(file,varname,mode="r",share=false) + if(file.is_a?(String)) + file = NetCDF.open(file,mode,share) + elsif(!file.is_a?(NetCDF)) + raise TypeError, "1st arg must be a NetCDF (file object) or a String (path)" + end + file.var(varname) + end + + alias open new + end + + alias :rank :ndims + + def each_att + num_att=natts() + for attnum in 0..num_att-1 + obj_Att=id2att(attnum) + yield(obj_Att) + end + end + + def dim_names + ary = Array.new() + dims.each{|dim| ary.push(dim.name)} + ary + end + + def att_names + num_att=natts() + names=[] + for attnum in 0..num_att-1 + obj_Att=id2att(attnum) + names=names+[obj_Att.name] + end + return names + end + + def put_att(attname,val,atttype=nil) + put_attraw(attname,val,atttype) + end + + def shape_ul0 + sh = [] + dims.each{|d| + if d.unlimited? then + sh.push(0) + else + sh.push(d.length) + end + } + sh + end + + def shape_current + sh = [] + dims.each{|d| + sh.push(d.length) + } + sh + end + + # The put and get methods in the NetCDFVar class + + def pack(na) + sf = att('scale_factor') + ao = att('add_offset') + if ( sf == nil && ao == nil ) then + na + else + na = NArray.to_na(na) if na.is_a?(Array) + if sf + csf = sf.get + raise NetcdfError,"scale_factor is not a numeric" if csf.is_a?(String) + raise NetcdfError, "scale_factor is not unique" if csf.length != 1 + raise NetcdfError, "zero scale_factor" if csf[0] == 0 + else + csf = nil + end + if ao + cao = ao.get + raise NetcdfError, "add_offset is not a numeric" if cao.is_a?(String) + raise NetcdfError, "add_offset is not unique" if cao.length != 1 + else + cao = nil + end + if csf and cao + packed = (na - cao) / csf + elsif csf + packed = na / csf + elsif cao + packed = na - cao + end + if self.typecode <= NArray::LINT + packed = packed.round + end + packed + end + end + + def scaled_put(var,hash=nil) + simple_put( pack(var), hash) + end + + @@unpack_type = nil + class << NetCDFVar + def unpack_type + @@unpack_type + end + def unpack_type=(na_type) + if [NArray::BYTE, NArray::SINT, NArray::INT, + NArray::SFLOAT, NArray::FLOAT, nil].include?(na_type) + @@unpack_type = na_type + else + raise ArgumentError, "Arg must be one of NArray::BYTE, NArray::SINT, NArray::INT, NArray::SFLOAT, NArray::FLOAT" + end + end + + end + + def unpack(na) + sf = att('scale_factor') + ao = att('add_offset') + if ( sf == nil && ao == nil ) then + na + else + if sf + csf = sf.get + raise NetcdfError,"scale_factor is not a numeric" if csf.is_a?(String) + raise NetcdfError, "scale_factor is not unique" if csf.length != 1 + raise NetcdfError, "zero scale_factor" if csf[0] == 0 + else + csf =nil + end + if ao + cao = ao.get + raise NetcdfError, "add_offset is not a numeric" if cao.is_a?(String) + raise NetcdfError, "add_offset is not unique" if cao.length != 1 + else + cao = nil + end + if csf and cao + una = na * csf + cao # csf & cao are NArray -> coerced to their types + elsif csf + una = na * csf + elsif cao + una = na + cao + end + una = una.to_type(@@unpack_type) if @@unpack_type + una + end + end + + def scaled_get(hash=nil) + unpack( simple_get(hash) ) + end + + def simple_put(var,hash=nil) + if hash==nil + if self.vartype == "char" + put_var_char(var) + elsif self.vartype == "byte" + put_var_byte(var) + elsif self.vartype == "sint" + put_var_sint(var) + elsif self.vartype == "int" + put_var_int(var) + elsif self.vartype == "sfloat" + put_var_sfloat(var) + elsif self.vartype == "float" + put_var_float(var) + else + raise NetcdfError,"variable type isn't supported in netCDF" + end + elsif hash.key?("index")==true + if self.vartype == "char" + put_var1_char(var,hash["index"]) + elsif self.vartype=="byte" + put_var1_byte(var,hash["index"]) + elsif self.vartype=="sint" + put_var1_sint(var,hash["index"]) + elsif self.vartype == "int" + put_var1_int(var,hash["index"]) + elsif self.vartype == "sfloat" + put_var1_sfloat(var,hash["index"]) + elsif self.vartype == "float" + put_var1_float(var,hash["index"]) + else + raise NetcdfError,"variable type isn't supported in netCDF" + end + elsif hash.key?("start")==true + if hash.key?("end")==false && hash.key?("stride")==false + if self.vartype == "char" + put_vars_char(var,hash["start"],nil,nil) + elsif self.vartype=="byte" + put_vars_byte(var,hash["start"],nil,nil) + elsif self.vartype=="sint" + put_vars_sint(var,hash["start"],nil,nil) + elsif self.vartype=="int" + put_vars_int(var,hash["start"],nil,nil) + elsif self.vartype=="sfloat" + put_vars_sfloat(var,hash["start"],nil,nil) + elsif self.vartype=="float" + put_vars_float(var,hash["start"],nil,nil) + else + raise NetcdfError, "variable type isn't supported in netCDF" + end + elsif hash.key?("end")==true && hash.key?("stride") == false + if self.vartype == "char" + put_vars_char(var,hash["start"],hash["end"],nil) + elsif self.vartype=="byte" + put_vars_byte(var,hash["start"],hash["end"],nil) + elsif self.vartype=="sint" + put_vars_sint(var,hash["start"],hash["end"],nil) + elsif self.vartype=="int" + put_vars_int(var,hash["start"],hash["end"],nil) + elsif self.vartype == "sfloat" + put_vars_sfloat(var,hash["start"],hash["end"],nil) + elsif self.vartype =="float" + put_vars_float(var,hash["start"],hash["end"],nil) + else + raise NetcdfError, "variable type isn't supported in netCDF" + end + elsif hash.key?("end")==false && hash.key?("stride")==true + if self.vartype == "char" + put_vars_char(var,hash["start"],nil,hash["stride"]) + elsif self.vartype=="byte" + put_vars_byte(var,hash["start"],nil,hash["stride"]) + elsif self.vartype=="sint" + put_vars_sint(var,hash["start"],nil,hash["stride"]) + elsif self.vartype=="int" + put_vars_int(var,hash["start"],nil,hash["stride"]) + elsif self.vartype=="sfloat" + put_vars_sfloat(var,hash["start"],nil,hash["stride"]) + elsif self.vartype=="float" + put_vars_float(var,hash["start"],nil,hash["stride"]) + else + raise NetcdfError, "variable type isn't supported in netCDF" + end + else hash.key?("end")==true && hash.key?("stride")==true + if self.vartype == "char" + put_vars_char(var,hash["start"],hash["end"],hash["stride"]) + elsif self.vartype=="byte" + put_vars_byte(var,hash["start"],hash["end"],hash["stride"]) + elsif self.vartype=="sint" + put_vars_sint(var,hash["start"],hash["end"],hash["stride"]) + elsif self.vartype=="int" + put_vars_int(var,hash["start"],hash["end"],hash["stride"]) + elsif self.vartype=="sfloat" + put_vars_sfloat(var,hash["start"],hash["end"],hash["stride"]) + elsif self.vartype=="float" + put_vars_float(var,hash["start"],hash["end"],hash["stride"]) + else + raise NetcdfError, "variable type isn't supported in netCDF" + end + end + else + raise ArgumentError,"{'start'}=>[ARRAY] or {'index'}=>[ARRAY] is needed" + end + end + + alias put simple_put + + def simple_get(hash=nil) + t_var = self.vartype + if hash == nil + if t_var == "char" + get_var_char + elsif t_var == "byte" + get_var_byte + elsif t_var == "sint" + get_var_sint + elsif t_var == "int" + get_var_int + elsif t_var == "sfloat" + get_var_sfloat + elsif t_var == "float" + get_var_float + else + raise NetcdfError, "variable type #{t_var} isn't supported in netCDF" + end + elsif hash.key?("index")==true + ind = hash["index"] + if t_var == "char" + get_var1_char(ind) + elsif t_var == "byte" + get_var1_byte(ind) + elsif t_var == "sint" + get_var1_sint(ind) + elsif t_var == "int" + get_var1_int(ind) + elsif t_var == "sfloat" + get_var1_sfloat(ind) + elsif t_var == "float" + get_var1_float(ind) + else + raise NetcdfError,"variable type #{t_var} isn't supported in netCDF" + end + elsif hash.key?("start")==true + h_sta = hash["start"] + endq = hash.key?("end") + strq = hash.key?("stride") + if endq == false && strq == false + if t_var == "char" + get_vars_char(h_sta,nil,nil) + elsif t_var == "byte" + get_vars_byte(h_sta,nil,nil) + elsif t_var == "sint" + get_vars_sint(h_sta,nil,nil) + elsif t_var == "int" + get_vars_int(h_sta,nil,nil) + elsif t_var == "sfloat" + get_vars_sfloat(h_sta,nil,nil) + elsif t_var == "float" + get_vars_float(h_sta,nil,nil) + else + raise NetcdfError, "varialbe type #{t_var} isn't supported in netCDF" + end + elsif endq == true && strq == false + h_end = hash["end"] + if t_var == "char" + get_vars_char(h_sta,h_end,nil) + elsif t_var == "byte" + get_vars_byte(h_sta,h_end,nil) + elsif t_var == "sint" + get_vars_sint(h_sta,h_end,nil) + elsif t_var == "int" + get_vars_int(h_sta,h_end,nil) + elsif t_var == "sfloat" + get_vars_sfloat(h_sta,h_end,nil) + elsif t_var == "float" + get_vars_float(h_sta,h_end,nil) + else + raise NetcdfError, "variable type #{t_var} isn't supported in netCDF" + end + elsif endq == false && strq == true + h_str = hash["stride"] + if t_var == "char" + get_vars_char(h_sta,nil,h_str) + elsif t_var == "byte" + get_vars_byte(h_sta,nil,h_str) + elsif t_var == "sint" + get_vars_sint(h_sta,nil,h_str) + elsif t_var == "int" + get_vars_int(h_sta,nil,h_str) + elsif t_var == "sfloat" + get_vars_sfloat(h_sta,nil,h_str) + elsif t_var == "float" + get_vars_float(h_sta,nil,h_str) + else + raise NetcdfError, "variable type #{t_var} isn't supported in netCDF" + end + else endq == true && strq == true + h_end = hash["end"] + h_str = hash["stride"] + if t_var == "char" + get_vars_char(h_sta,h_end,h_str) + elsif t_var == "byte" + get_vars_byte(h_sta,h_end,h_str) + elsif t_var == "sint" + get_vars_sint(h_sta,h_end,h_str) + elsif t_var == "int" + get_vars_int(h_sta,h_end,h_str) + elsif t_var == "sfloat" + get_vars_sfloat(h_sta,h_end,h_str) + elsif t_var == "float" + get_vars_float(h_sta,h_end,h_str) + else + raise NetcdfError, "variable type #{t_var} isn't supported in netCDF" + end + end + else + raise ArgumentError,"{'start'}=>{ARRAY} or {'index'}=>{ARRAY} is needed" + end + end + + alias get simple_get + + def __rubber_expansion( args ) + if (id = args.index(false)) # substitution into id + # false is incuded + alen = args.length + if args.rindex(false) != id + raise ArguemntError,"only one rubber dimension is permitted" + elsif alen > rank+1 + raise ArgumentError, "too many args" + end + ar = ( id!=0 ? args[0..id-1] : [] ) + args = ar + [true]*(rank-alen+1) + args[id+1..-1] + elsif args.length == 0 # to support empty [], []= + args = [true]*rank + end + args + end + private :__rubber_expansion + + def [](*a) + if a.length == 0 + return self.get + end + a = __rubber_expansion(a) + first = Array.new + last = Array.new + stride = Array.new + set_stride = false + a.each{|i| + if(i.is_a?(Fixnum)) + first.push(i) + last.push(i) + stride.push(1) + elsif(i.is_a?(Range)) + first.push(i.first) + last.push(i.exclude_end? ? i.last-1 : i.last) + stride.push(1) + elsif(i.is_a?(Hash)) + r = (i.to_a[0])[0] + s = (i.to_a[0])[1] + if ( !( r.is_a?(Range) ) || ! ( s.is_a?(Integer) ) ) + raise TypeError, "Hash argument must be {a_Range, step}" + end + first.push(r.first) + last.push(r.exclude_end? ? r.last-1 : r.last) + stride.push(s) + set_stride = true + elsif(i.is_a?(TrueClass)) + first.push(0) + last.push(-1) + stride.push(1) + elsif( i.is_a?(Array) || i.is_a?(NArray)) + a_new = a.dup + at = a.index(i) + i = NArray.to_na(i) if i.is_a?(Array) + for n in 0..i.length-1 + a_new[at] = i[n]..i[n] + na_tmp = self[*a_new] + if n==0 then + k = at + if at > 0 + a[0..at-1].each{|x| if x.is_a?(Fixnum) then k -= 1 end} + end + shape_tmp = na_tmp.shape + shape_tmp[k] = i.length + na = na_tmp.class.new(na_tmp.typecode,*shape_tmp) + index_tmp = Array.new(shape_tmp.length,true) + end + index_tmp[k] = n..n + na[*index_tmp] = na_tmp + end + return na + else + raise TypeError, "argument must be Fixnum, Range, Hash, TrueClass, Array, or NArray" + end + } + + if(set_stride) + na = self.get({"start"=>first, "end"=>last, "stride"=>stride}) + else + na = self.get({"start"=>first, "end"=>last}) + end + shape = na.shape + (a.length-1).downto(0){ |i| + shape.delete_at(i) if a[i].is_a?(Fixnum) + } + na.reshape!( *shape ) + na + end + + def []=(*a) + val = a.pop + a = __rubber_expansion(a) + first = Array.new + last = Array.new + stride = Array.new + set_stride = false + a.each{|i| + if(i.is_a?(Fixnum)) + first.push(i) + last.push(i) + stride.push(1) + elsif(i.is_a?(Range)) + first.push(i.first) + last.push(i.exclude_end? ? i.last-1 : i.last) + stride.push(1) + elsif(i.is_a?(Hash)) + r = (i.to_a[0])[0] + s = (i.to_a[0])[1] + if ( !( r.is_a?(Range) ) || ! ( s.is_a?(Integer) ) ) + raise ArgumentError, "Hash argument must be {first..last, step}" + end + first.push(r.first) + last.push(r.exclude_end? ? r.last-1 : r.last) + stride.push(s) + set_stride = true + elsif(i.is_a?(TrueClass)) + first.push(0) + last.push(-1) + stride.push(1) + elsif(i.is_a?(Array) || i.is_a?(NArray)) + a_new = a.dup + at = a.index(i) + i = NArray.to_na(i) if i.is_a?(Array) + val = NArray.to_na(val) if val.is_a?(Array) + rank_of_subset = a.dup.delete_if{|v| v.is_a?(Fixnum)}.length + if val.rank != rank_of_subset + raise "rank of the rhs (#{val.rank}) is not equal to the rank "+ + "of the subset specified by #{a.inspect} (#{rank_of_subset})" + end + k = at + a[0..at-1].each{|x| if x.is_a?(Fixnum) then k -= 1 end} + if i.length != val.shape[k] + raise "length of the #{k+1}-th dim of rhs is incorrect "+ + "(#{i.length} for #{val.shape[k]})" + end + index_tmp = Array.new(val.rank,true) if !val.is_a?(Numeric) #==>Array-like + for n in 0..i.length-1 + a_new[at] = i[n]..i[n] + if !val.is_a?(Numeric) then + index_tmp[k] = n..n + self[*a_new] = val[*index_tmp] + else + self[*a_new] = val + end + end + return self + else + raise TypeError, "argument must be Fixnum, Range, Hash, TrueClass, Array, or NArray" + end + } + + if(set_stride) + self.put(val, {"start"=>first, "end"=>last, "stride"=>stride}) + else + self.put(val, {"start"=>first, "end"=>last}) + end + end + + def inspect + 'NetCDFVar:'+file.path+'?var='+name + end + + end + + class NetCDFAtt + + def put(val,atttype=nil) + putraw(val,atttype) + end + + def inspect + 'NetCDFAtt:'+name + end + end + + class NetCDFDim + def inspect + 'NetCDFDim:'+name + end + + def length_ul0 + if unlimited? + 0 + else + length + end + end + + end +end diff --git a/lib/numru/netcdf_miss.rb b/lib/numru/netcdf_miss.rb new file mode 100644 index 0000000..4b168f0 --- /dev/null +++ b/lib/numru/netcdf_miss.rb @@ -0,0 +1,203 @@ +require "numru/netcdf" +require "narray_miss" + +module NumRu + + class NetCDFVar + + def get_with_miss(*args) + __interpret_missing_params if !defined?(@missval) + data = simple_get(*args) + if @vmin || @vmax + if @vmin + mask = (data >= @vmin) + mask = mask.and(data <= @vmax) if @vmax + else + mask = (data <= @vmax) + end + data = NArrayMiss.to_nam(data, mask) + elsif @missval # only missing_value is present. + mask = (data.ne(@missval)) + data = NArrayMiss.to_nam(data, mask) + end + data + end + + def get_with_miss_and_scaling(*args) + __interpret_missing_params if !defined?(@missval) + data = simple_get(*args) + if @vmin || @vmax + if @vmin + mask = (data >= @vmin) + mask = mask.and(data <= @vmax) if @vmax + else + mask = (data <= @vmax) + end + data = NArrayMiss.to_nam(data, mask) + elsif @missval # only missing_value is present. + mask = (data.ne(@missval)) + data = NArrayMiss.to_nam(data, mask) + end + data = unpack( data ) + data + end + + def put_with_miss(data, *args) + if data.is_a?( NArrayMiss ) + __interpret_missing_params if !defined?(@missval) + if @missval + simple_put(data.to_na(@missval), *args) + else + simple_put(data.to_na, *args) + end + else + simple_put(data, *args) + end + end + + def put_with_miss_and_scaling(data, *args) + if data.is_a?( NArrayMiss ) + __interpret_missing_params if !defined?(@missval) + if @missval + data = pack( data ) + data = data.to_na(@missval) + else + data = pack( data ) + data = data.to_na + end + simple_put(data, *args) + else + scaled_put(data, *args) + end + end + + ######### private ########## + + def __interpret_missing_params + # Interprets the specification of missing data, + # either by valid_range, (valid_min and/or valid_max), or missing_value. + # (unlike the NetCDF User's guide (NUG), missing_value is interpreted, + # but valid_* has a higher precedence.) + # Always sets @missval whether missing_value is defined or not, + # since it will be used as a fill value for data missing. + # + @vmin = att('valid_min') + @vmin = @vmin.get if @vmin # kept in a NArray(size==1) to consv type + @vmax = att('valid_max') + @vmax = @vmax.get if @vmax # kept in a NArray(size==1) to consv type + vrange = att('valid_range') + vrange = vrange.get if vrange + if vrange + vrange.sort! + @vmin = vrange[0..0] # kept in... (same) + @vmax = vrange[-1..-1] # kept in... (same) + end + @missval = att('missing_value') || att('_FillValue') + @missval = @missval.get if @missval # kept in... (same) + + sf = att('scale_factor') + ao = att('add_offset') + if ( sf || ao ) + ## Both NUG & CF conventions requires to specify the valid + ## range with respect to the external (i.e. packed) values. + ## However, some conventions require specification + ## with respect to unpacked values. The following + ## is to support such cases as well: + thres_tp = [ self.typecode, NArray::LINT ].max + @missval = pack(@missval) if @missval && @missval.typecode > thres_tp + @vmin = pack(@vmin) if @vmin && @vmin.typecode > thres_tp + @vmax = pack(@vmax) if @vmax && @vmax.typecode > thres_tp + end + + if @missval + if @vmin && @vmax + if @vmin[0] <= @missval[0] && @missval[0] <= @vmax[0] + warn "WARNING: missing_value #{@missval[0]} is in the valid range #{@vmin[0]}..#{@vmax[0]} --> will be ignored (#{__FILE__}:#{__LINE__})" + end + else + if @vmin && @missval[0] >= @vmin[0] + warn "WARNING: missing_value #{@missval[0]} >= valid min #{@vmin[0]} --> will be ignored (#{__FILE__}:#{__LINE__})" + elsif @vmax && @missval[0] <= @vmax[0] + warn "WARNING: missing_value #{@missval[0]} <= valid min #{@vmin[0]} --> will be ignored (#{__FILE__}:#{__LINE__})" + end + end + else + realtc = NArray::SFLOAT + if @vmin + if @vmin[0] >= 0 + @missval = ( @vmin.typecode>=realtc ? 0.99*@vmin : @vmin-1 ) + else + @missval = ( @vmin.typecode>=realtc ? 1.01*@vmin : @vmin-1 ) + end + elsif @vmax + if @vmax[0] >= 0 + @missval = ( @vmax.typecode>=realtc ? 1.01*@vmax : @vmax+1 ) + else + @missval = ( @vmax.typecode>=realtc ? 0.99*@vmax : @vmax+1 ) + end + end + end + + end + + private :__interpret_missing_params + + end + +end + +if $0 == __FILE__ + include NumRu + + filename = "tmp.nc" + print "creating ",filename,"...\n" + file=NetCDF.create(filename) + nx = 10 + dimx = file.def_dim("x",nx) + xf = file.def_var("xf","sfloat",[dimx]) + xfn = file.def_var("xfn","sfloat",[dimx]) + xf.put_att("valid_range",[-1e12,1e12]) + f = 10 ** (2*NArray.sfloat(nx).indgen!) + xr = file.def_var("xr","sint",[dimx]) + xr.put_att("valid_max",[0.5]) + xr.put_att("scale_factor",1e-4) + xr.put_att("add_offset",0.5) + xr2 = file.def_var("xr2","sint",[dimx]) + xr2.put_att("valid_max",NArray.sint(1).fill!(1000)) + xr2.put_att("scale_factor",1e-4) + xr2.put_att("add_offset",0.5) + r = NArray.sfloat(nx).indgen!/nx + file.enddef + xf.put(f) + xfn.put(f) + xr.scaled_put(r) + file.close + + file = NetCDF.open(filename,'r+') + xf = file.var('xf') + xfn = file.var('xfn') + p "f0" + xf.get.each{|v| print "#{v} "} ; print "\n" + p( 'f1', nam = xf.get_with_miss ) + def xf.get(*args); get_with_miss(*args); end + p( 'f12', xf[2..-3].to_na ) + p( 'fn10', xfn.get_with_miss ) + p( 'fn11', xfn.get_with_miss_and_scaling ) + nam.invalidation([0,1]) + p 'f2', nam + xf.put_with_miss(nam) + p( 'f3', xf.get_with_miss ) + xr = file.var('xr') + p "r0" + xr.simple_get.each{|v| print "#{v} "} ; print "\n" + p( 'r1', xr.get_with_miss_and_scaling ) + def xr.get(*args); get_with_miss_and_scaling(*args); end + def xr.put(*args); put_with_miss_and_scaling(*args); end + #xr[0..3] = xr[0..3]*10 + p( 'r2', xr.get_with_miss_and_scaling ) + p 'r',r + xr2.put_with_miss_and_scaling(r) + p 'xr2',xr2.get_with_miss_and_scaling + file.close + print "** ncdump tmp.nc **\n", `ncdump tmp.nc` +end diff --git a/netcdfraw.c b/netcdfraw.c deleted file mode 100644 index 9922d19..0000000 --- a/netcdfraw.c +++ /dev/null @@ -1,4614 +0,0 @@ -#include -#include "ruby.h" -#include "narray.h" -#include -#include - -/* for compatibility with ruby 1.6 */ -#ifndef RSTRING_PTR -#define RSTRING_PTR(s) (RSTRING(s)->ptr) -#endif -#ifndef RSTRING_LEN -#define RSTRING_LEN(s) (RSTRING(s)->len) -#endif -#ifndef RARRAY_PTR -#define RARRAY_PTR(a) (RARRAY(a)->ptr) -#endif -#ifndef RARRAY_LEN -#define RARRAY_LEN(a) (RARRAY(a)->len) -#endif -#ifndef StringValueCStr -#define StringValueCStr(s) STR2CSTR(s) -#endif -#ifndef SafeStringValue -#define SafeStringValue(s) Check_SafeStr(s) -#endif - -/* Data to NArray */ - -/* memcpy(ary->ptr,nc_ptr,na_sizeof[NA_SINT]*ary->total); \ */ - -#define Cbyte_to_NArray(v, rank, shape, up) \ -{ \ - struct NARRAY *ary; \ - v = na_make_object(NA_BYTE, rank, shape, cNArray); \ - GetNArray(v,ary); \ - up = (unsigned char *)ary->ptr; \ -} - -#define Csint_to_NArray(v, rank, shape, sp) \ -{ \ - struct NARRAY *ary; \ - v = na_make_object(NA_SINT, rank, shape, cNArray); \ - GetNArray(v, ary); \ - sp = (short *)ary->ptr; \ -} - -#define Clint_to_NArray(v, rank, shape, lp) \ -{ \ - struct NARRAY *ary; \ - v = na_make_object(NA_LINT, rank, shape, cNArray); \ - GetNArray(v, ary); \ - lp = (int *)ary->ptr; \ -} -#define Cfloat_to_NArray(v, rank, shape, fp) \ -{ \ - struct NARRAY *ary; \ - v = na_make_object(NA_SFLOAT, rank, shape, cNArray); \ - GetNArray(v, ary); \ - fp = (float *)ary->ptr; \ -} -#define Cdouble_to_NArray(v, rank, shape, dp); \ -{ \ - struct NARRAY *ary; \ - v = na_make_object(NA_DFLOAT, rank, shape, cNArray); \ - GetNArray(v, ary); \ - dp = (double *)ary->ptr; \ -} - -/* Array or NArray to pointer and length (with no new allocation) */ - -#define Array_to_Cfloat_len(obj, ptr, len) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_SFLOAT); \ - GetNArray(obj, na); \ - ptr = (float *) NA_PTR(na,0); \ - len = na->total; \ -} - -#define Array_to_Cfloat_len_shape(obj, ptr, len, shape) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_SFLOAT); \ - GetNArray(obj, na); \ - ptr = (float *) NA_PTR(na,0); \ - len = na->total; \ - shape = na->shape; \ -} - -#define Array_to_Cdouble_len(obj, ptr, len) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_DFLOAT); \ - GetNArray(obj, na); \ - ptr = (double *) NA_PTR(na,0); \ - len = na->total; \ -} -#define Array_to_Cdouble_len_shape(obj, ptr, len, shape) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_DFLOAT); \ - GetNArray(obj, na); \ - ptr = (double *) NA_PTR(na,0); \ - len = na->total; \ - shape = na->shape; \ -} - -#define Array_to_Cbyte_len(obj, ptr, len) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_BYTE); \ - GetNArray(obj, na); \ - ptr = (u_int8_t *) NA_PTR(na,0); \ - len = na->total; \ -} - -#define Array_to_Cbyte_len_shape(obj, ptr, len, shape) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_BYTE); \ - GetNArray(obj, na); \ - ptr = (u_int8_t *) NA_PTR(na,0); \ - len = na->total; \ - shape = na->shape; \ -} - -#define Array_to_Csint_len(obj, ptr, len) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_SINT); \ - GetNArray(obj, na); \ - ptr = (int16_t *) NA_PTR(na,0); \ - len = na->total; \ -} - -#define Array_to_Csint_len_shape(obj, ptr, len, shape) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_SINT); \ - GetNArray(obj, na); \ - ptr = (int16_t *) NA_PTR(na,0); \ - len = na->total; \ - shape = na->shape; \ -} - - -#define Array_to_Clint_len(obj, ptr, len) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_LINT); \ - GetNArray(obj, na); \ - ptr = (int32_t *) NA_PTR(na,0); \ - len = na->total; \ -} - -#define Array_to_Clint_len_shape(obj, ptr, len, shape) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_LINT); \ - GetNArray(obj, na); \ - ptr = (int32_t *) NA_PTR(na,0); \ - len = na->total; \ - shape = na->shape; \ -} - - -/* Array or NArray to pointer (with no new allocation) */ - -#define Array_to_Cfloat(obj, ptr) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_SFLOAT); \ - GetNArray(obj, na); \ - ptr = (float *) NA_PTR(na,0); \ -} -#define Array_to_Cdouble(obj, ptr) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_DFLOAT); \ - GetNArray(obj, na); \ - ptr = (double *) NA_PTR(na,0); \ -} -#define Array_to_Cbyte(obj, ptr) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_BYTE); \ - GetNArray(obj, na); \ - ptr = (u_int8_t *) NA_PTR(na,0); \ -} -#define Array_to_Csint(obj, ptr) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_SINT); \ - GetNArray(obj, na); \ - ptr = (int16_t *) NA_PTR(na,0); \ -} -#define Array_to_Clint(obj, ptr) \ -{ \ - struct NARRAY *na; \ - obj = na_cast_object(obj, NA_LINT); \ - GetNArray(obj, na); \ - ptr = (int32_t *) NA_PTR(na,0); \ -} - -#define NC_RAISE(status) rb_raise(err_status2class(status),(nc_strerror(status))) -#define NC_RAISE2(status, str) rb_raise(err_status2class(status),"%s (%s)",nc_strerror(status),(str) ) - -static VALUE mNumRu = 0; -static VALUE cNetCDF; -static VALUE cNetCDFDim; -static VALUE cNetCDFAtt; -static VALUE cNetCDFVar; - -static VALUE rb_eNetcdfError; -static VALUE rb_eNetcdfBadid; -static VALUE rb_eNetcdfNfile; -static VALUE rb_eNetcdfExist; -static VALUE rb_eNetcdfInval; -static VALUE rb_eNetcdfPerm; -static VALUE rb_eNetcdfNotindefine; -static VALUE rb_eNetcdfIndefine; -static VALUE rb_eNetcdfInvalcoords; -static VALUE rb_eNetcdfMaxdims; -static VALUE rb_eNetcdfNameinuse; -static VALUE rb_eNetcdfNotatt; -static VALUE rb_eNetcdfMaxatts; -static VALUE rb_eNetcdfBadtype; -static VALUE rb_eNetcdfBaddim; -static VALUE rb_eNetcdfUnlimpos; -static VALUE rb_eNetcdfMaxvars; -static VALUE rb_eNetcdfNotvar; -static VALUE rb_eNetcdfGlobal; -static VALUE rb_eNetcdfNotnc; -static VALUE rb_eNetcdfSts; -static VALUE rb_eNetcdfMaxname; -static VALUE rb_eNetcdfUnlimit; -static VALUE rb_eNetcdfNorecvars; -static VALUE rb_eNetcdfChar; -static VALUE rb_eNetcdfEdge; -static VALUE rb_eNetcdfStride; -static VALUE rb_eNetcdfBadname; -static VALUE rb_eNetcdfRange; -static VALUE rb_eNetcdfNomem; - -/* Special Error */ -/* Global error status */ - -static VALUE rb_eNetcdfFatal; - -/* Global options variable. Used to determine behavior of error handler. */ - -static VALUE rb_eNetcdfEntool; -static VALUE rb_eNetcdfExdr; -static VALUE rb_eNetcdfSyserr; - - -struct Netcdf{ - int ncid; - char *name; - int closed; -}; - -struct NetCDFDim{ - int dimid; - int ncid; -}; - -struct NetCDFVar{ - int varid; - int ncid; - VALUE file; -}; - -struct NetCDFAtt{ - int varid; - int ncid; - char *name; -}; - -static struct Netcdf * -NetCDF_init(int ncid,char *filename) -{ - struct Netcdf *Netcdffile; - Netcdffile=xmalloc(sizeof(struct Netcdf)); - Netcdffile->ncid=ncid; - Netcdffile->closed=0; - Netcdffile->name=xmalloc((strlen(filename)+1)*sizeof(char)); - strcpy(Netcdffile->name,filename); - return(Netcdffile); -} - -static struct NetCDFDim * -NetCDF_dim_init(int ncid,int dimid) -{ - struct NetCDFDim *Netcdf_dim; - Netcdf_dim=xmalloc(sizeof(struct NetCDFDim)); - Netcdf_dim->dimid=dimid; - Netcdf_dim->ncid=ncid; - return(Netcdf_dim); -} - -static struct NetCDFVar * -NetCDF_var_init(int ncid,int varid,VALUE file) -{ - struct NetCDFVar *Netcdf_var; - Netcdf_var=xmalloc(sizeof(struct NetCDFVar)); - Netcdf_var->varid=varid; - Netcdf_var->ncid=ncid; - Netcdf_var->file=file; - return(Netcdf_var); -} -static struct NetCDFAtt * -NetCDF_att_init(int ncid,int varid,char *attname) -{ - struct NetCDFAtt *Netcdf_att; - Netcdf_att=xmalloc(sizeof(struct NetCDFAtt)); - Netcdf_att->ncid=ncid; - Netcdf_att->varid=varid; - Netcdf_att->name=xmalloc((strlen(attname)+1)*sizeof(char)); - strcpy(Netcdf_att->name,attname); - return(Netcdf_att); -} - -void -Netcdf_att_free(struct NetCDFAtt *Netcdf_att) -{ - free(Netcdf_att->name); - free(Netcdf_att); -} - -void -NetCDF_var_free(struct NetCDFVar *Netcdf_var) -{ - free(Netcdf_var); -} - -void -NetCDF_dim_free(struct NetCDFDim *Netcdf_dim) -{ - free(Netcdf_dim); -} - -void -NetCDF_free(struct Netcdf *Netcdffile) -{ - int status; - if (!Netcdffile->closed){ - status = nc_close(Netcdffile->ncid); /* no error check -- not to stop during GC */ - } - free(Netcdffile->name); - free(Netcdffile); -} - -static VALUE -err_status2class(int status) -{ - if(NC_ISSYSERR(status)){ - return(rb_eNetcdfSyserr); - } - switch(status) - { - case(NC_EBADID): - return(rb_eNetcdfBadid);break; - case(NC_ENFILE): - return(rb_eNetcdfNfile);break; - case(NC_EEXIST): - return(rb_eNetcdfExist);break; - case(NC_EINVAL): - return(rb_eNetcdfInval);break; - case(NC_EPERM): - return(rb_eNetcdfPerm);break; - case(NC_ENOTINDEFINE): - return(rb_eNetcdfNotindefine);break; - case(NC_EINDEFINE): - return(rb_eNetcdfIndefine);break; - case(NC_EINVALCOORDS): - return(rb_eNetcdfInvalcoords);break; - case(NC_EMAXDIMS): - return(rb_eNetcdfMaxdims);break; - case(NC_ENAMEINUSE): - return(rb_eNetcdfNameinuse);break; - case(NC_ENOTATT): - return(rb_eNetcdfNotatt);break; - case(NC_EMAXATTS): - return(rb_eNetcdfMaxatts);break; - case(NC_EBADTYPE): - return(rb_eNetcdfBadtype);break; - case(NC_EBADDIM): - return(rb_eNetcdfBaddim);break; - case(NC_EUNLIMPOS): - return(rb_eNetcdfUnlimpos);break; - case(NC_EMAXVARS): - return(rb_eNetcdfMaxvars);break; - case(NC_ENOTVAR): - return(rb_eNetcdfNotvar);break; - case(NC_EGLOBAL): - return(rb_eNetcdfGlobal);break; - case(NC_ENOTNC): - return(rb_eNetcdfNotnc);break; - case(NC_ESTS): - return(rb_eNetcdfSts);break; - case(NC_EMAXNAME): - return(rb_eNetcdfMaxname);break; - case(NC_EUNLIMIT): - return(rb_eNetcdfUnlimit);break; - case(NC_ENORECVARS): - return(rb_eNetcdfNorecvars);break; - case(NC_ECHAR): - return(rb_eNetcdfChar);break; - case(NC_EEDGE): - return(rb_eNetcdfEdge);break; - case(NC_ESTRIDE): - return(rb_eNetcdfStride);break; - case(NC_EBADNAME): - return(rb_eNetcdfBadname);break; - case(NC_ERANGE): - return(rb_eNetcdfRange);break; - case(NC_ENOMEM): - return(rb_eNetcdfNomem);break; - /* case(NC_ENTOOL): - return(rb_eNetcdfEntool);break; */ - case(NC_EXDR): - return(rb_eNetcdfExdr);break; - case(NC_SYSERR): - return(rb_eNetcdfSyserr);break; - case(NC_FATAL): - return(rb_eNetcdfFatal);break; - } -} - -static const char* -nctype2natype(int nctype){ - switch(nctype){ - case NC_CHAR: - return("char"); - case NC_BYTE: - return("byte"); - case NC_SHORT: - return("sint"); - case NC_INT: - return("int"); - case NC_FLOAT: - return("sfloat"); - case NC_DOUBLE: - return("float"); - default: - rb_raise(rb_eNetcdfError, "No such netcdf type number %d\n",nctype); - } -} - -static int -nctype2natypecode(int nctype){ - switch(nctype){ - case NC_CHAR: - return(NA_BYTE); - case NC_BYTE: - return(NA_BYTE); - case NC_SHORT: - return(NA_SINT); - case NC_INT: - return(NA_LINT); - case NC_FLOAT: - return(NA_SFLOAT); - case NC_DOUBLE: - return(NA_DFLOAT); - default: - rb_raise(rb_eNetcdfError, "No such netcdf type number %d\n",nctype); - } -} - -static int -natype2nctype(char *natype) -{ - if(strcmp(natype,"byte")==0) return(NC_BYTE); - else if(strcmp(natype,"char")==0) return(NC_CHAR); - else if(strcmp(natype,"text")==0) return(NC_CHAR); /* alias of char */ - else if(strcmp(natype,"string")==0) return(NC_CHAR); /* alias of char */ - else if(strcmp(natype,"sint")==0) return(NC_SHORT); - else if(strcmp(natype,"int")==0) return(NC_INT); - else if(strcmp(natype,"sfloat")==0) return(NC_FLOAT); - else if(strcmp(natype,"float")==0) return(NC_DOUBLE); - else rb_raise(rb_eNetcdfError, "No such NArray type '%s'",natype); -} - -static int -natypecode2nctype(int natypecode) -{ - if(natypecode==NA_BYTE) return(NC_BYTE); - else if(natypecode==NA_SINT) return(NC_SHORT); - else if(natypecode==NA_LINT) return(NC_INT); - else if(natypecode==NA_SFLOAT) return(NC_FLOAT); - else if(natypecode==NA_DFLOAT) return(NC_DOUBLE); - else rb_raise(rb_eNetcdfError, "No such NArray typecode '%d'",natypecode); -} - -static void -nc_mark_obj(struct NetCDFVar *netcdf_var) -{ - VALUE ptr; - - ptr = netcdf_var->file; - rb_gc_mark(ptr); -} - - -VALUE -NetCDF_clone(VALUE file) -{ - VALUE clone; - struct Netcdf *nc1, *nc2; - - Data_Get_Struct(file, struct Netcdf, nc1); - nc2 = NetCDF_init(nc1->ncid, nc1->name); - clone = Data_Wrap_Struct(cNetCDF, 0, NetCDF_free, nc2); - CLONESETUP(clone, file); - return clone; -} - -VALUE -NetCDF_dim_clone(VALUE dim) -{ - VALUE clone; - struct NetCDFDim *nd1, *nd2; - - Data_Get_Struct(dim, struct NetCDFDim, nd1); - nd2 = NetCDF_dim_init(nd1->ncid, nd1->dimid); - clone = Data_Wrap_Struct(cNetCDFDim, 0, NetCDF_dim_free, nd2); - CLONESETUP(clone, dim); - return clone; -} - -VALUE -NetCDF_att_clone(VALUE att) -{ - VALUE clone; - struct NetCDFAtt *na1, *na2; - - Data_Get_Struct(att, struct NetCDFAtt, na1); - na2 = NetCDF_att_init(na1->ncid, na1->varid, na1->name); - clone = Data_Wrap_Struct(cNetCDFAtt, 0, Netcdf_att_free, na2); - CLONESETUP(clone, att); - return clone; -} - -VALUE -NetCDF_var_clone(VALUE var) -{ - VALUE clone; - struct NetCDFVar *nv1, *nv2; - - Data_Get_Struct(var, struct NetCDFVar, nv1); - nv2 = NetCDF_var_init(nv1->ncid, nv1->varid, nv1->file); - clone = Data_Wrap_Struct(cNetCDFVar, nc_mark_obj, NetCDF_var_free, nv2); - CLONESETUP(clone, var); - return clone; -} - -VALUE -NetCDF_close(file) - VALUE file; -{ - int status; - int ncid; - struct Netcdf *Netcdffile; - - if (rb_safe_level() >= 4 && !OBJ_TAINTED(file)) { - rb_raise(rb_eSecurityError, "Insecure: can't close"); - } - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid=Netcdffile->ncid; - if(!Netcdffile->closed){ - status = nc_close(ncid); - if(status != NC_NOERR) NC_RAISE(status); - Netcdffile->closed = 1; - } else { - rb_warn("file %s is already closed", Netcdffile->name); - } - return Qnil; -} - -VALUE -NetCDF_def_dim(VALUE file,VALUE dim_name,VALUE length) -{ - char* c_dim_name; - size_t c_length; - int ncid; - int dimidp; - int status; - struct Netcdf *Netcdffile; - struct NetCDFDim *Netcdf_dim; - VALUE Dimension; - - rb_secure(4); - Data_Get_Struct(file,struct Netcdf,Netcdffile); - - Check_Type(dim_name,T_STRING); - c_dim_name=RSTRING_PTR(dim_name); - c_length=NUM2UINT(length); - ncid=Netcdffile->ncid; - - status = nc_def_dim(ncid,c_dim_name,c_length,&dimidp); - if(status !=NC_NOERR) NC_RAISE(status); - - Netcdf_dim = NetCDF_dim_init(ncid,dimidp); - - Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); - return Dimension; -} - - -static VALUE -NetCDF_put_att_char(int ncid, char *name,VALUE value,VALUE atttype, int varid) -{ - int status; - struct NetCDFAtt *ncatt; - - /* check atttype (not necessarily needed but it's better to do it) */ - if (TYPE(atttype) == T_STRING){ - if ( natype2nctype(RSTRING_PTR(atttype)) != NC_CHAR ) { - rb_raise(rb_eNetcdfError, - "attribute type must be 'char' (or nil) for a String value"); - } - } else if (TYPE(atttype) != T_NIL) { - rb_raise(rb_eNetcdfError, - "type specfication must be by a string or nil"); - } - /* put value */ - Check_Type(value,T_STRING); - status = nc_put_att_text(ncid, varid, name, - RSTRING_LEN(value), RSTRING_PTR(value)); - if(status != NC_NOERR) NC_RAISE(status); - - ncatt = NetCDF_att_init(ncid,varid,name); - return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,ncatt)); -} - -static VALUE -NetCDF_put_att_numeric(int ncid, char *name,VALUE value,VALUE atttype, int varid) -{ - VALUE val; - struct NARRAY *na_val; - int na_typecode, status, len; - char *ptr; - struct NetCDFAtt *ncatt; - - /* check atttype and cast to an appropriate NArray if needed */ - - if (TYPE(atttype) != T_NIL){ - na_typecode = na_get_typecode(atttype); - GetNArray( na_cast_object(value, na_typecode), na_val ); - } else { - if (TYPE(value)==T_ARRAY) { - val = RARRAY_PTR(value)[0]; /* to check the 1st elemnt if Array */ - } else { - val = value; - } - switch(TYPE(val)){ - case T_FIXNUM: - case T_BIGNUM: - na_typecode = NA_LINT; - GetNArray( na_cast_object(value, na_typecode), na_val ); - break; - case T_FLOAT: - na_typecode = NA_DFLOAT; - GetNArray( na_cast_object(value, na_typecode), na_val ); - break; - case T_DATA: - if ( IsNArray(value) ){ - GetNArray(value,na_val); - na_typecode = na_val->type; - } else { - rb_raise(rb_eNetcdfError,"value has a wrong data type"); - } - break; - default: - rb_raise(rb_eNetcdfError, - "value (or its first element) has a wrong type"); - } - } - - /* put value */ - - len = na_val->total; - ptr = na_val->ptr; - switch(na_typecode){ - case NA_BYTE: - status = nc_put_att_uchar(ncid,varid,name,NC_BYTE,len,(unsigned char *)ptr); - break; - case NA_SINT: - status = nc_put_att_short(ncid,varid,name,NC_SHORT,len,(short *)ptr); - break; - case NA_LINT: - status = nc_put_att_int(ncid,varid,name,NC_INT,len,(int *)ptr); - break; - case NA_SFLOAT: - status = nc_put_att_float(ncid,varid,name,NC_FLOAT,len,(float *)ptr); - break; - case NA_DFLOAT: - status = nc_put_att_double(ncid,varid,name,NC_DOUBLE,len,(double*)ptr); - break; - default: - rb_raise(rb_eNetcdfError, - "unsupported type. code = %d",na_typecode); - } - if(status != NC_NOERR) NC_RAISE(status); - - ncatt = NetCDF_att_init(ncid,varid,name); - return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,ncatt)); -} - -static VALUE -NetCDF_put_att__(int ncid, char *name, VALUE value, VALUE atttype, int varid) - /* - * atttype: nil or a String ("string","int",etc). If nil, - * the type of attribute is determined from the type of value - */ -{ - switch(TYPE(value)){ - case T_STRING: - return(NetCDF_put_att_char(ncid, name, value, atttype, varid)); - default: - return(NetCDF_put_att_numeric(ncid, name, value, atttype, varid)); - } -} - -VALUE -NetCDF_put_att(VALUE file,VALUE att_name,VALUE value,VALUE atttype) - /* - * atttype: nil or a String ("string","int",etc). If nil, - * the type of attribute is determined from the type of value - */ -{ - struct Netcdf *ncfile; - char *name; - - rb_secure(4); - Data_Get_Struct(file,struct Netcdf,ncfile); - Check_Type(att_name,T_STRING); - name = RSTRING_PTR(att_name); - - return( NetCDF_put_att__(ncfile->ncid, name, value, atttype, NC_GLOBAL) ); -} - -VALUE -NetCDF_put_att_var(VALUE var,VALUE att_name,VALUE value,VALUE atttype) - /* - * atttype: nil or a String ("string","int",etc). If nil, - * the type of attribute is determined from the type of value - */ -{ - struct NetCDFVar *ncvar; - char *name; - - rb_secure(4); - Data_Get_Struct(var,struct NetCDFVar,ncvar); - Check_Type(att_name,T_STRING); - name = RSTRING_PTR(att_name); - - return( NetCDF_put_att__(ncvar->ncid, name, value, atttype, ncvar->varid)); -} - - -VALUE -NetCDF_def_var(VALUE file,VALUE var_name,VALUE vartype,VALUE dimensions) -{ - int ncid; - char *c_var_name; - static int xtype; - long c_ndims; - int varidp; - int dimidp; - int i=0; - int status; - char *c_dim_name; - int c_dimids[NC_MAX_DIMS]; - struct Netcdf *Netcdffile; - struct NetCDFVar *Netcdf_var; - struct NetCDFDim *Netcdf_dim; - VALUE Var; - - rb_secure(4); - Check_Type(var_name,T_STRING); - Check_Type(dimensions,T_ARRAY); - - c_var_name=RSTRING_PTR(var_name); - c_ndims=RARRAY_LEN(dimensions); - - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid=Netcdffile->ncid; - - if (TYPE(vartype) == T_STRING){ - xtype = natype2nctype(RSTRING_PTR(vartype)); - } else if (TYPE(vartype) == T_FIXNUM){ - xtype = natypecode2nctype(NUM2INT(vartype)); - } else { - rb_raise(rb_eNetcdfError, - "type specfication must be by a string or nil"); - } - - for(i=0;idimid; - break; - default: - rb_raise(rb_eNetcdfError, "No such object of the netCDF dimension class."); - } - } - - status = nc_def_var(ncid,c_var_name,xtype,c_ndims,c_dimids,&varidp); - if(status != NC_NOERR) NC_RAISE(status); - - Netcdf_var = NetCDF_var_init(ncid,varidp,file); - - Var=Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var); - return Var; -} - - -VALUE -NetCDF_dim(VALUE file,VALUE dim_name) -{ - int ncid; - char *c_dim_name; - int dimidp; - int status; - struct Netcdf *Netcdffile; - struct NetCDFDim *Netcdf_dim; - VALUE Dimension; - - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid=Netcdffile->ncid; - Check_Type(dim_name,T_STRING); - c_dim_name=RSTRING_PTR(dim_name); - - status = nc_inq_dimid(ncid,c_dim_name,&dimidp); - if(status !=NC_NOERR){ - if(status == NC_EBADDIM){ - return(Qnil); /*2003/08/27 back to orig (from changes on 2003/02/03)*/ - } else{ - NC_RAISE(status); - } - } - - Netcdf_dim=NetCDF_dim_init(ncid,dimidp); - - Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); - return Dimension; -} - -VALUE -NetCDF_var(VALUE file,VALUE var_name) -{ - int ncid; - int status; - int varidp; - char *c_var_name; - struct Netcdf *Netcdffile; - struct NetCDFVar *Netcdf_var; - VALUE Variable; - - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid=Netcdffile->ncid; - Check_Type(var_name,T_STRING); - c_var_name=RSTRING_PTR(var_name); - - status=nc_inq_varid(ncid,c_var_name,&varidp); - if(status != NC_NOERR){ - if(status == NC_ENOTVAR){ - return(Qnil); /*2003/08/27 back to orig (from changes on 2003/02/03)*/ - } else{ - NC_RAISE(status); - } - } - - Netcdf_var = NetCDF_var_init(ncid,varidp,file); - Variable = Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var); - return Variable; -} - -VALUE -NetCDF_att(VALUE file,VALUE att_name) -{ - int ncid; - int status; - int attnump; - char *c_att_name; - struct Netcdf *Netcdffile; - struct NetCDFAtt *Netcdf_att; - VALUE Attribute; - - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid=Netcdffile->ncid; - Check_Type(att_name,T_STRING); - c_att_name=RSTRING_PTR(att_name); - - - status = nc_inq_attid(ncid,NC_GLOBAL,c_att_name,&attnump); - if(status != NC_NOERR){ - if(status == NC_ENOTATT){ - return(Qnil); - } - else{ - NC_RAISE(status); - } - } - - Netcdf_att = NetCDF_att_init(ncid,NC_GLOBAL,c_att_name); - - Attribute = Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att); - - return Attribute; -} -VALUE -NetCDF_fill(VALUE file,VALUE mode) -{ - int ncid; - int status; - struct Netcdf *Netcdffile; - int old_modep; - - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid = Netcdffile->ncid; - if(mode==Qfalse){ - status = nc_set_fill(ncid,NC_NOFILL,&old_modep); - if(status != NC_NOERR) NC_RAISE(status); - } - else if(mode == Qtrue){ - status = nc_set_fill(ncid,NC_FILL,&old_modep); - if(status != NC_NOERR) NC_RAISE(status); - } - else - rb_raise(rb_eNetcdfError,"Usage:self.fill(true) or self.fill(false)"); - return Qnil; -} - -VALUE -NetCDF_redef(VALUE file) -{ - int ncid; - int status; - struct Netcdf *Netcdffile; - - rb_secure(4); - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid=Netcdffile->ncid; - status = nc_redef(ncid); - if(status !=NC_NOERR){ - if(status == NC_EINDEFINE){ - return Qnil; - } - else{ - NC_RAISE(status); - } - } - return Qtrue; -} - -VALUE -NetCDF_enddef(VALUE file) -{ - int ncid; - int status; - struct Netcdf *Netcdffile; - - rb_secure(4); - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid=Netcdffile->ncid; - status = nc_enddef(ncid); - if(status !=NC_NOERR){ - if(status == NC_ENOTINDEFINE){ - return Qnil; - } - else{ - NC_RAISE(status); - } - } - return Qtrue; -} - -VALUE -NetCDF_whether_in_define_mode(VALUE file) -{ - /* returns true if the NetCDF object is currently in the define mode, - false if in the data mode, and - nil if else (possibly the file is read-only, or some other - error occurred) - */ - int ncid; - int status; - struct Netcdf *Netcdffile; - - rb_secure(4); - Data_Get_Struct(file,struct Netcdf,Netcdffile); - ncid=Netcdffile->ncid; - status = nc_redef(ncid); - if(status == NC_EINDEFINE){ - return Qtrue; - } else if(status == NC_NOERR) { - /* was in the data mode --> recover the data mode and report false */ - status = nc_enddef(ncid); - if(status == NC_NOERR) { - return Qfalse; - } else { - return Qnil; - } - } else { - return Qnil; - } -} - -VALUE -NetCDF_open(VALUE mod,VALUE filename,VALUE omode) -{ - int status; - int ncid; - char* c_filename; - int c_omode; - struct Netcdf *ncfile; - VALUE retval; - - Check_Type(filename,T_STRING); - SafeStringValue(filename); - c_filename=RSTRING_PTR(filename); - Check_Type(omode,T_FIXNUM); - c_omode=NUM2INT(omode); - - status = nc_open(c_filename,c_omode,&ncid); - if(status !=NC_NOERR){NC_RAISE2(status,c_filename);} - - ncfile = NetCDF_init(ncid,c_filename); - retval = Data_Wrap_Struct(cNetCDF,0,NetCDF_free,ncfile); - return( retval ); -} - -VALUE -NetCDF_create(VALUE mod,VALUE filename,VALUE cmode) -{ - int ncid; - int status; - char* c_filename; - int c_cmode; - struct Netcdf *ncfile; - - Check_Type(filename,T_STRING); - SafeStringValue(filename); - c_filename=RSTRING_PTR(filename); - Check_Type(cmode,T_FIXNUM); - c_cmode=NUM2INT(cmode); - - status = nc_create(c_filename,c_cmode,&ncid); - if(status != NC_NOERR) NC_RAISE2(status, c_filename); - - ncfile = NetCDF_init(ncid,c_filename); - return( Data_Wrap_Struct(cNetCDF,0,NetCDF_free,ncfile) ); -} - -VALUE -NetCDF_ndims(VALUE file) -{ - int ncid; - int ndimsp; - VALUE Integer; - int status; - struct Netcdf *ncfile; - - Data_Get_Struct(file,struct Netcdf,ncfile); - ncid=ncfile->ncid; - status = nc_inq_ndims(ncid,&ndimsp); - if(status != NC_NOERR) NC_RAISE (status); - Integer = INT2NUM(ndimsp); - return Integer; -} - -VALUE -NetCDF_nvars(VALUE file) -{ - int ncid; - int nvarsp; - int status; - VALUE Integer; - struct Netcdf *ncfile; - Data_Get_Struct(file,struct Netcdf,ncfile); - ncid=ncfile->ncid; - status = nc_inq_nvars(ncid,&nvarsp); - if(status != NC_NOERR) NC_RAISE (status); - Integer = INT2NUM(nvarsp); - return Integer; -} - -VALUE -NetCDF_natts(VALUE file) -{ - int ncid; - int nattsp; - int status; - VALUE Integer; - struct Netcdf *ncfile; - - Data_Get_Struct(file,struct Netcdf,ncfile); - ncid=ncfile->ncid; - status=nc_inq_natts(ncid,&nattsp); - if(status != NC_NOERR) NC_RAISE (status); - Integer = INT2NUM(nattsp); - return Integer; -} - -VALUE -NetCDF_unlimited(VALUE file) -{ - int ncid; - int unlimdimidp; - int status; - struct Netcdf *ncfile; - struct NetCDFDim *Netcdf_dim; - VALUE Dimension; - - Data_Get_Struct(file,struct Netcdf,ncfile); - ncid=ncfile->ncid; - status=nc_inq_unlimdim(ncid,&unlimdimidp); - if(status !=NC_NOERR) NC_RAISE(status); - - Netcdf_dim = NetCDF_dim_init(ncid,unlimdimidp); - - /* If unlimdimidp=-1,No unlimited dimension is defined in the netCDF dataset */ - if(unlimdimidp != -1) - { - Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); - return Dimension; - } - else - { - return Qnil; - } -} - -VALUE -NetCDF_sync(VALUE file) -{ - int ncid; - int status; - struct Netcdf *ncfile; - - rb_secure(4); - Data_Get_Struct(file,struct Netcdf,ncfile); - ncid=ncfile->ncid; - status = nc_sync(ncid); - if(status !=NC_NOERR) NC_RAISE (status); - return Qnil; -} - -VALUE -NetCDF_path(VALUE file) -{ - char *path; - struct Netcdf *ncfile; - - Data_Get_Struct(file,struct Netcdf,ncfile); - path=ncfile->name; - return(rb_str_new2(path)); -} - -VALUE -NetCDF_dim_length(VALUE Dim) -{ - int ncid; - int status; - int dimid; - size_t lengthp; - struct NetCDFDim *Netcdf_dim; - - Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim); - ncid=Netcdf_dim->ncid; - dimid=Netcdf_dim->dimid; - - status = nc_inq_dimlen(ncid,dimid,&lengthp); - if(status != NC_NOERR) NC_RAISE(status); - - return(INT2NUM(lengthp)); -} - -VALUE -NetCDF_dim_name(VALUE Dim,VALUE dimension_newname) -{ - int ncid; - int status; - int dimid; - char *c_dim_name; - struct NetCDFDim *Netcdf_dim; - - rb_secure(4); - Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim); - ncid=Netcdf_dim->ncid; - dimid=Netcdf_dim->dimid; - Check_Type(dimension_newname,T_STRING); - c_dim_name = StringValueCStr(dimension_newname); - - status = nc_rename_dim(ncid,dimid,c_dim_name); - if(status !=NC_NOERR) NC_RAISE(status); - - return Qnil; -} - -VALUE -NetCDF_dim_inqname(VALUE Dim) -{ - int ncid; - int status; - int dimid; - char c_dim_name[NC_MAX_NAME]; - struct NetCDFDim *Netcdf_dim; - VALUE str; - - Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim); - ncid=Netcdf_dim->ncid; - dimid=Netcdf_dim->dimid; - - status = nc_inq_dimname(ncid,dimid,c_dim_name); - if(status !=NC_NOERR) NC_RAISE(status); - - str = rb_str_new2(c_dim_name); - OBJ_TAINT(str); - return(str); -} - -VALUE -NetCDF_dim_whether_unlimited(VALUE Dim) -{ - int status; - int uldid; - struct NetCDFDim *Netcdf_dim; - - Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim); - status=nc_inq_unlimdim(Netcdf_dim->ncid,&uldid); - if(status !=NC_NOERR) NC_RAISE(status); - if(Netcdf_dim->dimid == uldid){ - return(Qtrue); - } else { - return(Qfalse); - } -} - -VALUE -NetCDF_att_inq_name(VALUE Att) -{ - char *c_att_name; - struct NetCDFAtt *Netcdf_att; - VALUE str; - - Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); - c_att_name=Netcdf_att->name; - - str = rb_str_new2(c_att_name); - OBJ_TAINT(str); - return(str); -} - -VALUE -NetCDF_att_rename(VALUE Att,VALUE new_att_name) -{ - int ncid; - int status; - int varid; - char *c_att_name; - char *c_new_att_name; - struct NetCDFAtt *Netcdf_att; - Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); - ncid=Netcdf_att->ncid; - varid=Netcdf_att->varid; - - c_att_name=Netcdf_att->name; - - Check_Type(new_att_name,T_STRING); - SafeStringValue(new_att_name); - c_new_att_name=StringValueCStr(new_att_name); - - status = nc_rename_att(ncid,varid,c_att_name,c_new_att_name); - if(status != NC_NOERR) NC_RAISE(status); - - strcpy(Netcdf_att->name,c_new_att_name); - return Qnil; -} - -VALUE -NetCDF_id2dim(VALUE file,VALUE dimid) -{ - int ncid; - int c_dimid; - struct Netcdf *ncfile; - struct NetCDFDim *Netcdf_dim; - VALUE Dim; - - Data_Get_Struct(file,struct Netcdf,ncfile); - ncid=ncfile->ncid; - Check_Type(dimid,T_FIXNUM); - c_dimid=NUM2INT(dimid); - Netcdf_dim = NetCDF_dim_init(ncid,c_dimid); - Dim=Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); - return(Dim); -} - -VALUE -NetCDF_id2var(VALUE file,VALUE varid) -{ - int ncid; - int c_varid; - struct Netcdf *ncfile; - struct NetCDFVar *Netcdf_var; - VALUE Var; - - Data_Get_Struct(file,struct Netcdf,ncfile); - ncid=ncfile->ncid; - Check_Type(varid,T_FIXNUM); - c_varid=NUM2INT(varid); - Netcdf_var = NetCDF_var_init(ncid,c_varid,file); - Var=Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var); - return(Var); -} - - -VALUE -NetCDF_id2att(VALUE file,VALUE attnum) -{ - int ncid; - int c_attnum; - int status; - struct Netcdf *ncfile; - struct NetCDFAtt *Netcdf_att; - char *c_att_name; - VALUE Att; - c_att_name=ALLOCA_N(char,NC_MAX_NAME); - - Data_Get_Struct(file,struct Netcdf,ncfile); - ncid=ncfile->ncid; - - Check_Type(attnum,T_FIXNUM); - c_attnum=NUM2INT(attnum); - - status = nc_inq_attname(ncid,NC_GLOBAL,c_attnum,c_att_name); - if(status != NC_NOERR) NC_RAISE(status); - - Netcdf_att=NetCDF_att_init(ncid,NC_GLOBAL,c_att_name); - - Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att); - return(Att); - -} - -VALUE -NetCDF_var_id2att(VALUE Var,VALUE attnum) -{ - int ncid; - int c_attnum; - int status; - int c_varid; - struct NetCDFVar *Netcdf_var; - struct NetCDFAtt *Netcdf_att; - char *c_att_name; - VALUE Att; - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - ncid=Netcdf_var->ncid; - c_varid=Netcdf_var->varid; - - Check_Type(attnum,T_FIXNUM); - c_attnum=NUM2INT(attnum); - - c_att_name=ALLOCA_N(char,NC_MAX_NAME); - - status = nc_inq_attname(ncid,c_varid,c_attnum,c_att_name); - if(status != NC_NOERR) NC_RAISE(status); - - Netcdf_att=NetCDF_att_init(ncid,c_varid,c_att_name); - Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att); - return(Att); -} - -VALUE -NetCDF_var_dims(VALUE Var) -{ - int ncid, *dimids, ndims, varid, i, status; - struct NetCDFVar *Netcdf_var; - struct NetCDFDim *Netcdf_dim; - VALUE Dims; - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - ncid = Netcdf_var->ncid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - dimids=ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - Dims = rb_ary_new(); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - if(c_ith < 0 || c_ith >= ndims) { - rb_raise(rb_eNetcdfError, "dimension count less than zero or greater than ndims-1"); - } - dimids=ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - Netcdf_dim = NetCDF_dim_init(ncid,dimids[ndims-1-c_ith]); - Dim = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim); - return(Dim); -} - -VALUE -NetCDF_att_copy(VALUE Att,VALUE Var_or_File) -{ - int ncid_in,ncid_out; - int status; - int varid_in,varid_out; - char *att_name; - struct NetCDFAtt *Netcdf_att; - struct NetCDFVar *Netcdf_var; - struct Netcdf *ncfile; - struct NetCDFAtt *Netcdf_att_out; - - rb_secure(4); - Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); - ncid_in=Netcdf_att->ncid; - varid_in=Netcdf_att->varid; - att_name=Netcdf_att->name; - - if( rb_obj_is_kind_of(Var_or_File, cNetCDFVar) ){ - Data_Get_Struct(Var_or_File,struct NetCDFVar, Netcdf_var); - ncid_out=Netcdf_var->ncid; - varid_out=Netcdf_var->varid; - } else if ( rb_obj_is_kind_of(Var_or_File, cNetCDF) ){ - Data_Get_Struct(Var_or_File,struct Netcdf, ncfile); - ncid_out=ncfile->ncid; - varid_out=NC_GLOBAL; - } else { - rb_raise(rb_eNetcdfError,"The argument must be a NetCDFVar or a NetCDF"); - } - - status = nc_copy_att(ncid_in,varid_in,att_name,ncid_out,varid_out); - if(status != NC_NOERR) NC_RAISE(status); - Netcdf_att_out = NetCDF_att_init(ncid_out,varid_out,att_name); - return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att_out)); -} - -VALUE -NetCDF_att_atttype(VALUE Att) -{ - int ncid; - int varid; - int status; - char *att_name; - const char *Attname; - struct NetCDFAtt *Netcdf_att; - nc_type xtypep; - - Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); - ncid = Netcdf_att->ncid; - varid = Netcdf_att->varid; - att_name = Netcdf_att->name; - - status = nc_inq_atttype(ncid,varid,att_name,&xtypep); - if(status != NC_NOERR) NC_RAISE(status); - - Attname = nctype2natype(xtypep); - return(rb_str_new2(Attname)); -} - -VALUE -NetCDF_att_typecode(VALUE Att) -{ - int ncid; - int varid; - int status; - char *att_name; - struct NetCDFAtt *Netcdf_att; - nc_type xtypep; - - Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); - ncid = Netcdf_att->ncid; - varid = Netcdf_att->varid; - att_name = Netcdf_att->name; - - status = nc_inq_atttype(ncid,varid,att_name,&xtypep); - if(status != NC_NOERR) NC_RAISE(status); - - return(INT2NUM(nctype2natypecode(xtypep))); -} - -VALUE -NetCDF_att_delete(VALUE Att) -{ - int ncid; - int status; - int varid; - char *c_att_name; - struct NetCDFAtt *Netcdf_att; - - rb_secure(4); - Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); - - ncid=Netcdf_att->ncid; - varid=Netcdf_att->varid; - c_att_name=Netcdf_att->name; - - status = nc_del_att(ncid,varid,c_att_name); - if(status != NC_NOERR) NC_RAISE(status); - - return Qnil; -} - -VALUE -NetCDF_att_put(VALUE Att,VALUE value,VALUE atttype) - /* - * atttype: nil or a String ("string","int",etc). If nil, - * the type of attribute is determined from the type of value - */ -{ - struct NetCDFAtt *ncatt; - - rb_secure(4); - Data_Get_Struct(Att,struct NetCDFAtt,ncatt); - return( NetCDF_put_att__(ncatt->ncid, ncatt->name, value, - atttype, ncatt->varid) ); -} - -VALUE -NetCDF_att_get(VALUE Att) -{ - int ncid; - int varid; - char *c_attname; - int status; - struct NetCDFAtt *Netcdf_att; - nc_type xtypep; - size_t lenp; - int attlen[1]; /* NArray uses int instead of size_t */ - char *tp; - unsigned char *up; - short *sp; - int *ip; - float *fp; - double *dp; - VALUE NArray; - VALUE str; - - Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att); - ncid = Netcdf_att->ncid; - varid = Netcdf_att->varid; - c_attname = Netcdf_att->name; - - status = nc_inq_atttype(ncid,varid,c_attname,&xtypep); - if(status != NC_NOERR) NC_RAISE(status); - - switch(xtypep){ - case NC_CHAR: - status = nc_inq_attlen(ncid,varid,c_attname,&lenp); - if(status != NC_NOERR) NC_RAISE(status); - tp = ALLOCA_N(char,lenp+1); - tp[lenp]= '\0'; - status = nc_get_att_text(ncid,varid,c_attname,tp); - if(status != NC_NOERR) NC_RAISE(status); - str = rb_str_new2(tp); - OBJ_TAINT(str); - return(str); - break; - case NC_BYTE: - status = nc_inq_attlen(ncid,varid,c_attname,&lenp); - if(status != NC_NOERR) NC_RAISE(status); - - attlen[0]=lenp; - Cbyte_to_NArray(NArray,1,attlen,up); - - status = nc_get_att_uchar(ncid,varid,c_attname,up); - if(status != NC_NOERR) NC_RAISE(status); - - OBJ_TAINT(NArray); - return NArray; - break; - case NC_SHORT: - status = nc_inq_attlen(ncid,varid,c_attname,&lenp); - if(status != NC_NOERR) NC_RAISE(status); - - attlen[0]=lenp; - Csint_to_NArray(NArray,1,attlen,sp); - - status = nc_get_att_short(ncid,varid,c_attname,sp); - if(status != NC_NOERR) NC_RAISE(status); - OBJ_TAINT(NArray); - return NArray; - break; - case NC_INT: - status = nc_inq_attlen(ncid,varid,c_attname,&lenp); - if(status != NC_NOERR) NC_RAISE(status); - - attlen[0]=lenp; - Clint_to_NArray(NArray,1,attlen,ip); - - status = nc_get_att_int(ncid,varid,c_attname,ip); - if(status != NC_NOERR) NC_RAISE(status); - - OBJ_TAINT(NArray); - return NArray; - break; - case NC_FLOAT: - status = nc_inq_attlen(ncid,varid,c_attname,&lenp); - if(status != NC_NOERR) NC_RAISE(status); - - attlen[0]=lenp; - Cfloat_to_NArray(NArray,1,attlen,fp); - - status = nc_get_att_float(ncid,varid,c_attname,fp); - if(status != NC_NOERR) NC_RAISE(status); - - OBJ_TAINT(NArray); - return NArray; - break; - case NC_DOUBLE: - status = nc_inq_attlen(ncid,varid,c_attname,&lenp); - if(status != NC_NOERR) NC_RAISE(status); - - attlen[0]=lenp; - Cdouble_to_NArray(NArray,1,attlen,dp); - - status = nc_get_att_double(ncid,varid,c_attname,dp); - if(status != NC_NOERR) NC_RAISE(status); - OBJ_TAINT(NArray); - return NArray; - break; - default: - rb_raise(rb_eNetcdfError,"atttype isn't supported in netCDF"); - } - return Qnil; -} - - -VALUE -NetCDF_var_inq_name(VALUE Var) -{ - int ncid; - int status; - int varid; - char c_var_name[NC_MAX_NAME]; - struct NetCDFVar *Netcdf_var; - VALUE Var_name; - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - - ncid=Netcdf_var->ncid; - varid=Netcdf_var->varid; - status = nc_inq_varname(ncid,varid,c_var_name); - if(status != NC_NOERR) NC_RAISE(status); - - Var_name=rb_str_new2(c_var_name); - OBJ_TAINT(Var_name); - return Var_name; -} - -VALUE -NetCDF_var_ndims(VALUE Var) -{ - int ncid; - int status; - int varid; - int ndimsp; - struct NetCDFVar *Netcdf_var; - VALUE Var_ndims; - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - - ncid=Netcdf_var->ncid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - Var_ndims=INT2FIX(ndimsp); - return Var_ndims; -} - -VALUE -NetCDF_var_vartype(VALUE Var) -{ - int ncid; - int status; - int varid; - nc_type xtypep; - struct NetCDFVar *Netcdf_var; - const char *Vartype; - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - - ncid=Netcdf_var->ncid; - varid=Netcdf_var->varid; - - status = nc_inq_vartype(ncid,varid,&xtypep); - if(status != NC_NOERR) NC_RAISE(status); - - Vartype=nctype2natype(xtypep); - return(rb_str_new2(Vartype)); -} - -VALUE -NetCDF_var_typecode(VALUE Var) -{ - int ncid; - int status; - int varid; - nc_type xtypep; - struct NetCDFVar *Netcdf_var; - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - - ncid=Netcdf_var->ncid; - varid=Netcdf_var->varid; - - status = nc_inq_vartype(ncid,varid,&xtypep); - if(status != NC_NOERR) NC_RAISE(status); - - return(INT2NUM(nctype2natypecode(xtypep))); -} - - -VALUE -NetCDF_var_natts(VALUE Var) -{ - int ncid; - int status; - int varid; - int nattsp; - struct NetCDFVar *Netcdf_var; - VALUE Var_natts; - - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - - ncid=Netcdf_var->ncid; - varid=Netcdf_var->varid; - - status= nc_inq_varnatts(ncid,varid,&nattsp); - if(status !=NC_NOERR) NC_RAISE(status); - - Var_natts=INT2FIX(nattsp); - return Var_natts; -} - -VALUE -NetCDF_var_file(VALUE Var) -{ - struct NetCDFVar *Netcdf_var; - /* VALUE file; */ - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - - return (Netcdf_var->file); -} - -VALUE -NetCDF_var_rename(VALUE Var,VALUE var_new_name) -{ - int ncid; - int status; - int varid; - char *c_var_new_name; - struct NetCDFVar *Netcdf_var; - - rb_secure(4); - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - ncid=Netcdf_var->ncid; - varid=Netcdf_var->varid; - - Check_Type(var_new_name,T_STRING); - c_var_new_name=StringValueCStr(var_new_name); - - status = nc_rename_var(ncid,varid,c_var_new_name); - if(status !=NC_NOERR) NC_RAISE(status); - - return Qnil; -} - -VALUE -NetCDF_var_att(VALUE Var,VALUE att_name) -{ - int ncid; - int status; - int varid; - char *c_att_name; - int c_attnump; - struct NetCDFVar *Netcdf_var; - struct NetCDFAtt *Netcdf_att; - VALUE Att; - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - - ncid=Netcdf_var->ncid; - varid=Netcdf_var->varid; - - Check_Type(att_name,T_STRING); - c_att_name=StringValueCStr(att_name); - - status = nc_inq_attid(ncid,varid,c_att_name,&c_attnump); - if(status == NC_NOERR){ - Netcdf_att=NetCDF_att_init(ncid,varid,c_att_name); - Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att); - return Att; - } - else if(status == NC_ENOTATT){ - return Qnil; - } - else{ - NC_RAISE(status); - return Qnil; - } -} - -/* Redifinition of the "==" and "eql?" methods */ - -VALUE -NetCDF_eql(VALUE filea,VALUE fileb) -{ - struct Netcdf *ncfilea; - struct Netcdf *ncfileb; - - if( rb_obj_is_kind_of(fileb, cNetCDF) ){ - Data_Get_Struct(filea,struct Netcdf,ncfilea); - Data_Get_Struct(fileb,struct Netcdf,ncfileb); - - if(ncfilea->ncid == ncfileb->ncid && - strcmp(ncfilea->name,ncfileb->name)==0){ - return Qtrue; - } else { - return Qfalse; - } - } else { - return Qfalse; - } -} - -VALUE -NetCDF_var_eql(VALUE Vara,VALUE Varb) -{ - struct NetCDFVar *Netcdf_vara; - struct NetCDFVar *Netcdf_varb; - - if( rb_obj_is_kind_of(Varb, cNetCDFVar) ){ - Data_Get_Struct(Vara,struct NetCDFVar,Netcdf_vara); - Data_Get_Struct(Varb,struct NetCDFVar,Netcdf_varb); - - if(Netcdf_vara->ncid == Netcdf_varb->ncid && - Netcdf_vara->varid == Netcdf_varb->varid){ - return Qtrue; - } else { - return Qfalse; - } - } else { - return Qfalse; - } -} - -VALUE -NetCDF_dim_eql(VALUE Dima,VALUE Dimb) -{ - struct NetCDFDim *Netcdf_dima; - struct NetCDFDim *Netcdf_dimb; - - if( rb_obj_is_kind_of(Dimb, cNetCDFDim) ){ - Data_Get_Struct(Dima,struct NetCDFDim,Netcdf_dima); - Data_Get_Struct(Dimb,struct NetCDFDim,Netcdf_dimb); - - if(Netcdf_dima->ncid == Netcdf_dimb->ncid && - Netcdf_dima->dimid == Netcdf_dimb->dimid){ - return Qtrue; - } else { - return Qfalse; - } - } else { - return Qfalse; - } -} - -VALUE -NetCDF_att_eql(VALUE Atta,VALUE Attb) -{ - struct NetCDFAtt *Netcdf_atta; - struct NetCDFAtt *Netcdf_attb; - - if( rb_obj_is_kind_of(Attb, cNetCDFAtt) ){ - Data_Get_Struct(Atta,struct NetCDFAtt,Netcdf_atta); - Data_Get_Struct(Attb,struct NetCDFAtt,Netcdf_attb); - - if(Netcdf_atta->ncid == Netcdf_atta->ncid && - Netcdf_atta->varid == Netcdf_attb->varid && - strcmp(Netcdf_atta->name,Netcdf_attb->name)==0){ - return Qtrue; - } else { - return Qfalse; - } - } else { - return Qfalse; - } -} - -/* Follow methods is to connect "NArray" with "Netcdf" */ -VALUE -NetCDF_get_var_char(VALUE Var) -{ - int ncid; - int varid; - int status; - unsigned char *ptr; - struct NetCDFVar *Netcdf_var; - int i=0; - int ndimsp; - int *dimids; - size_t lengthp; - int *shape; /* NArray uses int instead of size_t */ - VALUE NArray; - - Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var); - ncid = Netcdf_var->ncid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - dimids = ALLOCA_N(int,ndimsp); - if (ndimsp != 0){ - shape = ALLOCA_N(int,ndimsp); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - dimids = ALLOCA_N(int,ndimsp); - if (ndimsp != 0){ - shape = ALLOCA_N(int,ndimsp); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - dimids = ALLOCA_N(int,ndimsp); - if (ndimsp != 0){ - shape = ALLOCA_N(int,ndimsp); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - dimids = ALLOCA_N(int,ndimsp); - if (ndimsp != 0){ - shape = ALLOCA_N(int,ndimsp); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - dimids = ALLOCA_N(int,ndimsp); - if (ndimsp != 0){ - shape = ALLOCA_N(int,ndimsp); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - dimids = ALLOCA_N(int,ndimsp); - if (ndimsp != 0){ - shape = ALLOCA_N(int,ndimsp); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR)NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); - } - - c_start=ALLOCA_N(size_t,ndims); - c_count=ALLOCA_N(int,ndims); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR)NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); - } - - c_start=ALLOCA_N(size_t,ndims); - c_count=ALLOCA_N(int,ndims); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR) NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); - } - - c_start=ALLOCA_N(size_t,ndims); - c_count=ALLOCA_N(int,ndims); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR)NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); - } - - c_start=ALLOCA_N(size_t,ndims); - c_count=ALLOCA_N(int,ndims); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR)NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); - } - - c_start=ALLOCA_N(size_t,ndims); - c_count=ALLOCA_N(int,ndims); - for(i=0;incid; - varid = Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR)NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n"); - } - - c_start=ALLOCA_N(size_t,ndims); - c_count=ALLOCA_N(int,ndims); - for(i=0;incid; - varid = Netcdf_var->varid; - - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims){ - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start = ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid = Netcdf_var->varid; - - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims){ - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start = ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid = Netcdf_var->varid; - - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims){ - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start = ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid = Netcdf_var->varid; - - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims){ - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start = ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid = Netcdf_var->varid; - - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims){ - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start = ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid = Netcdf_var->varid; - - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - if(ndims == 0) { - rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n"); - } - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims){ - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start = ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid=Netcdf_var->varid; - - Array_to_Cbyte_len(NArray,ptr,len); - - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - for(i=0;incid; - varid=Netcdf_var->varid; - - Array_to_Cbyte_len(NArray,ptr,len); - - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - for(i=0;incid; - varid=Netcdf_var->varid; - Array_to_Csint_len(NArray,ptr,len); - - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - for(i=0;incid; - varid=Netcdf_var->varid; - - Array_to_Clint_len(NArray,ptr,len); - - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - for(i=0;incid; - varid=Netcdf_var->varid; - - Array_to_Cfloat_len(NArray,ptr,len); - - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - for(i=0;incid; - varid=Netcdf_var->varid; - - Array_to_Cdouble_len(NArray,ptr,len); - - status = nc_inq_varndims(ncid,varid,&ndimsp); - if(status != NC_NOERR) NC_RAISE(status); - for(i=0;incid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) ncid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) ncid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) ncid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) ncid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) ncid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid,varid,&ndims); - if(status != NC_NOERR) NC_RAISE(status); - - - dimids = ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid,varid,dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) ncid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR) NC_RAISE(status); - - dimids=ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid, varid, dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start=ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR) NC_RAISE(status); - - dimids=ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid, varid, dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start=ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR) NC_RAISE(status); - - dimids=ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid, varid, dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start=ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR) NC_RAISE(status); - - dimids=ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid, varid, dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start=ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR) NC_RAISE(status); - - dimids=ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid, varid, dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start=ALLOCA_N(size_t,ndims); - for(i=0; incid; - varid=Netcdf_var->varid; - status = nc_inq_varndims(ncid, varid, &ndims); - if(status != NC_NOERR) NC_RAISE(status); - - dimids=ALLOCA_N(int,ndims); - status = nc_inq_vardimid(ncid, varid, dimids); - if(status != NC_NOERR) NC_RAISE(status); - - Check_Type(start,T_ARRAY); - if(RARRAY_LEN(start) < ndims) { - rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n"); - } - c_start=ALLOCA_N(size_t,ndims); - for(i=0; i