rb-grib 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rb-grib.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,57 @@
+Ruby-GRIB is copyrighted free software by Seiya Nishizawa and the 
+GFD Dennou Club.
+You can redistribute it and/or modify it under either the terms of the
+GPL, or the conditions below, which is idential to Ruby's license
+(http://www.ruby-lang.org/en/LICENSE.txt):
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     See each file for the copying condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.rdoc

@@ -0,0 +1,34 @@
+= What's Ruby-GRIB
+
+Ruby-GRIB is a class library to handle GRIB file.
+
+= Requires
+
+* Ruby (http://www.ruby-lang.org/)
+* NArray (http://narray.rubyforge.org/index.html.en)
+* GRIB API (http://www.ecmwf.int/products/data/software/grib_api.html)
+
+= Install
+
+ # gem install rb-grib
+
+= Usage
+
+To use this library, put the following in your script.
+ require 'numru/grib'
+
+
+= Example
+
+ require 'numru/grib'
+ include NumRu
+
+ filename = "test.grib"
+ grib = Grib.open(filename)
+ varnames = grib.var_names # => Array
+ varnames.each do |vname|
+    var = grib.var(vname) # => GribVar
+    dimnames = var.dim_names # => Array
+    ary = var.get # => NArray
+ end
+ grib.close

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+
+dir_config("grib_api")
+if have_header("grib_api.h") && have_library("grib_api")
+  create_makefile("numru/grib")
+end

data/ext/grib.c

@@ -0,0 +1,435 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "ruby.h"
+#include "grib_api.h"
+#include "narray.h"
+
+
+#define MAX_VALUE_LENGTH 1024
+
+VALUE cGrib;
+VALUE cMessage;
+
+typedef struct {
+  FILE *file;
+  char *fname;
+  grib_handle **handles;
+  int n;
+} rg_file;
+
+typedef struct {
+  VALUE file;
+  grib_handle *handle;
+} rg_message;
+
+static void
+check_error(int code)
+{
+  if (code)
+    rb_raise(rb_eRuntimeError, grib_get_error_message(code));
+};
+
+
+static void
+message_free(rg_message *message)
+{
+  if (message) {
+    free(message);
+  }
+}
+static void
+message_mark(rg_message *message)
+{
+  if (message && message->file != Qnil)
+    rb_gc_mark(message->file);
+}
+static VALUE
+message_alloc(VALUE klass)
+{
+  rg_message *message = ALLOC(rg_message);
+  message->file = Qnil;
+  message->handle = NULL;
+  return Data_Wrap_Struct(klass, message_mark, message_free, message);
+}
+
+static void
+file_close(rg_file *gfile)
+{
+  int i;
+  if (gfile) {
+    if (gfile->handles) {
+      for (i=0; i<gfile->n; i++)
+	if (gfile->handles[i]) grib_handle_delete(gfile->handles[i]);
+      free(gfile->handles);
+      gfile->handles = NULL;
+    }
+    gfile->n = 0;
+    if (gfile->file) {
+      fclose(gfile->file);
+      gfile->file = NULL;
+    }
+    if (gfile->fname) {
+      free(gfile->fname);
+      gfile->fname = NULL;
+    }
+  }
+}
+static void
+file_free(rg_file *gfile)
+{
+  if (gfile) {
+    file_close(gfile);
+    free(gfile);
+  }
+}
+static VALUE
+file_alloc(VALUE klass)
+{
+  rg_file *gfile = ALLOC(rg_file);
+  gfile->file = NULL;
+  gfile->fname = NULL;
+  gfile->handles = NULL;
+  gfile->n = 0;
+  return Data_Wrap_Struct(klass, 0, file_free, gfile);
+}
+
+/*
+  NumRu::Grib.open(filename [, mode]) -> NumRu::Grib::File
+*/
+/*
+static VALUE
+rg_open(int argc, VALUE *argv, VALUE self)
+{
+  VALUE rgfile = file_alloc(self);
+  return rg_file_initialize(argc, argv, rgfile);
+}
+*/
+
+/*
+  NumRu::Grib.multi=(flag) -> True/False
+*/
+static VALUE
+rg_multi(VALUE self, VALUE flag)
+{
+  if (flag == Qtrue)
+    grib_multi_support_on(0);
+  else if (flag == Qfalse)
+    grib_multi_support_off(0);
+  else
+    rb_raise(rb_eArgError, "flag must be true or false");
+  return flag;
+}
+
+/*
+  NumRu::Grib#initialize(filename, [, mode])
+*/
+static VALUE
+rg_file_initialize(int argc, VALUE *argv, VALUE self)
+{
+  char *fname, *mode;
+  VALUE rfname, rmode;
+  rb_scan_args(argc, argv, "11", &rfname, &rmode);
+  fname = StringValueCStr(rfname);
+  if (rmode == Qnil)
+    mode = "r";
+  else
+    mode = StringValueCStr(rmode);
+
+  FILE *file = fopen(fname, mode);
+  if (!file)
+    rb_raise(rb_eRuntimeError, "unable to open file %s", fname);
+
+  rg_file *gfile;
+  Data_Get_Struct(self, rg_file, gfile);
+  gfile->file = file;
+  gfile->fname = ALLOC_N(char, strlen(fname)+1);
+  strcpy(gfile->fname, fname);
+
+  int n = 0;
+  int error;
+  grib_handle *handle;
+  while ((handle = grib_handle_new_from_file(0, file, &error))) {
+    check_error(error);
+    if (handle == NULL)
+      rb_raise(rb_eRuntimeError, "unable to create handle in %s", fname);
+    grib_handle_delete(handle);
+    n++;
+  }
+  rewind(file);
+  grib_handle **handles = ALLOC_N(grib_handle*, n);
+  int i;
+  for (i=0; i<n; i++) handles[i] = NULL;
+  for (i=0; i<n; i++) {
+    handle = grib_handle_new_from_file(0, file, &error);
+    check_error(error);
+    if (handle == NULL)
+      rb_raise(rb_eRuntimeError, "unable to create handle in %s", fname);
+    handles[i] = handle;
+  }
+  gfile->n = n;
+  gfile->handles = handles;
+  return self;
+}
+/*
+  NumRu::Grib#close() -> nil
+ */
+static VALUE
+rg_file_close(VALUE self)
+{
+  rg_file *gfile;
+  Data_Get_Struct(self, rg_file, gfile);
+  file_close(gfile);
+  return Qnil;
+}
+
+/*
+  NumRu::Grib#get_messages() -> Array
+*/
+static VALUE
+rg_file_get_messages(VALUE self)
+{
+  rg_file *gfile;
+  Data_Get_Struct(self, rg_file, gfile);
+  VALUE ary = rb_ary_new2(gfile->n);
+  rg_message *message;
+  VALUE rmessage;
+  int i;
+  for (i=0; i<gfile->n; i++) {
+    rmessage = message_alloc(cMessage);
+    Data_Get_Struct(rmessage, rg_message, message);
+    message->file = self;
+    message->handle = gfile->handles[i];
+    rb_ary_store(ary, i, rmessage);
+  }
+  return ary;
+}
+
+/*
+  NumRu::Grib#path() -> String
+*/
+static VALUE
+rg_file_path(VALUE self)
+{
+  rg_file *gfile;
+  Data_Get_Struct(self, rg_file, gfile);
+  return rb_str_new2(gfile->fname);
+}
+
+/*
+  NumRu::GribMessage#initialize()
+*/
+static VALUE
+rg_message_initialize(VALUE self, VALUE file)
+{
+  rg_message *message;
+  Data_Get_Struct(self, rg_message, message);
+  message->file = file;
+  return self;
+}
+
+/*
+  NumRu::GribMessage#get_keys() -> Array
+*/
+static VALUE
+rg_message_get_keys(int argc, VALUE *argv, VALUE self)
+{
+  VALUE rflag, rns;
+  unsigned long flag = GRIB_KEYS_ITERATOR_SKIP_READ_ONLY || GRIB_KEYS_ITERATOR_SKIP_COMPUTED;
+  //  unsigned long flag = GRIB_KEYS_ITERATOR_ALL_KEYS;
+  char *name_space = NULL;
+  rb_scan_args(argc, argv, "02", &rflag, &rns);
+  if (rflag != Qnil) flag = NUM2ULONG(rflag);
+  if (rns != Qnil) name_space = StringValueCStr(rns);
+    
+  rg_message *message;
+  Data_Get_Struct(self, rg_message, message);
+  grib_keys_iterator *ki = NULL;
+  ki = grib_keys_iterator_new(message->handle, flag, name_space);
+  if (!ki)
+    rb_raise(rb_eRuntimeError, "unable to create key iterator");
+  VALUE keys = rb_ary_new();
+  while (grib_keys_iterator_next(ki)) {
+    const char *name = grib_keys_iterator_get_name(ki);
+    rb_ary_push(keys, rb_str_new2(name));
+  }
+  grib_keys_iterator_delete(ki);
+  return keys;
+}
+
+/*
+  NumRu::GribMessage#get_value(name [,type]) -> String
+*/
+static VALUE
+rg_message_get_value(int argc, VALUE *argv, VALUE self)
+{
+  VALUE rname, rtype;
+  rb_scan_args(argc, argv, "11", &rname, &rtype);
+  char *name = StringValueCStr(rname);
+  int type;
+  rg_message *message;
+  Data_Get_Struct(self, rg_message, message);
+  if (rtype == Qnil)
+    grib_get_native_type(message->handle, name, &type);
+  else
+    type = NUM2INT(rtype);
+  size_t len;
+  VALUE ret = Qnil;
+  grib_get_size(message->handle, name, &len);
+  switch (type) {
+  case GRIB_TYPE_UNDEFINED:
+  case GRIB_TYPE_STRING:
+  case GRIB_TYPE_LABEL:
+    {
+      char value[MAX_VALUE_LENGTH];
+      len = MAX_VALUE_LENGTH;
+      bzero(value, len);
+      if (grib_get_string(message->handle, name, value, &len) == GRIB_SUCCESS) {
+	if (value[len-1] == '\0') len--;
+	ret = rb_str_new(value, len);
+      }
+    }
+    break;
+  case GRIB_TYPE_BYTES:
+    {
+      unsigned char value[MAX_VALUE_LENGTH];
+      len = MAX_VALUE_LENGTH;
+      bzero(value, len);
+      if (grib_get_bytes(message->handle, name, value, &len) == GRIB_SUCCESS)
+	ret = rb_str_new((char*)value, len);
+    }
+    break;
+  case GRIB_TYPE_LONG:
+    {
+      if (len == 1) {
+	long l;
+	if (rtype == Qnil) {
+	  char value[MAX_VALUE_LENGTH];
+	  len = MAX_VALUE_LENGTH;
+	  bzero(value, len);
+	  if (grib_get_string(message->handle, name, value, &len) == GRIB_SUCCESS) {
+	    check_error(grib_get_long(message->handle, name, &l));
+	    if (atol(value) == l)
+	      ret = LONG2NUM(l);
+	    else
+	      ret = rb_str_new2(value);
+	  }
+	} else {
+	  check_error(grib_get_long(message->handle, name, &l));
+	  ret = LONG2NUM(l);
+	}	  
+      } else {
+	int shape[1];
+	struct NARRAY *nary;
+	shape[0] = len;
+	VALUE rnary = na_make_object(NA_LINT, 1, shape, cNArray);
+	GetNArray(rnary, nary);
+	if (grib_get_long_array(message->handle, name, (long*)nary->ptr, &len) == GRIB_SUCCESS)
+	  ret = rnary;
+      }
+    }
+    break;
+  case GRIB_TYPE_DOUBLE:
+    {
+      if (len == 1) {
+	double value;
+	if (grib_get_double(message->handle, name, &value) == GRIB_SUCCESS)
+	  ret = rb_float_new(value);
+      } else {
+	int shape[1];
+	struct NARRAY *nary;
+	shape[0] = len;
+	VALUE rnary = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+	GetNArray(rnary, nary);
+	if (grib_get_double_array(message->handle, name, (double*)nary->ptr, &len) == GRIB_SUCCESS)
+	  ret = rnary;
+      }
+    }
+    break;
+  default:
+    rb_raise(rb_eArgError, "type is invalid: %d", type);
+  }
+  return ret;
+}
+
+/*
+  NumRu::GribMessage#get_data() -> [lon, lat, value]
+*/
+static VALUE
+rg_message_get_data(VALUE self)
+{
+  rg_message *message;
+  Data_Get_Struct(self, rg_message, message);
+  int error;
+  grib_iterator *iter = grib_iterator_new(message->handle, 0, &error);
+  check_error(error);
+  long np;
+  check_error(grib_get_long(message->handle, "numberOfPoints", &np));
+  double *lon, *lat, *value;
+  VALUE na_lon, na_lat, na_value;
+  struct NARRAY *nary;
+  int shape[1];
+  shape[0] = np;
+  na_lon = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  GetNArray(na_lon, nary);
+  lon = (double*) nary->ptr;
+  na_lat = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  GetNArray(na_lat, nary);
+  lat = (double*) nary->ptr;
+  na_value = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+  GetNArray(na_value, nary);
+  value = (double*) nary->ptr;
+  int n = 0;
+  double lo, la, val;
+  while( grib_iterator_next(iter, &la, &lo, &val) ) {
+    lat[n] = la;
+    lon[n] = lo;
+    value[n] = val;
+    n++;
+  }
+  grib_iterator_delete(iter);
+  return rb_ary_new3(3, na_lon, na_lat, na_value);
+}
+
+
+
+void Init_grib()
+{
+  rb_require("narray");
+
+  VALUE mNumRu = rb_define_module("NumRu");
+  cGrib = rb_define_class_under(mNumRu, "Grib", rb_cObject);
+  cMessage = rb_define_class_under(mNumRu, "GribMessage", rb_cObject);
+
+  grib_multi_support_on(0);
+
+  //rb_define_singleton_method(cGrib, "open", rg_open, -1);
+  rb_define_singleton_method(cGrib, "multi=", rg_multi, 1);
+
+  rb_define_alloc_func(cGrib, file_alloc);
+  rb_define_method(cGrib, "initialize", rg_file_initialize, -1);
+  rb_define_method(cGrib, "close", rg_file_close, 0);
+  rb_define_method(cGrib, "get_messages", rg_file_get_messages, 0);
+  rb_define_method(cGrib, "path", rg_file_path, 0);
+
+  rb_define_alloc_func(cMessage, message_alloc);
+  rb_define_method(cMessage, "initialize", rg_message_initialize, 1);
+  rb_define_method(cMessage, "get_keys", rg_message_get_keys, -1);
+  rb_define_method(cMessage, "get_value", rg_message_get_value, -1);
+  rb_define_method(cMessage, "get_data", rg_message_get_data, 0);
+
+  rb_define_const(cGrib, "TYPE_UNDEFINED", INT2NUM(GRIB_TYPE_UNDEFINED));
+  rb_define_const(cGrib, "TYPE_LONG", INT2NUM(GRIB_TYPE_LONG));
+  rb_define_const(cGrib, "TYPE_DOUBLE", INT2NUM(GRIB_TYPE_DOUBLE));
+  rb_define_const(cGrib, "TYPE_STRING", INT2NUM(GRIB_TYPE_STRING));
+  rb_define_const(cGrib, "TYPE_BYTES", INT2NUM(GRIB_TYPE_BYTES));
+  rb_define_const(cGrib, "TYPE_SECTION", INT2NUM(GRIB_TYPE_SECTION));
+  rb_define_const(cGrib, "TYPE_LABEL", INT2NUM(GRIB_TYPE_LABEL));
+  rb_define_const(cGrib, "TYPE_MISSING", INT2NUM(GRIB_TYPE_MISSING));
+
+  rb_define_const(cGrib, "NEAREST_SAME_GRID", ULONG2NUM(GRIB_NEAREST_SAME_GRID));
+  rb_define_const(cGrib, "NEAREST_SAME_DATA", ULONG2NUM(GRIB_NEAREST_SAME_DATA));
+  rb_define_const(cGrib, "NEAREST_SAME_POINT", ULONG2NUM(GRIB_NEAREST_SAME_POINT));
+
+  rb_define_const(cGrib, "KEYS_ITERATOR_ALL_KEYS", ULONG2NUM(GRIB_KEYS_ITERATOR_ALL_KEYS));
+  rb_define_const(cGrib, "KEYS_ITERATOR_SKIP_READ_ONLY", ULONG2NUM(GRIB_KEYS_ITERATOR_SKIP_READ_ONLY));
+}

data/lib/numru/grib.rb

@@ -0,0 +1,2 @@
+require "numru/grib/version"
+require "numru/grib/grib.rb"

data/lib/numru/grib/grib.rb

@@ -0,0 +1,528 @@
+require "narray_miss"
+require "date"
+require "numru/grib.so"
+
+
+module NumRu
+  class Grib
+    class << self
+      # cache due to momery leak in the original grib_api library
+      @@gribs = Hash.new
+      def is_a_Grib?(fname)
+        is = false
+        File.open(fname) do |file|
+          is = (file.read(4) == "GRIB")
+        end
+        return is
+      end
+      alias :_new :new
+      def new(fname, mode="r")
+        key = [fname,mode]
+        if (obj = @@gribs[key])
+          obj[1] += 1
+          return obj[0]
+        else
+          grib = _new(fname, mode)
+          @@gribs[key] = [grib, 1]
+          return grib
+        end
+      end
+      alias :open :new
+    end # class << self
+
+    alias :_close :close
+    def close
+      @@gribs.each do |k, val|
+        if self == val[0]
+          val[1] -= 1
+          if val[1] < 1
+            _close
+            @@gribs.delete(k)
+            return true
+          end
+        end
+      end
+      return false
+    end
+
+    def var_names
+      parse_vars unless @vars
+      return @vars.keys
+    end
+    def var(name)
+      parse_vars unless @vars
+      var = @vars[name]
+      return nil if var.nil?
+      return ::NumRu::GribVar.parse(self, var, name)
+    end
+    def inspect
+      "Grib: #{path}"
+    end
+    private
+    def parse_vars
+      vars = Hash.new
+      get_messages.each do |msg|
+        name = msg.sname
+        # zn = msg.z_sname
+        # name << "_" << zn unless /\A(pl|isobaricIn)/ =~ zn
+        hash = (vars[name] ||= Hash.new)
+        nij = [msg.get_value("Ni"), msg.get_value("Nj"), msg.gtype, msg.z_type]
+        if hash[nij]
+          hash[nij][1].push msg
+        else
+          hash[nij] = [hash.length, [msg]]
+        end
+      end
+      @vars = Hash.new
+      vars.each do |name,hash|
+        if hash.length == 1
+          @vars[name] = hash.values[0][1]
+        else
+          hash.each do |k,ary|
+            @vars[name+"_"+ary[0].to_s] = ary[1]
+          end
+        end
+      end
+    end
+  end # class Grib
+
+  class GribMessage
+    def name
+      n = get_value("name")
+      return n if (n && n != "unknown")
+      get_value("parameterName") || get_value("indicatorOfParameter")
+    end
+    def sname
+      sn = get_value("shortName")
+      return sn if (sn && sn != "unknown")
+      "id" + (get_value("indicatorOfParameter", ::NumRu::Grib::TYPE_LONG) || get_value("parameterNumber", ::NumRu::Grib::TYPE_LONG)).to_s
+    end
+    def units
+      get_value("parameterUnits") || get_value("units")
+    end
+    alias :unit :units
+    def z_type
+      zt = get_value("typeOfLevel")
+      return zt if zt && zt != "unknown"
+      z_sname
+    end
+    def z_sname
+      get_value("indicatorOfTypeOfLevel") || get_value("typeOfLevel") || "level"
+    end
+    def z_value
+      get_value("level")
+    end
+    def z_units
+      get_value("pressureUnits")
+    end
+    def date
+      d = get_value("dataDate").to_s.rjust(8,"0")
+      h = get_value("dataTime").to_s.rjust(4,"0")
+      return DateTime.parse(d << h)
+    end
+    def forecast_time
+      get_value("forecastTime")
+    end
+    def time_interval
+      get_value("lengthOfTimeRange")
+    end
+    def step_units
+      get_value("stepUnits")
+    end
+    MEMBER_NAME = {1 => "", 2 => "n", 3 => "p"}
+    def ensemble_member
+      pn = get_value("perturbationNumber")
+      te = get_value("typeOfEnsembleForecast")
+      name = ""
+      name << pn.to_s if pn
+      name << (MEMBER_NAME[te] || te.to_s) if te
+      name
+    end
+    def gtype
+      get_value("typeOfGrid")
+    end
+    def missing_value
+      get_value("missingValue")
+    end
+    def get_xy
+      lo, la, = get_data
+      case gtype
+      when "regular_ll", "regular_gg"
+        lon = Hash.new
+        lat = Hash.new
+        if get_value("jPointsAreConsecutive") == 1
+          lon["ij"] = 1
+          lat["ij"] = 0
+          shape = [get_value("Nj"), get_value("Ni")]
+        else
+          lon["ij"] = 0
+          lat["ij"] = 1
+          shape = [get_value("Ni"), get_value("Nj")]
+        end
+        lo.reshape!(*shape)
+        la.reshape!(*shape)
+        lon["short_name"] = "lon"
+        lon["long_name"] = "longitude"
+        lon["units"] = "degrees_east"
+        idx = [0,0]; idx[lon["ij"]] = true
+        lon["value"] = lo[*idx]
+        lat["short_name"] = "lat"
+        lat["long_name"] = "latitude"
+        lat["units"] = "degrees_north"
+        idx = [0,0]; idx[lat["ij"]] = true
+        lat["value"] = la[*idx]
+        return [lon,lat]
+      else
+        raise "not defined yet: #{gtype}"
+      end
+    end
+  end # class GribMessage
+
+  class GribVar
+    Day0 = DateTime.new(1900)
+    MAXNDIM = 7 # lon, lat, lev, t, forecastTime, timeInterval, ensemble
+    class << self
+      def parse(file,msgs,name)
+        msg = msgs[0]
+        va = ::NumRu::GribVar.new(file,name)
+        va.put_att("long_name", msg.name)
+        # va.put_att("standard_name",std_name)
+        va.put_att("units",msg.units) if msg.units
+        va.put_att("grid_type", msg.gtype)
+        va.put_att("missing_value", [msg.missing_value]) if msg.missing_value
+        vdim = Array.new
+        xy_dims = 0
+        msg.get_xy.sort{|x,y| x["ij"]<=>y["ij"] }.each do |xy|
+          val = xy.delete("value")
+          sname = xy.delete("short_name")
+          ij = xy.delete("ij")
+          if val.length > 1
+            d = va.def_dim(sname, -1)
+            d.put(val)
+            xy.each{|k,v| d.put_att(k,v)}
+            xy_dims += 1
+          else
+            #xy.each{|k,v| va.put_att(k,v)}
+          end
+        end
+        z = Array.new
+        t = Array.new
+        ft = Array.new
+        ti = Array.new
+        en = Array.new
+        hash = Hash.new
+        msgs.each_with_index do |msg,i|
+          zv = msg.z_value
+          tv = get_time(msg.date)
+          ftv = msg.forecast_time
+          tiv = msg.time_interval
+          env = msg.ensemble_member
+          z.push zv
+          t.push tv
+          ft.push ftv
+          ti.push tiv
+          en.push env
+          ary = [zv,tv,ftv,tiv,env]
+          if hash[ary] # error
+            m1 = msgs[hash[ary]]
+            m2 = msgs[i]
+            a1 = m1.get_keys.map{|k| [k,m1.get_value(k)]}
+            a2 = m2.get_keys.map{|k| [k,m2.get_value(k)]}
+            a = Array.new
+            a1.length.times{|j| a.push [a1[j],a2[j]] if a1[j]!=a2[j]}
+            warn "BUG: send the following message to the developers"
+            p ary
+            p a
+            raise("error") 
+          end
+          hash[ary] = i
+        end
+        hash = hash.invert
+        [z, t, ft, ti, en].each{|a| a.uniq!}
+#        [z, t, ft, ti, en].each{|a| a.uniq!; a.sort!}
+        idx = Array.new(msgs.length) do |i|
+          zv, tv, ftv, tiv, env = hash[i]
+          [z.index(zv), t.index(tv), ft.index(ftv), ti.index(tiv), en.index(env)]
+        end
+        del_dims = Array.new
+        if z.length == 1
+          va.put_att("level_type", msg.z_type)
+          va.put_att("level_value", [z[0]])
+          va.put_att("level_units", msg.z_units) if msg.z_units
+          del_dims.push xy_dims
+        else
+          d = va.def_dim(msg.z_sname, -1)
+          d.put_att("long_name", msg.z_type)
+          d.put_att("units", msg.z_units) if msg.z_units
+          d.put(NArray.to_na(z))
+        end
+        if t.length == 1
+          va.put_att("time", msg.date.to_s)
+          del_dims.push xy_dims + 1
+        else
+          d = va.def_dim("time", -1)
+          d.put_att("long_name","time")
+          d.put_att("units","hours since #{Day0.strftime('%Y-%m-%d %H:%M:%S')}")
+          d.put(NArray.to_na(t))
+        end
+        if ft.length == 1
+          va.put_att("forecast_time", [msg.forecast_time]) if msg.forecast_time
+          va.put_att("forcast_time_units", msg.step_units) if msg.step_units
+          del_dims.push xy_dims + 2
+        else
+          d = va.def_dim("forecast_time", -1)
+          d.put_att("long_name", "forecast_time")
+          d.put_att("units", msg.step_units) if msg.step_units
+          d.put(NArray.to_na(ft))
+        end
+        if ti.length == 1
+          del_dims.push xy_dims + 3
+        else
+          d = va.def_dim("time_interval", -1)
+          d.put_att("long_name", "time_interval")
+          d.put_att("units", msg.step_units) if msg.step_units
+          d.put(NArray.to_na(ti))
+        end
+        if en.length == 1
+          del_dims.push xy_dims + 4
+        else
+          d = va.def_dim("member", -1)
+          d.put_att("long_name", "ensemble_member")
+          d.put(NArray.to_na(en))
+        end
+        va.set_msgs(msgs, idx, xy_dims, del_dims)
+        return va
+      end
+      def get_time(date)
+        ((date - Day0)*24).to_f
+      end
+    end # class << self
+    attr_reader :file, :name
+    def initialize(file,name)
+      @file = file
+      @name = name
+      @attr = Hash.new
+      @dims = Array.new
+    end
+    def set_msgs(msgs, idx, xy_dims, del_dims)
+      @msgs = msgs
+      @idx = idx
+      @xy_dims = xy_dims
+      @del_dims = del_dims
+    end
+    def rank
+      @dims.length
+    end
+    alias :ndims :rank
+    def total
+      @dims.inject(1){|t,d| t*d.length}
+    end
+    def dim_names
+      @dims.collect{|d| d.name}
+    end
+    def shape
+      @dims.collect{|d| d.length}
+    end
+    def dim(index)
+      index = dim_names.index(index) if String===index
+      return nil if index.nil?
+      @dims[index]
+    end
+    def def_dim(name,index)
+      d = ::NumRu::GribDim.new(self,name)
+      if index == -1
+        @dims.push(d)
+      else
+        @dims[index] = d
+      end
+      return d
+    end
+    def put_att(key,val)
+      @attr[key] = val
+    end
+    alias :set_att :put_att
+    def att(key)
+      @attr[key]
+    end
+    def att_names
+      @attr.keys
+    end
+    def typecode
+      if missing_value
+        NArrayMiss::DFLOAT
+      else
+        NArray::DFLOAT
+      end
+    end
+    def missing_value
+      @msgs[0].missing_value
+    end
+    def get(*indices)
+      sha = shape
+      mask = nil
+      first = Array.new(rank-@xy_dims,0)
+      if indices.length != 0
+        if indices[0] == false
+          indices[0] = [true]*(sha.length-indices.length+1)
+        elsif indices[-1] == false
+          indices[-1] = [true]*(sha.length-indices.length+1)
+        elsif indices.include?(false) || indices.length != rank
+          raise "invalid indices"
+        end
+        rank.times{|n|
+          ind = indices[n]
+          case ind
+          when true
+            indices[n] = 0..sha[n]-1
+          when Fixnum
+            sha[n] = 1
+          when Range
+            f = ind.first
+            e = ind.end
+            e = sha[n]-1 if e==-1
+            e -= 1 if ind.exclude_end?
+            sha[n] = e-f+1
+            indices[n] = f..e
+          else
+            raise "invalid indices"
+          end
+        }
+        if rank > @xy_dims
+          mask = NArray.byte(*shape[@xy_dims..-1])
+          mask[*indices[@xy_dims..-1]] = 1
+          (rank-@xy_dims).times do |i|
+            ind = indices[@xy_dims+i]
+            case ind
+            when Fixnum
+              first[i] = ind
+            when Range
+              first[i] = ind.first
+              first[i] += shape[@xy_dims+i] if first[i] < 0
+            end
+          end
+        end
+      end
+
+      shape2 = shape.dup
+      sha2 = sha.dup
+      @del_dims.each do |i|
+        shape2.insert(i,1)
+        sha2.insert(i,1)
+        first.insert(i-@xy_dims,0)
+      end
+      mask.reshape!(*shape2[@xy_dims..-1]) if mask
+      
+      value = missing_value ? NArrayMiss.sfloat(*sha2) : NArray.sfloat(*sha2)
+      index = Array.new(MAXNDIM-2)
+      @msgs.each_with_index do |msg,i|
+        idx = @idx[i]
+        next if (mask && mask[*idx]==0)
+        val = msg.get_value("values")
+        if @xy_dims > 0
+          val.reshape!(*shape[0...@xy_dims])
+          #        val = msg.get_data[2].reshape!(*shape[0...@xy_dims])
+          unless indices.length==0 || indices[0...@xy_dims].inject(true){|t,v| t &&= v==true}
+            val = val[*indices[0...@xy_dims]]
+          end
+        end
+        (MAXNDIM-2).times do |i| index[i] = idx[i]-first[i] end
+        value[*(Array.new(@xy_dims,true)+index)] = val
+      end
+      ns = sha.length
+      ns.times do |ii|
+        i = ns-ii-1
+        sha.delete_at(i) if indices[i].kind_of?(Fixnum)
+      end
+      value.reshape!(*sha)
+      if missing_value
+        value.set_mask value.get_array!.ne(missing_value)
+      end
+      return value
+    end
+    alias :[] :get
+    alias :val :get
+    def inspect
+      "GribVar: #{name} in #{@file.path}, [#{shape.join(",")}]"
+    end
+  end # class GribVar
+
+  class GribDim
+    attr_reader :var, :length, :name
+    def initialize(var,name)
+      @var = var
+      @name = name
+      @attr = Hash.new
+    end
+    alias :total :length
+    def get
+      @ary
+    end
+    def typecode
+      if NArray===@ary
+        @ary.typecode
+      elsif Array===@ary
+        @ary[0]["value"].typecode
+      end
+    end
+    def val
+      return @ary
+    end
+    def [](*ind)
+      return val[*ind]
+    end
+    def put(ary)
+      @ary = ary
+      @length = val.length
+      return @ary
+    end
+    def put_att(key,val)
+      @attr[key]=val
+    end
+    alias :set_att :put_att
+    def att(key)
+      @attr[key]
+    end
+    def att_names
+      @attr.keys
+    end
+    def inspect
+      "GribDim: #{name} length=#{length}"
+    end
+  end # class GribDim
+
+end # module NumRu
+
+
+
+
+
+#####################################################
+if $0 == __FILE__
+
+  include NumRu
+
+  if ARGV.length>0
+    infname = ARGV.shift
+  else
+    infname = "../../../testdata/T.jan.grib"
+  end
+
+
+  Grib.is_a_Grib?(infname) || raise("file is not a Grib dataset")
+  p grib = Grib.open(infname)
+
+
+
+  print "\nVars\n"
+  grib.var_names.each{|vn|
+    p v = grib.var(vn)
+    p v.dim_names
+    v.dim_names.each{|dn| p dn; p v.dim(dn).get }
+    p v.shape
+    v.att_names.each{|an| print an, " => ", v.att(an), "\n" }
+    puts "\n"
+    p v.val
+  }
+
+
+end

data/lib/numru/grib/version.rb

@@ -0,0 +1,5 @@
+module NumRu
+  class Grib
+    VERSION = "0.1.0"
+  end
+end

data/rb-grib.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "numru/grib/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rb-grib"
+  s.version     = NumRu::Grib::VERSION
+  s.authors     = ["Seiya Nishizawa"]
+  s.email       = ["seiya@gfd-dennou.org"]
+  s.homepage    = "http://ruby.gfd-dennu.org/products/rb-grib/"
+  s.summary     = %q{Ruby class library to hanlde GRIB file}
+  s.description = %q{This class library enable you to handle GRIB file.}
+
+  s.rubyforge_project = "rb-grib"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.extensions << "ext/extconf.rb"
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: rb-grib
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Seiya Nishizawa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-29 00:00:00 Z
+dependencies: []
+
+description: This class library enable you to handle GRIB file.
+email: 
+- seiya@gfd-dennou.org
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- ext/extconf.rb
+- ext/grib.c
+- lib/numru/grib.rb
+- lib/numru/grib/grib.rb
+- lib/numru/grib/version.rb
+- rb-grib.gemspec
+homepage: http://ruby.gfd-dennu.org/products/rb-grib/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rb-grib
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Ruby class library to hanlde GRIB file
+test_files: []
+