gphys 1.5.6 → 1.5.7

data/ext/numru/gphys/interpo.c

@@ -520,6 +520,327 @@ interpo_find_loc_1D_MD(obj, X, x, dimc, missval, extrapo)
     return rb_ary_new3(2, na_ids, na_f);
 }
 
+/**
+ * @brief interpolate missing
+ * 
+ * @details
+ * input data is converted into double (NArray's Float) type. So unuable for
+ * complex data.
+ * 
+ * Supports cyclic interpolation. Extrapolation is not supported (so far).
+ * 
+ * Returned is a two-element Array consisting of the interpolated NArray (rval)
+ * and the updated mask (rmask).
+ */
+static VALUE
+interpo_missing(obj, val, mask, dim, pos, cyclic, modulo)
+     VALUE obj;
+     VALUE val; // [NArray] real/int (not complex) NArray with data missing
+     VALUE mask;  // [NArray (byte)] mask array (shape same as val)
+     VALUE dim;  // [Integer] dimension along which missing is interpolated
+     VALUE pos; // [1D NArray] grid point positions alog dim
+     VALUE cyclic; // [false/true] whether cyclic extension is conducted
+     VALUE modulo; // [Float] modulo used when cyclic
+     // VALUE extrapo; // [false/true] whether to extrapolate when !cyclic
+{
+    VALUE rval, rmask, rary; // result
+    struct NARRAY *na;
+    na_shape_t rank;
+    na_shape_t *sh, sh0=1, sh1, sh2=1, i, j, k, js, je;
+    int dm, d;
+    double *y, ys, ye, *x, xs, xe, xc, mod;
+    u_int8_t *mk;
+ 
+    rval = na_dup_w_type(val, NA_DFLOAT);
+    rank = NA_RANK(rval);
+    GetNArray(rval, na);
+    sh = na->shape;
+    y = NA_PTR_TYPE(rval, double *);
+
+    if ( NA_TOTAL(mask) != NA_TOTAL(val) )
+        rb_raise(rb_eArgError, "The lengths of val and mask disgagree.");
+    if ( na_get_typecode(mask) != NA_BYTE) 
+        rb_raise(rb_eArgError, "mask must be a byte NArray");
+    rmask = na_clone(mask);
+    mk = NA_PTR_TYPE(rmask, u_int8_t *);
+
+    rary = rb_ary_new();
+    rb_ary_push(rary, rval);
+    rb_ary_push(rary, rmask);
+    
+    if (cyclic == Qtrue) mod = NUM2DBL(modulo);
+    
+    dm = NUM2INT(dim);
+    if (dm < 0) dm += rank;
+    if (dm < 0 || dm >= rank)
+        rb_raise(rb_eArgError, "dim %d does not exist in the rank %d array",
+                 NUM2INT( dim ), rank);
+    for (d=0; d<dm; d++) sh0 *= sh[d];
+    sh1 = sh[dm];
+    for (d=dm+1; d<rank; d++) sh2 *= sh[d];
+
+    if ( NA_TOTAL(pos) != sh1 )
+        rb_raise(rb_eArgError, "len of pos (%d) != len along dim (%d)",
+                 NA_TOTAL(rval), sh1);
+    pos = na_cast_object(pos, NA_DFLOAT);
+    x = NA_PTR_TYPE(pos, double *);
+    for (k=0; k<sh2; k++){
+        for (i=0; i<sh0; i++){
+            js = -1;
+            je = 0;
+            while ( je < sh1 ) {
+                for( j=je; j<sh1-1; j++ ) {
+                    if ( mk[i+sh0*(j+sh1*k)] &&
+                         !mk[i+sh0*((j+1)+sh1*k)] ) {
+                        js = j;
+                        break;
+                    }
+                }
+                if (js >= je) {
+                    for( j=js+1; j<sh1-1; j++ ) {
+                        if ( !mk[i+sh0*(j+sh1*k)] &&
+                             mk[i+sh0*((j+1)+sh1*k)] ){
+                            je = j+1;
+                            break;
+                        }
+                    }
+                    if (je > js+1) {
+                        // interpolate between js & je
+                        xs = x[js];
+                        xe = x[je];
+                        ys = y[i+sh0*(js+sh1*k)];
+                        ye = y[i+sh0*(je+sh1*k)];
+                        for( j=js+1; j<je; j++ ) {
+                            y[i+sh0*(j+sh1*k)] =
+                                ( (xe-x[j])*ys + (x[j]-xs)*ye ) / (xe-xs);
+                            mk[i+sh0*(j+sh1*k)] = (u_int8_t) 1;
+                        }
+                    } else {
+                        break; // no non-cyclic gap remains -> break
+                    }
+                } else {
+                    break; // no (further) non-cyclic gap found -> break
+                }
+            }
+            if (cyclic == Qtrue && ( !mk[i+sh0*(0     +sh1*k)] ||
+                                     !mk[i+sh0*(sh1-1 +sh1*k)] ) ) {
+                // the first or last element remains as missing
+                js = je = -1;
+                for( j=sh1-1; j>=0; j-- ) {
+                    if ( mk[i+sh0*(j+sh1*k)] ) {
+                        js = j;
+                        break;
+                    }
+                }
+                for( j=0; j<=js; j++ ) {
+                    if ( mk[i+sh0*(j+sh1*k)] ) {
+                        je = j+sh1;
+                        break;
+                    }
+                }
+                if (js>=0 && je>=sh1) {
+                    xs = x[js];
+                    xe = x[je-sh1] + mod;
+                    ys = y[i+sh0*(js+sh1*k)];
+                    ye = y[i+sh0*(je-sh1+sh1*k)];
+                    for( j=js+1; j<je; j++ ) {
+                        xc = x[j % sh1] + (j/sh1)*mod;
+                        y[i+sh0*(j%sh1+sh1*k)] =
+                            ( (xe-xc)*ys + (xc-xs)*ye ) / (xe-xs) ;
+                        mk[i+sh0*(j%sh1+sh1*k)] = (u_int8_t) 1;
+                    }
+                }
+            }
+        }
+    }
+    return rary;
+}
+
+/**
+ * @brief multi-dimensional regrid for based on indices (which is essentially fro equally separated grid)
+ * 
+ * @details
+ * input data is converted into double (NArray's Float) type. So unuable for
+ * complex data.
+ * 
+ * * dims must be an Array containing integers (>=0 & < rank)
+ * * lengths of the Array arguments must be the same (rclen),
+ *   and the rank of NArrays in scidxs must also be rclen.
+ * * shapes of the NArrays in scidxs must be the same
+ * 
+ * Supports cyclic interpolation. Extrapolation is not supported.
+ * 
+ * Returned is a two-element Array consisting of the interpolated NArray (rval)
+ * and the updated mask (rmask).
+ * 
+ * @note
+ * implemntation strategy: make a consolidate single loop for the return 
+ * value
+ */
+static VALUE
+regrid2_w_idx(obj, val, mask, dims, scidxs, cyclics)
+     VALUE obj;
+     VALUE val; // [NArray] real/int (not complex) NArray with data missing
+     VALUE mask; // [NArray (byte)] mask array (shape same as val)
+     VALUE dims; // [Array of Integer] dimensions along which regrid is made
+     VALUE scidxs; // [Array of NArray] float index vals at which sampled (0..)
+     VALUE cyclics; // [Array of true/false or nil] wheather the dim is cyclic.
+                    // modulo is assumed to be the dimension length, so
+                    // available only when exactly 1-grid extension is needed
+{
+    VALUE rval, rmask, rary; // result
+    VALUE scidx; // (work) one of scidxs
+    double *iv, *rv; // input & return values
+    double **sci; // sampling index values
+    int *cyc;
+    double a, c; // subgrid position and coefficient for linear interporation
+    u_int8_t *imsk, *rmsk; // input & return masks
+    struct NARRAY *na;  // work
+    na_shape_t *ish, *rsh, *ssh;   // shapes of input, retrun & sampling values
+    na_shape_t *icsh, *rcsh, *scsh; // cumulative shapes
+    na_shape_t i, j, k, m, si;
+    na_shape_t ii, ii0, dii; // related to 1D indices along input val
+    na_shape_t itot, rtot, stot; // total array lengths (input, return, sample)
+    int rank, ndims, d, dc, *dms, nd2p, kup;
+    int *dimmap;  // to indicate dimensions to be sampled and left
+
+    ndims = RARRAY_LEN(dims);
+    if (ndims != RARRAY_LEN(scidxs)) 
+        rb_raise(rb_eArgError, "lens of dims & scidx do not agree");
+    if (!NIL_P(cyclics) && ndims != RARRAY_LEN(cyclics))
+            rb_raise(rb_eArgError, "lens of dims & cyclics do not agree");
+
+    val = na_cast_object(val, NA_DFLOAT);
+    rank = NA_RANK(val);
+    if (ndims>rank)
+        rb_raise(rb_eArgError, "# of dims exceeds val.rank (%d)", rank);
+    GetNArray(val, na);
+    ish = na->shape;
+    iv = NA_PTR_TYPE(val, double *);
+    itot = NA_TOTAL(val);
+    if (itot != NA_TOTAL(mask))
+        rb_raise(rb_eArgError, "lens of val and mask do not agree");
+    imsk = NA_PTR_TYPE(mask, u_int8_t *);
+
+    scidx = RARRAY_AREF(scidxs, 0);
+    if (NA_RANK(scidx) != ndims)
+        rb_raise(rb_eArgError, "rank of sampling indices != # of dims");
+    GetNArray(scidx, na);
+    ssh = na->shape;
+    stot = NA_TOTAL(scidx);
+    sci =  ALLOCA_N(double *, ndims);
+    for (d=1; d<ndims; d++) {
+        if (NA_TOTAL(RARRAY_AREF(scidxs, d)) != stot)
+            rb_raise(rb_eArgError, "lens of scidxs are not uniform");
+    }
+    for (d=0; d<ndims; d++) {
+        sci[d] = NA_PTR_TYPE(RARRAY_AREF(scidxs, d), double *);
+    }
+
+    dms =  ALLOCA_N(int, ndims);
+    for (d=0; d<ndims; d++) {
+        dms[d] = NUM2INT(RARRAY_AREF(dims, d));
+        if (dms[d] < 0 || dms[d]>=rank)
+            rb_raise(rb_eArgError, "values of dims is not within 0...rank(%d)",
+                     rank);
+    }
+    cyc =  ALLOCA_N(int, ndims);
+    for (d=0; d<ndims; d++) {
+        cyc[d] = !NIL_P(cyclics) && RARRAY_AREF(cyclics, d) == Qtrue;
+    }
+
+    dimmap =  ALLOCA_N(int, rank); // e.g. [-1,0,-1,1,-1,-1,..] if dims==[1,3]
+    for (d=0; d<rank; d++) {
+        dimmap[d] = -1; // initialization (-1 indicates where dimension is left)
+    }
+    for (d=0; d<ndims; d++) {
+        dimmap[dms[d]] = d; // position (0...ndims) of dimension to be sampled
+    }
+    
+    rsh = ALLOCA_N(na_shape_t, rank); 
+    for (d=0; d<rank; d++) {
+        if (dimmap[d] < 0) {
+            rsh[d] = ish[d];
+        } else {
+            rsh[d] = ssh[dimmap[d]];
+        }
+    }
+
+    icsh = ALLOCA_N(na_shape_t, rank);  // cumulative shape [1, sh0, sh0*sh1,..]
+    rcsh = ALLOCA_N(na_shape_t, rank);  // cumulative shape [1, sh0, sh0*sh1,..]
+    scsh = ALLOCA_N(na_shape_t, ndims); // cumulative shape [1, sh0, sh0*sh1,..]
+    icsh[0] = rcsh[0] = scsh[0] = 1;
+    for (d=1; d<rank; d++) {
+        icsh[d] = icsh[d-1]*ish[d-1];
+        rcsh[d] = rcsh[d-1]*rsh[d-1];
+    }
+    for (d=1; d<ndims; d++) {
+        scsh[d] = scsh[d-1]*ssh[d-1];
+    }
+
+    rval = na_make_object(NA_DFLOAT, rank, rsh, cNArray);
+    rv = NA_PTR_TYPE(rval, double *);
+    rtot = NA_TOTAL(rval);
+
+    rmask = na_make_object(NA_BYTE, rank, rsh, cNArray);
+    rmsk = NA_PTR_TYPE(rmask, u_int8_t *);
+
+    rary = rb_ary_new();
+    rb_ary_push(rary, rval);
+    rb_ary_push(rary, rmask);
+
+    nd2p = 1 << ndims;  // 2**ndims
+    for (j=0; j<rtot; j++) {  // 1-dimensionalized loop for return values
+        rmsk[j] = 1;   // (initialization) as all-valid
+        si = 0; // (initialization) 1-dimensionalized index of scidx
+        ii0 = 0; // (initialization) offset of ii for non-regrided dims
+        for (d=0; d<rank; d++) {
+            m = (j/rcsh[d]) % rsh[d]; // index along d-th dim of rv
+            if (dimmap[d] >= 0) {
+                si += m * scsh[dimmap[d]];   // for dim to regrid
+            } else {
+                ii0 += m * icsh[d];          // for dim not to regrid
+            }
+        }
+        rv[j] = 0.0;  // (initialization) base of summation
+        for (i=0; i<nd2p; i++) {  // loop for multi-D linear interpolation
+            dii = 0; //(initialization) 1-dimensionalized iv index diff from ii0
+            c = 1.0; //(initialization) fractional factor to sum up
+            for (d=0; d<rank; d++) {
+                dc = dimmap[d];  // if >0, dc-th sci is treated (dc: 0,1,..)
+                if (dc >= 0) {
+                    k = floor(sci[dc][si]); // index along d-th dim of iv
+                    a = sci[dc][si] - k;  // subgrid fractional distance
+                    kup = (i >> dc) % 2; // 0(1) to use the this(next) grid pt
+                                         // (note: i>>d is equal to i/2**d)
+                    k += kup;
+                    if (k<0 || k>=ish[d]) {
+                        if (cyc[d]) {
+                            k = k % ish[d];
+                            if (k<0) k += ish[d]; // for negative mod of C lang
+                        } else {
+                            rmsk[j] = 0;  // do not extrapolate
+                            break;
+                        }
+                    }
+                    dii += k * icsh[d];
+                    c *= ( kup ? a : 1.0-a );
+                }
+            }
+            if (rmsk[j] == 0) {
+                break;  // have been set in the d loop --> break the i loop
+            }
+            ii = ii0 + dii;
+            if ( imsk[ii] ) {
+                rv[j] += c*iv[ii];
+            } else {
+                rmsk[j] = 0;
+                break;
+            }
+        }
+    }
+    return rary;
+}
 
 void
 init_gphys_interpo()
@@ -532,10 +853,12 @@ init_gphys_interpo()
     cGPhys = rb_define_class_under(mNumRu, "GPhys", rb_cObject);
     rb_define_private_method(cGPhys, "c_interpo_find_loc_1D", interpo_find_loc_1D, 4);
     rb_define_private_method(cGPhys, "c_interpo_find_loc_1D_MD", interpo_find_loc_1D_MD, 5);
-
     rb_define_private_method(cGPhys, "c_interpo_do", interpo_do, 5);
+    rb_define_private_method(cGPhys, "c_interpo_missing", interpo_missing, 6);
+    rb_define_private_method(cGPhys, "c_regrid2_w_idx", regrid2_w_idx, 5);
 
     // to make "find loc" methods available outside GPhys as class methods
-    rb_define_singleton_method(cGPhys, "interpo_find_loc_1D", interpo_find_loc_1D, 2);
-    rb_define_singleton_method(cGPhys, "interpo_find_loc_1D_MD", interpo_find_loc_1D_MD, 3);
+    rb_define_singleton_method(cGPhys, "interpo_find_loc_1D", interpo_find_loc_1D, 4);
+    rb_define_singleton_method(cGPhys, "interpo_find_loc_1D_MD", interpo_find_loc_1D_MD, 5);
+    rb_define_singleton_method(cGPhys, "na_interpo_missing", interpo_missing, 6);
 }

data/lib/numru/dclext.rb

@@ -725,7 +725,7 @@ module NumRu
 
     #<<< udpack >>>
 
-    def ud_coloring(clr_min=13, clr_max=99)
+    def ud_coloring(clr_min, clr_max)
       # change the colors of existing contours to make a gradation
       # (rainbow colors with the default color map).
       nlev = DCL.udqcln
@@ -736,7 +736,7 @@ module NumRu
       DCL.udiclv     # clear the contours
 
       colors = clr_min +
-               NArray.int(nlev).indgen! * (clr_max-clr_min) / nlev
+               (NArray.float(nlev).indgen! * (clr_max-clr_min)/(nlev-1)).round
 
       cont_params.sort!
       for i in 0...nlev
@@ -777,8 +777,8 @@ module NumRu
         DCL.uddclv(0.0)
       end
       if options['coloring']
-        clr_min = ( options['clr_min'] || 13 )
-        clr_max = ( options['clr_max'] || 99 )
+        clr_min = ( options['clr_min'] || DCL.uepget('icolor1') )
+        clr_max = ( options['clr_max'] || DCL.uepget('icolor2') )
         ud_coloring( clr_min, clr_max )
       end
     end
@@ -1100,6 +1100,7 @@ module NumRu
       ["top",  false, "place the bar at the top (effective if landscape)"],
       ["left", false, "place the bar in the left (effective if portrait)"],
       ["units", nil, "units of the axis of the color bar"],
+      ["unit_tidy", true, "reform units for DCL (by handling power etc)"],
       ["units_voff", 0.0, "offset value for units from the default position in the V coordinate (only for 'units' != nil)"],
       ["title", nil, "title of the color bar"],
       ["title_voff", 0.0, "offset value for title from the default position in the V coordinate (only for 'title' != nil)"],
@@ -1265,7 +1266,8 @@ module NumRu
       end
 
       DCLExt.color_bar_title_units(vxmin, vxmax, vymin, vymax, portrait, voff, 
-              opt['title'], opt['units'], opt['title_voff'], opt['units_voff'])
+              opt['title'], opt['units'], opt['title_voff'], opt['units_voff'],
+              opt['unit_tidy'])
 
       inffact = opt["inffact"]
       if inf0
@@ -1422,6 +1424,15 @@ module NumRu
 	  str.sub!(/^0/,'') if !opt['year'] && opt['month']
 	  labels.push(str)
 	end
+        if pos.length == 1
+          u = pos[0]
+          if u<u1 || u>u2
+            pos[0] = (u1+u2)/2
+          end
+        else
+          pos[0] = u1 if pos[0]<u1
+          pos[-1] = u2 if pos[-1]>u2
+        end
 
         if xax
 	  DCL.uxsaxz(cside,DCL.uzpget('roffx'+cside))
@@ -1456,9 +1467,14 @@ module NumRu
       ['cside', nil, '"b", "t", "l", "r", nil (=>left/bottom), or false (=>right/top)'],
       ['margin_factor', 0.9, 'Factor to control the extent to use UCPACK; The smaller, the less, requiring more space between year labels'],
       ['dtick1', nil, '(For long time series) small tick interval (years)'],
-      ['dtick2', nil, '(For long time series) large tick with year labels (years)']
+      ['dtick2', nil, '(For long time series) large tick with year labels (years)'],
+      ['noyear', false, 'do not show years']
     )
 
+    def set_date_ax_options(options)
+      @@date_ax_options.set(options)
+    end
+    
     def date_ax(date_from, date_to, options=nil)
       # < intepret the options >
       opt = @@date_ax_options.interpret(options)
@@ -1498,9 +1514,19 @@ module NumRu
       if use_ucpack
         jd0 = date_from.strftime('%Y%m%d').to_i
         if xax
-          DCL.ucxacl(cside,jd0,nday)
+          if opt['noyear']
+            DCL.ucxady(cside,jd0,nday)
+            DCL.ucxamn(cside,jd0,nday)
+          else
+            DCL.ucxacl(cside,jd0,nday)
+          end
         else
-          DCL.ucyacl(cside,jd0,nday)
+          if opt['noyear']
+            DCL.ucyady(cside,jd0,nday)
+            DCL.ucyamn(cside,jd0,nday)
+          else
+            DCL.ucyacl(cside,jd0,nday)
+          end
         end
       else
         year_ax(xax, cside, date_from, date_to)
@@ -1739,6 +1765,7 @@ module NumRu
       ['inplace',true, "Whether to print labels right by the unit vector (true) or below the x axis (false)"],
       ['rsizet', nil, "Label size(default taken from uz-parameter 'rsizel1')"],
       ['index',  3," Line index of the unit vector"],
+      ['units', nil, "units of the quantity"],
       ['vertical', true,"(used only in unit_vect_single) the unit vector is directed upward if true, to the right if not."]
     )
 
@@ -1773,6 +1800,7 @@ module NumRu
       vxuloc = opt['vxuloc']
       vyuloc = opt['vyuloc']
       rsizet = opt['rsizet']
+      units = opt['units']
       index = opt['index']
 
       #< unit vector >
@@ -1805,6 +1833,8 @@ module NumRu
       #< labelling >
       sfxunit = sprintf("%.2g",fxunit)
       sfyunit = sprintf("%.2g",fyunit)
+      sfxunit += ' '+units if units
+      sfyunit += ' '+units if units
       rsizet = DCL.uzpget('rsizel1') if !rsizet
       if opt['inplace']
         if vxunit != 0
@@ -1837,6 +1867,7 @@ module NumRu
       rsizet = opt['rsizet'] || DCL.uzpget('rsizel1')
       index = opt['index']
       vertical = opt['vertical']
+      units = opt['units']
 
       #< show the unit vector and the label >
 
@@ -1847,6 +1878,7 @@ module NumRu
       end
       vlen = vfratio * flen
       label = DCL.chval("B",flen)
+      label += ' '+units if units
 
       lclip_bk = DCLExt.sg_set_params("lclip" => false)
       if vertical
@@ -2154,6 +2186,7 @@ module NumRu
       ["top",  false, "place the bar at the top (effective if landscape)"],
       ["left", false, "place the bar in the left (effective if portrait)"],
       ["units", nil, "units of the axis of the color bar"],
+      ["unit_tidy", true, "reform units for DCL (by handling power etc)"],
       ["units_voff", 0.0, "offset value for units from the default position in the V coordinate (only for 'units' != nil)"],
       ["title", nil, "title of the color bar"],
       ["title_voff", 0.0, "offset value for title from the default position in the V coordinate (only for 'title' != nil)"],
@@ -2307,28 +2340,51 @@ module NumRu
       DCL.sgplzv(v3[0], v3[1], 1, index)
     end
 
-    def color_bar_title_units(vxmin, vxmax, vymin, vymax, portrait, voff, title, units, title_voff, units_voff)
+    def format_units(units)
+      units.to_s.split(/ +|\./).map{|s| s.sub(/1[eE](-?\d+)/,'10\^{\1}').sub(/([a-zA-Z]+)(-?\d+)$/,'\1\^{\2}')}.join('\_{ }')
+    end
+
+    def color_bar_title_units(vxmin, vxmax, vymin, vymax, portrait, voff, title, units, title_voff, units_voff, unit_tidy=true, old_style=false)
       rsizel1 = DCL::uzrget('rsizel1')
       charindex = DCL::uziget('indexl1')
       pad1 = DCL::uzrget('pad1')
+      if units && unit_tidy
+        units = format_units(units)
+      end
       if portrait
         if voff > 0
           # title
-          DCL::sgtxzr(vxmin - (0.5 + pad1) * rsizel1, (vymin + vymax) / 2.0 + title_voff, title, rsizel1, 90, 0, charindex) if title
+          if title && old_style
+            DCL::sgtxzr(vxmin - (0.5 + pad1) * rsizel1, (vymin + vymax) / 2.0 + title_voff, title, rsizel1, 90, 0, charindex)
+          end
           # units
           DCL::sgtxzr(vxmax + pad1 * rsizel1, vymax + 2.6 * rsizel1 + units_voff, units, rsizel1, 0, -1, charindex) if units
         else
+          exit
           # title
-          DCL::sgtxzr(vxmax + (0.5 + pad1) * rsizel1, (vymin + vymax) / 2.0 - title_voff, title, rsizel1, -90, 0, charindex) if title
+          if title && old_style
+            DCL::sgtxzr(vxmax + (0.5 + pad1) * rsizel1, (vymin + vymax) / 2.0 - title_voff, title, rsizel1, -90, 0, charindex)
+          end
           # units
           DCL::sgtxzr(vxmin - pad1 * rsizel1, vymax + 2.6 * rsizel1 + units_voff, units, rsizel1, 0, 1, charindex) if units
         end
+        if title && !old_style
+          sv = DCLExt.uz_set_params("rsizet1"=>rsizel1)
+          DCL.uysttl("r",title,title_voff)
+          DCLExt.uz_set_params(sv)
+        end
       else
         spacer = (0.5 + pad1) * rsizel1
         tmpvy = [vymin - spacer, vymax + spacer]
         tmpvy = [tmpvy[1], tmpvy[0]] if voff <= 0
         # title
-        DCL::sgtxzr((vxmin + vxmax) / 2.0 + title_voff, tmpvy[0], title, rsizel1, 0, 0, charindex) if title
+        if title && old_style
+          DCL::sgtxzr((vxmin + vxmax) / 2.0 + title_voff, tmpvy[0], title, rsizel1, 0, 0, charindex)
+        elsif title
+          sv = DCLExt.uz_set_params("rsizet1"=>rsizel1)
+          DCL.uxsttl("b",title,title_voff)
+          DCLExt.uz_set_params(sv)
+        end
         # units
         DCL::sgtxzr(vxmax + 2.6 * rsizel1 + units_voff, tmpvy[1], units, rsizel1, 0, -1, charindex) if units
       end
@@ -2697,8 +2753,13 @@ module NumRu
           end
         end
 
-        DCLExt.color_bar_title_units(vxmin, vxmax, vymin, vymax, portrait, voff, 
-                                     opt['title'], opt['units'], opt['title_voff'], opt['units_voff'])
+        units = opt['units']
+        if units && opt['unit_tidy']
+          units = units.split(/ +|\./).map{|s| s.sub(/(-?\d)$/,'\^{\1}')}.join('\_{ }')
+        end
+        DCLExt.color_bar_title_units(vxmin, vxmax, vymin, vymax, portrait, voff,
+                     opt['title'], units, opt['title_voff'], opt['units_voff'],
+                     opt['unit_tidy'])
         if portrait
           cent = ((voff > 0) ? -1 : 1)
           spacer = DCL::uzrget('pad1') * rsizel1
@@ -2836,8 +2897,9 @@ module NumRu
 
           DCL::uxsfmt(cfmt_bk)
         end
-        DCLExt.color_bar_title_units(vxmin, vxmax, vymin, vymax, portrait, voff, 
-                                     opt['title'], opt['units'], opt['title_voff'], opt['units_voff'])
+        DCLExt.color_bar_title_units(vxmin, vxmax, vymin, vymax, portrait, voff,
+              opt['title'], opt['units'], opt['title_voff'], opt['units_voff'],
+              opt['unit_tidy'])
 
         # RESTORE PARAMS
         DCLExt.restore_proj_params(proj_params)

data/lib/numru/ganalysis/beta_plane.rb

@@ -78,9 +78,10 @@ module NumRu
       # RETURN VALUE
       # * grad_x (GPhys objects)
       def grad_x(gphys, x=nil)
-        lond, latd = Planet::find_lon_lat_dims
+        lond, latd = Planet::find_lon_lat_dims(gphys)
         x, = get_x_y(gphys) if !x
-        gphys.cderiv(lond,x)
+        bc = GPhys::Derivative::CYCLIC_OR_LINEAR
+        gphys.cderiv(lond,bc,x)
       end
 
       # Gradient in the y direction
@@ -93,9 +94,10 @@ module NumRu
       # RETURN VALUE
       # * grad_y (GPhys objects)
       def grad_y(gphys, y=nil)
-        lond, latd = Planet::find_lon_lat_dims
+        lond, latd = Planet::find_lon_lat_dims(gphys)
         x, y = get_x_y(gphys) if !y
-        gphys.threepoint_O2nd_deriv(latd,y)
+        bc = GPhys::Derivative::CYCLIC_OR_LINEAR
+        gphys.threepoint_O2nd_deriv(latd,bc,y)
       end
 
     end