ruby-grads 1.0.0

data/lib/grads/command.rb

@@ -0,0 +1,751 @@
+require "tempfile"
+require "open3"
+require "date"
+require "carray"
+
+class GrADS::Command
+
+  class Expression
+    def initialize (expr)
+      @expr = expr
+    end
+    def to_s
+      return @expr
+    end
+    def paren
+      return ["(",@expr,")"].join
+    end
+    alias to_str to_s
+    def -@
+      return Expression.new(["-", self.paren].join)
+    end
+    def +@
+      return Expression.new(["+", self.paren].join)
+    end
+    def + (other)
+      case other
+      when Expression
+        return Expression.new([self.paren,"+",other.paren].join)
+      else
+        return Expression.new([self.paren,"+",other.to_s].join)
+      end
+    end
+    def - (other)
+      case other
+      when Expression
+        return Expression.new([self.paren,"-",other.paren].join)
+      else
+        return Expression.new([self.paren,"-",other.to_s].join)
+      end
+    end
+    def / (other)
+      case other
+      when Expression
+        return Expression.new([self.paren,"/",other.paren].join)
+      else
+        return Expression.new([self.paren,"/",other.to_s].join)
+      end
+    end
+    def * (other)
+      case other
+      when Expression
+        return Expression.new([self.paren,"*",other.paren].join)
+      else
+        return Expression.new([self.paren,"*",other.to_s].join)
+      end
+    end
+    def method_missing (id, *argv)
+      if argv.size > 0
+        return Expression.new(format("#{id}(%s,%s)", @expr, argv.join(",")))
+      else
+        return Expression.new(format("#{id}(%s)", @expr))
+      end
+    end
+  end
+
+  class Variable < Expression
+    def initialize (file_id, name)
+      if file_id
+        @expr = [name,".",file_id].join("")
+      else
+        @expr = name.to_s
+      end
+    end
+    def to_s
+      return @expr
+    end
+    alias to_str to_s
+    def [] (hash)
+      spec = ["(",hash.map{ |k,v| [k,"=",v].join("") }.join(","),")"].join("")
+      return Expression.new([@expr,spec].join(""))
+    end
+    def method_missing (id, *argv)
+      if argv.size == 0
+        return Expression.new(format("#{id}(%s)", @expr))
+      else
+        return Expression.new(format("#{id}(%s,%s)", @expr, argv.join(",")))
+      end
+    end
+  end
+
+  class DataHandler
+    def initialize (file_id)
+      @file_id = file_id
+    end
+    attr_reader :file_id
+    def var (name)
+      return Variable.new(@file_id, name)
+    end
+    def method_missing (id, *argv)
+      if argv.empty?
+        return Variable.new(@file_id, id.to_s)
+      else
+        super
+      end
+    end
+  end
+  
+  def initialize (*argv, &block)
+    if argv.last.is_a?(Hash)
+      options = argv.pop
+    else
+      options = {}
+    end
+    if argv.first
+      grads_command = argv.first
+    else
+      grads_command = "grads"
+    end
+    if options[:batch] 
+      grads_command = grads_command + " -b"
+    end
+    if options[:portrait]
+      grads_command += " -p "
+    elsif options[:landscape]
+      grads_command += " -l "
+    else
+      grads_command += " -l "
+    end
+    begin
+      @io, @stdout, @stderr = Open3.popen3(grads_command)
+    rescue NotImplementedError
+      raise NotImplementedError, "system dosen't support Open3.popen3"
+    end
+    @debug = false
+    @log = ""
+    @imported = []
+    @echoback = false
+    @listen = Thread.start {
+      Thread.abort_on_exception = true
+      begin
+        while line = @stderr.gets ### read(1024)
+          STDERR << line
+          STDERR.flush
+        end
+      rescue IOError ### @stdout may externally closed
+      end
+    }
+    @io.puts "ECHOBACK_TEST_FOR_RUBY_GRADS"
+    while @stdout.gets !~ /Unknown command: ECHOBACK_TEST_FOR_RUBY_GRADS/
+    end
+    @io.puts "ECHOBACK_TEST_FOR_RUBY_GRADS"
+    if @stdout.gets =~ /ga-> ECHOBACK_TEST_FOR_RUBY_GRADS/
+      @echoback = true
+      @stdout.gets
+    else
+      @echoback = false
+    end
+    put "set grads off"
+    put "set timelab off"
+    if block_given?
+      begin
+        case block.arity
+        when 1
+          yield(self)
+        when -1, 0
+          instance_eval(&block)
+        else
+          raise "invalid # of block parameters"
+        end
+      ensure
+        self.quit
+      end
+    end
+  end
+  
+  attr_reader :log
+
+  def method_missing (id, *argv)
+    return id, *argv
+  end
+
+  def quit
+    put("quit")
+    @io.close
+    @listen.join
+    @stdout.close
+    @stderr.close
+  end
+  
+  alias exit quit
+  
+  def put (*args)
+    command = args.join("\n")
+    @log << command << "\n"
+    if @debug
+      STDERR.puts "ga-> " + command 
+    end
+    thread = Thread.start {
+      begin
+        size = command.size
+        s = 0
+        while s < size
+          s += @io.write(command[s, 1024])
+        end
+        @io.puts
+        @io.puts "SIGNAL_FOR_RUBY_GRADS"
+        @io.flush
+      rescue Errno::EPIPE
+      end
+    }
+    output = ""
+    while line = @stdout.gets
+      if @echoback and line =~ /^ga->\s+/
+        next
+      else
+        line.sub!(/^ga->\s+/,'')
+      end
+      case line
+      when /SIGNAL_FOR_RUBY_GRADS/
+        STDERR.print(output) if @debug and not output.empty?
+        return output.chomp
+      when /^(\w+) error: (.*?) /
+        output << line
+        STDERR.print output
+        raise "GRADS Error"
+      else
+        output << line
+      end
+    end
+  ensure
+    thread.join
+  end
+
+  def debug_on
+    @debug = true
+  end
+
+  def debug_off
+    @debug = false
+  end
+
+  def sublin (text, n)
+    return text.split(/\n/)[n-1]
+  end
+
+  def subwrd (text, n)
+    wrd = text.strip.split(/\s*\n\s*|\s+/)[n-1]
+    return wrd ? wrd.strip : ""
+  end
+
+  def open (*argv)
+    text = put "open " + argv.join(" ")
+    file_id = nil
+    text.each_line do |line|
+      if line =~ /is open as file/
+        file_id = subwrd(line, 8).to_i
+        break
+      end
+    end
+    if file_id 
+      return DataHandler.new(file_id)
+    else
+      raise "failed to open file #{argv.first}"
+    end
+  end
+  
+  def close (dh)
+    file_id = dh.file_id
+    put "close #{file_id}"
+  end
+  
+  def xdfopen (*argv)
+    text = put "xdfopen " + argv.join(" ")
+    file_id = nil
+    text.each_line do |line|
+      if line =~ /is open as file/
+        file_id = subwrd(line, 8).to_i
+        break
+      end
+    end
+    if file_id 
+      return DataHandler.new(file_id)
+    else
+      raise "failed to open file #{argv.first}"
+    end
+  end
+
+  def sdfopen (*argv)
+    text = put "sdfopen " + argv.join(" ")
+    file_id = nil
+    text.each_line do |line|
+      if line =~ /is open as file/
+        file_id = subwrd(line, 8).to_i
+        break
+      end
+    end
+    if file_id 
+      return DataHandler.new(file_id)
+    else
+      raise "failed to open file #{argv.first}"
+    end
+  end
+
+  def scan (ctltext)
+    io = Tempfile.open("CA_GrADS_", ".")
+    io.write ctltext
+    io.flush
+    return open(io.path)
+  ensure
+    io.close
+  end
+
+  def xdfscan (ctltext)
+    io = Tempfile.open("CA_GrADS_", ".")
+    io.write ctltext
+    io.flush
+    return xdfopen(io.path)
+  ensure
+    io.close
+  end
+
+  def exec (name, *argv)
+    put "exec #{name} " + argv.flatten.join(" ")
+  end
+
+  def exec_string (definition, *argv)
+    io = Tempfile.open("CA_GrADS_", ".")
+    io.write definition 
+    io.puts
+    io.flush
+    return exec(io.path, *argv)
+  ensure
+    io.close
+  end
+
+  def script (name, definition)
+    io = Tempfile.new("CA_GrADS_", ".")
+    io.write(definition)
+    io.flush
+    instance_eval %{
+      def #{name} (*args)
+        run "#{io.path}", *args
+      end
+    }
+  end
+
+  def set (*argv)
+    put "set " + argv.flatten.join(" ")
+  end
+
+  def display (*argv)
+    if argv.first.is_a?(Array)
+      put "display " + argv.first.map{|v| "("+v.to_s+")" }.join(";")
+    else
+      put "display " + argv.join(" ")
+    end
+  end
+
+  def define (name, expr)
+    put "define #{name} = " + expr
+    return Variable.new(nil, name)
+  end
+
+  def eval (expr)
+    put expr.to_s
+  end
+
+  def enable (id, *argv)
+    case id.to_s
+    when "print"
+      begin
+        put "enable print " + argv.join(" ")
+        yield
+      ensure
+        put "disable print"
+      end
+    else
+      put "enable #{id} " + argv.join(" ")      
+    end
+  end
+
+  def draw (*argv)
+    put "draw " + argv.flatten.join(" ")
+  end
+
+  def redraw (*argv)
+    put "redraw " + argv.flatten.join(" ")
+  end
+
+  [
+    "buffrscan",
+    "collect",
+    "disable",
+    "flush",
+    "modify",
+    "outxwd",
+    "print",
+    "printim",
+    "gxprint",
+    "query",
+    "quit",
+    "reinit",
+    "reset",
+    "run",
+    "sdfwrite",
+    "swap",
+    "undefine",
+  ].each do |name|
+     class_eval %{
+       def #{name} (*argv)
+         put "#{name} " + argv.join(" ")
+       end
+     }  
+  end
+
+  def clear (*argv)
+    @ccols = nil
+    @clevs = nil
+    put "clear " + argv.join(" ")
+  end
+
+  alias d display
+  alias c clear
+  alias q query
+
+  def set_time (*argv)
+    list = []
+    argv.each do |time|
+      timestr = nil
+      case time
+      when DateTime, Time
+        timestr = time.strftime("%H:%Mz%d%b%Y")    
+      when Date
+        timestr = time.strftime("%d%b%Y")
+      when String
+        timestr = time
+      else
+        raise "unknown time variable #{time.inspect}"
+      end
+      list << timestr
+    end
+    set :time, *list
+  end
+
+  def get_time
+    list = query("time").split(/\s+/)
+    if list[2] == list[4]
+      return DateTime.parse(list[2].sub(/Z/," "))
+    else
+      return DateTime.parse(list[2].sub(/Z/," "))..DateTime.parse(list[4].sub(/Z/," "))
+    end
+  end
+
+  def get_time_start
+    list = query("time").split(/\s+/)
+    return DateTime.parse(list[2].sub(/Z/," "))
+  end
+
+  def get_time_end
+    list = query("time").split(/\s+/)
+    return DateTime.parse(list[4].sub(/Z/," "))
+  end
+
+  def get_level
+    return subwrd(sublin(query("dims"),4),6).to_f    
+  end
+
+  def get_value (*argv)
+    var = argv.shift
+    if argv.empty?
+      list = query(:defval, var, 0, 0).split(/\s+/)
+    else
+      list = query(:defval, var, *argv).split(/\s+/)
+    end
+    return list[2].to_f
+  end
+
+  def get_mouse_click (trans = nil)
+    list = query("pos").split(/\s+/)
+    button = list[4].to_i
+    x, y = list[2].to_f, list[3].to_f
+    if trans
+      list = query(trans, x, y).split(/\s+/)
+      x, y = list[2].to_f, list[5].to_f
+    end
+    return x, y, button
+  end
+  
+  def transform (kind, v1, v2)
+    result = query(kind, v1, v2)
+    r1 = subwrd(result, 3)
+    r2 = subwrd(result, 6)
+    return r1, r2
+  end
+  
+  def w2xy (lat, lon)
+    return transform(:w2xy, lat, lon)
+  end
+
+  def w2gr (lat, lon)
+    return transform(:w2gr, lat, lon)
+  end
+
+  def gr2w (fi, fj)
+    return transform(:gr2w, fi, fj)
+  end
+
+  def gr2xy (fi, fj)
+    return transform(:gr2xy, fi, fj)
+  end
+
+  def xy2w (x, y)
+    return transform(:xy2w, x, y)
+  end
+
+  def xy2gr (x, y)
+    return transform(:xy2gr, x, y)
+  end
+
+  def set_clevs (*argv)
+    @clevs = argv
+    set :clevs, *argv
+  end
+
+  def set_ccols (*argv)
+    @ccols = argv
+    set :ccols, *argv
+  end
+  
+  def import (*args)
+    args.each do |name|
+      if @imported.include?(name)
+        next
+      end
+      self.class.module_eval %{
+        def #{name} (*argv)
+          put "#{name} " + argv.join(" ")
+        end
+      }
+      @imported.push name
+    end
+  end
+
+  def imported? (arg)
+    return @imported.include?(arg)
+  end
+
+  def pause
+    get_mouse_click
+  end
+
+  def template2d (sd, *args, &block)
+    return __template__(2, sd, *args, &block)
+  end
+
+  def template3d (sd, *args, &block)
+    return __template__(3, sd, *args, &block)
+  end
+
+  def __template__ (d, sd, *args, &block)
+    if args.last.is_a?(Hash)
+      opts = args.pop
+    else
+      opts = {}
+    end
+    args = args.map{|v| CA_FLOAT(v) }
+    dataio   = Tempfile.open("CA_GrADS_", ".")
+    dataname = dataio.path
+    datactl  = dataname + ".ctl"
+    if sd
+      result   = q :file, sd.file_id
+      ctlfile  = subwrd(sublin(result, 2), 2)
+      ctl = GrADS::Gridded.new(ctlfile)
+    else
+      ref = args.first
+      ctl = GrADS::Gridded::Writer.new
+      case d
+      when 2
+        if ref.rank == 2
+          ctl.define {
+            tdef "1 linear 0z01jan2000 1dy"
+            zdef "1 linear 1 1"
+            ydef ref.dim0, "linear 1 1"
+            xdef ref.dim1, "linear 1 1"
+          }
+        else
+          ctl.define {
+            tdef ref.dim0, "linear 0z01jan2000 1dy"
+            zdef "1 linear 1 1"
+            ydef ref.dim1, "linear 1 1"
+            xdef ref.dim2, "linear 1 1"
+          }
+        end
+      when 3
+        if ref.rank == 3
+          ctl.define {
+            tdef "1 linear 0z01jan2000 1dy"
+            zdef ref.dim0, "linear 1 1"
+            ydef ref.dim1, "linear 1 1"
+            xdef ref.dim2, "linear 1 1"
+          }
+        else
+          ctl.define {
+            tdef ref.dim0, "linear 0z01jan2000 1dy"
+            zdef ref.dim1, "linear 1 1"
+            ydef ref.dim2, "linear 1 1"
+            xdef ref.dim3, "linear 1 1"
+          }
+        end
+      end
+    end
+    ctl.define {
+      if opts[:undef]
+        undef! opts[:undef]
+      else
+        undef! 1e30
+      end
+    }
+    if block
+      ctl.define(&block)
+    end
+    begin
+      names = []
+      ctl.template(datactl) do
+        dset dataname
+        args.each_with_index do |arg, i|
+          names << ( name = "tmpvar#{i}" )
+          case d
+          when 2
+            var2d(name, arg)
+          when 3
+            var3d(name, arg)
+          end
+        end
+      end
+      ss = open(datactl)
+      vars = []
+      names.each do |name|
+        vars << define(name, ss.send(name))
+      end
+      return vars
+    ensure
+      dataio.close
+      File.unlink(datactl)
+    end
+  end
+
+  begin
+    require "netcdflib"
+    def get_var (expr)
+      @var_id ||= 0
+      @var_id += 1
+      filename = "CA_GRADS_#{$$}_#{@var_id}.nc"
+      begin
+        define :grdvar, expr
+        set :sdfwrite, filename
+        sdfwrite :grdvar
+        nc_id = NC.open(filename, NC::NC_NOWRITE)
+        var_id = NC.inq_varid(nc_id, "grdvar")
+        rank = NC.inq_varndims(nc_id, var_id)
+        dim = Array.new(rank)
+        axis = Array.new(rank)
+        dim_ids = NC.inq_vardimid(nc_id, var_id)
+        dim_ids.each_with_index do |dim_id, i|
+          dim[i] = NC.inq_dimlen(nc_id,dim_id) 
+          name = NC.inq_dimname(nc_id,dim_id) 
+          axis_id = NC.inq_varid(nc_id,name)
+          axis[i] = CArray.double(dim[i])
+          NC.get_var(nc_id,axis_id,axis[i])
+          if name == "time"
+            NC.get_att(nc_id, axis_id, "units", str = "")
+            units, inittime = *str.split(/\s*since\s*/)
+            time0 = DateTime.parse(inittime)
+            case units
+            when "minutes"
+              axis[i] = axis[i].convert(:object) {|x| time0 + x.to_i * 1.quo(1440) }
+            else
+              raise "unknown time minutes"
+            end
+          end
+        end
+        data = CArray.double(*dim)
+        NC.get_var(nc_id, var_id, data)
+        miss = CScalar.double
+        NC.get_att(nc_id, var_id, "missing_value", miss)
+        NC.close(nc_id)
+        data[:eq,miss] = UNDEF
+      #ensure
+        File.unlink(filename)
+      end
+      return data, axis.reverse
+    end
+  rescue LoadError
+    begin 
+      require "numru/netcdf"      
+      def get_var (expr)
+        @var_id ||= 0
+        @var_id += 1
+        filename = "CA_GRADS_#{$$}_#{@var_id}.nc"
+        begin
+          define :grdvar, expr
+          set :sdfwrite, filename
+          sdfwrite :grdvar
+          nc = NumRu::NetCDF.open(filename)
+          var = nc.var("grdvar")
+          axis = []
+          var.dim_names.each_with_index do |name,i|
+            axis[i] = nc.var(name).get.ca
+            if name == "time"
+              str = nc.var(name).att("units").get
+              units, inittime = *str.split(/\s*since\s*/)
+              time0 = DateTime.parse(inittime)
+              case units
+              when "minutes"
+                axis[i] = axis[i].convert(:object) {|x| time0 + x.to_i * 1.quo(1440) }
+              else
+                raise "unknown time minutes"
+              end
+            end
+          end
+          miss = var.att("missing_value").get
+          data = var.get.ca
+          data[:eq,miss] = UNDEF
+        ensure
+          File.unlink(filename)
+        end
+        return data, axis.reverse
+      end
+    rescue LoadError
+    end
+  end
+
+end
+
+def GrADS.start (*argv, &block)
+  return GrADS::Command.new(*argv, &block)
+end
+
+def GrADS.script (name, definition)
+  io = Tempfile.new("CA_GrADS_", ".")
+  io.write(definition)
+  io.flush
+  GrADS::Command.class_eval %{
+    def #{name} (*args)
+      run "#{io.path}", *args
+    end
+  }
+end
+
+
+