gphys 1.5.5 → 1.5.7

data/lib/numru/ganalysis/lomb_scargle.rb

@@ -0,0 +1,205 @@
+# coding: utf-8
+=begin
+= Lomb-Scargle periodgram
+=end
+
+require "numru/gphys"
+
+module NumRu
+  module GAnalysis
+    module LombScargle
+      module_function
+
+      # = Lomb-Scargle periodgram
+      # 
+      # ARGUMENTS
+      # * y [NArray or NArrayMiss] : data
+      # * dim [Integer] : the dimension to apply LS
+      # * t [1D NArray] : "time" (the coordinate values along dim)
+      # * f [Numric or 1D NArray] : frequency. If 1D NArray, the frequency
+      #   dimension is added to the end of outputs
+      # 
+      # OUTPUTS
+      # * a : coef of cos
+      # * b : coef of sin  (sqrt(a**2+b**2) is the amplitude)
+      # * reconst : reconstructed y (fitting result)
+      # * cos [NArray or NArrayMiss]: cos(2*pi*f*t + ph)
+      #   (useful if you want to reconstruct for a part of f)
+      # * sin [NArray or NArrayMiss]: sin(2*pi*f*t + ph)
+      #   (useful if you want to reconstruct for a part of f)
+      # * cc [NArray or NArrayMiss]: normarization factor sum(cos**2)
+      #   (needed to derive power spectrum)
+      # * ss [NArray or NArrayMiss]: normarization factor sum(sin**2)
+      #   (needed to derive power spectrum)
+      # * ph [NArray or NArrayMiss]: phase (for each f and,
+      #   if with miss, for each grid point)
+      def lomb_scargle(y, dim, t, f)
+        rank = y.rank
+        if y.respond_to?(:get_mask)
+          mask = y.get_mask
+        else
+          mask = nil
+        end
+        ph, ot_ph = derive_phase(t,f,dim,rank,mask)
+        cos = Misc::EMath.cos( ot_ph )
+        sin = Misc::EMath.sin( ot_ph )
+        cc = (cos*cos).sum(dim)
+        ss = (sin*sin).sum(dim)
+        #p "%%%", (cos*sin).sum(dim), cc, ss
+        if !f.is_a?(Numeric)
+          y = y.newdim(-1)
+        end
+        a = (y*cos).sum(dim) / cc
+        b = (y*sin).sum(dim) / ss
+        reconst = (a.newdim(-2)*cos).sum(-1) + (b.newdim(-2)*sin).sum(-1)
+        [a,b,reconst,cos,sin,cc,ss,ph]
+      end
+
+      def derive_phase(t,f,dim,rank,mask=nil)
+        multiple_f = !f.is_a?(Numeric)
+        if multiple_f
+          o2t = 4*Math::PI * f.newdim(0) * t.newdim(-1)  # 2 omega t
+          mask = mask.newdim(-1) if mask
+          nf = f.length
+        else
+          o2t = 4*Math::PI * f * t  # 2 omega t
+        end
+        with_miss = (mask && mask.count_false > 0)
+        if dim >= 1
+          o2t = o2t.newdim!( *([0]*dim) )
+        end
+        if dim < rank-1
+          o2t = o2t.newdim!( *([dim+1]*(rank-1-dim)) )
+        end
+        if with_miss
+          # sampling is not common for all grid points
+          expander = NArray.float( *mask.shape )
+          o2t += expander    # duplicates o2t for all grid points
+          if multiple_f
+            expander = NArray.byte(*([1]*rank+[nf])) # duplicates mask for all f
+            mask += expander
+          end
+          o2t = NArrayMiss.to_nam(o2t,mask)
+        end
+        ph = 0.5* Misc::EMath::atan2( Misc::EMath.sin(o2t).sum(dim),
+                                     -Misc::EMath.cos(o2t).sum(dim)).newdim(dim)
+        ot_ph = o2t*0.5 + ph  # omega*t + ph
+        [ph, ot_ph]
+      end
+    end
+  end
+
+  class GPhys
+    # = Lomb-Scargle periodgram
+    # 
+    # The direct outputs are the amplitude of each wave components,
+    # ga as the coefficties for cos and gb as the coefficties for sin.
+    # 
+    # LS power spectrum can be derived as
+    #   pw = ga**2 * cc/(ntlen*df) + gb**2 * ss/(ntlen*df)
+    #      = ga**2 * cc/(2*fmax) + gb**2 * ss/(2*fmax)
+    # Here, ntlen=2*f.length (equivalent data length from frequency sampling).
+    #
+    # ARGUMENTS
+    # * dim [Integer or String] : dimension to apply fitting
+    # * fmax [Numeric]: max frequency (sampling frequencies [df, 2*df,...,fmax])
+    #   fmax should be a multiple of df
+    # * df [Numeric/nil]: frequency increment (If nil, set to fmax: single freq)
+    # * f_long_name, f_name : long_name and name of the "frequency" axis.
+    #   You may want to specify them if the dimension is not time.
+    # 
+    # OUTPUTS
+    # * ga [GPhys]: coef of cos
+    # * gb [GPhys]: coef of sin  (sqrt(a**2+b**2) is the amplitude)
+    # * greconst [GPhys]: reconstructed y (fitting result)
+    # * cos [NArray or NArrayMiss]: cos(2*pi*f*t + ph)
+    #   (useful if you want to reconstruct for a part of f)
+    # * sin [NArray or NArrayMiss]: sin(2*pi*f*t + ph)
+    #   (useful if you want to reconstruct for a part of f)
+    # * cc [NArray or NArrayMiss]: normarization factor sum(cos**2)
+    #   (needed to derive power spectrum)
+    # * ss [NArray or NArrayMiss]: normarization factor sum(sin**2)
+    #   (needed to derive power spectrum)
+    # * ph [NArray or NArrayMiss]: phase (for each f and,
+    #   if with miss, for each grid point)
+    # * f [1D NArray]: frequencies derived from df and fmax
+
+    def lomb_scargle(dim, fmax, df=nil, f_long_name="frequency", f_name="f")
+
+      #< prep >
+      df = fmax if df.nil?
+      dim = dim_index( dim )
+      ct = coord(dim)
+      t = ct.val
+      nf = (fmax/df).round
+      f = df * (NArray.float(nf).indgen!+1.0)
+      y = val
+
+      #< do it >
+      a, b, reconst, cos, sin, cc, ss, ph =
+                   GAnalysis::LombScargle::lomb_scargle(y, dim, t, f)
+
+      #< to gphys >
+      tun = Units.new( coord(dim).units.to_s.sub(/ *since.*$/,'') )
+      fun = (tun**(-1)).to_s
+      fax = Axis.new.set_pos(
+            VArray.new(f, {"long_name"=>f_long_name,"units"=>fun}, f_name) )
+      oaxes = (0...rank).map{|d| axis(d)}
+      caxes = oaxes.dup
+      caxes[dim] = fax
+      cgrid = Grid.new(*caxes)  # grid of fitting (~Fourier) coefficients
+      un = units.to_s
+      ga = GPhys.new( cgrid,
+                      VArray.new(a,{"long_name"=>"coef a","units"=>un},"a") )
+      gb = GPhys.new( cgrid,
+                      VArray.new(b,{"long_name"=>"coef b","units"=>un},"b") )
+      greconst = GPhys.new( grid, VArray.new(reconst,data,name) )
+      [ga, gb, greconst, cos, sin, cc, ss, ph, f]
+    end
+  end
+
+end
+
+################################################
+##### test part ######
+if $0 == __FILE__
+  require "numru/ggraph"
+  include NumRu
+  include Misc::EMath
+
+  cx = VArray.new(NArray.float(2).indgen!, {"units"=>"1","long_name"=>"x"}, "x")
+
+  ## unequal spacing : fitting
+  #t = NArray.to_na( [0.0, 0.1, 1, 1.5, 3, 3.3, 3.8, 6, 6.3, 7, 7,5, 8, 9] )
+
+  ## equal spacing with missing
+  #t = NArray.to_na( [0.0, 2, 3, 4, 5, 6, 7, 8, 9] )
+
+  # equal spacing: equal to DFT if f is multiples of 1/10
+  t = NArray.float(10).indgen!
+
+  ct = VArray.new(t, {"units"=>"days","long_name"=>"time"},"t")
+  grid = Grid.new( Axis.new.set_pos(cx), Axis.new.set_pos(ct) )
+  nt = t.length
+
+  v = NArrayMiss.float(2,nt)
+  f = 1.0/10.0  # base frequency
+  o = 2*PI*f
+  v[0,true] = sin(o*t) + 0.4*sin(2*o*t) + 0.2*cos(2*o*t) + 0.3*cos(3*o*t)
+  v[1,true] = cos(o*t) + 0.2*sin(2*o*t) + 0.2*cos(2*o*t) + 2*sin(3*o*t)
+
+  v.invalidation(1,1)  # then, v[1,true] fitting will be different from DFT
+  
+  y = VArray.new(v, {"units"=>"m/s","long_name"=>"y"}, "y")
+  gp = GPhys.new(grid, y)
+
+  df = f
+  fmax = 4*df
+  #df = f / 2
+  #fmax = 8*df
+  ga, gb, greconst, cos, sin, ph = gp.lomb_scargle("t",fmax,df)
+  p "**", ga, ph
+  ampsp = ga**2 + gb**2
+  amp = Misc::EMath.sqrt(ampsp.val)
+  p "&&", amp, ampsp.val.sum(-1)/2, ((greconst.val - v)**2).mean(-1)
+end

data/lib/numru/ganalysis/met_z.rb

@@ -48,7 +48,12 @@ module NumRu
 
           pcv_val = pcv.val
           v_val = v.val             # should be NArray or NArrayMiss
-          v_val = v_val.to_na if v_val.is_a?(NArrayMiss)
+          if v_val.is_a?(NArrayMiss)
+            misval = 9.9692099683868690e+36
+            v_val = v_val.to_na(misval)
+          else
+            misval = nil
+          end
           if pcv_val[0] > pcv_val[-1]
             # reverse the p coordinate to the increasing order
             pcv_val = pcv_val[-1..0]
@@ -67,7 +72,7 @@ module NumRu
           vs_val = vs_val.to_na if vs_val.is_a?(NArrayMiss)
 
           v_val, p_over_g, nzbound = GPhys.c_cap_by_boundary(v_val, zdim, 
-                                           pcv_over_g, true, ps_over_g, vs_val)
+                                    pcv_over_g, true, ps_over_g, vs_val, misval)
 
         elsif zdim = SigmaCoord.find_sigma_d(v)  # substitution, not comparison
           # has a sigma coordnate
@@ -85,6 +90,12 @@ module NumRu
           ps = ps.convert_units(pascal) if ps.units != pascal
           sig_val = sig.val
           v_val = v.val    # should be NArray, not NArrayMiss (coz sigma)
+          if v_val.is_a?(NArrayMiss)
+            v_val = v_val.to_na
+            mask = v_val.get_mask
+          else
+            mask = nil
+          end
           p_over_g = SigmaCoord.sig_ps2p(ps.val/grav, sig_val, zdim)
         else
           raise ArgumentError, "v does not have a p or sigma coordinate."
@@ -102,7 +113,7 @@ module NumRu
 
         pc_over_g = pc_val / grav
 
-        rho_v_cum = GPhys.c_cum_integ_irreg(v_val, p_over_g, zdim, nzbound,
+        rho_v_cum = GPhys.c_cum_integ_irreg(v_val, mask, p_over_g, zdim, nzbound,
                                          pc_over_g, nil)
 
         #< zonal mean & latitudinal factor >
@@ -295,6 +306,124 @@ module NumRu
         mstrm
       end
 
+      # Integrate v with p to ps (where v==vs if vs is given)
+      #
+      # Normally, p and ps are pressure, but they are actually arbitrary.
+      # The assumption here is that the ps is the upper cap of p, and
+      # the integration with p is from the smallest p up to ps.
+      # fact is a factor. E.g., 1/gravity to get mass-weighted integration
+      # through dp/g = -\rho dz
+      #
+      # ARGUMENT
+      # * v [GPhys] a multi-dimensional GPhys
+      # * pdim [Integer or String] The dimension of p
+      # * ps [GPhys] the capping value of p (~surface pressure);
+      #   rank must be one smaller than v's (no-missing data allowed)
+      # * vs [nil or GPhys] v at ps (shape must be ps's); if nil, v is 
+      #   interpolated. (If vs==nil, no extrapolation is made when ps>p.max)
+      # * fact [nil or UNumeric or..] factor to be multiplied afterwords
+      #   (e.g., 1/Met.g)
+      # * name [nil or String] name to be set
+      # * long_name [nil or String] long_name to be set
+      #
+      # RETURN VALUE
+      # * a GPhys
+      def integrate_w_p_to_ps(v, pdim, ps, vs: nil, fact: nil,
+                              name: nil, long_name: nil)
+        pdim = v.dim_index(pdim)
+        p = v.coord(pdim)
+
+        if ps
+          if p.units !~ ps.units
+            raise("units mis-match #{p.units} vs #{ps.units}")
+          end
+          if p.units != ps.units
+            p = p.convert_units(ps.units)
+          end
+          pv = p.val
+          psv = ps.val
+          if psv.is_a?(NArrayMiss)
+            raise("data missing exists in ps") if psv.count_invalid != 0
+            psv = psv.to_na
+          end
+        else
+          pv = p.val
+          psv = NArray.float(1).fill!(pv.max)
+        end
+
+        vv = v.val
+        if vv.is_a?(NArrayMiss)
+          mask = vv.get_mask
+          misval = 9.9692099683868690e+36  # near 15 * 2^119 (as nc fill val)
+          vv = vv.to_na(misval)
+        else
+          mask = nil
+          misval = nil
+        end
+
+        nzbound = nil
+
+        if ps
+          if pv[0] > pv[-1]
+            # reverse the p coordinate to the increasing order
+            pv = pv[-1..0]
+            vv = vv[ *([true]*pdim + [-1..0,false]) ]
+          end
+          if vs
+            vsv = vs.val
+            if vsv.is_a?(NArrayMiss)
+              raise("data missing exists in vs") if vsv.count_invalid != 0
+              vsv = vsv.to_na
+            end
+          else
+            vsv = nil
+          end
+          vv, pv, nzbound = GPhys.c_cap_by_boundary(vv, pdim,
+                                           pv, true, psv, vsv, misval)
+          mask_e = NArray.byte(*vv.shape).fill!(1)  # pdim has get longer by one
+          mask_e[ *( [true]*pdim + [0..-2,false]) ] = mask
+          mask = mask_e
+        end
+
+        psv = psv.newdim!(pdim) if ps
+        for iidx in [0,20]
+          sel = [iidx,50,true,0]
+          vi = GPhys.c_cell_integ_irreg(vv, mask, pv, pdim, nzbound, psv, nil)
+        end
+        osh = v.shape.clone
+        osh.delete_at(pdim)
+        vi.reshape!(*osh)
+
+        data = VArray.new(vi, v.data, v.name)
+        data.units = v.units * p.units
+        data = data * fact if fact
+        data.name = name if name
+        data.long_name = long_name if long_name
+
+        grid = v.grid.delete_axes(pdim)
+        grid.set_lost_axes( Array.new )   # reset
+        GPhys.new(grid, data)
+      end
+
     end
   end
 end
+
+######################################
+
+if $0 == __FILE__
+  require "numru/ggraph"
+  include NumRu
+
+  v = GPhys::IO.open("../../../testdata/T.jan.nc","T")
+  v = v.copy.replace_val( NArray.float(*v.shape).fill!(1.0) )
+  ps = GPhys::IO.open("../../../testdata/pres.jan.nc","pres")
+  ps = ps.convert_units("Pa")
+  pdim = GAnalysis::Met.find_prs_d(v)
+  vp = GAnalysis::MetZ.integrate_w_p_to_ps(v, pdim, ps)
+  p "ps", ps.val
+  p "result 1", vp.val+1000
+  vs = ps * 0.0
+  vp = GAnalysis::MetZ.integrate_w_p_to_ps(v, pdim, ps, vs: vs)
+  p "result 2", vp.val+1000
+end

data/lib/numru/ganalysis/narray_ext.rb

@@ -0,0 +1,13 @@
+require "narray"
+require "numru/ganalysis_ext"
+
+class NArray
+  def cum_sum(dim)
+    case self.typecode
+    when DFLOAT
+      NumRu::NArrayExt.cum_sum_dfloat(self,dim)
+    else
+      raise "Sorry, this narray type #{self.typecode} is not supported."
+    end
+  end
+end

data/lib/numru/ganalysis/pde.rb

@@ -0,0 +1,109 @@
+require "numru/gphys"
+require "numru/ganalysis_ext"
+
+module NumRu
+  module GAnalysis
+    module PDE
+      module_function
+      #
+      # = Solve 2-dim 2nd order PDE by the succesive over-relaxation method
+      # 
+      # ARGUMENTS.
+      # * z [in-out, 2D dfloat NArray] : When in, initial values. When out,
+      #   the result. Boundary values are not changed (Dirichlet problem)
+      #   (developper's memo: Neuman cond can be supported as an option)
+      # * a, b, c, d, e, f [in, 2D dfloat NArray with the same shape as z] :
+      #   Specifies the PDF as
+      #      a z_xx + 2*b z_xy + c z_yy + d z_x + e z_y = f
+      #               ^^^
+      #   Please note that 2*b is the coefficient of z_xy.
+      #   x is the first (0th) NArray dimension.
+      # * dx, dy [Float] : grid spacings
+      # * ome [Float] : the over-relaxation parameter 1<=ome<2.
+      #   For a large-scale poisson equation, should be ~ 2 (e.g. 1.9).
+      # * eps [optional, Float] : conversion threshold (e.g. 1e-5).
+      #   Compared with |increment|/|F| (| | is the L2 norm).
+      #   When |f| == 0 (homogenous), compared simply with |increment|.
+      # * maxi [optional, Integer]: max iteration times(default, 5*[nx,ny].max).
+      #   Since SOR (or the Gauss-Seidel method) acts like a stepwise diffusion,
+      #   it must be greater than the along-x and along-y grid sizes.
+      # * ignore_non_eliptic : if true (non-nil,non-false), do not raise
+      #   error when the coeeficients are not entirely eliptic.
+      # 
+      # RETURN VALUE
+      # * |last increment|/|F| of |last increment| (to be compared with eps)
+      # 
+      def SOR_2D_2ndorder(z, a, b, c, d, e, f, dx, dy, ome, eps: nil, maxi: nil,
+                          ignore_non_eliptic: false)
+        lf = Math.sqrt( (f**2).sum )  # L2 norm of f
+        lf = 1.0 if lf==0   # when |f|==0 (homogeneous), no-division by |f|.
+        res = nil
+        if !maxi
+          maxi = [ z.shape[0], z.shape[1] ].max * 5  # default max itr times
+        end
+        convd = false
+        for i in 0...maxi
+          res = SOR_2D_2ndorder_1step(z, a, b, c, d, e, f, dx, dy, ome,
+                                      ignore_non_eliptic)
+          #p res/lf, z
+          if (eps && res/lf < eps)
+            convd = true
+            break
+          end
+        end
+        if (eps && !convd)
+          raise("Max iteration times (#{maxi}) reached before convergence" +
+                " (#{res/lf} > #{eps}). Change ome (#{ome}) or specify maxi.")
+        end
+        #p i,res/lf #, z
+        res/lf
+      end
+    end
+  end
+end
+
+################################################
+##### test part ######
+if $0 == __FILE__
+  require "numru/ggraph"
+  include NumRu
+
+  #nx = ny = 9
+  nx = ny = 91
+  z = NArray.float(nx,ny)
+  a = c = NArray.float(nx,ny).fill!(1.0)
+  b = d = e = NArray.float(nx,ny)
+  f = NArray.float(nx,ny)
+  f[nx/2,ny/2] = 1.0
+  dx = dy = 1.0
+  #ome = 1.9
+  #GAnalysis::PDE.SOR_2D_2ndorder(z, a, b, c, d, e, f, dx, dy, ome)
+=begin
+  (1.0..1.91).step(0.1){|ome|
+    puts "ome = #{ome}"
+    GAnalysis::PDE.SOR_2D_2ndorder(z, a, b, c, d, e, f, dx, dy, ome)
+  }
+=end
+  eps = 1e-6
+  ome = 1.95
+  GAnalysis::PDE.SOR_2D_2ndorder(z, a, b, c, d, e, f, dx, dy, ome, eps: eps)
+
+  # -- make gphys object
+  nax = NArray.sfloat(nx).indgen!
+  hax = {'long_name'=>'x-coordinate', 'units'=>'grid number'}
+  vax = VArray.new(nax, hax, 'x')
+  axx = Axis.new.set_pos(vax)
+
+  nay = NArray.sfloat(ny).indgen!
+  hay = {'long_name'=>'y-coordinate', 'units'=>'grid number'}
+  vay = VArray.new(nay, hay, 'y')
+  axy = Axis.new.set_pos(vay)
+
+  haz = {'long_name'=>'', 'units'=>''}
+  vaz = VArray.new(z, haz, 'data')
+  gpz = GPhys.new(Grid.new(axx, axy), vaz)
+
+  GGraph.startup('iws'=>1)
+  GGraph.tone_and_contour gpz,true,'color_bar'=>true
+  GGraph.close
+end

data/lib/numru/ganalysis/planet.rb

@@ -95,6 +95,82 @@ module NumRu
         rot
       end
 
+      # spherical divergence for entire rectagular regional data
+      def div_s_box(u,v, only_u: false, only_v: false,
+                    xs0: false, xe0: false, ys0: false, ye0: false)
+        lam, phi, xd, yd  = get_lambda_phi(u)
+        lon = u.coord(xd)
+        lat = u.coord(yd)
+        cos_phi = phi.cos
+        nx = lam.length
+        ny = phi.length
+        if nx>2
+          ixends = {0..-1=>(nx-1)}
+        else
+          ixends = true
+        end
+        if ny>2
+          iyends = {0..-1=>(ny-1)}
+        else
+          iyends = true
+        end
+        ub = u[*([true]*xd + [ixends, false])].copy  # ends along lon
+        vb = v[*([true]*yd + [iyends, false])].copy  # ends along lat
+        ub.axis(xd).set_pos(lam[ixends].data)
+        ub.axis(yd).set_pos(phi.data)
+        vb.axis(xd).set_pos(lam.data)
+        vb.axis(yd).set_pos(phi[iyends].data)
+        ubi = ub.integrate(yd)   # trapezoidal integration by default
+        vbi = vb.integrate(xd) * cos_phi[iyends]
+        dlam = lam[-1].val - lam[0].val
+        sin_phib = phi[iyends].sin.val
+        dsin_phi = sin_phib[-1] - sin_phib[0]
+        if xd<yd
+          xdi = xd
+          ydi = yd-1
+        else
+          xdi = xd-1
+          ydi = yd
+        end
+        scalar=false
+        ubi.axis(xdi).set_pos(lon[ixends])  # to lon before the cut is recoreded
+        vbi.axis(ydi).set_pos(lat[iyends])  # to lat before the cut is recoreded
+        if ubi.rank>1
+          xe = ubi[*([true]*xdi+[-1,false])]
+          xs = ubi[*([true]*xdi+[0,false])]
+          ye = vbi[*([true]*ydi+[-1,false])]
+          ys = vbi[*([true]*ydi+[0,false])]
+        else
+          # to defer the result becomes a scalar
+          scalar=true
+          xe = ubi[*([true]*xdi+[-1..-1,false])]
+          xs = ubi[*([true]*xdi+[0..0,false])]
+          ye = vbi[*([true]*ydi+[-1..-1,false])]
+          ys = vbi[*([true]*ydi+[0..0,false])]
+        end
+        xe *= 0.0 if xe0
+        xs *= 0.0 if xs0
+        ye *= 0.0 if ye0
+        ys *= 0.0 if ys0
+        dub = xe - xs
+        dvb = ye - ys
+        if only_u
+          div = dub/(@@R*dlam*dsin_phi.abs) 
+        elsif only_v
+          div = dvb/(@@R*dlam.abs*dsin_phi)
+        else
+          div = dub/(@@R*dlam*dsin_phi.abs) +
+                dvb/(@@R*dlam.abs*dsin_phi)
+              # (dlam*dsin_phi).abs is the area for the unit radius
+        end
+        if scalar
+          div = div[0]
+        end
+        div.long_name = "div(#{u.name},#{v.name})"
+        div.name = "div"
+        div
+      end
+      
       def vor_s(u,v)
         vor = rot_s(u,v)
         vor.long_name = "Relative Vorticity"
@@ -131,7 +207,7 @@ module NumRu
       end
 
       def grad_sy(s)
-        lam, phi, lond, latd  = get_lambda_phi(s)
+        phi, latd  = get_phi(s)
         cos_phi = phi.cos
         ys = s.cderiv(latd,latbc(phi),phi) / @@R
         ys.long_name = "ygrad(#{s.name})"
@@ -196,6 +272,22 @@ module NumRu
         [lam, phi, lond, latd]
       end
 
+      def get_lambda(gp, err_raise=true)
+        lond = find_lon_dim(gp, err_raise)
+        lam = lond && gp.axis(lond).to_gphys.convert_units("rad") # lon in rad
+        lam.units = "" if lond                            # treat as non-dim
+        @@lam = lam
+        [lam, lond]
+      end
+
+      def get_phi(gp, err_raise=true)
+        latd = find_lat_dim(gp, err_raise)
+        phi = latd && gp.axis(latd).to_gphys.convert_units("rad") # lat in rad
+        phi.units = "" if latd                            # treat as non-dim
+        @@phi = phi
+        [phi, latd]
+      end
+
       # Find longitude and latitude coordinates.
       # 
       # ARGUMENTS
@@ -254,6 +346,49 @@ module NumRu
         end
         [lond,latd]
       end
+
+      def find_lon_dim(gp, err_raise=false)
+        lond = nil
+        (0...gp.rank).each do |dim|
+          crd = gp.coord(dim)
+          if /^degrees?_east$/i =~ crd.get_att("units")
+            lond = dim
+            break
+          elsif ( ( /longitude/i =~ crd.long_name || 
+                    /^lon/i =~ crd.name ||
+                    (nm=crd.get_att("standard_name") && /longitude/i =~ nm ) &&
+                    (crd.units =~ Units["degrees_east"]) ) )
+            lond = dim
+            break
+          end
+        end
+        if err_raise
+          raise("Longitude dimension was not found") if !lond
+        end
+        lond
+      end
+
+      def find_lat_dim(gp, err_raise=false)
+        latd = nil
+        (0...gp.rank).each do |dim|
+          crd = gp.coord(dim)
+          if /^degrees?_north$/i =~ crd.get_att("units")
+            latd = dim
+            break
+          elsif ( ( /latitude/i =~ crd.long_name || 
+                    /^lat/i =~ crd.name ||
+                    (nm=crd.get_att("standard_name") && /latitude/i =~ nm ) &&
+                    (crd.units =~ Units["degrees_north"]) ) )
+            latd = dim
+            break
+          end
+        end
+        if err_raise
+          raise("Latitude dimension was not found") if !latd
+        end
+        latd
+      end
+
     end
 
   end