gphys 1.5.6 → 1.5.7

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

@@ -1,5 +1,5 @@
 require "narray"
-require "numru/ganalysis/ganalysis_ext"
+require "numru/ganalysis_ext"
 
 class NArray
   def cum_sum(dim)

data/lib/numru/ganalysis/pde.rb

@@ -1,5 +1,5 @@
 require "numru/gphys"
-require "numru/ganalysis/ganalysis_ext"
+require "numru/ganalysis_ext"
 
 module NumRu
   module GAnalysis
@@ -87,4 +87,23 @@ if $0 == __FILE__
   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

data/lib/numru/ganalysis/qg.rb

@@ -213,7 +213,217 @@ module NumRu
         divh
       end
 
+      # Wave activity flux by Takaya and Nakamura (2001) (TN2001)
+      #
+      # This method works by mix-in in QG (Cartesian) or QG_sphere (spherical).
+      # (so the call it either as QG::waf_tn2001(gph, gphbs, ..) or
+      # QG_sphere::waf_tn2001(gph, gphbs, ..) ).
+      #
+      # DEFINITIONS
+      #
+      # * if called through QG: a modified version of Eq (32) of TN2001
+      # * if called through QG_sphere: a modified version of Eq (38) of TN2001
+      # The modification of Eq (32) and (38) is as follows:
+      # * The multiplication by p is omitted. This is because
+      #    it is more convenient to do it afterwords if needed
+      #    (for example, to integrate with p would require not to have
+      #    done this multiplication).
+      # * The C_u M term is not included as in convention.
+      #   (but the multiplication by cos(phi) is done in QG_sphere).
+      #   Note that this term vanishes for stationary waves, because C_u=0.
+      # * The normal vector (n1, n2) in TN2001 can be set flexibly.
+      #   This vector is called (nx, ny) in this method, since n2 is used
+      #   for the buoyancy frequency. In eqs. (32) and (38), (nx, ny)
+      #   is prescribed as (nx, ny) = (U,V)/|U,V| where U is ubs and V is vbs.
+      #   However, this relation is not necessarily valid, since (nx, ny)
+      #   is originally attributed to the QGPV gradient of the basic flow.
+      #   Therefore, in this method, (nx, ny) can be set arbitrary.
+      #   Also, one can set (nx, ny) = (1, 0) or (0, 1) by setting the
+      #   optional argument zonal or merid to true.
+      #
+      # ARGUMENTS
+      # * gph: geopotential height
+      # * gphbs: geopotential height (basic state). Basically, it needs to have
+      #   the same spacial grid as gph, but it can be a meridional section
+      #   (such as zonal mean), if the normal vector is specified by
+      #   (ubs, vbs) or (nx, ny) or zonal or merid.
+      # * nx, ny: normalized vector to designate the direction of wave
+      #   propagation. By default, set to the direction of (ubs, vbs),
+      #   or set by zonal/merid (see below).
+      # * ubs, vbs: Basic state zonal and meridional winds to compute
+      #   the normal vector (nx,ny) as (ubs,vbs)/sqrt(ubs**2 + vbs**2).
+      #   Neglected if nx and ny are specified. By default ubs and vbs
+      #   are derived geostrophically from gphbs
+      # * zonal: derive the flux in the zonal direction assuming (nx,ny)=(1,0)
+      # * merid: derive the flux in the meridional dir assuming (nx,ny)=(0,1)
+      # * n2: Brunt-Vaisala (buoyancy) frequency squared. By default, derived
+      #   from gphbs
+      # * derive_M0: derive M (the wave-activity pseudomomentum of TN20001)
+      #   when the wave is stationary (cp=0). You need to give ubs and vbs
+      #   (or have them derived from gphbs by not using nx, ny, zonal or merid)
+      #   to make this option available.
+      #
+      # RETURN VALUE
+      # * [wx, wy, wz, ret_hash] where [wx, wy, wz] are the WAF vector
+      #   and ret_hash provides extra derived quantities such as the
+      #   perturbation stream function (:pp), pseudomomentum M0 (:M0), etc.
+      #
+      # REFERENCE
+      # * Takaya and Namaura (2001): A formulation of a phase-independent
+      #   wave-activity flux for stationary and migratory quasigeostrophic
+      #   eddies on a zonally varying basic flow. J. Atmos. Sci, 58, 608-627.
+      #
+      def waf_tn2001(gph, gphbs, nx: nil, ny: nil, ubs: nil, vbs: nil,
+                     zonal: false, merid: false, n2: nil,
+                     derive_M0: false)
+
+        #< prepration >
+        if self==QG
+          f = f0
+          wgt = nil
+        elsif self==QG_sphere
+          f = f_mask0(gph)
+          wgt = cos_phi(gph)
+        else
+          raise("unsupported module to mix-in #{self}")
+        end
+        ret_hash = Hash.new
+
+        #< perturbation stream function >
+        gf = Met::g / f
+        pp = (gph - gphbs)*gf   # psi' (perturbation stream function)
+        if /gpm/i =~ (us=pp.units.to_s)
+          pp.units = us.sub(/gpm/i,'m')
+        end
+        ret_hash[:pp] = pp
+
+        #< derive nx, ny if not given >
+        ul = psibs = nil
+        if zonal
+          nx = 1.0
+          ny = 0.0
+        elsif merid
+          nx = 0.0
+          ny = 1.0
+        elsif nx.nil? && ny.nil?
+          if !ubs || !vbs
+            psibs, gpref = gph2psi_gpref(gphbs)
+            if /gpm/i =~ (us=psibs.units.to_s)
+              psibs.units = us.sub(/gpm/i,'m')
+            end
+            ubs, vbs = psi2ug_vg(psibs)
+            ret_hash[:ubs] = ubs
+            ret_hash[:vbs] = vbs
+            ret_hash[:gpref] = gpref
+          end
+          ul = (ubs**2+vbs**2).sqrt
+          nx = ubs/ul
+          ny = vbs/ul
+        end
+
+        #< derive aspect ratio >
+        unless n2
+          n2 = LogP::gph2n2(gphbs)
+          ret_hash[:n2] = n2
+        end
+        eps = f**2/n2
+
+        #< cross terms --> WAF >
+        px,py = grad_h(pp)
+        pxx,pxy = grad_h(px)
+        pyy = grad_hy(py) unless ny==0.0
+        pz = LogP::pcdata_dz(pp)
+        pxz = LogP::pcdata_dz(px) unless nx==0.0
+        pyz = LogP::pcdata_dz(py) unless ny==0.0
+        ret_hash[:px] = px
+        ret_hash[:py] = py
+
+        wx = nil
+        unless nx==0.0
+          wx = px*px - pp*pxx
+          wy = px*py - pp*pxy
+          wz = ( px*pz - pp*pxz ) * eps
+          nx2 = nx/2.0
+          wx = wx * nx2
+          wy = wy * nx2
+          wz = wz * nx2
+        end
+
+        unless ny==0.0
+          wx_ = px*py - pp*pxy
+          wy_ = py*py - pp*pyy
+          wz_ = (py*pz - pp*pyz) * eps
+          ny2 = ny/2.0
+          wx_ = wx_ * ny2
+          wy_ = wy_ * ny2
+          wz_ = wz_ * ny2
+          if wx
+            wx += wx_
+            wy += wy_
+            wz += wz_
+          else
+            wx = wx_
+            wy = wy_
+            wz = wz_
+          end
+        end
 
+        if wgt
+          wx = wx * wgt
+          wy = wy * wgt
+          wz = wz * wgt
+        end
+        wx.name = "Wx"
+        wy.name = "Wy"
+        wz.name = "Wz"
+        wx.long_name = "WAFx"
+        wy.long_name = "WAFy"
+        wz.long_name = "WAFz"
+
+        #< derive M0 if required >
+        if derive_M0
+          raise("ubs and vbs are needed to derive M0") if !ubs || !vbs
+          ul = (ubs**2+vbs**2).sqrt unless ul
+          unless psibs
+            psibs, gpref = gph2psi_gpref(gphbs)
+            if /gpm/i =~ (us=psibs.units.to_s)
+              psibs.units = us.sub(/gpm/i,'m')
+            end
+            ret_hash[:gpref] = gpref
+          end
+          n2p = Planet::ave_s(n2)
+          if n2p.rank >= 2
+            pdim = Met.find_prs_d(n2p)
+            ds = Array.new
+            (0...n2p.rank).each do |d| 
+              ds.push(d) unless d == pdim
+            end
+            n2p = n2p.mean(*ds)
+          end
+          qp, = psi2q(pp,n2p)
+          qbs, = psi2q(psibs,n2p)
+          qbx, qby = grad_h(qbs)
+          e2 = px**2 + py**2 + pz**2 * eps  # 2*e
+          qbgrad = (qbx**2+qby**2).sqrt.running_mean(0,3).running_mean(1,3)
+          a = qp**2 / qbgrad / 4.0   # A of TN2001
+          e0 = e2 / ul / 4.0         # E of TN2001 when cp=0
+          m0 = a + e0
+          a.name = "A"
+          a.long_name = "A"
+          e0.name = "E0"
+          e0.long_name = "stationary E"
+          m0.name = "M0"
+          m0.long_name = "stationary TN2001 pseudomomentum"
+          ret_hash[:qp] = qp
+          ret_hash[:qbs] = qbs
+          ret_hash[:A] = a
+          ret_hash[:E0] = e0
+          ret_hash[:M0] = m0
+        end
+
+        #< return >
+        [wx, wy, wz, ret_hash]
+      end
    end
 
     ######################################################
@@ -409,6 +619,12 @@ module NumRu
       def grad_h(gphys)
         @@bp.grad_h(gphys)
       end
+      def grad_hy(gphys)
+        @@bp.grad_y(gphys)
+      end
+      def grad_hx(gphys)
+        @@bp.grad_x(gphys)
+      end
 
       # horizontal divergence (Cartesian)
       def div_h(gphys_u, gphys_v)
@@ -442,9 +658,8 @@ module NumRu
 
       # geopotential height -> geostrophic winds
       def gph2ug_vg(gph)
-        gpx, gpy = Planet::grad_s(gph * Met::g)
-        f = f_mask0(gph)
-        [ -gpy/f, gpx/f]
+        psi, gpref = gph2psi_gpref(gph)
+        psi2ug_vg(psi)
       end
 
       # geopotential height -> QG stream function and the reference geopotential
@@ -524,6 +739,12 @@ module NumRu
       def grad_h(gphys)
         Planet::grad_s(gphys)
       end
+      def grad_hx(gphys)
+        Planet::grad_sx(gphys)
+      end
+      def grad_hy(gphys)
+        Planet::grad_sy(gphys)
+      end
 
       # horizontal divergence (spherical)
       def div_h(fx, fy)