gphys 1.1.1a

data/lib/numru/ggraph_on_merdional_section.rb

@@ -0,0 +1,178 @@
+require 'numru/ggraph'
+require 'numru/gphys/ep_flux'
+
+############################################################
+
+=begin
+=module NumRu::GGraph in vector_on_merdional_section.rb
+
+This file defines additional method of NumRu::GGraph. This method is for 
+drawing vector on merdional sections.
+
+==Index
+* ((<module NumRu::GGraph>))
+  * ((<vector_on_merdional_section>))
+    Draw vector by selecting the first 2 dimensions 
+    (with GPhys#first2D) if (({gphys})) is more than 3D.
+
+==Module Functions
+
+---vector_on_merdional_section(fx, fy, newframe=true, options=nil)
+    Draw vector by selecting the first 2 dimensions 
+    (with GPhys#first2D) if (({gphys})) is more than 3D.
+
+    ARGUMENTS
+    * fx (GPhys) : a GPhys whose data is plotted x-componet.
+    * fy (GPhys) : a GPhys whose data is plotted y-componet.
+    * newframe (true/false) : if true, calls ((<fig>)), ((<axes>)),
+      ((<title>)), and ((<annotate>)) internally; if false, only
+      the poly-line is drawn (overlaid to the exiting figure).
+    * options (Hash) : options to change the default behavior if specified.
+      It is a Hash with option names (String) as keys and their values.
+      Options are interpreted by a NumRu::Misc::KeywordOptAutoHelp,
+      so you can shorten the keys (by omitting tails) as long as it is 
+      unambiguous.
+       option name     default value # description:
+       "title"         nil           # Title of the figure(if nil, internally 
+                                     # determined)
+       "annotate"      true          # if false, do not put texts on the right
+                                     # margin even when newframe==true
+       "transpose"     false         # if true, exchange x and y axes
+       "flow_vect"     true          # If true, use DCLExt::flow_vect to draw
+                                     # vectors; otherwise, DCL::ugvect is used
+       "xintv"         1             # (Effective only if flow_vect) interval
+                                     # sampling in x of data 
+       "yintv"         1             # (Effective only if flow_vect) interval
+                                     # of data sampling in y 
+       "factor"        1.0           # (Effective only if flow_vect) scaling 
+                                     # factor to strech/reduce the arrow 
+                                     # lengths.
+       "use_before_scale"            #
+                       false         #(Effective only unless flow_vect) If true, 
+                                     # use scale factor before vector.
+       "unit_vect"     false         # Show the unit vector
+       "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.
+
+    RETURN VALUE
+    * nil
+
+=end
+
+############################################################
+
+module NumRu
+
+  module GGraph
+
+    module_function
+
+    def vector_on_merdional_section(fx, fy, newframe=true, options=nil)  
+      if ! defined?(@@vector_on_merdional_section_options)
+        @@vector_on_merdional_section_options = Misc::KeywordOptAutoHelp.new(
+          ['newfig', true, 'if false, do not cleared before figure setting.'],
+          ['title', nil, 'Title of the figure(if nil, internally determined)'],
+          ['annotate', true, 'if false, do not put texts on the right margin even when newframe==true'],
+          ['transpose', false, 'if true, exchange x and y axes'],
+          ['flow_vect', true, 'If true, use DCLExt::flow_vect to draw vectors; otherwise, DCL::ugvect is used.'],
+          ['xintv', 1, '(Effective only if flow_vect) interval of data sampling in x'],
+          ['yintv', 1, '(Effective only if flow_vect) interval of data sampling in y'],
+          ['factor', 1.0, '(Effective only if flow_vect) scaling factor to strech/reduce the arrow lengths'],
+          ['unit_vect', false, 'Show the unit vector'],
+          ['use_before_scale', false, '(Effective only unless flow_vect) If true, use scale factor before vector.'],
+          ['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.']
+        )
+      end
+      opts = @@vector_on_merdional_section_options.interpret(options)
+      fx = fx.first2D.copy
+      fy = fy.first2D.copy
+      sh = fx.shape
+      if sh != fy.shape
+        raise ArgumentError, "shapes of fx and fy do not agree with each other"
+      end
+      fx = fx.transpose(1,0) if opts['transpose']
+      fy = fy.transpose(1,0) if opts['transpose']
+      if ((xi=opts['xintv']) >= 2)
+        idx = NArray.int(sh[0]/xi).indgen!*xi     # [0,xi,2*xi,..]
+        fx = fx[idx, true]
+        fy = fy[idx, true]
+      end
+      if ((yi=opts['xintv']) >= 2)
+        idx = NArray.int(sh[1]/yi).indgen!*yi     # [0,yi,2*yi,..]
+        fx = fx[true, idx]
+        fy = fy[true, idx]
+      end
+      xax = fx.coord(0)
+      yax = fy.coord(1)
+      aphi_ax, z_ax, was_proportional_to_p = \
+            GPhys::EP_Flux::preparate_for_vector_on_merdional_section(xax, yax)
+      if was_proportional_to_p
+	itr = 2 
+      else
+	itr = 1
+      end
+      if newframe
+	nextfig = @@next_fig.dup  if ( @@next_fig != nil ) # backup next_fig
+        fig(xax, yax, {'itr'=>itr}) 
+        axes(xax, yax)
+        if opts['title']
+          ttl = opts['title']
+        else
+          fxnm = fx.data.get_att('long_name') || fx.name
+          fynm = fy.data.get_att('long_name') || fy.name
+          ttl =   '('+fxnm+','+fynm+')'
+        end
+        title( ttl )
+        annotate(fx.lost_axes) if opts['annotate']
+	@@next_fig = nextfig      if ( @@next_fig != nil )
+      end
+      fig(aphi_ax, z_ax, {'new_frame'=>false, 'itr'=>1, 'yreverse'=>false}) \
+                                                          if (opts['newfig'])
+      DCL.uwsgxa(aphi_ax.val) 
+      DCL.uwsgya(z_ax.val)
+      if opts['flow_vect']
+	if opts['use_before_scale']
+	  vxfxratio = @@uninfo[0]; vxfyratio = @@uninfo[1]
+	  before=DCLExt.ug_set_params( {'LNRMAL'=>false, 'LMSG'=>false,
+					 'XFACT1'=>1.0, 'YFACT1'=>1.0} )
+	  DCL.ugvect(vxfxratio*fx.val, vxfyratio*fy.val)
+	  DCLExt.ug_set_params(before) 
+	  if opts['unit_vect']
+	    if opts['max_unit_vect']
+	      DCLExt.unit_vect(*@@uninfo)
+	    else
+	      DCLExt.unit_vect(*@@uninfo[0..1])
+	    end
+	  end
+	else
+	  @@uninfo = DCLExt.flow_vect(fx.val, fy.val, opts['factor'] )
+	  if opts['unit_vect']
+	    if opts['max_unit_vect']
+	      DCLExt.unit_vect(*@@uninfo)
+	    else
+	      DCLExt.unit_vect(*@@uninfo[0..1])
+	    end
+	  end
+	end
+      else
+	if opts['use_before_scale']
+	  vxfxratio = @@uninfo[0]; vxfyratio = @@uninfo[1]
+	  before1=DCLExt.ug_set_params({'lunit'=>true}) if opts['unit_vect']
+	  before2=DCLExt.ug_set_params( {'LNRMAL'=>false, 'LMSG'=>false,
+					 'XFACT1'=>1.0, 'YFACT1'=>1.0} )
+	  DCL.ugvect(vxfxratio*fx.val, vxfyratio*fy.val)
+	  DCLExt.ug_set_params(before1) if opts['unit_vect']
+	  DCLExt.ug_set_params(before2) 
+	else
+	  before=DCLExt.ug_set_params({'lunit'=>true}) if opts['unit_vect']
+	  DCL.ugvect(fx.val, fy.val)
+	  DCLExt.ug_set_params(before) if opts['unit_vect']
+	end
+	nil
+      end
+    end
+  end
+end

data/lib/numru/gphys/assoccoords.rb

@@ -0,0 +1,359 @@
+require "narray"
+#require "numru/gphys_ext"
+
+module NumRu
+
+  # = Associated coordinates
+  #
+  # To use in a Grid in order to support non-rectangular coordnate systems
+  #
+  class AssocCoords
+
+    # * assoc_crds : Array of GPhys
+    # * axnames : Array of axis names of the original Grid
+    #
+    def initialize(assoc_crds, axnames)
+
+      # < argument check >
+      if assoc_crds.uniq.length != assoc_crds.length
+	raise ArgumentError, "Names are not uniq: #{assoc_crds.inspect}."
+      end
+      assoc_crds.each do |gp|
+	raise(ArgumentError,"Non-GPhys included") if !gp.is_a?(GPhys)
+	if axnames.include?(gp.name)
+	  raise ArgumentError, 
+	      "'#{gp.name}' overwraps an axis name #{axnames.inspect}."
+	end
+      end
+
+      # < some internal variables >
+
+      @assoc_crds = Hash.new
+      assoc_crds.each{|gp| @assoc_crds[gp.name] = gp}
+      @axnames = axnames.dup
+      @lost_assoc_crds = nil
+
+      # < lengths of original axes >
+
+      @axlens = Hash.new
+      @axnames.each do |nm|
+        len = nil
+        lens = nil
+        assoc_crds.each do |gp|
+          if gp.axnames.include?(nm)
+            len = gp.axis(nm).length
+            if lens && len!=lens
+              raise("Inconsistency in assoc coord length for ax #{nm}: #{len} (#{gp.name}) vs #{lens}") 
+            end
+            lens = len
+          end
+        end
+        @axlens[nm] = len      # can be nil
+      end
+
+      # < grouping in terms of original-dimension sharing >
+      @groups = Hash.new    # axnames => assoc coord names
+      assoc_crds.each do |gp|
+        pushed = false
+        @groups.each do | axnames, acnames |
+          a = gp.axnames
+          if (axnames - a).length < axnames.length   # included?
+            axnames.concat(a).uniq!
+            acnames.push(gp.name)
+            pushed = true
+            break
+          end
+        end
+        @groups[ gp.axnames ] = [gp.name] if !pushed  # new group
+      end
+
+    end
+
+    attr_reader :assoc_crds, :axnames, :axlens
+    protected :assoc_crds, :axnames
+
+    def merge(other)
+      if other.nil?
+        self
+      else
+        ac = self.assoc_crds.merge(other.assoc_crds)
+        an = (self.axnames + other.axnames).uniq
+        self.class.new(ac,an)
+      end
+    end
+
+    def inspect
+      "<AssocCoords  #{@assoc_crds.collect{|nm,gp| gp.data.inspect}.join("\n\t")}\n\t#{@groups.inspect}>"
+    end
+
+    def copy
+      self.class.new( @assoc_crds.values.collect{|gp| gp.copy}, @axnames )
+    end
+
+    def coord(name)
+      @assoc_crds[name].data   # return a VArray
+    end
+
+    def coord_gphys(name)
+      @assoc_crds[name]   # return a GPhys
+    end
+
+    def has_coord?(name)
+      @assoc_crds.has_key?(name)
+    end
+
+    def coordnames
+      @assoc_crds.keys
+    end
+
+    # assoc_crds �Ɋւ�����W�l�x�[�X�̐؂�o�� : ������ Hash �̂�
+    def cut(hash)
+      cutaxnms = hash.keys
+      newcrds = Array.new
+      slicer_hash = Hash.new
+      @groups.each do |orgaxnms, group|
+        ca2 = cutaxnms - group
+        if ca2.length < cutaxnms.length
+          # Some of cutaxnms are included in group
+          # --> Do cutting regarding this group
+          crds = Array.new
+          crdnms = Array.new
+          crdaxexist = Array.new
+          masks = Array.new   # for NArrayMiss
+          cuts = Array.new
+          group.each do |nm|
+            cutter = hash[nm]
+            if !cutter.nil? && cutter!=true && cutter!=(0..-1)
+              crdnms.push( nm )
+              cuts.push( hash[nm] )
+	      anms = @assoc_crds[nm].axnames
+              crdaxexist.push( NArray.to_na(
+		    orgaxnms.collect{|a| anms.include?(a) ? 1 : 0} ) )
+              v = @assoc_crds[nm].val   # ���W�l (NArray or NArrayMiss)
+              if v.is_a?(NArrayMiss)
+                crds.push(v.to_na)
+                masks.push(v.get_mask)
+              else
+                crds.push(v)
+                masks.push(nil)
+              end
+            end
+          end
+          cuttype = cuts.collect{|x| x.class}.uniq
+          if cuttype.length == 1
+            orgaxlens = @axlens.values_at(*orgaxnms)
+            if cuttype[0] == Range
+	      vmins = Array.new
+	      vmaxs = Array.new
+	      cuts.each do |range|
+		a = range.first
+		b = range.last
+		if (b<a)
+		  vmins.push(b)
+		  vmaxs.push(a)
+		else
+		  vmins.push(a)
+		  vmaxs.push(b)
+		end
+	      end
+              idxs = cut_range(vmins,vmaxs,crds,masks,crdaxexist,orgaxlens)
+            elsif cuttype[0] == Numeric
+              raise "SORRY!  cut_nearest is yet to be implemented."
+              idxs = cut_nearest()  # YET TO BE IMPLEMENT
+            else
+              raise ArgumentError, "Not allowed cutting type (#{cuttype[0]})"
+            end
+            ncrds = group.collect{ |nm| 
+              gp = @assoc_crds[nm]
+              sl = gp.axnames.collect{|anm| idxs[orgaxnms.index(anm)]}
+              gp[ *sl ]
+            }
+            newcrds.concat( ncrds )
+            orgaxnms.each_with_index{|nm,i| slicer_hash[nm] = idxs[i]}
+          else
+            raise "Cutting specification for a group of assoc coords (here, #{group.inspect}) must be uniformly set to either by range or by point -- Cannot mix."
+          end
+        else
+          # None of cutaxnms are included in group --> just copy
+          ncrds = group.collect{ |nm| @assoc_crds[nm] }
+          newcrds.concat( ncrds )
+        end
+        cutaxnms = ca2
+        break if cutaxnms.length == 0     # cutting finished
+      end
+      new_assocoords = self.class.new( newcrds, @axnames )
+      [ new_assocoords, slicer_hash ] 
+    end
+
+    # slicing in terms of the original axes
+    #
+    def [](*args)
+      return self.dup if args.length == 0
+
+      args = __rubber_expansion( args )
+      slicer = Hash.new
+      @axnames.each_with_index{|nm,i| slicer[nm] = args[i]}
+
+      new_assoc_crds = Array.new
+      lost_assoc_crds = Array.new
+      @assoc_crds.each do |dummy, gp|
+        sub = gp[ *( gp.axnames.collect{|nm| slicer[nm] || true} ) ]
+        if sub.rank > 0
+          new_assoc_crds.push( sub )
+        else
+          lost_assoc_crds.push( "#{sub.name}=#{sub.val}" )
+        end
+      end
+
+      ret = self.class.new( new_assoc_crds, @axnames )
+      ret.set_lost_coords( lost_assoc_crds ) if !lost_assoc_crds.empty?
+      ret
+    end
+
+    # make a subset with assoc coords related only to axnames
+    def subset_having_axnames( axnames )
+      acnms = Array.new
+      @groups.each do |ks,vs|
+        acnms.concat(vs) if ( (ks-axnames).length == 0 )  # all of ks present
+      end
+      assoc_crds = acnms.collect{|nm| @assoc_crds[nm]}
+      self.class.new(assoc_crds, axnames)
+    end
+
+    def set_lost_coords( lost_assoc_crds )
+      @lost_assoc_crds = lost_assoc_crds   # Array of String
+      self
+    end
+
+      def lost_coords
+	@lost_assoc_crds.dup
+      end
+
+    def __rubber_expansion( args )
+      if (id = args.index(false))  # substitution into id
+        # false is incuded
+        rank = @axnames.length
+        alen = args.length
+        if args.rindex(false) != id
+          raise ArguemntError,"only one rubber dimension is permitted"
+        elsif alen > rank+1
+          raise ArgumentError, "too many args"
+        end
+        ar = ( id!=0 ? args[0..id-1] : [] )
+        args = ar + [true]*(rank-alen+1) + args[id+1..-1]
+      end
+      args
+    end
+    private :__rubber_expansion
+
+  end
+
+end
+
+
+
+#######################################
+## < test >
+if $0 == __FILE__
+  require "numru/gphys"
+  include NumRu
+  include NMath
+  nx = 10
+  ny = 7
+  nz = 2
+  x = (NArray.sfloat(nx).indgen! + 0.5) * (2*PI/nx)
+  y = NArray.sfloat(ny).indgen! * (2*PI/(ny-1))
+  z = NArray.sfloat(nz).indgen! 
+  vx = VArray.new( x ).rename("x")
+  vy = VArray.new( y ).rename("y")
+  vz = VArray.new( z ).rename("z")
+  xax = Axis.new().set_pos(vx)
+  yax = Axis.new().set_pos(vy)
+  zax = Axis.new().set_pos(vz)
+  xygrid = Grid.new(xax, yax)
+  xyzgrid = Grid.new(xax, yax, zax)
+  p xygrid, xyzgrid
+
+  sqrt2 = sqrt(2.0)
+
+  p = NArray.sfloat(nx,ny)
+  q = NArray.sfloat(nx,ny)
+  for j in 0...ny
+    p[true,j] = NArray.sfloat(nx).indgen!(2*j,1)*sqrt2
+    q[true,j] = NArray.sfloat(nx).indgen!(2*j,-1)*sqrt2
+  end
+  vp = VArray.new( p ).rename("p")
+  vq = VArray.new( q ).rename("q")
+  gp = GPhys.new(xygrid, vp) 
+  gq = GPhys.new(xygrid, vq) 
+
+  r = NArray.sfloat(nz).indgen! * 2
+  vr = VArray.new( r ).rename("r")
+  gr = GPhys.new( Grid.new(zax), vr ) 
+
+  assoc = AssocCoords.new([gp,gq], xyzgrid.axnames)
+  assoc2 = AssocCoords.new([gp,gq,gr], xyzgrid.axnames)
+
+  print "--- AssocCoord objects ---\n"
+  p assoc, assoc2
+  p assoc.coordnames
+  p assoc.axlens
+
+  print "\n----- Subsetting by [] -----\n"
+
+  sa = assoc[0..3,{0..4=>2}]
+  p sa.coord('p').val, sa.coord('q').val
+  p sa.copy
+
+  p assoc[1,2].lost_coords
+
+  print "\n----- Subsetting by cut -----\n"
+
+  ac,sl = assoc.cut('p'=>4.0..10.0)
+  p ac.copy,sl
+  ac2,sl = assoc2.cut('p'=>4.0..10.0)
+  p ac2.copy,sl
+
+  print "\n----- GPhys making -----\n"
+
+  d = sin(x.newdim(1,1)) * cos(y.newdim(0,1)) + z.newdim(0,0)
+  vd = VArray.new( d ).rename("d")
+  gd = GPhys.new(xyzgrid, vd)
+  gd.set_assoc_coords([gp,gq,gr])
+  print "GPhys with associated coordinates:\n"
+  p gd
+
+  print "Coordiantes:\n"
+  p gd.axnames
+  p gd.coordnames
+  p gd.coord("p")
+
+  print "\n--- GPhys Subsetting ---\n"
+  p gd[1..2,0,0].copy
+  p gd[0,false].first2D
+
+  p gd.cut('p'=>4.0..10.0, 'z'=>0).copy
+
+=begin
+  print "\n--- writing in a NetCDF file ---\n"
+  file = NetCDF.create("tmp.nc")
+  GPhys::IO.write(file,gd)
+  file.close
+=end
+
+  print "\n--- GPhys methods that need proper AssocCoord handling ---\n"
+  print "* mean(2)\n"
+  p gd.mean(2)
+  print "* stddev(0)\n"
+  p gd.stddev(0)
+  print "* integrate(0)\n"
+  p gd.integrate(1)
+
+  print "\n--- coord_dim ---\n"
+  grid = gd.grid_copy
+  grid.coordnames.each do |nm|
+    print nm, "  ", grid.coord_dim_indices(nm).inspect, "\n"
+  end
+
+end
+

data/lib/numru/gphys/attribute.rb

@@ -0,0 +1,129 @@
+require "narray"
+
+module NumRu
+=begin
+=class Attribute < Hash
+A Hash class compatible with NetCDF attributes.
+* Values are restricted to NetCDFAttr values
+* Keys must be String or Symbol (Symbol is converted into String such that
+  they are used interchangeably. E.g., attr[:units] == attr["units"] )
+=end
+   class Attribute < Hash 
+      # privatalize all so that public methods must be set explicitly
+      private( *((Hash.instance_methods(false) - Object.new.methods).
+                 collect{|i| i.intern} - [:[], :default]))
+      #":[]" and ":default" should not be private on ruby 1.9. 
+      #Once they become private, super does not work well.
+
+      #protected :[], :[]=   # to be aliased 
+      #-> Alias does not work well in this case on ruby 1.9 !!!
+      public :each, :each_key, :length, :keys, :delete, :delete_if
+      public :has_key?, :include?, :key?, :merge, :update
+
+      def initialize
+	 super
+      end
+
+      class << self
+	 ## < class methods > ##
+
+	 def [](*keyval)
+	    attr = new
+	    0.step(keyval.length-1,2){ |i|
+	       key,val = keyval[i],keyval[i+1]
+	       if key.is_a?(Symbol)
+		  key=key.to_s
+	       elsif ! key.is_a?(String)
+		  raise ArgumentError,"Attribute key must be String or Symbol: #{key} -- #{key.class}."
+	       end
+	       attr[key]=val
+	    }
+	    attr
+	 end
+      end
+
+      ## < methods > ##
+
+      def copy(to=nil)
+	 # deep copy (clone), or addition to "to" if given.
+	 if to == nil
+	    to = NumRu::Attribute.new
+	 end
+	 self.each{|key, val|
+	    if(val)
+	       to[key] = val.clone
+	    else
+	       to[key] = val
+	    end
+	 }
+	 to
+      end
+
+      def [](key)
+	 if key.is_a?(Symbol)
+	    key = key.to_s
+	 elsif ! key.is_a?(String)
+	    raise ArgumentError, "Attribute key must be Symbol or String: #{key} -- #{key.class}." 
+	 end
+	 if /^[A-Za-z_]\w*$/ !~ key
+	   raise ArgumentError, "Attribute key must match /^[A-Za-z_]\w*$/"
+         end
+         super(key)
+      end
+
+      def []=(key, val)
+	 if _val_allowed?(val)
+	    if key.is_a?(Symbol)
+	       key = key.to_s
+	    elsif ! key.is_a?(String)
+	       raise ArgumentError, "Attribute key must be Symbol or String: #{key} -- #{key.class}." 
+	    end
+	    super(key, val)
+	 else
+	    raise ArgumentError, "Not allowed as an attribute value: #{val} (String or NArray/Array of numerics are required`)" 
+	 end
+	 val
+      end
+
+      def rename(key_from, key_to)
+	 v = self[key_from]
+	 if v==nil; raise "attribute #{key_from} does not exist"; end
+         self[key_to]=v
+	 self.delete(key_from)
+      end
+
+      ## < private methods > ##
+      private
+      def _val_allowed?(val)
+	 # to ensure the compatibility with NetCDFAttr
+	 begin
+	    val.is_a?(String) || 
+	    ##   val.is_a?(Numeric) ||   # disabled 2005/03/25 by horinout
+	       val.is_a?(NilClass) ||
+	       ( ( (val.is_a?(NArray) && val.rank==1) || 
+	           (val.is_a?(Array) && val=NArray.to_na(val)) ) &&
+	         val.typecode <= NArray::DFLOAT )
+	 rescue
+	    # for possible error in val=NArray.to_na(val)) above
+	    false
+	 end
+      end
+   end
+end
+
+if __FILE__ == $0
+   a = NumRu::Attribute.new
+   p a
+   a["name"]="takeshi"
+   p a
+   b = @attr = NumRu::Attribute[:name2,"var", :units,"m/s", :valid_range,nil]
+   p b[:units]
+   p b["units"]
+   p b
+   p b["allowd"] = [1,10]
+   begin
+      b["not_allowd"] = [1,10,'no, no']
+   rescue
+      print "(OK): exception raised as expected\n"
+   end
+end