gentooboontoo-ruby-netcdf 0.6.6.2

data/lib/numru/netcdf_miss.rb

@@ -0,0 +1,203 @@
+require "numru/netcdf"
+require "narray_miss"
+
+module NumRu
+
+  class NetCDFVar
+
+    def get_with_miss(*args)
+      __interpret_missing_params if !defined?(@missval)
+      data = simple_get(*args)
+      if @vmin || @vmax
+	if @vmin
+	  mask = (data >= @vmin) 
+	  mask = mask.and(data <= @vmax) if @vmax
+	else
+	  mask = (data <= @vmax)
+	end
+	data = NArrayMiss.to_nam(data, mask)
+      elsif @missval	# only missing_value is present.
+	mask = (data.ne(@missval)) 
+	data = NArrayMiss.to_nam(data, mask)
+      end
+      data
+    end
+
+    def get_with_miss_and_scaling(*args)
+      __interpret_missing_params if !defined?(@missval)
+      data = simple_get(*args)
+      if @vmin || @vmax
+	if @vmin
+	  mask = (data >= @vmin) 
+	  mask = mask.and(data <= @vmax) if @vmax
+	else
+	  mask = (data <= @vmax)
+	end
+	data = NArrayMiss.to_nam(data, mask)
+      elsif @missval	# only missing_value is present.
+	mask = (data.ne(@missval))
+	data = NArrayMiss.to_nam(data, mask)
+      end
+      data = unpack( data )
+      data
+    end
+
+    def put_with_miss(data, *args)
+      if data.is_a?( NArrayMiss )
+	__interpret_missing_params if !defined?(@missval)
+	if @missval
+	  simple_put(data.to_na(@missval), *args)
+	else
+	  simple_put(data.to_na, *args)
+	end
+      else
+	simple_put(data, *args)
+      end
+    end
+
+    def put_with_miss_and_scaling(data, *args)
+      if data.is_a?( NArrayMiss )
+	__interpret_missing_params if !defined?(@missval)
+	if @missval
+	  data = pack( data )
+	  data = data.to_na(@missval)
+	else
+	  data = pack( data )
+	  data = data.to_na
+	end
+	simple_put(data, *args)
+      else
+	scaled_put(data, *args)
+      end
+    end
+
+    ######### private ##########
+
+    def __interpret_missing_params
+      # Interprets the specification of missing data,
+      # either by valid_range, (valid_min and/or valid_max), or missing_value.
+      # (unlike the NetCDF User's guide (NUG), missing_value is interpreted, 
+      # but valid_* has a higher precedence.)
+      # Always sets @missval whether missing_value is defined or not,
+      # since it will be used as a fill value for data missing.
+      #
+      @vmin = att('valid_min')
+      @vmin = @vmin.get if @vmin  # kept in a NArray(size==1) to consv type
+      @vmax = att('valid_max')
+      @vmax = @vmax.get if @vmax  # kept in a NArray(size==1) to consv type
+      vrange = att('valid_range')
+      vrange = vrange.get if vrange
+      if vrange
+	vrange.sort!
+	@vmin = vrange[0..0]        # kept in... (same)
+	@vmax = vrange[-1..-1]      # kept in... (same)
+      end
+      @missval = att('missing_value') || att('_FillValue')
+      @missval = @missval.get if @missval # kept in... (same)
+
+      sf = att('scale_factor')
+      ao = att('add_offset')
+      if ( sf || ao )
+        ## Both NUG & CF conventions requires to specify the valid
+        ## range with respect to the external (i.e. packed) values. 
+        ## However, some conventions require specification
+        ## with respect to unpacked values. The following
+        ## is to support such cases as well:
+        thres_tp = [ self.typecode, NArray::LINT ].max
+        @missval = pack(@missval) if @missval && @missval.typecode > thres_tp
+        @vmin = pack(@vmin) if @vmin && @vmin.typecode > thres_tp
+        @vmax = pack(@vmax) if @vmax && @vmax.typecode > thres_tp
+      end
+
+      if @missval
+        if @vmin && @vmax 
+	  if @vmin[0] <= @missval[0] && @missval[0] <= @vmax[0]
+            warn "WARNING: missing_value #{@missval[0]} is in the valid range #{@vmin[0]}..#{@vmax[0]} --> will be ignored (#{__FILE__}:#{__LINE__})"
+          end
+        else
+          if @vmin && @missval[0] >= @vmin[0]
+            warn "WARNING: missing_value #{@missval[0]} >= valid min #{@vmin[0]} --> will be ignored (#{__FILE__}:#{__LINE__})"
+          elsif @vmax && @missval[0] <= @vmax[0]
+            warn "WARNING: missing_value #{@missval[0]} <= valid min #{@vmin[0]} --> will be ignored (#{__FILE__}:#{__LINE__})"
+          end
+        end
+      else
+        realtc = NArray::SFLOAT
+        if @vmin
+          if @vmin[0] >= 0
+            @missval = ( @vmin.typecode>=realtc ? 0.99*@vmin : @vmin-1 )
+          else
+            @missval = ( @vmin.typecode>=realtc ? 1.01*@vmin : @vmin-1 )
+          end
+        elsif @vmax
+          if @vmax[0] >= 0
+            @missval = ( @vmax.typecode>=realtc ? 1.01*@vmax : @vmax+1 )
+          else
+            @missval = ( @vmax.typecode>=realtc ? 0.99*@vmax : @vmax+1 )
+          end
+        end
+      end
+
+    end
+
+    private :__interpret_missing_params
+
+  end
+
+end
+
+if $0 == __FILE__
+  include NumRu
+
+  filename = "tmp.nc"
+  print "creating ",filename,"...\n"
+  file=NetCDF.create(filename)
+  nx = 10
+  dimx = file.def_dim("x",nx)
+  xf = file.def_var("xf","sfloat",[dimx])
+  xfn = file.def_var("xfn","sfloat",[dimx])
+  xf.put_att("valid_range",[-1e12,1e12])
+  f = 10 ** (2*NArray.sfloat(nx).indgen!)
+  xr = file.def_var("xr","sint",[dimx])
+  xr.put_att("valid_max",[0.5])
+  xr.put_att("scale_factor",1e-4)
+  xr.put_att("add_offset",0.5)
+  xr2 = file.def_var("xr2","sint",[dimx])
+  xr2.put_att("valid_max",NArray.sint(1).fill!(1000))
+  xr2.put_att("scale_factor",1e-4)
+  xr2.put_att("add_offset",0.5)
+  r = NArray.sfloat(nx).indgen!/nx
+  file.enddef
+  xf.put(f)
+  xfn.put(f)
+  xr.scaled_put(r)
+  file.close
+
+  file = NetCDF.open(filename,'r+')
+  xf = file.var('xf')
+  xfn = file.var('xfn')
+  p "f0"
+  xf.get.each{|v| print "#{v} "} ; print "\n"
+  p( 'f1', nam = xf.get_with_miss )
+  def xf.get(*args); get_with_miss(*args); end
+  p( 'f12',  xf[2..-3].to_na )
+  p( 'fn10', xfn.get_with_miss )
+  p( 'fn11', xfn.get_with_miss_and_scaling )
+  nam.invalidation([0,1])
+  p 'f2', nam
+  xf.put_with_miss(nam)
+  p( 'f3', xf.get_with_miss )
+  xr = file.var('xr')
+  p "r0"
+  xr.simple_get.each{|v| print "#{v} "} ; print "\n"
+  p( 'r1', xr.get_with_miss_and_scaling )
+  def xr.get(*args); get_with_miss_and_scaling(*args); end
+  def xr.put(*args); put_with_miss_and_scaling(*args); end
+  #xr[0..3] = xr[0..3]*10
+  p( 'r2', xr.get_with_miss_and_scaling )
+  p 'r',r
+  xr2.put_with_miss_and_scaling(r)
+  p 'xr2',xr2.get_with_miss_and_scaling
+  file.close
+  print "** ncdump tmp.nc **\n", `ncdump tmp.nc`
+end

data/test/aref_aset.rb

@@ -0,0 +1,37 @@
+require 'numru/netcdf'
+include NumRu
+s = 'tmp.nc'
+f = NetCDF.create(s)
+f.redef
+dx = f.def_dim('x',5)
+dy = f.def_dim('y',3)
+v = f.def_var('x','sfloat',[dx])
+v2 = f.def_var('x2',NArray::SFLOAT,[dx])
+vxy = f.def_var('xy','sfloat',[dx,dy])
+f.enddef
+v.put([1,2,3,4,5])
+p 'testing []= ...'
+v[{0..3=>2}]=[100,500]
+v[1]=999
+v[3..4]=[-99,-99]
+v2.put(666)
+v2[0..2]=777
+vxy.put(NArray.sfloat(5,3).indgen!)
+vxy[[2,0],[0,2,1]] = [[1,2],[3,4],[5,6]]
+vxy[1,[2,0,1]] = [10,20,30]
+vxy[[4,3],2] = [100,200]
+
+f.close
+
+f = NetCDF.open(s)
+v = f.var('x')
+p 'testing [] ...'
+p '*0*',v[{0..3=>2}]
+p '*1*',v[1]
+p '*2*',v[3..4],v.rank
+p '*3*',v[[2,0,0]]
+vxy = f.var('xy')
+p '*4*',vxy[[2,0],[0,2,1]]
+p '*5*',vxy[1,[2,0,1]]
+p '*6*',vxy[[4,3],2]
+f.close

data/test/char_var.rb

@@ -0,0 +1,25 @@
+## test of "char" variables
+
+require 'numru/netcdf'
+include NumRu
+s = 'tmp.nc'
+f = NetCDF.create(s)
+d = f.def_dim('x',5)
+v = f.def_var('x','char',[d])
+tv = f.def_var('text','char',[d])
+f.enddef
+v.put( NArray.byte(5).indgen! )
+tv.put( NArray.to_na("hello","byte",5) )
+tv.put( NArray.to_na("LO","byte",2), 'start'=>[3] )
+tv.put( NArray.to_na("H","byte",1), 'index'=>[0] )
+f.close
+
+f = NetCDF.open(s)
+v = f.var('x')
+p v.get
+tv = f.var('text')
+p tv.get
+p tv.get.to_s
+
+
+

data/test/clone.rb

@@ -0,0 +1,54 @@
+require 'numru/netcdf'
+include NumRu
+s = 'tmp.nc'
+#f = NetCDF.new(s,'rw')
+f = NetCDF.create(s)
+f.redef
+d = f.def_dim('x',3)
+v = f.def_var('x','sfloat',[d])
+a = f.put_att('long_name','xx')
+f.enddef
+v.put([1,2,3])
+f.taint
+f.freeze
+f2 = f.clone
+p 'netcdf  clone'
+p f.path, f2.path   
+p f.tainted?, f2.tainted?, f.frozen?, f2.frozen?  
+
+p 'netcdf  dup'
+f3 = f.dup
+p f.tainted?, f3.tainted?, f.frozen?, f3.frozen?  
+
+p 'netcdfdim'
+d.taint
+d2 = d.clone
+d3 = d.dup
+p d.tainted?, d2.tainted?, d3.tainted?
+
+p 'netcdfvar'
+v.taint
+v2 = v.clone
+v3 = v.dup
+p v.tainted?, v2.tainted?, v3.tainted?
+
+p 'netcdfatt'
+a.taint
+a2 = a.clone
+a3 = a.dup
+p a.tainted?, a2.tainted?, a3.tainted?
+
+f.close
+
+p 'narray (for reference)'
+a = NArray.float(3)
+a.taint
+b = a.clone
+p a.tainted?, b.tainted?  
+b = a.dup
+p a.tainted?, b.tainted?  
+
+
+
+
+

data/test/create_tmp.rb

@@ -0,0 +1,15 @@
+require 'numru/netcdf'
+
+$DEBUG = true
+include NumRu
+file = NetCDF.create_tmp
+file.def_dim('x',5)
+file.put_att("history", __FILE__ )
+p file.path
+p file.att("history").get
+print "environment variable TEMP ="+(ENV['TEMP'] || '')+"\n"
+file2=file
+print "000\n"
+file.close
+GC.start
+print "aaa\n"

data/test/def_var_with_dim.rb

@@ -0,0 +1,14 @@
+require 'numru/netcdf'
+include NumRu
+file = NetCDF.create("tmp.nc")
+var1 = file.def_var_with_dim("var1","sfloat",[6],["x"])
+var2 = file.def_var_with_dim("var2","sfloat",[6,3],["x","y"])
+var3 = file.def_var_with_dim("var3","sfloat",[3],["y"])
+var3 = file.def_var_with_dim("var4","sfloat",[0],["t"])
+att = var1.put_att("long_name","test")
+file.close
+
+p var1 == nil
+p file == nil
+p att == nil
+p att == att, var1 ==var1, file == file

data/test/factor_offset.rb

@@ -0,0 +1,53 @@
+require 'numru/netcdf'
+include NumRu
+
+s = 'tmp.nc'
+f = NetCDF.create(s)
+
+nx = 10
+d = f.def_dim('x',nx)
+v1 = f.def_var('v1','sint',[d])
+v2 = f.def_var('v2','sint',[d])
+v3 = f.def_var('v3','int',[d])
+v1.put_att('scale_factor',0.1,'sfloat')
+v1.put_att('add_offset',100.0,'sfloat')
+v2.put_att('scale_factor',0.1,'sfloat')
+v2.put_att('add_offset',100.0,'sfloat')
+v3.put_att('scale_factor',0.1,'sfloat')
+v3.put_att('add_offset',100.0,'sfloat')
+f.enddef
+v1.put( NArray.sint(nx).indgen!+100 )
+v2.scaled_put( NArray.float(nx).indgen!+100 )
+v3.scaled_put( NArray.float(nx).indgen!+100 )
+f.close
+
+
+print "** originally unscaled\n"
+f = NetCDF.open(s)
+v1 = f.var('v1')
+v11 = v1.get
+v12 = v1.scaled_get
+p v11
+p v12
+
+print "** originally scaled\n"
+v2 = f.var('v2')
+v21 = v2.get
+v22 = v2.scaled_get
+p v21
+p v22
+
+print "** originally sclaed (int --> double)\n"
+v3 = f.var('v3')
+v31 = v3.get
+v32 = v3.scaled_get
+p v31
+p v32
+
+print "** unpack type fixed to sfloat\n"
+NetCDFVar.unpack_type = NArray::SFLOAT
+v33 = v3.scaled_get
+p v33
+NetCDFVar.unpack_type = NArray::INT
+v33 = v3.scaled_get
+p v33

data/test/putatt.cdl

@@ -0,0 +1,23 @@
+netcdf tmp {
+dimensions:
+	x = 5 ;
+variables:
+	float x(x) ;
+		x:long_name = "test variable" ;
+		x:int_att = 123s ;
+		x:float_att = 0.333333333333333 ;
+		x:float_array = 0.1, 0.2, 30. ;
+		x:sfloat_narray = 0.f, 0.3333333f, 0.6666667f ;
+		x:float_narray = 0., 1., 2. ;
+		x:sint_narray = 0s, 1s, 2s ;
+		x:int2float = 10. ;
+		x:changed = "changed to text" ;
+
+// global attributes:
+		:history = "2001-12-23" ;
+		:int_att = 123s ;
+		:sfloat_att = 0.3333333f ;
+data:
+
+ x = _, _, _, _, _ ;
+}

data/test/putatt.rb

@@ -0,0 +1,56 @@
+require 'numru/netcdf'
+include NumRu
+s = 'tmp.nc'
+f = NetCDF.create(s)
+d = f.def_dim('x',5)
+v = f.def_var('x','sfloat',[d])
+
+require 'date'
+att = f.put_att("history", Date.today.to_s )
+p att.get, f.att("history").get
+att = f.put_att("int_att",123)
+att = f.put_att("sfloat_att",1.0/3.0,'sfloat')
+att = f.put_att("sfloat_att2",2.0/3.0,NArray::SFLOAT)
+att = v.put_att("long_name",'test variable')
+att = v.put_att("int_att",123)
+p att.get, v.att("int_att").get
+att = v.put_att("float_att",1.0/3.0)
+att = v.put_att("float_array",[0.1, 0.2, 30])
+att = v.put_att("sfloat_narray",NArray.sfloat(3).indgen!/3)
+att = v.put_att("float_narray",NArray.float(3).indgen!)
+att = v.put_att("sint_narray",NArray.sint(3).indgen!)
+att = v.put_att("int2float",10,'float')
+att = att = v.put_att("dummy",10,'float')
+att.put('changed to text')
+att.name = 'changed'
+begin
+   v.put_att("destined_to_fail",9.8,'complex')
+rescue
+   print "*1* exception raised as expected -- (",
+         __FILE__,":",__LINE__,") ", $!,"\n"
+end
+begin
+   v.put_att("destined_to_fail",9.8,'string')
+rescue
+   print "*2* exception raised as expected -- (",
+         __FILE__,":",__LINE__,") ", $!,"\n"
+end
+
+begin
+   v.put_att("destined_to_fail",'hello','int')
+rescue
+   print "*3* exception raised as expected -- (",
+         __FILE__,":",__LINE__,") ", $!,"\n"
+end
+
+begin
+   v.put_att("destined_to_fail",[10,30,'sss'])
+rescue
+   print "*4* exception raised as expected -- (",
+         __FILE__,":",__LINE__,") ", $!,"\n"
+end
+
+
+f.close
+
+print `ncdump tmp.nc`