gphys 1.2.2.1 → 1.4.3

data/lib/numru/gphys/grib_params.rb

@@ -262,7 +262,7 @@ PARAM_RDN_LWTOP = 114
 PARAM_RDN_LW = 115
 PARAM_RDN_SW = 116
 PARAM_RDN_GLBL = 117
-#PARAM_BRTMP = 118
+PARAM_BRTMP = 118
 #PARAM_LWRAD = 119
 #PARAM_SWRAD = 120
 PARAM_LAT_HT = 121
@@ -529,7 +529,7 @@ NAMES_UNITS = {
   PARAM_PTND => ["Pressure tendency", "PTEND", "Pa/s", "tendency_of_air_pressure"],
 #  PARAM_ICAHT => nil,
   PARAM_GPT => ["Geopotential", "GP", "m2/s2", "geopotential"],
-  PARAM_GPT_HGT => ["Geopotential height", "HGTZ", "Gpm", "geopotential_height"],
+  PARAM_GPT_HGT => ["Geopotential height", "HGT", "Gpm", "geopotential_height"],
   PARAM_GEOM_HGT => ["Geometric height", "DIST", "M", "altitude"],
   PARAM_HSTDV => ["Standard deviation of height", "HSTDV", "M", "equivalent_thickness_at_stp_of_atmosphere_o3_content"],
   PARAM_TOZNE => ["Total ozone", "TOZNE", "Dobson", "equivalent_thickness_at_stp_of_atmosphere_o3_content"],
@@ -640,7 +640,7 @@ NAMES_UNITS = {
   PARAM_RDN_LW => ["Long wave radiation", "LWAVR", "W/m2", "net_upward_longwave_flux_in_air"],
   PARAM_RDN_SW => ["Short wave radiation", "SWAVR", "W/m2", "net_upward_shortwave_flux_in_air"],
   PARAM_RDN_GLBL => ["Global radiation", "GRAD", "W/m2", "surface_downwelling_shortwave_flux"],
-#  PARAM_BRTMP => nil,
+  PARAM_BRTMP => ["Brightness temperature", "BRTMP", "K", "brightness_temperature"],
 #  PARAM_LWRAD => nil,
 #  PARAM_SWRAD => nil,
   PARAM_LAT_HT => ["Latent heat net flux", "LHTFL", "W/m2", "surface_upward_latent_heat_flux"],
@@ -1463,3 +1463,26 @@ PARAMS_JMA = {
   251 => PARAM_LWHR,
   253 => PARAM_LRGMR,
 }
+
+## JRA parameter code table
+## JRA-55: Code Table 200: 
+## http://rda.ucar.edu/datasets/ds628.0/#metadata/grib.html?_do=y
+##   Ref JRA-25: 
+##   http://rda.ucar.edu/datasets/ds625.0/docs/jra-25_grib_table.html
+##   POT_VOR is also 4 in JRA-25. Otherwise, JRA-25 is supported by
+##   the PARAMS_JMA table (as of 2014-08)
+PARAMS_JRA55 = PARAMS_2.merge( PARAMS_JMA )
+PARAMS_JRA55[4]   = PARAM_POT_VOR
+PARAMS_JRA55[118] = PARAM_BRTMP  # 118 is mean surface pressure in JRA-25
+PARAMS_JRA55[221] = PARAM_CLWMR  
+PARAMS_JRA55[225] = PARAM_SOILW
+=begin
+Yet to be supported (JRA-55)
+190	UTHE	Zonal thermal energy flux	W m-1
+191	VTHE	Meridional thermal energy flux	W m-1
+226	SMC	Mass concentration of condensed water in soil	kg m-3
+227	CW	Cloud liquid water	kg m-2
+228	CLWC	Cloud liquid water	kg kg-1
+229	CIWC	Cloud ice	kg kg-1
+252	VTYPE	Type of vegetation	code
+=end

data/lib/numru/gphys/grid.rb

@@ -186,16 +186,16 @@ A class to handle discretized grids of physical quantities.
 #    RETURN VALUE
 #    * self
 #
-#---insert_axis(dim_or_dimname, axis)
-#    Inserts an axis. (Returns a new object)
-#
-#    ARGUMENTS
-#    * dim_or_dimname (String or Integer) to specify an axis.
-#    * axis (Axis)
-#
-#    RETURN VALUE
-#    * a Grid
-#
+---insert_axis(dim, axis)
+    Inserts an axis. (non destructive; returns a new object)
+
+    ARGUMENTS
+    * dim (Integer) to specify the position to insert
+    * axis (Axis)
+
+    RETURN VALUE
+    * a Grid
+
 #---insert_axis!(dim_or_dimname, axis)
 #    Inserts an axis. (overwrites self)
 #
@@ -225,11 +225,12 @@ module NumRu
       def initialize( *axes )
 	 @axes = Array.new
 	 axes.each{|ag|
-	    if ag.is_a?(Axis)
-	       @axes.push(ag)
-	    else
-	       raise ArgumentError, "each argument must be an Axis"
-	    end
+            ### commented out for the duck typing:
+            #if ag.is_a?(Axis)
+            @axes.push(ag)
+            #else
+            #   raise ArgumentError, "each argument must be an Axis"
+	    #end
 	 }
 	 @lost_axes = Array.new   # Array of String
 	 @rank = @axes.length
@@ -409,7 +410,18 @@ module NumRu
 	newgrid = self.class.new( *newaxes )
 	newgrid.set_lost_axes( @lost_axes.dup )
         if @assoc_coords
-          newgrid.assoc_coords=@assoc_coords.subset_having_axnames(newgrid.axnames)
+          if deleted_by && VArray::NArray_type3_methods.include?(deleted_by)
+            assoc_coords = Array.new
+            assoccoordnames.each do |aname|
+              g = assoc_coord_gphys(aname)
+              args = g.axnames & at.collect{|i| @axnames[i]}
+              g = g.mean(*args) unless args.empty?
+              assoc_coords.push g if GPhys === g
+            end
+            newgrid.set_assoc_coords assoc_coords
+          else
+            newgrid.assoc_coords = @assoc_coords.subset_having_axnames(newgrid.axnames)
+          end
         end
 
 	if !deleted_by 
@@ -466,6 +478,26 @@ module NumRu
       end
       alias shape_current shape
 
+      # similar to [] but only for cut
+      def _new_grid_for_cut(slicer, axes)
+        axs = Array.new
+        lost = self.lost_axes  #Array.new
+        for i in 0...rank
+          if axes[i].is_a?(String)
+            lost.push( axes[i] )
+          else
+            axs.push( axes[i] )
+          end
+        end
+        grid = self.class.new( *axs )
+        grid.set_lost_axes( lost ) if lost.length != 0
+        if @assoc_coords
+          grid.assoc_coords = @assoc_coords[*slicer]
+        end
+        grid
+      end
+      private :_new_grid_for_cut
+
       def [] (*slicer)
 	 if slicer.length == 0
 	    # make a clone
@@ -481,15 +513,14 @@ module NumRu
 	    lost = self.lost_axes  #Array.new
 	    for i in 0...rank
 	       ax = @axes[i][slicer[i]]
-	       if ax.is_a?(Axis)      # else its rank became zero (lost)
-		  axes.push( ax )
+	       if ax.is_a?(String)
+                 lost.push( ax )
                else
-		  lost.push( ax )
+                 axes.push( ax )
 	       end
 	    end
 	    grid = self.class.new( *axes )
 	    grid.set_lost_axes( lost ) if lost.length != 0
-	    grid
 	 end
          if @assoc_coords
            grid.assoc_coords = @assoc_coords[*slicer]
@@ -550,17 +581,18 @@ module NumRu
 	end
 
 	slicer = Array.new
+	axes = Array.new
 
 	for dim in 0...rank
 	  ax = @axes[dim]
 	  if conserve_rank
-	    dummy, slicer[dim] = ax.cut_rank_conserving(args[dim])
+	    axes[dim], slicer[dim] = ax.cut_rank_conserving(args[dim])
 	  else
-	    dummy, slicer[dim] = ax.cut(args[dim])
+	    axes[dim], slicer[dim] = ax.cut(args[dim])
 	  end
 	end
 
-	[ self[*slicer], slicer ]
+	[ _new_grid_for_cut(slicer,axes), slicer ]
       end
       private :_cut_
 
@@ -599,17 +631,6 @@ module NumRu
 #	 self
 #      end
 
-#      def insert_axis(dim_or_dimname, axis)
-#	 dim = dim_index(dim_or_dimname)
-#	 axes = @axes.dup
-#	 if axis.is_a?(Axis)
-#	    axes[dim+1,0] = axis    # axes.insert(dim, axis) if ruby 1.7
-#	 else
-#	    # do nothing
-#	 end
-#	 self.class.new( *axes )
-#      end
-
 #      def insert_axis!(dim_or_dimname, axis)
 #	 dim = dim_index(dim_or_dimname)
 #	 if axis == nil
@@ -622,6 +643,20 @@ module NumRu
 #	 self
 #      end
 
+      def insert_axis(dim, axis)
+        axes = @axes.dup
+        ### commented out for the duck typing:
+        #if axis.is_a?(Axis)
+          axes.insert(dim, axis)
+        #else
+        #  raise ArgumentError, "2nd arg must be an Axis"
+        #end
+        grid = self.class.new( *axes )
+	grid.set_lost_axes( lost_axes )
+        grid.assoc_coords = @assoc_coords.dup if @assoc_coords
+	grid
+      end
+
       def transpose( *dims )
 	if dims.sort != NArray.int(rank).indgen!.to_a
 	  raise ArgumentError, 
@@ -719,5 +754,11 @@ if $0 == __FILE__
    p grid.delete_axes([0,1], 'mean').lost_axes
 
    p grid, grid.transpose(1,0)
+
+   puts "Test insert_axis..."
+   vz = VArray.new( NArray.float(3).indgen! + 10 ).rename("z")
+   zax = Axis.new().set_pos(vz)
+   grid3 = grid.insert_axis(-1,zax)
+   p grid3
 end
 

data/lib/numru/gphys/interpolate.rb

@@ -477,11 +477,18 @@ module NumRu
             f2 = NArray.float(len)
             for j in 0...len  
               ## [�J������] (������) ���̃��[�v��C�ɂ����ق��������i1D�Ȃ̂ł܂��������ǁC����2D�̂�����Ȃ�ꏏ�Ɂj�D���̍ہCg2ictr �͒T�������������ĂȂ��̂ŁCinterpo_find_loc_1D ��2D�ł̒T����������� g2ibl2 �𒼐ڌĂԕ��������D
-              uxi, uyi = DCL.g2ictr(txi[j], tyi[j])
-              ids1[j] = [ [uxi.floor,0].max, uxg.length-2 ].min
-              ids2[j] = [ [uyi.floor,0].max, uyg.length-2 ].min
-              f1[j] = uxi - ids1[j]
-              f2[j] = uyi - ids2[j]
+              begin
+                uxi, uyi = DCL.g2ictr(txi[j], tyi[j])
+                ids1[j] = [ [uxi.floor,0].max, uxg.length-2 ].min
+                ids2[j] = [ [uyi.floor,0].max, uyg.length-2 ].min
+                f1[j] = uxi - ids1[j]
+                f2[j] = uyi - ids2[j]
+              rescue
+                ids1[j] = -999
+                ids2[j] = -999
+                f1[j] = 0.0
+                f2[j] = 0.0
+              end
             end
             idxmap.push( [ od[0], m[1][0][0], nil, ids1, f1] ) # mapping from 1D
             idxmap.push( [ od[1], m[1][0][0], nil, ids2, f2] ) # mapping from 1D
@@ -497,11 +504,18 @@ module NumRu
             for k in 0...leny  
               for j in 0...lenx  
                 ## [�J������] (������) ���̃��[�v��C�ɂ����ق�������(2D��������)�D���̍ہCg2ictr �͒T�������������ĂȂ��̂ŁCinterpo_find_loc_1D ��2D�ł̒T����������� g2ibl2 �𒼐ڌĂԕ��������D
-                uxi, uyi = DCL.g2ictr(txi[j], tyi[k])
-                ids1[j,k] = [ [uxi.floor,0].max, uxg.length-2 ].min
-                ids2[j,k] = [ [uyi.floor,0].max, uyg.length-2 ].min
-                f1[j,k] = uxi - ids1[j,k]
-                f2[j,k] = uyi - ids2[j,k]
+                begin
+                  uxi, uyi = DCL.g2ictr(txi[j], tyi[k])
+                  ids1[j,k] = [ [uxi.floor,0].max, uxg.length-2 ].min
+                  ids2[j,k] = [ [uyi.floor,0].max, uyg.length-2 ].min
+                  f1[j,k] = uxi - ids1[j,k]
+                  f2[j,k] = uyi - ids2[j,k]
+                rescue
+                  ids1[j,k] = -999
+                  ids2[j,k] = -999
+                  f1[j] = 0.0
+                  f2[j] = 0.0
+                end
               end
             end
             idxmap.push( [ od[0], m[1][0][0], [m[1][1][0]], ids1, f1] )  # mapping from 2D

data/lib/numru/gphys/mdstorage.rb

@@ -0,0 +1,160 @@
+require "narray"
+
+module NumRu
+  class MDStorage
+    def initialize(rank=1)
+      raise(ArgumentError,"rank must be a positive integer") if !(rank>0)
+      @rank = rank
+      @shape = []
+      rank.times{@shape.push(1)}
+      @data = [nil]
+      (rank-1).times{
+        @data = [@data]
+      }
+    end
+
+    attr_reader :rank
+
+    def shape
+      @shape.dup
+    end
+
+    # add a new dimension to the last
+    def add_dim
+      @rank += 1
+      @shape.push(1)
+      @data = [@data]
+    end
+
+    # increase the length of a dimension by one
+    def extend(dim)
+      if dim<0 or dim>=rank
+        raise(ArgumentError,"invalid dim (#{dim}): not in #{0..rank-1}")
+      end
+      yield_at_depth(@data,rank-1-dim){|a| 
+        a.push( dim==0 ? nil : make_nested_array(shape[0..dim-1]) )
+      }
+      @shape[dim] += 1
+      self
+    end
+
+    # substituion at a position specified with integers (only one element)
+    def []=(*args)
+      val = args.pop
+      raise(ArgumentError,"# of args != rank (#{rank})") if args.length != rank
+      x = @data
+      (rank-1).downto(1) do |d|
+        idx = args[d]
+        raise(ArgumentError,"all args must be integers") if !idx.is_a?(Integer)
+        len = shape[d]
+        idx += len if idx<0
+        raise("Too big negative index for dim #{d}: #{idx-len}") if idx<0
+        if 0<=idx and idx<len
+          x = x[idx]
+        elsif idx >= len
+          (idx-len+1).times{extend(d)}
+          x = x[idx]
+        else
+          raise(ArgumentError,"invalid specification")
+        end
+      end
+
+      idx = args[0]
+      len = shape[0]
+      idx += len if idx<0
+      raise("Too big negative index for dim #{0}: #{idx-len}") if idx<0
+      if idx >= len
+        (idx-len+1).times{extend(0)}
+      end
+      x[idx] = val
+    end
+
+    # read from a position specified with integers (only one element)
+    def [](*args)
+      raise(ArgumentError,"# of args != rank (#{rank})") if args.length != rank
+      x = @data
+      args.reverse_each do |idx|
+        raise(ArgumentError,"all args must be integers") if !idx.is_a?(Integer)
+        x = x[idx]
+        return(x) if x.nil?
+      end
+      x
+    end
+
+    def to_na
+      NArray.to_na(@data)
+    end
+
+    # count the total length (including nil)
+    def length
+      len = 1
+      @shape.each{|s| len *= s}
+      len
+    end
+
+    # count the number of non-nil objects
+    def count_non_nil
+      a = @data.flatten
+      a.delete(nil)
+      a.length
+    end
+
+    #############################################
+    ## < private methods >
+    private
+=begin
+    def __rubber_expansion( args )
+      if (id = args.index(false))  # substitution into id
+        # false is incuded
+        alen = args.length
+        if args.rindex(false) != id
+          raise ArguemntError,"only one rubber dimension is permitted"
+        elsif alen > rank+1
+          raise ArgumentError, "too many args"
+        end
+        ar = ( id!=0 ? args[0..id-1] : [] )
+        args = ar + [true]*(rank-alen+1) + args[id+1..-1]
+      end
+      args
+    end
+=end
+
+    # make a neste multi-D Array filled with nil
+    def make_nested_array(shape)
+      if shape.length == 1
+        Array.new(shape[0])      # => [nil,nil,...,nil]
+      elsif shape.length > 1   # recursive construction
+        (0...shape[-1]).collect{make_nested_array(shape[0..-2])}
+      else
+        raise ArgumentError, "shape must have 1 or more elements"
+      end
+    end
+
+    # call the block at the depth in the nested array
+    def yield_at_depth(ary,depth, &blk)
+      if depth==0
+        blk.call(ary)    # call the block
+      elsif depth>0
+        ary.each{|sub| yield_at_depth(sub,depth-1,&blk)}
+      else
+        raise ArgumentError, "depth must be >= 0"
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  include NumRu
+  a = MDStorage.new(3)
+  p a
+  p a.extend(2)
+  p a.extend(2)
+  p a.extend(0)
+  a[0,0,0] = 10.9
+  a[1,0,-1] = "XX"
+  p a, a[0,0,0], a[1,0,-1]
+  a[2,0,2] = '###'
+  p a
+  p a.to_na
+  p a.length, a.count_non_nil
+end

data/lib/numru/gphys/netcdf_convention.rb

@@ -328,10 +328,12 @@ module NumRu
         nms = s.split(/ +/)
         case data.file
         when NArray
-          nms.delete_if{|nm| !data.file[0].var(nm)}
+          fl = data.file[0]
         else
-          nms.delete_if{|nm| !data.file.var(nm)}
+          fl = data.file
         end
+        nms.delete_if{|nm| !fl.var(nm)}
+        nms.delete_if{|nm| fl.dim_names.include?(nm)}
         nms
       else
         nil