gphys 1.2.2.1 → 1.4.3

data/lib/numru/gphys/gphys_dim_op.rb

@@ -0,0 +1,331 @@
+# = Operations along a dimension such as running mean
+#
+# (Plan: binning will be supported too)
+
+require "numru/gphys/gphys"
+require 'numru/gphys_ext'  # extension library
+
+module NumRu
+  class GPhys
+    BC_SIMPLE = 10   # enum in convol_filter.c
+    BC_CYCLIC = 11   # enum in convol_filter.c
+    BC_TRIM   = 12   # enum in convol_filter.c
+
+    @@default_missval = 9.9692099683868690e+36 # NC_FILL_DOUBLE/FLOAT ~15*2^119
+
+    # Running mean along a dimension (with optional weight specification).
+    # 
+    # ARGUMENTS
+    # * dim (Integer or String) : the dimension
+    # * len_or_wgt : If Integer, specifies the length; if 1D NArray,
+    #   specifies the weight (e.g., NArray[1.0, 2.0, 1.0] for
+    #   the 1-2-1 smooting)
+    # * bc (Integer; optional) : Speficy one of the folloing:
+    #   * GPhys::BC_SIMPLE (default) : Averaging is trucated at the boundaries
+    #     (the number of grid points used is reduced near the boundaries).
+    #     The shape of the object is conserved.
+    #   * GPhys::BC_CYCLIC : Cyclic boundary condition. Shape conserved.
+    #   * GPhys::BC_TRIM : Grids near the boundaries are trimmed to
+    #     secure the number of grid points to average.
+    #     Shape not conserved; length along the dim is reduced by (len-1).
+    # * nminvalid (Integer; optional; defualt=1): 
+    #   This parameter is used only when the data have missing.
+    #   Minimum number of grid points needed for averaging.
+    #   Must be from 1 to len.
+    # 
+    # RETURN VALUE
+    # * a GPhys
+    # 
+    # REMARK AND LIMITATION
+    # * If the length of the running mean is even number, fewer
+    #   grid points are used from the "left" side; e.g.,
+    #   If len is 6, result[2] is a mean over self[0]..self[5].
+    # * Regardless the na_type of self, double is used for avaraging, so:
+    # * This method does not support complex numbers.
+    # 
+    def running_mean(dim, len_or_wgt=nil, bc=BC_SIMPLE, nminvalid=1)
+
+      #< process arguments >
+
+      dim = dim_index(dim)  # to handle String or negative specification
+
+      case len_or_wgt
+      when nil
+        raise ArgumentError, "You need to specify the length (Integer) or the weight (1D NArray) as the 2nd argument"
+      when Integer
+        # len_or_wgt is a length
+        len = len_or_wgt  
+        wgt = NArray.float(len).fill!(1.0)
+      else
+        # len_or_wgt is a weight
+        wgt = len_or_wgt
+        if (!wgt.respond_to?(:rank) || wgt.rank != 1)
+          raise ArgumentError, "wgt: expect a 1D NArray(-like obj)"
+        end
+        len = wgt.length
+      end
+
+      #< calc running mean >
+
+      vi = self.val
+      if (vi.typecode > NArray::DFLOAT)
+        raise("This method supports only real or integer data")
+      end 
+      if vi.is_a?(NArrayMiss)
+        vi, missval = nam2na_missval(vi)
+        vo = c_running_mean(vi,dim,wgt,bc,missval,nminvalid)
+        vo = NArrayMiss.to_nam(vo, vo.ne(missval) )
+      else
+        vo = c_running_mean(vi,dim,wgt,bc)
+      end
+
+      #< grid >
+
+      if (bc ==  BC_TRIM)
+        fst = (len-1)/2    # if odd len/2, if even len/2-1
+        lst = -(len/2) - 1 
+        grid = self.grid[ *([true]*dim + [fst..lst, false]) ]
+      else
+        grid = self.grid
+      end
+
+      #< result >
+      vvo = VArray.new( vo, self.data, self.name )  # Inherit name & attrs
+      GPhys.new( grid, vvo )
+
+    end
+
+    # Binning along a dimension (mean)
+    # 
+    # The values are averaged every "len" grids; unlike running_mean
+    # the number of grids is reduced to 1/len. 
+    # Currently, the only available boundary condition is BC_TRIM.
+    # 
+    # ARGUMENTS
+    # * dim (Integer or String) : the dimension
+    # * len (Integer): length of the bin
+    # * nminvalid (Integer; optional; defualt=1): Effective only for data with
+    #   missing. Minimum number of grid points needed for averaging (1 to len).
+    # 
+    # RETURN VALUE
+    # * a GPhys
+    # 
+    def bin_mean(dim, len, nminvalid=1)
+      dim = dim_index(dim)  # to handle String or negative specification
+      GPhys.new( grid.binning(dim, len), data.bin_mean(dim, len, nminvalid) )
+    end
+
+    # Binning along a dimension (summation)
+    # 
+    # Similar to bin_mean, but the values are simply summed without averaging
+    # 
+    # ARGUMENTS
+    # * dim (Integer or String) : the dimension
+    # * len (Integer): length of the bin
+    # * nminvalid (Integer; optional; defualt=1): Effective only for data with
+    #   missing. Minimum number of grid points needed for averaging (1 to len).
+    # 
+    # RETURN VALUE
+    # * a GPhys
+    # 
+    def bin_sum(dim, len, nminvalid=1)
+      dim = dim_index(dim)  # to handle String or negative specification
+      GPhys.new( grid.binning(dim, len), data.bin_sum(dim, len, nminvalid) ) 
+    end
+
+    ##### private #########
+    def nam2na_missval(nam)
+      missval = ( (a=get_att('_FillValue')) ? a[0] : nil ) || 
+                ( (a=get_att('missing_value')) ? a[0] : nil ) || 
+                @@default_missval
+      [ nam.to_na(missval), missval ]
+    end
+    private :nam2na_missval
+
+    #def convolution(dim, g=nil, bc=BC_SIMPLE)
+    #end
+  end
+
+  class VArray
+    @@default_missval = 9.9692099683868690e+36 # NC_FILL_DOUBLE/FLOAT ~15*2^119
+
+    def bin_mean(dim, len, nminvalid=1)
+      vi = self.val
+      if vi.is_a?(NArrayMiss)
+        vi, missval = nam2na_missval(vi)
+        vo = c_bin_mean(vi,dim,len,missval,nminvalid)  # defined in dim_op.c
+        vo = NArrayMiss.to_nam(vo, vo.ne(missval) )
+      else
+        vo = c_bin_mean(vi,dim,len)  # defined in dim_op.c
+      end
+      VArray.new( vo, self, self.name )  # Inherit name & attrs 
+    end
+
+    def bin_sum(dim, len, nminvalid=1)
+      vi = self.val
+      if vi.is_a?(NArrayMiss)
+        vi, missval = nam2na_missval(vi)
+        vo = c_bin_sum(vi,dim,len,missval,nminvalid)  # defined in dim_op.c
+        vo = NArrayMiss.to_nam(vo, vo.ne(missval) )
+      else
+        vo = c_bin_sum(vi,dim,len)  # defined in dim_op.c
+      end
+      VArray.new( vo, self, self.name )  # Inherit name & attrs 
+    end
+
+    ##### private #########
+    def nam2na_missval(nam)
+      missval = ( (a=get_att('_FillValue')) ? a[0] : nil ) || 
+                ( (a=get_att('missing_value')) ? a[0] : nil ) || 
+                @@default_missval
+      [ nam.to_na(missval), missval ]
+    end
+    private :nam2na_missval
+
+  end
+
+  class Grid
+    def binning(dim, len)
+      dim = dim_index(dim)  # to handle String or negative specification
+
+      #< axes >
+      axes = (0...rank).collect{|d| axis(d)}
+      axes[dim] = axes[dim].binning(len)  # bin the dim-th axis
+      newgrid = Grid.new(*axes)
+
+      #< assoc coords are retained if it does not have the dim >
+      if assoc_coords
+        dimname = self.axis(dim).name
+        acs = Array.new
+        assoccoordnames.each do |nm|
+          ac = assoc_coord_gphys(nm)
+          acs.push(ac) if !ac.dimnames.include?(dimname)
+        end
+        newgrid.set_assoc_coords(acs) if acs.length > 0
+      end
+
+      #< return >
+      newgrid
+    end
+  end
+
+  class Axis
+    def binning(len)
+      if cell? && cell_center?
+        c = cell_center.bin_mean(0,len)
+        b = cell_bounds[ {0..-1=>len} ]
+        newax = Axis.new(true).set_cell(c,b)
+        newax = axcel.dup.set_pos_to_center
+      else
+        newax = Axis.new().set_pos( pos.bin_mean(0,len) )
+      end
+      newax  
+    end
+  end
+end
+
+######################################################
+## < test >
+if $0 == __FILE__
+  require 'test/unit'
+
+  class TC_GPhys_grid_op < Test::Unit::TestCase
+    include NumRu
+    def setup
+      nx = 11
+      ny = 5
+      vx = VArray.new( NArray.float(nx).indgen! ).rename("x")
+      vy = VArray.new( NArray.float(ny).indgen! ).rename("y")
+      xax = Axis.new().set_pos(vx)
+      yax = Axis.new().set_pos(vy)
+      grid = Grid.new(xax, yax)
+      z = VArray.new( na = NArray.float(nx, ny).indgen! % 5, nil, "z" )
+      zu = VArray.new( NArray.float(nx, ny).fill(3.0), nil, "z" )
+
+      @gp = GPhys.new(grid,z)
+      @gpu = GPhys.new(grid,zu)
+
+      nam = NArrayMiss.to_nam(na)
+      nam.invalidation(1,1)
+      nam.invalidation(2,2)
+      (1..4).each{|i| nam.invalidation(i,3)}
+      zm = VArray.new( nam, nil, "zm" )
+      @gpm = GPhys.new(grid,zm)
+
+    end
+
+    def test_0_0_running_mean
+      puts "*** running_mean: basic ***"
+      p(v0 = @gp.val)
+
+      p(v = @gp.running_mean(0,3).val)
+      assert_in_delta(v[4,0], 2.33333, 1e-4)
+
+      p(v = @gp.running_mean(1,3,GPhys::BC_TRIM).val)
+      assert_in_delta(v[2,1], 2.33333, 1e-4)
+
+      p(v = @gpu.running_mean(0,3,GPhys::BC_TRIM).val)
+      assert_in_delta(v[0,0], 3.0, 1e-4)
+      assert_equal(v.shape[0], v0.shape[0]-2)
+
+      p(v = @gp[0..9,true].running_mean(0,5,GPhys::BC_CYCLIC).val)
+      assert_in_delta(v[0,0], 2.0, 1e-4)
+    end
+
+    def test_0_1_running_mean
+      puts "*** running_mean: weight ***"
+      wgt = NArray[1.0, 2.0, 1.0]
+      p @gp.val
+      p(v = @gp.running_mean(0,wgt).val)
+      assert_in_delta(v[4,0], (3.0+4.0*2)/4, 1e-4)
+    end
+
+    def test_0_2_running_mean
+      puts "*** running_mean: with data missing ***"
+      p @gpm.val
+      p(v = @gpm.running_mean(0,3).val)
+      assert_in_delta(v[2,2], 1.5, 1e-4)
+      assert(v[2,3] > 1e30)  # missing value
+    end
+
+    def test_1_0_bin_mean
+      puts "*** bin_mean ***"
+      p @gp.val
+      b = @gp.bin_mean(0,3)
+      v = b.val
+      p v, b.coord(0).val, b.coord(1).val
+      assert_in_delta(b.val[1,1], 5.0/3.0, 1e-4)
+      assert_in_delta(b.coord(0).val[1], 4.0, 1e-4)
+    end
+
+    def test_1_1_bin_mean
+      puts "*** bin_mean: with data missing ***"
+      p @gpm.val
+      b = @gpm.bin_mean(0,3,2)
+      v = b.val
+      p v, b.coord(0).val, b.coord(1).val
+      assert_in_delta(v[0,2], 2.5, 1e-4)
+      assert(v[0,3] > 1e30)  # missing value
+    end
+
+    def test_2_0_bin_sum
+      puts "*** bin_sum ***"
+      p @gp.val
+      b = @gp.bin_sum(0,3)
+      v = b.val
+      p v, b.coord(0).val, b.coord(1).val
+      assert_in_delta(b.val[1,1], 5.0, 1e-4)
+    end
+
+    def test_2_1_bin_sum
+      puts "*** bin_sum: with data missing ***"
+      p @gpm.val
+      b = @gpm.bin_sum(0,3,2)
+      v = b.val
+      p v, b.coord(0).val, b.coord(1).val
+      assert_in_delta(v[0,2], 5.0, 1e-4)
+      assert(v[0,3] > 1e30)  # missing value
+    end
+
+  end
+end

data/lib/numru/gphys/gphys_fft.rb

@@ -439,6 +439,8 @@ module NumRu
 	  else
 	    val = val.to_na 
 	  end
+        elsif val.is_a?(NArrayMiss) && val.count_invalid == 0
+          val = val.to_na 
 	end
 	fcoef = FFTW3.fft( val, dir, *dims )
       else
@@ -454,6 +456,8 @@ module NumRu
 	  else
 	    val = val.to_na 
 	  end
+        elsif val.is_a?(NArrayMiss) && val.count_invalid == 0
+          val = val.to_na 
 	end
 	fcoef = FFTW.fftw( val, dir )
       end
@@ -498,6 +502,30 @@ module NumRu
       gfc
     end
 
+    def fft_deriv(dim)
+      tp = self.data.typecode
+      fc = self.fft(false,dim)
+      wn = fc.coord(dim)
+      k = wn.val.to_type(NArray::Complex)
+      n = k.length
+      n2a = (n-1)/2
+      n2b = [n/2 + 1, n-1].min  # min to avoid error if n=2 (though meaningless)
+      kmx = k[-1]+k[1]
+      ik = NArray.complex(n)
+      ik[0..n2a] = k[0..n2a]*Complex::I
+      ik[n2b..-1] = (k[n2b..-1]-kmx) * Complex::I
+      dim.times{ik.newdim!(0)}
+      (self.rank-dim-1).times{ik.newdim!(-1)}
+      fc.replace_val(fc.val*ik)
+      deriv = fc.fft(true,dim)
+      deriv.units = deriv.units * wn.units
+      if tp >= NArray::SCOMPLEX
+        deriv
+      else
+        deriv.real
+      end
+    end
+
     def __predefined_coord_units_conversion(coord)
       case coord.units
       when Units["degree"]
@@ -766,9 +794,9 @@ if $0 == __FILE__
   include NMath
 
   # < make a GPhys from scratch >
-  vx = VArray.new( NArray.float(11).indgen! * (3*Math::PI/11) ).rename("x")
+  vx = VArray.new( NArray.float(11).indgen! * (2*Math::PI/11) ).rename("x")
   vx.units = 'km'
-  vy = VArray.new( NArray.float(8).indgen! * (3*Math::PI/8) ).rename("y")
+  vy = VArray.new( NArray.float(8).indgen! * (2*Math::PI/8) ).rename("y")
   vy.units = 'km'
   xax = Axis.new().set_pos(vx)
   #yax = Axis.new(true).set_cell_guess_bounds(vy).set_pos_to_center
@@ -880,6 +908,24 @@ if $0 == __FILE__
   gpf = gp.phase_velocity_filter(0, 2, -0.3, -0.01, 1/kconv, 1/fconv)
   GGraph::tone gpf[true,0,true],true,"color_bar"=>true
 
+  ###
+  grid = Grid.new(xax, yax)
+  a = NArray.float(vx.length, vy.length)
+  a[] = sin(2*vx.val.newdim(1)) * cos(vy.val.newdim(0))
+  v = VArray.new( a )
+  v.units = 'm/s'
+  gpz = GPhys.new(grid,v)
+
+  dim = 0
+  x = gpz.coord(dim)
+  gp_x = gpz.fft_deriv(dim)
+  p gp_x
+  dim = 1
+  gp_y = gpz.fft_deriv(dim)
+  p gp_y
+  GGraph::tone gpz,true,"color_bar"=>true
+  GGraph::tone gp_x,true,"color_bar"=>true
+  GGraph::tone gp_y,true,"color_bar"=>true
 
   DCL.grcls
 end

data/lib/numru/gphys/gphys_io.rb

@@ -7,6 +7,7 @@ begin
   require "numru/gphys/gphys_hdfeos5_io"
 rescue LoadError
 end
+require "numru/gphys/mdstorage"   # for regexp2files
   
 
 =begin
@@ -24,8 +25,66 @@ For example, (('GPhys::IO.open(file, name)')) simply calls
 
 ==Module functions
 
----open(files, varname)
+---open(file, varname)
+    Opens a GPhys in (({file})) having the name (({varname})).
+
+    ARGUMENTS
+    * file (String, NetCDF, GRIB,.. etc, or Array, NArray, Regexp) :
+      Specifies the file. Path if String; a File pointer if NetCDF etc..
+      The processing is forwarded to (('open_multi')), if this argument is
+      an Array, NArray, or Regexp. 
+    * varname (String) : name of the variable
+
+    RETURN VALUE
+    * a GPhys
+
+---open_multi(files, varname)
+    Opens a GPhys by combining a variable across multiple files.
+    It initializes GPhys objects over the files by calling (('open')) and
+    unites them into a single GPhys object by using (({GPhys.join})) or
+    (({GPhys.join_md})).
+
+    ARGUMENTS
+    * files (Array, NArray (NArray.object), or Regexp) : Specifies the files.
+      * when Array, it must consist of paths or file pointers 
+        (that are accepted by (('open'))).
+        All coordinates of the variable in the files are scanned, 
+        and a joined object is constructed properly.
+        Thus, you can simply put subsets of a 2D tiling in a simple
+        non-nested 1D Array. (({GPhys.join})) is used in this case.
+      * when NArray, it must consist of paths or file pointers 
+        (that are accepted by (('open'))).
+        Each dimension with multiple elements must correspond
+        to a dimension along which joining is made. 
+        For example, a 2D tiling can be specified as
+           files = NArray.to_na([['f00.nc','f10.nc'],['f01.nc','f11.nc']])
+           gp = GPhys::IO.open_multi( files, "f" )
+        (({GPhys.join_md})) is used in this case.
+      * When Regexp, similar to when NArray, but expresses the paths.
+        The dimensions to join is specified by "captures"
+        (parentheses). For example, the above 2D tiling can be specified as
+           files = /f(\d)(\d).nc/
+           gp = GPhys::IO.open_multi( files, "f" )
+        The regexp can contain a directory path (e.g., /dir\/sub\/f(\d)(d).nc/),
+        but the directory part must be unique (i.e., a simple string),
+        so only a single directly can be specified. All captures must
+        be in the part representing the file names (in the directory).
+        (({GPhys.join_md})) is used in this case.
+    * varname (String) : name of the variable
+
+    RETURN VALUE
+    * a GPhys
+
 ---write(file, gphys, name=nil)
+    Writes a GPhys object in a file
+
+    ARGUMENTS
+    * file (NetCDF, GRIB,.. etc) : the file. Writing must be permitted.
+      To close (finalize) it after writing is left to the user.
+    * gphys (GPhys) : the GPhys object to write
+    * name (String; optional) : if specified, this name is used in the file
+      rather than the name of gphys
+
 ---write_grid(file, grid_or_gphys)
 ---each_along_dims_write(gphyses, files, *loopdims){...}  # a block is expected
 ---var_names(file)
@@ -36,15 +95,13 @@ For example, (('GPhys::IO.open(file, name)')) simply calls
     Figures out the file type supported in this module.
 
     ARGUMENTS
-    * file (String, Regexp, NetCDF, Grib, or GrADS_Gridded) :
+    * file (String, NetCDF, Grib, or GrADS_Gridded) :
       What to return is of course obvious if it is 
       NetCDF, Grib, or GrADS_Gridded. If it is a String,
       it is assumed to be a path of a file, and the file type      
       is determined by its suffix when 'nc', 'ctl', or 'grib';
       In other cases, the type is figured out by reading in 
-      a few bytes from the beginning. If Regexp, currently,
-      a NetCDF is assumed, since only NetCDF_IO.open supports
-      Regexp.
+      a few bytes from the beginning.
 
     RETURN VALUE
     * GPhys::IO::NETCDF, GPhys::IO::GRIB, or GPhys::IO::GRADS, 
@@ -127,7 +184,49 @@ module NumRu
 
       ## // module functions to be defined in specific IO modules -->
       def open(file, varname)
-	file2specific_module(file)::open(file, varname)
+        case file
+        when Array, NArray, Regexp
+          open_multi(file, varname)
+        else
+          file2specific_module(file)::open(file, varname)
+        end
+      end
+
+      def open_multi(files, varname)
+        case files
+        when Array
+          GPhys.join( files.collect{|f| open(f,varname)} )
+        when NArray
+          GPhys.join_md( files.collect{|f| open(f,varname)} )
+        when Regexp
+          GPhys.join_md( regexp2files(files).collect{|f| open(f,varname)} )
+        end
+      end
+
+      def regexp2files( pat )
+        if  /^(.*)\\?\/(.*)$/ =~ (pat.source)
+          d=$1
+          f=$2
+          dir = d.gsub(/\\/,'') + '/'
+          pat = Regexp.new(f)
+        else
+          dir = './'
+        end
+        flstore = MDStorage.new(1)
+        lbs = Array.new
+        Dir.open(dir).each do |fn| 
+          if pat =~ fn
+            raise(ArgumentError,"has no capture; need one or more") if $1.nil?
+            idx = Array.new
+            Regexp.last_match.captures.each_with_index{|lb,i|
+              flstore.add_dim if flstore.rank == i   # rank smaller by 1 -> add
+              lbs[i] = Array.new if lbs[i].nil?
+              idx.push( lbs[i].index(lb) || lbs[i].push(lb) && lbs[i].length-1 )
+            }
+            flstore[*idx] = NetCDF.open(dir+fn)
+          end
+        end
+        flstore.to_na
       end
 
       def write(file, gphys, name=nil)
@@ -203,8 +302,6 @@ module NumRu
           return NUSDAS
         when Gtool3
           return GTOOL3
-	when Regexp
-	  return NETCDF     # So far, only NetCDF_IO supports Regexp. 
 	when *@@nc_pattern
 	  return NETCDF
 	when *@@grad_pattern
@@ -215,7 +312,7 @@ module NumRu
           return NUSDAS
 	when String
 	  return NETCDF if /^http:\/\// =~ file   # assume a DODS URL
-          return nil unless File.exist?(file)
+          raise ArgumentError, "File not found: #{file}" unless File.exist?(file)
           return NETCDF if NetCDF_IO.is_a_NetCDF?(file)
           return GRADS if GrADS_IO.is_a_GrADS?(file)
           return GRIB if Grib_IO.is_a_Grib?(file)
@@ -232,6 +329,8 @@ module NumRu
             return He5   if HE5_IO.is_a_HE5?(file)
           end
         end
+        raise "cannot specify the file type of \""+ file + \
+              "\"; maybe unsupported format."
         return nil
       end
 
@@ -289,6 +388,13 @@ module NumRu
 	  raise "invalid URL: '[@|/]' between path & variable is not found\n\n" + 
 	         "URL format: " + GTURLfmt
 	end
+        if /[\*\?]/ =~ file ## match file names if wildcard expression included.
+          raise "\n Any files did not match the given expression: \""+file+\
+                "\" \n" if Dir[file].empty?
+          file = Dir[file].sort
+        elsif (!File.exist?(file))
+          raise "File specified by gturl \"#{gturl}\" was not found"
+        end
 	if /,/ =~ var
 	  slice = Hash.new
 	  cut_slice = Hash.new
@@ -328,18 +434,66 @@ module NumRu
 	  cut_slice = nil
 	  thinning = nil
 	end
+        if /[\*\?]/ =~ var ## match var names if wildcard expression included.
+          var_reg = var.gsub("*",".*").gsub("?",".") # convert to regular exp.
+          case file
+          when String
+            vars = GPhys::IO.var_names_except_coordinates(file)
+          when Array
+            vars_t = file.collect{|f| GPhys::IO.var_names_except_coordinates(f)}
+            vars = vars_t.flatten.uniq
+          end
+          vars_matched = vars.select{|v| v.match(/#{var_reg}/)}
+          if (vars_matched.empty?) 
+            raise "\n Any variables in \"#{file}\" did not match the given 
+            expression: \"#{var}\".\n Included variable(s): #{vars.join(", ")}."
+          end
+          # put the variable name by String if the number of matched variable is
+          # one, otherwise by Array of Strings.
+          var = vars_matched.length == 1 ? vars_matched[0] : vars_matched 
+        end
 	[file, var, slice, cut_slice, thinning]
       end   # def parse_gturl
 
       def open_gturl(gturl)
 	file, var, slice, cut_slice, thinning = GPhys::IO.parse_gturl(gturl)
-	gp = GPhys::IO.open(file,var)
+        if var.is_a?(Array)
+          raise "This method treats a gturl of a single GPhys object. " +
+             "Use open_multi_gturl to treat a gturl of multiple objects."
+        end
+        gp = GPhys::IO.open(file,var)
 	gp = gp[slice] if slice
 	gp = gp.cut(cut_slice) if cut_slice
 	gp = gp[thinning] if thinning
 	gp
       end   # def open_gturl
 
+      def open_multi_gturl(gturl)
+	files, vars, slice, cut_slice, thinning = GPhys::IO.parse_gturl(gturl)
+        vars = [vars] unless vars.is_a?(Array)
+        gp_array = Array.new
+        vars.each do |v|
+          begin 
+            gps = [ GPhys::IO.open(files,v) ]   # opened as a single GPhys
+          rescue ArgumentError 
+            if files.is_a?(Array)
+              # gturl may designate multiple GPhys objects
+              gps = files.collect{|f| gp = GPhys::IO.open(f,v) }
+            else
+              raise $!    # it must have been a real error
+            end
+          end
+          gp_array += gps
+        end
+        gp_array.map!{|gp|
+          gp = gp[slice] if slice
+          gp = gp.cut(cut_slice) if cut_slice
+          gp = gp[thinning] if thinning
+          gp
+        }
+        gp_array
+      end   # def open_multi_gturl
+
       def str2gphys(str)
 
         case str
@@ -387,7 +541,6 @@ if $0 == __FILE__
   puts "\n** test str2gphys **\n"
   p GPhys::IO.str2gphys("../../../testdata/T.jan.nc/T")
   p GPhys::IO.str2gphys("../../../testdata/T.jan.nc")
-  exit
 
   puts "\n** test NETCDF **\n"
 
@@ -417,7 +570,7 @@ if $0 == __FILE__
   GPhys::IO.write(file2,temp_edy)
   file2.close
   file3 = NetCDF.create('tmp2.nc')
-  GPhys::IO.write(file2,temp_xmean)
+  GPhys::IO.write(file3,temp_xmean)
   file3.close
 
   p '** test each_along_dims* **'
@@ -465,7 +618,82 @@ if $0 == __FILE__
   GPhys::IO.write(file2,temp_edy)
   file2.close
   file3 = NetCDF.create('tmp2.nc')
-  GPhys::IO.write(file2,temp_xmean)
+  GPhys::IO.write(file3,temp_xmean)
   file3.close
 
+  puts "\n** test open_multi (1) **"
+  # preparation...
+  gp = GPhys::IO.open("../../../testdata/T.jan.nc","T")
+  GPhys::IO.write(f=NetCDF.create('tmp_z0.nc'),gp[false,0..4]);   f.close
+  GPhys::IO.write(f=NetCDF.create('tmp_z1.nc'),gp[false,5..-1]);  f.close
+
+  # test...
+  gpm = GPhys::IO.open(['tmp_z1.nc','tmp_z0.nc'],"T")
+  gp.val == gpm.val ? puts("Test OK") : raise("Test failed")
+
+  gpm = GPhys::IO.open(/tmp_z(\d).nc/,"T")
+  gp.val == gpm.val ? puts("Test OK") : raise("Test failed")
+
+  puts "\n** test open_multi (2) **"
+  # preparation...
+  gp = GPhys::IO.open("../../../testdata/T.jan.nc","T")
+  GPhys::IO.write(f=NetCDF.create('tmp00.nc'), gp[0..20, 0..8, true]); f.close
+  GPhys::IO.write(f=NetCDF.create('tmp10.nc'), gp[21..-1,0..8, true]); f.close
+  GPhys::IO.write(f=NetCDF.create('tmp01.nc'), gp[0..20, 9..-1,true]); f.close
+  GPhys::IO.write(f=NetCDF.create('tmp11.nc'), gp[21..-1,9..-1,true]); f.close
+
+  # test...
+  files = NArray.to_na([['tmp00.nc','tmp10.nc'],['tmp01.nc','tmp11.nc']])
+  gpm = GPhys::IO.open(files,"T")
+  gp.val == gpm.val ? puts("Test OK") : raise("Test failed")
+
+  gpm = GPhys::IO.open(files.transpose(1,0),"T")  # fine even if tranposed
+  gp.val == gpm.val ? puts("Test OK") : raise("Test failed")
+
+  files = /tmp(\d)(\d).nc/
+  gpm = GPhys::IO.open(files,"T")
+  gp.val == gpm.val ? puts("Test OK") : raise("Test failed")
+
+  # test open_gturl
+
+  puts "** test open_gturl **"
+  sh = GPhys::IO.open_gturl('tmp[01]?.nc@T,lon=20:40,level=1000,lat=0').shape
+  sh == [3] ? puts("Test OK") : raise("Test failed")
+
+  # test open_multi_gturl
+
+  puts "** test open_multi_gturl **"
+
+  f=NetCDF.open('tmp11.nc','a')
+  f.redef
+  GPhys::IO.write(f, gp[21..-1,9..-1,true].copy.rename("R") )
+  f.close
+
+  str =  GPhys::IO.open_multi_gturl('tmp[01]?.nc@T').inspect + "\n"
+  str += GPhys::IO.open_multi_gturl('tmpE*.nc@T').inspect + "\n"
+  str += GPhys::IO.open_multi_gturl('tmp11.nc@*').inspect + "\n"
+
+  str2comp =<<EOS
+[<NumRu::GPhys grid=<3D grid <axis pos=<NumRu::VArrayComposite shape=[36] #_of_tiles=[2]>>
+	<axis pos=<NumRu::VArrayComposite shape=[19] #_of_tiles=[2]>>
+	<axis pos=<'level' in 'tmp00.nc'  sfloat[9]>>>
+   data=<NumRu::VArrayComposite shape=[36, 19, 9] #_of_tiles=[2, 2, 1]>>]
+[<NumRu::GPhys grid=<2D grid <axis pos=<'lat' in 'tmpE0.nc'  sfloat[19]>>
+	<axis pos=<'level' in 'tmpE0.nc'  sfloat[9]>>>
+   data=<'T' in 'tmpE0.nc'  sfloat[19, 9]>>, <NumRu::GPhys grid=<2D grid <axis pos=<'lat' in 'tmpE1.nc'  sfloat[19]>>
+	<axis pos=<'level' in 'tmpE1.nc'  sfloat[9]>>>
+   data=<'T' in 'tmpE1.nc'  sfloat[19, 9]>>, <NumRu::GPhys grid=<2D grid <axis pos=<'lat' in 'tmpE2.nc'  sfloat[19]>>
+	<axis pos=<'level' in 'tmpE2.nc'  sfloat[9]>>>
+   data=<'T' in 'tmpE2.nc'  sfloat[19, 9]>>]
+[<NumRu::GPhys grid=<3D grid <axis pos=<'lon' in 'tmp11.nc'  sfloat[15]>>
+	<axis pos=<'lat' in 'tmp11.nc'  sfloat[10]>>
+	<axis pos=<'level' in 'tmp11.nc'  sfloat[9]>>>
+   data=<'T' in 'tmp11.nc'  sfloat[15, 10, 9]>>, <NumRu::GPhys grid=<3D grid <axis pos=<'lon' in 'tmp11.nc'  sfloat[15]>>
+	<axis pos=<'lat' in 'tmp11.nc'  sfloat[10]>>
+	<axis pos=<'level' in 'tmp11.nc'  sfloat[9]>>>
+   data=<'R' in 'tmp11.nc'  sfloat[15, 10, 9]>>]
+EOS
+
+  str == str2comp ? puts("Test OK") : raise("Test failed")
+
 end