gphys 1.1.1a

data/lib/numru/gphys/varraynetcdf.rb

@@ -0,0 +1,350 @@
+=begin
+=ToDo list
+* Support a temporay attribute (@tmp_attr = Attribute.new)
+=end
+
+require "numru/netcdf"
+require "numru/gphys/varray"
+require "numru/gphys/attributenetcdf"
+require "numru/gphys/netcdf_convention"
+
+module NumRu
+
+   ###############################
+
+   ### /// for write buffering -->
+
+   class NetCDFVar
+     alias current_put put
+   end              # class NetCDFVar
+
+   module NetCDFDeferred
+      # To be "extend"ed in a NetCDF object to add simgular methods
+      # to support deferred operations.
+      # Used together with NetCDFVarDeferred.
+
+      def add_deferred(proc,args,length)
+	 defined?(@len_stored) ? @len_stored+=length : @len_stored=length
+	 @deferred = Array.new if ! defined?(@deferred) || ! @deferred
+	 @deferred.push( [proc, args] ) 
+      end
+      def flush
+	 if @deferred
+	    @deferred.each{|opr|
+	       if ($DEBUG)
+		  print "## flushing ## "; p opr
+               end
+	       opr[0].call(opr[1])
+	    }
+	    @deferred = nil
+	    NetCDFVarDeferred.flushed_length(@len_stored)
+	    @len_stored = 0
+	 end
+      end
+      def enddef
+	 super
+	 flush
+      end
+      def sync
+	 if define_mode?
+	    enddef
+	    super
+	    redef
+	 else
+	    super
+	 end
+      end
+      def close
+	 enddef
+	 super
+      end
+   end        # module NetCDFDeferred
+
+   #######
+
+   module NetCDFVarDeferred
+      # To be "extend"ed in a NetCDFVar object to add simgular methods
+      # to support deferred operations.
+      # Used together with NetCDFDeferred.
+
+      @@max_len_store = 1000000       # regardress sizeof(type)
+      @@len_stored = 0
+
+      class << self
+	 def flushed_length(len)
+	    @@len_stored -= len
+	 end
+	 def max_len_store; max_len_store; end
+	 def max_len_store= (l)
+	    @@max_len_store = l
+	 end
+      end
+
+      def name=(*args)
+	begin
+	  super(*args)
+	rescue
+	  file.redef
+	  #retry <- this will introduce endless loop
+	  super(*args)
+	end
+      end
+
+      def put_att(*args)
+	begin
+	  super(*args)
+	rescue
+	  file.redef
+	  #retry <- this will introduce endless loop
+	  super(*args)
+	end
+      end
+
+      def put(*args)
+	 if(self.file.define_mode?)
+	    if (@@len_stored < @@max_len_store)
+	       ## put operation is stored in self.file and deferred
+	       print "## storing (put) ##\n" if ($DEBUG)
+	       len = args[0].is_a?(Numeric) ? 1 : args[0].total
+	       self.file.add_deferred( Proc.new{|args| current_put(*args)}, args, len)
+	       @@len_stored += len
+	    else
+	       self.file.enddef
+	       current_put(*args)
+	       self.file.redef
+	    end
+	 else
+	    self.file.flush
+	    current_put(*args)
+	 end
+      end
+   end
+
+   ### <-- for write buffering ///
+
+   ####################################################################
+
+   class VArrayNetCDF < VArray
+
+      ## < initialization redefined > ##
+
+      def initialize(aNetCDFVar)
+	 @name = aNetCDFVar.name
+	 @mapping = nil
+	 @varray = nil
+	 raise ArgumentError,"Not a NetCDVAr" if ! aNetCDFVar.is_a?(NetCDFVar)
+	 @ary = aNetCDFVar
+	 @ary.extend(NetCDFVarDeferred)
+	 @ary.file.extend(NetCDFDeferred)
+	 @attr = AttributeNetCDF.new(aNetCDFVar)
+	 @convention = NetCDF_Conventions.find(aNetCDFVar.file)
+	 extend( @convention::VArray_Mixin )
+      end
+
+      def inspect
+	 "<'#{@name}' in '#{@ary.file.path}'  #{@ary.ntype}#{shape_current.inspect}>"
+      end
+
+      class << self
+	 ## < redefined class methods > ##
+
+         def new2(file, name, ntype, dimensions, vary=nil)
+	   dimensions = dimensions.collect{|dim| 
+	     if dim.is_a?(String)
+	       # specification by name is available for existing dimensions
+	       file.dim(dim) || raise("dimension "+dim+" is not in "+file.path)
+	     else
+	       dim
+	     end
+	   }
+	    va = new( file.def_var(name, ntype, dimensions) )
+            if vary
+	      vary.att_names.each{|name| va.set_att(name, vary.get_att(name))}
+	    end 
+            va
+         end
+
+	 alias def_var new2
+
+	 ## < additional class methods > ##
+
+	 def write(file, vary, rename=nil, dimnames=nil)
+	    raise ArgumentError, "1st arg: not a NetCDF" if !file.is_a?(NetCDF)
+	    raise ArgumentError, "2nd arg: not a VArray" if !vary.is_a?(VArray)
+	    rank=vary.rank
+	    if dimnames == nil
+	       if vary.is_a?(VArrayNetCDF)
+		  dimnames = vary.dim_names
+	       else
+		  dimnames=Array.new
+		  for i in 0...rank
+		     dimnames[i]='x'+i.to_s
+		  end
+	       end
+	    elsif( rank != dimnames.length)
+	       raise ArgumentError, 
+                    "# of dim names does not agree with the rank of the VArray"
+	    end
+	    fdimnms = file.dim_names
+	    begin
+	       shape = vary.shape
+	    rescue StandardError, NameError
+	       shape = vary.shape_ul0
+	    end
+	    dims = Array.new
+	    mode_switched = file.redef
+	    for i in 0...rank
+	       nm = dimnames[i]
+	       if fdimnms.include?(nm)
+		  dims[i] = dm = file.dim(nm)
+		  if dm.length != shape[i] && shape[i] != 0 && dm.length != 0
+		     raise "Length of the dimension #{nm} is #{dims[i].length}, while the #{i}-th dimension of the VArray #{vary.name} is #{shape[i]}"
+                  end
+	       else
+		  dims[i] = file.def_dim(nm,shape[i])
+	       end
+	    end
+	    nm = ( rename || vary.name )
+	    val = vary.val
+	    newvary = new2(file, nm, vary.typecode, dims, vary)
+	    newvary.val = val
+	    if  mode_switched; file.enddef; end
+	    newvary
+	 end
+      end
+
+      ## < redefined instance methods > ##
+
+      def val
+	 mode_switched = @ary.file.enddef
+	 v = @ary.get
+	 if mode_switched; @ary.file.redef; end
+	 v
+      end
+
+      def val=(narray)
+	if narray.is_a?(Numeric)
+	  @ary.put( narray )
+	else
+	  if shape_ul0.include?(0)
+	    # has unlimited dimension
+	    narray = __check_ary_class(narray)
+	    slicer = (0...rank).collect{|i|
+	      (shape_ul0[i] != 0) ? true : 0...narray.shape[i]
+	    }
+	    @ary[*slicer] = narray
+	  else
+	    @ary.put( __check_ary_class(narray) )
+	  end
+	  narray
+	end
+      end
+
+      # It is safer not to have the method "shape" to avoid misconfusion of 
+      # shape_ul0 and shape_current:
+      def shape
+	 raise "The shape method is not available. Use shape_ul0 or shape_current instead."
+      end
+
+      def name=(nm)
+	 @ary.name = nm
+	 @name = nm
+      end
+      def rename!(nm)
+	 @ary.name = nm
+	 @name = nm
+	 self
+      end
+      def rename_no_file_change(nm)
+	 @name = nm
+	 self
+      end
+      def rename(nm)
+	self.dup.rename_no_file_change(nm)
+      end
+
+      def ntype
+	@ary.ntype
+      end
+
+      def total
+	 len = 1
+	 @ary.shape_current.each{|i| len *= i}
+	 len
+      end
+      alias length total
+
+      def rank
+	shape_current.length
+      end
+
+#      def reshape!( *args )
+#	raise "cannot reshape a #{class}. Use copy first to make it a VArray with NArray"
+#      end
+      undef reshape!
+
+      def file
+	 @ary.file
+      end
+
+      ## < additional instance methods > ##
+
+      def dim_names
+	 @ary.dim_names
+      end
+      def shape_ul0
+	 @ary.shape_ul0
+      end
+      def shape_current
+	 @ary.shape_current
+      end
+      def file
+	 @ary.file
+      end
+
+      ## Not needed, so far:
+      #def convention
+      #  @convention
+      #end
+
+   end     # class VArrayNetCDF
+end     # module NumRu
+
+###########################################################
+### < test >
+
+if $0 == __FILE__
+ #  $DEBUG = true
+   include NumRu
+   file = NetCDF.create("tmp.nc")
+   dims = [ file.def_dim("x",10),  file.def_dim("t",0) ]
+   x = VArrayNetCDF.new2(file,"x","sfloat",dims[0..0])
+   x.set_att("units", "km")
+   x.val = 10
+   v = VArrayNetCDF.new2(file,"v","sfloat",dims)
+   v.set_att("units","m/s")
+   v_ = VArrayNetCDF.new2(file,"v_","sfloat",["x","t"])
+   # file.enddef  # (no need to call this)
+   v[0..-1,0] = 99.0
+   v[0..-1,1] = 66.0
+   w = VArrayNetCDF.write(file,v,"w")
+   wsub = w[0..-1,1]
+   wsub.val = 22.0
+   z = VArrayNetCDF.new2(file,"z","sfloat",dims)
+   z.val = NArray.int(10,2).indgen!
+   p w
+   #exit
+
+   file2 = NetCDF.create("tmp2.nc")
+   vv = VArrayNetCDF.write(file2,v,"vv")
+   vv2 = VArrayNetCDF.write(file2,v/3,"vv2")
+   vv3 = VArrayNetCDF.write(file2,v/3,"vv3")
+   v.copy(vv2)
+   (2*v/3).copy(vv3)
+   p "%%%%",(v + w).val,"#####"
+   p v.length
+   p v.file.path
+   p v[0..2,0].file.path
+   file.close
+   file2.close
+end

data/lib/numru/gphys/varraynusdas.rb

@@ -0,0 +1,59 @@
+begin
+  require "numru/nusdas"
+rescue LoadError
+end
+require "numru/gphys/varray"
+
+module NumRu
+
+  class VArrayNuSDaS < VArray
+
+    def initialize(var)
+      unless NuSDaSVar === var
+        raise ArgumentError, "Not a NuSDaSVar"
+      end
+      @name = var.name
+      @mapping = nil
+      @varray = nil
+      @ary = var
+      @attr = Attribute.new
+      var.att_names.each{|name|
+        @attr[name] = var.att(name)
+      }
+    end
+
+    def inspect
+      "<'#{name}' in '#{@ary.nusdas.root}' [#{@ary.shape.join(", ")}]>"
+    end
+
+    def val
+      @ary.get
+    end
+
+    def shape
+      @ary.shape
+    end
+    alias shape_ul0 shape
+    alias shape_current shape
+
+    def total
+      @ary.total
+    end
+    alias length total
+
+    def rank
+      @ary.rank
+    end
+
+    undef reshape!
+
+    def dim_names
+      @ary.dim_names
+    end
+
+    def file
+      @ary.nusdas
+    end
+
+  end
+end

data/lib/numru/gphys.rb

@@ -0,0 +1,9 @@
+# The root file to load the entire gphys package except GGraph.
+
+require 'numru/gphys/gphys'
+require "numru/gphys/gphys_io"
+require 'numru/gphys/gphys_fft'
+require 'numru/gphys_ext'  # extension library
+require 'numru/gphys/interpolate'
+require 'numru/gdir'
+# require 'numru/gphys/ep_flux' # Made optional. Require it explicitly if needed

data/lib/numru/htdir.rb

@@ -0,0 +1,170 @@
+=begin
+=class NumRu::GDir::HtDir
+A class to treat the URL of a "directory" as a directory, with a special
+interpretation for DODS if requested (not by default. You must turn it on
+explicitly by GDir::HtDir.dods_interpret=true).
+
+==Class Methods
+---GDir::HtDir.new(url, proxy=nil)
+   ARGUMENTS
+   url (String) url of a "directory"
+   proxy (String) proxy address and port such as 'proxy.org:8080'
+---GDir::HtDir.proxy=(proxy)
+---GDir::HtDir.dods_interpret=(t_or_f)
+
+==Instance Methods
+---each
+    Iterator for each "file" in the directory. Arguments
+    of the block will be String (as in Dir#each)
+---collect
+---each_dir
+    Like ((<each>)) but limited to iterate over subdirectories.
+---each_file
+    Like ((<each>)) but limited to iterate over files.
+---close
+    close the http connection.
+---rewind
+    Dummy for compatibilty with Dir.
+---body
+    Body of the http response.
+=end
+
+require 'net/http'
+Net::HTTP.version_1_2
+
+module NumRu
+  class GDir
+    class HtDir
+
+      Regexp_URL = /^(http:\/\/)?([\w\-\.]+)(:(\d+))?(\/[\w\-\.\/_~]*)?/
+      Regexp_File = /<img.*alt=\"\[(.*)\]\".*href=\"([^\"]+)\"[^>]*>([^<]*)/i
+      File_Type = {'DIR'=>'directory','TXT'=>'text'}
+
+      @@proxy_host = @@proxy_port = nil
+      @@dods_interpret = false
+
+      class << self
+
+	def dods_interpret; @@dods_interpret; end
+	def dods_interpret=(t_or_f)
+	  @@dods_interpret=t_or_f
+	end
+
+	def proxy_port; @@proxy_port; end
+	def proxy_host; @@proxy_host; end
+	def proxy=(proxy)
+	  if Regexp_URL =~ proxy
+	    @@proxy_host = $2
+	    @@proxy_port = ( $4 ? $4.to_i : 8080 )
+	  else
+	    raise "Invalid Proxy URL: "+proxy
+	  end
+	end
+      end
+
+      def initialize(url, proxy=nil)
+	url += '/' if /\/$/ !~ url    # treat URLs that always end with '/'
+        @url = url
+	if Regexp_URL =~ @url
+	  @host = $2
+	  @port = ( $4 ? $4.to_i : 80 )
+	  @path = $5
+	else
+	  raise "Invalid URL: "+url
+	end
+	if proxy
+	  if Regexp_URL =~ proxy
+	    @proxy_host = $2
+	    @proxy_port = ( $4 ? $4.to_i : 8080 )
+	  else
+	    raise "Invalid Proxy URL: "+proxy
+	  end
+	else
+	  @proxy_host = @@proxy_host
+	  @proxy_port = @@proxy_port
+	end
+	@http = Net::HTTP.new(@host, @port, @proxy_host, @proxy_port)
+	res = @http.get(@path)
+	@body = res.body
+	@files = Array.new
+	@body.each do |line|
+	  if Regexp_File =~ line
+	    fltyp = File_Type[$1]
+	    url = $2
+	    label = $3
+	    if @@dods_interpret
+	      if /Parent Directory/ =~ label
+		url = '..'
+	      else
+		url = File.basename( url.sub(/http:\//,'') )
+	      end
+	      if ( fltyp != 'text' and /\.(\w+)\.html$/ =~ url and
+		   /#{$1}$/ =~ label )
+		# It must be a dods file url with a '.html' suffix
+		url.sub!(/\.html$/,'')
+	      end
+	    end
+	    @files.push( {:file_type=>fltyp, :url=>url} )
+	  end
+	end
+      end
+
+      def body
+	@body
+      end
+
+      def each
+	@files.each do |fl|
+	  yield(fl[:url])
+	end
+      end
+
+      def collect
+	ary = Array.new
+	@files.each do |fl|
+	  ary.push( yield(fl[:url]) )
+	end
+	ary
+      end
+
+      def each_dir
+	@files.each do |fl|
+	  yield(fl[:url]) if fl[:file_type] == 'directory'
+	end
+      end
+
+      def each_file
+	@files.each do |fl|
+	  yield(fl[:url]) if fl[:file_type] != 'directory'
+	end
+      end
+
+      def close
+	@http.finish if @http.active?
+      end
+
+      def rewind
+	# do nothing
+      end
+
+    end  # HtDir
+  end  # GDir
+end  # NumRu
+
+if $0 == __FILE__
+  include NumRu
+  ## GDir::HtDir.proxy='proxy.kuins.net:8080'
+  GDir::HtDir.dods_interpret = true
+
+  htdir = GDir::HtDir.new('http://davis-dods.rish.kyoto-u.ac.jp/cgi-bin/nph-dods/jmadata/gpv/latest/gpv/latest/')
+  print htdir.body
+  htdir.each{|sub| p sub}
+  htdir = GDir::HtDir.new('http://davis-dods.rish.kyoto-u.ac.jp/cgi-bin/nph-dods/jmadata/gpv/latest/gpv/')
+  print htdir.body
+  p htdir.collect{|x| x}
+  htdir.each{|sub| p sub}
+  htdir = GDir::HtDir.new('http://www.gfd-dennou.org/arch/')
+  print htdir.body
+  htdir.each_dir{|sub| p sub}
+  htdir.each_file{|sub| p sub}
+end