gphys 1.5.5 → 1.5.7

data/lib/numru/ganalysis/eof.rb

@@ -44,6 +44,7 @@ module NumRu
     #                 it is cosine of latitude when the first two axes of the +gphys+ are "lon" and "lat" and +disable_weight+ option is not +true+,
     #                 else 1.
     #   * disable_weight: See weight option.
+    #   * no_pc: do not compute primary components
     #
     # == Return values
     # +eof+:: GPhys object for array of EOF vectors.
@@ -61,10 +62,12 @@ module NumRu
         dims = args
         opts = Hash.new
       end
-      dims = dims.map{|dim| gphys.dim_index(dim) }
+      no_pc = ( opts[:no_pc] || opts["no_pc"] )
+
+      dims = dims.map{|dim| gphys.dim_index(dim) }  # dimensions to vary (~"time")
       n = 1
       n_lost = 1
-      dims1 = Array.new
+      dims1 = Array.new     # vector dimensions (~"spatial")
       shape1 = Array.new
       gphys.shape.each_with_index{|s,i|
         if dims.include?(i)
@@ -75,61 +78,51 @@ module NumRu
           shape1.push s
         end
       }
-      new_grid = gphys.instance_variable_get("@grid").delete_axes(dims, "covariance matrix").copy
-      new_index = NArray.sint(*new_grid.shape).indgen
+      new_grid_wo_modes = gphys.instance_variable_get("@grid").delete_axes(dims, "covariance matrix").copy
+      new_index = NArray.sint(*new_grid_wo_modes.shape).indgen
       index = NArray.object(gphys.rank)
       index[dims] = true
 
+      wgtun = ""
       if w = (opts[:weight] || opts["weight"])
         if GPhys === w
           w = w.val
+          wgtun = w.units
         end
         unless NArray === w
           raise "weight must be NArray of GPhys"
         end
-        unless w.shape == new_grid.shape
+        unless w.shape == new_grid_wo_modes.shape
           raise "shape of weight is invalid"
         end
-        w /= w.mean
-        w.reshape!(n)
-      else
-        nc0 = new_grid.coord(0)
-        nc1 = new_grid.coord(1)
+        w_orgshape = w
+        w = w.reshape(n)
+      elsif new_grid_wo_modes.rank >= 2
+        nc0 = new_grid_wo_modes.coord(0)
+        nc1 = new_grid_wo_modes.coord(1)
         if !(opts[:disable_weight]||opts["disable_weight"]) &&
            ( /^lon/ =~ nc0.name || /^degree.*_east/ =~ nc0.units.to_s ) &&
            ( /^lat/ =~ nc1.name || /^degree.*_north/ =~ nc1.units.to_s )
           rad = NumRu::Units.new("radian")
           nlon = nc0.length
           lat = nc1.convert_units(rad).val
-          w = NArray.new(lat.typecode,nlon).fill!(1) * NMath::cos(lat).reshape(1,lat.length)
-          w /= w.mean
-          w.reshape!(n)
+          w2 = NMath::cos(lat)
+          eps = 1e-10   # a value whose sqrt is negligibly small as cosine
+          w2[ w2.le(0) ] = eps
+          w = NMath.sqrt(w2)     # sqrt(cos(lat))
+          w = NArray.new(lat.typecode,nlon).fill!(1) * w.reshape(1,lat.length)
+          w_orgshape = w
+          w = w.reshape(w.length)
         else
           w = nil
         end
+      else
+        w = nil
       end
 
-      ary = NArrayMiss.new(gphys.typecode, n_lost, n)
-      ind_rank = dims1.length
-      ind = Array.new(ind_rank,0)
-      n.times{|n1|
-        index[dims1] = ind
-        val = gphys[*index].val
-        val.reshape!(n_lost)
-        vm = val.mean
-        val -= vm unless vm.nil?
-        ary[true,n1] = val
-        break if n1==n-1
-        ind[0] += 1
-        ind_rank.times{|i|
-          if ind[i] == shape1[i]
-            ind[i] = 0
-            ind[i+1] += 1
-          else
-            break
-          end
-        }
-      }
+      val = gphys.val
+      ary = val.transpose( *(dims + dims1) ).reshape!(n_lost, n)
+      ary -= ary.mean(0).newdim(0)   # remove "temporal" mean
       ary = ary.mul!(w.reshape(1,n)) if w
 
       nmodes = opts[:nmodes] || opts["nmodes"] || n
@@ -148,7 +141,7 @@ module NumRu
             nn += 1
           end
         }
-        ary = nil # for GC
+        ary = nil if no_pc # for GC
         print "start calc eigen vector\n" if $DEBUG
         val, vec = SSL2.seig2(nary,nmodes)
       when "lapack"
@@ -159,7 +152,7 @@ module NumRu
           nary[n0...n,n0] = (ary[true,n0...n].mul_add(ary[true,n0],0)/(n_lost-1)).get_array!
           total_var += nary[n0,n0]
         }
-        ary = nil # for GC
+        ary = nil if no_pc  # for GC
         print "start calc eigen vector\n" if $DEBUG
         case nary.typecode
         when NArray::DFLOAT
@@ -169,8 +162,8 @@ module NumRu
 	  m, val, vec, isuppz, work, iwork, info, = NumRu::Lapack.ssyevr("V", "I", "L", nary, 0, 0, n-nmodes+1, n, 0.0, -1, -1)
 	  m, val, vec, = NumRu::Lapack.ssyevr("V", "I", "L", nary, 0, 0, n-nmodes+1, n, 0.0, work[0], iwork[0])
         end
-        val = val[-1..0]
         vec = vec[true,-1..0]
+        val = val[0...nmodes][-1..0]
       when "gsl"
         print "start calc covariance matrix\n" if $DEBUG
         nary = NArray.new(gphys.typecode,n,n)
@@ -178,7 +171,7 @@ module NumRu
           nary[n0...n,n0] = (ary[true,n0...n].mul_add(ary[true,n0],0)/(n_lost-1)).get_array!
           nary[n0,n0...n] = nary[n0...n,n0]
         }
-        ary = nil # for GC
+        ary = nil if no_pc  # for GC
         print "start calc eigen vector\n" if $DEBUG
         val, vec = GSL::Eigen::symmv(nary.to_gm)
         GSL::Eigen.symmv_sort(val, vec, GSL::Eigen::SORT_VAL_DESC)
@@ -188,15 +181,32 @@ module NumRu
         val = val[0...nmodes]
       end
 
-      axes = new_grid.instance_variable_get('@axes')
+      axes = new_grid_wo_modes.instance_variable_get('@axes')
       axis_order = Axis.new
       axis_order.pos = VArray.new(NArray.sint(nmodes).indgen(1),
                                   {}, "mode")
-      axes << axis_order
+      axes = axes + [ axis_order ]
       new_grid = Grid.new(*axes)
+
+      unless no_pc
+        mary = NMatrix.new(ary.typecode, *ary.shape)
+        mary[true,true] = ary.to_na
+        mvec = NMatrix.new(vec.typecode, *vec.shape)
+        mvec[true,true] = vec
+        mpc = mvec * mary   # use matrix multiplication
+        pc = NArray.new(mpc.typecode, *mpc.shape)
+        pc[true,true] = mpc
+        pc /= pc.stddev(0).newdim!(0)  # normalization
+        vary = VArray.new(pc, {"long_name"=>"Primary component",
+                          "units"=>"1"}, "PC")
+        grid = Grid.new( *dims.map{|d| gphys.grid.axis(d)} + axes[-1..-1] )
+        pc = GPhys.new( grid, vary )
+      end
+
       vec /= w if w
       vec.reshape!(*new_grid.shape)
       vec *= NMath::sqrt( val.reshape( *([1]*(axes.length-1)+[nmodes]) ) )
+          # multiply a sqrt(eigen value) -> variance same as in the input data
       va_eof = VArray.new(vec,
                           {"long_name"=>"EOF vector","units"=>gphys.units.to_s },
                           "EOF")
@@ -207,7 +217,19 @@ module NumRu
                            "rate")
       rate = GPhys.new(Grid.new(axis_order), va_rate)
 
-      return [eof, rate]
+      if w
+        w = w_orgshape
+        if w.rank == new_grid_wo_modes.rank
+          v = VArray.new(w, {"long_name"=>"weight",
+                             "units"=>wgtun}, "weight" )
+          w = GPhys.new( new_grid_wo_modes,
+                         v )
+        end
+      end
+      
+      ret = [eof, rate, w]
+      ret.push(pc) unless no_pc
+      return ret
     end
 
     def eof2(gphys1, gphys2, *args)

data/lib/numru/ganalysis/fitting.rb

@@ -96,6 +96,11 @@ module NumRu
       #   this argument can be used to specify the dimensions that are
       #   not included in +grid_locs+ and are treated as independent, so
       #   the fitting is made for each of their component.
+      # * +with_offset+ (optional) if true (default), constant offset is derived.
+      #   If false, offset is not treated.
+      # * +wgt_func+ (optional) [nil (defualt) or Proc] If Proc, weighting function
+      #   to conduct the weighted least square fit. It should conform with the
+      #   fitting functions.
       # 
       # Note that the sum of the lengths of +grid_locs+, +ensemble_dims+ and
       # +indep_dims+ must be equal to the rank (# of dims) of +data+.
@@ -215,14 +220,16 @@ module NumRu
       #   number of functions (also unsolvable).
       # 
       def least_square_fit(data, grid_locs, functions, ensemble_dims=nil,
-                           indep_dims=nil)
+                           indep_dims=nil, with_offset=true, wgt_func = nil)
 
         #< argument check >
 
         grid_locs.each_with_index{|x,i| self.ensure_1D_NArray(x, i)}
         functions.each{|f| raise("Found non-Proc arg") if !f.is_a?(Proc)}
 
-        functions = functions + [@@unity]   # constanf offset
+        if with_offset
+          functions = functions + [@@unity]   # constanf offset
+        end
 
         ng = grid_locs.length
         rank = data.rank
@@ -267,12 +274,20 @@ module NumRu
           if otherdims.length != ensemble_dims.length + n_indep
             raise ArgumentError, "Overlap in ensemble_dims and indep_dims"
           end
+          sh = data.shape
+          indep_len = 1
+          indep_dims.each{|i| indep_len *= sh[i]}
+          meandims = (0...rank).collect{|d| d} - indep_dims
         end
 
         #< pre-process data >
 
-        d0 = data.mean
-        data = data - d0     # constant offset for numerical stability
+        if with_offset
+          d0 = data.mean
+          data = data - d0     # constant offset for numerical stability
+        else
+          d0 = 0.0
+        end
 
         if data.is_a?(NArrayMiss)
           mask = data.get_mask
@@ -289,33 +304,66 @@ module NumRu
           otherdims.each{|d| f.newdim!(d)}
           f
         }
-
+        if wgt_func
+          wgt = wgt_func[*grid_locs]
+          otherdims.each{|d| wgt.newdim!(d)}
+        else
+          wgt = nil
+        end
+        
         ms = fv.length    # matrix size
 
         if ( (len=data.length) < ms )
           raise "Insufficient data length (#{len}) for the # of funcs+1 (#{ms})"
         end
 
-        mat = NMatrix.float(ms,ms)   #  wil be symmetric
+        if mask && indep_dims
+          mat = (0...indep_len).map{NMatrix.float(ms,ms)}
+        else
+          mat = NMatrix.float(ms,ms)   #  wil be symmetric
+        end
 
         for i in 0...ms
           for j in 0..i
             if mask
-              fvij = NArrayMiss.to_nam( fv[i] * fv[j] * mask, mask )
-              mat[i,j] = (fvij).mean
+              unless wgt
+                fvij = NArrayMiss.to_nam( fv[i] * fv[j] * mask, mask )
+              else
+                fvij = NArrayMiss.to_nam( fv[i] * fv[j] * wgt * mask, mask )
+              end
+              if !indep_dims
+                mat[i,j] = (fvij).mean
+              else
+                x = (fvij).mean(*meandims)
+                (0...indep_len).each{|k| mat[k][i,j] = x[k]}
+              end
             else
-              mat[i,j] = (fv[i] * fv[j]).mean
+              unless wgt
+                mat[i,j] = (fv[i] * fv[j]).mean
+              else
+                mat[i,j] = (fv[i] * fv[j] * wgt).mean
+              end
             end
           end
         end
 
         for i in 0...ms
           for j in i+1...ms
-            mat[i,j] = mat[j,i]      # symmetric
+            if mask && indep_dims
+              for k in 0...indep_len
+                mat[k][i,j] = mat[k][j,i]      # symmetric
+              end
+            else
+              mat[i,j] = mat[j,i]      # symmetric
+            end
           end
         end
         #p "*** mat ***",mat
-        lu = mat.lu
+        if mask && indep_dims
+          lu = (0...indep_len).map{|k| mat[k].lu}
+        else
+          lu = mat.lu
+        end
 
         #< derive the vector, solve, and best fit >
 
@@ -323,7 +371,11 @@ module NumRu
           # derive the vector
           b = NVector.float(ms)
           for i in 0...ms
-            b[i] = (data * fv[i]).mean
+            unless wgt
+              b[i] = (data * fv[i]).mean
+            else
+              b[i] = (data * fv[i] * wgt).mean
+            end
           end
 
           # solve
@@ -336,9 +388,16 @@ module NumRu
           c = na
 
           # best fit
-          bf = c[-1]    # the constant offset
-          for i in 0...ms-1
-            bf += c[i]*fv[i]
+          if with_offset
+            bf = c[-1]    # the constant offset
+            for i in 0...ms-1
+              bf += c[i]*fv[i]
+            end
+          else
+            bf = 0.0
+            for i in 0...ms
+              bf += c[i]*fv[i]
+            end
           end
 
         else    # fitting multiple times
@@ -346,7 +405,6 @@ module NumRu
           # derive vectors
           idshp = indep_dims.collect{|d| data.shape[d]}
           bs = NArray.float(ms,*idshp)
-          meandims = (0...rank).collect{|d| d} - indep_dims
           for i in 0...ms
             bsi = (data * fv[i]).mean(*meandims)
             if bsi.is_a?(NArrayMiss)
@@ -357,16 +415,18 @@ module NumRu
             end
             bs[i,false] = bsi
           end
-          idlen = 1
-          idshp.each{|l| idlen *= l}
 
           # solve
-          bs = bs.reshape(ms, idlen)
-          c = NArray.float(ms,idlen)
+          bs = bs.reshape(ms, indep_len)
+          c = NArray.float(ms,indep_len)
           b = NVector.float(ms)
-          for id in 0...idlen
+          for id in 0...indep_len
             b[true] = bs[true,id]
-            c[true,id] = lu.solve(b)
+            if mask
+              c[true,id] = lu[id].solve(b)
+            else
+              c[true,id] = lu.solve(b)
+            end
           end
           c[-1,true] += d0
           c = c.reshape(ms, *idshp)
@@ -381,9 +441,16 @@ module NumRu
             end
           end
           cs = c.reshape(ms, *idshp_full)
-          bf = cs[-1,false]
-          for i in 0...ms-1
-            bf += cs[i,false]*fv[i]
+          if with_offset
+            bf = cs[-1,false]
+            for i in 0...ms-1
+              bf += cs[i,false]*fv[i]
+            end
+          else
+            bf = cs[-1,false] * 0
+            for i in 0...ms
+              bf += cs[i,false]*fv[i]
+            end
           end
 
         end
@@ -437,6 +504,11 @@ module NumRu
     #   this argument can be used to specify the dimensions that are
     #   not included in +grid_locs+ and are treated as independent, so
     #   the fitting is made for each of their component.
+    # * +with_offset+ (optional) if true (default), constant offset is derived.
+    #   If false, offset is not treated.
+    # * +wgt_func+ (optional) [nil (defualt) or Proc] If Proc, weighting function
+    #   to conduct the weighted least square fit. It should conform with the
+    #   fitting functions.
     # 
     # === RETURN VALUES
     #   [ c, bf, diff ]
@@ -457,7 +529,8 @@ module NumRu
 
 
 
-    def least_square_fit(functions, ensemble_dims=nil, indep_dims=nil)
+    def least_square_fit(functions, ensemble_dims=nil, indep_dims=nil, with_offset=true,
+                         wgt_func = nil)
 
       #< preparation >
 
@@ -476,7 +549,8 @@ module NumRu
 
       #< fitting >
       c, bf, diff = GAnalysis::Fitting.least_square_fit(data, grid_locs, 
-                                          functions, ensemble_dims, indep_dims)
+                           functions, ensemble_dims, indep_dims,
+                           with_offset, wgt_func)
 
       #< make a GPhys of the best fit >
 
@@ -541,12 +615,17 @@ if $0 == __FILE__
   data = x + x*x*0.1
   c, bf, diff = GAnalysis::Fitting.least_square_fit(data, [x], 
                                               [GAnalysis::Fitting::X])
-  p "data:", data, "c:", c, "bf:", bf
-exit
+  p "*1* data:", data, "c:", c, "bf:", bf, "diff:", diff
 
   c, bf, diff = GAnalysis::Fitting.least_square_fit(data, [x], 
                              [GAnalysis::Fitting::X,GAnalysis::Fitting::XX])
-  p c
+  p "*2* data:", data, "c:", c, "bf:", bf, "diff:", diff
+
+  wgt = Proc.new{|x| 1.0 + x**2}
+  c, bf, diff = GAnalysis::Fitting.least_square_fit(data, [x], 
+                             [GAnalysis::Fitting::X,GAnalysis::Fitting::XX],
+                             nil, nil, true, wgt)
+  p "*3* data:", data, "x:", x, "c:", c, "bf:", bf, "diff:", diff
 
   xx = x.newdim(-1)
   data = xx + 2*yy + 100

data/lib/numru/ganalysis/histogram.rb

@@ -43,9 +43,9 @@ module NumRu
       val = gphys0.val
       val = val.get_array![val.get_mask!] if NArrayMiss === val
       val = NMath.log10(val) if log_bins
-      hist.increment(val)
+      val.each{|v| hist.increment(v)}
 
-      bounds = hist.range.to_na
+      bounds =  NArray.to_na(hist.range.to_a)
       bounds = 10 ** bounds if log_bins
       center = (bounds[0..-2]+bounds[1..-1])/2
       cell_width = (bounds[1..-1] - bounds[0..-2]) / 2
@@ -57,7 +57,7 @@ module NumRu
       axis.set_cell(center, bounds, name)
       axis.set_pos_to_center
 
-      bin = hist.bin.to_na
+      bin = NArray.to_na(hist.bin.to_a)
       bin /= cell_width if opts["log_bins"]
       bin = VArray.new(bin,
                        {"long_name" => (log_bins ? "number per unit bin width" : "number in bins"), "units"=>"1"},

data/lib/numru/ganalysis/log_p.rb

@@ -74,6 +74,26 @@ module NumRu
         pi_dz_p_p_dz
       end
 
+      def gph2n2(gph)
+        phi = gph*Met.g
+        phi.units = Units[ phi.units.to_s.sub(/gpm/i,'m') ]
+        phi_zz = pcdata_dz2(phi)
+        phi_z = pcdata_dz(phi)
+        n2 = phi_zz + phi_z * (Met::Kappa/h)
+        n2 = n2.convert_units(Units["s-2"])
+        n2.name = "N2"
+        n2.long_name = "squared log-p buoyancy freq"
+        n2
+      end
+
+      def gph2n(gph)
+        n2 = gph2n2(gph)
+        n = n2.sqrt
+        n.name = "N"
+        n.long_name = "log-p buoyancy freq"
+        n
+      end
+
     end
   end