gphys 1.2.2.1 → 1.4.3

data/lib/numru/ganalysis/histogram.rb

@@ -34,14 +34,21 @@ module NumRu
         nbins = 10 if nbins < 10
         min = opts["min"] || gphys0.min.val
         max = opts["max"] || gphys0.max.val
+        if log_bins = (opts["log_bins"] && (min > 0))
+          min = Math.log10(min)
+          max = Math.log10(max)
+        end
         hist = GSL::Histogram.alloc(nbins,[min,max])
       end
       val = gphys0.val
       val = val.get_array![val.get_mask!] if NArrayMiss === val
+      val = NMath.log10(val) if log_bins
       hist.increment(val)
 
       bounds = hist.range.to_na
+      bounds = 10 ** bounds if log_bins
       center = (bounds[0..-2]+bounds[1..-1])/2
+      cell_width = (bounds[1..-1] - bounds[0..-2]) / 2
       name = gphys0.name
       attr = gphys0.data.attr_copy
       bounds = VArray.new(bounds, attr, name)
@@ -51,8 +58,9 @@ module NumRu
       axis.set_pos_to_center
 
       bin = hist.bin.to_na
+      bin /= cell_width if opts["log_bins"]
       bin = VArray.new(bin,
-                       {"long_name"=>"number in bins", "units"=>"1"},
+                       {"long_name" => (log_bins ? "number per unit bin width" : "number in bins"), "units"=>"1"},
                        "bin")
       new_gphys = GPhys.new(Grid.new(axis), bin)
       new_gphys.set_att("mean",[hist.mean])
@@ -157,7 +165,8 @@ module NumRu
             ['window', [nil,nil,nil,nil], "window bounds"],
             ['title', "histogram", "window title"],
             ['exchange', false, "exchange x and y"],
-            ['fill', false, "fill bars"]
+            ['fill', false, "fill bars"],
+            ['fill_pattern', nil, "fill pattern"]
                                                        )
     def histogram(gphys, newframe=true, options=nil)
       gropn_1_if_not_yet
@@ -173,7 +182,10 @@ module NumRu
       # if window is specified via GGraph#fig or GGraph#set_fig, use it.
       opts = @@histogram_options.interpret(options)
       exchange = opts["exchange"]
-      window = opts["window"] || @@fig['window']
+      raise "Option 'window' must be an Array of length == 4" unless opts["window"].is_a?(Array) && opts["window"].length == 4
+      window = opts["window"].dup
+      4.times{|i| window[i] ||= @@fig['window'][i]} if @@fig['window']
+      4.times{|i| window[i] ||= DCL::sgqwnd[i]} unless newframe
       unless exchange
         x = gphys.axis(0).cell_bounds
         y = gphys
@@ -201,7 +213,9 @@ module NumRu
           tmp = NArrayMiss.to_nam_no_dup(tmp, mask)
         end
         y.replace_val(tmp)
-        window[2] = tmp.abs.min * (tmp.min < 0 ? -1 : 1)
+        if(window[2].nil? || window[2] == 0)
+          window[2] = tmp.abs.min * (tmp.min < 0 ? -1 : 1)
+        end
       end
       if (itr==3 || itr==4)
         tmp = x.val
@@ -220,38 +234,35 @@ module NumRu
           tmp = NArrayMiss.to_nam_no_dup(tmp, mask)
         end
         x.replace_val(tmp)
-        window[0] = tmp.abs.min * (tmp.min < 0 ? -1 : 1)
+        if(window[0].nil? || window[0] == 0)
+          window[0] = tmp.abs.min * (tmp.min < 0 ? -1 : 1)
+        end
       end
       opts["window"] = window
 
-      if newframe
-        fig(x, y, "window"=>opts["window"])
-        axes(x, y, "title"=>opts["title"])
-      end
+      fig(x, y, "window" => window) if newframe
       lmiss = DCL::gllget("lmiss")
       DCL::gllset("lmiss", true)
+      if opts["fill"]
+        itps = DCL::uuqarp
+        itps[0] = itps[1] = opts["fill_pattern"] if opts["fill_pattern"]
+        DCL::uusarp(*itps)
+      end
       unless exchange
         if opts["fill"]
           DCL::uvbxa(x.val, [window[2]] * y.length, y.val)
         end
-        if (itr == 2) || (itr == 4)
-          bottom = [y.val.min] * y.length
-        else
-          bottom = [window[2]] * y.length
-        end
+        bottom = [window[2]] * y.length
         DCL::uvbxf(x.val, bottom, y.val)
       else
         if opts["fill"]
           DCL::uhbxa([window[0]] * x.length, x.val, y.val)
         end
-        if (itr == 3) || (itr == 4)
-          bottom = [x.val.min] * x.length
-        else
-          bottom = [window[0]] * x.length
-        end
+        bottom = [window[0]] * x.length
         DCL::uhbxf(bottom, x.val, y.val)
       end
       DCL::gllset("lmiss", lmiss)
+      axes(x, y, "title" => opts["title"]) if newframe
       return nil
     end
     alias :histogram1D :histogram
@@ -308,10 +319,16 @@ if $0 == __FILE__
   GGraph.set_fig("itr"=>4)
   GGraph.histogram(hist)
 
+  GGraph.set_fig("itr"=>1)
+  GGraph.histogram(hist, true, "fill" => true, "fill_pattern" => 15999)
+
   GGraph.set_fig("itr"=>1)
   hist = gphys1D.histogram("nbins"=>10)
   GGraph.histogram(hist, true, "title"=>"histogram 1D")
 
+  hist = GAnalysis.histogram(gphys1D, 'log_bins' => true)
+  GGraph.histogram(hist)
+
   hist = GAnalysis.histogram2D(gphys2D_0, gphys2D_1, "nbins0"=>50)
   GGraph.tone(hist, true, "tonc"=>true)
 

data/lib/numru/ganalysis/log_p.rb

@@ -0,0 +1,130 @@
+require "numru/gphys"
+require 'numru/gphys/derivative'
+require "numru/ganalysis/met"
+
+module NumRu
+  module GAnalysis
+
+    # module LogP : log-pressure coordinate support
+    #
+    module LogP
+      module_function
+
+      # P00 = 1e5 Pa (1000 hPa)
+      P00 = UNumeric[1e5,"Pa"]
+
+      @@H = UNumeric[7e3,"m"]
+
+      # set the constant log-p scale height (default 7e3 m)
+      #
+      # Argument
+      # * h [Unumeric]
+      def set_h(h)
+        @@H = h
+      end
+
+      # returns the current value of the log-p scale height (in UNumeric)
+      def h
+        @@H.clone
+      end
+
+      # convert pressure to log-p height
+      def p2z(p)
+        z = (p/P00).convert_units("1").log * (-@@H)
+        z.name = "z"
+        z.long_name = "log-p z"
+        z.del_att("positive")
+        z
+      end
+
+      # del/delz applied to data with the p coordinate
+      def pcdata_dz(gphys, pdim=nil)
+        pdim = Met.find_prs_d(gphys) if !pdim
+        p = gphys.axis(pdim).to_gphys
+        z = p2z(p.data)
+        bc = Derivative::LINEAR_EXT
+        delz = gphys.threepoint_O2nd_deriv(pdim, bc, z)
+        delz.name = gphys.name+"_z"
+        delz.long_name = "del/delz (#{gphys.long_name})"
+        delz
+      end
+
+      # del2/del2z applied to data with the p coordinate
+      def pcdata_dz2(gphys, pdim=nil)
+        pdim = Met.find_prs_d(gphys) if !pdim
+        p = gphys.axis(pdim).to_gphys
+        z = p2z(p.data)
+        bc = Derivative::LINEAR_EXT
+        delz = gphys.deriv2nd(pdim, bc, z)
+        delz.name = gphys.name+"_zz"
+        delz.long_name = "del2/del2z (#{gphys.long_name})"
+        delz
+      end
+
+      # p^{-1} del_z ( p del_z self )
+      # where del_z = del/del z
+      def pcdata_pi_dz_p_dz(gphys, pdim=nil)
+        pdim = Met.find_prs_d(gphys) if !pdim
+        p = gphys.axis(pdim).to_gphys
+        z = p2z(p.data)
+        bc = Derivative::LINEAR_EXT
+        p_dz = gphys.threepoint_O2nd_deriv(pdim, bc, z) * p
+        pi_dz_p_p_dz = p_dz.threepoint_O2nd_deriv(pdim, bc, z) / p
+        pi_dz_p_p_dz.long_name = "1/p del_z (p del_z #{gphys.name})"
+        pi_dz_p_p_dz
+      end
+
+    end
+  end
+
+  class GPhys
+    # Convert the pressure coordinate in self to log-pressure height (after duplicating self)
+    # 
+    # Return value: a GPhys
+    def logp_coord_p2z(pdim=nil)
+      pdim = GAnalysis::Met.find_prs_d(self) if !pdim
+      p = self.coord(pdim)
+      z = GAnalysis::LogP.p2z(p)
+      ax = self.axis(pdim).copy
+      ax.set_pos(z)
+      ax.name = z.name
+      grid = self.grid.copy.set_axis(pdim, ax)
+      GPhys.new(grid,self.data)
+    end
+
+  end
+end
+
+
+########################################
+##### test part ######
+if $0 == __FILE__
+  require "numru/ggraph"
+  include NumRu
+  u = GPhys::IO.open("../../../testdata/UV.jan.nc","U")
+  u2 = u.logp_coord_p2z
+  p u2.axnames
+  puts u2.coord(2).units
+  DCL.swpset('iwidth',1000)
+  DCL.swpset('iheight',500)
+  DCL.gropn(4)
+  DCL.sldiv('y',2,1)
+  DCL.sgpset('isub', 96)      # control character of subscription: '_' --> '`'
+  DCL.glpset('lmiss',true)
+  GGraph.contour u2[0,false]
+  u_zz = GAnalysis::LogP.pcdata_pi_dz_p_dz(u[0,false])
+  GGraph.tone u_zz
+  GGraph.contour u[0,false], false
+  GGraph.color_bar
+  puts u2.units, u_zz.units
+
+  #sig = (u.axis(2).to_gphys / GAnalysis::LogP::P00).convert_units("1")
+  z = GAnalysis::LogP.p2z(u.axis(2).to_gphys)
+  p z.val
+  y = u[0,false] * 0 - z
+  y_zz = GAnalysis::LogP.pcdata_pi_dz_p_dz(y)
+  GGraph.line y_zz[0,false], true, "exchange"=>true
+  GGraph.color_bar
+
+  DCL.grcls
+end

data/lib/numru/ganalysis/met.rb

@@ -5,6 +5,16 @@ require 'numru/ganalysis/planet'
 
 module NumRu
 
+  class GPhys
+    for f in %w!temp2theta interpolate_onto_theta z2geostrophic_wind q2r r2q r2e e2r q2e e2q lat e_sat rh2e theta_e theta_es!
+      eval <<-EOS
+        def #{f}(*args)
+          GAnalysis::Met.#{f}(self,*args)
+        end
+      EOS
+    end
+  end
+
   module GAnalysis
 
     # Meteorological analysis
@@ -133,7 +143,7 @@ module NumRu
       #   potential temperature values (Kelvin) on which PV is derived.
       #   
       # RETURN VALUE
-      # * potential temperature [GPhys] on a theta coordinate, where
+      # * potential voticity [GPhys] on a theta coordinate, where
       #   levels are set to theta_levs
       def pv_on_theta(u, v, theta, theta_levs)
         sigi = GAnalysis::Met.sigma_inv(theta)
@@ -147,6 +157,40 @@ module NumRu
         pv
       end
 
+      # Derive Ertel's potential vorticity on the pressure
+      # coordinate
+      #
+      #
+      # ARGUMENTS
+      # * u [GPhys] : zonal wind on pressure coordinate 
+      #   (u, v, and theta must share same coordinates)
+      # * v [GPhys] : meridional wind on pressure coordinate
+      # * theta [GPhys] : potential temperature on pressure coordinate
+      #   
+      # RETURN VALUE
+      # * potential vorticity [GPhys] on the same grid as the inputs
+      #
+      def pv_on_p(u, v, theta)
+        up,vp,thp = del_ngp(u,v,theta)    # -g del/del p
+        pv = Planet.absvor_s(u, v) * thp \
+             - vp * Planet.grad_sx(theta) \
+             + up * Planet.grad_sy(theta)
+        pv.long_name = "potential vorticity"
+        pv.name = "PV"
+        pv.units = pv.units.reduce5    # express in the MKS fundamental units
+        pv
+      end
+
+      # -g del/del p
+      def del_ngp(*gps)  # gps: array of GPhys objects having the same grid
+        d = find_prs_d(gps[0])
+        prs = gps[0].coord(d).convert_units(Units["Pa"])
+        dngps = gps.collect{|gp|
+          gp.threepoint_O2nd_deriv(d,Derivative::LINEAR_EXT,prs) * (-@@g)
+        }
+      end
+      private :del_ngp
+
       # Derive geostrophic wind from geopotential hight (spherical but fixed f)
       # 
       # ARGUMENTS
@@ -194,7 +238,7 @@ module NumRu
       # Here, the 2nd line (vertical advection) is optional;
       # [vx, vy] = gradH v; [thetax, thetay] = gradH theta;
       # [ux, uy] = cos_phi * gradH (u/cos_phi)
-      # va = v/tan_phi/a (a=radius).
+      # va = v*tan_phi/a (a=radius).
       # z and w is the vertical coordinate and the lagrangian
       # "velocity" in that coordinate --- Typically they are
       # p and omega, or log-p height and log-p w.
@@ -405,6 +449,327 @@ module NumRu
         dfdz / x
       end
 
+      ##### moist thermodynamics ###
+      
+      @@consider_ice = true
+      @@ice_thres = T0    # Celcius
+
+      # whether or not ice is considered in the water phase change
+      def consider_ice
+        @@consider_ice
+      end
+
+      # set whether or not ice is considered in the water phase change
+      def consider_ice=(t_or_f)
+        @@consider_ice=t_or_f
+      end
+
+      # the threshold temperature for liquid/ice-phase treatment
+      def ice_thres
+        @@ice_thres
+      end
+
+      # set the threshold temperature for liquid/ice-phase treatment (default: O degC)
+      def ice_thres=(temp)
+        @@ice_thres=temp
+      end
+
+      # specific humidity -> mixing ratio
+      #
+      # ARGUMENTS
+      # * q:  specific humidty
+      # 
+      # RETURN VALUE
+      # * r:  mixing ratio
+      def q2r(q)
+        r = q/(1.0-q)
+        r.name = "r"
+        r.long_name = "mixing ratio"
+        r
+      end
+
+      # mixing ratio -> specific humidity
+      #
+      # ARGUMENTS
+      # * r:  mixing ratio
+      # 
+      # RETURN VALUE
+      # * q:  specific humidty
+      def r2q(r)
+        q = r/(1.0+r)
+        q.name = "q"
+        q.long_name = "specific humidity"
+        q
+      end
+
+      # water vapor mixing ratio -> water vapor pressure
+      #
+      # ARGUMENTS
+      # * r:  water vapor mixing ratio
+      # * prs:  pressure
+      # 
+      # RETURN VALUE
+      # * e:  water vapor pressure
+      def r2e(r,prs=nil)
+        prs = get_prs(r) if !prs
+        prs = convert_units2Pa(prs)
+        rratio = R / Rv
+        e = prs*r/(rratio+r)     # water vapor pertial pressure
+        e.name = "e"
+        e.long_name = "water vapor pressure"
+        e
+      end
+
+      # water vapor pressure -> mixing ratio 
+      #
+      # ARGUMENTS
+      # * e:  water vapor pressure
+      # * prs:  pressure
+      # 
+      # RETURN VALUE
+      # * r:  mixing ratio
+      def e2r(e,prs=nil)
+        prs = get_prs(e) if !prs
+        prs = convert_units(prs,e.units)
+        rratio = R / Rv
+        r = rratio * e / (prs-e)
+        r.name = "r"
+        r.long_name = "mixing ratio"
+        r
+      end
+
+      # specific humidity -> water vapor pressure
+      #
+      # ARGUMENTS
+      # * q:  specific humidity[g/g]
+      # * prs:  pressure[hPa]
+      # 
+      # RETURN VALUE
+      # * e:  water vapor pressure
+      def q2e(q,prs=nil)
+        prs = get_prs(q) if !prs
+        prs = convert_units2Pa(prs)
+	rratio = R / Rv
+	e = prs*q/(rratio+(1-rratio)*q)     # water vapor pertial pressure
+        e.name = "e"
+        e.long_name = "water vapor pressure"
+        e
+      end
+
+      # water vapor pressure -> specific humidity
+      #
+      # ARGUMENTS
+      # * e:  water vapor pressure
+      # * prs:  pressure
+      # 
+      # RETURN VALUE
+      # * q: specific humidity
+      def e2q(e,prs=nil)
+        prs = get_prs(e) if !prs
+        prs = convert_units(prs,e.units)
+	rratio = R / Rv
+	q = rratio * e / (prs-(1-rratio)*e) 
+        q.name = "q"
+        q.long_name = "specific humidity"
+        q
+      end
+
+      # temperature --> latent heat [J.kg-1]
+      #
+      # good for -100<T<50
+      #
+      # ARGUMENTS
+      # * temp: temperature
+      # 
+      # RETURN VALUE
+      # * lat: latent heat
+      def lat(temp)
+        tempK = temp.convert_units("K")
+        lat = Lat0*(T0/tempK)**(0.167+tempK.val*3.67E-4) 
+        lat.name = "L"
+        lat.long_name = "Latent heat"
+        lat
+      end
+
+      # Bolton formula for saturation water vapor pressure against water
+      #
+      # ARGUMENTS
+      # * temp: temperature
+      # 
+      # RETURN VALUE
+      # * es: saturation water vapor pressure [Pa]
+      def e_sat_bolton(temp)
+        tempC = temp.convert_units("degC")
+        es = UNumeric[6.112e2,"Pa"] * 
+          Misc::EMath.exp( 17.67 * tempC / (tempC + UNumeric[243.5,"degC"] ) )
+        es.name = "e_sat"
+        es.long_name = "e_sat_water bolton"
+        es
+      end
+
+      # saturation water vapor pressure against ice. 
+      #
+      # Emanuel (1994) eq.(4.4.15)
+      #
+      # ARGUMENTS
+      # * temp: temperature
+      # 
+      # RETURN VALUE
+      # * es: saturation water vapor pressure [Pa]
+      def e_sat_emanuel_water(temp, mask=nil)
+        es = temp.copy
+        tempK = temp.convert_units("K").val   # units removed
+        tempK = tempK[mask] if mask
+        e = 53.67957 - 6743.769/tempK \
+             - 4.8451 * Misc::EMath.log(tempK)
+        if !mask
+          es.replace_val( Misc::EMath.exp(e) * 100.0 )
+        else
+          es[false] = 0
+          es[mask] = Misc::EMath.exp(e) * 100.0
+        end
+        es.units = "Pa"
+        es.name = "e_sat_ice"
+        es.long_name = "e_sat_ice emanuel"
+        es
+      end
+
+      # Saturation water vapor pressure against ice.
+      #
+      # Emanuel (1994) eq.(4.4.15)
+      #
+      # ARGUMENTS
+      # * temp: temperature
+      # 
+      # RETURN VALUE
+      # * es: saturation water vapor pressure [Pa]
+      def e_sat_emanuel_ice(temp, mask=nil)
+        es = temp.copy
+        tempK = temp.convert_units("K").val   # units removed
+        tempK = tempK[mask] if mask
+        e = 23.33086 - 6111.72784/tempK \
+             + 0.15215 * Misc::EMath.log(tempK)
+        if !mask
+          es.replace_val( Misc::EMath.exp(e) * 100.0 )
+        else
+          es[false] = 0
+          es[mask] = Misc::EMath.exp(e) * 100.0
+        end
+        es.units = "Pa"
+        es.name = "e_sat_ice"
+        es.long_name = "e_sat_ice emanuel"
+        es
+      end
+
+      # Selector of the formulat to compute saturation water vapor pressure against water (default: Bolton)
+      # 
+      # ARGUMENTS
+      # * formula: nil(default), "bolton", "emanuel"
+      # 
+      # RETURN VALUE
+      # * nil
+      def set_e_sat_water(formula=nil)
+        case formula
+        when nil,"bolton"
+          alias :e_sat_water :e_sat_bolton
+        when "emanuel"
+          alias :e_sat_water :e_sat_emanuel_water
+          module_function :e_sat_water
+        end
+        nil
+      end
+      set_e_sat_water
+      module_function :e_sat_water
+
+      # currently, only a single formula is avilable for ice
+      alias  :e_sat_ice :e_sat_emanuel_ice
+      module_function :e_sat_ice
+
+      # Calculates saturation water vapor pressure using enhanced 
+      #
+      # ARGUMENTS
+      # * temp: temperature
+      # 
+      # RETURN VALUE
+      # * es: saturation water vapor pressure
+      def e_sat(temp)
+
+        ice = @@consider_ice && ( temp.lt(@@ice_thres) )
+        #ice = ice.to_na
+        water = !@@consider_ice || ( (ice==true||ice==false) ? !ice : ice.not)
+
+        if water
+          es = e_sat_water(temp)
+        end
+
+        case ice
+        when true
+          es = e_sat_ice(temp)
+        when NArray, NArrayMiss 
+          es[ice] = e_sat_ice(temp,ice).val[ice]
+        end
+        es.name = "e_sat"
+        es.long_name = "e_sat"
+        es
+      end
+
+      # relative humidity -> water vapor pressure
+      #
+      # ARGUMENTS
+      # * rh: relative humidity
+      # * temp: temperature
+      # 
+      # RETURN VALUE
+      # * e: water vapor pressure
+      def rh2e(rh,temp)
+        es = e_sat(temp)
+        rh = rh.convert_units("1")
+        e = es * rh
+        e.name = "e"
+        e.long_name = "water vapor pressure"
+        e
+      end
+
+      # Derive equivalent potential temperature
+      # 
+      # ARGUMENTS
+      # * temp [GPhys] : temperature (ok whether degC or K)
+      # * q [GPhys] : specific humidity
+      # * prs [GPhys or VArray] : the pressure values. 
+      #   If nil, searched from coordinates (for data on
+      #   the pressure coordinate)
+      # 
+      # RETURN VALUE
+      # * theta_e: equivalent potential temperature
+      def theta_e(temp,q,prs=nil)
+        tempK = temp.convert_units("K")
+        theta = temp2theta(tempK, prs)
+        theta_e = theta * Misc::EMath.exp( lat(tempK)*q/(Cp*tempK) )
+        theta_e.name = "theta_e"
+        theta_e.long_name = "equivalent potential temperature"
+        theta_e
+      end
+
+      # Derive the saturation equivalent potential temperature
+      # 
+      # ARGUMENTS
+      # * temp [GPhys] : temperature (ok whether degC or K)
+      # * prs [GPhys or VArray] : the pressure values. 
+      #   If nil, searched from coordinates (for data on
+      #   the pressure coordinate)
+      # 
+      # RETURN VALUE
+      # * theta_es: saturation equivalent potential temperature
+      def theta_es(temp,prs=nil)
+        tempK = temp.convert_units("K")
+        theta = temp2theta(tempK, prs)
+        q = e_sat(temp).e2q(prs)
+        theta_e = theta * Misc::EMath.exp( lat(tempK)*q/(Cp*tempK) )
+        theta_e.name = "theta_es"
+        theta_e.long_name = "theta_e sat"
+        theta_e
+      end
+
     end
   end
 end
@@ -473,6 +838,35 @@ if $0 == __FILE__
   GGraph::tone pv.cut("theta"=>320),true,"nlev"=>20,"color_bar"=>true
   GGraph::tone pv.cut("theta"=>600),true,"nlev"=>20,"color_bar"=>true
 
+
+  #< moist thermo > 
+  DCL.grfrm
+
+  GGraph::set_fig "itr"=>2
+
+  sel = [0,true,0..-4]
+
+  es = temp[*sel].e_sat  
+  # es = GAnalysis::Met.e_sat(temp[*sel])  #  same as temp[*sel].e_sat
+  GGraph::tone es,true,"int"=>2e2,"max"=>4e3,"min"=>0,"tonf"=>true
+  GGraph::contour temp[*sel],false
+  GGraph.color_bar
+
+  GAnalysis::Met.consider_ice=false
+  es2 = temp[*sel].e_sat
+  GGraph::tone( (es2-es)/es,true )
+  GGraph.color_bar
+
+#  GAnalysis::Met.set_e_sat_water("emanuel")
+#  es3 = GAnalysis::Met.e_sat(temp[*sel])
+#  GGraph::tone (es2-es3)/es3,true,"tonf"=>true
+#  GGraph.color_bar
+
+  qs = es.e2r
+  GGraph::tone qs,true,"nlev"=>20
+  GGraph.color_bar
+
   #< finish >
   DCL.grcls
+
 end