gphys 1.2.2.1 → 1.4.3

data/spec/gphys_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Gphys do
+  it 'has a version number' do
+    expect(Gphys::VERSION).not_to be nil
+  end
+
+  it 'does something useful' do
+    expect(false).to eq(true)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'gphys'

data/test/test_assoccoords.rb

@@ -0,0 +1,102 @@
+$LOAD_PATH.unshift("../lib/")
+require "numru/gphys/gphys.rb"
+require "test/unit"
+include NumRu
+include NMath
+
+class AssocCoordsTest < Test::Unit::TestCase
+  def setup
+    #@nx = 10
+    #@ny = 7
+    @nx = 5
+    @ny = 3
+    @nz = 2
+    @nt = 2
+    x = (NArray.sfloat(@nx).indgen! + 0.5) * (2*PI/@nx)
+    y = NArray.sfloat(@ny).indgen! * (2*PI/(@ny-1))
+    z = NArray.sfloat(@nz).indgen! 
+    t = NArray.sfloat(@nt).indgen!
+    vx = VArray.new( x ).rename("x")
+    vy = VArray.new( y ).rename("y")
+    vz = VArray.new( z ).rename("z")
+    vt = VArray.new( t ).rename("t")
+    xax = Axis.new().set_pos(vx)
+    yax = Axis.new().set_pos(vy)
+    zax = Axis.new().set_pos(vz)
+    tax = Axis.new().set_pos(vt)
+    xygrid = Grid.new(xax, yax)
+    xyzgrid = Grid.new(xax, yax, zax)
+    xyztgrid = Grid.new(xax, yax, zax, tax)
+
+    sqrt2 = sqrt(2.0)
+    p = NArray.sfloat(@nx,@ny)
+    q = NArray.sfloat(@nx,@ny)
+    for j in 0...@ny
+      p[true,j] = NArray.sfloat(@nx).indgen!(2*j,1)*sqrt2
+      q[true,j] = NArray.sfloat(@nx).indgen!(2*j,-1)*sqrt2
+    end
+    vp = VArray.new( p ).rename("p")
+    vq = VArray.new( q ).rename("q")
+    gp = GPhys.new(xygrid, vp) 
+    gq = GPhys.new(xygrid, vq) 
+    r = NArray.sfloat(@nz).indgen! * 2
+    vr = VArray.new( r ).rename("r")
+    gr = GPhys.new( Grid.new(zax), vr ) 
+
+    d = sin(x.newdim(1,1)) * cos(y.newdim(0,1)) + z.newdim(0,0)
+    vd = VArray.new( d ).rename("d")
+    @gd = GPhys.new(xyzgrid, vd)
+    @gd.set_assoc_coords([gp,gq,gr])
+
+    s = p + r.reshape(1,1,@nz)
+    vs = VArray.new( s ).rename("s")
+    gs = GPhys.new( Grid.new(xax,yax,zax), vs )
+    u = NArray.sfloat(@ny).indgen!
+    vu = VArray.new( u ).rename("u")
+    gu = GPhys.new( Grid.new(yax), vu ) 
+    d2 = d * NArray.sfloat(1,1,1,@nt).indgen
+    vd2 = VArray.new( d2 ).rename("d2")
+    @gd2 = GPhys.new( xyztgrid, vd2 )
+    @gd2.set_assoc_coords([gp,gq,gs,gu])
+
+    #p @gd
+  end
+
+  def test_gd
+    # make sure @gd has proper associated coordinates.
+    assert_equal( @gd.coord("p").rank, 2 )
+    assert_equal( @gd.coord("p").shape, [@nx,@ny] )
+    assert_equal( @gd.coord("q").rank, 2 )
+    assert_equal( @gd.coord("r").rank, 1 )
+  end
+
+  def test_divide_and_join
+    # make sure to divide a GPhys into chunks and joining them
+    # restores the original assoccoords.
+    chunks = Array.new
+    [0..@nx/2,@nx/2+1..-1].each do |ix|
+      [0..@ny/2,@ny/2+1..-1].each do |iy|
+        chunks.push( @gd[ix,iy,true].copy )
+      end
+    end
+    gd2 = GPhys.join(chunks)
+    assert_equal( gd2.coord("p").shape, [@nx,@ny] )
+    assert_equal( gd2.coord("p").val, @gd.coord("p").val )
+  end
+
+  def test_cut_twice
+    c = @gd2[true,0,true,true] #=> [@nx,@nz,@nt]
+    c2 = c[true,true,0]        #=> [@nx,@nz]
+    assert_equal( c2.coord("p").shape, [@nx] )
+    assert_equal( c2.coord("q").shape, [@nx] )
+    assert_equal( c2.coord("s").shape, [@nx,@nz] )
+  end
+
+  def test_mean
+    c = @gd2.mean("y") #=> [@nx,@nz,@nt]
+    assert_equal( c.coord("p").shape, [@nx] )
+    assert_equal( c.coord("q").shape, [@nx] )
+    assert_equal( c.coord("s").shape, [@nx,@nz] )
+  end
+
+end

data/test/test_axis.rb

@@ -0,0 +1,61 @@
+##$LOAD_PATH.clear
+##$LOAD_PATH.push("/usr/lib/ruby/1.8")
+##$LOAD_PATH.push("/usr/lib/ruby/1.8/i686-linux")
+$LOAD_PATH.unshift("../lib/")
+require "numru/gphys/axis.rb"
+require "test/unit"
+include NumRu
+
+class AxisTest < Test::Unit::TestCase
+  def setup
+    @len = 10
+    xc = VArray.new( NArray.float(@len).indgen! + 0.5 ).rename("x")
+    xb = VArray.new( NArray.float(@len+1).indgen! ).rename("xb")
+    @axpt = Axis.new().set_pos(xc)
+    axcel = Axis.new(true).set_cell(xc,xb)
+    @axcel_c = axcel.dup.set_pos_to_center
+    @axcel_b = axcel.dup.set_pos_to_bounds
+    #axcel2 = Axis.new(true).set_cell_guess_bounds(xc)
+
+    xcc = xc.copy
+    xcc.set_att("modulo", [@len.to_f])
+    @axcyc = Axis.new().set_pos(xcc)
+  end
+
+  def test_cell
+    assert_equal(@axcel_c.cell_center?, true)
+    assert_equal(@axcel_b.cell_bounds?, true)
+  end
+
+  def test_length
+    assert_equal(@axpt.length, @len)
+    assert_equal(@axcel_c.length, @len)
+    assert_equal(@axcel_b.length, @len+1)
+  end
+
+  def test_cyclic
+    assert_equal(@axcyc.cyclic?, true)
+    assert_equal(@axcyc.cyclic_extendible?, true)
+    assert( @axcyc.cut(14.9)[0].is_a?(String) )  # cut by scalar
+    ax, sl = @axcyc.cut([5.6, 13.1, 14.9])    # cut by Array
+    assert_equal( ax.pos.val.to_a, [5.5, 13.5, 14.5] )
+    assert_equal( sl, [5, 3, 4] )
+    ax, sl = @axcyc.cut(-3..3)
+    assert_equal( ax.pos.val.to_a, [-2.5, -1.5, -0.5, 0.5, 1.5, 2.5] )
+    assert_equal( sl, [7,8,9,0,1,2] )
+    ax, sl = @axcyc.cut(-3..13)
+    assert_equal( ax.length, 16 )
+    assert_equal( sl.length, 16 )
+    p "###", ax.pos.val.to_a,sl.to_a
+    ##p "###", @axcyc.cut(0.1..0.2)
+  end
+
+  def test_add
+    assert_equal( @axpt.add(3.0).pos.val[0], @axpt.pos.val[0]+3.0 )
+    axcel_b2 = @axcel_b.add( NArray.float(@axcel_b.length).indgen! )
+    len = axcel_b2.length
+    assert_equal( @axcel_b.pos[-1].val + (len-1), axcel_b2.pos[-1].val )
+    assert_not_equal( @axcel_b.cell_center.val, axcel_b2.cell_center.val )
+    assert_nothing_raised{@axcel_c.add(NArray.float(@axcel_c.length).indgen!)}
+  end
+end

data/test/test_fitting.rb

@@ -0,0 +1,116 @@
+$LOAD_PATH.unshift( File.expand_path("../lib") )
+require "narray"
+require "numru/ganalysis/fitting"
+require "test/unit"
+include NumRu
+
+class FittingTest < Test::Unit::TestCase
+  def setup
+    nx = 7
+    ny = 5
+    @x = NArray.float(nx).indgen! - nx/2
+    @y = NArray.float(ny).indgen! - ny/2
+
+    x = @x.newdim(-1)
+    y = @y.newdim(0)
+    @data = x + 2*y + 10     # then the coefficients will be [1, 2, 10]
+    dist = (x*x)*(y*y)*1e-1
+    dist -= dist.mean
+    @data += dist  # disturbance that does not change the fitting result
+
+    @data2 = NArray.float(nx,2,ny)
+    @data2[true,0,true] = @data - 1
+    @data2[true,1,true] = @data + 1
+
+    @data3 = 2*NMath.cos(x) + 3*NMath.sin(y)
+
+    @f_cosx = proc {|x,y| NMath.cos(x).newdim!(-1)}
+    @f_sinx = proc {|x,y| NMath.sin(x).newdim!(-1)}
+    @f_cosy = proc {|x,y| NMath.cos(y).newdim!(0)}
+    @f_siny = proc {|x,y| NMath.sin(y).newdim!(0)}
+
+    d = NArray.float(nx,2,ny)
+    d[true,0,true] = x + 2*y + 10 - 1
+    d[true,1,true] = x + 2*y + 10 + 1
+    mask = NArray.byte( *d.shape )
+    mask[0..3,true,0..3] = mask[-3..-1,true,true] = 1
+    mask[0,0,0] = 0           # this is the source of a small descrepancy
+    @data2m = NArrayMiss.to_nam( d, mask )
+
+    @data4 = NArray.float(nx,2,ny,2)
+    @data4[false,0] = d - 0.1
+    @data4[false,1] = d + 0.1
+  end
+
+  def test_least_square_fit_1
+    f_x = GAnalysis::Fitting::X
+    f_y = GAnalysis::Fitting::Y
+
+    c, bf, dif = GAnalysis::Fitting.least_square_fit(@data, [@x,@y], [f_x, f_y])
+    err = (c - NArray[1.0, 2.0, 10.0]).abs.max
+    assert( err < 1e-5 )
+
+    c, bf, dif = GAnalysis::Fitting.least_square_fit(@data2, [@x,@y], 
+                                                     [f_x,f_y], [1])
+    err = (c - NArray[1.0, 2.0, 10.0]).abs.max
+    assert( err < 1e-5 )
+  end
+
+  def test_least_square_fit_2
+    c, bf, dif = GAnalysis::Fitting.least_square_fit(@data3, [@x,@y], 
+                                      [@f_cosx, @f_sinx, @f_cosy, @f_siny])
+    err = (c - NArray[2.0, 0, 0, 3, 0]).abs.max
+    assert( err < 1e-10 )
+    assert( dif < 1e-10 )
+  end
+
+  def test_least_square_fit_3
+    f_x = GAnalysis::Fitting::X
+    f_y = GAnalysis::Fitting::Y
+
+    c, bf, dif = GAnalysis::Fitting.least_square_fit(@data2m, [@x,@y], 
+                                                     [f_x,f_y],[1])
+    err = (c - NArray[1.0, 2.0, 10.0]).abs.max
+    assert( err < 3e-2 )
+  end
+
+  def test_least_square_fit_4
+    f_x = GAnalysis::Fitting::X
+    f_y = GAnalysis::Fitting::Y
+
+    c, bf, dif = GAnalysis::Fitting.least_square_fit(@data4, [@x,@y], [f_x,f_y],
+                                                nil, [1,3])
+    assert_equal( c.rank, 3 )  
+    assert( dif < 1e-10 )   # should be a perfect fit (except round-off)
+
+
+    c, bf, dif = GAnalysis::Fitting.least_square_fit(@data4, [@x,@y], [f_x,f_y],
+                                                [3], [1])
+    assert_equal( c.rank, 2 )
+    assert_equal( bf.rank, 4 )
+    assert_equal( bf.shape[3], 1 )
+  end
+
+  def test_least_square_fit_5
+    va = VArray.new(@data4,{"long_name"=>"data4","units"=>""},"data4")
+    xax = Axis.new().set_pos( VArray.new(@x,{"units"=>""},"x") )
+    yax = Axis.new().set_pos( VArray.new(@y,{"units"=>""},"y") )
+    v1 = NArray.float(@data4.shape[1]).indgen!
+    ax1 = Axis.new().set_pos( VArray.new(v1,nil,"d1") )
+    v3 = NArray.float(@data4.shape[3]).indgen!
+    ax3 = Axis.new().set_pos( VArray.new(v3,nil,"d3") )
+    grid = Grid.new(xax, ax1, yax, ax3)
+    gphys = GPhys.new(grid, va)
+
+    f_x = GAnalysis::Fitting::X
+    f_y = GAnalysis::Fitting::Y
+
+    c, bf, dif = gphys.least_square_fit([f_x,f_y], [3], [1])
+    assert_equal( c.rank, 2 )
+    assert_equal( bf.class, NumRu::GPhys )
+    assert_equal( bf.rank, 3 )   # rank reduced <-- ensemble_dims are deleted
+    assert_equal( bf.shape, [7,2,5] )   # [nx, len of indep_dim, ny ]
+  end
+
+end
+

data/test/test_gphys.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift("../lib/")
+require "numru/gphys/gphys.rb"
+require "numru/gphys/gphys_io.rb"
+require "test/unit"
+include NumRu
+
+class GPhysTest < Test::Unit::TestCase
+  def setup
+    @T = GPhys::IO.open("../testdata/T.jan.nc","T")      # NetCDF data
+    @Tgd = GPhys::IO.open("../testdata/T.jan.ctl","T")   # GrADS data
+  end
+
+  def test_cyclic_ext
+    te = @T.cyclic_ext(0)
+    assert_equal( te.shape[0], @T.shape[0]+1 )      # to make sure it is extened
+    assert_equal( te.axis(0).pos.max.to_f, 360.0 )  # to make sure it is extened
+    te = @Tgd.cyclic_ext(0)
+    assert_equal( te.axis(0).pos.max.to_f, 360.0 )  # to make sure it is extened
+  end
+end

data/test/test_met_z.rb

@@ -0,0 +1,96 @@
+$LOAD_PATH.unshift( File.expand_path("../lib") )
+require "narray"
+require "../gphys_ext"   # extention library is currently at the top directory
+require "numru/gphys"
+require "numru/ganalysis/met_z"
+require "numru/ganalysis/sigma_coord"
+require "test/unit"
+include NumRu
+
+
+class MetZTest < Test::Unit::TestCase
+  def setup
+    nx = 6
+    x = NArray.float(nx).indgen!*60
+    lam = ( x * (Math::PI/180) ).newdim(-1)
+    ny = 5
+    y = NArray.float(ny).indgen!*30 - 60.0
+    phi = ( y * (Math::PI/180) ).newdim(0)
+    ns = 5
+    s = 1.0 - NArray.float(ns).indgen / ns
+    vx = VArray.new(x,{"units"=>"degrees_east", "long_name"=>"longitude"},"lon")
+    vy = VArray.new(y,{"units"=>"degrees_north","long_name"=>"latitude"},"lat")
+    vs = VArray.new(s,{"units"=>"1","long_name"=>"sigma"},"sig")
+    ax = Axis.new().set_pos(vx)
+    ay = Axis.new().set_pos(vy)
+    as = Axis.new().set_pos(vs)
+    grid_xy = Grid.new(ax, ay)
+    grid_xys = Grid.new(ax, ay, as)
+
+    p = s * 1000.0
+    vp = VArray.new(p,{"units"=>"hPa","long_name"=>"pressure"},"p")
+    ap = Axis.new().set_pos(vp)
+    grid_xyp = Grid.new(ax, ay, ap)
+
+    ps = NArray.float(nx,ny).fill!(1000) + NMath.cos(lam)*NMath.cos(phi)*50
+    ps[1,1] = 750 
+    ps[2,1] = 500 
+    ps[3,1] = 700 
+
+    #< for test_mass_strm_p_* and test_mass_strm_* >
+
+    @ps = GPhys.new( grid_xy, VArray.new(ps, {"units"=>"hPa"}, "ps") )
+
+    #v = NArray.float(nx,ny,ns) + (NMath.cos(lam)*NMath.sin(2*phi)*10).newdim(-1)
+    v = NArray.float(nx,ny,ns).fill!(1.0)
+
+    @v_on_sig = GPhys.new( grid_xys, VArray.new(v, {"units"=>"m.s-1"}, "v") )
+    @v_on_p   = GPhys.new( grid_xyp, VArray.new(v, {"units"=>"m.s-1"}, "v") )
+
+    #v2 = v.clone
+    #(0...ns).each{|k| v2[false,k]=ns-k}
+    #v2[2,0,false]=300
+    #@v_on_p2 = GPhys.new( grid_xyp, VArray.new(v2, {"units"=>"m.s-1"}, "v") )
+    
+    @ans1 = NArray[ 5.41667e+07, 6.5e+09, 1.3e+10, 1.95e+10, 2.57292e+10 ]
+
+    #< additionally for test_mass_strm_* >
+
+    @p_on_sig = GAnalysis::SigmaCoord.sig_ps2p(@ps, s, 2)
+
+    @pcoord = vs * 1000
+    @pcoord.units = "hPa"
+    @pcoord.name = "p"
+    @pcoord.long_name = "pressure"
+    @pcoord.put_att("standard_name","air_pressure")
+    @pcoord.put_att("positive","down")
+
+  end
+
+  def test_mass_strm_p_1
+    mstr = GAnalysis::MetZ.mass_strm_p(@v_on_sig, @ps)
+    v = mstr[0,true].val / (2 * Math::PI)
+    eps = (v-@ans1).abs.max / v.abs.max
+    assert( eps < 1e-5 )
+  end
+
+  #def test_mass_strm_p_2
+  #  mstr = GAnalysis::MetZ.mass_strm_p(@v_on_p2, @ps)
+  #end
+
+  def test_mass_strm_p_3
+    mstr = GAnalysis::MetZ.mass_strm_p(@v_on_p, @ps)
+    v = mstr[0,true].val / (2 * Math::PI)
+    ans = NArray[ 0, 6.5e+09, 1.3e+10, 1.95e+10, 2.57292e+10 ]
+    eps = (v-ans).abs.max / v.abs.max
+    assert( eps < 1e-5 )
+  end
+
+  def test_mass_strm_any_1
+    mstr = GAnalysis::MetZ.mass_strm_any(@v_on_sig, @ps, @p_on_sig/10, @pcoord/10)
+    v = mstr[0,true].val / (2 * Math::PI)
+    eps = (v - @ans1).abs.max / v.abs.max
+    assert( eps < 1e-5 )
+  end
+
+end

data/test/test_sigma_coord.rb

@@ -0,0 +1,50 @@
+$LOAD_PATH.unshift( File.expand_path("../lib") )
+require "numru/gphys"
+require "numru/ganalysis/sigma_coord"
+require "test/unit"
+include NumRu
+
+class SigmaCoordTest < Test::Unit::TestCase
+  def setup
+    nx = 6
+    x = NArray.float(nx).indgen!*60
+    lam = ( x * (Math::PI/180) ).newdim(-1)
+    ny = 5
+    y = NArray.float(ny).indgen!*30 - 60.0
+    phi = ( y * (Math::PI/180) ).newdim(0)
+    ns = 4
+    s = 1.0 - NArray.float(ns).indgen / ns
+    vx = VArray.new(x,{"units"=>"degrees_east", "long_name"=>"longitude"},"lon")
+    vy = VArray.new(y,{"units"=>"degrees_north","long_name"=>"latitude"},"lat")
+    vs = VArray.new(s,{"units"=>"1","long_name"=>"sigma"},"sig")
+    ax = Axis.new().set_pos(vx)
+    ay = Axis.new().set_pos(vy)
+    as = Axis.new().set_pos(vs)
+    grid_xy = Grid.new(ax, ay)
+    grid_xys = Grid.new(ax, ay, as)
+
+    ps = NArray.float(nx,ny).fill!(1000) + NMath.cos(lam)*NMath.cos(phi)*10
+    @ps = GPhys.new( grid_xy, VArray.new(ps, {"units"=>"hPa"}, "ps") )
+
+    u = NArray.float(nx,ny,ns) + (NMath.cos(lam)*NMath.sin(2*phi)*10).newdim(-1)
+    @u = GPhys.new( grid_xys, VArray.new(u, {"units"=>"m.s-1"}, "u") )
+  end
+
+  def test_find_sigma_d
+    assert_equal( GAnalysis::SigmaCoord.find_sigma_d(@u), 2 )
+  end
+
+  def test_sig_ps2p
+    sig = @u.coord(2)
+    sigval = sig.val
+    p1 = GAnalysis::SigmaCoord.sig_ps2p(@ps.val, sigval, 2 )
+    assert( p1.is_a?(NArray) )
+    assert_equal( p1.shape, @u.shape )
+
+    p2 = GAnalysis::SigmaCoord.sig_ps2p(@ps, sig, 2 )
+    assert( p2.is_a?(GPhys) )
+    assert_equal( p2.shape, @u.shape )
+    assert_equal( p2.val, p1 )
+  end
+
+end