gphys 1.5.5 → 1.5.7

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)

data/lib/numru/ggraph.rb

@@ -788,9 +788,9 @@ library if you like.
        "interval"    nil     # contour interval
        "nozero"      nil     # delete zero contour
        "coloring"    false   # set color contours with ud_coloring
-       "clr_min"     13      # (if coloring) minimum color number for the
+       "clr_min"     nil      # (if coloring) minimum color number for the
                              # minimum data values
-       "clr_max"     99      # (if coloring) maximum color number for the
+       "clr_max"     nil      # (if coloring) maximum color number for the
                              # maximum data values
        "help"        false   # show help message if true
        "log"	     nil     # approximately log-scaled levels (by using
@@ -919,6 +919,10 @@ library if you like.
        "color_bar"   false   # Add a color bar: THIS IS ONLY FOR QUICK
                              # LOOK. Use the GGraph::color_bar method explicitly
                              # for full option control
+       "cbunits"     nil     # [nil or true or String] if non nil, shows units
+                             # in color_bar using the specified string or, when
+                             # true, the units of the argument
+                             # using the specified string or, if true, the units of the argument
        "min"         nil     # minimum tone level
        "max"         nil     # maximum tone level
        "nlev"        nil     # number of levels
@@ -1588,6 +1592,7 @@ module NumRu
       ['title',   nil,  'Title of the figure'],
       ['xunits',  nil,  'Units of x axis (if nil, internally determined)'],
       ['yunits',  nil,  'Units of y axis (if nil, internally determined)'],
+      ['format_units', true, 'Format unit expressions for DCL, e.g. m.s-1 -> m s\^{-1}'],
       ['xtickint',  nil,
             'Interval of x axis tickmark (if nil, internally determined)'],
       ['ytickint',  nil,
@@ -1641,16 +1646,27 @@ module NumRu
       ts = [t0,t1].min
       time = UNumeric.new(ts,sunits)
       tstr = time.to_datetime(0.1,calendar)
-      jd0 = tstr.strftime('%Y%m%d').to_i
+      #jd0 = tstr.strftime('%Y%m%d').to_i
       tlen = tun.convert( t1-t0, dayun ).abs
       axtype ||= (tlen < 5) ? 'h' : 'ymd'
       reverse = t1 < t0
+      if axtype == 'h'
+        dh = 0.0
+      else
+        tstr0 = tstr.to_date
+        dh = tstr - tstr0
+        if dh>1e-2  # << 1 な適当な小さな数
+          dh -= 1.0
+          tstr0 += 1.0
+        end
+        tend0 = (tstr+tlen).to_date
+      end
 
       if xax
         unless(reverse)
-          DCL.grswnd(0.0, tlen, window[2], window[3] )
+          DCL.grswnd(dh, tlen+dh, window[2], window[3] )
         else
-          DCL.grswnd(tlen, 0.0, window[2], window[3] )
+          DCL.grswnd(tlen+dh, dh, window[2], window[3] )
         end
         DCL.grstrf
         opts = {'cside'=>side}
@@ -1659,14 +1675,14 @@ module NumRu
         if axtype == 'h'
           DCLExt.datetime_ax(tstr, tstr+tlen, opts )
         else
-          DCLExt.date_ax(tstr, tstr+tlen, opts )
+          DCLExt.date_ax(tstr0, tend0, opts )
           ## DCL.ucxacl(side,jd0,tlen)  #Old: use it again if UCPACK is improved
         end
       else
         unless(reverse)
-          DCL.grswnd(window[0], window[1], 0.0, tlen)
+          DCL.grswnd(window[0], window[1], dh, tlen+dh)
         else
-          DCL.grswnd(window[0], window[1], tlen, 0.0)
+          DCL.grswnd(window[0], window[1], tlen+dh, dh)
         end
         DCL.grstrf
         opts = {'yax'=>true, 'cside'=>side}
@@ -1675,7 +1691,7 @@ module NumRu
         if axtype == 'h'
           DCLExt.datetime_ax(tstr, tstr+tlen, opts )
         else
-          DCLExt.date_ax(tstr, tstr+tlen, opts )
+          DCLExt.date_ax(tstr0, tend0, opts )
           ## DCL.ucyacl(side,jd0,tlen)  #Old: use it again if UCPACK is improved
         end
       end
@@ -1721,6 +1737,7 @@ module NumRu
                 	   opts['xtickint'], opts['xlabelint'])
             end
           else
+            sunits = DCLExt.format_units(sunits) if opts['format_units']
             DCL.uscset('cxttl', (opts['xtitle'] || xai['title']) )
             DCL.uscset('cxunit', sunits)
             DCL.uspset('dxt', opts['xtickint'])  if(opts['xtickint'])
@@ -1760,6 +1777,7 @@ module NumRu
                 	   opts['ytickint'], opts['ylabelint'])
             end
           else
+            sunits = DCLExt.format_units(sunits) if opts['format_units']
             DCL.uscset('cyttl', (opts['ytitle'] || yai['title']) )
             DCL.uscset('cyunit', sunits )
             DCL.uspset('dyt', opts['ytickint'])  if(opts['ytickint'])
@@ -2112,6 +2130,7 @@ module NumRu
       ['step_plot', false, 'If true, draw stair step plot (piecewise constant line plot).'],
       # ['step_extend_ends', false, 'If true, extend both ends of stair step plot.'], # NOT YET IMPLEMENTED
       ['step_position', 0, 'Data point will be at the right corner of each step if negative, center if 0, and left corner if positive.'],
+      ['proc_before_ax', nil, 'Proc (with no argument) to be called just before drawing the axes.'],
       @@data_prep_options
     )
 
@@ -2154,6 +2173,9 @@ module NumRu
       x, y, closer, gp, window = data_prep_1D(gphys, opts)
       if newframe
         fig(x, y, {'window'=>window})
+        if opts['proc_before_ax']
+          opts['proc_before_ax'].call
+        end
         axes_or_map_and_ttl(gp, opts, x, y)
       end
 
@@ -2245,6 +2267,7 @@ module NumRu
       ['legend_vy', nil, '(effective if legend) viewport y value of the legend (Float; or nil for automatic settting)'],
       ['legend_size', nil, '(effective if legend) character size of the legend'],
       ['map_axes', false, '[USE IT ONLY WHEN itr=10 (cylindrical)] If true, draws axes by temprarilly switching to itr=1 and calling GGraph::axes.'],
+      ['proc_before_ax', nil, 'Proc (with no argument) to be called just before drawing the axes.'],
       @@data_prep_options
         )
 
@@ -2275,6 +2298,9 @@ module NumRu
       x, y, closer, gp, window = data_prep_1D(gphys, opts, len1ok: true)
       if newframe
         fig(x, y, {'window'=>window})
+        if opts['proc_before_ax']
+          opts['proc_before_ax'].call
+        end
         axes_or_map_and_ttl(gp, opts, x, y)
       end
       DCL.uumrkz(x.val, y.val, opts['type'], opts['index'], opts['size'])
@@ -2298,8 +2324,8 @@ module NumRu
       ['interval', nil,       'contour interval'],
       ['nozero',   nil,       'delete zero contour'],
       ['coloring', false,     'set color contours with ud_coloring'],
-      ['clr_min',  13,        '(if coloring) minimum color number for the minimum data values'],
-      ['clr_max',  99,       '(if coloring) maximum color number for the maximum data values']
+      ['clr_min',  nil,        '(if coloring) minimum color number for the minimum data values (nil -> uepack parameter icolor1)'],
+      ['clr_max',  nil,       '(if coloring) maximum color number for the maximum data values  (nil -> uepack parameter icolor2)']
     )
     def set_linear_contour_options(options)
       @@linear_contour_options.set(options)
@@ -2497,9 +2523,21 @@ module NumRu
 
     def tone_and_contour(gphys, newframe=true, options=nil)
       options ? copt=@@contour_options.select_existent(options) : copt=nil
-      options ? topt=@@tone_options.select_existent(options) : topt=nil
+      options ? topt=@@tone_options.select_existent(options) : topt=Hash.new
+      topt = @@tone_options.interpret(topt)
+      cbar = topt["color_bar"]
+      topt["color_bar"]=false if cbar  # color bar will be plotted after contour
       tone(gphys, newframe, topt)
       contour(gphys, false, copt)
+      if cbar
+        cbunits = topt['cbunits']
+        cbunits = gphys.units.to_s if cbunits==true
+        if @@used_fullcolor_tone
+          color_bar "units"=>cbunits
+        else
+          color_bar "log"=>topt['log'], "units"=>cbunits
+        end
+      end
     end
 
     @@contour_levels =  Misc::KeywordOptAutoHelp.new(
@@ -2549,6 +2587,7 @@ module NumRu
       ['annotate', true, 'if false, do not put texts on the right margin even when newframe==true'],
       ['map_axes', false, '[USE IT ONLY WHEN itr=10 (cylindrical)] If true, draws axes by temprarilly switching to itr=1 and calling GGraph::axes.'],
       ['keep', false, 'Use the contour levels used previously'],
+      ['proc_before_ax', nil, 'Proc (with no argument) to be called just before drawing the axes.'],
       @@linear_contour_options,
       @@contour_levels,
       @@data_prep_options
@@ -2645,8 +2684,9 @@ module NumRu
       xax, yax, closer, gp = data_prep_2D([gphys], newframe, opts)
       if newframe
         fig(xax, yax)
-      end
-      if newframe
+        if opts['proc_before_ax']
+          opts['proc_before_ax'].call
+        end
         axes_or_map_and_ttl(gp,opts, xax, yax)
       end
       if !opts['keep'] or DCL.udqcln==0
@@ -2776,6 +2816,9 @@ module NumRu
       ['map_axes', false, '[USE IT ONLY WHEN itr=10 (cylindrical)] If true, draws axes by temprarilly switching to itr=1 and calling GGraph::axes.'],
       ['keep', false, 'Use the tone levels and patterns used previously'],
       ['color_bar', false, 'Add a color bar: THIS IS ONLY FOR QUICK LOOK. Use the GGraph::color_bar method explicitly for full option control'],
+      ['cbunits', nil, '[nil or true or String] if non nil, shows units in color_bar using the specified string or, when true, the units of the argument'],
+      ['proc_before_ax', nil, 'Proc (with no argument) to be called just before drawing the axes.'],
+      ['proc_before_tone', nil, 'Proc (with no argument) to be called just before plotting tone.'],
       @@linear_tone_options,
       @@tone_levels,
       @@fullcolor_tone_options,
@@ -2812,6 +2855,10 @@ module NumRu
       if newframe
         fig(xax, yax)
       end
+      if opts['proc_before_tone']
+        opts['proc_before_tone'].call
+      end
+
       DCL.uwsgxa(xax.val) if xax.rank==1
       DCL.uwsgya(yax.val) if yax.rank==1
       if !opts['keep'] or DCL.ueqntl==0
@@ -2839,11 +2886,7 @@ module NumRu
 
       @@used_fullcolor_tone = false
       val = gp.data.val
-      if ( opts['ltone'] && 
-          ( opts['tonf'] || opts['auto'] && !opts['tonb'] && !opts['tonc'] &&
-            ( val.length >= TONE_TONF_THRES_SIZE || val.shape.min >= TONE_TONF_THRES_LEN ) ) )
-        DCL.uetonf(val)
-      elsif opts['fullcolor']
+      if opts['fullcolor']
         @@used_fullcolor_tone = true
         sopt = opts.dup.delete_if{|k,v| !DCLExt.shade_1_option_keys.include?(k)}
         DCLExt.ui_shade_1(val, sopt)
@@ -2851,21 +2894,31 @@ module NumRu
         DCL.uetonb(val)
       elsif opts['tonc'] && opts['ltone']
         DCL.uetonc(val)
+      elsif ( opts['ltone'] && 
+              ( opts['tonf'] ||
+                opts['auto']  && ( val.length >= TONE_TONF_THRES_SIZE ||
+                                   val.shape.min >= TONE_TONF_THRES_LEN ) ) )
+        DCL.uetonf(val)
       else
         DCL.uetone(val)
       end
 
       if newframe
+        if opts['proc_before_ax']
+          opts['proc_before_ax'].call
+        end
         axes_or_map_and_ttl(gp,opts, xax, yax)
       end
       DCL.uepset('icolor1', icolor1_bak) if opts['clr_min']
       DCL.uepset('icolor2', icolor2_bak) if opts['clr_max']
 
       if opts['color_bar']
+        cbunits = opts['cbunits']
+        cbunits = gphys.units.to_s if cbunits==true
         if @@used_fullcolor_tone
-          color_bar
+          color_bar "units"=>cbunits
         else
-          color_bar "log"=>opts['log']
+          color_bar "log"=>opts['log'], "units"=>cbunits
         end
       end
       closer.call if closer
@@ -2882,6 +2935,7 @@ module NumRu
       ['size', 0.01, 'marks size'],
       ['map_axes', false, '[USE IT ONLY WHEN itr=10 (cylindrical)] If true, draws axes by temprarilly switching to itr=1 and calling GGraph::axes.'],
       ['correlation', false, 'calculate Pearson\'s correlation coefficient and show it on the bottom margin'],
+      ['proc_before_ax', nil, 'Proc (with no argument) to be called just before drawing the axes.'],
       @@data_prep_options
         )
     ## @@scatter_options.delete("transpose")   # delete is yet to be supported
@@ -2931,6 +2985,9 @@ module NumRu
       y = gpy.data
       if newframe
         fig(x, y)
+        if opts['proc_before_ax']
+          opts['proc_before_ax'].call
+        end
         axes_or_map_and_ttl(gpx, opts, x, y, gpy)
       end
       DCL.uumrkz(x.val, y.val, opts['type'], opts['index'], opts['size'])
@@ -3151,6 +3208,7 @@ module NumRu
       ['keep', false, 'Use the same vector scaling as in the previous call. -- Currently, works only when "flow_vect" is true'],
       ['factor', 1.0, '(Effective only if flow_vect) scaling factor to strech/reduce the arrow lengths'],
       ['unit_vect', false, 'Show the unit vector'],
+      ['uvunits', false, 'units in the unit vector (false: never, true: read from the GPhys; a String: use that'],
       ['max_unit_vect', false, '(Effective only if flow_vect && unit_vect) If true, use the maximum arrows to scale the unit vector; otherwise, normalize in V coordinate.'],
       ['ux_unit', nil, '(If Numeric) length of the x direction unit vector (precedence of this option is lower than max_unit_vect)'],
       ['uy_unit', nil, '(If Numeric) length of the y direction unit vector (precedence of this option is lower than max_unit_vect)'],
@@ -3199,6 +3257,20 @@ module NumRu
 
       oldindex = DCLExt.ug_set_params("index" => opts['index']) if opts['index']
 
+      if opts['unit_vect']
+        if (uvu=opts['uvunits'])
+          case uvu
+          when String
+            un = uvu
+          else
+            raise("fx-fy units miss match") if fx.units != fy.units
+            un = fx.units.to_s
+          end
+          uvopts = {'units'=>un}
+        else
+          uvopts = Hash.new
+        end
+      end
       if opts['flow_itr5']
         if itr_is?(5)
           DCLExt.flow_itr5( fx, fy, opts['factor'], opts['unit_vect'] )
@@ -3217,7 +3289,7 @@ module NumRu
         returnval = { "vfratio"=> @@vfratio, "flenmax"=>@@flenmax }
         if opts['unit_vect']
           len_unit = opts['len_unit'] || @@flenmax
-          DCLExt.unit_vect_single(@@vfratio, len_unit)
+          DCLExt.unit_vect_single(@@vfratio, len_unit, uvopts)
         end
       elsif opts['flow_vect']
         uninfo = DCLExt.flow_vect(fx.val, fy.val, opts['factor'], 1, 1,
@@ -3229,7 +3301,7 @@ module NumRu
             uninfo[2] = opts['ux_unit']  # nil or a Numeric to specify the len 
             uninfo[3] = opts['uy_unit']  # nil or a Numeric to specify the len 
           end
-          DCLExt.unit_vect(*uninfo)
+          DCLExt.unit_vect( *(uninfo+[uvopts]) )
         end
       else
         before=DCLExt.ug_set_params({'lunit'=>true}) if opts['unit_vect']

data/lib/numru/gphys/axis.rb

@@ -630,7 +630,7 @@ module NumRu
 	 end
 
 	 case slicer
-	 when Fixnum
+	 when Integer
 	    pos=@pos[slicer]
 	    cval = ( pos.val.is_a?(Numeric) ? pos.val : pos.val[0] )
 	    units = pos.get_att('units')
@@ -1063,7 +1063,9 @@ module NumRu
 	    @integ_weight = posv.dup
 	    @integ_weight[0] = (posv[1]-posv[0]).abs/2
 	    @integ_weight[-1] = (posv[-1]-posv[-2]).abs/2
-	    @integ_weight[1..-2] = (posv[2..-1] - posv[0..-3]).abs/2
+            if posv.length > 2
+	      @integ_weight[1..-2] = (posv[2..-1] - posv[0..-3]).abs/2
+            end
 	 else
 	    # --- assume that the center values represents the averages ---
 	    bd = @cell_bounds.val

data/lib/numru/gphys/gphys.rb

@@ -1210,7 +1210,8 @@ module NumRu
         grid = Grid.new(*axes)
         if gp0.assoc_coords
           assoc_coords = gp0.assoccoordnames.collect do |aname|
-            GPhys.join( gpnary.collect{|gp| gp.assoc_coord_gphys(aname)}, true )
+            GPhys.join( gpnary.collect{|gp| gp.assoc_coord_gphys(aname)}, true,
+                        true )
           end
           grid.set_assoc_coords(assoc_coords)
         end
@@ -1222,7 +1223,7 @@ module NumRu
         GPhys.new(grid, data)
       end
 
-      def GPhys.join_md(gpnary)
+      def GPhys.join_md(gpnary, no_sort=false)
         #< Check >
 
         if !gpnary.is_a?(NArray)
@@ -1283,7 +1284,7 @@ module NumRu
         end
 
         #< Sort along dimensions to join >
-        gpnary = __sort_gpnary(gpnary)
+        gpnary = __sort_gpnary(gpnary) unless no_sort
 
         #< Join! >
         self.join_md_nocheck(gpnary)
@@ -1294,7 +1295,7 @@ module NumRu
       # ARGUMENT
       # * gpnarray [Array (or 1D NArray) of GPhys]
       # 
-      def GPhys.join(gpary, ignore_overlap=false)
+      def GPhys.join(gpary, ignore_overlap=false, no_sort=false)
 
         #< initialization with the first GPhys object >
 
@@ -1332,7 +1333,7 @@ module NumRu
         gpnary = gpstore.to_na
 
         #< Sort along dimensions to join >
-        gpnary = __sort_gpnary(gpnary)
+        gpnary = __sort_gpnary(gpnary) unless no_sort
 
         #< Join! >
         self.join_md_nocheck(gpnary)