ruby-netcdf 0.6.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/ChangeLog +389 -0
- data/INSTALL +62 -0
- data/LICENSE.txt +59 -0
- data/Rakefile +40 -0
- data/ToDo +1 -0
- data/demo/README +14 -0
- data/demo/demo1-create-alt.rb +35 -0
- data/demo/demo1-create.rb +35 -0
- data/demo/demo2-graphic.rb +67 -0
- data/demo/demo3-ncepclim.rb +178 -0
- data/demo/demo4-copy.rb +32 -0
- data/doc/README_JP.txt +152 -0
- data/doc/Ref_man.html +1482 -0
- data/doc/Ref_man.rd +1312 -0
- data/doc/Ref_man_jp.html +1445 -0
- data/doc/Ref_man_jp.rd +1276 -0
- data/doc/to_html +7 -0
- data/extconf.rb +137 -0
- data/extconf.rb.orig +124 -0
- data/extconf.rb.rej +16 -0
- data/lib/netcdf.rb +791 -0
- data/lib/netcdf_miss.rb +203 -0
- data/netcdfraw.c +4613 -0
- data/test/aref_aset.rb +37 -0
- data/test/char_var.rb +25 -0
- data/test/clone.rb +54 -0
- data/test/create_tmp.rb +15 -0
- data/test/def_var_with_dim.rb +14 -0
- data/test/factor_offset.rb +53 -0
- data/test/putatt.cdl +23 -0
- data/test/putatt.rb +56 -0
- data/test/test.cdl +31 -0
- data/test/test.rb +192 -0
- data/test/type.rb +13 -0
- metadata +140 -0
data/lib/netcdf_miss.rb
ADDED
@@ -0,0 +1,203 @@
|
|
1
|
+
require "numru/netcdf"
|
2
|
+
require "narray_miss"
|
3
|
+
|
4
|
+
module NumRu
|
5
|
+
|
6
|
+
class NetCDFVar
|
7
|
+
|
8
|
+
def get_with_miss(*args)
|
9
|
+
__interpret_missing_params if !defined?(@missval)
|
10
|
+
data = simple_get(*args)
|
11
|
+
if @vmin || @vmax
|
12
|
+
if @vmin
|
13
|
+
mask = (data >= @vmin)
|
14
|
+
mask = mask.and(data <= @vmax) if @vmax
|
15
|
+
else
|
16
|
+
mask = (data <= @vmax)
|
17
|
+
end
|
18
|
+
data = NArrayMiss.to_nam(data, mask)
|
19
|
+
elsif @missval # only missing_value is present.
|
20
|
+
mask = (data.ne(@missval))
|
21
|
+
data = NArrayMiss.to_nam(data, mask)
|
22
|
+
end
|
23
|
+
data
|
24
|
+
end
|
25
|
+
|
26
|
+
def get_with_miss_and_scaling(*args)
|
27
|
+
__interpret_missing_params if !defined?(@missval)
|
28
|
+
data = simple_get(*args)
|
29
|
+
if @vmin || @vmax
|
30
|
+
if @vmin
|
31
|
+
mask = (data >= @vmin)
|
32
|
+
mask = mask.and(data <= @vmax) if @vmax
|
33
|
+
else
|
34
|
+
mask = (data <= @vmax)
|
35
|
+
end
|
36
|
+
data = NArrayMiss.to_nam(data, mask)
|
37
|
+
elsif @missval # only missing_value is present.
|
38
|
+
mask = (data.ne(@missval))
|
39
|
+
data = NArrayMiss.to_nam(data, mask)
|
40
|
+
end
|
41
|
+
data = unpack( data )
|
42
|
+
data
|
43
|
+
end
|
44
|
+
|
45
|
+
def put_with_miss(data, *args)
|
46
|
+
if data.is_a?( NArrayMiss )
|
47
|
+
__interpret_missing_params if !defined?(@missval)
|
48
|
+
if @missval
|
49
|
+
simple_put(data.to_na(@missval), *args)
|
50
|
+
else
|
51
|
+
simple_put(data.to_na, *args)
|
52
|
+
end
|
53
|
+
else
|
54
|
+
simple_put(data, *args)
|
55
|
+
end
|
56
|
+
end
|
57
|
+
|
58
|
+
def put_with_miss_and_scaling(data, *args)
|
59
|
+
if data.is_a?( NArrayMiss )
|
60
|
+
__interpret_missing_params if !defined?(@missval)
|
61
|
+
if @missval
|
62
|
+
data = pack( data )
|
63
|
+
data = data.to_na(@missval)
|
64
|
+
else
|
65
|
+
data = pack( data )
|
66
|
+
data = data.to_na
|
67
|
+
end
|
68
|
+
simple_put(data, *args)
|
69
|
+
else
|
70
|
+
scaled_put(data, *args)
|
71
|
+
end
|
72
|
+
end
|
73
|
+
|
74
|
+
######### private ##########
|
75
|
+
|
76
|
+
def __interpret_missing_params
|
77
|
+
# Interprets the specification of missing data,
|
78
|
+
# either by valid_range, (valid_min and/or valid_max), or missing_value.
|
79
|
+
# (unlike the NetCDF User's guide (NUG), missing_value is interpreted,
|
80
|
+
# but valid_* has a higher precedence.)
|
81
|
+
# Always sets @missval whether missing_value is defined or not,
|
82
|
+
# since it will be used as a fill value for data missing.
|
83
|
+
#
|
84
|
+
@vmin = att('valid_min')
|
85
|
+
@vmin = @vmin.get if @vmin # kept in a NArray(size==1) to consv type
|
86
|
+
@vmax = att('valid_max')
|
87
|
+
@vmax = @vmax.get if @vmax # kept in a NArray(size==1) to consv type
|
88
|
+
vrange = att('valid_range')
|
89
|
+
vrange = vrange.get if vrange
|
90
|
+
if vrange
|
91
|
+
vrange.sort!
|
92
|
+
@vmin = vrange[0..0] # kept in... (same)
|
93
|
+
@vmax = vrange[-1..-1] # kept in... (same)
|
94
|
+
end
|
95
|
+
@missval = att('missing_value') || att('_FillValue')
|
96
|
+
@missval = @missval.get if @missval # kept in... (same)
|
97
|
+
|
98
|
+
sf = att('scale_factor')
|
99
|
+
ao = att('add_offset')
|
100
|
+
if ( sf || ao )
|
101
|
+
## Both NUG & CF conventions requires to specify the valid
|
102
|
+
## range with respect to the external (i.e. packed) values.
|
103
|
+
## However, some conventions require specification
|
104
|
+
## with respect to unpacked values. The following
|
105
|
+
## is to support such cases as well:
|
106
|
+
thres_tp = [ self.typecode, NArray::LINT ].max
|
107
|
+
@missval = pack(@missval) if @missval && @missval.typecode > thres_tp
|
108
|
+
@vmin = pack(@vmin) if @vmin && @vmin.typecode > thres_tp
|
109
|
+
@vmax = pack(@vmax) if @vmax && @vmax.typecode > thres_tp
|
110
|
+
end
|
111
|
+
|
112
|
+
if @missval
|
113
|
+
if @vmin && @vmax
|
114
|
+
if @vmin[0] <= @missval[0] && @missval[0] <= @vmax[0]
|
115
|
+
warn "WARNING: missing_value #{@missval[0]} is in the valid range #{@vmin[0]}..#{@vmax[0]} --> will be ignored (#{__FILE__}:#{__LINE__})"
|
116
|
+
end
|
117
|
+
else
|
118
|
+
if @vmin && @missval[0] >= @vmin[0]
|
119
|
+
warn "WARNING: missing_value #{@missval[0]} >= valid min #{@vmin[0]} --> will be ignored (#{__FILE__}:#{__LINE__})"
|
120
|
+
elsif @vmax && @missval[0] <= @vmax[0]
|
121
|
+
warn "WARNING: missing_value #{@missval[0]} <= valid min #{@vmin[0]} --> will be ignored (#{__FILE__}:#{__LINE__})"
|
122
|
+
end
|
123
|
+
end
|
124
|
+
else
|
125
|
+
realtc = NArray::SFLOAT
|
126
|
+
if @vmin
|
127
|
+
if @vmin[0] >= 0
|
128
|
+
@missval = ( @vmin.typecode>=realtc ? 0.99*@vmin : @vmin-1 )
|
129
|
+
else
|
130
|
+
@missval = ( @vmin.typecode>=realtc ? 1.01*@vmin : @vmin-1 )
|
131
|
+
end
|
132
|
+
elsif @vmax
|
133
|
+
if @vmax[0] >= 0
|
134
|
+
@missval = ( @vmax.typecode>=realtc ? 1.01*@vmax : @vmax+1 )
|
135
|
+
else
|
136
|
+
@missval = ( @vmax.typecode>=realtc ? 0.99*@vmax : @vmax+1 )
|
137
|
+
end
|
138
|
+
end
|
139
|
+
end
|
140
|
+
|
141
|
+
end
|
142
|
+
|
143
|
+
private :__interpret_missing_params
|
144
|
+
|
145
|
+
end
|
146
|
+
|
147
|
+
end
|
148
|
+
|
149
|
+
if $0 == __FILE__
|
150
|
+
include NumRu
|
151
|
+
|
152
|
+
filename = "tmp.nc"
|
153
|
+
print "creating ",filename,"...\n"
|
154
|
+
file=NetCDF.create(filename)
|
155
|
+
nx = 10
|
156
|
+
dimx = file.def_dim("x",nx)
|
157
|
+
xf = file.def_var("xf","sfloat",[dimx])
|
158
|
+
xfn = file.def_var("xfn","sfloat",[dimx])
|
159
|
+
xf.put_att("valid_range",[-1e12,1e12])
|
160
|
+
f = 10 ** (2*NArray.sfloat(nx).indgen!)
|
161
|
+
xr = file.def_var("xr","sint",[dimx])
|
162
|
+
xr.put_att("valid_max",[0.5])
|
163
|
+
xr.put_att("scale_factor",1e-4)
|
164
|
+
xr.put_att("add_offset",0.5)
|
165
|
+
xr2 = file.def_var("xr2","sint",[dimx])
|
166
|
+
xr2.put_att("valid_max",NArray.sint(1).fill!(1000))
|
167
|
+
xr2.put_att("scale_factor",1e-4)
|
168
|
+
xr2.put_att("add_offset",0.5)
|
169
|
+
r = NArray.sfloat(nx).indgen!/nx
|
170
|
+
file.enddef
|
171
|
+
xf.put(f)
|
172
|
+
xfn.put(f)
|
173
|
+
xr.scaled_put(r)
|
174
|
+
file.close
|
175
|
+
|
176
|
+
file = NetCDF.open(filename,'r+')
|
177
|
+
xf = file.var('xf')
|
178
|
+
xfn = file.var('xfn')
|
179
|
+
p "f0"
|
180
|
+
xf.get.each{|v| print "#{v} "} ; print "\n"
|
181
|
+
p( 'f1', nam = xf.get_with_miss )
|
182
|
+
def xf.get(*args); get_with_miss(*args); end
|
183
|
+
p( 'f12', xf[2..-3].to_na )
|
184
|
+
p( 'fn10', xfn.get_with_miss )
|
185
|
+
p( 'fn11', xfn.get_with_miss_and_scaling )
|
186
|
+
nam.invalidation([0,1])
|
187
|
+
p 'f2', nam
|
188
|
+
xf.put_with_miss(nam)
|
189
|
+
p( 'f3', xf.get_with_miss )
|
190
|
+
xr = file.var('xr')
|
191
|
+
p "r0"
|
192
|
+
xr.simple_get.each{|v| print "#{v} "} ; print "\n"
|
193
|
+
p( 'r1', xr.get_with_miss_and_scaling )
|
194
|
+
def xr.get(*args); get_with_miss_and_scaling(*args); end
|
195
|
+
def xr.put(*args); put_with_miss_and_scaling(*args); end
|
196
|
+
#xr[0..3] = xr[0..3]*10
|
197
|
+
p( 'r2', xr.get_with_miss_and_scaling )
|
198
|
+
p 'r',r
|
199
|
+
xr2.put_with_miss_and_scaling(r)
|
200
|
+
p 'xr2',xr2.get_with_miss_and_scaling
|
201
|
+
file.close
|
202
|
+
print "** ncdump tmp.nc **\n", `ncdump tmp.nc`
|
203
|
+
end
|
data/netcdfraw.c
ADDED
@@ -0,0 +1,4613 @@
|
|
1
|
+
#include<stdio.h>
|
2
|
+
#include "ruby.h"
|
3
|
+
#include "narray.h"
|
4
|
+
#include<netcdf.h>
|
5
|
+
#include<string.h>
|
6
|
+
|
7
|
+
/* for compatibility with ruby 1.6 */
|
8
|
+
#ifndef RSTRING_PTR
|
9
|
+
#define RSTRING_PTR(s) (RSTRING(s)->ptr)
|
10
|
+
#endif
|
11
|
+
#ifndef RSTRING_LEN
|
12
|
+
#define RSTRING_LEN(s) (RSTRING(s)->len)
|
13
|
+
#endif
|
14
|
+
#ifndef RARRAY_PTR
|
15
|
+
#define RARRAY_PTR(a) (RARRAY(a)->ptr)
|
16
|
+
#endif
|
17
|
+
#ifndef RARRAY_LEN
|
18
|
+
#define RARRAY_LEN(a) (RARRAY(a)->len)
|
19
|
+
#endif
|
20
|
+
#ifndef StringValueCStr
|
21
|
+
#define StringValueCStr(s) STR2CSTR(s)
|
22
|
+
#endif
|
23
|
+
#ifndef SafeStringValue
|
24
|
+
#define SafeStringValue(s) Check_SafeStr(s)
|
25
|
+
#endif
|
26
|
+
|
27
|
+
/* Data to NArray */
|
28
|
+
|
29
|
+
/* memcpy(ary->ptr,nc_ptr,na_sizeof[NA_SINT]*ary->total); \ */
|
30
|
+
|
31
|
+
#define Cbyte_to_NArray(v, rank, shape, up) \
|
32
|
+
{ \
|
33
|
+
struct NARRAY *ary; \
|
34
|
+
v = na_make_object(NA_BYTE, rank, shape, cNArray); \
|
35
|
+
GetNArray(v,ary); \
|
36
|
+
up = (unsigned char *)ary->ptr; \
|
37
|
+
}
|
38
|
+
|
39
|
+
#define Csint_to_NArray(v, rank, shape, sp) \
|
40
|
+
{ \
|
41
|
+
struct NARRAY *ary; \
|
42
|
+
v = na_make_object(NA_SINT, rank, shape, cNArray); \
|
43
|
+
GetNArray(v, ary); \
|
44
|
+
sp = (short *)ary->ptr; \
|
45
|
+
}
|
46
|
+
|
47
|
+
#define Clint_to_NArray(v, rank, shape, lp) \
|
48
|
+
{ \
|
49
|
+
struct NARRAY *ary; \
|
50
|
+
v = na_make_object(NA_LINT, rank, shape, cNArray); \
|
51
|
+
GetNArray(v, ary); \
|
52
|
+
lp = (int *)ary->ptr; \
|
53
|
+
}
|
54
|
+
#define Cfloat_to_NArray(v, rank, shape, fp) \
|
55
|
+
{ \
|
56
|
+
struct NARRAY *ary; \
|
57
|
+
v = na_make_object(NA_SFLOAT, rank, shape, cNArray); \
|
58
|
+
GetNArray(v, ary); \
|
59
|
+
fp = (float *)ary->ptr; \
|
60
|
+
}
|
61
|
+
#define Cdouble_to_NArray(v, rank, shape, dp); \
|
62
|
+
{ \
|
63
|
+
struct NARRAY *ary; \
|
64
|
+
v = na_make_object(NA_DFLOAT, rank, shape, cNArray); \
|
65
|
+
GetNArray(v, ary); \
|
66
|
+
dp = (double *)ary->ptr; \
|
67
|
+
}
|
68
|
+
|
69
|
+
/* Array or NArray to pointer and length (with no new allocation) */
|
70
|
+
|
71
|
+
#define Array_to_Cfloat_len(obj, ptr, len) \
|
72
|
+
{ \
|
73
|
+
struct NARRAY *na; \
|
74
|
+
obj = na_cast_object(obj, NA_SFLOAT); \
|
75
|
+
GetNArray(obj, na); \
|
76
|
+
ptr = (float *) NA_PTR(na,0); \
|
77
|
+
len = na->total; \
|
78
|
+
}
|
79
|
+
|
80
|
+
#define Array_to_Cfloat_len_shape(obj, ptr, len, shape) \
|
81
|
+
{ \
|
82
|
+
struct NARRAY *na; \
|
83
|
+
obj = na_cast_object(obj, NA_SFLOAT); \
|
84
|
+
GetNArray(obj, na); \
|
85
|
+
ptr = (float *) NA_PTR(na,0); \
|
86
|
+
len = na->total; \
|
87
|
+
shape = na->shape; \
|
88
|
+
}
|
89
|
+
|
90
|
+
#define Array_to_Cdouble_len(obj, ptr, len) \
|
91
|
+
{ \
|
92
|
+
struct NARRAY *na; \
|
93
|
+
obj = na_cast_object(obj, NA_DFLOAT); \
|
94
|
+
GetNArray(obj, na); \
|
95
|
+
ptr = (double *) NA_PTR(na,0); \
|
96
|
+
len = na->total; \
|
97
|
+
}
|
98
|
+
#define Array_to_Cdouble_len_shape(obj, ptr, len, shape) \
|
99
|
+
{ \
|
100
|
+
struct NARRAY *na; \
|
101
|
+
obj = na_cast_object(obj, NA_DFLOAT); \
|
102
|
+
GetNArray(obj, na); \
|
103
|
+
ptr = (double *) NA_PTR(na,0); \
|
104
|
+
len = na->total; \
|
105
|
+
shape = na->shape; \
|
106
|
+
}
|
107
|
+
|
108
|
+
#define Array_to_Cbyte_len(obj, ptr, len) \
|
109
|
+
{ \
|
110
|
+
struct NARRAY *na; \
|
111
|
+
obj = na_cast_object(obj, NA_BYTE); \
|
112
|
+
GetNArray(obj, na); \
|
113
|
+
ptr = (u_int8_t *) NA_PTR(na,0); \
|
114
|
+
len = na->total; \
|
115
|
+
}
|
116
|
+
|
117
|
+
#define Array_to_Cbyte_len_shape(obj, ptr, len, shape) \
|
118
|
+
{ \
|
119
|
+
struct NARRAY *na; \
|
120
|
+
obj = na_cast_object(obj, NA_BYTE); \
|
121
|
+
GetNArray(obj, na); \
|
122
|
+
ptr = (u_int8_t *) NA_PTR(na,0); \
|
123
|
+
len = na->total; \
|
124
|
+
shape = na->shape; \
|
125
|
+
}
|
126
|
+
|
127
|
+
#define Array_to_Csint_len(obj, ptr, len) \
|
128
|
+
{ \
|
129
|
+
struct NARRAY *na; \
|
130
|
+
obj = na_cast_object(obj, NA_SINT); \
|
131
|
+
GetNArray(obj, na); \
|
132
|
+
ptr = (int16_t *) NA_PTR(na,0); \
|
133
|
+
len = na->total; \
|
134
|
+
}
|
135
|
+
|
136
|
+
#define Array_to_Csint_len_shape(obj, ptr, len, shape) \
|
137
|
+
{ \
|
138
|
+
struct NARRAY *na; \
|
139
|
+
obj = na_cast_object(obj, NA_SINT); \
|
140
|
+
GetNArray(obj, na); \
|
141
|
+
ptr = (int16_t *) NA_PTR(na,0); \
|
142
|
+
len = na->total; \
|
143
|
+
shape = na->shape; \
|
144
|
+
}
|
145
|
+
|
146
|
+
|
147
|
+
#define Array_to_Clint_len(obj, ptr, len) \
|
148
|
+
{ \
|
149
|
+
struct NARRAY *na; \
|
150
|
+
obj = na_cast_object(obj, NA_LINT); \
|
151
|
+
GetNArray(obj, na); \
|
152
|
+
ptr = (int32_t *) NA_PTR(na,0); \
|
153
|
+
len = na->total; \
|
154
|
+
}
|
155
|
+
|
156
|
+
#define Array_to_Clint_len_shape(obj, ptr, len, shape) \
|
157
|
+
{ \
|
158
|
+
struct NARRAY *na; \
|
159
|
+
obj = na_cast_object(obj, NA_LINT); \
|
160
|
+
GetNArray(obj, na); \
|
161
|
+
ptr = (int32_t *) NA_PTR(na,0); \
|
162
|
+
len = na->total; \
|
163
|
+
shape = na->shape; \
|
164
|
+
}
|
165
|
+
|
166
|
+
|
167
|
+
/* Array or NArray to pointer (with no new allocation) */
|
168
|
+
|
169
|
+
#define Array_to_Cfloat(obj, ptr) \
|
170
|
+
{ \
|
171
|
+
struct NARRAY *na; \
|
172
|
+
obj = na_cast_object(obj, NA_SFLOAT); \
|
173
|
+
GetNArray(obj, na); \
|
174
|
+
ptr = (float *) NA_PTR(na,0); \
|
175
|
+
}
|
176
|
+
#define Array_to_Cdouble(obj, ptr) \
|
177
|
+
{ \
|
178
|
+
struct NARRAY *na; \
|
179
|
+
obj = na_cast_object(obj, NA_DFLOAT); \
|
180
|
+
GetNArray(obj, na); \
|
181
|
+
ptr = (double *) NA_PTR(na,0); \
|
182
|
+
}
|
183
|
+
#define Array_to_Cbyte(obj, ptr) \
|
184
|
+
{ \
|
185
|
+
struct NARRAY *na; \
|
186
|
+
obj = na_cast_object(obj, NA_BYTE); \
|
187
|
+
GetNArray(obj, na); \
|
188
|
+
ptr = (u_int8_t *) NA_PTR(na,0); \
|
189
|
+
}
|
190
|
+
#define Array_to_Csint(obj, ptr) \
|
191
|
+
{ \
|
192
|
+
struct NARRAY *na; \
|
193
|
+
obj = na_cast_object(obj, NA_SINT); \
|
194
|
+
GetNArray(obj, na); \
|
195
|
+
ptr = (int16_t *) NA_PTR(na,0); \
|
196
|
+
}
|
197
|
+
#define Array_to_Clint(obj, ptr) \
|
198
|
+
{ \
|
199
|
+
struct NARRAY *na; \
|
200
|
+
obj = na_cast_object(obj, NA_LINT); \
|
201
|
+
GetNArray(obj, na); \
|
202
|
+
ptr = (int32_t *) NA_PTR(na,0); \
|
203
|
+
}
|
204
|
+
|
205
|
+
#define NC_RAISE(status) rb_raise(err_status2class(status),(nc_strerror(status)))
|
206
|
+
|
207
|
+
static VALUE mNumRu = 0;
|
208
|
+
static VALUE cNetCDF;
|
209
|
+
static VALUE cNetCDFDim;
|
210
|
+
static VALUE cNetCDFAtt;
|
211
|
+
static VALUE cNetCDFVar;
|
212
|
+
|
213
|
+
static VALUE rb_eNetcdfError;
|
214
|
+
static VALUE rb_eNetcdfBadid;
|
215
|
+
static VALUE rb_eNetcdfNfile;
|
216
|
+
static VALUE rb_eNetcdfExist;
|
217
|
+
static VALUE rb_eNetcdfInval;
|
218
|
+
static VALUE rb_eNetcdfPerm;
|
219
|
+
static VALUE rb_eNetcdfNotindefine;
|
220
|
+
static VALUE rb_eNetcdfIndefine;
|
221
|
+
static VALUE rb_eNetcdfInvalcoords;
|
222
|
+
static VALUE rb_eNetcdfMaxdims;
|
223
|
+
static VALUE rb_eNetcdfNameinuse;
|
224
|
+
static VALUE rb_eNetcdfNotatt;
|
225
|
+
static VALUE rb_eNetcdfMaxatts;
|
226
|
+
static VALUE rb_eNetcdfBadtype;
|
227
|
+
static VALUE rb_eNetcdfBaddim;
|
228
|
+
static VALUE rb_eNetcdfUnlimpos;
|
229
|
+
static VALUE rb_eNetcdfMaxvars;
|
230
|
+
static VALUE rb_eNetcdfNotvar;
|
231
|
+
static VALUE rb_eNetcdfGlobal;
|
232
|
+
static VALUE rb_eNetcdfNotnc;
|
233
|
+
static VALUE rb_eNetcdfSts;
|
234
|
+
static VALUE rb_eNetcdfMaxname;
|
235
|
+
static VALUE rb_eNetcdfUnlimit;
|
236
|
+
static VALUE rb_eNetcdfNorecvars;
|
237
|
+
static VALUE rb_eNetcdfChar;
|
238
|
+
static VALUE rb_eNetcdfEdge;
|
239
|
+
static VALUE rb_eNetcdfStride;
|
240
|
+
static VALUE rb_eNetcdfBadname;
|
241
|
+
static VALUE rb_eNetcdfRange;
|
242
|
+
static VALUE rb_eNetcdfNomem;
|
243
|
+
|
244
|
+
/* Special Error */
|
245
|
+
/* Global error status */
|
246
|
+
|
247
|
+
static VALUE rb_eNetcdfFatal;
|
248
|
+
|
249
|
+
/* Global options variable. Used to determine behavior of error handler. */
|
250
|
+
|
251
|
+
static VALUE rb_eNetcdfEntool;
|
252
|
+
static VALUE rb_eNetcdfExdr;
|
253
|
+
static VALUE rb_eNetcdfSyserr;
|
254
|
+
|
255
|
+
|
256
|
+
struct Netcdf{
|
257
|
+
int ncid;
|
258
|
+
char *name;
|
259
|
+
int closed;
|
260
|
+
};
|
261
|
+
|
262
|
+
struct NetCDFDim{
|
263
|
+
int dimid;
|
264
|
+
int ncid;
|
265
|
+
};
|
266
|
+
|
267
|
+
struct NetCDFVar{
|
268
|
+
int varid;
|
269
|
+
int ncid;
|
270
|
+
VALUE file;
|
271
|
+
};
|
272
|
+
|
273
|
+
struct NetCDFAtt{
|
274
|
+
int varid;
|
275
|
+
int ncid;
|
276
|
+
char *name;
|
277
|
+
};
|
278
|
+
|
279
|
+
static struct Netcdf *
|
280
|
+
NetCDF_init(int ncid,char *filename)
|
281
|
+
{
|
282
|
+
struct Netcdf *Netcdffile;
|
283
|
+
Netcdffile=xmalloc(sizeof(struct Netcdf));
|
284
|
+
Netcdffile->ncid=ncid;
|
285
|
+
Netcdffile->closed=0;
|
286
|
+
Netcdffile->name=xmalloc((strlen(filename)+1)*sizeof(char));
|
287
|
+
strcpy(Netcdffile->name,filename);
|
288
|
+
return(Netcdffile);
|
289
|
+
}
|
290
|
+
|
291
|
+
static struct NetCDFDim *
|
292
|
+
NetCDF_dim_init(int ncid,int dimid)
|
293
|
+
{
|
294
|
+
struct NetCDFDim *Netcdf_dim;
|
295
|
+
Netcdf_dim=xmalloc(sizeof(struct NetCDFDim));
|
296
|
+
Netcdf_dim->dimid=dimid;
|
297
|
+
Netcdf_dim->ncid=ncid;
|
298
|
+
return(Netcdf_dim);
|
299
|
+
}
|
300
|
+
|
301
|
+
static struct NetCDFVar *
|
302
|
+
NetCDF_var_init(int ncid,int varid,VALUE file)
|
303
|
+
{
|
304
|
+
struct NetCDFVar *Netcdf_var;
|
305
|
+
Netcdf_var=xmalloc(sizeof(struct NetCDFVar));
|
306
|
+
Netcdf_var->varid=varid;
|
307
|
+
Netcdf_var->ncid=ncid;
|
308
|
+
Netcdf_var->file=file;
|
309
|
+
return(Netcdf_var);
|
310
|
+
}
|
311
|
+
static struct NetCDFAtt *
|
312
|
+
NetCDF_att_init(int ncid,int varid,char *attname)
|
313
|
+
{
|
314
|
+
struct NetCDFAtt *Netcdf_att;
|
315
|
+
Netcdf_att=xmalloc(sizeof(struct NetCDFAtt));
|
316
|
+
Netcdf_att->ncid=ncid;
|
317
|
+
Netcdf_att->varid=varid;
|
318
|
+
Netcdf_att->name=xmalloc((strlen(attname)+1)*sizeof(char));
|
319
|
+
strcpy(Netcdf_att->name,attname);
|
320
|
+
return(Netcdf_att);
|
321
|
+
}
|
322
|
+
|
323
|
+
void
|
324
|
+
Netcdf_att_free(struct NetCDFAtt *Netcdf_att)
|
325
|
+
{
|
326
|
+
free(Netcdf_att->name);
|
327
|
+
free(Netcdf_att);
|
328
|
+
}
|
329
|
+
|
330
|
+
void
|
331
|
+
NetCDF_var_free(struct NetCDFVar *Netcdf_var)
|
332
|
+
{
|
333
|
+
free(Netcdf_var);
|
334
|
+
}
|
335
|
+
|
336
|
+
void
|
337
|
+
NetCDF_dim_free(struct NetCDFDim *Netcdf_dim)
|
338
|
+
{
|
339
|
+
free(Netcdf_dim);
|
340
|
+
}
|
341
|
+
|
342
|
+
void
|
343
|
+
NetCDF_free(struct Netcdf *Netcdffile)
|
344
|
+
{
|
345
|
+
int status;
|
346
|
+
if (!Netcdffile->closed){
|
347
|
+
status = nc_close(Netcdffile->ncid); /* no error check -- not to stop during GC */
|
348
|
+
}
|
349
|
+
free(Netcdffile->name);
|
350
|
+
free(Netcdffile);
|
351
|
+
}
|
352
|
+
|
353
|
+
static VALUE
|
354
|
+
err_status2class(int status)
|
355
|
+
{
|
356
|
+
if(NC_ISSYSERR(status)){
|
357
|
+
return(rb_eNetcdfSyserr);
|
358
|
+
}
|
359
|
+
switch(status)
|
360
|
+
{
|
361
|
+
case(NC_EBADID):
|
362
|
+
return(rb_eNetcdfBadid);break;
|
363
|
+
case(NC_ENFILE):
|
364
|
+
return(rb_eNetcdfNfile);break;
|
365
|
+
case(NC_EEXIST):
|
366
|
+
return(rb_eNetcdfExist);break;
|
367
|
+
case(NC_EINVAL):
|
368
|
+
return(rb_eNetcdfInval);break;
|
369
|
+
case(NC_EPERM):
|
370
|
+
return(rb_eNetcdfPerm);break;
|
371
|
+
case(NC_ENOTINDEFINE):
|
372
|
+
return(rb_eNetcdfNotindefine);break;
|
373
|
+
case(NC_EINDEFINE):
|
374
|
+
return(rb_eNetcdfIndefine);break;
|
375
|
+
case(NC_EINVALCOORDS):
|
376
|
+
return(rb_eNetcdfInvalcoords);break;
|
377
|
+
case(NC_EMAXDIMS):
|
378
|
+
return(rb_eNetcdfMaxdims);break;
|
379
|
+
case(NC_ENAMEINUSE):
|
380
|
+
return(rb_eNetcdfNameinuse);break;
|
381
|
+
case(NC_ENOTATT):
|
382
|
+
return(rb_eNetcdfNotatt);break;
|
383
|
+
case(NC_EMAXATTS):
|
384
|
+
return(rb_eNetcdfMaxatts);break;
|
385
|
+
case(NC_EBADTYPE):
|
386
|
+
return(rb_eNetcdfBadtype);break;
|
387
|
+
case(NC_EBADDIM):
|
388
|
+
return(rb_eNetcdfBaddim);break;
|
389
|
+
case(NC_EUNLIMPOS):
|
390
|
+
return(rb_eNetcdfUnlimpos);break;
|
391
|
+
case(NC_EMAXVARS):
|
392
|
+
return(rb_eNetcdfMaxvars);break;
|
393
|
+
case(NC_ENOTVAR):
|
394
|
+
return(rb_eNetcdfNotvar);break;
|
395
|
+
case(NC_EGLOBAL):
|
396
|
+
return(rb_eNetcdfGlobal);break;
|
397
|
+
case(NC_ENOTNC):
|
398
|
+
return(rb_eNetcdfNotnc);break;
|
399
|
+
case(NC_ESTS):
|
400
|
+
return(rb_eNetcdfSts);break;
|
401
|
+
case(NC_EMAXNAME):
|
402
|
+
return(rb_eNetcdfMaxname);break;
|
403
|
+
case(NC_EUNLIMIT):
|
404
|
+
return(rb_eNetcdfUnlimit);break;
|
405
|
+
case(NC_ENORECVARS):
|
406
|
+
return(rb_eNetcdfNorecvars);break;
|
407
|
+
case(NC_ECHAR):
|
408
|
+
return(rb_eNetcdfChar);break;
|
409
|
+
case(NC_EEDGE):
|
410
|
+
return(rb_eNetcdfEdge);break;
|
411
|
+
case(NC_ESTRIDE):
|
412
|
+
return(rb_eNetcdfStride);break;
|
413
|
+
case(NC_EBADNAME):
|
414
|
+
return(rb_eNetcdfBadname);break;
|
415
|
+
case(NC_ERANGE):
|
416
|
+
return(rb_eNetcdfRange);break;
|
417
|
+
case(NC_ENOMEM):
|
418
|
+
return(rb_eNetcdfNomem);break;
|
419
|
+
/* case(NC_ENTOOL):
|
420
|
+
return(rb_eNetcdfEntool);break; */
|
421
|
+
case(NC_EXDR):
|
422
|
+
return(rb_eNetcdfExdr);break;
|
423
|
+
case(NC_SYSERR):
|
424
|
+
return(rb_eNetcdfSyserr);break;
|
425
|
+
case(NC_FATAL):
|
426
|
+
return(rb_eNetcdfFatal);break;
|
427
|
+
}
|
428
|
+
}
|
429
|
+
|
430
|
+
static const char*
|
431
|
+
nctype2natype(int nctype){
|
432
|
+
switch(nctype){
|
433
|
+
case NC_CHAR:
|
434
|
+
return("char");
|
435
|
+
case NC_BYTE:
|
436
|
+
return("byte");
|
437
|
+
case NC_SHORT:
|
438
|
+
return("sint");
|
439
|
+
case NC_INT:
|
440
|
+
return("int");
|
441
|
+
case NC_FLOAT:
|
442
|
+
return("sfloat");
|
443
|
+
case NC_DOUBLE:
|
444
|
+
return("float");
|
445
|
+
default:
|
446
|
+
rb_raise(rb_eNetcdfError, "No such netcdf type number %d\n",nctype);
|
447
|
+
}
|
448
|
+
}
|
449
|
+
|
450
|
+
static int
|
451
|
+
nctype2natypecode(int nctype){
|
452
|
+
switch(nctype){
|
453
|
+
case NC_CHAR:
|
454
|
+
return(NA_BYTE);
|
455
|
+
case NC_BYTE:
|
456
|
+
return(NA_BYTE);
|
457
|
+
case NC_SHORT:
|
458
|
+
return(NA_SINT);
|
459
|
+
case NC_INT:
|
460
|
+
return(NA_LINT);
|
461
|
+
case NC_FLOAT:
|
462
|
+
return(NA_SFLOAT);
|
463
|
+
case NC_DOUBLE:
|
464
|
+
return(NA_DFLOAT);
|
465
|
+
default:
|
466
|
+
rb_raise(rb_eNetcdfError, "No such netcdf type number %d\n",nctype);
|
467
|
+
}
|
468
|
+
}
|
469
|
+
|
470
|
+
static int
|
471
|
+
natype2nctype(char *natype)
|
472
|
+
{
|
473
|
+
if(strcmp(natype,"byte")==0) return(NC_BYTE);
|
474
|
+
else if(strcmp(natype,"char")==0) return(NC_CHAR);
|
475
|
+
else if(strcmp(natype,"text")==0) return(NC_CHAR); /* alias of char */
|
476
|
+
else if(strcmp(natype,"string")==0) return(NC_CHAR); /* alias of char */
|
477
|
+
else if(strcmp(natype,"sint")==0) return(NC_SHORT);
|
478
|
+
else if(strcmp(natype,"int")==0) return(NC_INT);
|
479
|
+
else if(strcmp(natype,"sfloat")==0) return(NC_FLOAT);
|
480
|
+
else if(strcmp(natype,"float")==0) return(NC_DOUBLE);
|
481
|
+
else rb_raise(rb_eNetcdfError, "No such NArray type '%s'",natype);
|
482
|
+
}
|
483
|
+
|
484
|
+
static int
|
485
|
+
natypecode2nctype(int natypecode)
|
486
|
+
{
|
487
|
+
if(natypecode==NA_BYTE) return(NC_BYTE);
|
488
|
+
else if(natypecode==NA_SINT) return(NC_SHORT);
|
489
|
+
else if(natypecode==NA_LINT) return(NC_INT);
|
490
|
+
else if(natypecode==NA_SFLOAT) return(NC_FLOAT);
|
491
|
+
else if(natypecode==NA_DFLOAT) return(NC_DOUBLE);
|
492
|
+
else rb_raise(rb_eNetcdfError, "No such NArray typecode '%d'",natypecode);
|
493
|
+
}
|
494
|
+
|
495
|
+
static void
|
496
|
+
nc_mark_obj(struct NetCDFVar *netcdf_var)
|
497
|
+
{
|
498
|
+
VALUE ptr;
|
499
|
+
|
500
|
+
ptr = netcdf_var->file;
|
501
|
+
rb_gc_mark(ptr);
|
502
|
+
}
|
503
|
+
|
504
|
+
|
505
|
+
VALUE
|
506
|
+
NetCDF_clone(VALUE file)
|
507
|
+
{
|
508
|
+
VALUE clone;
|
509
|
+
struct Netcdf *nc1, *nc2;
|
510
|
+
|
511
|
+
Data_Get_Struct(file, struct Netcdf, nc1);
|
512
|
+
nc2 = NetCDF_init(nc1->ncid, nc1->name);
|
513
|
+
clone = Data_Wrap_Struct(cNetCDF, 0, NetCDF_free, nc2);
|
514
|
+
CLONESETUP(clone, file);
|
515
|
+
return clone;
|
516
|
+
}
|
517
|
+
|
518
|
+
VALUE
|
519
|
+
NetCDF_dim_clone(VALUE dim)
|
520
|
+
{
|
521
|
+
VALUE clone;
|
522
|
+
struct NetCDFDim *nd1, *nd2;
|
523
|
+
|
524
|
+
Data_Get_Struct(dim, struct NetCDFDim, nd1);
|
525
|
+
nd2 = NetCDF_dim_init(nd1->ncid, nd1->dimid);
|
526
|
+
clone = Data_Wrap_Struct(cNetCDFDim, 0, NetCDF_dim_free, nd2);
|
527
|
+
CLONESETUP(clone, dim);
|
528
|
+
return clone;
|
529
|
+
}
|
530
|
+
|
531
|
+
VALUE
|
532
|
+
NetCDF_att_clone(VALUE att)
|
533
|
+
{
|
534
|
+
VALUE clone;
|
535
|
+
struct NetCDFAtt *na1, *na2;
|
536
|
+
|
537
|
+
Data_Get_Struct(att, struct NetCDFAtt, na1);
|
538
|
+
na2 = NetCDF_att_init(na1->ncid, na1->varid, na1->name);
|
539
|
+
clone = Data_Wrap_Struct(cNetCDFAtt, 0, Netcdf_att_free, na2);
|
540
|
+
CLONESETUP(clone, att);
|
541
|
+
return clone;
|
542
|
+
}
|
543
|
+
|
544
|
+
VALUE
|
545
|
+
NetCDF_var_clone(VALUE var)
|
546
|
+
{
|
547
|
+
VALUE clone;
|
548
|
+
struct NetCDFVar *nv1, *nv2;
|
549
|
+
|
550
|
+
Data_Get_Struct(var, struct NetCDFVar, nv1);
|
551
|
+
nv2 = NetCDF_var_init(nv1->ncid, nv1->varid, nv1->file);
|
552
|
+
clone = Data_Wrap_Struct(cNetCDFVar, nc_mark_obj, NetCDF_var_free, nv2);
|
553
|
+
CLONESETUP(clone, var);
|
554
|
+
return clone;
|
555
|
+
}
|
556
|
+
|
557
|
+
VALUE
|
558
|
+
NetCDF_close(file)
|
559
|
+
VALUE file;
|
560
|
+
{
|
561
|
+
int status;
|
562
|
+
int ncid;
|
563
|
+
struct Netcdf *Netcdffile;
|
564
|
+
|
565
|
+
if (rb_safe_level() >= 4 && !OBJ_TAINTED(file)) {
|
566
|
+
rb_raise(rb_eSecurityError, "Insecure: can't close");
|
567
|
+
}
|
568
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
569
|
+
ncid=Netcdffile->ncid;
|
570
|
+
if(!Netcdffile->closed){
|
571
|
+
status = nc_close(ncid);
|
572
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
573
|
+
Netcdffile->closed = 1;
|
574
|
+
} else {
|
575
|
+
rb_warn("file %s is already closed", Netcdffile->name);
|
576
|
+
}
|
577
|
+
return Qnil;
|
578
|
+
}
|
579
|
+
|
580
|
+
VALUE
|
581
|
+
NetCDF_def_dim(VALUE file,VALUE dim_name,VALUE length)
|
582
|
+
{
|
583
|
+
char* c_dim_name;
|
584
|
+
size_t c_length;
|
585
|
+
int ncid;
|
586
|
+
int dimidp;
|
587
|
+
int status;
|
588
|
+
struct Netcdf *Netcdffile;
|
589
|
+
struct NetCDFDim *Netcdf_dim;
|
590
|
+
VALUE Dimension;
|
591
|
+
|
592
|
+
rb_secure(4);
|
593
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
594
|
+
|
595
|
+
Check_Type(dim_name,T_STRING);
|
596
|
+
c_dim_name=RSTRING_PTR(dim_name);
|
597
|
+
c_length=NUM2UINT(length);
|
598
|
+
ncid=Netcdffile->ncid;
|
599
|
+
|
600
|
+
status = nc_def_dim(ncid,c_dim_name,c_length,&dimidp);
|
601
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
602
|
+
|
603
|
+
Netcdf_dim = NetCDF_dim_init(ncid,dimidp);
|
604
|
+
|
605
|
+
Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim);
|
606
|
+
return Dimension;
|
607
|
+
}
|
608
|
+
|
609
|
+
|
610
|
+
static VALUE
|
611
|
+
NetCDF_put_att_char(int ncid, char *name,VALUE value,VALUE atttype, int varid)
|
612
|
+
{
|
613
|
+
int status;
|
614
|
+
struct NetCDFAtt *ncatt;
|
615
|
+
|
616
|
+
/* check atttype (not necessarily needed but it's better to do it) */
|
617
|
+
if (TYPE(atttype) == T_STRING){
|
618
|
+
if ( natype2nctype(RSTRING_PTR(atttype)) != NC_CHAR ) {
|
619
|
+
rb_raise(rb_eNetcdfError,
|
620
|
+
"attribute type must be 'char' (or nil) for a String value");
|
621
|
+
}
|
622
|
+
} else if (TYPE(atttype) != T_NIL) {
|
623
|
+
rb_raise(rb_eNetcdfError,
|
624
|
+
"type specfication must be by a string or nil");
|
625
|
+
}
|
626
|
+
/* put value */
|
627
|
+
Check_Type(value,T_STRING);
|
628
|
+
status = nc_put_att_text(ncid, varid, name,
|
629
|
+
RSTRING_LEN(value), RSTRING_PTR(value));
|
630
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
631
|
+
|
632
|
+
ncatt = NetCDF_att_init(ncid,varid,name);
|
633
|
+
return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,ncatt));
|
634
|
+
}
|
635
|
+
|
636
|
+
static VALUE
|
637
|
+
NetCDF_put_att_numeric(int ncid, char *name,VALUE value,VALUE atttype, int varid)
|
638
|
+
{
|
639
|
+
VALUE val;
|
640
|
+
struct NARRAY *na_val;
|
641
|
+
int na_typecode, status, len;
|
642
|
+
char *ptr;
|
643
|
+
struct NetCDFAtt *ncatt;
|
644
|
+
|
645
|
+
/* check atttype and cast to an appropriate NArray if needed */
|
646
|
+
|
647
|
+
if (TYPE(atttype) != T_NIL){
|
648
|
+
na_typecode = na_get_typecode(atttype);
|
649
|
+
GetNArray( na_cast_object(value, na_typecode), na_val );
|
650
|
+
} else {
|
651
|
+
if (TYPE(value)==T_ARRAY) {
|
652
|
+
val = RARRAY_PTR(value)[0]; /* to check the 1st elemnt if Array */
|
653
|
+
} else {
|
654
|
+
val = value;
|
655
|
+
}
|
656
|
+
switch(TYPE(val)){
|
657
|
+
case T_FIXNUM:
|
658
|
+
case T_BIGNUM:
|
659
|
+
na_typecode = NA_LINT;
|
660
|
+
GetNArray( na_cast_object(value, na_typecode), na_val );
|
661
|
+
break;
|
662
|
+
case T_FLOAT:
|
663
|
+
na_typecode = NA_DFLOAT;
|
664
|
+
GetNArray( na_cast_object(value, na_typecode), na_val );
|
665
|
+
break;
|
666
|
+
case T_DATA:
|
667
|
+
if ( IsNArray(value) ){
|
668
|
+
GetNArray(value,na_val);
|
669
|
+
na_typecode = na_val->type;
|
670
|
+
} else {
|
671
|
+
rb_raise(rb_eNetcdfError,"value has a wrong data type");
|
672
|
+
}
|
673
|
+
break;
|
674
|
+
default:
|
675
|
+
rb_raise(rb_eNetcdfError,
|
676
|
+
"value (or its first element) has a wrong type");
|
677
|
+
}
|
678
|
+
}
|
679
|
+
|
680
|
+
/* put value */
|
681
|
+
|
682
|
+
len = na_val->total;
|
683
|
+
ptr = na_val->ptr;
|
684
|
+
switch(na_typecode){
|
685
|
+
case NA_BYTE:
|
686
|
+
status = nc_put_att_uchar(ncid,varid,name,NC_BYTE,len,(unsigned char *)ptr);
|
687
|
+
break;
|
688
|
+
case NA_SINT:
|
689
|
+
status = nc_put_att_short(ncid,varid,name,NC_SHORT,len,(short *)ptr);
|
690
|
+
break;
|
691
|
+
case NA_LINT:
|
692
|
+
status = nc_put_att_int(ncid,varid,name,NC_INT,len,(int *)ptr);
|
693
|
+
break;
|
694
|
+
case NA_SFLOAT:
|
695
|
+
status = nc_put_att_float(ncid,varid,name,NC_FLOAT,len,(float *)ptr);
|
696
|
+
break;
|
697
|
+
case NA_DFLOAT:
|
698
|
+
status = nc_put_att_double(ncid,varid,name,NC_DOUBLE,len,(double*)ptr);
|
699
|
+
break;
|
700
|
+
default:
|
701
|
+
rb_raise(rb_eNetcdfError,
|
702
|
+
"unsupported type. code = %d",na_typecode);
|
703
|
+
}
|
704
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
705
|
+
|
706
|
+
ncatt = NetCDF_att_init(ncid,varid,name);
|
707
|
+
return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,ncatt));
|
708
|
+
}
|
709
|
+
|
710
|
+
static VALUE
|
711
|
+
NetCDF_put_att__(int ncid, char *name, VALUE value, VALUE atttype, int varid)
|
712
|
+
/*
|
713
|
+
* atttype: nil or a String ("string","int",etc). If nil,
|
714
|
+
* the type of attribute is determined from the type of value
|
715
|
+
*/
|
716
|
+
{
|
717
|
+
switch(TYPE(value)){
|
718
|
+
case T_STRING:
|
719
|
+
return(NetCDF_put_att_char(ncid, name, value, atttype, varid));
|
720
|
+
default:
|
721
|
+
return(NetCDF_put_att_numeric(ncid, name, value, atttype, varid));
|
722
|
+
}
|
723
|
+
}
|
724
|
+
|
725
|
+
VALUE
|
726
|
+
NetCDF_put_att(VALUE file,VALUE att_name,VALUE value,VALUE atttype)
|
727
|
+
/*
|
728
|
+
* atttype: nil or a String ("string","int",etc). If nil,
|
729
|
+
* the type of attribute is determined from the type of value
|
730
|
+
*/
|
731
|
+
{
|
732
|
+
struct Netcdf *ncfile;
|
733
|
+
char *name;
|
734
|
+
|
735
|
+
rb_secure(4);
|
736
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
737
|
+
Check_Type(att_name,T_STRING);
|
738
|
+
name = RSTRING_PTR(att_name);
|
739
|
+
|
740
|
+
return( NetCDF_put_att__(ncfile->ncid, name, value, atttype, NC_GLOBAL) );
|
741
|
+
}
|
742
|
+
|
743
|
+
VALUE
|
744
|
+
NetCDF_put_att_var(VALUE var,VALUE att_name,VALUE value,VALUE atttype)
|
745
|
+
/*
|
746
|
+
* atttype: nil or a String ("string","int",etc). If nil,
|
747
|
+
* the type of attribute is determined from the type of value
|
748
|
+
*/
|
749
|
+
{
|
750
|
+
struct NetCDFVar *ncvar;
|
751
|
+
char *name;
|
752
|
+
|
753
|
+
rb_secure(4);
|
754
|
+
Data_Get_Struct(var,struct NetCDFVar,ncvar);
|
755
|
+
Check_Type(att_name,T_STRING);
|
756
|
+
name = RSTRING_PTR(att_name);
|
757
|
+
|
758
|
+
return( NetCDF_put_att__(ncvar->ncid, name, value, atttype, ncvar->varid));
|
759
|
+
}
|
760
|
+
|
761
|
+
|
762
|
+
VALUE
|
763
|
+
NetCDF_def_var(VALUE file,VALUE var_name,VALUE vartype,VALUE dimensions)
|
764
|
+
{
|
765
|
+
int ncid;
|
766
|
+
char *c_var_name;
|
767
|
+
static int xtype;
|
768
|
+
long c_ndims;
|
769
|
+
int varidp;
|
770
|
+
int dimidp;
|
771
|
+
int i=0;
|
772
|
+
int status;
|
773
|
+
char *c_dim_name;
|
774
|
+
int c_dimids[NC_MAX_DIMS];
|
775
|
+
struct Netcdf *Netcdffile;
|
776
|
+
struct NetCDFVar *Netcdf_var;
|
777
|
+
struct NetCDFDim *Netcdf_dim;
|
778
|
+
VALUE Var;
|
779
|
+
|
780
|
+
rb_secure(4);
|
781
|
+
Check_Type(var_name,T_STRING);
|
782
|
+
Check_Type(dimensions,T_ARRAY);
|
783
|
+
|
784
|
+
c_var_name=RSTRING_PTR(var_name);
|
785
|
+
c_ndims=RARRAY_LEN(dimensions);
|
786
|
+
|
787
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
788
|
+
ncid=Netcdffile->ncid;
|
789
|
+
|
790
|
+
if (TYPE(vartype) == T_STRING){
|
791
|
+
xtype = natype2nctype(RSTRING_PTR(vartype));
|
792
|
+
} else if (TYPE(vartype) == T_FIXNUM){
|
793
|
+
xtype = natypecode2nctype(NUM2INT(vartype));
|
794
|
+
} else {
|
795
|
+
rb_raise(rb_eNetcdfError,
|
796
|
+
"type specfication must be by a string or nil");
|
797
|
+
}
|
798
|
+
|
799
|
+
for(i=0;i<c_ndims;i++){
|
800
|
+
switch(TYPE(RARRAY_PTR(dimensions)[c_ndims-1-i])){
|
801
|
+
case T_STRING:
|
802
|
+
Check_Type(RARRAY_PTR(dimensions)[c_ndims-1-i],T_STRING);
|
803
|
+
c_dim_name=StringValueCStr(RARRAY_PTR(dimensions)[c_ndims-1-i]);
|
804
|
+
status=nc_inq_dimid(ncid,c_dim_name,&dimidp);
|
805
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
806
|
+
c_dimids[i]=dimidp;
|
807
|
+
break;
|
808
|
+
case T_DATA:
|
809
|
+
Data_Get_Struct(RARRAY_PTR(dimensions)[c_ndims-1-i],struct NetCDFDim,Netcdf_dim);
|
810
|
+
c_dimids[i]=Netcdf_dim->dimid;
|
811
|
+
break;
|
812
|
+
default:
|
813
|
+
rb_raise(rb_eNetcdfError, "No such object of the netCDF dimension class.");
|
814
|
+
}
|
815
|
+
}
|
816
|
+
|
817
|
+
status = nc_def_var(ncid,c_var_name,xtype,c_ndims,c_dimids,&varidp);
|
818
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
819
|
+
|
820
|
+
Netcdf_var = NetCDF_var_init(ncid,varidp,file);
|
821
|
+
|
822
|
+
Var=Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var);
|
823
|
+
return Var;
|
824
|
+
}
|
825
|
+
|
826
|
+
|
827
|
+
VALUE
|
828
|
+
NetCDF_dim(VALUE file,VALUE dim_name)
|
829
|
+
{
|
830
|
+
int ncid;
|
831
|
+
char *c_dim_name;
|
832
|
+
int dimidp;
|
833
|
+
int status;
|
834
|
+
struct Netcdf *Netcdffile;
|
835
|
+
struct NetCDFDim *Netcdf_dim;
|
836
|
+
VALUE Dimension;
|
837
|
+
|
838
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
839
|
+
ncid=Netcdffile->ncid;
|
840
|
+
Check_Type(dim_name,T_STRING);
|
841
|
+
c_dim_name=RSTRING_PTR(dim_name);
|
842
|
+
|
843
|
+
status = nc_inq_dimid(ncid,c_dim_name,&dimidp);
|
844
|
+
if(status !=NC_NOERR){
|
845
|
+
if(status == NC_EBADDIM){
|
846
|
+
return(Qnil); /*2003/08/27 back to orig (from changes on 2003/02/03)*/
|
847
|
+
} else{
|
848
|
+
NC_RAISE(status);
|
849
|
+
}
|
850
|
+
}
|
851
|
+
|
852
|
+
Netcdf_dim=NetCDF_dim_init(ncid,dimidp);
|
853
|
+
|
854
|
+
Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim);
|
855
|
+
return Dimension;
|
856
|
+
}
|
857
|
+
|
858
|
+
VALUE
|
859
|
+
NetCDF_var(VALUE file,VALUE var_name)
|
860
|
+
{
|
861
|
+
int ncid;
|
862
|
+
int status;
|
863
|
+
int varidp;
|
864
|
+
char *c_var_name;
|
865
|
+
struct Netcdf *Netcdffile;
|
866
|
+
struct NetCDFVar *Netcdf_var;
|
867
|
+
VALUE Variable;
|
868
|
+
|
869
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
870
|
+
ncid=Netcdffile->ncid;
|
871
|
+
Check_Type(var_name,T_STRING);
|
872
|
+
c_var_name=RSTRING_PTR(var_name);
|
873
|
+
|
874
|
+
status=nc_inq_varid(ncid,c_var_name,&varidp);
|
875
|
+
if(status != NC_NOERR){
|
876
|
+
if(status == NC_ENOTVAR){
|
877
|
+
return(Qnil); /*2003/08/27 back to orig (from changes on 2003/02/03)*/
|
878
|
+
} else{
|
879
|
+
NC_RAISE(status);
|
880
|
+
}
|
881
|
+
}
|
882
|
+
|
883
|
+
Netcdf_var = NetCDF_var_init(ncid,varidp,file);
|
884
|
+
Variable = Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var);
|
885
|
+
return Variable;
|
886
|
+
}
|
887
|
+
|
888
|
+
VALUE
|
889
|
+
NetCDF_att(VALUE file,VALUE att_name)
|
890
|
+
{
|
891
|
+
int ncid;
|
892
|
+
int status;
|
893
|
+
int attnump;
|
894
|
+
char *c_att_name;
|
895
|
+
struct Netcdf *Netcdffile;
|
896
|
+
struct NetCDFAtt *Netcdf_att;
|
897
|
+
VALUE Attribute;
|
898
|
+
|
899
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
900
|
+
ncid=Netcdffile->ncid;
|
901
|
+
Check_Type(att_name,T_STRING);
|
902
|
+
c_att_name=RSTRING_PTR(att_name);
|
903
|
+
|
904
|
+
|
905
|
+
status = nc_inq_attid(ncid,NC_GLOBAL,c_att_name,&attnump);
|
906
|
+
if(status != NC_NOERR){
|
907
|
+
if(status == NC_ENOTATT){
|
908
|
+
return(Qnil);
|
909
|
+
}
|
910
|
+
else{
|
911
|
+
NC_RAISE(status);
|
912
|
+
}
|
913
|
+
}
|
914
|
+
|
915
|
+
Netcdf_att = NetCDF_att_init(ncid,NC_GLOBAL,c_att_name);
|
916
|
+
|
917
|
+
Attribute = Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att);
|
918
|
+
|
919
|
+
return Attribute;
|
920
|
+
}
|
921
|
+
VALUE
|
922
|
+
NetCDF_fill(VALUE file,VALUE mode)
|
923
|
+
{
|
924
|
+
int ncid;
|
925
|
+
int status;
|
926
|
+
struct Netcdf *Netcdffile;
|
927
|
+
int old_modep;
|
928
|
+
|
929
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
930
|
+
ncid = Netcdffile->ncid;
|
931
|
+
if(mode==Qfalse){
|
932
|
+
status = nc_set_fill(ncid,NC_NOFILL,&old_modep);
|
933
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
934
|
+
}
|
935
|
+
else if(mode == Qtrue){
|
936
|
+
status = nc_set_fill(ncid,NC_FILL,&old_modep);
|
937
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
938
|
+
}
|
939
|
+
else
|
940
|
+
rb_raise(rb_eNetcdfError,"Usage:self.fill(true) or self.fill(false)");
|
941
|
+
return Qnil;
|
942
|
+
}
|
943
|
+
|
944
|
+
VALUE
|
945
|
+
NetCDF_redef(VALUE file)
|
946
|
+
{
|
947
|
+
int ncid;
|
948
|
+
int status;
|
949
|
+
struct Netcdf *Netcdffile;
|
950
|
+
|
951
|
+
rb_secure(4);
|
952
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
953
|
+
ncid=Netcdffile->ncid;
|
954
|
+
status = nc_redef(ncid);
|
955
|
+
if(status !=NC_NOERR){
|
956
|
+
if(status == NC_EINDEFINE){
|
957
|
+
return Qnil;
|
958
|
+
}
|
959
|
+
else{
|
960
|
+
NC_RAISE(status);
|
961
|
+
}
|
962
|
+
}
|
963
|
+
return Qtrue;
|
964
|
+
}
|
965
|
+
|
966
|
+
VALUE
|
967
|
+
NetCDF_enddef(VALUE file)
|
968
|
+
{
|
969
|
+
int ncid;
|
970
|
+
int status;
|
971
|
+
struct Netcdf *Netcdffile;
|
972
|
+
|
973
|
+
rb_secure(4);
|
974
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
975
|
+
ncid=Netcdffile->ncid;
|
976
|
+
status = nc_enddef(ncid);
|
977
|
+
if(status !=NC_NOERR){
|
978
|
+
if(status == NC_ENOTINDEFINE){
|
979
|
+
return Qnil;
|
980
|
+
}
|
981
|
+
else{
|
982
|
+
NC_RAISE(status);
|
983
|
+
}
|
984
|
+
}
|
985
|
+
return Qtrue;
|
986
|
+
}
|
987
|
+
|
988
|
+
VALUE
|
989
|
+
NetCDF_whether_in_define_mode(VALUE file)
|
990
|
+
{
|
991
|
+
/* returns true if the NetCDF object is currently in the define mode,
|
992
|
+
false if in the data mode, and
|
993
|
+
nil if else (possibly the file is read-only, or some other
|
994
|
+
error occurred)
|
995
|
+
*/
|
996
|
+
int ncid;
|
997
|
+
int status;
|
998
|
+
struct Netcdf *Netcdffile;
|
999
|
+
|
1000
|
+
rb_secure(4);
|
1001
|
+
Data_Get_Struct(file,struct Netcdf,Netcdffile);
|
1002
|
+
ncid=Netcdffile->ncid;
|
1003
|
+
status = nc_redef(ncid);
|
1004
|
+
if(status == NC_EINDEFINE){
|
1005
|
+
return Qtrue;
|
1006
|
+
} else if(status == NC_NOERR) {
|
1007
|
+
/* was in the data mode --> recover the data mode and report false */
|
1008
|
+
status = nc_enddef(ncid);
|
1009
|
+
if(status == NC_NOERR) {
|
1010
|
+
return Qfalse;
|
1011
|
+
} else {
|
1012
|
+
return Qnil;
|
1013
|
+
}
|
1014
|
+
} else {
|
1015
|
+
return Qnil;
|
1016
|
+
}
|
1017
|
+
}
|
1018
|
+
|
1019
|
+
VALUE
|
1020
|
+
NetCDF_open(VALUE mod,VALUE filename,VALUE omode)
|
1021
|
+
{
|
1022
|
+
int status;
|
1023
|
+
int ncid;
|
1024
|
+
char* c_filename;
|
1025
|
+
int c_omode;
|
1026
|
+
struct Netcdf *ncfile;
|
1027
|
+
VALUE retval;
|
1028
|
+
|
1029
|
+
Check_Type(filename,T_STRING);
|
1030
|
+
SafeStringValue(filename);
|
1031
|
+
c_filename=RSTRING_PTR(filename);
|
1032
|
+
Check_Type(omode,T_FIXNUM);
|
1033
|
+
c_omode=NUM2INT(omode);
|
1034
|
+
|
1035
|
+
status = nc_open(c_filename,c_omode,&ncid);
|
1036
|
+
if(status !=NC_NOERR){NC_RAISE(status);}
|
1037
|
+
|
1038
|
+
ncfile = NetCDF_init(ncid,c_filename);
|
1039
|
+
retval = Data_Wrap_Struct(cNetCDF,0,NetCDF_free,ncfile);
|
1040
|
+
return( retval );
|
1041
|
+
}
|
1042
|
+
|
1043
|
+
VALUE
|
1044
|
+
NetCDF_create(VALUE mod,VALUE filename,VALUE cmode)
|
1045
|
+
{
|
1046
|
+
int ncid;
|
1047
|
+
int status;
|
1048
|
+
char* c_filename;
|
1049
|
+
int c_cmode;
|
1050
|
+
struct Netcdf *ncfile;
|
1051
|
+
|
1052
|
+
Check_Type(filename,T_STRING);
|
1053
|
+
SafeStringValue(filename);
|
1054
|
+
c_filename=RSTRING_PTR(filename);
|
1055
|
+
Check_Type(cmode,T_FIXNUM);
|
1056
|
+
c_cmode=NUM2INT(cmode);
|
1057
|
+
|
1058
|
+
status = nc_create(c_filename,c_cmode,&ncid);
|
1059
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1060
|
+
|
1061
|
+
ncfile = NetCDF_init(ncid,c_filename);
|
1062
|
+
return( Data_Wrap_Struct(cNetCDF,0,NetCDF_free,ncfile) );
|
1063
|
+
}
|
1064
|
+
|
1065
|
+
VALUE
|
1066
|
+
NetCDF_ndims(VALUE file)
|
1067
|
+
{
|
1068
|
+
int ncid;
|
1069
|
+
int ndimsp;
|
1070
|
+
VALUE Integer;
|
1071
|
+
int status;
|
1072
|
+
struct Netcdf *ncfile;
|
1073
|
+
|
1074
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1075
|
+
ncid=ncfile->ncid;
|
1076
|
+
status = nc_inq_ndims(ncid,&ndimsp);
|
1077
|
+
if(status != NC_NOERR) NC_RAISE (status);
|
1078
|
+
Integer = INT2NUM(ndimsp);
|
1079
|
+
return Integer;
|
1080
|
+
}
|
1081
|
+
|
1082
|
+
VALUE
|
1083
|
+
NetCDF_nvars(VALUE file)
|
1084
|
+
{
|
1085
|
+
int ncid;
|
1086
|
+
int nvarsp;
|
1087
|
+
int status;
|
1088
|
+
VALUE Integer;
|
1089
|
+
struct Netcdf *ncfile;
|
1090
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1091
|
+
ncid=ncfile->ncid;
|
1092
|
+
status = nc_inq_nvars(ncid,&nvarsp);
|
1093
|
+
if(status != NC_NOERR) NC_RAISE (status);
|
1094
|
+
Integer = INT2NUM(nvarsp);
|
1095
|
+
return Integer;
|
1096
|
+
}
|
1097
|
+
|
1098
|
+
VALUE
|
1099
|
+
NetCDF_natts(VALUE file)
|
1100
|
+
{
|
1101
|
+
int ncid;
|
1102
|
+
int nattsp;
|
1103
|
+
int status;
|
1104
|
+
VALUE Integer;
|
1105
|
+
struct Netcdf *ncfile;
|
1106
|
+
|
1107
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1108
|
+
ncid=ncfile->ncid;
|
1109
|
+
status=nc_inq_natts(ncid,&nattsp);
|
1110
|
+
if(status != NC_NOERR) NC_RAISE (status);
|
1111
|
+
Integer = INT2NUM(nattsp);
|
1112
|
+
return Integer;
|
1113
|
+
}
|
1114
|
+
|
1115
|
+
VALUE
|
1116
|
+
NetCDF_unlimited(VALUE file)
|
1117
|
+
{
|
1118
|
+
int ncid;
|
1119
|
+
int unlimdimidp;
|
1120
|
+
int status;
|
1121
|
+
struct Netcdf *ncfile;
|
1122
|
+
struct NetCDFDim *Netcdf_dim;
|
1123
|
+
VALUE Dimension;
|
1124
|
+
|
1125
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1126
|
+
ncid=ncfile->ncid;
|
1127
|
+
status=nc_inq_unlimdim(ncid,&unlimdimidp);
|
1128
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
1129
|
+
|
1130
|
+
Netcdf_dim = NetCDF_dim_init(ncid,unlimdimidp);
|
1131
|
+
|
1132
|
+
/* If unlimdimidp=-1,No unlimited dimension is defined in the netCDF dataset */
|
1133
|
+
if(unlimdimidp != -1)
|
1134
|
+
{
|
1135
|
+
Dimension = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim);
|
1136
|
+
return Dimension;
|
1137
|
+
}
|
1138
|
+
else
|
1139
|
+
{
|
1140
|
+
return Qnil;
|
1141
|
+
}
|
1142
|
+
}
|
1143
|
+
|
1144
|
+
VALUE
|
1145
|
+
NetCDF_sync(VALUE file)
|
1146
|
+
{
|
1147
|
+
int ncid;
|
1148
|
+
int status;
|
1149
|
+
struct Netcdf *ncfile;
|
1150
|
+
|
1151
|
+
rb_secure(4);
|
1152
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1153
|
+
ncid=ncfile->ncid;
|
1154
|
+
status = nc_sync(ncid);
|
1155
|
+
if(status !=NC_NOERR) NC_RAISE (status);
|
1156
|
+
return Qnil;
|
1157
|
+
}
|
1158
|
+
|
1159
|
+
VALUE
|
1160
|
+
NetCDF_path(VALUE file)
|
1161
|
+
{
|
1162
|
+
char *path;
|
1163
|
+
struct Netcdf *ncfile;
|
1164
|
+
|
1165
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1166
|
+
path=ncfile->name;
|
1167
|
+
return(rb_str_new2(path));
|
1168
|
+
}
|
1169
|
+
|
1170
|
+
VALUE
|
1171
|
+
NetCDF_dim_length(VALUE Dim)
|
1172
|
+
{
|
1173
|
+
int ncid;
|
1174
|
+
int status;
|
1175
|
+
int dimid;
|
1176
|
+
size_t lengthp;
|
1177
|
+
struct NetCDFDim *Netcdf_dim;
|
1178
|
+
|
1179
|
+
Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim);
|
1180
|
+
ncid=Netcdf_dim->ncid;
|
1181
|
+
dimid=Netcdf_dim->dimid;
|
1182
|
+
|
1183
|
+
status = nc_inq_dimlen(ncid,dimid,&lengthp);
|
1184
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1185
|
+
|
1186
|
+
return(INT2NUM(lengthp));
|
1187
|
+
}
|
1188
|
+
|
1189
|
+
VALUE
|
1190
|
+
NetCDF_dim_name(VALUE Dim,VALUE dimension_newname)
|
1191
|
+
{
|
1192
|
+
int ncid;
|
1193
|
+
int status;
|
1194
|
+
int dimid;
|
1195
|
+
char *c_dim_name;
|
1196
|
+
struct NetCDFDim *Netcdf_dim;
|
1197
|
+
|
1198
|
+
rb_secure(4);
|
1199
|
+
Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim);
|
1200
|
+
ncid=Netcdf_dim->ncid;
|
1201
|
+
dimid=Netcdf_dim->dimid;
|
1202
|
+
Check_Type(dimension_newname,T_STRING);
|
1203
|
+
c_dim_name = StringValueCStr(dimension_newname);
|
1204
|
+
|
1205
|
+
status = nc_rename_dim(ncid,dimid,c_dim_name);
|
1206
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
1207
|
+
|
1208
|
+
return Qnil;
|
1209
|
+
}
|
1210
|
+
|
1211
|
+
VALUE
|
1212
|
+
NetCDF_dim_inqname(VALUE Dim)
|
1213
|
+
{
|
1214
|
+
int ncid;
|
1215
|
+
int status;
|
1216
|
+
int dimid;
|
1217
|
+
char c_dim_name[NC_MAX_NAME];
|
1218
|
+
struct NetCDFDim *Netcdf_dim;
|
1219
|
+
VALUE str;
|
1220
|
+
|
1221
|
+
Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim);
|
1222
|
+
ncid=Netcdf_dim->ncid;
|
1223
|
+
dimid=Netcdf_dim->dimid;
|
1224
|
+
|
1225
|
+
status = nc_inq_dimname(ncid,dimid,c_dim_name);
|
1226
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
1227
|
+
|
1228
|
+
str = rb_str_new2(c_dim_name);
|
1229
|
+
OBJ_TAINT(str);
|
1230
|
+
return(str);
|
1231
|
+
}
|
1232
|
+
|
1233
|
+
VALUE
|
1234
|
+
NetCDF_dim_whether_unlimited(VALUE Dim)
|
1235
|
+
{
|
1236
|
+
int status;
|
1237
|
+
int uldid;
|
1238
|
+
struct NetCDFDim *Netcdf_dim;
|
1239
|
+
|
1240
|
+
Data_Get_Struct(Dim,struct NetCDFDim,Netcdf_dim);
|
1241
|
+
status=nc_inq_unlimdim(Netcdf_dim->ncid,&uldid);
|
1242
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
1243
|
+
if(Netcdf_dim->dimid == uldid){
|
1244
|
+
return(Qtrue);
|
1245
|
+
} else {
|
1246
|
+
return(Qfalse);
|
1247
|
+
}
|
1248
|
+
}
|
1249
|
+
|
1250
|
+
VALUE
|
1251
|
+
NetCDF_att_inq_name(VALUE Att)
|
1252
|
+
{
|
1253
|
+
char *c_att_name;
|
1254
|
+
struct NetCDFAtt *Netcdf_att;
|
1255
|
+
VALUE str;
|
1256
|
+
|
1257
|
+
Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att);
|
1258
|
+
c_att_name=Netcdf_att->name;
|
1259
|
+
|
1260
|
+
str = rb_str_new2(c_att_name);
|
1261
|
+
OBJ_TAINT(str);
|
1262
|
+
return(str);
|
1263
|
+
}
|
1264
|
+
|
1265
|
+
VALUE
|
1266
|
+
NetCDF_att_rename(VALUE Att,VALUE new_att_name)
|
1267
|
+
{
|
1268
|
+
int ncid;
|
1269
|
+
int status;
|
1270
|
+
int varid;
|
1271
|
+
char *c_att_name;
|
1272
|
+
char *c_new_att_name;
|
1273
|
+
struct NetCDFAtt *Netcdf_att;
|
1274
|
+
Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att);
|
1275
|
+
ncid=Netcdf_att->ncid;
|
1276
|
+
varid=Netcdf_att->varid;
|
1277
|
+
|
1278
|
+
c_att_name=Netcdf_att->name;
|
1279
|
+
|
1280
|
+
Check_Type(new_att_name,T_STRING);
|
1281
|
+
SafeStringValue(new_att_name);
|
1282
|
+
c_new_att_name=StringValueCStr(new_att_name);
|
1283
|
+
|
1284
|
+
status = nc_rename_att(ncid,varid,c_att_name,c_new_att_name);
|
1285
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1286
|
+
|
1287
|
+
strcpy(Netcdf_att->name,c_new_att_name);
|
1288
|
+
return Qnil;
|
1289
|
+
}
|
1290
|
+
|
1291
|
+
VALUE
|
1292
|
+
NetCDF_id2dim(VALUE file,VALUE dimid)
|
1293
|
+
{
|
1294
|
+
int ncid;
|
1295
|
+
int c_dimid;
|
1296
|
+
struct Netcdf *ncfile;
|
1297
|
+
struct NetCDFDim *Netcdf_dim;
|
1298
|
+
VALUE Dim;
|
1299
|
+
|
1300
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1301
|
+
ncid=ncfile->ncid;
|
1302
|
+
Check_Type(dimid,T_FIXNUM);
|
1303
|
+
c_dimid=NUM2INT(dimid);
|
1304
|
+
Netcdf_dim = NetCDF_dim_init(ncid,c_dimid);
|
1305
|
+
Dim=Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim);
|
1306
|
+
return(Dim);
|
1307
|
+
}
|
1308
|
+
|
1309
|
+
VALUE
|
1310
|
+
NetCDF_id2var(VALUE file,VALUE varid)
|
1311
|
+
{
|
1312
|
+
int ncid;
|
1313
|
+
int c_varid;
|
1314
|
+
struct Netcdf *ncfile;
|
1315
|
+
struct NetCDFVar *Netcdf_var;
|
1316
|
+
VALUE Var;
|
1317
|
+
|
1318
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1319
|
+
ncid=ncfile->ncid;
|
1320
|
+
Check_Type(varid,T_FIXNUM);
|
1321
|
+
c_varid=NUM2INT(varid);
|
1322
|
+
Netcdf_var = NetCDF_var_init(ncid,c_varid,file);
|
1323
|
+
Var=Data_Wrap_Struct(cNetCDFVar,nc_mark_obj,NetCDF_var_free,Netcdf_var);
|
1324
|
+
return(Var);
|
1325
|
+
}
|
1326
|
+
|
1327
|
+
|
1328
|
+
VALUE
|
1329
|
+
NetCDF_id2att(VALUE file,VALUE attnum)
|
1330
|
+
{
|
1331
|
+
int ncid;
|
1332
|
+
int c_attnum;
|
1333
|
+
int status;
|
1334
|
+
struct Netcdf *ncfile;
|
1335
|
+
struct NetCDFAtt *Netcdf_att;
|
1336
|
+
char *c_att_name;
|
1337
|
+
VALUE Att;
|
1338
|
+
c_att_name=ALLOCA_N(char,NC_MAX_NAME);
|
1339
|
+
|
1340
|
+
Data_Get_Struct(file,struct Netcdf,ncfile);
|
1341
|
+
ncid=ncfile->ncid;
|
1342
|
+
|
1343
|
+
Check_Type(attnum,T_FIXNUM);
|
1344
|
+
c_attnum=NUM2INT(attnum);
|
1345
|
+
|
1346
|
+
status = nc_inq_attname(ncid,NC_GLOBAL,c_attnum,c_att_name);
|
1347
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1348
|
+
|
1349
|
+
Netcdf_att=NetCDF_att_init(ncid,NC_GLOBAL,c_att_name);
|
1350
|
+
|
1351
|
+
Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att);
|
1352
|
+
return(Att);
|
1353
|
+
|
1354
|
+
}
|
1355
|
+
|
1356
|
+
VALUE
|
1357
|
+
NetCDF_var_id2att(VALUE Var,VALUE attnum)
|
1358
|
+
{
|
1359
|
+
int ncid;
|
1360
|
+
int c_attnum;
|
1361
|
+
int status;
|
1362
|
+
int c_varid;
|
1363
|
+
struct NetCDFVar *Netcdf_var;
|
1364
|
+
struct NetCDFAtt *Netcdf_att;
|
1365
|
+
char *c_att_name;
|
1366
|
+
VALUE Att;
|
1367
|
+
|
1368
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1369
|
+
ncid=Netcdf_var->ncid;
|
1370
|
+
c_varid=Netcdf_var->varid;
|
1371
|
+
|
1372
|
+
Check_Type(attnum,T_FIXNUM);
|
1373
|
+
c_attnum=NUM2INT(attnum);
|
1374
|
+
|
1375
|
+
c_att_name=ALLOCA_N(char,NC_MAX_NAME);
|
1376
|
+
|
1377
|
+
status = nc_inq_attname(ncid,c_varid,c_attnum,c_att_name);
|
1378
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1379
|
+
|
1380
|
+
Netcdf_att=NetCDF_att_init(ncid,c_varid,c_att_name);
|
1381
|
+
Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att);
|
1382
|
+
return(Att);
|
1383
|
+
}
|
1384
|
+
|
1385
|
+
VALUE
|
1386
|
+
NetCDF_var_dims(VALUE Var)
|
1387
|
+
{
|
1388
|
+
int ncid, *dimids, ndims, varid, i, status;
|
1389
|
+
struct NetCDFVar *Netcdf_var;
|
1390
|
+
struct NetCDFDim *Netcdf_dim;
|
1391
|
+
VALUE Dims;
|
1392
|
+
|
1393
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1394
|
+
ncid = Netcdf_var->ncid;
|
1395
|
+
varid = Netcdf_var->varid;
|
1396
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
1397
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1398
|
+
dimids=ALLOCA_N(int,ndims);
|
1399
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
1400
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1401
|
+
Dims = rb_ary_new();
|
1402
|
+
for(i=0;i<ndims;i++){
|
1403
|
+
Netcdf_dim = NetCDF_dim_init(ncid,dimids[ndims-1-i]);
|
1404
|
+
rb_ary_push(Dims,
|
1405
|
+
Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim));
|
1406
|
+
}
|
1407
|
+
return(Dims);
|
1408
|
+
}
|
1409
|
+
|
1410
|
+
VALUE
|
1411
|
+
NetCDF_var_dim(VALUE Var, VALUE ith)
|
1412
|
+
{
|
1413
|
+
int ncid, *dimids, ndims, varid, status, c_ith;
|
1414
|
+
struct NetCDFVar *Netcdf_var;
|
1415
|
+
struct NetCDFDim *Netcdf_dim;
|
1416
|
+
VALUE Dim;
|
1417
|
+
|
1418
|
+
Check_Type(ith,T_FIXNUM);
|
1419
|
+
c_ith=NUM2INT(ith);
|
1420
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1421
|
+
ncid = Netcdf_var->ncid;
|
1422
|
+
varid = Netcdf_var->varid;
|
1423
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
1424
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1425
|
+
if(c_ith < 0 || c_ith >= ndims) {
|
1426
|
+
rb_raise(rb_eNetcdfError, "dimension count less than zero or greater than ndims-1");
|
1427
|
+
}
|
1428
|
+
dimids=ALLOCA_N(int,ndims);
|
1429
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
1430
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1431
|
+
Netcdf_dim = NetCDF_dim_init(ncid,dimids[ndims-1-c_ith]);
|
1432
|
+
Dim = Data_Wrap_Struct(cNetCDFDim,0,NetCDF_dim_free,Netcdf_dim);
|
1433
|
+
return(Dim);
|
1434
|
+
}
|
1435
|
+
|
1436
|
+
VALUE
|
1437
|
+
NetCDF_att_copy(VALUE Att,VALUE Var_or_File)
|
1438
|
+
{
|
1439
|
+
int ncid_in,ncid_out;
|
1440
|
+
int status;
|
1441
|
+
int varid_in,varid_out;
|
1442
|
+
char *att_name;
|
1443
|
+
struct NetCDFAtt *Netcdf_att;
|
1444
|
+
struct NetCDFVar *Netcdf_var;
|
1445
|
+
struct Netcdf *ncfile;
|
1446
|
+
struct NetCDFAtt *Netcdf_att_out;
|
1447
|
+
|
1448
|
+
rb_secure(4);
|
1449
|
+
Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att);
|
1450
|
+
ncid_in=Netcdf_att->ncid;
|
1451
|
+
varid_in=Netcdf_att->varid;
|
1452
|
+
att_name=Netcdf_att->name;
|
1453
|
+
|
1454
|
+
if( rb_obj_is_kind_of(Var_or_File, cNetCDFVar) ){
|
1455
|
+
Data_Get_Struct(Var_or_File,struct NetCDFVar, Netcdf_var);
|
1456
|
+
ncid_out=Netcdf_var->ncid;
|
1457
|
+
varid_out=Netcdf_var->varid;
|
1458
|
+
} else if ( rb_obj_is_kind_of(Var_or_File, cNetCDF) ){
|
1459
|
+
Data_Get_Struct(Var_or_File,struct Netcdf, ncfile);
|
1460
|
+
ncid_out=ncfile->ncid;
|
1461
|
+
varid_out=NC_GLOBAL;
|
1462
|
+
} else {
|
1463
|
+
rb_raise(rb_eNetcdfError,"The argument must be a NetCDFVar or a NetCDF");
|
1464
|
+
}
|
1465
|
+
|
1466
|
+
status = nc_copy_att(ncid_in,varid_in,att_name,ncid_out,varid_out);
|
1467
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1468
|
+
Netcdf_att_out = NetCDF_att_init(ncid_out,varid_out,att_name);
|
1469
|
+
return (Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att_out));
|
1470
|
+
}
|
1471
|
+
|
1472
|
+
VALUE
|
1473
|
+
NetCDF_att_atttype(VALUE Att)
|
1474
|
+
{
|
1475
|
+
int ncid;
|
1476
|
+
int varid;
|
1477
|
+
int status;
|
1478
|
+
char *att_name;
|
1479
|
+
const char *Attname;
|
1480
|
+
struct NetCDFAtt *Netcdf_att;
|
1481
|
+
nc_type xtypep;
|
1482
|
+
|
1483
|
+
Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att);
|
1484
|
+
ncid = Netcdf_att->ncid;
|
1485
|
+
varid = Netcdf_att->varid;
|
1486
|
+
att_name = Netcdf_att->name;
|
1487
|
+
|
1488
|
+
status = nc_inq_atttype(ncid,varid,att_name,&xtypep);
|
1489
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1490
|
+
|
1491
|
+
Attname = nctype2natype(xtypep);
|
1492
|
+
return(rb_str_new2(Attname));
|
1493
|
+
}
|
1494
|
+
|
1495
|
+
VALUE
|
1496
|
+
NetCDF_att_typecode(VALUE Att)
|
1497
|
+
{
|
1498
|
+
int ncid;
|
1499
|
+
int varid;
|
1500
|
+
int status;
|
1501
|
+
char *att_name;
|
1502
|
+
struct NetCDFAtt *Netcdf_att;
|
1503
|
+
nc_type xtypep;
|
1504
|
+
|
1505
|
+
Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att);
|
1506
|
+
ncid = Netcdf_att->ncid;
|
1507
|
+
varid = Netcdf_att->varid;
|
1508
|
+
att_name = Netcdf_att->name;
|
1509
|
+
|
1510
|
+
status = nc_inq_atttype(ncid,varid,att_name,&xtypep);
|
1511
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1512
|
+
|
1513
|
+
return(INT2NUM(nctype2natypecode(xtypep)));
|
1514
|
+
}
|
1515
|
+
|
1516
|
+
VALUE
|
1517
|
+
NetCDF_att_delete(VALUE Att)
|
1518
|
+
{
|
1519
|
+
int ncid;
|
1520
|
+
int status;
|
1521
|
+
int varid;
|
1522
|
+
char *c_att_name;
|
1523
|
+
struct NetCDFAtt *Netcdf_att;
|
1524
|
+
|
1525
|
+
rb_secure(4);
|
1526
|
+
Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att);
|
1527
|
+
|
1528
|
+
ncid=Netcdf_att->ncid;
|
1529
|
+
varid=Netcdf_att->varid;
|
1530
|
+
c_att_name=Netcdf_att->name;
|
1531
|
+
|
1532
|
+
status = nc_del_att(ncid,varid,c_att_name);
|
1533
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1534
|
+
|
1535
|
+
return Qnil;
|
1536
|
+
}
|
1537
|
+
|
1538
|
+
VALUE
|
1539
|
+
NetCDF_att_put(VALUE Att,VALUE value,VALUE atttype)
|
1540
|
+
/*
|
1541
|
+
* atttype: nil or a String ("string","int",etc). If nil,
|
1542
|
+
* the type of attribute is determined from the type of value
|
1543
|
+
*/
|
1544
|
+
{
|
1545
|
+
struct NetCDFAtt *ncatt;
|
1546
|
+
|
1547
|
+
rb_secure(4);
|
1548
|
+
Data_Get_Struct(Att,struct NetCDFAtt,ncatt);
|
1549
|
+
return( NetCDF_put_att__(ncatt->ncid, ncatt->name, value,
|
1550
|
+
atttype, ncatt->varid) );
|
1551
|
+
}
|
1552
|
+
|
1553
|
+
VALUE
|
1554
|
+
NetCDF_att_get(VALUE Att)
|
1555
|
+
{
|
1556
|
+
int ncid;
|
1557
|
+
int varid;
|
1558
|
+
char *c_attname;
|
1559
|
+
int status;
|
1560
|
+
struct NetCDFAtt *Netcdf_att;
|
1561
|
+
nc_type xtypep;
|
1562
|
+
size_t lenp;
|
1563
|
+
int attlen[1]; /* NArray uses int instead of size_t */
|
1564
|
+
char *tp;
|
1565
|
+
unsigned char *up;
|
1566
|
+
short *sp;
|
1567
|
+
int *ip;
|
1568
|
+
float *fp;
|
1569
|
+
double *dp;
|
1570
|
+
VALUE NArray;
|
1571
|
+
VALUE str;
|
1572
|
+
|
1573
|
+
Data_Get_Struct(Att,struct NetCDFAtt,Netcdf_att);
|
1574
|
+
ncid = Netcdf_att->ncid;
|
1575
|
+
varid = Netcdf_att->varid;
|
1576
|
+
c_attname = Netcdf_att->name;
|
1577
|
+
|
1578
|
+
status = nc_inq_atttype(ncid,varid,c_attname,&xtypep);
|
1579
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1580
|
+
|
1581
|
+
switch(xtypep){
|
1582
|
+
case NC_CHAR:
|
1583
|
+
status = nc_inq_attlen(ncid,varid,c_attname,&lenp);
|
1584
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1585
|
+
tp = ALLOCA_N(char,lenp+1);
|
1586
|
+
tp[lenp]= '\0';
|
1587
|
+
status = nc_get_att_text(ncid,varid,c_attname,tp);
|
1588
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1589
|
+
str = rb_str_new2(tp);
|
1590
|
+
OBJ_TAINT(str);
|
1591
|
+
return(str);
|
1592
|
+
break;
|
1593
|
+
case NC_BYTE:
|
1594
|
+
status = nc_inq_attlen(ncid,varid,c_attname,&lenp);
|
1595
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1596
|
+
|
1597
|
+
attlen[0]=lenp;
|
1598
|
+
Cbyte_to_NArray(NArray,1,attlen,up);
|
1599
|
+
|
1600
|
+
status = nc_get_att_uchar(ncid,varid,c_attname,up);
|
1601
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1602
|
+
|
1603
|
+
OBJ_TAINT(NArray);
|
1604
|
+
return NArray;
|
1605
|
+
break;
|
1606
|
+
case NC_SHORT:
|
1607
|
+
status = nc_inq_attlen(ncid,varid,c_attname,&lenp);
|
1608
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1609
|
+
|
1610
|
+
attlen[0]=lenp;
|
1611
|
+
Csint_to_NArray(NArray,1,attlen,sp);
|
1612
|
+
|
1613
|
+
status = nc_get_att_short(ncid,varid,c_attname,sp);
|
1614
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1615
|
+
OBJ_TAINT(NArray);
|
1616
|
+
return NArray;
|
1617
|
+
break;
|
1618
|
+
case NC_INT:
|
1619
|
+
status = nc_inq_attlen(ncid,varid,c_attname,&lenp);
|
1620
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1621
|
+
|
1622
|
+
attlen[0]=lenp;
|
1623
|
+
Clint_to_NArray(NArray,1,attlen,ip);
|
1624
|
+
|
1625
|
+
status = nc_get_att_int(ncid,varid,c_attname,ip);
|
1626
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1627
|
+
|
1628
|
+
OBJ_TAINT(NArray);
|
1629
|
+
return NArray;
|
1630
|
+
break;
|
1631
|
+
case NC_FLOAT:
|
1632
|
+
status = nc_inq_attlen(ncid,varid,c_attname,&lenp);
|
1633
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1634
|
+
|
1635
|
+
attlen[0]=lenp;
|
1636
|
+
Cfloat_to_NArray(NArray,1,attlen,fp);
|
1637
|
+
|
1638
|
+
status = nc_get_att_float(ncid,varid,c_attname,fp);
|
1639
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1640
|
+
|
1641
|
+
OBJ_TAINT(NArray);
|
1642
|
+
return NArray;
|
1643
|
+
break;
|
1644
|
+
case NC_DOUBLE:
|
1645
|
+
status = nc_inq_attlen(ncid,varid,c_attname,&lenp);
|
1646
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1647
|
+
|
1648
|
+
attlen[0]=lenp;
|
1649
|
+
Cdouble_to_NArray(NArray,1,attlen,dp);
|
1650
|
+
|
1651
|
+
status = nc_get_att_double(ncid,varid,c_attname,dp);
|
1652
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1653
|
+
OBJ_TAINT(NArray);
|
1654
|
+
return NArray;
|
1655
|
+
break;
|
1656
|
+
default:
|
1657
|
+
rb_raise(rb_eNetcdfError,"atttype isn't supported in netCDF");
|
1658
|
+
}
|
1659
|
+
return Qnil;
|
1660
|
+
}
|
1661
|
+
|
1662
|
+
|
1663
|
+
VALUE
|
1664
|
+
NetCDF_var_inq_name(VALUE Var)
|
1665
|
+
{
|
1666
|
+
int ncid;
|
1667
|
+
int status;
|
1668
|
+
int varid;
|
1669
|
+
char c_var_name[NC_MAX_NAME];
|
1670
|
+
struct NetCDFVar *Netcdf_var;
|
1671
|
+
VALUE Var_name;
|
1672
|
+
|
1673
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1674
|
+
|
1675
|
+
ncid=Netcdf_var->ncid;
|
1676
|
+
varid=Netcdf_var->varid;
|
1677
|
+
status = nc_inq_varname(ncid,varid,c_var_name);
|
1678
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1679
|
+
|
1680
|
+
Var_name=rb_str_new2(c_var_name);
|
1681
|
+
OBJ_TAINT(Var_name);
|
1682
|
+
return Var_name;
|
1683
|
+
}
|
1684
|
+
|
1685
|
+
VALUE
|
1686
|
+
NetCDF_var_ndims(VALUE Var)
|
1687
|
+
{
|
1688
|
+
int ncid;
|
1689
|
+
int status;
|
1690
|
+
int varid;
|
1691
|
+
int ndimsp;
|
1692
|
+
struct NetCDFVar *Netcdf_var;
|
1693
|
+
VALUE Var_ndims;
|
1694
|
+
|
1695
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1696
|
+
|
1697
|
+
ncid=Netcdf_var->ncid;
|
1698
|
+
varid=Netcdf_var->varid;
|
1699
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
1700
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1701
|
+
Var_ndims=INT2FIX(ndimsp);
|
1702
|
+
return Var_ndims;
|
1703
|
+
}
|
1704
|
+
|
1705
|
+
VALUE
|
1706
|
+
NetCDF_var_vartype(VALUE Var)
|
1707
|
+
{
|
1708
|
+
int ncid;
|
1709
|
+
int status;
|
1710
|
+
int varid;
|
1711
|
+
nc_type xtypep;
|
1712
|
+
struct NetCDFVar *Netcdf_var;
|
1713
|
+
const char *Vartype;
|
1714
|
+
|
1715
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1716
|
+
|
1717
|
+
ncid=Netcdf_var->ncid;
|
1718
|
+
varid=Netcdf_var->varid;
|
1719
|
+
|
1720
|
+
status = nc_inq_vartype(ncid,varid,&xtypep);
|
1721
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1722
|
+
|
1723
|
+
Vartype=nctype2natype(xtypep);
|
1724
|
+
return(rb_str_new2(Vartype));
|
1725
|
+
}
|
1726
|
+
|
1727
|
+
VALUE
|
1728
|
+
NetCDF_var_typecode(VALUE Var)
|
1729
|
+
{
|
1730
|
+
int ncid;
|
1731
|
+
int status;
|
1732
|
+
int varid;
|
1733
|
+
nc_type xtypep;
|
1734
|
+
struct NetCDFVar *Netcdf_var;
|
1735
|
+
|
1736
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1737
|
+
|
1738
|
+
ncid=Netcdf_var->ncid;
|
1739
|
+
varid=Netcdf_var->varid;
|
1740
|
+
|
1741
|
+
status = nc_inq_vartype(ncid,varid,&xtypep);
|
1742
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1743
|
+
|
1744
|
+
return(INT2NUM(nctype2natypecode(xtypep)));
|
1745
|
+
}
|
1746
|
+
|
1747
|
+
|
1748
|
+
VALUE
|
1749
|
+
NetCDF_var_natts(VALUE Var)
|
1750
|
+
{
|
1751
|
+
int ncid;
|
1752
|
+
int status;
|
1753
|
+
int varid;
|
1754
|
+
int nattsp;
|
1755
|
+
struct NetCDFVar *Netcdf_var;
|
1756
|
+
VALUE Var_natts;
|
1757
|
+
|
1758
|
+
|
1759
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1760
|
+
|
1761
|
+
ncid=Netcdf_var->ncid;
|
1762
|
+
varid=Netcdf_var->varid;
|
1763
|
+
|
1764
|
+
status= nc_inq_varnatts(ncid,varid,&nattsp);
|
1765
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
1766
|
+
|
1767
|
+
Var_natts=INT2FIX(nattsp);
|
1768
|
+
return Var_natts;
|
1769
|
+
}
|
1770
|
+
|
1771
|
+
VALUE
|
1772
|
+
NetCDF_var_file(VALUE Var)
|
1773
|
+
{
|
1774
|
+
struct NetCDFVar *Netcdf_var;
|
1775
|
+
/* VALUE file; */
|
1776
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1777
|
+
|
1778
|
+
return (Netcdf_var->file);
|
1779
|
+
}
|
1780
|
+
|
1781
|
+
VALUE
|
1782
|
+
NetCDF_var_rename(VALUE Var,VALUE var_new_name)
|
1783
|
+
{
|
1784
|
+
int ncid;
|
1785
|
+
int status;
|
1786
|
+
int varid;
|
1787
|
+
char *c_var_new_name;
|
1788
|
+
struct NetCDFVar *Netcdf_var;
|
1789
|
+
|
1790
|
+
rb_secure(4);
|
1791
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1792
|
+
ncid=Netcdf_var->ncid;
|
1793
|
+
varid=Netcdf_var->varid;
|
1794
|
+
|
1795
|
+
Check_Type(var_new_name,T_STRING);
|
1796
|
+
c_var_new_name=StringValueCStr(var_new_name);
|
1797
|
+
|
1798
|
+
status = nc_rename_var(ncid,varid,c_var_new_name);
|
1799
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
1800
|
+
|
1801
|
+
return Qnil;
|
1802
|
+
}
|
1803
|
+
|
1804
|
+
VALUE
|
1805
|
+
NetCDF_var_att(VALUE Var,VALUE att_name)
|
1806
|
+
{
|
1807
|
+
int ncid;
|
1808
|
+
int status;
|
1809
|
+
int varid;
|
1810
|
+
char *c_att_name;
|
1811
|
+
int c_attnump;
|
1812
|
+
struct NetCDFVar *Netcdf_var;
|
1813
|
+
struct NetCDFAtt *Netcdf_att;
|
1814
|
+
VALUE Att;
|
1815
|
+
|
1816
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1817
|
+
|
1818
|
+
ncid=Netcdf_var->ncid;
|
1819
|
+
varid=Netcdf_var->varid;
|
1820
|
+
|
1821
|
+
Check_Type(att_name,T_STRING);
|
1822
|
+
c_att_name=StringValueCStr(att_name);
|
1823
|
+
|
1824
|
+
status = nc_inq_attid(ncid,varid,c_att_name,&c_attnump);
|
1825
|
+
if(status == NC_NOERR){
|
1826
|
+
Netcdf_att=NetCDF_att_init(ncid,varid,c_att_name);
|
1827
|
+
Att=Data_Wrap_Struct(cNetCDFAtt,0,Netcdf_att_free,Netcdf_att);
|
1828
|
+
return Att;
|
1829
|
+
}
|
1830
|
+
else if(status == NC_ENOTATT){
|
1831
|
+
return Qnil;
|
1832
|
+
}
|
1833
|
+
else{
|
1834
|
+
NC_RAISE(status);
|
1835
|
+
return Qnil;
|
1836
|
+
}
|
1837
|
+
}
|
1838
|
+
|
1839
|
+
/* Redifinition of the "==" and "eql?" methods */
|
1840
|
+
|
1841
|
+
VALUE
|
1842
|
+
NetCDF_eql(VALUE filea,VALUE fileb)
|
1843
|
+
{
|
1844
|
+
struct Netcdf *ncfilea;
|
1845
|
+
struct Netcdf *ncfileb;
|
1846
|
+
|
1847
|
+
if( rb_obj_is_kind_of(fileb, cNetCDF) ){
|
1848
|
+
Data_Get_Struct(filea,struct Netcdf,ncfilea);
|
1849
|
+
Data_Get_Struct(fileb,struct Netcdf,ncfileb);
|
1850
|
+
|
1851
|
+
if(ncfilea->ncid == ncfileb->ncid &&
|
1852
|
+
strcmp(ncfilea->name,ncfileb->name)==0){
|
1853
|
+
return Qtrue;
|
1854
|
+
} else {
|
1855
|
+
return Qfalse;
|
1856
|
+
}
|
1857
|
+
} else {
|
1858
|
+
return Qfalse;
|
1859
|
+
}
|
1860
|
+
}
|
1861
|
+
|
1862
|
+
VALUE
|
1863
|
+
NetCDF_var_eql(VALUE Vara,VALUE Varb)
|
1864
|
+
{
|
1865
|
+
struct NetCDFVar *Netcdf_vara;
|
1866
|
+
struct NetCDFVar *Netcdf_varb;
|
1867
|
+
|
1868
|
+
if( rb_obj_is_kind_of(Varb, cNetCDFVar) ){
|
1869
|
+
Data_Get_Struct(Vara,struct NetCDFVar,Netcdf_vara);
|
1870
|
+
Data_Get_Struct(Varb,struct NetCDFVar,Netcdf_varb);
|
1871
|
+
|
1872
|
+
if(Netcdf_vara->ncid == Netcdf_varb->ncid &&
|
1873
|
+
Netcdf_vara->varid == Netcdf_varb->varid){
|
1874
|
+
return Qtrue;
|
1875
|
+
} else {
|
1876
|
+
return Qfalse;
|
1877
|
+
}
|
1878
|
+
} else {
|
1879
|
+
return Qfalse;
|
1880
|
+
}
|
1881
|
+
}
|
1882
|
+
|
1883
|
+
VALUE
|
1884
|
+
NetCDF_dim_eql(VALUE Dima,VALUE Dimb)
|
1885
|
+
{
|
1886
|
+
struct NetCDFDim *Netcdf_dima;
|
1887
|
+
struct NetCDFDim *Netcdf_dimb;
|
1888
|
+
|
1889
|
+
if( rb_obj_is_kind_of(Dimb, cNetCDFDim) ){
|
1890
|
+
Data_Get_Struct(Dima,struct NetCDFDim,Netcdf_dima);
|
1891
|
+
Data_Get_Struct(Dimb,struct NetCDFDim,Netcdf_dimb);
|
1892
|
+
|
1893
|
+
if(Netcdf_dima->ncid == Netcdf_dimb->ncid &&
|
1894
|
+
Netcdf_dima->dimid == Netcdf_dimb->dimid){
|
1895
|
+
return Qtrue;
|
1896
|
+
} else {
|
1897
|
+
return Qfalse;
|
1898
|
+
}
|
1899
|
+
} else {
|
1900
|
+
return Qfalse;
|
1901
|
+
}
|
1902
|
+
}
|
1903
|
+
|
1904
|
+
VALUE
|
1905
|
+
NetCDF_att_eql(VALUE Atta,VALUE Attb)
|
1906
|
+
{
|
1907
|
+
struct NetCDFAtt *Netcdf_atta;
|
1908
|
+
struct NetCDFAtt *Netcdf_attb;
|
1909
|
+
|
1910
|
+
if( rb_obj_is_kind_of(Attb, cNetCDFAtt) ){
|
1911
|
+
Data_Get_Struct(Atta,struct NetCDFAtt,Netcdf_atta);
|
1912
|
+
Data_Get_Struct(Attb,struct NetCDFAtt,Netcdf_attb);
|
1913
|
+
|
1914
|
+
if(Netcdf_atta->ncid == Netcdf_atta->ncid &&
|
1915
|
+
Netcdf_atta->varid == Netcdf_attb->varid &&
|
1916
|
+
strcmp(Netcdf_atta->name,Netcdf_attb->name)==0){
|
1917
|
+
return Qtrue;
|
1918
|
+
} else {
|
1919
|
+
return Qfalse;
|
1920
|
+
}
|
1921
|
+
} else {
|
1922
|
+
return Qfalse;
|
1923
|
+
}
|
1924
|
+
}
|
1925
|
+
|
1926
|
+
/* Follow methods is to connect "NArray" with "Netcdf" */
|
1927
|
+
VALUE
|
1928
|
+
NetCDF_get_var_char(VALUE Var)
|
1929
|
+
{
|
1930
|
+
int ncid;
|
1931
|
+
int varid;
|
1932
|
+
int status;
|
1933
|
+
unsigned char *ptr;
|
1934
|
+
struct NetCDFVar *Netcdf_var;
|
1935
|
+
int i=0;
|
1936
|
+
int ndimsp;
|
1937
|
+
int *dimids;
|
1938
|
+
size_t lengthp;
|
1939
|
+
int *shape; /* NArray uses int instead of size_t */
|
1940
|
+
VALUE NArray;
|
1941
|
+
|
1942
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1943
|
+
ncid = Netcdf_var->ncid;
|
1944
|
+
varid = Netcdf_var->varid;
|
1945
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
1946
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1947
|
+
dimids = ALLOCA_N(int,ndimsp);
|
1948
|
+
if (ndimsp != 0){
|
1949
|
+
shape = ALLOCA_N(int,ndimsp);
|
1950
|
+
for(i=0;i<ndimsp;i++){
|
1951
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
1952
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1953
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
1954
|
+
shape[ndimsp-1-i]=lengthp;
|
1955
|
+
}
|
1956
|
+
} else {
|
1957
|
+
ndimsp = 1;
|
1958
|
+
shape = ALLOCA_N(int,1);
|
1959
|
+
shape[0]=1;
|
1960
|
+
}
|
1961
|
+
|
1962
|
+
Cbyte_to_NArray(NArray,ndimsp,shape,ptr);
|
1963
|
+
|
1964
|
+
status = nc_get_var_text(ncid,varid,(char *)ptr);
|
1965
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1966
|
+
|
1967
|
+
OBJ_TAINT(NArray);
|
1968
|
+
return NArray;
|
1969
|
+
}
|
1970
|
+
|
1971
|
+
VALUE
|
1972
|
+
NetCDF_get_var_byte(VALUE Var)
|
1973
|
+
{
|
1974
|
+
int ncid;
|
1975
|
+
int varid;
|
1976
|
+
int status;
|
1977
|
+
unsigned char *ptr;
|
1978
|
+
struct NetCDFVar *Netcdf_var;
|
1979
|
+
int i=0;
|
1980
|
+
int ndimsp;
|
1981
|
+
int *dimids;
|
1982
|
+
size_t lengthp;
|
1983
|
+
int *shape; /* NArray uses int instead of size_t */
|
1984
|
+
VALUE NArray;
|
1985
|
+
|
1986
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
1987
|
+
ncid = Netcdf_var->ncid;
|
1988
|
+
varid = Netcdf_var->varid;
|
1989
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
1990
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1991
|
+
dimids = ALLOCA_N(int,ndimsp);
|
1992
|
+
if (ndimsp != 0){
|
1993
|
+
shape = ALLOCA_N(int,ndimsp);
|
1994
|
+
for(i=0;i<ndimsp;i++){
|
1995
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
1996
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
1997
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
1998
|
+
shape[ndimsp-1-i]=lengthp;
|
1999
|
+
}
|
2000
|
+
} else {
|
2001
|
+
ndimsp = 1;
|
2002
|
+
shape = ALLOCA_N(int,1);
|
2003
|
+
shape[0]=1;
|
2004
|
+
}
|
2005
|
+
|
2006
|
+
Cbyte_to_NArray(NArray,ndimsp,shape,ptr);
|
2007
|
+
|
2008
|
+
status = nc_get_var_uchar(ncid,varid,ptr);
|
2009
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2010
|
+
|
2011
|
+
OBJ_TAINT(NArray);
|
2012
|
+
return NArray;
|
2013
|
+
}
|
2014
|
+
|
2015
|
+
VALUE
|
2016
|
+
NetCDF_get_var_sint(VALUE Var)
|
2017
|
+
{
|
2018
|
+
int ncid;
|
2019
|
+
int varid;
|
2020
|
+
int status;
|
2021
|
+
short *ptr;
|
2022
|
+
struct NetCDFVar *Netcdf_var;
|
2023
|
+
int i=0;
|
2024
|
+
int ndimsp;
|
2025
|
+
int *dimids;
|
2026
|
+
size_t lengthp;
|
2027
|
+
int *shape; /* NArray uses int instead of size_t */
|
2028
|
+
VALUE NArray;
|
2029
|
+
|
2030
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2031
|
+
ncid = Netcdf_var->ncid;
|
2032
|
+
varid = Netcdf_var->varid;
|
2033
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
2034
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2035
|
+
dimids = ALLOCA_N(int,ndimsp);
|
2036
|
+
if (ndimsp != 0){
|
2037
|
+
shape = ALLOCA_N(int,ndimsp);
|
2038
|
+
for(i=0;i<ndimsp;i++){
|
2039
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2040
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2041
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
2042
|
+
shape[ndimsp-1-i]=lengthp;
|
2043
|
+
}
|
2044
|
+
} else {
|
2045
|
+
ndimsp = 1;
|
2046
|
+
shape = ALLOCA_N(int,1);
|
2047
|
+
shape[0]=1;
|
2048
|
+
}
|
2049
|
+
|
2050
|
+
Csint_to_NArray(NArray,ndimsp,shape,ptr);
|
2051
|
+
|
2052
|
+
status = nc_get_var_short(ncid,varid,ptr);
|
2053
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2054
|
+
|
2055
|
+
OBJ_TAINT(NArray);
|
2056
|
+
return NArray;
|
2057
|
+
}
|
2058
|
+
|
2059
|
+
VALUE
|
2060
|
+
NetCDF_get_var_int(VALUE Var)
|
2061
|
+
{
|
2062
|
+
int ncid;
|
2063
|
+
int varid;
|
2064
|
+
int status;
|
2065
|
+
int *ptr;
|
2066
|
+
struct NetCDFVar *Netcdf_var;
|
2067
|
+
int i=0;
|
2068
|
+
int ndimsp;
|
2069
|
+
int *dimids;
|
2070
|
+
size_t lengthp;
|
2071
|
+
int *shape; /* NArray uses int instead of size_t */
|
2072
|
+
VALUE NArray;
|
2073
|
+
|
2074
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2075
|
+
ncid = Netcdf_var->ncid;
|
2076
|
+
varid = Netcdf_var->varid;
|
2077
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
2078
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2079
|
+
dimids = ALLOCA_N(int,ndimsp);
|
2080
|
+
if (ndimsp != 0){
|
2081
|
+
shape = ALLOCA_N(int,ndimsp);
|
2082
|
+
for(i=0;i<ndimsp;i++){
|
2083
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2084
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2085
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
2086
|
+
shape[ndimsp-1-i]=lengthp;
|
2087
|
+
}
|
2088
|
+
} else {
|
2089
|
+
ndimsp = 1;
|
2090
|
+
shape = ALLOCA_N(int,1);
|
2091
|
+
shape[0]=1;
|
2092
|
+
}
|
2093
|
+
|
2094
|
+
Clint_to_NArray(NArray,ndimsp,shape,ptr);
|
2095
|
+
|
2096
|
+
status = nc_get_var_int(ncid,varid,ptr);
|
2097
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2098
|
+
|
2099
|
+
OBJ_TAINT(NArray);
|
2100
|
+
return NArray;
|
2101
|
+
}
|
2102
|
+
|
2103
|
+
VALUE
|
2104
|
+
NetCDF_get_var_float(VALUE Var)
|
2105
|
+
{
|
2106
|
+
int ncid;
|
2107
|
+
int varid;
|
2108
|
+
int status;
|
2109
|
+
float *ptr;
|
2110
|
+
struct NetCDFVar *Netcdf_var;
|
2111
|
+
int i=0;
|
2112
|
+
int ndimsp;
|
2113
|
+
int *dimids;
|
2114
|
+
size_t lengthp;
|
2115
|
+
int *shape; /* NArray uses int instead of size_t */
|
2116
|
+
VALUE NArray;
|
2117
|
+
|
2118
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2119
|
+
ncid = Netcdf_var->ncid;
|
2120
|
+
varid = Netcdf_var->varid;
|
2121
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
2122
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2123
|
+
dimids = ALLOCA_N(int,ndimsp);
|
2124
|
+
if (ndimsp != 0){
|
2125
|
+
shape = ALLOCA_N(int,ndimsp);
|
2126
|
+
for(i=0;i<ndimsp;i++){
|
2127
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2128
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2129
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
2130
|
+
shape[ndimsp-1-i]=lengthp;
|
2131
|
+
}
|
2132
|
+
} else {
|
2133
|
+
ndimsp = 1;
|
2134
|
+
shape = ALLOCA_N(int,1);
|
2135
|
+
shape[0]=1;
|
2136
|
+
}
|
2137
|
+
|
2138
|
+
Cfloat_to_NArray(NArray,ndimsp,shape,ptr);
|
2139
|
+
|
2140
|
+
status = nc_get_var_float(ncid,varid,ptr);
|
2141
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2142
|
+
|
2143
|
+
OBJ_TAINT(NArray);
|
2144
|
+
return NArray;
|
2145
|
+
}
|
2146
|
+
|
2147
|
+
VALUE
|
2148
|
+
NetCDF_get_var_double(VALUE Var)
|
2149
|
+
{
|
2150
|
+
int ncid;
|
2151
|
+
int varid;
|
2152
|
+
int status;
|
2153
|
+
double *ptr;
|
2154
|
+
struct NetCDFVar *Netcdf_var;
|
2155
|
+
int i=0;
|
2156
|
+
int ndimsp;
|
2157
|
+
int *dimids;
|
2158
|
+
size_t lengthp;
|
2159
|
+
int *shape; /* NArray uses int instead of size_t */
|
2160
|
+
VALUE NArray;
|
2161
|
+
|
2162
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2163
|
+
ncid = Netcdf_var->ncid;
|
2164
|
+
varid = Netcdf_var->varid;
|
2165
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
2166
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2167
|
+
dimids = ALLOCA_N(int,ndimsp);
|
2168
|
+
if (ndimsp != 0){
|
2169
|
+
shape = ALLOCA_N(int,ndimsp);
|
2170
|
+
for(i=0;i<ndimsp;i++){
|
2171
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2172
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2173
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
2174
|
+
shape[ndimsp-1-i]=lengthp;
|
2175
|
+
}
|
2176
|
+
} else {
|
2177
|
+
ndimsp = 1;
|
2178
|
+
shape = ALLOCA_N(int,1);
|
2179
|
+
shape[0]=1;
|
2180
|
+
}
|
2181
|
+
|
2182
|
+
Cdouble_to_NArray(NArray,ndimsp,shape,ptr);
|
2183
|
+
|
2184
|
+
status = nc_get_var_double(ncid,varid,ptr);
|
2185
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2186
|
+
|
2187
|
+
OBJ_TAINT(NArray);
|
2188
|
+
return NArray;
|
2189
|
+
}
|
2190
|
+
|
2191
|
+
VALUE
|
2192
|
+
NetCDF_get_var1_char(VALUE Var,VALUE start)
|
2193
|
+
{
|
2194
|
+
int ncid;
|
2195
|
+
int varid;
|
2196
|
+
int status;
|
2197
|
+
unsigned char *ptr;
|
2198
|
+
int i;
|
2199
|
+
struct NetCDFVar *Netcdf_var;
|
2200
|
+
long l_start;
|
2201
|
+
size_t *c_start;
|
2202
|
+
int ndims;
|
2203
|
+
int dimids[NC_MAX_DIMS];
|
2204
|
+
size_t dimlen;
|
2205
|
+
int *c_count;
|
2206
|
+
int nc_tlen=0;
|
2207
|
+
VALUE NArray;
|
2208
|
+
|
2209
|
+
|
2210
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2211
|
+
ncid = Netcdf_var->ncid;
|
2212
|
+
varid = Netcdf_var->varid;
|
2213
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
2214
|
+
if(status != NC_NOERR)NC_RAISE(status);
|
2215
|
+
if(ndims == 0) {
|
2216
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2217
|
+
}
|
2218
|
+
|
2219
|
+
Check_Type(start,T_ARRAY);
|
2220
|
+
if(RARRAY_LEN(start) < ndims) {
|
2221
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
2222
|
+
}
|
2223
|
+
|
2224
|
+
c_start=ALLOCA_N(size_t,ndims);
|
2225
|
+
c_count=ALLOCA_N(int,ndims);
|
2226
|
+
for(i=0;i<ndims;i++){
|
2227
|
+
l_start = NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2228
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2229
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2230
|
+
if(l_start < 0) {
|
2231
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2232
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2233
|
+
l_start += dimlen;
|
2234
|
+
}
|
2235
|
+
c_start[i]=l_start;
|
2236
|
+
|
2237
|
+
c_count[i]=1;
|
2238
|
+
nc_tlen = 1+nc_tlen;
|
2239
|
+
}
|
2240
|
+
|
2241
|
+
|
2242
|
+
|
2243
|
+
|
2244
|
+
Cbyte_to_NArray(NArray,ndims,c_count,ptr);
|
2245
|
+
status = nc_get_var1_text(ncid,varid,c_start,(char *)ptr);
|
2246
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2247
|
+
|
2248
|
+
OBJ_TAINT(NArray);
|
2249
|
+
return NArray;
|
2250
|
+
|
2251
|
+
}
|
2252
|
+
|
2253
|
+
VALUE
|
2254
|
+
NetCDF_get_var1_byte(VALUE Var,VALUE start)
|
2255
|
+
{
|
2256
|
+
int ncid;
|
2257
|
+
int varid;
|
2258
|
+
int status;
|
2259
|
+
unsigned char *ptr;
|
2260
|
+
int i;
|
2261
|
+
struct NetCDFVar *Netcdf_var;
|
2262
|
+
long l_start;
|
2263
|
+
size_t *c_start;
|
2264
|
+
int ndims;
|
2265
|
+
int dimids[NC_MAX_DIMS];
|
2266
|
+
size_t dimlen;
|
2267
|
+
int *c_count;
|
2268
|
+
int nc_tlen=0;
|
2269
|
+
VALUE NArray;
|
2270
|
+
|
2271
|
+
|
2272
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2273
|
+
ncid = Netcdf_var->ncid;
|
2274
|
+
varid = Netcdf_var->varid;
|
2275
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
2276
|
+
if(status != NC_NOERR)NC_RAISE(status);
|
2277
|
+
if(ndims == 0) {
|
2278
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2279
|
+
}
|
2280
|
+
|
2281
|
+
Check_Type(start,T_ARRAY);
|
2282
|
+
if(RARRAY_LEN(start) < ndims) {
|
2283
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
2284
|
+
}
|
2285
|
+
|
2286
|
+
c_start=ALLOCA_N(size_t,ndims);
|
2287
|
+
c_count=ALLOCA_N(int,ndims);
|
2288
|
+
for(i=0;i<ndims;i++){
|
2289
|
+
l_start = NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2290
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2291
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2292
|
+
if(l_start < 0) {
|
2293
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2294
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2295
|
+
l_start += dimlen;
|
2296
|
+
}
|
2297
|
+
c_start[i]=l_start;
|
2298
|
+
|
2299
|
+
c_count[i]=1;
|
2300
|
+
nc_tlen = 1+nc_tlen;
|
2301
|
+
}
|
2302
|
+
|
2303
|
+
|
2304
|
+
|
2305
|
+
|
2306
|
+
Cbyte_to_NArray(NArray,ndims,c_count,ptr);
|
2307
|
+
status = nc_get_var1_uchar(ncid,varid,c_start,ptr);
|
2308
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2309
|
+
|
2310
|
+
OBJ_TAINT(NArray);
|
2311
|
+
return NArray;
|
2312
|
+
|
2313
|
+
}
|
2314
|
+
|
2315
|
+
VALUE
|
2316
|
+
NetCDF_get_var1_sint(VALUE Var,VALUE start)
|
2317
|
+
{
|
2318
|
+
int ncid;
|
2319
|
+
int varid;
|
2320
|
+
int status;
|
2321
|
+
short *ptr;
|
2322
|
+
int i;
|
2323
|
+
struct NetCDFVar *Netcdf_var;
|
2324
|
+
long l_start;
|
2325
|
+
size_t *c_start;
|
2326
|
+
int ndims;
|
2327
|
+
int dimids[NC_MAX_DIMS];
|
2328
|
+
size_t dimlen;
|
2329
|
+
int *c_count;
|
2330
|
+
int nc_tlen=0;
|
2331
|
+
VALUE NArray;
|
2332
|
+
|
2333
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2334
|
+
ncid = Netcdf_var->ncid;
|
2335
|
+
varid = Netcdf_var->varid;
|
2336
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
2337
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2338
|
+
if(ndims == 0) {
|
2339
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2340
|
+
}
|
2341
|
+
|
2342
|
+
Check_Type(start,T_ARRAY);
|
2343
|
+
if(RARRAY_LEN(start) < ndims) {
|
2344
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
2345
|
+
}
|
2346
|
+
|
2347
|
+
c_start=ALLOCA_N(size_t,ndims);
|
2348
|
+
c_count=ALLOCA_N(int,ndims);
|
2349
|
+
for(i=0;i<ndims;i++){
|
2350
|
+
l_start = NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2351
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2352
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2353
|
+
if(l_start < 0) {
|
2354
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2355
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2356
|
+
l_start += dimlen;
|
2357
|
+
}
|
2358
|
+
c_start[i]=l_start;
|
2359
|
+
c_count[i]=1;
|
2360
|
+
nc_tlen = nc_tlen+1;
|
2361
|
+
}
|
2362
|
+
|
2363
|
+
Csint_to_NArray(NArray,ndims,c_count,ptr);
|
2364
|
+
|
2365
|
+
status = nc_get_var1_short(ncid,varid,c_start,ptr);
|
2366
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2367
|
+
|
2368
|
+
OBJ_TAINT(NArray);
|
2369
|
+
return NArray;
|
2370
|
+
|
2371
|
+
}
|
2372
|
+
|
2373
|
+
VALUE
|
2374
|
+
NetCDF_get_var1_int(VALUE Var,VALUE start)
|
2375
|
+
{
|
2376
|
+
int ncid;
|
2377
|
+
int varid;
|
2378
|
+
int status;
|
2379
|
+
int *ptr;
|
2380
|
+
int i;
|
2381
|
+
struct NetCDFVar *Netcdf_var;
|
2382
|
+
long l_start;
|
2383
|
+
size_t *c_start;
|
2384
|
+
int ndims;
|
2385
|
+
int dimids[NC_MAX_DIMS];
|
2386
|
+
size_t dimlen;
|
2387
|
+
int *c_count;
|
2388
|
+
int nc_tlen=0;
|
2389
|
+
VALUE NArray;
|
2390
|
+
|
2391
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2392
|
+
ncid = Netcdf_var->ncid;
|
2393
|
+
varid = Netcdf_var->varid;
|
2394
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
2395
|
+
if(status != NC_NOERR)NC_RAISE(status);
|
2396
|
+
if(ndims == 0) {
|
2397
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2398
|
+
}
|
2399
|
+
|
2400
|
+
Check_Type(start,T_ARRAY);
|
2401
|
+
if(RARRAY_LEN(start) < ndims) {
|
2402
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
2403
|
+
}
|
2404
|
+
|
2405
|
+
c_start=ALLOCA_N(size_t,ndims);
|
2406
|
+
c_count=ALLOCA_N(int,ndims);
|
2407
|
+
for(i=0;i<ndims;i++){
|
2408
|
+
l_start = NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2409
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2410
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2411
|
+
if(l_start < 0) {
|
2412
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2413
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2414
|
+
l_start += dimlen;
|
2415
|
+
}
|
2416
|
+
c_start[i]=l_start;
|
2417
|
+
c_count[i]=1;
|
2418
|
+
nc_tlen= nc_tlen+1;
|
2419
|
+
}
|
2420
|
+
|
2421
|
+
Clint_to_NArray(NArray,ndims,c_count,ptr);
|
2422
|
+
|
2423
|
+
status = nc_get_var1_int(ncid,varid,c_start,ptr);
|
2424
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2425
|
+
|
2426
|
+
OBJ_TAINT(NArray);
|
2427
|
+
return NArray;
|
2428
|
+
|
2429
|
+
}
|
2430
|
+
|
2431
|
+
VALUE
|
2432
|
+
NetCDF_get_var1_float(VALUE Var,VALUE start)
|
2433
|
+
{
|
2434
|
+
int ncid;
|
2435
|
+
int varid;
|
2436
|
+
int status;
|
2437
|
+
float *ptr;
|
2438
|
+
int i;
|
2439
|
+
struct NetCDFVar *Netcdf_var;
|
2440
|
+
long l_start;
|
2441
|
+
size_t *c_start;
|
2442
|
+
int ndims;
|
2443
|
+
int dimids[NC_MAX_DIMS];
|
2444
|
+
size_t dimlen;
|
2445
|
+
int *c_count;
|
2446
|
+
int nc_tlen=0;
|
2447
|
+
VALUE NArray;
|
2448
|
+
|
2449
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2450
|
+
ncid = Netcdf_var->ncid;
|
2451
|
+
varid = Netcdf_var->varid;
|
2452
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
2453
|
+
if(status != NC_NOERR)NC_RAISE(status);
|
2454
|
+
if(ndims == 0) {
|
2455
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2456
|
+
}
|
2457
|
+
|
2458
|
+
Check_Type(start,T_ARRAY);
|
2459
|
+
if(RARRAY_LEN(start) < ndims) {
|
2460
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
2461
|
+
}
|
2462
|
+
|
2463
|
+
c_start=ALLOCA_N(size_t,ndims);
|
2464
|
+
c_count=ALLOCA_N(int,ndims);
|
2465
|
+
for(i=0;i<ndims;i++){
|
2466
|
+
l_start = NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2467
|
+
status = nc_inq_vardimid(ncid, varid, dimids);
|
2468
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2469
|
+
if(l_start < 0) {
|
2470
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2471
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2472
|
+
l_start += dimlen;
|
2473
|
+
}
|
2474
|
+
c_start[i]=l_start;
|
2475
|
+
c_count[i]=1;
|
2476
|
+
nc_tlen = nc_tlen+1;
|
2477
|
+
}
|
2478
|
+
|
2479
|
+
Cfloat_to_NArray(NArray,ndims,c_count,ptr);
|
2480
|
+
|
2481
|
+
status = nc_get_var1_float(ncid,varid,c_start,ptr);
|
2482
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2483
|
+
|
2484
|
+
OBJ_TAINT(NArray);
|
2485
|
+
return NArray;
|
2486
|
+
|
2487
|
+
}
|
2488
|
+
|
2489
|
+
VALUE
|
2490
|
+
NetCDF_get_var1_double(VALUE Var,VALUE start)
|
2491
|
+
{
|
2492
|
+
int ncid;
|
2493
|
+
int varid;
|
2494
|
+
int status;
|
2495
|
+
double *ptr;
|
2496
|
+
int i;
|
2497
|
+
struct NetCDFVar *Netcdf_var;
|
2498
|
+
long l_start;
|
2499
|
+
size_t *c_start;
|
2500
|
+
int ndims;
|
2501
|
+
int dimids[NC_MAX_DIMS];
|
2502
|
+
size_t dimlen;
|
2503
|
+
int *c_count;
|
2504
|
+
int nc_tlen=0;
|
2505
|
+
VALUE NArray;
|
2506
|
+
|
2507
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2508
|
+
ncid = Netcdf_var->ncid;
|
2509
|
+
varid = Netcdf_var->varid;
|
2510
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
2511
|
+
if(status != NC_NOERR)NC_RAISE(status);
|
2512
|
+
if(ndims == 0) {
|
2513
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2514
|
+
}
|
2515
|
+
|
2516
|
+
Check_Type(start,T_ARRAY);
|
2517
|
+
if(RARRAY_LEN(start) < ndims) {
|
2518
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
2519
|
+
}
|
2520
|
+
|
2521
|
+
c_start=ALLOCA_N(size_t,ndims);
|
2522
|
+
c_count=ALLOCA_N(int,ndims);
|
2523
|
+
for(i=0;i<ndims;i++){
|
2524
|
+
l_start = NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2525
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2526
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
2527
|
+
if(l_start < 0) {
|
2528
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2529
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2530
|
+
l_start += dimlen;
|
2531
|
+
}
|
2532
|
+
c_start[i]=l_start;
|
2533
|
+
c_count[i]=1;
|
2534
|
+
nc_tlen = nc_tlen+1;
|
2535
|
+
}
|
2536
|
+
|
2537
|
+
Cdouble_to_NArray(NArray,ndims,c_count,ptr);
|
2538
|
+
|
2539
|
+
status = nc_get_var1_double(ncid,varid,c_start,ptr);
|
2540
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2541
|
+
|
2542
|
+
OBJ_TAINT(NArray);
|
2543
|
+
return NArray;
|
2544
|
+
|
2545
|
+
}
|
2546
|
+
|
2547
|
+
VALUE
|
2548
|
+
NetCDF_get_vars_char(VALUE Var,VALUE start,VALUE end,VALUE stride)
|
2549
|
+
{
|
2550
|
+
int ncid;
|
2551
|
+
int varid;
|
2552
|
+
int status;
|
2553
|
+
unsigned char *ptr;
|
2554
|
+
int i;
|
2555
|
+
struct NetCDFVar *Netcdf_var;
|
2556
|
+
long l_start, l_end;
|
2557
|
+
size_t *c_start;
|
2558
|
+
size_t *c_count;
|
2559
|
+
ptrdiff_t *c_stride;
|
2560
|
+
int *shape; /* NArray uses int instead of size_t */
|
2561
|
+
int ndims;
|
2562
|
+
int *dimids;
|
2563
|
+
int nc_tlen=1;
|
2564
|
+
size_t dimlen;
|
2565
|
+
VALUE NArray;
|
2566
|
+
|
2567
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2568
|
+
ncid = Netcdf_var->ncid;
|
2569
|
+
varid = Netcdf_var->varid;
|
2570
|
+
|
2571
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
2572
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2573
|
+
if(ndims == 0) {
|
2574
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2575
|
+
}
|
2576
|
+
|
2577
|
+
dimids = ALLOCA_N(int,ndims);
|
2578
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2579
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2580
|
+
|
2581
|
+
Check_Type(start,T_ARRAY);
|
2582
|
+
if(RARRAY_LEN(start) < ndims){
|
2583
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
2584
|
+
}
|
2585
|
+
c_start = ALLOCA_N(size_t,ndims);
|
2586
|
+
for(i=0; i<ndims; i++){
|
2587
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2588
|
+
|
2589
|
+
if(l_start < 0) {
|
2590
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
2591
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2592
|
+
l_start += dimlen;
|
2593
|
+
}
|
2594
|
+
c_start[i]=l_start;
|
2595
|
+
}
|
2596
|
+
|
2597
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
2598
|
+
switch(TYPE(stride)){
|
2599
|
+
case T_NIL:
|
2600
|
+
for(i=0; i<ndims; i++){
|
2601
|
+
c_stride[i]=1;
|
2602
|
+
}
|
2603
|
+
break;
|
2604
|
+
default:
|
2605
|
+
Check_Type(stride,T_ARRAY);
|
2606
|
+
if(RARRAY_LEN(stride) < ndims) {
|
2607
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride is too short\n");
|
2608
|
+
}
|
2609
|
+
for(i=0;i<ndims; i++){
|
2610
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
2611
|
+
if(c_stride[i]==0){
|
2612
|
+
rb_raise(rb_eNetcdfError,"stride cannot be zero\n");
|
2613
|
+
}
|
2614
|
+
}
|
2615
|
+
}
|
2616
|
+
|
2617
|
+
c_count=ALLOCA_N(size_t,ndims);
|
2618
|
+
switch(TYPE(end)){
|
2619
|
+
case T_NIL:
|
2620
|
+
for(i=0; i<ndims; i++){
|
2621
|
+
nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2622
|
+
c_count[i]=(dimlen-c_start[i]-1)/c_stride[i]+1;
|
2623
|
+
}
|
2624
|
+
break;
|
2625
|
+
default:
|
2626
|
+
Check_Type(end,T_ARRAY);
|
2627
|
+
if(RARRAY_LEN(end) <ndims) {
|
2628
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
2629
|
+
}
|
2630
|
+
for(i=0; i<ndims; i++){
|
2631
|
+
l_end= NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
2632
|
+
if(l_end < 0) {
|
2633
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2634
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2635
|
+
l_end +=dimlen;
|
2636
|
+
}
|
2637
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
2638
|
+
}
|
2639
|
+
}
|
2640
|
+
for(i=0;i<ndims;i++){
|
2641
|
+
nc_tlen = nc_tlen*c_count[i];
|
2642
|
+
}
|
2643
|
+
|
2644
|
+
|
2645
|
+
shape = ALLOCA_N(int,ndims);
|
2646
|
+
for(i=0;i<ndims;i++){
|
2647
|
+
shape[ndims-1-i]=c_count[i];
|
2648
|
+
}
|
2649
|
+
|
2650
|
+
Cbyte_to_NArray(NArray,ndims,shape,ptr);
|
2651
|
+
|
2652
|
+
status = nc_get_vars_text(ncid,varid,c_start,c_count,c_stride,(char *)ptr);
|
2653
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2654
|
+
|
2655
|
+
OBJ_TAINT(NArray);
|
2656
|
+
return NArray;
|
2657
|
+
}
|
2658
|
+
|
2659
|
+
VALUE
|
2660
|
+
NetCDF_get_vars_byte(VALUE Var,VALUE start,VALUE end,VALUE stride)
|
2661
|
+
{
|
2662
|
+
int ncid;
|
2663
|
+
int varid;
|
2664
|
+
int status;
|
2665
|
+
unsigned char *ptr;
|
2666
|
+
int i;
|
2667
|
+
struct NetCDFVar *Netcdf_var;
|
2668
|
+
long l_start, l_end;
|
2669
|
+
size_t *c_start;
|
2670
|
+
size_t *c_count;
|
2671
|
+
ptrdiff_t *c_stride;
|
2672
|
+
int *shape; /* NArray uses int instead of size_t */
|
2673
|
+
int ndims;
|
2674
|
+
int *dimids;
|
2675
|
+
int nc_tlen=1;
|
2676
|
+
size_t dimlen;
|
2677
|
+
VALUE NArray;
|
2678
|
+
|
2679
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2680
|
+
ncid = Netcdf_var->ncid;
|
2681
|
+
varid = Netcdf_var->varid;
|
2682
|
+
|
2683
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
2684
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2685
|
+
if(ndims == 0) {
|
2686
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2687
|
+
}
|
2688
|
+
|
2689
|
+
dimids = ALLOCA_N(int,ndims);
|
2690
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2691
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2692
|
+
|
2693
|
+
Check_Type(start,T_ARRAY);
|
2694
|
+
if(RARRAY_LEN(start) < ndims){
|
2695
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
2696
|
+
}
|
2697
|
+
c_start = ALLOCA_N(size_t,ndims);
|
2698
|
+
for(i=0; i<ndims; i++){
|
2699
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2700
|
+
|
2701
|
+
if(l_start < 0) {
|
2702
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
2703
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2704
|
+
l_start += dimlen;
|
2705
|
+
}
|
2706
|
+
c_start[i]=l_start;
|
2707
|
+
}
|
2708
|
+
|
2709
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
2710
|
+
switch(TYPE(stride)){
|
2711
|
+
case T_NIL:
|
2712
|
+
for(i=0; i<ndims; i++){
|
2713
|
+
c_stride[i]=1;
|
2714
|
+
}
|
2715
|
+
break;
|
2716
|
+
default:
|
2717
|
+
Check_Type(stride,T_ARRAY);
|
2718
|
+
if(RARRAY_LEN(stride) < ndims) {
|
2719
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride is too short\n");
|
2720
|
+
}
|
2721
|
+
for(i=0;i<ndims; i++){
|
2722
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
2723
|
+
if(c_stride[i]==0){
|
2724
|
+
rb_raise(rb_eNetcdfError,"stride cannot be zero\n");
|
2725
|
+
}
|
2726
|
+
}
|
2727
|
+
}
|
2728
|
+
|
2729
|
+
c_count=ALLOCA_N(size_t,ndims);
|
2730
|
+
switch(TYPE(end)){
|
2731
|
+
case T_NIL:
|
2732
|
+
for(i=0; i<ndims; i++){
|
2733
|
+
nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2734
|
+
c_count[i]=(dimlen-c_start[i]-1)/c_stride[i]+1;
|
2735
|
+
}
|
2736
|
+
break;
|
2737
|
+
default:
|
2738
|
+
Check_Type(end,T_ARRAY);
|
2739
|
+
if(RARRAY_LEN(end) <ndims) {
|
2740
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
2741
|
+
}
|
2742
|
+
for(i=0; i<ndims; i++){
|
2743
|
+
l_end= NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
2744
|
+
if(l_end < 0) {
|
2745
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2746
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2747
|
+
l_end +=dimlen;
|
2748
|
+
}
|
2749
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
2750
|
+
}
|
2751
|
+
}
|
2752
|
+
for(i=0;i<ndims;i++){
|
2753
|
+
nc_tlen = nc_tlen*c_count[i];
|
2754
|
+
}
|
2755
|
+
|
2756
|
+
|
2757
|
+
shape = ALLOCA_N(int,ndims);
|
2758
|
+
for(i=0;i<ndims;i++){
|
2759
|
+
shape[ndims-1-i]=c_count[i];
|
2760
|
+
}
|
2761
|
+
|
2762
|
+
Cbyte_to_NArray(NArray,ndims,shape,ptr);
|
2763
|
+
|
2764
|
+
status = nc_get_vars_uchar(ncid,varid,c_start,c_count,c_stride,ptr);
|
2765
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2766
|
+
|
2767
|
+
OBJ_TAINT(NArray);
|
2768
|
+
return NArray;
|
2769
|
+
}
|
2770
|
+
|
2771
|
+
VALUE
|
2772
|
+
NetCDF_get_vars_sint(VALUE Var,VALUE start,VALUE end,VALUE stride)
|
2773
|
+
{
|
2774
|
+
int ncid;
|
2775
|
+
int varid;
|
2776
|
+
int status;
|
2777
|
+
short *ptr;
|
2778
|
+
int i;
|
2779
|
+
struct NetCDFVar *Netcdf_var;
|
2780
|
+
long l_start, l_end;
|
2781
|
+
size_t *c_start;
|
2782
|
+
size_t *c_count;
|
2783
|
+
ptrdiff_t *c_stride;
|
2784
|
+
int *shape; /* NArray uses int instead of size_t */
|
2785
|
+
int ndims;
|
2786
|
+
int *dimids;
|
2787
|
+
int nc_tlen=1;
|
2788
|
+
size_t dimlen;
|
2789
|
+
VALUE NArray;
|
2790
|
+
|
2791
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2792
|
+
ncid = Netcdf_var->ncid;
|
2793
|
+
varid = Netcdf_var->varid;
|
2794
|
+
|
2795
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
2796
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2797
|
+
if(ndims == 0) {
|
2798
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2799
|
+
}
|
2800
|
+
|
2801
|
+
dimids = ALLOCA_N(int,ndims);
|
2802
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2803
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2804
|
+
|
2805
|
+
Check_Type(start,T_ARRAY);
|
2806
|
+
if(RARRAY_LEN(start) < ndims){
|
2807
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
2808
|
+
}
|
2809
|
+
c_start = ALLOCA_N(size_t,ndims);
|
2810
|
+
for(i=0; i<ndims; i++){
|
2811
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2812
|
+
|
2813
|
+
if(l_start < 0) {
|
2814
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
2815
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2816
|
+
l_start += dimlen;
|
2817
|
+
}
|
2818
|
+
c_start[i]=l_start;
|
2819
|
+
}
|
2820
|
+
|
2821
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
2822
|
+
switch(TYPE(stride)){
|
2823
|
+
case T_NIL:
|
2824
|
+
for(i=0; i<ndims; i++){
|
2825
|
+
c_stride[i]=1;
|
2826
|
+
}
|
2827
|
+
break;
|
2828
|
+
default:
|
2829
|
+
Check_Type(stride,T_ARRAY);
|
2830
|
+
if(RARRAY_LEN(stride) < ndims) {
|
2831
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride is too short\n");
|
2832
|
+
}
|
2833
|
+
for(i=0;i<ndims; i++){
|
2834
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
2835
|
+
if(c_stride[i]==0){
|
2836
|
+
rb_raise(rb_eNetcdfError,"stride cannot be zero\n");
|
2837
|
+
}
|
2838
|
+
}
|
2839
|
+
}
|
2840
|
+
|
2841
|
+
c_count=ALLOCA_N(size_t,ndims);
|
2842
|
+
switch(TYPE(end)){
|
2843
|
+
case T_NIL:
|
2844
|
+
for(i=0; i<ndims; i++){
|
2845
|
+
nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2846
|
+
c_count[i]=(dimlen-c_start[i]-1)/c_stride[i]+1;
|
2847
|
+
}
|
2848
|
+
break;
|
2849
|
+
default:
|
2850
|
+
Check_Type(end,T_ARRAY);
|
2851
|
+
if(RARRAY_LEN(end) <ndims) {
|
2852
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
2853
|
+
}
|
2854
|
+
for(i=0; i<ndims; i++){
|
2855
|
+
l_end= NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
2856
|
+
if(l_end < 0) {
|
2857
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2858
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2859
|
+
l_end +=dimlen;
|
2860
|
+
}
|
2861
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
2862
|
+
}
|
2863
|
+
}
|
2864
|
+
|
2865
|
+
for(i=0;i<ndims;i++){
|
2866
|
+
nc_tlen = nc_tlen*c_count[i];
|
2867
|
+
}
|
2868
|
+
|
2869
|
+
shape = ALLOCA_N(int,ndims);
|
2870
|
+
for(i=0;i<ndims;i++){
|
2871
|
+
shape[ndims-1-i]=c_count[i];
|
2872
|
+
}
|
2873
|
+
|
2874
|
+
Csint_to_NArray(NArray,ndims,shape,ptr);
|
2875
|
+
|
2876
|
+
|
2877
|
+
status = nc_get_vars_short(ncid,varid,c_start,c_count,c_stride,ptr);
|
2878
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2879
|
+
|
2880
|
+
OBJ_TAINT(NArray);
|
2881
|
+
return NArray;
|
2882
|
+
}
|
2883
|
+
|
2884
|
+
VALUE
|
2885
|
+
NetCDF_get_vars_int(VALUE Var,VALUE start,VALUE end,VALUE stride)
|
2886
|
+
{
|
2887
|
+
int ncid;
|
2888
|
+
int varid;
|
2889
|
+
int status;
|
2890
|
+
int *ptr;
|
2891
|
+
int i;
|
2892
|
+
struct NetCDFVar *Netcdf_var;
|
2893
|
+
long l_start, l_end;
|
2894
|
+
size_t *c_start;
|
2895
|
+
size_t *c_count;
|
2896
|
+
ptrdiff_t *c_stride;
|
2897
|
+
int *shape; /* NArray uses int instead of size_t */
|
2898
|
+
int ndims;
|
2899
|
+
int *dimids;
|
2900
|
+
int nc_tlen=1;
|
2901
|
+
size_t dimlen;
|
2902
|
+
VALUE NArray;
|
2903
|
+
|
2904
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
2905
|
+
ncid = Netcdf_var->ncid;
|
2906
|
+
varid = Netcdf_var->varid;
|
2907
|
+
|
2908
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
2909
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2910
|
+
if(ndims == 0) {
|
2911
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
2912
|
+
}
|
2913
|
+
|
2914
|
+
dimids = ALLOCA_N(int,ndims);
|
2915
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
2916
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2917
|
+
|
2918
|
+
Check_Type(start,T_ARRAY);
|
2919
|
+
if(RARRAY_LEN(start) < ndims){
|
2920
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
2921
|
+
}
|
2922
|
+
c_start = ALLOCA_N(size_t,ndims);
|
2923
|
+
for(i=0; i<ndims; i++){
|
2924
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
2925
|
+
|
2926
|
+
if(l_start < 0) {
|
2927
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
2928
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2929
|
+
l_start += dimlen;
|
2930
|
+
}
|
2931
|
+
c_start[i]=l_start;
|
2932
|
+
}
|
2933
|
+
|
2934
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
2935
|
+
switch(TYPE(stride)){
|
2936
|
+
case T_NIL:
|
2937
|
+
for(i=0; i<ndims; i++){
|
2938
|
+
c_stride[i]=1;
|
2939
|
+
}
|
2940
|
+
break;
|
2941
|
+
default:
|
2942
|
+
Check_Type(stride,T_ARRAY);
|
2943
|
+
if(RARRAY_LEN(stride) < ndims) {
|
2944
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride is too short\n");
|
2945
|
+
}
|
2946
|
+
for(i=0;i<ndims; i++){
|
2947
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
2948
|
+
if(c_stride[i]==0){
|
2949
|
+
rb_raise(rb_eNetcdfError,"stride cannot be zero\n");
|
2950
|
+
}
|
2951
|
+
}
|
2952
|
+
}
|
2953
|
+
|
2954
|
+
c_count=ALLOCA_N(size_t,ndims);
|
2955
|
+
switch(TYPE(end)){
|
2956
|
+
case T_NIL:
|
2957
|
+
for(i=0; i<ndims; i++){
|
2958
|
+
nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2959
|
+
c_count[i]=(dimlen-c_start[i]-1)/c_stride[i]+1;
|
2960
|
+
}
|
2961
|
+
break;
|
2962
|
+
default:
|
2963
|
+
Check_Type(end,T_ARRAY);
|
2964
|
+
if(RARRAY_LEN(end) <ndims) {
|
2965
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
2966
|
+
}
|
2967
|
+
for(i=0; i<ndims; i++){
|
2968
|
+
l_end= NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
2969
|
+
if(l_end < 0) {
|
2970
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
2971
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2972
|
+
l_end +=dimlen;
|
2973
|
+
}
|
2974
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
2975
|
+
}
|
2976
|
+
}
|
2977
|
+
|
2978
|
+
for(i=0;i<ndims;i++){
|
2979
|
+
nc_tlen = nc_tlen*c_count[i];
|
2980
|
+
}
|
2981
|
+
|
2982
|
+
shape = ALLOCA_N(int,ndims);
|
2983
|
+
for(i=0;i<ndims;i++){
|
2984
|
+
shape[ndims-1-i]=c_count[i];
|
2985
|
+
}
|
2986
|
+
|
2987
|
+
Clint_to_NArray(NArray,ndims,shape,ptr);
|
2988
|
+
|
2989
|
+
|
2990
|
+
status = nc_get_vars_int(ncid,varid,c_start,c_count,c_stride,ptr);
|
2991
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
2992
|
+
|
2993
|
+
OBJ_TAINT(NArray);
|
2994
|
+
return NArray;
|
2995
|
+
}
|
2996
|
+
|
2997
|
+
VALUE
|
2998
|
+
NetCDF_get_vars_float(VALUE Var,VALUE start,VALUE end,VALUE stride)
|
2999
|
+
{
|
3000
|
+
int ncid;
|
3001
|
+
int varid;
|
3002
|
+
int status;
|
3003
|
+
float *ptr;
|
3004
|
+
int i;
|
3005
|
+
struct NetCDFVar *Netcdf_var;
|
3006
|
+
long l_start, l_end;
|
3007
|
+
size_t *c_start;
|
3008
|
+
size_t *c_count;
|
3009
|
+
ptrdiff_t *c_stride;
|
3010
|
+
int *shape; /* NArray uses int instead of size_t */
|
3011
|
+
int ndims;
|
3012
|
+
int *dimids;
|
3013
|
+
int nc_tlen=1;
|
3014
|
+
size_t dimlen;
|
3015
|
+
VALUE NArray;
|
3016
|
+
|
3017
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3018
|
+
ncid = Netcdf_var->ncid;
|
3019
|
+
varid = Netcdf_var->varid;
|
3020
|
+
|
3021
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
3022
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3023
|
+
if(ndims == 0) {
|
3024
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
3025
|
+
}
|
3026
|
+
|
3027
|
+
dimids = ALLOCA_N(int,ndims);
|
3028
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3029
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3030
|
+
|
3031
|
+
Check_Type(start,T_ARRAY);
|
3032
|
+
if(RARRAY_LEN(start) < ndims){
|
3033
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
3034
|
+
}
|
3035
|
+
c_start = ALLOCA_N(size_t,ndims);
|
3036
|
+
for(i=0; i<ndims; i++){
|
3037
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3038
|
+
|
3039
|
+
if(l_start < 0) {
|
3040
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
3041
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3042
|
+
l_start += dimlen;
|
3043
|
+
}
|
3044
|
+
c_start[i]=l_start;
|
3045
|
+
}
|
3046
|
+
|
3047
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
3048
|
+
switch(TYPE(stride)){
|
3049
|
+
case T_NIL:
|
3050
|
+
for(i=0; i<ndims; i++){
|
3051
|
+
c_stride[i]=1;
|
3052
|
+
}
|
3053
|
+
break;
|
3054
|
+
default:
|
3055
|
+
Check_Type(stride,T_ARRAY);
|
3056
|
+
if(RARRAY_LEN(stride) < ndims) {
|
3057
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride is too short\n");
|
3058
|
+
}
|
3059
|
+
for(i=0;i<ndims; i++){
|
3060
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
3061
|
+
if(c_stride[i]==0){
|
3062
|
+
rb_raise(rb_eNetcdfError,"stride cannot be zero\n");
|
3063
|
+
}
|
3064
|
+
}
|
3065
|
+
}
|
3066
|
+
|
3067
|
+
c_count=ALLOCA_N(size_t,ndims);
|
3068
|
+
switch(TYPE(end)){
|
3069
|
+
case T_NIL:
|
3070
|
+
for(i=0; i<ndims; i++){
|
3071
|
+
nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3072
|
+
c_count[i]=(dimlen-c_start[i]-1)/c_stride[i]+1;
|
3073
|
+
}
|
3074
|
+
break;
|
3075
|
+
default:
|
3076
|
+
Check_Type(end,T_ARRAY);
|
3077
|
+
if(RARRAY_LEN(end) <ndims) {
|
3078
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
3079
|
+
}
|
3080
|
+
for(i=0; i<ndims; i++){
|
3081
|
+
l_end= NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
3082
|
+
if(l_end < 0) {
|
3083
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3084
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3085
|
+
l_end +=dimlen;
|
3086
|
+
}
|
3087
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
3088
|
+
}
|
3089
|
+
}
|
3090
|
+
|
3091
|
+
for(i=0;i<ndims;i++){
|
3092
|
+
nc_tlen = nc_tlen*c_count[i];
|
3093
|
+
}
|
3094
|
+
|
3095
|
+
shape = ALLOCA_N(int,ndims);
|
3096
|
+
for(i=0;i<ndims;i++){
|
3097
|
+
shape[ndims-1-i]=c_count[i];
|
3098
|
+
}
|
3099
|
+
|
3100
|
+
Cfloat_to_NArray(NArray,ndims,shape,ptr);
|
3101
|
+
|
3102
|
+
|
3103
|
+
status = nc_get_vars_float(ncid,varid,c_start,c_count,c_stride,ptr);
|
3104
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3105
|
+
|
3106
|
+
OBJ_TAINT(NArray);
|
3107
|
+
return NArray;
|
3108
|
+
}
|
3109
|
+
|
3110
|
+
VALUE
|
3111
|
+
NetCDF_get_vars_double(VALUE Var,VALUE start,VALUE end,VALUE stride)
|
3112
|
+
{
|
3113
|
+
int ncid;
|
3114
|
+
int varid;
|
3115
|
+
int status;
|
3116
|
+
double *ptr;
|
3117
|
+
int i;
|
3118
|
+
struct NetCDFVar *Netcdf_var;
|
3119
|
+
long l_start, l_end;
|
3120
|
+
size_t *c_start;
|
3121
|
+
size_t *c_count;
|
3122
|
+
ptrdiff_t *c_stride;
|
3123
|
+
int *shape; /* NArray uses int instead of size_t */
|
3124
|
+
int ndims;
|
3125
|
+
int *dimids;
|
3126
|
+
int nc_tlen=1;
|
3127
|
+
size_t dimlen;
|
3128
|
+
VALUE NArray;
|
3129
|
+
|
3130
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3131
|
+
ncid = Netcdf_var->ncid;
|
3132
|
+
varid = Netcdf_var->varid;
|
3133
|
+
|
3134
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
3135
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3136
|
+
if(ndims == 0) {
|
3137
|
+
rb_raise(rb_eNetcdfError,"Cannot specify a subset of a rank-0 scalar\n");
|
3138
|
+
}
|
3139
|
+
|
3140
|
+
dimids = ALLOCA_N(int,ndims);
|
3141
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3142
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3143
|
+
|
3144
|
+
Check_Type(start,T_ARRAY);
|
3145
|
+
if(RARRAY_LEN(start) < ndims){
|
3146
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
3147
|
+
}
|
3148
|
+
c_start = ALLOCA_N(size_t,ndims);
|
3149
|
+
for(i=0; i<ndims; i++){
|
3150
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3151
|
+
|
3152
|
+
if(l_start < 0) {
|
3153
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
3154
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3155
|
+
l_start += dimlen;
|
3156
|
+
}
|
3157
|
+
c_start[i]=l_start;
|
3158
|
+
}
|
3159
|
+
|
3160
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
3161
|
+
switch(TYPE(stride)){
|
3162
|
+
case T_NIL:
|
3163
|
+
for(i=0; i<ndims; i++){
|
3164
|
+
c_stride[i]=1;
|
3165
|
+
}
|
3166
|
+
break;
|
3167
|
+
default:
|
3168
|
+
Check_Type(stride,T_ARRAY);
|
3169
|
+
if(RARRAY_LEN(stride) < ndims) {
|
3170
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride is too short\n");
|
3171
|
+
}
|
3172
|
+
for(i=0;i<ndims; i++){
|
3173
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
3174
|
+
if(c_stride[i]==0){
|
3175
|
+
rb_raise(rb_eNetcdfError,"stride cannot be zero\n");
|
3176
|
+
}
|
3177
|
+
}
|
3178
|
+
}
|
3179
|
+
|
3180
|
+
c_count=ALLOCA_N(size_t,ndims);
|
3181
|
+
switch(TYPE(end)){
|
3182
|
+
case T_NIL:
|
3183
|
+
for(i=0; i<ndims; i++){
|
3184
|
+
nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3185
|
+
c_count[i]=(dimlen-c_start[i]-1)/c_stride[i]+1;
|
3186
|
+
}
|
3187
|
+
break;
|
3188
|
+
default:
|
3189
|
+
Check_Type(end,T_ARRAY);
|
3190
|
+
if(RARRAY_LEN(end) <ndims) {
|
3191
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
3192
|
+
}
|
3193
|
+
for(i=0; i<ndims; i++){
|
3194
|
+
l_end= NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
3195
|
+
if(l_end < 0) {
|
3196
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3197
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3198
|
+
l_end +=dimlen;
|
3199
|
+
}
|
3200
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
3201
|
+
}
|
3202
|
+
}
|
3203
|
+
|
3204
|
+
for(i=0;i<ndims;i++){
|
3205
|
+
nc_tlen = nc_tlen*c_count[i];
|
3206
|
+
}
|
3207
|
+
|
3208
|
+
shape = ALLOCA_N(int,ndims);
|
3209
|
+
for(i=0;i<ndims;i++){
|
3210
|
+
shape[ndims-1-i]=c_count[i];
|
3211
|
+
}
|
3212
|
+
|
3213
|
+
Cdouble_to_NArray(NArray,ndims,shape,ptr);
|
3214
|
+
|
3215
|
+
status = nc_get_vars_double(ncid,varid,c_start,c_count,c_stride,ptr);
|
3216
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3217
|
+
|
3218
|
+
OBJ_TAINT(NArray);
|
3219
|
+
return NArray;
|
3220
|
+
}
|
3221
|
+
|
3222
|
+
|
3223
|
+
VALUE
|
3224
|
+
NetCDF_put_var_char(VALUE Var,VALUE NArray)
|
3225
|
+
{
|
3226
|
+
int ncid;
|
3227
|
+
int varid;
|
3228
|
+
int status;
|
3229
|
+
unsigned char *ptr,scalar;
|
3230
|
+
int len,i=0;
|
3231
|
+
struct NetCDFVar *Netcdf_var;
|
3232
|
+
int nc_tlen=1;
|
3233
|
+
int ndimsp;
|
3234
|
+
int dimids[NC_MAX_DIMS];
|
3235
|
+
size_t lengthp;
|
3236
|
+
char *var_name;
|
3237
|
+
|
3238
|
+
rb_secure(4);
|
3239
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3240
|
+
ncid=Netcdf_var->ncid;
|
3241
|
+
varid=Netcdf_var->varid;
|
3242
|
+
|
3243
|
+
Array_to_Cbyte_len(NArray,ptr,len);
|
3244
|
+
|
3245
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
3246
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3247
|
+
for(i=0;i<ndimsp;i++){
|
3248
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3249
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3250
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
3251
|
+
nc_tlen=lengthp*nc_tlen;
|
3252
|
+
}
|
3253
|
+
if(len == 1 && len != nc_tlen){
|
3254
|
+
scalar = *ptr;
|
3255
|
+
ptr = ALLOCA_N(unsigned char,nc_tlen);
|
3256
|
+
for(i=0;i<nc_tlen;i++){ptr[i]=scalar;}
|
3257
|
+
} else if(len != nc_tlen){
|
3258
|
+
var_name=ALLOCA_N(char,NC_MAX_NAME);
|
3259
|
+
status = nc_inq_varname(ncid,varid,var_name);
|
3260
|
+
if(status != NC_NOERR) NC_RAISE(status );
|
3261
|
+
rb_raise(rb_eNetcdfError,"Length of NArray don't equal to length of total array in the '%s'\n",var_name);
|
3262
|
+
}
|
3263
|
+
status = nc_put_var_text(ncid,varid,(char *)ptr);
|
3264
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
3265
|
+
return Qnil;
|
3266
|
+
}
|
3267
|
+
|
3268
|
+
VALUE
|
3269
|
+
NetCDF_put_var_byte(VALUE Var,VALUE NArray)
|
3270
|
+
{
|
3271
|
+
int ncid;
|
3272
|
+
int varid;
|
3273
|
+
int status;
|
3274
|
+
unsigned char *ptr,scalar;
|
3275
|
+
int len,i=0;
|
3276
|
+
struct NetCDFVar *Netcdf_var;
|
3277
|
+
int nc_tlen=1;
|
3278
|
+
int ndimsp;
|
3279
|
+
int dimids[NC_MAX_DIMS];
|
3280
|
+
size_t lengthp;
|
3281
|
+
char *var_name;
|
3282
|
+
|
3283
|
+
rb_secure(4);
|
3284
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3285
|
+
ncid=Netcdf_var->ncid;
|
3286
|
+
varid=Netcdf_var->varid;
|
3287
|
+
|
3288
|
+
Array_to_Cbyte_len(NArray,ptr,len);
|
3289
|
+
|
3290
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
3291
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3292
|
+
for(i=0;i<ndimsp;i++){
|
3293
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3294
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3295
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
3296
|
+
nc_tlen=lengthp*nc_tlen;
|
3297
|
+
}
|
3298
|
+
if(len == 1 && len != nc_tlen){
|
3299
|
+
scalar = *ptr;
|
3300
|
+
ptr = ALLOCA_N(unsigned char,nc_tlen);
|
3301
|
+
for(i=0;i<nc_tlen;i++){ptr[i]=scalar;}
|
3302
|
+
} else if(len != nc_tlen){
|
3303
|
+
var_name=ALLOCA_N(char,NC_MAX_NAME);
|
3304
|
+
status = nc_inq_varname(ncid,varid,var_name);
|
3305
|
+
if(status != NC_NOERR) NC_RAISE(status );
|
3306
|
+
rb_raise(rb_eNetcdfError,"Length of NArray don't equal to length of total array in the '%s'\n",var_name);
|
3307
|
+
}
|
3308
|
+
status = nc_put_var_uchar(ncid,varid,ptr);
|
3309
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
3310
|
+
return Qnil;
|
3311
|
+
}
|
3312
|
+
|
3313
|
+
VALUE
|
3314
|
+
NetCDF_put_var_short(VALUE Var,VALUE NArray)
|
3315
|
+
{
|
3316
|
+
int ncid;
|
3317
|
+
int varid;
|
3318
|
+
int status;
|
3319
|
+
short *ptr,scalar;
|
3320
|
+
int len,i=0;
|
3321
|
+
struct NetCDFVar *Netcdf_var;
|
3322
|
+
int nc_tlen=1;
|
3323
|
+
int ndimsp;
|
3324
|
+
int dimids[NC_MAX_DIMS];
|
3325
|
+
size_t lengthp;
|
3326
|
+
char *var_name;
|
3327
|
+
|
3328
|
+
rb_secure(4);
|
3329
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3330
|
+
ncid=Netcdf_var->ncid;
|
3331
|
+
varid=Netcdf_var->varid;
|
3332
|
+
Array_to_Csint_len(NArray,ptr,len);
|
3333
|
+
|
3334
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
3335
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3336
|
+
for(i=0;i<ndimsp;i++){
|
3337
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3338
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3339
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
3340
|
+
nc_tlen=lengthp*nc_tlen;
|
3341
|
+
}
|
3342
|
+
if(len == 1 && len != nc_tlen){
|
3343
|
+
scalar = *ptr;
|
3344
|
+
ptr = ALLOCA_N(short,nc_tlen);
|
3345
|
+
for(i=0;i<nc_tlen;i++){ptr[i]=scalar;}
|
3346
|
+
} else if(len != nc_tlen){
|
3347
|
+
var_name=ALLOCA_N(char,NC_MAX_NAME);
|
3348
|
+
status = nc_inq_varname(ncid,varid,var_name);
|
3349
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3350
|
+
rb_raise(rb_eNetcdfError,"Length of NArray don't equal to length of total array length in the '%s'\n",var_name);
|
3351
|
+
}
|
3352
|
+
|
3353
|
+
status = nc_put_var_short(ncid,varid,ptr);
|
3354
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
3355
|
+
return Qnil;
|
3356
|
+
}
|
3357
|
+
|
3358
|
+
VALUE
|
3359
|
+
NetCDF_put_var_int(VALUE Var,VALUE NArray)
|
3360
|
+
{
|
3361
|
+
int ncid;
|
3362
|
+
int varid;
|
3363
|
+
int status;
|
3364
|
+
int *ptr,scalar;
|
3365
|
+
int len,i=0;
|
3366
|
+
struct NetCDFVar *Netcdf_var;
|
3367
|
+
int nc_tlen=1;
|
3368
|
+
int ndimsp;
|
3369
|
+
int dimids[NC_MAX_DIMS];
|
3370
|
+
size_t lengthp;
|
3371
|
+
char *var_name;
|
3372
|
+
|
3373
|
+
rb_secure(4);
|
3374
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3375
|
+
ncid=Netcdf_var->ncid;
|
3376
|
+
varid=Netcdf_var->varid;
|
3377
|
+
|
3378
|
+
Array_to_Clint_len(NArray,ptr,len);
|
3379
|
+
|
3380
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
3381
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3382
|
+
for(i=0;i<ndimsp;i++){
|
3383
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3384
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3385
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
3386
|
+
nc_tlen=lengthp*nc_tlen;
|
3387
|
+
}
|
3388
|
+
if(len == 1 && len != nc_tlen){
|
3389
|
+
scalar = *ptr;
|
3390
|
+
ptr = ALLOCA_N(int,nc_tlen);
|
3391
|
+
for(i=0;i<nc_tlen;i++){ptr[i]=scalar;}
|
3392
|
+
} else if(len != nc_tlen){
|
3393
|
+
var_name=ALLOCA_N(char,NC_MAX_NAME);
|
3394
|
+
status = nc_inq_varname(ncid,varid,var_name);
|
3395
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3396
|
+
rb_raise(rb_eNetcdfError,"Length of NArray don't equal to length of total array length in the '%s'\n",var_name);
|
3397
|
+
}
|
3398
|
+
|
3399
|
+
|
3400
|
+
status = nc_put_var_int(ncid,varid,ptr);
|
3401
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
3402
|
+
return Qnil;
|
3403
|
+
}
|
3404
|
+
|
3405
|
+
|
3406
|
+
VALUE
|
3407
|
+
NetCDF_put_var_float(VALUE Var,VALUE NArray)
|
3408
|
+
{
|
3409
|
+
int ncid;
|
3410
|
+
int varid;
|
3411
|
+
int status;
|
3412
|
+
float *ptr,scalar;
|
3413
|
+
int len,i=0;
|
3414
|
+
struct NetCDFVar *Netcdf_var;
|
3415
|
+
int nc_tlen=1;
|
3416
|
+
int ndimsp;
|
3417
|
+
int dimids[NC_MAX_DIMS];
|
3418
|
+
size_t lengthp;
|
3419
|
+
char *var_name;
|
3420
|
+
|
3421
|
+
|
3422
|
+
rb_secure(4);
|
3423
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3424
|
+
ncid=Netcdf_var->ncid;
|
3425
|
+
varid=Netcdf_var->varid;
|
3426
|
+
|
3427
|
+
Array_to_Cfloat_len(NArray,ptr,len);
|
3428
|
+
|
3429
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
3430
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3431
|
+
for(i=0;i<ndimsp;i++){
|
3432
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3433
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3434
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
3435
|
+
nc_tlen=lengthp*nc_tlen;
|
3436
|
+
}
|
3437
|
+
if(len == 1 && len != nc_tlen){
|
3438
|
+
scalar = *ptr;
|
3439
|
+
ptr = ALLOCA_N(float,nc_tlen);
|
3440
|
+
for(i=0;i<nc_tlen;i++){ptr[i]=scalar;}
|
3441
|
+
} else if(len != nc_tlen){
|
3442
|
+
var_name=ALLOCA_N(char,NC_MAX_NAME);
|
3443
|
+
status = nc_inq_varname(ncid,varid,var_name);
|
3444
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3445
|
+
rb_raise(rb_eNetcdfError,"Length of NArray don't equal to length of total array length in the '%s'\n",var_name);
|
3446
|
+
}
|
3447
|
+
|
3448
|
+
status = nc_put_var_float(ncid,varid,ptr);
|
3449
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
3450
|
+
return Qnil;
|
3451
|
+
}
|
3452
|
+
|
3453
|
+
VALUE
|
3454
|
+
NetCDF_put_var_double(VALUE Var,VALUE NArray)
|
3455
|
+
{
|
3456
|
+
int ncid;
|
3457
|
+
int varid;
|
3458
|
+
int status;
|
3459
|
+
double *ptr,scalar;
|
3460
|
+
int len,i=0;
|
3461
|
+
struct NetCDFVar *Netcdf_var;
|
3462
|
+
int nc_tlen=1;
|
3463
|
+
int ndimsp;
|
3464
|
+
int dimids[NC_MAX_DIMS];
|
3465
|
+
size_t lengthp;
|
3466
|
+
char *var_name;
|
3467
|
+
|
3468
|
+
|
3469
|
+
rb_secure(4);
|
3470
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3471
|
+
ncid=Netcdf_var->ncid;
|
3472
|
+
varid=Netcdf_var->varid;
|
3473
|
+
|
3474
|
+
Array_to_Cdouble_len(NArray,ptr,len);
|
3475
|
+
|
3476
|
+
status = nc_inq_varndims(ncid,varid,&ndimsp);
|
3477
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3478
|
+
for(i=0;i<ndimsp;i++){
|
3479
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3480
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3481
|
+
nc_inq_dimlen(ncid,dimids[i],&lengthp);
|
3482
|
+
nc_tlen=lengthp*nc_tlen;
|
3483
|
+
}
|
3484
|
+
if(len == 1 && len != nc_tlen){
|
3485
|
+
scalar = *ptr;
|
3486
|
+
ptr = ALLOCA_N(double,nc_tlen);
|
3487
|
+
for(i=0;i<nc_tlen;i++){ptr[i]=scalar;}
|
3488
|
+
} else if(len != nc_tlen){
|
3489
|
+
var_name=ALLOCA_N(char,NC_MAX_NAME);
|
3490
|
+
status = nc_inq_varname(ncid,varid,var_name);
|
3491
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3492
|
+
rb_raise(rb_eNetcdfError,"Length of NArray don't equal to length of total array length in the '%s'\n",var_name);
|
3493
|
+
}
|
3494
|
+
|
3495
|
+
status = nc_put_var_double(ncid,varid,ptr);
|
3496
|
+
if(status !=NC_NOERR) NC_RAISE(status);
|
3497
|
+
return Qnil;
|
3498
|
+
}
|
3499
|
+
|
3500
|
+
VALUE
|
3501
|
+
NetCDF_put_var1_char(VALUE Var,VALUE NArray,VALUE start)
|
3502
|
+
{
|
3503
|
+
int ncid;
|
3504
|
+
int varid;
|
3505
|
+
int status;
|
3506
|
+
unsigned char *ptr;
|
3507
|
+
int i;
|
3508
|
+
struct NetCDFVar *Netcdf_var;
|
3509
|
+
long l_start;
|
3510
|
+
size_t *c_start;
|
3511
|
+
int ndims;
|
3512
|
+
int *dimids;
|
3513
|
+
size_t dimlen;
|
3514
|
+
|
3515
|
+
rb_secure(4);
|
3516
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3517
|
+
ncid=Netcdf_var->ncid;
|
3518
|
+
varid=Netcdf_var->varid;
|
3519
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
3520
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3521
|
+
|
3522
|
+
|
3523
|
+
dimids = ALLOCA_N(int,ndims);
|
3524
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3525
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3526
|
+
|
3527
|
+
Check_Type(start,T_ARRAY);
|
3528
|
+
if(RARRAY_LEN(start) <ndims) {
|
3529
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
3530
|
+
}
|
3531
|
+
|
3532
|
+
c_start=ALLOCA_N(size_t,ndims);
|
3533
|
+
for(i=0;i<ndims;i++){
|
3534
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3535
|
+
|
3536
|
+
if(l_start < 0) {
|
3537
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3538
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3539
|
+
l_start += dimlen;
|
3540
|
+
}
|
3541
|
+
c_start[i]=l_start;
|
3542
|
+
|
3543
|
+
}
|
3544
|
+
Array_to_Cbyte(NArray,ptr);
|
3545
|
+
|
3546
|
+
status = nc_put_var1_text(ncid,varid,c_start,(char *)ptr);
|
3547
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3548
|
+
return Qnil;
|
3549
|
+
}
|
3550
|
+
|
3551
|
+
VALUE
|
3552
|
+
NetCDF_put_var1_byte(VALUE Var,VALUE NArray,VALUE start)
|
3553
|
+
{
|
3554
|
+
int ncid;
|
3555
|
+
int varid;
|
3556
|
+
int status;
|
3557
|
+
unsigned char *ptr;
|
3558
|
+
int i;
|
3559
|
+
struct NetCDFVar *Netcdf_var;
|
3560
|
+
long l_start;
|
3561
|
+
size_t *c_start;
|
3562
|
+
int ndims;
|
3563
|
+
int *dimids;
|
3564
|
+
size_t dimlen;
|
3565
|
+
|
3566
|
+
rb_secure(4);
|
3567
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3568
|
+
ncid=Netcdf_var->ncid;
|
3569
|
+
varid=Netcdf_var->varid;
|
3570
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
3571
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3572
|
+
|
3573
|
+
|
3574
|
+
dimids = ALLOCA_N(int,ndims);
|
3575
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3576
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3577
|
+
|
3578
|
+
Check_Type(start,T_ARRAY);
|
3579
|
+
if(RARRAY_LEN(start) <ndims) {
|
3580
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
3581
|
+
}
|
3582
|
+
|
3583
|
+
c_start=ALLOCA_N(size_t,ndims);
|
3584
|
+
for(i=0;i<ndims;i++){
|
3585
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3586
|
+
|
3587
|
+
if(l_start < 0) {
|
3588
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3589
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3590
|
+
l_start += dimlen;
|
3591
|
+
}
|
3592
|
+
c_start[i]=l_start;
|
3593
|
+
|
3594
|
+
}
|
3595
|
+
Array_to_Cbyte(NArray,ptr);
|
3596
|
+
|
3597
|
+
status = nc_put_var1_uchar(ncid,varid,c_start,ptr);
|
3598
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3599
|
+
return Qnil;
|
3600
|
+
}
|
3601
|
+
|
3602
|
+
VALUE
|
3603
|
+
NetCDF_put_var1_sint(VALUE Var,VALUE NArray,VALUE start)
|
3604
|
+
{
|
3605
|
+
int ncid;
|
3606
|
+
int varid;
|
3607
|
+
int status;
|
3608
|
+
short *ptr;
|
3609
|
+
int i;
|
3610
|
+
struct NetCDFVar *Netcdf_var;
|
3611
|
+
long l_start;
|
3612
|
+
size_t *c_start;
|
3613
|
+
int ndims;
|
3614
|
+
int *dimids;
|
3615
|
+
size_t dimlen;
|
3616
|
+
|
3617
|
+
rb_secure(4);
|
3618
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3619
|
+
ncid=Netcdf_var->ncid;
|
3620
|
+
varid=Netcdf_var->varid;
|
3621
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
3622
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3623
|
+
|
3624
|
+
|
3625
|
+
dimids = ALLOCA_N(int,ndims);
|
3626
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3627
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3628
|
+
|
3629
|
+
Check_Type(start,T_ARRAY);
|
3630
|
+
if(RARRAY_LEN(start) <ndims) {
|
3631
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
3632
|
+
}
|
3633
|
+
|
3634
|
+
c_start=ALLOCA_N(size_t,ndims);
|
3635
|
+
for(i=0;i<ndims;i++){
|
3636
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3637
|
+
|
3638
|
+
if(l_start < 0) {
|
3639
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3640
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3641
|
+
l_start += dimlen;
|
3642
|
+
}
|
3643
|
+
c_start[i]=l_start;
|
3644
|
+
|
3645
|
+
}
|
3646
|
+
Array_to_Csint(NArray,ptr);
|
3647
|
+
|
3648
|
+
status = nc_put_var1_short(ncid,varid,c_start,ptr);
|
3649
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3650
|
+
return Qnil;
|
3651
|
+
}
|
3652
|
+
VALUE
|
3653
|
+
NetCDF_put_var1_int(VALUE Var,VALUE NArray,VALUE start)
|
3654
|
+
{
|
3655
|
+
int ncid;
|
3656
|
+
int varid;
|
3657
|
+
int status;
|
3658
|
+
int *ptr;
|
3659
|
+
int i;
|
3660
|
+
struct NetCDFVar *Netcdf_var;
|
3661
|
+
long l_start;
|
3662
|
+
size_t *c_start;
|
3663
|
+
int ndims;
|
3664
|
+
int *dimids;
|
3665
|
+
size_t dimlen;
|
3666
|
+
|
3667
|
+
rb_secure(4);
|
3668
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3669
|
+
ncid=Netcdf_var->ncid;
|
3670
|
+
varid=Netcdf_var->varid;
|
3671
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
3672
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3673
|
+
|
3674
|
+
|
3675
|
+
dimids = ALLOCA_N(int,ndims);
|
3676
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3677
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3678
|
+
|
3679
|
+
Check_Type(start,T_ARRAY);
|
3680
|
+
if(RARRAY_LEN(start) <ndims) {
|
3681
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
3682
|
+
}
|
3683
|
+
|
3684
|
+
c_start=ALLOCA_N(size_t,ndims);
|
3685
|
+
for(i=0;i<ndims;i++){
|
3686
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3687
|
+
|
3688
|
+
if(l_start < 0) {
|
3689
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3690
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3691
|
+
l_start += dimlen;
|
3692
|
+
}
|
3693
|
+
c_start[i]=l_start;
|
3694
|
+
|
3695
|
+
}
|
3696
|
+
Array_to_Clint(NArray,ptr);
|
3697
|
+
|
3698
|
+
status = nc_put_var1_int(ncid,varid,c_start,ptr);
|
3699
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3700
|
+
return Qnil;
|
3701
|
+
}
|
3702
|
+
|
3703
|
+
VALUE
|
3704
|
+
NetCDF_put_var1_float(VALUE Var,VALUE NArray,VALUE start)
|
3705
|
+
{
|
3706
|
+
int ncid;
|
3707
|
+
int varid;
|
3708
|
+
int status;
|
3709
|
+
float *ptr;
|
3710
|
+
int i;
|
3711
|
+
struct NetCDFVar *Netcdf_var;
|
3712
|
+
long l_start;
|
3713
|
+
size_t *c_start;
|
3714
|
+
int ndims;
|
3715
|
+
int *dimids;
|
3716
|
+
size_t dimlen;
|
3717
|
+
|
3718
|
+
rb_secure(4);
|
3719
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3720
|
+
ncid=Netcdf_var->ncid;
|
3721
|
+
varid=Netcdf_var->varid;
|
3722
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
3723
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3724
|
+
|
3725
|
+
|
3726
|
+
dimids = ALLOCA_N(int,ndims);
|
3727
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3728
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3729
|
+
|
3730
|
+
Check_Type(start,T_ARRAY);
|
3731
|
+
if(RARRAY_LEN(start) <ndims) {
|
3732
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
3733
|
+
}
|
3734
|
+
|
3735
|
+
c_start=ALLOCA_N(size_t,ndims);
|
3736
|
+
for(i=0;i<ndims;i++){
|
3737
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3738
|
+
|
3739
|
+
if(l_start < 0) {
|
3740
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3741
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3742
|
+
l_start += dimlen;
|
3743
|
+
}
|
3744
|
+
c_start[i]=l_start;
|
3745
|
+
|
3746
|
+
}
|
3747
|
+
Array_to_Cfloat(NArray,ptr);
|
3748
|
+
|
3749
|
+
status = nc_put_var1_float(ncid,varid,c_start,ptr);
|
3750
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3751
|
+
return Qnil;
|
3752
|
+
}
|
3753
|
+
|
3754
|
+
VALUE
|
3755
|
+
NetCDF_put_var1_double(VALUE Var,VALUE NArray,VALUE start)
|
3756
|
+
{
|
3757
|
+
int ncid;
|
3758
|
+
int varid;
|
3759
|
+
int status;
|
3760
|
+
double *ptr;
|
3761
|
+
int i;
|
3762
|
+
struct NetCDFVar *Netcdf_var;
|
3763
|
+
long l_start;
|
3764
|
+
size_t *c_start;
|
3765
|
+
int ndims;
|
3766
|
+
int *dimids;
|
3767
|
+
size_t dimlen;
|
3768
|
+
|
3769
|
+
rb_secure(4);
|
3770
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3771
|
+
ncid=Netcdf_var->ncid;
|
3772
|
+
varid=Netcdf_var->varid;
|
3773
|
+
status = nc_inq_varndims(ncid,varid,&ndims);
|
3774
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3775
|
+
|
3776
|
+
|
3777
|
+
dimids = ALLOCA_N(int,ndims);
|
3778
|
+
status = nc_inq_vardimid(ncid,varid,dimids);
|
3779
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3780
|
+
|
3781
|
+
Check_Type(start,T_ARRAY);
|
3782
|
+
if(RARRAY_LEN(start) <ndims) {
|
3783
|
+
rb_raise(rb_eNetcdfError,"Length of 'start' is too short\n");
|
3784
|
+
}
|
3785
|
+
|
3786
|
+
c_start=ALLOCA_N(size_t,ndims);
|
3787
|
+
for(i=0;i<ndims;i++){
|
3788
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3789
|
+
|
3790
|
+
if(l_start < 0) {
|
3791
|
+
status = nc_inq_dimlen(ncid,dimids[i],&dimlen);
|
3792
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3793
|
+
l_start += dimlen;
|
3794
|
+
}
|
3795
|
+
c_start[i]=l_start;
|
3796
|
+
|
3797
|
+
}
|
3798
|
+
Array_to_Cdouble(NArray,ptr);
|
3799
|
+
|
3800
|
+
status = nc_put_var1_double(ncid,varid,c_start,ptr);
|
3801
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3802
|
+
return Qnil;
|
3803
|
+
}
|
3804
|
+
|
3805
|
+
|
3806
|
+
VALUE
|
3807
|
+
NetCDF_put_vars_char(VALUE Var,VALUE NArray,VALUE start,VALUE end,VALUE stride)
|
3808
|
+
{
|
3809
|
+
int ncid;
|
3810
|
+
int varid;
|
3811
|
+
int status;
|
3812
|
+
unsigned char *ptr,scalar;
|
3813
|
+
int len,i;
|
3814
|
+
int c_count_all=1;
|
3815
|
+
struct NetCDFVar *Netcdf_var;
|
3816
|
+
long l_start, l_end;
|
3817
|
+
size_t *c_start;
|
3818
|
+
size_t *c_count;
|
3819
|
+
ptrdiff_t *c_stride;
|
3820
|
+
int ndims;
|
3821
|
+
int *shape;
|
3822
|
+
int *dimids;
|
3823
|
+
size_t dimlen;
|
3824
|
+
|
3825
|
+
rb_secure(4);
|
3826
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3827
|
+
ncid=Netcdf_var->ncid;
|
3828
|
+
varid=Netcdf_var->varid;
|
3829
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
3830
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3831
|
+
|
3832
|
+
dimids=ALLOCA_N(int,ndims);
|
3833
|
+
status = nc_inq_vardimid(ncid, varid, dimids);
|
3834
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3835
|
+
|
3836
|
+
Check_Type(start,T_ARRAY);
|
3837
|
+
if(RARRAY_LEN(start) < ndims) {
|
3838
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
3839
|
+
}
|
3840
|
+
c_start=ALLOCA_N(size_t,ndims);
|
3841
|
+
for(i=0; i<ndims; i++){
|
3842
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3843
|
+
|
3844
|
+
if(l_start < 0) {
|
3845
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
3846
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3847
|
+
l_start += dimlen;
|
3848
|
+
}
|
3849
|
+
c_start[i]=l_start;
|
3850
|
+
}
|
3851
|
+
|
3852
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
3853
|
+
switch(TYPE(stride)){
|
3854
|
+
case T_NIL:
|
3855
|
+
for(i=0; i<ndims; i++){
|
3856
|
+
c_stride[i]=1;
|
3857
|
+
}
|
3858
|
+
break;
|
3859
|
+
default:
|
3860
|
+
Check_Type(stride,T_ARRAY);
|
3861
|
+
if(RARRAY_LEN(stride) < ndims) {
|
3862
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride' is too short\n");
|
3863
|
+
}
|
3864
|
+
for(i=0; i<ndims; i++){
|
3865
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
3866
|
+
if(c_stride[i]==0) {
|
3867
|
+
rb_raise(rb_eNetcdfError, "stride cannot be zero\n");
|
3868
|
+
}
|
3869
|
+
}
|
3870
|
+
}
|
3871
|
+
|
3872
|
+
Array_to_Cbyte_len_shape(NArray,ptr,len,shape);
|
3873
|
+
|
3874
|
+
c_count=ALLOCA_N(size_t,ndims);
|
3875
|
+
switch(TYPE(end)){
|
3876
|
+
case T_NIL:
|
3877
|
+
for(i=0; i<ndims; i++){
|
3878
|
+
c_count[i]=shape[i];
|
3879
|
+
}
|
3880
|
+
c_count_all=len;
|
3881
|
+
break;
|
3882
|
+
default:
|
3883
|
+
Check_Type(end,T_ARRAY);
|
3884
|
+
if(RARRAY_LEN(end) < ndims) {
|
3885
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
3886
|
+
}
|
3887
|
+
for(i=0; i<ndims; i++){
|
3888
|
+
l_end=NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
3889
|
+
if(l_end < 0) {
|
3890
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
3891
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3892
|
+
l_end += dimlen;
|
3893
|
+
}
|
3894
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
3895
|
+
c_count_all=c_count[i]*c_count_all;
|
3896
|
+
}
|
3897
|
+
if(len == 1 && len != c_count_all){
|
3898
|
+
scalar = *ptr;
|
3899
|
+
ptr = ALLOCA_N(unsigned char,c_count_all);
|
3900
|
+
for(i=0;i<c_count_all;i++){ptr[i]=scalar;}
|
3901
|
+
} else if(len != c_count_all) {
|
3902
|
+
rb_raise(rb_eNetcdfError,
|
3903
|
+
"lengh of the array does not agree with that of the subset\n");
|
3904
|
+
}
|
3905
|
+
}
|
3906
|
+
|
3907
|
+
status = nc_put_vars_text(ncid,varid,c_start,c_count,c_stride,(char *)ptr);
|
3908
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3909
|
+
return Qnil;
|
3910
|
+
}
|
3911
|
+
|
3912
|
+
VALUE
|
3913
|
+
NetCDF_put_vars_byte(VALUE Var,VALUE NArray,VALUE start,VALUE end,VALUE stride)
|
3914
|
+
{
|
3915
|
+
int ncid;
|
3916
|
+
int varid;
|
3917
|
+
int status;
|
3918
|
+
unsigned char *ptr,scalar;
|
3919
|
+
int len,i;
|
3920
|
+
int c_count_all=1;
|
3921
|
+
struct NetCDFVar *Netcdf_var;
|
3922
|
+
long l_start, l_end;
|
3923
|
+
size_t *c_start;
|
3924
|
+
size_t *c_count;
|
3925
|
+
ptrdiff_t *c_stride;
|
3926
|
+
int ndims;
|
3927
|
+
int *shape;
|
3928
|
+
int *dimids;
|
3929
|
+
size_t dimlen;
|
3930
|
+
|
3931
|
+
rb_secure(4);
|
3932
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
3933
|
+
ncid=Netcdf_var->ncid;
|
3934
|
+
varid=Netcdf_var->varid;
|
3935
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
3936
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3937
|
+
|
3938
|
+
dimids=ALLOCA_N(int,ndims);
|
3939
|
+
status = nc_inq_vardimid(ncid, varid, dimids);
|
3940
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3941
|
+
|
3942
|
+
Check_Type(start,T_ARRAY);
|
3943
|
+
if(RARRAY_LEN(start) < ndims) {
|
3944
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
3945
|
+
}
|
3946
|
+
c_start=ALLOCA_N(size_t,ndims);
|
3947
|
+
for(i=0; i<ndims; i++){
|
3948
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
3949
|
+
|
3950
|
+
if(l_start < 0) {
|
3951
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
3952
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3953
|
+
l_start += dimlen;
|
3954
|
+
}
|
3955
|
+
c_start[i]=l_start;
|
3956
|
+
}
|
3957
|
+
|
3958
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
3959
|
+
switch(TYPE(stride)){
|
3960
|
+
case T_NIL:
|
3961
|
+
for(i=0; i<ndims; i++){
|
3962
|
+
c_stride[i]=1;
|
3963
|
+
}
|
3964
|
+
break;
|
3965
|
+
default:
|
3966
|
+
Check_Type(stride,T_ARRAY);
|
3967
|
+
if(RARRAY_LEN(stride) < ndims) {
|
3968
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride' is too short\n");
|
3969
|
+
}
|
3970
|
+
for(i=0; i<ndims; i++){
|
3971
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
3972
|
+
if(c_stride[i]==0) {
|
3973
|
+
rb_raise(rb_eNetcdfError, "stride cannot be zero\n");
|
3974
|
+
}
|
3975
|
+
}
|
3976
|
+
}
|
3977
|
+
|
3978
|
+
Array_to_Cbyte_len_shape(NArray,ptr,len,shape);
|
3979
|
+
|
3980
|
+
c_count=ALLOCA_N(size_t,ndims);
|
3981
|
+
switch(TYPE(end)){
|
3982
|
+
case T_NIL:
|
3983
|
+
for(i=0; i<ndims; i++){
|
3984
|
+
c_count[i]=shape[i];
|
3985
|
+
}
|
3986
|
+
c_count_all=len;
|
3987
|
+
break;
|
3988
|
+
default:
|
3989
|
+
Check_Type(end,T_ARRAY);
|
3990
|
+
if(RARRAY_LEN(end) < ndims) {
|
3991
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
3992
|
+
}
|
3993
|
+
for(i=0; i<ndims; i++){
|
3994
|
+
l_end=NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
3995
|
+
if(l_end < 0) {
|
3996
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
3997
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
3998
|
+
l_end += dimlen;
|
3999
|
+
}
|
4000
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
4001
|
+
c_count_all=c_count[i]*c_count_all;
|
4002
|
+
}
|
4003
|
+
if(len == 1 && len != c_count_all){
|
4004
|
+
scalar = *ptr;
|
4005
|
+
ptr = ALLOCA_N(unsigned char,c_count_all);
|
4006
|
+
for(i=0;i<c_count_all;i++){ptr[i]=scalar;}
|
4007
|
+
} else if(len != c_count_all) {
|
4008
|
+
rb_raise(rb_eNetcdfError,
|
4009
|
+
"lengh of the array does not agree with that of the subset\n");
|
4010
|
+
}
|
4011
|
+
}
|
4012
|
+
|
4013
|
+
status = nc_put_vars_uchar(ncid,varid,c_start,c_count,c_stride,ptr);
|
4014
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4015
|
+
return Qnil;
|
4016
|
+
}
|
4017
|
+
|
4018
|
+
VALUE
|
4019
|
+
NetCDF_put_vars_sint(VALUE Var,VALUE NArray,VALUE start,VALUE end,VALUE stride)
|
4020
|
+
{
|
4021
|
+
int ncid;
|
4022
|
+
int varid;
|
4023
|
+
int status;
|
4024
|
+
short *ptr,scalar;
|
4025
|
+
int len,i;
|
4026
|
+
int c_count_all=1;
|
4027
|
+
struct NetCDFVar *Netcdf_var;
|
4028
|
+
long l_start, l_end;
|
4029
|
+
size_t *c_start;
|
4030
|
+
size_t *c_count;
|
4031
|
+
ptrdiff_t *c_stride;
|
4032
|
+
int ndims;
|
4033
|
+
int *shape;
|
4034
|
+
int *dimids;
|
4035
|
+
size_t dimlen;
|
4036
|
+
|
4037
|
+
rb_secure(4);
|
4038
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
4039
|
+
ncid=Netcdf_var->ncid;
|
4040
|
+
varid=Netcdf_var->varid;
|
4041
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
4042
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4043
|
+
|
4044
|
+
dimids=ALLOCA_N(int,ndims);
|
4045
|
+
status = nc_inq_vardimid(ncid, varid, dimids);
|
4046
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4047
|
+
|
4048
|
+
Check_Type(start,T_ARRAY);
|
4049
|
+
if(RARRAY_LEN(start) < ndims) {
|
4050
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
4051
|
+
}
|
4052
|
+
c_start=ALLOCA_N(size_t,ndims);
|
4053
|
+
for(i=0; i<ndims; i++){
|
4054
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
4055
|
+
|
4056
|
+
if(l_start < 0) {
|
4057
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
4058
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4059
|
+
l_start += dimlen;
|
4060
|
+
}
|
4061
|
+
c_start[i]=l_start;
|
4062
|
+
}
|
4063
|
+
|
4064
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
4065
|
+
switch(TYPE(stride)){
|
4066
|
+
case T_NIL:
|
4067
|
+
for(i=0; i<ndims; i++){
|
4068
|
+
c_stride[i]=1;
|
4069
|
+
}
|
4070
|
+
break;
|
4071
|
+
default:
|
4072
|
+
Check_Type(stride,T_ARRAY);
|
4073
|
+
if(RARRAY_LEN(stride) < ndims) {
|
4074
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride' is too short\n");
|
4075
|
+
}
|
4076
|
+
for(i=0; i<ndims; i++){
|
4077
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
4078
|
+
if(c_stride[i]==0) {
|
4079
|
+
rb_raise(rb_eNetcdfError, "stride cannot be zero\n");
|
4080
|
+
}
|
4081
|
+
}
|
4082
|
+
}
|
4083
|
+
|
4084
|
+
Array_to_Csint_len_shape(NArray,ptr,len,shape);
|
4085
|
+
|
4086
|
+
c_count=ALLOCA_N(size_t,ndims);
|
4087
|
+
switch(TYPE(end)){
|
4088
|
+
case T_NIL:
|
4089
|
+
for(i=0; i<ndims; i++){
|
4090
|
+
c_count[i]=shape[i];
|
4091
|
+
}
|
4092
|
+
c_count_all=len;
|
4093
|
+
break;
|
4094
|
+
default:
|
4095
|
+
Check_Type(end,T_ARRAY);
|
4096
|
+
if(RARRAY_LEN(end) < ndims) {
|
4097
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
4098
|
+
}
|
4099
|
+
for(i=0; i<ndims; i++){
|
4100
|
+
l_end=NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
4101
|
+
if(l_end < 0) {
|
4102
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
4103
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4104
|
+
l_end += dimlen;
|
4105
|
+
}
|
4106
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
4107
|
+
c_count_all=c_count[i]*c_count_all;
|
4108
|
+
}
|
4109
|
+
if(len == 1 && len != c_count_all){
|
4110
|
+
scalar = *ptr;
|
4111
|
+
ptr = ALLOCA_N(short,c_count_all);
|
4112
|
+
for(i=0;i<c_count_all;i++){ptr[i]=scalar;}
|
4113
|
+
} else if(len != c_count_all) {
|
4114
|
+
rb_raise(rb_eNetcdfError,
|
4115
|
+
"lengh of the array does not agree with that of the subset\n");
|
4116
|
+
}
|
4117
|
+
}
|
4118
|
+
|
4119
|
+
status = nc_put_vars_short(ncid,varid,c_start,c_count,c_stride,ptr);
|
4120
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4121
|
+
return Qnil;
|
4122
|
+
}
|
4123
|
+
|
4124
|
+
|
4125
|
+
VALUE
|
4126
|
+
NetCDF_put_vars_int(VALUE Var,VALUE NArray,VALUE start,VALUE end,VALUE stride)
|
4127
|
+
{
|
4128
|
+
int ncid;
|
4129
|
+
int varid;
|
4130
|
+
int status;
|
4131
|
+
int *ptr,scalar;
|
4132
|
+
int len,i;
|
4133
|
+
int c_count_all=1;
|
4134
|
+
struct NetCDFVar *Netcdf_var;
|
4135
|
+
long l_start, l_end;
|
4136
|
+
size_t *c_start;
|
4137
|
+
size_t *c_count;
|
4138
|
+
ptrdiff_t *c_stride;
|
4139
|
+
int ndims;
|
4140
|
+
int *shape;
|
4141
|
+
int *dimids;
|
4142
|
+
size_t dimlen;
|
4143
|
+
|
4144
|
+
rb_secure(4);
|
4145
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
4146
|
+
ncid=Netcdf_var->ncid;
|
4147
|
+
varid=Netcdf_var->varid;
|
4148
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
4149
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4150
|
+
|
4151
|
+
dimids=ALLOCA_N(int,ndims);
|
4152
|
+
status = nc_inq_vardimid(ncid, varid, dimids);
|
4153
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4154
|
+
|
4155
|
+
Check_Type(start,T_ARRAY);
|
4156
|
+
if(RARRAY_LEN(start) < ndims) {
|
4157
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
4158
|
+
}
|
4159
|
+
c_start=ALLOCA_N(size_t,ndims);
|
4160
|
+
for(i=0; i<ndims; i++){
|
4161
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
4162
|
+
|
4163
|
+
if(l_start < 0) {
|
4164
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
4165
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4166
|
+
l_start += dimlen;
|
4167
|
+
}
|
4168
|
+
c_start[i]=l_start;
|
4169
|
+
}
|
4170
|
+
|
4171
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
4172
|
+
switch(TYPE(stride)){
|
4173
|
+
case T_NIL:
|
4174
|
+
for(i=0; i<ndims; i++){
|
4175
|
+
c_stride[i]=1;
|
4176
|
+
}
|
4177
|
+
break;
|
4178
|
+
default:
|
4179
|
+
Check_Type(stride,T_ARRAY);
|
4180
|
+
if(RARRAY_LEN(stride) < ndims) {
|
4181
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride' is too short\n");
|
4182
|
+
}
|
4183
|
+
for(i=0; i<ndims; i++){
|
4184
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
4185
|
+
if(c_stride[i]==0) {
|
4186
|
+
rb_raise(rb_eNetcdfError, "stride cannot be zero\n");
|
4187
|
+
}
|
4188
|
+
}
|
4189
|
+
}
|
4190
|
+
|
4191
|
+
Array_to_Clint_len_shape(NArray,ptr,len,shape);
|
4192
|
+
|
4193
|
+
c_count=ALLOCA_N(size_t,ndims);
|
4194
|
+
switch(TYPE(end)){
|
4195
|
+
case T_NIL:
|
4196
|
+
for(i=0; i<ndims; i++){
|
4197
|
+
c_count[i]=shape[i];
|
4198
|
+
}
|
4199
|
+
c_count_all=len;
|
4200
|
+
break;
|
4201
|
+
default:
|
4202
|
+
Check_Type(end,T_ARRAY);
|
4203
|
+
if(RARRAY_LEN(end) < ndims) {
|
4204
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
4205
|
+
}
|
4206
|
+
for(i=0; i<ndims; i++){
|
4207
|
+
l_end=NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
4208
|
+
if(l_end < 0) {
|
4209
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
4210
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4211
|
+
l_end += dimlen;
|
4212
|
+
}
|
4213
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
4214
|
+
c_count_all=c_count[i]*c_count_all;
|
4215
|
+
}
|
4216
|
+
if(len == 1 && len != c_count_all){
|
4217
|
+
scalar = *ptr;
|
4218
|
+
ptr = ALLOCA_N(int,c_count_all);
|
4219
|
+
for(i=0;i<c_count_all;i++){ptr[i]=scalar;}
|
4220
|
+
} else if(len != c_count_all) {
|
4221
|
+
rb_raise(rb_eNetcdfError,
|
4222
|
+
"length of the array does not agree with that of the subset\n");
|
4223
|
+
}
|
4224
|
+
}
|
4225
|
+
|
4226
|
+
status = nc_put_vars_int(ncid,varid,c_start,c_count,c_stride,ptr);
|
4227
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4228
|
+
return Qnil;
|
4229
|
+
}
|
4230
|
+
|
4231
|
+
|
4232
|
+
VALUE
|
4233
|
+
NetCDF_put_vars_float(VALUE Var,VALUE NArray,VALUE start,VALUE end,VALUE stride)
|
4234
|
+
{
|
4235
|
+
int ncid;
|
4236
|
+
int varid;
|
4237
|
+
int status;
|
4238
|
+
float *ptr,scalar;
|
4239
|
+
int len,i;
|
4240
|
+
int c_count_all=1;
|
4241
|
+
struct NetCDFVar *Netcdf_var;
|
4242
|
+
long l_start, l_end;
|
4243
|
+
size_t *c_start;
|
4244
|
+
size_t *c_count;
|
4245
|
+
ptrdiff_t *c_stride;
|
4246
|
+
int ndims;
|
4247
|
+
int *shape;
|
4248
|
+
int *dimids;
|
4249
|
+
size_t dimlen;
|
4250
|
+
|
4251
|
+
rb_secure(4);
|
4252
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
4253
|
+
ncid=Netcdf_var->ncid;
|
4254
|
+
varid=Netcdf_var->varid;
|
4255
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
4256
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4257
|
+
|
4258
|
+
dimids=ALLOCA_N(int,ndims);
|
4259
|
+
status = nc_inq_vardimid(ncid, varid, dimids);
|
4260
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4261
|
+
|
4262
|
+
Check_Type(start,T_ARRAY);
|
4263
|
+
if(RARRAY_LEN(start) < ndims) {
|
4264
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
4265
|
+
}
|
4266
|
+
c_start=ALLOCA_N(size_t,ndims);
|
4267
|
+
for(i=0; i<ndims; i++){
|
4268
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
4269
|
+
|
4270
|
+
if(l_start < 0) {
|
4271
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
4272
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4273
|
+
l_start += dimlen;
|
4274
|
+
}
|
4275
|
+
c_start[i]=l_start;
|
4276
|
+
}
|
4277
|
+
|
4278
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
4279
|
+
switch(TYPE(stride)){
|
4280
|
+
case T_NIL:
|
4281
|
+
for(i=0; i<ndims; i++){
|
4282
|
+
c_stride[i]=1;
|
4283
|
+
}
|
4284
|
+
break;
|
4285
|
+
default:
|
4286
|
+
Check_Type(stride,T_ARRAY);
|
4287
|
+
if(RARRAY_LEN(stride) < ndims) {
|
4288
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride' is too short\n");
|
4289
|
+
}
|
4290
|
+
for(i=0; i<ndims; i++){
|
4291
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
4292
|
+
if(c_stride[i]==0) {
|
4293
|
+
rb_raise(rb_eNetcdfError, "stride cannot be zero\n");
|
4294
|
+
}
|
4295
|
+
}
|
4296
|
+
}
|
4297
|
+
|
4298
|
+
Array_to_Cfloat_len_shape(NArray,ptr,len,shape);
|
4299
|
+
|
4300
|
+
c_count=ALLOCA_N(size_t,ndims);
|
4301
|
+
switch(TYPE(end)){
|
4302
|
+
case T_NIL:
|
4303
|
+
for(i=0; i<ndims; i++){
|
4304
|
+
c_count[i]=shape[i];
|
4305
|
+
}
|
4306
|
+
c_count_all=len;
|
4307
|
+
break;
|
4308
|
+
default:
|
4309
|
+
Check_Type(end,T_ARRAY);
|
4310
|
+
if(RARRAY_LEN(end) < ndims) {
|
4311
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
4312
|
+
}
|
4313
|
+
for(i=0; i<ndims; i++){
|
4314
|
+
l_end=NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
4315
|
+
if(l_end < 0) {
|
4316
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
4317
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4318
|
+
l_end += dimlen;
|
4319
|
+
}
|
4320
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
4321
|
+
c_count_all=c_count[i]*c_count_all;
|
4322
|
+
}
|
4323
|
+
if(len == 1 && len != c_count_all){
|
4324
|
+
scalar = *ptr;
|
4325
|
+
ptr = ALLOCA_N(float,c_count_all);
|
4326
|
+
for(i=0;i<c_count_all;i++){ptr[i]=scalar;}
|
4327
|
+
} else if(len != c_count_all) {
|
4328
|
+
rb_raise(rb_eNetcdfError,
|
4329
|
+
"lengh of the array does not agree with that of the subset\n");
|
4330
|
+
}
|
4331
|
+
}
|
4332
|
+
|
4333
|
+
status = nc_put_vars_float(ncid,varid,c_start,c_count,c_stride,ptr);
|
4334
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4335
|
+
return Qnil;
|
4336
|
+
}
|
4337
|
+
|
4338
|
+
|
4339
|
+
VALUE
|
4340
|
+
NetCDF_put_vars_double(VALUE Var,VALUE NArray,VALUE start,VALUE end,VALUE stride)
|
4341
|
+
{
|
4342
|
+
int ncid;
|
4343
|
+
int varid;
|
4344
|
+
int status;
|
4345
|
+
double *ptr,scalar;
|
4346
|
+
int len,i;
|
4347
|
+
int c_count_all=1;
|
4348
|
+
struct NetCDFVar *Netcdf_var;
|
4349
|
+
long l_start, l_end;
|
4350
|
+
size_t *c_start;
|
4351
|
+
size_t *c_count;
|
4352
|
+
ptrdiff_t *c_stride;
|
4353
|
+
int ndims;
|
4354
|
+
int *shape;
|
4355
|
+
int *dimids;
|
4356
|
+
size_t dimlen;
|
4357
|
+
|
4358
|
+
rb_secure(4);
|
4359
|
+
Data_Get_Struct(Var,struct NetCDFVar,Netcdf_var);
|
4360
|
+
ncid=Netcdf_var->ncid;
|
4361
|
+
varid=Netcdf_var->varid;
|
4362
|
+
status = nc_inq_varndims(ncid, varid, &ndims);
|
4363
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4364
|
+
|
4365
|
+
dimids=ALLOCA_N(int,ndims);
|
4366
|
+
status = nc_inq_vardimid(ncid, varid, dimids);
|
4367
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4368
|
+
|
4369
|
+
Check_Type(start,T_ARRAY);
|
4370
|
+
if(RARRAY_LEN(start) < ndims) {
|
4371
|
+
rb_raise(rb_eNetcdfError, "Length of 'start' is too short\n");
|
4372
|
+
}
|
4373
|
+
c_start=ALLOCA_N(size_t,ndims);
|
4374
|
+
for(i=0; i<ndims; i++){
|
4375
|
+
l_start=NUM2INT(RARRAY_PTR(start)[ndims-1-i]);
|
4376
|
+
|
4377
|
+
if(l_start < 0) {
|
4378
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
4379
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4380
|
+
l_start += dimlen;
|
4381
|
+
}
|
4382
|
+
c_start[i]=l_start;
|
4383
|
+
}
|
4384
|
+
|
4385
|
+
c_stride=ALLOCA_N(ptrdiff_t,ndims);
|
4386
|
+
switch(TYPE(stride)){
|
4387
|
+
case T_NIL:
|
4388
|
+
for(i=0; i<ndims; i++){
|
4389
|
+
c_stride[i]=1;
|
4390
|
+
}
|
4391
|
+
break;
|
4392
|
+
default:
|
4393
|
+
Check_Type(stride,T_ARRAY);
|
4394
|
+
if(RARRAY_LEN(stride) < ndims) {
|
4395
|
+
rb_raise(rb_eNetcdfError, "Length of 'stride' is too short\n");
|
4396
|
+
}
|
4397
|
+
for(i=0; i<ndims; i++){
|
4398
|
+
c_stride[i]=NUM2INT(RARRAY_PTR(stride)[ndims-1-i]);
|
4399
|
+
if(c_stride[i]==0) {
|
4400
|
+
rb_raise(rb_eNetcdfError, "stride cannot be zero\n");
|
4401
|
+
}
|
4402
|
+
}
|
4403
|
+
}
|
4404
|
+
|
4405
|
+
Array_to_Cdouble_len_shape(NArray,ptr,len,shape);
|
4406
|
+
|
4407
|
+
c_count=ALLOCA_N(size_t,ndims);
|
4408
|
+
switch(TYPE(end)){
|
4409
|
+
case T_NIL:
|
4410
|
+
for(i=0; i<ndims; i++){
|
4411
|
+
c_count[i]=shape[i];
|
4412
|
+
}
|
4413
|
+
c_count_all=len;
|
4414
|
+
break;
|
4415
|
+
default:
|
4416
|
+
Check_Type(end,T_ARRAY);
|
4417
|
+
if(RARRAY_LEN(end) < ndims) {
|
4418
|
+
rb_raise(rb_eNetcdfError, "Length of 'end' is too short\n");
|
4419
|
+
}
|
4420
|
+
for(i=0; i<ndims; i++){
|
4421
|
+
l_end=NUM2INT(RARRAY_PTR(end)[ndims-1-i]);
|
4422
|
+
if(l_end < 0) {
|
4423
|
+
status = nc_inq_dimlen(ncid, dimids[i], &dimlen);
|
4424
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4425
|
+
l_end += dimlen;
|
4426
|
+
}
|
4427
|
+
c_count[i]=(l_end-c_start[i])/c_stride[i]+1;
|
4428
|
+
c_count_all=c_count[i]*c_count_all;
|
4429
|
+
}
|
4430
|
+
if(len == 1 && len != c_count_all){
|
4431
|
+
scalar = *ptr;
|
4432
|
+
ptr = ALLOCA_N(double,c_count_all);
|
4433
|
+
for(i=0;i<c_count_all;i++){ptr[i]=scalar;}
|
4434
|
+
} else if(len != c_count_all) {
|
4435
|
+
rb_raise(rb_eNetcdfError,
|
4436
|
+
"lengh of the array does not agree with that of the subset\n");
|
4437
|
+
}
|
4438
|
+
}
|
4439
|
+
|
4440
|
+
status = nc_put_vars_double(ncid,varid,c_start,c_count,c_stride,ptr);
|
4441
|
+
if(status != NC_NOERR) NC_RAISE(status);
|
4442
|
+
return Qnil;
|
4443
|
+
}
|
4444
|
+
|
4445
|
+
void
|
4446
|
+
Init_netcdfraw(void)
|
4447
|
+
{
|
4448
|
+
mNumRu = rb_define_module("NumRu");
|
4449
|
+
|
4450
|
+
/* Difinitions of the classes */
|
4451
|
+
cNetCDF = rb_define_class_under(mNumRu, "NetCDF", rb_cObject);
|
4452
|
+
cNetCDFDim = rb_define_class_under(mNumRu, "NetCDFDim", rb_cObject);
|
4453
|
+
cNetCDFAtt = rb_define_class_under(mNumRu, "NetCDFAtt", rb_cObject);
|
4454
|
+
cNetCDFVar = rb_define_class_under(mNumRu, "NetCDFVar", rb_cObject);
|
4455
|
+
|
4456
|
+
rb_eNetcdfError = rb_define_class("NetcdfError",rb_eStandardError);
|
4457
|
+
rb_eNetcdfBadid = rb_define_class("NetcdfBadid",rb_eNetcdfError);
|
4458
|
+
rb_eNetcdfNfile = rb_define_class("NetcdfNfile",rb_eNetcdfError);
|
4459
|
+
rb_eNetcdfExist = rb_define_class("NetcdfExist",rb_eNetcdfError);
|
4460
|
+
rb_eNetcdfInval = rb_define_class("NetcdfInval",rb_eNetcdfError);
|
4461
|
+
rb_eNetcdfPerm = rb_define_class("NetcdfPerm",rb_eNetcdfError);
|
4462
|
+
rb_eNetcdfNotindefine = rb_define_class("NetcdfNotindefine",rb_eNetcdfError);
|
4463
|
+
rb_eNetcdfIndefine = rb_define_class("NetcdfIndefine",rb_eNetcdfError);
|
4464
|
+
rb_eNetcdfInvalcoords = rb_define_class("NetcdfInvalcoords",rb_eNetcdfError);
|
4465
|
+
rb_eNetcdfMaxdims = rb_define_class("NetcdfMaxdims",rb_eNetcdfError);
|
4466
|
+
rb_eNetcdfNameinuse = rb_define_class("NetcdfNameinuse",rb_eNetcdfError);
|
4467
|
+
rb_eNetcdfNotatt = rb_define_class("NetcdfNotatt",rb_eNetcdfError);
|
4468
|
+
rb_eNetcdfMaxatts = rb_define_class("NetcdfMaxatts",rb_eNetcdfError);
|
4469
|
+
rb_eNetcdfBadtype = rb_define_class("NetcdfBadtype",rb_eNetcdfError);
|
4470
|
+
rb_eNetcdfBaddim = rb_define_class("NetcdfBaddim",rb_eNetcdfError);
|
4471
|
+
rb_eNetcdfUnlimpos = rb_define_class("NetcdFUnlimpos",rb_eNetcdfError);
|
4472
|
+
rb_eNetcdfMaxvars = rb_define_class("NetcdfMaxvars",rb_eNetcdfError);
|
4473
|
+
rb_eNetcdfNotvar = rb_define_class("NetcdfNotvar",rb_eNetcdfError);
|
4474
|
+
rb_eNetcdfGlobal = rb_define_class("NetcdfGlobal",rb_eNetcdfError);
|
4475
|
+
rb_eNetcdfNotnc = rb_define_class("NetcdfNotnc",rb_eNetcdfError);
|
4476
|
+
rb_eNetcdfSts = rb_define_class("NetcdfSts",rb_eNetcdfError);
|
4477
|
+
rb_eNetcdfMaxname = rb_define_class("NetcdfMaxname",rb_eNetcdfError);
|
4478
|
+
rb_eNetcdfUnlimit = rb_define_class("NetcdfUnlimit",rb_eNetcdfError);
|
4479
|
+
rb_eNetcdfNorecvars = rb_define_class("NetcdfNorecvars",rb_eNetcdfError);
|
4480
|
+
rb_eNetcdfChar = rb_define_class("NetcdfChar",rb_eNetcdfError);
|
4481
|
+
rb_eNetcdfEdge = rb_define_class("NetcdfEdge",rb_eNetcdfError);
|
4482
|
+
rb_eNetcdfStride = rb_define_class("NetcdfStride",rb_eNetcdfError);
|
4483
|
+
rb_eNetcdfBadname = rb_define_class("NetcdfBadname",rb_eNetcdfError);
|
4484
|
+
/* N.B. following must match value in ncx.h */
|
4485
|
+
rb_eNetcdfRange = rb_define_class("NetcdfRange",rb_eNetcdfError);
|
4486
|
+
rb_eNetcdfNomem = rb_define_class("NetcdfNomem",rb_eNetcdfError);
|
4487
|
+
/* Global error status */
|
4488
|
+
rb_eNetcdfEntool = rb_define_class("NetcdfEntool",rb_eNetcdfError);
|
4489
|
+
rb_eNetcdfExdr = rb_define_class("NetcdfExdr",rb_eNetcdfError);
|
4490
|
+
rb_eNetcdfSyserr = rb_define_class("NetcdfSyserr",rb_eNetcdfError);
|
4491
|
+
/* Global options variable. Used to determine behavior of error handler. */
|
4492
|
+
rb_eNetcdfFatal = rb_define_class("NetcdfFatal",rb_eNetcdfError);
|
4493
|
+
|
4494
|
+
/* Class Constants Definition */
|
4495
|
+
rb_define_const(cNetCDF, "NC_NOWRITE", INT2FIX(NC_NOWRITE));
|
4496
|
+
rb_define_const(cNetCDF, "NC_WRITE", INT2FIX(NC_WRITE));
|
4497
|
+
rb_define_const(cNetCDF, "NC_SHARE", INT2FIX(NC_SHARE));
|
4498
|
+
rb_define_const(cNetCDF, "NC_CLOBBER", INT2FIX(NC_CLOBBER));
|
4499
|
+
rb_define_const(cNetCDF, "NC_NOCLOBBER", INT2FIX(NC_NOCLOBBER));
|
4500
|
+
|
4501
|
+
/* Difinitions of the ruby methods */
|
4502
|
+
/* The methods of the NetCDF class */
|
4503
|
+
rb_define_singleton_method(cNetCDF,"nc_open",NetCDF_open,2);
|
4504
|
+
rb_define_method(cNetCDF,"clone",NetCDF_clone,0);
|
4505
|
+
rb_define_method(cNetCDF,"close",NetCDF_close,0);
|
4506
|
+
/* rb_define_singleton_method(cNetCDF,"new",NetCDF_open,2); */
|
4507
|
+
rb_define_singleton_method(cNetCDF,"nc_create",NetCDF_create,2);
|
4508
|
+
rb_define_method(cNetCDF,"def_dim",NetCDF_def_dim,2);
|
4509
|
+
rb_define_method(cNetCDF,"def_var",NetCDF_def_var,3);
|
4510
|
+
rb_define_method(cNetCDF,"put_attraw",NetCDF_put_att,3);
|
4511
|
+
rb_define_method(cNetCDF,"redef",NetCDF_redef,0);
|
4512
|
+
rb_define_method(cNetCDF,"enddef",NetCDF_enddef,0);
|
4513
|
+
rb_define_method(cNetCDF,"define_mode?",NetCDF_whether_in_define_mode,0);
|
4514
|
+
rb_define_method(cNetCDF,"fill",NetCDF_fill,1);
|
4515
|
+
rb_define_method(cNetCDF,"ndims",NetCDF_ndims,0);
|
4516
|
+
rb_define_method(cNetCDF,"nvars",NetCDF_nvars,0);
|
4517
|
+
rb_define_method(cNetCDF,"natts",NetCDF_natts,0);
|
4518
|
+
rb_define_method(cNetCDF,"sync",NetCDF_sync,0);
|
4519
|
+
rb_define_method(cNetCDF,"path",NetCDF_path,0);
|
4520
|
+
rb_define_method(cNetCDF,"dim",NetCDF_dim,1);
|
4521
|
+
rb_define_method(cNetCDF,"var",NetCDF_var,1);
|
4522
|
+
rb_define_method(cNetCDF,"att",NetCDF_att,1);
|
4523
|
+
rb_define_method(cNetCDF,"unlimited",NetCDF_unlimited,0);
|
4524
|
+
rb_define_private_method(cNetCDF,"id2var",NetCDF_id2var,1);
|
4525
|
+
rb_define_private_method(cNetCDF,"id2dim",NetCDF_id2dim,1);
|
4526
|
+
rb_define_private_method(cNetCDF,"id2att",NetCDF_id2att,1);
|
4527
|
+
rb_define_method(cNetCDF,"==",NetCDF_eql,1);
|
4528
|
+
/* rb_define_method(cNetCDF,"eql?",NetCDF_eql,1); */
|
4529
|
+
|
4530
|
+
/* The methods of the NetCDFDim class */
|
4531
|
+
rb_define_method(cNetCDFDim,"clone",NetCDF_dim_clone,0);
|
4532
|
+
rb_define_method(cNetCDFDim,"length",NetCDF_dim_length,0);
|
4533
|
+
rb_define_method(cNetCDFDim,"name=",NetCDF_dim_name,1);
|
4534
|
+
rb_define_method(cNetCDFDim,"name",NetCDF_dim_inqname,0);
|
4535
|
+
rb_define_method(cNetCDFDim,"unlimited?",NetCDF_dim_whether_unlimited,0);
|
4536
|
+
rb_define_method(cNetCDFDim,"==",NetCDF_dim_eql,1);
|
4537
|
+
/* rb_define_method(cNetCDFDim,"eql?",NetCDF_dim_eql,1); */
|
4538
|
+
|
4539
|
+
/* The methods of the NetCDFAtt class */
|
4540
|
+
rb_define_method(cNetCDFAtt,"clone",NetCDF_att_clone,0);
|
4541
|
+
rb_define_method(cNetCDFAtt,"name",NetCDF_att_inq_name,0);
|
4542
|
+
rb_define_method(cNetCDFAtt,"name=",NetCDF_att_rename,1);
|
4543
|
+
rb_define_method(cNetCDFAtt,"delete",NetCDF_att_delete,0);
|
4544
|
+
rb_define_method(cNetCDFAtt,"copy",NetCDF_att_copy,1);
|
4545
|
+
rb_define_method(cNetCDFAtt,"atttype",NetCDF_att_atttype,0);
|
4546
|
+
rb_define_method(cNetCDFAtt,"typecode",NetCDF_att_typecode,0);
|
4547
|
+
rb_define_method(cNetCDFAtt,"==",NetCDF_att_eql,1);
|
4548
|
+
/* rb_define_method(cNetCDFAtt,"eql?",NetCDF_att_eql,1); */
|
4549
|
+
rb_define_method(cNetCDFAtt,"putraw",NetCDF_att_put,2);
|
4550
|
+
rb_define_method(cNetCDFAtt,"get",NetCDF_att_get,0);
|
4551
|
+
|
4552
|
+
/* The methods of the NetCDFVar class */
|
4553
|
+
rb_define_method(cNetCDFVar,"clone",NetCDF_var_clone,0);
|
4554
|
+
rb_define_method(cNetCDFVar,"name",NetCDF_var_inq_name,0);
|
4555
|
+
rb_define_method(cNetCDFVar,"ndims",NetCDF_var_ndims,0);
|
4556
|
+
rb_define_method(cNetCDFVar,"vartype",NetCDF_var_vartype,0);
|
4557
|
+
rb_define_method(cNetCDFVar,"typecode",NetCDF_var_typecode,0);
|
4558
|
+
rb_define_method(cNetCDFVar,"ntype",NetCDF_var_vartype,0);
|
4559
|
+
rb_define_method(cNetCDFVar,"natts",NetCDF_var_natts,0);
|
4560
|
+
rb_define_method(cNetCDFVar,"file",NetCDF_var_file,0);
|
4561
|
+
rb_define_method(cNetCDFVar,"name=",NetCDF_var_rename,1);
|
4562
|
+
rb_define_method(cNetCDFVar,"att",NetCDF_var_att,1);
|
4563
|
+
rb_define_method(cNetCDFVar,"put_attraw",NetCDF_put_att_var,3);
|
4564
|
+
rb_define_method(cNetCDFVar,"dims",NetCDF_var_dims,0);
|
4565
|
+
rb_define_method(cNetCDFVar,"dim",NetCDF_var_dim,1);
|
4566
|
+
/*rb_define_private_method(cNetCDFVar,"id2dim",NetCDF_var_id2dim,1); */
|
4567
|
+
rb_define_private_method(cNetCDFVar,"id2att",NetCDF_var_id2att,1);
|
4568
|
+
rb_define_method(cNetCDFVar,"==",NetCDF_var_eql,1);
|
4569
|
+
/* rb_define_method(cNetCDFVar,"eql?",NetCDF_var_eql,1); */
|
4570
|
+
|
4571
|
+
/* The "get*" or "put*" methods in the NetCDFVar class */
|
4572
|
+
rb_define_method(cNetCDFVar,"put_var_char",NetCDF_put_var_char,1);
|
4573
|
+
rb_define_method(cNetCDFVar,"put_var_byte",NetCDF_put_var_byte,1);
|
4574
|
+
rb_define_method(cNetCDFVar,"put_var_sint",NetCDF_put_var_short,1);
|
4575
|
+
rb_define_method(cNetCDFVar,"put_var_int",NetCDF_put_var_int,1);
|
4576
|
+
rb_define_method(cNetCDFVar,"put_var_sfloat",NetCDF_put_var_float,1);
|
4577
|
+
rb_define_method(cNetCDFVar,"put_var_float",NetCDF_put_var_double,1);
|
4578
|
+
|
4579
|
+
rb_define_method(cNetCDFVar,"put_vars_char",NetCDF_put_vars_char,4);
|
4580
|
+
rb_define_method(cNetCDFVar,"put_vars_byte",NetCDF_put_vars_byte,4);
|
4581
|
+
rb_define_method(cNetCDFVar,"put_vars_sint",NetCDF_put_vars_sint,4);
|
4582
|
+
rb_define_method(cNetCDFVar,"put_vars_int",NetCDF_put_vars_int,4);
|
4583
|
+
rb_define_method(cNetCDFVar,"put_vars_sfloat",NetCDF_put_vars_float,4);
|
4584
|
+
rb_define_method(cNetCDFVar,"put_vars_float",NetCDF_put_vars_double,4);
|
4585
|
+
|
4586
|
+
rb_define_method(cNetCDFVar,"put_var1_char",NetCDF_put_var1_char,2);
|
4587
|
+
rb_define_method(cNetCDFVar,"put_var1_byte",NetCDF_put_var1_byte,2);
|
4588
|
+
rb_define_method(cNetCDFVar,"put_var1_sint",NetCDF_put_var1_sint,2);
|
4589
|
+
rb_define_method(cNetCDFVar,"put_var1_int",NetCDF_put_var1_int,2);
|
4590
|
+
rb_define_method(cNetCDFVar,"put_var1_sfloat",NetCDF_put_var1_float,2);
|
4591
|
+
rb_define_method(cNetCDFVar,"put_var1_float",NetCDF_put_var1_double,2);
|
4592
|
+
|
4593
|
+
rb_define_method(cNetCDFVar,"get_var_char",NetCDF_get_var_char,0);
|
4594
|
+
rb_define_method(cNetCDFVar,"get_var_byte",NetCDF_get_var_byte,0);
|
4595
|
+
rb_define_method(cNetCDFVar,"get_var_sint",NetCDF_get_var_sint,0);
|
4596
|
+
rb_define_method(cNetCDFVar,"get_var_int",NetCDF_get_var_int,0);
|
4597
|
+
rb_define_method(cNetCDFVar,"get_var_sfloat",NetCDF_get_var_float,0);
|
4598
|
+
rb_define_method(cNetCDFVar,"get_var_float",NetCDF_get_var_double,0);
|
4599
|
+
|
4600
|
+
rb_define_method(cNetCDFVar,"get_vars_char",NetCDF_get_vars_char,3);
|
4601
|
+
rb_define_method(cNetCDFVar,"get_vars_byte",NetCDF_get_vars_byte,3);
|
4602
|
+
rb_define_method(cNetCDFVar,"get_vars_sint",NetCDF_get_vars_sint,3);
|
4603
|
+
rb_define_method(cNetCDFVar,"get_vars_int",NetCDF_get_vars_int,3);
|
4604
|
+
rb_define_method(cNetCDFVar,"get_vars_sfloat",NetCDF_get_vars_float,3);
|
4605
|
+
rb_define_method(cNetCDFVar,"get_vars_float",NetCDF_get_vars_double,3);
|
4606
|
+
|
4607
|
+
rb_define_method(cNetCDFVar,"get_var1_char",NetCDF_get_var1_char,1);
|
4608
|
+
rb_define_method(cNetCDFVar,"get_var1_byte",NetCDF_get_var1_byte,1);
|
4609
|
+
rb_define_method(cNetCDFVar,"get_var1_sint",NetCDF_get_var1_sint,1);
|
4610
|
+
rb_define_method(cNetCDFVar,"get_var1_int",NetCDF_get_var1_int,1);
|
4611
|
+
rb_define_method(cNetCDFVar,"get_var1_sfloat",NetCDF_get_var1_float,1);
|
4612
|
+
rb_define_method(cNetCDFVar,"get_var1_float",NetCDF_get_var1_double,1);
|
4613
|
+
}
|