gphys 1.1.1 → 1.2.2

data/lib/numru/derivative.rb

@@ -28,13 +28,12 @@ Module functions of Derivative Operater for NArray.
 
 ---threepoint_O2nd_deriv(z, x, dim, bc=LINEAR_EXT)
 
-    Derivate (({z})) respect to (({dim})) th dimension with 2nd Order difference. 
-    return an NArray which result of the difference ((<z>)) divided difference
-    (({x})) (in other wards, 
-     (s**2*z_{i+1} + (t**2 - s**2)*f_{i} - t**2*f_{i-1}) / (s*t*(s + t)):
-     now s represents (x_{i} - x_{i-1}) ,t represents (x_{i+1} - x_{i})
-     and _{i} represents the suffix of {i} th element in the ((<dim>)) th 
-     dimension of array. ).
+    Derivate of (({z})) with respect to (({dim})) th dim using a 2nd 
+    order 3-point differentiation valid for non-uniform grid: 
+      (s**2*z_{i+1} + (t**2 - s**2)*f_{i} - t**2*f_{i-1}) / (s*t*(s + t))
+    Here, s represents (x_{i} - x_{i-1}) ,t represents (x_{i+1} - x_{i})
+    and _{i} represents the suffix of {i} th element in the ((<dim>)) th 
+    dimension of the array. ).
 
     ARGUMENTS
     * z (NArray): a NArray which you want to derivative.
@@ -59,11 +58,28 @@ Module functions of Derivative Operater for NArray.
 
 ---cderiv(z, x, dim, bc=LINEAR_EXT)
 
-    Derivate (({z})) respect to (({dim})) th dimension with center difference. 
-    return an NArray which result of the difference ((<z>)) divided difference
-    (({x})) ( in other wards,  (z_{i+1} - z_{i-1}) / (x_{i+1} - x_{i-1}): 
-    now _{i} represents the suffix of {i} th element in the ((<dim>)) th 
-    dimension of array. ).
+    Derivate of (({z})) with respect to (({dim})) th dim using centeral 
+    differenciation: (z_{i+1} - z_{i-1}) / (x_{i+1} - x_{i-1})
+
+    ARGUMENTS
+    * z (NArray): a NArray which you want to derivative.
+    * x (NArray): a NArray represents the dimension which derivative respect 
+      to. z.rank must be 1.
+    * dim (Numeric): a Numeric represents the dimention which derivative 
+      respect to. you can give number count backward (((<dim>))<0), but 
+      ((<z.rank ��dim>)) must be > 0. 
+    * bc (Numeric) : a Numeric to represent boundary condition.
+      See ((<threepoint_O2nd_deriv>)) for supported conditions.
+
+    RETURN VALUE
+    * cderiv_data (NArray): (z_{i+1} - z_{i-1}) / (x_{i+1} - x_{i-1})
+
+---deriv2nd(z, x, dim, bc=LINEAR_EXT)
+
+    2nd Derivate of (({z})) with respect to (({dim}))-th dim
+    covering non-uniform grids. Based on:
+      ( (z_{i+1}-z_{i})/(x_{i+1}-x_{i}) - (z_{i}-z_{i-1})/(x_{i}-x_{i-1}) )
+      / ((x_{i+1}-x_{i-1})/2)
 
     ARGUMENTS
     * z (NArray): a NArray which you want to derivative.
@@ -169,6 +185,31 @@ module NumRu
       return dzdx
     end
 
+    # 2nd derivative covering uniform grids
+    def deriv2nd(z, x, dim, bc=LINEAR_EXT)
+      dim += z.rank if dim<0
+      if dim < 0 || dim >= z.rank
+        raise ArgumentError,"dim value(#{dim}) must be between 0 and (#{z.rank-1}"
+      end
+      raise ArgumentError,"rank of x (#{x.rank}) must be 1" if x.rank != 1
+      # <<expand boundaries>>
+      ze = b_expand(z,dim,bc)
+      xe = b_expand_linear_ext(x,0)                 # always linear extention
+      # <<differenciation>>
+      to_rankD = [1]*dim + [true] + [1]*(ze.rank-1-dim) # to exand 1D to rank D
+      dx20 = xe[2..-1] - xe[0..-3]          # x_{i+1} - x_{i-1} (for i=1..-2)
+      dx21 = xe[2..-1] - xe[1..-2]          # x_{i+1} - x_{i}   (for i=1..-2)
+      dx10 = xe[1..-2] - xe[0..-3]          # x_{i} - x_{i-1}   (for i=1..-2)
+      a2 = 2/(dx21*dx20).reshape(*to_rankD)
+      a1 = (-2)/(dx21*dx10).reshape(*to_rankD)
+      a0 = 2/(dx10*dx20).reshape(*to_rankD)
+      d2zdx2    =     ze[ *([true]*dim+[2..-1,false]) ] *  a2 \
+                    + ze[ *([true]*dim+[1..-2,false]) ] *  a1 \
+                    + ze[ *([true]*dim+[0..-3,false]) ] *  a0
+      return d2zdx2
+    end
+
+
     def b_expand(z,dim,bc)
       case bc
       when LINEAR_EXT

data/lib/numru/ganalysis/eof.rb

@@ -11,6 +11,10 @@ module NumRu
         require "numru/lapack"
         @@EOF_engin = "lapack"
       rescue LoadError
+        begin
+          require "rubygems"
+        rescue LoadError
+        end
         begin
           require "gsl"
           @@EOF_engin = "gsl"

data/lib/numru/ganalysis/histogram.rb

@@ -154,7 +154,7 @@ module NumRu
     module_function
 
     @@histogram_options = Misc::KeywordOptAutoHelp.new(
-            ['window', [nil,nil,0,nil], "window bounds"],
+            ['window', [nil,nil,nil,nil], "window bounds"],
             ['title', "histogram", "window title"],
             ['exchange', false, "exchange x and y"],
             ['fill', false, "fill bars"]
@@ -170,30 +170,88 @@ module NumRu
       unless gphys.axis(0).cell?
         raise ArgumentError, "axis must be cell type"
       end
+      # 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']
       unless exchange
         x = gphys.axis(0).cell_bounds
         y = gphys
+        window[2] ||= 0
       else
         y = gphys.axis(0).cell_bounds
         x = gphys
+        window[0] ||= 0
       end
+      itr = @@fig['itr'] || DCL::sgpget("itr")
+      if (itr==2 || itr==4)
+        tmp = y.val
+        if tmp.min * tmp.max < 0
+          if tmp.min.abs < tmp.max
+            mask = tmp.lt(0)
+          else
+            mask = tmp.gt(0)
+          end
+        else
+          mask = tmp.ne(0)
+        end
+        if tmp.is_a?(NArrayMiss)
+          tmp.set_mask(mask * tmp.get_mask)
+        else
+          tmp = NArrayMiss.to_nam_no_dup(tmp, mask)
+        end
+        y.replace_val(tmp)
+        window[2] = tmp.abs.min * (tmp.min < 0 ? -1 : 1)
+      end
+      if (itr==3 || itr==4)
+        tmp = x.val
+        if tmp.min * tmp.max < 0
+          if tmp.min.abs < tmp.max
+            mask = tmp.lt(0)
+          else
+            mask = tmp.gt(0)
+          end
+        else
+          mask = tmp.ne(0)
+        end
+        if tmp.is_a?(NArrayMiss)
+          tmp.set_mask(mask * tmp.get_mask)
+        else
+          tmp = NArrayMiss.to_nam_no_dup(tmp, mask)
+        end
+        x.replace_val(tmp)
+        window[0] = tmp.abs.min * (tmp.min < 0 ? -1 : 1)
+      end
+      opts["window"] = window
+
       if newframe
         fig(x, y, "window"=>opts["window"])
         axes(x, y, "title"=>opts["title"])
       end
+      lmiss = DCL::gllget("lmiss")
+      DCL::gllset("lmiss", true)
       unless exchange
         if opts["fill"]
-          DCL::uvbxa(x.val, [0]*y.length, y.val)
+          DCL::uvbxa(x.val, [window[2]] * y.length, y.val)
         end
-        DCL::uvbxf(x.val, [0]*y.length, y.val)
+        if (itr == 2) || (itr == 4)
+          bottom = [y.val.min] * y.length
+        else
+          bottom = [window[2]] * y.length
+        end
+        DCL::uvbxf(x.val, bottom, y.val)
       else
         if opts["fill"]
-          DCL::uhbxa([0]*x.length, x.val, y.val)
+          DCL::uhbxa([window[0]] * x.length, x.val, y.val)
         end
-        DCL::uhbxf([0]*x.length, x.val, y.val)
+        if (itr == 3) || (itr == 4)
+          bottom = [x.val.min] * x.length
+        else
+          bottom = [window[0]] * x.length
+        end
+        DCL::uhbxf(bottom, x.val, y.val)
       end
+      DCL::gllset("lmiss", lmiss)
       return nil
     end
     alias :histogram1D :histogram
@@ -241,6 +299,16 @@ if $0 == __FILE__
   hist = GAnalysis.histogram(gphys1D)
   GGraph.histogram(hist)
 
+  GGraph.set_fig("itr"=>2)
+  GGraph.histogram(hist)
+
+  GGraph.set_fig("itr"=>3)
+  GGraph.histogram(hist)
+
+  GGraph.set_fig("itr"=>4)
+  GGraph.histogram(hist)
+
+  GGraph.set_fig("itr"=>1)
   hist = gphys1D.histogram("nbins"=>10)
   GGraph.histogram(hist, true, "title"=>"histogram 1D")
 

data/lib/numru/ganalysis/met.rb

@@ -95,7 +95,8 @@ module NumRu
         dim = find_prs_d(theta) if !dim
         prs = get_prs(theta) if !prs
         prs = convert_units2Pa(prs)
-        dtheta_dp = df_dx(theta, prs, dim)
+        #dtheta_dp = df_dx(theta, prs, dim)
+        dtheta_dp = df_dx_vialogscale(theta, prs, dim)
         sig_inv = dtheta_dp * (-@@g)
         if sig_inv.respond_to?(:long_name)  # VArray or GPhys
           sig_inv.name = "sig_inv"
@@ -134,7 +135,7 @@ module NumRu
       # RETURN VALUE
       # * potential temperature [GPhys] on a theta coordinate, where
       #   levels are set to theta_levs
-     def pv_on_theta(u, v, theta, theta_levs)
+      def pv_on_theta(u, v, theta, theta_levs)
         sigi = GAnalysis::Met.sigma_inv(theta)
         uth = GAnalysis::Met.interpolate_onto_theta(u, theta, theta_levs)
         vth = GAnalysis::Met.interpolate_onto_theta(v, theta, theta_levs)
@@ -146,6 +147,154 @@ module NumRu
         pv
       end
 
+      # Derive geostrophic wind from geopotential hight (spherical but fixed f)
+      # 
+      # ARGUMENTS
+      # * z [GPhys] : geopotential height on the pressure (or log-pressure)
+      #   coordinate
+      # * f [nil or Numeric of UNumeric] : the constant f value 
+      #   (Coriolis parameter).
+      #   If nil, the value at the north pole is assumed.
+      #   If Numeric, units are assumed to be "s-1".
+      #
+      def z2geostrophic_wind(z, f=nil)
+        if f.nil?
+          f = 2 * GAnalysis::Planet.omega
+        elsif f.is_a?(Numeric)
+          f = UNumeric[f,"s-1"]
+        end
+        z = z.convert_units("m")
+        gx, gy = GAnalysis::Planet.grad_s( z * (g/f) )
+        u = -gy
+        v = gx
+        u.name = "u"
+        u.long_name = "geostrophic U"
+        u.put_att("assumed_f",f.to_s)
+        v.name = "v"
+        v.long_name = "geostrophic V"
+        v.put_att("assumed_f",f.to_s)
+        [u, v]
+      end
+
+      # Adiabatic frontogenesis function over the sphere. --
+      # D/Dt(|gradH theta|) or D/Dt(|gradH theta|^2), where gradH express
+      # the horizontal component of gradient. 
+      # 
+      # if full_adv is true (default),
+      #  D/Dt(|gradH theta|) = 
+      #    [ -(ux-va)*thetax^2 - (vx+uy)*thetax*thetay - vy*thetay^2
+      #      - (wx*thetax + wy*thetay)*theta_z ]
+      #    / |gradH theta|
+      # or else,
+      #  (\del/\del t + u gradx + v grady )(|gradH theta|) = 
+      #    [ -(ux-va)*thetax^2 - (vx+uy)*thetax*thetay - vy*thetay^2
+      #      - (w*theta_z)_x*thetax - (w*theta_z)_y*thetay ]
+      #    / |gradH theta|
+      # 
+      # 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).
+      # 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.
+      # 
+      # This formulation is adiabatic; the diabatic heating effect
+      # can be easily included if needed.
+      # 
+      # ARGUMENTS
+      # * theta [GPhys] : potential temperature
+      # * u [GPhys] : zonal wind
+      # * v [GPhys] : meridional wind
+      # * w [nil (default) or GPhys] : (optional) "vertical wind", which must
+      #   be dimensionally consistent with the vertical coordiante 
+      #   (e.g., omega for the pressure coordinate). 
+      #   If w is given, the vertical cooridnate is assumed to be
+      #   the 3rd one (dim=2).
+      # * fstodr [true (default) or false] (optional) if true 
+      #   D/Dt(|\NablaH theta|) returned; if false D/Dt(|\NablaH theta|^2)
+      #   is returned.
+      # * full_adv [true (default) or false] : whether to calculate
+      #   full lagrangian tendency or lagragian tendency only in 
+      #   horizontal direction
+      # 
+      # RETURN VALUE
+      # * frontogenesis function [GPhys]
+      # 
+      def frontogenesis_func(theta, u, v, w=nil, fstodr=true, full_adv = true)
+        thx, thy = GAnalysis::Planet.grad_s( theta )
+        ux = GAnalysis::Planet.grad_sx( u )
+        uy = GAnalysis::Planet.grad_sy_cosphifact( u, -1 )
+        vx, vy =  GAnalysis::Planet.grad_s( v )
+        va = GAnalysis::Planet.weight_tanphi( v, 1, -1 )
+        frgf = - (ux-va)*thx*thx - (vx+uy)*thx*thy - vy*thy*thy
+        frgf.name = "frgen"
+        frgf.long_name = "frontogenesis function"
+        if w 
+          zdim = 2
+          if (wun=w.units) !~ (ztun = theta.coord(zdim).units * Units["s-1"])
+            raise "w in #{wun} is inconsistent with the vertical coordinate of theta in #{ztun}"
+          else
+            w = w.convert_units(ztun)    # For example, Pa/s -> hPa/s
+          end
+          z = theta.axis(zdim).to_gphys
+          if z.units =~ Units["Pa"]
+            thz = df_dx_vialogscale(theta, z, zdim)
+          else
+            thz = df_dx(theta, z, zdim)
+          end
+          if full_adv
+            # full lagragian tendency of theta-gradient strength
+            wx,  wy =  GAnalysis::Planet.grad_s( w ) 
+            frgf -= (wx*thx + wy*thy)*thz
+          else
+            # lagragian tendency only in horizontal direction
+            wthzx,  wthzy =  GAnalysis::Planet.grad_s( w*thz ) 
+            frgf -= wthzx*thx + wthzy*thy
+          end
+        end
+        if fstodr
+          frgf /= (thx**2 + thy**2).sqrt 
+        else
+          frgf *= 2
+        end
+        frgf
+      end
+
+=begin
+      def frontogenesis_eulerian(theta, u, v, w=nil, fstodr=true )
+        thx, thy = GAnalysis::Planet.grad_s( theta )
+        uthxx,  uthxy =  GAnalysis::Planet.grad_s( u*thx )
+        vthyx,  vthyy =  GAnalysis::Planet.grad_s( v*thy )
+        va = GAnalysis::Planet.weight_tanphi( v, 1, -1 )
+        frgf = - (uthxx+vthyx)*thx - (uthxy+vthyy)*thy
+        frgf.name = "thgrd_tend"
+        frgf.long_name = "Eluerian grad-theta tendency"
+        if w 
+          zdim = 2
+          if (wun=w.units) !~ (ztun = theta.coord(zdim).units * Units["s-1"])
+            raise "w in #{wun} is inconsistent with the vertical coordinate of theta in #{ztun}"
+          else
+            w = w.convert_units(ztun)    # For example, Pa/s -> hPa/s
+          end
+          z = theta.axis(zdim).to_gphys
+          if z.units =~ Units["Pa"]
+            thz = df_dx_vialogscale(theta, z, zdim)
+          else
+            thz = df_dx(theta, z, zdim)
+          end
+          wthzx,  wthzy =  GAnalysis::Planet.grad_s( w*thz ) 
+          frgf -= wthzx*thx + wthzy*thy
+        end
+        if fstodr
+          frgf /= (thx**2 + thy**2).sqrt 
+        else
+          frgf *= 2
+        end
+        frgf
+      end
+=end
+
       # Find a pressure coordinate in a GPhys object
       # 
       # ARGUMENT
@@ -244,6 +393,18 @@ module NumRu
       end
       private :df_dx   # this method should be defined somewhere else
 
+      def df_dx_vialogscale(f, x, dim)
+        z = Misc::EMath.log(x)
+        if GPhys === f
+          mdl = NumRu::GPhys::Derivative
+          dfdz = mdl.threepoint_O2nd_deriv(f, dim, mdl::LINEAR_EXT, z)
+        else
+          mdl = NumRu::Derivative
+          dfdz = mdl.threepoint_O2nd_deriv(f, z, dim, mdl::LINEAR_EXT)
+        end
+        dfdz / x
+      end
+
     end
   end
 end