rb-grib 0.1.4 → 0.2.0

data/.gitignore

@@ -2,3 +2,7 @@
 .bundle
 Gemfile.lock
 pkg/*
+ext/Makefile
+ext/mkmf.log
+ext/*.o
+ext/*.so

data/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 2011 Seiya Nishizawa and GFD Dennou Club. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/Gemfile

@@ -2,3 +2,7 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in rb-grib.gemspec
 gemspec
+
+group :development do
+  gem "rspec"
+end

data/LICENSE.txt

@@ -1,8 +1,7 @@
-Ruby-GRIB is copyrighted free software by Seiya Nishizawa and the 
-GFD Dennou Club.
+rb-GRIB is copyrighted free software by Seiya Nishizawa <seiya@gfd-dennou.org>
+and 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):
+2-clause BSDL (see the file BSDL), or the conditions below:
 
   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
@@ -19,31 +18,33 @@ GPL, or the conditions below, which is idential to Ruby's license
        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.
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
 
        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:
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
 
-       a) distribute the executables and library files of the software,
+       a) distribute the binaries 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
+       c) give non-standard binaries 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.
+     are not written by the authors, so that they are not under these terms.
 
-     See each file for the copying condition.
+     The data files in the "data" directory are provided by GRIB API
+     (http://www.ecmwf.int/products/data/software/grib_api.html)
+     under the GNU Lesser General Public License.
 
   5. The scripts and library files supplied as input to or produced as 
      output from the software do not automatically fall under the

data/README.rdoc

@@ -2,16 +2,31 @@
 
 rb-GRIB is a class library to handle GRIB file.
 
+
+= rb-GRIB home-page
+
+The URL of the rb-GRIB home-page is:
+ http://ruby.gfd-dennou.org/products/rb-grib/
+
+
 = Requires
 
 * Ruby (http://www.ruby-lang.org/)
 * NArray (http://narray.rubyforge.org/index.html.en)
+* NArrayMiss (http://ruby.gfd-dennou.org/products/narray_miss/)
 * GRIB API (http://www.ecmwf.int/products/data/software/grib_api.html)
 
+
 = Install
 
  # gem install rb-grib
 
+
+= Copying
+
+See the file LICENSE.txt.
+
+
 = Usage
 
 To use this library, put the following in your script.
@@ -32,3 +47,11 @@ To use this library, put the following in your script.
     ary = var.get # => NArray
  end
  grib.close
+
+
+= The Author
+
+Feel free to send comments and bug reports to the author.
+The author's e-mail addess is
+
+ seiya@gfd-dennou.org

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run all spec"
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/ext/grib.c

@@ -7,63 +7,264 @@
 
 #define MAX_VALUE_LENGTH 1024
 
+// error check
+static void
+check_error(int code)
+{
+  if (code) rb_raise(rb_eRuntimeError, grib_get_error_message(code));
+};
+
+
+
+
+// flexible length array
+#define BUF_SIZE 256
+#define MAX_BUF_NUM 1000
+typedef struct {
+  grib_handle ***buffer;
+  size_t size;
+  size_t len;
+} msg_array;
+static msg_array*
+alloc_msg_array(void)
+{
+  msg_array *ary = ALLOC(msg_array);
+  if (ary) {
+    ary->buffer = (grib_handle***) malloc(sizeof(grib_handle**)*MAX_BUF_NUM);
+    if (ary->buffer) {
+      ary->buffer[0] = (grib_handle**) malloc(sizeof(grib_handle*)*BUF_SIZE);
+      if (ary->buffer[0]) {
+	ary->size = BUF_SIZE;
+	ary->len = 0;
+	return ary;
+      }
+      free(ary->buffer);
+    }
+    free(ary);
+  }
+  return NULL;
+}
+static
+void free_msg_array(msg_array *ary)
+{
+  int i, j;
+  int num = ary->size/BUF_SIZE;
+  int len;
+  for (i=0; i<num; i++) {
+    len = i==num-1 ? ary->len%BUF_SIZE : BUF_SIZE;
+    for (j=0; j<len; j++) grib_handle_delete(ary->buffer[i][j]);
+    free(ary->buffer[i]);
+  }
+  free(ary->buffer);
+  free(ary);
+}
+static void
+push_msg(msg_array *ary, grib_handle *handle)
+{
+  int idx = ary->size/BUF_SIZE-1;
+  if (ary->len >= ary->size) {
+    idx += 1;
+    if (idx < MAX_BUF_NUM) {
+      ary->buffer[idx] = (grib_handle**)malloc(sizeof(grib_handle*)*BUF_SIZE);
+      if (ary->buffer[idx]) {
+	ary->size += BUF_SIZE;
+      } else {
+	rb_raise(rb_eRuntimeError, "cannot allocate memory");
+      }
+    } else {
+      rb_raise(rb_eRuntimeError, "cannot allocate memory");
+    }
+  }
+  ary->buffer[idx][ary->len%BUF_SIZE] = handle;
+  ary->len += 1;
+}
+static grib_handle*
+get_msg(msg_array *ary, size_t index)
+{
+  if (index < ary->len) {
+    return ary->buffer[index/BUF_SIZE][index%BUF_SIZE];
+  } else {
+    rb_raise(rb_eRuntimeError, "index exceed size of array");
+  }
+  return NULL;
+}
+
+
+// variable list
+typedef struct var_list var_list;
+struct var_list {
+  char *vname;
+  long ni;
+  long nj;
+  char *gtype;
+  long ltype_id;
+  char *ltype;
+  msg_array *ary;
+  var_list *next;
+  VALUE file;
+};
+static var_list*
+var_list_alloc(VALUE file)
+{
+  var_list *var = ALLOC(var_list);
+  if (var) {
+    var->ary = alloc_msg_array();
+    if (var->ary) {
+      var->vname = (char*) malloc(sizeof(char)*MAX_VALUE_LENGTH*2);
+      if (var->vname) {
+	var->gtype = (char*) malloc(sizeof(char)*MAX_VALUE_LENGTH);
+	if (var->gtype) {
+	  var->ltype = (char*) malloc(sizeof(char)*MAX_VALUE_LENGTH);
+	  if (var->ltype) {
+	    var->next = NULL;
+	    var->file = file;
+	    return var;
+	  }
+	  free(var->gtype);
+	}
+	free(var->vname);
+      }
+      free_msg_array(var->ary);
+    }
+    free(var);
+  }
+  return NULL;
+}
+static void
+var_list_free(var_list *var)
+{
+  var_list *next;
+  while(var) {
+    free_msg_array(var->ary);
+    free(var->vname);
+    free(var->gtype);
+    free(var->ltype);
+    var->file = Qnil;
+    next = var->next;
+    free(var);
+    var = next;
+  }
+}
+static void
+push_msg_var(var_list **pvar, grib_handle *handle, VALUE file)
+{
+  size_t len = MAX_VALUE_LENGTH;
+  char vname[MAX_VALUE_LENGTH];
+  bzero(vname, len);
+  if (grib_get_string(handle, "shortName", vname, &len) != GRIB_SUCCESS ||
+      strcmp("unknown", vname) == 0) {
+    long id;
+    if (grib_get_long(handle, "indicatorOfParameter", &id) == GRIB_SUCCESS ||
+	grib_get_long(handle, "parameterNumber", &id) == GRIB_SUCCESS) {
+      sprintf(vname, "id%ld", id);
+    } else {
+      printf("%s\n", vname);
+      rb_raise(rb_eRuntimeError, "cannot get variable name");
+    }
+  }
+  long ni, nj, ltype_id;
+  char gtype[MAX_VALUE_LENGTH];
+  len = MAX_VALUE_LENGTH;
+   if (grib_get_long(handle, "Ni", &ni) != GRIB_SUCCESS ||
+      grib_get_long(handle, "Nj", &nj) != GRIB_SUCCESS ||
+       grib_get_string(handle, "typeOfGrid", gtype, &len) != GRIB_SUCCESS ||
+       (grib_get_long(handle, "indicatorOfTypeOfLevel", &ltype_id) != GRIB_SUCCESS && grib_get_long(handle, "typeOfFirstFixedSurface", &ltype_id) != GRIB_SUCCESS)) {
+    rb_raise(rb_eRuntimeError, "connot identify grid type");
+  }
+  var_list *last = NULL;
+  var_list *var = pvar[0];
+  if (var) {
+    while (var) {
+      if (strcmp(var->vname, vname)==0 && var->ni == ni && var->nj == nj && strcmp(var->gtype,gtype)==0 && var->ltype_id==ltype_id) {
+	push_msg(var->ary, handle);
+	return;
+      }
+      last = var;
+      var = var->next;
+    }
+  }
+  var_list *var_new = var_list_alloc(file);
+  if (var_new == NULL)
+    rb_raise(rb_eRuntimeError, "cannot allocate memory");
+  var_new->ni = ni;
+  var_new->nj = nj;
+  var_new->ltype_id = ltype_id;
+  strcpy(var_new->vname, vname);
+  strcpy(var_new->gtype, gtype);
+  len = MAX_VALUE_LENGTH;
+  check_error(grib_get_string(handle, "typeOfLevel", vname, &len));
+  strcpy(var_new->ltype, vname);
+  push_msg(var_new->ary, handle);
+  if (last)
+    last->next = var_new;
+  else
+    pvar[0] = var_new;
+}
+
+
+
+
 VALUE cGrib;
+VALUE cVar;
 VALUE cMessage;
 
 typedef struct {
   FILE *file;
   char *fname;
-  grib_handle **handles;
-  int n;
+  var_list *var;
 } rg_file;
-
+typedef struct {
+  VALUE file;
+  var_list *var_list;
+} rg_var;
 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);
-  }
+  if (message) free(message);
 }
 static void
 message_mark(rg_message *message)
 {
-  if (message && message->file != Qnil)
-    rb_gc_mark(message->file);
+  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
+var_free(rg_var *var)
+{
+  if (var) free(var);
+}
+static void
+var_mark(rg_var *var)
+{
+  if (var && var->file != Qnil) rb_gc_mark(var->file);
+}
+static VALUE
+var_alloc(VALUE klass)
+{
+  rg_var *var = ALLOC(rg_var);
+  var->file = Qnil;
+  return Data_Wrap_Struct(klass, var_mark, var_free, var);
+}
 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;
+    if (gfile->var) {
+      var_list_free(gfile->var);
+      gfile->var = NULL;
     }
-    gfile->n = 0;
     if (gfile->file) {
       fclose(gfile->file);
       gfile->file = NULL;
@@ -88,23 +289,10 @@ file_alloc(VALUE klass)
   rg_file *gfile = ALLOC(rg_file);
   gfile->file = NULL;
   gfile->fname = NULL;
-  gfile->handles = NULL;
-  gfile->n = 0;
+  gfile->var = NULL;
   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
 */
@@ -145,29 +333,71 @@ rg_file_initialize(int argc, VALUE *argv, VALUE self)
   gfile->fname = ALLOC_N(char, strlen(fname)+1);
   strcpy(gfile->fname, fname);
 
-  int n = 0;
   int error;
   grib_handle *handle;
+  var_list *var = NULL;
   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++;
+    push_msg_var(&var, handle, self);
   }
-  rewind(file);
-  grib_handle **handles = ALLOC_N(grib_handle*, n);
+  gfile->var = var;
+  var_list *var2;
+  const char *vname;
+  char buf[MAX_VALUE_LENGTH];
+  int first_ltype, first_gtype;
   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;
+  while (var) {
+    vname = var->vname;
+    var2 = var->next;
+    i = 0;
+    first_ltype = 1;
+    first_gtype = 1;
+    while (var2) {
+      if (strcmp(var2->vname, vname) == 0) {
+	if (var->ltype_id != var2->ltype_id) {
+	  if (first_ltype) {
+	    if (strcmp(var->ltype,"isobaricInhPa") != 0 && strcmp(var->ltype,"pl") !=0) {
+	      if (strcmp(var->ltype, "unknown")==0)
+		sprintf(buf, "%s_level%ld", var->vname, var->ltype_id);
+	      else
+		sprintf(buf, "%s_%s", var->vname, var->ltype);
+	      strcpy(var->vname, buf);
+	    }
+	    first_ltype = 0;
+	  }
+	  if (strcmp(var2->ltype,"isobaricInhPa") != 0 && strcmp(var2->ltype,"pl") != 0) {
+	    if (strcmp(var2->ltype, "unknown")==0)
+	      sprintf(buf, "%s_level%ld", var2->vname, var2->ltype_id);
+	    else
+	      sprintf(buf, "%s_%s", var2->vname, var2->ltype);
+	    strcpy(var2->vname, buf);
+	  }
+	} else if (strcmp(var->gtype, var2->gtype) != 0) {
+	  if (first_gtype) {
+	    sprintf(buf, "%s_%s", var->vname, var->gtype);
+	    strcpy(var->vname, buf);
+	    first_gtype = 0;
+	  }
+	  sprintf(buf, "%s_%s", var2->vname, var2->gtype);
+	  strcpy(var2->vname, buf);
+	} else {
+	  if (i==0) {
+	    sprintf(buf, "%s_%d", var->vname, i);
+	    strcpy(var->vname, buf);
+	    i += 1;
+	  }
+	  sprintf(buf, "%s_%d", var2->vname, i);
+	  strcpy(var2->vname, buf);
+	  i += 1;
+	}
+      }
+      var2 = var2->next;
+    }
+    var = var->next;
   }
-  gfile->n = n;
-  gfile->handles = handles;
+  
   return self;
 }
 /*
@@ -183,36 +413,104 @@ rg_file_close(VALUE self)
 }
 
 /*
-  NumRu::Grib#get_messages() -> Array
+  NumRu::Grib#path() -> String
 */
 static VALUE
-rg_file_get_messages(VALUE self)
+rg_file_path(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 rb_str_new2(gfile->fname);
+}
+
+/*
+  NumRu::Grib#var_names() -> Array
+*/
+static VALUE
+rg_file_var_names(VALUE self)
+{
+  rg_file *gfile;
+  Data_Get_Struct(self, rg_file, gfile);
+  VALUE ary = rb_ary_new();
+  var_list *var = gfile->var;
+  while (var) {
+    rb_ary_push(ary, rb_str_new2(var->vname));
+    var = var->next;
   }
   return ary;
 }
 
+static VALUE id_init;
 /*
-  NumRu::Grib#path() -> String
+  NumRu::Grib#var(String) -> NumRu::GribVar
 */
 static VALUE
-rg_file_path(VALUE self)
+rg_file_var(VALUE self, VALUE rvname)
 {
+  char *vname = StringValueCStr(rvname);
   rg_file *gfile;
   Data_Get_Struct(self, rg_file, gfile);
-  return rb_str_new2(gfile->fname);
+  var_list *var_list = gfile->var;
+  while (var_list) {
+    if (strcmp(var_list->vname, vname) == 0) {
+      VALUE rvar = var_alloc(cVar);
+      rg_var *var;
+      Data_Get_Struct(rvar, rg_var, var);
+      var->file = self;
+      var->var_list = var_list;
+      rb_funcall(rvar, id_init, 0);
+      return rvar;
+    }
+    var_list = var_list->next;
+  }
+  rb_raise(rb_eArgError, "cannot find variable: %s", vname);
+}
+
+/*
+  NumRu::GribVar#file() -> NumRu::Grib
+*/
+static VALUE
+rg_var_file(VALUE self)
+{
+  rg_var *var;
+  Data_Get_Struct(self, rg_var, var);
+  return var->file;
+}
+
+/*
+  NumRu::GribVar#name() -> String
+*/
+static VALUE
+rg_var_name(VALUE self)
+{
+  rg_var *var;
+  Data_Get_Struct(self, rg_var, var);
+  return rb_str_new2(var->var_list->vname);
+}
+
+/*
+  NumRu::GribVar#get_messages() -> Array
+*/
+static VALUE
+rg_var_get_messages(VALUE self)
+{
+  rg_var *var;
+  Data_Get_Struct(self, rg_var, var);
+  var_list *var_list = var->var_list;
+  size_t len = var_list->ary->len;
+  VALUE ary = rb_ary_new2(len);
+  rg_message *message;
+  VALUE rmessage;
+  int i;
+  for (i=0; i<len; i++) {
+    rmessage = message_alloc(cMessage);
+    Data_Get_Struct(rmessage, rg_message, message);
+    message->file = self;
+    message->handle = get_msg(var_list->ary, i);
+    rb_ary_store(ary, i, rmessage);
+  }
+  return ary;
+
 }
 
 /*
@@ -396,8 +694,11 @@ void Init_grib()
 {
   rb_require("narray");
 
+  id_init = rb_intern("init");
+
   VALUE mNumRu = rb_define_module("NumRu");
   cGrib = rb_define_class_under(mNumRu, "Grib", rb_cObject);
+  cVar = rb_define_class_under(mNumRu, "GribVar", rb_cObject);
   cMessage = rb_define_class_under(mNumRu, "GribMessage", rb_cObject);
 
   grib_multi_support_on(0);
@@ -408,8 +709,15 @@ void Init_grib()
   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_method(cGrib, "var_names", rg_file_var_names, 0);
+  rb_define_method(cGrib, "var", rg_file_var, 1);
+
+  rb_define_alloc_func(cVar, var_alloc);
+  rb_define_method(cVar, "file", rg_var_file, 0);
+  rb_define_method(cVar, "name", rg_var_name, 0);
+  rb_define_method(cVar, "get_messages", rg_var_get_messages, 0);
+
 
   rb_define_alloc_func(cMessage, message_alloc);
   rb_define_method(cMessage, "initialize", rg_message_initialize, 1);